opencodekit 0.15.21 → 0.16.1

package/dist/template/.opencode/plugin/memory.ts

@@ -19,6 +19,12 @@
 import fsPromises from "node:fs/promises";
 import path from "node:path";
 import type { Plugin } from "@opencode-ai/plugin";
+import {
+	checkFTS5Available,
+	checkpointWAL,
+	getDatabaseSizes,
+	optimizeFTS5,
+} from "./lib/memory-db.js";
 
 // ============================================================================
 // Configuration
@@ -491,8 +497,39 @@ export const MemoryPlugin: Plugin = async ({ client, $: _$ }) => {
 			}
 		},
 
-		// Hook: session.idle - Session completed
+		// Hook: session.idle - Session completed + FTS5 optimization
 		"session.idle": async () => {
+			// ===== FTS5 Optimization =====
+			// Run FTS5 optimize at session end to keep search fast
+			try {
+				if (checkFTS5Available()) {
+					optimizeFTS5();
+					await log("FTS5 index optimized");
+				}
+			} catch (err) {
+				const errMsg = err instanceof Error ? err.message : String(err);
+				await log(`FTS5 optimization failed: ${errMsg}`, "warn");
+			}
+
+			// ===== WAL Checkpoint (if WAL > 1MB) =====
+			// Checkpoint WAL to main DB when it gets too large
+			try {
+				const sizes = getDatabaseSizes();
+				if (sizes.wal > 1024 * 1024) {
+					// WAL > 1MB
+					const result = checkpointWAL();
+					if (result.checkpointed) {
+						await log(
+							`WAL checkpointed (was ${Math.round(sizes.wal / 1024)}KB)`,
+						);
+					}
+				}
+			} catch (err) {
+				const errMsg = err instanceof Error ? err.message : String(err);
+				await log(`WAL checkpoint failed: ${errMsg}`, "warn");
+			}
+
+			// ===== Session Summary Prompt =====
 			if (config.sessionSummaryEnabled === false) return;
 
 			await log("Session idle - prompting memory summary");

package/dist/template/.opencode/skill/index-knowledge/SKILL.md

@@ -10,11 +10,23 @@ Generate hierarchical AGENTS.md files. Root + complexity-scored subdirectories.
 ## Usage
 
 ```
---create-new   # Read existing → remove all → regenerate from scratch
---max-depth=2  # Limit directory depth (default: 5)
+/index-knowledge                  # Update mode (default)
+/index-knowledge --create-new     # Delete all → regenerate from scratch
+/index-knowledge --max-depth=2    # Limit directory depth (default: 5)
 ```
 
-Default: Update mode (modify existing + create new where warranted)
+## Load Skills
+
+```typescript
+skill({ name: "memory-system" }); // Search for existing patterns
+skill({ name: "deep-research" }); // For thorough LSP exploration
+```
+
+## Check Memory First
+
+```typescript
+memory_search({ query: "AGENTS.md conventions patterns", limit: 3 });
+```
 
 ---
 
@@ -30,13 +42,13 @@ Default: Update mode (modify existing + create new where warranted)
 <critical>
 **TodoWrite ALL phases. Mark in_progress → completed in real-time.**
   
-```
-TodoWrite([
+```typescript
+todowrite({ todos: [
   { id: "discovery", content: "Fire explore agents + LSP codemap + read existing", status: "pending", priority: "high" },
   { id: "scoring", content: "Score directories, determine locations", status: "pending", priority: "high" },
   { id: "generate", content: "Generate AGENTS.md files (root + subdirs)", status: "pending", priority: "high" },
   { id: "review", content: "Deduplicate, validate, trim", status: "pending", priority: "medium" }
-])
+]});
 ```
 </critical>
 
@@ -93,14 +105,14 @@ Task(
 <dynamic-agents>
 **DYNAMIC AGENT SPAWNING**: After bash analysis, spawn ADDITIONAL explore agents based on project scale:
 
-| Factor | Threshold | Additional Agents |
-|--------|-----------|-------------------|
-| **Total files** | >100 | +1 per 100 files |
-| **Total lines** | >10k | +1 per 10k lines |
-| **Directory depth** | ≥4 | +2 for deep exploration |
+| Factor                       | Threshold | Additional Agents          |
+| ---------------------------- | --------- | -------------------------- |
+| **Total files**              | >100      | +1 per 100 files           |
+| **Total lines**              | >10k      | +1 per 10k lines           |
+| **Directory depth**          | ≥4        | +2 for deep exploration    |
 | **Large files (>500 lines)** | >10 files | +1 for complexity hotspots |
-| **Monorepo** | detected | +1 per package/workspace |
-| **Multiple languages** | >1 | +1 per language |
+| **Monorepo**                 | detected  | +1 per package/workspace   |
+| **Multiple languages**       | >1        | +1 per language            |
 
 ```bash
 # Measure project scale first
