agent-watch 1.0.0 → 1.1.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 1.1.0
+
+### Minor Changes
+
+- Enhance session extraction architecture with tool-specific extractors for Claude Code, Copilot Chat, and Copilot CLI. Refactor session handling code for better maintainability and add comprehensive documentation.
+
+## 1.0.1
+
+### Patch Changes
+
+- Add debug mode with --debug flag for troubleshooting, improve documentation, and remove obsolete workflows
+
 All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),

package/README.md

@@ -1,95 +1,382 @@
 # Agent Watch
 
-CLI tool that uses git hooks to keep your AI agent configuration files in sync with your codebase. It watches for commits or pushes, gathers context from git changes and chat sessions, and automatically updates your agent files.
+**Keep your AI agents in sync with your evolving codebase—automatically.**
 
-## Install
+Agent Watch is a CLI tool that captures knowledge from your development workflow—git commits, code changes, and AI chat sessions—and intelligently updates your AI agent configuration files. Stop manually copying patterns from chat sessions. Stop forgetting to update CLAUDE.md or Copilot instructions. Let agent-watch learn from your work and keep your AI agents informed.
 
+## Why Agent Watch?
+
+### The Problem
+You're having productive conversations with Claude Code, GitHub Copilot, and other AI assistants. They help you establish patterns, conventions, and best practices. But this knowledge stays trapped in chat history. Your agent configuration files (CLAUDE.md, copilot-instructions.md, etc.) become outdated within days.
+
+**Result:** Your AI assistants keep making the same mistakes. They forget your team's conventions. You waste time repeating yourself.
+
+### The Solution
+Agent Watch automatically:
+- ✅ **Extracts patterns** from your Claude Code, Copilot Chat, and Copilot CLI sessions
+- ✅ **Summarizes learnings** using AI to distill actionable conventions
+- ✅ **Updates all agent files** in one atomic operation via git hooks
+- ✅ **Deduplicates intelligently** to never reprocess the same sessions
+- ✅ **Maintains consistency** across all your AI agent configuration files
+
+### Business Value
+- 🚀 **Faster onboarding**: New team members get AI assistants that know your codebase conventions from day one
+- 🎯 **Consistent code quality**: AI agents follow your established patterns automatically
+- ⏱️ **Time savings**: Stop manually updating agent files or repeating yourself in chat
+- 📈 **Knowledge retention**: Capture architectural decisions and patterns from every conversation
+- 🤝 **Team alignment**: Share learnings across the team through version-controlled agent files
+
+---
+
+## Quick Start
+
+### 1. Install
+
+**Global installation** (recommended):
 ```bash
 npm install -g agent-watch
 ```
 
-Or run directly:
+**Or as a dev dependency** (for team consistency):
+```bash
+npm install -D agent-watch
+# or
+pnpm add -D agent-watch
+```
 
+**Or run directly** without installation:
 ```bash
 npx agent-watch init
 ```
 
-## Quick start
+### 2. Initialize in Your Project
 
 ```bash
 cd your-project
 agent-watch init
 ```
 
