@task0/cli 0.4.1 → 0.7.0

package/dist/main.js

@@ -10,20 +10,23 @@ var __export = (target, all) => {
 };
 
 // ../../packages/shared/dist/node/yaml.js
-import fs2 from "fs";
-import path2 from "path";
-import yaml2 from "js-yaml";
+import fs from "fs";
+import path from "path";
+import yaml from "js-yaml";
 function readYaml(filePath) {
-  if (!fs2.existsSync(filePath))
+  if (!fs.existsSync(filePath))
     return null;
-  const raw = fs2.readFileSync(filePath, "utf-8");
-  return yaml2.load(raw);
+  const raw = fs.readFileSync(filePath, "utf-8");
+  return yaml.load(raw);
+}
+function writeYaml(filePath, data) {
+  fs.writeFileSync(filePath, yaml.dump(data, { lineWidth: 120 }), "utf-8");
 }
 function readContext(taskDir) {
-  const files = fs2.readdirSync(taskDir).filter((f) => f.endsWith(".md"));
+  const files = fs.readdirSync(taskDir).filter((f) => f.endsWith(".md"));
   if (files.length === 0)
     return void 0;
-  const content = fs2.readFileSync(path2.join(taskDir, files[0]), "utf-8");
+  const content = fs.readFileSync(path.join(taskDir, files[0]), "utf-8");
   const stripped = content.replace(/^---[\s\S]*?---\s*/, "");
   return stripped.trim() || void 0;
 }
@@ -141,29 +144,29 @@ var init_task = __esm({
 });
 
 // ../../packages/shared/dist/node/scanner.js
