opencodekit 0.21.4 → 0.21.5

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

@@ -40,11 +40,12 @@ skill({ name: "beads" });
 
 ## Available Tools
 
-| Tool            | Use When              |
-| --------------- | --------------------- |
-| `br`            | Task status and stats |
-| `git`           | Git state and history |
-| `find_sessions` | Recent sessions       |
+| Tool            | Use When                                        |
+| --------------- | ----------------------------------------------- |
+| `br`            | Task status and stats                           |
+| `git`           | Git state and history                           |
+| `find_sessions` | Recent sessions                                 |
+| `portless`      | Optional read-only local URL state if installed |
 
 ## Phase 1: Gather State (Parallel)
 
@@ -62,6 +63,14 @@ git branch --show-current
 git log --oneline -5
 ```
 
+Optionally include Portless local URL state only if the binary is already installed:
+
+```bash
+if command -v portless >/dev/null 2>&1; then portless list; fi
+```
+
+Do not install Portless, start/stop proxies, trust CAs, sync hosts, prune/clean state, or expose LAN services from `/status`.
+
 ```typescript
 find_sessions({ query: "<project-name or recent-bead-keywords>", limit: 5 });
 ```

package/dist/template/.opencode/command/ui-review.md

@@ -13,6 +13,7 @@ model: proxypal/gemini-3-pro-preview
 skill({ name: "visual-analysis" }); // Analysis framework
 skill({ name: "accessibility-audit" }); // WCAG checklists
 skill({ name: "frontend-design" }); // Anti-patterns, design quality
+skill({ name: "ux-quality-gates" }); // IA, heuristics, forms, recovery, state coverage
 ```
 
 ## Input
@@ -33,31 +34,50 @@ Use the `visual-analysis` skill to perform deep analysis:
 - Visual properties (colors, typography, spacing, layout)
 - Design patterns and potential issues
 
-### 2. Score Categories
+### 2. Usability Heuristic Pass
 
-Rate each 1-10 with brief justification:
+Apply `ux-quality-gates` before visual scoring. Check:
+
+- System status is visible for async or multi-step work
+- Labels and navigation use user vocabulary, not implementation terms
+- Users can cancel, undo, go back, retry, or recover from failure
+- Controls, names, and layouts are consistent across the surface
+- Dangerous or invalid actions are prevented before they happen
+- Options and relationships are visible without relying on memory
+- High-volume workflows expose efficient paths where appropriate
+- Empty/loading/error/success states are present and useful
+
+Any failure that blocks task completion or recovery is **Critical**, even if the screen looks polished.
 
-| Category               | What to Evaluate                                               |
-| ---------------------- | -------------------------------------------------------------- |
-| **Typography**         | Hierarchy, readability, weight contrast, intentional choices   |
-| **Color**              | Palette cohesion, contrast, semantic usage, no AI slop         |
-| **Layout & Spacing**   | Visual hierarchy, consistency, alignment, white space          |
-| **Interactive States** | Hover, focus, active, disabled, loading coverage               |
-| **Accessibility**      | WCAG AA compliance (use `accessibility-audit` skill checklist) |
-| **Visual Polish**      | Consistency, attention to detail, motion, shadows, icons       |
+### 3. Score Categories
+
+Rate each 1-10 with brief justification:
 
