@weaveio/weave-adapter-opencode 0.0.0-preview-20260715084847 → 0.0.0-preview-20260716213903

package/dist/index.js

@@ -20173,6 +20173,28 @@ When to delegate to each specialist:
 
 Delegate aggressively to keep your context lean. Thread and Spindle are cheap (read-only); use them liberally for evidence gathering before routing to implementation agents.
 
+{{#reviewRouting}}
+
+## Adversarial Review Routing
+
+When a review is requested for any of the following agents, run the base reviewer AND all listed variants in parallel, then collate their findings into a unified verdict.
+
+{{#groups}}
+### {{sourceAgent}}
+
+Run all of the following reviewers:
+- \`{{sourceAgent}}\` (base reviewer)
+{{#variants}}
+- \`{{name}}\` (model: {{{model}}})
+{{/variants}}
+{{/groups}}
+
+**Rules:**
+- Always run the base reviewer AND all listed variants. Do not replace the base reviewer with a variant.
+- Run all reviewers in parallel when possible.
+- Collate results strictly: if all approve, report Approve. If any rejects or blocks, report that. Surface disagreements between reviewers.
+{{/reviewRouting}}
+
 ## Category Shuttles
 
 Category shuttles are domain-scoped specialists generated from your project's category definitions. They appear in the list above with names like \`shuttle-{category}\`. **Prefer a category shuttle over the generic shuttle whenever the task clearly falls within a category's domain.**
@@ -20578,6 +20600,29 @@ Available specialists:
 {{/delegation.targets}}
 
 Route implementation tasks to \`shuttle-{category}\` agents when file patterns match. Fall back to \`shuttle\` when no category matches.
+
+{{#reviewRouting}}
+
+## Adversarial Review Routing
+
+When delegating review tasks from a plan, run the base reviewer AND all listed variants for adversarial coverage.
+
+{{#groups}}
+### {{sourceAgent}}
+
+Run all of the following reviewers:
+- \`{{sourceAgent}}\` (base reviewer)
+{{#variants}}
+- \`{{name}}\` (model: {{{model}}})
+{{/variants}}
+{{/groups}}
+
+**Rules:**
+- Always run the base reviewer AND all listed variants. Do not replace the base reviewer with a variant.
+- Run all reviewers in parallel when possible.
+- Collate results strictly: all must approve for the review to pass. Any rejection or block means the review fails.
+- Surface disagreements between reviewers to the user.
+{{/reviewRouting}}
 </Delegation>
 
 <Routing>
@@ -21511,6 +21556,12 @@ var ALLOWED_TEMPLATE_PATHS = new Set([
   "delegation.targets.isCategory",
   "delegation.targets.isCategory.name",
   "delegation.targets.isCategory.description",
+  "reviewRouting",
+  "reviewRouting.groups",
+  "reviewRouting.groups.sourceAgent",
+  "reviewRouting.groups.variants",
+  "reviewRouting.groups.variants.name",
+  "reviewRouting.groups.variants.model",
   "."
 ]);
 function projectDelegationTarget(target) {
@@ -21551,7 +21602,8 @@ function buildTemplateContext(input) {
     skills,
     category,
     effectiveToolPolicy,
-    delegationTargets
+    delegationTargets,
+    reviewRouting
   } = input;
   const agentEntry = {
     name: agentName,
@@ -21590,6 +21642,9 @@ function buildTemplateContext(input) {
   if (categoryEntry !== undefined) {
     context.category = categoryEntry;
   }
+  if (reviewRouting !== undefined) {
+    context.reviewRouting = reviewRouting;
+  }
   log.debug({
     agentName,
     hasCategory: category !== undefined,
@@ -22421,8 +22476,40 @@ function loadAppendSourceFromInput(contextLabel, input) {
     fileErrorMessage: cause instanceof Error ? cause.message : String(cause)
   })).map((content) => ({ content, fromFile: true }));
 }
-function composeAgentDescriptor(agentName, agentConfig, config2, allAgents, category) {
+function buildReviewRoutingContext(reviewVariants, delegationTargetNames) {
+  const delegationSet = new Set(delegationTargetNames);
+  const variants = reviewVariants.filter((a) => a.source === "review-variant");
+  const groups = new Map;
+  for (const variant of variants) {
+    const sourceAgentName = variant.reviewMeta?.sourceAgentName;
+    if (sourceAgentName === undefined)
+      continue;
+    if (!delegationSet.has(sourceAgentName))
+      continue;
+    const existing = groups.get(sourceAgentName);
+    const entry = {
+      name: variant.agentName,
+      model: variant.reviewMeta?.reviewModel ?? ""
+    };
+    if (existing !== undefined) {
+      existing.push(entry);
+    } else {
+      groups.set(sourceAgentName, [entry]);
+    }
+  }
+  if (groups.size === 0)
+    return;
+  return {
+    groups: Array.from(groups.entries()).map(([sourceAgent, variantList]) => ({
+      sourceAgent,
+      variants: variantList
+    }))
+  };
+}
+function composeAgentDescriptor(agentName, agentConfig, config2, allAgents, category, materializedReviewVariants) {
   const delegationTargets = buildDelegationTargets(agentName, agentConfig, config2, allAgents);
+  const delegationTargetNames = delegationTargets.map((t) => t.name);
+  const reviewRouting = buildReviewRoutingContext(materializedReviewVariants ?? [], delegationTargetNames);
   const effectiveToolPolicy = evaluateEffectiveToolPolicy(agentConfig.tool_policy);
   const contextResult = buildTemplateContext({
     agentName,
@@ -22431,7 +22518,8 @@ function composeAgentDescriptor(agentName, agentConfig, config2, allAgents, cate
     skills: agentConfig.skills ?? [],
     category,
     effectiveToolPolicy,
-    delegationTargets
+    delegationTargets,
+    reviewRouting
   });
   if (contextResult.isErr()) {
     return errAsync({
@@ -22888,13 +22976,8 @@ function buildLegacyRunAgentEffect(stepName) {
     resolvedSkills: []
   };
 }
-function buildConfiguredRunAgentEffect(step, promptMetadata, agentConfig) {
+function buildConfiguredRunAgentEffect(step, promptMetadata) {
   const effectivePolicy = evaluateEffectiveToolPolicy(undefined);
-  const isGateReviewVerdict = step.type === "gate" && step.completion.method === "review_verdict";
-  const reviewFanOutIntent = isGateReviewVerdict && agentConfig?.review_models && agentConfig.review_models.length > 0 ? {
-    agentName: step.agent,
-    reviewModels: agentConfig.review_models
-  } : undefined;
   return {
     kind: "run-agent",
     agentName: step.agent,
@@ -22914,8 +22997,7 @@ function buildConfiguredRunAgentEffect(step, promptMetadata, agentConfig) {
     completionMethod: step.completion.method,
     stepType: step.type,
     correlationId: crypto.randomUUID(),
-    promptMetadata,
-    ...reviewFanOutIntent !== undefined ? { reviewFanOutIntent } : {}
+    promptMetadata
   };
 }
 function resolveWorkflowStep(workflowConfig, stepName) {
@@ -22994,7 +23076,7 @@ function dispatchStep(input, store) {
       effects: [
         {
           kind: "dispatch-agent",
-          runAgent: buildConfiguredRunAgentEffect(step, promptMetadata, input.context?.agentConfigs?.[step.agent])
+          runAgent: buildConfiguredRunAgentEffect(step, promptMetadata)
         }
       ],
       ...hasInputs ? { artifactInputSummary } : {}
@@ -23416,6 +23498,64 @@ function startExecution(input, store) {
     effects: []
   }));
 }
+// ../../engine/src/review-variants.ts
+function reviewVariantName(agentName, model) {
+  const safeModel = model.replace(/[^a-zA-Z0-9_-]/g, "-");
+  return `${agentName}-${safeModel}`;
+}
+function generateReviewVariants(config2) {
+  const result = {};
+  for (const [agentName, agent] of Object.entries(config2.agents)) {
+    if (!agent.review_models || agent.review_models.length === 0)
+      continue;
+    if (config2.disabled.agents.includes(agentName))
+      continue;
+    for (const reviewModel of agent.review_models) {
+      const variantName = reviewVariantName(agentName, reviewModel);
+      if (config2.agents[variantName] !== undefined) {
+        return err({
+          type: "ReviewVariantConflictError",
+          variantName,
+          agentName,
+          reviewModel,
+          message: `Agent "${variantName}" is explicitly declared and would also be ` + `generated as a review variant of "${agentName}" for model "${reviewModel}". ` + "Remove the explicit agent declaration or rename the agent."
+        });
+      }
+      if (result[variantName] !== undefined) {
+        return err({
+          type: "ReviewVariantConflictError",
+          variantName,
+          agentName,
+          reviewModel,
+          message: `Review variant name "${variantName}" would be generated more than once. ` + `Two agents produce the same variant name for model "${reviewModel}". ` + "Ensure no two agents produce the same variant name."
+        });
+      }
+      if (config2.disabled.agents.includes(variantName))
+        continue;
+      const readOnlyPolicy = {
+        read: "allow",
+        write: "deny",
+        execute: "deny",
+        delegate: "deny",
+        network: "deny"
+      };
+      result[variantName] = {
+        config: {
+          ...agent,
+          name: variantName,
+          mode: "subagent",
+          models: [reviewModel],
+          tool_policy: readOnlyPolicy,
+          review_models: undefined
+        },
+        sourceAgentName: agentName,
+        reviewModel
+      };
+    }
+  }
+  return ok(result);
+}
+
 // ../../engine/src/materialization.ts
 function filterDisabled(entries, disabled) {
   return entries.filter(([agentName]) => !disabled.includes(agentName));
@@ -23431,16 +23571,56 @@ function materializeAgents(input) {
       conflict: generatedShuttlesResult.error
     }
   ] : [];
-  const explicitEntries = filterDisabled(Object.entries(config2.agents), disabled);
-  const generatedEntries = filterDisabled(Object.entries(generatedShuttles).map(([agentName, generated]) => [agentName, generated.config]), disabled);
-  const allEntries = [
+  const generatedReviewVariantsResult = generateReviewVariants(config2);
+  const generatedReviewVariants = generatedReviewVariantsResult.isOk() ? generatedReviewVariantsResult.value : {};
+  const reviewVariantErrors = generatedReviewVariantsResult.isErr() ? [
+    {
+      type: "ReviewVariantConflict",
+      conflict: generatedReviewVariantsResult.error
+    }
+  ] : [];
+  const explicitEntries = filterDisabled(Object.entries(config2.agents), disabled).map(([agentName, agentConfig]) => ({
+    agentName,
+    agentConfig,
+    entrySource: { source: "explicit" }
+  }));
+  const generatedEntries = filterDisabled(Object.entries(generatedShuttles).map(([agentName, generated]) => [agentName, generated.config]), disabled).map(([agentName, agentConfig]) => ({
+    agentName,
+    agentConfig,
+    entrySource: { source: "category-shuttle" }
+  }));
+  const reviewVariantEntries = Object.entries(generatedReviewVariants).filter(([agentName]) => !disabled.includes(agentName)).map(([agentName, generated]) => ({
+    agentName,
+    agentConfig: generated.config,
+    entrySource: {
+      source: "review-variant",
+      sourceAgentName: generated.sourceAgentName,
+      reviewModel: generated.reviewModel
+    }
+  }));
+  const allTypedEntries = [
     ...explicitEntries,
-    ...generatedEntries
+    ...generatedEntries,
+    ...reviewVariantEntries
   ];
+  const allEntries = allTypedEntries.map(({ agentName, agentConfig }) => [agentName, agentConfig]);
   const allAgents = Object.fromEntries(allEntries);
-  const compositionPromises = allEntries.map(([agentName, agentConfig]) => {
+  const prebuiltReviewVariants = reviewVariantEntries.map(({ agentName: rvName, agentConfig: _rvConfig, entrySource: rvSource }) => {
+    const rv = rvSource;
+    return {
+      agentName: rvName,
+      descriptor: null,
+      source: "review-variant",
+      reviewMeta: {
+        sourceAgentName: rv.sourceAgentName,
+        reviewModel: rv.reviewModel
+      }
+    };
+  });
+  const compositionPromises = allTypedEntries.map(({ agentName, agentConfig, entrySource }) => {
     const category = generatedShuttles[agentName]?.categoryMeta;
-    return composeAgentDescriptor(agentName, agentConfig, config2, allAgents, category).match((descriptor) => ({ ok: true, agentName, descriptor }), (cause) => ({
+    const isPrimary = agentConfig.mode === "primary";
+    return composeAgentDescriptor(agentName, agentConfig, config2, allAgents, category, isPrimary ? prebuiltReviewVariants : undefined).match((descriptor) => ({ ok: true, agentName, descriptor, entrySource }), (cause) => ({
       ok: false,
       error: { type: "DescriptorCompositionFailure", agentName, cause }
     }));
@@ -23450,16 +23630,25 @@ function materializeAgents(input) {
     const compositionErrors = [];
     for (const result of composed) {
       if (result.ok) {
-        agents.push({
+        const agent = {
           agentName: result.agentName,
-          descriptor: result.descriptor
-        });
+          descriptor: result.descriptor,
+          source: result.entrySource.source
+        };
+        if (result.entrySource.source === "review-variant") {
+          agent.reviewMeta = {
+            sourceAgentName: result.entrySource.sourceAgentName,
+            reviewModel: result.entrySource.reviewModel
+          };
+        }
+        agents.push(agent);
       } else {
         compositionErrors.push(result.error);
       }
     }
     const errors3 = [
       ...conflictErrors,
+      ...reviewVariantErrors,
       ...compositionErrors
     ];
     return okAsync({ agents, errors: errors3 });
@@ -24446,16 +24635,20 @@ function resolveNextStepName(workflowConfig, completedStepName) {
     return;
   return workflowConfig.steps[currentIndex + 1]?.name;
 }
-function completeAndAdvance(stepName, state) {
+function completeAndAdvance(stepName, state, dispatchEffect) {
   const stepConfig = state.workflowConfig.steps.find((s) => s.name === stepName);
   const completionMethod = stepConfig?.completion.method ?? "agent_signal";
+  const isReviewVerdict = dispatchEffect?.runAgent.completionMethod === "review_verdict";
+  const outcome = "success";
+  const approved = isReviewVerdict ? true : undefined;
   return completeStep({
     workflowInstanceId: state.workflowInstanceId,
     leaseId: state.leaseId,
     stepName,
     completionSignal: {
-      outcome: "success",
-      method: completionMethod
+      outcome,
+      method: completionMethod,
+      ...approved !== undefined ? { approved } : {}
     },
     context: state.context,
     planStateProvider: state.planStateProvider
@@ -24513,9 +24706,9 @@ function completeAndAdvance(stepName, state) {
         });
       }
       log8.info({ nextStepName, stepsDispatched: state.stepsDispatched }, "Auto-advancing to next step");
-      return state.projectEffect(nextDispatch).andThen(() => completeAndAdvance(nextStepName, state));
+      return state.projectEffect(nextDispatch).andThen(() => completeAndAdvance(nextStepName, state, nextDispatch));
     }
-    log8.warn({ stepName, effectKinds: completionEffects.map((e) => e.kind) }, "completeStep returned no terminal or advance effect \u2014 treating as completed");
+    log8.warn({ stepName, effectKinds: completionEffects.map((e) => e.kind) }, "completeStep returned no terminal or advance effect \u2014 treated as completed");
     return okAsync({
       workflowInstanceId: state.workflowInstanceId,
       leaseId: state.leaseId,
@@ -24549,8 +24742,7 @@ function runWorkflowLifecycle(input) {
     workflowName,
     goal,
     slug,
-    workflows,
-    ...input.agentConfigs !== undefined ? { agentConfigs: input.agentConfigs } : {}
+    workflows
   };
   log8.info({ workflowName, goal, slug, workflowInstanceId }, "Starting workflow lifecycle");
   return startExecution({
@@ -24571,7 +24763,8 @@ function runWorkflowLifecycle(input) {
       effects,
       stepsDispatched: 0,
       maxSteps,
-      projectEffect
+      projectEffect,
+      goal
     };
     return dispatchStep({
       workflowInstanceId,
@@ -24585,7 +24778,8 @@ function runWorkflowLifecycle(input) {
       }
       const dispatchAgentEffects = dispatchEffects.filter((e) => e.kind === "dispatch-agent");
       const applyAll = dispatchAgentEffects.reduce((chain, effect) => chain.andThen(() => projectEffect(effect)), okAsync(undefined));
-      return applyAll.andThen(() => completeAndAdvance(stepName, state));
+      const firstDispatch = dispatchAgentEffects[0];
+      return applyAll.andThen(() => completeAndAdvance(stepName, state, firstDispatch));
     });
   });
 }
@@ -26020,7 +26214,7 @@ var log18 = logger.child({ module: "adapter-opencode/plugin" });
 var DEFAULT_PLUGIN_LOG_SUBPATH = ".weave/weave.log";
 function createWeavePlugin(options = {}) {
   return async (input) => {
-    const { client: sdkClient, directory } = input;
+    const { directory } = input;
     if (!env.WEAVE_LOG_FILE) {
       const dirExists = await Bun.file(directory).stat().then(() => true).catch(() => false);
       if (dirExists) {
@@ -26064,37 +26258,6 @@ function createWeavePlugin(options = {}) {
       log18.debug({ agent: agentName }, "Agent translated for config hook");
     }
     log18.info({ agentCount: translatedMap.size }, "Agents translated for config hook injection");
-    const agentDescriptors = plan.agents.map(({ agentName, descriptor }) => ({
-      agentName,
-      descriptor
-    }));
-    const clientFacade = options.clientFacade ?? new SdkOpenCodeClient(sdkClient);
-    let reconciled = false;
-    async function runReconciliation() {
-      if (reconciled)
-        return;
-      reconciled = true;
-      log18.info({ agentCount: agentDescriptors.length }, "Running deferred SDK reconciliation (session.created)");
-      const adapter = new OpenCodeAdapter({
-        projectRoot: directory,
-        client: clientFacade
-      });
-      try {
-        await adapter.init();
-      } catch (initErr) {
-        log18.error({ error: initErr }, "adapter.init() failed \u2014 aborting deferred SDK reconciliation");
-        return;
-      }
-      for (const { agentName, descriptor } of agentDescriptors) {
-        const spawnResult = await adapter.spawnSubagent(descriptor);
-        if (spawnResult.isErr()) {
-          log18.error({ agent: agentName, error: spawnResult.error }, "Failed to materialize agent \u2014 continuing with remaining agents");
-        } else {
-          log18.info({ agent: agentName }, "Agent materialized via SDK");
-        }
-      }
-      log18.info({ agentCount: agentDescriptors.length }, "Deferred SDK reconciliation complete");
-    }
     log18.info("Weave plugin hooks ready \u2014 returning immediately");
     return {
       config: async (cfg) => {

package/dist/opencode-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"opencode-client.d.ts","sourceRoot":"","sources":["../src/opencode-client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAW,WAAW,EAAE,MAAM,YAAY,CAAC;AAElD,OAAO,KAAK,EACV,aAAa,EACb,mBAAmB,EACnB,cAAc,EACf,MAAM,gBAAgB,CAAC;AAMxB;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAC3B;IACE,IAAI,EAAE,iBAAiB,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,GACD;IACE,IAAI,EAAE,kBAAkB,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,GACD;IACE,IAAI,EAAE,kBAAkB,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAMN;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,UAAU,IAAI,WAAW,CAAC,aAAa,EAAE,EAAE,mBAAmB,CAAC,CAAC;IAEhE;;;;;;;;OAQG;IACH,WAAW,CACT,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,mBAAmB,GAC1B,WAAW,CAAC,IAAI,EAAE,mBAAmB,CAAC,CAAC;IAE1C;;;;;;;;;;;OAWG;IACH,WAAW,CACT,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,mBAAmB,GAC1B,WAAW,CAAC,IAAI,EAAE,mBAAmB,CAAC,CAAC;CAC3C;AAMD;;;;;GAKG;AACH,qBAAa,iBAAkB,YAAW,oBAAoB;IAChD,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,cAAc;IAEnD,UAAU,IAAI,WAAW,CAAC,aAAa,EAAE,EAAE,mBAAmB,CAAC;IAkB/D,WAAW,CACT,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,mBAAmB,GAC1B,WAAW,CAAC,IAAI,EAAE,mBAAmB,CAAC;IAoBzC,WAAW,CACT,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,mBAAmB,GAC1B,WAAW,CAAC,IAAI,EAAE,mBAAmB,CAAC;CAmB1C"}
+{"version":3,"file":"opencode-client.d.ts","sourceRoot":"","sources":["../src/opencode-client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC,OAAO,KAAK,EACV,aAAa,EACb,mBAAmB,EACnB,cAAc,EACf,MAAM,gBAAgB,CAAC;AAMxB;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAC3B;IACE,IAAI,EAAE,iBAAiB,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,GACD;IACE,IAAI,EAAE,kBAAkB,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,GACD;IACE,IAAI,EAAE,kBAAkB,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAMN;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,UAAU,IAAI,WAAW,CAAC,aAAa,EAAE,EAAE,mBAAmB,CAAC,CAAC;IAEhE;;;;;;;;OAQG;IACH,WAAW,CACT,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,mBAAmB,GAC1B,WAAW,CAAC,IAAI,EAAE,mBAAmB,CAAC,CAAC;IAE1C;;;;;;;;;;;OAWG;IACH,WAAW,CACT,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,mBAAmB,GAC1B,WAAW,CAAC,IAAI,EAAE,mBAAmB,CAAC,CAAC;CAC3C;AAMD;;;;;GAKG;AACH,qBAAa,iBAAkB,YAAW,oBAAoB;IAChD,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,cAAc;IAEnD,UAAU,IAAI,WAAW,CAAC,aAAa,EAAE,EAAE,mBAAmB,CAAC;IAkB/D,WAAW,CACT,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,mBAAmB,GAC1B,WAAW,CAAC,IAAI,EAAE,mBAAmB,CAAC;IAoBzC,WAAW,CACT,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,mBAAmB,GAC1B,WAAW,CAAC,IAAI,EAAE,mBAAmB,CAAC;CAmB1C"}

package/dist/plugin.d.ts

@@ -87,7 +87,7 @@
  */
 import type { Plugin } from "@opencode-ai/plugin";
 import { type FileReader } from "@weaveio/weave-config";
-import { type OpenCodeClientFacade } from "./opencode-client.js";
+import type { OpenCodeClientFacade } from "./opencode-client.js";
 /**
  * Options for `createWeavePlugin`.
  *

package/dist/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsFG;AAGH,OAAO,KAAK,EAAS,MAAM,EAAe,MAAM,qBAAqB,CAAC;AACtE,OAAO,EAAE,KAAK,UAAU,EAAc,MAAM,uBAAuB,CAAC;AAepE,OAAO,EACL,KAAK,oBAAoB,EAE1B,MAAM,sBAAsB,CAAC;AAuB9B;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,CAAC;IAEjC;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,oBAAoB,CAAC;CAC9C;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,kBAAuB,GAAG,MAAM,CA6P1E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,WAAW,EAAE,MAA4B,CAAC;AAEvD;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,QAAc,CAAC;AAElC,eAAe,WAAW,CAAC"}
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsFG;AAGH,OAAO,KAAK,EAAS,MAAM,EAAe,MAAM,qBAAqB,CAAC;AACtE,OAAO,EAAE,KAAK,UAAU,EAAc,MAAM,uBAAuB,CAAC;AAapE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAuBjE;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,CAAC;IAEjC;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,oBAAoB,CAAC;CAC9C;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,kBAAuB,GAAG,MAAM,CAkL1E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,WAAW,EAAE,MAA4B,CAAC;AAEvD;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,QAAc,CAAC;AAElC,eAAe,WAAW,CAAC"}