@alucify/cli 0.6.5 → 0.7.1

package/dist/docs/help/vscode/chat/refining-specs-in-chat.md

@@ -0,0 +1,47 @@
+---
+order: 2
+title: "Refining Specs in Chat"
+description: "Using chat to resolve AI Coding Risks and improve specifications."
+---
+
+# Refining Specs in Chat
+
+Chat-based spec refinement is the fastest way to resolve an [AI Coding Risk](../../concepts/ai-coding-risks.md). Claude sees the risk context, the relevant spec, and the code — so you can have a focused conversation about the fix.
+
+For the general concept of chat across Alucify, see [Chat Refinement](../../concepts/chat-refinement.md).
+
+## Starting from a Risk
+
+1. Open the [AI Coding Risks Panel](../code-analysis/ai-coding-risks-panel.md)
+2. Click a risk to expand it
+3. Click **Resolve via chat**
+
+The Chat view opens in the secondary sidebar with the risk context loaded.
+
+## Bulk Refinement
+
+Select multiple risks via checkboxes and click **Refine Specs** at the top of the panel. Claude will see all selected risks together and work through them systematically.
+
+## What Claude Sees
+
+When you open refinement chat, the session pre-loads:
+
+- The risk(s) you selected (type, severity, label, suggested action)
+- The relevant spec content
+- The connected code nodes
+- Alucify's suggested solutions
+
+This grounding prevents hallucination — Claude won't invent specs that don't exist or misquote code.
+
+## Applying Suggestions
+
+When Claude proposes a spec edit, an **Apply to spec** button appears next to the suggestion. Clicking it opens a diff view in VS Code so you can approve or modify the change before it's written.
+
+## When Chat Isn't the Right Tool
+
+- **If the fix is in code, not specs** — close the chat and edit the code directly, or use `/alucify-continue` in Claude Code to have an agent do it
+- **If you're exploring, not fixing** — use [Ask About Your Project](asking-about-your-project.md) instead
+
+## Session Persistence
+
+Each refinement session is saved per-workspace and can be resumed later from the session switcher at the top of the chat panel.

package/dist/docs/help/vscode/code-analysis/_meta.json

@@ -0,0 +1 @@
+{ "title": "Code Analysis", "order": 4 }

package/dist/docs/help/vscode/code-analysis/ai-coding-risks-panel.md

@@ -0,0 +1,42 @@
+---
+order: 5
+title: "AI Coding Risks Panel"
+description: "How to view and interpret the AI Coding Risks panel in VS Code."
+---
+
+# AI Coding Risks Panel
+
+For what AI Coding Risks are and what each risk type means, see [AI Coding Risks](../../concepts/ai-coding-risks.md).
+
+## Opening the Panel
+
+- From the Code Analysis tab, click **View Details** next to the AI Coding Risks section
+- Or open the Command Palette and search for **Alucify: View AI Coding Risks**
+
+## Reading a Risk Entry
+
+Each risk in the list shows:
+
+1. **Severity** — Color-coded dot indicating severity level
+2. **Risk Type** — Category of the risk
+3. **Label** — A brief description of the specific issue
+4. **Action** — The recommended action to resolve it
+
+## Exploring Solutions
+
+Click on a risk to expand it and see solution options:
+
+- **Recommended** — The solution Alucify suggests based on the analysis (marked with a badge)
+- **Alternative options** — Other ways to address the issue
+- Each solution shows its expected impact
+
+## Resolving Risks
+
+You have several options for each risk:
+
+- **Resolve via chat** — Opens the [Refine Specs](../spec-analysis/refining-specs.md) chat to work with Claude on resolving the issue interactively
+- **Ignore this issue** — Marks the risk as ignored if it's not relevant to your project
+
+## Bulk Actions
+
+You can select multiple risks using checkboxes and resolve them together using the **Refine Specs** button at the top of the panel.

package/dist/docs/help/vscode/code-analysis/project-analysis-panel.md