@@ -111,6 +123,7 @@ max_depth=$(find . -type d -not -path '*/node_modules/*' -not -path '*/.git/*' |
 ```
 
 Example spawning (all in ONE message for parallel execution):
+
 ```
 // 500 files, 50k lines, depth 6, 15 large files → spawn additional agents
 Task(
@@ -132,6 +145,7 @@ Task(
 )
 // ... more based on calculation
 ```
+
 </dynamic-agents>
 
 ### Main Session: Concurrent Analysis
@@ -139,6 +153,7 @@ Task(
 **While Task agents execute**, main session does:
 
 #### 1. Bash Structural Analysis
+
 ```bash
 # Directory depth + file counts
 find . -type d -not -path '*/\.*' -not -path '*/node_modules/*' -not -path '*/venv/*' -not -path '*/dist/*' -not -path '*/build/*' | awk -F/ '{print NF-1}' | sort -n | uniq -c
@@ -154,6 +169,7 @@ find . -type f \( -name "AGENTS.md" -o -name "CLAUDE.md" \) -not -path '*/node_m
 ```
 
 #### 2. Read Existing AGENTS.md
+
 ```
 For each existing file found:
   Read(filePath=file)
@@ -164,6 +180,7 @@ For each existing file found:
 If `--create-new`: Read all existing first (preserve context) → then delete all → regenerate.
 
 #### 3. LSP Codemap (if available)
+
 ```
 lsp_servers()  # Check availability
 
@@ -192,27 +209,28 @@ lsp_find_references(filePath="...", line=X, character=Y)
 
 ### Scoring Matrix
 
-| Factor | Weight | High Threshold | Source |
-|--------|--------|----------------|--------|
-| File count | 3x | >20 | bash |
-| Subdir count | 2x | >5 | bash |
-| Code ratio | 2x | >70% | bash |
-| Unique patterns | 1x | Has own config | explore |
-| Module boundary | 2x | Has index.ts/__init__.py | bash |
-| Symbol density | 2x | >30 symbols | LSP |
-| Export count | 2x | >10 exports | LSP |
-| Reference centrality | 3x | >20 refs | LSP |
+| Factor               | Weight | High Threshold           | Source  |
+| -------------------- | ------ | ------------------------ | ------- |
+| File count           | 3x     | >20                      | bash    |
+| Subdir count         | 2x     | >5                       | bash    |
+| Code ratio           | 2x     | >70%                     | bash    |
+| Unique patterns      | 1x     | Has own config           | explore |
+| Module boundary      | 2x     | Has index.ts/**init**.py | bash    |
+| Symbol density       | 2x     | >30 symbols              | LSP     |
+| Export count         | 2x     | >10 exports              | LSP     |
+| Reference centrality | 3x     | >20 refs                 | LSP     |
 
 ### Decision Rules
 
-| Score | Action |
-|-------|--------|
-| **Root (.)** | ALWAYS create |
-| **>15** | Create AGENTS.md |
-| **8-15** | Create if distinct domain |
-| **<8** | Skip (parent covers) |
+| Score        | Action                    |
+| ------------ | ------------------------- |
+| **Root (.)** | ALWAYS create             |
+| **>15**      | Create AGENTS.md          |
+| **8-15**     | Create if distinct domain |
+| **<8**       | Skip (parent covers)      |
 
 ### Output
+
 ```
 AGENTS_LOCATIONS = [
   { path: ".", type: "root" },
@@ -239,39 +257,48 @@ AGENTS_LOCATIONS = [
 **Branch:** {BRANCH}
 
 ## OVERVIEW
+
 {1-2 sentences: what + core stack}
 
 ## STRUCTURE
+
 \`\`\`
 {root}/
-├── {dir}/    # {non-obvious purpose only}
+├── {dir}/ # {non-obvious purpose only}
 └── {entry}
 \`\`\`
 
 ## WHERE TO LOOK
+
 | Task | Location | Notes |
-|------|----------|-------|
+| ---- | -------- | ----- |
 
 ## CODE MAP
+
 {From LSP - skip if unavailable or project <10 files}
 
 | Symbol | Type | Location | Refs | Role |
 
 ## CONVENTIONS
+
 {ONLY deviations from standard}
 
 ## ANTI-PATTERNS (THIS PROJECT)
+
 {Explicitly forbidden here}
 
 ## UNIQUE STYLES
+
 {Project-specific}
 
 ## COMMANDS
+
 \`\`\`bash
 {dev/test/build}
 \`\`\`
 
 ## NOTES
+
 {Gotchas}
 ```
 
@@ -316,6 +343,7 @@ Task(
 **Mark "review" as in_progress.**
 
 For each generated file:
+
 - Remove generic advice
 - Remove parent duplicates
 - Trim to size limits
@@ -356,3 +384,20 @@ Hierarchy:
 - **Redundancy**: Child never repeats parent
 - **Generic content**: Remove anything that applies to ALL projects
 - **Verbose style**: Telegraphic or die
+- **Skipping memory**: ALWAYS search memory for existing patterns before starting
+
+---
+
+## Record Findings
+
+After completion, save significant discoveries:
+
+```typescript
+observation({
+  type: "pattern",
+  title: "AGENTS.md patterns for [project]",
+  narrative: "[Key conventions, anti-patterns, structure decisions]",
+  concepts: "AGENTS.md, documentation, codebase, knowledge",
+  confidence: "high",
+});
+```

package/dist/template/.opencode/skill/memory-system/SKILL.md

@@ -5,90 +5,94 @@ description: Use when persisting learnings, loading previous context, or searchi
 
 # Memory System
 
-Persistent context that survives across sessions.
+Persistent context that survives across sessions. Uses **SQLite + FTS5** as single source of truth.
 
-## Directory Structure
+## Architecture
 
 ```
-.opencode/memory/
-  _templates/     # Task templates (prd, observation, session-summary)
-  handoffs/       # Phase transitions
-  research/       # Research findings
-  observations/   # Structured observations
-  project/        # Persistent project knowledge
-    commands.md       # Build, test, lint, deploy commands
-    conventions.md    # Code patterns, commit style, PR process
-    gotchas.md        # Footguns, edge cases, "don't forget this"
-    architecture.md   # Key modules, directory structure
-  user.md         # Identity, preferences, communication style
+SQLite Database: .opencode/memory/memory.sqlite
+├── observations table (FTS5 indexed)
+├── handoffs/ subdirectory
+├── research/ subdirectory
+└── project/ subdirectory (commands, conventions, gotchas, architecture)
 ```
 
-## Standard Memory Blocks
+**Key principle:** All writes go to SQLite. No dual-write pattern. No markdown fallbacks.
 
-| File                      | Purpose                  | Update When                 |
-| ------------------------- | ------------------------ | --------------------------- |
-| `project/commands.md`     | Build/test/lint commands | Discovering new command     |
-| `project/conventions.md`  | Code patterns, style     | Learning team pattern       |
-| `project/gotchas.md`      | Footguns, warnings       | Hitting unexpected behavior |
-| `project/architecture.md` | Key modules, structure   | Mapping new area            |
-| `user.md`                 | Preferences, workflow    | Learning user preference    |
+## Memory Tools
 
-## Explicit Memory Updates
+### memory-search (Start Here)
 
-Don't rely on implicit learning. Explicitly persist:
+Fast FTS5 full-text search. Returns **compact index** (50-100 tokens per result) for progressive disclosure.
 
-- Non-obvious project behavior → `project/gotchas.md`
-- User preferences discovered → `user.md`
-- New build/test commands → `project/commands.md`
-- Code patterns to follow → `project/conventions.md`
+```typescript
+memory_search({ query: "authentication" });
+memory_search({ query: "bugfix", type: "observations", limit: 5 });
+memory_search({ query: "session", type: "handoffs" });
+memory_search({ query: "patterns", type: "all" }); // Search everything
+```
 
-## Memory Tools
+**Search modes:**
+
+- `observations` (default): Search SQLite with FTS5 ranking
+- `handoffs`, `research`, `templates`: Search specific directories
+- `beads`: Search .beads/artifacts
+- `all`: Search everything
 
-### memory-read
+### memory-get (Progressive Disclosure)
 
-Load previous context or templates:
+Fetch full observation details after identifying relevant IDs from search:
 
 ```typescript
-memory - read({ file: "project/commands" }); // Load commands
-memory - read({ file: "_templates/prd" }); // Load PRD template
-memory - read({ file: "handoffs/bd-abc123" }); // Load specific handoff
+memory_get({ ids: "42" }); // Single observation
+memory_get({ ids: "1,5,10" }); // Multiple observations
 ```
 
-### memory-update
+### memory-timeline (Chronological Context)
 
-Save learnings or handoffs:
+See what happened before/after a specific observation:
 
 ```typescript
-memory -
-  update({
-    file: "project/gotchas",
-    content: "### New Gotcha\n\nDescription...",
-    mode: "append", // or "replace"
-  });
+memory_timeline({ anchor_id: 42, depth_before: 5, depth_after: 5 });
 ```
 
-### memory-search
+### memory-read (Files)
 
-Find past decisions, research, or handoffs:
+Load project files, handoffs, or templates:
 
 ```typescript
-memory - search({ query: "authentication" });
-memory - search({ query: "bugfix", type: "observations" });
-memory - search({ query: "session", type: "handoffs" });
+memory_read({ file: "project/commands" });
+memory_read({ file: "handoffs/2024-01-20-phase-1" });
+memory_read({ file: "research/auth-patterns" });
+```
+
+### memory-update (Files)
+
+Save to project files or handoffs:
+
+```typescript
+memory_update({
+  file: "project/gotchas",
+  content: "### New Gotcha\n\nDescription...",
+  mode: "append", // or "replace"
+});
 ```
 
 ## Observations
 
-Record important findings with structured metadata:
+Record structured findings to SQLite with FTS5 indexing:
 
 ```typescript
 observation({
   type: "decision", // decision, bugfix, feature, pattern, discovery, learning, warning
   title: "Use JWT auth",
-  content: "Decided to use JWT because...",
-  concepts: "auth, security",
-  files: "src/auth.ts",
-  bead_id: "bd-abc123",
+  narrative: "Decided to use JWT because it's stateless and scales well...",
+  facts: "stateless, scalable, industry standard", // Key facts (comma-separated)
+  concepts: "auth, jwt, security", // Keywords for search
+  confidence: "high", // high, medium, low
+  files_read: "src/auth.ts, src/middleware.ts", // Files consulted
+  files_modified: "src/auth.ts", // Files changed
+  bead_id: "bd-abc123", // Link to task (optional)
 });
 ```
 
@@ -99,9 +103,60 @@ observation({
 - Patterns worth reusing
 - Gotchas and warnings for future
 
+## Standard Project Files
+
+| File                      | Purpose                  | Update When                 |
+| ------------------------- | ------------------------ | --------------------------- |
+| `project/commands.md`     | Build/test/lint commands | Discovering new command     |
+| `project/conventions.md`  | Code patterns, style     | Learning team pattern       |
+| `project/gotchas.md`      | Footguns, warnings       | Hitting unexpected behavior |
+| `project/architecture.md` | Key modules, structure   | Mapping new area            |
+
+## Progressive Disclosure Pattern
+
+Memory search returns **compact results** to avoid context bloat. Follow this pattern:
+
+```typescript
+// 1. Search for relevant context
+memory_search({ query: "auth patterns" });
+
+// 2. Identify relevant observation IDs from compact index
+// 3. Fetch full details only for what you need
+memory_get({ ids: "42,45" });
+
+// 4. See chronological context if needed
+memory_timeline({ anchor_id: 42 });
+```
+
 ## Best Practices
 
-1. **Read before work** - Check relevant memory files at session start
-2. **Update during work** - Don't wait until end; persist incrementally
-3. **Be specific** - Include file paths, function names, concrete examples
-4. **Keep it actionable** - Future agents should know what to do with the info
+1. **Search before work** - Run `memory_search` at session start
+2. **Progressive disclosure** - Use search → get → timeline pattern
+3. **Record decisions** - Create observations for non-obvious choices
+4. **Be specific** - Include file paths, function names, concrete examples
+5. **Keep it actionable** - Future agents should know what to do with the info
+
+## Maintenance
+
+For long-term storage health:
+
+```typescript
+// Check current status
+memory_maintain({ operation: "status" });
+
+// Full maintenance (archive >90 days, checkpoint WAL, vacuum)
+memory_maintain({ operation: "full" });
+
+// Preview what would be archived
+memory_maintain({ operation: "archive", older_than_days: 60, dry_run: true });
+```
+
+**Automatic maintenance** runs at session end:
+
+- FTS5 index optimization
+- WAL checkpoint (if WAL > 1MB)
+
+**Manual maintenance** (run monthly or when storage grows):
+
+- `archive`: Move old observations to archive table
+- `vacuum`: Defragment and reclaim space

package/dist/template/.opencode/skill/tool-priority/SKILL.md

@@ -120,7 +120,7 @@ Task({
 | **codesearch**                  | Real implementation patterns | GitHub code examples    |
 | **grepsearch**                  | Cross-repo patterns          | grep.app search         |
 | **webfetch**                    | Specific URL content         | User-provided links     |
-| **oracle**                      | Second opinion               | Validate approach       |
+| **review (Task)**               | Second opinion               | Validate approach       |
 
 ## Workflow Pattern
 
@@ -251,7 +251,7 @@ RESEARCH:
   context7_resolve_library_id({ libraryName: "..." })
   context7_query_docs({ libraryId: "...", topic: "..." })
   websearch({ query: "..." })
-  oracle({ question: "..." })
+Task({ subagent_type: "review", description: "Second opinion", prompt: "Review the approach." })
 
 MEMORY:
   memory_search({ query: "..." })               → Find past learnings

package/dist/template/.opencode/tool/memory-get.ts

@@ -0,0 +1,143 @@
+import { tool } from "@opencode-ai/plugin";
+import {
+	type ObservationRow,
+	getObservationsByIds,
+} from "../plugin/lib/memory-db";
+
+const TYPE_ICONS: Record<string, string> = {
+	decision: "🎯",
+	bugfix: "🐛",
+	feature: "✨",
+	pattern: "🔄",
+	discovery: "💡",
+	learning: "📚",
+	warning: "⚠️",
+};
+
+const CONFIDENCE_ICONS: Record<string, string> = {
+	high: "🟢",
+	medium: "🟡",
+	low: "🔴",
+};
+
+function parseJsonArray(jsonStr: string | null): string[] {
+	if (!jsonStr) return [];
+	try {
+		return JSON.parse(jsonStr);
+	} catch {
+		return [];
+	}
+}
+
+function formatFullObservation(obs: ObservationRow): string {
+	const icon = TYPE_ICONS[obs.type] || "📝";
+	const confIcon = CONFIDENCE_ICONS[obs.confidence] || "🟢";
+	const date = obs.created_at.split("T")[0];
+
+	let output = `# ${icon} #${obs.id}: ${obs.title}\n\n`;
+
+	// Metadata
+	output += `**Type**: ${obs.type} | **Confidence**: ${confIcon} ${obs.confidence} | **Created**: ${date}\n\n`;
+
+	if (obs.subtitle) {
+		output += `*${obs.subtitle}*\n\n`;
+	}
+
+	// Concepts
+	const concepts = parseJsonArray(obs.concepts);
+	if (concepts.length > 0) {
+		output += `**Concepts**: ${concepts.join(", ")}\n\n`;
+	}
+
+	// Files
+	const filesRead = parseJsonArray(obs.files_read);
+	const filesModified = parseJsonArray(obs.files_modified);
+	if (filesRead.length > 0) {
+		output += `**Files Read**: ${filesRead.join(", ")}\n`;
+	}
+	if (filesModified.length > 0) {
+		output += `**Files Modified**: ${filesModified.join(", ")}\n`;
+	}
+	if (filesRead.length > 0 || filesModified.length > 0) {
+		output += "\n";
+	}
+
+	// Facts
+	const facts = parseJsonArray(obs.facts);
+	if (facts.length > 0) {
+		output += "## Key Facts\n\n";
+		for (const fact of facts) {
+			output += `- ${fact}\n`;
+		}
+		output += "\n";
+	}
+
+	// Narrative
+	if (obs.narrative) {
+		output += "## Content\n\n";
+		output += obs.narrative;
+		output += "\n\n";
+	}
+
+	// Relationships
+	if (obs.bead_id) {
+		output += `**Linked Bead**: ${obs.bead_id}\n`;
+	}
+	if (obs.supersedes) {
+		output += `**Supersedes**: #${obs.supersedes}\n`;
+	}
+	if (obs.superseded_by) {
+		output += `⚠️ **Superseded by**: #${obs.superseded_by}\n`;
+	}
+	if (obs.valid_until) {
+		output += `**Valid until**: ${obs.valid_until}\n`;
+	}
+	if (obs.markdown_file) {
+		output += `**Source file**: ${obs.markdown_file}\n`;
+	}
+
+	return output;
+}
+
+export default tool({
+	description: `Get full observation details by ID.
+	
+	Purpose:
+	- Progressive disclosure: fetch full details after identifying relevant observations via search
+	- Get complete narrative, facts, and metadata
+	- Supports multiple IDs for batch retrieval
+	
+	Example:
+	memory-get({ ids: "42" })           // Single observation
+	memory-get({ ids: "1,5,10" })       // Multiple observations`,
+	args: {
+		ids: tool.schema
+			.string()
+			.describe("Comma-separated observation IDs to retrieve"),
+	},
+	execute: async (args: { ids: string }) => {
+		const ids = args.ids
+			.split(",")
+			.map((id) => Number.parseInt(id.trim(), 10))
+			.filter((id) => !Number.isNaN(id));
+
+		if (ids.length === 0) {
+			return "No valid observation IDs provided.";
+		}
+
+		const observations = getObservationsByIds(ids);
+
+		if (observations.length === 0) {
+			return `No observations found for IDs: ${args.ids}`;
+		}
+
+		let output = `# Retrieved ${observations.length} Observation(s)\n\n`;
+
+		for (const obs of observations) {
+			output += formatFullObservation(obs);
+			output += "\n---\n\n";
+		}
+
+		return output;
+	},
+});