aircana 3.0.0.rc7 → 3.0.0

data/README.md

@@ -5,21 +5,9 @@
 
 ## Intro
 
-Aircana is a "batteries-included" CLI for creating and managing Claude Code plugins. It provides:
+Aircana is a CLI for generating [Claude Code plugins](https://docs.claude.com/en/docs/claude-code/plugins) with per-agent knowledge bases. Each agent gets a curated knowledge base synced from Confluence (label-based) or web URLs, yielding more relevant, predictable, and project-specific results than general-purpose agents.
 
-**Plugin Development**: Create distributable Claude Code plugins with proper manifests and structure.
-
-**Knowledge Base Management**: Agent-accessible knowledge bases sourced from Confluence or public websites, with automatic syncing and caching.
-
-**Specialized Agents**: Generate domain-specific agents with dedicated knowledge bases for improved context management.
-
-**Complete Development Workflow**: Five-phase workflow (plan, record, execute, review, apply-feedback) for systematic feature development.
-
-**Hook Management**: Event-driven automation through Claude Code hooks with support for multiple hook types.
-
-**Plugin Distribution**: Create plugins that can be shared via Claude Code plugin marketplaces.
-
-While Aircana includes features beneficial in many agentic contexts (like knowledge base syncing), its primary tools are built on "human-in-the-loop" principles.
+Knowledge bases automatically refresh once daily on session start, keeping agents up-to-date without manual intervention. Knowledge sources are tracked in version-controlled manifests, so team members can independently refresh content while keeping actual documentation out of git.
 
 ## How can I try it?
 
@@ -97,6 +85,8 @@ aircana plugin validate
 
 ### Things to try
 
+- Follow the [Getting Started](#getting-started) tutorial to create agents with knowledge bases—Aircana's key differentiator
+
 - Configure the Confluence integration and create domain-specific agents
 
 - Use the `/ask-expert` command to consult multiple specialized agents
@@ -105,108 +95,152 @@ aircana plugin validate
 
 - Explore other tools by running `aircana --help`
 
-## Development Workflow
+## Getting Started
 
-Aircana provides a complete development lifecycle through five integrated slash commands:
+This tutorial walks through creating a complete Claude Code plugin with agents backed by Confluence knowledge bases, then publishing it to a marketplace for team distribution.
 
-```mermaid
-stateDiagram-v2
-    [*] --> Plan: /plan
-    Plan --> Record: /record
-    Record --> Execute: /execute
-    Execute --> Review: /review
-    Review --> ApplyFeedback: /apply-feedback
-    ApplyFeedback --> Review: More issues found
-    ApplyFeedback --> [*]: Satisfied
+### Prerequisites
+
+1. **Install Aircana:**
+```bash
+gem install aircana
+aircana doctor  # Verify dependencies
 ```
 
-### Quick Overview
+2. **Configure Confluence (optional but recommended):**
 
-1. **`/plan`** - Create strategic implementation plan
-2. **`/record`** - Save plan to Jira ticket
-3. **`/execute`** - Implement plan and create commit
-4. **`/review`** - Adversarial code review with expert feedback
-5. **`/apply-feedback`** - Apply review changes and amend commit
+Add to your shell profile (`.bashrc`, `.zshrc`, etc.):
+```bash
+export CONFLUENCE_BASE_URL="https://your-company.atlassian.net"
+export CONFLUENCE_USERNAME="your.email@company.com"
+export CONFLUENCE_API_TOKEN="your-generated-token"
+```
 
-### Command Details
+To generate a Confluence API token:
+1. Go to your Confluence instance
+2. Click profile picture → **Account Settings** → **Security**
+3. Select **Create and manage API tokens** → **Create API token**
+4. Copy the token and add to your environment variables
 
-#### 1. `/plan` - Strategic Planning
+Reload your shell: `source ~/.zshrc` (or your shell config file)
 
-Creates a high-level implementation plan by:
-- Asking you to specify relevant files and directories
-- Consulting specialized sub-agents for domain expertise
-- Sharing research context to avoid duplicate work
-- Generating a focused strategic plan (what to do, not how)
-- Creating actionable todo checklist
+### Step 1: Create Your Plugin
 
-The planner focuses on architecture decisions and approach, avoiding exhaustive code implementations.
+```bash
+# Create a new directory for your plugin
+mkdir my-team-plugin
+cd my-team-plugin
 
-#### 2. `/record` - Save to Jira
+# Initialize the plugin
+aircana init --plugin-name my-team
 
-Records your approved plan to a Jira ticket by:
-- Taking the ticket key/ID as input
-- Delegating to the `jira` sub-agent for MCP operations
-- Storing the plan in the ticket description or comments
+# Verify the structure was created
+ls -la
+```
 
-This creates a traceable link between planning and execution.
+This creates:
+- `.claude-plugin/plugin.json` - Plugin manifest with metadata
+- `agents/` - Directory for specialized agents
+- `commands/` - Custom slash commands
+- `hooks/hooks.json` - Hook configurations
+- `scripts/` - Hook scripts and utilities
 
-#### 3. `/execute` - Implementation
+### Step 2: Create an Agent Backed by Confluence
 
-Executes the strategic plan by:
-- Reading the plan from the Jira ticket
-- Creating detailed implementation todo list
-- Presenting plan for your approval
-- Implementing changes sequentially
-- Writing unit tests (delegates to test-writing sub-agent if available)
-- Running tests to verify implementation
-- Creating git commit (delegates to git-ops sub-agent if available)
+```bash
+aircana agents create
+```
 
-After commit creation, suggests running `/review`.
+You'll be prompted for:
+- **Agent name**: e.g., "backend-api" (use kebab-case)
+- **Description**: e.g., "Expert in backend API development and best practices"
+- **Model**: Choose sonnet (smarter), haiku (faster), or inherit (uses default)
+- **Color**: Pick an interface color for visual identification
 
-#### 4. `/review` - Adversarial Review
+The agent file is created at `agents/backend-api.md` with:
+- Agent configuration (name, description, model)
+- Knowledge base path reference
+- Custom instructions
 
-Conducts comprehensive code review of HEAD commit by:
-- Analyzing changed files to identify technical domains
-- Using sub-agent-coordinator to select relevant expert agents
-- Presenting changes to experts in parallel
-- Synthesizing feedback organized by severity (Critical/Important/Suggestions)
-- Storing review output for next step
+### Step 3: Tag Confluence Pages
 
-Explicitly states "Reviewing: <commit message>" and ends with "Run /apply-feedback".
+In Confluence, label pages you want the agent to access:
 
-#### 5. `/apply-feedback` - Apply Changes
+1. Open a relevant Confluence page (e.g., "API Design Guidelines")
+2. Click **...** → **Edit labels**
+3. Add label: `backend-api` (must match your agent name)
+4. Click **Save**
 
-Applies code review feedback by:
-- Reading review output from conversation context
-- Creating prioritized change plan (critical issues first)
-- Presenting plan for your approval
-- Applying approved changes
-- Re-running unit tests
-- Fixing any test failures
-- **Amending HEAD commit** with improvements using `git commit --amend --no-edit`
+Repeat for all documentation pages relevant to this agent. Aircana will discover pages by label during the refresh process.
 
-This preserves the original commit message while incorporating review improvements in a single commit.
+**Tip:** Use a consistent labeling strategy. For example, label all backend documentation with `backend-api`, all frontend docs with `frontend-expert`, etc.
 
-### Usage Example
+### Step 4: Refresh Agent Knowledge
 
 ```bash
-# 1. Start planning
-/plan
-> Specify relevant files: src/api/, spec/api/
+aircana agents refresh backend-api
+```
 
-# 2. Save plan to ticket
-/record PROJ-123
+This will:
+1. Search Confluence for pages labeled `backend-api`
+2. Download page content via Confluence REST API
+3. Convert HTML to Markdown using ReverseMarkdown
+4. Store content in the knowledge base directory
+5. Update `agents/backend-api/manifest.json` with source metadata
 
-# 3. Execute implementation
-/execute PROJ-123
+**Output:** Knowledge files are created in `~/.claude/agents/my-team-backend-api/knowledge/`
 
-# 4. Review the commit
-/review
+**Note:** The actual knowledge content is stored globally (not in your plugin directory) to avoid version control bloat and potential sensitive information leaks. Only the manifest (source tracking) is version controlled.
 
-# 5. Apply feedback
-/apply-feedback
+### Step 5: Add Web URLs (Optional)
+
+You can also add public web documentation to your agent's knowledge base:
+
+```bash
+aircana agents add-url backend-api https://docs.example.com/api-guide
+aircana agents add-url backend-api https://restfulapi.net/rest-architectural-constraints/
 ```
 
+This downloads the web page, extracts main content (removes nav/ads/scripts), converts to Markdown, and adds it to the knowledge base.
+
+Refresh to sync web URLs:
+```bash
+aircana agents refresh backend-api
+```
+
+### Step 6: Use Your Agent
+
+Your agent is now ready! Claude Code will automatically consult your agent when appropriate based on the agent's description. You can also explicitly request the agent:
+
+```
+Ask backend-api to review this API endpoint design
+Ask backend-api how to implement authentication
+```
+
+The agent has access to all Confluence pages and web URLs you've synced to its knowledge base.
+
+### Step 7: Share Your Plugin with Your Team
+
+For detailed instructions on distributing your plugin via Git repositories or Claude Code plugin marketplaces, see the official [Claude Code Plugin Marketplaces documentation](https://docs.claude.com/en/docs/claude-code/plugin-marketplaces).
+
+**Quick summary:**
+- Share via Git repository: Team members clone the plugin, configure Confluence credentials, and run `aircana agents refresh-all`
+- Publish to a marketplace: Create a marketplace.json file in a separate repository, add your plugin metadata, and team members install via the marketplace UI
+
+### Next: Keep Knowledge Up-to-Date
+
+As your Confluence documentation evolves:
+
+```bash
+# Refresh a specific agent's knowledge
+aircana agents refresh backend-api
+
+# Or refresh all agents at once
+aircana agents refresh-all
+```
+
+Knowledge sources are tracked in `agents/<agent-name>/manifest.json`, so team members can independently refresh without manual coordination.
+
 ## Key Concepts
 
 ### Plugins
@@ -266,7 +300,7 @@ Aircana provides each agent with a human-curated knowledge base stored within th
 - Stay up-to-date with refreshable sources
 - Provide more relevant responses with less back-and-forth
 
-Knowledge bases support multiple source types and can be refreshed to pull the latest content.
+Knowledge bases support multiple source types and can be refreshed to pull the latest content. **Aircana-generated plugins automatically refresh all agent knowledge bases once daily on session start** via the SessionStart hook, keeping agents up-to-date without manual intervention.
 
 #### Confluence
 
@@ -334,6 +368,137 @@ At Instructure this means you can easily configure Claude Code to send you slack
 
 (Instructions coming soon, send a message if you want help with this)
 
+## Best Practices
+
+### Designing Effective Agents
+
+**Design agents as narrow domain experts, not generalists.** More granular agents with focused knowledge bases generally perform better than broad, general-purpose agents.
+
+**Examples:**
+
+✅ **Good - Narrow domains:**
+- `database-schema-expert` - Database design, migrations, indexing strategies
+- `api-authentication-expert` - OAuth, JWT, session management
+- `frontend-styling-expert` - CSS, design systems, responsive layouts
+
+❌ **Avoid - Too broad:**
+- `backend-engineer` - Too many domains, knowledge base becomes unfocused
+- `full-stack-developer` - Overlapping responsibilities with unclear boundaries
+
+**Why narrow domains work better:**
+- **Focused knowledge bases**: Each agent gets highly relevant documentation for their specific domain
+- **Better results**: Agents can provide more accurate, detailed answers within their expertise
+- **Less context pollution**: Smaller, focused context windows prevent information overload
+- **Non-overlapping responsibilities**: Clear delegation boundaries reduce confusion
+
+**Tips:**
+- Break large domains into smaller, specialized areas
+- Each agent should have a clear, distinct purpose
+- Knowledge bases should contain 5-20 highly relevant documents, not 100+ loosely related ones
+- Use agent descriptions to clearly define boundaries and expertise areas
+
+## Development Workflow
+
+Aircana provides a complete development lifecycle through five integrated slash commands:
+
+```mermaid
+stateDiagram-v2
+    [*] --> Plan: /plan
+    Plan --> Record: /record
+    Record --> Execute: /execute
+    Execute --> Review: /review
+    Review --> ApplyFeedback: /apply-feedback
+    ApplyFeedback --> Review: More issues found
+    ApplyFeedback --> [*]: Satisfied
+```
+
+### Quick Overview
+
+1. **`/plan`** - Create strategic implementation plan
+2. **`/record`** - Save plan to Jira ticket
+3. **`/execute`** - Implement plan and create commit
+4. **`/review`** - Adversarial code review with expert feedback
+5. **`/apply-feedback`** - Apply review changes and amend commit
+
+### Command Details
+
+#### 1. `/plan` - Strategic Planning
+
+Creates a high-level implementation plan by:
+- Asking you to specify relevant files and directories
+- Consulting specialized sub-agents for domain expertise
+- Sharing research context to avoid duplicate work
+- Generating a focused strategic plan (what to do, not how)
+- Creating actionable todo checklist
+
+The planner focuses on architecture decisions and approach, avoiding exhaustive code implementations.
+
+#### 2. `/record` - Save to Jira
+
+Records your approved plan to a Jira ticket by:
+- Taking the ticket key/ID as input
+- Delegating to the `jira` sub-agent for MCP operations
+- Storing the plan in the ticket description or comments
+
+This creates a traceable link between planning and execution.
+
+#### 3. `/execute` - Implementation
+
+Executes the strategic plan by:
+- Reading the plan from the Jira ticket
+- Creating detailed implementation todo list
+- Presenting plan for your approval
+- Implementing changes sequentially
+- Writing unit tests (delegates to test-writing sub-agent if available)
+- Running tests to verify implementation
+- Creating git commit (delegates to git-ops sub-agent if available)
+
+After commit creation, suggests running `/review`.
+
+#### 4. `/review` - Adversarial Review
+
+Conducts comprehensive code review of HEAD commit by:
+- Analyzing changed files to identify technical domains
+- Using sub-agent-coordinator to select relevant expert agents
+- Presenting changes to experts in parallel
+- Synthesizing feedback organized by severity (Critical/Important/Suggestions)
+- Storing review output for next step
+
+Explicitly states "Reviewing: <commit message>" and ends with "Run /apply-feedback".
+
+#### 5. `/apply-feedback` - Apply Changes
+
+Applies code review feedback by:
+- Reading review output from conversation context
+- Creating prioritized change plan (critical issues first)
+- Presenting plan for your approval
+- Applying approved changes
+- Re-running unit tests
+- Fixing any test failures
+- **Amending HEAD commit** with improvements using `git commit --amend --no-edit`
+
+This preserves the original commit message while incorporating review improvements in a single commit.
+
+### Usage Example
+
+```bash
+# 1. Start planning
+/plan
+> Specify relevant files: src/api/, spec/api/
+
+# 2. Save plan to ticket
+/record PROJ-123
+
+# 3. Execute implementation
+/execute PROJ-123
+
+# 4. Review the commit
+/review
+
+# 5. Apply feedback
+/apply-feedback
+```
+
 ## Configuration (Optional)
 
 ### Confluence Setup (Optional)
@@ -408,73 +573,6 @@ aircana doctor
 
 This will check if Confluence and other integrations are properly configured.
 
-## Agent Workflow Tutorial
-
-Here's a complete example of creating an agent and syncing knowledge from Confluence:
-
-### 1. Create an Agent
-
-```bash
-aircana agents create
-```
-
-You'll be prompted for:
-- **Agent name**: e.g., "backend-api"
-- **Description**: e.g., "Helps with backend API development"
-- **Model**: Choose from sonnet, haiku, or inherit
-- **Color**: Choose interface color
-
-### 2. Tag Confluence Pages
-
-In Confluence, add the label `backend-api` (matching your agent name) to relevant pages:
-
-1. Open a Confluence page with relevant documentation
-2. Click **...** → **Edit labels**
-3. Add label: `backend-api`
-4. Save
-
-Repeat for all pages you want the agent to know about.
-
-### 3. Add Knowledge Sources
-
-**From Confluence:**
-```bash
-aircana agents refresh backend-api
-```
-
-This downloads all Confluence pages labeled `backend-api` and makes them available to your agent.
-
-**From Web URLs:**
-```bash
-aircana agents add-url backend-api https://docs.example.com/api-guide
-aircana agents add-url backend-api https://blog.example.com/best-practices
-```
-
-This fetches web content and converts it to Markdown for your agent's knowledge base.
-
-### 4. Use the Agent
-
-Once created with a good description, Claude Code will automatically use your agent when appropriate during conversations. You can also explicitly request a specific agent:
-
-```
-Ask backend-api for a code review of this function
-Ask backend-api to help debug this API endpoint
-Ask rspec-test-writer to write and run tests for @file
-```
-
-The agent will have access to all the Confluence knowledge you synced.
-
-### 5. Update Knowledge
-
-Whenever you update Confluence pages, add new ones with the agent label, or want to refresh web content:
-
-```bash
-aircana agents refresh backend-api
-```
-
-This refreshes both Confluence pages and web URLs associated with the agent.
-
-
 ## All Commands
 
 ### Plugin Management

data/agents/apply_feedback.md

@@ -30,7 +30,7 @@ Work through each task in the todo list sequentially:
 TASK DETAILS:
 
 1. PARSE FEEDBACK: Extract review feedback from conversation:
-   - Look for review output from previous /air-review command
+   - Look for review output from previous /review command
    - Parse feedback organized by severity (Critical / Important / Suggestions)
    - Extract actionable items with file, line, issue, and recommendation
    - If no review feedback found in context, inform user and exit

data/agents/executor.md

@@ -72,7 +72,7 @@ TASK DETAILS:
    - Provide context: Jira ticket key, summary of changes, files modified
    - If no git-ops agent exists, create commit directly using Bash tool
    - Commit message should reference Jira ticket and describe implementation
-   - After successful commit, suggest user runs '/air-review' command to review changes
+   - After successful commit, suggest user runs '/review' command to review changes
 
 IMPORTANT INSTRUCTIONS:
 - ALWAYS start by creating the todo list file before doing any other work

data/agents/planner.md

@@ -14,7 +14,7 @@ MANDATORY WORKFLOW (Use TodoWrite to track):
 3. Perform targeted research on user-specified files
 4. Create implementation plan in current session
 5. Iterate with user feedback
-6. Suggest '/air-record' command to save plan to Jira
+6. Suggest '/record' command to save plan to Jira
 
 TASK DETAILS:
 

data/agents/reviewer.md

@@ -20,7 +20,7 @@ First, create a todo list file with the following tasks enumerated in order:
 6. Present changes to each expert agent in parallel for review
 7. Synthesize feedback organized by severity
 8. Present comprehensive review report
-9. Suggest running '/air-apply-feedback' command
+9. Suggest running '/apply-feedback' command
 
 STEP 2: EXECUTE EACH TASK IN ORDER
 Work through each task in the todo list sequentially:
@@ -79,7 +79,7 @@ TASK DETAILS:
    - Store this output in conversation context for apply-feedback agent
 
 9. NEXT STEPS: End with clear instruction:
-   - Output: "Run /air-apply-feedback to apply recommended changes"
+   - Output: "Run /apply-feedback to apply recommended changes"
    - This guides user to next step in workflow
 
 IMPORTANT INSTRUCTIONS:

data/lib/aircana/cli/app.rb

@@ -29,7 +29,7 @@ module Aircana
       end
 
       desc "dump-context",
-           "dumps relevant files, knowledge, memories, and decisions for the specified agent"
+           "dumps knowledge, memories, and decisions for the specified agent"
       option :verbose, type: :boolean, default: true
       def dump_context(agent_name)
         DumpContext.run(agent_name: agent_name, verbose: options[:verbose])

data/lib/aircana/cli/commands/generate.rb

@@ -25,6 +25,7 @@ module Aircana
         end
 
         def run
+          clean_output_directories
           generators.each(&:generate)
           generate_default_agents
           generate_default_hooks
@@ -33,6 +34,16 @@ module Aircana
 
         private
 
+        def clean_output_directories
+          # Remove stale command files to prevent duplicates during init
+          commands_dir = File.join(Aircana.configuration.output_dir, "commands")
+          FileUtils.rm_rf(Dir.glob("#{commands_dir}/*")) if Dir.exist?(commands_dir)
+
+          # Remove stale agent files for consistency
+          agents_dir = File.join(Aircana.configuration.output_dir, "agents")
+          FileUtils.rm_rf(Dir.glob("#{agents_dir}/*")) if Dir.exist?(agents_dir)
+        end
+
         def generate_default_agents
           Aircana::Generators::AgentsGenerator.available_default_agents.each do |agent_name|
             Aircana::Generators::AgentsGenerator.create_default_agent(agent_name)

data/lib/aircana/configuration.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
+require "json"
+
 module Aircana
   class Configuration
     attr_accessor :global_dir, :project_dir, :stream, :output_dir,
                   :claude_code_config_path, :claude_code_project_config_path, :agent_knowledge_dir,
                   :hooks_dir, :scripts_dir, :confluence_base_url, :confluence_username, :confluence_api_token,
-                  :plugin_root, :plugin_manifest_dir, :commands_dir, :agents_dir
+                  :plugin_root, :plugin_manifest_dir, :commands_dir, :agents_dir, :global_agents_dir
 
     def initialize
       setup_directory_paths
@@ -30,6 +32,28 @@ module Aircana
       File.join(@hooks_dir, "hooks.json")
     end
 
+    # Returns the plugin name from plugin.json, or falls back to directory name
+    def plugin_name
+      return @plugin_name if defined?(@plugin_name)
+
+      @plugin_name = if plugin_mode?
+                       manifest = JSON.parse(File.read(plugin_manifest_path))
+                       manifest["name"]
+                     else
+                       # Fallback to directory name if not in plugin mode
+                       File.basename(@plugin_root).downcase.gsub(/[^a-z0-9]+/, "-")
+                     end
+    rescue StandardError
+      # If anything fails, use directory name as fallback
+      File.basename(@plugin_root).downcase.gsub(/[^a-z0-9]+/, "-")
+    end
+
+    # Returns the global knowledge directory path for an agent
+    # Format: ~/.claude/agents/<plugin-name>-<agent-name>/knowledge/
+    def global_agent_knowledge_path(agent_name)
+      File.join(@global_agents_dir, "#{plugin_name}-#{agent_name}", "knowledge")
+    end
+
     private
 
     def setup_directory_paths
@@ -54,6 +78,8 @@ module Aircana
       @claude_code_config_path = File.join(Dir.home, ".claude")
       # For backward compatibility, keep this but plugin mode uses plugin_root
       @claude_code_project_config_path = File.join(Dir.pwd, ".claude")
+      # Global agents directory for knowledge bases (not version controlled)
+      @global_agents_dir = File.join(Dir.home, ".claude", "agents")
     end
 
     def setup_stream

data/lib/aircana/contexts/local.rb

@@ -20,7 +20,8 @@ module Aircana
 
       def create_agent_knowledge_dir(agent)
         config = Aircana.configuration
-        agent_dir = File.join(config.agent_knowledge_dir, agent, "knowledge")
+        # Use global agents directory with plugin prefix
+        agent_dir = config.global_agent_knowledge_path(agent)
 
         FileUtils.mkdir_p(agent_dir)
 

data/lib/aircana/generators/agents_generator.rb

@@ -45,7 +45,7 @@ module Aircana
       def locals
         super.merge({
                       agent_name:, short_description:, description:,
-                      model:, color:, knowledge_path:
+                      model:, color:, knowledge_path:, plugin_prefix:
                     })
       end
 
@@ -63,9 +63,13 @@ module Aircana
         File.join(Aircana.configuration.agents_dir, "#{agent_name}.md")
       end
 
+      def plugin_prefix
+        Aircana.configuration.plugin_name
+      end
+
       def knowledge_path
-        # Use plugin-relative path for knowledge base
-        "agents/#{agent_name}/knowledge/"
+        # Use global agents directory with plugin prefix
+        "~/.claude/agents/#{plugin_prefix}-#{agent_name}/knowledge/"
       end
     end
   end

data/lib/aircana/templates/agents/base_agent.erb

@@ -5,7 +5,7 @@ model: <%=  model %>
 color: <%=  color %>
 ---
 
-<%=  helpers.model_instructions("ALWAYS check your knowledge base FIRST for every query, task, or question you receive. Use `ls ${CLAUDE_PLUGIN_ROOT}/agents/#{agent_name}/knowledge/*.md` to list files from your knowledge base.
+<%=  helpers.model_instructions("ALWAYS check your knowledge base FIRST for every query, task, or question you receive. Use `ls #{knowledge_path}*.md` to list files from your knowledge base.
 
 MANDATORY WORKFLOW:
 1. BEFORE responding to ANY request - search and read relevant files in your knowledge base
@@ -18,7 +18,7 @@ Your knowledge base contains domain-specific information that takes priority ove
 
 ## Knowledge Base Integration
 
-Your specialized knowledge is in the plugin directory. Use `ls ${CLAUDE_PLUGIN_ROOT}/agents/<%=  agent_name %>/knowledge/*.md` to list available files, then read them with the Read tool.
+Your specialized knowledge is in the global agents directory. Use `ls <%= knowledge_path %>*.md` to list available files, then read them with the Read tool.
 
 This knowledge base contains:
 - Domain-specific documentation from Confluence