opencode-swarm-plugin 0.30.6 → 0.31.0

package/dist/plugin.js

@@ -27051,13 +27051,41 @@ echo "Project directory: $1"
   };
 });
 
+// src/model-selection.ts
+var exports_model_selection = {};
+__export(exports_model_selection, {
+  selectWorkerModel: () => selectWorkerModel
+});
+function selectWorkerModel(subtask, config2) {
+  if (subtask.model) {
+    return subtask.model;
+  }
+  const files = subtask.files || [];
+  if (files.length > 0) {
+    const allDocs = files.every((f) => {
+      const lower = f.toLowerCase();
+      return lower.endsWith(".md") || lower.endsWith(".mdx");
+    });
+    const allTests = files.every((f) => {
+      const lower = f.toLowerCase();
+      return lower.includes(".test.") || lower.includes(".spec.");
+    });
+    if (allDocs || allTests) {
+      return config2.liteModel || config2.primaryModel || "anthropic/claude-haiku-4-5";
+    }
+  }
+  return config2.primaryModel || "anthropic/claude-haiku-4-5";
+}
+
 // src/hive.ts
 init_dist();
 import {
   createHiveAdapter,
   FlushManager,
   importFromJSONL,
-  getSwarmMail
+  syncMemories,
+  getSwarmMail,
+  resolvePartialId
 } from "swarm-mail";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