-The `init` command walks you through an interactive setup:
+The interactive setup wizard will:
+1. **Detect existing agent files** (CLAUDE.md, copilot-instructions.md, etc.)
+2. **Let you select which files to manage** (space to toggle, enter to confirm)
+3. **Ask about git context** - include commit messages and file changes?
+4. **Ask about chat sessions** - extract patterns from AI conversations?
+5. **Let you choose AI tools** - Claude Code, Copilot Chat, Copilot CLI?
+6. **Pick when to run** - after `git commit` or before `git push`?
+7. **Install the git hook** automatically
+
+Your configuration is saved to `.agent-watch/config.json`.
+
+### 3. Start Coding Normally
+
+That's it! Now whenever you commit code:
+
+```bash
+git add .
+git commit -m "feat: add user authentication"
+# agent-watch runs automatically
+# ✅ Extracts latest 3 sessions from each AI tool
+# ✅ Generates summaries of patterns discussed
+# ✅ Updates CLAUDE.md, copilot-instructions.md, etc.
+```
+
+---
+
+## How It Works
+
+### Architecture Overview
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│ 1. GIT COMMIT TRIGGERED                                     │
+│    User commits code → git hook activates agent-watch       │
+└─────────────────────────────────────────────────────────────┘
+                            ↓
+┌─────────────────────────────────────────────────────────────┐
+│ 2. EXTRACT LATEST SESSIONS (3 per tool)                     │
+│    ├─ Claude Code: ~/.claude/projects/<hash>/               │
+│    ├─ Copilot Chat: ~/Library/.../workspaceStorage/         │
+│    └─ Copilot CLI: ~/.copilot/session-state/                │
+└─────────────────────────────────────────────────────────────┘
+                            ↓
+┌─────────────────────────────────────────────────────────────┐
+│ 3. SUMMARIZE PATTERNS (via GitHub Copilot CLI)              │
+│    For each session:                                        │
+│    • Extract human messages + AI's final response           │
+│    • Ask Copilot: "What patterns/rules were discussed?"     │
+│    • Get concise summary of conventions                     │
+└─────────────────────────────────────────────────────────────┘
+                            ↓
+┌─────────────────────────────────────────────────────────────┐
+│ 4. COLLECT GIT CONTEXT                                      │
+│    • Files changed in commit                                │
+│    • Commit message                                         │
+│    • Diff statistics                                        │
+└─────────────────────────────────────────────────────────────┘
+                            ↓
+┌─────────────────────────────────────────────────────────────┐
+│ 5. SINGLE ATOMIC UPDATE (copilot --yolo)                    │
+│    Send one prompt with:                                    │
+│    • All session summaries                                  │
+│    • Git context                                            │
+│    • Paths to all agent files                               │
+│                                                             │
+│    Copilot reads and updates all files together,            │
+│    maintaining consistency across CLAUDE.md,                │
+│    copilot-instructions.md, AGENTS.md, etc.                 │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### Smart Deduplication
 
-1. **Select agent files** - auto-detects existing files and lets you pick which ones to manage (space to toggle, enter to confirm)
-2. **Git context** - choose whether to use commit messages and chat sessions when updating files
-3. **Hook trigger** - pick when to run: after `git commit` or before `git push`
-4. **AI agents** - select which agent integrations to enable (GitHub Copilot CLI, more coming)
+Agent Watch tracks which sessions have been processed **per tool**:
 
-Your choices are saved to `.agent-watch.json` in the project root.
+```json
+{
+  "processedSessions": {
+    "claude-code": ["session-1", "session-2"],
+    "github-copilot-chat": ["chat-1", "chat-2"],
+    "github-copilot-cli": ["cli-1", "cli-2"]
+  }
+}
+```
+
+**You'll never waste time reprocessing the same conversations.**
+
+### Smart Filtering
+
+Agent Watch automatically **skips analysis** when only these files change:
+- Documentation (README.md, CHANGELOG.md, etc.)
+- Config files (.gitignore, tsconfig.json, etc.)
+- Lock files (package-lock.json, pnpm-lock.yaml, etc.)
+- Agent files themselves (CLAUDE.md, copilot-instructions.md, etc.)
+
+**Your workflow stays fast.**
+
+---
+
+## Supported AI Tools
+
+| AI Tool                 | What Gets Extracted            | Where Sessions Are Stored                             |
+| ----------------------- | ------------------------------ | ----------------------------------------------------- |
+| **Claude Code**         | Conversations from CLI and IDE | `~/.claude/projects/<hash>/`                          |
+| **GitHub Copilot Chat** | Chat sessions in VS Code       | `~/Library/.../workspaceStorage/<hash>/chatSessions/` |
+| **GitHub Copilot CLI**  | Terminal chat sessions         | `~/.copilot/session-state/`                           |
+
+**More tools coming:** Cursor, Windsurf, Cline support is on the roadmap.
 
-## Supported agent files
+---
 
-| File                              | Agent          |
-| --------------------------------- | -------------- |
-| `CLAUDE.md`                       | Claude Code    |
-| `.github/copilot-instructions.md` | GitHub Copilot |
-| `copilot-instructions.md`         | GitHub Copilot |
-| `AGENTS.md` / `agents.md`         | Generic        |
-| `.cursorrules` / `.cursor/rules`  | Cursor         |
-| `.windsurfrules`                  | Windsurf       |
-| `.clinerules`                     | Cline          |
+## Supported Agent Files
 
-## How it works
+Agent Watch can manage these configuration files:
 
-After running `agent-watch init`:
+| File                              | AI Tool             |
+| --------------------------------- | ------------------- |
+| `CLAUDE.md`                       | Claude Code         |
+| `.github/copilot-instructions.md` | GitHub Copilot      |
+| `AGENTS.md` / `agents.md`         | Generic (all tools) |
+| `.cursorrules` / `.cursor/rules`  | Cursor              |
+| `.windsurfrules`                  | Windsurf            |
+| `.clinerules`                     | Cline               |
 
