[NOTICKET] feat(knowledge,analysis): add deletion confirmation, duplicate-name guard, and unusable-analysis lockout

- Require confirmation with an impact preview (affected analyses) before
deleting a knowledge source or clearing all documents in KnowledgeManagement
- Block creating analyses with a name that duplicates an existing one
(case/whitespace-insensitive) in NewAnalysisDialog
- Derive an "unusable" state from the existing staleSources check and disable
chat input/send/help, suggested questions, generate-report, and the
source-rebind controls in AnalysisHeader once a bound source is deleted,
while keeping chat history and reports viewable

.specify/feature.json

@@ -1 +1,3 @@
-{"feature_directory": "specs/002-fix-analysis-chat-ui"}
+{
+  "feature_directory": "specs/003-knowledge-delete-guardrails"
+}

CLAUDE.md

@@ -1,6 +1,6 @@
 <!-- SPECKIT START -->
 For additional context about technologies to be used, project structure,
 shell commands, and other important information, see:
-- Implementation Plan: specs/002-fix-analysis-chat-ui/plan.md
-- Feature Specification: specs/002-fix-analysis-chat-ui/spec.md
+- Implementation Plan: specs/003-knowledge-delete-guardrails/plan.md
+- Feature Specification: specs/003-knowledge-delete-guardrails/spec.md
 <!-- SPECKIT END -->

specs/003-knowledge-delete-guardrails/checklists/requirements.md

@@ -0,0 +1,35 @@
+# Specification Quality Checklist: Knowledge Source Deletion Guardrails
+
+**Purpose**: Validate specification completeness and quality before proceeding to planning
+**Created**: 2026-07-24
+**Feature**: [spec.md](../spec.md)
+
+## Content Quality
+
+- [x] No implementation details (languages, frameworks, APIs)
+- [x] Focused on user value and business needs
+- [x] Written for non-technical stakeholders
+- [x] All mandatory sections completed
+
+## Requirement Completeness
+
+- [x] No [NEEDS CLARIFICATION] markers remain
+- [x] Requirements are testable and unambiguous
+- [x] Success criteria are measurable
+- [x] Success criteria are technology-agnostic (no implementation details)
+- [x] All acceptance scenarios are defined
+- [x] Edge cases are identified
+- [x] Scope is clearly bounded
+- [x] Dependencies and assumptions identified
+
+## Feature Readiness
+
+- [x] All functional requirements have clear acceptance criteria
+- [x] User scenarios cover primary flows
+- [x] Feature meets measurable outcomes defined in Success Criteria
+- [x] No implementation details leak into specification
+
+## Notes
+
+- No clarifications were required: reasonable defaults were assumed for near-duplicate name matching, "unusable" state semantics, and re-binding being out of scope. These are documented in the Assumptions section of spec.md.
+- All checklist items pass on first validation pass.

specs/003-knowledge-delete-guardrails/contracts/components.md