-### 3. Conditional Reviews
+| Category                          | What to Evaluate                                               |
+| --------------------------------- | -------------------------------------------------------------- |
+| **Information Architecture**      | User vocabulary, scope clarity, relationships, navigation      |
+| **Task Flow & Recovery**          | Primary action, cancellation, undo/retry, error recovery       |
+| **Forms & Data Interaction**      | Labels, helper text, validation, selection, bulk actions       |
+| **Typography**                    | Hierarchy, readability, weight contrast, intentional choices   |
+| **Color**                         | Palette cohesion, contrast, semantic usage, no AI slop         |
+| **Layout & Spacing**              | Visual hierarchy, consistency, alignment, white space          |
+| **Interactive States**            | Hover, focus, active, disabled, loading/error/success coverage |
+| **Accessibility & Semantic HTML** | WCAG AA compliance, native semantics, keyboard/focus behavior  |
+| **Component Consistency**         | Shared token DNA: radius, height, border, shadow, states       |
+| **Visual Polish**                 | Consistency, attention to detail, motion, shadows, icons       |
+
+### 4. Conditional Reviews
 
 **If `--responsive`**: Check at 375px, 768px, 1280px, 1536px+. Flag touch targets, horizontal scroll, text sizing.
 
 **If `--dark-mode`**: Check contrast on dark backgrounds, adapted colors (not just inverted), shadow adjustments, focus visibility.
 
-### 4. Report Findings
+### 5. Report Findings
 
 Group by severity:
 
-- **Critical (Must Fix)**: Accessibility failures, broken interactions
-- **Warning (Should Fix)**: AI slop patterns, inconsistent spacing, missing states
+- **Critical (Must Fix)**: Accessibility failures, broken interactions, dead-end errors, unsafe destructive actions
+- **Warning (Should Fix)**: AI slop patterns, inconsistent spacing, missing states, confusing IA/naming
 - **Info (Nice to Have)**: Polish opportunities
 
 For each finding: location, impact, and recommended fix.