-- A git hook is installed (or instructions are provided if you use lefthook/husky)
-- On each commit or push (depending on your config), agent-watch gathers context from:
-  - Changed files in the commit
-  - Git commit messages
-  - Chat sessions from supported AI tools
-- It uses this context to update your selected agent configuration files
+**You choose which files to manage during setup.**
 
-**Smart filtering**: agent-watch automatically skips running when only documentation or config files are modified (like README.md, .gitignore, lock files, etc.), keeping your workflow fast.
+---
 
 ## Configuration
 
-The `.agent-watch.json` config file:
+After running `agent-watch init`, your config is stored in `.agent-watch/config.json`:
 
 ```json
 {
   "version": 1,
   "agentFiles": ["CLAUDE.md", ".github/copilot-instructions.md"],
-  "useGitContext": true,
+  "watchFileChanges": true,
+  "includeChatSession": true,
   "hookTrigger": "commit",
-  "agents": ["github-copilot-cli"]
+  "agents": ["claude-code", "github-copilot-chat", "github-copilot-cli"]
 }
 ```
 
-## Git hook integration
+### Configuration Options
+
+| Option               | Type                 | Description                             |
+| -------------------- | -------------------- | --------------------------------------- |
+| `agentFiles`         | `string[]`           | Which agent files to update             |
+| `watchFileChanges`   | `boolean`            | Include git commit context              |
+| `includeChatSession` | `boolean`            | Extract and summarize chat sessions     |
+| `hookTrigger`        | `"commit" \| "push"` | When to run agent-watch                 |
+| `agents`             | `string[]`           | Which AI tools to extract sessions from |
+
+---
+
+## Advanced Usage
+
+### Debug Mode
+
+See what agent-watch is doing under the hood:
+
+```bash
+agent-watch run --debug
+```
+
+This creates `.agent-watch/debug/` with:
+- Raw session extractions
+- Generated summaries
+- Final prompt sent to Copilot
+- Copilot's response
+
+**Useful for troubleshooting or understanding how summaries are generated.**
+
+### Manual Run
+
+Trigger agent-watch without committing:
+
+```bash
+agent-watch run
+```
+
+### Git Hook Integration
+
+Agent Watch automatically detects and integrates with:
+
+**Lefthook** - Adds to `lefthook.yml`:
+```yaml
+post-commit:
+  commands:
+    agent-watch:
+      run: npx agent-watch run
+```
+
+**Husky** - Creates hook:
+```bash
+npx husky add .husky/post-commit "npx agent-watch run"
+```
+
+**Direct** - Installs to `.git/hooks/post-commit` if no hook manager detected.
+
+---
+
+## Real-World Example
+
+### Before Agent Watch
+
+You're building a React app. Over several days, you have these conversations with Claude Code:
+
+1. **Monday**: Establish that all API calls should use React Query
+2. **Tuesday**: Decide to use Zod for validation schemas
+3. **Wednesday**: Create a pattern for error boundaries
+4. **Thursday**: New team member asks Claude to fetch data with `fetch()` (Claude suggests it because CLAUDE.md is outdated)
+
+**Problem:** Your conventions are lost in chat history. New code violates established patterns.
+
+### After Agent Watch
+
+Every time you commit:
+
+1. **Monday commit**: CLAUDE.md updated with "Use React Query for all API calls"
+2. **Tuesday commit**: CLAUDE.md updated with "Validate with Zod schemas"
+3. **Wednesday commit**: CLAUDE.md updated with error boundary pattern
+4. **Thursday**: New team member's Claude Code already knows to use React Query (reads CLAUDE.md)
+
+**Result:** Consistency maintained automatically. Knowledge compounds.
+
+---
 
-agent-watch detects your existing hook manager:
+## FAQ
 
-- **Lefthook** - prints the config to add to `lefthook.yml`
-- **Husky** - prints the `npx husky add` command to run
-- **No hook manager** - installs directly to `.git/hooks/`
+**Q: Does this require GitHub Copilot subscription?**
+A: Yes, for the summarization feature. Agent Watch uses `copilot --yolo` to intelligently update agent files. However, session extraction works independently.
 
-The hook is idempotent and can be safely re-run.
+**Q: Will this commit the updated agent files automatically?**
+A: No. Agent Watch updates the files, but you'll see them as unstaged changes. Review and commit them when ready.
 
-## Programmatic API
+**Q: What if I don't want to extract from all tools?**
+A: During `agent-watch init`, select only the tools you want. You can also edit `.agent-watch/config.json` later.
 
