@task0/cli 0.8.0 → 0.10.0

package/README.md

@@ -65,15 +65,19 @@ task0 run <id>           # drive the full triage → plan → refine → exec lo
 ## Run as a service (autostart on login / boot)
 
 `task0 daemon register` installs an OS-level autostart service in addition to
-recording the daemon identity. After registering you can sign out, reboot, and
-the daemon reconnects on its own.
+recording the daemon identity. The server URL comes from the active profile's
+`api_url` — set it once per profile, then `register` reads it. After registering
+you can sign out, reboot, and the daemon reconnects on its own.
 
 ```sh
-# user-level (default) — starts at user login, no sudo needed
-task0 daemon register --server https://central.example.com:4318
+# 1. Tell the active profile which server to talk to (once per profile)
+task0 profile set api_url https://central.example.com:4318
 
-# system-level — starts at boot, runs without an active login
-sudo -E task0 daemon register --system --server https://central.example.com:4318
+# 2a. user-level (default) — starts at user login, no sudo needed
+task0 daemon register
+
+# 2b. system-level — starts at boot, runs without an active login
+sudo -E task0 daemon register --system
 
 # pause / resume without forgetting the identity
 task0 daemon stop
@@ -83,6 +87,10 @@ task0 daemon start
 task0 daemon logout
 ```
 
+To target a different server for one invocation without writing it to the
+profile, export `TASK0_API_URL` — it overrides the profile's `api_url` for
+that shell session.
+
 Per platform:
 
 | Platform | Scope    | File written |

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
     });
@@ -1306,6 +1310,9 @@ function profileExists(name) {
   }
 }
 var activeProfileCache = null;
+function getActiveProfile() {
+  return activeProfileCache;
+}
 function activateProfile(argv) {
   ensureDefaultProfile();
   const flagValue = parseProfileFlag(argv);
@@ -1329,9 +1336,14 @@ function activateProfile(argv) {
     }
   }
   process.env.TASK0_PROFILE = name;
+  const envApiUrlOverride = process.env.TASK0_API_URL?.trim() || void 0;
   const apiUrl = getApiUrl();
-  activeProfileCache = { name, ...apiUrl ? { apiUrl } : {} };
-  if (apiUrl && !process.env.TASK0_API_URL) {
+  activeProfileCache = {
+    name,
+    ...apiUrl ? { apiUrl } : {},
+    ...envApiUrlOverride ? { envApiUrlOverride } : {}
+  };
+  if (apiUrl && !envApiUrlOverride) {
     process.env.TASK0_API_URL = apiUrl;
   }
 }
@@ -1695,7 +1707,7 @@ function requireLocalDaemon() {
   const id = localDaemonId();
   if (!id) {
     console.error(chalk.red("This host is not registered as a daemon."));
-    console.error(chalk.dim("Run `task0 daemon register --server <url>` first."));
+    console.error(chalk.dim("Run `task0 daemon register` first (set api_url with `task0 profile set api_url <url>` if needed)."));
     process.exit(1);
   }
   return id;
@@ -4809,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";
@@ -5032,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;
@@ -5158,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
@@ -5171,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 ?? {};
@@ -5192,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" });
@@ -5209,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);
@@ -5229,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 };
   },
