@task0/cli 0.7.0 → 0.9.0

package/dist/main.js

@@ -492,6 +492,90 @@ var init_task_state = __esm({
   }
 });
 
+// ../../packages/shared/dist/node/paths.js
+import fs5 from "fs";
+import os2 from "os";
+import path5 from "path";
+function task0Home() {
+  const override = process.env.TASK0_HOME;
+  if (override && override.length > 0)
+    return override;
+  return path5.join(os2.homedir(), ".task0");
+}
+function profilesRoot() {
+  return path5.join(task0Home(), "profiles");
+}
+function currentProfileName() {
+  const fromEnv = process.env.TASK0_PROFILE?.trim();
+  if (fromEnv && PROFILE_NAME_RE.test(fromEnv))
+    return fromEnv;
+  const fromFile = readCurrentProfileFile();
+  if (fromFile && PROFILE_NAME_RE.test(fromFile))
+    return fromFile;
+  return DEFAULT_PROFILE_NAME;
+}
+function readCurrentProfileFile() {
+  const file = path5.join(profilesRoot(), CURRENT_PROFILE_FILE);
+  if (!fs5.existsSync(file))
+    return null;
+  try {
+    return fs5.readFileSync(file, "utf-8").trim() || null;
+  } catch {
+    return null;
+  }
+}
+function currentProfileFilePath() {
+  return path5.join(profilesRoot(), CURRENT_PROFILE_FILE);
+}
+function writeCurrentProfile(name) {
+  fs5.mkdirSync(profilesRoot(), { recursive: true });
+  const file = currentProfileFilePath();
+  if (name === null) {
+    if (fs5.existsSync(file))
+      fs5.unlinkSync(file);
+    return;
+  }
+  if (!PROFILE_NAME_RE.test(name)) {
+    throw new Error(`Invalid profile name "${name}". Must match ${PROFILE_NAME_RE}.`);
+  }
+  fs5.writeFileSync(file, name + "\n", "utf-8");
+}
+function profileDir(name) {
+  const resolved = name ?? currentProfileName();
+  if (!PROFILE_NAME_RE.test(resolved)) {
+    throw new Error(`Invalid profile name "${resolved}". Must match ${PROFILE_NAME_RE}.`);
+  }
+  return path5.join(profilesRoot(), resolved);
+}
+function listProfileNames() {
+  const root = profilesRoot();
+  if (!fs5.existsSync(root))
+    return [];
+  try {
+    return fs5.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && PROFILE_NAME_RE.test(entry.name)).map((entry) => entry.name).sort();
+  } catch {
+    return [];
+  }
+}
+function isValidProfileName(name) {
+  return PROFILE_NAME_RE.test(name);
+}
+function serverWorkingDir() {
+  const fromEnv = process.env.TASK0_SERVER_DIR?.trim();
+  if (fromEnv)
+    return fromEnv;
+  return path5.join(task0Home(), "server");
+}
+var DEFAULT_PROFILE_NAME, CURRENT_PROFILE_FILE, PROFILE_NAME_RE;
+var init_paths = __esm({
+  "../../packages/shared/dist/node/paths.js"() {
+    "use strict";
+    DEFAULT_PROFILE_NAME = "default";
+    CURRENT_PROFILE_FILE = ".current";
+    PROFILE_NAME_RE = /^[a-zA-Z0-9_-]+$/;
+  }
+});
+
 // ../../packages/shared/dist/types/error-report.js
 var ERROR_REPORT_SCHEMA_VERSION;
 var init_error_report = __esm({
@@ -583,19 +667,12 @@ var init_redact = __esm({
 });
 
 // ../../packages/shared/dist/node/error-reports.js
-import fs5 from "fs";
-import os2 from "os";
-import path5 from "path";
+import fs6 from "fs";
+import path6 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 path5.join(os2.homedir(), ".task0");
-}
 function errorsRoot() {
-  return path5.join(task0Home(), "errors");
+  return path6.join(profileDir(), "errors");
 }
 function createErrorReportId() {
   return `err_${crypto.randomBytes(4).toString("hex")}`;
@@ -696,13 +773,13 @@ function buildErrorReport(input) {
 function writeErrorReportSync(report, rootOverride) {
   const root = rootOverride ?? errorsRoot();
   const dirName = errorReportDirName(new Date(report.captured_at), report.id);
-  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 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 json = JSON.stringify(report, null, 2);
-  fs5.writeFileSync(tmpPath, json, "utf-8");
-  fs5.renameSync(tmpPath, finalPath);
+  fs6.writeFileSync(tmpPath, json, "utf-8");
+  fs6.renameSync(tmpPath, finalPath);
   return { dir, path: finalPath };
 }
 function parseReportDir(name) {
@@ -719,7 +796,7 @@ function listErrorReports(rootOverride) {
   };
   let entries;
   try {
-    entries = fs5.readdirSync(root, { withFileTypes: true });
+    entries = fs6.readdirSync(root, { withFileTypes: true });
   } catch (err) {
     if (err.code === "ENOENT")
       return result;
@@ -731,11 +808,11 @@ function listErrorReports(rootOverride) {
     const parsed = parseReportDir(entry.name);
     if (!parsed)
       continue;
-    const dir = path5.join(root, entry.name);
-    const file = path5.join(dir, REPORT_FILENAME);
+    const dir = path6.join(root, entry.name);
+    const file = path6.join(dir, REPORT_FILENAME);
     let raw;
     try {
-      raw = fs5.readFileSync(file, "utf-8");
+      raw = fs6.readFileSync(file, "utf-8");
     } catch {
       result.skipped.unreadable += 1;
       continue;
@@ -753,7 +830,7 @@ function listErrorReports(rootOverride) {
     }
     let size = 0;
     try {
-      size = fs5.statSync(file).size;
+      size = fs6.statSync(file).size;
     } catch {
     }
     result.reports.push({
@@ -788,7 +865,7 @@ function resolveErrorReport(query, rootOverride) {
   return { kind: "miss", query };
 }
 function readErrorReport(summary) {
-  const raw = fs5.readFileSync(summary.path, "utf-8");
+  const raw = fs6.readFileSync(summary.path, "utf-8");
   return JSON.parse(raw);
 }
 function pruneErrorReports(opts, rootOverride) {
@@ -826,7 +903,7 @@ function pruneErrorReports(opts, rootOverride) {
 }
 function removeReportDir(dir) {
   try {
-    fs5.rmSync(dir, { recursive: true, force: true });
+    fs6.rmSync(dir, { recursive: true, force: true });
     return true;
   } catch {
     return false;
@@ -837,6 +914,7 @@ var init_error_reports = __esm({
   "../../packages/shared/dist/node/error-reports.js"() {
     "use strict";
     init_error_report();
+    init_paths();
     init_redact();
     REPORT_FILENAME = "report.json";
     TMP_FILENAME = "report.json.tmp";
@@ -844,9 +922,9 @@ var init_error_reports = __esm({
 });
 
 // ../../packages/shared/dist/node/file-lock.js
-import fs6 from "fs";
+import fs7 from "fs";
 import os3 from "os";
-import path6 from "path";
+import path7 from "path";
 var init_file_lock = __esm({
   "../../packages/shared/dist/node/file-lock.js"() {
     "use strict";
@@ -862,8 +940,8 @@ var init_tmux = __esm({
 });
 
 // ../../packages/shared/dist/node/agent-skills.js
-import fs7 from "fs";
-import path7 from "path";
+import fs8 from "fs";
+import path8 from "path";
 import yaml3 from "js-yaml";
 function isRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
@@ -881,9 +959,9 @@ function extractFrontmatter(raw) {
 }
 function readTextIfExists(filePath) {
   try {
-    if (!fs7.existsSync(filePath))
+    if (!fs8.existsSync(filePath))
       return null;
-    return fs7.readFileSync(filePath, "utf-8");
+    return fs8.readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -891,13 +969,13 @@ function readTextIfExists(filePath) {
 function getSymlinkInfo(...candidatePaths) {
   for (const candidatePath of candidatePaths) {
     try {
-      const stat = fs7.lstatSync(candidatePath);
+      const stat = fs8.lstatSync(candidatePath);
       if (!stat.isSymbolicLink())
         continue;
-      const target = fs7.readlinkSync(candidatePath);
+      const target = fs8.readlinkSync(candidatePath);
       return {
         isSymlink: true,
-        symlinkTarget: path7.isAbsolute(target) ? target : path7.resolve(path7.dirname(candidatePath), target)
+        symlinkTarget: path8.isAbsolute(target) ? target : path8.resolve(path8.dirname(candidatePath), target)
       };
     } catch {
     }
@@ -930,7 +1008,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 = path7.basename(filePath), description2 = "", kind = "instruction") {
+function pushInstructionIfExists(skills, agent2, scope, filePath, name = path8.basename(filePath), description2 = "", kind = "instruction") {
   const raw = readTextIfExists(filePath);
   if (raw === null)
     return;
@@ -947,17 +1025,17 @@ function pushInstructionIfExists(skills, agent2, scope, filePath, name = path7.b
 function scanClaudeSkillDir(skills, skillsDir, scope) {
   let entries = [];
   try {
-    if (!fs7.existsSync(skillsDir))
+    if (!fs8.existsSync(skillsDir))
       return;
-    entries = fs7.readdirSync(skillsDir, { withFileTypes: true });
+    entries = fs8.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 skillDirPath = path8.join(skillsDir, entry.name);
+    const skillFilePath = path8.join(skillDirPath, "SKILL.md");
     const raw = readTextIfExists(skillFilePath);
     if (raw === null)
       continue;
@@ -978,7 +1056,7 @@ function scanCursorRuleFile(skills, filePath, scope) {
   if (raw === null)
     return;
   const frontmatter = extractFrontmatter(raw);
-  const baseName = path7.basename(filePath, ".mdc");
+  const baseName = path8.basename(filePath, ".mdc");
   skills.push({
     agent: "cursor",
     scope,
@@ -994,9 +1072,9 @@ function scanCursorRuleFile(skills, filePath, scope) {
 function scanCursorRulesDir(skills, rulesDir, scope) {
   let entries = [];
   try {
-    if (!fs7.existsSync(rulesDir))
+    if (!fs8.existsSync(rulesDir))
       return;
-    entries = fs7.readdirSync(rulesDir, { withFileTypes: true });
+    entries = fs8.readdirSync(rulesDir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -1005,26 +1083,26 @@ function scanCursorRulesDir(skills, rulesDir, scope) {
       continue;
     if (!entry.isFile() && !entry.isSymbolicLink())
       continue;
-    scanCursorRuleFile(skills, path7.join(rulesDir, entry.name), scope);
+    scanCursorRuleFile(skills, path8.join(rulesDir, entry.name), scope);
   }
 }
 function getProjectAgentSkills(projectPath) {
-  const absProjectPath = path7.resolve(projectPath);
+  const absProjectPath = path8.resolve(projectPath);
   let projectStat;
   try {
-    projectStat = fs7.statSync(absProjectPath);
+    projectStat = fs8.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");
+  scanClaudeSkillDir(skills, path8.join(absProjectPath, ".claude", "skills"), "project");
+  pushInstructionIfExists(skills, "claude_code", "project", path8.join(absProjectPath, "CLAUDE.md"));
+  pushInstructionIfExists(skills, "claude_code", "project", path8.join(absProjectPath, "AGENTS.md"));
+  pushInstructionIfExists(skills, "codex", "project", path8.join(absProjectPath, "AGENTS.md"));
+  scanCursorRulesDir(skills, path8.join(absProjectPath, ".cursor", "rules"), "project");
+  pushInstructionIfExists(skills, "cursor", "project", path8.join(absProjectPath, ".cursorrules"), "Legacy Cursor Rules", "", "rule");
   return sortSkills(skills);
 }
 function getGlobalAgentSkills() {
@@ -1032,8 +1110,8 @@ function getGlobalAgentSkills() {
   if (!homeDir)
     return [];
   const skills = [];
-  scanClaudeSkillDir(skills, path7.join(homeDir, ".claude", "skills"), "global");
-  scanCursorRulesDir(skills, path7.join(homeDir, ".cursor", "rules"), "global");
+  scanClaudeSkillDir(skills, path8.join(homeDir, ".claude", "skills"), "global");
+  scanCursorRulesDir(skills, path8.join(homeDir, ".cursor", "rules"), "global");
   return sortSkills(skills);
 }
 var AGENT_ORDER, SCOPE_ORDER, KIND_ORDER;
@@ -1065,6 +1143,7 @@ var init_node = __esm({
     init_scanner();
     init_open_questions();
     init_task_state();
+    init_paths();
     init_error_reports();
     init_redact();
     init_file_lock();
@@ -1089,7 +1168,7 @@ __export(task_state_exports, {
   withTaskYamlLock: () => withTaskYamlLock,
   writeTaskYaml: () => writeTaskYaml
 });
-import fs12 from "fs";
+import fs15 from "fs";
 function readWorkflow(taskYml) {
   return readTaskWorkflow(taskYml);
 }
@@ -1098,14 +1177,14 @@ async function updateWorkflow(taskYml, patch) {
 }
 function nextArtifactIndex(taskDir, prefix, ext = "md") {
   const pattern = new RegExp(`^${prefix}-(\\d+).*\\.${ext}$`);
-  const entries = fs12.readdirSync(taskDir);
+  const entries = fs15.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 (!fs12.existsSync(taskDir)) return null;
-  const matches = fs12.readdirSync(taskDir).filter((name) => pattern.test(name));
+  if (!fs15.existsSync(taskDir)) return null;
+  const matches = fs15.readdirSync(taskDir).filter((name) => pattern.test(name));
   if (matches.length === 0) return null;
   matches.sort();
   return matches[matches.length - 1] || null;
@@ -1118,115 +1197,42 @@ var init_task_state2 = __esm({
 });
 
 // src/main.ts
-import { Command as Command24 } from "commander";
-import chalk24 from "chalk";
+import { Command as Command25 } from "commander";
+import chalk25 from "chalk";
+
+// src/core/profile.ts
+init_node();
+import fs10 from "fs";
 
 // src/core/config.ts
 init_node();
-import fs8 from "fs";
-import os4 from "os";
-import path8 from "path";
+import fs9 from "fs";
+import path9 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 configFile() {
+  return path9.join(profileDir(), "config.yml");
 }
-function configFilePath() {
-  return registryFile();
+function defaultConfig() {
+  return { sources: [] };
 }
-function readYamlFile(file) {
-  if (!fs8.existsSync(file)) return null;
+function loadConfig() {
+  const file = configFile();
+  if (!fs9.existsSync(file)) return defaultConfig();
   try {
-    const raw = fs8.readFileSync(file, "utf-8");
-    const parsed = yaml4.load(raw);
-    return parsed ?? null;
+    const raw = fs9.readFileSync(file, "utf-8");
+    const data = yaml4.load(raw) ?? {};
+    return {
+      ...data,
+      sources: Array.isArray(data?.sources) ? data.sources : []
+    };
   } catch {
-    return null;
+    return defaultConfig();
   }
 }
-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);
+  const file = configFile();
+  fs9.mkdirSync(path9.dirname(file), { recursive: true });
+  fs9.writeFileSync(file, yaml4.dump(config, { lineWidth: 120 }), "utf-8");
 }
 function addSource(entry) {
   const config = loadConfig();
@@ -1246,6 +1252,9 @@ function removeSource(name) {
   saveConfig(config);
   return true;
 }
+function getApiUrl() {
+  return loadConfig().api_url;
+}
 
 // src/core/profile.ts
 var ProfileNotFoundError = class extends Error {
@@ -1284,42 +1293,238 @@ function isProfileSubcommandInvocation(argv) {
   }
   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()));
+function ensureDefaultProfile() {
+  fs10.mkdirSync(profileDir(DEFAULT_PROFILE_NAME), { recursive: true });
+  fs10.mkdirSync(profilesRoot(), { recursive: true });
+}
+function profileExists(name) {
+  if (!isValidProfileName(name)) return false;
+  try {
+    return fs10.statSync(profileDir(name)).isDirectory();
+  } catch {
+    return false;
   }
-  return { name: requested, entry };
 }
 var activeProfileCache = null;
+function getActiveProfile() {
+  return activeProfileCache;
+}
 function activateProfile(argv) {
+  ensureDefaultProfile();
   const flagValue = parseProfileFlag(argv);
-  let active2;
-  try {
-    active2 = resolveActiveProfile(flagValue);
-  } catch (error2) {
-    if (isProfileSubcommandInvocation(argv) && error2 instanceof ProfileNotFoundError && flagValue === null) {
-      active2 = null;
+  let name;
+  if (flagValue !== null) {
+    if (!isValidProfileName(flagValue) || !profileExists(flagValue)) {
+      if (!isProfileSubcommandInvocation(argv)) {
+        throw new ProfileNotFoundError(flagValue, listProfileNames());
+      }
+      name = DEFAULT_PROFILE_NAME;
     } else {
-      throw error2;
+      name = flagValue;
     }
+  } else {
+    name = currentProfileNameFromEnvOrFile();
+    if (!profileExists(name)) {
+      if (!isProfileSubcommandInvocation(argv)) {
+        throw new ProfileNotFoundError(name, listProfileNames());
+      }
+      name = DEFAULT_PROFILE_NAME;
+    }
+  }
+  process.env.TASK0_PROFILE = name;
+  const envApiUrlOverride = process.env.TASK0_API_URL?.trim() || void 0;
+  const apiUrl = getApiUrl();
+  activeProfileCache = {
+    name,
+    ...apiUrl ? { apiUrl } : {},
+    ...envApiUrlOverride ? { envApiUrlOverride } : {}
+  };
+  if (apiUrl && !envApiUrlOverride) {
+    process.env.TASK0_API_URL = apiUrl;
   }
-  if (active2) {
-    activeProfileCache = active2;
-    if (active2.entry.task0_home && active2.entry.task0_home.length > 0) {
-      process.env.TASK0_HOME = active2.entry.task0_home;
+}
+function currentProfileNameFromEnvOrFile() {
+  const fromEnv = process.env.TASK0_PROFILE?.trim();
+  if (fromEnv && isValidProfileName(fromEnv)) return fromEnv;
+  try {
+    const file = `${profilesRoot()}/.current`;
+    if (fs10.existsSync(file)) {
+      const v = fs10.readFileSync(file, "utf-8").trim();
+      if (v && isValidProfileName(v)) return v;
     }
-    if (active2.entry.api_url && !process.env.TASK0_API_URL) {
-      process.env.TASK0_API_URL = active2.entry.api_url;
+  } catch {
+  }
+  return DEFAULT_PROFILE_NAME;
+}
+
+// src/core/migrate-layout.ts
+init_node();
+import fs11 from "fs";
+import os4 from "os";
+import path10 from "path";
+import yaml5 from "js-yaml";
+var MIGRATION_MARKER = ".migrated-v1";
+function legacyDaemonJson() {
+  return path10.join(task0Home(), "daemon.json");
+}
+function legacyErrorsDir() {
+  return path10.join(task0Home(), "errors");
+}
+function legacyAgentRunDir() {
+  return path10.join(task0Home(), "agent-run");
+}
+function legacyLogsDir() {
+  return path10.join(task0Home(), "logs");
+}
+function legacyServerConfigYml() {
+  return path10.join(task0Home(), "config.yml");
+}
+function legacyRegistryDir() {
+  return path10.join(process.env.HOME || process.env.USERPROFILE || os4.homedir(), ".config", "task0");
+}
+function legacyRegistryFile() {
+  return path10.join(legacyRegistryDir(), "config.yml");
+}
+function migrationMarkerPath() {
+  return path10.join(profilesRoot(), MIGRATION_MARKER);
+}
+function safeMv(from, to, steps, opts = {}) {
+  if (!fs11.existsSync(from)) return false;
+  if (fs11.existsSync(to)) {
+    steps.push({ kind: "skip", from, to, detail: "destination already exists" });
+    return false;
+  }
+  if (!opts.dryRun) {
+    fs11.mkdirSync(path10.dirname(to), { recursive: true });
+    fs11.renameSync(from, to);
+  }
+  steps.push({ kind: "mv", from, to });
+  return true;
+}
+function readYamlSafe(file) {
+  if (!fs11.existsSync(file)) return null;
+  try {
+    const raw = fs11.readFileSync(file, "utf-8");
+    return yaml5.load(raw) ?? null;
+  } catch {
+    return null;
+  }
+}
+function extractCliKeysFromLegacyConfig() {
+  const data = readYamlSafe(legacyServerConfigYml());
+  if (!data || typeof data !== "object") return null;
+  const out = {};
+  if (Array.isArray(data.sources)) {
+    const projects = data.sources.filter((s) => s?.type === "project");
+    if (projects.length > 0) out.sources = projects;
+  }
+  if (data.agentModels && typeof data.agentModels === "object") {
+    out.agentModels = data.agentModels;
+  }
+  return Object.keys(out).length > 0 ? out : null;
+}
+function reconstructProfilesFromRegistry(steps, opts = {}) {
+  const file = legacyRegistryFile();
+  const data = readYamlSafe(file);
+  if (!data?.profiles || typeof data.profiles !== "object") return;
+  for (const [name, entry] of Object.entries(data.profiles)) {
+    if (!isValidProfileName(name)) continue;
+    const dir = profileDir(name);
+    if (!opts.dryRun) fs11.mkdirSync(dir, { recursive: true });
+    steps.push({ kind: "mkdir", to: dir });
+    const profileConfig = {};
+    if (entry.api_url) profileConfig.api_url = entry.api_url;
+    const profileConfigFile = path10.join(dir, "config.yml");
+    if (!fs11.existsSync(profileConfigFile) && Object.keys(profileConfig).length > 0) {
+      if (!opts.dryRun) {
+        fs11.writeFileSync(profileConfigFile, yaml5.dump(profileConfig, { lineWidth: 120 }), "utf-8");
+      }
+      steps.push({ kind: "write", to: profileConfigFile, detail: `api_url=${entry.api_url}` });
+    }
+    if (entry.task0_home) {
+      const oldDaemonJson = path10.join(entry.task0_home, "daemon.json");
+      const newDaemonJson = path10.join(dir, "daemon.json");
+      if (fs11.existsSync(oldDaemonJson) && !fs11.existsSync(newDaemonJson)) {
+        safeMv(oldDaemonJson, newDaemonJson, steps, opts);
+      }
     }
   }
+  if (data.current_profile && isValidProfileName(data.current_profile)) {
+    if (!opts.dryRun) writeCurrentProfile(data.current_profile);
+    steps.push({ kind: "write", to: path10.join(profilesRoot(), ".current"), detail: data.current_profile });
+  }
+  const backup = file + ".migrated-bak";
+  if (fs11.existsSync(file) && !fs11.existsSync(backup)) {
+    if (!opts.dryRun) fs11.renameSync(file, backup);
+    steps.push({ kind: "mv", from: file, to: backup, detail: "legacy v0.7.0 registry archived" });
+  }
+}
+function migrateCliLayout(opts = {}) {
+  const result = { ran: false, steps: [], alreadyMigrated: false };
+  if (fs11.existsSync(migrationMarkerPath())) {
+    result.alreadyMigrated = true;
+    return result;
+  }
+  if (!opts.dryRun) fs11.mkdirSync(profilesRoot(), { recursive: true });
+  const defaultDir = profileDir(DEFAULT_PROFILE_NAME);
+  if (!fs11.existsSync(defaultDir)) {
+    if (!opts.dryRun) fs11.mkdirSync(defaultDir, { recursive: true });
+    result.steps.push({ kind: "mkdir", to: defaultDir });
+  }
+  safeMv(legacyDaemonJson(), path10.join(defaultDir, "daemon.json"), result.steps, opts);
+  safeMv(legacyErrorsDir(), path10.join(defaultDir, "errors"), result.steps, opts);
+  safeMv(legacyAgentRunDir(), path10.join(defaultDir, "agent-run"), result.steps, opts);
+  safeMv(legacyLogsDir(), path10.join(defaultDir, "logs"), result.steps, opts);
+  const cliKeys = extractCliKeysFromLegacyConfig();
+  if (cliKeys) {
+    const target = path10.join(defaultDir, "config.yml");
+    if (!fs11.existsSync(target)) {
+      if (!opts.dryRun) {
+        fs11.writeFileSync(target, yaml5.dump(cliKeys, { lineWidth: 120 }), "utf-8");
+      }
+      result.steps.push({ kind: "write", to: target, detail: "extracted CLI keys from legacy config.yml" });
+    }
+    const data = readYamlSafe(legacyServerConfigYml());
+    if (data) {
+      let dirty = false;
+      if (Array.isArray(data.sources)) {
+        const nonProjectOnly = data.sources.filter((s) => s?.type !== "project");
+        if (nonProjectOnly.length !== data.sources.length) {
+          data.sources = nonProjectOnly;
+          dirty = true;
+        }
+      }
+      if (data.agentModels) {
+        delete data.agentModels;
+        dirty = true;
+      }
+      if (dirty) {
+        if (!opts.dryRun) {
+          fs11.writeFileSync(legacyServerConfigYml(), yaml5.dump(data, { lineWidth: 120 }), "utf-8");
+        }
+        result.steps.push({ kind: "extract", from: legacyServerConfigYml(), detail: "stripped CLI-owned keys" });
+      }
+    }
+  }
+  if (fs11.existsSync(legacyRegistryFile())) {
+    reconstructProfilesFromRegistry(result.steps, opts);
+  }
+  if (!opts.dryRun) {
+    fs11.writeFileSync(migrationMarkerPath(), (/* @__PURE__ */ new Date()).toISOString() + "\n", "utf-8");
+  }
+  result.ran = result.steps.length > 0;
+  return result;
+}
+function resetMigrationMarker() {
+  const marker = migrationMarkerPath();
+  if (!fs11.existsSync(marker)) return false;
+  fs11.unlinkSync(marker);
+  return true;
 }
 
 // src/commands/source.ts
 import { Command } from "commander";
-import path11 from "path";
+import path13 from "path";
 import chalk from "chalk";
 
 // src/types.ts
@@ -1327,10 +1532,10 @@ init_task();
 
 // src/core/admin-token.ts
 init_node();
-import fs9 from "fs";
-import path9 from "path";
+import fs12 from "fs";
+import path11 from "path";
 function tokenFile() {
-  return path9.join(task0Home(), "admin.token");
+  return path11.join(serverWorkingDir(), "admin.token");
 }
 var cached = null;
 var AdminTokenUnavailableError = class extends Error {
@@ -1351,8 +1556,8 @@ function readAdminToken() {
     return cached;
   }
   const file = tokenFile();
-  if (fs9.existsSync(file)) {
-    const v = fs9.readFileSync(file, "utf-8").trim();
+  if (fs12.existsSync(file)) {
+    const v = fs12.readFileSync(file, "utf-8").trim();
     if (v) {
       cached = v;
       return cached;
@@ -1366,40 +1571,37 @@ function adminAuthHeader() {
 
 // 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");
+import fs13 from "fs";
+import path12 from "path";
+function configFile2() {
+  return path12.join(profileDir(), "daemon.json");
 }
 function daemonConfigPath() {
-  return configFile();
+  return configFile2();
 }
 function readDaemonIdentity() {
-  const file = configFile();
-  if (!fs10.existsSync(file)) return null;
+  const file = configFile2();
+  if (!fs13.existsSync(file)) return null;
   try {
-    const raw = fs10.readFileSync(file, "utf-8");
+    const raw = fs13.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 });
+  const file = configFile2();
+  fs13.mkdirSync(path12.dirname(file), { recursive: true });
+  fs13.writeFileSync(file, JSON.stringify(identity, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
   try {
-    fs10.chmodSync(file, 384);
+    fs13.chmodSync(file, 384);
   } catch {
   }
 }
 function clearDaemonIdentity() {
-  const file = configFile();
-  if (!fs10.existsSync(file)) return false;
-  fs10.unlinkSync(file);
+  const file = configFile2();
+  if (!fs13.existsSync(file)) return false;
+  fs13.unlinkSync(file);
   return true;
 }
 
@@ -1501,15 +1703,15 @@ function requireLocalDaemon() {
   const id = localDaemonId();
   if (!id) {
     console.error(chalk.red("This host is not registered as a daemon."));
-    console.error(chalk.dim("Run `task0 daemon register --server <url>` first."));
+    console.error(chalk.dim("Run `task0 daemon register` first (set api_url with `task0 profile set api_url <url>` if needed)."));
     process.exit(1);
   }
   return id;
 }
 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 absPath = path13.resolve(inputPath);
+  const name = opts.name || path13.basename(absPath);
   const daemonId = requireLocalDaemon();
   let resp;
   try {
@@ -1607,9 +1809,9 @@ ${project2}`));
 
 // src/commands/project.ts
 import { Command as Command2 } from "commander";
-import fs11 from "fs";
-import path12 from "path";
-import yaml5 from "js-yaml";
+import fs14 from "fs";
+import path14 from "path";
+import yaml6 from "js-yaml";
 import chalk2 from "chalk";
 
 // ../../packages/shared/dist/index.js
@@ -1647,15 +1849,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 = path12.join(cwd, "task0.yml");
-  if (fs11.existsSync(ymlPath)) {
+  const ymlPath = path14.join(cwd, "task0.yml");
+  if (fs14.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 };
-  fs11.writeFileSync(ymlPath, yaml5.dump(config), "utf-8");
-  const tasksDir = path12.join(cwd, opts.tasksDir);
-  fs11.mkdirSync(tasksDir, { recursive: true });
+  fs14.writeFileSync(ymlPath, yaml6.dump(config), "utf-8");
+  const tasksDir = path14.join(cwd, opts.tasksDir);
+  fs14.mkdirSync(tasksDir, { recursive: true });
   console.log(chalk2.green("Initialized task0 project"));
   console.log(`  ${ymlPath}`);
   console.log(`  ${tasksDir}/`);
@@ -1664,9 +1866,9 @@ 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 fs17 from "fs";
-import path15 from "path";
-import yaml6 from "js-yaml";
+import fs20 from "fs";
+import path17 from "path";
+import yaml7 from "js-yaml";
 import chalk8 from "chalk";
 
 // src/lib/api.ts
@@ -1703,18 +1905,18 @@ async function request(method, pathname, body) {
   }
 }
 var api = {
-  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)
+  get: (path32) => request("GET", path32),
+  post: (path32, body) => request("POST", path32, body ?? {}),
+  put: (path32, body) => request("PUT", path32, body ?? {}),
+  patch: (path32, body) => request("PATCH", path32, body ?? {}),
+  del: (path32) => request("DELETE", path32)
 };
 
 // src/commands/task/triage.ts
 import { Command as Command3 } from "commander";
 import chalk3 from "chalk";
-import fs13 from "fs";
-import path13 from "path";
+import fs16 from "fs";
+import path15 from "path";
 
 // src/core/agent-run-wait.ts
 async function getAgentRun(id) {
@@ -1765,8 +1967,8 @@ init_task_state2();
 var ISSUE_DETAIL_RE = /^ISSUE-\d+\.md$/;
 var TRIAGE_SKILL_NAME = "triage";
 function resolveSkillFilePath(projectRoot, skillName) {
-  const p = path13.join(projectRoot, ".claude", "skills", skillName, "SKILL.md");
-  return fs13.existsSync(p) ? p : null;
+  const p = path15.join(projectRoot, ".claude", "skills", skillName, "SKILL.md");
+  return fs16.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 {
@@ -1785,7 +1987,7 @@ var triage = new Command3("triage").description("Decompose IDEA into ISSUE.md +
         process.exit(1);
       }
       for (const name of existingIssues) {
-        fs13.rmSync(path13.join(loc.taskDir, name), { force: true });
+        fs16.rmSync(path15.join(loc.taskDir, name), { force: true });
       }
     }
     if (opts.model || opts.effort) {
@@ -1823,8 +2025,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 = fs13.existsSync(path13.join(loc.taskDir, "ISSUE.md"));
-      const issueFiles = fs13.readdirSync(loc.taskDir).filter((name) => ISSUE_DETAIL_RE.test(name)).sort();
+      const hasOverview = fs16.existsSync(path15.join(loc.taskDir, "ISSUE.md"));
+      const issueFiles = fs16.readdirSync(loc.taskDir).filter((name) => ISSUE_DETAIL_RE.test(name)).sort();
       if (!hasOverview || issueFiles.length === 0) {
         const missing = [];
         if (!hasOverview) missing.push("ISSUE.md");
@@ -1834,7 +2036,7 @@ var triage = new Command3("triage").description("Decompose IDEA into ISSUE.md +
       }
       let blockingQuestionCount = 0;
       for (const name of issueFiles) {
-        const content = fs13.readFileSync(path13.join(loc.taskDir, name), "utf-8");
+        const content = fs16.readFileSync(path15.join(loc.taskDir, name), "utf-8");
         blockingQuestionCount += countBlockingQuestions(content);
       }
       await updateWorkflow(loc.taskYml, {
@@ -1862,8 +2064,8 @@ var triage = new Command3("triage").description("Decompose IDEA into ISSUE.md +
   }
 });
 function listIssueArtifacts(taskDir) {
-  if (!fs13.existsSync(taskDir)) return [];
-  return fs13.readdirSync(taskDir).filter((name) => name === "ISSUE.md" || ISSUE_DETAIL_RE.test(name)).sort();
+  if (!fs16.existsSync(taskDir)) return [];
+  return fs16.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);
@@ -1877,13 +2079,13 @@ function countBlockingQuestions(md) {
 // src/commands/task/exec.ts
 import { Command as Command4 } from "commander";
 import chalk4 from "chalk";
-import fs14 from "fs";
-import path14 from "path";
+import fs17 from "fs";
+import path16 from "path";
 init_task_state2();
 var PLAN_EXECUTE_SKILL_NAME = "plan-execute";
 function resolveSkillFilePath2(projectRoot, skillName) {
-  const p = path14.join(projectRoot, ".claude", "skills", skillName, "SKILL.md");
-  return fs14.existsSync(p) ? p : null;
+  const p = path16.join(projectRoot, ".claude", "skills", skillName, "SKILL.md");
+  return fs17.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 {
@@ -1976,7 +2178,7 @@ var summarize = new Command5("summarize").description("Generate a concise title
 });
 
 // src/commands/task/comment.ts
-import fs15 from "fs";
+import fs18 from "fs";
 import { Command as Command6 } from "commander";
 import chalk6 from "chalk";
 var comment = new Command6("comment").description("Manage comments on a task");
@@ -1986,8 +2188,8 @@ function fail(err) {
 }
 function readBodyFromOpts(opts) {
   if (opts.body !== void 0) return opts.body;
-  if (opts.file === "-") return fs15.readFileSync(0, "utf-8");
-  if (opts.file) return fs15.readFileSync(opts.file, "utf-8");
+  if (opts.file === "-") return fs18.readFileSync(0, "utf-8");
+  if (opts.file) return fs18.readFileSync(opts.file, "utf-8");
   throw new Error("Provide --body or --file");
 }
 function preview(body, width = 60) {
@@ -2086,7 +2288,7 @@ comment.command("delete <cmtId>").description("Delete a comment by its cmt_ id")
 });
 
 // src/commands/task/description.ts
-import fs16 from "fs";
+import fs19 from "fs";
 import { Command as Command7 } from "commander";
 import chalk7 from "chalk";
 var description = new Command7("description").description("Show or update the task description");
@@ -2096,8 +2298,8 @@ function fail2(err) {
 }
 function readBodyFromOpts2(opts) {
   if (opts.body !== void 0) return opts.body;
-  if (opts.file === "-") return fs16.readFileSync(0, "utf-8");
-  if (opts.file) return fs16.readFileSync(opts.file, "utf-8");
+  if (opts.file === "-") return fs19.readFileSync(0, "utf-8");
+  if (opts.file) return fs19.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) => {
@@ -2146,12 +2348,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 = path15.join(cwd, "task0.yml");
-  if (!fs17.existsSync(projectYml)) {
+  const projectYml = path17.join(cwd, "task0.yml");
+  if (!fs20.existsSync(projectYml)) {
     console.error(chalk8.red("Not a task0 project (task0.yml not found). Run `task0 project init` first."));
     process.exit(1);
   }
-  const projectConfig = yaml6.load(fs17.readFileSync(projectYml, "utf-8"));
+  const projectConfig = yaml7.load(fs20.readFileSync(projectYml, "utf-8"));
   if (projectConfig.kind !== "project") {
     console.error(chalk8.red('Invalid task0.yml: kind is not "project"'));
     process.exit(1);
@@ -2167,38 +2369,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 = path15.join(cwd, "task0.yml");
-  if (!fs17.existsSync(projectYml)) {
+  const projectYml = path17.join(cwd, "task0.yml");
+  if (!fs20.existsSync(projectYml)) {
     console.error(chalk8.red("Not a task0 project (task0.yml not found). Run `task0 project init` first."));
     process.exit(1);
   }
-  const projectConfig = yaml6.load(fs17.readFileSync(projectYml, "utf-8"));
+  const projectConfig = yaml7.load(fs20.readFileSync(projectYml, "utf-8"));
   if (projectConfig.kind !== "project") {
     console.error(chalk8.red('Invalid task0.yml: kind is not "project"'));
     process.exit(1);
   }
-  const tasksDir = path15.join(cwd, projectConfig.tasks_dir);
-  if (!fs17.existsSync(tasksDir)) {
+  const tasksDir = path17.join(cwd, projectConfig.tasks_dir);
+  if (!fs20.existsSync(tasksDir)) {
     console.error(chalk8.red(`Tasks directory not found: ${tasksDir}`));
     process.exit(1);
   }
-  const entries = fs17.readdirSync(tasksDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  const entries = fs20.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 = path15.join(tasksDir, name);
-    const taskYml = path15.join(taskDir, "task0.yml");
-    if (fs17.existsSync(taskYml)) {
+    const taskDir = path17.join(tasksDir, name);
+    const taskYml = path17.join(taskDir, "task0.yml");
+    if (fs20.existsSync(taskYml)) {
       skipped++;
       try {
-        const raw = yaml6.load(fs17.readFileSync(taskYml, "utf-8"));
+        const raw = yaml7.load(fs20.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 {
-            fs17.writeFileSync(taskYml, yaml6.dump(raw, { lineWidth: 120 }), "utf-8");
+            fs20.writeFileSync(taskYml, yaml7.dump(raw, { lineWidth: 120 }), "utf-8");
             console.log(chalk8.green(`  seed object_id: ${taskYml}`));
           }
           seededObjectIds++;
@@ -2223,7 +2425,7 @@ task.command("migrate").description("Add task0.yml to legacy task directories th
     if (opts.dryRun) {
       console.log(chalk8.dim(`[dry-run] ${taskYml}`));
     } else {
-      fs17.writeFileSync(taskYml, yaml6.dump(taskConfig), "utf-8");
+      fs20.writeFileSync(taskYml, yaml7.dump(taskConfig), "utf-8");
       console.log(chalk8.green(`  ${taskYml}`));
     }
     migrated++;
@@ -2283,7 +2485,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 = yaml6.load(fs17.readFileSync(loc.taskYml, "utf-8"));
+    const raw = yaml7.load(fs20.readFileSync(loc.taskYml, "utf-8"));
     if (opts.phase) {
       const phase = opts.phase.trim();
       if (!phase) {
@@ -2296,7 +2498,7 @@ task.command("done <id>").description("Write task lifecycle state to task0.yml \
         return;
       }
       raw.workflow = { ...workflow2, phase };
-      fs17.writeFileSync(loc.taskYml, yaml6.dump(raw, { lineWidth: 120 }), "utf-8");
+      fs20.writeFileSync(loc.taskYml, yaml7.dump(raw, { lineWidth: 120 }), "utf-8");
       console.log(chalk8.green(`${id} phase: ${phase}`));
       return;
     }
@@ -2307,7 +2509,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" };
-    fs17.writeFileSync(loc.taskYml, yaml6.dump(raw, { lineWidth: 120 }), "utf-8");
+    fs20.writeFileSync(loc.taskYml, yaml7.dump(raw, { lineWidth: 120 }), "utf-8");
     console.log(chalk8.green(`${id} marked as done`));
   } catch (err) {
     console.error(chalk8.red(err.message));
@@ -2316,33 +2518,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 = path15.join(cwd, "task0.yml");
-  if (!fs17.existsSync(projectYml)) {
+  const projectYml = path17.join(cwd, "task0.yml");
+  if (!fs20.existsSync(projectYml)) {
     console.error(chalk8.red("Not a task0 project (task0.yml not found)."));
     process.exit(1);
   }
-  const projectConfig = yaml6.load(fs17.readFileSync(projectYml, "utf-8"));
+  const projectConfig = yaml7.load(fs20.readFileSync(projectYml, "utf-8"));
   if (projectConfig.kind !== "project") {
     console.error(chalk8.red('Invalid task0.yml: kind is not "project"'));
     process.exit(1);
   }
-  const tasksDir = path15.join(cwd, projectConfig.tasks_dir);
-  const taskDir = path15.join(tasksDir, id);
-  if (!fs17.existsSync(taskDir)) {
+  const tasksDir = path17.join(cwd, projectConfig.tasks_dir);
+  const taskDir = path17.join(tasksDir, id);
+  if (!fs20.existsSync(taskDir)) {
     console.error(chalk8.red(`Task "${id}" not found at ${taskDir}`));
     process.exit(1);
   }
   const tarFile = tasksDir + ".tar";
   archiveTaskToTar(tasksDir, id, tarFile);
-  fs17.rmSync(taskDir, { recursive: true });
+  fs20.rmSync(taskDir, { recursive: true });
   console.log(chalk8.green(`Archived "${id}" \u2192 ${tarFile}`));
 });
 function archiveTaskToTar(tasksDir, taskId, tarFile) {
-  if (fs17.existsSync(tarFile) && !fs17.statSync(tarFile).isFile()) {
+  if (fs20.existsSync(tarFile) && !fs20.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 (fs17.existsSync(tarFile)) {
+  if (fs20.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)}`);
@@ -2352,9 +2554,9 @@ function archiveTaskToTar(tasksDir, taskId, tarFile) {
 // src/commands/ui.ts
 import { Command as Command9 } from "commander";
 import { spawn } from "child_process";
-import path16 from "path";
+import path18 from "path";
 import chalk9 from "chalk";
-var DASHBOARD_DIR = path16.resolve(
+var DASHBOARD_DIR = path18.resolve(
   import.meta.dirname,
   "..",
   "..",
@@ -2417,31 +2619,6 @@ var AGENT_MODEL_DEFAULTS = {
     { 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-agent")
     return "cursor-agent models";
@@ -2660,12 +2837,12 @@ models.command("default <agent>").description("Get or set default model / effort
 });
 
 // src/commands/agent-run.ts
-import fs18 from "fs";
-import path17 from "path";
+import fs21 from "fs";
+import path19 from "path";
 import { Command as Command11 } from "commander";
 import chalk11 from "chalk";
 import { spawn as spawn2, spawnSync as spawnSync3 } from "child_process";
-import yaml7 from "js-yaml";
+import yaml8 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 {
@@ -2789,7 +2966,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(yaml7.dump(result.runtime.exec, { lineWidth: 100 }));
+    console.log(yaml8.dump(result.runtime.exec, { lineWidth: 100 }));
   } catch (err) {
     const apiErr = err;
     if (apiErr.status === 404) failProfile(`not found: ${ref}`);
@@ -2799,7 +2976,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 = yaml7.load(fs18.readFileSync(path17.resolve(opts.fromFile), "utf-8"));
+    parsed = yaml8.load(fs21.readFileSync(path19.resolve(opts.fromFile), "utf-8"));
   } catch (err) {
     failProfile(`cannot read ${opts.fromFile}: ${err.message}`);
   }
@@ -2815,14 +2992,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 = 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 tmp = path19.join(process.env.TMPDIR || "/tmp", `task0-runtime-${result.runtime.slug}-${Date.now()}.yml`);
+    fs21.writeFileSync(tmp, yaml8.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 = yaml7.load(fs18.readFileSync(tmp, "utf-8"));
+    const updated = yaml8.load(fs21.readFileSync(tmp, "utf-8"));
     await api.put(`/api/runtime-profiles/${encodeURIComponent(ref)}`, updated);
-    fs18.unlinkSync(tmp);
+    fs21.unlinkSync(tmp);
     console.log(chalk11.green(`updated ${ref}`));
   } catch (err) {
     failProfile(err.message);
@@ -2842,13 +3019,13 @@ agentRun.addCommand(profile);
 // src/commands/plan.ts
 import { Command as Command12 } from "commander";
 import chalk12 from "chalk";
-import fs19 from "fs";
-import path18 from "path";
+import fs22 from "fs";
+import path20 from "path";
 init_task_state2();
 var PLAN_GENERATE_SKILL_NAME = "plan-generate";
 function resolveSkillFilePath3(projectRoot, skillName) {
-  const p = path18.join(projectRoot, ".claude", "skills", skillName, "SKILL.md");
-  return fs19.existsSync(p) ? p : null;
+  const p = path20.join(projectRoot, ".claude", "skills", skillName, "SKILL.md");
+  return fs22.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) => {
@@ -2980,7 +3157,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 = fs19.readdirSync(loc.taskDir);
+    const files = fs22.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."));
@@ -3022,8 +3199,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 = path18.join(loc.taskDir, refinedFile);
-      const wrote = fs19.existsSync(refinedPath);
+      const refinedPath = path20.join(loc.taskDir, refinedFile);
+      const wrote = fs22.existsSync(refinedPath);
       if (final.status === "done" && wrote) {
         await updateWorkflow(loc.taskYml, {
           phase: "refined",
@@ -3175,8 +3352,8 @@ import { Command as Command14 } from "commander";
 import chalk14 from "chalk";
 
 // src/lib/project.ts
-import path19 from "path";
-import fs20 from "fs";
+import path21 from "path";
+import fs23 from "fs";
 function resolveProjectName(opts) {
   if (opts.project && opts.project.length > 0) return opts.project;
   const config = loadConfig();
@@ -3186,15 +3363,15 @@ function resolveProjectName(opts) {
       "Cannot resolve project: no registered projects. Use `task0 source add <path>` first, or pass --project <name>."
     );
   }
-  const cwd = fs20.realpathSync(process.cwd());
+  const cwd = fs23.realpathSync(process.cwd());
   for (const source2 of projects) {
     let sourceAbs;
     try {
-      sourceAbs = fs20.realpathSync(path19.resolve(source2.path));
+      sourceAbs = fs23.realpathSync(path21.resolve(source2.path));
     } catch {
-      sourceAbs = path19.resolve(source2.path);
+      sourceAbs = path21.resolve(source2.path);
     }
-    if (cwd === sourceAbs || cwd.startsWith(sourceAbs + path19.sep)) {
+    if (cwd === sourceAbs || cwd.startsWith(sourceAbs + path21.sep)) {
       return source2.name;
     }
   }
@@ -3834,12 +4011,12 @@ import chalk17 from "chalk";
 
 // src/core/issue/decision.ts
 init_node();
-import fs21 from "fs";
-import path20 from "path";
+import fs24 from "fs";
+import path22 from "path";
 init_task_state2();
 var DECISION_FILE_RE = /^DECISION-(\d+)-([a-z0-9-]+)\.md$/;
 function selectBlockingIssues(taskDir, explicitIssue) {
-  const files = fs21.existsSync(taskDir) ? fs21.readdirSync(taskDir) : [];
+  const files = fs24.existsSync(taskDir) ? fs24.readdirSync(taskDir) : [];
   const issueFiles = files.filter((f) => /^ISSUE-\d+\.md$/.test(f)).sort();
   const all = readOpenQuestions(taskDir, issueFiles);
   if (!explicitIssue) return all;
@@ -3943,12 +4120,12 @@ function parseConsolidatedAnswers(md) {
   return sections;
 }
 function rewriteIssueWithDecisions(taskDir, issueFile, consolidatedFile) {
-  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 issuePath = path22.join(taskDir, issueFile);
+  const consolidatedPath = path22.join(taskDir, consolidatedFile);
+  if (!fs24.existsSync(issuePath)) throw new Error(`${issueFile} not found in ${taskDir}`);
+  if (!fs24.existsSync(consolidatedPath)) throw new Error(`${consolidatedFile} not found in ${taskDir}`);
+  const issueMd = fs24.readFileSync(issuePath, "utf-8");
+  const consolidatedMd = fs24.readFileSync(consolidatedPath, "utf-8");
   const answers = parseConsolidatedAnswers(consolidatedMd);
   if (answers.length === 0) {
     throw new Error(`${consolidatedFile} has no "## Qn" sections; cannot derive Decisions`);
@@ -3970,7 +4147,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");
-  fs21.writeFileSync(issuePath, next, "utf-8");
+  fs24.writeFileSync(issuePath, next, "utf-8");
   return { replaced: answers.length };
 }
 async function propose(opts) {
@@ -3998,8 +4175,8 @@ async function propose(opts) {
     const kicks = [];
     for (const agent2 of opts.agents) {
       const decisionFile = decisionFileName(issue2, agent2);
-      const decisionPath = path20.join(loc.taskDir, decisionFile);
-      if (fs21.existsSync(decisionPath) && !opts.force) {
+      const decisionPath = path22.join(loc.taskDir, decisionFile);
+      if (fs24.existsSync(decisionPath) && !opts.force) {
         if (opts.ifNeeded) {
           kicks.push({
             issue: issue2.file,
@@ -4074,7 +4251,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 (!fs21.existsSync(path20.join(loc.taskDir, k.decisionFile))) {
+          } else if (!fs24.existsSync(path22.join(loc.taskDir, k.decisionFile))) {
             k.error = `runtime completed but ${k.decisionFile} was not written`;
           }
         } catch (err) {
@@ -4095,7 +4272,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 = fs21.readdirSync(loc.taskDir);
+    const files = fs24.readdirSync(loc.taskDir);
     const proposalFiles = files.filter((f) => {
       const m = f.match(DECISION_FILE_RE);
       return !!m && m[1] === issue2.index && m[2] !== "consolidated";
@@ -4141,7 +4318,7 @@ async function consolidate(opts) {
       if (opts.wait) {
         try {
           const final = await waitForAgentRun(agentRunId);
-          const wrote = fs21.existsSync(path20.join(loc.taskDir, consolidatedFile));
+          const wrote = fs24.existsSync(path22.join(loc.taskDir, consolidatedFile));
           if (final.status !== "done") {
             kick.error = final.error || `runtime ${agentRunId} ended with ${final.status}`;
           } else if (!wrote) {
@@ -4207,7 +4384,7 @@ async function approve(opts) {
   return { updated };
 }
 function buildReferenceFiles(taskDir, issue2) {
-  const names = fs21.readdirSync(taskDir);
+  const names = fs24.readdirSync(taskDir);
   const refs = [issue2.file];
   if (names.includes("ISSUE.md")) refs.push("ISSUE.md");
   const ideaFile = `IDEA-${issue2.index}.md`;
@@ -4315,12 +4492,12 @@ issue.command("approve <taskId>").description("Apply the consolidated decisions
 });
 
 // src/commands/agent.ts
-import fs22 from "fs";
-import path21 from "path";
+import fs25 from "fs";
+import path23 from "path";
 import { spawnSync as spawnSync5 } from "child_process";
 import { Command as Command18 } from "commander";
 import chalk18 from "chalk";
-import yaml8 from "js-yaml";
+import yaml9 from "js-yaml";
 function statusBadge(s) {
   if (s === "working") return chalk18.cyan("\u25CF");
   if (s === "error") return chalk18.red("\u25CF");
@@ -4380,10 +4557,10 @@ agent.command("get <ref>").description("Show one agent by object_id or slug").op
     }
     console.log();
     console.log(chalk18.dim("--- spec ---"));
-    console.log(yaml8.dump(result.agent.spec, { lineWidth: 100 }));
+    console.log(yaml9.dump(result.agent.spec, { lineWidth: 100 }));
     if (result.agent.mcp_config) {
       console.log(chalk18.dim("--- mcp_config ---"));
-      console.log(yaml8.dump(result.agent.mcp_config, { lineWidth: 100 }));
+      console.log(yaml9.dump(result.agent.mcp_config, { lineWidth: 100 }));
     }
   } catch (err) {
     const apiErr = err;
@@ -4394,8 +4571,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 = fs22.readFileSync(path21.resolve(opts.fromFile), "utf-8");
-    parsed = yaml8.load(raw);
+    const raw = fs25.readFileSync(path23.resolve(opts.fromFile), "utf-8");
+    parsed = yaml9.load(raw);
   } catch (err) {
     fail5(`cannot read ${opts.fromFile}: ${err.message}`);
   }
@@ -4410,17 +4587,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)}`);
-    const tmp = path21.join(
+    const tmp = path23.join(
       process.env.TMPDIR || "/tmp",
       `task0-agent-${result.agent.slug}-${Date.now()}.yml`
     );
-    fs22.writeFileSync(tmp, yaml8.dump(result.agent, { lineWidth: 100 }), "utf-8");
+    fs25.writeFileSync(tmp, yaml9.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 = yaml8.load(fs22.readFileSync(tmp, "utf-8"));
+    const updated = yaml9.load(fs25.readFileSync(tmp, "utf-8"));
     await api.put(`/api/agents/${encodeURIComponent(ref)}`, updated);
-    fs22.unlinkSync(tmp);
+    fs25.unlinkSync(tmp);
     console.log(chalk18.green(`updated ${ref}`));
   } catch (err) {
     fail5(err.message);
@@ -4491,7 +4668,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(fs22.readFileSync(path21.resolve(opts.fromFile), "utf-8"));
+    parsed = JSON.parse(fs25.readFileSync(path23.resolve(opts.fromFile), "utf-8"));
   } catch (err) {
     fail5(`cannot parse ${opts.fromFile}: ${err.message}`);
   }
@@ -4640,36 +4817,36 @@ function pickRegisterAuth(flagToken) {
 
 // src/core/daemon-rpc-handlers.ts
 init_node();
-import fs25 from "fs";
-import path24 from "path";
+import fs28 from "fs";
+import path26 from "path";
 
 // src/core/daemon-agent-run-runner.ts
 import { execFileSync } from "child_process";
-import fs24 from "fs";
-import path23 from "path";
+import fs27 from "fs";
+import path25 from "path";
 
 // src/core/daemon-agent-run-dir.ts
 init_node();
-import fs23 from "fs";
-import path22 from "path";
+import fs26 from "fs";
+import path24 from "path";
 function agentRunRoot() {
-  return process.env.TASK0_DAEMON_AGENT_RUN_DIR || path22.join(task0Home(), "agent-run");
+  return process.env.TASK0_DAEMON_AGENT_RUN_DIR || path24.join(profileDir(), "agent-run");
 }
 function agentRunDir(runId) {
-  return path22.join(agentRunRoot(), runId);
+  return path24.join(agentRunRoot(), runId);
 }
 function agentRunStatusPath(runId) {
-  return path22.join(agentRunDir(runId), "status.json");
+  return path24.join(agentRunDir(runId), "status.json");
 }
 function ensureAgentRunDir(runId) {
   const dir = agentRunDir(runId);
-  fs23.mkdirSync(dir, { recursive: true });
+  fs26.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 });
+  if (!fs26.existsSync(dir)) return;
+  fs26.rmSync(dir, { recursive: true, force: true });
 }
 
 // src/core/daemon-agent-run-runner.ts
@@ -4711,9 +4888,9 @@ function killSession2(sessionName) {
 }
 function readStatusFile(runId) {
   const filePath = agentRunStatusPath(runId);
-  if (!fs24.existsSync(filePath)) return null;
+  if (!fs27.existsSync(filePath)) return null;
   try {
-    const raw = fs24.readFileSync(filePath, "utf-8");
+    const raw = fs27.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     return { raw, parsed };
   } catch {
@@ -4738,22 +4915,22 @@ function launchAgentRun(params) {
   if (active.has(params.runId)) {
     throw Object.assign(new Error(`agent run already active: ${params.runId}`), { code: "already_running" });
   }
-  if (!fs24.existsSync(params.workspace)) {
+  if (!fs27.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 });
+  const scriptPath = path25.join(runDir, "script.sh");
+  fs27.writeFileSync(scriptPath, params.scriptContent, { mode: 493 });
   if (params.promptContent !== void 0) {
-    fs24.writeFileSync(path23.join(runDir, "prompt.txt"), params.promptContent, "utf-8");
+    fs27.writeFileSync(path25.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");
+    fs27.writeFileSync(path25.join(runDir, name), content, "utf-8");
   }
-  fs24.writeFileSync(
+  fs27.writeFileSync(
     agentRunStatusPath(params.runId),
     JSON.stringify({ status: "starting", updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2),
     "utf-8"
@@ -4834,15 +5011,15 @@ function ensureString(value, name) {
 }
 function ensureSafeTaskId(value) {
   const id = ensureString(value, "taskId");
-  if (id.includes("/") || id.includes("\\") || id.includes("\0") || id === "." || id === ".." || path24.isAbsolute(id)) {
+  if (id.includes("/") || id.includes("\\") || id.includes("\0") || id === "." || id === ".." || path26.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)) {
+  const root = path26.resolve(rootAbs);
+  const target = path26.resolve(resolvedAbs);
+  if (target !== root && !target.startsWith(root + path26.sep)) {
     throw Object.assign(new Error("path escapes containment root"), { code: "invalid_params" });
   }
 }
@@ -4884,7 +5061,7 @@ var rpcHandlers = {
   // 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 : path24.basename(rootPath);
+    const name = typeof params.name === "string" && params.name ? params.name : path26.basename(rootPath);
     const result = scanProjectWithRepair(rootPath, name);
     return { tasks: result.tasks, errors: result.errors };
   },
@@ -4895,7 +5072,7 @@ var rpcHandlers = {
     const filePath = ensureString(params.path, "path");
     let stat;
     try {
-      stat = fs25.statSync(filePath);
+      stat = fs28.statSync(filePath);
     } catch {
       throw Object.assign(new Error("file not found"), { code: "not_found" });
     }
@@ -4905,7 +5082,7 @@ 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 = fs25.readFileSync(filePath, "utf-8");
+    const content = fs28.readFileSync(filePath, "utf-8");
     return { content, size: stat.size, modifiedAt: stat.mtime.toISOString() };
   },
   // ---------------------------------------------------------------------
@@ -4920,15 +5097,15 @@ var rpcHandlers = {
   },
   async project_add(params, ctx) {
     const rawPath = ensureString(params.path, "path");
-    const absPath = path24.resolve(rawPath);
-    if (!fs25.existsSync(absPath)) {
+    const absPath = path26.resolve(rawPath);
+    if (!fs28.existsSync(absPath)) {
       throw Object.assign(new Error(`path does not exist: ${absPath}`), { code: "not_found" });
     }
-    const stat = fs25.statSync(absPath);
+    const stat = fs28.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 name = optionalString(params.name)?.trim() || path26.basename(absPath);
     const result = scanProjectWithRepair(absPath, name);
     addSource({ name, type: "project", path: absPath, enabled: true });
     ctx.notifyManifestChanged();
@@ -4977,24 +5154,24 @@ var rpcHandlers = {
     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"));
+    const projectAbs = path26.resolve(project2.path);
+    const projectConfig = readYaml(path26.join(projectAbs, "task0.yml"));
     if (!projectConfig) {
       throw Object.assign(new Error(`invalid project: missing task0.yml at ${projectAbs}`), { code: "invalid_project" });
     }
-    const tasksRoot = path24.resolve(projectAbs, projectConfig.tasks_dir);
-    const taskDir = path24.resolve(tasksRoot, taskId);
+    const tasksRoot = path26.resolve(projectAbs, projectConfig.tasks_dir);
+    const taskDir = path26.resolve(tasksRoot, taskId);
     assertContained(tasksRoot, taskDir);
-    if (!fs25.existsSync(taskDir)) {
+    if (!fs28.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) {
+    const taskYml = path26.join(taskDir, "task0.yml");
+    const yaml11 = readYaml(taskYml);
+    if (!yaml11) {
       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 };
+    const files = fs28.readdirSync(taskDir).filter((name) => name !== "task0.yml");
+    return { task_dir: taskDir, yaml: yaml11, files };
   },
   // Create a task directory + write task0.yml + write any additional named
   // files. Hub decides the taskId and yaml content (slug/object_id are
@@ -5002,8 +5179,8 @@ var rpcHandlers = {
   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") {
+    const yaml11 = params.yaml;
+    if (!yaml11 || typeof yaml11 !== "object") {
       throw Object.assign(new Error("yaml (object) is required"), { code: "invalid_params" });
     }
     const files = params.files ?? {};
@@ -5011,24 +5188,24 @@ var rpcHandlers = {
     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"));
+    const projectAbs = path26.resolve(project2.path);
+    const projectConfig = readYaml(path26.join(projectAbs, "task0.yml"));
     if (!projectConfig) {
       throw Object.assign(new Error(`invalid project: missing task0.yml at ${projectAbs}`), { code: "invalid_project" });
     }
-    const tasksRoot = path24.resolve(projectAbs, projectConfig.tasks_dir);
-    const taskDir = path24.resolve(tasksRoot, taskId);
+    const tasksRoot = path26.resolve(projectAbs, projectConfig.tasks_dir);
+    const taskDir = path26.resolve(tasksRoot, taskId);
     assertContained(tasksRoot, taskDir);
-    if (fs25.existsSync(taskDir)) {
+    if (fs28.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);
+    fs28.mkdirSync(taskDir, { recursive: true });
+    writeYaml(path26.join(taskDir, "task0.yml"), yaml11);
     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");
+      fs28.writeFileSync(path26.join(taskDir, name), content, "utf-8");
     }
     ctx.notifyManifestChanged();
     return { task_dir: taskDir };
@@ -5040,27 +5217,27 @@ var rpcHandlers = {
   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") {
+    const yaml11 = params.yaml;
+    if (!yaml11 || typeof yaml11 !== "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"));
+    const projectAbs = path26.resolve(project2.path);
+    const projectConfig = readYaml(path26.join(projectAbs, "task0.yml"));
     if (!projectConfig) {
       throw Object.assign(new Error(`invalid project: missing task0.yml at ${projectAbs}`), { code: "invalid_project" });
     }
-    const tasksRoot = path24.resolve(projectAbs, projectConfig.tasks_dir);
-    const taskDir = path24.resolve(tasksRoot, taskId);
+    const tasksRoot = path26.resolve(projectAbs, projectConfig.tasks_dir);
+    const taskDir = path26.resolve(tasksRoot, taskId);
     assertContained(tasksRoot, taskDir);
-    const taskYml = path24.join(taskDir, "task0.yml");
-    if (!fs25.existsSync(taskYml)) {
+    const taskYml = path26.join(taskDir, "task0.yml");
+    if (!fs28.existsSync(taskYml)) {
       throw Object.assign(new Error(`task yaml not found: ${taskYml}`), { code: "not_found" });
     }
-    writeYaml(taskYml, yaml10);
+    writeYaml(taskYml, yaml11);
     ctx.notifyManifestChanged();
     return { task_dir: taskDir };
   },
@@ -5073,18 +5250,18 @@ var rpcHandlers = {
     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"));
+    const projectAbs = path26.resolve(project2.path);
+    const projectConfig = readYaml(path26.join(projectAbs, "task0.yml"));
     if (!projectConfig) {
       throw Object.assign(new Error(`invalid project: missing task0.yml at ${projectAbs}`), { code: "invalid_project" });
     }
-    const tasksRoot = path24.resolve(projectAbs, projectConfig.tasks_dir);
-    const taskDir = path24.resolve(tasksRoot, taskId);
+    const tasksRoot = path26.resolve(projectAbs, projectConfig.tasks_dir);
+    const taskDir = path26.resolve(tasksRoot, taskId);
     assertContained(tasksRoot, taskDir);
-    if (!fs25.existsSync(taskDir)) {
+    if (!fs28.existsSync(taskDir)) {
       throw Object.assign(new Error(`task not found: ${taskId}`), { code: "not_found" });
     }
-    fs25.rmSync(taskDir, { recursive: true, force: true });
+    fs28.rmSync(taskDir, { recursive: true, force: true });
     ctx.notifyManifestChanged();
     return { task_dir: taskDir, deleted: true };
   },
@@ -5115,9 +5292,9 @@ var rpcHandlers = {
     const projectSkills = getProjectAgentSkills(workspace);
     const globalSkills = getGlobalAgentSkills();
     const all = [...projectSkills, ...globalSkills];
-    const resolved = path24.resolve(filePath);
+    const resolved = path26.resolve(filePath);
     const skill = all.find(
-      (s) => s.agent === agent2 && path24.resolve(s.filePath) === resolved
+      (s) => s.agent === agent2 && path26.resolve(s.filePath) === resolved
     ) ?? null;
     return { skill };
   },
@@ -5150,16 +5327,16 @@ var rpcHandlers = {
 
 // src/core/daemon-service/launchd.ts
 import { spawnSync as spawnSync6 } from "child_process";
-import fs27 from "fs";
-import path26 from "path";
+import fs30 from "fs";
+import path28 from "path";
 
 // src/core/daemon-service/binary.ts
-import fs26 from "fs";
+import fs29 from "fs";
 import { fileURLToPath } from "url";
 function resolveTask0Invocation() {
   const node = process.execPath;
   const argv1 = process.argv[1] ?? fileURLToPath(import.meta.url);
-  const main2 = fs26.realpathSync(argv1);
+  const main2 = fs29.realpathSync(argv1);
   if (!isInstalledBuild(main2) && process.env.TASK0_ALLOW_DEV_SERVICE !== "1") {
     throw new Error(
       `Refusing to install autostart service pointing at ${main2}.
@@ -5177,15 +5354,19 @@ function isInstalledBuild(p) {
 // src/core/daemon-service/paths.ts
 init_node();
 import os5 from "os";
-import path25 from "path";
+import path27 from "path";
 
 // src/core/daemon-service/types.ts
+init_node();
 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);
+  const home = process.env.TASK0_HOME ?? "";
+  const profile3 = currentProfileName();
+  if ((!home || home.length === 0) && profile3 === DEFAULT_PROFILE_NAME) {
+    return BASE_SERVICE_LABEL;
+  }
+  const hash = crypto2.createHash("sha256").update(`${home}\0${profile3}`).digest("hex").slice(0, 8);
   return `${BASE_SERVICE_LABEL}.${hash}`;
 }
 
@@ -5194,21 +5375,21 @@ function unitPath(scope) {
   const platform = process.platform;
   const label = serviceLabel();
   if (platform === "darwin") {
-    return scope === "user" ? path25.join(os5.homedir(), "Library", "LaunchAgents", `${label}.plist`) : path25.join("/", "Library", "LaunchDaemons", `${label}.plist`);
+    return scope === "user" ? path27.join(os5.homedir(), "Library", "LaunchAgents", `${label}.plist`) : path27.join("/", "Library", "LaunchDaemons", `${label}.plist`);
   }
   if (platform === "linux") {
-    return scope === "user" ? path25.join(os5.homedir(), ".config", "systemd", "user", `${label}.service`) : path25.join("/", "etc", "systemd", "system", `${label}.service`);
+    return scope === "user" ? path27.join(os5.homedir(), ".config", "systemd", "user", `${label}.service`) : path27.join("/", "etc", "systemd", "system", `${label}.service`);
   }
   throw new Error(`Unsupported platform for service install: ${platform}`);
 }
 function logDir() {
-  return path25.join(task0Home(), "logs");
+  return path27.join(profileDir(), "logs");
 }
 function logPaths() {
   const dir = logDir();
   return {
-    out: path25.join(dir, "daemon.out.log"),
-    err: path25.join(dir, "daemon.err.log")
+    out: path27.join(dir, "daemon.out.log"),
+    err: path27.join(dir, "daemon.err.log")
   };
 }
 
@@ -5283,8 +5464,8 @@ function createLaunchdManager(scope) {
   const logs = logPaths();
   async function install() {
     const inv = resolveTask0Invocation();
-    fs27.mkdirSync(logDir(), { recursive: true });
-    fs27.mkdirSync(path26.dirname(file), { recursive: true });
+    fs30.mkdirSync(logDir(), { recursive: true });
+    fs30.mkdirSync(path28.dirname(file), { recursive: true });
     const body = renderPlist({
       node: inv.node,
       main: inv.main,
@@ -5294,7 +5475,7 @@ function createLaunchdManager(scope) {
       err: logs.err,
       task0Env: collectTask0Env()
     });
-    fs27.writeFileSync(file, body, { mode: 420 });
+    fs30.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);
@@ -5320,9 +5501,9 @@ function createLaunchdManager(scope) {
   }
   async function uninstall() {
     run2("launchctl", ["bootout", serviceTarget(scope)]);
-    if (fs27.existsSync(file)) {
+    if (fs30.existsSync(file)) {
       run2("launchctl", ["unload", file]);
-      fs27.unlinkSync(file);
+      fs30.unlinkSync(file);
     }
   }
   async function start() {
@@ -5341,7 +5522,7 @@ function createLaunchdManager(scope) {
     }
   }
   async function status() {
-    if (!fs27.existsSync(file)) return "absent";
+    if (!fs30.existsSync(file)) return "absent";
     const printed = run2("launchctl", ["print", serviceTarget(scope)]);
     if (printed.code !== 0) return "installed";
     const out = printed.stdout;
@@ -5364,8 +5545,8 @@ function createLaunchdManager(scope) {
 
 // src/core/daemon-service/systemd.ts
 import { spawnSync as spawnSync7 } from "child_process";
-import fs28 from "fs";
-import path27 from "path";
+import fs31 from "fs";
+import path29 from "path";
 function shellEscape(s) {
   if (!/[\s"\\$]/.test(s)) return s;
   return `"${s.replace(/[\\"]/g, (m) => `\\${m}`)}"`;
@@ -5415,8 +5596,8 @@ function createSystemdManager(scope) {
   const unitName = `${serviceLabel()}.service`;
   async function install() {
     const inv = resolveTask0Invocation();
-    fs28.mkdirSync(logDir(), { recursive: true });
-    fs28.mkdirSync(path27.dirname(file), { recursive: true });
+    fs31.mkdirSync(logDir(), { recursive: true });
+    fs31.mkdirSync(path29.dirname(file), { recursive: true });
     const body = renderUnit({
       node: inv.node,
       main: inv.main,
@@ -5426,7 +5607,7 @@ function createSystemdManager(scope) {
       scope,
       task0Env: collectTask0Env2()
     });
-    fs28.writeFileSync(file, body, { mode: 420 });
+    fs31.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}`);
@@ -5435,8 +5616,8 @@ function createSystemdManager(scope) {
   }
   async function uninstall() {
     run3("systemctl", [...scopeFlag(scope), "disable", "--now", unitName]);
-    if (fs28.existsSync(file)) {
-      fs28.unlinkSync(file);
+    if (fs31.existsSync(file)) {
+      fs31.unlinkSync(file);
     }
     run3("systemctl", [...scopeFlag(scope), "daemon-reload"]);
   }
@@ -5453,7 +5634,7 @@ function createSystemdManager(scope) {
     }
   }
   async function status() {
-    if (!fs28.existsSync(file)) return "absent";
+    if (!fs31.existsSync(file)) return "absent";
     const res = run3("systemctl", [...scopeFlag(scope), "is-active", unitName]);
     const out = res.stdout.trim();
     if (out === "active") return "running";
@@ -5489,14 +5670,14 @@ function getServiceManager(scope) {
 // src/core/cli-version.ts
 import { readFileSync } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import path28 from "path";
+import path30 from "path";
 var cached2 = null;
 function readCliVersion() {
   if (cached2 !== null) return cached2;
-  const here = path28.dirname(fileURLToPath2(import.meta.url));
+  const here = path30.dirname(fileURLToPath2(import.meta.url));
   const candidates = [
-    path28.resolve(here, "..", "package.json"),
-    path28.resolve(here, "..", "..", "package.json")
+    path30.resolve(here, "..", "package.json"),
+    path30.resolve(here, "..", "..", "package.json")
   ];
   for (const candidate of candidates) {
     try {
@@ -5512,73 +5693,6 @@ 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];
@@ -5681,10 +5795,20 @@ function fail6(message, code = 1) {
 function loadRequiredIdentity() {
   const identity = readDaemonIdentity();
   if (!identity) {
-    fail6(`No daemon identity at ${daemonConfigPath()}. Run \`task0 daemon register --server <url>\` first.`);
+    fail6(`No daemon identity at ${daemonConfigPath()}. Run \`task0 daemon register\` first (set api_url with \`task0 profile set api_url <url>\` if it isn't already configured).`);
   }
   return identity;
 }
+function resolveTargetServerUrl() {
+  const url = process.env.TASK0_API_URL?.trim();
+  if (url) return url.replace(/\/$/, "");
+  fail6(
+    `No server URL configured for the active profile.
+Set it with:
+  task0 profile set api_url <url>
+\u2026or export TASK0_API_URL for a one-off override.`
+  );
+}
 function serverBase(identity) {
   if (identity) return identity.server_url.replace(/\/$/, "");
   return (process.env.TASK0_API_URL || "http://127.0.0.1:4318").replace(/\/$/, "");
@@ -5722,7 +5846,7 @@ function rerunArgv() {
   return ["task0", ...process.argv.slice(2)].join(" ");
 }
 var daemonCmd = new Command19("daemon").description("Manage this host as a task0 daemon registered with a central server");
-daemonCmd.command("register").description("Register this host with a central server, install the autostart service, and start it").requiredOption("-s, --server <url>", "Central server URL (e.g. https://central.example.com:4318)").option("-n, --name <name>", "Display name for this daemon (defaults to hostname)").option("-t, --token <token>", "API token (apit_...) for registration. Falls back to TASK0_API_TOKEN, then admin token.").option("--force", "Overwrite existing identity if present").option("--system", "Install at the system layer (LaunchDaemons / /etc/systemd/system, requires sudo)").option("--no-install", "Skip installing the autostart service unit").option("--no-start", "Install the service unit but do not start it now").action(async (opts) => {
+daemonCmd.command("register").description("Register this host with the server configured in the active profile, install the autostart service, and start it").option("-n, --name <name>", "Display name for this daemon (defaults to hostname)").option("-t, --token <token>", "API token (apit_...) for registration. Falls back to TASK0_API_TOKEN, then admin token.").option("--force", "Overwrite existing identity if present").option("--system", "Install at the system layer (LaunchDaemons / /etc/systemd/system, requires sudo)").option("--no-install", "Skip installing the autostart service unit").option("--no-start", "Install the service unit but do not start it now").action(async (opts) => {
   const scope = opts.system ? "system" : "user";
   if (opts.install) {
     requireRootIfSystem(scope, rerunArgv());
@@ -5731,7 +5855,7 @@ daemonCmd.command("register").description("Register this host with a central ser
   if (existing && !opts.force) {
     fail6(`Already registered as ${existing.daemon_id}. Pass --force to re-register.`);
   }
-  const base = opts.server.replace(/\/$/, "");
+  const base = resolveTargetServerUrl();
   let authHeader;
   try {
     const choice = pickRegisterAuth(opts.token);
@@ -5836,12 +5960,6 @@ 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;
@@ -6055,8 +6173,8 @@ function fail7(message, code = 1) {
   console.error(chalk20.red(message));
   process.exit(code);
 }
-async function callServer(path31, init = {}) {
-  const url = `${serverBase2()}${path31}`;
+async function callServer(path32, init = {}) {
+  const url = `${serverBase2()}${path32}`;
   let auth;
   try {
     auth = adminAuthHeader();
@@ -6560,159 +6678,219 @@ automation.command("runs <id>").description("List recent runs for an automation"
 });
 
 // src/commands/profile.ts
-import fs30 from "fs";
-import os7 from "os";
-import path30 from "path";
+init_node();
+import fs32 from "fs";
+import path31 from "path";
 import { Command as Command23 } from "commander";
 import chalk23 from "chalk";
-var VALID_NAME = /^[a-zA-Z0-9_-]+$/;
+import yaml10 from "js-yaml";
+var PROFILE_SCALAR_KEYS = ["api_url"];
+function isProfileScalarKey(key) {
+  return PROFILE_SCALAR_KEYS.includes(key);
+}
 function fail9(msg) {
   console.error(chalk23.red(msg));
   process.exit(1);
 }
-function legacyTask0Home() {
-  return path30.join(os7.homedir(), ".task0");
-}
-function readDaemonAt(home) {
-  const file = path30.join(home, "daemon.json");
-  if (!fs30.existsSync(file)) return null;
+function readDaemonAt(dir) {
+  const file = path31.join(dir, "daemon.json");
+  if (!fs32.existsSync(file)) return null;
   try {
-    return JSON.parse(fs30.readFileSync(file, "utf-8"));
+    return JSON.parse(fs32.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);
+function readProfileApiUrl(name) {
+  const file = path31.join(profileDir(name), "config.yml");
+  if (!fs32.existsSync(file)) return void 0;
+  try {
+    const data = yaml10.load(fs32.readFileSync(file, "utf-8"));
+    return data?.api_url;
+  } catch {
+    return void 0;
+  }
+}
+var profile2 = new Command23("profile").description("Manage CLI profiles (directories under ~/.task0/profiles/)");
+profile2.command("list").description("List configured profiles (one directory per profile)").action(() => {
+  const names = listProfileNames();
+  const current = currentProfileName();
   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()})`));
+    console.log("No profiles configured.");
     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."));
+    const apiUrl = readProfileApiUrl(name);
+    const url = apiUrl ? chalk23.dim(` \u2192 ${apiUrl}`) : "";
+    console.log(`${marker}${name}${url}`);
   }
 });
-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}.`);
+profile2.command("add <name>").description("Create a new profile directory (use `task0 profile use <name>` to activate)").option("--api-url <url>", "API server URL the CLI should call when this profile is active").action((name, opts) => {
+  if (!isValidProfileName(name)) {
+    fail9(`Invalid profile name "${name}". Must match /^[a-zA-Z0-9_-]+$/.`);
   }
-  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).`);
-    }
+  if (name === DEFAULT_PROFILE_NAME) {
+    fail9(`"${DEFAULT_PROFILE_NAME}" is reserved; it always exists.`);
   }
-  const parent = path30.dirname(absHome);
-  if (!fs30.existsSync(parent)) {
-    fail9(`Parent directory does not exist: ${parent}`);
+  const dir = profileDir(name);
+  if (fs32.existsSync(dir)) {
+    fail9(`Profile "${name}" already exists at ${dir}.`);
   }
+  fs32.mkdirSync(dir, { recursive: true });
+  const prev = process.env.TASK0_PROFILE;
+  process.env.TASK0_PROFILE = name;
   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.`));
+    const config = loadConfig();
+    if (opts.apiUrl) config.api_url = opts.apiUrl;
+    saveConfig(config);
+  } finally {
+    if (prev === void 0) delete process.env.TASK0_PROFILE;
+    else process.env.TASK0_PROFILE = prev;
   }
   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(`  dir:     ${dir}`);
+  if (opts.apiUrl) console.log(`  api_url: ${opts.apiUrl}`);
   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) {
+profile2.command("remove <name>").description('Delete a profile directory (refuses to delete "default")').option("-f, --force", `Remove even if it's the current profile (resets current to "default")`).action((name, opts) => {
+  if (!isValidProfileName(name)) {
+    fail9(`Invalid profile name "${name}".`);
+  }
+  if (name === DEFAULT_PROFILE_NAME) {
+    fail9(`"${DEFAULT_PROFILE_NAME}" cannot be removed.`);
+  }
+  const dir = profileDir(name);
+  if (!fs32.existsSync(dir)) {
     fail9(`Profile "${name}" not found.`);
   }
-  const current = getCurrentProfileName();
+  const current = currentProfileName();
   if (current === name && !opts.force) {
-    fail9(`Profile "${name}" is current. Re-run with --force to remove it (this clears current_profile).`);
+    fail9(`Profile "${name}" is current. Re-run with --force to remove it.`);
   }
-  removeProfile(name);
-  console.log(chalk23.green(`Removed profile "${name}".`));
+  fs32.rmSync(dir, { recursive: true, force: true });
   if (current === name) {
-    console.log(chalk23.dim("current_profile cleared. Use `task0 profile use <name>` to pick another."));
+    writeCurrentProfile(null);
+    console.log(chalk23.dim('Current profile reset to "default".'));
   }
-  console.log(chalk23.dim(`Note: ${entry.task0_home} was not deleted.`));
+  console.log(chalk23.green(`Removed profile "${name}".`));
 });
 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)"}.`);
+  if (!isValidProfileName(name)) {
+    fail9(`Invalid profile name "${name}".`);
+  }
+  if (!fs32.existsSync(profileDir(name))) {
+    const names = listProfileNames();
+    fail9(`Profile "${name}" not found. Available: ${names.join(", ")}.`);
   }
-  setCurrentProfile(name);
+  writeCurrentProfile(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>`."));
+profile2.command("current").description('Print the current profile name (always succeeds; defaults to "default")').action(() => {
+  console.log(currentProfileName());
+});
+profile2.command("set <key> <value>").description(`Set a config field on the active profile. Supported keys: ${PROFILE_SCALAR_KEYS.join(", ")}.`).action((key, value) => {
+  if (!isProfileScalarKey(key)) {
+    fail9(`Unknown key "${key}". Supported keys: ${PROFILE_SCALAR_KEYS.join(", ")}.`);
+  }
+  const config = loadConfig();
+  config[key] = value;
+  saveConfig(config);
+  console.log(chalk23.green(`${currentProfileName()}.${key} = ${value}`));
+});
+profile2.command("get <key>").description(`Read a config field from the active profile. Supported keys: ${PROFILE_SCALAR_KEYS.join(", ")}.`).action((key) => {
+  if (!isProfileScalarKey(key)) {
+    fail9(`Unknown key "${key}". Supported keys: ${PROFILE_SCALAR_KEYS.join(", ")}.`);
+  }
+  const value = loadConfig()[key];
+  if (typeof value !== "string" || value.length === 0) {
     process.exit(1);
   }
-  console.log(current);
+  console.log(value);
 });
-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.");
+profile2.command("show [name]").description("Show a profile's configuration and daemon registration").action((name) => {
+  const target = name ?? currentProfileName();
+  if (!isValidProfileName(target)) {
+    fail9(`Invalid profile name "${target}".`);
   }
-  const entry = getProfile(target);
-  if (!entry) {
+  const dir = profileDir(target);
+  if (!fs32.existsSync(dir)) {
     fail9(`Profile "${target}" not found.`);
   }
-  const current = getCurrentProfileName();
+  const current = currentProfileName();
+  const apiUrl = readProfileApiUrl(target);
+  const identity = readDaemonAt(dir);
+  const envOverride = target === current ? getActiveProfile()?.envApiUrlOverride : void 0;
+  const effective = envOverride ?? apiUrl;
   console.log(`${chalk23.bold(target)}${current === target ? chalk23.green(" (current)") : ""}`);
-  console.log(`  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);
+  console.log(`  dir:        ${dir}`);
+  console.log(`  config:     ${path31.join(dir, "config.yml")}`);
+  if (envOverride && apiUrl && envOverride !== apiUrl) {
+    console.log(`  api_url:    ${envOverride} ${chalk23.dim("(TASK0_API_URL env, overrides profile)")}`);
+    console.log(`              ${chalk23.dim(`profile: ${apiUrl}`)}`);
+  } else if (envOverride && !apiUrl) {
+    console.log(`  api_url:    ${envOverride} ${chalk23.dim("(TASK0_API_URL env; profile config.yml is unset)")}`);
+  } else if (apiUrl) {
+    console.log(`  api_url:    ${apiUrl} ${chalk23.dim("(profile config.yml)")}`);
+  } else {
+    console.log(`  api_url:    ${chalk23.dim("(unset \u2014 run `task0 profile set api_url <url>`)")}`);
+  }
   if (!identity) {
     console.log(chalk23.dim("  daemon.json: (not registered yet)"));
     return;
   }
   console.log(`  daemon_id:  ${identity.daemon_id ?? chalk23.dim("(missing)")}`);
   console.log(`  daemon.server_url: ${identity.server_url ?? chalk23.dim("(missing)")}`);
-  if (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}`));
+  if (effective && identity.server_url && effective !== identity.server_url) {
+    console.log(chalk23.yellow(`  warn: effective api_url and daemon.json.server_url disagree.`));
+    console.log(chalk23.dim(`        Re-register the daemon to align: task0 --profile ${target} daemon register --force`));
   }
 });
 
+// src/commands/migrate-layout.ts
+import { Command as Command24 } from "commander";
+import chalk24 from "chalk";
+var migrateLayout = new Command24("migrate-layout").description("Move legacy daemon-side files into the v0.8 ~/.task0/profiles/<name>/ layout").option("-n, --dry-run", "Show what would happen without modifying disk").option("-f, --force", "Reset the migration marker first; useful when the previous run was interrupted").action((opts) => {
+  if (opts.force && !opts.dryRun) {
+    const removed = resetMigrationMarker();
+    if (removed) console.log(chalk24.dim("Reset migration marker."));
+  }
+  const result = migrateCliLayout({ dryRun: opts.dryRun });
+  if (result.alreadyMigrated) {
+    console.log(chalk24.dim("Already migrated \u2014 nothing to do."));
+    console.log(chalk24.dim("Pass --force to rerun."));
+    return;
+  }
+  if (result.steps.length === 0) {
+    console.log("No legacy files found.");
+    return;
+  }
+  if (opts.dryRun) {
+    console.log(chalk24.bold("Dry run \u2014 no changes written:"));
+  } else {
+    console.log(chalk24.bold(`Migrated ${result.steps.length} item(s):`));
+  }
+  for (const step of result.steps) {
+    console.log(`  ${formatStep(step)}`);
+  }
+});
+function formatStep(step) {
+  switch (step.kind) {
+    case "mv":
+      return `mv     ${step.from} \u2192 ${step.to}${step.detail ? ` (${step.detail})` : ""}`;
+    case "mkdir":
+      return `mkdir  ${step.to}`;
+    case "write":
+      return `write  ${step.to}${step.detail ? ` (${step.detail})` : ""}`;
+    case "extract":
+      return `update ${step.from}${step.detail ? ` (${step.detail})` : ""}`;
+    case "skip":
+      return `skip   ${step.from ?? step.to}${step.detail ? ` (${step.detail})` : ""}`;
+    case "note":
+      return `note   ${step.detail ?? ""}`;
+  }
+}
+
 // src/core/error-capture.ts
 init_node();
 var DEFAULT_KEEP = 50;
@@ -6811,7 +6989,7 @@ function captureTopLevel(err, options) {
 
 // src/main.ts
 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)");
+var program = new Command25().name("task0").description("Task-centric control layer for agent workflow").version(TASK0_VERSION).option("--profile <name>", "Use a named profile under ~/.task0/profiles/<name>/ (overrides .current pointer and TASK0_PROFILE env)");
 program.addCommand(source);
 program.addCommand(project);
 program.addCommand(task);
@@ -6830,12 +7008,23 @@ program.addCommand(userCmd);
 program.addCommand(error);
 program.addCommand(automation);
 program.addCommand(profile2);
+program.addCommand(migrateLayout);
 async function main() {
+  try {
+    const result = migrateCliLayout();
+    if (result.ran && process.env.TASK0_LOG_MIGRATION !== "off") {
+      console.error(chalk25.dim(`task0: migrated CLI layout (${result.steps.length} step(s))`));
+    }
+  } catch (err) {
+    console.error(chalk25.yellow(
+      `task0: layout migration failed: ${err instanceof Error ? err.message : String(err)}. Continuing.`
+    ));
+  }
   try {
     activateProfile(process.argv);
   } catch (err) {
     if (err instanceof ProfileNotFoundError) {
-      console.error(chalk24.red(err.message));
+      console.error(chalk25.red(err.message));
       process.exit(1);
     }
     throw err;