-You can also use agent-watch as a library:
+**Q: Can I use this with a monorepo?**
+A: Yes! Run `agent-watch init` in each package that has its own agent files.
 
-```ts
-import { loadConfig, detectAgentFiles, KNOWN_AGENT_FILES } from "agent-watch"
+**Q: What about privacy? Are my chat sessions sent anywhere?**
+A: No external services. Everything runs locally. Sessions are summarized via your local Copilot CLI installation.
 
-const config = loadConfig("./my-project")
-const files = detectAgentFiles("./my-project")
+**Q: Can I customize the summarization prompt?**
+A: Not currently, but this is on the roadmap. Open an issue if you need this feature.
+
+---
+
+## Roadmap
+
+- [ ] Support for more AI tools (Cursor, Windsurf, Cline)
+- [ ] Customizable summarization prompts
+- [ ] Team-wide deduplication (shared processed sessions state)
+- [ ] Export/import of agent file versions
+- [ ] Integration with CI/CD pipelines
+- [ ] Web dashboard for visualizing pattern evolution
+
+---
+
+## Contributing
+
+We welcome contributions! To get started:
+
+1. Fork the repository
+2. Create a feature branch: `git checkout -b feature/my-feature`
+3. Make your changes
+4. Add tests if applicable
+5. Run tests: `pnpm test:ci`
+6. Submit a pull request
+
+### Development Setup
+
+```bash
+git clone https://github.com/surnr/agent-watch.git
+cd agent-watch
+pnpm install
+pnpm build
+pnpm link --global
 ```
 
+Now you can test your changes with `agent-watch` commands.
+
+---
+
+## Troubleshooting
+
+**Issue: "No agent files configured"**
+**Solution:** Run `agent-watch init` to set up configuration.
+
+**Issue: "copilot: command not found"**
+**Solution:** Install GitHub Copilot CLI: `npm install -g @githubnext/github-copilot-cli`
+
+**Issue: Sessions not being extracted**
+**Solution:**
+1. Check that you have chat sessions in the expected locations
+2. Run `agent-watch run --debug` to see what's happening
+3. Verify your tool selections in `.agent-watch/config.json`
+
+**Issue: Agent files not updating**
+**Solution:**
+1. Ensure Copilot CLI is authenticated: `copilot auth`
+2. Check `.agent-watch/debug/` logs if debug mode is enabled
+3. Verify agent file paths in config are correct
+
+---
+
 ## License
 
-MIT
+MIT License - see [LICENSE](LICENSE) file for details.
+
+---
+
+## Support
+
+- 🐛 **Bug reports:** [GitHub Issues](https://github.com/surnr/agent-watch/issues)
+- 💡 **Feature requests:** [GitHub Discussions](https://github.com/surnr/agent-watch/discussions)
+- 📖 **Documentation:** Check the [docs](./docs) folder
+- ⭐ **Star us on GitHub** if you find this useful!
+
+---
+
+**Built with ❤️ for developers who believe AI assistants should remember your conversations.**

package/dist/cli.cjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const require_sessions = require('./sessions-_HBb3nIW.cjs');
+const require_sessions = require('./sessions-Di0snUK6.cjs');
 let node_module = require("node:module");
 let commander = require("commander");
 let _inquirer_prompts = require("@inquirer/prompts");
@@ -593,6 +593,58 @@ async function initCommand() {
 	require_sessions.logger.blank();
 }
 
+//#endregion
+//#region src/utils/debug.ts
+/**
+* Global debug mode flag
+*/
+let debugMode = false;
+/**
+* Set the debug mode for the current run
+*/
+function setDebugMode(enabled) {
+	debugMode = enabled;
+}
+/**
+* Generate a timestamp for log filenames
+*/
+function getTimestamp() {
+	return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+}
+/**
+* Ensure the debug logs directory exists
+*/
+function ensureDebugDir(projectRoot) {
+	const debugDir = (0, node_path.join)(projectRoot, require_sessions.AGENT_WATCH_DIR, require_sessions.DEBUG_LOGS_DIR);
+	if (!(0, node_fs.existsSync)(debugDir)) (0, node_fs.mkdirSync)(debugDir, { recursive: true });
+	return debugDir;
+}
+/**
+* Write debug content to a file in the debug logs directory
+*/
+function writeDebugLog(projectRoot, filename, content) {
+	if (!debugMode) return;
+	(0, node_fs.writeFileSync)((0, node_path.join)(ensureDebugDir(projectRoot), `${getTimestamp()}_${filename}`), content, "utf-8");
+}
+/**
+* Log the context built from file changes and chat sessions
+*/
+function logContext(projectRoot, context) {
+	writeDebugLog(projectRoot, "context.txt", context);
+}
+/**
+* Log the prompt sent to copilot
+*/
+function logCopilotPrompt(projectRoot, agentFile, prompt) {
+	writeDebugLog(projectRoot, `prompt_${agentFile.replace(/[/\\]/g, "_")}.txt`, prompt);
+}
+/**
+* Log the response from copilot
+*/
+function logCopilotResponse(projectRoot, agentFile, response) {
+	writeDebugLog(projectRoot, `response_${agentFile.replace(/[/\\]/g, "_")}.txt`, response);
+}
+
 //#endregion
 //#region src/commands/run.ts
 /**
@@ -635,12 +687,12 @@ function getModifiedFiles() {
 	}
 }
 /**
-* Check if a file path should be ignored (doesn't trigger agent-watch analysis)
+* Check if a file path should be ignored
 */
 function shouldIgnoreFile(filePath) {
-	const normalizedPath = filePath.replace(/\\/g, "/");
+	const normalizedPath = filePath.replaceAll("\\", "/");
 	for (const pattern of require_sessions.IGNORED_FILE_PATTERNS) {
-		const normalizedPattern = pattern.replace(/\\/g, "/");
+		const normalizedPattern = pattern.replaceAll("\\", "/");
 		if (normalizedPath === normalizedPattern) return true;
 		if (normalizedPath.startsWith(`${normalizedPattern}/`)) return true;
 		if (normalizedPath.split("/").pop() === normalizedPattern) return true;
@@ -655,49 +707,28 @@ function shouldSkipAnalysis(modifiedFiles) {
 	return modifiedFiles.every(shouldIgnoreFile);
 }
 /**
-* Use Copilot CLI to intelligently update agent file content
+* Format git context as a readable string
 */
-function updateAgentFileWithCopilot(projectRoot, context, agentFilePath, currentContent) {
-	try {
-		const output = (0, node_child_process.execSync)(`copilot -p "${`You are maintaining ${agentFilePath}, a living document of patterns, conventions, and code rules.
-
-Your task:
-1. Read the CURRENT content of this file carefully
-2. Analyze the RECENT changes and conversations below
-3. Determine if there are new patterns, rules, or conventions to document
-4. If updates are needed, output the COMPLETE UPDATED file content
-5. If no meaningful updates needed, output exactly: NO_UPDATE
-
-Guidelines:
-- Intelligently merge new insights into existing sections
-- Update or refine existing rules if patterns have evolved
-- Remove outdated information
-- Keep it concise - no code snippets unless absolutely necessary
-- Maintain the file's existing structure and tone
-- Focus on patterns, conventions, and learnings - not changelogs
-
-CURRENT FILE CONTENT:
-${currentContent}
-
-RECENT CONTEXT:
-${context}
-
-Output the complete updated file, or NO_UPDATE if nothing significant to add:`.replaceAll("\"", String.raw`\"`)}" -s`, {
-			cwd: projectRoot,
-			encoding: "utf-8",
-			stdio: "pipe",
-			timeout: 9e4
-		}).trim();
-		if (output === "NO_UPDATE" || output.length === 0 || output === currentContent) return null;
-		return output;
-	} catch {
-		return null;
-	}
+function formatGitContext(commitMessage, modifiedFiles, diffStats) {
+	const parts = [];
+	if (commitMessage) parts.push(`Commit message: ${commitMessage}`);
+	if (modifiedFiles.length > 0) parts.push(`Files changed: ${modifiedFiles.join(", ")}`);
+	if (diffStats) parts.push(`Diff stats:\n${diffStats}`);
+	return parts.join("\n\n");
+}
+/**
+* Escape prompt for safe shell execution
+*/
+function escapeShellPrompt(prompt) {
+	return prompt.replaceAll("\"", String.raw`\"`);
 }
 /**
 * Run command - update agent files with extracted patterns and learnings
+* New approach: Collect summaries from all tools, then use single yolo command
 */
