@opencode_weave/weave 0.7.1 → 0.7.3

package/dist/config/schema.d.ts

@@ -84,6 +84,7 @@ export declare const ExperimentalConfigSchema: z.ZodObject<{
     plugin_load_timeout_ms: z.ZodOptional<z.ZodNumber>;
     context_window_warning_threshold: z.ZodOptional<z.ZodNumber>;
     context_window_critical_threshold: z.ZodOptional<z.ZodNumber>;
+    task_system: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
 export declare const DelegationTriggerSchema: z.ZodObject<{
     domain: z.ZodString;
@@ -258,6 +259,7 @@ export declare const WeaveConfigSchema: z.ZodObject<{
         plugin_load_timeout_ms: z.ZodOptional<z.ZodNumber>;
         context_window_warning_threshold: z.ZodOptional<z.ZodNumber>;
         context_window_critical_threshold: z.ZodOptional<z.ZodNumber>;
+        task_system: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>>;
     workflows: z.ZodOptional<z.ZodObject<{
         disabled_workflows: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/dist/features/task-system/index.d.ts

@@ -0,0 +1,6 @@
+export { createTaskCreateTool, createTaskUpdateTool, createTaskListTool } from "./tools";
+export { TaskStatus, TaskObjectSchema, TaskStatusSchema } from "./types";
+export type { TaskObject, TaskCreateInput, TaskUpdateInput, TaskListInput } from "./types";
+export { getTaskDir, generateTaskId, readTask, writeTask, readAllTasks } from "./storage";
+export { syncTaskToTodo, syncTaskTodoUpdate, syncAllTasksToTodos } from "./todo-sync";
+export type { TodoWriter, TodoInfo } from "./todo-sync";

package/dist/features/task-system/storage.d.ts

@@ -0,0 +1,38 @@
+import { type TaskObject } from "./types";
+/**
+ * Derive the task storage directory for a given project.
+ * Uses the opencode config dir (~/.config/opencode by default) + sanitized project slug.
+ */
+export declare function getTaskDir(directory: string, configDir?: string): string;
+/** Generate a unique task ID */
+export declare function generateTaskId(): string;
+/**
+ * Read and parse a JSON file safely. Returns null for missing, corrupt, or invalid data.
+ */
+export declare function readJsonSafe<T>(filePath: string, schema: {
+    parse: (data: unknown) => T;
+}): T | null;
+/**
+ * Write JSON atomically: write to a temp file then rename.
+ * This prevents partial writes from corrupting the target file.
+ */
+export declare function writeJsonAtomic(filePath: string, data: unknown): void;
+/**
+ * Acquire a file-based lock. Uses exclusive file creation (wx flag).
+ * Returns a release function on success, null on failure.
+ *
+ * Stale locks older than `staleThresholdMs` (default 30s) are automatically broken.
+ */
+export declare function acquireLock(lockPath: string, staleThresholdMs?: number): (() => void) | null;
+/** Ensure a directory exists */
+export declare function ensureDir(dirPath: string): void;
+/** List task files (T-*.json) in the task directory */
+export declare function listTaskFiles(taskDir: string): string[];
+/** Get the file path for a task by ID */
+export declare function getTaskFilePath(taskDir: string, taskId: string): string;
+/** Read a single task from file storage */
+export declare function readTask(taskDir: string, taskId: string): TaskObject | null;
+/** Write a single task to file storage (atomic) */
+export declare function writeTask(taskDir: string, task: TaskObject): void;
+/** Read all tasks from a task directory */
+export declare function readAllTasks(taskDir: string): TaskObject[];

package/dist/features/task-system/todo-sync.d.ts

@@ -0,0 +1,38 @@
+import type { TaskObject } from "./types";
+/** TodoInfo matches the shape expected by OpenCode's todo sidebar */
+export interface TodoInfo {
+    id?: string;
+    content: string;
+    status: "pending" | "in_progress" | "completed";
+    priority?: "high" | "medium" | "low";
+}
+/** TodoWriter interface — abstracts the OpenCode todo write API */
+export interface TodoWriter {
+    read(sessionId: string): Promise<TodoInfo[]>;
+    update(sessionId: string, todos: TodoInfo[]): Promise<void>;
+}
+/**
+ * Map a TaskObject to a TodoInfo for the sidebar.
+ * Returns null for deleted tasks (they should be removed from the sidebar).
+ */
+export declare function syncTaskToTodo(task: TaskObject): TodoInfo | null;
+/**
+ * Check if two todo items match by ID first, then by content as fallback.
+ */
+export declare function todosMatch(a: TodoInfo, b: TodoInfo): boolean;
+/**
+ * Sync a single task to the todo sidebar.
+ * This is the anti-obliteration mechanism:
+ * 1. Read current todos
+ * 2. Filter out the matching item (by ID or content)
+ * 3. Push the updated item (or omit it if deleted)
+ * 4. Write back the full list
+ *
+ * Non-task todos (those not matching any task ID) survive intact.
+ */
+export declare function syncTaskTodoUpdate(writer: TodoWriter | null, sessionId: string, task: TaskObject): Promise<void>;
+/**
+ * Sync all tasks to the todo sidebar, preserving non-task todos.
+ * Used for bulk reconciliation.
+ */
+export declare function syncAllTasksToTodos(writer: TodoWriter | null, sessionId: string, tasks: TaskObject[]): Promise<void>;

package/dist/features/task-system/tools/index.d.ts

@@ -0,0 +1,3 @@
+export { createTaskCreateTool } from "./task-create";
+export { createTaskUpdateTool } from "./task-update";
+export { createTaskListTool } from "./task-list";

package/dist/features/task-system/tools/task-create.d.ts

@@ -0,0 +1,9 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+import { type TodoWriter } from "../todo-sync";
+declare const TASK_ID_PATTERN: RegExp;
+export declare function createTaskCreateTool(options: {
+    directory: string;
+    configDir?: string;
+    todoWriter?: TodoWriter | null;
+}): ToolDefinition;
+export { TASK_ID_PATTERN };

package/dist/features/task-system/tools/task-list.d.ts

@@ -0,0 +1,5 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+export declare function createTaskListTool(options: {
+    directory: string;
+    configDir?: string;
+}): ToolDefinition;

package/dist/features/task-system/tools/task-update.d.ts

@@ -0,0 +1,7 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+import { type TodoWriter } from "../todo-sync";
+export declare function createTaskUpdateTool(options: {
+    directory: string;
+    configDir?: string;
+    todoWriter?: TodoWriter | null;
+}): ToolDefinition;

package/dist/features/task-system/types.d.ts

@@ -0,0 +1,63 @@
+import { z } from "zod";
+/** Task status values */
+export declare const TaskStatus: {
+    readonly PENDING: "pending";
+    readonly IN_PROGRESS: "in_progress";
+    readonly COMPLETED: "completed";
+    readonly DELETED: "deleted";
+};
+export type TaskStatus = (typeof TaskStatus)[keyof typeof TaskStatus];
+export declare const TaskStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    completed: "completed";
+    in_progress: "in_progress";
+    deleted: "deleted";
+}>;
+/**
+ * Core task object — simplified from OmO's schema.
+ * Drops: activeForm, owner, repoURL, parentID (per design decision D4).
+ */
+export declare const TaskObjectSchema: z.ZodObject<{
+    id: z.ZodString;
+    subject: z.ZodString;
+    description: z.ZodString;
+    status: z.ZodEnum<{
+        pending: "pending";
+        completed: "completed";
+        in_progress: "in_progress";
+        deleted: "deleted";
+    }>;
+    threadID: z.ZodString;
+    blocks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    blockedBy: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type TaskObject = z.infer<typeof TaskObjectSchema>;
+/** Input schema for task_create tool */
+export declare const TaskCreateInputSchema: z.ZodObject<{
+    subject: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    blocks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    blockedBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type TaskCreateInput = z.infer<typeof TaskCreateInputSchema>;
+/** Input schema for task_update tool */
+export declare const TaskUpdateInputSchema: z.ZodObject<{
+    id: z.ZodString;
+    subject: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        pending: "pending";
+        completed: "completed";
+        in_progress: "in_progress";
+        deleted: "deleted";
+    }>>;
+    addBlocks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    addBlockedBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type TaskUpdateInput = z.infer<typeof TaskUpdateInputSchema>;
+/** Input schema for task_list tool (no args needed for PoC) */
+export declare const TaskListInputSchema: z.ZodObject<{}, z.core.$strip>;
+export type TaskListInput = z.infer<typeof TaskListInputSchema>;

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";
@@ -53,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(),
@@ -1247,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>
@@ -1909,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) {
@@ -2289,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;
@@ -2299,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,
@@ -2491,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;
@@ -2517,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 {
@@ -2572,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;
@@ -2591,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;
@@ -2606,7 +2888,7 @@ function getPlanProgress(planPath) {
   }
 }
 function getPlanName(planPath) {
-  return basename(planPath, ".md");
+  return basename2(planPath, ".md");
 }
 function pauseWork(directory) {
   const state = readWorkState(directory);
@@ -2623,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 = [];
@@ -2646,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,
@@ -2684,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 = [
@@ -2708,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;
@@ -2888,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"
     });
   }
 }
@@ -2909,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")}`;
@@ -2946,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;
@@ -2963,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;
@@ -2989,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 {
@@ -3024,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
@@ -3194,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;
@@ -3246,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,
@@ -3262,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}` };
   }
@@ -4224,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";
@@ -4240,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 {}
@@ -4273,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 = [];
@@ -4294,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;
@@ -4318,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 {}
@@ -4344,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 = [];
@@ -4509,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) {
@@ -4574,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(`
 `);
@@ -4609,7 +4899,7 @@ function extractFilePath2(raw) {
 function extractPlannedFiles(planPath) {
   let content;
   try {
-    content = readFileSync10(planPath, "utf-8");
+    content = readFileSync11(planPath, "utf-8");
   } catch {
     return [];
   }
@@ -4759,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;
@@ -4771,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;
       }
     },
@@ -4845,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);
           }
         }
@@ -4882,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";
@@ -5066,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)) {
@@ -5182,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)
@@ -5198,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;
@@ -5303,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,
@@ -5314,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({
@@ -5329,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({
@@ -5349,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;
     }
@@ -5527,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,
@@ -5589,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 });
@@ -5602,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;

package/dist/plugin/plugin-interface.d.ts

@@ -14,4 +14,5 @@ export declare function createPluginInterface(args: {
     client?: PluginContext["client"];
     directory?: string;
     tracker?: SessionTracker;
+    taskSystemEnabled?: boolean;
 }): PluginInterface;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencode_weave/weave",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "description": "Weave — lean OpenCode plugin with multi-agent orchestration",
   "author": "Weave",
   "license": "MIT",