thoth-agents 0.11.0 → 0.12.0

package/dist/opencode/agents.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '@opencode/plugin';
+import type { OpenCodeDependencies } from './context';
+export declare function registerAgents(ctx: Plugin.Context, deps: OpenCodeDependencies): Promise<void>;

package/dist/opencode/command.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '@opencode/plugin';
+import type { OpenCodeDependencies } from './context';
+export declare function registerCommand(ctx: Plugin.Context, deps: OpenCodeDependencies): Promise<void>;

package/dist/opencode/context.d.ts

@@ -0,0 +1,20 @@
+import type { Plugin } from '@opencode/plugin';
+import { type AgentDefinition } from '../agents';
+import { type PluginConfig } from '../config';
+import { renderOpenCodeAgentConfigs } from '../harness/adapters/opencode';
+type ModelEntry = {
+    id: string;
+    variant?: string;
+};
+export interface OpenCodeDependencies {
+    directory: string;
+    packageRoot: string;
+    config: PluginConfig;
+    agentDefs: AgentDefinition[];
+    agents: ReturnType<typeof renderOpenCodeAgentConfigs>;
+    modelArrayMap: Record<string, ModelEntry[]>;
+    effectiveModelArrays: Record<string, ModelEntry[]>;
+    runtimeChains: Record<string, string[]>;
+}
+export declare function loadOpenCodeDependencies(ctx: Plugin.Context): OpenCodeDependencies;
+export {};

package/dist/opencode/delegation-hooks.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '@opencode/plugin';
+import type { OpenCodeDependencies } from './context';
+export declare function registerDelegationHooks(ctx: Plugin.Context, deps: OpenCodeDependencies): Promise<void>;

package/dist/opencode/mcp.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '@opencode/plugin';
+import type { OpenCodeDependencies } from './context';
+export declare function registerMcp(ctx: Plugin.Context, deps: OpenCodeDependencies): Promise<void>;

package/dist/opencode/permission-rules.d.ts

@@ -0,0 +1,9 @@
+import type { AgentDefinition } from '../agents';
+type Effect = 'allow' | 'deny' | 'ask';
+export interface PermissionRule {
+    action: string;
+    resource: string;
+    effect: Effect;
+}
+export declare function translatePermissionRules(permission: AgentDefinition['config']['permission']): PermissionRule[];
+export {};

package/dist/opencode/permissions.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '@opencode/plugin';
+import type { OpenCodeDependencies } from './context';
+export declare function registerPermissions(ctx: Plugin.Context, deps: OpenCodeDependencies): Promise<void>;

package/dist/opencode/session-hooks.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '@opencode/plugin';
+import type { OpenCodeDependencies } from './context';
+export declare function registerSessionHooks(ctx: Plugin.Context, deps: OpenCodeDependencies): Promise<void>;

package/dist/opencode/session-state.d.ts

@@ -0,0 +1,39 @@
+import type { Plugin } from '@opencode/plugin';
+type SessionID = Parameters<Plugin.Context['session']['instructions']['entry']['put']>[0]['sessionID'];
+export type StateEvent = {
+    type: 'session.created';
+    data: {
+        sessionID: SessionID;
+        parentID?: SessionID;
+    };
+} | {
+    type: 'session.status';
+    data: {
+        sessionID: SessionID;
+        status: {
+            type: 'idle' | 'busy' | 'retry';
+        };
+    };
+} | {
+    type: 'session.deleted';
+    data: {
+        sessionID: SessionID;
+    };
+};
+/** Read-only record inventory plus live children. All updates are serialized. */
+export declare class SessionState {
+    private readonly directory;
+    private readonly instructions;
+    private readonly parents;
+    private readonly running;
+    private readonly published;
+    private readonly records;
+    private queue;
+    constructor(directory: string, instructions: Plugin.Context['session']['instructions']);
+    private serialize;
+    refresh(sessionID: SessionID): Promise<string>;
+    event(event: StateEvent): Promise<void>;
+    private inventory;
+    private publish;
+}
+export {};

