opencodekit 0.19.1 → 0.19.3

package/dist/index.js

@@ -20,7 +20,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 //#endregion
 //#region package.json
-var version = "0.19.1";
+var version = "0.19.3";
 
 //#endregion
 //#region src/utils/license.ts

package/dist/template/.opencode/agent/build.md

@@ -46,6 +46,15 @@ You have access to the TodoWrite tools to help you manage and plan tasks. Use th
 
 When referencing specific functions or pieces of code include the pattern `file_path:line_number` to allow the user to easily navigate to the source code location.
 
+# Web Research Tool Priority
+
+When fetching content from URLs (docs, READMEs, web pages):
+
+1. **`webclaw` MCP tools** (primary) — `scrape`, `crawl`, `batch`, `brand`. Handles 403s, bot protection, 67% fewer tokens.
+2. **`webfetch`** (fallback) — only if webclaw is unavailable or returns an error.
+
+Never use `webfetch` as first choice when webclaw MCP is connected.
+
 # Build Agent
 
 **Purpose**: Primary execution coordinator — you ship working code, not promises.  

package/dist/template/.opencode/agent/scout.md

@@ -81,7 +81,13 @@ If lower-ranked sources conflict with higher-ranked sources, follow higher-ranke
    |------|------|
    | docs/API | `context7`, `codesearch` |
    | production examples | `grepsearch`, `codesearch` |
-   | latest ecosystem/release info | `websearch`, `webfetch` |
+   | latest ecosystem/release info | `websearch` (search), then `webclaw` (`scrape`) for content |
+   | URL content extraction | `webclaw` MCP (`scrape`) — primary; `webfetch` only as fallback |
+   | crawl a doc site | `webclaw` MCP (`crawl`) |
+   | batch multi-URL extraction | `webclaw` MCP (`batch`) |
+   | brand identity from a site | `webclaw` MCP (`brand`) |
+
+   **Web content priority:** Always try `webclaw` tools first for URL extraction. They handle 403s, bot protection, and produce 67% fewer tokens than raw HTML. Fall back to `webfetch` only if webclaw is unavailable.
 
 3. Run independent calls in parallel
 4. Return concise recommendations with sources

package/dist/template/.opencode/agent/vision.md

@@ -72,6 +72,7 @@ Route by need:
 | Distinctive UI direction / anti-slop guidance | `frontend-design`     |
 | Figma design data (read/write via MCP)        | `figma-go`            |
 | Pencil design-as-code workflow                | `pencil`              |
+| Brand identity extraction from URLs           | `webclaw`             |
 
 ### Taste-Skill Variants (installed)
 
@@ -115,6 +116,14 @@ If design must be created or iterated quickly, use Pencil:
 2. Export PNGs for review
 3. Provide audit with node-level critique where possible
 
+## Brand Extraction Workflow (when auditing existing sites)
+
+Use `webclaw` MCP to extract brand identity from live sites:
+
+1. `brand(url)` → get colors, fonts, logos
+2. Cross-reference with visual analysis findings
+3. Flag inconsistencies between declared brand and actual UI
+
 ## Design QA Checklist (strict)
 
 - **Hierarchy**: clear H1/H2/body scale and weight separation

package/dist/template/.opencode/context/git-context.md

@@ -0,0 +1,32 @@
+---
+purpose: Git spatial awareness injected into all agent prompts
+updated: 2026-04-01
+---
+
+# Git Context
+
+## Auto-Context (start of every task)
+
+Before starting work, establish your position in the repo. Run once per session and cache results:
+
+```bash
+git branch --show-current        # What branch am I on?
+git status --short               # What's modified/staged? (cap at 20 lines)
+git log --oneline -5             # What happened recently?
+```
+
+## When to Refresh
+
+Re-run git context after:
+
+- Any commit you make
+- Switching branches
+- Pulling, merging, or rebasing
+- Stashing or unstashing
+
+## How to Use
+
+- **Commit messages**: Use branch name for scope (e.g., `feat(auth):` if on `feature/auth`)
+- **Branch decisions**: Check if you're on main before creating a feature branch
+- **Conflict awareness**: `git status` shows modified files — avoid editing files with uncommitted changes from another task
+- **Recent history**: `git log` shows what was just done — prevents duplicate work

package/dist/template/.opencode/dcp-prompts/defaults/README.md

