@opencode_weave/weave 0.7.0 → 0.7.3

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/index.ts
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 
 // src/config/loader.ts
 import { existsSync as existsSync2, readFileSync } from "node:fs";
@@ -22,7 +22,8 @@ var AgentOverrideConfigSchema = z.object({
   tools: z.record(z.string(), z.boolean()).optional(),
   disable: z.boolean().optional(),
   mode: z.enum(["subagent", "primary", "all"]).optional(),
-  maxTokens: z.number().optional()
+  maxTokens: z.number().optional(),
+  display_name: z.string().optional()
 });
 var AgentOverridesSchema = z.record(z.string(), AgentOverrideConfigSchema);
 var CategoryConfigSchema = z.object({
@@ -52,7 +53,8 @@ var TmuxConfigSchema = z.object({
 var ExperimentalConfigSchema = z.object({
   plugin_load_timeout_ms: z.number().min(1000).optional(),
   context_window_warning_threshold: z.number().min(0).max(1).optional(),
-  context_window_critical_threshold: z.number().min(0).max(1).optional()
+  context_window_critical_threshold: z.number().min(0).max(1).optional(),
+  task_system: z.boolean().default(true)
 });
 var DelegationTriggerSchema = z.object({
   domain: z.string(),
@@ -223,6 +225,7 @@ var AGENT_DISPLAY_NAMES = {
   weft: "weft"
 };
 var BUILTIN_CONFIG_KEYS = new Set(Object.keys(AGENT_DISPLAY_NAMES));
+var INITIAL_BUILTIN_DISPLAY_NAMES = new Map(Object.entries(AGENT_DISPLAY_NAMES));
 var reverseDisplayNames = null;
 function getReverseDisplayNames() {
   if (reverseDisplayNames === null) {
@@ -234,6 +237,11 @@ function registerAgentDisplayName(configKey, displayName) {
   if (BUILTIN_CONFIG_KEYS.has(configKey)) {
     throw new Error(`Cannot register display name for "${configKey}": it is a built-in agent name`);
   }
+  for (const [builtinKey, initialDisplayName] of INITIAL_BUILTIN_DISPLAY_NAMES) {
+    if (initialDisplayName.toLowerCase() === displayName.toLowerCase()) {
+      throw new Error(`Display name "${displayName}" is reserved for built-in agent "${builtinKey}"`);
+    }
+  }
   const reverse = getReverseDisplayNames();
   const existingKey = reverse[displayName.toLowerCase()];
   if (existingKey !== undefined && BUILTIN_CONFIG_KEYS.has(existingKey)) {
@@ -242,6 +250,13 @@ function registerAgentDisplayName(configKey, displayName) {
   AGENT_DISPLAY_NAMES[configKey] = displayName;
   reverseDisplayNames = null;
 }
+function updateBuiltinDisplayName(configKey, displayName) {
+  if (!BUILTIN_CONFIG_KEYS.has(configKey)) {
+    throw new Error(`Cannot update builtin display name for "${configKey}": not a built-in agent`);
+  }
+  AGENT_DISPLAY_NAMES[configKey] = displayName;
+  reverseDisplayNames = null;
+}
 function getAgentDisplayName(configKey) {
   const exactMatch = AGENT_DISPLAY_NAMES[configKey];
   if (exactMatch !== undefined)
@@ -1233,6 +1248,8 @@ Use this structure:
 \`\`\`
 
 CRITICAL: Use \`- [ ]\` checkboxes for ALL actionable items. The /start-work system tracks progress by counting these checkboxes.
+
+Use the exact section headings shown in the template above (\`## TL;DR\`, \`## Context\`, \`## Objectives\`, \`## TODOs\`, \`## Verification\`). Consistent headings help downstream tooling parse the plan.
 </PlanOutput>
 
 <Constraints>
@@ -1725,12 +1742,19 @@ var AGENT_NAME_VARIANTS = {
   loom: ["loom", "Loom"],
   tapestry: ["tapestry", "Tapestry"]
 };
+var INITIAL_NAME_VARIANTS = new Map(Object.entries(AGENT_NAME_VARIANTS).map(([k, v]) => [k, [...v]]));
 function registerAgentNameVariants(name, variants) {
   if (AGENT_NAME_VARIANTS[name])
     return;
   const titleCase = name.charAt(0).toUpperCase() + name.slice(1);
   AGENT_NAME_VARIANTS[name] = variants ?? [name, titleCase];
 }
+function addBuiltinNameVariant(configKey, variant) {
+  const existing = AGENT_NAME_VARIANTS[configKey];
+  if (existing && !existing.includes(variant)) {
+    existing.push(variant);
+  }
+}
 function stripDisabledAgentReferences(prompt, disabled) {
   if (disabled.size === 0)
     return prompt;
@@ -1743,7 +1767,7 @@ function stripDisabledAgentReferences(prompt, disabled) {
   }
   if (disabledVariants.length === 0)
     return prompt;
-  const pattern = new RegExp(`\\b(${disabledVariants.map((v) => v.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})\\b`);
+  const pattern = new RegExp(`(?<!\\w)(${disabledVariants.map((v) => v.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})(?!\\w)`);
   const lines = prompt.split(`
 `);
   const filtered = lines.filter((line) => !pattern.test(line));
@@ -1888,7 +1912,10 @@ var KNOWN_TOOL_NAMES = new Set([
   "call_weave_agent",
   "webfetch",
   "todowrite",
-  "skill"
+  "skill",
+  "task_create",
+  "task_update",
+  "task_list"
 ]);
 var AGENT_NAME_PATTERN = /^[a-z][a-z0-9_-]*$/;
 function parseFallbackModels(models) {
@@ -1988,6 +2015,26 @@ function createManagers(options) {
     fingerprint,
     customAgentMetadata
   });
+  if (pluginConfig.agents) {
+    for (const [name, override] of Object.entries(pluginConfig.agents)) {
+      const displayName = override.display_name?.trim();
+      if (displayName) {
+        try {
+          updateBuiltinDisplayName(name, displayName);
+          addBuiltinNameVariant(name, displayName);
+          if (agents[name]) {
+            agents[name] = { ...agents[name], description: displayName };
+          }
+        } catch (err) {
+          if (err instanceof Error && err.message.includes("not a built-in agent")) {
+            log(`Skipping display_name override for non-builtin agent "${name}"`);
+          } else {
+            throw err;
+          }
+        }
+      }
+    }
+  }
   if (pluginConfig.custom_agents) {
     const disabledSet = new Set(pluginConfig.disabled_agents ?? []);
     for (const [name, customConfig] of Object.entries(pluginConfig.custom_agents)) {
@@ -2248,6 +2295,275 @@ function createSkillResolver(discovered) {
     return resolveMultipleSkills(skillNames, disabledSkills, discovered);
   };
 }
+// src/features/task-system/tools/task-create.ts
+import { tool } from "@opencode-ai/plugin";
+
+// src/features/task-system/storage.ts
+import { mkdirSync as mkdirSync2, writeFileSync, readFileSync as readFileSync4, renameSync, unlinkSync, readdirSync as readdirSync2, statSync, openSync, closeSync } from "fs";
+import { join as join5, basename } from "path";
+import { randomUUID } from "crypto";
+
+// src/features/task-system/types.ts
+import { z as z2 } from "zod";
+var TaskStatus = {
+  PENDING: "pending",
+  IN_PROGRESS: "in_progress",
+  COMPLETED: "completed",
+  DELETED: "deleted"
+};
+var TaskStatusSchema = z2.enum(["pending", "in_progress", "completed", "deleted"]);
+var TaskObjectSchema = z2.object({
+  id: z2.string(),
+  subject: z2.string(),
+  description: z2.string(),
+  status: TaskStatusSchema,
+  threadID: z2.string(),
+  blocks: z2.array(z2.string()).default([]),
+  blockedBy: z2.array(z2.string()).default([]),
+  metadata: z2.record(z2.string(), z2.unknown()).optional()
+});
+var TaskCreateInputSchema = z2.object({
+  subject: z2.string().describe("Short title for the task (required)"),
+  description: z2.string().optional().describe("Detailed description of the task"),
+  blocks: z2.array(z2.string()).optional().describe("Task IDs that this task blocks"),
+  blockedBy: z2.array(z2.string()).optional().describe("Task IDs that block this task"),
+  metadata: z2.record(z2.string(), z2.unknown()).optional().describe("Arbitrary key-value metadata")
+});
+var TaskUpdateInputSchema = z2.object({
+  id: z2.string().describe("Task ID to update (required, format: T-{uuid})"),
+  subject: z2.string().optional().describe("New subject/title"),
+  description: z2.string().optional().describe("New description"),
+  status: TaskStatusSchema.optional().describe("New status"),
+  addBlocks: z2.array(z2.string()).optional().describe("Task IDs to add to blocks (additive, no replacement)"),
+  addBlockedBy: z2.array(z2.string()).optional().describe("Task IDs to add to blockedBy (additive, no replacement)"),
+  metadata: z2.record(z2.string(), z2.unknown()).optional().describe("Metadata to merge (null values delete keys)")
+});
+var TaskListInputSchema = z2.object({});
+
+// src/features/task-system/storage.ts
+function getTaskDir(directory, configDir) {
+  const base = configDir ?? join5(getHomeDir(), ".config", "opencode");
+  const slug = sanitizeSlug(basename(directory));
+  return join5(base, "tasks", slug);
+}
+function getHomeDir() {
+  return process.env.HOME ?? process.env.USERPROFILE ?? "/tmp";
+}
+function sanitizeSlug(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-_]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "") || "default";
+}
+function generateTaskId() {
+  return `T-${randomUUID()}`;
+}
+function readJsonSafe(filePath, schema) {
+  try {
+    const raw = readFileSync4(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return schema.parse(parsed);
+  } catch {
+    return null;
+  }
+}
+function writeJsonAtomic(filePath, data) {
+  const dir = join5(filePath, "..");
+  mkdirSync2(dir, { recursive: true });
+  const tmpPath = `${filePath}.tmp`;
+  writeFileSync(tmpPath, JSON.stringify(data, null, 2), "utf-8");
+  renameSync(tmpPath, filePath);
+}
+function ensureDir(dirPath) {
+  mkdirSync2(dirPath, { recursive: true });
+}
+function listTaskFiles(taskDir) {
+  try {
+    return readdirSync2(taskDir).filter((f) => f.startsWith("T-") && f.endsWith(".json")).map((f) => join5(taskDir, f));
+  } catch {
+    return [];
+  }
+}
+function getTaskFilePath(taskDir, taskId) {
+  return join5(taskDir, `${taskId}.json`);
+}
+function readTask(taskDir, taskId) {
+  return readJsonSafe(getTaskFilePath(taskDir, taskId), TaskObjectSchema);
+}
+function writeTask(taskDir, task) {
+  writeJsonAtomic(getTaskFilePath(taskDir, task.id), task);
+}
+function readAllTasks(taskDir) {
+  const files = listTaskFiles(taskDir);
+  const tasks = [];
+  for (const file of files) {
+    const task = readJsonSafe(file, TaskObjectSchema);
+    if (task)
+      tasks.push(task);
+  }
+  return tasks;
+}
+
+// src/features/task-system/todo-sync.ts
+function syncTaskToTodo(task) {
+  if (task.status === TaskStatus.DELETED) {
+    return null;
+  }
+  const statusMap = {
+    [TaskStatus.PENDING]: "pending",
+    [TaskStatus.IN_PROGRESS]: "in_progress",
+    [TaskStatus.COMPLETED]: "completed"
+  };
+  const priority = task.metadata?.priority ?? undefined;
+  return {
+    id: task.id,
+    content: task.subject,
+    status: statusMap[task.status] ?? "pending",
+    ...priority ? { priority } : {}
+  };
+}
+function todosMatch(a, b) {
+  if (a.id && b.id)
+    return a.id === b.id;
+  return a.content === b.content;
+}
+async function syncTaskTodoUpdate(writer, sessionId, task) {
+  if (!writer) {
+    log("[task-sync] No todo writer available — skipping sidebar sync");
+    return;
+  }
+  try {
+    const currentTodos = await writer.read(sessionId);
+    const todoItem = syncTaskToTodo(task);
+    const filtered = currentTodos.filter((t) => !todosMatch(t, { id: task.id, content: task.subject, status: "pending" }));
+    if (todoItem) {
+      filtered.push(todoItem);
+    }
+    await writer.update(sessionId, filtered);
+  } catch (err) {
+    log("[task-sync] Failed to sync task to sidebar (non-fatal)", { taskId: task.id, error: String(err) });
+  }
+}
+
+// src/features/task-system/tools/task-create.ts
+function createTaskCreateTool(options) {
+  const { directory, configDir, todoWriter = null } = options;
+  return tool({
+    description: "Create a new task. Use this instead of todowrite for task tracking. " + "Each task gets a unique ID and is stored atomically — creating a task never destroys existing tasks or todos.",
+    args: {
+      subject: tool.schema.string().describe("Short title for the task (required)"),
+      description: tool.schema.string().optional().describe("Detailed description of the task"),
+      blocks: tool.schema.array(tool.schema.string()).optional().describe("Task IDs that this task blocks"),
+      blockedBy: tool.schema.array(tool.schema.string()).optional().describe("Task IDs that block this task"),
+      metadata: tool.schema.record(tool.schema.string(), tool.schema.unknown()).optional().describe("Arbitrary key-value metadata")
+    },
+    async execute(args, context) {
+      const taskDir = getTaskDir(directory, configDir);
+      ensureDir(taskDir);
+      const task = {
+        id: generateTaskId(),
+        subject: args.subject,
+        description: args.description ?? "",
+        status: TaskStatus.PENDING,
+        threadID: context.sessionID,
+        blocks: args.blocks ?? [],
+        blockedBy: args.blockedBy ?? [],
+        metadata: args.metadata
+      };
+      writeTask(taskDir, task);
+      log("[task-create] Created task", { id: task.id, subject: task.subject });
+      await syncTaskTodoUpdate(todoWriter, context.sessionID, task);
+      return JSON.stringify({ task: { id: task.id, subject: task.subject } });
+    }
+  });
+}
+// src/features/task-system/tools/task-update.ts
+import { tool as tool2 } from "@opencode-ai/plugin";
+var TASK_ID_PATTERN = /^T-[A-Za-z0-9-]+$/;
+function createTaskUpdateTool(options) {
+  const { directory, configDir, todoWriter = null } = options;
+  return tool2({
+    description: "Update an existing task by ID. Modifies only the specified fields — " + "other tasks and non-task todos are completely untouched. " + "blocks/blockedBy are additive (appended, never replaced).",
+    args: {
+      id: tool2.schema.string().describe("Task ID to update (required, format: T-{uuid})"),
+      subject: tool2.schema.string().optional().describe("New subject/title"),
+      description: tool2.schema.string().optional().describe("New description"),
+      status: tool2.schema.enum(["pending", "in_progress", "completed", "deleted"]).optional().describe("New status"),
+      addBlocks: tool2.schema.array(tool2.schema.string()).optional().describe("Task IDs to add to blocks (additive)"),
+      addBlockedBy: tool2.schema.array(tool2.schema.string()).optional().describe("Task IDs to add to blockedBy (additive)"),
+      metadata: tool2.schema.record(tool2.schema.string(), tool2.schema.unknown()).optional().describe("Metadata to merge (null values delete keys)")
+    },
+    async execute(args, context) {
+      if (!TASK_ID_PATTERN.test(args.id)) {
+        return JSON.stringify({ error: "invalid_task_id", message: `Invalid task ID format: ${args.id}. Expected T-{uuid}` });
+      }
+      const taskDir = getTaskDir(directory, configDir);
+      const task = readTask(taskDir, args.id);
+      if (!task) {
+        return JSON.stringify({ error: "task_not_found", message: `Task ${args.id} not found` });
+      }
+      if (args.subject !== undefined)
+        task.subject = args.subject;
+      if (args.description !== undefined)
+        task.description = args.description;
+      if (args.status !== undefined)
+        task.status = args.status;
+      if (args.addBlocks?.length) {
+        const existing = new Set(task.blocks);
+        for (const b of args.addBlocks) {
+          if (!existing.has(b)) {
+            task.blocks.push(b);
+            existing.add(b);
+          }
+        }
+      }
+      if (args.addBlockedBy?.length) {
+        const existing = new Set(task.blockedBy);
+        for (const b of args.addBlockedBy) {
+          if (!existing.has(b)) {
+            task.blockedBy.push(b);
+            existing.add(b);
+          }
+        }
+      }
+      if (args.metadata) {
+        const meta = task.metadata ?? {};
+        for (const [key, value] of Object.entries(args.metadata)) {
+          if (value === null) {
+            delete meta[key];
+          } else {
+            meta[key] = value;
+          }
+        }
+        task.metadata = Object.keys(meta).length > 0 ? meta : undefined;
+      }
+      writeTask(taskDir, task);
+      log("[task-update] Updated task", { id: task.id });
+      await syncTaskTodoUpdate(todoWriter, context.sessionID, task);
+      return JSON.stringify({ task });
+    }
+  });
+}
+// src/features/task-system/tools/task-list.ts
+import { tool as tool3 } from "@opencode-ai/plugin";
+function createTaskListTool(options) {
+  const { directory, configDir } = options;
+  return tool3({
+    description: "List all active tasks (pending and in_progress). " + "Excludes completed and deleted tasks. " + "Shows unresolved blockers for each task.",
+    args: {},
+    async execute(_args, _context) {
+      const taskDir = getTaskDir(directory, configDir);
+      const allTasks = readAllTasks(taskDir);
+      const activeTasks = allTasks.filter((t) => t.status !== TaskStatus.COMPLETED && t.status !== TaskStatus.DELETED);
+      const completedIds = new Set(allTasks.filter((t) => t.status === TaskStatus.COMPLETED).map((t) => t.id));
+      const tasks = activeTasks.map((t) => ({
+        id: t.id,
+        subject: t.subject,
+        status: t.status,
+        blockedBy: t.blockedBy.filter((b) => !completedIds.has(b))
+      }));
+      log("[task-list] Listed tasks", { count: tasks.length });
+      return JSON.stringify({ tasks });
+    }
+  });
+}
 // src/create-tools.ts
 async function createTools(options) {
   const { ctx, pluginConfig } = options;
@@ -2258,6 +2574,13 @@ async function createTools(options) {
   });
   const resolveSkillsFn = createSkillResolver(skillResult);
   const tools = {};
+  if (pluginConfig.experimental?.task_system !== false) {
+    const toolOptions = { directory: ctx.directory };
+    tools.task_create = createTaskCreateTool(toolOptions);
+    tools.task_update = createTaskUpdateTool(toolOptions);
+    tools.task_list = createTaskListTool(toolOptions);
+    log("[task-system] Registered task tools (task_create, task_update, task_list)");
+  }
   return {
     tools,
     availableSkills: skillResult.skills,
@@ -2450,17 +2773,17 @@ var WORK_STATE_FILE = "state.json";
 var WORK_STATE_PATH = `${WEAVE_DIR}/${WORK_STATE_FILE}`;
 var PLANS_DIR = `${WEAVE_DIR}/plans`;
 // src/features/work-state/storage.ts
-import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync, unlinkSync, mkdirSync as mkdirSync2, readdirSync as readdirSync2, statSync } from "fs";
-import { join as join6, basename } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2, mkdirSync as mkdirSync3, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
+import { join as join7, basename as basename2 } from "path";
 import { execSync } from "child_process";
 var UNCHECKED_RE = /^[-*]\s*\[\s*\]/gm;
 var CHECKED_RE = /^[-*]\s*\[[xX]\]/gm;
 function readWorkState(directory) {
-  const filePath = join6(directory, WEAVE_DIR, WORK_STATE_FILE);
+  const filePath = join7(directory, WEAVE_DIR, WORK_STATE_FILE);
   try {
     if (!existsSync7(filePath))
       return null;
-    const raw = readFileSync5(filePath, "utf-8");
+    const raw = readFileSync6(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
       return null;
@@ -2476,21 +2799,21 @@ function readWorkState(directory) {
 }
 function writeWorkState(directory, state) {
   try {
-    const dir = join6(directory, WEAVE_DIR);
+    const dir = join7(directory, WEAVE_DIR);
     if (!existsSync7(dir)) {
-      mkdirSync2(dir, { recursive: true });
+      mkdirSync3(dir, { recursive: true });
     }
-    writeFileSync(join6(dir, WORK_STATE_FILE), JSON.stringify(state, null, 2), "utf-8");
+    writeFileSync2(join7(dir, WORK_STATE_FILE), JSON.stringify(state, null, 2), "utf-8");
     return true;
   } catch {
     return false;
   }
 }
 function clearWorkState(directory) {
-  const filePath = join6(directory, WEAVE_DIR, WORK_STATE_FILE);
+  const filePath = join7(directory, WEAVE_DIR, WORK_STATE_FILE);
   try {
     if (existsSync7(filePath)) {
-      unlinkSync(filePath);
+      unlinkSync2(filePath);
     }
     return true;
   } catch {
@@ -2531,13 +2854,13 @@ function getHeadSha(directory) {
   }
 }
 function findPlans(directory) {
-  const plansDir = join6(directory, PLANS_DIR);
+  const plansDir = join7(directory, PLANS_DIR);
   try {
     if (!existsSync7(plansDir))
       return [];
-    const files = readdirSync2(plansDir).filter((f) => f.endsWith(".md")).map((f) => {
-      const fullPath = join6(plansDir, f);
-      const stat = statSync(fullPath);
+    const files = readdirSync3(plansDir).filter((f) => f.endsWith(".md")).map((f) => {
+      const fullPath = join7(plansDir, f);
+      const stat = statSync2(fullPath);
       return { path: fullPath, mtime: stat.mtimeMs };
     }).sort((a, b) => b.mtime - a.mtime).map((f) => f.path);
     return files;
@@ -2550,7 +2873,7 @@ function getPlanProgress(planPath) {
     return { total: 0, completed: 0, isComplete: true };
   }
   try {
-    const content = readFileSync5(planPath, "utf-8");
+    const content = readFileSync6(planPath, "utf-8");
     const unchecked = content.match(UNCHECKED_RE) || [];
     const checked = content.match(CHECKED_RE) || [];
     const total = unchecked.length + checked.length;
@@ -2565,7 +2888,7 @@ function getPlanProgress(planPath) {
   }
 }
 function getPlanName(planPath) {
-  return basename(planPath, ".md");
+  return basename2(planPath, ".md");
 }
 function pauseWork(directory) {
   const state = readWorkState(directory);
@@ -2582,7 +2905,7 @@ function resumeWork(directory) {
   return writeWorkState(directory, state);
 }
 // src/features/work-state/validation.ts
-import { readFileSync as readFileSync6, existsSync as existsSync8 } from "fs";
+import { readFileSync as readFileSync7, existsSync as existsSync8 } from "fs";
 import { resolve as resolve3, sep as sep2 } from "path";
 function validatePlan(planPath, projectDir) {
   const errors = [];
@@ -2605,13 +2928,13 @@ function validatePlan(planPath, projectDir) {
     });
     return { valid: false, errors, warnings };
   }
-  const content = readFileSync6(resolvedPlanPath, "utf-8");
+  const content = readFileSync7(resolvedPlanPath, "utf-8");
   validateStructure(content, errors, warnings);
   validateCheckboxes(content, errors, warnings);
   validateFileReferences(content, projectDir, warnings);
   validateNumbering(content, errors, warnings);
   validateEffortEstimate(content, warnings);
-  validateVerificationSection(content, errors);
+  validateVerificationSection(content, warnings);
   return {
     valid: errors.length === 0,
     errors,
@@ -2643,15 +2966,15 @@ function hasSection(content, heading) {
   return content.split(`
 `).some((line) => line.trim() === heading);
 }
-function validateStructure(content, errors, warnings) {
-  const requiredSections = [
-    ["## TL;DR", "Missing required section: ## TL;DR"],
-    ["## TODOs", "Missing required section: ## TODOs"],
-    ["## Verification", "Missing required section: ## Verification"]
+function validateStructure(content, _errors, warnings) {
+  const expectedSections = [
+    ["## TL;DR", "Missing expected section: ## TL;DR"],
+    ["## TODOs", "Missing expected section: ## TODOs"],
+    ["## Verification", "Missing expected section: ## Verification"]
   ];
-  for (const [heading, message] of requiredSections) {
+  for (const [heading, message] of expectedSections) {
     if (!hasSection(content, heading)) {
-      errors.push({ severity: "error", category: "structure", message });
+      warnings.push({ severity: "warning", category: "structure", message });
     }
   }
   const optionalSections = [
@@ -2667,6 +2990,14 @@ function validateStructure(content, errors, warnings) {
 function validateCheckboxes(content, errors, warnings) {
   const todosSection = extractSection(content, "## TODOs");
   if (todosSection === null) {
+    const hasAnyCheckbox = /^- \[[ x]\] /m.test(content);
+    if (!hasAnyCheckbox) {
+      errors.push({
+        severity: "error",
+        category: "checkboxes",
+        message: "Plan contains no checkboxes (- [ ] or - [x]) — nothing to execute"
+      });
+    }
     return;
   }
   const checkboxPattern = /^- \[[ x]\] /m;
@@ -2847,17 +3178,17 @@ function validateEffortEstimate(content, warnings) {
     });
   }
 }
-function validateVerificationSection(content, errors) {
+function validateVerificationSection(content, warnings) {
   const verificationSection = extractSection(content, "## Verification");
   if (verificationSection === null) {
     return;
   }
   const hasCheckbox = /^- \[[ x]\] /m.test(verificationSection);
   if (!hasCheckbox) {
-    errors.push({
-      severity: "error",
+    warnings.push({
+      severity: "warning",
       category: "verification",
-      message: "## Verification section contains no checkboxes — at least one verifiable condition is required"
+      message: "## Verification section contains no checkboxes — consider adding verifiable conditions"
     });
   }
 }
@@ -2868,8 +3199,8 @@ var ACTIVE_INSTANCE_FILE = "active-instance.json";
 var WORKFLOWS_DIR_PROJECT = ".opencode/workflows";
 var WORKFLOWS_DIR_USER = "workflows";
 // src/features/workflow/storage.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2, mkdirSync as mkdirSync3, readdirSync as readdirSync3 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync8, writeFileSync as writeFileSync3, unlinkSync as unlinkSync3, mkdirSync as mkdirSync4, readdirSync as readdirSync4 } from "fs";
+import { join as join8 } from "path";
 import { randomBytes } from "node:crypto";
 function generateInstanceId() {
   return `wf_${randomBytes(4).toString("hex")}`;
@@ -2905,11 +3236,11 @@ function createWorkflowInstance(definition, definitionPath, goal, sessionId) {
   };
 }
 function readWorkflowInstance(directory, instanceId) {
-  const filePath = join7(directory, WORKFLOWS_STATE_DIR, instanceId, INSTANCE_STATE_FILE);
+  const filePath = join8(directory, WORKFLOWS_STATE_DIR, instanceId, INSTANCE_STATE_FILE);
   try {
     if (!existsSync9(filePath))
       return null;
-    const raw = readFileSync7(filePath, "utf-8");
+    const raw = readFileSync8(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
       return null;
@@ -2922,22 +3253,22 @@ function readWorkflowInstance(directory, instanceId) {
 }
 function writeWorkflowInstance(directory, instance) {
   try {
-    const dir = join7(directory, WORKFLOWS_STATE_DIR, instance.instance_id);
+    const dir = join8(directory, WORKFLOWS_STATE_DIR, instance.instance_id);
     if (!existsSync9(dir)) {
-      mkdirSync3(dir, { recursive: true });
+      mkdirSync4(dir, { recursive: true });
     }
-    writeFileSync2(join7(dir, INSTANCE_STATE_FILE), JSON.stringify(instance, null, 2), "utf-8");
+    writeFileSync3(join8(dir, INSTANCE_STATE_FILE), JSON.stringify(instance, null, 2), "utf-8");
     return true;
   } catch {
     return false;
   }
 }
 function readActiveInstance(directory) {
-  const filePath = join7(directory, WORKFLOWS_STATE_DIR, ACTIVE_INSTANCE_FILE);
+  const filePath = join8(directory, WORKFLOWS_STATE_DIR, ACTIVE_INSTANCE_FILE);
   try {
     if (!existsSync9(filePath))
       return null;
-    const raw = readFileSync7(filePath, "utf-8");
+    const raw = readFileSync8(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || typeof parsed.instance_id !== "string")
       return null;
@@ -2948,22 +3279,22 @@ function readActiveInstance(directory) {
 }
 function setActiveInstance(directory, instanceId) {
   try {
-    const dir = join7(directory, WORKFLOWS_STATE_DIR);
+    const dir = join8(directory, WORKFLOWS_STATE_DIR);
     if (!existsSync9(dir)) {
-      mkdirSync3(dir, { recursive: true });
+      mkdirSync4(dir, { recursive: true });
     }
     const pointer = { instance_id: instanceId };
-    writeFileSync2(join7(dir, ACTIVE_INSTANCE_FILE), JSON.stringify(pointer, null, 2), "utf-8");
+    writeFileSync3(join8(dir, ACTIVE_INSTANCE_FILE), JSON.stringify(pointer, null, 2), "utf-8");
     return true;
   } catch {
     return false;
   }
 }
 function clearActiveInstance(directory) {
-  const filePath = join7(directory, WORKFLOWS_STATE_DIR, ACTIVE_INSTANCE_FILE);
+  const filePath = join8(directory, WORKFLOWS_STATE_DIR, ACTIVE_INSTANCE_FILE);
   try {
     if (existsSync9(filePath)) {
-      unlinkSync2(filePath);
+      unlinkSync3(filePath);
     }
     return true;
   } catch {
@@ -2983,35 +3314,35 @@ import * as os3 from "os";
 import { parse as parseJsonc } from "jsonc-parser";
 
 // src/features/workflow/schema.ts
-import { z as z2 } from "zod";
-var CompletionConfigSchema = z2.object({
-  method: z2.enum(["user_confirm", "plan_created", "plan_complete", "review_verdict", "agent_signal"]),
-  plan_name: z2.string().optional(),
-  keywords: z2.array(z2.string()).optional()
+import { z as z3 } from "zod";
+var CompletionConfigSchema = z3.object({
+  method: z3.enum(["user_confirm", "plan_created", "plan_complete", "review_verdict", "agent_signal"]),
+  plan_name: z3.string().optional(),
+  keywords: z3.array(z3.string()).optional()
 });
-var ArtifactRefSchema = z2.object({
-  name: z2.string(),
-  description: z2.string().optional()
+var ArtifactRefSchema = z3.object({
+  name: z3.string(),
+  description: z3.string().optional()
 });
-var StepArtifactsSchema = z2.object({
-  inputs: z2.array(ArtifactRefSchema).optional(),
-  outputs: z2.array(ArtifactRefSchema).optional()
+var StepArtifactsSchema = z3.object({
+  inputs: z3.array(ArtifactRefSchema).optional(),
+  outputs: z3.array(ArtifactRefSchema).optional()
 });
-var WorkflowStepSchema = z2.object({
-  id: z2.string().regex(/^[a-z][a-z0-9-]*$/, "Step ID must be lowercase alphanumeric with hyphens"),
-  name: z2.string(),
-  type: z2.enum(["interactive", "autonomous", "gate"]),
-  agent: z2.string(),
-  prompt: z2.string(),
+var WorkflowStepSchema = z3.object({
+  id: z3.string().regex(/^[a-z][a-z0-9-]*$/, "Step ID must be lowercase alphanumeric with hyphens"),
+  name: z3.string(),
+  type: z3.enum(["interactive", "autonomous", "gate"]),
+  agent: z3.string(),
+  prompt: z3.string(),
   completion: CompletionConfigSchema,
   artifacts: StepArtifactsSchema.optional(),
-  on_reject: z2.enum(["pause", "fail"]).optional()
+  on_reject: z3.enum(["pause", "fail"]).optional()
 });
-var WorkflowDefinitionSchema = z2.object({
-  name: z2.string().regex(/^[a-z][a-z0-9-]*$/, "Workflow name must be lowercase alphanumeric with hyphens"),
-  description: z2.string().optional(),
-  version: z2.number().int().positive(),
-  steps: z2.array(WorkflowStepSchema).min(1, "Workflow must have at least one step")
+var WorkflowDefinitionSchema = z3.object({
+  name: z3.string().regex(/^[a-z][a-z0-9-]*$/, "Workflow name must be lowercase alphanumeric with hyphens"),
+  description: z3.string().optional(),
+  version: z3.number().int().positive(),
+  steps: z3.array(WorkflowStepSchema).min(1, "Workflow must have at least one step")
 });
 
 // src/features/workflow/discovery.ts
@@ -3153,7 +3484,7 @@ function truncateSummary(text) {
 }
 // src/features/workflow/completion.ts
 import { existsSync as existsSync11 } from "fs";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 var DEFAULT_CONFIRM_KEYWORDS = ["confirmed", "approved", "continue", "done", "let's proceed", "looks good", "lgtm"];
 var VERDICT_APPROVE_RE = /\[\s*APPROVE\s*\]/i;
 var VERDICT_REJECT_RE = /\[\s*REJECT\s*\]/i;
@@ -3205,7 +3536,7 @@ function checkPlanCreated(context) {
       summary: `Plan created at ${matchingPlan}`
     };
   }
-  const directPath = join9(directory, ".weave", "plans", `${planName}.md`);
+  const directPath = join10(directory, ".weave", "plans", `${planName}.md`);
   if (existsSync11(directPath)) {
     return {
       complete: true,
@@ -3221,7 +3552,7 @@ function checkPlanComplete(context) {
   if (!planName) {
     return { complete: false, reason: "plan_complete requires plan_name in completion config" };
   }
-  const planPath = join9(directory, ".weave", "plans", `${planName}.md`);
+  const planPath = join10(directory, ".weave", "plans", `${planName}.md`);
   if (!existsSync11(planPath)) {
     return { complete: false, reason: `Plan file not found: ${planPath}` };
   }
@@ -4183,8 +4514,8 @@ function clearSession2(sessionId) {
   sessionMap.delete(sessionId);
 }
 // src/features/analytics/storage.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync4, appendFileSync as appendFileSync2, readFileSync as readFileSync9, writeFileSync as writeFileSync3, statSync as statSync2 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync5, appendFileSync as appendFileSync2, readFileSync as readFileSync10, writeFileSync as writeFileSync4, statSync as statSync3 } from "fs";
+import { join as join11 } from "path";
 
 // src/features/analytics/types.ts
 var ANALYTICS_DIR = ".weave/analytics";
@@ -4199,30 +4530,30 @@ function zeroTokenUsage() {
 // src/features/analytics/storage.ts
 var MAX_SESSION_ENTRIES = 1000;
 function ensureAnalyticsDir(directory) {
-  const dir = join10(directory, ANALYTICS_DIR);
-  mkdirSync4(dir, { recursive: true, mode: 448 });
+  const dir = join11(directory, ANALYTICS_DIR);
+  mkdirSync5(dir, { recursive: true, mode: 448 });
   return dir;
 }
 function appendSessionSummary(directory, summary) {
   try {
     const dir = ensureAnalyticsDir(directory);
-    const filePath = join10(dir, SESSION_SUMMARIES_FILE);
+    const filePath = join11(dir, SESSION_SUMMARIES_FILE);
     const line = JSON.stringify(summary) + `
 `;
     appendFileSync2(filePath, line, { encoding: "utf-8", mode: 384 });
     try {
       const TYPICAL_ENTRY_BYTES = 200;
       const rotationSizeThreshold = MAX_SESSION_ENTRIES * TYPICAL_ENTRY_BYTES * 0.9;
-      const { size } = statSync2(filePath);
+      const { size } = statSync3(filePath);
       if (size > rotationSizeThreshold) {
-        const content = readFileSync9(filePath, "utf-8");
+        const content = readFileSync10(filePath, "utf-8");
         const lines = content.split(`
 `).filter((l) => l.trim().length > 0);
         if (lines.length > MAX_SESSION_ENTRIES) {
           const trimmed = lines.slice(-MAX_SESSION_ENTRIES).join(`
 `) + `
 `;
-          writeFileSync3(filePath, trimmed, { encoding: "utf-8", mode: 384 });
+          writeFileSync4(filePath, trimmed, { encoding: "utf-8", mode: 384 });
         }
       }
     } catch {}
@@ -4232,11 +4563,11 @@ function appendSessionSummary(directory, summary) {
   }
 }
 function readSessionSummaries(directory) {
-  const filePath = join10(directory, ANALYTICS_DIR, SESSION_SUMMARIES_FILE);
+  const filePath = join11(directory, ANALYTICS_DIR, SESSION_SUMMARIES_FILE);
   try {
     if (!existsSync12(filePath))
       return [];
-    const content = readFileSync9(filePath, "utf-8");
+    const content = readFileSync10(filePath, "utf-8");
     const lines = content.split(`
 `).filter((line) => line.trim().length > 0);
     const summaries = [];
@@ -4253,19 +4584,19 @@ function readSessionSummaries(directory) {
 function writeFingerprint(directory, fingerprint) {
   try {
     const dir = ensureAnalyticsDir(directory);
-    const filePath = join10(dir, FINGERPRINT_FILE);
-    writeFileSync3(filePath, JSON.stringify(fingerprint, null, 2), { encoding: "utf-8", mode: 384 });
+    const filePath = join11(dir, FINGERPRINT_FILE);
+    writeFileSync4(filePath, JSON.stringify(fingerprint, null, 2), { encoding: "utf-8", mode: 384 });
     return true;
   } catch {
     return false;
   }
 }
 function readFingerprint(directory) {
-  const filePath = join10(directory, ANALYTICS_DIR, FINGERPRINT_FILE);
+  const filePath = join11(directory, ANALYTICS_DIR, FINGERPRINT_FILE);
   try {
     if (!existsSync12(filePath))
       return null;
-    const content = readFileSync9(filePath, "utf-8");
+    const content = readFileSync10(filePath, "utf-8");
     const parsed = JSON.parse(content);
     if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.stack))
       return null;
@@ -4277,23 +4608,23 @@ function readFingerprint(directory) {
 function writeMetricsReport(directory, report) {
   try {
     const dir = ensureAnalyticsDir(directory);
-    const filePath = join10(dir, METRICS_REPORTS_FILE);
+    const filePath = join11(dir, METRICS_REPORTS_FILE);
     const line = JSON.stringify(report) + `
 `;
     appendFileSync2(filePath, line, { encoding: "utf-8", mode: 384 });
     try {
       const TYPICAL_ENTRY_BYTES = 200;
       const rotationSizeThreshold = MAX_METRICS_ENTRIES * TYPICAL_ENTRY_BYTES * 0.9;
-      const { size } = statSync2(filePath);
+      const { size } = statSync3(filePath);
       if (size > rotationSizeThreshold) {
-        const content = readFileSync9(filePath, "utf-8");
+        const content = readFileSync10(filePath, "utf-8");
         const lines = content.split(`
 `).filter((l) => l.trim().length > 0);
         if (lines.length > MAX_METRICS_ENTRIES) {
           const trimmed = lines.slice(-MAX_METRICS_ENTRIES).join(`
 `) + `
 `;
-          writeFileSync3(filePath, trimmed, { encoding: "utf-8", mode: 384 });
+          writeFileSync4(filePath, trimmed, { encoding: "utf-8", mode: 384 });
         }
       }
     } catch {}
@@ -4303,11 +4634,11 @@ function writeMetricsReport(directory, report) {
   }
 }
 function readMetricsReports(directory) {
-  const filePath = join10(directory, ANALYTICS_DIR, METRICS_REPORTS_FILE);
+  const filePath = join11(directory, ANALYTICS_DIR, METRICS_REPORTS_FILE);
   try {
     if (!existsSync12(filePath))
       return [];
-    const content = readFileSync9(filePath, "utf-8");
+    const content = readFileSync10(filePath, "utf-8");
     const lines = content.split(`
 `).filter((line) => line.trim().length > 0);
     const reports = [];
@@ -4468,7 +4799,7 @@ function topTools(summaries, limit = 5) {
       counts[t.tool] = (counts[t.tool] ?? 0) + t.count;
     }
   }
-  return Object.entries(counts).map(([tool, count]) => ({ tool, count })).sort((a, b) => b.count - a.count).slice(0, limit);
+  return Object.entries(counts).map(([tool4, count]) => ({ tool: tool4, count })).sort((a, b) => b.count - a.count).slice(0, limit);
 }
 function formatMetricsMarkdown(reports, summaries, args) {
   if (reports.length === 0 && summaries.length === 0) {
@@ -4533,7 +4864,7 @@ function formatMetricsMarkdown(reports, summaries, args) {
 }
 
 // src/features/analytics/plan-parser.ts
-import { readFileSync as readFileSync10 } from "fs";
+import { readFileSync as readFileSync11 } from "fs";
 function extractSection2(content, heading) {
   const lines = content.split(`
 `);
@@ -4568,7 +4899,7 @@ function extractFilePath2(raw) {
 function extractPlannedFiles(planPath) {
   let content;
   try {
-    content = readFileSync10(planPath, "utf-8");
+    content = readFileSync11(planPath, "utf-8");
   } catch {
     return [];
   }
@@ -4718,7 +5049,7 @@ function generateMetricsReport(directory, state) {
 // src/plugin/plugin-interface.ts
 var FINALIZE_TODOS_MARKER = "<!-- weave:finalize-todos -->";
 function createPluginInterface(args) {
-  const { pluginConfig, hooks, tools, configHandler, agents, client, directory = "", tracker } = args;
+  const { pluginConfig, hooks, tools, configHandler, agents, client, directory = "", tracker, taskSystemEnabled = false } = args;
   const lastAssistantMessageText = new Map;
   const lastUserMessageText = new Map;
   const todoFinalizedSessions = new Set;
@@ -4730,9 +5061,24 @@ function createPluginInterface(args) {
         agents,
         availableTools: []
       });
-      config.agent = result.agents;
-      config.command = result.commands;
-      if (result.defaultAgent) {
+      const existingAgents = config.agent ?? {};
+      if (Object.keys(existingAgents).length > 0) {
+        log("[config] Merging Weave agents over existing agents", {
+          existingCount: Object.keys(existingAgents).length,
+          weaveCount: Object.keys(result.agents).length,
+          existingKeys: Object.keys(existingAgents)
+        });
+        const collisions = Object.keys(result.agents).filter((key) => (key in existingAgents));
+        if (collisions.length > 0) {
+          log("[config] Weave agents overriding user-defined agents with same name", {
+            overriddenKeys: collisions
+          });
+        }
+      }
+      config.agent = { ...existingAgents, ...result.agents };
+      const existingCommands = config.command ?? {};
+      config.command = { ...existingCommands, ...result.commands };
+      if (result.defaultAgent && !config.default_agent) {
         config.default_agent = result.defaultAgent;
       }
     },
@@ -4804,7 +5150,7 @@ ${result.contextInjection}`;
 `).trim() ?? "";
         if (userText && sessionID) {
           lastUserMessageText.set(sessionID, userText);
-          if (!userText.includes(FINALIZE_TODOS_MARKER)) {
+          if (!taskSystemEnabled && !userText.includes(FINALIZE_TODOS_MARKER)) {
             todoFinalizedSessions.delete(sessionID);
           }
         }
@@ -4841,7 +5187,7 @@ ${cmdResult.contextInjection}`;
         const isStartWork = promptText.includes("<session-context>");
         const isContinuation = promptText.includes(CONTINUATION_MARKER);
         const isWorkflowContinuation = promptText.includes(WORKFLOW_CONTINUATION_MARKER);
-        const isTodoFinalize = promptText.includes(FINALIZE_TODOS_MARKER);
+        const isTodoFinalize = !taskSystemEnabled && promptText.includes(FINALIZE_TODOS_MARKER);
         const isActiveWorkflow = (() => {
           const wf = getActiveWorkflowInstance(directory);
           return wf != null && wf.status === "running";
@@ -5025,7 +5371,7 @@ ${cmdResult.contextInjection}`;
           }
         }
       }
-      if (event.type === "session.idle" && client && !continuationFired) {
+      if (event.type === "session.idle" && client && !continuationFired && !taskSystemEnabled) {
         const evt = event;
         const sessionId = evt.properties?.sessionID ?? "";
         if (sessionId && !todoFinalizedSessions.has(sessionId)) {
@@ -5141,14 +5487,14 @@ Use todowrite NOW to mark all of them as "completed" (or "cancelled" if abandone
   };
 }
 // src/features/analytics/fingerprint.ts
-import { existsSync as existsSync13, readFileSync as readFileSync12, readdirSync as readdirSync5 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync13, readdirSync as readdirSync6 } from "fs";
+import { join as join13 } from "path";
 import { arch } from "os";
 
 // src/shared/version.ts
-import { readFileSync as readFileSync11 } from "fs";
+import { readFileSync as readFileSync12 } from "fs";
 import { fileURLToPath } from "url";
-import { dirname as dirname2, join as join11 } from "path";
+import { dirname as dirname2, join as join12 } from "path";
 var cachedVersion;
 function getWeaveVersion() {
   if (cachedVersion !== undefined)
@@ -5157,7 +5503,7 @@ function getWeaveVersion() {
     const thisDir = dirname2(fileURLToPath(import.meta.url));
     for (const rel of ["../../package.json", "../package.json"]) {
       try {
-        const pkg = JSON.parse(readFileSync11(join11(thisDir, rel), "utf-8"));
+        const pkg = JSON.parse(readFileSync12(join12(thisDir, rel), "utf-8"));
         if (pkg.name === "@opencode_weave/weave" && typeof pkg.version === "string") {
           const version = pkg.version;
           cachedVersion = version;
@@ -5262,7 +5608,7 @@ function detectStack(directory) {
   const detected = [];
   for (const marker of STACK_MARKERS) {
     for (const file of marker.files) {
-      if (existsSync13(join12(directory, file))) {
+      if (existsSync13(join13(directory, file))) {
         detected.push({
           name: marker.name,
           confidence: marker.confidence,
@@ -5273,9 +5619,9 @@ function detectStack(directory) {
     }
   }
   try {
-    const pkgPath = join12(directory, "package.json");
+    const pkgPath = join13(directory, "package.json");
     if (existsSync13(pkgPath)) {
-      const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync13(pkgPath, "utf-8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps.react) {
         detected.push({
@@ -5288,7 +5634,7 @@ function detectStack(directory) {
   } catch {}
   if (!detected.some((d) => d.name === "dotnet")) {
     try {
-      const entries = readdirSync5(directory);
+      const entries = readdirSync6(directory);
       const dotnetFile = entries.find((e) => e.endsWith(".csproj") || e.endsWith(".fsproj") || e.endsWith(".sln"));
       if (dotnetFile) {
         detected.push({
@@ -5308,27 +5654,27 @@ function detectStack(directory) {
   });
 }
 function detectPackageManager(directory) {
-  if (existsSync13(join12(directory, "bun.lockb")))
+  if (existsSync13(join13(directory, "bun.lockb")))
     return "bun";
-  if (existsSync13(join12(directory, "pnpm-lock.yaml")))
+  if (existsSync13(join13(directory, "pnpm-lock.yaml")))
     return "pnpm";
-  if (existsSync13(join12(directory, "yarn.lock")))
+  if (existsSync13(join13(directory, "yarn.lock")))
     return "yarn";
-  if (existsSync13(join12(directory, "package-lock.json")))
+  if (existsSync13(join13(directory, "package-lock.json")))
     return "npm";
-  if (existsSync13(join12(directory, "package.json")))
+  if (existsSync13(join13(directory, "package.json")))
     return "npm";
   return;
 }
 function detectMonorepo(directory) {
   for (const marker of MONOREPO_MARKERS) {
-    if (existsSync13(join12(directory, marker)))
+    if (existsSync13(join13(directory, marker)))
       return true;
   }
   try {
-    const pkgPath = join12(directory, "package.json");
+    const pkgPath = join13(directory, "package.json");
     if (existsSync13(pkgPath)) {
-      const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync13(pkgPath, "utf-8"));
       if (pkg.workspaces)
         return true;
     }
@@ -5486,7 +5832,7 @@ class SessionTracker {
     const now = new Date;
     const startedAt = new Date(session.startedAt);
     const durationMs = now.getTime() - startedAt.getTime();
-    const toolUsage = Object.entries(session.toolCounts).map(([tool, count]) => ({ tool, count }));
+    const toolUsage = Object.entries(session.toolCounts).map(([tool4, count]) => ({ tool: tool4, count }));
     const totalToolCalls = toolUsage.reduce((sum, entry) => sum + entry.count, 0);
     const summary = {
       sessionId,
@@ -5548,7 +5894,7 @@ var WeavePlugin = async (ctx) => {
   const analyticsEnabled = pluginConfig.analytics?.enabled === true;
   const fingerprintEnabled = analyticsEnabled && pluginConfig.analytics?.use_fingerprint === true;
   const fingerprint = fingerprintEnabled ? getOrCreateFingerprint(ctx.directory) : null;
-  const configDir = join13(ctx.directory, ".opencode");
+  const configDir = join14(ctx.directory, ".opencode");
   const toolsResult = await createTools({ ctx, pluginConfig });
   const managers = createManagers({ ctx, pluginConfig, resolveSkills: toolsResult.resolveSkillsFn, fingerprint, configDir });
   const hooks = createHooks({ pluginConfig, isHookEnabled, directory: ctx.directory, analyticsEnabled });
@@ -5561,7 +5907,8 @@ var WeavePlugin = async (ctx) => {
     agents: managers.agents,
     client: ctx.client,
     directory: ctx.directory,
-    tracker: analytics?.tracker
+    tracker: analytics?.tracker,
+    taskSystemEnabled: pluginConfig.experimental?.task_system !== false
   });
 };
 var src_default = WeavePlugin;