opencodekit 0.21.10 → 0.23.0

package/dist/template/.opencode/skill/context-condensation/SKILL.md

@@ -1,149 +0,0 @@
----
-name: context-condensation
-description: Use when context is approaching budget limits and you need to compress, OR when handing off to another session. Provides the explicit keep/drop rubric for what survives compression — preserve goals, progress, critical files, failing tests; drop exploration noise and resolved threads. Pairs with `/dcp compress` and `/handoff`. Adapted from OpenHands context-condensation, Manus context engineering, HumanLayer backpressure.
----
-
-# Context Condensation
-
-> Compression is not deletion — it is **selection of what survives**. The wrong selection makes the agent restart from zero. This skill defines what to keep.
-
-## When to Use
-
-- Context >100k tokens and growing
-- Phase boundary reached (research done, ready to implement)
-- Handing off to a new session via `/handoff`
-- A subagent returns large output you need to integrate
-- After `/dcp compress` ran but you still feel context drift
-
-## Core Principle: 4 Tiers of Survival
-
-Every conversation chunk falls into one of four tiers. Compress accordingly.
-
-| Tier | Content                                                  | Action                  |
-| ---- | -------------------------------------------------------- | ----------------------- |
-| 1    | Goal, constraints, user-stated requirements              | **Preserve verbatim**   |
-| 2    | Critical state — failing tests, current bug, open files  | **Preserve as summary** |
-| 3    | Decisions made, alternatives rejected, why               | **Preserve as 1-liner** |
-| 4    | Exploration noise — failed greps, dead ends, raw outputs | **Drop entirely**       |
-
-## Keep List (Always)
-
-Compress around these — never drop:
-
-- **The user's literal request.** Direct quote when short. Paraphrase only when long, and label as paraphrase.
-- **Active failures.** Current error message, failing test name + reason, open bug. Tells the next agent what's broken.
-- **Decisions + rationale.** "Chose JWT over sessions because [reason]." One line each. Future agents inherit the why.
-- **File paths currently being edited.** Exact paths, not "the auth file".
-- **Verification status.** Last typecheck/lint/test result with timestamp.
-- **Open questions for the user.** Questions awaiting human input.
-- **Constraints discovered mid-task.** "User can't add new deps", "DB is read-only in this env".
-
-## Drop List (Aggressive)
-
-Compress these to a single line or remove entirely:
-
-- **Resolved exploration.** Found the file? Drop the 5 greps that led there.
-- **Tool output noise.** Full directory listings, `ls` outputs, package install logs. Keep only the relevant filename.
-- **Verbose reasoning.** Your own multi-paragraph thinking that ended in one decision. Keep the decision.
-- **Acknowledgments.** "Got it", "I'll do that next" — pure social filler.
-- **Failed attempts that taught nothing.** If a wrong approach added no information, drop it. Keep failures that revealed a constraint.
-- **Sub-agent self-reports.** Keep the result + verification, drop the agent's narrative summary (Worker Distrust Protocol — don't trust the prose).
-- **Old plans you've since revised.** Keep only the current plan.
-
-## Failure Preservation Rule
-
-> **Useful failures stay. Useless failures go.**
-
-A failure is **useful** if it:
-
-- Revealed a constraint ("can't use `mv` on this filesystem")
-- Eliminated a hypothesis ("the bug is not in the parser")
-- Showed a trap that another agent would re-fall into
-
-A failure is **useless** if it:
-
-- Was a typo / fat-finger fixed immediately
-- Was a tool-call format error with no semantic content
-- Was an obvious dead end no agent would repeat
-
-**Manus rule** (from "Context Engineering for AI Agents: Lessons from Building Manus"): keep useful failures **in-context** as warnings. Don't compress to "encountered errors then succeeded" — that loses the warning.
-
-## Condensation Triggers (Beyond Token Count)
-
-Token count is one trigger. These are the others:
-
-| Trigger                               | Action                                          |
-| ------------------------------------- | ----------------------------------------------- |
-| Phase boundary (research → implement) | Compress all of research phase to summary       |
-| Subagent returns >2k tokens           | Compress immediately, keep result + evidence    |
-| Same question asked twice in session  | Indicates context drift — compress aggressively |
-| Plan revised                          | Drop old plan completely                        |
-| Conversation feels "lost"             | Compress; restart from goal + current state     |
-
-## The Handoff Variant
-
-When compressing for `/handoff` (different session, different agent will pick up), be **even more selective**:
-
-- Preserve everything in Keep List
-- Add a **`## Next Step`** with the literal next action
-- Add a **`## Don't Re-Discover`** with traps already mapped
-- Drop everything else
-
-Handoff format:
-
-```markdown
-## Goal
-
-[user's literal request]
-
-## Status
-
-- Done: [list of completed items with file:line]
-- In progress: [current task]
-- Blocked: [what's blocking, what was tried]
-
-## Critical State
-
-- Open files: [paths]
-- Last verification: [command + result + timestamp]
-- Active failures: [error / failing test]
-
-## Decisions Made
-
-- [one-liner] → [one-line rationale]
-
-## Don't Re-Discover
-
-- [trap 1]: [why]
-- [trap 2]: [why]
-
-## Next Step
-
-[literal next action — copy-pastable command or description]
-```
-
-## Anti-Patterns
-
-- **"Let me summarize what we did so far..."** in every response — you're re-summarizing instead of compressing once at boundaries
-- **Dropping the goal during compression** — the worst failure mode; the next agent has no anchor
-- **Keeping all failures** — context fills with noise, real signals get buried
-- **Lossy paraphrase of user request** — when in doubt, quote verbatim
-- **Compressing during active edits** — wait for atomic step to finish
-
-## Integration
-
-- **Before `/dcp compress`:** Use this rubric to decide what your `summary` field should contain
-- **In `/handoff`:** This skill defines the handoff format
-- **After subagent return:** Apply Drop List to the agent's narrative, keep result + verification only
-- **In long sessions:** Re-read your own context every ~30 messages and apply the rubric
-
-## Output
-
-When you condense, briefly state what survived and what dropped:
-
-```
-Compressed messages 12-34. Kept: goal, 3 decisions, current failure (auth.ts:42 null deref).
-Dropped: 5 file searches, 2 abandoned approaches, dir listings.
-```
-
-This makes the compression auditable. The user (or next agent) can challenge what got cut.

