opencode-ultra 0.9.6 → 0.9.8

package/dist/config.d.ts

@@ -82,6 +82,91 @@ declare const PluginConfigSchema: z.ZodObject<{
         implementAgent: z.ZodOptional<z.ZodString>;
         reviewAgent: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
+    activeProfile: z.ZodOptional<z.ZodString>;
+    profiles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            variant: z.ZodOptional<z.ZodString>;
+            category: z.ZodOptional<z.ZodString>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            top_p: z.ZodOptional<z.ZodNumber>;
+            prompt: z.ZodOptional<z.ZodString>;
+            prompt_append: z.ZodOptional<z.ZodString>;
+            disable: z.ZodOptional<z.ZodBoolean>;
+            description: z.ZodOptional<z.ZodString>;
+            mode: z.ZodOptional<z.ZodEnum<{
+                subagent: "subagent";
+                primary: "primary";
+                all: "all";
+            }>>;
+            maxTokens: z.ZodOptional<z.ZodNumber>;
+            thinking: z.ZodOptional<z.ZodObject<{
+                type: z.ZodEnum<{
+                    enabled: "enabled";
+                    disabled: "disabled";
+                }>;
+                budgetTokens: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            reasoningEffort: z.ZodOptional<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+                xhigh: "xhigh";
+            }>>;
+        }, z.core.$loose>>>>;
+        categories: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            variant: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>>;
+        fragments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+        prompt_renderer: z.ZodOptional<z.ZodObject<{
+            default: z.ZodOptional<z.ZodEnum<{
+                markdown: "markdown";
+                xml: "xml";
+                json: "json";
+            }>>;
+            model_overrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+                markdown: "markdown";
+                xml: "xml";
+                json: "json";
+            }>>>;
+        }, z.core.$strip>>;
+        disabled_agents: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        disabled_hooks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        disabled_tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        disabled_mcps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        token_truncation: z.ZodOptional<z.ZodObject<{
+            maxChars: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        demote_builtin: z.ZodOptional<z.ZodBoolean>;
+        background_task: z.ZodOptional<z.ZodObject<{
+            defaultConcurrency: z.ZodOptional<z.ZodNumber>;
+            providerConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+            modelConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+            staleTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        comment_checker: z.ZodOptional<z.ZodObject<{
+            maxRatio: z.ZodOptional<z.ZodNumber>;
+            slopThreshold: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        todo_enforcer: z.ZodOptional<z.ZodObject<{
+            maxEnforcements: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        mcp_api_keys: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        safety: z.ZodOptional<z.ZodObject<{
+            maxTotalSpawned: z.ZodOptional<z.ZodNumber>;
+            agentTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        evolve_exe: z.ZodOptional<z.ZodObject<{
+            maxIterations: z.ZodOptional<z.ZodNumber>;
+            iterationTimeoutMs: z.ZodOptional<z.ZodNumber>;
+            totalTimeoutMs: z.ZodOptional<z.ZodNumber>;
+            skipReview: z.ZodOptional<z.ZodBoolean>;
+            skipTests: z.ZodOptional<z.ZodBoolean>;
+            implementAgent: z.ZodOptional<z.ZodString>;
+            reviewAgent: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$loose>>>;
 }, z.core.$loose>;
 export type PluginConfig = z.infer<typeof PluginConfigSchema>;
 export declare function parsePluginConfig(raw: unknown): PluginConfig;

package/dist/hooks/comment-checker.d.ts

@@ -13,5 +13,5 @@ export declare function createCommentCheckerHook(internalSessions: Set<string>,
     args: Record<string, unknown>;
     sessionID: string;
 }, output: {
-    output: string;
+    output: unknown;
 }) => void;

package/dist/hooks/token-truncation.d.ts

@@ -1,9 +1,9 @@
-export declare function truncateMiddle(input: string, maxChars: number): string;
+export declare function truncateMiddle(input: unknown, maxChars: number): string;
 export declare function createTokenTruncationHook(internalSessions: Set<string>, maxChars?: number): (input: {
     tool: string | {
         name: string;
     };
     sessionID: string;
 }, output: {
-    output: string;
+    output: unknown;
 }) => void;

package/dist/index.js

@@ -14661,7 +14661,7 @@ var CategoryConfigSchema = exports_external.object({
   model: exports_external.string().optional(),
   variant: exports_external.string().optional()
 }).passthrough();
-var PluginConfigSchema = exports_external.object({
+var BaseConfigSchema = exports_external.object({
   agents: AgentOverridesSchema.optional(),
   categories: exports_external.record(exports_external.string(), CategoryConfigSchema).optional(),
   fragments: exports_external.record(exports_external.string(), exports_external.array(exports_external.string())).optional(),
@@ -14705,6 +14705,10 @@ var PluginConfigSchema = exports_external.object({
     reviewAgent: exports_external.string().optional()
   }).optional()
 }).passthrough();
+var PluginConfigSchema = BaseConfigSchema.extend({
+  activeProfile: exports_external.string().optional(),
+  profiles: exports_external.record(exports_external.string(), BaseConfigSchema).optional()
+});
 function parsePluginConfig(raw) {
   const result = PluginConfigSchema.safeParse(raw);
   if (result.success)
@@ -14772,6 +14776,23 @@ function detectConfigFile(basePath) {
     return basePath + ".json";
   return null;
 }
+function resolveProfile(config2) {
+  const profiles = config2.profiles;
+  if (!profiles)
+    return config2;
+  const profileName = process.env.OPENCODE_ULTRA_PROFILE || config2.activeProfile;
+  if (!profileName)
+    return config2;
+  const profile = profiles[profileName];
+  if (!profile) {
+    log(`Profile "${profileName}" not found. Available: ${Object.keys(profiles).join(", ")}`);
+    return config2;
+  }
+  const { profiles: _p, activeProfile: _a2, ...base } = config2;
+  const merged = mergeConfigs(base, profile);
+  log(`Profile "${profileName}" activated`);
+  return merged;
+}
 function loadConfig(projectDir) {
   const userPath = detectConfigFile(path.join(getConfigDir(), "opencode-ultra"));
   let config2 = {};
@@ -14795,6 +14816,7 @@ function loadConfig(projectDir) {
       log(`Error loading project config: ${err}`);
     }
   }
+  config2 = resolveProfile(config2);
   return config2;
 }
 
@@ -27942,7 +27964,8 @@ var INJECTION_PATTERNS = [
   { pattern: /(?:\u65B0\u3057\u3044|\u66F4\u65B0\u3055\u308C\u305F)\u6307\u793A\s*[:\uFF1A]/i, label: "new-instructions-ja" }
 ];
 var SUSPICIOUS_UNICODE = /[\u200B-\u200F\u202A-\u202E\u2060-\u2069\uFEFF\u00AD]/g;
-function sanitizeAgentOutput(text) {
+function sanitizeAgentOutput(input) {
+  let text = typeof input === "string" ? input : JSON.stringify(input) ?? "";
   const warnings = [];
   const invisibleCount = (text.match(SUSPICIOUS_UNICODE) || []).length;
   if (invisibleCount > 0) {
@@ -28277,7 +28300,7 @@ async function runAgent(ctx, task, toolCtx, internalSessions, resilience, provid
     }), { maxAttempts: 3 });
     const messages = messagesResp.data ?? [];
     const lastAssistant = messages.filter((m) => m.info?.role === "assistant").pop();
-    const rawResult = lastAssistant?.parts?.filter((p) => p.type === "text" && p.text).map((p) => p.text).join(`
+    const rawResult = lastAssistant?.parts?.filter((p) => p.type === "text" && p.text).map((p) => typeof p.text === "string" ? p.text : JSON.stringify(p.text)).join(`
 `) ?? "(No response from agent)";
     internalSessions.delete(id);
     await ctx.client.session.delete({ path: { id }, query: { directory: ctx.directory } }).catch(() => {});
@@ -30534,7 +30557,8 @@ function createCommentCheckerHook(internalSessions, maxRatio = 0.3, slopThreshol
       const content = fs12.readFileSync(filePath, "utf-8");
       const result = checkComments(content, filePath, maxRatio, slopThreshold);
       if (result.shouldWarn) {
-        output.output += `
+        const current = typeof output.output === "string" ? output.output : JSON.stringify(output.output) ?? "";
+        output.output = current + `
 
 [Comment Checker] ${result.message}`;
         log(`Comment Checker warning: ${filePath}`, {
@@ -30549,13 +30573,14 @@ function createCommentCheckerHook(internalSessions, maxRatio = 0.3, slopThreshol
 // src/hooks/token-truncation.ts
 var DEFAULT_MAX_CHARS = 30000;
 function truncateMiddle(input, maxChars) {
+  const text = typeof input === "string" ? input : JSON.stringify(input) ?? "";
   if (!Number.isFinite(maxChars) || maxChars <= 0)
-    return input;
-  if (input.length <= maxChars)
-    return input;
+    return text;
+  if (text.length <= maxChars)
+    return text;
   if (maxChars < 32)
-    return input.slice(0, maxChars);
-  const len = input.length;
+    return text.slice(0, maxChars);
+  const len = text.length;
   let head = Math.floor(maxChars * 0.4);
   let tail = Math.floor(maxChars * 0.4);
   head = Math.min(Math.max(head, 1), maxChars);
@@ -30577,9 +30602,9 @@ function truncateMiddle(input, maxChars) {
     const marker22 = buildMarker(removed22);
     const budget = h + marker22.length + finalTail2;
     if (budget > maxChars) {
-      return input.slice(0, maxChars);
+      return text.slice(0, maxChars);
     }
-    return input.slice(0, h) + marker22 + input.slice(len - finalTail2);
+    return text.slice(0, h) + marker22 + text.slice(len - finalTail2);
   };
   const removed = Math.max(0, len - head - tail);
   const marker = buildMarker(removed);
@@ -30596,7 +30621,7 @@ function createTokenTruncationHook(internalSessions, maxChars = DEFAULT_MAX_CHAR
   return (input, output) => {
     if (internalSessions.has(input.sessionID))
       return;
-    const before = output.output;
+    const before = typeof output.output === "string" ? output.output : JSON.stringify(output.output) ?? "";
     const after = truncateMiddle(before, budget);
     if (after !== before) {
       output.output = after;

package/dist/safety/sanitizer.d.ts

@@ -11,9 +11,9 @@ export interface SanitizeResult {
  * Sanitize text from agent outputs to prevent prompt injection.
  * Returns the cleaned text plus any warnings.
  */
-export declare function sanitizeAgentOutput(text: string): SanitizeResult;
+export declare function sanitizeAgentOutput(input: unknown): SanitizeResult;
 /**
  * Apply sanitizer to a spawn_agent result string.
  * Adds a warning banner if injection was detected.
  */
-export declare function sanitizeSpawnResult(result: string): string;
+export declare function sanitizeSpawnResult(result: unknown): string;

package/dist/threadweaver/complexity-router.d.ts

@@ -0,0 +1,35 @@
+/**
+ * ThreadWeaver — Complexity Router
+ * Determines standard/heavy mode and sparse-activates relevant agents.
+ */
+import type { AgentRole, ComplexityAnalysis, ThreadWeaverConfig } from "./types";
+/**
+ * Compute complexity score (0-11).
+ *
+ * Token score: 0-3
+ * Domain score: 0-3
+ * Heavy signal score: 0-3
+ * Question score: 0-2
+ */
+export declare function computeComplexityScore(query: string): {
+    score: number;
+    tokens: number;
+    domainCount: number;
+    matchedDomains: string[];
+    heavySignals: number;
+    questions: number;
+};
+/**
+ * Compute domain relevance score for a specialist agent against the query.
+ * Returns 0.0-1.0 indicating how relevant this agent is.
+ */
+export declare function computeDomainRelevance(agent: AgentRole, query: string): number;
+/**
+ * Sparse-activate specialist agents based on query domain relevance.
+ * Returns only specialists above the activation threshold.
+ */
+export declare function sparseActivate(query: string, threshold: number): AgentRole[];
+/**
+ * Route complexity and select activated agents.
+ */
+export declare function routeComplexity(query: string, config: ThreadWeaverConfig): ComplexityAnalysis;

package/dist/threadweaver/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ThreadWeaver — Public Exports
+ */
+export { createThreadWeaverTool } from "./threadweaver-tool";
+export { runThreadWeaver, type ThreadWeaverDeps } from "./protocol";
+export { routeComplexity, computeComplexityScore, computeDomainRelevance, sparseActivate } from "./complexity-router";
+export { computeDynamicWeights, extractConfidence, parseCritiques, computeCrossAgreement } from "./weighting";
+export { CORE_ROLES, SPECIALIST_ROLES, ALL_ROLES, getCoreRoles, getAllRoles, findRole } from "./roles";
+export { type ThreadWeaverConfig, type ThreadWeaverResult, type ComplexityLevel, type ComplexityAnalysis, type AgentRole, type AgentOutput, type AgentWeight, type Critique, type Dissent, type RoundResult, type RoundType, DEFAULT_THREADWEAVER_CONFIG, } from "./types";

package/dist/threadweaver/prompts.d.ts

@@ -0,0 +1,25 @@
+/**
+ * ThreadWeaver — Prompt Templates
+ * Structured prompts for each round of the debate protocol.
+ */
+import type { AgentRole, AgentOutput, Critique } from "./types";
+/**
+ * Build the analysis prompt for Round 1 (parallel initial analysis).
+ */
+export declare function buildAnalysisPrompt(role: AgentRole, query: string): string;
+/**
+ * Build the cross-critique prompt for Round 2.
+ */
+export declare function buildCritiquePrompt(role: AgentRole, query: string, round1Outputs: AgentOutput[]): string;
+/**
+ * Build the revision prompt for Round 3.
+ */
+export declare function buildRevisionPrompt(role: AgentRole, query: string, ownRound1Output: AgentOutput, critiquesOfMe: Critique[]): string;
+/**
+ * Build the synthesis prompt for the Captain (final round).
+ */
+export declare function buildSynthesisPrompt(query: string, round3Outputs: AgentOutput[], weights: Array<{
+    agentId: string;
+    role: string;
+    finalWeight: number;
+}>): string;

package/dist/threadweaver/protocol.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ThreadWeaver — Debate Protocol
+ * Orchestrates the 3-round debate loop with parallel agent execution.
+ */
+import type { PluginInput, ToolContext } from "@opencode-ai/plugin";
+import { ProviderResilience } from "../shared";
+import type { ConcurrencyPool } from "../concurrency";
+import type { ThreadWeaverConfig, ThreadWeaverResult } from "./types";
+export interface ThreadWeaverDeps {
+    pool?: ConcurrencyPool;
+    resilience?: ProviderResilience;
+    internalSessions: Set<string>;
+}
+/**
+ * Main entry point: Run the ThreadWeaver debate protocol.
+ */
+export declare function runThreadWeaver(ctx: PluginInput, query: string, userConfig: Partial<ThreadWeaverConfig>, deps: ThreadWeaverDeps, toolCtx: ToolContext): Promise<ThreadWeaverResult>;

package/dist/threadweaver/roles.d.ts

@@ -0,0 +1,15 @@
+/**
+ * ThreadWeaver — Agent Role Definitions
+ * Standard (4 core) + Heavy (16 = 4 core + 12 specialists)
+ */
+import type { AgentRole } from "./types";
+export declare const CORE_ROLES: AgentRole[];
+export declare const SPECIALIST_ROLES: AgentRole[];
+/** All 16 roles (4 core + 12 specialists) */
+export declare const ALL_ROLES: AgentRole[];
+/** Get core roles only (standard mode) */
+export declare function getCoreRoles(): AgentRole[];
+/** Get all roles (heavy mode) */
+export declare function getAllRoles(): AgentRole[];
+/** Find a role by ID */
+export declare function findRole(id: string): AgentRole | undefined;

package/dist/threadweaver/threadweaver-tool.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ThreadWeaver — Tool Registration
+ * Registers the threadweaver tool with the OpenCode plugin system.
+ */
+import type { PluginInput } from "@opencode-ai/plugin";
+import { tool } from "@opencode-ai/plugin";
+import type { ThreadWeaverConfig } from "./types";
+import { type ThreadWeaverDeps } from "./protocol";
+export declare function createThreadWeaverTool(ctx: PluginInput, twConfig: Partial<ThreadWeaverConfig>, deps: ThreadWeaverDeps): ReturnType<typeof tool>;

package/dist/threadweaver/types.d.ts

@@ -0,0 +1,81 @@
+/**
+ * ThreadWeaver — Multi-Agent Debate Protocol
+ * All TypeScript type definitions.
+ */
+export type ComplexityLevel = "standard" | "heavy";
+export interface ThreadWeaverConfig {
+    debateRounds: number;
+    heavyThreshold: number;
+    forceComplexity: ComplexityLevel | null;
+    model: string | null;
+    activationThreshold: number;
+    roundTimeoutMs: number;
+    totalTimeoutMs: number;
+    saveLedger: boolean;
+}
+export declare const DEFAULT_THREADWEAVER_CONFIG: ThreadWeaverConfig;
+export interface AgentRole {
+    id: string;
+    role: string;
+    grokEquiv: string;
+    focus: string;
+    /** Domain keywords for sparse activation relevance scoring */
+    domains: string[];
+    /** For specialist agents, reference to the core role they extend */
+    parentRole?: string;
+}
+export type RoundType = "analysis" | "critique" | "revision";
+export interface AgentOutput {
+    agentId: string;
+    role: string;
+    content: string;
+    selfConfidence: number;
+    durationMs: number;
+    error?: string;
+}
+export interface Critique {
+    criticId: string;
+    targetId: string;
+    /** -1 (disagree), 0 (neutral), 1 (agree) */
+    agreement: number;
+    issues: string[];
+    strengths: string[];
+}
+export interface RoundResult {
+    roundNumber: number;
+    roundType: RoundType;
+    outputs: AgentOutput[];
+    critiques?: Critique[];
+    durationMs: number;
+}
+export interface AgentWeight {
+    agentId: string;
+    role: string;
+    selfConfidence: number;
+    crossAgreement: number;
+    domainRelevance: number;
+    finalWeight: number;
+}
+export interface Dissent {
+    topic: string;
+    positions: Array<{
+        agentId: string;
+        position: string;
+    }>;
+}
+export interface ThreadWeaverResult {
+    query: string;
+    complexity: ComplexityLevel;
+    activatedAgents: string[];
+    rounds: RoundResult[];
+    weights: AgentWeight[];
+    synthesis: string;
+    dissents: Dissent[];
+    totalDurationMs: number;
+    partial?: boolean;
+}
+export interface ComplexityAnalysis {
+    level: ComplexityLevel;
+    score: number;
+    activatedAgents: AgentRole[];
+}

package/dist/threadweaver/weighting.d.ts

@@ -0,0 +1,36 @@
+/**
+ * ThreadWeaver — Dynamic Weighting
+ * Computes final weights from self-confidence, cross-agreement, and domain relevance.
+ */
+import type { AgentOutput, AgentWeight, Critique, AgentRole } from "./types";
+/**
+ * Extract self-reported confidence from agent output.
+ * Looks for "Confidence: X/10" pattern at end of content.
+ * Returns 0.0-1.0 (normalized from 0-10 scale).
+ * Default: 0.5 if not found.
+ */
+export declare function extractConfidence(content: string): number;
+/**
+ * Parse critique blocks from an agent's round-2 output.
+ *
+ * Expected format:
+ * ## Re: [agent-id]
+ * Agreement: 1 (or 0, -1)
+ * Issues: ...
+ * Strengths: ...
+ */
+export declare function parseCritiques(criticId: string, content: string): Critique[];
+/**
+ * Compute cross-agreement score for an agent.
+ * Average of all agreement values from other agents, normalized to 0-1.
+ * agreement: -1 → 0.0, 0 → 0.5, 1 → 1.0
+ */
+export declare function computeCrossAgreement(agentId: string, allCritiques: Critique[]): number;
+/**
+ * Compute dynamic weights for all agents after all rounds.
+ *
+ * Formula:
+ *   raw_weight = (selfConfidence * 0.25) + (crossAgreement * 0.45) + (domainRelevance * 0.30)
+ *   final_weight = raw_weight / sum(all_raw_weights)
+ */
+export declare function computeDynamicWeights(outputs: AgentOutput[], allCritiques: Critique[], activatedRoles: AgentRole[], query: string): AgentWeight[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-ultra",
-  "version": "0.9.6",
+  "version": "0.9.8",
   "description": "Lightweight OpenCode 1.2.x plugin — ultrawork mode, multi-agent orchestration, rules injection",
   "keywords": [
     "opencode",