@@ -0,0 +1,46 @@
+---
+order: 2
+title: "Project Analysis Panel"
+description: "A walkthrough of the Code Analysis tab in VS Code — metrics, codebase summary, and what each section means."
+---
+
+# Project Analysis Panel
+
+The Code Analysis tab is the first of three tabs in the Project Analysis panel. It shows the results of your codebase scan.
+
+## Codebase Section
+
+This section provides a high-level summary of your project:
+
+- **Lines of Code** — Total lines across your project (displayed as "1.2M", "301k", "45k", etc.)
+- **Tech Stack** — Detected frameworks and languages shown as tag pills (e.g., "React", "Express", "PostgreSQL")
+- **Analysis Date** — When the codebase was last analyzed (hover the info icon for the exact date)
+
+## Analysis Mode
+
+Shows which [analysis mode](../../concepts/analysis-modes.md) was used: **Speed**, **Balanced**, or **Quality**.
+
+## Architecture Health
+
+If a technical debt analysis has been run, this section shows:
+
+- **Health Score** — A 0–100 score with a letter grade (A–F) rating your architecture's structural health
+- **View Details** link — Opens the full [Tech Debt Panel](tech-debt-panel.md)
+
+## AI Coding Risks
+
+If risks have been identified, this section shows a summary:
+
+- **Risk count** — Total number of identified risks
+- **Severity breakdown** — Count by severity level (Critical, High, Medium, Low)
+- **View Details** link — Opens the full [AI Coding Risks Panel](ai-coding-risks-panel.md)
+
+## Action Buttons
+
+- **Analyze Code** — Appears when no baseline exists, or when code has changed since the last analysis. Click to run or re-run code analysis.
+
+## Understanding Scores
+
+When you first see your scores, a dismissible card explains: "These scores show how ready your specs are for AI coding. Higher is better. Hover any score for details and check out the recommendations for next steps."
+
+Click **Got it** to dismiss this card permanently.

package/dist/docs/help/vscode/code-analysis/running-code-analysis.md

@@ -0,0 +1,54 @@
+---
+order: 1
+title: "Analyzing Your Codebase"
+description: "How to run code analysis to build a baseline understanding of your project."
+---
+
+# Analyzing Your Codebase
+
+Code analysis scans your project's source code to build a structured understanding of its architecture — what screens, logic, and data models exist.
+
+## Running Code Analysis
+
+1. Open the Alucify sidebar by clicking the Alucify icon in the activity bar
+2. In the **Project Analysis** panel, click the **Analyze Code** button
+3. Select an analysis mode:
+   - **Speed** — Optimized for speed, usually 5–10 minutes
+   - **Balanced** — Balances speed and quality, usually 15–60 minutes
+   - **Quality** — Optimized for quality, usually 45–90 minutes
+4. Wait for the analysis to complete
+
+A progress indicator shows the current phase. You can continue working in VS Code while the analysis runs.
+
+## Choosing an Analysis Mode
+
+See [Analysis Modes](../../concepts/analysis-modes.md) for a detailed comparison of the three modes.
+
+As a general rule:
+- Start with **Speed** to get quick results at no cost
+- Use **Balanced** for most projects where you want AI-powered insights
+- Use **Quality** for important analyses where thoroughness matters most
+
+## Re-Analyzing After Code Changes
+
+When your code changes after a previous analysis, the Code Analysis tab shows a message: "Code has changed since the last baseline was generated." Click **Analyze Code** again to update your baseline with the latest changes.
+
+## What Happens During Analysis
+
+During code analysis, Alucify:
+
+1. Scans your source files to identify components, services, and data models
+2. Maps dependencies and relationships between them
+3. Detects your tech stack (frameworks, languages)
+4. Counts lines of code
+5. Saves a versioned snapshot of the analysis
+
+When complete, the results appear in the [Project Analysis Panel](project-analysis-panel.md).
+
+## Using the Command Palette
+
+You can also start code analysis from the Command Palette:
+
+1. Press `Ctrl+Shift+P` / `Cmd+Shift+P`
+2. Search for **Alucify: Analyze Code**
+3. Select your analysis mode

package/dist/docs/help/vscode/code-analysis/tech-debt-panel.md

