opencode-rules-md 0.6.5

package/src/runtime.ts

@@ -0,0 +1,369 @@
+import { readAndFormatRules, type RuleFilterContext } from './rule-filter.js';
+import { extractFilePathsFromMessages } from './message-paths.js';
+import { type DiscoveredRule } from './rule-discovery.js';
+import {
+  extractLatestUserPrompt,
+  extractSessionID,
+  normalizeContextPath,
+  sanitizePathForContext,
+  toExtractableMessages,
+  type MessageWithInfo,
+} from './message-context.js';
+import { extractConnectedMcpCapabilityIDs } from './mcp-tools.js';
+import { createDebugLog, type DebugLog } from './debug.js';
+import type { SessionStore } from './session-store.js';
+import {
+  buildFilterContext,
+  type BuildFilterContextOptions,
+} from './runtime-context.js';
+import {
+  handleChatMessage,
+  type ChatMessageInput,
+  type ChatMessageOutput,
+} from './runtime-chat.js';
+import { writeActiveRulesState } from './active-rules-state.js';
+
+interface MessagesTransformOutput {
+  messages: MessageWithInfo[];
+}
+
+interface SystemTransformInput {
+  sessionID?: string;
+}
+
+interface SystemTransformOutput {
+  system?: string | string[];
+}
+
+interface OpenCodeRulesRuntimeOptions {
+  client: unknown;
+  directory: string;
+  projectDirectory: string;
+  ruleFiles: DiscoveredRule[];
+  sessionStore: SessionStore;
+  debugLog?: DebugLog;
+  now?: () => number;
+}
+
+export class OpenCodeRulesRuntime {
+  private client: unknown;
+  private directory: string;
+  private projectDirectory: string;
+  private ruleFiles: DiscoveredRule[];
+  private sessionStore: SessionStore;
+  private debugLog: DebugLog;
+  private now: () => number;
+
+  constructor(opts: OpenCodeRulesRuntimeOptions) {
+    this.client = opts.client;
+    this.directory = opts.directory;
+    this.projectDirectory = opts.projectDirectory;
+    this.ruleFiles = opts.ruleFiles;
+    this.sessionStore = opts.sessionStore;
+    this.debugLog = opts.debugLog ?? createDebugLog();
+    this.now = opts.now ?? (() => Date.now());
+  }
+
+  createHooks(): Record<string, unknown> {
+    return {
+      'tool.execute.before': this.onToolExecuteBefore.bind(this),
+      'experimental.chat.messages.transform':
+        this.onMessagesTransform.bind(this),
+      'chat.message': this.onChatMessage.bind(this),
+      'experimental.chat.system.transform': this.onSystemTransform.bind(this),
+      'experimental.session.compacting': this.onSessionCompacting.bind(this),
+    };
+  }
+
+  private async onToolExecuteBefore(
+    input: { tool?: string; sessionID?: string; callID?: string },
+    output: { args?: Record<string, unknown> }
+  ): Promise<void> {
+    const sessionID = input?.sessionID;
+    const toolName = input?.tool;
+    const args = output?.args;
+
+    if (!sessionID || !toolName || !args) {
+      return;
+    }
+
+    let filePath: string | undefined;
+
+    if (['read', 'edit', 'write'].includes(toolName)) {
+      const arg = args.filePath;
+      if (typeof arg === 'string' && arg.length > 0) {
+        filePath = arg;
+      }
+    } else if (['glob', 'grep'].includes(toolName)) {
+      const arg = args.path;
+      if (typeof arg === 'string' && arg.length > 0) {
+        filePath = arg;
+      }
+    } else if (toolName === 'bash') {
+      const arg = args.workdir;
+      if (typeof arg === 'string' && arg.length > 0) {
+        filePath = arg;
+      }
+    }
+
+    if (filePath) {
+      const normalized = normalizeContextPath(filePath, this.projectDirectory);
+      this.sessionStore.upsert(sessionID, state => {
+        state.contextPaths.add(normalized);
+      });
+
+      this.debugLog(
+        `Recorded context path from tool ${toolName}: ${normalized}`
+      );
+    }
+  }
+
+  private async onMessagesTransform(
+    _input: Record<string, never>,
+    output: MessagesTransformOutput
+  ): Promise<MessagesTransformOutput> {
+    const sessionID = extractSessionID(output.messages);
+    if (!sessionID) {
+      this.debugLog('No sessionID found in messages');
+      return output;
+    }
+
+    const existingState = this.sessionStore.get(sessionID);
+    if (existingState && existingState.seededFromHistory) {
+      this.debugLog(`Session ${sessionID} already seeded, skipping rescan`);
+      return output;
+    }
+
+    const contextPaths = extractFilePathsFromMessages(
+      toExtractableMessages(output.messages)
+    );
+    const userPrompt = extractLatestUserPrompt(output.messages);
+
+    this.sessionStore.upsert(sessionID, state => {
+      for (const p of contextPaths) {
+        state.contextPaths.add(normalizeContextPath(p, this.projectDirectory));
+      }
+      if (userPrompt && !state.lastUserPrompt) {
+        state.lastUserPrompt = userPrompt;
+      }
+      state.seededFromHistory = true;
+      state.seedCount = (state.seedCount ?? 0) + 1;
+    });
+
+    if (contextPaths.length > 0) {
+      this.debugLog(
+        `Seeded ${contextPaths.length} context path(s) for session ${sessionID}: ${contextPaths
+          .slice(0, 5)
+          .join(', ')}${contextPaths.length > 5 ? '...' : ''}`
+      );
+    }
+
+    if (userPrompt) {
+      this.debugLog(
+        `Seeded user prompt for session ${sessionID} (len=${userPrompt.length})`
+      );
+    }
+
+    return output;
+  }
+
+  private async onChatMessage(
+    input: ChatMessageInput,
+    output: ChatMessageOutput
+  ): Promise<void> {
+    handleChatMessage(input, output, this.sessionStore, this.debugLog);
+  }
+
+  private async onSystemTransform(
+    hookInput: SystemTransformInput,
+    output: SystemTransformOutput | null
+  ): Promise<SystemTransformOutput> {
+    const sessionID = hookInput?.sessionID;
+    const sessionState = sessionID
+      ? this.sessionStore.get(sessionID)
+      : undefined;
+
+    if (sessionID) {
+      const skip = this.sessionStore.shouldSkipInjection(
+        sessionID,
+        this.now(),
+        30_000
+      );
+      if (skip) {
+        this.debugLog(
+          `Session ${sessionID} is compacting - skipping rule injection`
+        );
+        return output ?? {};
+      }
+    }
+
+    if (sessionState?.rulesInjected) {
+      this.debugLog(
+        `Session ${sessionID} already has rules injected - skipping to prevent loop`
+      );
+      return output ?? {};
+    }
+
+    const contextPaths = sessionState
+      ? Array.from(sessionState.contextPaths).sort((a, b) => a.localeCompare(b))
+      : [];
+    const userPrompt = sessionState?.lastUserPrompt;
+
+    const availableToolIDs = await this.queryAvailableToolIDs();
+
+    const filterContextOpts: BuildFilterContextOptions = {
+      contextFilePaths: contextPaths,
+      userPrompt,
+      availableToolIDs,
+      modelID: sessionState?.lastModelID,
+      agentType: sessionState?.lastAgentType,
+    };
+
+    const filterContext: RuleFilterContext = await buildFilterContext(
+      filterContextOpts,
+      this.projectDirectory,
+      this.debugLog
+    );
+
+    const { formattedRules, matchedPaths } = await readAndFormatRules(
+      this.ruleFiles,
+      filterContext
+    );
+
+    if (sessionID) {
+      writeActiveRulesState(sessionID, matchedPaths);
+    }
+
+    if (!formattedRules) {
+      this.debugLog('No applicable rules for current context');
+      return output ?? {};
+    }
+
+    this.debugLog('Injecting rules into system prompt');
+
+    if (!output) {
+      if (sessionID) {
+        this.sessionStore.upsert(sessionID, state => {
+          state.rulesInjected = true;
+          state.lastInjectedAt = this.now();
+        });
+      }
+      return { system: formattedRules };
+    }
+
+    if (Array.isArray(output.system)) {
+      output.system.push(formattedRules);
+    } else {
+      output.system = output.system
+        ? `${output.system}\n\n${formattedRules}`
+        : formattedRules;
+    }
+
+    if (sessionID) {
+      this.sessionStore.upsert(sessionID, state => {
+        state.rulesInjected = true;
+        state.lastInjectedAt = this.now();
+      });
+    }
+
+    return output;
+  }
+
+  private async queryAvailableToolIDs(): Promise<string[]> {
+    const ids = new Set<string>();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const client = this.client as any;
+    const query = { directory: this.directory };
+
+    const [toolResult, mcpResult] = await Promise.allSettled([
+      client.tool?.ids?.({ query }),
+      client.mcp?.status?.({ query }),
+    ]);
+
+    if (
+      toolResult.status === 'fulfilled' &&
+      Array.isArray(toolResult.value?.data)
+    ) {
+      for (const id of toolResult.value.data) {
+        ids.add(id);
+      }
+      this.debugLog(
+        `Built-in tools: ${toolResult.value.data.slice(0, 10).join(', ')}${toolResult.value.data.length > 10 ? '...' : ''} (${toolResult.value.data.length} total)`
+      );
+    } else if (toolResult.status === 'rejected') {
+      const message =
+        toolResult.reason instanceof Error
+          ? toolResult.reason.message
+          : String(toolResult.reason);
+      console.warn(
+        `[opencode-rules-md] Warning: Failed to query tool IDs: ${message}`
+      );
+    }
+
+    if (mcpResult.status === 'fulfilled' && mcpResult.value?.data) {
+      const mcpIds = extractConnectedMcpCapabilityIDs(mcpResult.value.data);
+      for (const id of mcpIds) {
+        ids.add(id);
+      }
+      if (mcpIds.length > 0) {
+        this.debugLog(`MCP capability IDs: ${mcpIds.join(', ')}`);
+      }
+    } else if (mcpResult.status === 'rejected') {
+      const message =
+        mcpResult.reason instanceof Error
+          ? mcpResult.reason.message
+          : String(mcpResult.reason);
+      console.warn(
+        `[opencode-rules-md] Warning: Failed to query MCP status: ${message}`
+      );
+    }
+
+    return Array.from(ids);
+  }
+
+  private async onSessionCompacting(
+    input: { sessionID?: string },
+    output: { context?: string[] }
+  ): Promise<void> {
+    const sessionID = input?.sessionID;
+    if (!sessionID) {
+      this.debugLog('No sessionID in compacting hook input');
+      return;
+    }
+
+    const sessionState = this.sessionStore.get(sessionID);
+    if (!sessionState || sessionState.contextPaths.size === 0) {
+      this.debugLog(
+        `No context paths for session ${sessionID} during compaction`
+      );
+      return;
+    }
+
+    this.sessionStore.markCompacting(sessionID, this.now());
+
+    const sortedPaths = Array.from(sessionState.contextPaths).sort((a, b) =>
+      a.localeCompare(b)
+    );
+    const maxPaths = 20;
+    const pathsToInclude = sortedPaths.slice(0, maxPaths);
+
+    const contextString = [
+      'OpenCode Rules: Working context',
+      'Current file paths in context:',
+      ...pathsToInclude.map(p => `  - ${sanitizePathForContext(p)}`),
+      ...(sortedPaths.length > maxPaths
+        ? [`  ... and ${sortedPaths.length - maxPaths} more paths`]
+        : []),
+    ].join('\n');
+
+    if (!output.context) {
+      output.context = [];
+    }
+
+    output.context.push(contextString);
+
+    this.debugLog(
+      `Added ${pathsToInclude.length} context path(s) to compaction for session ${sessionID}`
+    );
+  }
+}

