@alucify/cli 0.6.5 → 0.7.0

package/dist/docs/help/vscode/resetting-analysis.md

@@ -0,0 +1,46 @@
+---
+order: 9
+title: "Resetting Your Analysis"
+description: "How to reset your analysis data and start fresh, including what gets archived."
+---
+
+# Resetting Your Analysis
+
+If you need to start fresh, you can reset all analysis data. This archives your existing data and returns Alucify to its initial state.
+
+## How to Reset
+
+1. Open the Command Palette (`Ctrl+Shift+P` / `Cmd+Shift+P`)
+2. Search for **Alucify: Reset Analysis**
+3. Confirm the reset when prompted
+
+You'll see a warning: "Reset all analysis? This will archive your current baseline, spec analysis, progress tracking, and all version history. Your data will be preserved in .alucify/archived/ if you need to recover it."
+
+Click **Reset Analysis** to proceed, or cancel to keep your data.
+
+## What Gets Archived
+
+All of your analysis data is moved to `.alucify/archived/[timestamp]/`, including:
+
+- Code analysis baseline
+- Spec analysis results
+- Version history
+- Progress tracking data
+- Imported artifacts
+
+## What Happens After Reset
+
+- All panels refresh to show their empty state
+- The Code Analysis tab shows the **Analyze Code** button again
+- The Specifications panel is empty
+- You'll see a confirmation: "Analysis reset. All previous data archived to .alucify/archived/."
+
+## Recovering Archived Data
+
+Your archived data is preserved in `.alucify/archived/` with a timestamp. While there's no built-in restore feature, the files are standard JSON and can be manually copied back if needed.
+
+## When to Reset
+
+- You've significantly restructured your project and want a clean baseline
+- You want to re-analyze with different settings from scratch
+- You're switching the project that a workspace is used for

package/dist/docs/help/vscode/settings/_meta.json

@@ -0,0 +1 @@
+{ "title": "Settings", "order": 8 }

package/dist/docs/help/vscode/settings/advanced-mode.md