-async function runCommand() {
+async function runCommand(debug = false) {
+	setDebugMode(debug);
+	if (debug) require_sessions.logger.info("Debug mode enabled - logs will be saved to .agent-watch/debug/");
 	const gitRoot = findGitRoot(process.cwd());
 	if (!gitRoot) {
 		require_sessions.logger.error("Not inside a git repository");
@@ -712,46 +743,43 @@ async function runCommand() {
 		require_sessions.logger.warn("No agent files configured");
 		return;
 	}
-	const contextParts = [];
+	let gitContext = "";
 	if (config.watchFileChanges) {
 		const modifiedFiles = getModifiedFiles();
 		if (shouldSkipAnalysis(modifiedFiles)) {
 			require_sessions.logger.info("Skipping analysis - only config/documentation files changed");
 			return;
 		}
-		const commitMessage = getCommitMessage();
-		const diffStats = getGitDiffStats();
-		if (modifiedFiles.length > 0) {
-			const fileContext = [
-				commitMessage ? `Commit: ${commitMessage}` : "",
-				`Files changed: ${modifiedFiles.join(", ")}`,
-				diffStats ? `Stats:\n${diffStats}` : ""
-			].filter(Boolean).join("\n");
-			contextParts.push(fileContext);
-		}
+		gitContext = formatGitContext(getCommitMessage(), modifiedFiles, getGitDiffStats());
 	}
-	if (config.includeChatSession) {
-		const sessionContext = require_sessions.processNewSessions(gitRoot);
-		if (sessionContext) contextParts.push(`Conversations:\n${sessionContext}`);
-	}
-	if (contextParts.length === 0) {
+	const summaries = config.includeChatSession && config.agents.length > 0 ? require_sessions.processAllSessions(gitRoot, config.agents) : [];
+	if (!gitContext && summaries.length === 0) {
 		require_sessions.logger.info("No new context to analyze");
 		return;
 	}
-	const context = contextParts.join("\n\n");
-	require_sessions.logger.step("Analyzing context for patterns and rules...");
-	let updatedCount = 0;
-	for (const filePath of config.agentFiles) {
-		const fullPath = (0, node_path.join)(gitRoot, filePath);
-		const updatedContent = updateAgentFileWithCopilot(gitRoot, context, filePath, (0, node_fs.readFileSync)(fullPath, "utf-8"));
-		if (updatedContent) {
-			(0, node_fs.writeFileSync)(fullPath, updatedContent, "utf-8");
-			require_sessions.logger.success(`Updated ${filePath}`);
-			updatedCount++;
-		}
+	const agentFilePaths = config.agentFiles.map((f) => (0, node_path.join)(gitRoot, f));
+	const prompt = `Based on the following context, intelligently update the agent configuration files listed below. Only update if there are meaningful new patterns, conventions, or rules to document.
+
+${gitContext ? `## Git Changes\n${gitContext}\n\n` : ""}${summaries.length > 0 ? `## Pattern Summaries from Chat Sessions\n${summaries.join("\n\n")}\n\n` : ""}## Agent Files to Update
+${agentFilePaths.map((p) => `- ${p}`).join("\n")}
+
+Read each file, analyze its current content, and update with new insights. Merge patterns intelligently, maintain existing structure, remove outdated info. Focus on patterns and conventions, not changelogs.`;
+	logContext(gitRoot, `${gitContext}\n\nSummaries:\n${summaries.join("\n\n")}`);
+	logCopilotPrompt(gitRoot, "yolo-update", prompt);
+	require_sessions.logger.step("Updating agent files via Copilot --yolo...");
+	try {
+		logCopilotResponse(gitRoot, "yolo-update", (0, node_child_process.execSync)(`copilot -p "${escapeShellPrompt(prompt)}" --yolo`, {
+			cwd: gitRoot,
+			encoding: "utf-8",
+			stdio: "pipe",
+			timeout: 18e4
+		}));
+		require_sessions.logger.success("Agent files updated successfully");
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		require_sessions.logger.error(`Failed to update files: ${errorMessage}`);
+		process.exit(1);
 	}
-	if (updatedCount > 0) require_sessions.logger.success(`Updated ${updatedCount} agent file(s) with new insights`);
-	else require_sessions.logger.info("No significant patterns found to update");
 }
 
 //#endregion
@@ -761,8 +789,8 @@ commander.program.name("agent-watch").description("Keep your AI agent configurat
 commander.program.command("init").description("Initialize agent-watch in the current project").action(async () => {
 	await initCommand();
 });
-commander.program.command("run").description("Update agent files with recent changes and chat sessions").action(async () => {
-	await runCommand();
+commander.program.command("run").description("Update agent files with recent changes and chat sessions").option("--debug", "Enable debug mode to save all content to .agent-watch/debug/").action(async (options) => {
+	await runCommand(options.debug ?? false);
 });
 commander.program.parse();