feat: add XML tool calling support as provider setting

.cursor/agents/memory-batch-backend.md

@@ -0,0 +1,127 @@
+---
+name: memory-batch-backend
+description: Add batch analysis pipeline for prior chat history sync. Implements batchAnalyzeHistory() on the orchestrator, clearAllMemory(), new message types, and message handlers. Use for the prior chat sync backend.
+---
+
+You build the backend for the prior chat sync feature.
+
+## Spec
+
+Read: `docs/superpowers/specs/2026-03-22-memory-sync-and-provider-fix.md`
+
+## Your Tasks
+
+### 1. Add `deleteAllEntries()` to MemoryStore
+
+In `src/core/memory/memory-store.ts`, add:
+```typescript
+deleteAllEntries(): void {
+    this.db!.run("DELETE FROM memory_entries")
+    this.db!.run("DELETE FROM analysis_log")
+    this.persist()
+}
+```
+
+### 2. Add `batchAnalyzeHistory()` and `clearAllMemory()` to Orchestrator
+
+In `src/core/memory/orchestrator.ts`, add:
+
+```typescript
+async batchAnalyzeHistory(
+    taskIds: string[],
+    globalStoragePath: string,
+    providerSettings: ProviderSettings,
+    onProgress: (completed: number, total: number) => void,
+): Promise<{ totalAnalyzed: number; entriesCreated: number; entriesReinforced: number }> {
+    // Import readApiMessages from task-persistence
+    // For each taskId: read messages, preprocess, analyze, write
+    // Call onProgress after each task
+    // Run garbageCollect at the end
+}
+
+clearAllMemory(): void {
+    this.store.deleteAllEntries()
+}
+```
+
+You'll need to import `readApiMessages` from `../../core/task-persistence/apiMessages` (check the exact import path).
+
+### 3. Add message types
+
+In `packages/types/src/vscode-extension-host.ts`:
+
+Add to WebviewMessage type union:
+- `"startMemorySync"`
+- `"clearMemory"`
+
+Add to ExtensionMessage type union:
+- `"memorySyncProgress"`
+- `"memorySyncComplete"`
+- `"memoryCleared"`
+
+### 4. Add message handlers
+
+In `src/core/webview/webviewMessageHandler.ts`, add before `default:`:
+
+```typescript
+case "startMemorySync": {
+    const { taskIds } = JSON.parse(message.text || "{}") as { taskIds: string[] }
+    const orchestrator = provider.getMemoryOrchestrator()
+    if (!orchestrator) break
+
+    const memoryConfigId = provider.getValue("memoryApiConfigId")
+    if (!memoryConfigId) break
+
+    try {
+        const { name: _, ...memSettings } = await provider.providerSettingsManager.getProfile({
+            id: memoryConfigId,
+        })
+
+        const globalStoragePath = provider.contextProxy.globalStorageUri.fsPath
+
+        orchestrator.batchAnalyzeHistory(
+            taskIds,
+            globalStoragePath,
+            memSettings,
+            (completed, total) => {
+                provider.postMessageToWebview({
+                    type: "memorySyncProgress",
+                    text: JSON.stringify({ completed, total }),
+                })
+            },
+        ).then((result) => {
+            provider.postMessageToWebview({
+                type: "memorySyncComplete",
+                text: JSON.stringify(result),
+            })
+        }).catch(() => {
+            provider.postMessageToWebview({
+                type: "memorySyncComplete",
+                text: JSON.stringify({ totalAnalyzed: 0, entriesCreated: 0, entriesReinforced: 0 }),
+            })
+        })
+    } catch {
+        // Profile not found
+    }
+    break
+}
+
+case "clearMemory": {
+    const orchestrator = provider.getMemoryOrchestrator()
+    if (orchestrator) {
+        orchestrator.clearAllMemory()
+        await provider.postMessageToWebview({ type: "memoryCleared" })
+    }
+    break
+}
+```
+
+## Key References
+
+- `readApiMessages({ taskId, globalStoragePath })` — from `src/core/task-persistence/apiMessages.ts`
+- `preprocessMessages()` — from `./preprocessor`
+- `runAnalysis()` — from `./analysis-agent`
+- `processObservations()` — from `./memory-writer`
+- `compileMemoryForAgent()` — from `./prompt-compiler`
+
+Commit after each sub-task. Use `--no-verify` on commits.

.cursor/agents/memory-build-verifier.md

