opencode-swarm-plugin 0.30.6 → 0.31.0

package/dist/index.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";
@@ -27253,7 +27281,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),
@@ -27907,6 +27936,43 @@ async function importJsonlToPGLite(projectPath) {
   return { imported, updated, errors: errors3 };
 }
 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);
@@ -28061,6 +28127,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 = [];
@@ -28125,7 +28202,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")
@@ -28135,27 +28212,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");
     }
   }
@@ -28163,7 +28247,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) {
@@ -28171,11 +28255,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");
     }
   }
@@ -28183,17 +28274,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");
     }
   }
@@ -28247,8 +28345,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",
@@ -30647,7 +30755,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
@@ -30720,7 +30828,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
@@ -30886,10 +30994,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));
@@ -31017,7 +31125,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)")
   },
@@ -34318,6 +34426,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;
@@ -34403,6 +34526,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: {
@@ -35079,7 +35204,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
@@ -35231,18 +35356,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)
 \`\`\`
@@ -35328,21 +35471,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)
 \`\`\`
@@ -35433,17 +35599,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.
@@ -35576,7 +35745,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"),
@@ -35589,7 +35758,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({
@@ -35602,13 +35772,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);
   }
 });
@@ -35647,10 +35832,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) {
@@ -50310,12 +50495,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;
@@ -50426,12 +50617,13 @@ function resetMemoryCache() {
   cachedProjectPath = null;
 }
 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/memory-tools.d.ts

@@ -29,12 +29,14 @@ export declare const semantic_memory_store: {
         collection: import("zod").ZodOptional<import("zod").ZodString>;
         tags: import("zod").ZodOptional<import("zod").ZodString>;
         metadata: import("zod").ZodOptional<import("zod").ZodString>;
+        confidence: import("zod").ZodOptional<import("zod").ZodNumber>;
     };
     execute(args: {
         information: string;
         collection?: string | undefined;
         tags?: string | undefined;
         metadata?: string | undefined;
+        confidence?: number | undefined;
     }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
 };
 /**
@@ -134,12 +136,14 @@ export declare const memoryTools: {
             collection: import("zod").ZodOptional<import("zod").ZodString>;
             tags: import("zod").ZodOptional<import("zod").ZodString>;
             metadata: import("zod").ZodOptional<import("zod").ZodString>;
+            confidence: import("zod").ZodOptional<import("zod").ZodNumber>;
         };
         execute(args: {
             information: string;
             collection?: string | undefined;
             tags?: string | undefined;
             metadata?: string | undefined;
+            confidence?: number | undefined;
         }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
     };
     readonly "semantic-memory_find": {

package/dist/memory-tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory-tools.d.ts","sourceRoot":"","sources":["../src/memory-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH,OAAO,EACN,mBAAmB,EACnB,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,QAAQ,EACb,KAAK,MAAM,EACX,KAAK,QAAQ,EACb,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,MAAM,UAAU,CAAC;AAGlB,YAAY,EACX,aAAa,EACb,SAAS,EACT,QAAQ,EACR,MAAM,EACN,QAAQ,EACR,WAAW,EACX,UAAU,EACV,WAAW,EACX,YAAY,EACZ,eAAe,GACf,CAAC;AA2CF;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CAGvC;AAGD,OAAO,EAAE,mBAAmB,EAAE,CAAC;AAM/B;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;CAyBhC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;CA2B/B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;CAU9B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;CAUjC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;CAWnC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;CAa/B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;CAQhC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;CAShC,CAAC;AAMH;;;;GAIG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CASd,CAAC"}
+{"version":3,"file":"memory-tools.d.ts","sourceRoot":"","sources":["../src/memory-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH,OAAO,EACN,mBAAmB,EACnB,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,QAAQ,EACb,KAAK,MAAM,EACX,KAAK,QAAQ,EACb,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,MAAM,UAAU,CAAC;AAGlB,YAAY,EACX,aAAa,EACb,SAAS,EACT,QAAQ,EACR,MAAM,EACN,QAAQ,EACR,WAAW,EACX,UAAU,EACV,WAAW,EACX,YAAY,EACZ,eAAe,GACf,CAAC;AA2CF;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CAGvC;AAGD,OAAO,EAAE,mBAAmB,EAAE,CAAC;AAM/B;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;CA6BhC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;CA2B/B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;CAU9B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;CAUjC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;CAWnC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;CAa/B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;CAQhC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;CAShC,CAAC;AAMH;;;;GAIG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CASd,CAAC"}

package/dist/memory.d.ts

@@ -38,6 +38,8 @@ export interface StoreArgs {
     readonly collection?: string;
     readonly tags?: string;
     readonly metadata?: string;
+    /** Confidence level (0.0-1.0) affecting decay rate. Higher = slower decay. Default 0.7 */
+    readonly confidence?: number;
 }
 /** Arguments for find operation */
 export interface FindArgs {

package/dist/memory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../src/memory.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../src/memory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAGH,OAAO,EACN,KAAK,eAAe,EAKpB,KAAK,MAAM,EAIX,MAAM,YAAY,CAAC;AAYpB;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAE1C;AAMD,oCAAoC;AACpC,MAAM,WAAW,SAAS;IACzB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,0FAA0F;IAC1F,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,mCAAmC;AACnC,MAAM,WAAW,QAAQ;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,mDAAmD;AACnD,MAAM,WAAW,MAAM;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACpB;AAED,mCAAmC;AACnC,MAAM,WAAW,QAAQ;IACxB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,kCAAkC;AAClC,MAAM,WAAW,WAAW;IAC3B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CACzB;AAED,iCAAiC;AACjC,MAAM,WAAW,UAAU;IAC1B,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC;QACvB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;QACpB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;QAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAC3C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;KAC3B,CAAC,CAAC;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACvB;AAED,kCAAkC;AAClC,MAAM,WAAW,WAAW;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC5B;AAED,+BAA+B;AAC/B,MAAM,WAAW,YAAY;IAC5B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,6CAA6C;AAC7C,MAAM,WAAW,eAAe;IAC/B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC1B;AAiED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC7B,QAAQ,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;IAC1D,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;IACvD,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACvD,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,eAAe,CAAC,CAAC;IAC5D,QAAQ,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,eAAe,CAAC,CAAC;IAC9D,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IACrD,QAAQ,CAAC,KAAK,EAAE,MAAM,OAAO,CAAC,WAAW,CAAC,CAAC;IAC3C,QAAQ,CAAC,WAAW,EAAE,MAAM,OAAO,CAAC,YAAY,CAAC,CAAC;CAClD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,mBAAmB,CACxC,EAAE,EAAE,eAAe,GACjB,OAAO,CAAC,aAAa,CAAC,CA4NxB"}

package/dist/model-selection.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Model Selection Module
+ *
+ * Determines which model a worker agent should use based on subtask
+ * characteristics like file types and complexity.
+ *
+ * Priority:
+ * 1. Explicit model field in subtask
+ * 2. File-type inference (docs/tests → lite model)
+ * 3. Default to primary model
+ */
+import type { DecomposedSubtask } from "./schemas/task";
+/**
+ * Configuration interface for swarm models
+ */
+export interface SwarmConfig {
+    primaryModel: string;
+    liteModel?: string;
+}
+/**
+ * Select the appropriate model for a worker agent based on subtask characteristics
+ *
+ * Priority order:
+ * 1. Explicit `model` field in subtask (if present)
+ * 2. File-type inference:
+ *    - All .md/.mdx files → liteModel
+ *    - All .test./.spec. files → liteModel
+ * 3. Mixed files or implementation → primaryModel
+ *
+ * @param subtask - The subtask to evaluate
+ * @param config - Swarm configuration with model preferences
+ * @returns Model identifier string
+ */
+export declare function selectWorkerModel(subtask: DecomposedSubtask & {
+    model?: string;
+}, config: SwarmConfig): string;
+//# sourceMappingURL=model-selection.d.ts.map

package/dist/model-selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-selection.d.ts","sourceRoot":"","sources":["../src/model-selection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,iBAAiB,GAAG;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,EAC/C,MAAM,EAAE,WAAW,GAClB,MAAM,CA4BR"}