@@ -27238,7 +27266,8 @@ var DecomposedSubtaskSchema = exports_external.object({
   description: exports_external.string(),
   files: exports_external.array(exports_external.string()),
   estimated_effort: EffortLevelSchema,
-  risks: exports_external.array(exports_external.string()).optional().default([])
+  risks: exports_external.array(exports_external.string()).optional().default([]),
+  model: exports_external.string().optional()
 });
 var SubtaskDependencySchema = exports_external.object({
   from: exports_external.number().int().min(0),
@@ -27664,6 +27693,43 @@ function ensureHiveDirectory(projectPath) {
   }
 }
 var adapterCache = new Map;
+var exitHookRegistered = false;
+var exitHookRunning = false;
+function registerExitHook() {
+  if (exitHookRegistered) {
+    return;
+  }
+  exitHookRegistered = true;
+  process.on("beforeExit", async (code) => {
+    if (exitHookRunning) {
+      return;
+    }
+    exitHookRunning = true;
+    try {
+      const flushPromises = [];
+      for (const [projectKey, adapter] of adapterCache.entries()) {
+        const flushPromise = (async () => {
+          try {
+            ensureHiveDirectory(projectKey);
+            const flushManager = new FlushManager({
+              adapter,
+              projectKey,
+              outputPath: `${projectKey}/.hive/issues.jsonl`
+            });
+            await flushManager.flush();
+          } catch (error45) {
+            console.warn(`[hive exit hook] Failed to flush ${projectKey}:`, error45 instanceof Error ? error45.message : String(error45));
+          }
+        })();
+        flushPromises.push(flushPromise);
+      }
+      await Promise.all(flushPromises);
+    } finally {
+      exitHookRunning = false;
+    }
+  });
+}
+registerExitHook();
 async function getHiveAdapter(projectKey) {
   if (adapterCache.has(projectKey)) {
     return adapterCache.get(projectKey);
@@ -27817,6 +27883,17 @@ var hive_create_epic = tool({
           console.warn("[hive_create_epic] Failed to emit DecompositionGeneratedEvent:", error45);
         }
       }
+      try {
+        ensureHiveDirectory(projectKey);
+        const flushManager = new FlushManager({
+          adapter,
+          projectKey,
+          outputPath: `${projectKey}/.hive/issues.jsonl`
+        });
+        await flushManager.flush();
+      } catch (error45) {
+        console.warn("[hive_create_epic] Failed to sync to JSONL:", error45);
+      }
       return JSON.stringify(result, null, 2);
     } catch (error45) {
       const rollbackErrors = [];
@@ -27881,7 +27958,7 @@ var hive_query = tool({
 var hive_update = tool({
   description: "Update cell status/description",
   args: {
-    id: tool.schema.string().describe("Cell ID"),
+    id: tool.schema.string().describe("Cell ID or partial hash"),
     status: tool.schema.enum(["open", "in_progress", "blocked", "closed"]).optional().describe("New status"),
     description: tool.schema.string().optional().describe("New description"),
     priority: tool.schema.number().min(0).max(3).optional().describe("New priority")
@@ -27891,27 +27968,34 @@ var hive_update = tool({
     const projectKey = getHiveWorkingDirectory();
     const adapter = await getHiveAdapter(projectKey);
     try {
+      const cellId = await resolvePartialId(adapter, projectKey, validated.id) || validated.id;
       let cell;
       if (validated.status) {
-        cell = await adapter.changeCellStatus(projectKey, validated.id, validated.status);
+        cell = await adapter.changeCellStatus(projectKey, cellId, validated.status);
       }
       if (validated.description !== undefined || validated.priority !== undefined) {
-        cell = await adapter.updateCell(projectKey, validated.id, {
+        cell = await adapter.updateCell(projectKey, cellId, {
           description: validated.description,
           priority: validated.priority
         });
       } else if (!validated.status) {
-        const existingCell = await adapter.getCell(projectKey, validated.id);
+        const existingCell = await adapter.getCell(projectKey, cellId);
         if (!existingCell) {
           throw new HiveError(`Cell not found: ${validated.id}`, "hive_update");
         }
         cell = existingCell;
       }
-      await adapter.markDirty(projectKey, validated.id);
+      await adapter.markDirty(projectKey, cellId);
       const formatted = formatCellForOutput(cell);
       return JSON.stringify(formatted, null, 2);
     } catch (error45) {
       const message = error45 instanceof Error ? error45.message : String(error45);
+      if (message.includes("Ambiguous hash")) {
+        throw new HiveError(`Ambiguous ID '${validated.id}': multiple cells match. Please provide more characters.`, "hive_update");
+      }
+      if (message.includes("Bead not found") || message.includes("Cell not found")) {
+        throw new HiveError(`No cell found matching ID '${validated.id}'`, "hive_update");
+      }
       throw new HiveError(`Failed to update cell: ${message}`, "hive_update");
     }
   }
@@ -27919,7 +28003,7 @@ var hive_update = tool({
 var hive_close = tool({
   description: "Close a cell with reason",
   args: {
-    id: tool.schema.string().describe("Cell ID"),
+    id: tool.schema.string().describe("Cell ID or partial hash"),
     reason: tool.schema.string().describe("Completion reason")
   },
   async execute(args, ctx) {
@@ -27927,11 +28011,18 @@ var hive_close = tool({
     const projectKey = getHiveWorkingDirectory();
     const adapter = await getHiveAdapter(projectKey);
     try {
-      const cell = await adapter.closeCell(projectKey, validated.id, validated.reason);
-      await adapter.markDirty(projectKey, validated.id);
+      const cellId = await resolvePartialId(adapter, projectKey, validated.id) || validated.id;
+      const cell = await adapter.closeCell(projectKey, cellId, validated.reason);
+      await adapter.markDirty(projectKey, cellId);
       return `Closed ${cell.id}: ${validated.reason}`;
     } catch (error45) {
       const message = error45 instanceof Error ? error45.message : String(error45);
+      if (message.includes("Ambiguous hash")) {
+        throw new HiveError(`Ambiguous ID '${validated.id}': multiple cells match. Please provide more characters.`, "hive_close");
+      }
+      if (message.includes("Bead not found") || message.includes("Cell not found")) {
+        throw new HiveError(`No cell found matching ID '${validated.id}'`, "hive_close");
+      }
       throw new HiveError(`Failed to close cell: ${message}`, "hive_close");
     }
   }
@@ -27939,17 +28030,24 @@ var hive_close = tool({
 var hive_start = tool({
   description: "Mark a cell as in-progress (shortcut for update --status in_progress)",
   args: {
-    id: tool.schema.string().describe("Cell ID")
+    id: tool.schema.string().describe("Cell ID or partial hash")
   },
   async execute(args, ctx) {
     const projectKey = getHiveWorkingDirectory();
     const adapter = await getHiveAdapter(projectKey);
     try {
-      const cell = await adapter.changeCellStatus(projectKey, args.id, "in_progress");
-      await adapter.markDirty(projectKey, args.id);
+      const cellId = await resolvePartialId(adapter, projectKey, args.id) || args.id;
+      const cell = await adapter.changeCellStatus(projectKey, cellId, "in_progress");
+      await adapter.markDirty(projectKey, cellId);
       return `Started: ${cell.id}`;
     } catch (error45) {
       const message = error45 instanceof Error ? error45.message : String(error45);
+      if (message.includes("Ambiguous hash")) {
+        throw new HiveError(`Ambiguous ID '${args.id}': multiple cells match. Please provide more characters.`, "hive_start");
+      }
+      if (message.includes("Bead not found") || message.includes("Cell not found")) {
+        throw new HiveError(`No cell found matching ID '${args.id}'`, "hive_start");
+      }
       throw new HiveError(`Failed to start cell: ${message}`, "hive_start");
     }
   }
@@ -28003,8 +28101,18 @@ var hive_sync = tool({
       outputPath: `${projectKey}/.hive/issues.jsonl`
     });
     const flushResult = await withTimeout(flushManager.flush(), TIMEOUT_MS, "flush hive");
-    if (flushResult.cellsExported === 0) {
-      return "No cells to sync";
+    const swarmMail = await getSwarmMail(projectKey);
+    const db = await swarmMail.getDatabase();
+    const hivePath = join(projectKey, ".hive");
+    let memoriesSynced = 0;
+    try {
+      const memoryResult = await syncMemories(db, hivePath);
+      memoriesSynced = memoryResult.exported;
+    } catch (err) {
+      console.warn("[hive_sync] Memory sync warning:", err);
+    }
+    if (flushResult.cellsExported === 0 && memoriesSynced === 0) {
+      return "No cells or memories to sync";
     }
     const hiveStatusResult = await runGitCommand([
       "status",
@@ -30265,7 +30373,7 @@ Agents MUST update their bead status as they work. No silent progress.
 
 ## Requirements
 
-1. **Break into 2-{max_subtasks} independent subtasks** that can run in parallel
+1. **Break into independent subtasks** that can run in parallel (as many as needed)
 2. **Assign files** - each subtask must specify which files it will modify
 3. **No file overlap** - files cannot appear in multiple subtasks (they get exclusive locks)
 4. **Order by dependency** - if subtask B needs subtask A's output, A must come first in the array
@@ -30338,7 +30446,7 @@ Agents MUST update their bead status as they work. No silent progress.
 
 ## Requirements
 
-1. **Break into 2-{max_subtasks} independent subtasks** that can run in parallel
+1. **Break into independent subtasks** that can run in parallel (as many as needed)
 2. **Assign files** - each subtask must specify which files it will modify
 3. **No file overlap** - files cannot appear in multiple subtasks (they get exclusive locks)
 4. **Order by dependency** - if subtask B needs subtask A's output, A must come first in the array
@@ -30504,10 +30612,10 @@ var swarm_decompose = tool({
   description: "Generate decomposition prompt for breaking task into parallelizable subtasks. Optionally queries CASS for similar past tasks.",
   args: {
     task: tool.schema.string().min(1).describe("Task description to decompose"),
-    max_subtasks: tool.schema.number().int().min(2).max(10).default(5).describe("Maximum number of subtasks (default: 5)"),
+    max_subtasks: tool.schema.number().int().min(1).optional().describe("Suggested max subtasks (optional - LLM decides if not specified)"),
     context: tool.schema.string().optional().describe("Additional context (codebase info, constraints, etc.)"),
     query_cass: tool.schema.boolean().optional().describe("Query CASS for similar past tasks (default: true)"),
-    cass_limit: tool.schema.number().int().min(1).max(10).optional().describe("Max CASS results to include (default: 3)")
+    cass_limit: tool.schema.number().int().min(1).optional().describe("Max CASS results to include (default: 3)")
   },
   async execute(args) {
     const { formatMemoryQueryForDecomposition: formatMemoryQueryForDecomposition2 } = await Promise.resolve().then(() => (init_learning(), exports_learning));
@@ -30635,7 +30743,7 @@ var swarm_delegate_planning = tool({
   args: {
     task: tool.schema.string().min(1).describe("The task to decompose"),
     context: tool.schema.string().optional().describe("Additional context to include"),
-    max_subtasks: tool.schema.number().int().min(2).max(10).optional().default(5).describe("Maximum number of subtasks (default: 5)"),
+    max_subtasks: tool.schema.number().int().min(1).optional().describe("Suggested max subtasks (optional - LLM decides if not specified)"),
     strategy: tool.schema.enum(["auto", "file-based", "feature-based", "risk-based"]).optional().default("auto").describe("Decomposition strategy (default: auto-detect)"),
     query_cass: tool.schema.boolean().optional().default(true).describe("Query CASS for similar past tasks (default: true)")
   },
@@ -33917,6 +34025,21 @@ This will be recorded as a negative learning signal.`;
           }
         }, null, 2);
       }
+      let syncSuccess = false;
+      let syncError;
+      try {
+        const previousWorkingDir = getHiveWorkingDirectory();
+        setHiveWorkingDirectory(args.project_key);
+        try {
+          const syncResult = await hive_sync.execute({ auto_pull: false }, _ctx);
+          syncSuccess = !syncResult.includes("error");
+        } finally {
+          setHiveWorkingDirectory(previousWorkingDir);
+        }
+      } catch (error45) {
+        syncError = error45 instanceof Error ? error45.message : String(error45);
+        console.warn(`[swarm_complete] Auto-sync failed (non-fatal): ${syncError}`);
+      }
       try {
         const epicId3 = args.bead_id.includes(".") ? args.bead_id.split(".")[0] : args.bead_id;
         const durationMs2 = args.start_time ? Date.now() - args.start_time : 0;
@@ -34002,6 +34125,8 @@ This will be recorded as a negative learning signal.`;
         bead_id: args.bead_id,
         closed: true,
         reservations_released: true,
+        synced: syncSuccess,
+        sync_error: syncError,
         message_sent: messageSent,
         message_error: messageError,
         agent_registration: {
@@ -34678,7 +34803,7 @@ Agents MUST update their cell status as they work. No silent progress.
 
 ## Requirements
 
-1. **Break into 2-{max_subtasks} independent subtasks** that can run in parallel
+1. **Break into independent subtasks** that can run in parallel (as many as needed)
 2. **Assign files** - each subtask must specify which files it will modify
 3. **No file overlap** - files cannot appear in multiple subtasks (they get exclusive locks)
 4. **Order by dependency** - if subtask B needs subtask A's output, A must come first in the array
@@ -34830,18 +34955,36 @@ swarmmail_init(project_path="{project_path}", task_description="{bead_id}: {subt
 
 **If you skip this step, your work will not be tracked and swarm_complete will fail.**
 
-### Step 2: Query Past Learnings (BEFORE starting work)
+### Step 2: \uD83E\uDDE0 Query Past Learnings (MANDATORY - BEFORE starting work)
+
+**⚠️ CRITICAL: ALWAYS query semantic memory BEFORE writing ANY code.**
+
 \`\`\`
-semantic-memory_find(query="<keywords from your task>", limit=5)
+semantic-memory_find(query="<keywords from your task>", limit=5, expand=true)
 \`\`\`
 
-**Check if past agents solved similar problems.** Search for:
-- Error messages if debugging
-- Domain concepts (e.g., "authentication", "caching")
-- Technology stack (e.g., "Next.js", "React")
-- Patterns (e.g., "event sourcing", "validation")
+**Why this is MANDATORY:**
+- Past agents may have already solved your exact problem
+- Avoids repeating mistakes that wasted 30+ minutes before
+- Discovers project-specific patterns and gotchas
+- Finds known workarounds for tool/library quirks
+
+**Search Query Examples by Task Type:**
+
+- **Bug fix**: Use exact error message or "<symptom> <component>"
+- **New feature**: Search "<domain concept> implementation pattern"
+- **Refactor**: Query "<pattern name> migration approach"
+- **Integration**: Look for "<library name> gotchas configuration"
+- **Testing**: Find "testing <component type> characterization tests"
+- **Performance**: Search "<technology> performance optimization"
 
-**Past learnings save time and prevent repeating mistakes.**
+**BEFORE you start coding:**
+1. Run semantic-memory_find with keywords from your task
+2. Read the results with expand=true for full content
+3. Check if any memory solves your problem or warns of pitfalls
+4. Adjust your approach based on past learnings
+
+**If you skip this step, you WILL waste time solving already-solved problems.**
 
 ### Step 3: Load Relevant Skills (if available)
 \`\`\`
@@ -34927,21 +35070,44 @@ swarm_checkpoint(
 
 **Checkpoints preserve context so you can recover if things go wrong.**
 
-### Step 8: Store Learnings (if you discovered something)
+### Step 8: \uD83D\uDCBE STORE YOUR LEARNINGS (if you discovered something)
+
+**If you learned it the hard way, STORE IT so the next agent doesn't have to.**
+
 \`\`\`
 semantic-memory_store(
   information="<what you learned, WHY it matters, how to apply it>",
-  metadata="<tags: domain, tech-stack, pattern-type>"
+  tags="<domain, tech-stack, pattern-type>"
 )
 \`\`\`
 
-**Store:**
-- Tricky bugs you solved (root cause + solution)
-- Project-specific patterns or domain rules
-- Tool/library gotchas and workarounds
-- Failed approaches (anti-patterns to avoid)
+**MANDATORY Storage Triggers - Store when you:**
+- \uD83D\uDC1B **Solved a tricky bug** (>15min debugging) - include root cause + solution
+- \uD83D\uDCA1 **Discovered a project-specific pattern** - domain rules, business logic quirks
+- ⚠️ **Found a tool/library gotcha** - API quirks, version-specific bugs, workarounds
+- \uD83D\uDEAB **Tried an approach that failed** - anti-patterns to avoid, why it didn't work
+- \uD83C\uDFD7️ **Made an architectural decision** - reasoning, alternatives considered, tradeoffs
 
-**Don't store generic knowledge.** Store the WHY, not just the WHAT.
+**What Makes a GOOD Memory:**
+
+✅ **GOOD** (actionable, explains WHY):
+\`\`\`
+"OAuth refresh tokens need 5min buffer before expiry to avoid race conditions.
+Without buffer, token refresh can fail mid-request if expiry happens between
+check and use. Implemented with: if (expiresAt - Date.now() < 300000) refresh()"
+\`\`\`
+
+❌ **BAD** (generic, no context):
+\`\`\`
+"Fixed the auth bug by adding a null check"
+\`\`\`
+
+**What NOT to Store:**
+- Generic knowledge that's in official documentation
+- Implementation details that change frequently
+- Vague descriptions without context ("fixed the thing")
+
+**The WHY matters more than the WHAT.** Future agents need context to apply your learning.
 
 ### Step 9: Complete (REQUIRED - releases reservations)
 \`\`\`
@@ -35032,17 +35198,20 @@ Other cell operations:
 
 **NON-NEGOTIABLE:**
 1. Step 1 (swarmmail_init) MUST be first - do it before anything else
-2. Step 2 (semantic-memory_find) MUST happen before starting work
+2. \uD83E\uDDE0 Step 2 (semantic-memory_find) MUST happen BEFORE starting work - query first, code second
 3. Step 4 (swarmmail_reserve) - YOU reserve files, not coordinator
 4. Step 6 (swarm_progress) - Report at milestones, don't work silently
-5. Step 9 (swarm_complete) - Use this to close, NOT hive_close
+5. \uD83D\uDCBE Step 8 (semantic-memory_store) - If you learned something hard, STORE IT
+6. Step 9 (swarm_complete) - Use this to close, NOT hive_close
 
 **If you skip these steps:**
 - Your work won't be tracked (swarm_complete will fail)
-- You'll waste time repeating solved problems (no semantic memory query)
+- \uD83D\uDD04 You'll waste time repeating already-solved problems (no semantic memory query)
 - Edit conflicts with other agents (no file reservation)
 - Lost work if you crash (no checkpoints)
-- Future agents repeat your mistakes (no learnings stored)
+- \uD83D\uDD04 Future agents repeat YOUR mistakes (no learnings stored)
+
+**Memory is the swarm's collective intelligence. Query it. Feed it.**
 
 Begin now.`;
 var EVALUATION_PROMPT = `Evaluate the work completed for this subtask.
@@ -35175,7 +35344,7 @@ var swarm_subtask_prompt = tool({
   }
 });
 var swarm_spawn_subtask = tool({
-  description: "Prepare a subtask for spawning. Returns prompt with Agent Mail/hive tracking instructions. IMPORTANT: Pass project_path for swarmmail_init.",
+  description: "Prepare a subtask for spawning. Returns prompt with Agent Mail/hive tracking instructions. IMPORTANT: Pass project_path for swarmmail_init. Automatically selects appropriate model based on file types.",
   args: {
     bead_id: tool.schema.string().describe("Subtask bead ID"),
     epic_id: tool.schema.string().describe("Parent epic bead ID"),
@@ -35188,7 +35357,8 @@ var swarm_spawn_subtask = tool({
       shared_context: tool.schema.string().optional(),
       skills_to_load: tool.schema.array(tool.schema.string()).optional(),
       coordinator_notes: tool.schema.string().optional()
-    }).optional().describe("Recovery context from checkpoint compaction")
+    }).optional().describe("Recovery context from checkpoint compaction"),
+    model: tool.schema.string().optional().describe("Optional explicit model override (auto-selected if not provided)")
   },
   async execute(args) {
     const prompt = formatSubtaskPromptV2({
@@ -35201,13 +35371,28 @@ var swarm_spawn_subtask = tool({
       project_path: args.project_path,
       recovery_context: args.recovery_context
     });
+    const { selectWorkerModel: selectWorkerModel2 } = await Promise.resolve().then(() => exports_model_selection);
+    const subtask = {
+      title: args.subtask_title,
+      description: args.subtask_description || "",
+      files: args.files,
+      estimated_effort: "medium",
+      risks: [],
+      model: args.model
+    };
+    const config2 = {
+      primaryModel: "anthropic/claude-sonnet-4-5",
+      liteModel: "anthropic/claude-haiku-4-5"
+    };
+    const selectedModel = selectWorkerModel2(subtask, config2);
     return JSON.stringify({
       prompt,
       bead_id: args.bead_id,
       epic_id: args.epic_id,
       files: args.files,
       project_path: args.project_path,
-      recovery_context: args.recovery_context
+      recovery_context: args.recovery_context,
+      recommended_model: selectedModel
     }, null, 2);
   }
 });
@@ -35246,10 +35431,10 @@ var swarm_plan_prompt = tool({
   args: {
     task: tool.schema.string().min(1).describe("Task description to decompose"),
     strategy: tool.schema.enum(["file-based", "feature-based", "risk-based", "auto"]).optional().describe("Decomposition strategy (default: auto-detect)"),
-    max_subtasks: tool.schema.number().int().min(2).max(10).default(5).describe("Maximum number of subtasks (default: 5)"),
+    max_subtasks: tool.schema.number().int().min(1).optional().describe("Suggested max subtasks (optional - LLM decides if not specified)"),
     context: tool.schema.string().optional().describe("Additional context (codebase info, constraints, etc.)"),
     query_cass: tool.schema.boolean().optional().describe("Query CASS for similar past tasks (default: true)"),
-    cass_limit: tool.schema.number().int().min(1).max(10).optional().describe("Max CASS results to include (default: 3)"),
+    cass_limit: tool.schema.number().int().min(1).optional().describe("Max CASS results to include (default: 3)"),
     include_skills: tool.schema.boolean().optional().describe("Include available skills in context (default: true)")
   },
   async execute(args) {
@@ -49863,12 +50048,18 @@ async function createMemoryAdapter(db) {
       if (tags.length > 0) {
         metadata.tags = tags;
       }
+      const clampConfidence = (c) => {
+        if (c === undefined)
+          return 0.7;
+        return Math.max(0, Math.min(1, c));
+      };
       const memory = {
         id,
         content: args2.information,
         metadata,
         collection,
-        createdAt: new Date
+        createdAt: new Date,
+        confidence: clampConfidence(args2.confidence)
       };
       const program = exports_Effect.gen(function* () {
         const ollama = yield* Ollama;
@@ -49975,12 +50166,13 @@ async function getMemoryAdapter(projectPath) {
   return cachedAdapter;
 }
 var semantic_memory_store = tool({
-  description: "Store a memory with semantic embedding. Memories are searchable by semantic similarity and can be organized into collections.",
+  description: "Store a memory with semantic embedding. Memories are searchable by semantic similarity and can be organized into collections. Confidence affects decay rate: high confidence (1.0) = 135 day half-life, low confidence (0.0) = 45 day half-life.",
   args: {
     information: tool.schema.string().describe("The information to store (required)"),
     collection: tool.schema.string().optional().describe("Collection name (defaults to 'default')"),
     tags: tool.schema.string().optional().describe("Comma-separated tags (e.g., 'auth,tokens,oauth')"),
-    metadata: tool.schema.string().optional().describe("JSON string with additional metadata")
+    metadata: tool.schema.string().optional().describe("JSON string with additional metadata"),
+    confidence: tool.schema.number().optional().describe("Confidence level (0.0-1.0) affecting decay rate. Higher = slower decay. Default 0.7")
   },
   async execute(args2, ctx) {
     const adapter = await getMemoryAdapter();

package/dist/schemas/task.d.ts

@@ -44,6 +44,7 @@ export declare const DecomposedSubtaskSchema: z.ZodObject<{
         large: "large";
     }>;
     risks: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    model: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type DecomposedSubtask = z.infer<typeof DecomposedSubtaskSchema>;
 /**
@@ -78,6 +79,7 @@ export declare const TaskDecompositionSchema: z.ZodObject<{
             large: "large";
         }>;
         risks: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        model: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     dependencies: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
         from: z.ZodNumber;

package/dist/schemas/task.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../../src/schemas/task.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB;;;;;EAK5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;EAI/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;iBAOlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;iBAMlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;;;GAIG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;iBAWlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;iBAI9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;iBAe7B,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;iBAMjC,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;iBAe7B,CAAC;AACJ,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;iBAS5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}
+{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../../src/schemas/task.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB;;;;;EAK5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;EAI/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;iBAYlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;iBAMlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;;;GAIG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;iBAWlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;iBAI9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;iBAe7B,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;iBAMjC,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;iBAe7B,CAAC;AACJ,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;iBAS5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/swarm-decompose.d.ts

@@ -58,14 +58,14 @@ export declare const swarm_decompose: {
     description: string;
     args: {
         task: z.ZodString;
-        max_subtasks: z.ZodDefault<z.ZodNumber>;
+        max_subtasks: z.ZodOptional<z.ZodNumber>;
         context: z.ZodOptional<z.ZodString>;
         query_cass: z.ZodOptional<z.ZodBoolean>;
         cass_limit: z.ZodOptional<z.ZodNumber>;
     };
     execute(args: {
         task: string;
-        max_subtasks: number;
+        max_subtasks?: number | undefined;
         context?: string | undefined;
         query_cass?: boolean | undefined;
         cass_limit?: number | undefined;
@@ -122,7 +122,7 @@ export declare const swarm_delegate_planning: {
     args: {
         task: z.ZodString;
         context: z.ZodOptional<z.ZodString>;
-        max_subtasks: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        max_subtasks: z.ZodOptional<z.ZodNumber>;
         strategy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
             "file-based": "file-based";
             "feature-based": "feature-based";
@@ -133,10 +133,10 @@ export declare const swarm_delegate_planning: {
     };
     execute(args: {
         task: string;
-        max_subtasks: number;
         strategy: "file-based" | "feature-based" | "risk-based" | "auto";
         query_cass: boolean;
         context?: string | undefined;
+        max_subtasks?: number | undefined;
     }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
 };
 export declare class SwarmError extends Error {
@@ -200,14 +200,14 @@ export declare const decomposeTools: {
         description: string;
         args: {
             task: z.ZodString;
-            max_subtasks: z.ZodDefault<z.ZodNumber>;
+            max_subtasks: z.ZodOptional<z.ZodNumber>;
             context: z.ZodOptional<z.ZodString>;
             query_cass: z.ZodOptional<z.ZodBoolean>;
             cass_limit: z.ZodOptional<z.ZodNumber>;
         };
         execute(args: {
             task: string;
-            max_subtasks: number;
+            max_subtasks?: number | undefined;
             context?: string | undefined;
             query_cass?: boolean | undefined;
             cass_limit?: number | undefined;
@@ -227,7 +227,7 @@ export declare const decomposeTools: {
         args: {
             task: z.ZodString;
             context: z.ZodOptional<z.ZodString>;
-            max_subtasks: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            max_subtasks: z.ZodOptional<z.ZodNumber>;
             strategy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                 "file-based": "file-based";
                 "feature-based": "feature-based";
@@ -238,10 +238,10 @@ export declare const decomposeTools: {
         };
         execute(args: {
             task: string;
-            max_subtasks: number;
             strategy: "file-based" | "feature-based" | "risk-based" | "auto";
             query_cass: boolean;
             context?: string | undefined;
+            max_subtasks?: number | undefined;
         }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
     };
     swarm_plan_interactive: {

package/dist/swarm-decompose.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swarm-decompose.d.ts","sourceRoot":"","sources":["../src/swarm-decompose.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAwJxB;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,mBAAmB,GAAG,eAAe,CAAC;IACrD,WAAW,EAAE,MAAM,CAAC;CACrB;AA8CD;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GACvD,mBAAmB,EAAE,CAmDvB;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,GACnC,MAAM,EAAE,CAgBV;AA+GD;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;CA0G1B,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;CAkHvC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;CA6LlC,CAAC;AAMH,qBAAa,UAAW,SAAQ,KAAK;aAGjB,SAAS,EAAE,MAAM;aACjB,OAAO,CAAC,EAAE,OAAO;gBAFjC,OAAO,EAAE,MAAM,EACC,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,OAAO,YAAA;CAKpC;AAED,qBAAa,kBAAmB,SAAQ,UAAU;aAG9B,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ;gBADrC,OAAO,EAAE,MAAM,EACC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,YAAA;CAIxC;AAkCD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;CA0RjC,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK1B,CAAC"}
+{"version":3,"file":"swarm-decompose.d.ts","sourceRoot":"","sources":["../src/swarm-decompose.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAwJxB;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,mBAAmB,GAAG,eAAe,CAAC;IACrD,WAAW,EAAE,MAAM,CAAC;CACrB;AA8CD;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GACvD,mBAAmB,EAAE,CAmDvB;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,GACnC,MAAM,EAAE,CAgBV;AA+GD;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;CAwG1B,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;CAkHvC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;CA2LlC,CAAC;AAMH,qBAAa,UAAW,SAAQ,KAAK;aAGjB,SAAS,EAAE,MAAM;aACjB,OAAO,CAAC,EAAE,OAAO;gBAFjC,OAAO,EAAE,MAAM,EACC,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,OAAO,YAAA;CAKpC;AAED,qBAAa,kBAAmB,SAAQ,UAAU;aAG9B,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ;gBADrC,OAAO,EAAE,MAAM,EACC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,YAAA;CAIxC;AAkCD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;CA0RjC,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK1B,CAAC"}

package/dist/swarm-orchestrate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swarm-orchestrate.d.ts","sourceRoot":"","sources":["../src/swarm-orchestrate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAaxB,OAAO,EACL,KAAK,aAAa,EAEnB,MAAM,0BAA0B,CAAC;AAmDlC;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,sBAAsB,CAAC,EAAE,MAAM,EAAE,CAAC;IAClC,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,GAAG,aAAa,CA4BhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,gBAAgB,CAC9B,aAAa,EAAE,MAAM,EAAE,EACvB,WAAW,EAAE,MAAM,EAAE,GACpB;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,MAAM,EAAE,CAAA;CAAE,CAqC1C;AA8hBD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;CA8JrB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;CAoFvB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;CAkHzB,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;CA6E1B,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8qBzB,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkJ/B,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;CA6CjC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;CAmClC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;CAmB9B,CAAC;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;CAoJ9B,CAAC;AA4BH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqG3B,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;CAsGxB,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgMtB,CAAC;AAMH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAc5B,CAAC"}
+{"version":3,"file":"swarm-orchestrate.d.ts","sourceRoot":"","sources":["../src/swarm-orchestrate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAaxB,OAAO,EACL,KAAK,aAAa,EAEnB,MAAM,0BAA0B,CAAC;AAmDlC;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,sBAAsB,CAAC,EAAE,MAAM,EAAE,CAAC;IAClC,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,GAAG,aAAa,CA4BhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,gBAAgB,CAC9B,aAAa,EAAE,MAAM,EAAE,EACvB,WAAW,EAAE,MAAM,EAAE,GACpB;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,MAAM,EAAE,CAAA;CAAE,CAqC1C;AA8hBD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;CA8JrB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;CAoFvB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;CAkHzB,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;CA6E1B,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwsBzB,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkJ/B,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;CA6CjC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;CAmClC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;CAmB9B,CAAC;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;CAoJ9B,CAAC;AA4BH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqG3B,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;CAsGxB,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgMtB,CAAC;AAMH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAc5B,CAAC"}