package/dist/opencode/skills.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '@opencode/plugin';
+import type { OpenCodeDependencies } from './context';
+export declare function registerSkills(ctx: Plugin.Context, deps: OpenCodeDependencies): Promise<void>;

package/dist/opencode/tools.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '@opencode/plugin';
+import type { OpenCodeDependencies } from './context';
+export declare function registerTools(ctx: Plugin.Context, _deps: OpenCodeDependencies): Promise<void>;

package/dist/pi.js

@@ -1,17 +1,17 @@
 import {
   formatGateVerdict,
   summarizeGateResult
-} from "./chunk-RWQPMWEM.js";
+} from "./chunk-JLU3FSBT.js";
 import {
   PI_ROOT_END,
   PI_ROOT_START,
   createPiToolsPanelAdapter,
   renderPiRootInstructions,
   syncPiSpecialists
-} from "./chunk-5WPP6IY7.js";
+} from "./chunk-7F33WUSD.js";
 import {
   findPackageRoot
-} from "./chunk-DNPKVFOB.js";
+} from "./chunk-NY2IPJ7V.js";
 
 // src/pi.ts
 import { homedir } from "os";

package/dist/tools/ast-grep/cli.d.ts

@@ -1,5 +1,6 @@
 import type { CliLanguage, SgResult } from './types';
 export interface RunOptions {
+    signal?: AbortSignal;
     pattern: string;
     lang: CliLanguage;
     paths?: string[];

package/dist/tools/ast-grep/index.d.ts

@@ -1,6 +1,112 @@
-import type { ToolDefinition } from '@opencode-ai/plugin';
 import { ast_grep_replace, ast_grep_search } from './tools';
-export declare const builtinTools: Record<string, ToolDefinition>;
+export declare const builtinTools: {
+    ast_grep_search: {
+        name: string;
+        description: string;
+        input: import("zod").ZodObject<{
+            pattern: import("zod").ZodString;
+            lang: import("zod").ZodEnum<{
+                bash: "bash";
+                c: "c";
+                cpp: "cpp";
+                csharp: "csharp";
+                css: "css";
+                elixir: "elixir";
+                go: "go";
+                haskell: "haskell";
+                html: "html";
+                java: "java";
+                javascript: "javascript";
+                json: "json";
+                kotlin: "kotlin";
+                lua: "lua";
+                nix: "nix";
+                php: "php";
+                python: "python";
+                ruby: "ruby";
+                rust: "rust";
+                scala: "scala";
+                solidity: "solidity";
+                swift: "swift";
+                typescript: "typescript";
+                tsx: "tsx";
+                yaml: "yaml";
+            }>;
+            paths: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            globs: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            context: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        execute(input: {
+            pattern: string;
+            lang: "bash" | "c" | "cpp" | "csharp" | "css" | "elixir" | "go" | "haskell" | "html" | "java" | "javascript" | "json" | "kotlin" | "lua" | "nix" | "php" | "python" | "ruby" | "rust" | "scala" | "solidity" | "swift" | "typescript" | "tsx" | "yaml";
+            paths?: string[] | undefined;
+            globs?: string[] | undefined;
+            context?: number | undefined;
+        }, context: import("@opencode/plugin/promise/tool").ToolContext): Promise<{
+            content: string;
+            metadata: {
+                output: string;
+            };
+        } | {
+            content: string;
+            metadata?: undefined;
+        }>;
+    };
+    ast_grep_replace: {
+        name: string;
+        description: string;
+        input: import("zod").ZodObject<{
+            pattern: import("zod").ZodString;
+            rewrite: import("zod").ZodString;
+            lang: import("zod").ZodEnum<{
+                bash: "bash";
+                c: "c";
+                cpp: "cpp";
+                csharp: "csharp";
+                css: "css";
+                elixir: "elixir";
+                go: "go";
+                haskell: "haskell";
+                html: "html";
+                java: "java";
+                javascript: "javascript";
+                json: "json";
+                kotlin: "kotlin";
+                lua: "lua";
+                nix: "nix";
+                php: "php";
+                python: "python";
+                ruby: "ruby";
+                rust: "rust";
+                scala: "scala";
+                solidity: "solidity";
+                swift: "swift";
+                typescript: "typescript";
+                tsx: "tsx";
+                yaml: "yaml";
+            }>;
+            paths: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            globs: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            dryRun: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$strip>;
+        execute(input: {
+            pattern: string;
+            rewrite: string;
+            lang: "bash" | "c" | "cpp" | "csharp" | "css" | "elixir" | "go" | "haskell" | "html" | "java" | "javascript" | "json" | "kotlin" | "lua" | "nix" | "php" | "python" | "ruby" | "rust" | "scala" | "solidity" | "swift" | "typescript" | "tsx" | "yaml";
+            paths?: string[] | undefined;
+            globs?: string[] | undefined;
+            dryRun?: boolean | undefined;
+        }, context: import("@opencode/plugin/promise/tool").ToolContext): Promise<{
+            content: string;
+            metadata: {
+                output: string;
+            };
+        } | {
+            content: string;
+            metadata?: undefined;
+        }>;
+    };
+};
 export { ast_grep_search, ast_grep_replace };
 export { ensureCliAvailable, getAstGrepPath, isCliAvailable, startBackgroundInit, } from './cli';
 export type { EnvironmentCheckResult } from './constants';

package/dist/tools/ast-grep/tools.d.ts

@@ -1,3 +1,107 @@
-import { type ToolDefinition } from '@opencode-ai/plugin/tool';
-export declare const ast_grep_search: ToolDefinition;
-export declare const ast_grep_replace: ToolDefinition;
+import { z } from 'zod';
+export declare const ast_grep_search: {
+    name: string;
+    description: string;
+    input: z.ZodObject<{
+        pattern: z.ZodString;
+        lang: z.ZodEnum<{
+            bash: "bash";
+            c: "c";
+            cpp: "cpp";
+            csharp: "csharp";
+            css: "css";
+            elixir: "elixir";
+            go: "go";
+            haskell: "haskell";
+            html: "html";
+            java: "java";
+            javascript: "javascript";
+            json: "json";
+            kotlin: "kotlin";
+            lua: "lua";
+            nix: "nix";
+            php: "php";
+            python: "python";
+            ruby: "ruby";
+            rust: "rust";
+            scala: "scala";
+            solidity: "solidity";
+            swift: "swift";
+            typescript: "typescript";
+            tsx: "tsx";
+            yaml: "yaml";
+        }>;
+        paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        globs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        context: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    execute(input: {
+        pattern: string;
+        lang: "bash" | "c" | "cpp" | "csharp" | "css" | "elixir" | "go" | "haskell" | "html" | "java" | "javascript" | "json" | "kotlin" | "lua" | "nix" | "php" | "python" | "ruby" | "rust" | "scala" | "solidity" | "swift" | "typescript" | "tsx" | "yaml";
+        paths?: string[] | undefined;
+        globs?: string[] | undefined;
+        context?: number | undefined;
+    }, context: import("@opencode/plugin/promise/tool").ToolContext): Promise<{
+        content: string;
+        metadata: {
+            output: string;
+        };
+    } | {
+        content: string;
+        metadata?: undefined;
+    }>;
+};
+export declare const ast_grep_replace: {
+    name: string;
+    description: string;
+    input: z.ZodObject<{
+        pattern: z.ZodString;
+        rewrite: z.ZodString;
+        lang: z.ZodEnum<{
+            bash: "bash";
+            c: "c";
+            cpp: "cpp";
+            csharp: "csharp";
+            css: "css";
+            elixir: "elixir";
+            go: "go";
+            haskell: "haskell";
+            html: "html";
+            java: "java";
+            javascript: "javascript";
+            json: "json";
+            kotlin: "kotlin";
+            lua: "lua";
+            nix: "nix";
+            php: "php";
+            python: "python";
+            ruby: "ruby";
+            rust: "rust";
+            scala: "scala";
+            solidity: "solidity";
+            swift: "swift";
+            typescript: "typescript";
+            tsx: "tsx";
+            yaml: "yaml";
+        }>;
+        paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        globs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        dryRun: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    execute(input: {
+        pattern: string;
+        rewrite: string;
+        lang: "bash" | "c" | "cpp" | "csharp" | "css" | "elixir" | "go" | "haskell" | "html" | "java" | "javascript" | "json" | "kotlin" | "lua" | "nix" | "php" | "python" | "ruby" | "rust" | "scala" | "solidity" | "swift" | "typescript" | "tsx" | "yaml";
+        paths?: string[] | undefined;
+        globs?: string[] | undefined;
+        dryRun?: boolean | undefined;
+    }, context: import("@opencode/plugin/promise/tool").ToolContext): Promise<{
+        content: string;
+        metadata: {
+            output: string;
+        };
+    } | {
+        content: string;
+        metadata?: undefined;
+    }>;
+};

package/dist/tools/define-tool.d.ts

@@ -0,0 +1,23 @@
+import type { ToolContext } from '@opencode/plugin/promise/tool';
+import type { z } from 'zod';
+/** Adapt the existing text-producing tools to the host's v2 result contract. */
+export declare function defineTool<Input extends z.ZodType>(definition: {
+    name: string;
+    description: string;
+    input: Input;
+    showOutput?: boolean;
+    execute: (input: z.infer<Input>, context: ToolContext) => Promise<string>;
+}): {
+    name: string;
+    description: string;
+    input: Input;
+    execute(input: z.infer<Input>, context: ToolContext): Promise<{
+        content: string;
+        metadata: {
+            output: string;
+        };
+    } | {
+        content: string;
+        metadata?: undefined;
+    }>;
+};

package/dist/tools/lsp/tools.d.ts

@@ -1,5 +1,97 @@
-import { type ToolDefinition } from '@opencode-ai/plugin/tool';
-export declare const lsp_goto_definition: ToolDefinition;
-export declare const lsp_find_references: ToolDefinition;
-export declare const lsp_diagnostics: ToolDefinition;
-export declare const lsp_rename: ToolDefinition;
+import { z } from 'zod';
+export declare const lsp_goto_definition: {
+    name: string;
+    description: string;
+    input: z.ZodObject<{
+        filePath: z.ZodString;
+        line: z.ZodNumber;
+        character: z.ZodNumber;
+    }, z.core.$strip>;
+    execute(input: {
+        filePath: string;
+        line: number;
+        character: number;
+    }, context: import("@opencode/plugin/promise/tool").ToolContext): Promise<{
+        content: string;
+        metadata: {
+            output: string;
+        };
+    } | {
+        content: string;
+        metadata?: undefined;
+    }>;
+};
+export declare const lsp_find_references: {
+    name: string;
+    description: string;
+    input: z.ZodObject<{
+        filePath: z.ZodString;
+        line: z.ZodNumber;
+        character: z.ZodNumber;
+        includeDeclaration: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    execute(input: {
+        filePath: string;
+        line: number;
+        character: number;
+        includeDeclaration?: boolean | undefined;
+    }, context: import("@opencode/plugin/promise/tool").ToolContext): Promise<{
+        content: string;
+        metadata: {
+            output: string;
+        };
+    } | {
+        content: string;
+        metadata?: undefined;
+    }>;
+};
+export declare const lsp_diagnostics: {
+    name: string;
+    description: string;
+    input: z.ZodObject<{
+        filePath: z.ZodString;
+        severity: z.ZodOptional<z.ZodEnum<{
+            error: "error";
+            all: "all";
+            warning: "warning";
+            information: "information";
+            hint: "hint";
+        }>>;
+    }, z.core.$strip>;
+    execute(input: {
+        filePath: string;
+        severity?: "error" | "all" | "warning" | "information" | "hint" | undefined;
+    }, context: import("@opencode/plugin/promise/tool").ToolContext): Promise<{
+        content: string;
+        metadata: {
+            output: string;
+        };
+    } | {
+        content: string;
+        metadata?: undefined;
+    }>;
+};
+export declare const lsp_rename: {
+    name: string;
+    description: string;
+    input: z.ZodObject<{
+        filePath: z.ZodString;
+        line: z.ZodNumber;
+        character: z.ZodNumber;
+        newName: z.ZodString;
+    }, z.core.$strip>;
+    execute(input: {
+        filePath: string;
+        line: number;
+        character: number;
+        newName: string;
+    }, context: import("@opencode/plugin/promise/tool").ToolContext): Promise<{
+        content: string;
+        metadata: {
+            output: string;
+        };
+    } | {
+        content: string;
+        metadata?: undefined;
+    }>;
+};

package/dist/utils/index.d.ts

@@ -3,5 +3,4 @@ export * from './env';
 export * from './internal-initiator';
 export { log } from './logger';
 export * from './polling';
-export * from './tmux';
 export { extractZip } from './zip-extractor';

package/package.json

@@ -1,9 +1,21 @@
 {
   "name": "thoth-agents",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Adaptive multi-harness orchestration with six roles, runtime-autonomous AI-first execution routes, and external provider boundaries.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json",
+    "./dist/*": "./dist/*",
+    "./skills/*": "./skills/*",
+    "./plugin/*": "./plugin/*",
+    "./pi/*": "./pi/*",
+    "./thoth-agents.schema.json": "./thoth-agents.schema.json"
+  },
   "bin": {
     "thoth-agents": "./dist/cli/index.js"
   },
@@ -81,8 +93,6 @@
   "dependencies": {
     "@ast-grep/cli": "^0.40.0",
     "@modelcontextprotocol/sdk": "^1.26.0",
-    "@opencode-ai/plugin": "1.18.2",
-    "@opencode-ai/sdk": "1.18.2",
     "hosted-git-info": "9.0.3",
     "ink": "^7.0.3",
     "react": "^19.2.6",
@@ -103,6 +113,7 @@
     "@earendil-works/pi-ai": "1.5.0",
     "@earendil-works/pi-coding-agent": "1.5.0",
     "@earendil-works/pi-tui": "1.5.0",
+    "@opencode/plugin": "2.2.5",
     "@types/hosted-git-info": "3.0.5",
     "@types/node": "^22.19.19",
     "@types/react": "^19.2.15",

package/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "thoth-agents",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Adaptive multi-harness agent pack with six roles and proportional SDD governance for Claude Code.",
   "author": {
     "name": "thoth-agents"

package/plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "thoth-agents",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Bundled AI-first work skills and MCP configuration; the six-role global Codex layer requires thoth-agents CLI setup.",
   "skills": "./skills/",
   "mcpServers": "./codex.mcp.json",

package/plugin/skills/thoth-sdd/SKILL.md

@@ -206,7 +206,13 @@ Validation is not authorization.
 
 Delivery differs by harness: Pi attaches verdicts to completion notifications,
 `subagent_result`, and task-mode `subagent_run` (match `taskId`); OpenCode appends
-them to Oracle `task` output. Claude Code verdicts arrive with Subagent hand-back
+them to completed foreground Oracle `subagent` tool output. OpenCode background
+completions arrive automatically as `<subagent sessionID=... state="completed">`
+messages without a `thoth-gate-verdict` line; root must use the explicit compact
+validator fallback below. Delegate with `subagent` arguments `agent`,
+`description`, `prompt`, optional `model`, `background:true` for independent work,
+and `sessionID` to continue or clarify a child, including while running. No
+status polling tool exists; default nesting depth is 1. Claude Code verdicts arrive with Subagent hand-back
 reports (foreground or background; `agent` is the agent id, match it to the Agent
 result's `agentId`) and completed foreground `Agent` results whose content carries
 the report. Other deliveries (e.g. background runs without hand-back) carry none;
@@ -220,7 +226,7 @@ result.
 ### Explicit compact fallback
 
 Only when no verdict was delivered (hook unavailable/untrusted, a Codex multi-agent
-v2 delivery, or a Claude background run without hand-back), resolve `<skill-dir>` from the installed
+v2 delivery, an OpenCode background completion, or a Claude background run without hand-back), resolve `<skill-dir>` from the installed
 thoth-sdd SKILL.md directory, exactly as for `scripts/validate.mjs`, and run:
 
 ```text

package/plugin/skills/thoth-sdd/scripts/validate-result.mjs

@@ -122,12 +122,38 @@ function checkExpectations(options, issue) {
     );
 }
 
+const isFenceLine = (line) => /^(?:`{3,}|~{3,})/.test(line);
+const isVerdictLine = (line) => line.startsWith('thoth-gate-verdict ');
+
+function unwrapSubagent(message, lines) {
+  if (!message.startsWith('<subagent ')) return message;
+  if (lines.at(-1) !== '</subagent>') return '';
+  const opener = lines.lastIndexOf('```thoth-result');
+  if (opener < 1) return '';
+  const header = lines.slice(0, opener).join('\n').trimEnd();
+  // Native descriptions are interpolated verbatim, not escaped attributes.
+  // Only structural lines and the completed-state marker are authoritative.
+  if (
+    !header.includes('state="completed"') ||
+    lines
+      .slice(0, opener)
+      .some((line) => isFenceLine(line) || isVerdictLine(line))
+  )
+    return '';
+  return lines.slice(opener, -1).join('\n').trim();
+}
+
 function parseEnvelope(message) {
-  const trimmed = typeof message === 'string' ? message.trim() : '';
+  const complete = typeof message === 'string' ? message.trim() : '';
+  const lines = complete.split(/\r\n|\r|\n/);
+  // Check structural lines in the complete delivery, including the header.
+  const singleEnvelope =
+    lines.filter(isFenceLine).length === 2 && !lines.some(isVerdictLine);
+  const trimmed = singleEnvelope ? unwrapSubagent(complete, lines) : '';
   const block = new RegExp(
     `^\`\`\`${contract.fence}\\r?\\n([\\s\\S]*?)\\r?\\n\`\`\`$`,
   ).exec(trimmed);
-  if (!block || (trimmed.match(/^```.*$/gm) ?? []).length !== 2) {
+  if (!block) {
     return {
       issues: [
         {

package/skills/thoth-sdd/SKILL.md

@@ -206,7 +206,13 @@ Validation is not authorization.
 
 Delivery differs by harness: Pi attaches verdicts to completion notifications,
 `subagent_result`, and task-mode `subagent_run` (match `taskId`); OpenCode appends
-them to Oracle `task` output. Claude Code verdicts arrive with Subagent hand-back
+them to completed foreground Oracle `subagent` tool output. OpenCode background
+completions arrive automatically as `<subagent sessionID=... state="completed">`
+messages without a `thoth-gate-verdict` line; root must use the explicit compact
+validator fallback below. Delegate with `subagent` arguments `agent`,
+`description`, `prompt`, optional `model`, `background:true` for independent work,
+and `sessionID` to continue or clarify a child, including while running. No
+status polling tool exists; default nesting depth is 1. Claude Code verdicts arrive with Subagent hand-back
 reports (foreground or background; `agent` is the agent id, match it to the Agent
 result's `agentId`) and completed foreground `Agent` results whose content carries
 the report. Other deliveries (e.g. background runs without hand-back) carry none;
@@ -220,7 +226,7 @@ result.
 ### Explicit compact fallback
 
 Only when no verdict was delivered (hook unavailable/untrusted, a Codex multi-agent
-v2 delivery, or a Claude background run without hand-back), resolve `<skill-dir>` from the installed
+v2 delivery, an OpenCode background completion, or a Claude background run without hand-back), resolve `<skill-dir>` from the installed
 thoth-sdd SKILL.md directory, exactly as for `scripts/validate.mjs`, and run:
 
 ```text