@task0/cli 0.9.0 → 0.11.0

package/dist/main.js

@@ -207,6 +207,8 @@ function scanProject(projectPath, sourceName) {
     const summary = raw.summary || void 0;
     const displayTitle = summary?.title || title;
     const displayTags = summary?.tags ?? tags;
+    const agentRuns = Array.isArray(raw.agent_runs) ? raw.agent_runs.filter((v) => typeof v === "string") : void 0;
+    const runtimes = Array.isArray(raw.runtimes) ? raw.runtimes.filter((v) => typeof v === "string") : void 0;
     tasks.push({
       id,
       object_id: objectId,
@@ -227,6 +229,8 @@ function scanProject(projectPath, sourceName) {
       workflow: raw.workflow || void 0,
       summary,
       comments: raw.comments || void 0,
+      agent_runs: agentRuns,
+      runtimes,
       display_title: displayTitle,
       display_tags: displayTags
     });
@@ -1905,11 +1909,11 @@ async function request(method, pathname, body) {
   }
 }
 var api = {
-  get: (path32) => request("GET", path32),
-  post: (path32, body) => request("POST", path32, body ?? {}),
-  put: (path32, body) => request("PUT", path32, body ?? {}),
-  patch: (path32, body) => request("PATCH", path32, body ?? {}),
-  del: (path32) => request("DELETE", path32)
+  get: (path33) => request("GET", path33),
+  post: (path33, body) => request("POST", path33, body ?? {}),
+  put: (path33, body) => request("PUT", path33, body ?? {}),
+  patch: (path33, body) => request("PATCH", path33, body ?? {}),
+  del: (path33) => request("DELETE", path33)
 };
 
 // src/commands/task/triage.ts
@@ -4817,8 +4821,10 @@ function pickRegisterAuth(flagToken) {
 
 // src/core/daemon-rpc-handlers.ts
 init_node();
+import { execSync as execSync3 } from "child_process";
 import fs28 from "fs";
 import path26 from "path";
+import yaml10 from "js-yaml";
 
 // src/core/daemon-agent-run-runner.ts
 import { execFileSync } from "child_process";
@@ -5040,6 +5046,44 @@ function optionalBoolean(value) {
 function listProjects() {
   return loadConfig().sources.filter((source2) => source2.type === "project");
 }
+function resolveTaskDir(params, opts = {}) {
+  const projectName = ensureString(params.projectName, "projectName");
+  const taskId = ensureSafeTaskId(params.taskId);
+  const project2 = listProjects().find((p) => p.name === projectName);
+  if (!project2) {
+    throw Object.assign(new Error(`project not found: ${projectName}`), { code: "not_found" });
+  }
+  const projectAbs = path26.resolve(project2.path);
+  const projectConfig = readYaml(path26.join(projectAbs, "task0.yml"));
+  if (!projectConfig) {
+    throw Object.assign(
+      new Error(`invalid project: missing task0.yml at ${projectAbs}`),
+      { code: "invalid_project" }
+    );
+  }
+  const tasksRoot = path26.resolve(projectAbs, projectConfig.tasks_dir);
+  const taskDir = path26.resolve(tasksRoot, taskId);
+  assertContained(tasksRoot, taskDir);
+  const taskYml = path26.join(taskDir, "task0.yml");
+  if (opts.requireExists !== false && !fs28.existsSync(taskDir)) {
+    throw Object.assign(new Error(`task not found: ${taskId}`), { code: "not_found" });
+  }
+  return { projectName, taskId, projectAbs, tasksRoot, taskDir, taskYml };
+}
+async function withTaskYaml(ctx, resolved, mutate) {
+  const outcome = await withTaskYamlLock(resolved.taskDir, async () => {
+    const raw = readYaml(resolved.taskYml);
+    if (!raw) {
+      throw Object.assign(new Error(`task yaml missing or unreadable: ${resolved.taskYml}`), { code: "not_found" });
+    }
+    const { yaml: yaml12, result } = await mutate(raw);
+    if (yaml12) writeYaml(resolved.taskYml, yaml12);
+    const objectId = typeof (yaml12 ?? raw).object_id === "string" ? (yaml12 ?? raw).object_id : void 0;
+    return { result, object_id: objectId, mutated: yaml12 !== void 0 };
+  });
+  if (outcome.mutated) ctx.notifyManifestChanged();
+  return { result: outcome.result, object_id: outcome.object_id };
+}
 function applyRepair(r) {
   const raw = readYaml(r.taskYml);
   if (!raw) return;
@@ -5166,12 +5210,12 @@ var rpcHandlers = {
       throw Object.assign(new Error(`task not found: ${taskId}`), { code: "not_found" });
     }
     const taskYml = path26.join(taskDir, "task0.yml");
-    const yaml11 = readYaml(taskYml);
-    if (!yaml11) {
+    const yaml12 = readYaml(taskYml);
+    if (!yaml12) {
       throw Object.assign(new Error(`task yaml missing or unreadable: ${taskYml}`), { code: "not_found" });
     }
     const files = fs28.readdirSync(taskDir).filter((name) => name !== "task0.yml");
-    return { task_dir: taskDir, yaml: yaml11, files };
+    return { task_dir: taskDir, yaml: yaml12, files };
   },
   // Create a task directory + write task0.yml + write any additional named
   // files. Hub decides the taskId and yaml content (slug/object_id are
@@ -5179,8 +5223,8 @@ var rpcHandlers = {
   async task_create(params, ctx) {
     const projectName = ensureString(params.projectName, "projectName");
     const taskId = ensureSafeTaskId(params.taskId);
-    const yaml11 = params.yaml;
-    if (!yaml11 || typeof yaml11 !== "object") {
+    const yaml12 = params.yaml;
+    if (!yaml12 || typeof yaml12 !== "object") {
       throw Object.assign(new Error("yaml (object) is required"), { code: "invalid_params" });
     }
     const files = params.files ?? {};
@@ -5200,7 +5244,7 @@ var rpcHandlers = {
       throw Object.assign(new Error(`task already exists: ${taskId}`), { code: "already_exists" });
     }
     fs28.mkdirSync(taskDir, { recursive: true });
-    writeYaml(path26.join(taskDir, "task0.yml"), yaml11);
+    writeYaml(path26.join(taskDir, "task0.yml"), yaml12);
     for (const [name, content] of Object.entries(files)) {
       if (name.includes("/") || name.includes("\\") || name === ".." || name === ".") {
         throw Object.assign(new Error(`invalid file name: ${name}`), { code: "invalid_params" });
@@ -5217,8 +5261,8 @@ var rpcHandlers = {
   async task_write_yaml(params, ctx) {
     const projectName = ensureString(params.projectName, "projectName");
     const taskId = ensureSafeTaskId(params.taskId);
-    const yaml11 = params.yaml;
-    if (!yaml11 || typeof yaml11 !== "object") {
+    const yaml12 = params.yaml;
+    if (!yaml12 || typeof yaml12 !== "object") {
       throw Object.assign(new Error("yaml (object) is required"), { code: "invalid_params" });
     }
     const project2 = listProjects().find((p) => p.name === projectName);
@@ -5237,7 +5281,7 @@ var rpcHandlers = {
     if (!fs28.existsSync(taskYml)) {
       throw Object.assign(new Error(`task yaml not found: ${taskYml}`), { code: "not_found" });
     }
-    writeYaml(taskYml, yaml11);
+    writeYaml(taskYml, yaml12);
     ctx.notifyManifestChanged();
     return { task_dir: taskDir };
   },
@@ -5265,6 +5309,596 @@ var rpcHandlers = {
     ctx.notifyManifestChanged();
     return { task_dir: taskDir, deleted: true };
   },
+  // Archive a task directory: append it to `<tasks_dir>.tar`, then remove
+  // the active directory. Returns the task's object_id so the hub can emit
+  // a `task.archived` event. After the archive completes, notifyManifestChanged
+  // re-pushes the daemon's manifest so the hub's daemon_tasks cache drops
+  // the archived row.
+  async task_archive(params, ctx) {
+    const projectName = ensureString(params.projectName, "projectName");
+    const taskId = ensureSafeTaskId(params.taskId);
+    const project2 = listProjects().find((p) => p.name === projectName);
+    if (!project2) {
+      throw Object.assign(new Error(`project not found: ${projectName}`), { code: "not_found" });
+    }
+    const projectAbs = path26.resolve(project2.path);
+    const projectConfig = readYaml(path26.join(projectAbs, "task0.yml"));
+    if (!projectConfig) {
+      throw Object.assign(new Error(`invalid project: missing task0.yml at ${projectAbs}`), { code: "invalid_project" });
+    }
+    const tasksRoot = path26.resolve(projectAbs, projectConfig.tasks_dir);
+    const taskDir = path26.resolve(tasksRoot, taskId);
+    assertContained(tasksRoot, taskDir);
+    const tarFile = tasksRoot + ".tar";
+    if (fs28.existsSync(tarFile) && !fs28.statSync(tarFile).isFile()) {
+      throw Object.assign(
+        new Error(`${tarFile} exists but is not a file. Remove it manually first.`),
+        { code: "invalid_target" }
+      );
+    }
+    if (!fs28.existsSync(taskDir)) {
+      if (fs28.existsSync(tarFile)) {
+        const listing = execSync3(`tar -tf ${JSON.stringify(tarFile)}`).toString();
+        const dirs = new Set(listing.split("\n").map((line) => line.split("/")[0]).filter(Boolean));
+        if (dirs.has(taskId)) {
+          return { task_dir: taskDir, already_archived: true };
+        }
+      }
+      throw Object.assign(new Error(`task directory missing on disk: ${taskId}`), { code: "not_found" });
+    }
+    const taskYaml = readYaml(path26.join(taskDir, "task0.yml"));
+    const objectId = typeof taskYaml?.object_id === "string" ? taskYaml.object_id : void 0;
+    const tarFlag = fs28.existsSync(tarFile) ? "-rf" : "-cf";
+    execSync3(`tar ${tarFlag} ${JSON.stringify(tarFile)} -C ${JSON.stringify(tasksRoot)} ${JSON.stringify(taskId)}`);
+    fs28.rmSync(taskDir, { recursive: true });
+    ctx.notifyManifestChanged();
+    return { task_dir: taskDir, object_id: objectId, already_archived: false };
+  },
+  // Reverse of task_archive: extract `<taskId>` from `<tasks_dir>.tar`, then
+  // rewrite the tar without it (or delete the tar if it becomes empty). Refuses
+  // when an active directory already exists. Returns the extracted task's
+  // object_id (read from the freshly-restored task0.yml) so the hub can emit
+  // a `task.unarchived` event.
+  async task_unarchive(params, ctx) {
+    const resolved = resolveTaskDir(params, { requireExists: false });
+    const { tasksRoot, taskDir, taskId, projectAbs } = resolved;
+    const tarFile = tasksRoot + ".tar";
+    if (!fs28.existsSync(tarFile)) {
+      throw Object.assign(new Error("no archive found"), { code: "not_found" });
+    }
+    if (fs28.existsSync(taskDir)) {
+      throw Object.assign(
+        new Error(`task already exists in active tasks: ${taskId}`),
+        { code: "already_exists" }
+      );
+    }
+    execSync3(`tar -xf ${JSON.stringify(tarFile)} -C ${JSON.stringify(tasksRoot)} ${JSON.stringify(taskId)}`);
+    const listing = execSync3(`tar -tf ${JSON.stringify(tarFile)}`).toString();
+    const remainingDirs = [
+      ...new Set(
+        listing.split("\n").map((line) => line.split("/")[0]).filter((dir) => dir && dir !== taskId)
+      )
+    ];
+    if (remainingDirs.length === 0) {
+      fs28.unlinkSync(tarFile);
+    } else {
+      const tmpTar = tarFile + ".tmp";
+      const tmpDir = fs28.mkdtempSync(path26.join(projectAbs, ".task0", ".unarchive-"));
+      try {
+        execSync3(`tar -xf ${JSON.stringify(tarFile)} -C ${JSON.stringify(tmpDir)}`);
+        fs28.rmSync(path26.join(tmpDir, taskId), { recursive: true, force: true });
+        const dirs = fs28.readdirSync(tmpDir).filter((dir) => fs28.statSync(path26.join(tmpDir, dir)).isDirectory());
+        if (dirs.length === 0) {
+          fs28.unlinkSync(tarFile);
+        } else {
+          execSync3(
+            `tar -cf ${JSON.stringify(tmpTar)} -C ${JSON.stringify(tmpDir)} ${dirs.map((dir) => JSON.stringify(dir)).join(" ")}`
+          );
+          fs28.renameSync(tmpTar, tarFile);
+        }
+      } finally {
+        fs28.rmSync(tmpDir, { recursive: true, force: true });
+      }
+    }
+    const taskYaml = readYaml(path26.join(taskDir, "task0.yml"));
+    const objectId = typeof taskYaml?.object_id === "string" ? taskYaml.object_id : void 0;
+    ctx.notifyManifestChanged();
+    return { task_dir: taskDir, object_id: objectId };
+  },
+  // ---------------------------------------------------------------------
+  // Task-yaml field mutations. Each handler is a single read-modify-write
+  // transaction under the task's file lock, then re-pushes the manifest so
+  // the hub's daemon_tasks cache catches up immediately. Hub controllers
+  // call these instead of writing task0.yml directly.
+  // ---------------------------------------------------------------------
+  async task_link_issue(params, ctx) {
+    const resolved = resolveTaskDir(params);
+    const link = params.link;
+    if (!link || typeof link !== "object") {
+      throw Object.assign(new Error("link (object) is required"), { code: "invalid_params" });
+    }
+    const identifier = ensureString(link.identifier, "link.identifier");
+    const { object_id } = await withTaskYaml(ctx, resolved, (raw) => {
+      const linked = Array.isArray(raw.linked_issues) ? raw.linked_issues : [];
+      if (linked.some((issue2) => issue2.identifier === identifier)) {
+        return { result: { linked: false } };
+      }
+      linked.push({ ...link, linked_at: (/* @__PURE__ */ new Date()).toISOString() });
+      raw.linked_issues = linked;
+      return { yaml: raw, result: { linked: true } };
+    });
+    return { object_id, linked: true };
+  },
+  async task_unlink_issue(params, ctx) {
+    const resolved = resolveTaskDir(params);
+    const identifier = ensureString(params.identifier, "identifier");
+    const { object_id } = await withTaskYaml(ctx, resolved, (raw) => {
+      const linked = Array.isArray(raw.linked_issues) ? raw.linked_issues : [];
+      const next = linked.filter((issue2) => issue2.identifier !== identifier);
+      if (next.length === linked.length) {
+        return { result: { removed: false } };
+      }
+      if (next.length === 0) delete raw.linked_issues;
+      else raw.linked_issues = next;
+      return { yaml: raw, result: { removed: true } };
+    });
+    return { object_id, removed: true };
+  },
+  async task_set_description(params, ctx) {
+    const resolved = resolveTaskDir(params);
+    const description2 = typeof params.description === "string" ? params.description : null;
+    if (description2 === null) {
+      throw Object.assign(new Error("description (string) is required"), { code: "invalid_params" });
+    }
+    const { object_id, result } = await withTaskYaml(ctx, resolved, (raw) => {
+      const previous = typeof raw.description === "string" ? raw.description : void 0;
+      if (description2.length === 0) delete raw.description;
+      else raw.description = description2;
+      return { yaml: raw, result: { previous } };
+    });
+    return { object_id, description: description2, previous: result.previous };
+  },
+  async task_set_summary(params, ctx) {
+    const resolved = resolveTaskDir(params);
+    const title = ensureString(params.title, "title");
+    const tagsRaw = params.tags;
+    if (!Array.isArray(tagsRaw) || tagsRaw.some((t) => typeof t !== "string")) {
+      throw Object.assign(new Error("tags (string[]) is required"), { code: "invalid_params" });
+    }
+    const tags = tagsRaw;
+    const { object_id } = await withTaskYaml(ctx, resolved, (raw) => {
+      raw.title = title;
+      raw.tags = [...tags];
+      delete raw.summary;
+      return { yaml: raw, result: null };
+    });
+    return { object_id, title, tags };
+  },
+  async task_set_metadata(params, ctx) {
+    const resolved = resolveTaskDir(params);
+    const patch = params.patch;
+    if (!patch || typeof patch !== "object") {
+      throw Object.assign(new Error("patch (object) is required"), { code: "invalid_params" });
+    }
+    const { object_id, result: metadata } = await withTaskYaml(
+      ctx,
+      resolved,
+      (raw) => {
+        const current = raw.metadata || {};
+        const next = { ...current };
+        for (const [key, value] of Object.entries(patch)) {
+          if (value === null) delete next[key];
+          else if (typeof value === "string") next[key] = value;
+        }
+        if (Object.keys(next).length === 0) delete raw.metadata;
+        else raw.metadata = next;
+        return { yaml: raw, result: next };
+      }
+    );
+    return { object_id, metadata };
+  },
+  async task_add_agent_run(params, ctx) {
+    const resolved = resolveTaskDir(params);
+    const agentRunObjectId = ensureString(params.agentRunObjectId, "agentRunObjectId");
+    const { object_id } = await withTaskYaml(ctx, resolved, (raw) => {
+      if (raw.kind !== "task") return { result: null };
+      const fromCanonical = Array.isArray(raw.agent_runs) ? raw.agent_runs.filter((v) => typeof v === "string") : [];
+      const fromLegacy = Array.isArray(raw.runtimes) ? raw.runtimes.filter((v) => typeof v === "string") : [];
+      const merged = [.../* @__PURE__ */ new Set([...fromCanonical, ...fromLegacy])];
+      if (!merged.includes(agentRunObjectId)) merged.push(agentRunObjectId);
+      raw.agent_runs = merged;
+      delete raw.runtimes;
+      return { yaml: raw, result: null };
+    });
+    return { object_id };
+  },
+  async task_remove_agent_run(params, ctx) {
+    const resolved = resolveTaskDir(params);
+    const agentRunObjectId = ensureString(params.agentRunObjectId, "agentRunObjectId");
+    const { object_id } = await withTaskYaml(ctx, resolved, (raw) => {
+      if (raw.kind !== "task") return { result: null };
+      const fromCanonical = Array.isArray(raw.agent_runs) ? raw.agent_runs.filter((v) => typeof v === "string") : [];
+      const fromLegacy = Array.isArray(raw.runtimes) ? raw.runtimes.filter((v) => typeof v === "string") : [];
+      const merged = [.../* @__PURE__ */ new Set([...fromCanonical, ...fromLegacy])].filter((id) => id !== agentRunObjectId);
+      delete raw.runtimes;
+      if (merged.length === 0) delete raw.agent_runs;
+      else raw.agent_runs = merged;
+      return { yaml: raw, result: null };
+    });
+    return { object_id };
+  },
+  // Append a comment (or a reply to parentCommentId). The hub provides the
+  // pre-generated comment record (id, author, timestamps, body, metadata).
+  // Daemon serializes it into task0.yml.comments under the file lock.
+  async task_add_comment(params, ctx) {
+    const resolved = resolveTaskDir(params);
+    const comment2 = params.comment;
+    if (!comment2 || typeof comment2 !== "object") {
+      throw Object.assign(new Error("comment (object) is required"), { code: "invalid_params" });
+    }
+    const parentCommentId = typeof params.parentCommentId === "string" ? params.parentCommentId : void 0;
+    const dedupeMetadata = params.dedupeMetadata;
+    const { object_id, result } = await withTaskYaml(
+      ctx,
+      resolved,
+      (raw) => {
+        const comments = Array.isArray(raw.comments) ? raw.comments : [];
+        if (dedupeMetadata && typeof dedupeMetadata === "object") {
+          const dedupeEntries = Object.entries(dedupeMetadata);
+          if (dedupeEntries.length > 0) {
+            const matches = (m) => {
+              if (!m) return false;
+              return dedupeEntries.every(([k, v]) => m[k] === v);
+            };
+            const existing = comments.find((c) => {
+              if (matches(c.metadata)) return true;
+              const replies = Array.isArray(c.replies) ? c.replies : [];
+              return replies.some((r) => matches(r.metadata));
+            });
+            if (existing) {
+              const replies = Array.isArray(existing.replies) ? existing.replies : [];
+              const matched = matches(existing.metadata) ? existing : replies.find((r) => matches(r.metadata));
+              return { result: { comment: matched, skipped: true } };
+            }
+          }
+        }
+        if (parentCommentId) {
+          const idx = comments.findIndex((c) => c.id === parentCommentId);
+          if (idx < 0) {
+            throw Object.assign(
+              new Error(`parent comment ${parentCommentId} not found`),
+              { code: "not_found" }
+            );
+          }
+          const parent = comments[idx];
+          const replies = Array.isArray(parent.replies) ? parent.replies : [];
+          const reply = { ...comment2, parent_comment_id: parent.id };
+          const updated = [...comments];
+          updated[idx] = { ...parent, replies: [...replies, reply] };
+          raw.comments = updated;
+          return { yaml: raw, result: { comment: reply, skipped: false } };
+        }
+        raw.comments = [...comments, comment2];
+        return { yaml: raw, result: { comment: comment2, skipped: false } };
+      }
+    );
+    return { object_id, comment: result.comment, skipped: result.skipped };
+  },
+  async task_update_comment(params, ctx) {
+    const resolved = resolveTaskDir(params);
+    const commentId = ensureString(params.commentId, "commentId");
+    const patch = params.patch;
+    if (!patch || typeof patch !== "object") {
+      throw Object.assign(new Error("patch (object) is required"), { code: "invalid_params" });
+    }
+    const { object_id, result } = await withTaskYaml(
+      ctx,
+      resolved,
+      (raw) => {
+        const comments = Array.isArray(raw.comments) ? raw.comments : [];
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        for (let i = 0; i < comments.length; i++) {
+          if (comments[i].id === commentId) {
+            const updated = { ...comments[i], ...patch, updated_at: now };
+            const next = [...comments];
+            next[i] = updated;
+            raw.comments = next;
+            return { yaml: raw, result: { comment: updated } };
+          }
+          const replies = Array.isArray(comments[i].replies) ? comments[i].replies : [];
+          for (let j = 0; j < replies.length; j++) {
+            if (replies[j].id === commentId) {
+              const updatedReply = { ...replies[j], ...patch, updated_at: now };
+              const nextReplies = [...replies];
+              nextReplies[j] = updatedReply;
+              const next = [...comments];
+              next[i] = { ...comments[i], replies: nextReplies };
+              raw.comments = next;
+              return { yaml: raw, result: { comment: updatedReply } };
+            }
+          }
+        }
+        throw Object.assign(new Error(`comment ${commentId} not found`), { code: "not_found" });
+      }
+    );
+    return { object_id, comment: result.comment };
+  },
+  async task_delete_comment(params, ctx) {
+    const resolved = resolveTaskDir(params);
+    const commentId = ensureString(params.commentId, "commentId");
+    const { object_id, result } = await withTaskYaml(
+      ctx,
+      resolved,
+      (raw) => {
+        const comments = Array.isArray(raw.comments) ? raw.comments : [];
+        for (let i = 0; i < comments.length; i++) {
+          if (comments[i].id === commentId) {
+            const deleted = comments[i];
+            const next = comments.filter((_, idx) => idx !== i);
+            if (next.length === 0) delete raw.comments;
+            else raw.comments = next;
+            return { yaml: raw, result: { deleted } };
+          }
+          const replies = Array.isArray(comments[i].replies) ? comments[i].replies : [];
+          for (let j = 0; j < replies.length; j++) {
+            if (replies[j].id === commentId) {
+              const deleted = replies[j];
+              const nextReplies = replies.filter((_, idx) => idx !== j);
+              const next = [...comments];
+              next[i] = { ...comments[i], replies: nextReplies };
+              if (nextReplies.length === 0) delete next[i].replies;
+              raw.comments = next;
+              return { yaml: raw, result: { deleted } };
+            }
+          }
+        }
+        throw Object.assign(new Error(`comment ${commentId} not found`), { code: "not_found" });
+      }
+    );
+    return { object_id, deleted: result.deleted };
+  },
+  // ---------------------------------------------------------------------
+  // Task-directory file ops. task_write_file supports auto_index: { prefix }
+  // for "next IDEA-NN.md" semantics — daemon scans the dir and picks the next
+  // 2-digit number atomically (under taskDir lock) so concurrent saves don't
+  // collide.
+  // ---------------------------------------------------------------------
+  async task_write_file(params, ctx) {
+    const resolved = resolveTaskDir(params);
+    const content = ensureString(params.content, "content");
+    const explicitName = optionalString(params.name);
+    const autoIndex = params.auto_index;
+    if (!explicitName && !autoIndex) {
+      throw Object.assign(new Error("either name or auto_index is required"), { code: "invalid_params" });
+    }
+    return withTaskYamlLock(resolved.taskDir, () => {
+      let fileName;
+      if (explicitName) {
+        if (explicitName.includes("/") || explicitName.includes("\\") || explicitName === "." || explicitName === ".." || explicitName.startsWith(".")) {
+          throw Object.assign(new Error(`invalid file name: ${explicitName}`), { code: "invalid_params" });
+        }
+        fileName = explicitName;
+      } else {
+        const prefix = ensureString(autoIndex.prefix, "auto_index.prefix");
+        const suffix = autoIndex.suffix ?? ".md";
+        const pattern = new RegExp(`^${prefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(\\d+)${suffix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`);
+        const existing = fs28.readdirSync(resolved.taskDir);
+        const maxIdx = existing.reduce((max, name) => {
+          const m = name.match(pattern);
+          if (!m) return max;
+          const n = parseInt(m[1], 10);
+          return n > max ? n : max;
+        }, 0);
+        const nextIdx = String(maxIdx + 1).padStart(2, "0");
+        fileName = `${prefix}${nextIdx}${suffix}`;
+      }
+      const target = path26.resolve(resolved.taskDir, fileName);
+      assertContained(resolved.taskDir, target);
+      fs28.writeFileSync(target, content, "utf-8");
+      ctx.notifyManifestChanged();
+      return { file: fileName, path: target };
+    });
+  },
+  async task_delete_file(params, ctx) {
+    const resolved = resolveTaskDir(params);
+    const fileName = ensureString(params.name, "name");
+    if (fileName.includes("/") || fileName.includes("\\") || fileName === "." || fileName === ".." || fileName === "task0.yml") {
+      throw Object.assign(new Error(`invalid file name: ${fileName}`), { code: "invalid_params" });
+    }
+    const target = path26.resolve(resolved.taskDir, fileName);
+    assertContained(resolved.taskDir, target);
+    if (!fs28.existsSync(target)) {
+      throw Object.assign(new Error(`file not found: ${fileName}`), { code: "not_found" });
+    }
+    fs28.unlinkSync(target);
+    ctx.notifyManifestChanged();
+    return { deleted: true };
+  },
+  // Build the four-section context blob (yaml subset + IDEA + ISSUE + PLAN)
+  // hub uses for summarize / agent run prompts. Reads files daemon-side so
+  // remote projects work the same as local ones. Sections are truncated to
+  // 4000 chars to keep prompts bounded.
+  async task_build_context(params) {
+    const resolved = resolveTaskDir(params);
+    const SECTION_CHAR_LIMIT = 4e3;
+    function truncate2(text, max) {
+      if (text.length <= max) return text;
+      return text.slice(0, max) + "\n\n[...truncated]";
+    }
+    function latestMatching(pattern) {
+      const matches = fs28.readdirSync(resolved.taskDir).filter((n) => pattern.test(n)).sort();
+      return matches.length === 0 ? null : matches[matches.length - 1];
+    }
+    function readOrEmpty(file) {
+      try {
+        return fs28.readFileSync(file, "utf-8");
+      } catch {
+        return "";
+      }
+    }
+    let ymlSection = "";
+    if (fs28.existsSync(resolved.taskYml)) {
+      const raw = yaml10.load(fs28.readFileSync(resolved.taskYml, "utf-8"));
+      if (raw) {
+        const slim = {};
+        for (const key of ["title", "tags", "status", "current_step", "linked_issues"]) {
+          if (raw[key] !== void 0) slim[key] = raw[key];
+        }
+        ymlSection = yaml10.dump(slim, { lineWidth: 120 }).trim();
+      }
+    }
+    const ideaFile = latestMatching(/^IDEA-\d+\.md$/);
+    const ideaSection = ideaFile ? truncate2(readOrEmpty(path26.join(resolved.taskDir, ideaFile)), SECTION_CHAR_LIMIT) : "";
+    let issueSection = "";
+    const issueOverview = path26.join(resolved.taskDir, "ISSUE.md");
+    if (fs28.existsSync(issueOverview)) {
+      issueSection = truncate2(readOrEmpty(issueOverview), SECTION_CHAR_LIMIT);
+    } else if (fs28.existsSync(resolved.taskDir)) {
+      const details = fs28.readdirSync(resolved.taskDir).filter((n) => /^ISSUE-\d+\.md$/.test(n)).sort();
+      if (details.length > 0) {
+        const concatenated = details.map((name) => `## ${name}
+${readOrEmpty(path26.join(resolved.taskDir, name))}`).join("\n\n");
+        issueSection = truncate2(concatenated, SECTION_CHAR_LIMIT);
+      }
+    }
+    const refinedPlan = latestMatching(/^PLAN-\d+-refined\.md$/);
+    const anyPlan = refinedPlan ?? latestMatching(/^PLAN-\d+.*\.md$/);
+    const planSection = anyPlan ? truncate2(readOrEmpty(path26.join(resolved.taskDir, anyPlan)), SECTION_CHAR_LIMIT) : "";
+    return { yaml: ymlSection, idea: ideaSection, issue: issueSection, plan: planSection };
+  },
+  // List files (non-yaml) in a task directory with size + mtime. Hub calls
+  // this from GET /api/tasks/:taskId/files so the dashboard can render the
+  // task-detail file list regardless of which daemon hosts the project.
+  async task_list_files(params) {
+    const resolved = resolveTaskDir(params);
+    const entries = fs28.readdirSync(resolved.taskDir, { withFileTypes: true });
+    const files = entries.filter((entry) => entry.isFile()).map((entry) => {
+      const full = path26.join(resolved.taskDir, entry.name);
+      const stat = fs28.statSync(full);
+      return { name: entry.name, size: stat.size, modified: stat.mtime.toISOString(), path: full };
+    }).sort((a, b) => a.name.localeCompare(b.name));
+    return { files };
+  },
+  // List archived tasks (one per top-level directory inside `<tasks_dir>.tar`)
+  // along with a summary derived from each task's archived task0.yml + first
+  // matching markdown file. Hub uses this to populate the archived-tasks view.
+  async archive_list(params) {
+    const projectName = ensureString(params.projectName, "projectName");
+    const project2 = listProjects().find((p) => p.name === projectName);
+    if (!project2) {
+      throw Object.assign(new Error(`project not found: ${projectName}`), { code: "not_found" });
+    }
+    const projectAbs = path26.resolve(project2.path);
+    const projectConfig = readYaml(path26.join(projectAbs, "task0.yml"));
+    if (!projectConfig) {
+      throw Object.assign(
+        new Error(`invalid project: missing task0.yml at ${projectAbs}`),
+        { code: "invalid_project" }
+      );
+    }
+    const tasksRoot = path26.resolve(projectAbs, projectConfig.tasks_dir);
+    const tarFile = tasksRoot + ".tar";
+    if (!fs28.existsSync(tarFile)) return { tasks: [] };
+    const listing = execSync3(`tar -tf ${JSON.stringify(tarFile)}`).toString();
+    const lines = listing.split("\n");
+    const dirs = [...new Set(lines.map((line) => line.split("/")[0]).filter(Boolean))];
+    const tasks = [];
+    for (const dir of dirs) {
+      try {
+        const ymlContent = execSync3(
+          `tar -xf ${JSON.stringify(tarFile)} -O ${JSON.stringify(dir + "/task0.yml")}`
+        ).toString();
+        const raw = yaml10.load(ymlContent);
+        if (!raw || raw.kind !== "task") continue;
+        const mdFiles = lines.filter((line) => line.startsWith(dir + "/") && line.endsWith(".md"));
+        let context = "";
+        if (mdFiles.length > 0) {
+          try {
+            const md = execSync3(
+              `tar -xf ${JSON.stringify(tarFile)} -O ${JSON.stringify(mdFiles[0])}`
+            ).toString();
+            context = md.replace(/^---[\s\S]*?---\s*/, "").trim();
+          } catch {
+          }
+        }
+        tasks.push({
+          id: raw.id || dir,
+          object_id: raw.object_id,
+          title: raw.title || dir,
+          status: "archived",
+          created_at: raw.created_at || "",
+          context
+        });
+      } catch {
+      }
+    }
+    return { tasks };
+  },
+  // List files inside a specific archived task. Returns name + size; mtime is
+  // not preserved by tar's default flags so we omit it.
+  async archive_list_task_files(params) {
+    const projectName = ensureString(params.projectName, "projectName");
+    const taskId = ensureSafeTaskId(params.taskId);
+    const project2 = listProjects().find((p) => p.name === projectName);
+    if (!project2) {
+      throw Object.assign(new Error(`project not found: ${projectName}`), { code: "not_found" });
+    }
+    const projectAbs = path26.resolve(project2.path);
+    const projectConfig = readYaml(path26.join(projectAbs, "task0.yml"));
+    if (!projectConfig) {
+      throw Object.assign(
+        new Error(`invalid project: missing task0.yml at ${projectAbs}`),
+        { code: "invalid_project" }
+      );
+    }
+    const tarFile = path26.resolve(projectAbs, projectConfig.tasks_dir) + ".tar";
+    if (!fs28.existsSync(tarFile)) return { files: [] };
+    const listing = execSync3(`tar -tvf ${JSON.stringify(tarFile)}`).toString();
+    const prefix = taskId + "/";
+    const files = listing.split("\n").filter((line) => {
+      const parts = line.trim().split(/\s+/);
+      const filePath = parts[parts.length - 1];
+      return filePath && filePath.startsWith(prefix) && filePath !== prefix && !filePath.endsWith("/");
+    }).map((line) => {
+      const parts = line.trim().split(/\s+/);
+      const filePath = parts[parts.length - 1];
+      const size = parseInt(parts[2], 10) || 0;
+      const name = filePath.slice(prefix.length);
+      return { name, size, modified: "", path: filePath };
+    }).sort((a, b) => a.name.localeCompare(b.name));
+    return { files };
+  },
+  // Read a specific file (path is relative to a directory inside the tar:
+  // e.g., `<taskId>/task0.yml` or `<taskId>/IDEA-01.md`). Hub uses this for
+  // the archived-task detail view.
+  async archive_read_file(params) {
+    const projectName = ensureString(params.projectName, "projectName");
+    const archivePath = ensureString(params.path, "path");
+    if (archivePath.includes("..") || archivePath.startsWith("/")) {
+      throw Object.assign(new Error(`invalid archive path: ${archivePath}`), { code: "invalid_params" });
+    }
+    const project2 = listProjects().find((p) => p.name === projectName);
+    if (!project2) {
+      throw Object.assign(new Error(`project not found: ${projectName}`), { code: "not_found" });
+    }
+    const projectAbs = path26.resolve(project2.path);
+    const projectConfig = readYaml(path26.join(projectAbs, "task0.yml"));
+    if (!projectConfig) {
+      throw Object.assign(
+        new Error(`invalid project: missing task0.yml at ${projectAbs}`),
+        { code: "invalid_project" }
+      );
+    }
+    const tasksRoot = path26.resolve(projectAbs, projectConfig.tasks_dir);
+    const tarFile = tasksRoot + ".tar";
+    if (!fs28.existsSync(tarFile)) {
+      throw Object.assign(new Error("no archive found"), { code: "not_found" });
+    }
+    const content = execSync3(
+      `tar -xOf ${JSON.stringify(tarFile)} ${JSON.stringify(archivePath)}`
+    ).toString("utf-8");
+    return { content, path: archivePath };
+  },
   // ---------------------------------------------------------------------
   // Agent run lifecycle (P3.A scaffolding — handlers reject until P3.B
   // moves the actual spawn / tmux / supervise logic from hub's
@@ -5693,15 +6327,119 @@ function readCliVersion() {
   return cached2;
 }
 
+// src/core/project-watcher.ts
+init_node();
+import fs32 from "fs";
+import path31 from "path";
+var ProjectWatcher = class {
+  perProject = /* @__PURE__ */ new Map();
+  debounceTimers = /* @__PURE__ */ new Map();
+  debounceMs;
+  onChange;
+  constructor(opts) {
+    this.onChange = opts.onChange;
+    this.debounceMs = opts.debounceMs ?? 300;
+  }
+  /**
+   * Reconcile watchers against the desired project list. Idempotent — call it
+   * whenever the daemon's project set changes (project_add / project_remove /
+   * project_set_enabled RPCs, or on reconnect with the latest config).
+   */
+  setProjects(projects) {
+    const wanted = /* @__PURE__ */ new Map();
+    for (const p of projects) {
+      if (p.enabled) wanted.set(p.name, p);
+    }
+    for (const [name, entry] of this.perProject) {
+      const target = wanted.get(name);
+      if (!target || path31.resolve(target.path) !== entry.rootPath) {
+        this.stopProject(name);
+      }
+    }
+    for (const [name, proj] of wanted) {
+      if (!this.perProject.has(name)) {
+        this.startProject(proj);
+      }
+    }
+  }
+  close() {
+    for (const name of [...this.perProject.keys()]) this.stopProject(name);
+    for (const [, t] of this.debounceTimers) clearTimeout(t);
+    this.debounceTimers.clear();
+  }
+  startProject(proj) {
+    const rootPath = path31.resolve(proj.path);
+    const projectYml = path31.join(rootPath, "task0.yml");
+    const cfg = readYaml(projectYml);
+    if (!cfg || typeof cfg.tasks_dir !== "string" || cfg.tasks_dir.length === 0) {
+      return;
+    }
+    const tasksDir = path31.resolve(rootPath, cfg.tasks_dir);
+    const watchers = [];
+    try {
+      const w = fs32.watch(tasksDir, { recursive: true }, () => this.notify(proj.name));
+      w.on("error", () => {
+      });
+      watchers.push(w);
+    } catch {
+    }
+    try {
+      const parentDir = path31.dirname(tasksDir);
+      const tasksDirName = path31.basename(tasksDir);
+      const tarName = tasksDirName + ".tar";
+      const w = fs32.watch(parentDir, (_event, filename) => {
+        if (!filename) return;
+        if (filename === tasksDirName || filename === tarName) {
+          this.notify(proj.name);
+        }
+      });
+      w.on("error", () => {
+      });
+      watchers.push(w);
+    } catch {
+    }
+    this.perProject.set(proj.name, { watchers, rootPath });
+  }
+  stopProject(name) {
+    const entry = this.perProject.get(name);
+    if (!entry) return;
+    for (const w of entry.watchers) {
+      try {
+        w.close();
+      } catch {
+      }
+    }
+    this.perProject.delete(name);
+    const timer = this.debounceTimers.get(name);
+    if (timer) {
+      clearTimeout(timer);
+      this.debounceTimers.delete(name);
+    }
+  }
+  notify(projectName) {
+    const prev = this.debounceTimers.get(projectName);
+    if (prev) clearTimeout(prev);
+    const t = setTimeout(() => {
+      this.debounceTimers.delete(projectName);
+      try {
+        this.onChange(projectName);
+      } catch (err) {
+        console.error(`project watcher onChange threw for ${projectName}:`, err);
+      }
+    }, this.debounceMs);
+    this.debounceTimers.set(projectName, t);
+  }
+};
+
 // src/commands/daemon.ts
-async function dispatchRpc(ws, id, method, params) {
+async function dispatchRpc(ws, id, method, params, notifyManifestChanged) {
   const handler = rpcHandlers[method];
   if (!handler) {
     sendRpc(ws, { type: "rpc_error", id, error: { code: "unknown_method", message: `unknown method: ${method}` } });
     return;
   }
   try {
-    const ctx = { notifyManifestChanged: () => pushManifest(ws) };
+    const ctx = { notifyManifestChanged };
     const result = await handler(params ?? {}, ctx);
     sendRpc(ws, { type: "rpc_response", id, result });
   } catch (error2) {
@@ -5748,6 +6486,9 @@ function buildManifest() {
   }
   return { type: "manifest", projects, tasks, scan_errors: scanErrors };
 }
+function currentWatchedProjects() {
+  return loadConfig().sources.filter((source2) => source2.type === "project").map((source2) => ({ name: source2.name, path: source2.path, enabled: source2.enabled }));
+}
 function pushManifest(ws) {
   if (ws.readyState !== ws.OPEN) return;
   const manifest = buildManifest();
@@ -5965,11 +6706,21 @@ daemonCmd.command("run").description("Run the daemon WebSocket loop in foregroun
   let reconnectDelay = 1e3;
   let shouldRun = true;
   let activeWs = null;
+  let activeWatcher = null;
   function connect() {
     const ws = new WebSocket(wsUrl, {
       headers: { authorization: `Bearer ${identity.token}` }
     });
     activeWs = ws;
+    const watcher = new ProjectWatcher({
+      onChange: () => pushManifest(ws),
+      debounceMs: 300
+    });
+    activeWatcher = watcher;
+    const notifyManifestChanged = () => {
+      pushManifest(ws);
+      watcher.setProjects(currentWatchedProjects());
+    };
     ws.on("open", () => {
       reconnectDelay = 1e3;
       console.log(chalk19.green(`[${(/* @__PURE__ */ new Date()).toISOString()}] connected`));
@@ -5995,6 +6746,7 @@ daemonCmd.command("run").description("Run the daemon WebSocket loop in foregroun
       const manifest = buildManifest();
       ws.send(JSON.stringify(manifest));
       console.log(chalk19.dim(`pushed manifest: ${manifest.projects.length} project(s)`));
+      watcher.setProjects(currentWatchedProjects());
       const sink = {
         send: (frame) => {
           if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(frame));
@@ -6017,7 +6769,7 @@ daemonCmd.command("run").description("Run the daemon WebSocket loop in foregroun
       } else if (msg.type === "error") {
         console.error(chalk19.yellow(`server error: ${msg.message}`));
       } else if (msg.type === "rpc_request") {
-        void dispatchRpc(ws, msg.id, msg.method, msg.params);
+        void dispatchRpc(ws, msg.id, msg.method, msg.params, notifyManifestChanged);
       } else if (msg.type === "agent_run_resume_request") {
         const sent = replayAfterRanges(msg.ranges);
         if (sent > 0) {
@@ -6028,6 +6780,8 @@ daemonCmd.command("run").description("Run the daemon WebSocket loop in foregroun
     ws.on("close", (code, reason) => {
       activeWs = null;
       bindAgentRunFrameSink(null);
+      watcher.close();
+      if (activeWatcher === watcher) activeWatcher = null;
       const reasonText = reason.toString("utf-8") || "no reason";
       console.log(chalk19.yellow(`[${(/* @__PURE__ */ new Date()).toISOString()}] disconnected (code=${code}, ${reasonText})`));
       if (code === 4001) {
@@ -6045,6 +6799,10 @@ daemonCmd.command("run").description("Run the daemon WebSocket loop in foregroun
   }
   const shutdown = () => {
     shouldRun = false;
+    try {
+      activeWatcher?.close();
+    } catch {
+    }
     try {
       activeWs?.close(1e3, "shutdown");
     } catch {
@@ -6173,8 +6931,8 @@ function fail7(message, code = 1) {
   console.error(chalk20.red(message));
   process.exit(code);
 }
-async function callServer(path32, init = {}) {
-  const url = `${serverBase2()}${path32}`;
+async function callServer(path33, init = {}) {
+  const url = `${serverBase2()}${path33}`;
   let auth;
   try {
     auth = adminAuthHeader();
@@ -6679,11 +7437,11 @@ automation.command("runs <id>").description("List recent runs for an automation"
 
 // src/commands/profile.ts
 init_node();
-import fs32 from "fs";
-import path31 from "path";
+import fs33 from "fs";
+import path32 from "path";
 import { Command as Command23 } from "commander";
 import chalk23 from "chalk";
-import yaml10 from "js-yaml";
+import yaml11 from "js-yaml";
 var PROFILE_SCALAR_KEYS = ["api_url"];
 function isProfileScalarKey(key) {
   return PROFILE_SCALAR_KEYS.includes(key);
@@ -6693,19 +7451,19 @@ function fail9(msg) {
   process.exit(1);
 }
 function readDaemonAt(dir) {
-  const file = path31.join(dir, "daemon.json");
-  if (!fs32.existsSync(file)) return null;
+  const file = path32.join(dir, "daemon.json");
+  if (!fs33.existsSync(file)) return null;
   try {
-    return JSON.parse(fs32.readFileSync(file, "utf-8"));
+    return JSON.parse(fs33.readFileSync(file, "utf-8"));
   } catch {
     return null;
   }
 }
 function readProfileApiUrl(name) {
-  const file = path31.join(profileDir(name), "config.yml");
-  if (!fs32.existsSync(file)) return void 0;
+  const file = path32.join(profileDir(name), "config.yml");
+  if (!fs33.existsSync(file)) return void 0;
   try {
-    const data = yaml10.load(fs32.readFileSync(file, "utf-8"));
+    const data = yaml11.load(fs33.readFileSync(file, "utf-8"));
     return data?.api_url;
   } catch {
     return void 0;
@@ -6734,10 +7492,10 @@ profile2.command("add <name>").description("Create a new profile directory (use
     fail9(`"${DEFAULT_PROFILE_NAME}" is reserved; it always exists.`);
   }
   const dir = profileDir(name);
-  if (fs32.existsSync(dir)) {
+  if (fs33.existsSync(dir)) {
     fail9(`Profile "${name}" already exists at ${dir}.`);
   }
-  fs32.mkdirSync(dir, { recursive: true });
+  fs33.mkdirSync(dir, { recursive: true });
   const prev = process.env.TASK0_PROFILE;
   process.env.TASK0_PROFILE = name;
   try {
@@ -6761,14 +7519,14 @@ profile2.command("remove <name>").description('Delete a profile directory (refus
     fail9(`"${DEFAULT_PROFILE_NAME}" cannot be removed.`);
   }
   const dir = profileDir(name);
-  if (!fs32.existsSync(dir)) {
+  if (!fs33.existsSync(dir)) {
     fail9(`Profile "${name}" not found.`);
   }
   const current = currentProfileName();
   if (current === name && !opts.force) {
     fail9(`Profile "${name}" is current. Re-run with --force to remove it.`);
   }
-  fs32.rmSync(dir, { recursive: true, force: true });
+  fs33.rmSync(dir, { recursive: true, force: true });
   if (current === name) {
     writeCurrentProfile(null);
     console.log(chalk23.dim('Current profile reset to "default".'));
@@ -6779,7 +7537,7 @@ profile2.command("use <name>").description("Set the current profile").action((na
   if (!isValidProfileName(name)) {
     fail9(`Invalid profile name "${name}".`);
   }
-  if (!fs32.existsSync(profileDir(name))) {
+  if (!fs33.existsSync(profileDir(name))) {
     const names = listProfileNames();
     fail9(`Profile "${name}" not found. Available: ${names.join(", ")}.`);
   }
@@ -6814,7 +7572,7 @@ profile2.command("show [name]").description("Show a profile's configuration and
     fail9(`Invalid profile name "${target}".`);
   }
   const dir = profileDir(target);
-  if (!fs32.existsSync(dir)) {
+  if (!fs33.existsSync(dir)) {
     fail9(`Profile "${target}" not found.`);
   }
   const current = currentProfileName();
@@ -6824,7 +7582,7 @@ profile2.command("show [name]").description("Show a profile's configuration and
   const effective = envOverride ?? apiUrl;
   console.log(`${chalk23.bold(target)}${current === target ? chalk23.green(" (current)") : ""}`);
   console.log(`  dir:        ${dir}`);
-  console.log(`  config:     ${path31.join(dir, "config.yml")}`);
+  console.log(`  config:     ${path32.join(dir, "config.yml")}`);
   if (envOverride && apiUrl && envOverride !== apiUrl) {
     console.log(`  api_url:    ${envOverride} ${chalk23.dim("(TASK0_API_URL env, overrides profile)")}`);
     console.log(`              ${chalk23.dim(`profile: ${apiUrl}`)}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@task0/cli",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "task0 — task-centric agent workflow CLI",
   "homepage": "https://github.com/cy0-labs/task0#readme",
   "repository": {