-import fs3 from "fs";
-import path3 from "path";
+import fs2 from "fs";
+import path2 from "path";
 function scanProject(projectPath, sourceName) {
-  const absPath = path3.resolve(projectPath);
-  const resolvedSourceName = sourceName ?? path3.basename(absPath);
+  const absPath = path2.resolve(projectPath);
+  const resolvedSourceName = sourceName ?? path2.basename(absPath);
   const errors = [];
   const tasks = [];
   const repairs = [];
-  const projectYml = path3.join(absPath, "task0.yml");
+  const projectYml = path2.join(absPath, "task0.yml");
   const projectConfig = readYaml(projectYml);
   if (!projectConfig)
     return { tasks, errors: [`${projectYml} not found`], repairs };
   if (projectConfig.kind !== "project")
     return { tasks, errors: [`Invalid: kind="${projectConfig.kind}"`], repairs };
-  const tasksDir = path3.join(absPath, projectConfig.tasks_dir);
-  if (!fs3.existsSync(tasksDir))
+  const tasksDir = path2.join(absPath, projectConfig.tasks_dir);
+  if (!fs2.existsSync(tasksDir))
     return { tasks, errors: [`tasks_dir not found: ${tasksDir}`], repairs };
-  const entries = fs3.readdirSync(tasksDir, { withFileTypes: true });
+  const entries = fs2.readdirSync(tasksDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const taskDir = path3.join(tasksDir, entry.name);
-    const taskYml = path3.join(taskDir, "task0.yml");
+    const taskDir = path2.join(tasksDir, entry.name);
+    const taskYml = path2.join(taskDir, "task0.yml");
     const raw = readYaml(taskYml);
     if (!raw || raw.kind !== "task")
       continue;
@@ -199,7 +202,7 @@ function scanProject(projectPath, sourceName) {
       continue;
     }
     const context = readContext(taskDir);
-    const stat = fs3.statSync(taskYml);
+    const stat = fs2.statSync(taskYml);
     const tags = raw.tags || [];
     const summary = raw.summary || void 0;
     const displayTitle = summary?.title || title;
@@ -242,18 +245,18 @@ var init_scanner = __esm({
 });
 
 // ../../packages/shared/dist/node/open-questions.js
-import fs4 from "fs";
-import path4 from "path";
+import fs3 from "fs";
+import path3 from "path";
 function readOpenQuestions(taskDir, issueFiles) {
   const result = [];
   for (const file of issueFiles) {
     const m = file.match(/^ISSUE-(\d+)\.md$/);
     if (!m)
       continue;
-    const fullPath = path4.join(taskDir, file);
-    if (!fs4.existsSync(fullPath))
+    const fullPath = path3.join(taskDir, file);
+    if (!fs3.existsSync(fullPath))
       continue;
-    const md = fs4.readFileSync(fullPath, "utf-8");
+    const md = fs3.readFileSync(fullPath, "utf-8");
     const match = md.match(OPEN_QUESTIONS_SECTION_RE);
     if (!match)
       continue;
@@ -276,34 +279,34 @@ var init_open_questions = __esm({
 });
 
 // ../../packages/shared/dist/node/task-state.js
-import fs5 from "fs";
+import fs4 from "fs";
 import os from "os";
-import path5 from "path";
-import yaml3 from "js-yaml";
+import path4 from "path";
+import yaml2 from "js-yaml";
 function findProjectRoot(start = process.cwd()) {
-  let dir = path5.resolve(start);
+  let dir = path4.resolve(start);
   while (true) {
-    const ymlPath = path5.join(dir, "task0.yml");
-    if (fs5.existsSync(ymlPath)) {
+    const ymlPath = path4.join(dir, "task0.yml");
+    if (fs4.existsSync(ymlPath)) {
       try {
-        const raw = yaml3.load(fs5.readFileSync(ymlPath, "utf-8"));
+        const raw = yaml2.load(fs4.readFileSync(ymlPath, "utf-8"));
         if (raw?.kind === "project")
           return dir;
       } catch {
       }
     }
-    const parent = path5.dirname(dir);
+    const parent = path4.dirname(dir);
     if (parent === dir)
       return null;
     dir = parent;
   }
 }
 function readProjectConfig(projectRoot) {
-  return yaml3.load(fs5.readFileSync(path5.join(projectRoot, "task0.yml"), "utf-8"));
+  return yaml2.load(fs4.readFileSync(path4.join(projectRoot, "task0.yml"), "utf-8"));
 }
 function resolveTasksDir(projectRoot, projectConfig) {
   const cfg = projectConfig ?? readProjectConfig(projectRoot);
-  return path5.isAbsolute(cfg.tasks_dir) ? cfg.tasks_dir : path5.join(projectRoot, cfg.tasks_dir);
+  return path4.isAbsolute(cfg.tasks_dir) ? cfg.tasks_dir : path4.join(projectRoot, cfg.tasks_dir);
 }
 function resolveTaskByObjectId(objectId, projectRoot) {
   const root = projectRoot ?? findProjectRoot();
@@ -314,16 +317,16 @@ function resolveTaskByObjectId(objectId, projectRoot) {
     throw new Error(`Expected a task object_id like 'tsk_XXXXX', got '${objectId}'. Directory names are no longer accepted; run 'task0 task list' to find the object_id.`);
   }
   const tasksDir = resolveTasksDir(root);
-  const entries = fs5.readdirSync(tasksDir, { withFileTypes: true });
+  const entries = fs4.readdirSync(tasksDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const taskDir = path5.join(tasksDir, entry.name);
-    const taskYml = path5.join(taskDir, "task0.yml");
-    if (!fs5.existsSync(taskYml))
+    const taskDir = path4.join(tasksDir, entry.name);
+    const taskYml = path4.join(taskDir, "task0.yml");
+    if (!fs4.existsSync(taskYml))
       continue;
     try {
-      const raw = yaml3.load(fs5.readFileSync(taskYml, "utf-8"));
+      const raw = yaml2.load(fs4.readFileSync(taskYml, "utf-8"));
       if (raw && raw.object_id === objectId) {
         return { projectRoot: root, tasksDir, taskDir, taskYml };
       }
@@ -333,15 +336,15 @@ function resolveTaskByObjectId(objectId, projectRoot) {
   throw new Error(`No task with object_id '${objectId}' found under ${tasksDir}. If tasks pre-date object_id, run 'task0 task migrate' to seed them.`);
 }
 function readTaskYaml(taskYml) {
-  if (!fs5.existsSync(taskYml))
+  if (!fs4.existsSync(taskYml))
     throw new Error(`task0.yml not found: ${taskYml}`);
-  return yaml3.load(fs5.readFileSync(taskYml, "utf-8")) || {};
+  return yaml2.load(fs4.readFileSync(taskYml, "utf-8")) || {};
 }
 function writeTaskYaml(taskYml, data) {
-  fs5.writeFileSync(taskYml, yaml3.dump(data, { lineWidth: 120 }), "utf-8");
+  fs4.writeFileSync(taskYml, yaml2.dump(data, { lineWidth: 120 }), "utf-8");
 }
 function taskYamlLockPath(taskDir) {
-  return path5.join(taskDir, TASK_YAML_LOCKFILE);
+  return path4.join(taskDir, TASK_YAML_LOCKFILE);
 }
 function isProcessAlive(pid) {
   try {
@@ -353,17 +356,17 @@ function isProcessAlive(pid) {
 }
 function readTaskYamlLockInfo(file) {
   try {
-    return JSON.parse(fs5.readFileSync(file, "utf-8"));
+    return JSON.parse(fs4.readFileSync(file, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeTaskYamlLockInfo(file, info) {
-  const fd = fs5.openSync(file, "wx");
+  const fd = fs4.openSync(file, "wx");
   try {
-    fs5.writeFileSync(fd, JSON.stringify(info, null, 2), "utf-8");
+    fs4.writeFileSync(fd, JSON.stringify(info, null, 2), "utf-8");
   } finally {
-    fs5.closeSync(fd);
+    fs4.closeSync(fd);
   }
 }
 function sleep(ms) {
@@ -389,7 +392,7 @@ async function acquireTaskYamlLock(taskDir) {
     const existing = readTaskYamlLockInfo(file);
     if (existing && existing.hostname === info.hostname && !isProcessAlive(existing.pid)) {
       try {
-        fs5.unlinkSync(file);
+        fs4.unlinkSync(file);
         continue;
       } catch (err) {
         if (err.code !== "ENOENT") {
@@ -411,7 +414,7 @@ function releaseTaskYamlLock(taskDir, info) {
     return;
   }
   try {
-    fs5.unlinkSync(file);
+    fs4.unlinkSync(file);
   } catch (err) {
     if (err.code !== "ENOENT") {
       throw err;
@@ -419,7 +422,7 @@ function releaseTaskYamlLock(taskDir, info) {
   }
 }
 async function withTaskYamlLock(taskDir, fn) {
-  const key = path5.resolve(taskDir);
+  const key = path4.resolve(taskDir);
   const prev = yamlLocks.get(key) ?? Promise.resolve();
   const next = prev.then(async () => {
     const lock = await acquireTaskYamlLock(taskDir);
@@ -450,7 +453,7 @@ function readTaskWorkflow(taskYml) {
   return raw.workflow || {};
 }
 async function updateTaskWorkflow(taskYml, patch) {
-  const taskDir = path5.dirname(taskYml);
+  const taskDir = path4.dirname(taskYml);
   return withTaskYamlLock(taskDir, () => {
     const raw = readTaskYaml(taskYml);
     const current = raw.workflow || {};
@@ -580,19 +583,19 @@ var init_redact = __esm({
 });
 
 // ../../packages/shared/dist/node/error-reports.js
-import fs6 from "fs";
+import fs5 from "fs";
 import os2 from "os";
-import path6 from "path";
+import path5 from "path";
 import { spawnSync } from "child_process";
 import crypto from "crypto";
 function task0Home() {
   const override = process.env.TASK0_HOME;
   if (override && override.length > 0)
     return override;
-  return path6.join(os2.homedir(), ".task0");
+  return path5.join(os2.homedir(), ".task0");
 }
 function errorsRoot() {
-  return path6.join(task0Home(), "errors");
+  return path5.join(task0Home(), "errors");
 }
 function createErrorReportId() {
   return `err_${crypto.randomBytes(4).toString("hex")}`;
@@ -693,13 +696,13 @@ function buildErrorReport(input) {
 function writeErrorReportSync(report, rootOverride) {
   const root = rootOverride ?? errorsRoot();
   const dirName = errorReportDirName(new Date(report.captured_at), report.id);
-  const dir = path6.join(root, dirName);
-  fs6.mkdirSync(dir, { recursive: true });
-  const finalPath = path6.join(dir, REPORT_FILENAME);
-  const tmpPath = path6.join(dir, TMP_FILENAME);
+  const dir = path5.join(root, dirName);
+  fs5.mkdirSync(dir, { recursive: true });
+  const finalPath = path5.join(dir, REPORT_FILENAME);
+  const tmpPath = path5.join(dir, TMP_FILENAME);
   const json = JSON.stringify(report, null, 2);
-  fs6.writeFileSync(tmpPath, json, "utf-8");
-  fs6.renameSync(tmpPath, finalPath);
+  fs5.writeFileSync(tmpPath, json, "utf-8");
+  fs5.renameSync(tmpPath, finalPath);
   return { dir, path: finalPath };
 }
 function parseReportDir(name) {
@@ -716,7 +719,7 @@ function listErrorReports(rootOverride) {
   };
   let entries;
   try {
-    entries = fs6.readdirSync(root, { withFileTypes: true });
+    entries = fs5.readdirSync(root, { withFileTypes: true });
   } catch (err) {
     if (err.code === "ENOENT")
       return result;
@@ -728,11 +731,11 @@ function listErrorReports(rootOverride) {
     const parsed = parseReportDir(entry.name);
     if (!parsed)
       continue;
-    const dir = path6.join(root, entry.name);
-    const file = path6.join(dir, REPORT_FILENAME);
+    const dir = path5.join(root, entry.name);
+    const file = path5.join(dir, REPORT_FILENAME);
     let raw;
     try {
-      raw = fs6.readFileSync(file, "utf-8");
+      raw = fs5.readFileSync(file, "utf-8");
     } catch {
       result.skipped.unreadable += 1;
       continue;
@@ -750,7 +753,7 @@ function listErrorReports(rootOverride) {
     }
     let size = 0;
     try {
-      size = fs6.statSync(file).size;
+      size = fs5.statSync(file).size;
     } catch {
     }
     result.reports.push({
@@ -785,7 +788,7 @@ function resolveErrorReport(query, rootOverride) {
   return { kind: "miss", query };
 }
 function readErrorReport(summary) {
-  const raw = fs6.readFileSync(summary.path, "utf-8");
+  const raw = fs5.readFileSync(summary.path, "utf-8");
   return JSON.parse(raw);
 }
 function pruneErrorReports(opts, rootOverride) {
@@ -823,7 +826,7 @@ function pruneErrorReports(opts, rootOverride) {
 }
 function removeReportDir(dir) {
   try {
-    fs6.rmSync(dir, { recursive: true, force: true });
+    fs5.rmSync(dir, { recursive: true, force: true });
     return true;
   } catch {
     return false;
@@ -841,9 +844,9 @@ var init_error_reports = __esm({
 });
 
 // ../../packages/shared/dist/node/file-lock.js
-import fs7 from "fs";
+import fs6 from "fs";
 import os3 from "os";
-import path7 from "path";
+import path6 from "path";
 var init_file_lock = __esm({
   "../../packages/shared/dist/node/file-lock.js"() {
     "use strict";
@@ -858,6 +861,202 @@ var init_tmux = __esm({
   }
 });
 
+// ../../packages/shared/dist/node/agent-skills.js
+import fs7 from "fs";
+import path7 from "path";
+import yaml3 from "js-yaml";
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function extractFrontmatter(raw) {
+  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+  if (!match)
+    return null;
+  try {
+    const parsed = yaml3.load(match[1]);
+    return isRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function readTextIfExists(filePath) {
+  try {
+    if (!fs7.existsSync(filePath))
+      return null;
+    return fs7.readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function getSymlinkInfo(...candidatePaths) {
+  for (const candidatePath of candidatePaths) {
+    try {
+      const stat = fs7.lstatSync(candidatePath);
+      if (!stat.isSymbolicLink())
+        continue;
+      const target = fs7.readlinkSync(candidatePath);
+      return {
+        isSymlink: true,
+        symlinkTarget: path7.isAbsolute(target) ? target : path7.resolve(path7.dirname(candidatePath), target)
+      };
+    } catch {
+    }
+  }
+  return { isSymlink: false };
+}
+function normalizeString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function normalizeGlobs(value) {
+  if (typeof value === "string") {
+    const glob = value.trim();
+    return glob ? [glob] : void 0;
+  }
+  if (Array.isArray(value)) {
+    const globs = value.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean);
+    return globs.length > 0 ? globs : void 0;
+  }
+  return void 0;
+}
+function normalizeBoolean(value) {
+  if (typeof value === "boolean")
+    return value;
+  if (value === "true")
+    return true;
+  if (value === "false")
+    return false;
+  return void 0;
+}
+function sortSkills(skills) {
+  return skills.sort((a, b) => AGENT_ORDER[a.agent] - AGENT_ORDER[b.agent] || SCOPE_ORDER[a.scope] - SCOPE_ORDER[b.scope] || KIND_ORDER[a.kind] - KIND_ORDER[b.kind] || a.name.localeCompare(b.name) || a.filePath.localeCompare(b.filePath));
+}
+function pushInstructionIfExists(skills, agent2, scope, filePath, name = path7.basename(filePath), description2 = "", kind = "instruction") {
+  const raw = readTextIfExists(filePath);
+  if (raw === null)
+    return;
+  skills.push({
+    agent: agent2,
+    scope,
+    kind,
+    name,
+    description: description2,
+    filePath,
+    ...getSymlinkInfo(filePath)
+  });
+}
+function scanClaudeSkillDir(skills, skillsDir, scope) {
+  let entries = [];
+  try {
+    if (!fs7.existsSync(skillsDir))
+      return;
+    entries = fs7.readdirSync(skillsDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory() && !entry.isSymbolicLink())
+      continue;
+    const skillDirPath = path7.join(skillsDir, entry.name);
+    const skillFilePath = path7.join(skillDirPath, "SKILL.md");
+    const raw = readTextIfExists(skillFilePath);
+    if (raw === null)
+      continue;
+    const frontmatter = extractFrontmatter(raw);
+    skills.push({
+      agent: "claude_code",
+      scope,
+      kind: "skill",
+      name: normalizeString(frontmatter?.name) || entry.name,
+      description: normalizeString(frontmatter?.description),
+      filePath: skillFilePath,
+      ...getSymlinkInfo(skillDirPath, skillFilePath)
+    });
+  }
+}
+function scanCursorRuleFile(skills, filePath, scope) {
+  const raw = readTextIfExists(filePath);
+  if (raw === null)
+    return;
+  const frontmatter = extractFrontmatter(raw);
+  const baseName = path7.basename(filePath, ".mdc");
+  skills.push({
+    agent: "cursor",
+    scope,
+    kind: "rule",
+    name: normalizeString(frontmatter?.name) || baseName,
+    description: normalizeString(frontmatter?.description),
+    filePath,
+    globs: normalizeGlobs(frontmatter?.globs),
+    alwaysApply: normalizeBoolean(frontmatter?.alwaysApply),
+    ...getSymlinkInfo(filePath)
+  });
+}
+function scanCursorRulesDir(skills, rulesDir, scope) {
+  let entries = [];
+  try {
+    if (!fs7.existsSync(rulesDir))
+      return;
+    entries = fs7.readdirSync(rulesDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.name.endsWith(".mdc"))
+      continue;
+    if (!entry.isFile() && !entry.isSymbolicLink())
+      continue;
+    scanCursorRuleFile(skills, path7.join(rulesDir, entry.name), scope);
+  }
+}
+function getProjectAgentSkills(projectPath) {
+  const absProjectPath = path7.resolve(projectPath);
+  let projectStat;
+  try {
+    projectStat = fs7.statSync(absProjectPath);
+  } catch {
+    return [];
+  }
+  if (!projectStat.isDirectory())
+    return [];
+  const skills = [];
+  scanClaudeSkillDir(skills, path7.join(absProjectPath, ".claude", "skills"), "project");
+  pushInstructionIfExists(skills, "claude_code", "project", path7.join(absProjectPath, "CLAUDE.md"));
+  pushInstructionIfExists(skills, "claude_code", "project", path7.join(absProjectPath, "AGENTS.md"));
+  pushInstructionIfExists(skills, "codex", "project", path7.join(absProjectPath, "AGENTS.md"));
+  scanCursorRulesDir(skills, path7.join(absProjectPath, ".cursor", "rules"), "project");
+  pushInstructionIfExists(skills, "cursor", "project", path7.join(absProjectPath, ".cursorrules"), "Legacy Cursor Rules", "", "rule");
+  return sortSkills(skills);
+}
+function getGlobalAgentSkills() {
+  const homeDir = process.env.HOME;
+  if (!homeDir)
+    return [];
+  const skills = [];
+  scanClaudeSkillDir(skills, path7.join(homeDir, ".claude", "skills"), "global");
+  scanCursorRulesDir(skills, path7.join(homeDir, ".cursor", "rules"), "global");
+  return sortSkills(skills);
+}
+var AGENT_ORDER, SCOPE_ORDER, KIND_ORDER;
+var init_agent_skills = __esm({
+  "../../packages/shared/dist/node/agent-skills.js"() {
+    "use strict";
+    AGENT_ORDER = {
+      claude_code: 0,
+      codex: 1,
+      cursor: 2
+    };
+    SCOPE_ORDER = {
+      project: 0,
+      global: 1
+    };
+    KIND_ORDER = {
+      skill: 0,
+      rule: 1,
+      instruction: 2
+    };
+  }
+});
+
 // ../../packages/shared/dist/node/index.js
 var init_node = __esm({
   "../../packages/shared/dist/node/index.js"() {
@@ -870,6 +1069,7 @@ var init_node = __esm({
     init_redact();
     init_file_lock();
     init_tmux();
+    init_agent_skills();
     init_error_report();
   }
 });
@@ -889,7 +1089,7 @@ __export(task_state_exports, {
   withTaskYamlLock: () => withTaskYamlLock,
   writeTaskYaml: () => writeTaskYaml
 });
-import fs9 from "fs";
+import fs12 from "fs";
 function readWorkflow(taskYml) {
   return readTaskWorkflow(taskYml);
 }
@@ -898,14 +1098,14 @@ async function updateWorkflow(taskYml, patch) {
 }
 function nextArtifactIndex(taskDir, prefix, ext = "md") {
   const pattern = new RegExp(`^${prefix}-(\\d+).*\\.${ext}$`);
-  const entries = fs9.readdirSync(taskDir);
+  const entries = fs12.readdirSync(taskDir);
   const indices = entries.map((name) => name.match(pattern)?.[1]).filter((v) => v != null).map(Number);
   const next = indices.length > 0 ? Math.max(...indices) + 1 : 1;
   return String(next).padStart(2, "0");
 }
 function latestArtifact(taskDir, pattern) {
-  if (!fs9.existsSync(taskDir)) return null;
-  const matches = fs9.readdirSync(taskDir).filter((name) => pattern.test(name));
+  if (!fs12.existsSync(taskDir)) return null;
+  const matches = fs12.readdirSync(taskDir).filter((name) => pattern.test(name));
   if (matches.length === 0) return null;
   matches.sort();
   return matches[matches.length - 1] || null;
@@ -918,44 +1118,115 @@ var init_task_state2 = __esm({
 });
 
 // src/main.ts
-import { readFileSync } from "fs";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import path25 from "path";
-import { Command as Command23 } from "commander";
-
-// src/commands/source.ts
-import { Command } from "commander";
-import path8 from "path";
-import chalk from "chalk";
+import { Command as Command24 } from "commander";
+import chalk24 from "chalk";
 
 // src/core/config.ts
-import fs from "fs";
-import path from "path";
-import yaml from "js-yaml";
-var CONFIG_DIR = path.join(
-  process.env.HOME || process.env.USERPROFILE || "~",
-  ".config",
-  "task0"
-);
-var CONFIG_FILE = path.join(CONFIG_DIR, "config.yml");
-function ensureConfigDir() {
-  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+init_node();
+import fs8 from "fs";
+import os4 from "os";
+import path8 from "path";
+import yaml4 from "js-yaml";
+function registryDir() {
+  return path8.join(
+    process.env.HOME || process.env.USERPROFILE || os4.homedir(),
+    ".config",
+    "task0"
+  );
+}
+function registryFile() {
+  return path8.join(registryDir(), "config.yml");
+}
+function homeStateFile() {
+  return path8.join(task0Home(), "config.yml");
+}
+function configFilePath() {
+  return registryFile();
+}
+function readYamlFile(file) {
+  if (!fs8.existsSync(file)) return null;
+  try {
+    const raw = fs8.readFileSync(file, "utf-8");
+    const parsed = yaml4.load(raw);
+    return parsed ?? null;
+  } catch {
+    return null;
+  }
+}
+function writeYamlFile(file, data) {
+  fs8.mkdirSync(path8.dirname(file), { recursive: true });
+  fs8.writeFileSync(file, yaml4.dump(data, { lineWidth: 120 }), "utf-8");
+}
+function loadRegistry() {
+  return readYamlFile(registryFile()) ?? {};
+}
+function saveRegistry(data) {
+  writeYamlFile(registryFile(), data);
 }
-function defaultConfig() {
-  return { sources: [] };
+function loadHomeState() {
+  return readYamlFile(homeStateFile()) ?? {};
+}
+function saveHomeState(data) {
+  writeYamlFile(homeStateFile(), data);
 }
 function loadConfig() {
-  if (!fs.existsSync(CONFIG_FILE)) return defaultConfig();
-  const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
-  const data = yaml.load(raw);
+  const registry = loadRegistry();
+  const home = loadHomeState();
+  const profiles = registry.profiles && typeof registry.profiles === "object" && !Array.isArray(registry.profiles) ? registry.profiles : void 0;
+  const current = typeof registry.current_profile === "string" && registry.current_profile.length > 0 ? registry.current_profile : void 0;
+  const sources = Array.isArray(home.sources) ? home.sources : Array.isArray(registry.sources) ? registry.sources : [];
+  const agentModels = home.agentModels !== void 0 ? home.agentModels : registry.agentModels;
   return {
-    ...data ?? {},
-    sources: Array.isArray(data?.sources) ? data.sources : []
+    sources,
+    ...agentModels !== void 0 ? { agentModels } : {},
+    ...profiles ? { profiles } : {},
+    ...current ? { current_profile: current } : {}
   };
 }
 function saveConfig(config) {
-  ensureConfigDir();
-  fs.writeFileSync(CONFIG_FILE, yaml.dump(config, { lineWidth: 120 }), "utf-8");
+  const { sources, agentModels, ...registryFields } = config;
+  saveRegistry(registryFields);
+  saveHomeState({
+    ...sources !== void 0 ? { sources } : {},
+    ...agentModels !== void 0 ? { agentModels } : {}
+  });
+}
+function listProfiles() {
+  return loadConfig().profiles ?? {};
+}
+function getProfile(name) {
+  return listProfiles()[name];
+}
+function getCurrentProfileName() {
+  return loadConfig().current_profile;
+}
+function addProfile(name, entry) {
+  const config = loadConfig();
+  const profiles = { ...config.profiles ?? {} };
+  profiles[name] = entry;
+  config.profiles = profiles;
+  saveConfig(config);
+}
+function removeProfile(name) {
+  const config = loadConfig();
+  if (!config.profiles || !(name in config.profiles)) return false;
+  const profiles = { ...config.profiles };
+  delete profiles[name];
+  config.profiles = profiles;
+  if (config.current_profile === name) {
+    delete config.current_profile;
+  }
+  saveConfig(config);
+  return true;
+}
+function setCurrentProfile(name) {
+  const config = loadConfig();
+  if (name === null) {
+    delete config.current_profile;
+  } else {
+    config.current_profile = name;
+  }
+  saveConfig(config);
 }
 function addSource(entry) {
   const config = loadConfig();
@@ -975,96 +1246,370 @@ function removeSource(name) {
   saveConfig(config);
   return true;
 }
-function getSource(name) {
-  return loadConfig().sources.find((s) => s.name === name);
+
+// src/core/profile.ts
+var ProfileNotFoundError = class extends Error {
+  constructor(name, available) {
+    const list = available.length > 0 ? available.join(", ") : "(none)";
+    super(`Profile "${name}" not found. Available: ${list}. Run "task0 profile list" to inspect.`);
+    this.name = "ProfileNotFoundError";
+  }
+};
+function parseProfileFlag(argv) {
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--") return null;
+    if (arg === "--profile") {
+      const next = argv[i + 1];
+      if (typeof next === "string" && !next.startsWith("-")) return next;
+      return null;
+    }
+    if (typeof arg === "string" && arg.startsWith("--profile=")) {
+      const value = arg.slice("--profile=".length);
+      return value.length > 0 ? value : null;
+    }
+  }
+  return null;
+}
+function isProfileSubcommandInvocation(argv) {
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--") break;
+    if (typeof arg !== "string") continue;
+    if (arg.startsWith("-")) {
+      if (arg === "--profile" || arg === "-C") i++;
+      continue;
+    }
+    return arg === "profile";
+  }
+  return true;
+}
+function resolveActiveProfile(flagValue) {
+  const requested = flagValue ?? getCurrentProfileName() ?? null;
+  if (!requested) return null;
+  const entry = getProfile(requested);
+  if (!entry) {
+    throw new ProfileNotFoundError(requested, Object.keys(listProfiles()));
+  }
+  return { name: requested, entry };
+}
+var activeProfileCache = null;
+function activateProfile(argv) {
+  const flagValue = parseProfileFlag(argv);
+  let active2;
+  try {
+    active2 = resolveActiveProfile(flagValue);
+  } catch (error2) {
+    if (isProfileSubcommandInvocation(argv) && error2 instanceof ProfileNotFoundError && flagValue === null) {
+      active2 = null;
+    } else {
+      throw error2;
+    }
+  }
+  if (active2) {
+    activeProfileCache = active2;
+    if (active2.entry.task0_home && active2.entry.task0_home.length > 0) {
+      process.env.TASK0_HOME = active2.entry.task0_home;
+    }
+    if (active2.entry.api_url && !process.env.TASK0_API_URL) {
+      process.env.TASK0_API_URL = active2.entry.api_url;
+    }
+  }
 }
 
 // src/commands/source.ts
-init_node();
+import { Command } from "commander";
+import path11 from "path";
+import chalk from "chalk";
 
 // src/types.ts
 init_task();
 
+// src/core/admin-token.ts
+init_node();
+import fs9 from "fs";
+import path9 from "path";
+function tokenFile() {
+  return path9.join(task0Home(), "admin.token");
+}
+var cached = null;
+var AdminTokenUnavailableError = class extends Error {
+  constructor() {
+    super(
+      `Admin token not found.
+  \u2022 If the task0 server runs on this host, run the task0-server binary once \u2014 the token will be generated at ${tokenFile()}.
+  \u2022 Otherwise, copy the token from the server host and set TASK0_ADMIN_TOKEN.`
+    );
+    this.name = "AdminTokenUnavailableError";
+  }
+};
+function readAdminToken() {
+  if (cached) return cached;
+  const fromEnv = process.env.TASK0_ADMIN_TOKEN?.trim();
+  if (fromEnv) {
+    cached = fromEnv;
+    return cached;
+  }
+  const file = tokenFile();
+  if (fs9.existsSync(file)) {
+    const v = fs9.readFileSync(file, "utf-8").trim();
+    if (v) {
+      cached = v;
+      return cached;
+    }
+  }
+  throw new AdminTokenUnavailableError();
+}
+function adminAuthHeader() {
+  return { authorization: `Bearer ${readAdminToken()}` };
+}
+
+// src/core/daemon-config.ts
+init_node();
+import fs10 from "fs";
+import path10 from "path";
+function configDir() {
+  return task0Home();
+}
+function configFile() {
+  return path10.join(configDir(), "daemon.json");
+}
+function daemonConfigPath() {
+  return configFile();
+}
+function readDaemonIdentity() {
+  const file = configFile();
+  if (!fs10.existsSync(file)) return null;
+  try {
+    const raw = fs10.readFileSync(file, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function writeDaemonIdentity(identity) {
+  const file = configFile();
+  fs10.mkdirSync(configDir(), { recursive: true });
+  fs10.writeFileSync(file, JSON.stringify(identity, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
+  try {
+    fs10.chmodSync(file, 384);
+  } catch {
+  }
+}
+function clearDaemonIdentity() {
+  const file = configFile();
+  if (!fs10.existsSync(file)) return false;
+  fs10.unlinkSync(file);
+  return true;
+}
+
+// src/core/hub-client.ts
+var HubUnreachableError = class extends Error {
+  constructor(url, cause) {
+    super(`Cannot reach hub at ${url}: ${cause instanceof Error ? cause.message : String(cause)}`);
+    this.name = "HubUnreachableError";
+  }
+};
+var HubResponseError = class extends Error {
+  status;
+  code;
+  body;
+  constructor(status, body, code) {
+    super(`Hub returned ${status}: ${body}`);
+    this.name = "HubResponseError";
+    this.status = status;
+    this.code = code;
+    this.body = body;
+  }
+};
+function resolveHubUrl() {
+  const fromEnv = process.env.TASK0_API_URL?.trim();
+  if (fromEnv) return fromEnv.replace(/\/$/, "");
+  const identity = readDaemonIdentity();
+  if (identity?.server_url) return identity.server_url.replace(/\/$/, "");
+  return "http://127.0.0.1:4318";
+}
+function resolveAuthHeader() {
+  const apiToken = process.env.TASK0_API_TOKEN?.trim();
+  if (apiToken) return { authorization: `Bearer ${apiToken}` };
+  try {
+    return adminAuthHeader();
+  } catch (error2) {
+    if (error2 instanceof AdminTokenUnavailableError) {
+      throw new Error(
+        `No CLI credential available. Set TASK0_API_TOKEN (preferred \u2014 issue one via the dashboard) or place a server admin token at ${error2.message.includes(".token") ? error2.message.split("at ")[1]?.split(".")[0] + ".token" : "~/.task0/admin.token"}.`
+      );
+    }
+    throw error2;
+  }
+}
+async function callHub(pathname, opts = {}) {
+  const base = resolveHubUrl();
+  const url = new URL(pathname.startsWith("/") ? pathname : `/${pathname}`, base + "/");
+  for (const [k, v] of Object.entries(opts.query ?? {})) {
+    if (v !== void 0) url.searchParams.set(k, v);
+  }
+  const init = {
+    method: opts.method ?? "GET",
+    headers: {
+      ...resolveAuthHeader(),
+      ...opts.body !== void 0 ? { "content-type": "application/json" } : {}
+    }
+  };
+  if (opts.body !== void 0) init.body = JSON.stringify(opts.body);
+  if (opts.timeoutMs) init.signal = AbortSignal.timeout(opts.timeoutMs);
+  let res;
+  try {
+    res = await fetch(url, init);
+  } catch (error2) {
+    throw new HubUnreachableError(url.toString(), error2);
+  }
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    let code = null;
+    try {
+      const parsed = JSON.parse(body);
+      if (typeof parsed?.code === "string") code = parsed.code;
+    } catch {
+    }
+    throw new HubResponseError(res.status, body, code);
+  }
+  if (res.status === 204) return void 0;
+  const text = await res.text();
+  if (!text) return void 0;
+  return JSON.parse(text);
+}
+function localDaemonId() {
+  const identity = readDaemonIdentity();
+  return identity?.daemon_id ?? null;
+}
+
 // src/commands/source.ts
-var source = new Command("source").description("Manage task sources");
-source.command("add <path>").description("Add a local project as task source").option("-n, --name <name>", "Source name (defaults to directory name)").action((inputPath, opts) => {
-  const absPath = path8.resolve(inputPath);
-  const name = opts.name || path8.basename(absPath);
-  const result = scanProject(absPath);
-  if (result.errors.length > 0 && result.tasks.length === 0) {
-    for (const err of result.errors) console.error(chalk.red(`  error: ${err}`));
+function reportHubError(error2) {
+  if (error2 instanceof HubUnreachableError) {
+    console.error(chalk.red(error2.message));
+    console.error(chalk.dim("Tip: ensure the hub is running and TASK0_API_URL points to it."));
+    process.exit(1);
+  }
+  if (error2 instanceof HubResponseError) {
+    console.error(chalk.red(`Hub error (${error2.status}): ${error2.body || "(empty body)"}`));
+    process.exit(1);
+  }
+  throw error2;
+}
+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."));
     process.exit(1);
   }
-  addSource({ name, type: "project", path: absPath, enabled: true });
+  return id;
+}
+var source = new Command("source").description("Manage task sources");
+source.command("add <path>").description("Register a local project on this host's daemon (via hub)").option("-n, --name <name>", "Source name (defaults to directory name)").action(async (inputPath, opts) => {
+  const absPath = path11.resolve(inputPath);
+  const name = opts.name || path11.basename(absPath);
+  const daemonId = requireLocalDaemon();
+  let resp;
+  try {
+    resp = await callHub(`/api/daemons/${encodeURIComponent(daemonId)}/projects`, {
+      method: "POST",
+      body: { path: absPath, name }
+    });
+  } catch (error2) {
+    reportHubError(error2);
+  }
   console.log(chalk.green(`Added source "${name}" \u2192 ${absPath}`));
-  console.log(`  ${result.tasks.length} tasks found`);
-  if (result.errors.length > 0) {
-    for (const err of result.errors) console.warn(chalk.yellow(`  warn: ${err}`));
+  if (typeof resp.taskCount === "number") {
+    console.log(`  ${resp.taskCount} tasks found`);
   }
 });
-source.command("list").description("List registered task sources").action(() => {
-  const config = loadConfig();
-  if (config.sources.length === 0) {
+source.command("list").description("List registered task sources (queries the hub)").action(async () => {
+  let data;
+  try {
+    data = await callHub("/api/config");
+  } catch (error2) {
+    if (error2 instanceof HubUnreachableError) {
+      console.error(chalk.red(error2.message));
+      console.error(chalk.dim("Tip: ensure the hub is running and TASK0_API_URL points to it."));
+      process.exit(1);
+    }
+    if (error2 instanceof HubResponseError) {
+      console.error(chalk.red(`Hub error (${error2.status}): ${error2.body || "(empty body)"}`));
+      process.exit(1);
+    }
+    throw error2;
+  }
+  if (data.sources.length === 0) {
     console.log("No sources registered. Use `task0 source add <path>` to add one.");
     return;
   }
-  for (const s of config.sources) {
+  for (const s of data.sources) {
     const status = s.enabled ? chalk.green("\u25CF") : chalk.dim("\u25CB");
-    console.log(`${status} ${s.name}  ${chalk.dim(s.type)}  ${s.path}`);
-  }
-});
-source.command("remove <name>").description("Remove a task source").action((name) => {
-  if (removeSource(name)) {
-    console.log(chalk.green(`Removed source "${name}"`));
-  } else {
-    console.error(chalk.red(`Source "${name}" not found`));
-    process.exit(1);
+    const where = s.path ?? (s.type === "github" ? "(github)" : s.type === "linear" ? "(linear)" : "");
+    const owner = s.daemon_id ? chalk.dim(` @${s.daemon_id}`) : "";
+    console.log(`${status} ${s.name}  ${chalk.dim(s.type)}  ${where}${owner}`);
   }
 });
-source.command("scan [name]").description("Scan source(s) and display tasks").option("--json", "Output as JSON").action((name, opts) => {
-  const config = loadConfig();
-  const sources = name ? (() => {
-    const s = getSource(name);
-    if (!s) {
-      console.error(chalk.red(`Source "${name}" not found`));
+source.command("remove <name>").description("Remove a project source from this host's daemon (via hub)").action(async (name) => {
+  const daemonId = requireLocalDaemon();
+  try {
+    await callHub(`/api/daemons/${encodeURIComponent(daemonId)}/projects/${encodeURIComponent(name)}`, {
+      method: "DELETE"
+    });
+  } catch (error2) {
+    if (error2 instanceof HubResponseError && error2.status === 404) {
+      console.error(chalk.red(`Source "${name}" not found on this daemon.`));
       process.exit(1);
     }
-    return [s];
-  })() : config.sources.filter((s) => s.enabled);
-  if (sources.length === 0) {
-    console.log("No sources to scan.");
+    reportHubError(error2);
+  }
+  console.log(chalk.green(`Removed source "${name}"`));
+});
+source.command("scan [name]").description("Scan source(s) via the hub and display tasks").option("--json", "Output as JSON").action(async (name, opts) => {
+  let data;
+  try {
+    data = await callHub("/api/tasks", { query: { source: name } });
+  } catch (error2) {
+    reportHubError(error2);
+  }
+  if (data.tasks.length === 0) {
+    console.log(name ? `No tasks in source "${name}".` : "No tasks.");
     return;
   }
-  const allTasks = [];
-  for (const s of sources) {
-    const result = scanProject(s.path, s.name);
-    if (opts.json) {
-      allTasks.push(...result.tasks.map((t) => ({ ...t, _source: s.name })));
-    } else {
-      console.log(chalk.bold(`
-${s.name}`) + chalk.dim(` (${s.path})`));
-      if (result.errors.length > 0) {
-        for (const err of result.errors) console.warn(chalk.yellow(`  warn: ${err}`));
-      }
-      const objectIdWidth = Math.max(...result.tasks.map((t) => (t.object_id || "").length), 9);
-      for (const t of result.tasks) {
-        const statusColor2 = isActiveTaskStatus(t.status) ? chalk.green : t.status === "blocked" ? chalk.red : t.status === "todo" ? chalk.yellow : t.status === "done" ? chalk.dim : chalk.white;
-        const objectId = chalk.cyan((t.object_id || "-").padEnd(objectIdWidth));
-        console.log(`  ${objectId}  ${statusColor2(t.status.padEnd(8))}  ${chalk.dim(t.id)}  ${t.title}`);
-      }
-      console.log(chalk.dim(`  ${result.tasks.length} tasks`));
+  if (opts.json) {
+    const out = data.tasks.map((t) => ({ ...t, _source: t.project }));
+    console.log(JSON.stringify(out, null, 2));
+    return;
+  }
+  const byProject = /* @__PURE__ */ new Map();
+  for (const t of data.tasks) {
+    const list = byProject.get(t.project) ?? [];
+    list.push(t);
+    byProject.set(t.project, list);
+  }
+  for (const [project2, tasks] of byProject) {
+    console.log(chalk.bold(`
+${project2}`));
+    const objectIdWidth = Math.max(...tasks.map((t) => (t.object_id || "").length), 9);
+    for (const t of tasks) {
+      const statusColor2 = isActiveTaskStatus(t.status) ? chalk.green : t.status === "blocked" ? chalk.red : t.status === "todo" ? chalk.yellow : t.status === "done" ? chalk.dim : chalk.white;
+      const objectId = chalk.cyan((t.object_id || "-").padEnd(objectIdWidth));
+      console.log(`  ${objectId}  ${statusColor2(t.status.padEnd(8))}  ${chalk.dim(t.id)}  ${t.title}`);
     }
+    console.log(chalk.dim(`  ${tasks.length} tasks`));
   }
-  if (opts.json) {
-    console.log(JSON.stringify(allTasks, null, 2));
+  if (data.errors.length > 0) {
+    for (const err of data.errors) console.warn(chalk.yellow(`warn: ${err}`));
   }
 });
 
 // src/commands/project.ts
 import { Command as Command2 } from "commander";
-import fs8 from "fs";
-import path9 from "path";
-import yaml4 from "js-yaml";
+import fs11 from "fs";
+import path12 from "path";
+import yaml5 from "js-yaml";
 import chalk2 from "chalk";
 
 // ../../packages/shared/dist/index.js
@@ -1072,44 +1617,45 @@ init_object_id();
 
 // src/commands/project.ts
 var project = new Command2("project").description("Manage projects");
-function readProjectObjectId(projectPath) {
-  const ymlPath = path9.join(projectPath, "task0.yml");
-  if (!fs8.existsSync(ymlPath)) return "-";
+project.command("list").description("List registered projects (queries the hub)").action(async () => {
+  let data;
   try {
-    const raw = yaml4.load(fs8.readFileSync(ymlPath, "utf-8"));
-    const id = raw && typeof raw.object_id === "string" ? raw.object_id : "";
-    return id || "-";
-  } catch {
-    return "-";
+    data = await callHub("/api/config");
+  } catch (error2) {
+    if (error2 instanceof HubUnreachableError) {
+      console.error(chalk2.red(error2.message));
+      process.exit(1);
+    }
+    if (error2 instanceof HubResponseError) {
+      console.error(chalk2.red(`Hub error (${error2.status}): ${error2.body || "(empty body)"}`));
+      process.exit(1);
+    }
+    throw error2;
   }
-}
-project.command("list").description("List registered projects").action(() => {
-  const projects = loadConfig().sources.filter((s) => s.type === "project");
+  const projects = data.sources.filter((s) => s.type === "project");
   if (projects.length === 0) {
     console.log("No projects registered. Use `task0 source add <path>` to add one.");
     return;
   }
-  const rows = projects.map((p) => ({ p, objectId: readProjectObjectId(p.path) }));
-  const objectIdWidth = Math.max(...rows.map((r) => r.objectId.length), 9);
-  const nameWidth = Math.max(...rows.map((r) => r.p.name.length), 4);
-  for (const { p, objectId } of rows) {
+  const nameWidth = Math.max(...projects.map((p) => p.name.length), 4);
+  for (const p of projects) {
     const status = p.enabled ? chalk2.green("\u25CF") : chalk2.dim("\u25CB");
-    const oid = chalk2.cyan(objectId.padEnd(objectIdWidth));
     const name = p.name.padEnd(nameWidth);
-    console.log(`${status} ${oid}  ${name}  ${chalk2.dim(p.path)}`);
+    const owner = p.daemon_id ? chalk2.dim(` @${p.daemon_id}`) : "";
+    console.log(`${status} ${name}  ${chalk2.dim(p.path ?? "")}${owner}`);
   }
 });
 project.command("init").description("Initialize task0.yml in the current directory").option("-d, --tasks-dir <dir>", "Tasks directory", ".task0/tasks").action((opts) => {
   const cwd = process.cwd();
-  const ymlPath = path9.join(cwd, "task0.yml");
-  if (fs8.existsSync(ymlPath)) {
+  const ymlPath = path12.join(cwd, "task0.yml");
+  if (fs11.existsSync(ymlPath)) {
     console.error(chalk2.yellow("task0.yml already exists"));
     process.exit(1);
   }
   const config = { kind: "project", object_id: generateObjectId("project"), tasks_dir: opts.tasksDir };
-  fs8.writeFileSync(ymlPath, yaml4.dump(config), "utf-8");
-  const tasksDir = path9.join(cwd, opts.tasksDir);
-  fs8.mkdirSync(tasksDir, { recursive: true });
+  fs11.writeFileSync(ymlPath, yaml5.dump(config), "utf-8");
+  const tasksDir = path12.join(cwd, opts.tasksDir);
+  fs11.mkdirSync(tasksDir, { recursive: true });
   console.log(chalk2.green("Initialized task0 project"));
   console.log(`  ${ymlPath}`);
   console.log(`  ${tasksDir}/`);
@@ -1118,61 +1664,57 @@ project.command("init").description("Initialize task0.yml in the current directo
 // src/commands/task.ts
 import { Command as Command8 } from "commander";
 import { execSync } from "child_process";
-import fs14 from "fs";
-import path12 from "path";
-import yaml5 from "js-yaml";
+import fs17 from "fs";
+import path15 from "path";
+import yaml6 from "js-yaml";
 import chalk8 from "chalk";
 
 // src/lib/api.ts
-var DEFAULT_BASE = "http://127.0.0.1:4318";
 function apiBaseUrl() {
-  return process.env.TASK0_API_URL || DEFAULT_BASE;
+  return process.env.TASK0_API_URL || "http://127.0.0.1:4318";
 }
-async function request(method, pathname, body) {
-  const url = apiBaseUrl().replace(/\/$/, "") + pathname;
-  let res;
-  try {
-    res = await fetch(url, {
-      method,
-      headers: body !== void 0 ? { "content-type": "application/json" } : void 0,
-      body: body !== void 0 ? JSON.stringify(body) : void 0
-    });
-  } catch (error2) {
+function toApiError(method, pathname, error2) {
+  if (error2 instanceof HubUnreachableError) {
     const err = new Error(
       `Cannot reach task0 API at ${apiBaseUrl()}. Start the task0-server binary (download from GitHub Releases) or repoint TASK0_API_URL.`
     );
     err.cause = error2;
-    throw err;
+    return err;
   }
-  const text = await res.text();
-  let parsed = null;
-  try {
-    parsed = text ? JSON.parse(text) : null;
-  } catch {
-    parsed = text;
+  if (error2 instanceof HubResponseError) {
+    let parsedBody = error2.body;
+    try {
+      parsedBody = error2.body ? JSON.parse(error2.body) : null;
+    } catch {
+    }
+    const message = parsedBody?.error || error2.body || error2.message;
+    const err = new Error(`API ${method} ${pathname} failed (${error2.status}): ${message}`);
+    err.status = error2.status;
+    err.body = parsedBody;
+    return err;
   }
-  if (!res.ok) {
-    const message = parsed?.error || text || res.statusText;
-    const err = new Error(`API ${method} ${pathname} failed (${res.status}): ${message}`);
-    err.status = res.status;
-    err.body = parsed;
-    throw err;
+  return error2 instanceof Error ? error2 : new Error(String(error2));
+}
+async function request(method, pathname, body) {
+  try {
+    return await callHub(pathname, { method, body });
+  } catch (error2) {
+    throw toApiError(method, pathname, error2);
   }
-  return parsed;
 }
 var api = {
-  get: (path26) => request("GET", path26),
-  post: (path26, body) => request("POST", path26, body ?? {}),
-  put: (path26, body) => request("PUT", path26, body ?? {}),
-  patch: (path26, body) => request("PATCH", path26, body ?? {}),
-  del: (path26) => request("DELETE", path26)
+  get: (path31) => request("GET", path31),
+  post: (path31, body) => request("POST", path31, body ?? {}),
+  put: (path31, body) => request("PUT", path31, body ?? {}),
+  patch: (path31, body) => request("PATCH", path31, body ?? {}),
+  del: (path31) => request("DELETE", path31)
 };
 
 // src/commands/task/triage.ts
 import { Command as Command3 } from "commander";
 import chalk3 from "chalk";
-import fs10 from "fs";
-import path10 from "path";
+import fs13 from "fs";
+import path13 from "path";
 
 // src/core/agent-run-wait.ts
 async function getAgentRun(id) {
@@ -1223,8 +1765,8 @@ init_task_state2();
 var ISSUE_DETAIL_RE = /^ISSUE-\d+\.md$/;
 var TRIAGE_SKILL_NAME = "triage";
 function resolveSkillFilePath(projectRoot, skillName) {
-  const p = path10.join(projectRoot, ".claude", "skills", skillName, "SKILL.md");
-  return fs10.existsSync(p) ? p : null;
+  const p = path13.join(projectRoot, ".claude", "skills", skillName, "SKILL.md");
+  return fs13.existsSync(p) ? p : null;
 }
 var triage = new Command3("triage").description("Decompose IDEA into ISSUE.md + ISSUE-NN.md").argument("<objectId>", "Task object_id (tsk_XXXXX)").option("--agent <name>", "Agent (claude-code|codex)", "claude-code").option("--model <id>", "Model id or alias (see `task0 models refresh`)").option("--effort <level>", "Reasoning effort (e.g. low|medium|high)").option("--idea <file>", "IDEA file (default: latest IDEA-NN.md)").option("--force", "Overwrite existing ISSUE files").option("--wait", "Wait for completion").option("--json", "Output JSON").action(async (objectId, opts) => {
   try {
@@ -1243,7 +1785,7 @@ var triage = new Command3("triage").description("Decompose IDEA into ISSUE.md +
         process.exit(1);
       }
       for (const name of existingIssues) {
-        fs10.rmSync(path10.join(loc.taskDir, name), { force: true });
+        fs13.rmSync(path13.join(loc.taskDir, name), { force: true });
       }
     }
     if (opts.model || opts.effort) {
@@ -1281,8 +1823,8 @@ var triage = new Command3("triage").description("Decompose IDEA into ISSUE.md +
         console.error(chalk3.red(`triage failed: ${final.error || "unknown"}`));
         process.exit(1);
       }
-      const hasOverview = fs10.existsSync(path10.join(loc.taskDir, "ISSUE.md"));
-      const issueFiles = fs10.readdirSync(loc.taskDir).filter((name) => ISSUE_DETAIL_RE.test(name)).sort();
+      const hasOverview = fs13.existsSync(path13.join(loc.taskDir, "ISSUE.md"));
+      const issueFiles = fs13.readdirSync(loc.taskDir).filter((name) => ISSUE_DETAIL_RE.test(name)).sort();
       if (!hasOverview || issueFiles.length === 0) {
         const missing = [];
         if (!hasOverview) missing.push("ISSUE.md");
@@ -1292,7 +1834,7 @@ var triage = new Command3("triage").description("Decompose IDEA into ISSUE.md +
       }
       let blockingQuestionCount = 0;
       for (const name of issueFiles) {
-        const content = fs10.readFileSync(path10.join(loc.taskDir, name), "utf-8");
+        const content = fs13.readFileSync(path13.join(loc.taskDir, name), "utf-8");
         blockingQuestionCount += countBlockingQuestions(content);
       }
       await updateWorkflow(loc.taskYml, {
@@ -1320,8 +1862,8 @@ var triage = new Command3("triage").description("Decompose IDEA into ISSUE.md +
   }
 });
 function listIssueArtifacts(taskDir) {
-  if (!fs10.existsSync(taskDir)) return [];
-  return fs10.readdirSync(taskDir).filter((name) => name === "ISSUE.md" || ISSUE_DETAIL_RE.test(name)).sort();
+  if (!fs13.existsSync(taskDir)) return [];
+  return fs13.readdirSync(taskDir).filter((name) => name === "ISSUE.md" || ISSUE_DETAIL_RE.test(name)).sort();
 }
 function countBlockingQuestions(md) {
   const match = md.match(/## Open Questions\s*\n([\s\S]*?)(\n## |\n*$)/i);
@@ -1335,13 +1877,13 @@ function countBlockingQuestions(md) {
 // src/commands/task/exec.ts
 import { Command as Command4 } from "commander";
 import chalk4 from "chalk";
-import fs11 from "fs";
-import path11 from "path";
+import fs14 from "fs";
+import path14 from "path";
 init_task_state2();
 var PLAN_EXECUTE_SKILL_NAME = "plan-execute";
 function resolveSkillFilePath2(projectRoot, skillName) {
-  const p = path11.join(projectRoot, ".claude", "skills", skillName, "SKILL.md");
-  return fs11.existsSync(p) ? p : null;
+  const p = path14.join(projectRoot, ".claude", "skills", skillName, "SKILL.md");
+  return fs14.existsSync(p) ? p : null;
 }
 var exec = new Command4("exec").description("Execute a plan against the task (cwd = project root; agent sets up its own worktree if needed)").argument("<objectId>", "Task object_id (tsk_XXXXX)").option("--agent <name>", "Agent (claude-code|codex|cursor)", "claude-code").option("--model <id>", "Model id or alias (see `task0 models refresh`)").option("--effort <level>", "Reasoning effort (e.g. low|medium|high)").option("--plan <file>", "Plan file (default: refined plan, else latest PLAN)").option("--no-commit", "Skip commit").option("--wait", "Wait for completion").option("--json", "Output JSON").action(async (objectId, opts) => {
   try {
@@ -1434,7 +1976,7 @@ var summarize = new Command5("summarize").description("Generate a concise title
 });
 
 // src/commands/task/comment.ts
-import fs12 from "fs";
+import fs15 from "fs";
 import { Command as Command6 } from "commander";
 import chalk6 from "chalk";
 var comment = new Command6("comment").description("Manage comments on a task");
@@ -1444,8 +1986,8 @@ function fail(err) {
 }
 function readBodyFromOpts(opts) {
   if (opts.body !== void 0) return opts.body;
-  if (opts.file === "-") return fs12.readFileSync(0, "utf-8");
-  if (opts.file) return fs12.readFileSync(opts.file, "utf-8");
+  if (opts.file === "-") return fs15.readFileSync(0, "utf-8");
+  if (opts.file) return fs15.readFileSync(opts.file, "utf-8");
   throw new Error("Provide --body or --file");
 }
 function preview(body, width = 60) {
@@ -1544,7 +2086,7 @@ comment.command("delete <cmtId>").description("Delete a comment by its cmt_ id")
 });
 
 // src/commands/task/description.ts
-import fs13 from "fs";
+import fs16 from "fs";
 import { Command as Command7 } from "commander";
 import chalk7 from "chalk";
 var description = new Command7("description").description("Show or update the task description");
@@ -1554,8 +2096,8 @@ function fail2(err) {
 }
 function readBodyFromOpts2(opts) {
   if (opts.body !== void 0) return opts.body;
-  if (opts.file === "-") return fs13.readFileSync(0, "utf-8");
-  if (opts.file) return fs13.readFileSync(opts.file, "utf-8");
+  if (opts.file === "-") return fs16.readFileSync(0, "utf-8");
+  if (opts.file) return fs16.readFileSync(opts.file, "utf-8");
   throw new Error("Provide --body or --file (use --file - to read stdin)");
 }
 description.command("show <taskId>").description("Print the current description (taskId is short id or tsk_)").option("--json", "Output JSON").action(async (taskId, opts) => {
@@ -1604,12 +2146,12 @@ task.addCommand(comment);
 task.addCommand(description);
 task.command("init <input>").description("Create a task from a description or Linear/GitHub issue URL").action(async (input) => {
   const cwd = process.cwd();
-  const projectYml = path12.join(cwd, "task0.yml");
-  if (!fs14.existsSync(projectYml)) {
+  const projectYml = path15.join(cwd, "task0.yml");
+  if (!fs17.existsSync(projectYml)) {
     console.error(chalk8.red("Not a task0 project (task0.yml not found). Run `task0 project init` first."));
     process.exit(1);
   }
-  const projectConfig = yaml5.load(fs14.readFileSync(projectYml, "utf-8"));
+  const projectConfig = yaml6.load(fs17.readFileSync(projectYml, "utf-8"));
   if (projectConfig.kind !== "project") {
     console.error(chalk8.red('Invalid task0.yml: kind is not "project"'));
     process.exit(1);
@@ -1625,38 +2167,38 @@ task.command("init <input>").description("Create a task from a description or Li
 });
 task.command("migrate").description("Add task0.yml to legacy task directories that lack one").option("--dry-run", "Show what would be created without writing").action((opts) => {
   const cwd = process.cwd();
-  const projectYml = path12.join(cwd, "task0.yml");
-  if (!fs14.existsSync(projectYml)) {
+  const projectYml = path15.join(cwd, "task0.yml");
+  if (!fs17.existsSync(projectYml)) {
     console.error(chalk8.red("Not a task0 project (task0.yml not found). Run `task0 project init` first."));
     process.exit(1);
   }
-  const projectConfig = yaml5.load(fs14.readFileSync(projectYml, "utf-8"));
+  const projectConfig = yaml6.load(fs17.readFileSync(projectYml, "utf-8"));
   if (projectConfig.kind !== "project") {
     console.error(chalk8.red('Invalid task0.yml: kind is not "project"'));
     process.exit(1);
   }
-  const tasksDir = path12.join(cwd, projectConfig.tasks_dir);
-  if (!fs14.existsSync(tasksDir)) {
+  const tasksDir = path15.join(cwd, projectConfig.tasks_dir);
+  if (!fs17.existsSync(tasksDir)) {
     console.error(chalk8.red(`Tasks directory not found: ${tasksDir}`));
     process.exit(1);
   }
-  const entries = fs14.readdirSync(tasksDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  const entries = fs17.readdirSync(tasksDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
   let migrated = 0;
   let skipped = 0;
   let seededObjectIds = 0;
   for (const name of entries) {
-    const taskDir = path12.join(tasksDir, name);
-    const taskYml = path12.join(taskDir, "task0.yml");
-    if (fs14.existsSync(taskYml)) {
+    const taskDir = path15.join(tasksDir, name);
+    const taskYml = path15.join(taskDir, "task0.yml");
+    if (fs17.existsSync(taskYml)) {
       skipped++;
       try {
-        const raw = yaml5.load(fs14.readFileSync(taskYml, "utf-8"));
+        const raw = yaml6.load(fs17.readFileSync(taskYml, "utf-8"));
         if (raw && raw.kind === "task" && !raw.object_id) {
           raw.object_id = generateObjectId("task");
           if (opts.dryRun) {
             console.log(chalk8.dim(`[dry-run] seed object_id: ${taskYml}`));
           } else {
-            fs14.writeFileSync(taskYml, yaml5.dump(raw, { lineWidth: 120 }), "utf-8");
+            fs17.writeFileSync(taskYml, yaml6.dump(raw, { lineWidth: 120 }), "utf-8");
             console.log(chalk8.green(`  seed object_id: ${taskYml}`));
           }
           seededObjectIds++;
@@ -1681,7 +2223,7 @@ task.command("migrate").description("Add task0.yml to legacy task directories th
     if (opts.dryRun) {
       console.log(chalk8.dim(`[dry-run] ${taskYml}`));
     } else {
-      fs14.writeFileSync(taskYml, yaml5.dump(taskConfig), "utf-8");
+      fs17.writeFileSync(taskYml, yaml6.dump(taskConfig), "utf-8");
       console.log(chalk8.green(`  ${taskYml}`));
     }
     migrated++;
@@ -1741,7 +2283,7 @@ task.command("done <id>").description("Write task lifecycle state to task0.yml \
   try {
     const { resolveTaskByObjectId: resolveTaskByObjectId2 } = await Promise.resolve().then(() => (init_task_state2(), task_state_exports));
     const loc = resolveTaskByObjectId2(id);
-    const raw = yaml5.load(fs14.readFileSync(loc.taskYml, "utf-8"));
+    const raw = yaml6.load(fs17.readFileSync(loc.taskYml, "utf-8"));
     if (opts.phase) {
       const phase = opts.phase.trim();
       if (!phase) {
@@ -1754,7 +2296,7 @@ task.command("done <id>").description("Write task lifecycle state to task0.yml \
         return;
       }
       raw.workflow = { ...workflow2, phase };
-      fs14.writeFileSync(loc.taskYml, yaml5.dump(raw, { lineWidth: 120 }), "utf-8");
+      fs17.writeFileSync(loc.taskYml, yaml6.dump(raw, { lineWidth: 120 }), "utf-8");
       console.log(chalk8.green(`${id} phase: ${phase}`));
       return;
     }
@@ -1765,7 +2307,7 @@ task.command("done <id>").description("Write task lifecycle state to task0.yml \
     raw.status = "done";
     const workflow = raw.workflow ?? {};
     raw.workflow = { ...workflow, phase: "completed" };
-    fs14.writeFileSync(loc.taskYml, yaml5.dump(raw, { lineWidth: 120 }), "utf-8");
+    fs17.writeFileSync(loc.taskYml, yaml6.dump(raw, { lineWidth: 120 }), "utf-8");
     console.log(chalk8.green(`${id} marked as done`));
   } catch (err) {
     console.error(chalk8.red(err.message));
@@ -1774,33 +2316,33 @@ task.command("done <id>").description("Write task lifecycle state to task0.yml \
 });
 task.command("archive <id>").description("Archive a task (append to tasks.tar, remove from tasks/)").action((id) => {
   const cwd = process.cwd();
-  const projectYml = path12.join(cwd, "task0.yml");
-  if (!fs14.existsSync(projectYml)) {
+  const projectYml = path15.join(cwd, "task0.yml");
+  if (!fs17.existsSync(projectYml)) {
     console.error(chalk8.red("Not a task0 project (task0.yml not found)."));
     process.exit(1);
   }
-  const projectConfig = yaml5.load(fs14.readFileSync(projectYml, "utf-8"));
+  const projectConfig = yaml6.load(fs17.readFileSync(projectYml, "utf-8"));
   if (projectConfig.kind !== "project") {
     console.error(chalk8.red('Invalid task0.yml: kind is not "project"'));
     process.exit(1);
   }
-  const tasksDir = path12.join(cwd, projectConfig.tasks_dir);
-  const taskDir = path12.join(tasksDir, id);
-  if (!fs14.existsSync(taskDir)) {
+  const tasksDir = path15.join(cwd, projectConfig.tasks_dir);
+  const taskDir = path15.join(tasksDir, id);
+  if (!fs17.existsSync(taskDir)) {
     console.error(chalk8.red(`Task "${id}" not found at ${taskDir}`));
     process.exit(1);
   }
   const tarFile = tasksDir + ".tar";
   archiveTaskToTar(tasksDir, id, tarFile);
-  fs14.rmSync(taskDir, { recursive: true });
+  fs17.rmSync(taskDir, { recursive: true });
   console.log(chalk8.green(`Archived "${id}" \u2192 ${tarFile}`));
 });
 function archiveTaskToTar(tasksDir, taskId, tarFile) {
-  if (fs14.existsSync(tarFile) && !fs14.statSync(tarFile).isFile()) {
+  if (fs17.existsSync(tarFile) && !fs17.statSync(tarFile).isFile()) {
     console.error(chalk8.red(`${tarFile} exists but is not a file (likely a leftover directory). Remove it manually first.`));
     process.exit(1);
   }
-  if (fs14.existsSync(tarFile)) {
+  if (fs17.existsSync(tarFile)) {
     execSync(`tar -rf ${JSON.stringify(tarFile)} -C ${JSON.stringify(tasksDir)} ${JSON.stringify(taskId)}`);
   } else {
     execSync(`tar -cf ${JSON.stringify(tarFile)} -C ${JSON.stringify(tasksDir)} ${JSON.stringify(taskId)}`);
@@ -1810,9 +2352,9 @@ function archiveTaskToTar(tasksDir, taskId, tarFile) {
 // src/commands/ui.ts
 import { Command as Command9 } from "commander";
 import { spawn } from "child_process";
-import path13 from "path";
+import path16 from "path";
 import chalk9 from "chalk";
-var DASHBOARD_DIR = path13.resolve(
+var DASHBOARD_DIR = path16.resolve(
   import.meta.dirname,
   "..",
   "..",
@@ -1846,17 +2388,17 @@ import chalk10 from "chalk";
 // ../../packages/shared/dist/types/agent.js
 var AGENT_KINDS = ["coding", "llm_api", "workflow"];
 var AGENT_KIND_SET = new Set(AGENT_KINDS);
-var CODING_RUNTIME_AGENTS = ["claude-code", "codex", "cursor"];
-var CODING_RUNTIME_AGENT_SET = new Set(CODING_RUNTIME_AGENTS);
-function isCodingRuntimeAgent(value) {
-  return typeof value === "string" && CODING_RUNTIME_AGENT_SET.has(value);
+var AGENT_PROVIDERS = ["claude-code", "codex", "cursor-agent"];
+var AGENT_PROVIDER_SET = new Set(AGENT_PROVIDERS);
+function isAgentProvider(value) {
+  return typeof value === "string" && AGENT_PROVIDER_SET.has(value);
 }
 
 // ../../packages/shared/dist/types/runtime.js
 var AGENT_RUN_STATUS_VALUES = ["starting", "running", "done", "error"];
 var AGENT_RUN_STATUS_SET = new Set(AGENT_RUN_STATUS_VALUES);
-var RUNTIME_AGENTS = CODING_RUNTIME_AGENTS;
-var isRuntimeAgent = isCodingRuntimeAgent;
+var RUNTIME_AGENTS = AGENT_PROVIDERS;
+var isRuntimeAgent = isAgentProvider;
 var AGENT_MODEL_DEFAULTS = {
   "claude-code": [
     { id: "opus", label: "Opus" },
@@ -1868,20 +2410,45 @@ var AGENT_MODEL_DEFAULTS = {
     { id: "o3", label: "o3" },
     { id: "o4-mini", label: "o4-mini" }
   ],
-  cursor: [
+  "cursor-agent": [
     { id: "", label: "Default" },
     { id: "gpt-5", label: "GPT-5" },
     { id: "sonnet-4", label: "Sonnet 4" },
     { id: "sonnet-4-thinking", label: "Sonnet 4 Thinking" }
   ]
 };
+var AGENT_EFFORT_DEFAULTS = {
+  "claude-code": [
+    { id: "high", label: "High" },
+    { id: "max", label: "Max" },
+    { id: "medium", label: "Medium" },
+    { id: "low", label: "Low" }
+  ],
+  codex: [
+    { id: "xhigh", label: "Extra High" },
+    { id: "high", label: "High" },
+    { id: "medium", label: "Medium" },
+    { id: "low", label: "Low" }
+  ],
+  "cursor-agent": []
+};
+var AGENT_DEFAULT_MODEL = {
+  "claude-code": "opus",
+  codex: "gpt-5.4",
+  "cursor-agent": ""
+};
+var AGENT_DEFAULT_EFFORT = {
+  "claude-code": "high",
+  codex: "xhigh",
+  "cursor-agent": ""
+};
 function defaultAgentModelFetchCommand(agent2) {
-  if (agent2 === "cursor")
+  if (agent2 === "cursor-agent")
     return "cursor-agent models";
   return void 0;
 }
 function defaultAgentModelOutputFormat(agent2) {
-  if (agent2 === "cursor")
+  if (agent2 === "cursor-agent")
     return "lines";
   return void 0;
 }
@@ -2093,12 +2660,12 @@ models.command("default <agent>").description("Get or set default model / effort
 });
 
 // src/commands/agent-run.ts
-import fs15 from "fs";
-import path14 from "path";
+import fs18 from "fs";
+import path17 from "path";
 import { Command as Command11 } from "commander";
 import chalk11 from "chalk";
 import { spawn as spawn2, spawnSync as spawnSync3 } from "child_process";
-import yaml6 from "js-yaml";
+import yaml7 from "js-yaml";
 var agentRun = new Command11("agent-run").description("Inspect and control agent runs");
 agentRun.command("list").description("List active agent runs").option("--json", "Output JSON").option("--task <id>", "Filter by task id").action(async (opts) => {
   try {
@@ -2222,7 +2789,7 @@ profile.command("get <ref>").description("Show one runtime profile by slug or ob
     console.log(formatProfile(result.runtime));
     console.log();
     console.log(chalk11.dim("--- exec ---"));
-    console.log(yaml6.dump(result.runtime.exec, { lineWidth: 100 }));
+    console.log(yaml7.dump(result.runtime.exec, { lineWidth: 100 }));
   } catch (err) {
     const apiErr = err;
     if (apiErr.status === 404) failProfile(`not found: ${ref}`);
@@ -2232,7 +2799,7 @@ profile.command("get <ref>").description("Show one runtime profile by slug or ob
 profile.command("create").description("Create a runtime profile from a YAML spec file").requiredOption("--from-file <file>", "YAML spec file with kind, slug, exec").option("--scope <scope>", "Storage scope: user (default) or project", "user").option("--project-root <path>", "Project root (required for --scope project)").action(async (opts) => {
   let parsed;
   try {
-    parsed = yaml6.load(fs15.readFileSync(path14.resolve(opts.fromFile), "utf-8"));
+    parsed = yaml7.load(fs18.readFileSync(path17.resolve(opts.fromFile), "utf-8"));
   } catch (err) {
     failProfile(`cannot read ${opts.fromFile}: ${err.message}`);
   }
@@ -2248,14 +2815,14 @@ profile.command("edit <ref>").description("Open the runtime profile YAML in $EDI
   try {
     const result = await api.get(`/api/runtime-profiles/${encodeURIComponent(ref)}`);
     if (result.runtime.system) failProfile("cannot edit a system runtime profile");
-    const tmp = path14.join(process.env.TMPDIR || "/tmp", `task0-runtime-${result.runtime.slug}-${Date.now()}.yml`);
-    fs15.writeFileSync(tmp, yaml6.dump(result.runtime, { lineWidth: 100 }), "utf-8");
+    const tmp = path17.join(process.env.TMPDIR || "/tmp", `task0-runtime-${result.runtime.slug}-${Date.now()}.yml`);
+    fs18.writeFileSync(tmp, yaml7.dump(result.runtime, { lineWidth: 100 }), "utf-8");
     const editor = process.env.EDITOR || "vi";
     const r = spawnSync3(editor, [tmp], { stdio: "inherit" });
     if (r.status !== 0) failProfile(`editor exited with status ${r.status}`);
-    const updated = yaml6.load(fs15.readFileSync(tmp, "utf-8"));
+    const updated = yaml7.load(fs18.readFileSync(tmp, "utf-8"));
     await api.put(`/api/runtime-profiles/${encodeURIComponent(ref)}`, updated);
-    fs15.unlinkSync(tmp);
+    fs18.unlinkSync(tmp);
     console.log(chalk11.green(`updated ${ref}`));
   } catch (err) {
     failProfile(err.message);
@@ -2275,13 +2842,13 @@ agentRun.addCommand(profile);
 // src/commands/plan.ts
 import { Command as Command12 } from "commander";
 import chalk12 from "chalk";
-import fs16 from "fs";
-import path15 from "path";
+import fs19 from "fs";
+import path18 from "path";
 init_task_state2();
 var PLAN_GENERATE_SKILL_NAME = "plan-generate";
 function resolveSkillFilePath3(projectRoot, skillName) {
-  const p = path15.join(projectRoot, ".claude", "skills", skillName, "SKILL.md");
-  return fs16.existsSync(p) ? p : null;
+  const p = path18.join(projectRoot, ".claude", "skills", skillName, "SKILL.md");
+  return fs19.existsSync(p) ? p : null;
 }
 var plan = new Command12("plan").description("Generate and refine plans");
 plan.command("generate <objectId>").description("Generate plan(s) from an IDEA file \u2014 supports agent fan-out").option("-a, --agents <list>", "Comma-separated agents (claude-code,codex,cursor)", "codex,claude-code").option("--model <id>", "Model id or alias \u2014 only with a single agent; use `task0 models default` for fan-out").option("--effort <level>", "Reasoning effort \u2014 only with a single agent; use `task0 models default` for fan-out").option("--idea <file>", "IDEA file name (default: latest IDEA-NN.md)").option("--additional-prompt <text>", "Extra prompt content").option("--wait", "Wait for completion").option("--force", "Overwrite existing plan files").option("--json", "Output JSON").action(async (objectId, opts) => {
@@ -2413,7 +2980,7 @@ var PLAN_REFINE_SKILL_NAME = "plan-refine";
 plan.command("refine <objectId>").description("Synthesize plan files + ISSUE files into a refined plan").option("--agent <name>", "Agent to run refine (claude-code|codex)", "claude-code").option("--model <id>", "Model id or alias (see `task0 models refresh`)").option("--effort <level>", "Reasoning effort (e.g. low|medium|high)").option("--wait", "Wait for completion").option("--json", "Output JSON").action(async (objectId, opts) => {
   try {
     const loc = resolveTaskByObjectId(objectId);
-    const files = fs16.readdirSync(loc.taskDir);
+    const files = fs19.readdirSync(loc.taskDir);
     const planFiles = files.filter((f) => /^PLAN-\d+-(codex|claude-code|cursor)\.md$/.test(f));
     if (planFiles.length === 0) {
       console.error(chalk12.red("No PLAN-NN-<agent>.md files found. Run `task0 plan generate` first."));
@@ -2455,8 +3022,8 @@ plan.command("refine <objectId>").description("Synthesize plan files + ISSUE fil
           if (!opts.json) console.log(chalk12.dim(`[refine] ${s.status}${s.phase ? " " + s.phase : ""}`));
         }
       });
-      const refinedPath = path15.join(loc.taskDir, refinedFile);
-      const wrote = fs16.existsSync(refinedPath);
+      const refinedPath = path18.join(loc.taskDir, refinedFile);
+      const wrote = fs19.existsSync(refinedPath);
       if (final.status === "done" && wrote) {
         await updateWorkflow(loc.taskYml, {
           phase: "refined",
@@ -2608,8 +3175,8 @@ import { Command as Command14 } from "commander";
 import chalk14 from "chalk";
 
 // src/lib/project.ts
-import path16 from "path";
-import fs17 from "fs";
+import path19 from "path";
+import fs20 from "fs";
 function resolveProjectName(opts) {
   if (opts.project && opts.project.length > 0) return opts.project;
   const config = loadConfig();
@@ -2619,15 +3186,15 @@ function resolveProjectName(opts) {
       "Cannot resolve project: no registered projects. Use `task0 source add <path>` first, or pass --project <name>."
     );
   }
-  const cwd = fs17.realpathSync(process.cwd());
+  const cwd = fs20.realpathSync(process.cwd());
   for (const source2 of projects) {
     let sourceAbs;
     try {
-      sourceAbs = fs17.realpathSync(path16.resolve(source2.path));
+      sourceAbs = fs20.realpathSync(path19.resolve(source2.path));
     } catch {
-      sourceAbs = path16.resolve(source2.path);
+      sourceAbs = path19.resolve(source2.path);
     }
-    if (cwd === sourceAbs || cwd.startsWith(sourceAbs + path16.sep)) {
+    if (cwd === sourceAbs || cwd.startsWith(sourceAbs + path19.sep)) {
       return source2.name;
     }
   }
@@ -3267,12 +3834,12 @@ import chalk17 from "chalk";
 
 // src/core/issue/decision.ts
 init_node();
-import fs18 from "fs";
-import path17 from "path";
+import fs21 from "fs";
+import path20 from "path";
 init_task_state2();
 var DECISION_FILE_RE = /^DECISION-(\d+)-([a-z0-9-]+)\.md$/;
 function selectBlockingIssues(taskDir, explicitIssue) {
-  const files = fs18.existsSync(taskDir) ? fs18.readdirSync(taskDir) : [];
+  const files = fs21.existsSync(taskDir) ? fs21.readdirSync(taskDir) : [];
   const issueFiles = files.filter((f) => /^ISSUE-\d+\.md$/.test(f)).sort();
   const all = readOpenQuestions(taskDir, issueFiles);
   if (!explicitIssue) return all;
@@ -3376,12 +3943,12 @@ function parseConsolidatedAnswers(md) {
   return sections;
 }
 function rewriteIssueWithDecisions(taskDir, issueFile, consolidatedFile) {
-  const issuePath = path17.join(taskDir, issueFile);
-  const consolidatedPath = path17.join(taskDir, consolidatedFile);
-  if (!fs18.existsSync(issuePath)) throw new Error(`${issueFile} not found in ${taskDir}`);
-  if (!fs18.existsSync(consolidatedPath)) throw new Error(`${consolidatedFile} not found in ${taskDir}`);
-  const issueMd = fs18.readFileSync(issuePath, "utf-8");
-  const consolidatedMd = fs18.readFileSync(consolidatedPath, "utf-8");
+  const issuePath = path20.join(taskDir, issueFile);
+  const consolidatedPath = path20.join(taskDir, consolidatedFile);
+  if (!fs21.existsSync(issuePath)) throw new Error(`${issueFile} not found in ${taskDir}`);
+  if (!fs21.existsSync(consolidatedPath)) throw new Error(`${consolidatedFile} not found in ${taskDir}`);
+  const issueMd = fs21.readFileSync(issuePath, "utf-8");
+  const consolidatedMd = fs21.readFileSync(consolidatedPath, "utf-8");
   const answers = parseConsolidatedAnswers(consolidatedMd);
   if (answers.length === 0) {
     throw new Error(`${consolidatedFile} has no "## Qn" sections; cannot derive Decisions`);
@@ -3403,7 +3970,7 @@ _Resolved from [${consolidatedFile}](${consolidatedFile}); see that file for rea
     throw new Error(`${issueFile} has no "## Open Questions" section to replace`);
   }
   const next = issueMd.replace(openQRe, decisionsSection.trimEnd() + "\n");
-  fs18.writeFileSync(issuePath, next, "utf-8");
+  fs21.writeFileSync(issuePath, next, "utf-8");
   return { replaced: answers.length };
 }
 async function propose(opts) {
@@ -3431,8 +3998,8 @@ async function propose(opts) {
     const kicks = [];
     for (const agent2 of opts.agents) {
       const decisionFile = decisionFileName(issue2, agent2);
-      const decisionPath = path17.join(loc.taskDir, decisionFile);
-      if (fs18.existsSync(decisionPath) && !opts.force) {
+      const decisionPath = path20.join(loc.taskDir, decisionFile);
+      if (fs21.existsSync(decisionPath) && !opts.force) {
         if (opts.ifNeeded) {
           kicks.push({
             issue: issue2.file,
@@ -3507,7 +4074,7 @@ async function propose(opts) {
           const final = await waitForAgentRun(k.agentRunId);
           if (final.status !== "done") {
             k.error = final.error || `runtime ${k.agentRunId} ended with ${final.status}`;
-          } else if (!fs18.existsSync(path17.join(loc.taskDir, k.decisionFile))) {
+          } else if (!fs21.existsSync(path20.join(loc.taskDir, k.decisionFile))) {
             k.error = `runtime completed but ${k.decisionFile} was not written`;
           }
         } catch (err) {
@@ -3528,7 +4095,7 @@ async function consolidate(opts) {
   const kicks = [];
   const modelOpts = resolveModelOptions(opts.agent, { model: opts.model, effort: opts.effort }, opts.warn);
   for (const issue2 of issues) {
-    const files = fs18.readdirSync(loc.taskDir);
+    const files = fs21.readdirSync(loc.taskDir);
     const proposalFiles = files.filter((f) => {
       const m = f.match(DECISION_FILE_RE);
       return !!m && m[1] === issue2.index && m[2] !== "consolidated";
@@ -3574,7 +4141,7 @@ async function consolidate(opts) {
       if (opts.wait) {
         try {
           const final = await waitForAgentRun(agentRunId);
-          const wrote = fs18.existsSync(path17.join(loc.taskDir, consolidatedFile));
+          const wrote = fs21.existsSync(path20.join(loc.taskDir, consolidatedFile));
           if (final.status !== "done") {
             kick.error = final.error || `runtime ${agentRunId} ended with ${final.status}`;
           } else if (!wrote) {
@@ -3640,7 +4207,7 @@ async function approve(opts) {
   return { updated };
 }
 function buildReferenceFiles(taskDir, issue2) {
-  const names = fs18.readdirSync(taskDir);
+  const names = fs21.readdirSync(taskDir);
   const refs = [issue2.file];
   if (names.includes("ISSUE.md")) refs.push("ISSUE.md");
   const ideaFile = `IDEA-${issue2.index}.md`;
@@ -3748,12 +4315,12 @@ issue.command("approve <taskId>").description("Apply the consolidated decisions
 });
 
 // src/commands/agent.ts
-import fs19 from "fs";
-import path18 from "path";
+import fs22 from "fs";
+import path21 from "path";
 import { spawnSync as spawnSync5 } from "child_process";
 import { Command as Command18 } from "commander";
 import chalk18 from "chalk";
-import yaml7 from "js-yaml";
+import yaml8 from "js-yaml";
 function statusBadge(s) {
   if (s === "working") return chalk18.cyan("\u25CF");
   if (s === "error") return chalk18.red("\u25CF");
@@ -3772,7 +4339,7 @@ function fail5(message, code = 1) {
   process.exit(code);
 }
 function formatAgent(a, withDetails = false) {
-  const tag = a.system ? chalk18.dim("(system)") : a.scope ? chalk18.dim(`(${a.scope})`) : "";
+  const tag = a.scope ? chalk18.dim(`(${a.scope})`) : "";
   const dot = statusBadge(a.status);
   const head = `${dot} ${chalk18.bold(a.slug.padEnd(24))} ${chalk18.dim(a.object_id.padEnd(16))} ${a.kind.padEnd(10)} ${tag}`;
   if (!withDetails) return head;
@@ -3813,10 +4380,10 @@ agent.command("get <ref>").description("Show one agent by object_id or slug").op
     }
     console.log();
     console.log(chalk18.dim("--- spec ---"));
-    console.log(yaml7.dump(result.agent.spec, { lineWidth: 100 }));
+    console.log(yaml8.dump(result.agent.spec, { lineWidth: 100 }));
     if (result.agent.mcp_config) {
       console.log(chalk18.dim("--- mcp_config ---"));
-      console.log(yaml7.dump(result.agent.mcp_config, { lineWidth: 100 }));
+      console.log(yaml8.dump(result.agent.mcp_config, { lineWidth: 100 }));
     }
   } catch (err) {
     const apiErr = err;
@@ -3827,8 +4394,8 @@ agent.command("get <ref>").description("Show one agent by object_id or slug").op
 agent.command("create").description("Create an agent from a YAML spec file").requiredOption("--from-file <file>", "YAML spec file with at least kind, slug, spec").option("--scope <scope>", "Storage scope: user (default) or project", "user").option("--project-root <path>", "Project root (required for --scope project)").action(async (opts) => {
   let parsed;
   try {
-    const raw = fs19.readFileSync(path18.resolve(opts.fromFile), "utf-8");
-    parsed = yaml7.load(raw);
+    const raw = fs22.readFileSync(path21.resolve(opts.fromFile), "utf-8");
+    parsed = yaml8.load(raw);
   } catch (err) {
     fail5(`cannot read ${opts.fromFile}: ${err.message}`);
   }
@@ -3843,18 +4410,17 @@ agent.command("create").description("Create an agent from a YAML spec file").req
 agent.command("edit <ref>").description("Open the agent YAML in $EDITOR and save changes").action(async (ref) => {
   try {
     const result = await api.get(`/api/agents/${encodeURIComponent(ref)}`);
-    if (result.agent.system) fail5("cannot edit a system agent");
-    const tmp = path18.join(
+    const tmp = path21.join(
       process.env.TMPDIR || "/tmp",
       `task0-agent-${result.agent.slug}-${Date.now()}.yml`
     );
-    fs19.writeFileSync(tmp, yaml7.dump(result.agent, { lineWidth: 100 }), "utf-8");
+    fs22.writeFileSync(tmp, yaml8.dump(result.agent, { lineWidth: 100 }), "utf-8");
     const editor = process.env.EDITOR || "vi";
     const r = spawnSync5(editor, [tmp], { stdio: "inherit" });
     if (r.status !== 0) fail5(`editor exited with status ${r.status}`);
-    const updated = yaml7.load(fs19.readFileSync(tmp, "utf-8"));
+    const updated = yaml8.load(fs22.readFileSync(tmp, "utf-8"));
     await api.put(`/api/agents/${encodeURIComponent(ref)}`, updated);
-    fs19.unlinkSync(tmp);
+    fs22.unlinkSync(tmp);
     console.log(chalk18.green(`updated ${ref}`));
   } catch (err) {
     fail5(err.message);
@@ -3925,7 +4491,7 @@ var mcp = new Command18("mcp").description("Manage per-agent MCP config (mcp_con
 mcp.command("set <ref>").description("Set mcp_config from a JSON file (replaces existing config)").requiredOption("--from-file <file>", "JSON file containing the mcp_config object").action(async (ref, opts) => {
   let parsed;
   try {
-    parsed = JSON.parse(fs19.readFileSync(path18.resolve(opts.fromFile), "utf-8"));
+    parsed = JSON.parse(fs22.readFileSync(path21.resolve(opts.fromFile), "utf-8"));
   } catch (err) {
     fail5(`cannot parse ${opts.fromFile}: ${err.message}`);
   }
@@ -3968,78 +4534,77 @@ async function streamOutput(ref, agentRunId) {
 }
 
 // src/commands/daemon.ts
-import os7 from "os";
+import os6 from "os";
+import { execFileSync as execFileSync2 } from "child_process";
 import { Command as Command19 } from "commander";
 import chalk19 from "chalk";
 import WebSocket from "ws";
 
-// src/core/admin-token.ts
-import fs20 from "fs";
-import os4 from "os";
-import path19 from "path";
-var CONFIG_DIR2 = path19.join(os4.homedir(), ".config", "task0");
-var TOKEN_FILE = path19.join(CONFIG_DIR2, "admin.token");
-var cached = null;
-var AdminTokenUnavailableError = class extends Error {
-  constructor() {
-    super(
-      `Admin token not found.
-  \u2022 If the task0 server runs on this host, run the task0-server binary once \u2014 the token will be generated at ${TOKEN_FILE}.
-  \u2022 Otherwise, copy the token from the server host and set TASK0_ADMIN_TOKEN.`
-    );
-    this.name = "AdminTokenUnavailableError";
-  }
-};
-function readAdminToken() {
-  if (cached) return cached;
-  const fromEnv = process.env.TASK0_ADMIN_TOKEN?.trim();
-  if (fromEnv) {
-    cached = fromEnv;
-    return cached;
-  }
-  if (fs20.existsSync(TOKEN_FILE)) {
-    const v = fs20.readFileSync(TOKEN_FILE, "utf-8").trim();
-    if (v) {
-      cached = v;
-      return cached;
+// src/core/daemon-agent-run-sink.ts
+var BUFFER_CAP = 5e3;
+var bound = null;
+var seqByRun = /* @__PURE__ */ new Map();
+var buffer = [];
+var logHistoryByRun = /* @__PURE__ */ new Map();
+function bindAgentRunFrameSink(sink) {
+  bound = sink;
+  if (!sink) return;
+  while (buffer.length > 0) {
+    const frame = buffer.shift();
+    try {
+      sink.send(frame);
+    } catch {
     }
   }
-  throw new AdminTokenUnavailableError();
-}
-function adminAuthHeader() {
-  return { authorization: `Bearer ${readAdminToken()}` };
-}
-
-// src/core/daemon-config.ts
-import fs21 from "fs";
-import os5 from "os";
-import path20 from "path";
-var CONFIG_DIR3 = path20.join(os5.homedir(), ".config", "task0");
-var CONFIG_FILE2 = path20.join(CONFIG_DIR3, "daemon.json");
-function daemonConfigPath() {
-  return CONFIG_FILE2;
 }
-function readDaemonIdentity() {
-  if (!fs21.existsSync(CONFIG_FILE2)) return null;
-  try {
-    const raw = fs21.readFileSync(CONFIG_FILE2, "utf-8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
+function deliverOrBuffer(frame) {
+  if (bound) {
+    try {
+      bound.send(frame);
+      return;
+    } catch {
+    }
   }
-}
-function writeDaemonIdentity(identity) {
-  fs21.mkdirSync(CONFIG_DIR3, { recursive: true });
-  fs21.writeFileSync(CONFIG_FILE2, JSON.stringify(identity, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
-  try {
-    fs21.chmodSync(CONFIG_FILE2, 384);
-  } catch {
+  if (buffer.length >= BUFFER_CAP) {
+    buffer.shift();
   }
+  buffer.push(frame);
+}
+function pruneRunHistory(runId) {
+  logHistoryByRun.delete(runId);
+  seqByRun.delete(runId);
 }
-function clearDaemonIdentity() {
-  if (!fs21.existsSync(CONFIG_FILE2)) return false;
-  fs21.unlinkSync(CONFIG_FILE2);
-  return true;
+function emitAgentRunStatus(runId, status, opts = {}) {
+  deliverOrBuffer({
+    type: "agent_run_status",
+    run_id: runId,
+    status,
+    phase: opts.phase ?? null,
+    exit_code: opts.exitCode ?? null,
+    error: opts.error ?? null,
+    ts: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  if (status === "completed" || status === "failed" || status === "killed") {
+    pruneRunHistory(runId);
+  }
+}
+function replayAfterRanges(ranges) {
+  if (!bound) return 0;
+  let sent = 0;
+  for (const { run_id, after_seq } of ranges) {
+    const ring = logHistoryByRun.get(run_id);
+    if (!ring) continue;
+    for (const frame of ring) {
+      if (frame.seq <= after_seq) continue;
+      try {
+        bound.send(frame);
+        sent += 1;
+      } catch {
+        return sent;
+      }
+    }
+  }
+  return sent;
 }
 
 // src/core/register-auth.ts
@@ -4049,7 +4614,7 @@ var RegisterAuthUnavailableError = class extends Error {
       `No registration credential available.
   \u2022 Pass --token <apit_...> with an API token created in the dashboard, or
   \u2022 Set TASK0_API_TOKEN in the environment, or
-  \u2022 Fall back to the server's admin token (TASK0_ADMIN_TOKEN or ~/.config/task0/admin.token).`
+  \u2022 Fall back to the server's admin token (TASK0_ADMIN_TOKEN or ~/.task0/admin.token).`
     );
     this.name = "RegisterAuthUnavailableError";
   }
@@ -4075,8 +4640,191 @@ function pickRegisterAuth(flagToken) {
 
 // src/core/daemon-rpc-handlers.ts
 init_node();
-import fs22 from "fs";
-import path21 from "path";
+import fs25 from "fs";
+import path24 from "path";
+
+// src/core/daemon-agent-run-runner.ts
+import { execFileSync } from "child_process";
+import fs24 from "fs";
+import path23 from "path";
+
+// src/core/daemon-agent-run-dir.ts
+init_node();
+import fs23 from "fs";
+import path22 from "path";
+function agentRunRoot() {
+  return process.env.TASK0_DAEMON_AGENT_RUN_DIR || path22.join(task0Home(), "agent-run");
+}
+function agentRunDir(runId) {
+  return path22.join(agentRunRoot(), runId);
+}
+function agentRunStatusPath(runId) {
+  return path22.join(agentRunDir(runId), "status.json");
+}
+function ensureAgentRunDir(runId) {
+  const dir = agentRunDir(runId);
+  fs23.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function removeAgentRunDir(runId) {
+  const dir = agentRunDir(runId);
+  if (!fs23.existsSync(dir)) return;
+  fs23.rmSync(dir, { recursive: true, force: true });
+}
+
+// src/core/daemon-agent-run-runner.ts
+var active = /* @__PURE__ */ new Map();
+var STATUS_POLL_MS = 500;
+var SESSION_PROBE_MS = 3e3;
+function getTmuxBin() {
+  const fromEnv = process.env.TASK0_TMUX_BIN;
+  if (fromEnv) return fromEnv;
+  return "tmux";
+}
+function checkTmuxAvailable() {
+  try {
+    execFileSync(getTmuxBin(), ["-V"], { stdio: ["ignore", "pipe", "pipe"] });
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, reason: `tmux not available: ${err instanceof Error ? err.message : String(err)}` };
+  }
+}
+function isSessionAlive2(sessionName) {
+  try {
+    execFileSync(getTmuxBin(), ["has-session", "-t", sessionName], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function killSession2(sessionName) {
+  try {
+    execFileSync(getTmuxBin(), ["kill-session", "-t", sessionName], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readStatusFile(runId) {
+  const filePath = agentRunStatusPath(runId);
+  if (!fs24.existsSync(filePath)) return null;
+  try {
+    const raw = fs24.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return { raw, parsed };
+  } catch {
+    return null;
+  }
+}
+function deriveStatus(parsed) {
+  const raw = typeof parsed.status === "string" ? parsed.status : "starting";
+  let status = "starting";
+  if (raw === "running") status = "running";
+  else if (raw === "done" || raw === "completed") status = "completed";
+  else if (raw === "error" || raw === "failed") status = "failed";
+  const phase = typeof parsed.phase === "string" ? parsed.phase : null;
+  const error2 = typeof parsed.error === "string" && parsed.error ? parsed.error : null;
+  return { status, phase, error: error2 };
+}
+function launchAgentRun(params) {
+  const tmuxCheck = checkTmuxAvailable();
+  if (!tmuxCheck.ok) {
+    throw Object.assign(new Error(tmuxCheck.reason ?? "tmux unavailable"), { code: "tmux_unavailable" });
+  }
+  if (active.has(params.runId)) {
+    throw Object.assign(new Error(`agent run already active: ${params.runId}`), { code: "already_running" });
+  }
+  if (!fs24.existsSync(params.workspace)) {
+    throw Object.assign(new Error(`workspace not found: ${params.workspace}`), { code: "workspace_missing" });
+  }
+  const runDir = ensureAgentRunDir(params.runId);
+  const scriptPath = path23.join(runDir, "script.sh");
+  fs24.writeFileSync(scriptPath, params.scriptContent, { mode: 493 });
+  if (params.promptContent !== void 0) {
+    fs24.writeFileSync(path23.join(runDir, "prompt.txt"), params.promptContent, "utf-8");
+  }
+  for (const [name, content] of Object.entries(params.auxFiles ?? {})) {
+    if (name.includes("/") || name.includes("\\") || name === ".." || name === ".") {
+      throw Object.assign(new Error(`invalid aux file name: ${name}`), { code: "invalid_params" });
+    }
+    fs24.writeFileSync(path23.join(runDir, name), content, "utf-8");
+  }
+  fs24.writeFileSync(
+    agentRunStatusPath(params.runId),
+    JSON.stringify({ status: "starting", updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2),
+    "utf-8"
+  );
+  try {
+    execFileSync(
+      getTmuxBin(),
+      ["new-session", "-d", "-s", params.sessionName, "-c", params.workspace, `bash ${JSON.stringify(scriptPath)}`],
+      { encoding: "utf-8", timeout: 5e3, stdio: ["ignore", "pipe", "pipe"] }
+    );
+  } catch (err) {
+    removeAgentRunDir(params.runId);
+    throw Object.assign(
+      new Error(`failed to start tmux session: ${err instanceof Error ? err.message : String(err)}`),
+      { code: "spawn_failed" }
+    );
+  }
+  emitAgentRunStatus(params.runId, "starting", { phase: null });
+  const entry = {
+    runId: params.runId,
+    sessionName: params.sessionName,
+    lastStatusJson: null,
+    finished: false,
+    pollInterval: setInterval(() => pollOne(params.runId), STATUS_POLL_MS)
+  };
+  active.set(params.runId, entry);
+  const sessionProbe = setInterval(() => {
+    const cur = active.get(params.runId);
+    if (!cur || cur.finished) {
+      clearInterval(sessionProbe);
+      return;
+    }
+    if (!isSessionAlive2(cur.sessionName)) {
+      finishRun(params.runId, "killed", { error: "tmux session disappeared" });
+      clearInterval(sessionProbe);
+    }
+  }, SESSION_PROBE_MS);
+  return { agentRunDir: runDir, sessionName: params.sessionName };
+}
+function pollOne(runId) {
+  const entry = active.get(runId);
+  if (!entry || entry.finished) return;
+  const current = readStatusFile(runId);
+  if (!current) return;
+  if (current.raw === entry.lastStatusJson) return;
+  entry.lastStatusJson = current.raw;
+  const { status, phase, error: error2 } = deriveStatus(current.parsed);
+  emitAgentRunStatus(runId, status, { phase, error: error2 });
+  if (status === "completed" || status === "failed") {
+    finishRun(runId, status, { phase, error: error2 });
+  }
+}
+function finishRun(runId, status, opts = {}) {
+  const entry = active.get(runId);
+  if (!entry || entry.finished) return;
+  entry.finished = true;
+  clearInterval(entry.pollInterval);
+  emitAgentRunStatus(runId, status, opts);
+  active.delete(runId);
+}
+function cancelAgentRun(runId) {
+  const entry = active.get(runId);
+  if (!entry) {
+    return { ok: false, sessionName: null };
+  }
+  killSession2(entry.sessionName);
+  finishRun(runId, "killed", { error: "cancelled by hub" });
+  return { ok: true, sessionName: entry.sessionName };
+}
+
+// src/core/daemon-rpc-handlers.ts
 var MAX_FILE_BYTES = 1 * 1024 * 1024;
 function ensureString(value, name) {
   if (typeof value !== "string" || value.length === 0) {
@@ -4084,13 +4832,61 @@ function ensureString(value, name) {
   }
   return value;
 }
+function ensureSafeTaskId(value) {
+  const id = ensureString(value, "taskId");
+  if (id.includes("/") || id.includes("\\") || id.includes("\0") || id === "." || id === ".." || path24.isAbsolute(id)) {
+    throw Object.assign(new Error(`invalid taskId: ${id}`), { code: "invalid_params" });
+  }
+  return id;
+}
+function assertContained(rootAbs, resolvedAbs) {
+  const root = path24.resolve(rootAbs);
+  const target = path24.resolve(resolvedAbs);
+  if (target !== root && !target.startsWith(root + path24.sep)) {
+    throw Object.assign(new Error("path escapes containment root"), { code: "invalid_params" });
+  }
+}
+function optionalString(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "string") {
+    throw Object.assign(new Error("expected string"), { code: "invalid_params" });
+  }
+  return value;
+}
+function optionalBoolean(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "boolean") {
+    throw Object.assign(new Error("expected boolean"), { code: "invalid_params" });
+  }
+  return value;
+}
+function listProjects() {
+  return loadConfig().sources.filter((source2) => source2.type === "project");
+}
+function applyRepair(r) {
+  const raw = readYaml(r.taskYml);
+  if (!raw) return;
+  if (r.reason === "missing_object_id") raw.object_id = generateObjectId("task");
+  if (r.reason === "id_mismatch") raw.id = r.dirName;
+  writeYaml(r.taskYml, raw);
+}
+function scanProjectWithRepair(projectPath, sourceName) {
+  let result = scanProject(projectPath, sourceName);
+  if (result.repairs.length > 0) {
+    for (const r of result.repairs) applyRepair(r);
+    result = scanProject(projectPath, sourceName);
+  }
+  return result;
+}
 var rpcHandlers = {
   // Scan a local project for its task manifest. Returns the same shape the
-  // in-process server's /api/tasks scanProject() returns.
+  // hub's in-process scanProject() used to return — with auto-repair of
+  // missing object_id / id mismatches applied in place on the daemon's FS.
   async scan_project(params) {
     const rootPath = ensureString(params.rootPath, "rootPath");
-    const name = typeof params.name === "string" && params.name ? params.name : path21.basename(rootPath);
-    return scanProject(rootPath, name);
+    const name = typeof params.name === "string" && params.name ? params.name : path24.basename(rootPath);
+    const result = scanProjectWithRepair(rootPath, name);
+    return { tasks: result.tasks, errors: result.errors };
   },
   // Read a file from disk on the daemon's host. The dashboard uses this to
   // peek into archived task content, runtime logs, etc. Cap is 1 MiB to
@@ -4099,7 +4895,7 @@ var rpcHandlers = {
     const filePath = ensureString(params.path, "path");
     let stat;
     try {
-      stat = fs22.statSync(filePath);
+      stat = fs25.statSync(filePath);
     } catch {
       throw Object.assign(new Error("file not found"), { code: "not_found" });
     }
@@ -4109,23 +4905,261 @@ var rpcHandlers = {
     if (stat.size > MAX_FILE_BYTES) {
       throw Object.assign(new Error(`file too large (${stat.size} bytes > ${MAX_FILE_BYTES})`), { code: "too_large" });
     }
-    const content = fs22.readFileSync(filePath, "utf-8");
+    const content = fs25.readFileSync(filePath, "utf-8");
     return { content, size: stat.size, modifiedAt: stat.mtime.toISOString() };
+  },
+  // ---------------------------------------------------------------------
+  // Project source CRUD. The daemon owns its host's project list; the hub
+  // routes /api/daemons/:id/projects through these handlers instead of
+  // writing config.yml directly. After every mutation we re-push manifest
+  // so the hub's daemon_projects table catches up without waiting for a
+  // restart.
+  // ---------------------------------------------------------------------
+  async project_list() {
+    return { projects: listProjects() };
+  },
+  async project_add(params, ctx) {
+    const rawPath = ensureString(params.path, "path");
+    const absPath = path24.resolve(rawPath);
+    if (!fs25.existsSync(absPath)) {
+      throw Object.assign(new Error(`path does not exist: ${absPath}`), { code: "not_found" });
+    }
+    const stat = fs25.statSync(absPath);
+    if (!stat.isDirectory()) {
+      throw Object.assign(new Error(`path is not a directory: ${absPath}`), { code: "invalid_target" });
+    }
+    const name = optionalString(params.name)?.trim() || path24.basename(absPath);
+    const result = scanProjectWithRepair(absPath, name);
+    addSource({ name, type: "project", path: absPath, enabled: true });
+    ctx.notifyManifestChanged();
+    return {
+      project: { name, type: "project", path: absPath, enabled: true },
+      taskCount: result.tasks.length
+    };
+  },
+  async project_remove(params, ctx) {
+    const name = ensureString(params.name, "name");
+    const ok = removeSource(name);
+    if (!ok) {
+      throw Object.assign(new Error(`project not found: ${name}`), { code: "not_found" });
+    }
+    ctx.notifyManifestChanged();
+    return { ok: true };
+  },
+  async project_set_enabled(params, ctx) {
+    const name = ensureString(params.name, "name");
+    const enabled = optionalBoolean(params.enabled);
+    if (enabled === void 0) {
+      throw Object.assign(new Error("enabled is required (boolean)"), { code: "invalid_params" });
+    }
+    const config = loadConfig();
+    const source2 = config.sources.find((s) => s.name === name && s.type === "project");
+    if (!source2) {
+      throw Object.assign(new Error(`project not found: ${name}`), { code: "not_found" });
+    }
+    source2.enabled = enabled;
+    saveConfig(config);
+    ctx.notifyManifestChanged();
+    return { project: source2 };
+  },
+  // ---------------------------------------------------------------------
+  // Task content R/W. These are the deep-pull operations from Q5(c): the
+  // hub asks the daemon to read/write/create/delete a task's yaml + sibling
+  // files on the daemon's FS. After every mutation we re-push manifest so
+  // hub's daemon_tasks index reflects the new state without a restart.
+  // ---------------------------------------------------------------------
+  // Read a task's task0.yml (parsed) plus an optional list of sibling files
+  // in the same task directory. Path is resolved from (projectName, taskId).
+  async task_read(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 = path24.resolve(project2.path);
+    const projectConfig = readYaml(path24.join(projectAbs, "task0.yml"));
+    if (!projectConfig) {
+      throw Object.assign(new Error(`invalid project: missing task0.yml at ${projectAbs}`), { code: "invalid_project" });
+    }
+    const tasksRoot = path24.resolve(projectAbs, projectConfig.tasks_dir);
+    const taskDir = path24.resolve(tasksRoot, taskId);
+    assertContained(tasksRoot, taskDir);
+    if (!fs25.existsSync(taskDir)) {
+      throw Object.assign(new Error(`task not found: ${taskId}`), { code: "not_found" });
+    }
+    const taskYml = path24.join(taskDir, "task0.yml");
+    const yaml10 = readYaml(taskYml);
+    if (!yaml10) {
+      throw Object.assign(new Error(`task yaml missing or unreadable: ${taskYml}`), { code: "not_found" });
+    }
+    const files = fs25.readdirSync(taskDir).filter((name) => name !== "task0.yml");
+    return { task_dir: taskDir, yaml: yaml10, files };
+  },
+  // Create a task directory + write task0.yml + write any additional named
+  // files. Hub decides the taskId and yaml content (slug/object_id are
+  // generated server-side); daemon just commits to disk.
+  async task_create(params, ctx) {
+    const projectName = ensureString(params.projectName, "projectName");
+    const taskId = ensureSafeTaskId(params.taskId);
+    const yaml10 = params.yaml;
+    if (!yaml10 || typeof yaml10 !== "object") {
+      throw Object.assign(new Error("yaml (object) is required"), { code: "invalid_params" });
+    }
+    const files = params.files ?? {};
+    const project2 = listProjects().find((p) => p.name === projectName);
+    if (!project2) {
+      throw Object.assign(new Error(`project not found: ${projectName}`), { code: "not_found" });
+    }
+    const projectAbs = path24.resolve(project2.path);
+    const projectConfig = readYaml(path24.join(projectAbs, "task0.yml"));
+    if (!projectConfig) {
+      throw Object.assign(new Error(`invalid project: missing task0.yml at ${projectAbs}`), { code: "invalid_project" });
+    }
+    const tasksRoot = path24.resolve(projectAbs, projectConfig.tasks_dir);
+    const taskDir = path24.resolve(tasksRoot, taskId);
+    assertContained(tasksRoot, taskDir);
+    if (fs25.existsSync(taskDir)) {
+      throw Object.assign(new Error(`task already exists: ${taskId}`), { code: "already_exists" });
+    }
+    fs25.mkdirSync(taskDir, { recursive: true });
+    writeYaml(path24.join(taskDir, "task0.yml"), yaml10);
+    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" });
+      }
+      fs25.writeFileSync(path24.join(taskDir, name), content, "utf-8");
+    }
+    ctx.notifyManifestChanged();
+    return { task_dir: taskDir };
+  },
+  // Patch a task's task0.yml in place. The hub computes the desired yaml
+  // (typically by loading + applying its own metadata patch), then sends
+  // the full replacement object back. Atomic at the file level — no
+  // partial writes.
+  async task_write_yaml(params, ctx) {
+    const projectName = ensureString(params.projectName, "projectName");
+    const taskId = ensureSafeTaskId(params.taskId);
+    const yaml10 = params.yaml;
+    if (!yaml10 || typeof yaml10 !== "object") {
+      throw Object.assign(new Error("yaml (object) is required"), { 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 = path24.resolve(project2.path);
+    const projectConfig = readYaml(path24.join(projectAbs, "task0.yml"));
+    if (!projectConfig) {
+      throw Object.assign(new Error(`invalid project: missing task0.yml at ${projectAbs}`), { code: "invalid_project" });
+    }
+    const tasksRoot = path24.resolve(projectAbs, projectConfig.tasks_dir);
+    const taskDir = path24.resolve(tasksRoot, taskId);
+    assertContained(tasksRoot, taskDir);
+    const taskYml = path24.join(taskDir, "task0.yml");
+    if (!fs25.existsSync(taskYml)) {
+      throw Object.assign(new Error(`task yaml not found: ${taskYml}`), { code: "not_found" });
+    }
+    writeYaml(taskYml, yaml10);
+    ctx.notifyManifestChanged();
+    return { task_dir: taskDir };
+  },
+  // Delete an entire task directory (use sparingly; mostly for archive
+  // workflows). Returns the deleted path so the hub can emit an event.
+  async task_delete(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 = path24.resolve(project2.path);
+    const projectConfig = readYaml(path24.join(projectAbs, "task0.yml"));
+    if (!projectConfig) {
+      throw Object.assign(new Error(`invalid project: missing task0.yml at ${projectAbs}`), { code: "invalid_project" });
+    }
+    const tasksRoot = path24.resolve(projectAbs, projectConfig.tasks_dir);
+    const taskDir = path24.resolve(tasksRoot, taskId);
+    assertContained(tasksRoot, taskDir);
+    if (!fs25.existsSync(taskDir)) {
+      throw Object.assign(new Error(`task not found: ${taskId}`), { code: "not_found" });
+    }
+    fs25.rmSync(taskDir, { recursive: true, force: true });
+    ctx.notifyManifestChanged();
+    return { task_dir: taskDir, deleted: true };
+  },
+  // ---------------------------------------------------------------------
+  // Agent run lifecycle (P3.A scaffolding — handlers reject until P3.B
+  // moves the actual spawn / tmux / supervise logic from hub's
+  // agent-run-launcher.ts into the daemon).
+  //
+  // Wire shape (subject to refinement in P3.B):
+  //   agent_run_launch  → {projectName, runId, runType, agentSlug,
+  //                        workspace, prompt, ...} → {tmuxSession}
+  //                       Daemon then streams agent_run_log /
+  //                       agent_run_status frames over WS.
+  //   agent_run_cancel  → {runId} → {ok: true}
+  // ---------------------------------------------------------------------
+  // Skill discovery on the daemon's host. Mirrors hub-side
+  // resolveAgentSkill() — given a workspace + agent + filePath, returns
+  // the matching AgentSkill record or null. P3.C uses this so the hub
+  // can dispatch agent runs to remote daemons without itself needing FS
+  // access to the workspace.
+  async agent_skill_resolve(params) {
+    const workspace = ensureString(params.workspace, "workspace");
+    const agent2 = ensureString(params.agent, "agent");
+    const filePath = ensureString(params.filePath, "filePath");
+    if (agent2 !== "claude_code" && agent2 !== "codex" && agent2 !== "cursor") {
+      throw Object.assign(new Error(`unknown skill agent: ${agent2}`), { code: "invalid_params" });
+    }
+    const projectSkills = getProjectAgentSkills(workspace);
+    const globalSkills = getGlobalAgentSkills();
+    const all = [...projectSkills, ...globalSkills];
+    const resolved = path24.resolve(filePath);
+    const skill = all.find(
+      (s) => s.agent === agent2 && path24.resolve(s.filePath) === resolved
+    ) ?? null;
+    return { skill };
+  },
+  async agent_run_launch(params) {
+    const runId = ensureString(params.runId, "runId");
+    const sessionName = ensureString(params.sessionName, "sessionName");
+    const workspace = ensureString(params.workspace, "workspace");
+    const scriptContent = ensureString(params.scriptContent, "scriptContent");
+    const auxFiles = params.auxFiles && typeof params.auxFiles === "object" ? params.auxFiles : {};
+    const promptContent = typeof params.promptContent === "string" ? params.promptContent : void 0;
+    const { agentRunDir: agentRunDir2, sessionName: actualSessionName } = launchAgentRun({
+      runId,
+      sessionName,
+      workspace,
+      scriptContent,
+      auxFiles,
+      promptContent
+    });
+    return { agent_run_dir: agentRunDir2, tmux_session: actualSessionName };
+  },
+  async agent_run_cancel(params) {
+    const runId = ensureString(params.runId, "runId");
+    const result = cancelAgentRun(runId);
+    if (!result.ok) {
+      throw Object.assign(new Error(`no active agent run: ${runId}`), { code: "not_found" });
+    }
+    return { ok: true, tmux_session: result.sessionName };
   }
 };
 
 // src/core/daemon-service/launchd.ts
 import { spawnSync as spawnSync6 } from "child_process";
-import fs24 from "fs";
-import path23 from "path";
+import fs27 from "fs";
+import path26 from "path";
 
 // src/core/daemon-service/binary.ts
-import fs23 from "fs";
+import fs26 from "fs";
 import { fileURLToPath } from "url";
 function resolveTask0Invocation() {
   const node = process.execPath;
   const argv1 = process.argv[1] ?? fileURLToPath(import.meta.url);
-  const main2 = fs23.realpathSync(argv1);
+  const main2 = fs26.realpathSync(argv1);
   if (!isInstalledBuild(main2) && process.env.TASK0_ALLOW_DEV_SERVICE !== "1") {
     throw new Error(
       `Refusing to install autostart service pointing at ${main2}.
@@ -4141,31 +5175,40 @@ function isInstalledBuild(p) {
 }
 
 // src/core/daemon-service/paths.ts
-import os6 from "os";
-import path22 from "path";
+init_node();
+import os5 from "os";
+import path25 from "path";
 
 // src/core/daemon-service/types.ts
-var SERVICE_LABEL = "cc.cy0.task0";
+import crypto2 from "crypto";
+var BASE_SERVICE_LABEL = "cc.cy0.task0";
+function serviceLabel() {
+  const home = process.env.TASK0_HOME;
+  if (!home || home.length === 0) return BASE_SERVICE_LABEL;
+  const hash = crypto2.createHash("sha256").update(home).digest("hex").slice(0, 8);
+  return `${BASE_SERVICE_LABEL}.${hash}`;
+}
 
 // src/core/daemon-service/paths.ts
 function unitPath(scope) {
   const platform = process.platform;
+  const label = serviceLabel();
   if (platform === "darwin") {
-    return scope === "user" ? path22.join(os6.homedir(), "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`) : path22.join("/", "Library", "LaunchDaemons", `${SERVICE_LABEL}.plist`);
+    return scope === "user" ? path25.join(os5.homedir(), "Library", "LaunchAgents", `${label}.plist`) : path25.join("/", "Library", "LaunchDaemons", `${label}.plist`);
   }
   if (platform === "linux") {
-    return scope === "user" ? path22.join(os6.homedir(), ".config", "systemd", "user", `${SERVICE_LABEL}.service`) : path22.join("/", "etc", "systemd", "system", `${SERVICE_LABEL}.service`);
+    return scope === "user" ? path25.join(os5.homedir(), ".config", "systemd", "user", `${label}.service`) : path25.join("/", "etc", "systemd", "system", `${label}.service`);
   }
   throw new Error(`Unsupported platform for service install: ${platform}`);
 }
 function logDir() {
-  return path22.join(os6.homedir(), ".task0", "logs");
+  return path25.join(task0Home(), "logs");
 }
 function logPaths() {
   const dir = logDir();
   return {
-    out: path22.join(dir, "daemon.out.log"),
-    err: path22.join(dir, "daemon.err.log")
+    out: path25.join(dir, "daemon.out.log"),
+    err: path25.join(dir, "daemon.err.log")
   };
 }
 
@@ -4173,14 +5216,29 @@ function logPaths() {
 function escapeXml(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
+function collectTask0Env() {
+  const out = {};
+  for (const [k, v] of Object.entries(process.env)) {
+    if (k.startsWith("TASK0_") && typeof v === "string") out[k] = v;
+  }
+  return out;
+}
 function renderPlist(opts) {
   const programArgs = [opts.node, opts.main, ...opts.args].map((a) => `    <string>${escapeXml(a)}</string>`).join("\n");
+  const envLines = [
+    `    <key>PATH</key>`,
+    `    <string>/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin</string>`,
+    ...Object.entries(opts.task0Env ?? {}).flatMap(([k, v]) => [
+      `    <key>${escapeXml(k)}</key>`,
+      `    <string>${escapeXml(v)}</string>`
+    ])
+  ].join("\n");
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
   <key>Label</key>
-  <string>${SERVICE_LABEL}</string>
+  <string>${serviceLabel()}</string>
   <key>ProgramArguments</key>
   <array>
 ${programArgs}
@@ -4202,8 +5260,7 @@ ${programArgs}
   <string>${escapeXml(opts.home)}</string>
   <key>EnvironmentVariables</key>
   <dict>
-    <key>PATH</key>
-    <string>/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin</string>
+${envLines}
   </dict>
 </dict>
 </plist>
@@ -4215,7 +5272,7 @@ function domainTarget(scope) {
   return `gui/${uid}`;
 }
 function serviceTarget(scope) {
-  return `${domainTarget(scope)}/${SERVICE_LABEL}`;
+  return `${domainTarget(scope)}/${serviceLabel()}`;
 }
 function run2(cmd, args) {
   const res = spawnSync6(cmd, args, { encoding: "utf-8" });
@@ -4226,17 +5283,18 @@ function createLaunchdManager(scope) {
   const logs = logPaths();
   async function install() {
     const inv = resolveTask0Invocation();
-    fs24.mkdirSync(logDir(), { recursive: true });
-    fs24.mkdirSync(path23.dirname(file), { recursive: true });
+    fs27.mkdirSync(logDir(), { recursive: true });
+    fs27.mkdirSync(path26.dirname(file), { recursive: true });
     const body = renderPlist({
       node: inv.node,
       main: inv.main,
       args: inv.args,
       home: process.env.HOME ?? "/",
       out: logs.out,
-      err: logs.err
+      err: logs.err,
+      task0Env: collectTask0Env()
     });
-    fs24.writeFileSync(file, body, { mode: 420 });
+    fs27.writeFileSync(file, body, { mode: 420 });
     const bootstrap = run2("launchctl", ["bootstrap", domainTarget(scope), file]);
     if (bootstrap.code !== 0) {
       const already = /already loaded|service already bootstrapped/i.test(bootstrap.stderr);
@@ -4262,9 +5320,9 @@ function createLaunchdManager(scope) {
   }
   async function uninstall() {
     run2("launchctl", ["bootout", serviceTarget(scope)]);
-    if (fs24.existsSync(file)) {
+    if (fs27.existsSync(file)) {
       run2("launchctl", ["unload", file]);
-      fs24.unlinkSync(file);
+      fs27.unlinkSync(file);
     }
   }
   async function start() {
@@ -4283,7 +5341,7 @@ function createLaunchdManager(scope) {
     }
   }
   async function status() {
-    if (!fs24.existsSync(file)) return "absent";
+    if (!fs27.existsSync(file)) return "absent";
     const printed = run2("launchctl", ["print", serviceTarget(scope)]);
     if (printed.code !== 0) return "installed";
     const out = printed.stdout;
@@ -4306,15 +5364,26 @@ function createLaunchdManager(scope) {
 
 // src/core/daemon-service/systemd.ts
 import { spawnSync as spawnSync7 } from "child_process";
-import fs25 from "fs";
-import path24 from "path";
+import fs28 from "fs";
+import path27 from "path";
 function shellEscape(s) {
   if (!/[\s"\\$]/.test(s)) return s;
   return `"${s.replace(/[\\"]/g, (m) => `\\${m}`)}"`;
 }
+function collectTask0Env2() {
+  const out = {};
+  for (const [k, v] of Object.entries(process.env)) {
+    if (k.startsWith("TASK0_") && typeof v === "string") out[k] = v;
+  }
+  return out;
+}
 function renderUnit(opts) {
   const execStart = [opts.node, opts.main, ...opts.args].map(shellEscape).join(" ");
   const wantedBy = opts.scope === "user" ? "default.target" : "multi-user.target";
+  const envLines = ["Environment=NODE_ENV=production"];
+  for (const [k, v] of Object.entries(opts.task0Env ?? {})) {
+    envLines.push(`Environment=${k}=${shellEscape(v)}`);
+  }
   return `[Unit]
 Description=task0 daemon \u2014 central-server bridge
 After=network-online.target
@@ -4327,7 +5396,7 @@ Restart=on-failure
 RestartSec=5s
 StandardOutput=append:${opts.out}
 StandardError=append:${opts.err}
-Environment=NODE_ENV=production
+${envLines.join("\n")}
 
 [Install]
 WantedBy=${wantedBy}
@@ -4343,20 +5412,21 @@ function run3(cmd, args) {
 function createSystemdManager(scope) {
   const file = unitPath(scope);
   const logs = logPaths();
-  const unitName = `${SERVICE_LABEL}.service`;
+  const unitName = `${serviceLabel()}.service`;
   async function install() {
     const inv = resolveTask0Invocation();
-    fs25.mkdirSync(logDir(), { recursive: true });
-    fs25.mkdirSync(path24.dirname(file), { recursive: true });
+    fs28.mkdirSync(logDir(), { recursive: true });
+    fs28.mkdirSync(path27.dirname(file), { recursive: true });
     const body = renderUnit({
       node: inv.node,
       main: inv.main,
       args: inv.args,
       out: logs.out,
       err: logs.err,
-      scope
+      scope,
+      task0Env: collectTask0Env2()
     });
-    fs25.writeFileSync(file, body, { mode: 420 });
+    fs28.writeFileSync(file, body, { mode: 420 });
     const reload = run3("systemctl", [...scopeFlag(scope), "daemon-reload"]);
     if (reload.code !== 0) {
       throw new Error(`systemctl daemon-reload failed: ${reload.stderr}`);
@@ -4365,8 +5435,8 @@ function createSystemdManager(scope) {
   }
   async function uninstall() {
     run3("systemctl", [...scopeFlag(scope), "disable", "--now", unitName]);
-    if (fs25.existsSync(file)) {
-      fs25.unlinkSync(file);
+    if (fs28.existsSync(file)) {
+      fs28.unlinkSync(file);
     }
     run3("systemctl", [...scopeFlag(scope), "daemon-reload"]);
   }
@@ -4383,7 +5453,7 @@ function createSystemdManager(scope) {
     }
   }
   async function status() {
-    if (!fs25.existsSync(file)) return "absent";
+    if (!fs28.existsSync(file)) return "absent";
     const res = run3("systemctl", [...scopeFlag(scope), "is-active", unitName]);
     const out = res.stdout.trim();
     if (out === "active") return "running";
@@ -4416,8 +5486,100 @@ function getServiceManager(scope) {
   );
 }
 
+// src/core/cli-version.ts
+import { readFileSync } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import path28 from "path";
+var cached2 = null;
+function readCliVersion() {
+  if (cached2 !== null) return cached2;
+  const here = path28.dirname(fileURLToPath2(import.meta.url));
+  const candidates = [
+    path28.resolve(here, "..", "package.json"),
+    path28.resolve(here, "..", "..", "package.json")
+  ];
+  for (const candidate of candidates) {
+    try {
+      const pkg = JSON.parse(readFileSync(candidate, "utf-8"));
+      if (pkg.name === "@task0/cli" && pkg.version) {
+        cached2 = pkg.version;
+        return cached2;
+      }
+    } catch {
+    }
+  }
+  cached2 = "unknown";
+  return cached2;
+}
+
+// src/core/scaffold-default-agents.ts
+init_node();
+import fs29 from "fs";
+import path29 from "path";
+import yaml9 from "js-yaml";
+function userAgentsDir() {
+  return path29.join(task0Home(), "agents");
+}
+var NAMES = {
+  "claude-code": "Claude Code",
+  codex: "Codex",
+  "cursor-agent": "Cursor"
+};
+var DESCRIPTIONS = {
+  "claude-code": "Anthropic Claude Code CLI, launched inside a tmux session against the task workspace.",
+  codex: "OpenAI Codex CLI, launched with `codex exec` against the task workspace.",
+  "cursor-agent": "Cursor agent CLI (`cursor-agent`), launched against the task workspace."
+};
+var STABLE_OBJECT_IDS = {
+  "claude-code": "agt_sysCC",
+  codex: "agt_sysCX",
+  "cursor-agent": "agt_sysCR"
+};
+function buildDefaultAgentYaml(provider) {
+  const fetchCommand = defaultAgentModelFetchCommand(provider);
+  const fetchFormat = defaultAgentModelOutputFormat(provider);
+  return {
+    object_id: STABLE_OBJECT_IDS[provider],
+    slug: provider,
+    name: NAMES[provider],
+    description: DESCRIPTIONS[provider],
+    kind: "coding",
+    spec: {
+      agent_provider: provider,
+      model: AGENT_DEFAULT_MODEL[provider],
+      effort: AGENT_DEFAULT_EFFORT[provider],
+      available_models: AGENT_MODEL_DEFAULTS[provider].map((m) => ({ id: m.id, label: m.label })),
+      available_efforts: AGENT_EFFORT_DEFAULTS[provider].map((m) => ({ id: m.id, label: m.label })),
+      ...fetchCommand ? { model_fetch_command: fetchCommand } : {},
+      ...fetchFormat ? { model_fetch_format: fetchFormat } : {}
+    }
+  };
+}
+function isDirectoryEmpty(dir) {
+  if (!fs29.existsSync(dir)) return true;
+  try {
+    return fs29.readdirSync(dir).length === 0;
+  } catch {
+    return true;
+  }
+}
+function scaffoldDefaultAgentsIfEmpty() {
+  const dir = userAgentsDir();
+  if (!isDirectoryEmpty(dir)) {
+    return { scaffolded: false, written: [] };
+  }
+  fs29.mkdirSync(dir, { recursive: true });
+  const written = [];
+  for (const provider of AGENT_PROVIDERS) {
+    const file = path29.join(dir, `${provider}.yml`);
+    const body = yaml9.dump(buildDefaultAgentYaml(provider), { lineWidth: 100 });
+    fs29.writeFileSync(file, body, "utf-8");
+    written.push(file);
+  }
+  return { scaffolded: true, written };
+}
+
 // src/commands/daemon.ts
-var DAEMON_VERSION = "0.1.0";
 async function dispatchRpc(ws, id, method, params) {
   const handler = rpcHandlers[method];
   if (!handler) {
@@ -4425,7 +5587,8 @@ async function dispatchRpc(ws, id, method, params) {
     return;
   }
   try {
-    const result = await handler(params ?? {});
+    const ctx = { notifyManifestChanged: () => pushManifest(ws) };
+    const result = await handler(params ?? {}, ctx);
     sendRpc(ws, { type: "rpc_response", id, result });
   } catch (error2) {
     const code = error2 && typeof error2 === "object" && "code" in error2 && typeof error2.code === "string" ? error2.code : "handler_error";
@@ -4438,6 +5601,79 @@ function sendRpc(ws, payload) {
     ws.send(JSON.stringify(payload));
   }
 }
+function summariseTask(projectName, task2) {
+  const { object_id = null, id, status, title, task_dir, ...extra } = task2;
+  return {
+    project: projectName,
+    object_id: typeof object_id === "string" ? object_id : null,
+    id,
+    status,
+    title,
+    task_dir,
+    extra
+  };
+}
+function buildManifest() {
+  const projectSources = loadConfig().sources.filter((source2) => source2.type === "project");
+  const projects = projectSources.map((source2) => ({
+    name: source2.name,
+    path: source2.path,
+    enabled: source2.enabled
+  }));
+  const tasks = [];
+  const scanErrors = {};
+  for (const source2 of projectSources) {
+    if (!source2.enabled) continue;
+    try {
+      const result = scanProjectWithRepair(source2.path, source2.name);
+      for (const task2 of result.tasks) tasks.push(summariseTask(source2.name, task2));
+      if (result.errors.length > 0) scanErrors[source2.name] = result.errors;
+    } catch (err) {
+      scanErrors[source2.name] = [err instanceof Error ? err.message : String(err)];
+    }
+  }
+  return { type: "manifest", projects, tasks, scan_errors: scanErrors };
+}
+function pushManifest(ws) {
+  if (ws.readyState !== ws.OPEN) return;
+  const manifest = buildManifest();
+  ws.send(JSON.stringify(manifest));
+}
+var AGENT_PROVIDER_BINARIES = {
+  "claude-code": "claude",
+  codex: "codex",
+  "cursor-agent": "cursor-agent"
+};
+function detectAgentProvider(provider) {
+  const binary = AGENT_PROVIDER_BINARIES[provider];
+  let resolvedPath;
+  try {
+    resolvedPath = execFileSync2("which", [binary], {
+      encoding: "utf-8",
+      timeout: 2e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return null;
+  }
+  if (!resolvedPath) return null;
+  let version = null;
+  try {
+    version = execFileSync2(binary, ["--version"], {
+      encoding: "utf-8",
+      timeout: 3e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    version = null;
+  }
+  return { agent_provider: provider, path: resolvedPath, version };
+}
+function detectInstalledAgentProviders() {
+  return AGENT_PROVIDERS.map(detectAgentProvider).filter(
+    (entry) => entry !== null
+  );
+}
 function fail6(message, code = 1) {
   console.error(chalk19.red(message));
   process.exit(code);
@@ -4508,7 +5744,7 @@ daemonCmd.command("register").description("Register this host with a central ser
     throw error2;
   }
   const body = {
-    hostname: os7.hostname(),
+    hostname: os6.hostname(),
     platform: process.platform,
     name: opts.name
   };
@@ -4600,6 +5836,12 @@ daemonCmd.command("stop").description("Stop the autostart service via launchctl
 });
 daemonCmd.command("run").description("Run the daemon WebSocket loop in foreground (invoked by the service unit; useful for debugging)").action(async () => {
   const identity = loadRequiredIdentity();
+  const scaffold = scaffoldDefaultAgentsIfEmpty();
+  if (scaffold.scaffolded) {
+    console.log(
+      chalk19.green(`Scaffolded ${scaffold.written.length} default agent yml(s) under ~/.task0/agents/`)
+    );
+  }
   const wsUrl = identity.server_url.replace(/^http/, "ws").replace(/\/$/, "") + "/ws/daemon";
   console.log(chalk19.green(`Starting daemon ${identity.daemon_id} \u2192 ${wsUrl}`));
   let reconnectDelay = 1e3;
@@ -4613,18 +5855,34 @@ daemonCmd.command("run").description("Run the daemon WebSocket loop in foregroun
     ws.on("open", () => {
       reconnectDelay = 1e3;
       console.log(chalk19.green(`[${(/* @__PURE__ */ new Date()).toISOString()}] connected`));
+      const installedAgentProviders = detectInstalledAgentProviders();
+      if (installedAgentProviders.length > 0) {
+        console.log(
+          chalk19.dim(
+            `detected agent providers: ${installedAgentProviders.map((p) => `${p.agent_provider}${p.version ? ` (${p.version})` : ""}`).join(", ")}`
+          )
+        );
+      } else {
+        console.log(chalk19.yellow("no agent providers detected on PATH (claude / codex / cursor-agent)"));
+      }
       const hello = {
         type: "hello",
         daemon_id: identity.daemon_id,
-        version: DAEMON_VERSION,
+        version: readCliVersion(),
         hostname: identity.hostname,
-        platform: identity.platform
+        platform: identity.platform,
+        installed_agent_providers: installedAgentProviders
       };
       ws.send(JSON.stringify(hello));
-      const projects = loadConfig().sources.filter((source2) => source2.type === "project").map((source2) => ({ name: source2.name, path: source2.path, enabled: source2.enabled }));
-      const manifest = { type: "manifest", projects };
+      const manifest = buildManifest();
       ws.send(JSON.stringify(manifest));
-      console.log(chalk19.dim(`pushed manifest: ${projects.length} project(s)`));
+      console.log(chalk19.dim(`pushed manifest: ${manifest.projects.length} project(s)`));
+      const sink = {
+        send: (frame) => {
+          if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(frame));
+        }
+      };
+      bindAgentRunFrameSink(sink);
     });
     ws.on("message", (raw) => {
       let msg;
@@ -4642,10 +5900,16 @@ daemonCmd.command("run").description("Run the daemon WebSocket loop in foregroun
         console.error(chalk19.yellow(`server error: ${msg.message}`));
       } else if (msg.type === "rpc_request") {
         void dispatchRpc(ws, msg.id, msg.method, msg.params);
+      } else if (msg.type === "agent_run_resume_request") {
+        const sent = replayAfterRanges(msg.ranges);
+        if (sent > 0) {
+          console.log(chalk19.dim(`replayed ${sent} agent-run log frame(s) for hub`));
+        }
       }
     });
     ws.on("close", (code, reason) => {
       activeWs = null;
+      bindAgentRunFrameSink(null);
       const reasonText = reason.toString("utf-8") || "no reason";
       console.log(chalk19.yellow(`[${(/* @__PURE__ */ new Date()).toISOString()}] disconnected (code=${code}, ${reasonText})`));
       if (code === 4001) {
@@ -4709,6 +5973,55 @@ daemonCmd.command("show [daemonId]").description("Show local daemon identity (no
   const data = await jsonGet(`${base}/api/daemons/${encodeURIComponent(daemonId)}`);
   console.log(JSON.stringify(data.daemon, null, 2));
 });
+daemonCmd.command("status").description("Show this host's daemon status (identity, CLI version, service state)").option("--system", "Inspect the system-layer service status (default: user)").option("--json", "Emit a machine-readable JSON report instead of formatted text").action(async (opts) => {
+  const identity = loadRequiredIdentity();
+  const cliVersion = readCliVersion();
+  const scope = opts.system ? "system" : "user";
+  let serviceState = "unsupported";
+  let unitPath2 = null;
+  let serviceError = null;
+  if (isPlatformSupported()) {
+    try {
+      const svc = getServiceManager(scope);
+      serviceState = await svc.status();
+      unitPath2 = svc.unitPath();
+    } catch (error2) {
+      serviceState = "unknown";
+      serviceError = error2 instanceof Error ? error2.message : String(error2);
+    }
+  }
+  if (opts.json) {
+    console.log(JSON.stringify({
+      daemon_id: identity.daemon_id,
+      name: identity.name,
+      hostname: identity.hostname,
+      platform: identity.platform,
+      server_url: identity.server_url,
+      registered_at: identity.registered_at,
+      cli_version: cliVersion,
+      service: {
+        scope,
+        state: serviceState,
+        unit_path: unitPath2,
+        error: serviceError
+      }
+    }, null, 2));
+    return;
+  }
+  const stateColor = serviceState === "running" ? chalk19.green : serviceState === "stopped" || serviceState === "absent" ? chalk19.yellow : serviceState === "errored" || serviceState === "unknown" ? chalk19.red : chalk19.dim;
+  const label = (s) => chalk19.bold(s.padEnd(11));
+  console.log(`${label("daemon")}${identity.daemon_id} (${identity.name})`);
+  console.log(`${label("host")}${identity.hostname} \xB7 ${identity.platform}`);
+  console.log(`${label("server")}${identity.server_url}`);
+  console.log(`${label("cli")}v${cliVersion}`);
+  console.log(`${label("registered")}${identity.registered_at}`);
+  if (isPlatformSupported()) {
+    console.log(`${label("service")}${stateColor(serviceState)} (${scope})${unitPath2 ? `  \u2192  ${unitPath2}` : ""}`);
+    if (serviceError) console.log(chalk19.dim(`            ${serviceError}`));
+  } else {
+    console.log(`${label("service")}${chalk19.dim(`not supported on ${process.platform}`)}`);
+  }
+});
 daemonCmd.command("logout").description("Stop and uninstall the autostart service, then forget the locally stored daemon identity").option("--system", "Target the system-layer service").option("--keep-service", "Leave the installed service unit in place; only clear the identity file").action(async (opts) => {
   const scope = opts.system ? "system" : "user";
   if (!opts.keepService) {
@@ -4735,16 +6048,15 @@ daemonCmd.command("logout").description("Stop and uninstall the autostart servic
 // src/commands/user.ts
 import { Command as Command20 } from "commander";
 import chalk20 from "chalk";
-var DEFAULT_BASE2 = (process.env.TASK0_API_URL || "http://127.0.0.1:4318").replace(/\/$/, "");
 function serverBase2() {
-  return DEFAULT_BASE2;
+  return (process.env.TASK0_API_URL || "http://127.0.0.1:4318").replace(/\/$/, "");
 }
 function fail7(message, code = 1) {
   console.error(chalk20.red(message));
   process.exit(code);
 }
-async function callServer(path26, init = {}) {
-  const url = `${serverBase2()}${path26}`;
+async function callServer(path31, init = {}) {
+  const url = `${serverBase2()}${path31}`;
   let auth;
   try {
     auth = adminAuthHeader();
@@ -5247,6 +6559,160 @@ automation.command("runs <id>").description("List recent runs for an automation"
   for (const run4 of automation_runs) printRun(run4);
 });
 
+// src/commands/profile.ts
+import fs30 from "fs";
+import os7 from "os";
+import path30 from "path";
+import { Command as Command23 } from "commander";
+import chalk23 from "chalk";
+var VALID_NAME = /^[a-zA-Z0-9_-]+$/;
+function fail9(msg) {
+  console.error(chalk23.red(msg));
+  process.exit(1);
+}
+function legacyTask0Home() {
+  return path30.join(os7.homedir(), ".task0");
+}
+function readDaemonAt(home) {
+  const file = path30.join(home, "daemon.json");
+  if (!fs30.existsSync(file)) return null;
+  try {
+    return JSON.parse(fs30.readFileSync(file, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+var profile2 = new Command23("profile").description("Manage named CLI profiles (each isolates TASK0_HOME)");
+profile2.command("list").description("List configured profiles").action(() => {
+  const profiles = listProfiles();
+  const current = getCurrentProfileName();
+  const names = Object.keys(profiles);
+  if (names.length === 0) {
+    console.log("No profiles configured. Add one with `task0 profile add <name> --task0-home <path>`.");
+    console.log(chalk23.dim(`(currently running in legacy mode \u2014 TASK0_HOME=${process.env.TASK0_HOME ?? legacyTask0Home()})`));
+    return;
+  }
+  for (const name of names) {
+    const entry = profiles[name];
+    const marker = name === current ? chalk23.green("\u25CF ") : "  ";
+    const url = entry.api_url ? chalk23.dim(` \u2192 ${entry.api_url}`) : "";
+    console.log(`${marker}${name}  ${chalk23.dim(entry.task0_home)}${url}`);
+  }
+  if (!current) {
+    console.log(chalk23.dim("\nNo current profile selected. Use `task0 profile use <name>` to activate one."));
+  }
+});
+profile2.command("add <name>").description("Register a new profile").requiredOption("--task0-home <path>", "Directory to hold this profile's daemon/admin state (will be created if missing)").option("--api-url <url>", "API server URL the CLI should call when this profile is active").action((name, opts) => {
+  if (!VALID_NAME.test(name)) {
+    fail9(`Invalid profile name "${name}". Must match ${VALID_NAME}.`);
+  }
+  const existing = getProfile(name);
+  if (existing) {
+    fail9(`Profile "${name}" already exists.`);
+  }
+  const absHome = path30.resolve(opts.task0Home);
+  const profiles = listProfiles();
+  for (const [otherName, entry2] of Object.entries(profiles)) {
+    if (path30.resolve(entry2.task0_home) === absHome) {
+      fail9(`Profile "${otherName}" already uses task0_home "${absHome}". Two profiles cannot share a task0_home (service labels collide).`);
+    }
+  }
+  const parent = path30.dirname(absHome);
+  if (!fs30.existsSync(parent)) {
+    fail9(`Parent directory does not exist: ${parent}`);
+  }
+  try {
+    fs30.accessSync(parent, fs30.constants.W_OK);
+  } catch {
+    fail9(`Parent directory is not writable: ${parent}`);
+  }
+  const isFirstAdd = Object.keys(profiles).length === 0;
+  if (isFirstAdd && name !== "default") {
+    const legacyHome = legacyTask0Home();
+    const legacy = readDaemonAt(legacyHome);
+    if (legacy) {
+      addProfile("default", {
+        task0_home: legacyHome,
+        ...legacy.server_url ? { api_url: legacy.server_url } : {}
+      });
+      console.log(chalk23.dim(`Auto-imported existing ~/.task0 state as profile "default" (use \`task0 profile use default\` to keep using it).`));
+    }
+  }
+  const entry = {
+    task0_home: absHome,
+    ...opts.apiUrl ? { api_url: opts.apiUrl } : {}
+  };
+  addProfile(name, entry);
+  fs30.mkdirSync(absHome, { recursive: true });
+  const adopted = readDaemonAt(absHome);
+  if (adopted) {
+    console.log(chalk23.yellow(`warn: ${absHome} already contains daemon state. Profile "${name}" will adopt it.`));
+  }
+  console.log(chalk23.green(`Added profile "${name}"`));
+  console.log(`  task0_home: ${absHome}`);
+  if (entry.api_url) console.log(`  api_url:    ${entry.api_url}`);
+  console.log(chalk23.dim(`Use \`task0 profile use ${name}\` to activate.`));
+});
+profile2.command("remove <name>").description("Remove a profile entry (does not delete the task0_home directory)").option("-f, --force", "Allow removing the current profile (clears current_profile)").action((name, opts) => {
+  const entry = getProfile(name);
+  if (!entry) {
+    fail9(`Profile "${name}" not found.`);
+  }
+  const current = getCurrentProfileName();
+  if (current === name && !opts.force) {
+    fail9(`Profile "${name}" is current. Re-run with --force to remove it (this clears current_profile).`);
+  }
+  removeProfile(name);
+  console.log(chalk23.green(`Removed profile "${name}".`));
+  if (current === name) {
+    console.log(chalk23.dim("current_profile cleared. Use `task0 profile use <name>` to pick another."));
+  }
+  console.log(chalk23.dim(`Note: ${entry.task0_home} was not deleted.`));
+});
+profile2.command("use <name>").description("Set the current profile").action((name) => {
+  const entry = getProfile(name);
+  if (!entry) {
+    const names = Object.keys(listProfiles());
+    fail9(`Profile "${name}" not found. Available: ${names.length > 0 ? names.join(", ") : "(none)"}.`);
+  }
+  setCurrentProfile(name);
+  console.log(chalk23.green(`Now using profile "${name}".`));
+});
+profile2.command("current").description("Print the current profile name (exits non-zero if none)").action(() => {
+  const current = getCurrentProfileName();
+  if (!current) {
+    console.error(chalk23.dim("No current profile. Set one with `task0 profile use <name>`."));
+    process.exit(1);
+  }
+  console.log(current);
+});
+profile2.command("show [name]").description("Show a profile's configuration and detect drift vs daemon.json").action((name) => {
+  const target = name ?? getCurrentProfileName();
+  if (!target) {
+    fail9("No profile name given and no current_profile set. Pass a name or run `task0 profile use <name>` first.");
+  }
+  const entry = getProfile(target);
+  if (!entry) {
+    fail9(`Profile "${target}" not found.`);
+  }
+  const current = getCurrentProfileName();
+  console.log(`${chalk23.bold(target)}${current === target ? chalk23.green(" (current)") : ""}`);
+  console.log(`  task0_home: ${entry.task0_home}`);
+  console.log(`  api_url:    ${entry.api_url ?? chalk23.dim("(unset)")}`);
+  console.log(`  config:     ${configFilePath()}`);
+  const identity = readDaemonAt(entry.task0_home);
+  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 (entry.api_url && identity.server_url && entry.api_url !== 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 ${entry.api_url}`));
+  }
+});
+
 // src/core/error-capture.ts
 init_node();
 var DEFAULT_KEEP = 50;
@@ -5344,17 +6810,8 @@ function captureTopLevel(err, options) {
 }
 
 // src/main.ts
-var TASK0_VERSION = readVersion();
-function readVersion() {
-  try {
-    const here = path25.dirname(fileURLToPath2(import.meta.url));
-    const pkg = JSON.parse(readFileSync(path25.resolve(here, "..", "package.json"), "utf-8"));
-    return pkg.version ?? "unknown";
-  } catch {
-    return "unknown";
-  }
-}
-var program = new Command23().name("task0").description("Task-centric control layer for agent workflow").version(TASK0_VERSION);
+var TASK0_VERSION = readCliVersion();
+var program = new Command24().name("task0").description("Task-centric control layer for agent workflow").version(TASK0_VERSION).option("--profile <name>", "Use a named profile from ~/.config/task0/config.yml (overrides current_profile and TASK0_HOME)");
 program.addCommand(source);
 program.addCommand(project);
 program.addCommand(task);
@@ -5372,7 +6829,17 @@ program.addCommand(daemonCmd);
 program.addCommand(userCmd);
 program.addCommand(error);
 program.addCommand(automation);
+program.addCommand(profile2);
 async function main() {
+  try {
+    activateProfile(process.argv);
+  } catch (err) {
+    if (err instanceof ProfileNotFoundError) {
+      console.error(chalk24.red(err.message));
+      process.exit(1);
+    }
+    throw err;
+  }
   installErrorCapture({ version: TASK0_VERSION });
   try {
     await program.parseAsync(process.argv);