@@ -0,0 +1,40 @@
+# DCP Prompt Defaults
+
+This directory stores the DCP prompts.
+Each prompt file here should contain plain text only (no XML wrappers).
+
+## Creating Overrides
+
+1. Copy a prompt file from this directory into an overrides directory using the same filename.
+2. Edit the copied file using plain text.
+3. Restart OpenCode.
+
+To reset an override, delete the matching file from your overrides directory.
+
+Do not edit the default prompt files directly, they are just for reference, only files in the overrides directory are used.
+
+Override precedence (highest first):
+1. `.opencode/dcp-prompts/overrides/` (project)
+2. `$OPENCODE_CONFIG_DIR/dcp-prompts/overrides/` (config dir)
+3. `~/.config/opencode/dcp-prompts/overrides/` (global)
+
+## Prompt Files
+
+- `system.md`
+  - Purpose: Core system-level DCP instruction block.
+  - Runtime use: Injected into the model system prompt on every request.
+- `compress-range.md`
+  - Purpose: range-mode compress tool instructions and summary constraints.
+  - Runtime use: Registered as the range-mode compress tool description.
+- `compress-message.md`
+  - Purpose: message-mode compress tool instructions and summary constraints.
+  - Runtime use: Registered as the message-mode compress tool description.
+- `context-limit-nudge.md`
+  - Purpose: High-priority nudge when context is over max threshold.
+  - Runtime use: Injected when context usage is beyond configured max limits.
+- `turn-nudge.md`
+  - Purpose: Nudge to compress closed ranges at turn boundaries.
+  - Runtime use: Injected when context is between min and max limits at a new user turn.
+- `iteration-nudge.md`
+  - Purpose: Nudge after many iterations without user input.
+  - Runtime use: Injected when iteration threshold is crossed.

package/dist/template/.opencode/dcp-prompts/defaults/compress-message.md

@@ -0,0 +1,42 @@
+Collapse selected individual messages in the conversation into detailed summaries.
+
+THE SUMMARY
+Your summary must be EXHAUSTIVE. Capture file paths, function signatures, decisions made, constraints discovered, key findings, tool outcomes, and user intent details that matter... EVERYTHING that preserves the value of the selected message after the raw message is removed.
+
+USER INTENT FIDELITY
+When a selected message contains user intent, preserve that intent with extra care. Do not change scope, constraints, priorities, acceptance criteria, or requested outcomes.
+Directly quote short user instructions when that best preserves exact meaning.
+
+Yet be LEAN. Strip away the noise: failed attempts that led nowhere, verbose tool output, and repetition. What remains should be pure signal - golden nuggets of detail that preserve full understanding with zero ambiguity.
+
+MESSAGE IDS
+You specify individual raw messages by ID using the injected IDs visible in the conversation:
+
+- `mNNNN` IDs identify raw messages
+
+Each message has an ID inside XML metadata tags like `<dcp-message-id priority="high">m0007</dcp-message-id>`.
+The ID tag appears at the end of the message it belongs to — each ID covers all the content above it back to the previous ID.
+Treat these tags as message metadata only, not as content to summarize. Use only the inner `mNNNN` value as the `messageId`.
+The `priority` attribute indicates relative context cost. Prefer higher-priority closed messages before lower-priority ones.
+Messages marked as `<dcp-message-id>BLOCKED</dcp-message-id>` cannot be compressed.
+
+Rules:
+
+- Pick each `messageId` directly from injected IDs visible in context.
+- Only use raw message IDs of the form `mNNNN`.
+- Ignore XML attributes such as `priority` when copying the ID; use only the inner `mNNNN` value.
+- Do NOT use compressed block IDs like `bN`.
+- Do not invent IDs. Use only IDs that are present in context.
+- Do not target prior compressed blocks or block summaries.
+
+BATCHING
+Select MANY messages in a single tool call when they are independently safe to compress.
+Each entry should summarize exactly one message, and the tool can receive as many entries as needed in one batch.
+When several messages are equally safe to compress, prefer higher-priority messages first.
+
+Because each message is compressed independently:
+
+- Do not describe ranges
+- Do not use start/end boundaries
+- Do not use compressed block placeholders
+- Do not reference prior compressed blocks with `(bN)`

package/dist/template/.opencode/dcp-prompts/defaults/compress-range.md