@@ -0,0 +1,27 @@
+---
+order: 4
+title: "Tech Debt Panel"
+description: "How to view and interpret the Technical Debt Analysis panel in VS Code."
+---
+
+# Tech Debt Panel
+
+For what Tech Debt Analysis measures and how to read each dimension, see [Tech Debt Analysis](../../concepts/tech-debt-analysis.md).
+
+## Opening the Panel
+
+- From the Code Analysis tab, click **View Details** next to the Architecture Health section
+- Or open the Command Palette and search for **Alucify: View Technical Debt Analysis**
+
+## Layout
+
+The panel shows the Architecture Health Score at top, four banner metrics below (Change Scope, Structural Risk, Debt Trend, plus a summary card), and six detail tabs:
+
+- **Remediation** — priority actions to reduce debt
+- **Change Scope** — visualization of change propagation
+- **Structural Risk** — Fragility Index + score breakdown + stress attribution
+- **Debt Trend** — forward-looking projection with trajectory graph
+- **Complexity** — complexity hotspots by location
+- **Outdated Packages** — dependency freshness
+
+Each dimension is explained in [Tech Debt Analysis](../../concepts/tech-debt-analysis.md). Click any hotspot or component name to jump to the source file in your editor.

package/dist/docs/help/vscode/command-palette.md

