@ai-setting/roy-task-plugin 0.7.1 → 0.7.3

package/dist/cli.js

@@ -3,12 +3,13 @@ import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // ../../../packages/cli/src/daemon/runners/types.ts
-var RUNTIMES = Object.freeze(["opencode", "claude", "codex"]);
+var RUNTIMES = Object.freeze(["opencode", "claude", "codex", "cursor"]);
 var DEFAULT_RUNTIME = "opencode";
 var DEFAULT_RUNTIME_BIN = Object.freeze({
   opencode: "opencode",
   claude: "claude",
-  codex: "codex"
+  codex: "codex",
+  cursor: "cursor-agent"
 });
 function isRuntimeName(value) {
   return RUNTIMES.includes(value);
@@ -137,6 +138,10 @@ function isMissingBinary(err) {
   return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
 }
 
+// ../../../packages/cli/src/daemon/runners/codex.ts
+import { dirname as dirname2, join as join2 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
 // ../../../packages/cli/src/daemon/task-created.ts
 var CREATED_LINE = /Task created(?:\s+successfully)?\s*:\s*#(\d+)/;
 function extractCreatedTask(text, titleHint) {
@@ -327,7 +332,7 @@ function titleFromCliSummary(text) {
   return title;
 }
 function isTaskCreateTool(name) {
-  return /(^|__)task_create$/.test(name);
+  return /(^|[-_])task_create$/.test(name);
 }
 
 // ../../../packages/cli/src/daemon/ndjson.ts
@@ -363,6 +368,9 @@ class NdjsonAssembler {
   sessionId;
   tools = [];
   createdTask;
+  get createdTaskSoFar() {
+    return this.createdTask;
+  }
   pushChunk(chunk) {
     this.tail += chunk;
     let idx = this.tail.indexOf(`
@@ -440,12 +448,14 @@ class NdjsonAssembler {
 var CODEX_ITEM_TYPES = Object.freeze({
   AGENT_MESSAGE: "agent_message",
   COMMAND_EXECUTION: "command_execution",
+  MCP_TOOL_CALL: "mcp_tool_call",
   ERROR: "error"
 });
 
 class CodexStreamDecoder {
   lines = new LineSplitter;
   state = { tools: [], errors: [], turnCompleted: false };
+  mcpSeen = new Set;
   pushChunk(chunk) {
     for (const line of this.lines.pushChunk(chunk))
       this.consume(line);
@@ -495,50 +505,550 @@ class CodexStreamDecoder {
       }
       return;
     }
-    if (item.type === CODEX_ITEM_TYPES.ERROR) {
-      if (typeof item.message === "string" && item.message.length > 0) {
-        this.state.errors.push(item.message);
+    if (item.type === CODEX_ITEM_TYPES.ERROR) {
+      if (typeof item.message === "string" && item.message.length > 0) {
+        this.state.errors.push(item.message);
+      }
+      return;
+    }
+    if (item.type === CODEX_ITEM_TYPES.COMMAND_EXECUTION) {
+      const id = item.id;
+      if (typeof id === "string" && id && this.state.tools.includes(id)) {} else {
+        this.state.tools.push(typeof id === "string" ? id : `cmd-${this.state.tools.length}`);
+      }
+      if (completed && this.state.createdTask === undefined) {
+        this.state.createdTask = extractCreatedTask(item.aggregated_output);
+      }
+      return;
+    }
+    if (item.type === CODEX_ITEM_TYPES.MCP_TOOL_CALL) {
+      const id = item.id;
+      if (typeof id === "string" && id) {
+        if (this.mcpSeen.has(id))
+          return;
+        this.mcpSeen.add(id);
+      }
+      const name = typeof item.tool === "string" && item.tool ? item.tool : undefined;
+      this.state.tools.push(name ?? (typeof id === "string" && id ? id : `mcp-${this.state.tools.length}`));
+      return;
+    }
+  }
+  toResult() {
+    const result = {
+      text: this.state.text ?? ""
+    };
+    if (this.state.sessionId)
+      result.sessionId = this.state.sessionId;
+    if (this.state.tools.length > 0) {
+      result.toolCalls = this.state.tools.length;
+      result.tools = [...this.state.tools];
+    }
+    if (this.state.createdTask)
+      result.createdTask = this.state.createdTask;
+    return result;
+  }
+}
+
+// ../../../packages/cli/src/daemon/runners/codex-sessions.ts
+function createCodexSessionRegistry() {
+  const sessions = new Map;
+  return {
+    get: (key) => sessions.get(key),
+    set: (key, id) => {
+      sessions.set(key, id);
+    },
+    delete: (key) => {
+      sessions.delete(key);
+    },
+    size: () => sessions.size
+  };
+}
+
+// ../../../packages/cli/src/daemon/runners/claude-agents.ts
+var CLAUDE_ROY_AGENT_NAME = "roy";
+var ROY_AGENT_DESCRIPTION = "Roy — task-as-first-class-citizen agent. Uses the roy-agent task lifecycle " + "(task_tree → task_create → task_update → task_operation_create → task_complete) " + "so every piece of work is tracked in the local task store.";
+var ROY_TASK_MCP_SERVER = "roy-task";
+var ROY_TASK_MCP_TOOLS = Object.freeze([
+  "task_create",
+  "task_update",
+  "task_operation_create",
+  "task_complete",
+  "task_get",
+  "task_list",
+  "task_tree",
+  "task_search"
+].map((t) => `mcp__${ROY_TASK_MCP_SERVER}__${t}`));
+var CLAUDE_ROY_TOOLS = Object.freeze([
+  "Read",
+  "Write",
+  "Edit",
+  "Bash",
+  "Grep",
+  "Glob",
+  "TodoWrite",
+  "WebFetch",
+  "WebSearch",
+  ...ROY_TASK_MCP_TOOLS
+]);
+var CLAUDE_ROY_SYSTEM_PROMPT = `# Roy — task-first-class-citizen agent
+
+You are **Roy**, an agent whose defining rule is simple:
+
+> **Task is a first-class citizen. No task, no work.**
+
+You are not a chat assistant that occasionally writes notes. You are a worker
+whose output is a *visible, trackable* stream of tasks. Every non-trivial
+request (more than one tool call / more than a couple of minutes of work) MUST
+become a tracked task before you start doing it, and MUST be closed out
+explicitly when you finish.
+
+## The lifecycle (non-negotiable)
+
+### 1. Orient — \`task_tree(depth=1)\` (or \`depth=2\` for bigger trees)
+Before creating anything, look at the existing tree. Decide:
+- does this work belong to an existing root (attach via \`parent_task_id\`)?
+- or is it genuinely new?
+
+Keep **root tasks ≤ 10**. Prefer attaching to an existing thematic root over
+spawning a new root. Never hardcode ids — read them from \`task_tree\`.
+
+### 2. Create — \`task_create\`
+Create the task **before** doing the work. Pass:
+- \`title\` (imperative, specific), \`description\`, \`goals_and_expected_deliverables\`
+- \`priority\` (low / medium / high), \`type\` (normal / cycle / longterm)
+- \`project_path\`, \`context\` (JSON string: worktree_path / branch / type …)
+- \`parent_task_id\` when the tree said so
+
+The tool returns a **numeric task id** — that number is your handle for the
+rest of the conversation.
+
+### 3. Track — \`task_update\`
+Report progress as you go, not only at the end:
+- \`status\`: todo → active → (paused / cancelled) → completed
+- \`progress\`: 0–100
+- \`current_status\`: one human sentence about where you are right now
+
+If the scope changes, \`task_update\` the description/goals instead of silently
+doing something else.
+
+### 4. Record milestones — \`task_operation_create\`
+This tool has **two orthogonal dimensions** and you must keep them distinct:
+- **state / milestone dimension** — \`milestone_type\` + \`milestone_title\` +
+  \`milestone_description\`: *what* was reached (e.g. "GREEN: all tests pass").
+- **process dimension** — \`process_description\`: *how* you got there —
+  strategy + tool steps, strictly **100–150 characters**.
+  Too short = rejected (no value); too long = rejected (use the session log).
+
+Rules: do **not** use the process field to restate the milestone, and do not
+use milestones as a substitute for progress. Milestones mark *state
+transitions*: RED→GREEN, blocker found, decision made, review passed.
+
+### 5. Close — \`task_complete\`
+Before completing:
+1. \`task_get(task_id)\` and re-read goal + delivery.
+2. Verify the goal and delivery actually match what you delivered. If they do
+   not, either extend the task (\`task_update\`) or say so honestly.
+3. Call \`task_complete\` with \`deliverable_storage_path\` — a locator for the
+   work product: a file path, a git branch/worktree, a doc URL, a commit URL.
+   The path is persisted into the task context and as an operation record.
+
+\`task_complete\` cannot be used on \`cycle\` tasks (they are periodic by
+design) — use \`task_update\` to reset those.
+
+## Other tools
+
+- \`task_get(task_id, include_operations)\` — full detail; use it before
+  resuming or completing a task.
+- \`task_list(...)\` — flat listing with filters (status / priority / type).
+- \`task_search(keywords)\` — find by title / description / goals / tags.
+  **Search before creating**, to avoid duplicates.
+
+## Where tasks live
+
+All tasks and operations are persisted by the roy-task-plugin in the
+**single** project store — locally that is SQLite at
+\`~/.roy-task-plugin/tasks.db\` (or the remote service when the plugin is
+configured with \`persistence: "remote"\`). Do not create side databases, do
+not maintain your own to-do list in files, and do not track work in chat only:
+if it is not in the task store, it is not tracked.
+
+## Tool surface on Claude Code
+
+The \`task_*\` tools are served by the **\`roy-task\` MCP server** this runtime
+loads. Call them directly:
+
+| lifecycle step | tool |
+|---|---|
+| \`task_tree(depth=1)\` | \`mcp__roy-task__task_tree\` |
+| \`task_create\` | \`mcp__roy-task__task_create\` |
+| \`task_update\` | \`mcp__roy-task__task_update\` |
+| \`task_operation_create\` | \`mcp__roy-task__task_operation_create\` |
+| \`task_complete\` | \`mcp__roy-task__task_complete\` |
+| \`task_get\` | \`mcp__roy-task__task_get\` |
+| \`task_list\` | \`mcp__roy-task__task_list\` |
+| \`task_search\` | \`mcp__roy-task__task_search\` |
+
+Same store, same ids, same semantics as the opencode tools — the daemon's
+progress card renders the task these tools create.
+
+⚠️ **Do not** shell out to the \`roy-agent tasks\` CLI as a substitute.
+Measured: it has no way to write a milestone (its \`operations <id>\` subcommand
+is a *reader*), and it targets a different database than this server. Use the
+MCP tools above; if they are genuinely unavailable, say so in your answer
+instead of silently skipping the lifecycle.
+
+## Style
+
+- Be direct and concrete; the user is reading task titles and milestones.
+- Report the task id and its state whenever you finish a step.
+- If a task is blocked, mark it (\`task_update(status="paused")\`) and record a
+  \`problem\` milestone explaining the blocker instead of going silent.`;
+function buildClaudeAgentsJson(opts = {}) {
+  const def = {
+    description: opts.description ?? ROY_AGENT_DESCRIPTION,
+    prompt: opts.prompt ?? CLAUDE_ROY_SYSTEM_PROMPT,
+    tools: [...opts.tools ?? CLAUDE_ROY_TOOLS]
+  };
+  if (opts.model)
+    def.model = opts.model;
+  return JSON.stringify({ [opts.name ?? CLAUDE_ROY_AGENT_NAME]: def });
+}
+
+// ../../../packages/cli/src/daemon/runners/claude.ts
+import { createHash } from "node:crypto";
+import { appendFileSync, existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// ../../../packages/cli/src/daemon/runners/claude-sessions.ts
+function createClaudeSessionRegistry() {
+  const sessions = new Map;
+  return {
+    get: (key) => sessions.get(key),
+    set: (key, id) => {
+      sessions.set(key, id);
+    },
+    delete: (key) => {
+      sessions.delete(key);
+    },
+    size: () => sessions.size
+  };
+}
+
+// ../../../packages/cli/src/daemon/runners/claude-stream.ts
+function errorDetail(result) {
+  if (typeof result.result === "string" && result.result.trim() !== "") {
+    return result.result.trim();
+  }
+  if (Array.isArray(result.errors)) {
+    const parts = result.errors.map((e) => typeof e === "string" ? e.trim() : "").filter((e) => e !== "");
+    if (parts.length > 0)
+      return parts.join("; ");
+  }
+  return result.subtype === undefined ? "claude reported is_error" : `claude reported ${result.subtype}`;
+}
+function flattenToolResult(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  const parts = [];
+  for (const block of content) {
+    if (typeof block === "string") {
+      parts.push(block);
+      continue;
+    }
+    if (typeof block === "object" && block !== null) {
+      const t = block.text;
+      if (typeof t === "string")
+        parts.push(t);
+    }
+  }
+  return parts.join(`
+`);
+}
+
+class ClaudeStreamDecoder {
+  lines = new LineSplitter;
+  state = {
+    assistantText: [],
+    tools: [],
+    pendingCreates: new Map
+  };
+  pushChunk(chunk) {
+    for (const line of this.lines.pushChunk(chunk))
+      this.consume(line);
+  }
+  finish() {
+    for (const line of this.lines.finish())
+      this.consume(line);
+    return this.toResult();
+  }
+  snapshot() {
+    return { ...this.state, assistantText: [...this.state.assistantText], tools: [...this.state.tools] };
+  }
+  consume(rawLine) {
+    const line = rawLine.trim();
+    if (!line.startsWith("{"))
+      return;
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (typeof event !== "object" || event === null)
+      return;
+    const ev = event;
+    const sessionId = typeof ev.session_id === "string" ? ev.session_id : undefined;
+    if (sessionId && !this.state.sessionId)
+      this.state.sessionId = sessionId;
+    if (ev.type === "assistant") {
+      this.consumeAssistant(ev);
+      return;
+    }
+    if (ev.type === "user") {
+      this.consumeUser(ev);
+      return;
+    }
+    if (ev.type === "result") {
+      this.state.result = ev;
+    }
+  }
+  consumeUser(ev) {
+    const message = ev.message;
+    const content = message?.content;
+    if (!Array.isArray(content))
+      return;
+    for (const block of content) {
+      if (typeof block !== "object" || block === null)
+        continue;
+      const b = block;
+      if (b.type !== "tool_result")
+        continue;
+      const id = typeof b.tool_use_id === "string" ? b.tool_use_id : undefined;
+      const pending = id ? this.state.pendingCreates.get(id) : undefined;
+      const text = flattenToolResult(b.content);
+      if (this.state.createdTask !== undefined)
+        continue;
+      if (pending) {
+        this.state.pendingCreates.delete(id);
+        this.state.createdTask = extractCreatedTask(text, pending.titleHint);
+        continue;
+      }
+      this.state.createdTask = extractCreatedTask(text);
+    }
+  }
+  consumeAssistant(ev) {
+    const message = ev.message;
+    const content = message?.content;
+    if (!Array.isArray(content))
+      return;
+    for (const block of content) {
+      if (typeof block !== "object" || block === null)
+        continue;
+      const b = block;
+      if (b.type === "text" && typeof b.text === "string") {
+        this.state.assistantText.push(b.text);
+      } else if (b.type === "tool_use") {
+        if (typeof b.name === "string") {
+          this.state.tools.push(b.name);
+          if (isTaskCreateTool(b.name) && typeof b.id === "string") {
+            const input = b.input;
+            const title = input?.["title"];
+            this.state.pendingCreates.set(b.id, {
+              tool: b.name,
+              titleHint: typeof title === "string" ? title : undefined
+            });
+          }
+        }
+      }
+    }
+  }
+  toResult() {
+    const { result } = this.state;
+    const toolCalls = this.state.tools.length > 0 ? this.state.tools.length : undefined;
+    const tools = this.state.tools.length > 0 ? [...this.state.tools] : undefined;
+    const createdTask = this.state.createdTask;
+    if (result?.is_error) {
+      const detail = errorDetail(result);
+      return {
+        text: "",
+        sessionId: this.state.sessionId,
+        toolCalls,
+        tools,
+        createdTask,
+        error: detail.slice(0, 1000)
+      };
+    }
+    if (typeof result?.result === "string" && result.result.trim() !== "") {
+      return { text: result.result.trim(), sessionId: this.state.sessionId, toolCalls, tools, createdTask };
+    }
+    const fallback = this.state.assistantText.join("").trim();
+    return { text: fallback, sessionId: this.state.sessionId, toolCalls, tools, createdTask };
+  }
+}
+
+// ../../../packages/cli/src/daemon/runners/claude.ts
+var DEFAULT_CLAUDE_TIMEOUT_MS = 10 * 60 * 1000;
+var CLAUDE_STDIO = Object.freeze([
+  "ignore",
+  "pipe",
+  "pipe"
+]);
+function buildClaudeArgs(input) {
+  const args = ["--print", "--output-format", "stream-json", "--verbose"];
+  if (input.agentsJson)
+    args.push("--agents", input.agentsJson);
+  if (input.pluginDir)
+    args.push("--plugin-dir", input.pluginDir);
+  if (input.mcpConfig)
+    args.push(`--mcp-config=${input.mcpConfig}`);
+  args.push("--agent", input.agent ?? "roy");
+  args.push("--dangerously-skip-permissions");
+  if (input.sessionId)
+    args.push("--resume", claudeSessionUuid(input.sessionId));
+  args.push(input.prompt);
+  return args;
+}
+function resolveClaudePluginDir(roots, explicit) {
+  if (explicit)
+    return explicit;
+  for (const root of roots) {
+    const candidate = join(root, "claude-plugin");
+    if (existsSync(join(candidate, ".mcp.json")))
+      return candidate;
+  }
+  return;
+}
+function buildRoyTaskMcpConfig(pluginDir) {
+  return JSON.stringify({
+    mcpServers: {
+      "roy-task": {
+        command: process.execPath,
+        args: [join(pluginDir, "mcp", "roy-task-mcp-server.mjs")]
+      }
+    }
+  });
+}
+function isClaudeSessionUuid(value) {
+  if (!value)
+    return false;
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
+}
+function claudeSessionUuid(sessionKey) {
+  if (isClaudeSessionUuid(sessionKey))
+    return sessionKey;
+  const digest = createHash("sha256").update(sessionKey).digest("hex");
+  const h = digest.slice(0, 32);
+  return [
+    h.slice(0, 8),
+    h.slice(8, 12),
+    `4${h.slice(13, 16)}`,
+    `8${h.slice(17, 20)}`,
+    h.slice(20, 32)
+  ].join("-");
+}
+function makeClaudeRunner(opts = {}) {
+  const bin = opts.bin ?? "claude";
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_CLAUDE_TIMEOUT_MS;
+  const agentsJson = opts.agentsJson ?? buildClaudeAgentsJson();
+  const sessions = opts.sessions ?? createClaudeSessionRegistry();
+  const pluginDir = opts.pluginDir ?? resolveClaudePluginDir([dirname(fileURLToPath(import.meta.url))]);
+  const mcpConfig = pluginDir ? buildRoyTaskMcpConfig(pluginDir) : undefined;
+  return async function runAgent(input) {
+    const known = input.sessionId ? sessions.get(input.sessionId) : undefined;
+    const args = buildClaudeArgs({
+      prompt: input.prompt,
+      agent: input.agent,
+      agentsJson,
+      ...pluginDir ? { pluginDir } : {},
+      ...mcpConfig ? { mcpConfig } : {},
+      sessionId: known
+    });
+    const decoder = new ClaudeStreamDecoder;
+    let stderr = "";
+    let reported = false;
+    const notifyProgress = () => {
+      if (reported || !input.onProgress)
+        return;
+      const created = decoder.snapshot().createdTask;
+      if (!created)
+        return;
+      reported = true;
+      try {
+        input.onProgress({ createdTask: created });
+      } catch {}
+    };
+    let handle;
+    try {
+      handle = spawnStreaming([bin, ...args], {
+        stdin: CLAUDE_STDIO[0],
+        env: { ...process.env, NO_COLOR: "1" },
+        timeoutMs,
+        onStdout: (chunk) => {
+          decoder.pushChunk(chunk);
+          notifyProgress();
+          if (process.env["ROY_TASK_DUMP_STREAM"]) {
+            try {
+              appendFileSync(process.env["ROY_TASK_DUMP_STREAM"], chunk);
+            } catch {}
+          }
+        },
+        onStderr: (chunk) => {
+          if (stderr.length < 64 * 1024)
+            stderr += chunk;
+        }
+      });
+    } catch (err) {
+      return { text: "", error: `failed to spawn ${bin}: ${errMsg(err)}` };
+    }
+    let code;
+    try {
+      code = await handle.exited;
+    } catch (err) {
+      if (isMissingBinary(err)) {
+        return { text: "", error: `failed to spawn ${bin}: ${errMsg(err)}` };
       }
-      return;
+      return { text: "", error: errMsg(err) };
     }
-    if (item.type === CODEX_ITEM_TYPES.COMMAND_EXECUTION) {
-      const id = item.id;
-      if (typeof id === "string" && id && this.state.tools.includes(id)) {} else {
-        this.state.tools.push(typeof id === "string" ? id : `cmd-${this.state.tools.length}`);
+    const result = decoder.finish();
+    const stderrText = stderr.trim();
+    const combined = result.error ? stderrText && !result.error.includes(stderrText) ? `${result.error} | ${stderrText}` : result.error : undefined;
+    const effective = combined ? { ...result, error: combined.slice(0, 1000) } : result;
+    if (input.sessionId && effective.sessionId) {
+      sessions.set(input.sessionId, effective.sessionId);
+    }
+    if (code === 124) {
+      return { ...effective, error: `claude timed out after ${timeoutMs}ms` };
+    }
+    if (effective.error) {
+      if (input.sessionId && STALE_SESSION_RE.test(effective.error)) {
+        sessions.delete(input.sessionId);
       }
-      if (completed && this.state.createdTask === undefined) {
-        this.state.createdTask = extractCreatedTask(item.aggregated_output);
+      return effective;
+    }
+    if (code !== 0 && !effective.text) {
+      const error = `claude exited ${code}: ${(stderr || "no stderr").trim().slice(0, 1000)}`;
+      if (input.sessionId && STALE_SESSION_RE.test(error)) {
+        sessions.delete(input.sessionId);
       }
+      return {
+        text: "",
+        toolCalls: effective.toolCalls,
+        tools: effective.tools,
+        error
+      };
     }
-  }
-  toResult() {
-    const result = {
-      text: this.state.text ?? ""
-    };
-    if (this.state.sessionId)
-      result.sessionId = this.state.sessionId;
-    if (this.state.tools.length > 0)
-      result.toolCalls = this.state.tools.length;
-    if (this.state.createdTask)
-      result.createdTask = this.state.createdTask;
-    return result;
-  }
-}
-
-// ../../../packages/cli/src/daemon/runners/codex-sessions.ts
-function createCodexSessionRegistry() {
-  const sessions = new Map;
-  return {
-    get: (key) => sessions.get(key),
-    set: (key, id) => {
-      sessions.set(key, id);
-    },
-    delete: (key) => {
-      sessions.delete(key);
-    },
-    size: () => sessions.size
+    return effective;
   };
 }
+var STALE_SESSION_RE = /No conversation found|not a UUID|session title/i;
+function errMsg(err) {
+  if (err instanceof Error)
+    return err.message;
+  return String(err);
+}
 
 // ../../../packages/cli/src/daemon/runners/codex.ts
 var DEFAULT_CODEX_TIMEOUT_MS = 10 * 60 * 1000;
@@ -555,12 +1065,44 @@ var CODEX_SANDBOX_MODES = Object.freeze([
 function isCodexSandboxMode(value) {
   return CODEX_SANDBOX_MODES.includes(value);
 }
+function buildRoyTaskCodexConfigArgs(pluginDir) {
+  const args = [
+    `-cmcp_servers.${ROY_TASK_MCP_SERVER}.command=${JSON.stringify(process.execPath)}`,
+    `-cmcp_servers.${ROY_TASK_MCP_SERVER}.args=${JSON.stringify([
+      join2(pluginDir, "mcp", "roy-task-mcp-server.mjs")
+    ])}`,
+    `-cmcp_servers.${ROY_TASK_MCP_SERVER}.default_tools_approval_mode="approve"`
+  ];
+  const envArg = buildMcpServerEnvArg();
+  if (envArg)
+    args.push(envArg);
+  return args;
+}
+function buildMcpServerEnvArg() {
+  const keys = [
+    "ROY_TASK_NOTIFY_ENABLED",
+    "ROY_TASK_NOTIFY_CHAT_ID",
+    "ROY_TASK_NOTIFY_PROFILE"
+  ];
+  const pairs = [];
+  for (const key of keys) {
+    const value = process.env[key];
+    if (!value)
+      continue;
+    const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+    pairs.push(`${key}="${escaped}"`);
+  }
+  if (pairs.length === 0)
+    return;
+  return `-cmcp_servers.${ROY_TASK_MCP_SERVER}.env={${pairs.join(",")}}`;
+}
 function buildCodexArgs(input) {
   const args = ["exec", "--json"];
   if (input.model)
     args.push("--model", input.model);
   args.push("--skip-git-repo-check");
   args.push("-s", input.sandbox ?? "read-only");
+  args.push(...input.mcpConfigArgs ?? []);
   args.push(input.prompt);
   return args;
 }
@@ -572,6 +1114,7 @@ function buildCodexResumeArgs(sessionId, input) {
   if (input.sandbox === "danger-full-access") {
     args.push("--dangerously-bypass-approvals-and-sandbox");
   }
+  args.push(...input.mcpConfigArgs ?? []);
   args.push(sessionId);
   args.push(input.prompt);
   return args;
@@ -582,10 +1125,13 @@ function makeCodexRunner(opts = {}) {
   const model = opts.model;
   const sandbox = opts.sandbox ?? "read-only";
   const sessions = opts.sessions ?? createCodexSessionRegistry();
+  const pluginDir = opts.pluginDir ?? resolveClaudePluginDir([dirname2(fileURLToPath2(import.meta.url))]);
+  const mcpConfigArgs = pluginDir ? buildRoyTaskCodexConfigArgs(pluginDir) : undefined;
   return async function runAgent(input) {
     const known = input.sessionId ? sessions.get(input.sessionId) : undefined;
-    const args = known ? buildCodexResumeArgs(known, { prompt: input.prompt, model, sandbox }) : buildCodexArgs({ prompt: input.prompt, model, sandbox });
+    const args = known ? buildCodexResumeArgs(known, { prompt: input.prompt, model, sandbox, mcpConfigArgs }) : buildCodexArgs({ prompt: input.prompt, model, sandbox, mcpConfigArgs });
     const decoder = new CodexStreamDecoder;
+    let reported = false;
     let stderr = "";
     let handle;
     try {
@@ -593,23 +1139,34 @@ function makeCodexRunner(opts = {}) {
         stdin: CODEX_STDIO[0],
         env: { ...process.env, NO_COLOR: "1" },
         timeoutMs,
-        onStdout: (chunk) => decoder.pushChunk(chunk),
+        onStdout: (chunk) => {
+          decoder.pushChunk(chunk);
+          if (!reported && input.onProgress) {
+            const created = decoder.snapshot().createdTask;
+            if (created) {
+              reported = true;
+              try {
+                input.onProgress({ createdTask: created });
+              } catch {}
+            }
+          }
+        },
         onStderr: (chunk) => {
           if (stderr.length < 64 * 1024)
             stderr += chunk;
         }
       });
     } catch (err) {
-      return { text: "", error: `failed to spawn ${bin}: ${errMsg(err)}` };
+      return { text: "", error: `failed to spawn ${bin}: ${errMsg2(err)}` };
     }
     let code;
     try {
       code = await handle.exited;
     } catch (err) {
       if (isMissingBinary(err)) {
-        return { text: "", error: `failed to spawn ${bin}: ${errMsg(err)}` };
+        return { text: "", error: `failed to spawn ${bin}: ${errMsg2(err)}` };
       }
-      return { text: "", error: errMsg(err) };
+      return { text: "", error: errMsg2(err) };
     }
     const result = decoder.finish();
     if (input.sessionId && result.sessionId && !result.error) {
@@ -632,7 +1189,7 @@ function makeCodexRunner(opts = {}) {
     return result;
   };
 }
-function errMsg(err) {
+function errMsg2(err) {
   if (err instanceof Error)
     return err.message;
   return String(err);
@@ -665,6 +1222,7 @@ var VALUE_FLAGS = new Set([
   "--opencode-bin",
   "--codex-model",
   "--codex-sandbox",
+  "--cursor-model",
   "--max-concurrency",
   "--timeout-ms"
 ]);
@@ -785,6 +1343,13 @@ function parseServe(argv) {
         serve.codexModel = v;
         break;
       }
+      case "--cursor-model": {
+        const v = take();
+        if (v instanceof Error)
+          return { command: "unknown", error: v.message };
+        serve.cursorModel = v;
+        break;
+      }
       case "--codex-sandbox": {
         const v = take();
         if (v instanceof Error)
@@ -877,7 +1442,7 @@ function resolveRuntimeBin(options) {
   return;
 }
 function usage() {
-  return `roy-task — bridge Feishu (Lark) messages to a roy agent (opencode, claude or codex)
+  return `roy-task — bridge Feishu (Lark) messages to a roy agent (opencode, claude, codex or cursor)
 
 USAGE
   roy-task [serve] [options]      start the daemon (default command)
@@ -903,6 +1468,7 @@ SERVE OPTIONS
   --opencode-bin <path>   DEPRECATED alias for --command
                           (only applies when --runtime opencode)
   --codex-model <name>    model for codex exec --model            (default: codex config)
+  --cursor-model <name>   model for cursor-agent --model         (default: cursor default)
   --codex-sandbox <mode>  codex exec -s policy                   (default: read-only)
                           one of: ${CODEX_SANDBOX_MODES.join(" | ")}
   --max-concurrency <n>   max simultaneous agent runs             (default: 1)
@@ -1042,13 +1608,13 @@ class Deduper {
 }
 
 // ../../../packages/cli/src/daemon/session-map.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 var DIGEST_LEN = 16;
 function deriveSessionId(input) {
   const profile = input.profile ?? "";
   const chatId = input.chatId ?? "";
   const material = `${profile}\x00${chatId}`;
-  const digest = createHash("sha256").update(material).digest("hex");
+  const digest = createHash2("sha256").update(material).digest("hex");
   return `ses_${digest.slice(0, DIGEST_LEN)}`;
 }
 
@@ -1238,6 +1804,7 @@ var TOOL_LABELS = {
   write: "写入文件",
   edit: "修改文件",
   bash: "执行命令",
+  runTerminal: "执行命令",
   glob: "搜索文件",
   grep: "搜索内容",
   task: "调用子任务",
@@ -1250,11 +1817,23 @@ var TOOL_LABELS = {
 };
 function describeToolUse(tool) {
   return {
-    title: TOOL_LABELS[tool] ?? tool,
+    title: TOOL_LABELS[normaliseMcpToolName(tool)] ?? tool,
     timestamp: new Date().toISOString(),
     category: tool
   };
 }
+function normaliseMcpToolName(tool) {
+  const mcp = /^mcp__[^_]+(?:_[^_]+)*__(.+)$/.exec(tool);
+  if (mcp)
+    return mcp[1];
+  const dash = /^([a-z0-9]+(?:-[a-z0-9]+)*)-([a-z0-9]+_[a-z0-9_]*)$/.exec(tool);
+  if (dash)
+    return dash[2];
+  const tag = /^([a-z][A-Za-z0-9]*)ToolCall$/.exec(tool);
+  if (tag)
+    return tag[1];
+  return tool;
+}
 
 // ../../../packages/cli/src/daemon/dispatcher.ts
 function cardReport(handle) {
@@ -1366,18 +1945,31 @@ class Dispatcher {
       return { status: "dry-run", plan };
     }
     const run = async () => {
-      const result = await this.deps.runAgent({
+      let earlyCard;
+      const onProgress = (progress) => {
+        if (earlyCard || !progress.createdTask)
+          return;
+        earlyCard = this.trace("dispatch.openCard", () => this.openCard({
+          chatId,
+          messageId,
+          profile,
+          createdTask: progress.createdTask,
+          requestText: extractUserText(raw)
+        }));
+      };
+      const result = await this.traceResult("dispatch.runAgent", async () => this.deps.runAgent({
         prompt: plan.prompt,
         agent: plan.agent,
-        sessionId: plan.sessionId
-      });
-      const card = await this.openCard({
+        sessionId: plan.sessionId,
+        onProgress
+      }), (r) => r.error);
+      const card = earlyCard ? await earlyCard : await this.trace("dispatch.openCard", () => this.openCard({
         chatId,
         messageId,
         profile,
         createdTask: result.createdTask,
         requestText: extractUserText(raw)
-      });
+      }));
       if (card.messageId) {
         await this.patchCard(card, {
           chatId,
@@ -1469,7 +2061,8 @@ class Dispatcher {
         ...cardReport(card)
       };
     };
-    return this.deps.gate ? this.deps.gate.run(plan.sessionId, run) : run();
+    const traced = () => this.trace("dispatch.handle", run);
+    return this.deps.gate ? this.deps.gate.run(plan.sessionId, traced) : traced();
   }
   async openCard(input) {
     const handle = { messageId: "" };
@@ -1556,6 +2149,18 @@ class Dispatcher {
       profile: input.profile
     };
   }
+  async trace(name, fn) {
+    const tracer = this.deps.tracer;
+    if (!tracer || !tracer.enabled)
+      return fn();
+    return tracer.span(name, fn);
+  }
+  async traceResult(name, fn, errorIf) {
+    const tracer = this.deps.tracer;
+    if (!tracer || !tracer.enabled)
+      return fn();
+    return tracer.spanResult(name, fn, errorIf);
+  }
 }
 
 // ../../../packages/cli/src/daemon/es-listener.ts
@@ -1600,192 +2205,134 @@ function createEventListener(config) {
   };
 }
 
-// ../../../packages/cli/src/daemon/runners/claude.ts
-import { createHash as createHash2 } from "node:crypto";
-import { appendFileSync } from "node:fs";
-
-// ../../../packages/cli/src/daemon/runners/claude-agents.ts
-var CLAUDE_ROY_AGENT_NAME = "roy";
-var ROY_AGENT_DESCRIPTION = "Roy — task-as-first-class-citizen agent. Uses the roy-agent task lifecycle " + "(task_tree → task_create → task_update → task_operation_create → task_complete) " + "so every piece of work is tracked in the local task store.";
-var CLAUDE_ROY_TOOLS = Object.freeze([
-  "Read",
-  "Write",
-  "Edit",
-  "Bash",
-  "Grep",
-  "Glob",
-  "TodoWrite",
-  "WebFetch",
-  "WebSearch"
-]);
-var CLAUDE_ROY_SYSTEM_PROMPT = `# Roy — task-first-class-citizen agent
-
-You are **Roy**, an agent whose defining rule is simple:
-
-> **Task is a first-class citizen. No task, no work.**
-
-You are not a chat assistant that occasionally writes notes. You are a worker
-whose output is a *visible, trackable* stream of tasks. Every non-trivial
-request (more than one tool call / more than a couple of minutes of work) MUST
-become a tracked task before you start doing it, and MUST be closed out
-explicitly when you finish.
-
-## The lifecycle (non-negotiable)
-
-### 1. Orient — \`task_tree(depth=1)\` (or \`depth=2\` for bigger trees)
-Before creating anything, look at the existing tree. Decide:
-- does this work belong to an existing root (attach via \`parent_task_id\`)?
-- or is it genuinely new?
-
-Keep **root tasks ≤ 10**. Prefer attaching to an existing thematic root over
-spawning a new root. Never hardcode ids — read them from \`task_tree\`.
-
-### 2. Create — \`task_create\`
-Create the task **before** doing the work. Pass:
-- \`title\` (imperative, specific), \`description\`, \`goals_and_expected_deliverables\`
-- \`priority\` (low / medium / high), \`type\` (normal / cycle / longterm)
-- \`project_path\`, \`context\` (JSON string: worktree_path / branch / type …)
-- \`parent_task_id\` when the tree said so
-
-The tool returns a **numeric task id** — that number is your handle for the
-rest of the conversation.
-
-### 3. Track — \`task_update\`
-Report progress as you go, not only at the end:
-- \`status\`: todo → active → (paused / cancelled) → completed
-- \`progress\`: 0–100
-- \`current_status\`: one human sentence about where you are right now
-
-If the scope changes, \`task_update\` the description/goals instead of silently
-doing something else.
-
-### 4. Record milestones — \`task_operation_create\`
-This tool has **two orthogonal dimensions** and you must keep them distinct:
-- **state / milestone dimension** — \`milestone_type\` + \`milestone_title\` +
-  \`milestone_description\`: *what* was reached (e.g. "GREEN: all tests pass").
-- **process dimension** — \`process_description\`: *how* you got there —
-  strategy + tool steps, strictly **100–150 characters**.
-  Too short = rejected (no value); too long = rejected (use the session log).
-
-Rules: do **not** use the process field to restate the milestone, and do not
-use milestones as a substitute for progress. Milestones mark *state
-transitions*: RED→GREEN, blocker found, decision made, review passed.
-
-### 5. Close — \`task_complete\`
-Before completing:
-1. \`task_get(task_id)\` and re-read goal + delivery.
-2. Verify the goal and delivery actually match what you delivered. If they do
-   not, either extend the task (\`task_update\`) or say so honestly.
-3. Call \`task_complete\` with \`deliverable_storage_path\` — a locator for the
-   work product: a file path, a git branch/worktree, a doc URL, a commit URL.
-   The path is persisted into the task context and as an operation record.
-
-\`task_complete\` cannot be used on \`cycle\` tasks (they are periodic by
-design) — use \`task_update\` to reset those.
-
-## Other tools
-
-- \`task_get(task_id, include_operations)\` — full detail; use it before
-  resuming or completing a task.
-- \`task_list(...)\` — flat listing with filters (status / priority / type).
-- \`task_search(keywords)\` — find by title / description / goals / tags.
-  **Search before creating**, to avoid duplicates.
-
-## Where tasks live
-
-All tasks and operations are persisted by the roy-task-plugin in the
-**single** project store — locally that is SQLite at
-\`~/.roy-task-plugin/tasks.db\` (or the remote service when the plugin is
-configured with \`persistence: "remote"\`). Do not create side databases, do
-not maintain your own to-do list in files, and do not track work in chat only:
-if it is not in the task store, it is not tracked.
-
-## Tool surface on Claude Code
-
-The lifecycle above is expressed through the \`roy-agent tasks\` CLI (run it with
-the \`Bash\` tool), because Claude Code does not yet expose the \`task_*\` tools
-natively. The mapping is 1:1 — same store, same ids, same semantics:
-
-| lifecycle step | Claude Code command |
-|---|---|
-| \`task_tree(depth=1)\` | \`roy-agent tasks tree\` |
-| \`task_create\` | \`roy-agent tasks create "<title>" -d "<description>" -g "<goals>" -p high --project-path "<path>"\` |
-| \`task_update\` | \`roy-agent tasks update <id> --status active --progress 50 --current-status "…"\` |
-| \`task_operation_create\` | \`roy-agent tasks operations <id>\` to read; record milestones via the CLI's update/ops surface |
-| \`task_complete\` | \`roy-agent tasks complete <id> --deliverable "<path>"\` |
-| \`task_get\` | \`roy-agent tasks get <id>\` |
-| \`task_list\` | \`roy-agent tasks list\` |
-| \`task_search\` | \`roy-agent tasks search <keywords>\` |
-
-Prefer \`--json\` (\`-j\`) when you need to parse ids. The task id printed by
-\`create\` is your handle for the rest of the turn.
-
-## Style
-
-- Be direct and concrete; the user is reading task titles and milestones.
-- Report the task id and its state whenever you finish a step.
-- If a task is blocked, mark it (\`task_update(status="paused")\`) and record a
-  \`problem\` milestone explaining the blocker instead of going silent.`;
-function buildClaudeAgentsJson(opts = {}) {
-  const def = {
-    description: opts.description ?? ROY_AGENT_DESCRIPTION,
-    prompt: opts.prompt ?? CLAUDE_ROY_SYSTEM_PROMPT,
-    tools: [...opts.tools ?? CLAUDE_ROY_TOOLS]
-  };
-  if (opts.model)
-    def.model = opts.model;
-  return JSON.stringify({ [opts.name ?? CLAUDE_ROY_AGENT_NAME]: def });
-}
-
-// ../../../packages/cli/src/daemon/runners/claude-sessions.ts
-function createClaudeSessionRegistry() {
-  const sessions = new Map;
-  return {
-    get: (key) => sessions.get(key),
-    set: (key, id) => {
-      sessions.set(key, id);
-    },
-    delete: (key) => {
-      sessions.delete(key);
-    },
-    size: () => sessions.size
-  };
-}
+// ../../../packages/cli/src/daemon/runners/cursor.ts
+import { appendFileSync as appendFileSync2, existsSync as existsSync2, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname as dirname3, join as join3 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 
-// ../../../packages/cli/src/daemon/runners/claude-stream.ts
-function errorDetail(result) {
-  if (typeof result.result === "string" && result.result.trim() !== "") {
-    return result.result.trim();
-  }
-  if (Array.isArray(result.errors)) {
-    const parts = result.errors.map((e) => typeof e === "string" ? e.trim() : "").filter((e) => e !== "");
-    if (parts.length > 0)
-      return parts.join("; ");
+// ../../../packages/cli/src/daemon/runners/cursor-stream.ts
+function cursorToolName(toolCall) {
+  if (typeof toolCall !== "object" || toolCall === null)
+    return;
+  const tc = toolCall;
+  for (const key of Object.keys(tc)) {
+    if (!key.endsWith("ToolCall") && !key.endsWith("Tool"))
+      continue;
+    const payload = tc[key];
+    if (typeof payload !== "object" || payload === null)
+      return key;
+    return nameFromPayload(payload) ?? key;
+  }
+  return nameFromPayload(tc);
+  function nameFromPayload(p) {
+    const fn = p["function"];
+    if (typeof fn === "object" && fn !== null) {
+      const f = fn;
+      if (typeof f.name === "string" && f.name !== "")
+        return f.name;
+      if (typeof f.args === "object" && f.args !== null) {
+        const name = f.args.name;
+        if (typeof name === "string" && name !== "")
+          return name;
+      }
+    }
+    const payloadArgs = p["args"];
+    if (typeof payloadArgs === "object" && payloadArgs !== null) {
+      const name = payloadArgs.name;
+      if (typeof name === "string" && name !== "")
+        return name;
+    }
+    return;
   }
-  return result.subtype === undefined ? "claude reported is_error" : `claude reported ${result.subtype}`;
 }
-function flattenToolResult(content) {
+function flattenCursorToolResult(result) {
+  if (typeof result === "string")
+    return result;
+  if (typeof result !== "object" || result === null)
+    return "";
+  const r = result;
+  const success = r["success"];
+  if (typeof success === "object" && success !== null) {
+    const s = success;
+    const nested2 = flattenContent(s["content"]);
+    if (nested2 !== "")
+      return nested2;
+    if (typeof s["output"] === "string")
+      return s["output"];
+    if (typeof s["text"] === "string")
+      return s["text"];
+  }
+  const nested = flattenContent(r["content"]);
+  if (nested !== "")
+    return nested;
+  if (typeof r["output"] === "string")
+    return r["output"];
+  if (typeof r["text"] === "string")
+    return r["text"];
+  return "";
+}
+function flattenContent(content) {
   if (typeof content === "string")
     return content;
   if (!Array.isArray(content))
     return "";
   const parts = [];
-  for (const block of content) {
-    if (typeof block === "string") {
-      parts.push(block);
+  for (const item of content) {
+    if (typeof item === "string") {
+      parts.push(item);
       continue;
     }
-    if (typeof block === "object" && block !== null) {
-      const t = block.text;
-      if (typeof t === "string")
-        parts.push(t);
+    if (typeof item !== "object" || item === null)
+      continue;
+    const block = item;
+    if (typeof block.text === "string") {
+      parts.push(block.text);
+      continue;
+    }
+    if (typeof block.text === "object" && block.text !== null) {
+      const inner = block.text.text;
+      if (typeof inner === "string")
+        parts.push(inner);
     }
   }
   return parts.join(`
 `);
 }
+function cursorTitleHint(toolCall) {
+  if (typeof toolCall !== "object" || toolCall === null)
+    return;
+  const tc = toolCall;
+  for (const key of Object.keys(tc)) {
+    const inner = tc[key];
+    if (typeof inner !== "object" || inner === null)
+      continue;
+    const holder = inner;
+    const titleFrom = (value) => {
+      if (typeof value !== "object" || value === null)
+        return;
+      const title = value.title;
+      return typeof title === "string" && title !== "" ? title : undefined;
+    };
+    const direct = titleFrom(holder.args);
+    if (direct)
+      return direct;
+    const deepArgs = holder.args?.args;
+    const nested = titleFrom(deepArgs);
+    if (nested)
+      return nested;
+    if (typeof holder.arguments === "string") {
+      try {
+        const parsed = titleFrom(JSON.parse(holder.arguments));
+        if (parsed)
+          return parsed;
+      } catch {}
+    }
+  }
+  return;
+}
 
-class ClaudeStreamDecoder {
+class CursorStreamDecoder {
   lines = new LineSplitter;
   state = {
     assistantText: [],
@@ -1802,7 +2349,11 @@ class ClaudeStreamDecoder {
     return this.toResult();
   }
   snapshot() {
-    return { ...this.state, assistantText: [...this.state.assistantText], tools: [...this.state.tools] };
+    return {
+      ...this.state,
+      assistantText: [...this.state.assistantText],
+      tools: [...this.state.tools]
+    };
   }
   consume(rawLine) {
     const line = rawLine.trim();
@@ -1817,157 +2368,261 @@ class ClaudeStreamDecoder {
     if (typeof event !== "object" || event === null)
       return;
     const ev = event;
-    const sessionId = typeof ev.session_id === "string" ? ev.session_id : undefined;
+    const sessionId = typeof ev["session_id"] === "string" ? ev["session_id"] : undefined;
     if (sessionId && !this.state.sessionId)
       this.state.sessionId = sessionId;
-    if (ev.type === "assistant") {
+    if (ev["type"] === "assistant") {
       this.consumeAssistant(ev);
       return;
     }
-    if (ev.type === "user") {
-      this.consumeUser(ev);
+    if (ev["type"] === "tool_call") {
+      this.consumeToolCall(ev);
       return;
     }
-    if (ev.type === "result") {
+    if (ev["type"] === "result") {
       this.state.result = ev;
     }
   }
-  consumeUser(ev) {
-    const message = ev.message;
-    const content = message?.content;
+  consumeAssistant(ev) {
+    const message = ev["message"];
+    if (typeof message !== "object" || message === null)
+      return;
+    const content = message.content;
     if (!Array.isArray(content))
       return;
     for (const block of content) {
       if (typeof block !== "object" || block === null)
         continue;
-      const b = block;
-      if (b.type !== "tool_result")
-        continue;
-      const id = typeof b.tool_use_id === "string" ? b.tool_use_id : undefined;
-      const pending = id ? this.state.pendingCreates.get(id) : undefined;
-      const text = flattenToolResult(b.content);
-      if (this.state.createdTask !== undefined)
-        continue;
-      if (pending) {
-        this.state.pendingCreates.delete(id);
-        this.state.createdTask = extractCreatedTask(text, pending.titleHint);
-        continue;
+      const text = block.text;
+      if (typeof text === "string" && text !== "")
+        this.state.assistantText.push(text);
+    }
+  }
+  consumeToolCall(ev) {
+    const callId = typeof ev["call_id"] === "string" ? ev["call_id"] : undefined;
+    const toolCall = ev["tool_call"];
+    const tool = cursorToolName(toolCall);
+    const subtype = ev["subtype"];
+    if (subtype === "started") {
+      if (tool) {
+        this.state.tools.push(tool);
+        if (callId && isTaskCreateTool(tool)) {
+          this.state.pendingCreates.set(callId, {
+            tool,
+            titleHint: cursorTitleHint(toolCall)
+          });
+        }
       }
-      this.state.createdTask = extractCreatedTask(text);
+      return;
+    }
+    if (subtype === "completed") {
+      if (!callId)
+        return;
+      const pending = this.state.pendingCreates.get(callId);
+      const payload = typeof toolCall === "object" && toolCall !== null ? toolCall : undefined;
+      const result = payload ? this.toolResultOf(payload) : undefined;
+      const text = flattenCursorToolResult(result);
+      if (!pending) {
+        const tool2 = payload ? cursorToolName(payload) : undefined;
+        if (!tool2 || !isTaskCreateTool(tool2))
+          return;
+        const created2 = extractCreatedTask(text, payload ? cursorTitleHint(payload) : undefined);
+        if (created2 && !this.state.createdTask)
+          this.state.createdTask = created2;
+        return;
+      }
+      this.state.pendingCreates.delete(callId);
+      const created = extractCreatedTask(text, pending.titleHint);
+      if (created && !this.state.createdTask)
+        this.state.createdTask = created;
     }
   }
-  consumeAssistant(ev) {
-    const message = ev.message;
-    const content = message?.content;
-    if (!Array.isArray(content))
-      return;
-    for (const block of content) {
-      if (typeof block !== "object" || block === null)
+  toolResultOf(toolCall) {
+    for (const key of Object.keys(toolCall)) {
+      const inner = toolCall[key];
+      if (typeof inner !== "object" || inner === null)
         continue;
-      const b = block;
-      if (b.type === "text" && typeof b.text === "string") {
-        this.state.assistantText.push(b.text);
-      } else if (b.type === "tool_use") {
-        if (typeof b.name === "string") {
-          this.state.tools.push(b.name);
-          if (isTaskCreateTool(b.name) && typeof b.id === "string") {
-            const input = b.input;
-            const title = input?.["title"];
-            this.state.pendingCreates.set(b.id, {
-              tool: b.name,
-              titleHint: typeof title === "string" ? title : undefined
-            });
-          }
-        }
-      }
+      const result = inner.result;
+      if (result !== undefined)
+        return result;
     }
+    return;
   }
   toResult() {
-    const { result } = this.state;
-    const toolCalls = this.state.tools.length > 0 ? this.state.tools.length : undefined;
-    const tools = this.state.tools.length > 0 ? [...this.state.tools] : undefined;
-    const createdTask = this.state.createdTask;
-    if (result?.is_error) {
-      const detail = errorDetail(result);
-      return {
-        text: "",
-        sessionId: this.state.sessionId,
-        toolCalls,
-        tools,
-        createdTask,
-        error: detail.slice(0, 1000)
-      };
+    const result = this.state.result;
+    const out = { text: "" };
+    if (result) {
+      if (typeof result.result === "string")
+        out.text = result.result;
+      if (result.is_error === true) {
+        out.error = typeof result.result === "string" && result.result.trim() !== "" ? result.result.trim() : `cursor reported ${result.subtype ?? "is_error"}`;
+      }
     }
-    if (typeof result?.result === "string" && result.result.trim() !== "") {
-      return { text: result.result.trim(), sessionId: this.state.sessionId, toolCalls, tools, createdTask };
+    if (out.text === "") {
+      const joined = this.state.assistantText.join(`
+`).trim();
+      if (joined !== "")
+        out.text = joined;
     }
-    const fallback = this.state.assistantText.join("").trim();
-    return { text: fallback, sessionId: this.state.sessionId, toolCalls, tools, createdTask };
+    if (this.state.sessionId)
+      out.sessionId = this.state.sessionId;
+    if (this.state.tools.length > 0) {
+      out.tools = [...this.state.tools];
+      out.toolCalls = this.state.tools.length;
+    }
+    if (this.state.createdTask)
+      out.createdTask = this.state.createdTask;
+    return out;
   }
 }
 
-// ../../../packages/cli/src/daemon/runners/claude.ts
-var DEFAULT_CLAUDE_TIMEOUT_MS = 10 * 60 * 1000;
-var CLAUDE_STDIO = Object.freeze([
+// ../../../packages/cli/src/daemon/runners/cursor-sessions.ts
+function createCursorSessionRegistry() {
+  const sessions = new Map;
+  return {
+    get: (key) => sessions.get(key),
+    set: (key, id) => {
+      sessions.set(key, id);
+    },
+    delete: (key) => {
+      sessions.delete(key);
+    },
+    size: () => sessions.size
+  };
+}
+
+// ../../../packages/cli/src/daemon/runners/cursor.ts
+var DEFAULT_CURSOR_TIMEOUT_MS = 10 * 60 * 1000;
+var CURSOR_STDIO = Object.freeze([
   "ignore",
   "pipe",
   "pipe"
 ]);
-function buildClaudeArgs(input) {
-  const args = ["--print", "--output-format", "stream-json", "--verbose"];
-  if (input.agentsJson)
-    args.push("--agents", input.agentsJson);
-  args.push("--agent", input.agent ?? "roy");
-  args.push("--dangerously-skip-permissions");
+function buildCursorArgs(input) {
+  const args = ["-p", "--output-format", "stream-json", "--force", "--trust", "--approve-mcps"];
+  if (input.model)
+    args.push("--model", input.model);
   if (input.sessionId)
-    args.push("--resume", claudeSessionUuid(input.sessionId));
+    args.push("--resume", input.sessionId);
+  if (input.workspace)
+    args.push("--workspace", input.workspace);
+  for (const dir of input.addDirs ?? [])
+    args.push("--add-dir", dir);
   args.push(input.prompt);
   return args;
 }
-function isClaudeSessionUuid(value) {
-  if (!value)
-    return false;
-  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
+function buildCursorMcpConfig(pluginDir, env) {
+  return JSON.stringify({
+    mcpServers: {
+      "roy-task": {
+        type: "stdio",
+        command: process.execPath,
+        args: [join3(pluginDir, "mcp", "roy-task-mcp-server.mjs")],
+        ...env && Object.keys(env).length > 0 ? { env } : {}
+      }
+    }
+  });
 }
-function claudeSessionUuid(sessionKey) {
-  if (isClaudeSessionUuid(sessionKey))
-    return sessionKey;
-  const digest = createHash2("sha256").update(sessionKey).digest("hex");
-  const h = digest.slice(0, 32);
-  return [
-    h.slice(0, 8),
-    h.slice(8, 12),
-    `4${h.slice(13, 16)}`,
-    `8${h.slice(17, 20)}`,
-    h.slice(20, 32)
-  ].join("-");
+function resolveCursorPluginDir(roots, explicit) {
+  if (explicit)
+    return explicit;
+  for (const root of roots) {
+    const candidate = join3(root, "claude-plugin");
+    if (existsSync2(join3(candidate, "mcp", "roy-task-mcp-server.mjs")))
+      return candidate;
+  }
+  return;
 }
-function makeClaudeRunner(opts = {}) {
-  const bin = opts.bin ?? "claude";
-  const timeoutMs = opts.timeoutMs ?? DEFAULT_CLAUDE_TIMEOUT_MS;
-  const agentsJson = opts.agentsJson ?? buildClaudeAgentsJson();
-  const sessions = opts.sessions ?? createClaudeSessionRegistry();
+function writeCursorMcpConfig(dir, pluginDir, env) {
+  const cursorDir = join3(dir, ".cursor");
+  mkdirSync(cursorDir, { recursive: true });
+  writeFileSync(join3(cursorDir, "mcp.json"), buildCursorMcpConfig(pluginDir, env), "utf8");
+  return dir;
+}
+function createCursorWorkspace(pluginDir, env) {
+  const dir = join3(tmpdir(), `roy-task-cursor-${process.pid}`);
+  mkdirSync(dir, { recursive: true });
+  return writeCursorMcpConfig(dir, pluginDir, env);
+}
+function removeCursorWorkspace(dir) {
+  try {
+    rmSync(dir, { recursive: true, force: true });
+  } catch {}
+}
+function collectMcpNotifyEnv() {
+  const env = {};
+  for (const key of ["ROY_TASK_NOTIFY_ENABLED", "ROY_TASK_NOTIFY_CHAT_ID", "ROY_TASK_NOTIFY_PROFILE"]) {
+    const value = process.env[key];
+    if (value)
+      env[key] = value;
+  }
+  return env;
+}
+function makeCursorRunner(opts = {}) {
+  const bin = opts.bin ?? "cursor-agent";
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_CURSOR_TIMEOUT_MS;
+  const sessions = opts.sessions ?? createCursorSessionRegistry();
+  const pluginDir = opts.pluginDir ?? resolveCursorPluginDir([dirname3(fileURLToPath3(import.meta.url))]);
+  let workspaceDir = opts.workspaceDir;
+  if (!workspaceDir && pluginDir) {
+    try {
+      workspaceDir = createCursorWorkspace(pluginDir, opts.mcpEnv ?? collectMcpNotifyEnv());
+    } catch {
+      workspaceDir = undefined;
+    }
+  }
+  if (workspaceDir && !opts.workspaceDir) {
+    const cleanup = () => removeCursorWorkspace(workspaceDir);
+    process.once("exit", cleanup);
+    process.once("SIGINT", cleanup);
+    process.once("SIGTERM", cleanup);
+  }
+  const refreshMcpConfig = () => {
+    if (!workspaceDir || !pluginDir)
+      return;
+    if (opts.workspaceDir)
+      return;
+    try {
+      writeCursorMcpConfig(workspaceDir, pluginDir, opts.mcpEnv ?? collectMcpNotifyEnv());
+    } catch {}
+  };
+  const addDirs = opts.addDirs ?? [process.cwd()];
   return async function runAgent(input) {
+    refreshMcpConfig();
     const known = input.sessionId ? sessions.get(input.sessionId) : undefined;
-    const args = buildClaudeArgs({
+    const args = buildCursorArgs({
       prompt: input.prompt,
-      agent: input.agent,
-      agentsJson,
+      model: opts.model,
+      workspace: workspaceDir,
+      addDirs,
       sessionId: known
     });
-    const decoder = new ClaudeStreamDecoder;
+    const decoder = new CursorStreamDecoder;
     let stderr = "";
+    let reported = false;
+    const notifyProgress = () => {
+      if (reported || !input.onProgress)
+        return;
+      const created = decoder.snapshot().createdTask;
+      if (!created)
+        return;
+      reported = true;
+      try {
+        input.onProgress({ createdTask: created });
+      } catch {}
+    };
     let handle;
     try {
       handle = spawnStreaming([bin, ...args], {
-        stdin: CLAUDE_STDIO[0],
+        stdin: CURSOR_STDIO[0],
         env: { ...process.env, NO_COLOR: "1" },
         timeoutMs,
         onStdout: (chunk) => {
           decoder.pushChunk(chunk);
+          notifyProgress();
           if (process.env["ROY_TASK_DUMP_STREAM"]) {
             try {
-              appendFileSync(process.env["ROY_TASK_DUMP_STREAM"], chunk);
+              appendFileSync2(process.env["ROY_TASK_DUMP_STREAM"], chunk);
             } catch {}
           }
         },
@@ -1977,53 +2632,38 @@ function makeClaudeRunner(opts = {}) {
         }
       });
     } catch (err) {
-      return { text: "", error: `failed to spawn ${bin}: ${errMsg2(err)}` };
+      return { text: "", error: `failed to spawn ${bin}: ${errMsg3(err)}` };
     }
     let code;
     try {
       code = await handle.exited;
     } catch (err) {
       if (isMissingBinary(err)) {
-        return { text: "", error: `failed to spawn ${bin}: ${errMsg2(err)}` };
+        return { text: "", error: `failed to spawn ${bin}: ${errMsg3(err)}` };
       }
-      return { text: "", error: errMsg2(err) };
+      return { text: "", error: errMsg3(err) };
     }
     const result = decoder.finish();
     const stderrText = stderr.trim();
-    const combined = result.error ? stderrText && !result.error.includes(stderrText) ? `${result.error} | ${stderrText}` : result.error : undefined;
-    const effective = combined ? { ...result, error: combined.slice(0, 1000) } : result;
-    if (input.sessionId && effective.sessionId) {
-      sessions.set(input.sessionId, effective.sessionId);
+    if (result.error === undefined && code !== 0) {
+      result.error = stderrText !== "" ? stderrText : `${bin} exited with code ${code}`;
     }
-    if (code === 124) {
-      return { ...effective, error: `claude timed out after ${timeoutMs}ms` };
-    }
-    if (effective.error) {
-      if (input.sessionId && STALE_SESSION_RE.test(effective.error)) {
-        sessions.delete(input.sessionId);
-      }
-      return effective;
+    if (result.error !== undefined && stderrText !== "" && !result.error.includes(stderrText)) {
+      result.error = `${result.error} | ${stderrText}`;
     }
-    if (code !== 0 && !effective.text) {
-      const error = `claude exited ${code}: ${(stderr || "no stderr").trim().slice(0, 1000)}`;
-      if (input.sessionId && STALE_SESSION_RE.test(error)) {
+    const sessionId = result.sessionId;
+    if (input.sessionId) {
+      if (result.error === undefined && sessionId) {
+        sessions.set(input.sessionId, sessionId);
+      } else if (result.error !== undefined) {
         sessions.delete(input.sessionId);
       }
-      return {
-        text: "",
-        toolCalls: effective.toolCalls,
-        tools: effective.tools,
-        error
-      };
     }
-    return effective;
+    return result;
   };
 }
-var STALE_SESSION_RE = /No conversation found|not a UUID|session title/i;
-function errMsg2(err) {
-  if (err instanceof Error)
-    return err.message;
-  return String(err);
+function errMsg3(err) {
+  return err instanceof Error ? err.message : String(err);
 }
 
 // ../../../packages/cli/src/daemon/runners/opencode.ts
@@ -2039,29 +2679,41 @@ function makeOpencodeRunner(opts = {}) {
     });
     const assembler = new NdjsonAssembler;
     let stderr = "";
+    let reported = false;
     let handle;
     try {
       handle = spawnStreaming([bin, ...args], {
         stdin: OPENCODE_STDIO[0],
         env: { ...process.env, NO_COLOR: "1" },
         timeoutMs,
-        onStdout: (chunk) => assembler.pushChunk(chunk),
+        onStdout: (chunk) => {
+          assembler.pushChunk(chunk);
+          if (!reported && input.onProgress) {
+            const created = assembler.createdTaskSoFar;
+            if (created) {
+              reported = true;
+              try {
+                input.onProgress({ createdTask: created });
+              } catch {}
+            }
+          }
+        },
         onStderr: (chunk) => {
           if (stderr.length < 64 * 1024)
             stderr += chunk;
         }
       });
     } catch (err) {
-      return { text: "", error: `failed to spawn ${bin}: ${errMsg3(err)}` };
+      return { text: "", error: `failed to spawn ${bin}: ${errMsg4(err)}` };
     }
     let code;
     try {
       code = await handle.exited;
     } catch (err) {
       if (isMissingBinary(err)) {
-        return { text: "", error: `failed to spawn ${bin}: ${errMsg3(err)}` };
+        return { text: "", error: `failed to spawn ${bin}: ${errMsg4(err)}` };
       }
-      return { text: "", error: errMsg3(err) };
+      return { text: "", error: errMsg4(err) };
     }
     const result = assembler.finish();
     if (code === 124) {
@@ -2102,7 +2754,7 @@ function makeOpencodeRunner(opts = {}) {
     };
   };
 }
-function errMsg3(err) {
+function errMsg4(err) {
   if (err instanceof Error)
     return err.message;
   return String(err);
@@ -2121,6 +2773,12 @@ var FACTORIES = {
     timeoutMs: input.timeoutMs,
     model: input.codexModel,
     sandbox: isCodexSandboxMode(input.codexSandbox ?? "") ? input.codexSandbox : undefined
+  }),
+  cursor: (input) => makeCursorRunner({
+    bin: input.bin,
+    timeoutMs: input.timeoutMs,
+    pluginDir: input.pluginDir,
+    model: input.cursorModel
   })
 };
 function makeRunner(input = {}) {
@@ -2216,6 +2874,90 @@ async function defaultReplyRunner(input) {
   }
 }
 
+// ../../../packages/cli/src/daemon/trace.ts
+import {
+  getTracerProvider,
+  resetTracerProvider,
+  wrapFunction
+} from "@ai-setting/roy-agent-core";
+async function createTaskTracer(options = {}) {
+  if (options.enabled === false)
+    return disabledTracer();
+  try {
+    const provider = options.dataHome ? isolatedProvider(options.dataHome) : getTracerProvider();
+    await provider.initialize();
+    const storage = provider.getStorage();
+    return {
+      enabled: true,
+      storage: () => storage,
+      async span(spanName, fn) {
+        const wrapped = wrapFunction(fn, spanName, {
+          recordParams: false,
+          recordResult: false,
+          recordError: true
+        });
+        return wrapped();
+      },
+      async spanResult(spanName, fn, errorIf) {
+        const wrapped = wrapFunction(fn, spanName, {
+          recordParams: false,
+          recordResult: false,
+          recordError: true,
+          errorIf: (result) => errorIf(result)
+        });
+        return wrapped();
+      }
+    };
+  } catch {
+    return disabledTracer();
+  }
+}
+function isolatedProvider(dataHome) {
+  resetTracerProvider();
+  const prevHome = process.env["XDG_DATA_HOME"];
+  const restore = withCleanTraceparent(() => {
+    process.env["XDG_DATA_HOME"] = dataHome;
+    return getTracerProvider();
+  });
+  if (prevHome === undefined)
+    delete process.env["XDG_DATA_HOME"];
+  else
+    process.env["XDG_DATA_HOME"] = prevHome;
+  return restore;
+}
+function withCleanTraceparent(fn) {
+  const prev = process.env["TRACEPARENT"];
+  delete process.env["TRACEPARENT"];
+  try {
+    return fn();
+  } finally {
+    if (prev !== undefined)
+      process.env["TRACEPARENT"] = prev;
+  }
+}
+function disabledTracer() {
+  return {
+    enabled: false,
+    storage() {
+      throw new Error("roy-task tracing is disabled: no span storage available");
+    },
+    async span(_name, fn) {
+      return fn();
+    },
+    async spanResult(_name, fn, _errorIf) {
+      return fn();
+    }
+  };
+}
+var runtime;
+var runtimeOptions = {};
+function getTraceRuntime(options) {
+  if (options)
+    runtimeOptions = options;
+  runtime ??= createTaskTracer(runtimeOptions);
+  return runtime;
+}
+
 // ../../../packages/cli/src/cmd/serve.ts
 function serve(options, deps = {}) {
   return startServe(options, deps);
@@ -2225,18 +2967,21 @@ async function startServe(options, deps) {
   const gate = new ConcurrencyGate({ maxConcurrency: options.maxConcurrency });
   const deduper = new Deduper;
   const card = deps.card ?? (options.cardEnabled && !options.dryRun ? createRoyAgentCardPort() : createNoopCardPort());
+  const tracer = deps.tracer ?? await getTraceRuntime();
   const dispatcher = new Dispatcher({
     runAgent: deps.runAgent ?? makeRunner({
       runtime: options.runtime,
       bin: resolveRuntimeBin(options),
       timeoutMs: options.timeoutMs,
       codexModel: options.codexModel,
-      codexSandbox: options.codexSandbox
+      codexSandbox: options.codexSandbox,
+      cursorModel: options.cursorModel
     }),
     reply: deps.reply ?? defaultReplyRunner,
     gate,
     deduper,
-    card
+    card,
+    tracer
   }, {
     dryRun: options.dryRun,
     replyEnabled: options.replyEnabled,
@@ -2260,7 +3005,7 @@ async function startServe(options, deps) {
       try {
         await listener.stop();
       } catch (err) {
-        log(`[roy-task] listener.stop() failed: ${errMsg4(err)}`);
+        log(`[roy-task] listener.stop() failed: ${errMsg5(err)}`);
       }
       log("[roy-task] stopped");
       resolveDone();
@@ -2282,7 +3027,7 @@ async function startServe(options, deps) {
         await stop();
       }
     } catch (err) {
-      log(`[roy-task] ${label} dispatch threw: ${errMsg4(err)}`);
+      log(`[roy-task] ${label} dispatch threw: ${errMsg5(err)}`);
       if (options.once)
         await stop();
     }
@@ -2292,7 +3037,7 @@ async function startServe(options, deps) {
   try {
     await listener.start();
   } catch (err) {
-    log(`[roy-task] failed to start event listener: ${errMsg4(err)}`);
+    log(`[roy-task] failed to start event listener: ${errMsg5(err)}`);
     clearInterval(sweeper);
     resolveDone();
     throw err;
@@ -2315,6 +3060,7 @@ function formatBanner(options, commands, maxConcurrency) {
       `  codex model      : ${options.codexModel ?? "(codex config)"}`,
       `  codex sandbox    : ${options.codexSandbox ?? "read-only"}`
     ] : [],
+    ...options.runtime === "cursor" ? [`  cursor model     : ${options.cursorModel ?? "(cursor default)"}`] : [],
     `  max concurrency  : ${maxConcurrency}`,
     `  reply enabled    : ${options.replyEnabled}`,
     `  progress cards   : ${options.cardEnabled && !options.dryRun}`,
@@ -2359,7 +3105,7 @@ function formatResult(label, result) {
       return `[roy-task] ${label} skipped: ${result.reason}`;
   }
 }
-function errMsg4(err) {
+function errMsg5(err) {
   return err instanceof Error ? err.message : String(err);
 }
 
@@ -2484,7 +3230,7 @@ function formatStatus(report) {
 }
 
 // ../../../packages/cli/src/main.ts
-var VERSION = "0.7.1";
+var VERSION = "0.7.2";
 async function main(argv) {
   const parsed = parseArgs(argv);
   switch (parsed.command) {