package/dist/template/.opencode/skill/context-initialization/SKILL.md

@@ -1,69 +0,0 @@
----
-name: context-initialization
-description: Initialize project context files from templates. Creates on-demand planning files (roadmap.md, state.md) and updates auto-injected project.md.
-version: 2.0.0
-tags: [context, workflow]
-dependencies: []
----
-
-# Context Initialization
-
-## When to Use
-
-- When initializing project context files (project.md, roadmap.md, state.md) from templates.
-- project.md is auto-injected into every prompt; roadmap.md and state.md are on-demand.
-
-## When NOT to Use
-
-- When context files already exist and only need minor manual edits.
-
-## Process
-
-### 1. Verify Templates
-
-```bash
-srcwalk files "*.md" --scope .opencode/memory/_templates
-# Required templates: project.md, roadmap.md, state.md
-```
-
-Stop if missing.
-
-### 2. Gather Input
-
-Ask 5 questions:
-
-1. Project vision
-2. Success criteria
-3. Target users
-4. Phases
-5. Current phase
-
-Skip if `--skip-questions` flag set.
-
-### 3. Create Files
-
-**project.md** (auto-injected — keep concise)
-
-- Read template via `Read({ filePath: ".opencode/memory/_templates/project.md" })`
-- Fill with answers
-- Write via `memory-update({ file: "project/project", content: ..., mode: "replace" })`
-
-**roadmap.md** (on-demand — access via `memory-read({ file: "project/roadmap" })`)
-
-- Read template
-- Parse phases into table
-- Write via `memory-update({ file: "project/roadmap", content: ..., mode: "replace" })`
-
-**state.md** (on-demand — access via `memory-read({ file: "project/state" })`)
-
-- Read template
-- Set initial state
-- Write via `memory-update({ file: "project/state", content: ..., mode: "replace" })`
-
-### 4. Verify
-
-```bash
-srcwalk files "*.md" --scope .opencode/memory/project
-```
-
-Report created files with their injection status (auto-injected vs on-demand).