package/src/session-store.ts

@@ -0,0 +1,129 @@
+export interface SessionState {
+  contextPaths: Set<string>;
+  lastUserPrompt?: string;
+  lastUpdated: number;
+  isCompacting?: boolean;
+  compactingSince?: number;
+  seededFromHistory: boolean;
+  seedCount?: number;
+  lastModelID?: string;
+  lastAgentType?: string;
+  rulesInjected?: boolean;
+  lastInjectedAt?: number;
+}
+
+interface SessionStoreOptions {
+  max?: number;
+}
+
+export class SessionStore {
+  private stateMap = new Map<string, SessionState>();
+  private max: number;
+  private tick = 0;
+
+  constructor(opts: SessionStoreOptions = {}) {
+    this.max = opts.max ?? 100;
+  }
+
+  setMax(limit: number): void {
+    this.max = limit;
+  }
+
+  ids(): string[] {
+    return Array.from(this.stateMap.keys());
+  }
+
+  get(sessionID: string): SessionState | undefined {
+    return this.stateMap.get(sessionID);
+  }
+
+  snapshot(sessionID: string): SessionState | undefined {
+    const s = this.stateMap.get(sessionID);
+    if (!s) return undefined;
+    return {
+      ...s,
+      contextPaths: new Set(s.contextPaths),
+    };
+  }
+
+  reset(): void {
+    this.stateMap.clear();
+    this.max = 100;
+    this.tick = 0;
+  }
+
+  upsert(sessionID: string, mutator: (state: SessionState) => void): void {
+    let state = this.stateMap.get(sessionID);
+    if (!state) {
+      state = this.createDefaultState();
+      this.stateMap.set(sessionID, state);
+    }
+
+    mutator(state);
+
+    // Match existing semantics: overwrite lastUpdated after mutation.
+    state.lastUpdated = ++this.tick;
+
+    while (this.stateMap.size > this.max) {
+      let oldestID: string | null = null;
+      let oldestTime = Infinity;
+
+      for (const [id, st] of this.stateMap.entries()) {
+        if (st.lastUpdated < oldestTime) {
+          oldestTime = st.lastUpdated;
+          oldestID = id;
+        }
+      }
+
+      if (oldestID) {
+        this.stateMap.delete(oldestID);
+      }
+    }
+  }
+
+  markCompacting(sessionID: string, nowMs: number): void {
+    this.upsert(sessionID, state => {
+      state.isCompacting = true;
+      state.compactingSince = nowMs;
+    });
+  }
+
+  shouldSkipInjection(
+    sessionID: string,
+    nowMs: number,
+    ttlMs = 30_000
+  ): boolean {
+    const state = this.stateMap.get(sessionID);
+    if (!state?.isCompacting) return false;
+
+    // Preserve existing behavior: missing timestamp means "still compacting".
+    if (!state.compactingSince) {
+      return true;
+    }
+
+    const expired = nowMs - state.compactingSince > ttlMs;
+    if (!expired) {
+      return true;
+    }
+
+    this.upsert(sessionID, s => {
+      s.isCompacting = false;
+    });
+
+    return false;
+  }
+
+  private createDefaultState(): SessionState {
+    // Match existing semantics: tick increments on creation, then again on upsert.
+    return {
+      contextPaths: new Set<string>(),
+      lastUpdated: ++this.tick,
+      seededFromHistory: false,
+      seedCount: 0,
+    };
+  }
+}
+
+export function createSessionStore(opts?: SessionStoreOptions): SessionStore {
+  return new SessionStore(opts ?? { max: 100 });
+}