@@ -0,0 +1,59 @@
+Collapse a range in the conversation into a detailed summary.
+
+THE SUMMARY
+Your summary must be EXHAUSTIVE. Capture file paths, function signatures, decisions made, constraints discovered, key findings... EVERYTHING that maintains context integrity. This is not a brief note - it is an authoritative record so faithful that the original conversation adds no value.
+
+USER INTENT FIDELITY
+When the compressed range includes user messages, preserve the user's intent with extra care. Do not change scope, constraints, priorities, acceptance criteria, or requested outcomes.
+Directly quote user messages when they are short enough to include safely. Direct quotes are preferred when they best preserve exact meaning.
+
+Yet be LEAN. Strip away the noise: failed attempts that led nowhere, verbose tool outputs, back-and-forth exploration. What remains should be pure signal - golden nuggets of detail that preserve full understanding with zero ambiguity.
+
+COMPRESSED BLOCK PLACEHOLDERS
+When the selected range includes previously compressed blocks, use this exact placeholder format when referencing one:
+
+- `(bN)`
+
+Compressed block sections in context are clearly marked with a header:
+
+- `[Compressed conversation section]`
+
+Compressed block IDs always use the `bN` form (never `mNNNN`) and are represented in the same XML metadata tag format.
+
+Rules:
+
+- Include every required block placeholder exactly once.
+- Do not invent placeholders for blocks outside the selected range.
+- Treat `(bN)` placeholders as RESERVED TOKENS. Do not emit `(bN)` text anywhere except intentional placeholders.
+- If you need to mention a block in prose, use plain text like `compressed bN` (not as a placeholder).
+- Preflight check before finalizing: the set of `(bN)` placeholders in your summary must exactly match the required set, with no duplicates.
+
+These placeholders are semantic references. They will be replaced with the full stored compressed block content when the tool processes your output.
+
+FLOW PRESERVATION WITH PLACEHOLDERS
+When you use compressed block placeholders, write the surrounding summary text so it still reads correctly AFTER placeholder expansion.
+
+- Treat each placeholder as a stand-in for a full conversation segment, not as a short label.
+- Ensure transitions before and after each placeholder preserve chronology and causality.
+- Do not write text that depends on the placeholder staying literal (for example, "as noted in `(b2)`").
+- Your final meaning must be coherent once each placeholder is replaced with its full compressed block content.
+
+BOUNDARY IDS
+You specify boundaries by ID using the injected IDs visible in the conversation:
+
+- `mNNNN` IDs identify raw messages
+- `bN` IDs identify previously compressed blocks
+
+Each message has an ID inside XML metadata tags like `<dcp-message-id>...</dcp-message-id>`.
+The ID tag appears at the end of the message it belongs to — each ID covers all the content above it back to the previous ID.
+Treat these tags as boundary metadata only, not as tool result content.
+
+Rules:
+
+- Pick `startId` and `endId` directly from injected IDs in context.
+- IDs must exist in the current visible context.
+- `startId` must appear before `endId`.
+- Do not invent IDs. Use only IDs that are present in context.
+
+BATCHING
+When multiple independent ranges are ready and their boundaries do not overlap, include all of them as separate entries in the `content` array of a single tool call. Each entry should have its own `startId`, `endId`, and `summary`.

package/dist/template/.opencode/dcp-prompts/defaults/context-limit-nudge.md

@@ -0,0 +1,21 @@
+CRITICAL WARNING: MAX CONTEXT LIMIT REACHED
+
+You are at or beyond the configured max context threshold. This is an emergency context-recovery moment.
+
+You MUST use the `compress` tool now. Do not continue normal exploration until compression is handled.
+
+If you are in the middle of a critical atomic operation, finish that atomic step first, then compress immediately.
+
+RANGE STRATEGY (MANDATORY)
+Prioritize one large, closed, high-yield compression range first.
+This overrides the normal preference for many small compressions.
+Only split into multiple compressions if one large range would reduce summary quality or make boundary selection unsafe.
+
+RANGE SELECTION
+Start from older, resolved history and capture as much stale context as safely possible in one pass.
+Avoid the newest active working slice unless it is clearly closed.
+Use visible injected boundary IDs for compression (`mNNNN` for messages, `bN` for compressed blocks), and ensure `startId` appears before `endId`.
+
+SUMMARY REQUIREMENTS
+Your summary must cover all essential details from the selected range so work can continue without reopening raw messages.
+If the compressed range includes user messages, preserve user intent exactly. Prefer direct quotes for short user messages to avoid semantic drift.

package/dist/template/.opencode/dcp-prompts/defaults/iteration-nudge.md

@@ -0,0 +1,5 @@
+You've been iterating for a while after the last user message.
+
+If there is a closed portion that is unlikely to be referenced immediately (for example, finished research before implementation), use the compress tool on it now.
+
+Prefer multiple short, closed ranges over one large range when several independent slices are ready.

package/dist/template/.opencode/dcp-prompts/defaults/system.md

@@ -0,0 +1,44 @@
+You operate in a context-constrained environment. Manage context continuously to avoid buildup and preserve retrieval quality. Efficient context management is paramount for your agentic performance.
+
+The ONLY tool you have for context management is `compress`. It replaces older conversation content with technical summaries you produce.
+
+`<dcp-message-id>` and `<dcp-system-reminder>` tags are environment-injected metadata. Do not output them.
+
+THE PHILOSOPHY OF COMPRESS
+`compress` transforms conversation content into dense, high-fidelity summaries. This is not cleanup - it is crystallization. Your summary becomes the authoritative record of what transpired.
+
+Think of compression as phase transitions: raw exploration becomes refined understanding. The original context served its purpose; your summary now carries that understanding forward.
+
+OPERATING STANCE
+Prefer short, closed, summary-safe compressions.
+When multiple independent stale sections exist, prefer several focused compressions (in parallel when possible) over one broad compression.
+
+Use `compress` as steady housekeeping while you work.
+
+CADENCE, SIGNALS, AND LATENCY
+
+- No fixed threshold mandates compression
+- Prioritize closedness and independence over raw size
+- Prefer smaller, regular compressions over infrequent massive compressions for better latency and summary quality
+- When multiple independent stale sections are ready, batch compressions in parallel
+
+COMPRESS WHEN
+
+A section is genuinely closed and the raw conversation has served its purpose:
+
+- Research concluded and findings are clear
+- Implementation finished and verified
+- Exploration exhausted and patterns understood
+- Dead-end noise can be discarded without waiting for a whole chapter to close
+
+DO NOT COMPRESS IF
+
+- Raw context is still relevant and needed for edits or precise references
+- The target content is still actively in progress
+- You may need exact code, error messages, or file contents in the immediate next steps
+
+Before compressing, ask: _"Is this section closed enough to become summary-only right now?"_
+
+Evaluate conversation signal-to-noise REGULARLY. Use `compress` deliberately with quality-first summaries. Prioritize stale content intelligently to maintain a high-signal context window that supports your agency.
+
+It is of your responsibility to keep a sharp, high-quality context window for optimal performance.