@@ -0,0 +1,53 @@
+---
+order: 4
+title: "Advanced Mode"
+description: "Unlocking hidden advanced commands and panels."
+---
+
+# Advanced Mode
+
+Advanced Mode reveals commands and panels that aren't shown by default. These are typically for debugging, advanced workflows, or features still being refined.
+
+## Turning It On
+
+1. Open VS Code Settings (`Cmd+,` / `Ctrl+,`)
+2. Search for `alucify.advanced`
+3. Check the box
+
+Or edit `settings.json`:
+```json
+{
+  "alucify.advanced": true
+}
+```
+
+Changes take effect immediately — no reload needed.
+
+## What Becomes Available
+
+Once enabled, the **Advanced** section appears in the Alucify Activity Bar view. It contains:
+
+- [Compare Versions](../versions/comparing-versions.md)
+- [Switch Version](../versions/switching-versions.md)
+- [Delete Version](../versions/deleting-versions.md)
+- [Reset Progress](../dev-progress/progress-panel-actions.md#reset-progress)
+- [Reset Analysis](../resetting-analysis.md)
+- [Reset Extension](../advanced/reset-extension.md)
+- Congruency / Coverage / Impact / Findings analyses (see [Advanced](../advanced/congruency-analysis.md))
+
+Additional command palette entries also appear (with **Alucify (Advanced):** prefix).
+
+## Why It's Gated
+
+Advanced features are either:
+- **Destructive** (reset commands) — should require intent to discover
+- **Low-usage** (separate per-dimension analyses) — would clutter the default UI
+- **In development** — we want feedback from power users before promoting them
+
+## Turning It Off
+
+Uncheck the setting. Hidden items disappear on next palette open or view refresh. Data produced while Advanced Mode was on is not affected.
+
+## Developer Mode (Separate)
+
+Advanced Mode is different from [Developer Mode](../advanced/developer-mode.md), which enables internal diagnostics used when debugging the extension itself.

package/dist/docs/help/vscode/settings/all-settings.md

@@ -0,0 +1,66 @@
+---
+order: 1
+title: "All Settings"
+description: "Comprehensive reference for every Alucify extension setting."
+---
+
+# All Settings
+
+All settings are accessible via VS Code Settings (`Cmd+,` / `Ctrl+,`) by searching for `alucify`.
+
+## Authentication
+
+| Setting | Default | Description |
+|---|---|---|
+| `alucify.authMode` | `claudeCode` | `"claudeCode"` or `"apiKey"`. See [Authentication Modes](../../concepts/authentication-modes.md). |
+
+The API key itself is stored in VS Code's secret storage (OS keychain), not in `settings.json`.
+
+## Notifications
+
+| Setting | Default | Description |
+|---|---|---|
+| `alucify.notifications.os` | `true` | Show OS-native notifications when workflows finish. See [Notification Preferences](notification-preferences.md). |
+
+## Analysis
+
+| Setting | Default | Description |
+|---|---|---|
+| `alucify.autoAnalyzeSpecs` | `false` | Automatically run spec analysis when a new artifact is added. See [Auto-Analyze Specs](auto-analyze-specs.md). |
+| `alucify.refineSpecs.mode` | `fast` | Analysis mode used during Refine Specs chat (speed/fast/full). |
+
+## Intent Capture
+
+| Setting | Default | Description |
+|---|---|---|
+| `alucify.intentCapture.enabled` | `false` | Poll Claude Code sessions and capture intent automatically. See [Enabling Intent Capture](../intent-capture/enabling-intent-capture.md). |
+| `alucify.intentCapture.pollIntervalSeconds` | `300` | How often to check for new sessions (seconds). |
+
+## Developer & Advanced
+
+| Setting | Default | Description |
+|---|---|---|
+| `alucify.advanced` | `false` | Reveal hidden advanced commands and panels. See [Advanced Mode](advanced-mode.md). |
+| `alucify.agentsInternalPath` | `""` | Override bundled agents location (developer-only; leave empty unless you're developing Alucify itself). |
+
+## Privacy
+
+| Setting | Default | Description |
+|---|---|---|
+| `alucify.telemetry` | `true` | Send anonymous usage telemetry. See [Telemetry](telemetry.md). |
+
+## Where Settings Live
+
+- **User settings** — apply to all VS Code workspaces for your user
+- **Workspace settings** — apply only to the current workspace (stored in `.vscode/settings.json`)
+- **Secrets** (API key, Auth0 tokens) — always in OS keychain, never in JSON
+
+## Global State (Not User-Editable)
+
+Some state is managed internally and not exposed as settings:
+- `welcomeDismissed` — whether you've dismissed the Welcome view
+- `authModeChosen` — whether you've picked an auth mode during onboarding
+- `mitigatedRisks` — which risks you've marked as resolved or ignored
+- `openPanels` — which detail panels are expanded in the current view
+
+You can reset these via [Reset Extension](../advanced/reset-extension.md).

package/dist/docs/help/vscode/settings/auto-analyze-specs.md

@@ -0,0 +1,43 @@
+---
+order: 5
+title: "Auto-Analyze Specs"
+description: "Automatically running spec analysis when you add a new artifact."
+---
+
+# Auto-Analyze Specs
+
+When enabled, adding a new spec artifact triggers spec analysis immediately — no manual click required.
+
+## Turning It On
+
+1. Open VS Code Settings (`Cmd+,` / `Ctrl+,`)
+2. Search for `alucify.autoAnalyzeSpecs`
+3. Check the box
+
+## What Triggers an Auto-Analysis
+
+- Adding one or more files via **Add Spec** in the Specs sidebar
+- Dragging files into the sidebar
+- Running `alucify add-spec` from the CLI while VS Code is open on the same workspace
+
+Not triggered by:
+- Files placed directly in `.alucify/artifacts/` without using the Add flow (considered manual; won't auto-process)
+- Changes to existing artifacts (edits run via the regular re-analysis flow)
+
+## Mode Used
+
+Auto-analyses run in the same mode as your last manual spec analysis. If you've never run spec analysis before, the default is **Fast (Balanced)**.
+
+## When Not to Use It
+
+- **On PDFs you haven't reviewed yet** — you may want to audit the spec first (see [Auditing Specs](../spec-analysis/auditing-specs.md)) before committing token spend to analysis
+- **When adding many files in a batch** — auto-analyzing each one separately is less efficient than batching; disable this, add all files, then manually click Analyze Specs
+
+## Token Cost
+
+Each auto-analysis consumes tokens. If you add many artifacts in succession, token usage adds up quickly. Check the [Token Usage Panel](../token-usage/viewing-token-usage.md) to monitor spend.
+
+## See Also
+
+- [Adding Specs](../spec-analysis/adding-specs.md)
+- [Analyzing Specs](../spec-analysis/analyzing-specs.md)

package/dist/docs/help/vscode/settings/notification-preferences.md

@@ -0,0 +1,38 @@
+---
+order: 2
+title: "Notification Preferences"
+description: "How to configure OS notifications for completed workflows."
+---
+
+# Notification Preferences
+
+Alucify can send native OS notifications when a workflow completes and VS Code is not in focus. This is useful when running long analyses in the background.
+
+## Configuring Notifications
+
+To enable or disable OS notifications:
+
+1. Open VS Code Settings (`Ctrl+,` / `Cmd+,`)
+2. Search for `alucify.notifications.os`
+3. Check or uncheck **Alucify: Notifications > OS**
+
+Or add this to your `settings.json`:
+
+```json
+{
+  "alucify.notifications.os": true
+}
+```
+
+## When Notifications Are Sent
+
+OS notifications are sent when:
+
+- A workflow (code analysis, spec analysis, or progress analysis) completes
+- VS Code is not the focused window
+
+If VS Code is in focus, you'll see the results directly in the sidebar without a separate notification.
+
+## Default Setting
+
+OS notifications are **enabled** by default.

package/dist/docs/help/vscode/settings/telemetry.md

@@ -0,0 +1,45 @@
+---
+order: 1
+title: "Telemetry & Privacy"
+description: "What anonymous usage data Alucify collects and how to opt out."
+---
+
+# Telemetry & Privacy
+
+Alucify collects anonymous usage telemetry to help improve the product. You can opt out at any time.
+
+## What's Collected
+
+Alucify tracks anonymous usage events such as:
+
+- Which commands are used (e.g., "Analyze Code was run")
+- Workflow state changes (e.g., "analysis started", "analysis completed")
+- General usage metrics
+
+Telemetry does **not** include:
+
+- Your source code
+- Your specification documents
+- File names or paths
+- API keys or credentials
+- Any personally identifiable information beyond your account ID
+
+## Opting Out
+
+To disable telemetry:
+
+1. Open VS Code Settings (`Ctrl+,` / `Cmd+,`)
+2. Search for `alucify.telemetry`
+3. Uncheck **Alucify: Telemetry**
+
+Or add this to your `settings.json`:
+
+```json
+{
+  "alucify.telemetry": false
+}
+```
+
+## Data Storage
+
+All analysis data (your project model, spec analysis, versions) is stored locally in the `.alucify/` directory within your project. This data is never sent to Alucify's servers — it stays on your machine and in your repository.

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

@@ -0,0 +1 @@
+{ "title": "Spec Analysis", "order": 5 }

package/dist/docs/help/vscode/spec-analysis/adding-specs.md

@@ -0,0 +1,40 @@
+---
+order: 1
+title: "Adding Specification Documents"
+description: "How to import PRDs, requirements docs, design files, and other specs into Alucify."
+---
+
+# Adding Specification Documents
+
+Specs are the documents that describe what your project should do — PRDs, requirements documents, design files, API specifications, and any other project documentation.
+
+## How to Add Specs
+
+1. In the Alucify sidebar, find the **Specifications** panel
+2. Click the **Add Spec** button (plus icon)
+3. A file picker opens — select one or more files
+4. The files are imported into your project's `.alucify/artifacts/` directory
+
+You can select multiple files at once to import them in batch.
+
+## Supported File Types
+
+Alucify supports a wide range of file formats:
+
+- **Documents:** PDF, Markdown (.md), plain text (.txt), ReStructuredText (.rst), AsciiDoc (.adoc)
+- **Data formats:** JSON, YAML, TOML, XML, CSV
+- **Images:** PNG, JPG, GIF, SVG, WebP
+- **Code files:** TypeScript, JavaScript, Python, Java, Go, Rust, Ruby, C/C++, C#, Swift, Kotlin
+
+## What Happens After Import
+
+After importing, your specs appear in the Specifications panel with a **Pending** status. They need to be analyzed before Alucify can compare them against your codebase.
+
+To analyze your specs, click **Analyze Specs** in the Project Analysis panel. See [Running Spec Analysis](analyzing-specs.md) for details.
+
+## Tips
+
+- **Import everything relevant** — PRDs, design docs, API contracts, wireframes, data models. The more context Alucify has, the better its analysis.
+- **Images work too** — Screenshots of wireframes and design mockups can be imported and analyzed.
+- **Large files are handled automatically** — Alucify chunks large documents for efficient processing.
+- **You can add more specs later** — Import additional specs at any time. When you run Analyze Specs again, Alucify will process only the new or changed files.

package/dist/docs/help/vscode/spec-analysis/analyzing-specs.md

@@ -0,0 +1,60 @@
+---
+order: 4
+title: "Running Spec Analysis"
+description: "How to run spec analysis to compare your specifications against your codebase."
+---
+
+# Running Spec Analysis
+
+Spec analysis compares your imported specifications against your codebase to find gaps, conflicts, and coverage issues.
+
+## Prerequisites
+
+Before running spec analysis:
+
+1. You've [run code analysis](../code-analysis/running-code-analysis.md) at least once
+2. You've [added specs](adding-specs.md) to the Specifications panel
+
+## How to Run Spec Analysis
+
+1. In the **Project Analysis** panel, switch to the **Spec Analysis** tab
+2. Click the **Analyze Specs** button
+3. Select an analysis mode:
+   - **Speed** — Fast mechanical projection (5–10 minutes, no AI cost)
+   - **Balanced** — AI-powered analysis (15–60 minutes)
+   - **Quality** — Comprehensive analysis (45–90 minutes)
+4. Wait for the analysis to complete
+
+A progress indicator shows the current phase.
+
+## What Happens During Analysis
+
+Spec analysis:
+
+1. Extracts requirements, features, and acceptance criteria from your spec documents
+2. Maps spec items to existing components in your codebase
+3. Identifies coverage gaps — requirements with no matching code
+4. Detects conflicts — contradictions between specs and code
+5. Measures congruency — how well specs and code align
+6. Generates AI coding risks based on the findings
+7. Saves a versioned snapshot
+
+## Incremental Analysis
+
+When you add new specs or update existing ones and re-run analysis:
+
+- **Unchanged specs are reused** — Only new or modified specs are re-analyzed
+- **You can choose to rebuild** — If you prefer a fresh analysis, you'll see the option to do a full rebuild
+
+This saves time and cost when iterating on your specs.
+
+## After Analysis
+
+Results appear in the [Specifications Panel](specifications-panel.md). You'll see congruency scores, coverage metrics, and any identified risks.
+
+## Using the Command Palette
+
+You can also start spec analysis from the Command Palette:
+
+1. Press `Ctrl+Shift+P` / `Cmd+Shift+P`
+2. Search for **Alucify: Analyze Specs**

package/dist/docs/help/vscode/spec-analysis/auditing-specs.md

@@ -0,0 +1,30 @@
+---
+order: 6
+title: "Auditing Imported Specs"
+description: "How to run an audit on your imported specifications to check for quality and completeness."
+---
+
+# Auditing Imported Specs
+
+The spec audit checks the quality of your imported specifications before or after a full analysis.
+
+## How to Audit Specs
+
+1. Open the Command Palette (`Ctrl+Shift+P` / `Cmd+Shift+P`)
+2. Search for **Alucify: Audit Specs**
+3. The audit runs against all imported specifications
+
+## What the Audit Checks
+
+The audit evaluates your specs for:
+
+- **Completeness** — Are all necessary details present? Are there missing sections or undefined requirements?
+- **Clarity** — Are requirements specific enough for an AI coding agent to implement?
+- **Consistency** — Do specs use consistent terminology? Are there contradictions between documents?
+- **Actionability** — Can each requirement be turned into a concrete implementation?
+
+## When to Audit
+
+- **After importing new specs** — Check that your documents are suitable for analysis before running full spec analysis
+- **After refining specs** — Verify that changes improved quality
+- **When AI readiness scores are low** — An audit can help identify which specs need improvement

package/dist/docs/help/vscode/spec-analysis/filtering-and-browsing-specs.md

@@ -0,0 +1,43 @@
+---
+order: 3
+title: "Filtering & Browsing the Specs Panel"
+description: "How to filter, browse, and manage your imported specifications."
+---
+
+# Filtering & Browsing the Specs Panel
+
+The **Specifications** panel in the Alucify sidebar shows all your imported spec documents and their analysis status.
+
+## Spec Lifecycle
+
+Each spec goes through a lifecycle shown at the top of the panel:
+
+1. **Pending** — The spec has been imported but not yet analyzed
+2. **Analyzed** — The spec has been fully analyzed and integrated
+
+Click on any status label to filter the list to specs in that state. The count next to each status shows how many specs are in that phase.
+
+## Filtering Specs
+
+### Using the Filter Button
+
+1. Click the **Filter** icon (funnel) in the Specifications panel header
+2. Choose a filter:
+   - **Show All** — Display all specs regardless of status
+   - **Pending** — Only show specs awaiting analysis
+   - **Analyzed** — Only show fully analyzed specs
+
+### Clearing Filters
+
+When a filter is active, the filter icon changes to indicate filtering is on. Click **Clear Filter** (filled funnel icon) to remove the filter and show all specs.
+
+## Refreshing the List
+
+Click the **Refresh** icon in the panel header to update the specs list. This is useful if you've added files to the `.alucify/artifacts/` directory outside of VS Code.
+
+## Spec Actions
+
+From the panel, you can:
+
+- **Add Spec** — Import new specification documents
+- **Generate Spec** — Create specs using AI (requires Claude Code CLI)

package/dist/docs/help/vscode/spec-analysis/generating-specs.md

@@ -0,0 +1,47 @@
+---
+order: 2
+title: "Generating Specs with AI"
+description: "How to use AI to generate specification documents from your codebase."
+---
+
+# Generating Specs with AI
+
+If you don't have existing specification documents, Alucify can help you generate them using AI.
+
+## Prerequisites
+
+- **Claude Code CLI** must be installed and authenticated on your machine
+- The Generate Spec button only appears when the CLI is detected
+
+## How to Generate a Spec
+
+1. In the **Specifications** panel, click the **Generate Spec** button (wand icon)
+2. Choose an artifact type from the picker:
+   - **Product Requirements Document** — Goals, personas, and functional requirements
+   - **Architecture Document** — Tech stack, system design, and architecture decisions
+   - **UX Specification** — User flows, screen designs, and interaction patterns
+   - **Epics & Stories** — Break down requirements into implementable work items
+   - **Quick Spec** — Lightweight technical spec for a focused task
+   - **Custom** — Describe any artifact you need
+3. An interactive chat session opens in the sidebar
+4. The AI uses your project context (if available) to draft the spec, and asks clarifying questions for anything it can't infer
+
+The generated spec is saved to `.alucify/artifacts/` and automatically picked up by Alucify for analysis.
+
+## Project Context
+
+If you've run a baseline or artifact analysis, the AI will use your project's architecture, data models, requirements, and coverage gaps to pre-populate the spec. This means you don't have to re-describe what already exists — the AI starts from what it knows and asks only about what's missing.
+
+For greenfield projects with no analysis, the AI guides you through each section step by step.
+
+## When to Use This
+
+- You have an existing codebase but no formal requirements documentation
+- You want to create API specifications from existing endpoints
+- You need to document existing business logic for AI coding agents
+- You're starting a new feature and want a structured spec template
+
+## Notes
+
+- The generated spec is a starting point — review and refine it before running spec analysis
+- You can also [add specs manually](adding-specs.md) if you prefer to write them yourself

package/dist/docs/help/vscode/spec-analysis/refining-specs.md

@@ -0,0 +1,53 @@
+---
+order: 7
+title: "Refining Specs with Chat"
+description: "How to use the interactive chat to refine and improve your specifications."
+---
+
+# Refining Specs with Chat
+
+After analyzing your specs and reviewing the identified risks, you can work with Claude interactively to resolve issues and improve your specifications.
+
+## Starting a Refinement Session
+
+### From the AI Coding Risks Panel
+
+1. Open the [AI Coding Risks](../code-analysis/ai-coding-risks-panel.md) panel
+2. Select one or more risks using the checkboxes
+3. Click the **Refine Specs** button (shows "Refine Specs (N selected)" with your selection count)
+4. A chat panel opens in the secondary sidebar
+
+### From the Command Palette
+
+1. Press `Ctrl+Shift+P` / `Cmd+Shift+P`
+2. Search for **Alucify: Refine Specs**
+
+## Using the Chat
+
+The chat panel opens with context about your selected risks. You can:
+
+- **Discuss the risks** — Ask Claude about the issues and get suggestions
+- **Review proposed changes** — Claude will suggest spec updates to resolve each risk
+- **Guide the resolution** — Tell Claude how you want to address each issue
+- **Type `/done`** to end the session
+- **Type `/help`** to see available commands
+
+As Claude resolves risks, their status updates from Open to Fixed in the AI Coding Risks panel.
+
+## Chat Mode vs. Terminal Mode
+
+Alucify supports two modes for spec refinement, configurable in settings:
+
+### Chat Mode (Default)
+An embedded chat panel in the VS Code secondary sidebar. You interact with Claude through a conversation interface, seeing messages, tool usage, and spec updates in real time.
+
+### Terminal Mode
+Uses the Claude Code CLI in a VS Code terminal. Progress is shown in the terminal output. This mode is useful if you prefer a CLI-based workflow.
+
+To switch modes, go to VS Code Settings and search for `alucify.refineSpecs.mode`.
+
+## Tips
+
+- **Select related risks together** — Resolving related risks in a single session is more efficient than addressing them one at a time
+- **Be specific** — Tell Claude how you want to resolve ambiguous issues rather than accepting all defaults
+- **Review changes** — After a session, re-run spec analysis to verify that the refinements improved your scores

package/dist/docs/help/vscode/spec-analysis/specifications-panel.md

@@ -0,0 +1,46 @@
+---
+order: 1
+title: "Specifications Panel"
+description: "A walkthrough of the Spec Analysis tab in VS Code — layout and how each section works."
+---
+
+# Specifications Panel
+
+The Spec Analysis tab is the second of three tabs in the Project Analysis panel. It shows how well your specifications align with your codebase.
+
+For what these metrics measure, see [Congruency, Coverage & Completeness](../../concepts/congruency-coverage-completeness.md).
+
+## Key Metrics
+
+At the top of the tab, you'll see several scores (0–100%):
+
+- **Congruency** — How well your specs align with your code
+- **Coverage** — How much of your codebase is covered by specifications
+- **Blast Radius** — The percentage of your project that could be affected by a change (lower is better). See [Blast Radius](../../concepts/blast-radius.md).
+- **AI Readiness** — A composite score. See [AI Readiness](../../concepts/ai-readiness.md).
+
+Each score includes a sparkline showing the trend across analysis versions.
+
+## Sections
+
+### Congruency
+Heatmap showing how well each specification aligns with the codebase. Each row represents one of your imported specs. Click **View Details** for the full congruency report for a specific spec.
+
+### Coverage
+Horizontal bars showing what percentage of each component type is grounded in specifications. Higher bars mean better spec coverage.
+
+### Completeness
+A visual indicator of how complete your specification coverage is across different dimensions.
+
+### Impact
+Pie chart showing how your project is distributed across impact categories (New / Modified / Affected / Intact). See [Congruency, Coverage & Completeness → Impact Categories](../../concepts/congruency-coverage-completeness.md#impact-categories).
+
+### AI Coding Risks
+A summary of identified risks with severity counts. Click **View Details** to open the full [AI Coding Risks Panel](../code-analysis/ai-coding-risks-panel.md).
+
+### Recommendations
+The top priority actions to improve your AI readiness score, ordered by impact. Click **View Details** to see the full list.
+
+## Empty State
+
+If you haven't added or analyzed specs yet, the tab shows: "Please add specs and analyze them to update this tab." with links to add specs and run analysis.

package/dist/docs/help/vscode/status-bar.md

@@ -0,0 +1,44 @@
+---
+order: 12
+title: "Status Bar"
+description: "The Alucify status bar item at the bottom of VS Code."
+---
+
+# Status Bar
+
+Alucify adds a single status bar item at the bottom-left of VS Code. It's a compact at-a-glance indicator of project state.
+
+## What It Shows
+
+### Idle State
+Displays a short summary: `Alucify • AI Readiness 72%` or `Alucify • No analysis yet`. Hover for more detail (open risk count, last analysis date).
+
+### Active Workflow
+Shows a spinner and the current phase: `Alucify • Analyzing Specs (Phase 3/7)`. Hover for a progress bar and ETA estimate.
+
+### Paused
+Shows a pause icon: `Alucify ⏸ Paused`. Click to resume or cancel.
+
+### Error State
+Shows an error indicator: `Alucify ⚠ Error`. Click to view the error in the Workflow Status view.
+
+## Clicking It
+
+A single click toggles the Workflow Status view in the sidebar — your quick path to controls when a workflow is running.
+
+## Hiding the Status Bar Item
+
+If you prefer not to see it:
+1. Right-click the VS Code status bar
+2. Uncheck **Alucify**
+
+This hides the item but doesn't affect functionality — workflows still run, notifications still fire.
+
+## Re-Showing It
+
+Same path: right-click the status bar and check **Alucify** again.
+
+## Related
+
+- [Workflow Controls](workflow-controls.md)
+- [Notification Preferences](settings/notification-preferences.md)

package/dist/docs/help/vscode/token-usage/_meta.json

@@ -0,0 +1 @@
+{ "title": "Token Usage", "order": 7 }