@@ -85,7 +105,7 @@ observation({
 
 ## Related Commands
 
-| Need                 | Command   |
-| -------------------- | --------- |
-| Design from scratch  | `/design` |
-| Ship implementation  | `/ship`   |
+| Need                | Command   |
+| ------------------- | --------- |
+| Design from scratch | `/design` |
+| Ship implementation | `/ship`   |

package/dist/template/.opencode/command/ui-slop-check.md

@@ -15,16 +15,17 @@ Run a focused anti-slop audit against changed UI files using the frontend-design
 skill({ name: "frontend-design" }); // Anti-pattern taxonomy + design references
 skill({ name: "visual-analysis" }); // Structured visual/code analysis workflow
 skill({ name: "accessibility-audit" }); // Keyboard/focus/contrast checks
+skill({ name: "ux-quality-gates" }); // UX correctness gates beyond visual slop
 ```
 
 ## Parse Arguments
 
-| Argument        | Default | Description                                                   |
-| --------------- | ------- | ------------------------------------------------------------- |
-| `[path\|auto]`  | `auto`  | Specific file/dir to audit, or auto-detect changed UI files   |
-| `--staged`      | false   | Audit staged changes only (`git diff --cached`)               |
-| `--since=<ref>` | `HEAD`  | Compare against ref (`main`, `HEAD~1`, commit SHA)            |
-| `--full-report` | false   | Include all categories even when no issues found              |
+| Argument        | Default | Description                                                 |
+| --------------- | ------- | ----------------------------------------------------------- |
+| `[path\|auto]`  | `auto`  | Specific file/dir to audit, or auto-detect changed UI files |
+| `--staged`      | false   | Audit staged changes only (`git diff --cached`)             |
+| `--since=<ref>` | `HEAD`  | Compare against ref (`main`, `HEAD~1`, commit SHA)          |
+| `--full-report` | false   | Include all categories even when no issues found            |
 
 ## Phase 1: Resolve Target Files
 
@@ -96,12 +97,34 @@ Evaluate each target file (or rendered screenshot if provided) against these che
 - Error copy includes what happened + why + how to fix
 - Empty states include guidance + next action
 - Terminology is consistent (avoid mixed synonyms for same action)
+- User-facing labels avoid implementation terms, database names, and internal acronyms
 
-### F) Accessibility Safety Nets
+### F) UX Quality Gates
+
+- One dominant filled primary action per view/section
+- Destructive actions require explicit confirm or undo, with specific entity/count in copy
+- No placeholder-as-label form fields
+- Form errors are associated with controls (`aria-describedby`, `aria-invalid`, `role="alert"`)
+- Submit/loading states prevent double-submit without layout shift
+- Empty, loading, error, and success states exist where async/data flows exist
+- Error toasts/banners persist long enough and include retry/undo/support where applicable
+- Data-heavy UI distinguishes empty state from filtered no-results state
+- Bulk actions show selected count and confirm destructive scope
+
+### G) Accessibility Safety Nets
 
 - Keyboard-visible focus treatment (`:focus-visible`)
 - Contrast baseline expectations (WCAG AA)
 - Touch targets reasonable (44x44 context where applicable)
+- Native semantic elements are used before ARIA patches (`button`, `a`, `form`, landmarks)
+- Heading structure has one logical `h1` per page/screen context
+
+### H) Component Family Consistency
+
+- Buttons and inputs in the same form share height, radius, border, and focus treatment
+- Focus, error, disabled, and loading states use the same token logic across components
+- No one-off radius/shadow/border width unless documented as a system-level exception
+- Semantic color roles are consistent: success, warning, destructive, info, primary
 
 ## Phase 3: Severity and Scoring
 

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

@@ -13,6 +13,7 @@ Check implementation against PRD before shipping.
 ```typescript
 skill({ name: "beads" });
 skill({ name: "verification-before-completion" });
+// If local web/browser verification needs stable URLs: skill({ name: "portless" });
 ```
 
 ## Parse Arguments
@@ -105,6 +106,8 @@ Follow the [Verification Protocol](../skill/verification-before-completion/refer
 1. **Parallel**: typecheck + lint (simultaneously)
 2. **Sequential** (after parallel passes): test, then build (ship only)
 
+For browser/manual local-web requirements, load the [portless](../skill/portless/SKILL.md) skill when stable named URLs would improve verification. Use only read-only Portless commands unless the user explicitly approves local networking changes; a reachable Portless URL supplements, but never replaces, typecheck/lint/test/build evidence.
+
 Report results with mode column:
 
 ```text

package/dist/template/.opencode/plugin/sdk/copilot/chat/convert-to-openai-compatible-chat-messages.ts

@@ -1,178 +1,172 @@
 import {
-	type LanguageModelV2Prompt,
-	type SharedV2ProviderMetadata,
-	UnsupportedFunctionalityError,
+  type LanguageModelV3Prompt,
+  type SharedV3ProviderOptions,
+  UnsupportedFunctionalityError,
 } from "@ai-sdk/provider";
 import { convertToBase64 } from "@ai-sdk/provider-utils";
 import type { OpenAICompatibleChatPrompt } from "./openai-compatible-api-types.js";
 
-function getOpenAIMetadata(message: {
-	providerOptions?: SharedV2ProviderMetadata;
-}) {
-	return message?.providerOptions?.copilot ?? {};
+function getOpenAIMetadata(message: { providerOptions?: SharedV3ProviderOptions }) {
+  return message?.providerOptions?.copilot ?? {};
 }
 
 export function convertToOpenAICompatibleChatMessages(
-	prompt: LanguageModelV2Prompt,
+  prompt: LanguageModelV3Prompt,
 ): OpenAICompatibleChatPrompt {
-	const messages: OpenAICompatibleChatPrompt = [];
-	for (const { role, content, ...message } of prompt) {
-		const metadata = getOpenAIMetadata({ ...message });
-		switch (role) {
-			case "system": {
-				// v1.1.49 fix: Copilot API expects system message content as plain string,
-				// not array format. Array format causes AGENTS.md to be silently ignored.
-				messages.push({
-					role: "system",
-					content: content,
-					...metadata,
-				});
-				break;
-			}
-
-			case "user": {
-				if (content.length === 1 && content[0].type === "text") {
-					messages.push({
-						role: "user",
-						content: content[0].text,
-						...getOpenAIMetadata(content[0]),
-					});
-					break;
-				}
-
-				messages.push({
-					role: "user",
-					content: content.map((part) => {
-						const partMetadata = getOpenAIMetadata(part);
-						switch (part.type) {
-							case "text": {
-								return {
-									type: "text" as const,
-									text: part.text,
-									...partMetadata,
-								};
-							}
-							case "file": {
-								if (part.mediaType.startsWith("image/")) {
-									const mediaType =
-										part.mediaType === "image/*"
-											? "image/jpeg"
-											: part.mediaType;
-
-									return {
-										type: "image_url" as const,
-										image_url: {
-											url:
-												part.data instanceof URL
-													? part.data.toString()
-													: `data:${mediaType};base64,${convertToBase64(part.data)}`,
-										},
-										...partMetadata,
-									};
-								} else {
-									throw new UnsupportedFunctionalityError({
-										functionality: `file part media type ${part.mediaType}`,
-									});
-								}
-							}
-						}
-					}),
-					...metadata,
-				});
-
-				break;
-			}
-
-			case "assistant": {
-				let text = "";
-				let reasoningText: string | undefined;
-				let reasoningOpaque: string | undefined;
-				const toolCalls: Array<{
-					id: string;
-					type: "function";
-					function: { name: string; arguments: string };
-				}> = [];
-
-				for (const part of content) {
-					const partMetadata = getOpenAIMetadata(part);
-					// Check for reasoningOpaque on any part (may be attached to text/tool-call)
-					const partOpaque = (
-						part.providerOptions as { copilot?: { reasoningOpaque?: string } }
-					)?.copilot?.reasoningOpaque;
-					if (partOpaque && !reasoningOpaque) {
-						reasoningOpaque = partOpaque;
-					}
-
-					switch (part.type) {
-						case "text": {
-							text += part.text;
-							break;
-						}
-						case "reasoning": {
-							reasoningText = part.text;
-							break;
-						}
-						case "tool-call": {
-							toolCalls.push({
-								id: part.toolCallId,
-								type: "function",
-								function: {
-									name: part.toolName,
-									arguments: JSON.stringify(part.input),
-								},
-								...partMetadata,
-							});
-							break;
-						}
-					}
-				}
-
-				messages.push({
-					role: "assistant",
-					content: text || null,
-					tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
-					reasoning_text: reasoningText,
-					reasoning_opaque: reasoningOpaque,
-					...metadata,
-				});
-
-				break;
-			}
-
-			case "tool": {
-				for (const toolResponse of content) {
-					const output = toolResponse.output;
-
-					let contentValue: string;
-					switch (output.type) {
-						case "text":
-						case "error-text":
-							contentValue = output.value;
-							break;
-						case "content":
-						case "json":
-						case "error-json":
-							contentValue = JSON.stringify(output.value);
-							break;
-					}
-
-					const toolResponseMetadata = getOpenAIMetadata(toolResponse);
-					messages.push({
-						role: "tool",
-						tool_call_id: toolResponse.toolCallId,
-						content: contentValue,
-						...toolResponseMetadata,
-					});
-				}
-				break;
-			}
-
-			default: {
-				const _exhaustiveCheck: never = role;
-				throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
-			}
-		}
-	}
-
-	return messages;
+  const messages: OpenAICompatibleChatPrompt = [];
+  for (const { role, content, ...message } of prompt) {
+    const metadata = getOpenAIMetadata({ ...message });
+    switch (role) {
+      case "system": {
+        messages.push({
+          role: "system",
+          content: content,
+          ...metadata,
+        });
+        break;
+      }
+
+      case "user": {
+        if (content.length === 1 && content[0].type === "text") {
+          messages.push({
+            role: "user",
+            content: content[0].text,
+            ...getOpenAIMetadata(content[0]),
+          });
+          break;
+        }
+
+        messages.push({
+          role: "user",
+          content: content.map((part) => {
+            const partMetadata = getOpenAIMetadata(part);
+            switch (part.type) {
+              case "text": {
+                return { type: "text" as const, text: part.text, ...partMetadata };
+              }
+              case "file": {
+                if (part.mediaType.startsWith("image/")) {
+                  const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
+
+                  return {
+                    type: "image_url" as const,
+                    image_url: {
+                      url:
+                        part.data instanceof URL
+                          ? part.data.toString()
+                          : `data:${mediaType};base64,${convertToBase64(part.data)}`,
+                    },
+                    ...partMetadata,
+                  };
+                } else {
+                  throw new UnsupportedFunctionalityError({
+                    functionality: `file part media type ${part.mediaType}`,
+                  });
+                }
+              }
+            }
+          }),
+          ...metadata,
+        });
+
+        break;
+      }
+
+      case "assistant": {
+        let text = "";
+        let reasoningText: string | undefined;
+        let reasoningOpaque: string | undefined;
+        const toolCalls: Array<{
+          id: string;
+          type: "function";
+          function: { name: string; arguments: string };
+        }> = [];
+
+        for (const part of content) {
+          const partMetadata = getOpenAIMetadata(part);
+          // Check for reasoningOpaque on any part (may be attached to text/tool-call)
+          const partOpaque = (part.providerOptions as { copilot?: { reasoningOpaque?: string } })
+            ?.copilot?.reasoningOpaque;
+          if (partOpaque && !reasoningOpaque) {
+            reasoningOpaque = partOpaque;
+          }
+
+          switch (part.type) {
+            case "text": {
+              text += part.text;
+              break;
+            }
+            case "reasoning": {
+              if (part.text) reasoningText = part.text;
+              break;
+            }
+            case "tool-call": {
+              toolCalls.push({
+                id: part.toolCallId,
+                type: "function",
+                function: {
+                  name: part.toolName,
+                  arguments: JSON.stringify(part.input),
+                },
+                ...partMetadata,
+              });
+              break;
+            }
+          }
+        }
+
+        messages.push({
+          role: "assistant",
+          content: text || null,
+          tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+          reasoning_text: reasoningOpaque ? reasoningText : undefined,
+          reasoning_opaque: reasoningOpaque,
+          ...metadata,
+        });
+
+        break;
+      }
+
+      case "tool": {
+        for (const toolResponse of content) {
+          if (toolResponse.type === "tool-approval-response") {
+            continue;
+          }
+          const output = toolResponse.output;
+
+          let contentValue: string;
+          switch (output.type) {
+            case "text":
+            case "error-text":
+              contentValue = output.value;
+              break;
+            case "execution-denied":
+              contentValue = output.reason ?? "Tool execution denied.";
+              break;
+            case "content":
+            case "json":
+            case "error-json":
+              contentValue = JSON.stringify(output.value);
+              break;
+          }
+
+          const toolResponseMetadata = getOpenAIMetadata(toolResponse);
+          messages.push({
+            role: "tool",
+            tool_call_id: toolResponse.toolCallId,
+            content: contentValue,
+            ...toolResponseMetadata,
+          });
+        }
+        break;
+      }
+
+      default: {
+        const _exhaustiveCheck: never = role;
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+
+  return messages;
 }

package/dist/template/.opencode/plugin/sdk/copilot/chat/map-openai-compatible-finish-reason.ts

@@ -1,19 +1,19 @@
-import type { LanguageModelV2FinishReason } from "@ai-sdk/provider";
+import type { LanguageModelV3FinishReason } from "@ai-sdk/provider";
 
 export function mapOpenAICompatibleFinishReason(
-	finishReason: string | null | undefined,
-): LanguageModelV2FinishReason {
-	switch (finishReason) {
-		case "stop":
-			return "stop";
-		case "length":
-			return "length";
-		case "content_filter":
-			return "content-filter";
-		case "function_call":
-		case "tool_calls":
-			return "tool-calls";
-		default:
-			return "unknown";
-	}
+  finishReason: string | null | undefined,
+): LanguageModelV3FinishReason["unified"] {
+  switch (finishReason) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "content_filter":
+      return "content-filter";
+    case "function_call":
+    case "tool_calls":
+      return "tool-calls";
+    default:
+      return "other";
+  }
 }