package/dist/template/.opencode/dcp-prompts/defaults/turn-nudge.md

@@ -0,0 +1,8 @@
+Evaluate the conversation for compressible ranges.
+
+If any range is cleanly closed and unlikely to be needed again, use the compress tool on it.
+If direction has shifted, compress earlier ranges that are now less relevant.
+
+Prefer small, closed-range compressions over one broad compression.
+The goal is to filter noise and distill key information so context accumulation stays under control.
+Keep active context uncompressed.

package/dist/template/.opencode/dcp-prompts/overrides/compress-message.md

@@ -0,0 +1,71 @@
+Collapse selected individual messages in the conversation into detailed summaries.
+
+THE SUMMARY
+Your summary must be EXHAUSTIVE. Use the following 9-section structure to ensure nothing is lost.
+Capture file paths, function signatures, decisions made, constraints discovered, key findings, tool outcomes, and user intent details that matter... EVERYTHING that preserves the value of the selected message after the raw message is removed.
+
+STRUCTURED SUMMARY FORMAT
+When summarizing each message, organize findings into these sections (omit empty sections):
+
+1. **Primary Request** — What the user actually wants. Quote exact instructions when short.
+2. **Key Technical Concepts** — Decisions made, constraints discovered, architecture choices, patterns identified.
+3. **Files and Code** — Exact file paths with line numbers (`path/file.ts:42-67`). Function signatures. Code snippets critical to understanding.
+4. **Errors and Fixes** — What broke, root cause, what fixed it. Include error messages verbatim when diagnostic.
+5. **Problem Solving** — Approaches tried (including failures). What worked and why.
+6. **User Messages** — Preserve exact user intent. Directly quote short user instructions when that best preserves meaning.
+7. **Pending Tasks** — Incomplete work with current status.
+8. **Current Work** — What's actively happening right now.
+9. **Next Step** — What should happen next (if clear from context).
+
+USER INTENT FIDELITY
+When a selected message contains user intent, preserve that intent with extra care. Do not change scope, constraints, priorities, acceptance criteria, or requested outcomes.
+Directly quote short user instructions when that best preserves exact meaning.
+
+Yet be LEAN. Strip away the noise: failed attempts that led nowhere, verbose tool output, and repetition. What remains should be pure signal — golden nuggets of detail that preserve full understanding with zero ambiguity.
+
+MESSAGE IDS
+You specify individual raw messages by ID using the injected IDs visible in the conversation:
+
+- `mNNNN` IDs identify raw messages
+
+Each message has an ID inside XML metadata tags like `<dcp-message-id priority="high">m0007</dcp-message-id>`.
+The ID tag appears at the end of the message it belongs to — each ID covers all the content above it back to the previous ID.
+Treat these tags as message metadata only, not as content to summarize. Use only the inner `mNNNN` value as the `messageId`.
+The `priority` attribute indicates relative context cost. Prefer higher-priority closed messages before lower-priority ones.
+Messages marked as `<dcp-message-id>BLOCKED</dcp-message-id>` cannot be compressed.
+
+Rules:
+
+- Pick each `messageId` directly from injected IDs visible in context.
+- Only use raw message IDs of the form `mNNNN`.
+- Ignore XML attributes such as `priority` when copying the ID; use only the inner `mNNNN` value.
+- Do NOT use compressed block IDs like `bN`.
+- Do not invent IDs. Use only IDs that are present in context.
+- Do not target prior compressed blocks or block summaries.
+
+BATCHING
+Select MANY messages in a single tool call when they are independently safe to compress.
+Each entry should summarize exactly one message, and the tool can receive as many entries as needed in one batch.
+When several messages are equally safe to compress, prefer higher-priority messages first.
+
+Because each message is compressed independently:
+
+- Do not describe ranges
+- Do not use start/end boundaries
+- Do not use compressed block placeholders
+- Do not reference prior compressed blocks with `(bN)`
+
+THE FORMAT OF COMPRESS
+
+```
+{
+  topic: string,           // Short label (3-5 words) for the overall batch
+  content: [               // One or more messages to compress independently
+    {
+      messageId: string,   // Raw message ID only: mNNNN (ignore metadata attributes like priority)
+      topic: string,       // Short label (3-5 words) for this one message summary
+      summary: string      // Complete technical summary replacing that one message (use 9-section format above)
+    }
+  ]
+}
+```

package/dist/template/.opencode/dcp.jsonc