package/src/utils.ts

@@ -0,0 +1,36 @@
+/**
+ * Utility functions for OpenCode Rules Plugin
+ *
+ * This module serves as a compatibility facade that re-exports
+ * from focused modules:
+ * - rule-discovery.ts: File discovery and caching
+ * - rule-metadata.ts: Frontmatter parsing
+ * - rule-filter.ts: Rule filtering and formatting
+ * - message-paths.ts: Message path extraction
+ */
+
+// Re-export from rule-discovery
+export {
+  discoverRuleFiles,
+  clearRuleCache,
+  type DiscoveredRule,
+} from './rule-discovery.js';
+
+// Re-export from rule-metadata (RuleMetadata is internal, not re-exported)
+export { parseRuleMetadata } from './rule-metadata.js';
+
+// Re-export from rule-filter
+export {
+  promptMatchesKeywords,
+  toolsMatchAvailable,
+  readAndFormatRules,
+  type RuleFilterContext,
+  type FilterResult,
+} from './rule-filter.js';
+
+// Re-export from message-paths
+export {
+  extractFilePathsFromMessages,
+  type Message,
+  type MessagePart,
+} from './message-paths.js';

package/tui/.atl/.skill-registry.cache.json

@@ -0,0 +1,3 @@
+{
+  "fingerprint": "18d17ed2835d3b3e0683b8421e3f9f306bc8764b"
+}

