opencodekit 0.21.10 → 0.22.0

package/dist/template/.opencode/command/compound.md

@@ -1,240 +0,0 @@
----
-description: Extract and persist learnings from completed work into institutional memory
-argument-hint: "[bead-id]"
-agent: build
----
-
-# Compound: $ARGUMENTS
-
-Capture what was learned. This is the flywheel step — each cycle makes the next cycle faster.
-
-> **Workflow:** `/plan` → `/ship` → **`/compound`** → `/pr`
->
-> Run after every completed task, review, or PR merge. The value compounds over time.
-
-## Load Skills
-
-```typescript
-skill({ name: "memory-system" });
-skill({ name: "verification-before-completion" });
-```
-
-## What This Does
-
-Extracts learnings from the just-completed work and stores them as structured observations in memory,
-so future Plan and Ship cycles start with institutional knowledge instead of blank slates.
-
-## Phase 1: Gather Evidence
-
-```bash
-# Get what changed (falls back gracefully if no remote)
-git diff origin/main..HEAD --stat 2>/dev/null || git diff HEAD~5..HEAD --stat
-git log origin/main..HEAD --oneline 2>/dev/null || git log --oneline -10
-
-# Get review comments if any
-br comments list $ARGUMENTS 2>/dev/null || echo "No bead"
-
-# Get bead context if provided
-br show $ARGUMENTS 2>/dev/null || echo "No bead specified"
-```
-
-Collect from all available sources:
-
-- Git diff (what files changed, what patterns were used)
-- Bead comments (review findings, decisions made)
-- Current session context (what was discovered, what was hard)
-- Any error messages that were solved
-
-## Phase 2: Classify Learnings
-
-For each finding, assign a type:
-
-| Type        | When to Use                                                | Example                                         |
-| ----------- | ---------------------------------------------------------- | ----------------------------------------------- |
-| `pattern`   | A reusable approach confirmed to work in this codebase     | "Always use X pattern for Y type of component"  |
-| `bugfix`    | A non-obvious bug and its root cause                       | "Bun doesn't support X, use Y instead"          |
-| `decision`  | An architectural or design choice with rationale           | "Chose JWT over sessions because..."            |
-| `warning`   | A footgun, constraint, or thing that looks wrong but isn't | "Don't modify dist/ directly, build overwrites" |
-| `discovery` | A non-obvious fact about the codebase or its dependencies  | "Build copies .opencode/ to dist/template/"     |
-| `warning`   | Something that will break if not followed                  | "Always run lint:fix before commit"             |
-
-**Quality bar:** Only record learnings that would save future-you 15+ minutes.
-Skip obvious things. Skip things already in AGENTS.md.
-
-## Phase 3: Store Observations
-
-For each learning worth keeping, create an observation:
-
-```typescript
-observation({
-  type: "pattern", // or bugfix, decision, discovery, warning, learning
-  title: "[Concise, searchable title — what someone would search for]",
-  narrative: "[What happened, why it matters, how to apply it]",
-  facts: "[comma, separated, key, facts]",
-  concepts: "[searchable, keywords, for, future, retrieval]",
-  files_modified: "[relevant/file.ts if applicable]",
-  confidence: "high", // high=verified, medium=likely, low=speculative
-  // ByteRover-inspired quality fields:
-  subtitle: "[One-line semantic summary — WHY this matters for future work]",
-});
-```
-
-**Minimum viable:** title + narrative. Everything else is bonus.
-
-**Quality enrichment:** Add `subtitle` (WHY it matters) for high-impact observations. Skip for routine findings.
-
-## Phase 4: Structural Loss Prevention
-
-When superseding an older observation, prevent accidental knowledge loss.
-
-**Trigger:** Only runs when `supersedes: "ID"` is set on a new observation.
-
-### Step 1: Read the old observation
-
-```typescript
-const old = memory_get({ ids: "<superseded-id>" });
-```
-
-### Step 2: Detect structural loss
-
-Compare the new observation against the old one:
-
-| Field            | Loss Detection                                                  |
-| ---------------- | --------------------------------------------------------------- |
-| `facts`          | Old facts not present in new facts (comma-separated comparison) |
-| `concepts`       | Old concepts not present in new concepts                        |
-| `narrative`      | New narrative significantly shorter than old (< 50% length)     |
-| `files_modified` | Old file paths not present in new list                          |
-
-### Step 3: Auto-merge if loss detected
-
-- **Array fields** (facts, concepts): Union merge — keep all old items, add new items, deduplicate
-- **Scalar fields** (narrative): If new is shorter, append `\n\n[Preserved from superseded observation #ID:]\n` + old narrative section
-- **File paths**: Union merge all paths
-
-### Step 4: Flag for review if high-impact
-
-If the old observation had `confidence: "high"` and the new one has `confidence: "medium"` or `confidence: "low"`, flag with a warning:
-
-> ⚠️ Confidence downgrade detected: superseding a high-confidence observation (#ID) with lower confidence. Verify this is intentional.
-
-**Principle:** Knowledge should accumulate, not be replaced. Merging is safer than overwriting.
-
-## Phase 5: Check AGENTS.md / Skill Updates
-
-Ask: does this learning belong as a permanent rule?
-
-If YES (it's a codebase-level constraint everyone must follow):
-
-- Suggest updating `.opencode/memory/project/gotchas.md`
-- Or the relevant skill file if it's procedure-level
-
-If MAYBE (it's a pattern, not a rule):
-
-- The observation is sufficient
-- Don't pollute AGENTS.md with every finding
-
-**Rule:** AGENTS.md changes require user confirmation. Observations are automatic.
-
-## Phase 6: Update Living Documentation
-
-Check if the shipped work changed architecture, APIs, conventions, or tech stack. If so, update the relevant project docs.
-
-**Check each:**
-
-| Doc                   | Update When                                               | What to Update                                      |
-| --------------------- | --------------------------------------------------------- | --------------------------------------------------- |
-| `tech-stack.md`       | New dependency added, build tool changed, runtime updated | Dependencies list, build tools, constraints         |
-| `project.md`          | Architecture changed, new key files, success criteria met | Architecture section, key files table, phase status |
-| `gotchas.md`          | New footgun discovered, constraint found                  | Add the gotcha with context                         |
-| `AGENTS.md` (project) | New convention established, boundary rule needed          | Boundaries, gotchas, code example sections          |
-
-```typescript
-// Check what changed
-// If tech stack changed:
-memory_update({ file: "project/tech-stack", content: "...", mode: "append" });
-// If new gotcha:
-memory_update({ file: "project/gotchas", content: "...", mode: "append" });
-```
-
-**Rule:** Only update docs when the change is structural (new pattern, new dep, new constraint). Don't update for routine bug fixes or small features. Ask user before modifying `AGENTS.md`.
-
-## Phase 7: Search for Related Past Observations
-
-```typescript
-// Check if this updates or supersedes an older observation
-memory_search({ query: "[key concept from the finding]", limit: 3 });
-```
-
-If a newer finding contradicts or updates an older one, note it:
-
-```typescript
-observation({
-  type: "decision",
-  title: "...",
-  narrative: "...",
-  supersedes: "42", // ID of the older observation
-});
-```
-
-## Phase 8: Output Summary
-
-Present extracted learnings for user review before finalizing:
-
-```
-## Compound Review
-
-**Work reviewed:** [brief description]
-**Learnings extracted:** [N] observations
-
-| # | Type | Title | Impact | Action |
-|---|------|-------|--------|--------|
-| 1 | pattern | ... | high | ✅ Store |
-| 2 | warning | ... | medium | ✅ Store |
-| 3 | bugfix | ... | low | ⏭️ Skip (routine) |
-```
-
-```typescript
-question({
-  questions: [
-    {
-      header: "Approve Learnings",
-      question: "Review extracted learnings. Store all approved observations?",
-      options: [
-        { label: "Store all (Recommended)", description: "Persist all marked ✅" },
-        { label: "Let me adjust", description: "I'll modify before storing" },
-        { label: "Skip compound", description: "Nothing worth persisting" },
-      ],
-    },
-  ],
-});
-```
-
-**After approval:** Store observations and report final summary:
-
-```
-## Compound Summary
-
-**Observations stored:** [N]
-**Superseded:** [N] older observations updated
-**AGENTS.md updates suggested:** [yes/no - describe if yes]
-**Next recommended:** /pr (or /plan <next-bead-id>)
-```
-
-## When Nothing to Compound
-
-If the work was trivial (a config change, 1-line fix with no surprises):
-
-> "Nothing worth compounding. Work was straightforward — no non-obvious patterns, bugs, or decisions encountered."
-
-Don't force observations. Quality over quantity.
-
-## Related Commands
-
-| Need            | Command            |
-| --------------- | ------------------ |
-| Full chain      | `/lfg`             |
-| Review codebase | `/review-codebase` |
-| Ship the work   | `/ship`            |
-| Curate memory   | `/curate`          |
-| Create PR       | `/pr`              |

package/dist/template/.opencode/command/curate.md

@@ -1,299 +0,0 @@
----
-description: Organize, deduplicate, and curate knowledge in project memory
-argument-hint: "[--scope recent|all] [--auto-merge]"
-agent: build
----
-
-# Curate: $ARGUMENTS
-
-Organize accumulated knowledge. Surface conflicts, merge duplicates, archive stale observations.
-
-> **Workflow:** `/ship` → `/compound` → **`/curate`** → `/pr`
->
-> Run periodically (weekly or after major work) to keep memory sharp. Inspired by ByteRover's structured curation pipeline.
-
-## Load Skills
-
-```typescript
-skill({ name: "memory-system" });
-skill({ name: "verification-before-completion" });
-```
-
-## Parse Arguments
-
-| Argument       | Default  | Description                                      |
-| -------------- | -------- | ------------------------------------------------ |
-| `--scope`      | `recent` | `recent` = last 30 days, `all` = entire memory   |
-| `--auto-merge` | false    | Auto-merge exact duplicates without confirmation |
-
-## Phase 1: Inventory
-
-Take stock of current memory state:
-
-```typescript
-memory_admin({ operation: "status" });
-memory_admin({ operation: "capture-stats" });
-```
-
-Report:
-
-```
-## Memory Inventory
-
-| Metric | Count |
-|--------|-------|
-| Total observations | [N] |
-| Recent (30 days) | [N] |
-| By type | pattern: N, decision: N, bugfix: N, ... |
-| Confidence distribution | high: N, medium: N, low: N |
-```
-
-## Phase 2: Domain Detection
-
-Analyze observations to extract semantic domains — groups of related knowledge.
-
-```typescript
-// Get memory status for inventory
-memory_admin({ operation: "status" });
-
-// Search by common concept categories to build domain map
-const domains = [];
-for (const concept of ["build", "test", "memory", "git", "agent", "auth", "ui", "config"]) {
-  const results = memory_search({ query: concept, limit: 20 });
-  // Group results by concept affinity
-}
-```
-
-Categorize observations into domains based on their `concepts` and `title` fields:
-
-| Domain         | Example Concepts                   | Observation Count |
-| -------------- | ---------------------------------- | ----------------- |
-| `build_system` | build, tsdown, rsync, dist         | [N]               |
-| `testing`      | vitest, test, TDD, coverage        | [N]               |
-| `memory`       | observation, FTS5, sqlite, handoff | [N]               |
-| `git_workflow` | commit, branch, push, PR           | [N]               |
-| `agent_system` | subagent, delegation, skills       | [N]               |
-
-**Domain naming rules:**
-
-- snake_case, 1-3 words
-- Semantically meaningful (not just "misc")
-- Maximum 10 domains (merge small groups)
-
-## Phase 3: Conflict & Duplicate Detection
-
-### 3a. Exact Duplicates
-
-```typescript
-memory_admin({ operation: "lint" });
-```
-
-Flag observations with identical or near-identical titles and narratives. Present for merge:
-
-```
-### Duplicates Found
-
-| Obs A | Obs B | Similarity | Recommended Action |
-|-------|-------|------------|-------------------|
-| #12 "Use JWT for auth" | #45 "JWT chosen for auth" | 95% title match | MERGE → keep #45 (newer) |
-| #8 "Build copies .opencode/" | #33 "Build copies .opencode/" | 100% title match | MERGE → keep #33 (newer) |
-```
-
-### 3b. Contradictions
-
-Search for observations where:
-
-- Same concepts but different decisions
-- Same file paths but conflicting patterns
-- Confidence downgrade without supersedes link
-
-```
-### Contradictions Found
-
-| Obs A | Obs B | Conflict | Recommended Action |
-|-------|-------|----------|-------------------|
-| #5 "Always use X pattern" | #29 "Avoid X pattern" | Opposite recommendations | RESOLVE — ask user which is current |
-```
-
-### 3c. Stale Observations
-
-Flag observations where:
-
-- Referenced files no longer exist
-- Referenced patterns no longer appear in codebase
-- Over 90 days old with no related recent activity
-
-```
-### Stale Observations
-
-| Obs | Age | Reason | Recommended Action |
-|-----|-----|--------|-------------------|
-| #3 "src/old-file.ts pattern" | 120 days | File deleted | ARCHIVE |
-| #7 "Use moment.js for dates" | 95 days | Dependency removed | ARCHIVE |
-```
-
-## Phase 4: Present Curation Plan
-
-Compile all findings into a review table:
-
-```
-## Curation Plan
-
-### Actions Required
-
-| # | Observation | Action | Reason |
-|---|------------|--------|--------|
-| 1 | #12 + #45 | MERGE | Duplicate — keep newer |
-| 2 | #5 vs #29 | RESOLVE | Contradicting patterns |
-| 3 | #3 | ARCHIVE | Referenced file deleted |
-| 4 | #7 | ARCHIVE | Dependency removed |
-| 5 | #18 | UPDATE | Low confidence → verify |
-```
-
-```typescript
-question({
-  questions: [
-    {
-      header: "Curation Plan",
-      question: "Review the curation plan. Proceed with all actions?",
-      options: [
-        { label: "Execute all (Recommended)", description: "Apply all actions above" },
-        { label: "Let me cherry-pick", description: "I'll approve individually" },
-        { label: "Skip curation", description: "No changes to memory" },
-      ],
-    },
-  ],
-});
-```
-
-## Phase 5: Execute Curation
-
-For each approved action:
-
-### MERGE (duplicates)
-
-```typescript
-// Read both observations
-const older = memory_get({ ids: "<older-id>" });
-const newer = memory_get({ ids: "<newer-id>" });
-
-// Union-merge: combine comma-separated lists, deduplicate (case-insensitive), existing items first
-// Example: older.facts="auth, jwt" + newer.facts="jwt, session" → "auth, jwt, session"
-
-// Create merged observation (newer as base, merge fields from older)
-observation({
-  type: newer.type,
-  title: newer.title,
-  narrative: newer.narrative,
-  // Manually combine comma-separated fields: keep all unique items from both
-  facts: "[combined unique facts from older + newer]",
-  concepts: "[combined unique concepts from older + newer]",
-  files_modified: "[combined unique file paths from older + newer]",
-  confidence: newer.confidence, // Newer confidence wins
-  supersedes: "<older-id>",
-  subtitle: "Merged from #<older-id> + #<newer-id>",
-});
-```
-
-**Union merge rule:** Combine comma-separated lists, deduplicate (case-insensitive), existing items first.
-
-### RESOLVE (contradictions)
-
-Present the conflicting observations side-by-side:
-
-```
-### Contradiction: #5 vs #29
-
-**#5 (older, high confidence):**
-> Always use X pattern for Y components
-
-**#29 (newer, medium confidence):**
-> Avoid X pattern — causes Z issues
-
-Which is the current truth?
-```
-
-```typescript
-question({
-  questions: [
-    {
-      header: "Resolve Conflict",
-      question: "Which observation reflects the current codebase reality?",
-      options: [
-        { label: "#5 (older) is correct", description: "Archive #29, keep #5" },
-        { label: "#29 (newer) is correct", description: "Supersede #5 with #29" },
-        { label: "Both partially correct", description: "I'll write a reconciled version" },
-      ],
-    },
-  ],
-});
-```
-
-### ARCHIVE (stale)
-
-```typescript
-// Verify staleness by checking codebase
-// If file doesn't exist or pattern not found:
-observation({
-  type: "warning",
-  title: "Archived: [original title]",
-  narrative: "Archived during curation — [reason]. Original observation #<id>.",
-  supersedes: "<stale-id>",
-  confidence: "low",
-});
-```
-
-### UPDATE (low confidence → verify)
-
-```typescript
-// Search codebase for evidence
-// If evidence found → upgrade confidence
-// If evidence not found → archive
-```
-
-## Phase 6: Compile Knowledge Index
-
-After curation, regenerate the knowledge index:
-
-```typescript
-memory_admin({ operation: "compile" });
-memory_admin({ operation: "index" });
-```
-
-## Phase 7: Report
-
-```
-## Curation Summary
-
-**Scope:** [recent / all]
-**Observations reviewed:** [N]
-**Domains identified:** [N]
-
-| Action | Count | Details |
-|--------|-------|---------|
-| Merged | [N] | [list merged pairs] |
-| Resolved | [N] | [list resolved conflicts] |
-| Archived | [N] | [list archived observations] |
-| Updated | [N] | [list confidence changes] |
-| No change | [N] | |
-
-**Memory health:** [Healthy / Needs attention: describe]
-**Next recommended:** /pr or continue work
-```
-
-## When Nothing to Curate
-
-If all observations are clean, well-organized, and non-conflicting:
-
-> "Memory is clean. No duplicates, contradictions, or stale observations found. [N] observations across [M] domains."
-
-Don't force curation. Quality memory means less curation needed.
-
-## Related Commands
-
-| Need                    | Command                        |
-| ----------------------- | ------------------------------ |
-| Extract learnings first | `/compound`                    |
-| Full chain              | `/lfg`                         |
-| Check memory health     | `/health`                      |
-| Search memory           | Use `memory-search()` directly |

package/dist/template/.opencode/command/handoff.md

@@ -1,149 +0,0 @@
----
-description: Save progress and context for next session
-argument-hint: "<bead-id> [instructions]"
-agent: build
----
-
-# Handoff: $ARGUMENTS
-
-Save state so the next session can pick up cleanly.
-
-> **Workflow:** Run this when pausing work. Resume with `/resume $ARGUMENTS`.
-
-## Parse Arguments
-
-| Argument         | Default  | Description                        |
-| ---------------- | -------- | ---------------------------------- |
-| `<bead-id>`      | required | The bead to hand off               |
-| `[instructions]` | none     | Extra context for the next session |
-
-## Load Skills
-
-```typescript
-skill({ name: "beads" });
-skill({ name: "memory-system" });
-```
-
----
-
-## Phase 1: Gather State (Parallel)
-
-```bash
-br show $ARGUMENTS
-git status --porcelain
-git branch --show-current
-git rev-parse --short HEAD
-Read `.beads/artifacts/$ARGUMENTS/` to check existing artifacts.
-```
-
----
-
-## Phase 2: Handle Uncommitted Changes
-
-If `git status` shows uncommitted changes, ask the user:
-
-```typescript
-question({
-  questions: [
-    {
-      header: "Uncommitted work",
-      question: "You have uncommitted changes. What should we do?",
-      options: [
-        { label: "Commit as WIP (Recommended)", description: "git commit -m 'WIP: $ARGUMENTS'" },
-        { label: "Leave uncommitted", description: "Skip commit, just write handoff" },
-      ],
-    },
-  ],
-});
-```
-
-If user chooses commit:
-
-```bash
-git add <specific-files-you-modified>
-git commit -m "WIP: $ARGUMENTS - [brief description of where you stopped]"
-```
-
-**Never use `git add -A` or `git add .`** — stage only the files you modified.
-
----
-
-## Phase 3: Write Handoff
-
-Write the handoff to the memory system:
-
-```typescript
-memory_update({
-  file: "handoffs/$ARGUMENTS",
-  content: `# Handoff: $ARGUMENTS
-
-**Date:** [timestamp]
-**Branch:** [from git branch]
-**Commit:** [from git rev-parse]
-
-## Done
-- [completed work]
-
-## In Progress
-- [current step] — stopped because [reason]
-
-## Remaining
-- [next steps]
-
-## Files Touched
-- \`path/to/file.ts\` — [what changed]
-
-## Decisions
-- [decision]: [why]
-
-## Blockers
-[any blockers, or "None"]
-
-## Resume Instructions
-1. [first thing to do]
-2. [second thing to do]
-
-Resume with: \`/resume $ARGUMENTS\`
-`,
-  mode: "replace",
-});
-```
-
----
-
-## Phase 4: Record Learnings (If Any)
-
-If you discovered patterns or gotchas worth remembering:
-
-```typescript
-observation({
-  type: "learning",
-  title: "[concise, searchable title]",
-  narrative: "[what you learned — specific and actionable]",
-  bead_id: "$ARGUMENTS",
-  concepts: "[keywords for search]",
-});
-```
-
----
-
-## Phase 5: Sync
-
-```bash
-br sync --flush-only
-```
-
----
-
-## Output
-
-```
-Handoff: $ARGUMENTS
-━━━━━━━━━━━━━━━━━━━
-
-Branch: [branch]
-Commit: [hash]
-Saved:  handoffs/$ARGUMENTS (memory system)
-
-Next session: /resume $ARGUMENTS
-```