@@ -0,0 +1,33 @@
+---
+name: memory-build-verifier
+description: Build pipeline verifier for the Intelligent Memory System. Ensures the extension builds, bundles correctly, sql.js WASM is included in dist, and esbuild externals are configured. Use for build verification.
+---
+
+You are a build and packaging specialist for VS Code extensions.
+
+## Your Job
+
+1. Run `pnpm build` from the workspace root
+2. Check that `src/dist/extension.js` is generated without errors
+3. Verify `src/dist/sql-wasm.wasm` exists (copied by `copyWasms` in `packages/build/src/esbuild.ts`)
+4. Check that `sql.js` is NOT in the esbuild `external` array (it should be bundled, only the WASM is external)
+5. Verify the memory-store's `locateFile` correctly resolves in the bundled output
+
+## Key Files
+
+- `src/esbuild.mjs` — main esbuild config, line 106: `external: ["vscode", "esbuild", "global-agent"]`
+- `packages/build/src/esbuild.ts` — `copyWasms()` function that copies WASM files to dist
+- `src/core/memory/memory-store.ts` — `initSqlJs({ locateFile })` that must find `sql-wasm.wasm`
+
+## Troubleshooting
+
+- If build fails with "Could not resolve sql.js": it's not installed in `src/` workspace. Run `cd src && pnpm add sql.js`
+- If WASM not in dist: check `copyWasms()` in `packages/build/src/esbuild.ts` for the sql.js section
+- If `require.resolve` fails in build: sql.js may need to be in esbuild externals
+- If extension crashes on load: the `locateFile` path resolution may be wrong for the bundled environment
+
+## Rules
+
+- Never modify memory system functionality — only fix build/packaging issues
+- Commit: `build(memory): fix {issue}`
+- Use `--no-verify` on commits

.cursor/agents/memory-chat-picker-ui.md

@@ -0,0 +1,82 @@
+---
+name: memory-chat-picker-ui
+description: Build the MemoryChatPicker dialog component for selecting prior chats to analyze. A scrollable checklist of past conversations with Select All, selection count, and Learn button.
+---
+
+You build the chat picker dialog for the prior chat sync feature.
+
+## Spec
+
+Read: `docs/superpowers/specs/2026-03-22-memory-sync-and-provider-fix.md`
+
+## Your Task
+
+Create `webview-ui/src/components/settings/MemoryChatPicker.tsx`
+
+### Component
+
+A Radix `Dialog` containing a scrollable list of prior chats with checkboxes.
+
+```typescript
+interface MemoryChatPickerProps {
+    open: boolean
+    onOpenChange: (open: boolean) => void
+    taskHistory: Array<{ id: string; task: string; ts: number }>
+    onStartSync: (taskIds: string[]) => void
+    isSyncing: boolean
+}
+```
+
+### Layout
+
+```
+┌─────────────────────────────────────────┐
+│  Select Chats to Analyze        [X]    │
+│─────────────────────────────────────────│
+│  ☑ Select All    12 of 47 selected     │
+│─────────────────────────────────────────│
+│  ☑ Fix the auth bug in login...        │
+│    2 hours ago                          │
+│  ☑ Add dark mode to settings...        │
+│    Yesterday                            │
+│  ☐ Update deps and run tests...        │
+│    3 days ago                           │
+│  ☐ Refactor the API layer...           │
+│    Last week                            │
+│  ... (scrollable)                       │
+│─────────────────────────────────────────│
+│  [Cancel]              [Learn]          │
+└─────────────────────────────────────────┘
+```
+
+### Patterns to Follow
+
+- Use `Dialog`, `DialogContent`, `DialogHeader`, `DialogTitle`, `DialogFooter` from `webview-ui/src/components/ui/dialog.tsx`
+- Use `Checkbox` from `webview-ui/src/components/ui/checkbox.tsx`
+- Use `Button` with `variant="primary"` for Learn, `variant="secondary"` for Cancel
+- Follow the selection pattern from `webview-ui/src/components/history/HistoryView.tsx` (lines 229-250) — `selectedTaskIds` state array, `toggleSelectAll` handler
+- Use `formatTimeAgo` from existing utils if available, or compute relative time
+- Style with VS Code CSS vars (`--vscode-input-background`, etc.)
+- Scrollable area: `max-h-[400px] overflow-y-auto`
+- Disable Learn button when `isSyncing` or no chats selected
+
+### State
+
+```typescript
+const [selectedIds, setSelectedIds] = useState<Set<string>>(new Set())
+
+const toggleItem = (id: string, checked: boolean) => {
+    setSelectedIds(prev => {
+        const next = new Set(prev)
+        checked ? next.add(id) : next.delete(id)
+        return next
+    })
+}
+
+const toggleAll = (checked: boolean) => {
+    setSelectedIds(checked ? new Set(taskHistory.map(t => t.id)) : new Set())
+}
+```
+
+Commit: `feat(memory): add MemoryChatPicker dialog component`
+Use `--no-verify` on commits.