@@ -0,0 +1,83 @@
+---
+order: 13
+title: "Command Palette Reference"
+description: "Every Alucify command you can invoke from the Command Palette in VS Code."
+---
+
+# Command Palette Reference
+
+Open the Command Palette with `Cmd+Shift+P` (macOS) or `Ctrl+Shift+P` (Windows/Linux), then type `Alucify` to filter.
+
+## Analysis
+
+| Command | What it does |
+|---|---|
+| **Alucify: Analyze Code** | Run baseline code analysis. [Docs](code-analysis/running-code-analysis.md) |
+| **Alucify: Analyze Specs** | Analyze imported specs against code. [Docs](spec-analysis/analyzing-specs.md) |
+| **Alucify: Add Spec** | Import a spec file. [Docs](spec-analysis/adding-specs.md) |
+| **Alucify: Generate Spec** | Generate a new artifact from a template. [Docs](spec-analysis/generating-specs.md) |
+| **Alucify: Refine Specs** | Open the chat to work on specific risks. [Docs](chat/refining-specs-in-chat.md) |
+| **Alucify: Audit Specs** | Quality-check specs before analysis. [Docs](spec-analysis/auditing-specs.md) |
+| **Alucify: Preview Specs** | Partial analysis for preview. [Docs](spec-analysis/filtering-and-browsing-specs.md) |
+
+## Progress
+
+| Command | What it does |
+|---|---|
+| **Alucify: Analyze Progress** | Track implementation status against commits. [Docs](dev-progress/analyzing-commits.md) |
+| **Alucify: Analyze Commits** (advanced) | Manual commit-by-commit analysis |
+| **Alucify: Analyze Intent** | Capture + integrate intent in one step. [Docs](intent-capture/analyzing-intent.md) |
+| **Alucify: Capture Intent** | Capture only (no integration). [Docs](intent-capture/enabling-intent-capture.md) |
+
+## Panels
+
+| Command | What it does |
+|---|---|
+| **Alucify: Open AppGraph Visualizer** | Interactive graph view. [Docs](appgraph-visualizer/opening-the-visualizer.md) |
+| **Alucify: View AI Coding Risks** | Full risks panel. [Docs](code-analysis/ai-coding-risks-panel.md) |
+| **Alucify: View Technical Debt Analysis** | Full tech debt panel. [Docs](code-analysis/tech-debt-panel.md) |
+| **Alucify: View Token Usage** | Token consumption panel. [Docs](token-usage/viewing-token-usage.md) |
+
+## Versions (Advanced Mode)
+
+| Command | What it does |
+|---|---|
+| **Alucify: Compare Versions** | Diff two snapshots. [Docs](versions/comparing-versions.md) |
+| **Alucify: Switch Version** | Load an older version. [Docs](versions/switching-versions.md) |
+| **Alucify: Delete Version** | Remove a snapshot. [Docs](versions/deleting-versions.md) |
+
+## Authentication
+
+| Command | What it does |
+|---|---|
+| **Alucify: Set Anthropic API Key** | Configure API key. [Docs](authentication/api-key-setup.md) |
+| **Alucify: Sign In** | Auth0 login. [Docs](authentication/signing-in.md) |
+| **Alucify: Logout** | Sign out |
+| **Alucify: Switch Auth Mode** | API Key ↔ Claude Code. [Docs](authentication/switching-auth-modes.md) |
+
+## Reset / Advanced Mode
+
+| Command | What it does |
+|---|---|
+| **Alucify (Advanced): Reset Progress** | Clear implementation statuses. [Docs](dev-progress/progress-panel-actions.md#reset-progress) |
+| **Alucify (Advanced): Reset Analysis** | Archive and start fresh. [Docs](resetting-analysis.md) |
+| **Alucify (Advanced): Reset Extension** | Factory reset including auth. [Docs](advanced/reset-extension.md) |
+| **Alucify (Advanced): Reset Welcome Screen** | Restore first-run onboarding |
+
+## Advanced Analyses
+
+Available only in [Advanced Mode](settings/advanced-mode.md):
+
+| Command | What it does |
+|---|---|
+| **Alucify (Advanced): Analyze Congruency** | Spec-code alignment check. [Docs](advanced/congruency-analysis.md) |
+| **Alucify (Advanced): Analyze Coverage** | Coverage gap check. [Docs](advanced/coverage-analysis.md) |
+| **Alucify (Advanced): Analyze Impact** | Blast radius analysis. [Docs](advanced/impact-analysis.md) |
+| **Alucify (Advanced): Analyze Findings** | Quality insight synthesis. [Docs](advanced/findings-synthesis.md) |
+
+## Help & Feedback
+
+| Command | What it does |
+|---|---|
+| **Alucify: Open Help** | Open this help browser |
+| **Alucify: Send Feedback** | Send feedback to the Alucify team |

package/dist/docs/help/vscode/dev-progress/_meta.json

@@ -0,0 +1 @@
+{ "title": "Dev Progress", "order": 6 }

package/dist/docs/help/vscode/dev-progress/analyzing-commits.md

@@ -0,0 +1,56 @@
+---
+order: 1
+title: "Analyzing Implementation Progress"
+description: "How to analyze your git commits to track implementation progress against specs."
+---
+
+# Analyzing Implementation Progress
+
+Progress tracking analyzes your git commits to determine what's been implemented, what's in progress, and what's still outstanding — all measured against your specifications.
+
+## Prerequisites
+
+Before analyzing progress:
+
+1. You've run both [code analysis](../code-analysis/running-code-analysis.md) and [spec analysis](../spec-analysis/analyzing-specs.md)
+2. You have git commits to analyze
+
+## How to Analyze Progress
+
+1. In the **Project Analysis** panel, switch to the **Dev Progress** tab
+2. Click the **Analyze Progress** button
+3. Alucify analyzes your commits since the last checkpoint
+
+The analysis classifies each commit's changes against your specifications, updating the implementation status of each requirement.
+
+## Automatic Progress Analysis
+
+After running **Analyze Specs**, progress analysis runs automatically if your project has requirements linked to code. You don't need to trigger it manually the first time — it happens as part of the spec analysis workflow.
+
+## What Happens During Analysis
+
+Progress analysis:
+
+1. Reads your git history since the last analyzed checkpoint
+2. Maps file changes to project components using source file links and code references
+3. Reads the **full file content** for components being reassessed, so the classifier can judge whether the implementation is complete — not just what changed
+4. Classifies whether changes implement, partially implement, or test requirements
+5. Records **implementation gaps** for in-progress components — concrete notes describing exactly what's missing (e.g., "has GET handler but missing POST/DELETE branches")
+6. Updates implementation statuses (Planned → In Progress → Implemented)
+7. Saves a checkpoint so future analyses only process new commits
+8. Creates a versioned snapshot
+
+## Using the Command Palette
+
+You can also start progress analysis from the Command Palette:
+
+1. Press `Ctrl+Shift+P` / `Cmd+Shift+P`
+2. Search for **Alucify: Analyze Progress**
+
+## Tips
+
+- **Analyze regularly** — Run progress analysis after significant commits to keep your status up to date
+- **The first analysis covers all history** — The initial run analyzes all commits since your spec analysis. Subsequent runs only process new commits.
+- **Uncommitted changes are included** — Analysis looks at both committed and uncommitted changes
+- **In-progress components are always re-checked** — Components marked as in-progress are reassessed on every run until they reach implemented, even if their files haven't changed since the last checkpoint
+- **Link files for better accuracy** — Use `link_context` (via Claude Code) to connect components to their implementation files. This enables mechanical matching and ensures components are tracked accurately across runs.

package/dist/docs/help/vscode/dev-progress/progress-panel-actions.md

@@ -0,0 +1,56 @@
+---
+order: 3
+title: "Progress Panel Actions"
+description: "Actions available on the Dev Progress panel — re-analyze, reset, filter."
+---
+
+# Progress Panel Actions
+
+The Dev Progress panel has several actions beyond just viewing status.
+
+## Re-Analyze Progress
+
+Triggers a fresh [`alucify analyze-progress`](../../cli/commands/analyze-progress.md) run against your current git state.
+
+- **Command Palette** — **Alucify: Analyze Progress**
+- **Dev Progress panel** — the **Re-analyze** button in the header
+
+Use this if:
+- You want to see changes that landed outside of a normal commit (e.g., a `git reset` or `cherry-pick`)
+- The post-commit hook didn't fire
+- You haven't run [`alucify enable`](../../cli/commands/enable-disable.md) and want to manually update progress
+
+## Reset Progress
+
+**Advanced Mode only.** Wipes all implementation status tracking and starts fresh. Does **not** delete specs, code analysis, or versions — only the per-node status fields.
+
+- **Command Palette** — **Alucify: Reset Progress**
+- **Advanced menu** — **Reset Progress**
+
+When to use:
+- You've significantly restructured specs and the old statuses are no longer meaningful
+- You want to re-baseline progress from scratch
+
+This doesn't undo existing commits or re-run analysis — it just clears the "implemented / in progress / tested" state so the next `analyze-progress` starts from zero.
+
+## Filtering
+
+The panel has filter controls at the top:
+
+- **Status** — show only Planned / In Progress / Implemented / Tested
+- **FunctionalArea** — narrow to a specific area
+- **New since last version** — only items added or changed since the previous snapshot
+
+## Jump to Node
+
+Click any requirement name to jump to its node in the [AppGraph Visualizer](../appgraph-visualizer/opening-the-visualizer.md), where you can see dependencies, connected code, and test coverage.
+
+## Export
+
+**Export Progress Report** produces a Markdown summary suitable for pasting into a status doc or sprint review.
+
+## See Also
+
+- [Understanding the Dev Progress Tab](understanding-the-dev-progress-tab.md)
+- [Analyzing Commits](analyzing-commits.md)
+- [Implementation Progress](../../concepts/implementation-progress.md)

package/dist/docs/help/vscode/dev-progress/understanding-the-dev-progress-tab.md

@@ -0,0 +1,40 @@
+---
+order: 2
+title: "Understanding the Dev Progress Tab"
+description: "A walkthrough of the Dev Progress tab — progress metrics, requirement status, and commit analysis."
+---
+
+# Understanding the Dev Progress Tab
+
+The Dev Progress tab is the third of three tabs in the Project Analysis panel. It tracks your implementation progress against specifications.
+
+## Dev Progress Metric
+
+At the top, a percentage shows your overall development progress — the proportion of specified components that have been implemented or tested. A sparkline shows the trend across analysis versions.
+
+## Requirements Section
+
+Below the progress metric, a breakdown shows the status of each requirement:
+
+- How many requirements exist in total
+- How many are in each status: Planned, In Progress, Implemented
+- A visual indicator for each requirement showing its current state
+- Per-requirement implementation progress showing how many components are done
+
+Requirements that were newly added since the last analysis are marked with a **NEW** badge.
+
+For in-progress components, the tab shows **implementation gaps** — concrete notes describing what's still missing (e.g., "Missing scope check before mutation; missing audit_log() call on delete"). These gap notes are used by the `/alucify-plan` skill to generate targeted code changes.
+
+## Getting Started
+
+If you haven't analyzed any commits yet, the tab shows a guide explaining the feature and an **Analyze Progress** button to get started.
+
+## Claude Code Integration
+
+The Dev Progress tab includes a toggle to enable Alucify integration with Claude Code. When enabled, Claude Code gains access to your project analysis through the MCP server, allowing it to make more informed implementation decisions.
+
+See [Setting Up the MCP Server](../../mcp-server/setup.md) for details.
+
+## Empty State
+
+If you haven't run spec analysis yet, the tab shows: "Run code and spec analysis first to start tracking progress."

package/dist/docs/help/vscode/installation.md

@@ -0,0 +1,34 @@
+---
+order: 2
+title: "Installing the Extension"
+description: "How to install the Alucify extension from the VS Code Marketplace."
+---
+
+# Installing the Extension
+
+## From the VS Code Marketplace
+
+1. Open VS Code
+2. Click the **Extensions** icon in the activity bar (or press `Ctrl+Shift+X` / `Cmd+Shift+X`)
+3. Search for **Alucify**
+4. Click **Install**
+
+After installation, the Alucify icon appears in your activity bar (left sidebar).
+
+## Requirements
+
+- VS Code version 1.85.0 or later
+- A project folder open in VS Code
+
+## First Launch
+
+When you click the Alucify icon for the first time, you'll see the welcome screen. This guides you through:
+
+1. Creating an Alucify account (free)
+2. Connecting to Claude (API key or Claude Code subscription)
+
+See [VS Code Extension Quick Start](quickstart.md) for the complete setup walkthrough.
+
+## Updating
+
+The extension updates automatically through VS Code's built-in extension update mechanism. You can also manually check for updates in the Extensions panel.

package/dist/docs/help/vscode/intent-capture/_meta.json

@@ -0,0 +1 @@
+{ "title": "Intent Capture", "order": 7 }

package/dist/docs/help/vscode/intent-capture/analyzing-intent.md

@@ -0,0 +1,49 @@
+---
+order: 3
+title: "Analyzing Intent"
+description: "Running the full intent capture + integration pass in one step."
+---
+
+# Analyzing Intent
+
+The **Analyze Intent** command captures intent from recent Claude Code sessions *and* integrates it into your AppGraph in one step — so you can see the results immediately.
+
+For what intent capture is, see [Intent Capture](../../concepts/intent-capture.md).
+
+## Running It
+
+- **Command Palette** — `Cmd+Shift+P` / `Ctrl+Shift+P` → **Alucify: Analyze Intent**
+
+## What It Does (Two Phases)
+
+### 1. Capture
+Reads your recent Claude Code sessions from `~/.claude/projects/` and extracts project-level decisions, requirements, and design context. Captured intent is staged in `.alucify/extractions/intents/`.
+
+### 2. Integrate
+Merges the staged intent into your project AppGraph:
+- New requirements become new FeatureSpec or AcceptanceCriterion nodes
+- Decisions attached to existing nodes become annotations
+- Origin is marked as `intent` so you can filter later
+
+## `Analyze Intent` vs. `Capture Intent`
+
+| Command | What it does | When to use |
+|---|---|---|
+| **Alucify: Capture Intent** | Extracts; stages for review | You want to review before integrating |
+| **Alucify: Analyze Intent** | Extract + integrate in one go | You trust the capture; want results now |
+
+For CLI equivalents, see [`alucify capture-intent`](../../cli/commands/capture-intent.md).
+
+## When There's Nothing New
+
+If no new intent is found (or no new sessions have run since last capture), the command exits quickly with a notification. Nothing is staged or integrated.
+
+## Reviewing What Was Integrated
+
+Open the [AppGraph Visualizer](../appgraph-visualizer/opening-the-visualizer.md) and filter by **Origin: Intent** to see the nodes and annotations added by intent capture.
+
+You can also compare before/after with [Comparing Versions](../versions/comparing-versions.md) — select the last version before intent integration as the base.
+
+## Turning It Off
+
+If you don't want automatic captures, turn off **Intent Capture: Enabled** in settings (see [Enabling Intent Capture](enabling-intent-capture.md)). You can still run `Analyze Intent` manually.

package/dist/docs/help/vscode/intent-capture/enabling-intent-capture.md

@@ -0,0 +1,40 @@
+---
+order: 1
+title: "Enabling Intent Capture"
+description: "How to turn on intent capture and surface requirements from your Claude Code sessions."
+---
+
+# Enabling Intent Capture
+
+Intent capture surfaces requirements, decisions, and design context from your Claude Code sessions and adds them to your AppGraph — so the thinking behind your code doesn't get lost when a session ends.
+
+## Prerequisites
+
+- You've run `alucify enable` (sets up the Claude Code integration)
+- You have an AppGraph (run **Analyze Code** or **Analyze Specs** first)
+
+## Turning It On
+
+1. Open VS Code Settings (`Cmd+,` / `Ctrl+,`)
+2. Search for **Alucify Intent Capture**
+3. Enable **Intent Capture: Enabled**
+
+Once enabled, Alucify periodically checks your recent Claude Code sessions and extracts anything relevant to your project.
+
+## Running It Manually
+
+You can trigger intent capture at any time from the Command Palette (`Cmd+Shift+P` / `Ctrl+Shift+P`):
+
+- **Alucify: Capture Intent** — Extract intent from your recent sessions. Results are staged for review before being added to the AppGraph.
+- **Alucify: Analyze Intent** — Capture intent and immediately integrate it into the AppGraph. Use this when you want to see results right away.
+
+## What Happens After Capture
+
+Extracted intent shows up in the AppGraph as new nodes or as annotations on existing nodes. You can explore them in the **AppGraph Visualizer** or see them reflected in your implementation status and coverage.
+
+## CLI
+
+```bash
+alucify capture-intent          # Extract from recent sessions
+alucify capture-intent --force  # Extract right now, don't wait
+```

package/dist/docs/help/vscode/quickstart.md

@@ -0,0 +1,60 @@
+---
+order: 1
+title: "VS Code Extension Quick Start"
+description: "Get up and running with the Alucify VS Code extension in under 5 minutes."
+---
+
+# VS Code Extension Quick Start
+
+Get Alucify analyzing your project in just a few steps.
+
+## 1. Install the Extension
+
+Search for **Alucify** in the VS Code Extensions marketplace and click **Install**. See [Installing the Extension](installation.md) for details.
+
+## 2. Open a Project
+
+Open a project folder in VS Code. The Alucify icon will appear in your activity bar (left sidebar).
+
+## 3. Complete the Welcome Setup
+
+Click the Alucify icon to open the sidebar. The welcome screen walks you through two setup steps:
+
+1. **Sign in to Alucify** — Create a free account or sign in to your existing one. Click **Sign Up / Sign In** to get started.
+
+2. **Connect to Claude** — Choose how Alucify connects to Claude for AI analysis:
+   - **Claude Code Subscription** — Use your existing Claude Code or Claude Max subscription
+   - **Anthropic API Key** — Pay per token with your own API key
+
+## 4. Analyze Your Code
+
+Once setup is complete, you'll see the **Project Analysis** panel. Click the **Analyze Code** button to scan your codebase.
+
+Choose an analysis mode:
+- **Speed** — Fast mechanical analysis (5–10 minutes, no AI cost)
+- **Balanced** — AI-powered analysis (15–60 minutes)
+- **Quality** — Comprehensive analysis (45–90 minutes)
+
+Wait for the analysis to complete. You'll see a progress indicator and can continue working while it runs.
+
+## 5. Review Your Results
+
+When analysis finishes, the **Code Analysis** tab shows:
+- Your tech stack
+- Lines of code
+- Architecture health score
+- AI coding risks (if any)
+
+## 6. Add and Analyze Specs (Optional)
+
+To compare your code against your requirements:
+
+1. Click **Add Spec** in the **Specifications** panel to import your PRDs, design docs, or other spec files
+2. Click **Analyze Specs** to run the comparison
+3. Review the results in the **Spec Analysis** tab
+
+## What's Next?
+
+- [Project Analysis Panel](code-analysis/project-analysis-panel.md)
+- [Adding Specification Documents](spec-analysis/adding-specs.md)
+- [Analyzing Implementation Progress](dev-progress/analyzing-commits.md)