package/dist/template/.opencode/skill/context-management/SKILL.md

@@ -1,390 +0,0 @@
----
-name: context-management
-description: Unified protocol for context health and session lifecycle management using DCP tools, thresholds, handoff, resume workflows, and post-compaction restoration.
-version: 3.0.0
-tags: [context, workflow, session]
-dependencies: []
----
-
-# Context Management
-
-> Unified protocol for context health across start, active execution, compression, restoration, handoff, and resume.
-
-Use this skill to keep context high-signal while preserving edit safety and execution continuity.
-
-## When to Use
-
-- Context is growing and signal quality is dropping
-- A phase is complete and should be compressed
-- You are preparing `/handoff` or resuming prior work
-- You need deterministic restoration after compaction
-- You need reusable summary templates for exploration/implementation/debugging
-
-## Core Principle
-
-Prefer **phase-level context hygiene** over emergency cleanup.
-
-```text
-compress > sweep > handoff
-```
-
-- **compress**: shrink closed chapters while preserving decisions
-- **sweep**: remove stale/noisy residue from closed chapters
-- **handoff**: reset in a fresh session when compression is insufficient
-
-## DCP Command Usage
-
-### `/dcp context`
-
-Run at session start and major boundaries to detect pressure early.
-
-### `/dcp compress`
-
-Primary action for completed chapters.
-
-Use when:
-
-- exploration has stable conclusions
-- implementation wave is complete and verified
-- review output has been synthesized
-
-### `/dcp sweep`
-
-Secondary cleanup after chapter closure.
-
-Sweep candidates:
-
-- wrong-target searches
-- superseded logs
-- duplicate tool output
-- dead-end exploration replaced by synthesis
-- large terminal dumps no longer needed
-
-Do not sweep active material needed for immediate edits.
-
-## Session Lifecycle Protocol
-
-### 1) Start Session
-
-1. Load task + essential policy docs only
-2. Run `/dcp context`
-3. Rehydrate prior state only if needed:
-   - `find_sessions({ query })`
-   - `read_session({ session_id, focus })`
-   - `memory-search({ query })` / `memory-read({ file })`
-4. Verify git position before edits
-
-### 2) During Active Work
-
-- Keep active file outputs readable until edit + verification finish
-- Reclassify context at boundaries: active vs closed
-- Compress closed chapters before opening a new major chapter
-- Sweep only after synthesis exists
-
-### 3) Pre-Handoff / Closeout
-
-1. Compress closed phases
-2. Sweep stale/noisy residue
-3. Persist decisions/learnings to memory
-4. Write concise handoff (changed, pending, risks)
-
-### 4) Resume Session
-
-1. Rehydrate only relevant context
-2. Validate assumptions against files + git state
-3. Continue with fresh budget and explicit priorities
-
-## Context Budget Thresholds
-
-| Threshold | Interpretation  | Required Action                    |
-| --------- | --------------- | ---------------------------------- |
-| <50k      | Healthy start   | Keep inputs minimal                |
-| 50k-100k  | Moderate growth | Compress completed phases          |
-| >100k     | High pressure   | Aggressive compress + `/dcp sweep` |
-| >150k     | Near capacity   | Handoff + resume fresh session     |
-
-Guardrails: ~70% consolidate closed exploration, ~85% schedule handoff, ~95% immediate cleanup/restart.
-
-## Phase Boundary Triggers
-
-Compress at these boundaries:
-
-- Research complete -> compress exploration/search output
-- Implementation wave complete -> compress read/edit/test cycle output
-- Review complete -> compress raw reviewer output; keep synthesis
-- Pre-handoff -> compress non-essential context since last checkpoint
-
-Rule: **Closed phases should not remain uncompressed for long.**
-
-## Compaction Decision Tree
-
-Use this before each cleanup action.
-
-```text
-Is context pressure increasing materially?
-├── NO
-│   └── Continue work; reassess at next phase boundary
-└── YES
-    ├── Is there a completed phase with stable conclusions?
-    │   ├── YES -> /dcp compress completed range
-    │   └── NO
-    │       ├── Is growth mostly stale/noisy closed-phase output?
-    │       │   ├── YES -> /dcp sweep
-    │       │   └── NO
-    │       │       ├── Is most remaining context still active/relevant?
-    │       │       │   ├── YES -> Prepare handoff + resume fresh session
-    │       │       │   └── NO -> Reclassify content, then compress/sweep
-    │       └── If uncertain, preserve active content until closure
-```
-
-## Custom Summarization Templates
-
-Use these templates to keep summaries dense and recoverable.
-
-### A) Code Exploration Template
-
-```markdown
-## Exploration Summary: [Component/Module]
-
-### Objective
-
-- [What was investigated]
-
-### Architecture Map
-
-- Entry points: `path/to/entry.ts`
-- Core modules: `A`, `B`, `C`
-- Data flow: [input -> transform -> output]
-- Dependencies/services: [list]
-
-### Verified Findings
-
-- [Finding with evidence]
-- [Finding with evidence]
-- [Finding with evidence]
-
-### Constraints
-
-- [Technical/policy/runtime constraints]
-
-### Decisions
-
-- [Decision] -> [Rationale]
-- [Decision] -> [Rationale]
-
-### Next Step
-
-- [Immediate next action]
-```
-
-### B) Implementation Template
-
-```markdown
-## Implementation Summary: [Feature/Fix]
-
-### Scope
-
-- [What this wave covered]
-
-### Completed
-
-- [x] `path/to/file.ts` -> [change]
-- [x] `path/to/file.test.ts` -> [coverage]
-- [x] [other completed work]
-
-### Verification Evidence
-
-- Typecheck: [command + result]
-- Lint: [command + result]
-- Tests: [command + result]
-
-### Remaining
-
-- [ ] [pending item]
-- [ ] [pending item]
-
-### Key Decisions
-
-- [Decision + reason]
-- [Decision + reason]
-
-### Resume Anchor
-
-- Resume from: `path/to/file.ts` [function/region]
-```
-
-### C) Debugging Template
-
-```markdown
-## Debug Summary: [Issue]
-
-### Symptoms
-
-- Error: [exact error]
-- Trigger: [request/action]
-- Location: `path:line`
-
-### Root Cause
-
-- [causal chain with evidence]
-
-### Fix Applied
-
-- `path/to/file.ts` -> [exact fix]
-- `path/to/test.ts` -> [new/updated coverage]
-
-### Verification
-
-- [test command + result]
-- [manual check + result]
-
-### Next Step
-
-- [if unresolved, next investigation/fix]
-```
-
-## DCP Plugin Integration
-
-This project uses `@tarquinen/opencode-dcp` via `experimental.chat.system.transform`.
-
-### DCP Responsibilities (Always On)
-
-- context budget monitoring + threshold cues
-- `/dcp` command surface (`context`, `compress`, `sweep`, `stats`)
-- prunable-tools guidance + token-aware nudges
-- critical-limit warnings
-
-### Context-Management Responsibilities (This Skill)
-
-- timing policy for compress/sweep/handoff
-- summary quality and template selection
-- post-compaction restoration protocol
-- cross-session rehydration sequence
-
-### Division of Responsibility
-
-- **DCP plugin**: measures/surfaces pressure, exposes cleanup commands
-- **context-management skill**: decides when to apply commands and how to preserve continuity
-
-### Custom Prompt Overrides
-
-Custom DCP prompts are enabled (`experimental.customPrompts: true`).
-
-Override precedence:
-
-1. `.opencode/dcp-prompts/overrides/` (project)
-2. config directory overrides
-3. `~/.config/opencode/dcp-prompts/overrides/` (global)
-
-Key file: `compress-message.md` (structured compression schema). Recommended blocks: Primary Request, Key Technical Concepts, Files/Code, Errors/Fixes, Problem Solving, User Messages, Pending Tasks, Current Work, Next Step.
-
-## Post-Compaction Restoration Protocol (Critical)
-
-After any compaction (server-side or `/dcp compress`), execute all 5 steps before editing.
-
-### Step 1 — Re-read Active Files (max 5)
-
-Re-read files active before compaction.
-
-- prioritize most recent edits first
-- cap at 5 files
-- use targeted reads (`offset`/`limit`) for precision
-
-Example:
-
-```text
-read({ filePath: "src/auth.ts", offset: 30, limit: 80 })
-```
-
-Why: restores exact local code context and satisfies read-before-edit safety requirements.
-
-### Step 2 — Restore Active Skills
-
-Reload any skills active before compaction.
-
-```typescript
-skill({ name: "<active-skill>" });
-```
-
-Why: skill instructions are prompt-injected and may be dropped by compaction.
-
-### Step 3 — Reconcile Todo State
-
-Rebuild exact task status:
-
-- what was `in_progress`
-- what remains `pending`
-- what is `completed`
-
-Why: prevents duplicate work and missed subtasks.
-
-### Step 4 — Verify Git Position
-
-```bash
-git branch --show-current
-git status --short
-```
-
-Why: confirms branch correctness and re-anchors uncommitted file state.
-
-### Step 5 — Scan Memory / Session Artifacts
-
-If compaction was heavy, recover nuance using:
-
-- `memory-search({ query, limit: 3 })`
-- `memory-read({ file })`
-- `find_sessions({ query, limit })`
-- `read_session({ session_id, focus })`
-
-Why: restores rationale/constraints often missing from short summaries.
-
-### Restoration Exit Criteria
-
-Do not resume edits until active targets are re-read, required skills are reloaded, todo state is reconciled, git position is confirmed, and critical rationale is recovered when needed.
-
-## Context Transfer Sources (Cross-Session)
-
-Use in priority order:
-
-1. Memory artifacts (`memory-search`, `memory-read`, observations)
-2. Session history (`find_sessions`, `read_session`)
-3. Task tracker state (`br show <id>`)
-4. Git evidence (`git diff`, `git log`, test output)
-
-Carry forward decisions, constraints, and next actions — not transcript bulk.
-
-## Anti-Patterns
-
-| Anti-Pattern                          | Why It Hurts                           | Correct Pattern                                |
-| ------------------------------------- | -------------------------------------- | ---------------------------------------------- |
-| Compressing active edit context       | Loses exact data needed for safe edits | Keep active outputs until edit+verify complete |
-| Sweeping still-live content           | Causes rework and precision loss       | Sweep only stale/noisy closed-phase outputs    |
-| Leaving closed phases uncompressed    | Context bloat degrades later turns     | Compress at each phase boundary                |
-| Handoff without memory persistence    | Next session loses rationale           | Persist decisions before handoff               |
-| Skipping restoration after compaction | Edit failures, skill drift, task drift | Run 5-step restoration before resuming         |
-
-## Verification
-
-Before claiming context cleanup complete, verify:
-
-- active edit targets are still readable
-- closed chapters are compressed or intentionally retained
-- no critical decision exists only in transient output
-- restoration protocol completed after compaction
-- handoff includes next actions and blockers
-
-## Quick Playbook
-
-```text
-1) /dcp context
-2) classify context: active vs closed
-3) /dcp compress on closed chapters
-4) /dcp sweep stale/noisy closed outputs
-5) if compaction happened: run 5-step restoration
-6) persist key decisions to memory
-7) handoff/resume with focused rehydration
-```
-
-## See Also
-
-- `memory-system`