@@ -1,83 +1,102 @@
 {
-  "$schema": "https://raw.githubusercontent.com/Opencode-DCP/opencode-dynamic-context-pruning/master/dcp.schema.json",
-  "enabled": true,
-  "debug": false,
-  // "off" | "minimal" | "detailed" — keep minimal for low-noise dev flow
-  "pruneNotification": "minimal",
-  // "chat" (in-conversation) or "toast" (system notification)
-  "pruneNotificationType": "toast",
-  // Slash commands: /dcp context, /dcp stats, /dcp sweep, /dcp compress, /dcp decompress, /dcp recompress
-  "commands": {
-    "enabled": true,
-    // Additional tools to protect from /dcp sweep (supports glob wildcards)
-    "protectedTools": ["observation", "memory-*"],
-  },
-  // Manual mode: disables autonomous context management
-  "manualMode": {
-    "enabled": false,
-    "automaticStrategies": true,
-  },
-  // Protect recent tool outputs from pruning
-  "turnProtection": {
-    "enabled": false,
-    "turns": 4,
-  },
-  // Glob patterns for files that should never be auto-pruned
-  // Keep tight: broad patterns reduce DCP effectiveness
-  "protectedFilePatterns": [
-    "**/.env*",
-    "**/AGENTS.md",
-    "**/.opencode/**",
-    "**/.beads/**",
-    "**/package.json",
-    "**/tsconfig.json",
-  ],
-  // Unified context compression tool (v3.1.0)
-  "compress": {
-    // "range" (stable) compresses spans into block summaries
-    // "message" (experimental) compresses individual raw messages
-    "mode": "message",
-    // "allow" (no prompt) | "ask" (prompt) | "deny" (tool not registered)
-    "permission": "allow",
-    "showCompression": false,
-    // v3.1.0: active summary tokens extend effective maxContextLimit
-    "summaryBuffer": true,
-    // Soft upper threshold: above this, strong compression nudges fire
-    // Accepts number or "X%" of model context window
-    "maxContextLimit": "80%",
-    // Soft lower threshold: below this, turn/iteration reminders are off
-    "minContextLimit": "35%",
-    // How often context-limit nudge fires above maxContextLimit (1 = every fetch)
-    "nudgeFrequency": 5,
-    // Messages since last user message before adding compression reminders
-    "iterationNudgeThreshold": 15,
-    // "strong" = more likely to compress, "soft" = less likely
-    "nudgeForce": "soft",
-    // Keep user messages compressible to avoid permanent context growth
-    "protectUserMessages": false,
-    // Auto-protected by DCP: task, skill, todowrite, todoread, compress, batch, plan_enter, plan_exit, write, edit
-    // Only list ADDITIONAL tools whose outputs should be appended to compression summaries
-    "protectedTools": ["observation", "memory-*", "tilth_*"],
-  },
-  // Experimental features
-  "experimental": {
-    // Allow DCP processing in subagent sessions (default: false)
-    "allowSubAgents": false,
-    // Enable user-editable prompt overrides under dcp-prompts directories
-    "customPrompts": false,
-  },
-  // Automatic pruning strategies (zero LLM cost)
-  "strategies": {
-    // Removes duplicate tool calls (same tool + same arguments), keeps most recent
-    "deduplication": {
-      "enabled": true,
-      "protectedTools": [],
-    },
-    // Prunes inputs from errored tool calls after N turns (error messages preserved)
-    "purgeErrors": {
-      "enabled": true,
-      "turns": 4,
-      "protectedTools": [],
-    },
-  },
+	"$schema": "https://raw.githubusercontent.com/Opencode-DCP/opencode-dynamic-context-pruning/master/dcp.schema.json",
+	"enabled": true,
+	"debug": false,
+	// "off" | "minimal" | "detailed" — keep minimal for low-noise dev flow
+	"pruneNotification": "minimal",
+	// "chat" (in-conversation) or "toast" (system notification)
+	"pruneNotificationType": "toast",
+	// Slash commands: /dcp context, /dcp stats, /dcp sweep, /dcp compress, /dcp decompress, /dcp recompress
+	"commands": {
+		"enabled": true,
+		// Additional tools to protect from /dcp sweep (supports glob wildcards)
+		"protectedTools": ["observation", "memory-*"]
+	},
+	// Manual mode: disables autonomous context management
+	"manualMode": {
+		"enabled": false,
+		"automaticStrategies": true
+	},
+	// Protect recent tool outputs from pruning
+	"turnProtection": {
+		"enabled": false,
+		"turns": 4
+	},
+	// Glob patterns for files that should never be auto-pruned
+	// Keep tight: broad patterns reduce DCP effectiveness
+	"protectedFilePatterns": [
+		"**/.env*",
+		"**/AGENTS.md",
+		"**/.opencode/**",
+		"**/.beads/**",
+		"**/package.json",
+		"**/tsconfig.json"
+	],
+	// Unified context compression tool (v3.1.0)
+	"compress": {
+		// "range" (stable) compresses spans into block summaries
+		// "message" (experimental) compresses individual raw messages
+		"mode": "message",
+		// "allow" (no prompt) | "ask" (prompt) | "deny" (tool not registered)
+		"permission": "allow",
+		"showCompression": false,
+		// v3.1.0: active summary tokens extend effective maxContextLimit
+		"summaryBuffer": true,
+		// Soft upper threshold: above this, strong compression nudges fire
+		// Accepts number or "X%" of model context window
+		"maxContextLimit": "80%",
+		// Per-model override for maxContextLimit (takes priority over global)
+		// Aligned to claude-opus-4.6 (216k context, 64k output) as primary build agent
+		"modelMaxLimits": {
+			"github-copilot/claude-opus-4.6": 192000,
+			"github-copilot/claude-opus-4.5": 192000,
+			"github-copilot/claude-sonnet-4.6": 192000,
+			"github-copilot/claude-sonnet-4.5": 192000,
+			"github-copilot/claude-sonnet-4": 192000,
+			"github-copilot/claude-haiku-4.5": 172000
+		},
+		// Soft lower threshold: below this, turn/iteration reminders are off
+		"minContextLimit": "35%",
+		// Per-model override for minContextLimit (takes priority over global)
+		"modelMinLimits": {
+			"github-copilot/claude-opus-4.6": "30%",
+			"github-copilot/claude-opus-4.5": "35%",
+			"github-copilot/claude-sonnet-4.6": "35%",
+			"github-copilot/claude-sonnet-4.5": "35%",
+			"github-copilot/claude-sonnet-4": "35%",
+			"github-copilot/claude-haiku-4.5": "25%"
+		},
+		// How often context-limit nudge fires above maxContextLimit (1 = every fetch)
+		"nudgeFrequency": 5,
+		// Messages since last user message before adding compression reminders
+		"iterationNudgeThreshold": 15,
+		// "strong" = more likely to compress, "soft" = less likely
+		"nudgeForce": "soft",
+		// Keep user messages compressible to avoid permanent context growth
+		"protectUserMessages": false,
+		// Auto-protected by DCP: task, skill, todowrite, todoread, compress, batch, plan_enter, plan_exit, write, edit
+		// Only list ADDITIONAL tools whose outputs should be appended to compression summaries
+		"protectedTools": ["observation", "memory-*", "tilth_*"]
+	},
+	// Experimental features
+	"experimental": {
+		// Allow DCP processing in subagent sessions (default: false)
+		"allowSubAgents": false,
+		// Enable user-editable prompt overrides under dcp-prompts directories
+		"customPrompts": true
+	},
+	// Automatic pruning strategies (zero LLM cost)
+	"strategies": {
+		// Removes duplicate tool calls (same tool + same arguments), keeps most recent
+		"deduplication": {
+			"enabled": true,
+			"protectedTools": []
+		},
+		// Prunes inputs from errored tool calls after N turns (error messages preserved)
+		"purgeErrors": {
+			"enabled": true,
+			"turns": 4,
+			"protectedTools": []
+		}
+	}
 }