@@ -5257,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
@@ -5787,10 +6429,20 @@ function fail6(message, code = 1) {
 function loadRequiredIdentity() {
   const identity = readDaemonIdentity();
   if (!identity) {
-    fail6(`No daemon identity at ${daemonConfigPath()}. Run \`task0 daemon register --server <url>\` first.`);
+    fail6(`No daemon identity at ${daemonConfigPath()}. Run \`task0 daemon register\` first (set api_url with \`task0 profile set api_url <url>\` if it isn't already configured).`);
   }
   return identity;
 }
+function resolveTargetServerUrl() {
+  const url = process.env.TASK0_API_URL?.trim();
+  if (url) return url.replace(/\/$/, "");
+  fail6(
+    `No server URL configured for the active profile.
+Set it with:
+  task0 profile set api_url <url>
+\u2026or export TASK0_API_URL for a one-off override.`
+  );
+}
 function serverBase(identity) {
   if (identity) return identity.server_url.replace(/\/$/, "");
   return (process.env.TASK0_API_URL || "http://127.0.0.1:4318").replace(/\/$/, "");
@@ -5828,7 +6480,7 @@ function rerunArgv() {
   return ["task0", ...process.argv.slice(2)].join(" ");
 }
 var daemonCmd = new Command19("daemon").description("Manage this host as a task0 daemon registered with a central server");
-daemonCmd.command("register").description("Register this host with a central server, install the autostart service, and start it").requiredOption("-s, --server <url>", "Central server URL (e.g. https://central.example.com:4318)").option("-n, --name <name>", "Display name for this daemon (defaults to hostname)").option("-t, --token <token>", "API token (apit_...) for registration. Falls back to TASK0_API_TOKEN, then admin token.").option("--force", "Overwrite existing identity if present").option("--system", "Install at the system layer (LaunchDaemons / /etc/systemd/system, requires sudo)").option("--no-install", "Skip installing the autostart service unit").option("--no-start", "Install the service unit but do not start it now").action(async (opts) => {
+daemonCmd.command("register").description("Register this host with the server configured in the active profile, install the autostart service, and start it").option("-n, --name <name>", "Display name for this daemon (defaults to hostname)").option("-t, --token <token>", "API token (apit_...) for registration. Falls back to TASK0_API_TOKEN, then admin token.").option("--force", "Overwrite existing identity if present").option("--system", "Install at the system layer (LaunchDaemons / /etc/systemd/system, requires sudo)").option("--no-install", "Skip installing the autostart service unit").option("--no-start", "Install the service unit but do not start it now").action(async (opts) => {
   const scope = opts.system ? "system" : "user";
   if (opts.install) {
     requireRootIfSystem(scope, rerunArgv());
@@ -5837,7 +6489,7 @@ daemonCmd.command("register").description("Register this host with a central ser
   if (existing && !opts.force) {
     fail6(`Already registered as ${existing.daemon_id}. Pass --force to re-register.`);
   }
-  const base = opts.server.replace(/\/$/, "");
+  const base = resolveTargetServerUrl();
   let authHeader;
   try {
     const choice = pickRegisterAuth(opts.token);
@@ -6665,7 +7317,11 @@ 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);
+}
 function fail9(msg) {
   console.error(chalk23.red(msg));
   process.exit(1);
@@ -6683,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;
@@ -6767,6 +7423,25 @@ profile2.command("use <name>").description("Set the current profile").action((na
 profile2.command("current").description('Print the current profile name (always succeeds; defaults to "default")').action(() => {
   console.log(currentProfileName());
 });
+profile2.command("set <key> <value>").description(`Set a config field on the active profile. Supported keys: ${PROFILE_SCALAR_KEYS.join(", ")}.`).action((key, value) => {
+  if (!isProfileScalarKey(key)) {
+    fail9(`Unknown key "${key}". Supported keys: ${PROFILE_SCALAR_KEYS.join(", ")}.`);
+  }
+  const config = loadConfig();
+  config[key] = value;
+  saveConfig(config);
+  console.log(chalk23.green(`${currentProfileName()}.${key} = ${value}`));
+});
+profile2.command("get <key>").description(`Read a config field from the active profile. Supported keys: ${PROFILE_SCALAR_KEYS.join(", ")}.`).action((key) => {
+  if (!isProfileScalarKey(key)) {
+    fail9(`Unknown key "${key}". Supported keys: ${PROFILE_SCALAR_KEYS.join(", ")}.`);
+  }
+  const value = loadConfig()[key];
+  if (typeof value !== "string" || value.length === 0) {
+    process.exit(1);
+  }
+  console.log(value);
+});
 profile2.command("show [name]").description("Show a profile's configuration and daemon registration").action((name) => {
   const target = name ?? currentProfileName();
   if (!isValidProfileName(target)) {
@@ -6779,19 +7454,30 @@ profile2.command("show [name]").description("Show a profile's configuration and
   const current = currentProfileName();
   const apiUrl = readProfileApiUrl(target);
   const identity = readDaemonAt(dir);
+  const envOverride = target === current ? getActiveProfile()?.envApiUrlOverride : void 0;
+  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(`  api_url:    ${apiUrl ?? chalk23.dim("(unset)")}`);
+  if (envOverride && apiUrl && envOverride !== apiUrl) {
+    console.log(`  api_url:    ${envOverride} ${chalk23.dim("(TASK0_API_URL env, overrides profile)")}`);
+    console.log(`              ${chalk23.dim(`profile: ${apiUrl}`)}`);
+  } else if (envOverride && !apiUrl) {
+    console.log(`  api_url:    ${envOverride} ${chalk23.dim("(TASK0_API_URL env; profile config.yml is unset)")}`);
+  } else if (apiUrl) {
+    console.log(`  api_url:    ${apiUrl} ${chalk23.dim("(profile config.yml)")}`);
+  } else {
+    console.log(`  api_url:    ${chalk23.dim("(unset \u2014 run `task0 profile set api_url <url>`)")}`);
+  }
   if (!identity) {
     console.log(chalk23.dim("  daemon.json: (not registered yet)"));
     return;
   }
   console.log(`  daemon_id:  ${identity.daemon_id ?? chalk23.dim("(missing)")}`);
   console.log(`  daemon.server_url: ${identity.server_url ?? chalk23.dim("(missing)")}`);
-  if (apiUrl && identity.server_url && apiUrl !== identity.server_url) {
-    console.log(chalk23.yellow(`  warn: profile.api_url and daemon.json.server_url disagree.`));
-    console.log(chalk23.dim(`        Re-register the daemon to align: task0 --profile ${target} daemon register --server ${apiUrl}`));
+  if (effective && identity.server_url && effective !== identity.server_url) {
+    console.log(chalk23.yellow(`  warn: effective api_url and daemon.json.server_url disagree.`));
+    console.log(chalk23.dim(`        Re-register the daemon to align: task0 --profile ${target} daemon register --force`));
   }
 });
 

package/package.json

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