@task0/cli 0.9.0 → 0.10.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
     });
@@ -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
@@ -6683,7 +7317,7 @@ import fs32 from "fs";
 import path31 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);
@@ -6705,7 +7339,7 @@ function readProfileApiUrl(name) {
   const file = path31.join(profileDir(name), "config.yml");
   if (!fs32.existsSync(file)) return void 0;
   try {
-    const data = yaml10.load(fs32.readFileSync(file, "utf-8"));
+    const data = yaml11.load(fs32.readFileSync(file, "utf-8"));
     return data?.api_url;
   } catch {
     return void 0;

package/package.json

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