@task0/cli 0.5.0 → 0.7.0

package/dist/main.js

@@ -9,38 +9,30 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// ../../packages/shared/dist/types/task.js
-function isActiveTaskStatus(status) {
-  return ACTIVE_TASK_STATUS_SET.has(status);
+// ../../packages/shared/dist/node/yaml.js
+import fs from "fs";
+import path from "path";
+import yaml from "js-yaml";
+function readYaml(filePath) {
+  if (!fs.existsSync(filePath))
+    return null;
+  const raw = fs.readFileSync(filePath, "utf-8");
+  return yaml.load(raw);
 }
-var TASK_STATUS_VALUES, ACTIVE_TASK_STATUSES, ATTENTION_TASK_STATUSES, ACTIVE_TASK_STATUS_SET, ATTENTION_TASK_STATUS_SET;
-var init_task = __esm({
-  "../../packages/shared/dist/types/task.js"() {
+function writeYaml(filePath, data) {
+  fs.writeFileSync(filePath, yaml.dump(data, { lineWidth: 120 }), "utf-8");
+}
+function readContext(taskDir) {
+  const files = fs.readdirSync(taskDir).filter((f) => f.endsWith(".md"));
+  if (files.length === 0)
+    return void 0;
+  const content = fs.readFileSync(path.join(taskDir, files[0]), "utf-8");
+  const stripped = content.replace(/^---[\s\S]*?---\s*/, "");
+  return stripped.trim() || void 0;
+}
+var init_yaml = __esm({
+  "../../packages/shared/dist/node/yaml.js"() {
     "use strict";
-    TASK_STATUS_VALUES = [
-      "todo",
-      "triaging",
-      "triaged",
-      "planning",
-      "planned",
-      "refining",
-      "refined",
-      "executing",
-      "blocked",
-      "done",
-      "archived"
-    ];
-    ACTIVE_TASK_STATUSES = [
-      "triaging",
-      "planning",
-      "refining",
-      "executing"
-    ];
-    ATTENTION_TASK_STATUSES = [
-      "blocked"
-    ];
-    ACTIVE_TASK_STATUS_SET = new Set(ACTIVE_TASK_STATUSES);
-    ATTENTION_TASK_STATUS_SET = new Set(ATTENTION_TASK_STATUSES);
   }
 });
 
@@ -116,57 +108,65 @@ var init_object_id = __esm({
   }
 });
 
-// ../../packages/shared/dist/node/yaml.js
-import fs5 from "fs";
-import path6 from "path";
-import yaml3 from "js-yaml";
-function readYaml(filePath) {
-  if (!fs5.existsSync(filePath))
-    return null;
-  const raw = fs5.readFileSync(filePath, "utf-8");
-  return yaml3.load(raw);
-}
-function writeYaml(filePath, data) {
-  fs5.writeFileSync(filePath, yaml3.dump(data, { lineWidth: 120 }), "utf-8");
-}
-function readContext(taskDir) {
-  const files = fs5.readdirSync(taskDir).filter((f) => f.endsWith(".md"));
-  if (files.length === 0)
-    return void 0;
-  const content = fs5.readFileSync(path6.join(taskDir, files[0]), "utf-8");
-  const stripped = content.replace(/^---[\s\S]*?---\s*/, "");
-  return stripped.trim() || void 0;
+// ../../packages/shared/dist/types/task.js
+function isActiveTaskStatus(status) {
+  return ACTIVE_TASK_STATUS_SET.has(status);
 }
-var init_yaml = __esm({
-  "../../packages/shared/dist/node/yaml.js"() {
+var TASK_STATUS_VALUES, ACTIVE_TASK_STATUSES, ATTENTION_TASK_STATUSES, ACTIVE_TASK_STATUS_SET, ATTENTION_TASK_STATUS_SET;
+var init_task = __esm({
+  "../../packages/shared/dist/types/task.js"() {
     "use strict";
+    TASK_STATUS_VALUES = [
+      "todo",
+      "triaging",
+      "triaged",
+      "planning",
+      "planned",
+      "refining",
+      "refined",
+      "executing",
+      "blocked",
+      "done",
+      "archived"
+    ];
+    ACTIVE_TASK_STATUSES = [
+      "triaging",
+      "planning",
+      "refining",
+      "executing"
+    ];
+    ATTENTION_TASK_STATUSES = [
+      "blocked"
+    ];
+    ACTIVE_TASK_STATUS_SET = new Set(ACTIVE_TASK_STATUSES);
+    ATTENTION_TASK_STATUS_SET = new Set(ATTENTION_TASK_STATUSES);
   }
 });
 
 // ../../packages/shared/dist/node/scanner.js
-import fs6 from "fs";
-import path7 from "path";
+import fs2 from "fs";
+import path2 from "path";
 function scanProject(projectPath, sourceName) {
-  const absPath = path7.resolve(projectPath);
-  const resolvedSourceName = sourceName ?? path7.basename(absPath);
+  const absPath = path2.resolve(projectPath);
+  const resolvedSourceName = sourceName ?? path2.basename(absPath);
   const errors = [];
   const tasks = [];
   const repairs = [];
-  const projectYml = path7.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 = path7.join(absPath, projectConfig.tasks_dir);
-  if (!fs6.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 = fs6.readdirSync(tasksDir, { withFileTypes: true });
+  const entries = fs2.readdirSync(tasksDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const taskDir = path7.join(tasksDir, entry.name);
-    const taskYml = path7.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;
@@ -202,7 +202,7 @@ function scanProject(projectPath, sourceName) {
       continue;
     }
     const context = readContext(taskDir);
-    const stat = fs6.statSync(taskYml);
+    const stat = fs2.statSync(taskYml);
     const tags = raw.tags || [];
     const summary = raw.summary || void 0;
     const displayTitle = summary?.title || title;
@@ -245,18 +245,18 @@ var init_scanner = __esm({
 });
 
 // ../../packages/shared/dist/node/open-questions.js
-import fs7 from "fs";
-import path8 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 = path8.join(taskDir, file);
-    if (!fs7.existsSync(fullPath))
+    const fullPath = path3.join(taskDir, file);
+    if (!fs3.existsSync(fullPath))
       continue;
-    const md = fs7.readFileSync(fullPath, "utf-8");
+    const md = fs3.readFileSync(fullPath, "utf-8");
     const match = md.match(OPEN_QUESTIONS_SECTION_RE);
     if (!match)
       continue;
@@ -279,34 +279,34 @@ var init_open_questions = __esm({
 });
 
 // ../../packages/shared/dist/node/task-state.js
-import fs8 from "fs";
-import os3 from "os";
-import path9 from "path";
-import yaml4 from "js-yaml";
+import fs4 from "fs";
+import os from "os";
+import path4 from "path";
+import yaml2 from "js-yaml";
 function findProjectRoot(start = process.cwd()) {
-  let dir = path9.resolve(start);
+  let dir = path4.resolve(start);
   while (true) {
-    const ymlPath = path9.join(dir, "task0.yml");
-    if (fs8.existsSync(ymlPath)) {
+    const ymlPath = path4.join(dir, "task0.yml");
+    if (fs4.existsSync(ymlPath)) {
       try {
-        const raw = yaml4.load(fs8.readFileSync(ymlPath, "utf-8"));
+        const raw = yaml2.load(fs4.readFileSync(ymlPath, "utf-8"));
         if (raw?.kind === "project")
           return dir;
       } catch {
       }
     }
-    const parent = path9.dirname(dir);
+    const parent = path4.dirname(dir);
     if (parent === dir)
       return null;
     dir = parent;
   }
 }
 function readProjectConfig(projectRoot) {
-  return yaml4.load(fs8.readFileSync(path9.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 path9.isAbsolute(cfg.tasks_dir) ? cfg.tasks_dir : path9.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();
@@ -317,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 = fs8.readdirSync(tasksDir, { withFileTypes: true });
+  const entries = fs4.readdirSync(tasksDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const taskDir = path9.join(tasksDir, entry.name);
-    const taskYml = path9.join(taskDir, "task0.yml");
-    if (!fs8.existsSync(taskYml))
+    const taskDir = path4.join(tasksDir, entry.name);
+    const taskYml = path4.join(taskDir, "task0.yml");
+    if (!fs4.existsSync(taskYml))
       continue;
     try {
-      const raw = yaml4.load(fs8.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 };
       }
@@ -336,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 (!fs8.existsSync(taskYml))
+  if (!fs4.existsSync(taskYml))
     throw new Error(`task0.yml not found: ${taskYml}`);
-  return yaml4.load(fs8.readFileSync(taskYml, "utf-8")) || {};
+  return yaml2.load(fs4.readFileSync(taskYml, "utf-8")) || {};
 }
 function writeTaskYaml(taskYml, data) {
-  fs8.writeFileSync(taskYml, yaml4.dump(data, { lineWidth: 120 }), "utf-8");
+  fs4.writeFileSync(taskYml, yaml2.dump(data, { lineWidth: 120 }), "utf-8");
 }
 function taskYamlLockPath(taskDir) {
-  return path9.join(taskDir, TASK_YAML_LOCKFILE);
+  return path4.join(taskDir, TASK_YAML_LOCKFILE);
 }
 function isProcessAlive(pid) {
   try {
@@ -356,17 +356,17 @@ function isProcessAlive(pid) {
 }
 function readTaskYamlLockInfo(file) {
   try {
-    return JSON.parse(fs8.readFileSync(file, "utf-8"));
+    return JSON.parse(fs4.readFileSync(file, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeTaskYamlLockInfo(file, info) {
-  const fd = fs8.openSync(file, "wx");
+  const fd = fs4.openSync(file, "wx");
   try {
-    fs8.writeFileSync(fd, JSON.stringify(info, null, 2), "utf-8");
+    fs4.writeFileSync(fd, JSON.stringify(info, null, 2), "utf-8");
   } finally {
-    fs8.closeSync(fd);
+    fs4.closeSync(fd);
   }
 }
 function sleep(ms) {
@@ -376,7 +376,7 @@ async function acquireTaskYamlLock(taskDir) {
   const file = taskYamlLockPath(taskDir);
   const info = {
     pid: process.pid,
-    hostname: os3.hostname(),
+    hostname: os.hostname(),
     started_at: (/* @__PURE__ */ new Date()).toISOString()
   };
   const deadline = Date.now() + TASK_YAML_LOCK_TIMEOUT_MS;
@@ -392,7 +392,7 @@ async function acquireTaskYamlLock(taskDir) {
     const existing = readTaskYamlLockInfo(file);
     if (existing && existing.hostname === info.hostname && !isProcessAlive(existing.pid)) {
       try {
-        fs8.unlinkSync(file);
+        fs4.unlinkSync(file);
         continue;
       } catch (err) {
         if (err.code !== "ENOENT") {
@@ -414,7 +414,7 @@ function releaseTaskYamlLock(taskDir, info) {
     return;
   }
   try {
-    fs8.unlinkSync(file);
+    fs4.unlinkSync(file);
   } catch (err) {
     if (err.code !== "ENOENT") {
       throw err;
@@ -422,7 +422,7 @@ function releaseTaskYamlLock(taskDir, info) {
   }
 }
 async function withTaskYamlLock(taskDir, fn) {
-  const key = path9.resolve(taskDir);
+  const key = path4.resolve(taskDir);
   const prev = yamlLocks.get(key) ?? Promise.resolve();
   const next = prev.then(async () => {
     const lock = await acquireTaskYamlLock(taskDir);
@@ -453,7 +453,7 @@ function readTaskWorkflow(taskYml) {
   return raw.workflow || {};
 }
 async function updateTaskWorkflow(taskYml, patch) {
-  const taskDir = path9.dirname(taskYml);
+  const taskDir = path4.dirname(taskYml);
   return withTaskYamlLock(taskDir, () => {
     const raw = readTaskYaml(taskYml);
     const current = raw.workflow || {};
@@ -583,19 +583,19 @@ var init_redact = __esm({
 });
 
 // ../../packages/shared/dist/node/error-reports.js
-import fs9 from "fs";
-import os4 from "os";
-import path10 from "path";
+import fs5 from "fs";
+import os2 from "os";
+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 path10.join(os4.homedir(), ".task0");
+  return path5.join(os2.homedir(), ".task0");
 }
 function errorsRoot() {
-  return path10.join(task0Home(), "errors");
+  return path5.join(task0Home(), "errors");
 }
 function createErrorReportId() {
   return `err_${crypto.randomBytes(4).toString("hex")}`;
@@ -696,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 = path10.join(root, dirName);
-  fs9.mkdirSync(dir, { recursive: true });
-  const finalPath = path10.join(dir, REPORT_FILENAME);
-  const tmpPath = path10.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);
-  fs9.writeFileSync(tmpPath, json, "utf-8");
-  fs9.renameSync(tmpPath, finalPath);
+  fs5.writeFileSync(tmpPath, json, "utf-8");
+  fs5.renameSync(tmpPath, finalPath);
   return { dir, path: finalPath };
 }
 function parseReportDir(name) {
@@ -719,7 +719,7 @@ function listErrorReports(rootOverride) {
   };
   let entries;
   try {
-    entries = fs9.readdirSync(root, { withFileTypes: true });
+    entries = fs5.readdirSync(root, { withFileTypes: true });
   } catch (err) {
     if (err.code === "ENOENT")
       return result;
@@ -731,11 +731,11 @@ function listErrorReports(rootOverride) {
     const parsed = parseReportDir(entry.name);
     if (!parsed)
       continue;
-    const dir = path10.join(root, entry.name);
-    const file = path10.join(dir, REPORT_FILENAME);
+    const dir = path5.join(root, entry.name);
+    const file = path5.join(dir, REPORT_FILENAME);
     let raw;
     try {
-      raw = fs9.readFileSync(file, "utf-8");
+      raw = fs5.readFileSync(file, "utf-8");
     } catch {
       result.skipped.unreadable += 1;
       continue;
@@ -753,7 +753,7 @@ function listErrorReports(rootOverride) {
     }
     let size = 0;
     try {
-      size = fs9.statSync(file).size;
+      size = fs5.statSync(file).size;
     } catch {
     }
     result.reports.push({
@@ -788,7 +788,7 @@ function resolveErrorReport(query, rootOverride) {
   return { kind: "miss", query };
 }
 function readErrorReport(summary) {
-  const raw = fs9.readFileSync(summary.path, "utf-8");
+  const raw = fs5.readFileSync(summary.path, "utf-8");
   return JSON.parse(raw);
 }
 function pruneErrorReports(opts, rootOverride) {
@@ -826,7 +826,7 @@ function pruneErrorReports(opts, rootOverride) {
 }
 function removeReportDir(dir) {
   try {
-    fs9.rmSync(dir, { recursive: true, force: true });
+    fs5.rmSync(dir, { recursive: true, force: true });
     return true;
   } catch {
     return false;
@@ -844,9 +844,9 @@ var init_error_reports = __esm({
 });
 
 // ../../packages/shared/dist/node/file-lock.js
-import fs10 from "fs";
-import os5 from "os";
-import path11 from "path";
+import fs6 from "fs";
+import os3 from "os";
+import path6 from "path";
 var init_file_lock = __esm({
   "../../packages/shared/dist/node/file-lock.js"() {
     "use strict";
@@ -862,9 +862,9 @@ var init_tmux = __esm({
 });
 
 // ../../packages/shared/dist/node/agent-skills.js
-import fs11 from "fs";
-import path12 from "path";
-import yaml5 from "js-yaml";
+import fs7 from "fs";
+import path7 from "path";
+import yaml3 from "js-yaml";
 function isRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -873,7 +873,7 @@ function extractFrontmatter(raw) {
   if (!match)
     return null;
   try {
-    const parsed = yaml5.load(match[1]);
+    const parsed = yaml3.load(match[1]);
     return isRecord(parsed) ? parsed : null;
   } catch {
     return null;
@@ -881,9 +881,9 @@ function extractFrontmatter(raw) {
 }
 function readTextIfExists(filePath) {
   try {
-    if (!fs11.existsSync(filePath))
+    if (!fs7.existsSync(filePath))
       return null;
-    return fs11.readFileSync(filePath, "utf-8");
+    return fs7.readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -891,13 +891,13 @@ function readTextIfExists(filePath) {
 function getSymlinkInfo(...candidatePaths) {
   for (const candidatePath of candidatePaths) {
     try {
-      const stat = fs11.lstatSync(candidatePath);
+      const stat = fs7.lstatSync(candidatePath);
       if (!stat.isSymbolicLink())
         continue;
-      const target = fs11.readlinkSync(candidatePath);
+      const target = fs7.readlinkSync(candidatePath);
       return {
         isSymlink: true,
-        symlinkTarget: path12.isAbsolute(target) ? target : path12.resolve(path12.dirname(candidatePath), target)
+        symlinkTarget: path7.isAbsolute(target) ? target : path7.resolve(path7.dirname(candidatePath), target)
       };
     } catch {
     }
@@ -930,7 +930,7 @@ function normalizeBoolean(value) {
 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 = path12.basename(filePath), description2 = "", kind = "instruction") {
+function pushInstructionIfExists(skills, agent2, scope, filePath, name = path7.basename(filePath), description2 = "", kind = "instruction") {
   const raw = readTextIfExists(filePath);
   if (raw === null)
     return;
@@ -947,17 +947,17 @@ function pushInstructionIfExists(skills, agent2, scope, filePath, name = path12.
 function scanClaudeSkillDir(skills, skillsDir, scope) {
   let entries = [];
   try {
-    if (!fs11.existsSync(skillsDir))
+    if (!fs7.existsSync(skillsDir))
       return;
-    entries = fs11.readdirSync(skillsDir, { withFileTypes: true });
+    entries = fs7.readdirSync(skillsDir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
     if (!entry.isDirectory() && !entry.isSymbolicLink())
       continue;
-    const skillDirPath = path12.join(skillsDir, entry.name);
-    const skillFilePath = path12.join(skillDirPath, "SKILL.md");
+    const skillDirPath = path7.join(skillsDir, entry.name);
+    const skillFilePath = path7.join(skillDirPath, "SKILL.md");
     const raw = readTextIfExists(skillFilePath);
     if (raw === null)
       continue;
@@ -978,7 +978,7 @@ function scanCursorRuleFile(skills, filePath, scope) {
   if (raw === null)
     return;
   const frontmatter = extractFrontmatter(raw);
-  const baseName = path12.basename(filePath, ".mdc");
+  const baseName = path7.basename(filePath, ".mdc");
   skills.push({
     agent: "cursor",
     scope,
@@ -994,9 +994,9 @@ function scanCursorRuleFile(skills, filePath, scope) {
 function scanCursorRulesDir(skills, rulesDir, scope) {
   let entries = [];
   try {
-    if (!fs11.existsSync(rulesDir))
+    if (!fs7.existsSync(rulesDir))
       return;
-    entries = fs11.readdirSync(rulesDir, { withFileTypes: true });
+    entries = fs7.readdirSync(rulesDir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -1005,26 +1005,26 @@ function scanCursorRulesDir(skills, rulesDir, scope) {
       continue;
     if (!entry.isFile() && !entry.isSymbolicLink())
       continue;
-    scanCursorRuleFile(skills, path12.join(rulesDir, entry.name), scope);
+    scanCursorRuleFile(skills, path7.join(rulesDir, entry.name), scope);
   }
 }
 function getProjectAgentSkills(projectPath) {
-  const absProjectPath = path12.resolve(projectPath);
+  const absProjectPath = path7.resolve(projectPath);
   let projectStat;
   try {
-    projectStat = fs11.statSync(absProjectPath);
+    projectStat = fs7.statSync(absProjectPath);
   } catch {
     return [];
   }
   if (!projectStat.isDirectory())
     return [];
   const skills = [];
-  scanClaudeSkillDir(skills, path12.join(absProjectPath, ".claude", "skills"), "project");
-  pushInstructionIfExists(skills, "claude_code", "project", path12.join(absProjectPath, "CLAUDE.md"));
-  pushInstructionIfExists(skills, "claude_code", "project", path12.join(absProjectPath, "AGENTS.md"));
-  pushInstructionIfExists(skills, "codex", "project", path12.join(absProjectPath, "AGENTS.md"));
-  scanCursorRulesDir(skills, path12.join(absProjectPath, ".cursor", "rules"), "project");
-  pushInstructionIfExists(skills, "cursor", "project", path12.join(absProjectPath, ".cursorrules"), "Legacy Cursor Rules", "", "rule");
+  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() {
@@ -1032,8 +1032,8 @@ function getGlobalAgentSkills() {
   if (!homeDir)
     return [];
   const skills = [];
-  scanClaudeSkillDir(skills, path12.join(homeDir, ".claude", "skills"), "global");
-  scanCursorRulesDir(skills, path12.join(homeDir, ".cursor", "rules"), "global");
+  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;
@@ -1118,28 +1118,226 @@ var init_task_state2 = __esm({
 });
 
 // src/main.ts
-import { Command as Command23 } from "commander";
+import { Command as Command24 } from "commander";
+import chalk24 from "chalk";
+
+// src/core/config.ts
+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 loadHomeState() {
+  return readYamlFile(homeStateFile()) ?? {};
+}
+function saveHomeState(data) {
+  writeYamlFile(homeStateFile(), data);
+}
+function loadConfig() {
+  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 {
+    sources,
+    ...agentModels !== void 0 ? { agentModels } : {},
+    ...profiles ? { profiles } : {},
+    ...current ? { current_profile: current } : {}
+  };
+}
+function saveConfig(config) {
+  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();
+  const existing = config.sources.findIndex((s) => s.name === entry.name);
+  if (existing >= 0) {
+    config.sources[existing] = entry;
+  } else {
+    config.sources.push(entry);
+  }
+  saveConfig(config);
+}
+function removeSource(name) {
+  const config = loadConfig();
+  const idx = config.sources.findIndex((s) => s.name === name);
+  if (idx < 0) return false;
+  config.sources.splice(idx, 1);
+  saveConfig(config);
+  return true;
+}
+
+// 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
 import { Command } from "commander";
-import path3 from "path";
+import path11 from "path";
 import chalk from "chalk";
 
 // src/types.ts
 init_task();
 
 // src/core/admin-token.ts
-import fs from "fs";
-import os from "os";
-import path from "path";
-var CONFIG_DIR = path.join(os.homedir(), ".config", "task0");
-var TOKEN_FILE = path.join(CONFIG_DIR, "admin.token");
+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 ${TOKEN_FILE}.
+  \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";
@@ -1152,8 +1350,9 @@ function readAdminToken() {
     cached = fromEnv;
     return cached;
   }
-  if (fs.existsSync(TOKEN_FILE)) {
-    const v = fs.readFileSync(TOKEN_FILE, "utf-8").trim();
+  const file = tokenFile();
+  if (fs9.existsSync(file)) {
+    const v = fs9.readFileSync(file, "utf-8").trim();
     if (v) {
       cached = v;
       return cached;
@@ -1166,34 +1365,41 @@ function adminAuthHeader() {
 }
 
 // src/core/daemon-config.ts
-import fs2 from "fs";
-import os2 from "os";
-import path2 from "path";
-var CONFIG_DIR2 = path2.join(os2.homedir(), ".config", "task0");
-var CONFIG_FILE = path2.join(CONFIG_DIR2, "daemon.json");
+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 CONFIG_FILE;
+  return configFile();
 }
 function readDaemonIdentity() {
-  if (!fs2.existsSync(CONFIG_FILE)) return null;
+  const file = configFile();
+  if (!fs10.existsSync(file)) return null;
   try {
-    const raw = fs2.readFileSync(CONFIG_FILE, "utf-8");
+    const raw = fs10.readFileSync(file, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
 function writeDaemonIdentity(identity) {
-  fs2.mkdirSync(CONFIG_DIR2, { recursive: true });
-  fs2.writeFileSync(CONFIG_FILE, JSON.stringify(identity, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
+  const file = configFile();
+  fs10.mkdirSync(configDir(), { recursive: true });
+  fs10.writeFileSync(file, JSON.stringify(identity, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
   try {
-    fs2.chmodSync(CONFIG_FILE, 384);
+    fs10.chmodSync(file, 384);
   } catch {
   }
 }
 function clearDaemonIdentity() {
-  if (!fs2.existsSync(CONFIG_FILE)) return false;
-  fs2.unlinkSync(CONFIG_FILE);
+  const file = configFile();
+  if (!fs10.existsSync(file)) return false;
+  fs10.unlinkSync(file);
   return true;
 }
 
@@ -1231,7 +1437,7 @@ function resolveAuthHeader() {
   } 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" : "~/.config/task0/admin.token"}.`
+        `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;
@@ -1302,8 +1508,8 @@ function requireLocalDaemon() {
 }
 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 = path3.resolve(inputPath);
-  const name = opts.name || path3.basename(absPath);
+  const absPath = path11.resolve(inputPath);
+  const name = opts.name || path11.basename(absPath);
   const daemonId = requireLocalDaemon();
   let resp;
   try {
@@ -1401,9 +1607,9 @@ ${project2}`));
 
 // src/commands/project.ts
 import { Command as Command2 } from "commander";
-import fs3 from "fs";
-import path4 from "path";
-import yaml 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
@@ -1441,15 +1647,15 @@ project.command("list").description("List registered projects (queries the hub)"
 });
 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 = path4.join(cwd, "task0.yml");
-  if (fs3.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 };
-  fs3.writeFileSync(ymlPath, yaml.dump(config), "utf-8");
-  const tasksDir = path4.join(cwd, opts.tasksDir);
-  fs3.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}/`);
@@ -1497,11 +1703,11 @@ async function request(method, pathname, body) {
   }
 }
 var api = {
-  get: (path29) => request("GET", path29),
-  post: (path29, body) => request("POST", path29, body ?? {}),
-  put: (path29, body) => request("PUT", path29, body ?? {}),
-  patch: (path29, body) => request("PATCH", path29, body ?? {}),
-  del: (path29) => request("DELETE", path29)
+  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
@@ -1532,54 +1738,6 @@ async function waitForAgentRun(id, opts = {}) {
   }
 }
 
-// src/core/config.ts
-import fs4 from "fs";
-import path5 from "path";
-import yaml2 from "js-yaml";
-var CONFIG_DIR3 = path5.join(
-  process.env.HOME || process.env.USERPROFILE || "~",
-  ".config",
-  "task0"
-);
-var CONFIG_FILE2 = path5.join(CONFIG_DIR3, "config.yml");
-function ensureConfigDir() {
-  fs4.mkdirSync(CONFIG_DIR3, { recursive: true });
-}
-function defaultConfig() {
-  return { sources: [] };
-}
-function loadConfig() {
-  if (!fs4.existsSync(CONFIG_FILE2)) return defaultConfig();
-  const raw = fs4.readFileSync(CONFIG_FILE2, "utf-8");
-  const data = yaml2.load(raw);
-  return {
-    ...data ?? {},
-    sources: Array.isArray(data?.sources) ? data.sources : []
-  };
-}
-function saveConfig(config) {
-  ensureConfigDir();
-  fs4.writeFileSync(CONFIG_FILE2, yaml2.dump(config, { lineWidth: 120 }), "utf-8");
-}
-function addSource(entry) {
-  const config = loadConfig();
-  const existing = config.sources.findIndex((s) => s.name === entry.name);
-  if (existing >= 0) {
-    config.sources[existing] = entry;
-  } else {
-    config.sources.push(entry);
-  }
-  saveConfig(config);
-}
-function removeSource(name) {
-  const config = loadConfig();
-  const idx = config.sources.findIndex((s) => s.name === name);
-  if (idx < 0) return false;
-  config.sources.splice(idx, 1);
-  saveConfig(config);
-  return true;
-}
-
 // src/core/model-options.ts
 function resolveModelOptions(agent2, cli, warn = () => {
 }) {
@@ -2230,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" },
@@ -2252,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;
 }
@@ -4156,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;
@@ -4227,7 +4410,6 @@ 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 = path21.join(
       process.env.TMPDIR || "/tmp",
       `task0-agent-${result.agent.slug}-${Date.now()}.yml`
@@ -4352,7 +4534,8 @@ async function streamOutput(ref, agentRunId) {
 }
 
 // src/commands/daemon.ts
-import os8 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";
@@ -4431,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";
   }
@@ -4466,11 +4649,11 @@ import fs24 from "fs";
 import path23 from "path";
 
 // src/core/daemon-agent-run-dir.ts
+init_node();
 import fs23 from "fs";
-import os6 from "os";
 import path22 from "path";
 function agentRunRoot() {
-  return process.env.TASK0_DAEMON_AGENT_RUN_DIR || path22.join(os6.homedir(), ".config", "task0", "agent-run");
+  return process.env.TASK0_DAEMON_AGENT_RUN_DIR || path22.join(task0Home(), "agent-run");
 }
 function agentRunDir(runId) {
   return path22.join(agentRunRoot(), runId);
@@ -4649,6 +4832,20 @@ 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") {
@@ -4775,7 +4972,7 @@ var rpcHandlers = {
   // in the same task directory. Path is resolved from (projectName, taskId).
   async task_read(params) {
     const projectName = ensureString(params.projectName, "projectName");
-    const taskId = ensureString(params.taskId, "taskId");
+    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" });
@@ -4785,26 +4982,28 @@ var rpcHandlers = {
     if (!projectConfig) {
       throw Object.assign(new Error(`invalid project: missing task0.yml at ${projectAbs}`), { code: "invalid_project" });
     }
-    const taskDir = path24.join(projectAbs, projectConfig.tasks_dir, taskId);
+    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 yaml9 = readYaml(taskYml);
-    if (!yaml9) {
+    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: yaml9, files };
+    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 = ensureString(params.taskId, "taskId");
-    const yaml9 = params.yaml;
-    if (!yaml9 || typeof yaml9 !== "object") {
+    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 ?? {};
@@ -4817,12 +5016,14 @@ var rpcHandlers = {
     if (!projectConfig) {
       throw Object.assign(new Error(`invalid project: missing task0.yml at ${projectAbs}`), { code: "invalid_project" });
     }
-    const taskDir = path24.join(projectAbs, projectConfig.tasks_dir, taskId);
+    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"), yaml9);
+    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" });
@@ -4838,9 +5039,9 @@ var rpcHandlers = {
   // partial writes.
   async task_write_yaml(params, ctx) {
     const projectName = ensureString(params.projectName, "projectName");
-    const taskId = ensureString(params.taskId, "taskId");
-    const yaml9 = params.yaml;
-    if (!yaml9 || typeof yaml9 !== "object") {
+    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);
@@ -4852,12 +5053,14 @@ var rpcHandlers = {
     if (!projectConfig) {
       throw Object.assign(new Error(`invalid project: missing task0.yml at ${projectAbs}`), { code: "invalid_project" });
     }
-    const taskDir = path24.join(projectAbs, projectConfig.tasks_dir, taskId);
+    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, yaml9);
+    writeYaml(taskYml, yaml10);
     ctx.notifyManifestChanged();
     return { task_dir: taskDir };
   },
@@ -4865,7 +5068,7 @@ var rpcHandlers = {
   // 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 = ensureString(params.taskId, "taskId");
+    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" });
@@ -4875,7 +5078,9 @@ var rpcHandlers = {
     if (!projectConfig) {
       throw Object.assign(new Error(`invalid project: missing task0.yml at ${projectAbs}`), { code: "invalid_project" });
     }
-    const taskDir = path24.join(projectAbs, projectConfig.tasks_dir, taskId);
+    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" });
     }
@@ -4970,25 +5175,34 @@ function isInstalledBuild(p) {
 }
 
 // src/core/daemon-service/paths.ts
-import os7 from "os";
+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" ? path25.join(os7.homedir(), "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`) : path25.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" ? path25.join(os7.homedir(), ".config", "systemd", "user", `${SERVICE_LABEL}.service`) : path25.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 path25.join(os7.homedir(), ".task0", "logs");
+  return path25.join(task0Home(), "logs");
 }
 function logPaths() {
   const dir = logDir();
@@ -5002,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}
@@ -5031,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>
@@ -5044,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" });
@@ -5063,7 +5291,8 @@ function createLaunchdManager(scope) {
       args: inv.args,
       home: process.env.HOME ?? "/",
       out: logs.out,
-      err: logs.err
+      err: logs.err,
+      task0Env: collectTask0Env()
     });
     fs27.writeFileSync(file, body, { mode: 420 });
     const bootstrap = run2("launchctl", ["bootstrap", domainTarget(scope), file]);
@@ -5141,9 +5370,20 @@ 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
@@ -5156,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}
@@ -5172,7 +5412,7 @@ 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();
     fs28.mkdirSync(logDir(), { recursive: true });
@@ -5183,7 +5423,8 @@ function createSystemdManager(scope) {
       args: inv.args,
       out: logs.out,
       err: logs.err,
-      scope
+      scope,
+      task0Env: collectTask0Env2()
     });
     fs28.writeFileSync(file, body, { mode: 420 });
     const reload = run3("systemctl", [...scopeFlag(scope), "daemon-reload"]);
@@ -5271,6 +5512,73 @@ function readCliVersion() {
   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
 async function dispatchRpc(ws, id, method, params) {
   const handler = rpcHandlers[method];
@@ -5331,6 +5639,41 @@ function pushManifest(ws) {
   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);
@@ -5401,7 +5744,7 @@ daemonCmd.command("register").description("Register this host with a central ser
     throw error2;
   }
   const body = {
-    hostname: os8.hostname(),
+    hostname: os6.hostname(),
     platform: process.platform,
     name: opts.name
   };
@@ -5493,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;
@@ -5506,12 +5855,23 @@ 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: readCliVersion(),
         hostname: identity.hostname,
-        platform: identity.platform
+        platform: identity.platform,
+        installed_agent_providers: installedAgentProviders
       };
       ws.send(JSON.stringify(hello));
       const manifest = buildManifest();
@@ -5688,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_BASE = (process.env.TASK0_API_URL || "http://127.0.0.1:4318").replace(/\/$/, "");
 function serverBase2() {
-  return DEFAULT_BASE;
+  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(path29, init = {}) {
-  const url = `${serverBase2()}${path29}`;
+async function callServer(path31, init = {}) {
+  const url = `${serverBase2()}${path31}`;
   let auth;
   try {
     auth = adminAuthHeader();
@@ -6200,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;
@@ -6298,7 +6811,7 @@ function captureTopLevel(err, options) {
 
 // src/main.ts
 var TASK0_VERSION = readCliVersion();
-var program = new Command23().name("task0").description("Task-centric control layer for agent workflow").version(TASK0_VERSION);
+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);
@@ -6316,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);