@@ -0,0 +1,119 @@
+# Component Contracts: Knowledge Source Deletion Guardrails
+
+This is a frontend-only feature with no backend/API contract changes. The contracts below describe the new/changed React component prop interfaces so implementation and review have a shared reference.
+
+## `src/app/components/ui/alert-dialog.tsx` (new)
+
+Thin shadcn-style wrapper around `@radix-ui/react-alert-dialog`, exporting: `AlertDialog`, `AlertDialogTrigger`, `AlertDialogContent`, `AlertDialogHeader`, `AlertDialogTitle`, `AlertDialogDescription`, `AlertDialogFooter`, `AlertDialogAction`, `AlertDialogCancel` — same shape as the standard shadcn/ui `alert-dialog` primitive. No project-specific props beyond styling.
+
+## `KnowledgeManagement.tsx` — internal confirmation dialog state (no new exported props)
+
+New internal state:
+
+```ts
+type DeleteIntent =
+  | { kind: "document"; docId: string; docName: string }
+  | { kind: "database"; clientId: string; clientName: string }
+  | { kind: "clear-all-documents" };
+
+const [deleteIntent, setDeleteIntent] = useState<DeleteIntent | null>(null);
+const [impact, setImpact] = useState<{ id: string; analysis_title: string }[]>([]);
+const [loadingImpact, setLoadingImpact] = useState(false);
+```
+
+Behavior contract:
+- Clicking any delete trigger (single document, single database client, "clear all documents") sets `deleteIntent` instead of calling the delete API directly, then fetches `listAnalyses()` and computes `impact` (see data-model.md `DeletionImpactSummary`).
+- The `AlertDialog` renders open whenever `deleteIntent !== null`.
+- `AlertDialogCancel` → `setDeleteIntent(null); setImpact([])` — no API call.
+- `AlertDialogAction` → performs the existing delete call(s) (`deleteDocument` / `deleteDatabaseClient`, looped for clear-all) that today run directly from the click handler, then closes the dialog.
+- Replaces the existing `window.confirm(...)` call in `deleteAllDocuments` (`KnowledgeManagement.tsx:266`) — that function becomes the `AlertDialogAction` handler for the `clear-all-documents` intent.
+
+## `NewAnalysisDialog.tsx`
+
+New/changed props:
+
+```ts
+interface NewAnalysisDialogProps {
+  open: boolean;
+  onClose: () => void;
+  onCreated: (analysis: Analysis) => void;
+  existingAnalyses: Analysis[]; // NEW — passed from AnalysisShell's existing `analyses` state
+}
+```
+
+Behavior contract:
+- `canSubmit` gains an additional condition: `!isDuplicateName(title, existingAnalyses)` (see data-model.md).
+- When the title is a duplicate, render an inline error near the title field (same visual pattern as the existing `error` state block) stating the name is already in use; this does not block typing, only submission.
+- Caller (`AnalysisShell.tsx`) passes its existing `analyses` array — no new fetch required.
+
+## `SuggestedQuestionsBar.tsx`
+
+New prop:
+
+```ts
+interface SuggestedQuestionsBarProps {
+  questions: string[];
+  onSelect: (question: string) => void;
+  disabled?: boolean; // NEW
+}
+```
+
+Behavior contract: when `disabled` is `true`, every rendered question button gets `disabled` and the existing click handler becomes a no-op (defense in depth beyond the `disabled` HTML attribute).
+
+## `ReportSidebar.tsx`
+
+New prop:
+
+```ts
+interface ReportSidebarProps {
+  analysis: Analysis;
+  userId?: string;
+  onCollapse?: () => void;
+  disabled?: boolean; // NEW — true when the analysis is unusable
+}
+```
+
+Behavior contract: the generate-report button (`handleGenerate`) is disabled when `disabled` is `true`; report viewing/history (existing report list/version selector) is unaffected and remains fully interactive.
+
+## `DataBindSelector.tsx`
+
+New prop:
+
+```ts
+interface DataBindSelectorProps {
+  value: DataBindItem[];
+  onChange: (items: DataBindItem[]) => void;
+  disabled?: boolean; // meaning extended: also true when hosting analysis is unusable, not just `submitting`
+}
+```
+
+Behavior contract: when used inside an unusable analysis's edit/update-data flow (specifically the instance embedded in `AnalysisHeader.tsx`'s source editor), `disabled` is forced `true` regardless of other state (e.g. `saving`), preventing `updateAnalysisDataBind` from being invoked. Per clarification, this applies even though this is the same control a user would otherwise use to fix the stale binding — there is no exception for "trying to recover."
+
+## `AnalysisShell.tsx` — orchestration (no new exported props; internal only)
+
+New internal derivation, reusing the **already-existing** `staleSources` state (`AnalysisShell.tsx:80`, computed at `AnalysisShell.tsx:117-138`) rather than recomputing it:
+
+```ts
+const isActiveAnalysisUnusable = staleSources.length > 0;
+```
+
+This value is passed as the new `disabled`/`unusable` prop into `ChatInput`, `HelpSkillButton` (via `ChatInput`'s existing `disabled` passthrough), `SuggestedQuestionsBar`, `ReportSidebar`, and the new `unusable` prop on `AnalysisHeader` (below). FR-010's visible indicator reuses `AnalysisHeader.tsx`'s existing stale-sources banner rather than adding a new one.
+
+## `AnalysisHeader.tsx`
+
+New prop:
+
+```ts
+interface AnalysisHeaderProps {
+  analysis: Analysis | null;
+  staleSources?: DataBindItem[];
+  onUpdateDataBind: (items: DataBindItem[]) => Promise<void>;
+  unusable?: boolean; // NEW — equivalent to staleSources.length > 0, passed explicitly for clarity at call sites
+}
+```
+
+Behavior contract (per clarification — no in-app recovery path):
+- When `unusable` is `true`, the header's "N sources" button (`openSourceEditor`, ~line 40) is disabled so the editor cannot be opened.
+- The existing stale-sources banner's "Update binding" button (~line 75) is disabled (not just visually — the `onClick` that sets `editingSources(true)` must be prevented).
+- If `editingSources` is somehow already `true` when `unusable` becomes true, the embedded `DataBindSelector` (~line 91) and the "Save sources" button (~line 97) are forced `disabled`.
+- The banner copy may be extended (not replaced) to also convey "this analysis can no longer be used" per FR-010, reusing this single banner for both the pre-existing "stale sources" warning and this feature's "unusable" indicator.

specs/003-knowledge-delete-guardrails/data-model.md

@@ -0,0 +1,49 @@
+# Data Model: Knowledge Source Deletion Guardrails
+
+No new persisted entities or backend schema changes. This feature only adds client-side derived values computed from existing `orchestrationApi` types (`src/services/orchestrationApi.ts`).
+
+## Existing entities reused (unchanged)
+
+- **`ApiDocument`** (`orchestrationApi.ts:60`-ish): `{ id, filename, file_type, file_size, status, created_at, ... }` — a document knowledge source.
+- **`DatabaseClient`**: `{ id, name, db_type, status, ... }` — a database knowledge source.
+- **`DataBindItem`** (`orchestrationApi.ts:150`): `{ id, name, group_type: "document" | "database", type }` — a reference from an `Analysis` to a bound knowledge source.
+- **`Analysis`** (`orchestrationApi.ts:157`): `{ id, analysis_title, objective, business_questions, status: "active" | "inactive" | string, data_bind: DataBindItem[], data_bind_version, ... }`. `status` is **not** modified by this feature (see Clarifications in spec.md).
+
+## New client-side derived values (not persisted, not sent to the backend)
+
+### `DeletionImpactSummary`
+
+Computed at delete-intent time in `KnowledgeManagement.tsx`, before the confirmation dialog opens.
+
+| Field | Type | Description |
+|---|---|---|
+| `sourceIds` | `string[]` | The knowledge source id(s) about to be deleted (one for single delete, many for "clear all"). |
+| `affectedAnalyses` | `{ id: string; analysis_title: string }[]` | Analyses whose `data_bind` contains at least one of `sourceIds`, deduplicated by analysis id. Derived by fetching `listAnalyses()` and filtering `analysis.data_bind.some(item => sourceIds.includes(item.id))`. |
+
+**Lifecycle**: Computed fresh each time a delete action is initiated; discarded when the dialog closes (confirm or cancel). Never persisted.
+
+### Analysis usability flag (`isUnusable`)
+
+**Reused, not newly computed**: `AnalysisShell.tsx` already maintains `staleSources: DataBindItem[]` (state at `AnalysisShell.tsx:80`, computed in the `useEffect` at `AnalysisShell.tsx:117-138`) by cross-referencing `activeAnalysis.data_bind` against live `getDocuments`/`getDatabaseClients` results — this is exactly the "unusable" derivation this feature needs, built for feature 002's stale-sources banner. This feature derives from it rather than re-implementing it:
+
+```
+isActiveAnalysisUnusable: boolean = staleSources.length > 0
+```
+
+- Any single missing bound source is sufficient to mark the whole analysis unusable (per spec Assumptions / Acceptance Scenario US3.6) — already true of `staleSources`'s existing filter logic.
+- This is a pure, stateless derivation — not stored on the `Analysis` object returned by the API, and never written back via `updateAnalysis`/`UpdateAnalysisPayload`.
+- Recomputed on-demand (page load / analysis selection), not via a live subscription (per research.md Unknown 3 and the plan's Constraints) — matching `staleSources`'s existing recompute trigger (the `activeAnalysis`-keyed effect).
+
+**State transitions**: `isActiveAnalysisUnusable` has no explicit transition function in this feature — it is a pure function of current data. It can only become `true` when a bound source is deleted (User Story 1 → 3). Per clarification, this feature has **no** transition back to `false`: once `staleSources.length > 0`, the update-bound-data action (including the pre-existing "Update binding" control that would normally clear `staleSources`) is itself disabled by this feature (FR-011/FR-014), so there is no in-app path to restore usability.
+
+## Validation rule: analysis name uniqueness
+
+Enforced client-side in `NewAnalysisDialog.tsx` before calling `createAnalysis()`:
+
+```
+isDuplicateName(candidate: string, existing: Analysis[]): boolean =
+  existing.some(a => a.analysis_title.trim().toLowerCase() === candidate.trim().toLowerCase())
+```
+
+- Requires the dialog to have access to the current analysis list (already loaded by the parent `AnalysisShell.tsx` as `analyses` state) — passed down as a new prop, or fetched via `listAnalyses()` if the dialog is opened without it in scope.
+- This is a client-side guard only; per FR-007/FR-008 no backend contract change is assumed to exist, so this check does not guarantee uniqueness under concurrent creation from two sessions (acceptable per spec — no server-side uniqueness constraint was requested).

specs/003-knowledge-delete-guardrails/plan.md

@@ -0,0 +1,80 @@
+# Implementation Plan: Knowledge Source Deletion Guardrails
+
+**Branch**: `003-knowledge-delete-guardrails` | **Date**: 2026-07-24 | **Spec**: [spec.md](./spec.md)
+
+**Input**: Feature specification from `/specs/003-knowledge-delete-guardrails/spec.md`
+
+**Note**: This template is filled in by the `/speckit-plan` command. See `.specify/templates/plan-template.md` for the execution workflow.
+
+## Summary
+
+Add a confirmation dialog to `KnowledgeManagement.tsx` for every document/database delete action (single delete and "clear all documents") that lists which analyses are bound to the source(s) being removed and warns that those analyses will stop working; add a client-side exact-match (case/whitespace-insensitive) duplicate-name guard to `NewAnalysisDialog.tsx`; and derive a client-side "unusable" state for any analysis whose `data_bind` references a knowledge source that no longer exists, reusing the existing `staleSources` computation already present in `AnalysisShell.tsx`/`AnalysisHeader.tsx` (built for a "some bound sources are no longer available" warning banner) rather than introducing a parallel computation. That derived state is propagated to disable `ChatInput`, `HelpSkillButton`, `SuggestedQuestionsBar`, the report-generation action in `ReportSidebar.tsx`, and — per clarification — the data-bind-update action in `DataBindSelector.tsx` **including the pre-existing "Update binding" recovery control** in `AnalysisHeader.tsx`'s stale-sources banner, so an unusable analysis has no in-app path back to usable; `MessageList.tsx` and existing report viewing remain fully readable. Per clarification, the unusable flag is a standalone derived value — it does **not** reuse or write to the existing `Analysis.status` ("active"/"inactive") field, since that field already drives the "active" filter used to fetch the sidebar analysis list and must not be touched. All changes are frontend-only (React 18 + TypeScript + Tailwind); no new backend endpoints are required — the impact computation and the unusable-state derivation both run client-side against data already available from `listAnalyses()`, `getDocuments()`, and `getDatabaseClients()`.
+
+## Technical Context
+
+**Language/Version**: TypeScript (React 18.3.1, Vite 6.3.5)
+
+**Primary Dependencies**: React 18, Tailwind CSS 4, `@radix-ui/react-alert-dialog` (already installed, unused so far — used for the new confirmation dialog), `lucide-react` icons, `sonner` for toasts
+
+**Storage**: N/A — this feature only touches client-side UI state and read-only client-side derivations; `Analysis`/`ApiDocument`/`DatabaseClient` data continues to come from the existing `orchestrationApi` service unchanged, no new persisted fields
+
+**Testing**: No test framework is currently configured in this project (no vitest/jest in `devDependencies`); verification is manual/visual, consistent with `specs/002-fix-analysis-chat-ui/plan.md`
+
+**Target Platform**: Web browser (desktop primary; existing `KnowledgeManagement` modal/page variants and `AnalysisShell` mobile drawer must keep working)
+
+**Project Type**: Single-page web application (Vite + React), frontend-only change — no `backend/` directory exists in this repo
+
+**Performance Goals**: Impact-preview computation (matching a source's id against every analysis's `data_bind`) must resolve within 300ms for typical catalogs (dozens of analyses) so the confirmation dialog opens without a visible delay (SC-002)
+
+**Constraints**: Unusable state is a standalone derived flag, independent of and never written into `Analysis.status` (per clarification — `status` already filters the sidebar's `listAnalyses({ status: "active" })` call and must not be repurposed); unusable state is recomputed on analysis load/selection (not real-time/live while a user is idle on the page, since no push/websocket mechanism exists in this codebase); deletion remains a soft warning, not a hard block — the confirm action always proceeds once acknowledged (FR-006); once an analysis is flagged unusable it has **no in-app recovery path** — the update-bound-data action is disabled unconditionally, including the pre-existing "Update binding" control in `AnalysisHeader.tsx`'s stale-sources banner (per clarification)
+
+**Scale/Scope**: 5 components modified (`KnowledgeManagement.tsx` for the confirmation dialog, `NewAnalysisDialog.tsx` for duplicate-name validation, `AnalysisShell.tsx` for computing/propagating the unusable flag, `ReportSidebar.tsx` and `DataBindSelector.tsx` for disabling report-generation/data-update, `SuggestedQuestionsBar.tsx` for adding a `disabled` prop it currently lacks); no new routes, no new backend endpoints, no new persisted entities
+
+## Constitution Check
+
+*GATE: Must pass before Phase 0 research. Re-check after Phase 1 design.*
+
+The project constitution (`.specify/memory/constitution.md`) is an unfilled template with no ratified principles — there are no constitutional gates to evaluate against. No violations to justify.
+
+## Project Structure
+
+### Documentation (this feature)
+
+```text
+specs/003-knowledge-delete-guardrails/
+├── plan.md              # This file (/speckit-plan command output)
+├── research.md          # Phase 0 output (/speckit-plan command)
+├── data-model.md         # Phase 1 output (/speckit-plan command)
+├── quickstart.md        # Phase 1 output (/speckit-plan command)
+├── contracts/           # Phase 1 output (/speckit-plan command) — UI component contracts only
+└── tasks.md             # Phase 2 output (/speckit-tasks command - NOT created by /speckit-plan)
+```
+
+### Source Code (repository root)
+
+```text
+src/
+├── app/
+│   └── components/
+│       ├── KnowledgeManagement.tsx        # Delete/clear-all handlers — touched for US1 (confirmation dialog + impact preview)
+│       └── analysis/
+│           ├── AnalysisShell.tsx          # Derives `isActiveAnalysisUnusable` from existing `staleSources`; wires disabled props — touched for US3
+│           ├── AnalysisHeader.tsx         # Existing stale-sources banner + "Update binding" control — touched for US3 (reuse banner for FR-010; disable "Update binding"/"N sources" controls and embedded DataBindSelector when unusable)
+│           ├── NewAnalysisDialog.tsx      # Title field validation — touched for US2 (duplicate-name guard)
+│           ├── ChatInput.tsx              # Already supports `disabled` — no change, just wired from US3
+│           ├── HelpSkillButton.tsx        # Already supports `disabled` — no change, just wired from US3
+│           ├── SuggestedQuestionsBar.tsx  # Touched for US3 (add `disabled` prop, currently missing)
+│           ├── ReportSidebar.tsx          # `handleGenerate`/generate-report button — touched for US3 (disable when unusable)
+│           ├── DataBindSelector.tsx       # Update-bound-data control (already supports `disabled`) — touched for US3 (forced disabled when unusable, both in AnalysisHeader's editor and in the "Update binding" trigger)
+│           └── ui/
+│               └── alert-dialog.tsx       # New shadcn/radix-style wrapper around the already-installed
+│                                          # @radix-ui/react-alert-dialog primitive — reused for US1's confirmation dialog
+└── services/
+    └── orchestrationApi.ts                # Unchanged; existing Analysis/DataBindItem/ApiDocument/DatabaseClient types reused
+```
+
+**Structure Decision**: Single frontend project (`src/app/components/` and `src/app/components/analysis/`) — no new top-level directories. All work happens within the existing Knowledge and Analysis feature folders, reusing the already-installed `@radix-ui/react-alert-dialog` (wrapped once as `src/app/components/ui/alert-dialog.tsx`, matching the existing shadcn-style pattern of `ui/resizable.tsx`) rather than adding a new dependency, and computing the impact list / unusable flag entirely client-side from data already returned by `listAnalyses()`, `getDocuments()`, and `getDatabaseClients()`.
+
+## Complexity Tracking
+
+> No Constitution Check violations — this section is not applicable.

specs/003-knowledge-delete-guardrails/quickstart.md

@@ -0,0 +1,42 @@
+# Quickstart: Verifying Knowledge Source Deletion Guardrails
+
+Manual verification steps (no test framework configured in this project — see plan.md Testing).
+
+## Prerequisites
+
+- Run the app: `pnpm dev` (or `npm run dev` per `package.json` scripts) and sign in with a user that has at least:
+  - One document knowledge source bound to at least one analysis
+  - One database knowledge source not bound to any analysis
+  - Two existing analyses with distinct names
+
+## User Story 1 — Deletion confirmation with impact preview
+
+1. Open the Knowledge menu, find a document bound to an analysis, click its delete icon.
+2. Verify a confirmation dialog opens (not a browser `confirm()` popup) listing the bound analysis by name and a warning that it will become unusable.
+3. Click Cancel — verify the document is still listed and no analysis state changed.
+4. Click delete again, click Confirm — verify the document disappears from the list.
+5. Delete a database source with **no** bound analyses — verify the dialog still appears but states no analyses will be affected.
+6. Click "Clear all" on documents with multiple docs (some bound to analyses) — verify the dialog lists the combined, deduplicated set of affected analyses.
+
+## User Story 2 — Duplicate analysis name guard
+
+1. Open "New Analysis", enter a title that exactly matches an existing analysis's title (try exact, then with different case/leading spaces).
+2. Verify submission is blocked and an inline message indicates the name is already in use.
+3. Change the title to something unique — verify the create button becomes usable and creation succeeds.
+4. Repeat step 1 with a different set of bound knowledge sources selected — verify the duplicate-name check still blocks submission the same way (FR-008).
+
+## User Story 3 — Unusable analysis after source deletion
+
+1. From User Story 1 step 4, open the analysis that was bound to the now-deleted document.
+2. Verify the existing "some bound sources are no longer available" banner is shown and now also states the analysis can no longer be used (this feature extends that banner rather than adding a new one).
+3. Verify: chat input textarea, Send button, Help button, and every suggested/recommended question button are disabled.
+4. Verify: the "Generate report" action is disabled.
+5. Verify: the "N sources" button and the banner's "Update binding" button are both disabled — clicking them does nothing, and the bound-data editor cannot be opened at all. This is intentional: per product decision, an unusable analysis has no in-app way to recover by re-binding a replacement source.
+6. Verify: existing chat messages are still visible/scrollable, and any previously generated report can still be opened and read.
+7. Try pressing Enter in the (disabled) chat textarea — verify no message is sent.
+
+## Regression checks
+
+- An analysis with no bound sources at all still behaves exactly as before (not flagged unusable).
+- An analysis with multiple bound sources where only one was deleted is still flagged unusable (any single missing source is sufficient).
+- The Analysis sidebar list (`listAnalyses({ status: "active" })`) still shows the unusable analysis — confirming `status` was not repurposed/changed by this feature.

specs/003-knowledge-delete-guardrails/research.md

@@ -0,0 +1,32 @@
+# Research: Knowledge Source Deletion Guardrails
+
+## Unknown 1: How to compute "which analyses are affected" by deleting a source
+
+**Decision**: On delete-intent (before showing the confirmation dialog), call `listAnalyses()` (existing `orchestrationApi` function, already used in `AnalysisShell.tsx`) to get the current analysis set, then filter client-side for analyses whose `data_bind: DataBindItem[]` array contains an item whose `id` matches the source(s) being deleted.
+
+**Rationale**: There is no dedicated "which analyses use source X" backend endpoint. `Analysis.data_bind` (`src/services/orchestrationApi.ts:164`) already embeds the bound source refs (`{ id, name, group_type, type }`) per analysis, so the join is cheap to do client-side and requires no new API contract. `KnowledgeManagement.tsx` does not currently import `listAnalyses`, so this is a new cross-feature dependency (Knowledge → Analysis service) but stays within the existing `orchestrationApi` module — no new service needed.
+
+**Alternatives considered**:
+- New backend endpoint returning source→analyses reverse index: rejected as unnecessary backend work for a computation the client can already do from data it fetches anyway (dozens of analyses is trivial to filter in-browser, matching the plan's <300ms budget).
+- Precomputing/caching the reverse index in a global store: rejected as premature — `listAnalyses()` is called fresh at KnowledgeManagement delete-intent time; no evidence of a global state library (Redux/Zustand) in this codebase to justify one.
+
+## Unknown 2: Confirmation dialog component to use
+
+**Decision**: Use `@radix-ui/react-alert-dialog` (already in `package.json` dependencies, currently unused anywhere in `src/`), wrapped once as `src/app/components/ui/alert-dialog.tsx` in the same shadcn-style pattern as the existing `src/app/components/ui/resizable.tsx` wrapper (per `specs/002-fix-analysis-chat-ui/plan.md` precedent of reusing already-installed-but-unused Radix primitives instead of adding new dependencies).
+
+**Rationale**: `AlertDialog` (vs. plain `Dialog`) is the Radix-recommended primitive specifically for "interrupt the user with imperative content and expect a response" confirmation flows — matches this feature's cancel/confirm requirement (FR-005/FR-006) and provides built-in focus-trap/escape/backdrop behavior the current `window.confirm` in `deleteAllDocuments` (`KnowledgeManagement.tsx:266`) lacks styling control over.
+
+**Alternatives considered**:
+- Keep using `window.confirm`: rejected — cannot render a formatted, scrollable list of affected analysis names (FR-002), which the current single-string browser confirm cannot do.
+- `@radix-ui/react-dialog` (already used elsewhere for `NewAnalysisDialog`'s manual overlay, though that component hand-rolls its own overlay rather than importing the Radix dialog primitive): rejected in favor of `AlertDialog` for the confirmation-specific semantics and to keep a single reusable primitive for this exact "are you sure" pattern.
+
+## Unknown 3: Where "unusable" is computed and how it propagates
+
+**Decision**: **Reuse the existing `staleSources` state already implemented in `AnalysisShell.tsx:80,117-138`** (added for feature 002's stale-sources banner) rather than computing a new/parallel derivation. `staleSources` already cross-references `activeAnalysis.data_bind` against live `getDocuments`/`getDatabaseClients` results and is recomputed in a `useEffect` keyed on `activeAnalysis`. Derive `isActiveAnalysisUnusable = staleSources.length > 0` from it. Thread that boolean as a `disabled`/`unusable` prop into `ChatInput`, `HelpSkillButton` (both already accept `disabled`), a new `disabled` prop added to `SuggestedQuestionsBar`, and new disable conditions added to `ReportSidebar`'s generate-report button, `DataBindSelector`'s update action, and — per the second clarification — `AnalysisHeader.tsx`'s existing "Update binding" button and "N sources" trigger (both of which currently open the same `DataBindSelector`-backed editor used to fix `staleSources`).
+
+**Rationale**: `AnalysisShell.tsx` already computes exactly the value this feature needs — an initial pass at this research (before source inspection) proposed a new computation, but that would have duplicated `staleSources` and diverged from it over time (see analysis finding A1). Per the first clarification answer, the resulting flag must remain standalone from `Analysis.status` — reusing `status` would corrupt the existing `listAnalyses({ status: "active" })` sidebar filter (`AnalysisShell.tsx:101`), silently hiding "unusable" analyses from the sidebar list, which directly contradicts FR-012 (chat history/reports must remain viewable/reachable). Per the second clarification answer, the pre-existing "Update binding" recovery control must **also** be disabled once `isActiveAnalysisUnusable` is true, even though that control already exists and today lets users fix exactly this condition — the feature intentionally removes that recovery path rather than special-casing it, so an unusable analysis has no in-app way back to usable (FR-009).
+
+**Alternatives considered**:
+- Real-time/live re-evaluation while the analysis screen is open (e.g., polling or a websocket) to catch a source being deleted in another tab while the user is mid-session: rejected as out of scope per the plan's Constraints — no push mechanism exists in this codebase, and the spec's Edge Cases only require "fail gracefully" on stale-state actions, not live UI updates.
+- Storing the unusable flag as a new persisted field on `Analysis` returned by the backend: rejected — no backend contract change is needed since the flag is fully derivable client-side from data already fetched, keeping this a frontend-only change per the Summary.
+- Keeping the "Update binding" control enabled as a recovery escape hatch while disabling everything else: considered and rejected per clarification — the user explicitly chose "disable it too" over preserving recovery.

specs/003-knowledge-delete-guardrails/spec.md

@@ -0,0 +1,124 @@
+# Feature Specification: Knowledge Source Deletion Guardrails
+
+**Feature Branch**: `003-knowledge-delete-guardrails`
+
+**Created**: 2026-07-24
+
+**Status**: Draft
+
+**Input**: User description: "ada beberapa behavior frontend yang perlu diperbaiki, 1. di menu knowledge, ketika user hendak menghapus salah satu atau semua sources (baik database / document) maka perlu ada pop up konfirmasi lagi ke user, apakah user benar-benar setuju atau tidak. Pada pop up tersebut ada informasi yang menjelaskan impactnya jika source tersebut dihapus (contoh: dokumen A atau database X digunakan pada Analisis XXX, analisis XXX tidak akan bisa digunakan lagi). Kemudian perlu ada rules untuk nama analysis yang di create tidak boleh ada yang sama persis. 2. Apabila user yakin untuk menghapus knowledge source (yang sudah di bind ke analysis), maka user tidak akan bisa lagi mengirim pesan ke analysis ini, tidak bisa update data yang ter-bind ke analysis ini, kemudian ada flagging analysis ini tidak bisa digunakan lagi meskipun masih bisa melihat chat history atau melihat report yang pernah ter-generate sebelumnya. Tombol tulis chat, kirim chat, generate report, help, recommendation question jadi disable karena ada knowledge yang terhapus."
+
+## Clarifications
+
+### Session 2026-07-24
+
+- Q: Should the "unusable" state reuse the existing analysis status concept, or be a separate independent flag? → A: "Unusable" is a separate, independent flag computed purely from comparing bound sources vs. existing sources, unrelated to any status field
+- Q: The codebase already has a "stale sources" banner (`AnalysisHeader.tsx`) with an "Update binding" control that lets a user re-bind a replacement source. Should that control stay enabled for an unusable analysis so the user can recover it, or be disabled along with everything else? → A: Disabled along with everything else — an unusable analysis has no in-app recovery path; the flag is permanent for that analysis within this feature's scope.
+
+## User Scenarios & Testing *(mandatory)*
+
+### User Story 1 - Confirm knowledge source deletion with impact preview (Priority: P1)
+
+A user managing Knowledge sources (documents or database connections) clicks delete on a single source, or clicks "clear all" to delete every source. Before anything is actually removed, the system shows a confirmation dialog that lists the impact of the deletion — specifically, which analyses currently use that source and a warning that those analyses will stop working. The user must explicitly confirm before the deletion proceeds; they can also cancel and keep the source.
+
+**Why this priority**: Deleting a knowledge source is destructive and currently happens with no confirmation at all (or only a generic browser confirm for "clear all"), risking accidental data loss and silently broken analyses. This is the foundational safeguard the rest of the feature depends on.
+
+**Independent Test**: Can be fully tested by attempting to delete a document or database source (used by at least one analysis) and verifying a confirmation dialog appears listing the affected analyses by name, and that choosing "cancel" leaves the source and all analyses untouched, while choosing "confirm" proceeds with deletion.
+
+**Acceptance Scenarios**:
+
+1. **Given** a document source that is bound to one or more analyses, **When** the user clicks delete on that source, **Then** a confirmation dialog appears listing each affected analysis by name and stating those analyses will no longer be usable after deletion.
+2. **Given** a database source that is not bound to any analysis, **When** the user clicks delete on that source, **Then** a confirmation dialog appears indicating no analyses will be affected, and the user can still confirm or cancel.
+3. **Given** the confirmation dialog is open, **When** the user clicks "cancel", **Then** the source is not deleted and the dialog closes.
+4. **Given** the confirmation dialog is open, **When** the user clicks "confirm", **Then** the source is deleted and any bound analyses are flagged as unusable (see User Story 3).
+5. **Given** the user clicks "clear all sources", **When** the confirmation dialog appears, **Then** it lists the combined set of all analyses that would be affected across all sources being cleared.
+
+---
+
+### User Story 2 - Prevent duplicate analysis names (Priority: P2)
+
+A user creating a new analysis enters a name that is identical to the name of an existing analysis. The system blocks creation and informs the user that the name is already in use, prompting them to choose a different name.
+
+**Why this priority**: Duplicate analysis names create ambiguity when browsing, searching, or referencing analyses (including in the impact-preview list from User Story 1), so this is important but independent of the deletion-confirmation flow and can ship separately.
+
+**Independent Test**: Can be fully tested by creating an analysis with a name, then attempting to create a second analysis using the exact same name, and verifying the second attempt is blocked with a clear message while a differently-named analysis creates successfully.
+
+**Acceptance Scenarios**:
+
+1. **Given** an existing analysis named "Sales Q1", **When** a user attempts to create a new analysis also named "Sales Q1" (exact match), **Then** the system prevents submission and shows a message that the name is already in use.
+2. **Given** an existing analysis named "Sales Q1", **When** a user creates a new analysis named "sales q1 " (different casing/whitespace) or "Sales Q2", **Then** the near-duplicate is blocked per the matching rule in Assumptions, and the non-matching name is allowed to proceed.
+3. **Given** the name-in-use message is shown, **When** the user edits the name to something unique, **Then** the creation action becomes available again.
+
+---
+
+### User Story 3 - Disable a usable analysis after its knowledge source is deleted (Priority: P1)
+
+A user opens an analysis whose bound knowledge source(s) have been deleted (via User Story 1). The analysis is visibly flagged as no longer usable. The user can still browse the full chat history and view previously generated reports, but every action that would create new activity — writing/sending a chat message, using the help/skill button, using suggested/recommended questions, generating a new report, or updating the analysis's bound data — is disabled.
+
+**Why this priority**: Without this, a deleted source leaves an analysis in a broken state where users can still attempt actions that will fail unexpectedly (e.g., sending a chat message with no backing data), producing confusing errors instead of a clear, upfront explanation. This is the direct consequence of User Story 1 and is equally critical.
+
+**Independent Test**: Can be fully tested by deleting a knowledge source bound to an existing analysis, then opening that analysis and verifying: a visible "unusable" flag/banner is shown, chat input/send/help/suggested-questions/generate-report/update-data controls are disabled, while chat history and prior reports remain viewable.
+
+**Acceptance Scenarios**:
+
+1. **Given** an analysis bound only to a knowledge source that has since been deleted, **When** the user opens that analysis, **Then** a clear indicator (e.g., banner or label) explains the analysis is unusable because a bound knowledge source was deleted.
+2. **Given** an analysis flagged as unusable, **When** the user views the chat panel, **Then** the chat input field, send button, help button, and suggested/recommended question buttons are all disabled.
+3. **Given** an analysis flagged as unusable, **When** the user looks for a way to generate a new report, **Then** the generate-report action is disabled.
+4. **Given** an analysis flagged as unusable, **When** the user looks for a way to change its bound data sources, **Then** the update/change-bound-data action is disabled.
+5. **Given** an analysis flagged as unusable, **When** the user scrolls through existing chat messages or opens a previously generated report, **Then** the content is fully viewable exactly as before.
+6. **Given** an analysis is bound to multiple knowledge sources and only one is deleted, **When** the user opens the analysis, **Then** the analysis is still flagged unusable (any missing bound source is sufficient to disable it) per the rule in Assumptions.
+
+---
+
+### Edge Cases
+
+- What happens if a user has the deletion confirmation dialog open and, in another tab/session, the source is already deleted or an affected analysis is deleted first? The confirmation action should fail gracefully with a message rather than silently succeeding or erroring uninformatively.
+- What happens when a knowledge source that was deleted is later replaced or a new source with a similar name is added? The previously flagged analysis remains unusable — flagging is tied to the specific deleted source/binding, not resolved by adding an unrelated new source, unless the user explicitly re-binds the analysis to a valid source (out of scope for this feature; see Assumptions).
+- How does the impact list behave when a source is bound to a very large number of analyses? The dialog should present the list in a readable, scannable way (e.g., scrollable list) rather than breaking the layout.
+- What happens if the user attempts analysis creation with a name that only differs by leading/trailing whitespace or case from an existing name? Covered by the near-duplicate rule in Assumptions.
+- What happens to an analysis that has zero bound sources at all (never bound, not a deletion scenario)? This feature only concerns analyses that had a bound source removed; analyses with no bound source retain their current existing behavior.
+
+## Requirements *(mandatory)*
+
+### Functional Requirements
+
+- **FR-001**: System MUST show a confirmation dialog before deleting any single knowledge source (document or database), and before executing a "clear all sources" action.
+- **FR-002**: The confirmation dialog MUST display, for the source(s) being deleted, the list of analyses currently bound to it/them by name, so the user understands which analyses will stop working.
+- **FR-003**: The confirmation dialog MUST clearly state that listed analyses will no longer be usable if the deletion proceeds.
+- **FR-004**: If a source being deleted is not bound to any analysis, the confirmation dialog MUST still appear but indicate that no analyses will be affected.
+- **FR-005**: The user MUST be able to cancel the confirmation dialog, in which case no deletion occurs and no analysis state changes.
+- **FR-006**: The user MUST be able to confirm the dialog, in which case the source is deleted and any bound analyses are flagged as unusable per FR-009.
+- **FR-007**: System MUST prevent creating a new analysis whose name is an exact (case/whitespace-insensitive) duplicate of an existing analysis's name, and MUST inform the user of the conflict.
+- **FR-008**: System MUST apply the duplicate-name check consistently regardless of which knowledge sources are bound to the new analysis.
+- **FR-009**: When a knowledge source is deleted, System MUST flag every analysis bound to that source as unusable. This flag is permanent for that analysis within this feature's scope: no in-app action can restore usability, because the update-bound-data action is itself disabled once an analysis is unusable (see FR-011/FR-014), including any pre-existing "update binding" control (e.g., the stale-sources banner's recovery button). Restoring usability would require a separate, out-of-scope capability.
+- **FR-010**: An analysis flagged as unusable MUST visibly communicate to the user why it is unusable (i.e., that a bound knowledge source was deleted). This indicator MAY reuse/extend an existing "sources are no longer available" banner if one already exists in the UI, rather than requiring a separate new banner.
+- **FR-011**: For an analysis flagged as unusable, System MUST disable: the chat input field, the send-message action, the help/skill action, the suggested/recommended question actions, the generate-report action, and the update/change-bound-data action — including any pre-existing control whose purpose is to let the user fix/re-bind the analysis's data sources (e.g., an existing "update binding" recovery button).
+- **FR-012**: For an analysis flagged as unusable, System MUST continue to allow full read access to existing chat history and previously generated reports.
+- **FR-013**: System MUST prevent a chat message from being sent to an unusable analysis even if attempted through means other than the disabled button (e.g., keyboard submit).
+- **FR-014**: System MUST prevent updating the bound data of an unusable analysis even if attempted through means other than the disabled control.
+
+### Key Entities *(include if feature involves data)*
+
+- **Knowledge Source**: A document or database connection available for use by analyses; has an identifier, a type (document/database), a name, and zero or more analyses bound to it.
+- **Analysis**: A chat-based analysis bound to one or more knowledge sources; has a name (must be unique among analyses), chat history, generated reports, and a usability state (usable / unusable). This usability state is a standalone flag derived solely from comparing bound source references against currently existing knowledge sources — it is independent of and does not overload any other existing analysis status/lifecycle field.
+- **Deletion Impact Summary**: The set of analyses affected by deleting one or more knowledge sources, computed and shown at confirmation time.
+
+## Success Criteria *(mandatory)*
+
+### Measurable Outcomes
+
+- **SC-001**: 100% of knowledge source deletions (single or "clear all") require explicit user confirmation before any data is removed.
+- **SC-002**: Users can identify, before confirming a deletion, which specific analyses will be affected without leaving the confirmation dialog or performing any additional clicks/scrolling beyond what's needed to read a short list.
+- **SC-003**: Zero analyses can be created with a name that exactly (case/whitespace-insensitive) duplicates an existing analysis name.
+- **SC-004**: 100% of analyses whose bound knowledge source was deleted show a visible unusable indicator and have chat, help, suggested questions, generate report, and data-update actions disabled on next view.
+- **SC-005**: Users can still access 100% of previously generated chat history and reports for an unusable analysis, with zero loss of read access.
+
+## Assumptions
+
+- Near-duplicate analysis names (differing only by case or leading/trailing whitespace) are treated as duplicates and blocked; matching is case-insensitive and ignores leading/trailing whitespace. Names that differ by internal spacing, punctuation, or any other characters are treated as distinct.
+- "Unusable" is a client-visible state derived from comparing an analysis's bound source references against the current set of existing knowledge sources (i.e., any bound source missing marks the analysis unusable); a single missing source is enough to disable the whole analysis, even if other bound sources are still intact.
+- Re-binding an unusable analysis to a new/replacement knowledge source to restore usability is explicitly disabled by this feature (per clarification), even where a pre-existing UI control for updating bound data already exists; building an alternate/separate recovery capability is out of scope for this feature.
+- The impact-preview list in the confirmation dialog shows analysis names only (not full analysis details); clicking into individual analyses from the dialog is not required.
+- "Clear all sources" refers to deleting all knowledge sources of the type(s) currently in scope of that action (e.g., all documents, or all sources), consistent with existing clear-all behavior in the Knowledge menu.
+- Existing analyses that currently have no bound knowledge source at all are unaffected by this feature and keep their current behavior.
+- Deletion of a knowledge source is still permitted even when it would make analyses unusable; the confirmation dialog is a warning, not a hard block — the user retains final say once informed of the impact.

specs/003-knowledge-delete-guardrails/tasks.md

@@ -0,0 +1,182 @@
+---
+
+description: "Task list for Knowledge Source Deletion Guardrails"
+
+---
+
+# Tasks: Knowledge Source Deletion Guardrails
+
+**Input**: Design documents from `/specs/003-knowledge-delete-guardrails/`
+
+**Prerequisites**: [plan.md](./plan.md), [spec.md](./spec.md), [research.md](./research.md), [data-model.md](./data-model.md), [contracts/components.md](./contracts/components.md), [quickstart.md](./quickstart.md)
+
+**Tests**: Not requested in the feature specification — no automated test framework is configured in this project (see plan.md Technical Context). Verification is manual, per `quickstart.md`.
+
+**Organization**: Tasks are grouped by user story (US1–US3, matching spec.md priorities P1/P2/P1) to enable independent implementation and testing of each story.
+
+## Format: `[ID] [P?] [Story] Description`
+
+- **[P]**: Can run in parallel (different files, no dependencies)
+- **[Story]**: Which user story this task belongs to
+- Tasks touching `src/app/components/analysis/AnalysisShell.tsx` are never marked `[P]` relative to each other — they share one file and must be applied sequentially in ID order.
+
+## Path Conventions
+
+Single frontend project. All paths are relative to repo root.
+
+---
+
+## Phase 1: Setup
+
+**Purpose**: Add the one shared, reusable primitive this feature needs before any user story can use it.
+
+- [X] T001 [P] Create `src/app/components/ui/alert-dialog.tsx`, a shadcn-style wrapper around the already-installed `@radix-ui/react-alert-dialog` dependency, exporting `AlertDialog`, `AlertDialogTrigger`, `AlertDialogContent`, `AlertDialogHeader`, `AlertDialogTitle`, `AlertDialogDescription`, `AlertDialogFooter`, `AlertDialogAction`, `AlertDialogCancel` (per contracts/components.md), styled consistently with existing `src/app/components/ui/*` primitives (e.g. `resizable.tsx`). No new dependency to install — `@radix-ui/react-alert-dialog` is already in `package.json`. — **Already existed in the codebase** with all required exports; no work needed, confirmed by reading the file.
+
+**Checkpoint**: `AlertDialog` primitive available for import; ready for US1.
+
+---
+
+## Phase 2: Foundational (Blocking Prerequisites)
+
+**Purpose**: Core infrastructure that MUST be complete before ANY user story can be implemented.
+
+**N/A for this feature** — US1 (Knowledge deletion confirmation), US2 (duplicate analysis name), and US3 (disable unusable analysis) touch disjoint sets of components (`KnowledgeManagement.tsx` vs. `NewAnalysisDialog.tsx` vs. `AnalysisShell.tsx`/`ReportSidebar.tsx`/`DataBindSelector.tsx`/`SuggestedQuestionsBar.tsx`) and share no blocking data model, auth, or routing scaffolding. Each story is independently implementable once Phase 1's `AlertDialog` primitive exists (only needed by US1).
+
+**Checkpoint**: Proceed directly to user story implementation.
+
+---
+
+## Phase 3: User Story 1 - Confirm knowledge source deletion with impact preview (Priority: P1) 🎯 MVP
+
+**Goal**: Deleting a document or database source (single, or "clear all documents") always shows a confirmation dialog listing which analyses will be affected before anything is actually removed.
+
+**Independent Test**: Delete a document/database source bound to at least one analysis, verify the dialog lists the affected analysis by name and that Cancel leaves everything untouched while Confirm proceeds with deletion (see quickstart.md § User Story 1).
+
+### Implementation for User Story 1
+
+- [X] T002 [US1] In `src/app/components/KnowledgeManagement.tsx`, import `listAnalyses` from `../../services/orchestrationApi` and add internal state: `deleteIntent: DeleteIntent | null`, `impact: { id: string; analysis_title: string }[]`, `loadingImpact: boolean` (per contracts/components.md `DeleteIntent` union: `document`, `database`, `clear-all-documents`).
+- [X] T003 [US1] In `src/app/components/KnowledgeManagement.tsx`, add a helper `computeImpact(sourceIds: string[])` that calls `listAnalyses()` and filters/dedupes analyses whose `data_bind` contains any of `sourceIds` (per data-model.md `DeletionImpactSummary`), setting `loadingImpact`/`impact` around the call.
+- [X] T004 [US1] In `src/app/components/KnowledgeManagement.tsx`, change the document delete button's `onClick` (currently calling `handleDeleteDocument(doc.id)` directly, ~line 687) to instead call `setDeleteIntent({ kind: "document", docId: doc.id, docName: doc.filename })` and `computeImpact([doc.id])`. Depends on T002, T003.
+- [X] T005 [P] [US1] In `src/app/components/KnowledgeManagement.tsx`, change the database client delete button's `onClick` (currently calling `handleDeleteClient(client.id)` directly, ~line 617) to instead call `setDeleteIntent({ kind: "database", clientId: client.id, clientName: client.name })` and `computeImpact([client.id])`. Depends on T002, T003.
+- [X] T006 [P] [US1] In `src/app/components/KnowledgeManagement.tsx`, replace the `window.confirm(...)` call in `deleteAllDocuments` (~line 266) with `setDeleteIntent({ kind: "clear-all-documents" })` and `computeImpact(documents.map(d => d.id))`. Depends on T002, T003.
+- [X] T007 [US1] In `src/app/components/KnowledgeManagement.tsx`, render an `AlertDialog` (imported from `./ui/alert-dialog`, added in T001) open whenever `deleteIntent !== null`, with: a title/description branching on `deleteIntent.kind` (per FR-002/FR-003), a scrollable list of `impact` analysis titles when `impact.length > 0` (per Edge Cases: large impact lists must stay scannable) or a "no analyses will be affected" message when `impact.length === 0` (FR-004), an `AlertDialogCancel` that resets `deleteIntent`/`impact` with no API call (FR-005), and an `AlertDialogAction` that performs the actual delete for the given `deleteIntent.kind` — calling existing `handleDeleteDocument`/`handleDeleteClient` for single deletes, or looping `deleteDocument` calls (the existing body of `deleteAllDocuments` minus its `window.confirm`) for `clear-all-documents` — then resets `deleteIntent`/`impact` (FR-006). Depends on T004, T005, T006.
+- [ ] T008 [US1] Manually verify per quickstart.md § User Story 1 — **NOT YET DONE, requires a human/browser pass**; `npm run build` succeeds with no compile/runtime-startup errors (confirms code correctness), but actual UI/UX verification needs manual browser testing: confirm dialog appears for a bound and an unbound source, for clear-all with mixed bound/unbound docs, and that Cancel vs. Confirm behave per FR-005/FR-006. Depends on T007.
+
+**Checkpoint**: Knowledge deletion confirmation with impact preview fully functional and independently testable per quickstart.md § User Story 1.
+
+---
+
+## Phase 4: User Story 2 - Prevent duplicate analysis names (Priority: P2)
+
+**Goal**: Creating a new analysis with a name that exactly (case/whitespace-insensitively) matches an existing analysis's name is blocked with a clear message.
+
+**Independent Test**: Create an analysis, then attempt to create a second one with the identical (or same-but-cased/whitespace-padded) name, and verify it's blocked while a distinct name succeeds (see quickstart.md § User Story 2).
+
+### Implementation for User Story 2
+
+- [X] T009 [P] [US2] In `src/app/components/analysis/NewAnalysisDialog.tsx`, add a new required prop `existingAnalyses: Analysis[]` to `NewAnalysisDialogProps` (per contracts/components.md) and a helper `isDuplicateName(candidate: string, existing: Analysis[])` comparing `analysis_title.trim().toLowerCase()` (per data-model.md).
+- [X] T010 [US2] In `src/app/components/analysis/NewAnalysisDialog.tsx`, add `isDuplicateName(title, existingAnalyses)` as an additional `canSubmit` condition, and render an inline error near the title field (same visual pattern as the existing `error` block) when the current title is a duplicate, without blocking further typing. Depends on T009.
+- [X] T011 [US2] In `src/app/components/analysis/AnalysisShell.tsx`, pass `existingAnalyses={analyses}` (the already-loaded sidebar analyses state) to `<NewAnalysisDialog />` (~line 554).
+- [ ] T012 [US2] Manually verify per quickstart.md § User Story 2 — **NOT YET DONE, requires a human/browser pass**: exact match blocked, case/whitespace variant blocked, distinct name succeeds, editing to a unique name re-enables submission, and the check behaves the same regardless of which knowledge sources are bound to the new analysis (FR-008). Depends on T010, T011.
+
+**Checkpoint**: Duplicate analysis name guard fully functional and independently testable per quickstart.md § User Story 2.
+
+---
+
+## Phase 5: User Story 3 - Disable a usable analysis after its knowledge source is deleted (Priority: P1)
+
+**Goal**: An analysis whose bound knowledge source no longer exists is visibly flagged unusable and has all activity-generating actions (chat, help, suggested questions, generate report, update bound data) disabled, while chat history and reports remain fully viewable.
+
+**Independent Test**: Delete a knowledge source bound to an existing analysis (via the app's existing delete action), open that analysis, and verify the unusable banner appears, all listed actions are disabled, and history/reports remain viewable (see quickstart.md § User Story 3).
+
+### Implementation for User Story 3
+
+- [X] T013 [P] [US3] In `src/app/components/analysis/SuggestedQuestionsBar.tsx`, add an optional `disabled?: boolean` prop; when `true`, render every question button with the `disabled` attribute and make the existing `onSelect` handler a no-op (per contracts/components.md).
+- [X] T014 [P] [US3] In `src/app/components/analysis/ReportSidebar.tsx`, add an optional `disabled?: boolean` prop; when `true`, disable the generate-report button (`handleGenerate`'s trigger) while leaving the report list/version selector/report viewing fully interactive (per contracts/components.md, FR-011/FR-012).
+- [X] T015 [P] [US3] In `src/app/components/analysis/AnalysisHeader.tsx`, add an optional `unusable?: boolean` prop (per contracts/components.md). When `true`: disable the "N sources" button (`openSourceEditor`, ~line 40-43) so the editor cannot be opened; disable the stale-sources banner's "Update binding" button (~line 75-85, prevent `setEditingSources(true)`); and force the embedded `DataBindSelector` (~line 91) and "Save sources" button (~line 97-105) to `disabled` if `editingSources` is already `true`. This intentionally disables the same control that today lets a user fix `staleSources` — per clarification, an unusable analysis has no in-app recovery path (FR-009/FR-011/FR-014).
+- [X] T016 [US3] In `src/app/components/analysis/AnalysisShell.tsx`, add `const isActiveAnalysisUnusable = staleSources.length > 0;`, reusing the **already-existing** `staleSources` state (`AnalysisShell.tsx:80`, computed by the existing `useEffect` at `AnalysisShell.tsx:117-138` which already fetches `getDocuments`/`getDatabaseClients` and cross-references `activeAnalysis.data_bind`) — do **not** add a new/parallel fetch or derivation (per research.md Unknown 3 / data-model.md `isActiveAnalysisUnusable`).
+- [X] T017 [US3] In `src/app/components/analysis/AnalysisHeader.tsx`, extend the existing stale-sources banner copy (~line 69-72, "Some bound sources are no longer available...") to also state the analysis can no longer be used (FR-010) — reuse this banner rather than adding a new one elsewhere. In `src/app/components/analysis/AnalysisShell.tsx`, pass `unusable={isActiveAnalysisUnusable}` into `<AnalysisHeader />` (~line 372). Depends on T015, T016.
+- [X] T018 [US3] In `src/app/components/analysis/AnalysisShell.tsx`, pass `disabled={isActiveAnalysisUnusable}` into `ChatInput` (which already forwards `disabled` to its Send button, textarea, and `HelpSkillButton` per existing code), `SuggestedQuestionsBar` (from T013), and `ReportSidebar` (from T014). Depends on T013, T014, T016.
+- [X] T019 [US3] In `src/app/components/analysis/ChatInput.tsx`, confirm the existing `onKeyDown` Enter-to-submit path already respects `disabled` via `canSend` (it does — `canSend = message.trim().length > 0 && !disabled && !streaming`); no code change expected, verify only (per FR-013).
+- [ ] T020 [US3] Manually verify per quickstart.md § User Story 3 — **NOT YET DONE, requires a human/browser pass**: unusable banner appears (reusing the stale-sources banner); chat input/send/help/suggested-questions/generate-report are all disabled; the "N sources"/"Update binding" controls and embedded `DataBindSelector` are all disabled with no way to open or submit the source editor (FR-014); chat history and prior reports remain fully viewable; an analysis with multiple bound sources where only one was deleted is still flagged unusable; an analysis with no bound sources is unaffected; the sidebar (`listAnalyses({ status: "active" })`) still lists the unusable analysis, confirming `status` was not repurposed. Depends on T017, T018, T019.
+
+**Checkpoint**: Unusable-analysis flagging and action-disabling fully functional and independently testable per quickstart.md § User Story 3.
+
+---
+
+## Phase 6: Polish & Cross-Cutting Concerns
+
+**Purpose**: Final validation across all three stories together.
+
+- [ ] T021 Run the full manual verification checklist in `quickstart.md` end-to-end (US1 → US3) against `npm run dev` (or `pnpm dev`), confirming no regressions between stories (e.g., an analysis flagged unusable by US3 still shows correctly in US1's impact-preview list if further sources bound to it are deleted).
+- [ ] T022 [P] Spot-check the mobile drawer/bottom-sheet variants of `KnowledgeManagement.tsx` (`variant="modal"` vs. `"page"`) and `AnalysisShell.tsx`'s mobile report panel still render the new `AlertDialog` and unusable banner correctly at mobile viewport widths.
+
+---
+
+## Dependencies & Execution Order
+
+### Phase Dependencies
+
+- **Setup (Phase 1)**: No dependencies — can start immediately. Only blocks US1 (T004–T007 need the `AlertDialog` primitive from T001).
+- **Foundational (Phase 2)**: N/A — no blocking work.
+- **User Stories (Phase 3–5)**: US1 depends on Phase 1 (T001). US2 and US3 have no dependency on Phase 1 or on each other and can start immediately in parallel with US1.
+- **Polish (Phase 6)**: Depends on all three user stories being complete.
+
+### User Story Dependencies
+
+- **US1 (P1)**: Depends only on Setup (T001, for `AlertDialog`). Touches `KnowledgeManagement.tsx` only.
+- **US2 (P2)**: Fully independent — touches `NewAnalysisDialog.tsx` and one prop-passing line in `AnalysisShell.tsx` (T011).
+- **US3 (P1)**: Fully independent of US1/US2 in intent (it only requires that *some* deletion has happened, which the app can already do today even before US1 ships) — touches `SuggestedQuestionsBar.tsx`, `ReportSidebar.tsx`, `AnalysisHeader.tsx`, and `AnalysisShell.tsx` (T016, T017, T018, sequential same-file edits; also share `AnalysisShell.tsx` with US2's T011, so apply T011 before T016–T018 if working in the same branch to avoid merge conflicts).
+
+### Parallel Opportunities
+
+- T005 and T006 (`KnowledgeManagement.tsx` database/clear-all delete triggers) can run in parallel with T004 (document delete trigger) — same file, but non-overlapping code regions; sequence by ID if working solo.
+- T009 (`NewAnalysisDialog.tsx`) can run any time, fully parallel with all of US1 and US3.
+- T013, T014, T015 (`SuggestedQuestionsBar.tsx`, `ReportSidebar.tsx`, `AnalysisHeader.tsx`) can all run in parallel with each other and with US1/US2 — three different files, no shared state.
+- T022 can run in parallel with T021.
+
+---
+
+## Parallel Example: Cross-story parallel batch (once Setup/T001 is done)
+
+```bash
+# These touch entirely different files and can be worked on simultaneously:
+Task: "Add existingAnalyses prop + duplicate-name guard to NewAnalysisDialog.tsx (T009, T010)"
+Task: "Add disabled prop to SuggestedQuestionsBar.tsx (T013)"
+Task: "Add disabled prop to ReportSidebar.tsx's generate-report button (T014)"
+Task: "Add unusable prop to AnalysisHeader.tsx, disabling its source-editor controls (T015)"
+```
+
+---
+
+## Implementation Strategy
+
+### MVP First (User Story 1 Only)
+
+1. Complete Phase 1: Setup (T001).
+2. Complete Phase 3: User Story 1 (deletion confirmation + impact preview).
+3. **STOP and VALIDATE**: Run quickstart.md § User Story 1 independently.
+4. Deploy/demo if ready — this alone closes the biggest accidental-data-loss risk.
+
+### Incremental Delivery
+
+1. Setup (T001) → done.
+2. US1 (Phase 3) → validate → ship (MVP).
+3. US3 (Phase 5) → validate → ship (closes the loop opened by US1: analyses whose sources were just deleted become properly unusable).
+4. US2 (Phase 4) → validate → ship.
+5. Polish (Phase 6) → final cross-story pass.
+
+Each story adds value without breaking previous stories. US1 and US3 are naturally paired (US1 makes deletion safe to do; US3 makes the consequence of doing it visible and enforced), but both can also ship independently since the app can already delete sources today.
+
+---
+
+## Notes
+
+- No automated tests exist in this project; all verification is manual via `quickstart.md`.
+- [P] tasks = different files, no dependencies.
+- [Story] label maps task to specific user story for traceability.
+- `AnalysisShell.tsx` is shared across US2 (T011) and US3 (T016, T017, T018) — respect task ID ordering there even when working in parallel on other files.
+- T015/T017's disabling of `AnalysisHeader.tsx`'s "Update binding" control is intentional (per clarification, an unusable analysis has no in-app recovery path) — do not "fix" this into an exception during implementation.
+- `KnowledgeManagement.tsx` is shared across all of US1's tasks (T002–T007) — apply in ID order even if split across contributors.
+- Commit after each task or logical group.
+- Stop at any checkpoint to validate a story independently.

src/app/components/KnowledgeManagement.tsx

@@ -27,6 +27,7 @@ import {
   ingestDatabaseClient,
   getDataCatalog,
   rebuildDataCatalog,
+  listAnalyses,
   type ApiDocument,
   type DocumentStatus,
   type DocTypeInfo,
@@ -35,6 +36,16 @@ import {
   type DatabaseClient,
   type DataCatalogSource,
 } from "../../services/orchestrationApi";
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+} from "./ui/alert-dialog";
 
 interface KnowledgeManagementProps {
   open: boolean;
@@ -44,6 +55,16 @@ interface KnowledgeManagementProps {
 
 type View = "main" | "db-select" | "db-credentials" | "catalog";
 
+type DeleteIntent =
+  | { kind: "document"; docId: string; docName: string }
+  | { kind: "database"; clientId: string; clientName: string }
+  | { kind: "clear-all-documents" };
+
+interface ImpactedAnalysis {
+  id: string;
+  analysis_title: string;
+}
+
 const LOGO_MAP: Record<string, string> = {
   postgres:  "https://cdn.simpleicons.org/postgresql/336791",
   mysql:     "https://cdn.simpleicons.org/mysql/4479A1",
@@ -85,6 +106,12 @@ export default function KnowledgeManagement({
   const [processing, setProcessing] = useState<string | null>(null);
   const [deleting, setDeleting] = useState<string | null>(null);
 
+  // -- Deletion confirmation state ---------------------------------------------
+  const [deleteIntent, setDeleteIntent] = useState<DeleteIntent | null>(null);
+  const [impact, setImpact] = useState<ImpactedAnalysis[]>([]);
+  const [loadingImpact, setLoadingImpact] = useState(false);
+  const [confirming, setConfirming] = useState(false);
+
   // -- Navigation state --------------------------------------------------------
   const [view, setView] = useState<View>("main");
   const [selectedDbType, setSelectedDbType] = useState<DbType | null>(null);
@@ -263,8 +290,6 @@ export default function KnowledgeManagement({
   };
 
   const deleteAllDocuments = async () => {
-    if (!window.confirm("Are you sure you want to delete all documents?"))
-      return;
     const userId = getUserId();
     if (!userId) return;
     for (const doc of documents) {
@@ -277,6 +302,65 @@ export default function KnowledgeManagement({
     setDocuments([]);
   };
 
+  // -- Deletion confirmation ----------------------------------------------------
+
+  const computeImpact = async (sourceIds: string[]) => {
+    setLoadingImpact(true);
+    try {
+      const result = await listAnalyses({ status: "active", limit: 200 });
+      const affected = result.analyses.filter((analysis) =>
+        analysis.data_bind.some((item) => sourceIds.includes(item.id))
+      );
+      const deduped = Array.from(new Map(affected.map((a) => [a.id, a])).values()).map(
+        (a) => ({ id: a.id, analysis_title: a.analysis_title })
+      );
+      setImpact(deduped);
+    } catch {
+      // non-blocking; if we can't compute impact, still allow the dialog to show with an empty list
+      setImpact([]);
+    } finally {
+      setLoadingImpact(false);
+    }
+  };
+
+  const requestDeleteDocument = (doc: ApiDocument) => {
+    setDeleteIntent({ kind: "document", docId: doc.id, docName: doc.filename });
+    void computeImpact([doc.id]);
+  };
+
+  const requestDeleteClient = (client: DatabaseClient) => {
+    setDeleteIntent({ kind: "database", clientId: client.id, clientName: client.name });
+    void computeImpact([client.id]);
+  };
+
+  const requestClearAllDocuments = () => {
+    setDeleteIntent({ kind: "clear-all-documents" });
+    void computeImpact(documents.map((d) => d.id));
+  };
+
+  const cancelDelete = () => {
+    setDeleteIntent(null);
+    setImpact([]);
+  };
+
+  const confirmDelete = async () => {
+    if (!deleteIntent) return;
+    setConfirming(true);
+    try {
+      if (deleteIntent.kind === "document") {
+        await handleDeleteDocument(deleteIntent.docId);
+      } else if (deleteIntent.kind === "database") {
+        await handleDeleteClient(deleteIntent.clientId);
+      } else {
+        await deleteAllDocuments();
+      }
+    } finally {
+      setConfirming(false);
+      setDeleteIntent(null);
+      setImpact([]);
+    }
+  };
+
   // -- DB handlers -------------------------------------------------------------
 
   const handleDbConnect = async () => {
@@ -446,6 +530,7 @@ export default function KnowledgeManagement({
   // -- Render -------------------------------------------------------------------
 
   return (
+    <>
     <div className={isPage ? "knowledge-surface h-full min-h-screen bg-slate-50" : "knowledge-surface fixed inset-0 z-50 flex items-center justify-center bg-black/40 p-4 backdrop-blur-sm"}>
       <div className={isPage ? "flex h-full min-h-screen w-full flex-col bg-white" : "flex max-h-[85vh] w-full max-w-md flex-col rounded-2xl bg-white shadow-xl"}>
 
@@ -614,7 +699,7 @@ export default function KnowledgeManagement({
                             )}
                           </div>
                           <button
-                            onClick={() => handleDeleteClient(client.id)}
+                            onClick={() => requestDeleteClient(client)}
                             disabled={deletingClient === client.id}
                             className="flex h-8 w-8 items-center justify-center rounded-lg text-slate-300 opacity-100 transition hover:bg-red-50 hover:text-red-500 disabled:opacity-30 sm:h-auto sm:w-auto sm:opacity-0 sm:group-hover:opacity-100"
                             title="Delete connection"
@@ -640,7 +725,7 @@ export default function KnowledgeManagement({
                   </span>
                   {documents.length > 0 && (
                     <button
-                      onClick={deleteAllDocuments}
+                      onClick={requestClearAllDocuments}
                       className="text-xs text-slate-400 hover:text-red-500 flex items-center gap-1 transition"
                     >
                       <Trash2 className="w-3 h-3" />
@@ -684,7 +769,7 @@ export default function KnowledgeManagement({
                         <div className="flex flex-shrink-0 items-center gap-1.5 sm:gap-2">
                           {renderStatus(doc)}
                           <button
-                            onClick={() => handleDeleteDocument(doc.id)}
+                            onClick={() => requestDeleteDocument(doc)}
                             disabled={deleting === doc.id}
                             className="flex h-8 w-8 items-center justify-center rounded-lg text-slate-300 opacity-100 transition hover:bg-red-50 hover:text-red-500 disabled:opacity-30 sm:h-auto sm:w-auto sm:opacity-0 sm:group-hover:opacity-100"
                             title="Delete"
@@ -924,5 +1009,58 @@ export default function KnowledgeManagement({
 
       </div>
     </div>
+
+    <AlertDialog open={deleteIntent !== null} onOpenChange={(open) => { if (!open) cancelDelete(); }}>
+      <AlertDialogContent>
+        <AlertDialogHeader>
+          <AlertDialogTitle>
+            {deleteIntent?.kind === "document" && `Delete "${deleteIntent.docName}"?`}
+            {deleteIntent?.kind === "database" && `Delete "${deleteIntent.clientName}"?`}
+            {deleteIntent?.kind === "clear-all-documents" && "Delete all documents?"}
+          </AlertDialogTitle>
+          <AlertDialogDescription asChild>
+            <div className="space-y-2 text-left">
+              {loadingImpact ? (
+                <div className="flex items-center gap-2 text-slate-500">
+                  <Loader2 className="h-3.5 w-3.5 animate-spin" />
+                  Checking which analyses use this source...
+                </div>
+              ) : impact.length === 0 ? (
+                <p>No analyses will be affected by this deletion.</p>
+              ) : (
+                <>
+                  <p>
+                    The following analys{impact.length === 1 ? "is is" : "es are"} using this source and will no longer be usable after deletion:
+                  </p>
+                  <div className="max-h-40 overflow-y-auto rounded-md border border-slate-200 bg-slate-50">
+                    <ul className="divide-y divide-slate-200">
+                      {impact.map((analysis) => (
+                        <li key={analysis.id} className="px-3 py-2 text-sm text-slate-700 truncate">
+                          {analysis.analysis_title}
+                        </li>
+                      ))}
+                    </ul>
+                  </div>
+                </>
+              )}
+            </div>
+          </AlertDialogDescription>
+        </AlertDialogHeader>
+        <AlertDialogFooter>
+          <AlertDialogCancel onClick={cancelDelete}>Cancel</AlertDialogCancel>
+          <AlertDialogAction
+            onClick={(e) => {
+              e.preventDefault();
+              void confirmDelete();
+            }}
+            disabled={confirming}
+            className="bg-red-600 text-white hover:bg-red-700"
+          >
+            {confirming ? "Deleting..." : "Delete"}
+          </AlertDialogAction>
+        </AlertDialogFooter>
+      </AlertDialogContent>
+    </AlertDialog>
+    </>
   );
 }

src/app/components/analysis/AnalysisHeader.tsx

@@ -7,9 +7,10 @@ interface AnalysisHeaderProps {
   analysis: Analysis | null;
   staleSources?: DataBindItem[];
   onUpdateDataBind: (items: DataBindItem[]) => Promise<void>;
+  unusable?: boolean;
 }
 
-export function AnalysisHeader({ analysis, staleSources = [], onUpdateDataBind }: AnalysisHeaderProps) {
+export function AnalysisHeader({ analysis, staleSources = [], onUpdateDataBind, unusable = false }: AnalysisHeaderProps) {
   const [editingSources, setEditingSources] = useState(false);
   const [draftBind, setDraftBind] = useState<DataBindItem[]>(analysis?.data_bind ?? []);
   const [saving, setSaving] = useState(false);
@@ -38,6 +39,7 @@ export function AnalysisHeader({ analysis, staleSources = [], onUpdateDataBind }
   };
 
   const openSourceEditor = () => {
+    if (unusable) return;
     setDraftBind(analysis.data_bind);
     setEditingSources((open) => !open);
   };
@@ -51,9 +53,10 @@ export function AnalysisHeader({ analysis, staleSources = [], onUpdateDataBind }
         <div className="flex flex-shrink-0 items-center gap-2 text-xs text-slate-500">
           <button
             type="button"
-            title="Update bound knowledge sources for this analysis"
+            title={unusable ? "Bound sources can no longer be updated for this analysis" : "Update bound knowledge sources for this analysis"}
             onClick={openSourceEditor}
-            className="inline-flex items-center gap-1 rounded-md border border-slate-200 px-2 py-1 hover:bg-slate-50 hover:text-slate-800"
+            disabled={unusable}
+            className="inline-flex items-center gap-1 rounded-md border border-slate-200 px-2 py-1 hover:bg-slate-50 hover:text-slate-800 disabled:cursor-not-allowed disabled:opacity-40 disabled:hover:bg-transparent disabled:hover:text-slate-500"
           >
             <Database className="h-3.5 w-3.5" />
             {analysis.data_bind.length} source{analysis.data_bind.length !== 1 ? "s" : ""}
@@ -66,27 +69,35 @@ export function AnalysisHeader({ analysis, staleSources = [], onUpdateDataBind }
           <div className="flex items-start gap-2">
             <AlertTriangle className="mt-0.5 h-4 w-4 flex-shrink-0" />
             <div>
-              <p className="font-medium">Some bound sources are no longer available.</p>
+              <p className="font-medium">
+                {unusable
+                  ? "Some bound sources are no longer available — this analysis can no longer be used."
+                  : "Some bound sources are no longer available."}
+              </p>
               <p className="mt-1 text-xs leading-5 text-amber-800">
-                Update sources before relying on this analysis: {staleSources.map((source) => source.name).join(", ")}.
+                {unusable
+                  ? `Missing sources: ${staleSources.map((source) => source.name).join(", ")}. Chat, help, suggested questions, report generation, and source updates are disabled for this analysis. You can still view its chat history and previously generated reports.`
+                  : `Update sources before relying on this analysis: ${staleSources.map((source) => source.name).join(", ")}.`}
               </p>
             </div>
           </div>
-          <button
-            type="button"
-            title="Open source binding editor"
-            onClick={() => {
-              setDraftBind(analysis.data_bind);
-              setEditingSources(true);
-            }}
-            className="rounded-md bg-amber-900 px-3 py-2 text-xs font-medium text-white hover:bg-amber-800"
-          >
-            Update binding
-          </button>
+          {!unusable && (
+            <button
+              type="button"
+              title="Open source binding editor"
+              onClick={() => {
+                setDraftBind(analysis.data_bind);
+                setEditingSources(true);
+              }}
+              className="rounded-md bg-amber-900 px-3 py-2 text-xs font-medium text-white hover:bg-amber-800"
+            >
+              Update binding
+            </button>
+          )}
         </div>
       )}
 
-      {editingSources && (
+      {editingSources && !unusable && (
         <div className="mt-4 rounded-lg border border-slate-200 bg-slate-50 p-3">
           <DataBindSelector value={draftBind} onChange={setDraftBind} disabled={saving} />
           {error && <p className="mt-2 text-xs text-red-600">{error}</p>}

src/app/components/analysis/AnalysisShell.tsx

@@ -367,9 +367,16 @@ export function AnalysisShell() {
   const activeMenuLabel =
     activeMenu === "analysis-agent" ? "Analysis Agent" : activeMenu === "knowledge" ? "Knowledge" : "Home";
 
+  const isActiveAnalysisUnusable = staleSources.length > 0;
+
   const chatPane = (
     <main className="flex h-full min-h-0 min-w-0 flex-col bg-slate-50">
-      <AnalysisHeader analysis={activeAnalysis} staleSources={staleSources} onUpdateDataBind={handleUpdateDataBind} />
+      <AnalysisHeader
+        analysis={activeAnalysis}
+        staleSources={staleSources}
+        onUpdateDataBind={handleUpdateDataBind}
+        unusable={isActiveAnalysisUnusable}
+      />
       <div className="min-h-0 flex-1 overflow-y-auto overflow-x-hidden overscroll-contain">
         {loadingMessages ? (
           <div className="flex h-full items-center justify-center text-sm text-slate-500">Loading messages</div>
@@ -384,9 +391,18 @@ export function AnalysisShell() {
         )}
       </div>
       {messages.length > 0 && (
-        <SuggestedQuestionsBar questions={activeAnalysis?.business_questions ?? []} onSelect={handleSend} />
+        <SuggestedQuestionsBar
+          questions={activeAnalysis?.business_questions ?? []}
+          onSelect={handleSend}
+          disabled={isActiveAnalysisUnusable}
+        />
       )}
-      <ChatInput disabled={!activeAnalysis} streaming={streamState !== "idle"} onSend={handleSend} onHelp={handleHelp} />
+      <ChatInput
+        disabled={!activeAnalysis || isActiveAnalysisUnusable}
+        streaming={streamState !== "idle"}
+        onSend={handleSend}
+        onHelp={handleHelp}
+      />
     </main>
   );
 
@@ -410,6 +426,7 @@ export function AnalysisShell() {
         onCollapse={() => setReportCollapsed(true)}
         fullscreen={reportFullscreen}
         onToggleFullscreen={() => setReportFullscreen((value) => !value)}
+        disabled={isActiveAnalysisUnusable}
       />
     </div>
   );
@@ -521,7 +538,12 @@ export function AnalysisShell() {
             className="absolute inset-0 bg-slate-950/40"
           />
           <div className="absolute inset-x-0 bottom-0 max-h-[86vh] overflow-y-auto rounded-t-xl bg-white p-4 shadow-2xl">
-            <ReportSidebar analysis={activeAnalysis} userId={session?.user_id} onCollapse={() => setMobileReportOpen(false)} />
+            <ReportSidebar
+              analysis={activeAnalysis}
+              userId={session?.user_id}
+              onCollapse={() => setMobileReportOpen(false)}
+              disabled={isActiveAnalysisUnusable}
+            />
           </div>
         </div>
       )}
@@ -551,7 +573,7 @@ export function AnalysisShell() {
         </div>
       </div>
 
-      <NewAnalysisDialog open={newAnalysisOpen} onClose={() => setNewAnalysisOpen(false)} onCreated={handleCreated} />
+      <NewAnalysisDialog open={newAnalysisOpen} onClose={() => setNewAnalysisOpen(false)} onCreated={handleCreated} existingAnalyses={analyses} />
     </div>
   );
 }

src/app/components/analysis/NewAnalysisDialog.tsx

@@ -16,13 +16,20 @@ function formatCreateAnalysisError(err: unknown) {
   }
   return message;
 }
+function isDuplicateName(candidate: string, existing: Analysis[]): boolean {
+  const normalized = candidate.trim().toLowerCase();
+  if (!normalized) return false;
+  return existing.some((a) => a.analysis_title.trim().toLowerCase() === normalized);
+}
+
 interface NewAnalysisDialogProps {
   open: boolean;
   onClose: () => void;
   onCreated: (analysis: Analysis) => void;
+  existingAnalyses: Analysis[];
 }
 
-export function NewAnalysisDialog({ open, onClose, onCreated }: NewAnalysisDialogProps) {
+export function NewAnalysisDialog({ open, onClose, onCreated, existingAnalyses }: NewAnalysisDialogProps) {
   const [title, setTitle] = useState("");
   const [objective, setObjective] = useState("");
   const [questions, setQuestions] = useState<string[]>(["", ""]);
@@ -32,7 +39,14 @@ export function NewAnalysisDialog({ open, onClose, onCreated }: NewAnalysisDialo
 
   if (!open) return null;
 
-  const canSubmit = title.trim() && objective.trim() && compactQuestions(questions).length >= 2 && dataBind.length > 0;
+  const duplicateName = isDuplicateName(title, existingAnalyses);
+
+  const canSubmit =
+    title.trim() &&
+    !duplicateName &&
+    objective.trim() &&
+    compactQuestions(questions).length >= 2 &&
+    dataBind.length > 0;
 
   const submit = async (event: React.FormEvent) => {
     event.preventDefault();
@@ -83,6 +97,9 @@ export function NewAnalysisDialog({ open, onClose, onCreated }: NewAnalysisDialo
               placeholder="Q3 revenue movement"
               className="w-full rounded-lg border border-slate-200 px-3 py-2 text-sm outline-none focus:border-emerald-500 focus:ring-2 focus:ring-emerald-100"
             />
+            {duplicateName && (
+              <p className="text-xs text-red-600">An analysis with this name already exists. Choose a different name.</p>
+            )}
           </div>
 
           <div className="space-y-1.5">

src/app/components/analysis/ReportSidebar.tsx

@@ -20,9 +20,10 @@ interface ReportSidebarProps {
   onCollapse?: () => void;
   fullscreen?: boolean;
   onToggleFullscreen?: () => void;
+  disabled?: boolean;
 }
 
-export function ReportSidebar({ analysis, userId, onCollapse, fullscreen = false, onToggleFullscreen }: ReportSidebarProps) {
+export function ReportSidebar({ analysis, userId, onCollapse, fullscreen = false, onToggleFullscreen, disabled = false }: ReportSidebarProps) {
   const [versions, setVersions] = useState<ReportSummary[]>([]);
   const [selectedVersion, setSelectedVersion] = useState<number | undefined>();
   const [detail, setDetail] = useState<ReportDetail | null>(null);
@@ -135,7 +136,7 @@ export function ReportSidebar({ analysis, userId, onCollapse, fullscreen = false
             aria-label="Generate report"
             title="Generate a new report version with the Python report skill"
             onClick={handleGenerate}
-            disabled={!analysis || !userId || generating}
+            disabled={!analysis || !userId || generating || disabled}
             className="inline-flex items-center gap-2 rounded-md bg-slate-900 px-3 py-2 text-xs font-medium text-white hover:bg-slate-800 disabled:cursor-not-allowed disabled:opacity-50"
           >
             {generating && <Loader2 className="h-3.5 w-3.5 animate-spin" />}

src/app/components/analysis/SuggestedQuestionsBar.tsx

@@ -4,9 +4,10 @@ import { compactQuestions } from "./utils";
 interface SuggestedQuestionsBarProps {
   questions: string[];
   onSelect: (question: string) => void;
+  disabled?: boolean;
 }
 
-export function SuggestedQuestionsBar({ questions, onSelect }: SuggestedQuestionsBarProps) {
+export function SuggestedQuestionsBar({ questions, onSelect, disabled }: SuggestedQuestionsBarProps) {
   const filtered = compactQuestions(questions);
   if (filtered.length === 0) return null;
 
@@ -18,9 +19,10 @@ export function SuggestedQuestionsBar({ questions, onSelect }: SuggestedQuestion
           <button
             key={question}
             type="button"
-            onClick={() => onSelect(question)}
+            onClick={() => { if (!disabled) onSelect(question); }}
+            disabled={disabled}
             title={question}
-            className="flex-shrink-0 whitespace-nowrap rounded-full border border-slate-200 bg-white px-3 py-1 text-xs text-slate-600 transition hover:border-emerald-300 hover:bg-emerald-50 hover:text-emerald-800"
+            className="flex-shrink-0 whitespace-nowrap rounded-full border border-slate-200 bg-white px-3 py-1 text-xs text-slate-600 transition hover:border-emerald-300 hover:bg-emerald-50 hover:text-emerald-800 disabled:cursor-not-allowed disabled:opacity-40 disabled:hover:border-slate-200 disabled:hover:bg-white disabled:hover:text-slate-600"
           >
             {question}
           </button>