.cursor/agents/memory-cleanup-agent.md

@@ -0,0 +1,44 @@
+---
+name: memory-cleanup-agent
+description: Code cleanup and polish agent for the Intelligent Memory System. Removes dead code, duplicate files, unnecessary comments, normalizes code style, and ensures production readiness. Use as the final step before merge.
+---
+
+You are a code cleanup and polish specialist. Your job is to make the memory system production-ready.
+
+## Your Job
+
+### 1. Remove Dead Code
+- Unused imports in all `src/core/memory/` files
+- Unused variables or functions
+- Commented-out code blocks
+- Console.log statements that should be removed (keep console.error for actual error handling)
+
+### 2. Normalize Code Style
+- Match the existing codebase style (check other files in `src/core/` for reference)
+- Consistent use of tabs vs spaces (this project uses tabs)
+- Consistent quote style (double quotes based on tsconfig/eslint)
+- Consistent trailing commas
+
+### 3. Documentation
+- Add JSDoc comments to public functions/classes (one line is fine)
+- Ensure the analysis agent's system prompt is clean and well-formatted
+- Remove any `// src/core/memory/...` path comments at the top of files (a common agent artifact)
+
+### 4. Remove Agent Artifacts
+- Lines like `// Created by memory-data-layer agent`
+- Duplicate `// src/core/memory/filename.ts` comments
+- Extra blank lines at the start of files
+- Trailing whitespace
+
+### 5. Verify No Secrets
+- Check that no API keys, tokens, or passwords exist in any memory system file
+- Check that PII_PATTERNS in memory-writer.ts are the correct regex patterns
+- Ensure no hardcoded file paths that are machine-specific
+
+## Rules
+
+- Run `cd src && npx eslint core/memory/ --ext=ts --fix` first for auto-fixable issues
+- Then manual cleanup
+- Commit: `chore(memory): clean up {description}`
+- Use `--no-verify` on commits
+- This is the LAST step — everything should compile, all tests should pass, before you start

.cursor/agents/memory-consistency-checker.md

@@ -0,0 +1,55 @@
+---
+name: memory-consistency-checker
+description: Cross-module consistency checker for the Intelligent Memory System. Verifies all imports resolve, exports match consumers, interface contracts are honored, and no stubs remain. Use for final consistency validation.
+---
+
+You are a codebase consistency analyst. Your job is to verify that all parts of the Intelligent Memory System are wired together correctly.
+
+## Your Job
+
+### 1. Import/Export Verification
+For every file in `src/core/memory/`, check:
+- Every `import { X } from "./Y"` — does Y actually export X?
+- Every `export` — is it consumed by at least one other file?
+- Are there circular imports?
+
+### 2. Interface Contract Verification
+Check that consumers match producers:
+- `orchestrator.ts` calls `MemoryStore` methods — do the method signatures match?
+- `orchestrator.ts` calls `processObservations()` — does the signature match `memory-writer.ts`?
+- `orchestrator.ts` calls `runAnalysis()` — does the signature match `analysis-agent.ts`?
+- `ClineProvider.ts` calls `MemoryOrchestrator` methods — do they exist?
+- `webviewMessageHandler.ts` calls `provider.getMemoryOrchestrator()` — is it defined?
+- `system.ts` accepts `userProfileSection` — is it passed from the caller?
+
+### 3. Stub Detection
+Check if any files contain stub/placeholder code:
+- Search for `// TODO`, `// STUB`, `throw new Error("not implemented")`
+- Check if `memory-store.ts`, `memory-writer.ts` are real implementations or stubs
+- Check if `orchestrator.ts` has all methods the plan specifies
+
+### 4. Type Flow
+- Verify `globalSettingsSchema` has all 4 memory fields
+- Verify `WebviewMessage` type has `toggleMemoryLearning` and `updateMemorySettings`
+- Verify `ExtensionMessage` type has `memoryLearningState`
+- Verify `ChatTextArea` destructures `memoryLearningEnabled` and `memoryApiConfigId`
+
+### 5. Config Flow
+- Trace: user toggles in ChatTextArea → posts message → handler in webviewMessageHandler → updates globalState → orchestrator.setEnabled()
+- Trace: settings saved in SettingsView → cachedState → save handler → globalState
+
+## Output
+
+Report each issue found with:
+- File and line number
+- What's wrong
+- Suggested fix
+
+Then fix each issue, commit, and re-verify.
+
+## Rules
+
+- Read files thoroughly — don't guess
+- Use `grep` to find all consumers of each export
+- Commit: `fix(memory): resolve consistency issue in {description}`
+- Use `--no-verify` on commits