package/tui/.atl/skill-registry.md

@@ -0,0 +1,57 @@
+# Skill Registry — tui
+
+<!-- Auto-generated by gentle-ai skill-registry refresh. Run `gentle-ai skill-registry refresh --force` to regenerate. -->
+
+Last updated: 2026-07-08
+
+## Sources scanned
+
+- /home/metalbolicx/.config/opencode/skills
+- /home/metalbolicx/.claude/skills
+
+## Contract
+
+**Delegator use only.** This registry is an index, not a summary. Any agent that launches subagents reads it to select relevant skills, then passes exact `SKILL.md` paths for the subagent to read before work.
+
+`SKILL.md` remains the source of truth. Do not inject generated summaries or compact rules by default; pass paths so subagents load the full runtime contract and preserve author intent.
+
+## Skills
+
+| Skill | Trigger / description | Scope | Path |
+| --- | --- | --- | --- |
+| `branch-pr` | Create Gentle AI pull requests with issue-first checks. Trigger: creating, opening, or preparing PRs for review. | user | `/home/metalbolicx/.config/opencode/skills/branch-pr/SKILL.md` |
+| `chained-pr` | Trigger: PRs over 400 lines, stacked PRs, review slices. Split oversized changes into chained PRs that protect review focus. | user | `/home/metalbolicx/.config/opencode/skills/chained-pr/SKILL.md` |
+| `cognitive-doc-design` | Design docs that reduce cognitive load. Trigger: writing guides, READMEs, RFCs, onboarding, architecture, or review-facing docs. | user | `/home/metalbolicx/.config/opencode/skills/cognitive-doc-design/SKILL.md` |
+| `comment-writer` | Write warm, direct collaboration comments. Trigger: PR feedback, issue replies, reviews, Slack messages, or GitHub comments. | user | `/home/metalbolicx/.config/opencode/skills/comment-writer/SKILL.md` |
+| `commit-process` | Walks from git diff to a well-crafted commit message and executes the commit. | user | `/home/metalbolicx/.claude/skills/commit-process/SKILL.md` |
+| `conceptual-grill` | Interview the user relentlessly about a theoretical plan or design to forge a shared mental model from scratch without a codebase. | user | `/home/metalbolicx/.claude/skills/conceptual-grill/SKILL.md` |
+| `diagnose` | Disciplined diagnosis loop for hard bugs and performance regressions. Reproduce -> minimise -> hypothesise -> instrument -> fix -> regression-test. Use when user says \"diagnose this\" / \"debug this\", reports a bug, says something is broken/throwing/failing, or describes a performance regression. | user | `/home/metalbolicx/.claude/skills/diagnose/SKILL.md` |
+| `doc-comments` | Context-aware documentation and type-hinting tool. Analyzes code to inject language-specific documentation and strict type hints while maintaining original logic. | user | `/home/metalbolicx/.claude/skills/doc-comments/SKILL.md` |
+| `docsify-docs-editor` | Architects and mutates a modular Docsify documentation suite. Enforces strict technical clarity, accurate component mapping, and deterministic diagram generation. | user | `/home/metalbolicx/.claude/skills/docsify-docs-editor/SKILL.md` |
+| `go-testing` | Trigger: Go tests, go test coverage, Bubbletea teatest, golden files. Apply focused Go testing patterns. | user | `/home/metalbolicx/.config/opencode/skills/go-testing/SKILL.md` |
+| `good-comments` | Refactors or adds code comments to emphasize the 'why' (intent, rationale) and 'how' (complex mechanics, edge cases) over the 'what' (syntax). | user | `/home/metalbolicx/.claude/skills/good-comments/SKILL.md` |
+| `grill-me` | Relentlessly interrogates the user to stress-test architectural plans or designs by systematically navigating decision trees. | user | `/home/metalbolicx/.claude/skills/grill-me/SKILL.md` |
+| `handoff` | Compacts the current conversation into a modular handoff document for a seamless transition to another agent. Avoids redundancy by linking to existing artifacts. | user | `/home/metalbolicx/.claude/skills/handoff/SKILL.md` |
+| `improve` | Survey any codebase as a senior advisor and produce prioritized, self-contained plans for other agents to execute. Read-only on source code; never implements, fixes, or refactors directly. | user | `/home/metalbolicx/.claude/skills/improve/SKILL.md` |
+| `issue-creation` | Create Gentle AI issues with issue-first checks. Trigger: creating GitHub issues, bug reports, or feature requests. | user | `/home/metalbolicx/.config/opencode/skills/issue-creation/SKILL.md` |
+| `judgment-day` | Trigger: judgment day, dual review, adversarial review, juzgar. Run blind dual review, fix confirmed issues, then re-judge. | user | `/home/metalbolicx/.config/opencode/skills/judgment-day/SKILL.md` |
+| `mermaid-diagram-generator` | Generates highly accurate, syntactically correct Mermaid diagrams based on user requirements. Supports over 23 diagram types including flowcharts, architecture diagrams, and timelines. | user | `/home/metalbolicx/.claude/skills/mermaid-diagram-generator/SKILL.md` |
+| `opencode-choice` | Decide between Commands, Skills, and Agents in OpenCode. Provides a decision table and flowchart to pick the right extension type. | user | `/home/metalbolicx/.claude/skills/opencode-choice/SKILL.md` |
+| `readme-refactor` | Interactively refactors a README.md into a professional, codebase-accurate document. Analyzes code behavior and applies standardized formatting rules. | user | `/home/metalbolicx/.claude/skills/readme-refactor/SKILL.md` |
+| `refactor` | Surgical code refactoring to improve maintainability without changing behavior. Covers extracting functions, renaming variables, breaking down god functions, improving type safety, eliminating code smells, and applying design patterns. Less drastic than repo-rebuilder; use for gradual improvements. | user | `/home/metalbolicx/.claude/skills/refactor/SKILL.md` |
+| `refactor-skill` | Refactors and modularizes raw instructions into a standardized Agent Skill. Optimizes formatting for 3-Level tiered context loading and enforces Separation of Concerns to minimize token overhead. | user | `/home/metalbolicx/.claude/skills/refactor-skill/SKILL.md` |
+| `rename-refactoring` | Refactors identifiers within code blocks to improve clarity, maintainability, and domain alignment. It operates strictly on naming conventions without altering underlying logic or structural flow. | user | `/home/metalbolicx/.claude/skills/rename-refactoring/SKILL.md` |
+| `review` | Review the changes since a fixed point (commit, branch, tag) along two axes: Standards and Spec. Runs both reviews in parallel sub-agents and reports them side by side. | user | `/home/metalbolicx/.claude/skills/review/SKILL.md` |
+| `skill-creator` | Trigger: new skills, agent instructions, documenting AI usage patterns. Create LLM-first skills with valid frontmatter. | user | `/home/metalbolicx/.config/opencode/skills/skill-creator/SKILL.md` |
+| `skill-improver` | Trigger: improve skills, audit skills, refactor skills, skill quality. Audit and upgrade existing LLM-first skills. | user | `/home/metalbolicx/.config/opencode/skills/skill-improver/SKILL.md` |
+| `ubiquitous-language` | Extracts a Domain-Driven Design ubiquitous language glossary from conversations. Helps resolve ambiguities and establishes canonical domain terminology. | user | `/home/metalbolicx/.claude/skills/ubiquitous-language/SKILL.md` |
+| `web-coder` | Expert 10x engineer with comprehensive knowledge of web development, internet protocols, and web standards. Use when working with HTML, CSS, JavaScript, web APIs, HTTP/HTTPS, web security, performance optimization, accessibility, or any web/internet concepts. Specializes in translating web terminology accurately and implementing modern web standards across frontend and backend development. | user | `/home/metalbolicx/.claude/skills/web-coder/SKILL.md` |
+| `work-unit-commits` | Plan commits as reviewable work units. Trigger: implementation, commit splitting, chained PRs, or keeping tests and docs with code. | user | `/home/metalbolicx/.config/opencode/skills/work-unit-commits/SKILL.md` |
+| `write-a-skill` | Create new agent skills with proper structure, progressive disclosure, and bundled resources. Use when user wants to create, write, or build a new agent skill. | user | `/home/metalbolicx/.claude/skills/write-a-skill/SKILL.md` |
+
+## Loading protocol
+
+1. Match task context and target files against the `Trigger / description` column.
+2. Pass only the matching `Path` values to the subagent under `## Skills to load before work`.
+3. Instruct the subagent to read those exact `SKILL.md` files before reading, writing, reviewing, testing, or creating artifacts.
+4. If no matching skill exists, proceed without project skill injection and report `skill_resolution: none`.