package/dist/template/.opencode/opencode.json

@@ -83,7 +83,8 @@
 		".opencode/memory/project/tech-stack.md",
 		".opencode/memory/project/project.md",
 		".opencode/memory/project/roadmap.md",
-		".opencode/memory/project/state.md"
+		".opencode/memory/project/state.md",
+		".opencode/context/git-context.md"
 	],
 	"keybinds": {
 		"leader": "`",
@@ -115,6 +116,12 @@
 			"environment": {},
 			"timeout": 120000,
 			"type": "local"
+		},
+		"webclaw": {
+			"command": ["webclaw-mcp"],
+			"enabled": true,
+			"timeout": 120000,
+			"type": "local"
 		}
 	},
 	"model": "opencode/minimax-m2.5-free",
@@ -171,7 +178,7 @@
 				"claude-haiku-4.5": {
 					"attachment": true,
 					"limit": {
-						"context": 144000,
+						"context": 216000,
 						"output": 32000
 					},
 					"options": {
@@ -199,7 +206,7 @@
 				"claude-opus-4.5": {
 					"attachment": true,
 					"limit": {
-						"context": 160000,
+						"context": 216000,
 						"output": 32000
 					},
 					"options": {
@@ -224,7 +231,7 @@
 				"claude-opus-4.6": {
 					"attachment": true,
 					"limit": {
-						"context": 144000,
+						"context": 216000,
 						"output": 64000
 					},
 					"options": {
@@ -294,7 +301,7 @@
 				"claude-sonnet-4.5": {
 					"attachment": true,
 					"limit": {
-						"context": 144000,
+						"context": 216000,
 						"output": 32000
 					},
 					"options": {
@@ -319,7 +326,7 @@
 				"claude-sonnet-4.6": {
 					"attachment": true,
 					"limit": {
-						"context": 200000,
+						"context": 216000,
 						"output": 32000
 					},
 					"options": {

package/dist/template/.opencode/plugin/sdk/copilot/chat/openai-compatible-chat-language-model.ts

@@ -9,22 +9,22 @@ import {
 	type SharedV2ProviderMetadata,
 } from "@ai-sdk/provider";
 import {
-	type FetchFunction,
-	type ParseResult,
-	type ResponseHandler,
 	combineHeaders,
 	createEventSourceResponseHandler,
 	createJsonErrorResponseHandler,
 	createJsonResponseHandler,
+	type FetchFunction,
 	generateId,
 	isParsableJson,
+	type ParseResult,
 	parseProviderOptions,
 	postJsonToApi,
+	type ResponseHandler,
 } from "@ai-sdk/provider-utils";
 import { z } from "zod/v4";
 import {
-	type ProviderErrorStructure,
 	defaultOpenAICompatibleErrorStructure,
+	type ProviderErrorStructure,
 } from "../openai-compatible-error.js";
 import { convertToOpenAICompatibleChatMessages } from "./convert-to-openai-compatible-chat-messages.js";
 import { getResponseMetadata } from "./get-response-metadata.js";
@@ -482,15 +482,15 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV2 {
 						const delta = choice.delta;
 
 						// Capture reasoning_opaque for Copilot multi-turn reasoning
+						// Claude models can send multiple reasoning_opaque delta chunks
+						// during streaming (especially with parallel tool calls).
+						// Concatenate them instead of throwing — same pattern as content/arguments.
+						// See: https://github.com/anomalyco/opencode/issues/17011
 						if (delta.reasoning_opaque) {
-							if (reasoningOpaque != null) {
-								throw new InvalidResponseDataError({
-									data: delta,
-									message:
-										"Multiple reasoning_opaque values received in a single response. Only one thinking part per response is supported.",
-								});
-							}
-							reasoningOpaque = delta.reasoning_opaque;
+							reasoningOpaque =
+								reasoningOpaque != null
+									? reasoningOpaque + delta.reasoning_opaque
+									: delta.reasoning_opaque;
 						}
 
 						// enqueue reasoning before text deltas (Copilot uses reasoning_text):

package/dist/template/.opencode/skill/compaction/SKILL.md

@@ -19,7 +19,6 @@ dependencies: []
 
 - Short sessions with low context usage where no compaction is needed.
 
-
 ## Overview
 
 **Compaction = Summarization + Preservation + Continuity**
@@ -53,7 +52,6 @@ Pay attention to these signals:
 
 Compress completed conversation phases into dense summaries. This is the primary DCP instrument in the installed beta.
 
-
 Compress completed conversation phases into dense summaries.
 
 ```
@@ -267,6 +265,75 @@ This project uses `@tarquinen/opencode-dcp` for always-on context management (in
 - **DCP plugin**: Context budget rules, tool guidance, prunable-tools list, nudges (always present via system prompt)
 - **Compaction plugin** (`.opencode/plugin/compaction.ts`): Session continuity, beads state, handoff recovery, post-compaction protocol (fires during compaction events only)
 
+**Custom prompts (enabled):**
+
+DCP custom prompts are enabled (`experimental.customPrompts: true`). Override files live at `.opencode/dcp-prompts/overrides/`:
+
+- `compress-message.md` — 9-section structured summary format (Primary Request, Key Technical Concepts, Files/Code, Errors/Fixes, Problem Solving, User Messages, Pending Tasks, Current Work, Next Step)
+
+Override precedence: project (`.opencode/dcp-prompts/overrides/`) > config dir > global (`~/.config/opencode/dcp-prompts/overrides/`).
+
+## Post-Compaction Restoration Protocol
+
+**Critical:** After any compaction (server-side or DCP compress), you lose raw file content and active context. Immediately restore:
+
+### Step 1: Re-read Active Files (max 5)
+
+Re-read the files you were actively editing before compaction. Prioritize by recency — most recently modified first. Cap at 5 files, use offset/limit to read only the sections you need (~200 lines each).
+
+```
+After compaction, if you were editing src/auth.ts:
+read({ filePath: "src/auth.ts", offset: 30, limit: 50 })
+```
+
+**Why:** The Write/Edit tool requires a prior Read in the same session (`FileTime.assert()`). Without re-reading, your next edit attempt will fail.
+
+### Step 2: Restore Active Skill Context
+
+If you were using a skill before compaction, re-load it:
+
+```typescript
+skill({ name: "<active-skill>" });
+```
+
+Skills are prompt-injected — compaction drops them. Re-load to restore the workflow.
+
+### Step 3: Check Todo State
+
+Review your TodoWrite list to re-establish task tracking:
+
+```
+- What was in_progress?
+- What was pending?
+- What was completed?
+```
+
+### Step 4: Verify Git Position
+
+```bash
+git branch --show-current
+git status --short
+```
+
+Confirms you're on the right branch and shows any uncommitted changes.
+
+### Step 5: Scan Memory for Context
+
+If the compaction was heavy (>50% reduction), check memory for recent observations:
+
+```typescript
+memory - search({ query: "<current task keywords>", limit: 3 });
+```
+
+### Why This Protocol Exists
+
+Compaction strips raw file content, tool outputs, and skill prompts. Without restoration:
+
+- File edits fail (`FileTime.assert` — no prior read)
+- Line-number precision is lost (you're guessing, not citing)
+- Skill workflows are inactive (no prompt injection)
+- Task tracking is disconnected (todos lost in compressed summary)
+
 ## Anti-Patterns
 
 ### ❌ Premature Compaction

package/dist/template/.opencode/skill/webclaw/SKILL.md

@@ -0,0 +1,155 @@
+---
+name: webclaw
+description: Web content extraction, crawling, and scraping via webclaw MCP server. Use when fetching URLs fails (403), when crawling doc sites, batch-extracting pages, tracking content changes, or extracting brand identity from websites.
+---
+
+# Webclaw Skill
+
+Fast, local-first web content extraction for LLMs. Rust-based scraper with TLS fingerprinting, 67% token reduction, and native MCP integration.
+
+## Prerequisites
+
+- `webclaw-mcp` binary installed at `~/.webclaw/webclaw-mcp`
+- Install: `brew tap 0xMassi/webclaw && brew install webclaw`
+- Or: download from https://github.com/0xMassi/webclaw/releases
+- MCP server must be enabled in `.opencode/opencode.json` (`"enabled": true`)
+
+## When to Use
+
+| Scenario               | Tool                   | Why                                        |
+| ---------------------- | ---------------------- | ------------------------------------------ |
+| `webfetch` got 403     | `scrape`               | TLS fingerprinting bypasses bot protection |
+| Research a doc site    | `crawl`                | BFS recursive extraction, same-origin      |
+| Extract multiple URLs  | `batch`                | Parallel multi-URL, faster than sequential |
+| Discover sitemap URLs  | `map`                  | Find all pages without crawling            |
+| Track doc changes      | `diff`                 | Snapshot + compare workflow                |
+| Extract brand identity | `brand`                | Colors, fonts, logos from any site         |
+| LLM-optimized output   | `scrape` with `-f llm` | 67% fewer tokens than raw HTML             |
+
+## MCP Tools (8 local, no API key needed)
+
+### scrape
+
+Extract clean content from a URL. Returns markdown, text, JSON, or LLM-optimized format.
+
+```
+scrape(url: "https://example.com", format: "llm")
+```
+
+Options: `format` (markdown|text|json|llm|html), `include` (CSS selectors), `exclude` (CSS selectors), `only_main_content` (boolean)
+
+### crawl
+
+Recursive BFS crawl of a site. Same-origin only.
+
+```
+crawl(url: "https://docs.example.com", depth: 2, max_pages: 50)
+```
+
+Options: `depth` (1-10), `max_pages`, `sitemap` (seed from sitemap.xml)
+
+### map
+
+Discover URLs from a site's sitemap without fetching content.
+
+```
+map(url: "https://docs.example.com")
+```
+
+### batch
+
+Parallel extraction from multiple URLs.
+
+```
+batch(urls: ["https://a.com", "https://b.com"], format: "llm")
+```
+
+### diff
+
+Compare current page content against a previous snapshot.
+
+```
+diff(url: "https://example.com", snapshot: previous_json)
+```
+
+### brand
+
+Extract visual identity: colors, fonts, logos, OG image.
+
+```
+brand(url: "https://stripe.com")
+```
+
+Returns: `{ name, colors: [{hex, usage}], fonts: [], logos: [{url, kind}] }`
+
+### extract (needs Ollama)
+
+LLM-powered structured extraction. Requires local Ollama instance.
+
+### summarize (needs Ollama)
+
+Page summarization via local LLM.
+
+## Workflow Patterns
+
+### Fallback when webfetch fails
+
+1. Try `webfetch` first (built-in, no setup)
+2. If 403 or empty → use `scrape` via webclaw MCP
+3. If JS-rendered SPA → note limitation (webclaw doesn't execute JS without cloud API)
+
+### Research a documentation site
+
+1. `map(url)` to discover all pages
+2. `crawl(url, depth: 2, max_pages: 50)` to extract content
+3. Feed results to analysis agent
+
+### Brand/design audit
+
+1. `brand(url)` to extract colors, fonts, logos
+2. Pass to vision agent for design system analysis
+
+### Track changes over time
+
+1. `scrape(url, format: "json")` → save as snapshot
+2. Later: `diff(url, snapshot: saved)` → see what changed
+
+## Installation
+
+```bash
+# Homebrew (recommended)
+brew tap 0xMassi/webclaw
+brew install webclaw
+
+# Prebuilt binary
+# Download from https://github.com/0xMassi/webclaw/releases
+# Place webclaw-mcp in ~/.webclaw/
+
+# Verify
+webclaw-mcp --version
+```
+
+## Configuration
+
+After install, enable in `.opencode/opencode.json`:
+
+```json
+{
+  "mcp": {
+    "webclaw": {
+      "enabled": true
+    }
+  }
+}
+```
+
+Optional env vars:
+
+- `WEBCLAW_API_KEY` — cloud API for bot-protected sites (optional)
+- `OLLAMA_HOST` — for extract/summarize tools (default: `http://localhost:11434`)
+
+## Limitations
+
+- **No JS rendering** (local mode) — SPAs that render entirely client-side won't extract fully. Use `--cloud` with API key, or use `playwright` skill instead.
+- **Same-origin crawl only** — won't follow external links during crawl.
+- **Early version** — v0.3.2, MIT license. Report issues to https://github.com/0xMassi/webclaw/issues

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencodekit",
-	"version": "0.19.1",
+	"version": "0.19.3",
 	"description": "CLI tool for bootstrapping and managing OpenCodeKit projects",
 	"keywords": [
 		"agents",