@defai.digital/automatosx 5.1.2 → 5.2.0

package/dist/index.js

@@ -583,12 +583,12 @@ var init_cache = __esm({
 });
 
 // src/types/path.ts
-var PathError2;
+var PathError;
 var init_path = __esm({
   "src/types/path.ts"() {
     "use strict";
     init_esm_shims();
-    PathError2 = class extends Error {
+    PathError = class extends Error {
       constructor(message, context) {
         super(message);
         this.context = context;
@@ -669,7 +669,7 @@ var init_path_resolver = __esm({
        */
       resolveUserPath(userPath) {
         if (process.platform !== "win32" && isWindowsPath(userPath)) {
-          throw new PathError2(
+          throw new PathError(
             `Windows paths are not supported on ${process.platform}`,
             { path: userPath, type: "invalid_path" }
           );
@@ -776,7 +776,7 @@ var init_path_resolver = __esm({
       validateInProject(path3) {
         const boundary = this.checkBoundaries(path3);
         if (boundary === "outside_boundaries" || boundary === "system_restricted") {
-          throw new PathError2("Path outside project directory", {
+          throw new PathError("Path outside project directory", {
             path: path3,
             projectDir: this.config.projectDir,
             boundary
@@ -868,7 +868,7 @@ var init_base_provider = __esm({
       async checkCLIAvailability() {
         try {
           const { spawn } = await import("child_process");
-          return new Promise((resolve10) => {
+          return new Promise((resolve9) => {
             const child = spawn(this.config.command, ["--version"], {
               stdio: "ignore",
               timeout: 5e3
@@ -877,7 +877,7 @@ var init_base_provider = __esm({
             child.on("close", (code) => {
               if (!resolved) {
                 resolved = true;
-                resolve10(code === 0 || code === 1);
+                resolve9(code === 0 || code === 1);
               }
             });
             child.on("error", (error) => {
@@ -885,9 +885,9 @@ var init_base_provider = __esm({
                 resolved = true;
                 if (error.code === "ENOENT") {
                   logger.warn(`CLI command not found: ${this.config.command}`);
-                  resolve10(false);
+                  resolve9(false);
                 } else {
-                  resolve10(true);
+                  resolve9(true);
                 }
               }
             });
@@ -895,7 +895,7 @@ var init_base_provider = __esm({
               if (!resolved) {
                 resolved = true;
                 child.kill();
-                resolve10(false);
+                resolve9(false);
               }
             }, 5e3);
           });
@@ -1098,7 +1098,7 @@ var init_base_provider = __esm({
         return Math.ceil(text.length / 4);
       }
       sleep(ms) {
-        return new Promise((resolve10) => setTimeout(resolve10, ms));
+        return new Promise((resolve9) => setTimeout(resolve9, ms));
       }
       /**
        * Convert ExecutionRequest to messages array for cache key generation
@@ -1243,7 +1243,7 @@ This is a placeholder response. Set AUTOMATOSX_MOCK_PROVIDERS=false to use real
        */
       async executeRealCLI(prompt, request) {
         const { spawn } = await import("child_process");
-        return new Promise((resolve10, reject) => {
+        return new Promise((resolve9, reject) => {
           let stdout = "";
           let stderr = "";
           let hasTimedOut = false;
@@ -1321,7 +1321,7 @@ Details: ${errorMsg}`
               if (!stdout.trim()) {
                 reject(new Error("Claude CLI returned empty response"));
               } else {
-                resolve10({ content: stdout.trim() });
+                resolve9({ content: stdout.trim() });
               }
             }
           });
@@ -1515,7 +1515,7 @@ This is a placeholder response. Set AUTOMATOSX_MOCK_PROVIDERS=false to use real
        */
       async executeRealCLI(prompt, request) {
         const { spawn } = await import("child_process");
-        return new Promise((resolve10, reject) => {
+        return new Promise((resolve9, reject) => {
           let stdout = "";
           let stderr = "";
           let hasTimedOut = false;
@@ -1551,7 +1551,7 @@ This is a placeholder response. Set AUTOMATOSX_MOCK_PROVIDERS=false to use real
             if (code !== 0) {
               reject(new Error(`Gemini CLI exited with code ${code}: ${stderr}`));
             } else {
-              resolve10({ content: stdout.trim() });
+              resolve9({ content: stdout.trim() });
             }
           });
           child.on("error", (error) => {
@@ -1716,7 +1716,7 @@ This is a placeholder response. Set AUTOMATOSX_MOCK_PROVIDERS=false to use real
        */
       async executeRealCLI(prompt, request) {
         const { spawn } = await import("child_process");
-        return new Promise((resolve10, reject) => {
+        return new Promise((resolve9, reject) => {
           let stdout = "";
           let stderr = "";
           let hasTimedOut = false;
@@ -1751,7 +1751,7 @@ This is a placeholder response. Set AUTOMATOSX_MOCK_PROVIDERS=false to use real
             if (code !== 0) {
               reject(new Error(`OpenAI CLI exited with code ${code}: ${stderr}`));
             } else {
-              resolve10({ content: stdout.trim() });
+              resolve9({ content: stdout.trim() });
             }
           });
           child.on("error", (error) => {
@@ -2014,16 +2014,8 @@ var DEFAULT_CONFIG = {
       timeout: 15e5,
       // 25 minutes (v5.1.0: increased from 15 min based on user feedback)
       enableCycleDetection: true
-    },
-    workspace: {
-      maxFileSize: 10485760,
-      // 10 MB
-      maxFiles: 100,
-      cleanupAfterDays: 7,
-      autoCleanup: true,
-      permissions: 448,
-      basePath: ".automatosx/workspaces"
     }
+    // v5.2: workspace moved to root level
   },
   memory: {
     maxEntries: 1e4,
@@ -2056,10 +2048,10 @@ var DEFAULT_CONFIG = {
     }
   },
   workspace: {
-    basePath: ".automatosx/workspaces",
-    autoCleanup: true,
-    cleanupDays: 7,
-    maxFiles: 100
+    prdPath: "automatosx/PRD",
+    tmpPath: "automatosx/tmp",
+    autoCleanupTmp: true,
+    tmpCleanupDays: 7
   },
   logging: {
     level: "info",
@@ -2256,37 +2248,6 @@ var ConfigError = class _ConfigError extends BaseError {
     );
   }
 };
-var PathError = class _PathError extends BaseError {
-  constructor(message, code = "E1103" /* PATH_INVALID */, suggestions = [], context, isOperational = true) {
-    super(message, code, suggestions, context, isOperational);
-  }
-  static traversal(path3) {
-    return new _PathError(
-      `Path traversal attempt detected: ${path3}`,
-      "E1100" /* PATH_TRAVERSAL */,
-      [
-        "Use relative paths within the project directory",
-        'Avoid using ".." in file paths',
-        "Check your file path for security issues"
-      ],
-      { path: path3 },
-      false
-      // Security error, not operational
-    );
-  }
-  static notFound(path3, type = "Path") {
-    return new _PathError(
-      `${type} not found: ${path3}`,
-      "E1101" /* PATH_NOT_FOUND */,
-      [
-        "Check that the path exists and is accessible",
-        "Verify you have the correct permissions",
-        `Use "automatosx list" to see available ${type.toLowerCase()}s`
-      ],
-      { path: path3, type }
-    );
-  }
-};
 var ProviderError = class _ProviderError extends BaseError {
   constructor(message, code = "E1301" /* PROVIDER_UNAVAILABLE */, suggestions = [], context) {
     super(message, code, suggestions, context);
@@ -2653,50 +2614,50 @@ function validateWorkspace(workspace) {
     });
     return errors;
   }
-  if (typeof workspace.basePath !== "string") {
+  if (typeof workspace.prdPath !== "string") {
     errors.push({
-      path: `${basePath}.basePath`,
-      message: "basePath must be a string",
-      value: workspace.basePath
+      path: `${basePath}.prdPath`,
+      message: "prdPath must be a string",
+      value: workspace.prdPath
     });
-  } else if (workspace.basePath.trim() === "") {
+  } else if (workspace.prdPath.trim() === "") {
     errors.push({
-      path: `${basePath}.basePath`,
-      message: "basePath cannot be empty",
-      value: workspace.basePath
+      path: `${basePath}.prdPath`,
+      message: "prdPath cannot be empty",
+      value: workspace.prdPath
     });
   }
-  if (typeof workspace.autoCleanup !== "boolean") {
+  if (typeof workspace.tmpPath !== "string") {
     errors.push({
-      path: `${basePath}.autoCleanup`,
-      message: "autoCleanup must be a boolean",
-      value: workspace.autoCleanup
+      path: `${basePath}.tmpPath`,
+      message: "tmpPath must be a string",
+      value: workspace.tmpPath
     });
-  }
-  if (typeof workspace.cleanupDays !== "number") {
+  } else if (workspace.tmpPath.trim() === "") {
     errors.push({
-      path: `${basePath}.cleanupDays`,
-      message: "cleanupDays must be a number",
-      value: workspace.cleanupDays
+      path: `${basePath}.tmpPath`,
+      message: "tmpPath cannot be empty",
+      value: workspace.tmpPath
     });
-  } else if (workspace.cleanupDays < 1) {
+  }
+  if (typeof workspace.autoCleanupTmp !== "boolean") {
     errors.push({
-      path: `${basePath}.cleanupDays`,
-      message: "cleanupDays must be >= 1",
-      value: workspace.cleanupDays
+      path: `${basePath}.autoCleanupTmp`,
+      message: "autoCleanupTmp must be a boolean",
+      value: workspace.autoCleanupTmp
     });
   }
-  if (typeof workspace.maxFiles !== "number") {
+  if (typeof workspace.tmpCleanupDays !== "number") {
     errors.push({
-      path: `${basePath}.maxFiles`,
-      message: "maxFiles must be a number",
-      value: workspace.maxFiles
+      path: `${basePath}.tmpCleanupDays`,
+      message: "tmpCleanupDays must be a number",
+      value: workspace.tmpCleanupDays
     });
-  } else if (workspace.maxFiles < 1) {
+  } else if (workspace.tmpCleanupDays < 1) {
     errors.push({
-      path: `${basePath}.maxFiles`,
-      message: "maxFiles must be >= 1",
-      value: workspace.maxFiles
+      path: `${basePath}.tmpCleanupDays`,
+      message: "tmpCleanupDays must be >= 1",
+      value: workspace.tmpCleanupDays
     });
   }
   return errors;
@@ -3160,26 +3121,6 @@ function validateConfig2(config) {
         errors.push(`Orchestration: delegation.timeout must be <= ${VALIDATION_LIMITS.MAX_TIMEOUT}ms`);
       }
     }
-    if (!isPositiveInteger(config.orchestration.workspace.maxFileSize)) {
-      errors.push("Orchestration: workspace.maxFileSize must be a positive integer");
-    } else {
-      if (config.orchestration.workspace.maxFileSize < VALIDATION_LIMITS.MIN_FILE_SIZE) {
-        errors.push(`Orchestration: workspace.maxFileSize must be >= ${VALIDATION_LIMITS.MIN_FILE_SIZE} bytes`);
-      }
-      if (config.orchestration.workspace.maxFileSize > VALIDATION_LIMITS.MAX_FILE_SIZE) {
-        errors.push(`Orchestration: workspace.maxFileSize must be <= ${VALIDATION_LIMITS.MAX_FILE_SIZE} bytes (100MB max)`);
-      }
-    }
-    if (!isPositiveInteger(config.orchestration.workspace.maxFiles)) {
-      errors.push("Orchestration: workspace.maxFiles must be a positive integer");
-    } else if (config.orchestration.workspace.maxFiles > 1e4) {
-      errors.push("Orchestration: workspace.maxFiles must be <= 10000");
-    }
-    if (!isPositiveInteger(config.orchestration.workspace.cleanupAfterDays)) {
-      errors.push("Orchestration: workspace.cleanupAfterDays must be a positive integer");
-    } else if (config.orchestration.workspace.cleanupAfterDays > 365) {
-      errors.push("Orchestration: workspace.cleanupAfterDays must be <= 365 days");
-    }
   }
   if (!isPositiveInteger(config.memory.maxEntries)) {
     errors.push("Memory: maxEntries must be a positive integer");
@@ -3257,15 +3198,16 @@ function validateConfig2(config) {
       }
     }
   }
-  if (!isPositiveInteger(config.workspace.cleanupDays)) {
-    errors.push("Workspace: cleanupDays must be a positive integer");
-  } else if (config.workspace.cleanupDays > 365) {
-    errors.push("Workspace: cleanupDays must be <= 365 days");
+  if (typeof config.workspace.prdPath !== "string" || !config.workspace.prdPath.trim()) {
+    errors.push("Workspace: prdPath must be a non-empty string");
+  }
+  if (typeof config.workspace.tmpPath !== "string" || !config.workspace.tmpPath.trim()) {
+    errors.push("Workspace: tmpPath must be a non-empty string");
   }
-  if (!isPositiveInteger(config.workspace.maxFiles)) {
-    errors.push("Workspace: maxFiles must be a positive integer");
-  } else if (config.workspace.maxFiles > 1e4) {
-    errors.push("Workspace: maxFiles must be <= 10000");
+  if (!isPositiveInteger(config.workspace.tmpCleanupDays)) {
+    errors.push("Workspace: tmpCleanupDays must be a positive integer");
+  } else if (config.workspace.tmpCleanupDays > 365) {
+    errors.push("Workspace: tmpCleanupDays must be <= 365 days");
   }
   if (config.logging?.retention) {
     if (!isPositiveInteger(config.logging.retention.maxSizeBytes)) {
@@ -3365,8 +3307,9 @@ function validateConfig2(config) {
     { name: "Abilities: basePath", value: config.abilities?.basePath },
     { name: "Abilities: fallbackPath", value: config.abilities?.fallbackPath },
     { name: "Orchestration: session.persistPath", value: config.orchestration?.session.persistPath },
-    { name: "Orchestration: workspace.basePath", value: config.orchestration?.workspace.basePath },
-    { name: "Workspace: basePath", value: config.workspace.basePath }
+    // v5.2: Workspace moved to root level
+    { name: "Workspace: prdPath", value: config.workspace.prdPath },
+    { name: "Workspace: tmpPath", value: config.workspace.tmpPath }
   ];
   for (const { name, value } of pathFields) {
     if (value && typeof value === "string" && !isValidRelativePath(value)) {
@@ -3631,11 +3574,11 @@ async function listConfig(config, verbose) {
   console.log(chalk3.bold.white("\n\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   console.log(chalk3.bold.white("\u2502 ") + chalk3.bold.cyan("Workspace"));
   console.log(chalk3.bold.white("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n"));
-  console.log(formatKeyValue("  Base Path      ", chalk3.blue(config.workspace.basePath)));
-  console.log(formatKeyValue("  Auto Cleanup   ", config.workspace.autoCleanup ? chalk3.green("\u2713 Enabled") : chalk3.gray("\u2717 Disabled")));
+  console.log(formatKeyValue("  PRD Path       ", chalk3.blue(config.workspace.prdPath)));
+  console.log(formatKeyValue("  Tmp Path       ", chalk3.blue(config.workspace.tmpPath)));
+  console.log(formatKeyValue("  Auto Cleanup   ", config.workspace.autoCleanupTmp ? chalk3.green("\u2713 Enabled") : chalk3.gray("\u2717 Disabled")));
   if (verbose) {
-    console.log(formatKeyValue("  Cleanup Days   ", chalk3.yellow(config.workspace.cleanupDays.toString())));
-    console.log(formatKeyValue("  Max Files      ", chalk3.yellow(config.workspace.maxFiles.toString())));
+    console.log(formatKeyValue("  Cleanup Days   ", chalk3.yellow(config.workspace.tmpCleanupDays.toString())));
   }
   console.log(chalk3.bold.white("\n\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   console.log(chalk3.bold.white("\u2502 ") + chalk3.bold.cyan("Logging"));
@@ -3725,21 +3668,24 @@ function setNestedValue(obj, path3, value) {
 
 // src/cli/commands/init.ts
 init_esm_shims();
-import { mkdir as mkdir2, writeFile as writeFile3, access as access2 } from "fs/promises";
+import { mkdir as mkdir2, writeFile as writeFile3, access as access2, readdir, copyFile, rm, stat } from "fs/promises";
 import { resolve as resolve3, join as join2, dirname as dirname2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { constants as constants2 } from "fs";
+import { constants as constants2, existsSync as existsSync3 } from "fs";
 import chalk4 from "chalk";
 init_logger();
 var __filename2 = fileURLToPath2(import.meta.url);
 var __dirname2 = dirname2(__filename2);
 function getPackageRoot() {
-  const currentDir = __dirname2;
-  if (currentDir.includes("/dist")) {
-    return join2(currentDir, "..");
-  } else {
-    return join2(currentDir, "../../..");
+  let current = __dirname2;
+  const root = "/";
+  while (current !== root) {
+    if (existsSync3(join2(current, "package.json"))) {
+      return current;
+    }
+    current = dirname2(current);
   }
+  throw new Error("Could not find package root (no package.json found)");
 }
 var initCommand = {
   command: "init [path]",
@@ -3759,8 +3705,25 @@ var initCommand = {
   handler: async (argv2) => {
     const projectDir = resolve3(argv2.path || ".");
     const automatosxDir = join2(projectDir, ".automatosx");
-    console.log(chalk4.blue.bold("\n\u{1F916} AutomatosX v4.0 - Project Initialization\n"));
+    const configPath = join2(projectDir, "automatosx.config.json");
+    const packageRoot = getPackageRoot();
+    let version = "5.1.2";
     try {
+      const packageJson = JSON.parse(
+        await import("fs/promises").then((fs2) => fs2.readFile(join2(packageRoot, "package.json"), "utf-8"))
+      );
+      version = packageJson.version;
+    } catch {
+    }
+    console.log(chalk4.blue.bold(`
+\u{1F916} AutomatosX v${version} - Project Initialization
+`));
+    const createdResources = [];
+    let shouldRollback = false;
+    try {
+      console.log(chalk4.cyan("\u{1F50D} Validating environment..."));
+      await validateEnvironment(packageRoot);
+      console.log(chalk4.green("   \u2713 Environment validation passed"));
       const exists = await checkExists2(automatosxDir);
       if (exists && !argv2.force) {
         console.log(chalk4.yellow("\u26A0\uFE0F  AutomatosX is already initialized in this directory"));
@@ -3773,23 +3736,31 @@ var initCommand = {
       }
       console.log(chalk4.cyan("\u{1F4C1} Creating directory structure..."));
       await createDirectoryStructure(automatosxDir);
+      createdResources.push(automatosxDir);
       console.log(chalk4.green("   \u2713 Directories created"));
+      console.log(chalk4.cyan("\u{1F465} Installing team configurations..."));
+      const teamCount = await copyExampleTeams(automatosxDir, packageRoot);
+      console.log(chalk4.green(`   \u2713 ${teamCount} team configurations installed`));
       console.log(chalk4.cyan("\u{1F916} Installing example agents..."));
-      await copyExampleAgents(automatosxDir);
-      console.log(chalk4.green("   \u2713 5 example agents installed"));
+      const agentCount = await copyExampleAgents(automatosxDir, packageRoot);
+      console.log(chalk4.green(`   \u2713 ${agentCount} example agents installed`));
       console.log(chalk4.cyan("\u26A1 Installing example abilities..."));
-      await copyExampleAbilities(automatosxDir);
-      console.log(chalk4.green("   \u2713 15 example abilities installed"));
+      const abilityCount = await copyExampleAbilities(automatosxDir, packageRoot);
+      console.log(chalk4.green(`   \u2713 ${abilityCount} example abilities installed`));
       console.log(chalk4.cyan("\u{1F4CB} Installing agent templates..."));
-      await copyExampleTemplates(automatosxDir);
-      console.log(chalk4.green("   \u2713 5 agent templates installed"));
+      const templateCount = await copyExampleTemplates(automatosxDir, packageRoot);
+      console.log(chalk4.green(`   \u2713 ${templateCount} agent templates installed`));
       console.log(chalk4.cyan("\u2699\uFE0F  Generating configuration..."));
-      const configPath = join2(projectDir, "automatosx.config.json");
       await createDefaultConfig(configPath, argv2.force ?? false);
+      createdResources.push(configPath);
       console.log(chalk4.green("   \u2713 Configuration created"));
       console.log(chalk4.cyan("\u{1F50C} Setting up Claude Code integration..."));
-      await setupClaudeIntegration(projectDir);
+      await setupClaudeIntegration(projectDir, packageRoot);
+      createdResources.push(join2(projectDir, ".claude"));
       console.log(chalk4.green("   \u2713 Claude Code integration configured"));
+      console.log(chalk4.cyan("\u{1F527} Initializing git repository..."));
+      await initializeGitRepository(projectDir);
+      console.log(chalk4.green("   \u2713 Git repository initialized"));
       console.log(chalk4.cyan("\u{1F4DD} Updating .gitignore..."));
       await updateGitignore(projectDir);
       console.log(chalk4.green("   \u2713 .gitignore updated"));
@@ -3815,15 +3786,28 @@ var initCommand = {
       console.log(chalk4.gray("  \u2022 Use /ax command in Claude Code"));
       console.log(chalk4.gray('  \u2022 Example: /ax assistant "Explain this code"'));
       console.log(chalk4.gray("  \u2022 MCP tools available in .claude/mcp/\n"));
-      logger.info("AutomatosX initialized", { projectDir, automatosxDir });
+      logger.info("AutomatosX initialized", {
+        projectDir,
+        automatosxDir,
+        counts: { teams: teamCount, agents: agentCount, abilities: abilityCount, templates: templateCount }
+      });
     } catch (error) {
+      shouldRollback = true;
+      if (createdResources.length > 0 && !argv2.force) {
+        console.log(chalk4.yellow("\n\u26A0\uFE0F  Initialization failed. Rolling back changes..."));
+        await rollbackCreatedResources(createdResources);
+        console.log(chalk4.green("   \u2713 Rollback completed"));
+      }
       printError(error, {
         verbose: false,
         showCode: true,
         showSuggestions: true,
         colors: true
       });
-      logger.error("Initialization failed", { error: error.message });
+      logger.error("Initialization failed", {
+        error: error.message,
+        rolledBack: shouldRollback && createdResources.length > 0
+      });
       process.exit(1);
     }
   }
@@ -3849,57 +3833,116 @@ async function createDirectoryStructure(baseDir) {
     // v5.1: MCP memory export directory
     join2(baseDir, "sessions"),
     // v5.1: Session persistence
-    join2(baseDir, "workspaces"),
+    // v5.2: Removed 'workspaces' - automatosx/PRD and automatosx/tmp created on-demand
     join2(baseDir, "logs")
   ];
   for (const dir of dirs) {
     await mkdir2(dir, { recursive: true });
   }
 }
-async function copyExampleAgents(baseDir) {
-  const { readdir: readdir8, copyFile: copyFile2 } = await import("fs/promises");
-  const examplesDir = join2(getPackageRoot(), "examples/agents");
+async function validateEnvironment(packageRoot) {
+  const requiredDirs = [
+    "examples/agents",
+    "examples/abilities",
+    "examples/templates",
+    "examples/teams"
+  ];
+  const errors = [];
+  for (const dir of requiredDirs) {
+    const fullPath = join2(packageRoot, dir);
+    try {
+      await stat(fullPath);
+    } catch {
+      errors.push(`Missing required directory: ${dir}`);
+    }
+  }
+  if (errors.length > 0) {
+    throw new Error(
+      `Environment validation failed:
+${errors.map((e) => `  \u2022 ${e}`).join("\n")}
+
+This usually means the package is corrupted. Try reinstalling:
+  npm uninstall -g @defai.digital/automatosx
+  npm install -g @defai.digital/automatosx`
+    );
+  }
+}
+async function rollbackCreatedResources(resources) {
+  for (const resource of resources.reverse()) {
+    try {
+      await rm(resource, { recursive: true, force: true });
+      logger.info("Rolled back resource", { resource });
+    } catch (error) {
+      logger.warn("Failed to rollback resource", {
+        resource,
+        error: error.message
+      });
+    }
+  }
+}
+async function copyExampleTeams(baseDir, packageRoot) {
+  const examplesDir = join2(packageRoot, "examples/teams");
+  const targetDir = join2(baseDir, "teams");
+  const files = await readdir(examplesDir);
+  let count = 0;
+  for (const file of files) {
+    if (file.endsWith(".yaml")) {
+      await copyFile(join2(examplesDir, file), join2(targetDir, file));
+      count++;
+    }
+  }
+  if (count === 0) {
+    throw new Error(`No team configuration files found in ${examplesDir}`);
+  }
+  return count;
+}
+async function copyExampleAgents(baseDir, packageRoot) {
+  const examplesDir = join2(packageRoot, "examples/agents");
   const targetDir = join2(baseDir, "agents");
-  try {
-    const files = await readdir8(examplesDir);
-    for (const file of files) {
-      if (file.endsWith(".yaml")) {
-        await copyFile2(join2(examplesDir, file), join2(targetDir, file));
-      }
+  const files = await readdir(examplesDir);
+  let count = 0;
+  for (const file of files) {
+    if (file.endsWith(".yaml")) {
+      await copyFile(join2(examplesDir, file), join2(targetDir, file));
+      count++;
     }
-  } catch (error) {
-    logger.warn("Could not copy example agents", { error: error.message });
   }
+  if (count === 0) {
+    throw new Error(`No agent files found in ${examplesDir}`);
+  }
+  return count;
 }
-async function copyExampleAbilities(baseDir) {
-  const { readdir: readdir8, copyFile: copyFile2 } = await import("fs/promises");
-  const examplesDir = join2(getPackageRoot(), "examples/abilities");
+async function copyExampleAbilities(baseDir, packageRoot) {
+  const examplesDir = join2(packageRoot, "examples/abilities");
   const targetDir = join2(baseDir, "abilities");
-  try {
-    const files = await readdir8(examplesDir);
-    for (const file of files) {
-      if (file.endsWith(".md")) {
-        await copyFile2(join2(examplesDir, file), join2(targetDir, file));
-      }
+  const files = await readdir(examplesDir);
+  let count = 0;
+  for (const file of files) {
+    if (file.endsWith(".md")) {
+      await copyFile(join2(examplesDir, file), join2(targetDir, file));
+      count++;
     }
-  } catch (error) {
-    logger.warn("Could not copy example abilities", { error: error.message });
   }
+  if (count === 0) {
+    throw new Error(`No ability files found in ${examplesDir}`);
+  }
+  return count;
 }
-async function copyExampleTemplates(baseDir) {
-  const { readdir: readdir8, copyFile: copyFile2 } = await import("fs/promises");
-  const examplesDir = join2(getPackageRoot(), "examples/templates");
+async function copyExampleTemplates(baseDir, packageRoot) {
+  const examplesDir = join2(packageRoot, "examples/templates");
   const targetDir = join2(baseDir, "templates");
-  try {
-    const files = await readdir8(examplesDir);
-    for (const file of files) {
-      if (file.endsWith(".yaml")) {
-        await copyFile2(join2(examplesDir, file), join2(targetDir, file));
-      }
+  const files = await readdir(examplesDir);
+  let count = 0;
+  for (const file of files) {
+    if (file.endsWith(".yaml")) {
+      await copyFile(join2(examplesDir, file), join2(targetDir, file));
+      count++;
     }
-  } catch (error) {
-    logger.warn("Could not copy agent templates", { error: error.message });
   }
+  if (count === 0) {
+    throw new Error(`No template files found in ${examplesDir}`);
+  }
+  return count;
 }
 async function createDefaultConfig(configPath, force) {
   const exists = await checkExists2(configPath);
@@ -3915,31 +3958,73 @@ async function createDefaultConfig(configPath, force) {
   const content = JSON.stringify(config, null, 2);
   await writeFile3(configPath, content, "utf-8");
 }
-async function setupClaudeIntegration(projectDir) {
-  const { readdir: readdir8, copyFile: copyFile2 } = await import("fs/promises");
-  const examplesBaseDir = join2(getPackageRoot(), "examples/claude");
+async function setupClaudeIntegration(projectDir, packageRoot) {
+  const examplesBaseDir = join2(packageRoot, "examples/claude");
   const claudeDir = join2(projectDir, ".claude");
   const commandsDir = join2(claudeDir, "commands");
   const mcpDir = join2(claudeDir, "mcp");
   await mkdir2(commandsDir, { recursive: true });
   await mkdir2(mcpDir, { recursive: true });
-  try {
-    const commandsSourceDir = join2(examplesBaseDir, "commands");
-    const commandFiles = await readdir8(commandsSourceDir);
-    for (const file of commandFiles) {
-      if (file.endsWith(".md")) {
-        await copyFile2(join2(commandsSourceDir, file), join2(commandsDir, file));
-      }
+  const commandsSourceDir = join2(examplesBaseDir, "commands");
+  const commandFiles = await readdir(commandsSourceDir);
+  for (const file of commandFiles) {
+    if (file.endsWith(".md")) {
+      await copyFile(join2(commandsSourceDir, file), join2(commandsDir, file));
     }
-    const mcpSourceDir = join2(examplesBaseDir, "mcp");
-    const mcpFiles = await readdir8(mcpSourceDir);
-    for (const file of mcpFiles) {
-      if (file.endsWith(".json")) {
-        await copyFile2(join2(mcpSourceDir, file), join2(mcpDir, file));
-      }
+  }
+  const mcpSourceDir = join2(examplesBaseDir, "mcp");
+  const mcpFiles = await readdir(mcpSourceDir);
+  for (const file of mcpFiles) {
+    if (file.endsWith(".json")) {
+      await copyFile(join2(mcpSourceDir, file), join2(mcpDir, file));
+    }
+  }
+}
+async function initializeGitRepository(projectDir) {
+  const gitDir = join2(projectDir, ".git");
+  try {
+    const isGitRepo = await checkExists2(gitDir);
+    if (isGitRepo) {
+      logger.info("Git repository already exists, skipping initialization");
+      return;
     }
+    const { spawn } = await import("child_process");
+    await new Promise((resolve9, reject) => {
+      const child = spawn("git", ["init"], {
+        cwd: projectDir,
+        stdio: "pipe"
+      });
+      let stderr = "";
+      child.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      child.on("close", (code) => {
+        if (code !== 0) {
+          reject(new Error(`git init failed with code ${code}: ${stderr}`));
+        } else {
+          logger.info("Git repository initialized successfully");
+          resolve9();
+        }
+      });
+      child.on("error", (error) => {
+        reject(error);
+      });
+    });
   } catch (error) {
-    logger.warn("Could not copy Claude integration files", { error: error.message });
+    const errorMessage = error.message;
+    if (errorMessage.includes("ENOENT") || errorMessage.includes("spawn git")) {
+      console.log(chalk4.yellow("   \u26A0\uFE0F  Git is not installed - skipping repository initialization"));
+      console.log(chalk4.gray("      Note: Codex CLI requires git. Install git to use Codex provider."));
+      logger.warn("Git not found, skipping repository initialization", {
+        error: errorMessage
+      });
+    } else {
+      console.log(chalk4.yellow("   \u26A0\uFE0F  Failed to initialize git repository"));
+      console.log(chalk4.gray(`      ${errorMessage}`));
+      logger.warn("Git initialization failed", {
+        error: errorMessage
+      });
+    }
   }
 }
 async function updateGitignore(projectDir) {
@@ -3948,8 +4033,8 @@ async function updateGitignore(projectDir) {
     "",
     "# AutomatosX",
     ".automatosx/memory/",
-    ".automatosx/workspaces/",
     ".automatosx/logs/",
+    "automatosx/tmp/  # v5.2: Temporary files",
     "automatosx.config.json  # Optional: remove to track config",
     ""
   ].join("\n");
@@ -3974,7 +4059,7 @@ async function updateGitignore(projectDir) {
 init_esm_shims();
 init_logger();
 init_path_resolver();
-import { readdir } from "fs/promises";
+import { readdir as readdir2 } from "fs/promises";
 import { join as join3 } from "path";
 import chalk5 from "chalk";
 var listCommand = {
@@ -4017,13 +4102,13 @@ var listCommand = {
 };
 async function listAgents(pathResolver) {
   const agentsDir = pathResolver.getAgentsDirectory();
-  const { existsSync: existsSync9 } = await import("fs");
+  const { existsSync: existsSync10 } = await import("fs");
   const projectDir = await detectProjectRoot();
   const examplesDir = join3(projectDir, "examples", "agents");
   try {
     const agentFiles = [];
-    if (existsSync9(agentsDir)) {
-      const files = await readdir(agentsDir);
+    if (existsSync10(agentsDir)) {
+      const files = await readdir2(agentsDir);
       for (const file of files) {
         if (file.endsWith(".yaml") || file.endsWith(".yml")) {
           agentFiles.push({
@@ -4034,8 +4119,8 @@ async function listAgents(pathResolver) {
         }
       }
     }
-    if (existsSync9(examplesDir)) {
-      const files = await readdir(examplesDir);
+    if (existsSync10(examplesDir)) {
+      const files = await readdir2(examplesDir);
       for (const file of files) {
         if (file.endsWith(".yaml") || file.endsWith(".yml")) {
           const alreadyLoaded = agentFiles.some((a) => a.file === file);
@@ -4090,7 +4175,7 @@ async function listAgents(pathResolver) {
 async function listAbilities(pathResolver) {
   const abilitiesDir = pathResolver.getAbilitiesDirectory();
   try {
-    const files = await readdir(abilitiesDir);
+    const files = await readdir2(abilitiesDir);
     const abilityFiles = files.filter((f) => f.endsWith(".md"));
     if (abilityFiles.length === 0) {
       console.log(chalk5.yellow("\n\u26A0\uFE0F  No abilities found\n"));
@@ -4338,7 +4423,7 @@ var Router = class {
 init_esm_shims();
 import Database from "better-sqlite3";
 import * as sqliteVec from "sqlite-vec";
-import { existsSync as existsSync3, mkdirSync } from "fs";
+import { existsSync as existsSync4, mkdirSync } from "fs";
 import { dirname as dirname4 } from "path";
 
 // src/types/memory.ts
@@ -4391,7 +4476,7 @@ var MemoryManager = class _MemoryManager {
     };
     this.validateCleanupConfig();
     const dir = dirname4(this.config.dbPath);
-    if (!existsSync3(dir)) {
+    if (!existsSync4(dir)) {
       mkdirSync(dir, { recursive: true });
     }
     this.db = new Database(this.config.dbPath);
@@ -5147,9 +5232,9 @@ var MemoryManager = class _MemoryManager {
     }
     try {
       const { dirname: dirname9 } = await import("path");
-      const { mkdir: mkdir7 } = await import("fs/promises");
+      const { mkdir: mkdir6 } = await import("fs/promises");
       const destDir = dirname9(destPath);
-      await mkdir7(destDir, { recursive: true });
+      await mkdir6(destDir, { recursive: true });
       await this.db.backup(destPath);
       logger.info("Database backup created", { destPath });
     } catch (error) {
@@ -5165,7 +5250,7 @@ var MemoryManager = class _MemoryManager {
       throw new MemoryError("Memory manager not initialized", "DATABASE_ERROR");
     }
     try {
-      if (!existsSync3(srcPath)) {
+      if (!existsSync4(srcPath)) {
         throw new MemoryError(
           `Backup file not found: ${srcPath}`,
           "DATABASE_ERROR",
@@ -5206,7 +5291,7 @@ var MemoryManager = class _MemoryManager {
     } = options || {};
     try {
       const destDir = dirname4(filePath);
-      if (!existsSync3(destDir)) {
+      if (!existsSync4(destDir)) {
         mkdirSync(destDir, { recursive: true });
       }
       let query = "SELECT e.* FROM memory_entries e";
@@ -5304,7 +5389,7 @@ var MemoryManager = class _MemoryManager {
       clearExisting = false
     } = options || {};
     try {
-      if (!existsSync3(filePath)) {
+      if (!existsSync4(filePath)) {
         throw new MemoryError(
           `Import file not found: ${filePath}`,
           "DATABASE_ERROR",
@@ -5410,7 +5495,7 @@ var MemoryManager = class _MemoryManager {
 // src/core/session-manager.ts
 init_esm_shims();
 import { randomUUID } from "crypto";
-import { readFile as readFile2, writeFile as writeFile4, mkdir as mkdir3, rename, copyFile, unlink } from "fs/promises";
+import { readFile as readFile2, writeFile as writeFile4, mkdir as mkdir3, rename, copyFile as copyFile2, unlink } from "fs/promises";
 import { dirname as dirname5 } from "path";
 
 // src/types/orchestration.ts
@@ -5432,14 +5517,6 @@ var SessionError = class extends Error {
     this.name = "SessionError";
   }
 };
-var WorkspaceError = class extends Error {
-  constructor(message, workspacePath, reason) {
-    super(message);
-    this.workspacePath = workspacePath;
-    this.reason = reason;
-    this.name = "WorkspaceError";
-  }
-};
 
 // src/core/session-manager.ts
 init_logger();
@@ -5874,8 +5951,8 @@ var SessionManager = class _SessionManager {
    * const result = await sessionManager.cleanupOldSessions();
    * console.log(`Removed ${result.removedCount} sessions`);
    *
-   * // Use removedSessionIds to cleanup corresponding workspaces
-   * await workspaceManager.cleanupSessionWorkspaces(result.removedSessionIds);
+   * // v5.2: Session workspaces no longer exist
+   * // All agents share automatosx/PRD and automatosx/tmp
    * ```
    */
   async cleanupOldSessions(maxAgeDays = 7) {
@@ -6101,7 +6178,7 @@ var SessionManager = class _SessionManager {
       }
       try {
         const backupPath = `${this.persistencePath}.corrupted.${Date.now()}`;
-        await copyFile(this.persistencePath, backupPath);
+        await copyFile2(this.persistencePath, backupPath);
         logger.error("Corrupted sessions file backed up, starting fresh", {
           path: this.persistencePath,
           backupPath,
@@ -6141,488 +6218,291 @@ var SessionManager = class _SessionManager {
 
 // src/core/workspace-manager.ts
 init_esm_shims();
+init_logger();
 import { promises as fs } from "fs";
 import path2 from "path";
-init_logger();
 var WorkspaceManager = class _WorkspaceManager {
-  workspacesRoot;
-  sharedRoot;
-  sessionsRoot;
-  persistentRoot;
-  /** Maximum file size for writeToSession (from config) */
-  maxFileSize;
-  /** UUID v4 validation regex (static for performance) */
-  static UUID_V4_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  projectDir;
+  prdDir;
+  tmpDir;
+  directoriesEnsured = false;
+  /** Maximum file size in bytes (10MB) */
+  static MAX_FILE_SIZE = 10 * 1024 * 1024;
   /**
    * Create WorkspaceManager
    *
    * @param projectDir - Project directory path
-   * @param config - Workspace configuration (optional, defaults to 10MB max file size)
+   * @param config - Optional workspace configuration
    */
   constructor(projectDir, config) {
-    this.workspacesRoot = path2.join(projectDir, ".automatosx", "workspaces");
-    this.sharedRoot = path2.join(this.workspacesRoot, "shared");
-    this.sessionsRoot = path2.join(this.sharedRoot, "sessions");
-    this.persistentRoot = path2.join(this.sharedRoot, "persistent");
-    this.maxFileSize = config?.maxFileSize ?? 10 * 1024 * 1024;
-  }
-  /**
-   * Initialize workspace structure
-   *
-   * Creates all necessary directories for workspace management.
-   *
-   * @example
-   * ```typescript
-   * await workspaceManager.initialize();
-   * ```
-   */
-  async initialize() {
-    await fs.mkdir(this.workspacesRoot, { recursive: true });
-    await fs.mkdir(this.sharedRoot, { recursive: true });
-    await fs.mkdir(this.sessionsRoot, { recursive: true });
-    await fs.mkdir(this.persistentRoot, { recursive: true });
-    logger.debug("Workspace structure initialized", {
-      workspacesRoot: this.workspacesRoot
-    });
+    this.projectDir = projectDir;
+    const prdPath = config?.prdPath ?? "automatosx/PRD";
+    const tmpPath = config?.tmpPath ?? "automatosx/tmp";
+    this.prdDir = path2.join(projectDir, prdPath);
+    this.tmpDir = path2.join(projectDir, tmpPath);
   }
   /**
-   * Create workspace for a session
+   * Ensure PRD/tmp directories exist (lazy initialization with caching)
    *
-   * @param sessionId - Session ID
-   * @throws {WorkspaceError} If creation fails
-   *
-   * @example
-   * ```typescript
-   * await workspaceManager.createSessionWorkspace('session-123');
-   * ```
+   * Creates directories only when needed, not during init.
+   * Uses caching to avoid repeated filesystem checks.
    */
-  async createSessionWorkspace(sessionId) {
-    const sessionDir = this.getSessionDir(sessionId);
-    const specsDir = path2.join(sessionDir, "specs");
-    const outputsDir = path2.join(sessionDir, "outputs");
-    try {
-      await fs.mkdir(sessionDir, { recursive: true });
-      await fs.mkdir(specsDir, { recursive: true });
-      await fs.mkdir(outputsDir, { recursive: true });
-      logger.info("Session workspace created", {
-        sessionId,
-        path: sessionDir
-      });
-    } catch (error) {
-      throw new WorkspaceError(
-        `Failed to create session workspace: ${error.message}`,
-        sessionDir,
-        "creation_failed"
-      );
+  async ensureDirectories() {
+    if (this.directoriesEnsured) {
+      return;
     }
+    await fs.mkdir(this.prdDir, { recursive: true });
+    await fs.mkdir(this.tmpDir, { recursive: true });
+    this.directoriesEnsured = true;
+    logger.debug("Workspace directories ensured", {
+      prdDir: this.prdDir,
+      tmpDir: this.tmpDir
+    });
   }
   /**
-   * Get agent's output directory within a session
-   *
-   * @param sessionId - Session ID
-   * @param agentName - Agent name
-   * @returns Path to agent's output directory
-   */
-  getAgentOutputDir(sessionId, agentName) {
-    return path2.join(this.getSessionDir(sessionId), "outputs", agentName);
-  }
-  /**
-   * Validate session ID format (must be valid UUID v4)
+   * Validate file size
    *
-   * @param sessionId - Session ID to validate
-   * @throws {WorkspaceError} If session ID is invalid
+   * @param content - File content
+   * @throws {Error} If file size exceeds MAX_FILE_SIZE
    */
-  validateSessionId(sessionId) {
-    if (!_WorkspaceManager.UUID_V4_REGEX.test(sessionId)) {
-      throw new WorkspaceError(
-        `Invalid session ID format: ${sessionId}. Session IDs must be valid UUID v4.`,
-        void 0,
-        "invalid_session_id"
+  validateFileSize(content) {
+    const sizeInBytes = Buffer.byteLength(content, "utf-8");
+    if (sizeInBytes > _WorkspaceManager.MAX_FILE_SIZE) {
+      throw new Error(
+        `File too large: ${sizeInBytes} bytes (max: ${_WorkspaceManager.MAX_FILE_SIZE} bytes)`
       );
     }
   }
   /**
-   * Get session directory path
+   * Validate path security (prevent path traversal attacks)
    *
-   * @param sessionId - Session ID
-   * @returns Session directory path
-   */
-  getSessionDir(sessionId) {
-    this.validateSessionId(sessionId);
-    return path2.join(this.sessionsRoot, sessionId);
-  }
-  /**
-   * Validate that a file path is safe (prevents path traversal attacks)
+   * Security checks:
+   * 1. Reject absolute paths
+   * 2. Normalize path and check for '..' at start
+   * 3. Verify resolved path is within base directory
    *
    * @param baseDir - Base directory that file must be within
    * @param filePath - Relative file path to validate
    * @returns Resolved absolute path
-   * @throws {WorkspaceError} If path is unsafe
-   *
-   * Security checks:
-   * 1. Normalize path to resolve '..' and '.'
-   * 2. Resolve to absolute path
-   * 3. Verify resolved path is within base directory
-   * 4. Prevent symlink attacks by checking real path
+   * @throws {Error} If path is unsafe
    */
-  async validatePath(baseDir, filePath) {
+  validatePath(baseDir, filePath) {
+    if (!filePath || !filePath.trim()) {
+      throw new Error("File path cannot be empty");
+    }
     if (path2.isAbsolute(filePath)) {
-      throw new WorkspaceError(
-        `Absolute paths not allowed: ${filePath}`,
-        filePath,
-        "permission_denied"
-      );
+      throw new Error(`Absolute paths not allowed: ${filePath}`);
     }
     const normalized = path2.normalize(filePath);
     if (normalized.startsWith("..")) {
-      throw new WorkspaceError(
-        `Path traversal detected: ${filePath}`,
-        filePath,
-        "permission_denied"
-      );
+      throw new Error(`Path traversal detected: ${filePath}`);
+    }
+    if (normalized === "." || normalized === "./") {
+      throw new Error("Cannot write to base directory itself");
     }
     const resolved = path2.resolve(baseDir, normalized);
     const resolvedBase = path2.resolve(baseDir);
     if (!resolved.startsWith(resolvedBase + path2.sep) && resolved !== resolvedBase) {
-      throw new WorkspaceError(
-        `Path outside workspace: ${filePath}`,
-        filePath,
-        "permission_denied"
-      );
+      throw new Error(`Path outside workspace: ${filePath}`);
     }
     return resolved;
   }
   /**
-   * Get agent's private workspace directory
+   * Write PRD document
    *
-   * @param agentName - Agent name
-   * @returns Agent workspace path
-   */
-  getAgentWorkspaceDir(agentName) {
-    return path2.join(this.workspacesRoot, agentName);
-  }
-  /**
-   * Write file to session workspace (agent's output area)
+   * PRD documents are permanent and should contain:
+   * - Feature designs (feature-*.md)
+   * - Workflow plans (workflow-*.md)
+   * - Architecture proposals (proposal-*.md)
    *
-   * @param sessionId - Session ID
-   * @param agentName - Agent writing the file
-   * @param filePath - Relative file path within agent's output
+   * @param fileName - Relative file path within PRD/
    * @param content - File content
-   * @param callerAgent - Optional: Agent profile of the caller (for permission verification)
-   * @throws {WorkspaceError} If write fails, path is invalid, or permission denied
+   * @throws {Error} If path is invalid, file too large, or write fails
    *
    * @example
    * ```typescript
-   * await workspaceManager.writeToSession(
-   *   'session-123',
-   *   'backend',
-   *   'api/users.ts',
-   *   'export interface User { ... }',
-   *   backendProfile  // Verify caller is actually 'backend'
-   * );
+   * await workspaceManager.writePRD('feature-auth.md', '# Authentication Feature...');
    * ```
    */
-  async writeToSession(sessionId, agentName, filePath, content, callerAgent) {
-    if (callerAgent && callerAgent.name !== agentName) {
-      throw new WorkspaceError(
-        `Agent '${callerAgent.name}' is not authorized to write to '${agentName}' workspace`,
-        void 0,
-        "permission_denied"
-      );
-    }
-    const agentOutputDir = this.getAgentOutputDir(sessionId, agentName);
-    const fullPath = await this.validatePath(agentOutputDir, filePath);
-    const fileSize = Buffer.byteLength(content, "utf-8");
-    if (fileSize > this.maxFileSize) {
-      throw new WorkspaceError(
-        `File too large: ${fileSize} bytes (max: ${this.maxFileSize} bytes)`,
-        fullPath,
-        "quota_exceeded"
-      );
-    }
-    try {
-      await fs.mkdir(path2.dirname(fullPath), { recursive: true });
-      await fs.writeFile(fullPath, content, "utf-8");
-      logger.debug("File written to session workspace", {
-        sessionId,
-        agentName,
-        filePath,
-        size: content.length
-      });
-    } catch (error) {
-      throw new WorkspaceError(
-        `Failed to write file: ${error.message}`,
-        fullPath,
-        "permission_denied"
-      );
-    }
+  async writePRD(fileName, content) {
+    await this.ensureDirectories();
+    this.validateFileSize(content);
+    const fullPath = this.validatePath(this.prdDir, fileName);
+    await fs.mkdir(path2.dirname(fullPath), { recursive: true });
+    await fs.writeFile(fullPath, content, "utf-8");
+    logger.info("PRD document created", { fileName, size: content.length });
   }
   /**
-   * Read file from another agent's workspace (within a session)
+   * Write temporary file
    *
-   * Requires permission check: requestingAgent must have targetAgent
-   * in their canReadWorkspaces whitelist.
+   * Temporary files should contain:
+   * - Test scripts
+   * - Analysis tools
+   * - Temporary reports
    *
-   * @param requestingAgent - Agent profile requesting access
-   * @param targetAgent - Target agent whose workspace to read
-   * @param sessionId - Session ID
-   * @param filePath - Relative file path within target agent's output
-   * @returns File content
-   * @throws {WorkspaceError} If permission denied or file not found
+   * These files can be cleaned up anytime.
+   *
+   * @param fileName - Relative file path within tmp/
+   * @param content - File content
+   * @throws {Error} If path is invalid, file too large, or write fails
    *
    * @example
    * ```typescript
-   * const spec = await workspaceManager.readFromAgentWorkspace(
-   *   frontendProfile,
-   *   'backend',
-   *   'session-123',
-   *   'api-spec.md'
-   * );
+   * await workspaceManager.writeTmp('test.sh', '#!/bin/bash\necho "test"');
    * ```
    */
-  async readFromAgentWorkspace(requestingAgent, targetAgent, sessionId, filePath) {
-    const canRead = requestingAgent.orchestration?.canReadWorkspaces;
-    if (!canRead || !canRead.includes(targetAgent)) {
-      throw new WorkspaceError(
-        `Agent '${requestingAgent.name}' is not authorized to read '${targetAgent}' workspace`,
-        void 0,
-        "permission_denied"
-      );
-    }
-    const agentOutputDir = this.getAgentOutputDir(sessionId, targetAgent);
-    const fullPath = await this.validatePath(agentOutputDir, filePath);
-    try {
-      const content = await fs.readFile(fullPath, "utf-8");
-      logger.debug("File read from agent workspace", {
-        requestingAgent: requestingAgent.name,
-        targetAgent,
-        sessionId,
-        filePath
-      });
-      return content;
-    } catch (error) {
-      const err = error;
-      if (err.code === "ENOENT") {
-        throw new WorkspaceError(
-          `File not found: ${filePath}`,
-          fullPath,
-          "not_found"
-        );
-      }
-      throw new WorkspaceError(
-        `Failed to read file: ${err.message}`,
-        fullPath,
-        "permission_denied"
-      );
-    }
+  async writeTmp(fileName, content) {
+    await this.ensureDirectories();
+    this.validateFileSize(content);
+    const fullPath = this.validatePath(this.tmpDir, fileName);
+    await fs.mkdir(path2.dirname(fullPath), { recursive: true });
+    await fs.writeFile(fullPath, content, "utf-8");
+    logger.debug("Temporary file created", { fileName, size: content.length });
   }
   /**
-   * Write to persistent shared workspace (cross-session)
-   *
-   * Requires permission check: agent must have canWriteToShared enabled.
+   * Read PRD document
    *
-   * @param agent - Agent profile
-   * @param filePath - Relative file path
-   * @param content - File content
-   * @throws {WorkspaceError} If permission denied or write fails
+   * @param fileName - Relative file path within PRD/
+   * @returns File content
+   * @throws {Error} If path is invalid or file not found
    *
    * @example
    * ```typescript
-   * await workspaceManager.writeToShared(
-   *   agentProfile,
-   *   'templates/api-template.ts',
-   *   'export const template = ...'
-   * );
+   * const content = await workspaceManager.readPRD('feature-auth.md');
    * ```
    */
-  async writeToShared(agent, filePath, content) {
-    if (!agent.orchestration?.canWriteToShared) {
-      throw new WorkspaceError(
-        `Agent '${agent.name}' is not authorized to write to shared workspace`,
-        void 0,
-        "permission_denied"
-      );
-    }
-    const fullPath = await this.validatePath(this.persistentRoot, filePath);
-    const fileSize = Buffer.byteLength(content, "utf-8");
-    if (fileSize > this.maxFileSize) {
-      throw new WorkspaceError(
-        `File too large: ${fileSize} bytes (max: ${this.maxFileSize} bytes)`,
-        fullPath,
-        "quota_exceeded"
-      );
-    }
-    try {
-      await fs.mkdir(path2.dirname(fullPath), { recursive: true });
-      await fs.writeFile(fullPath, content, "utf-8");
-      logger.info("File written to persistent shared workspace", {
-        agentName: agent.name,
-        filePath,
-        size: fileSize
-      });
-    } catch (error) {
-      throw new WorkspaceError(
-        `Failed to write to shared workspace: ${error.message}`,
-        fullPath,
-        "permission_denied"
-      );
-    }
+  async readPRD(fileName) {
+    const fullPath = this.validatePath(this.prdDir, fileName);
+    return await fs.readFile(fullPath, "utf-8");
   }
   /**
-   * List files in session workspace for a specific agent
+   * Read temporary file
+   *
+   * @param fileName - Relative file path within tmp/
+   * @returns File content
+   * @throws {Error} If path is invalid or file not found
+   */
+  async readTmp(fileName) {
+    const fullPath = this.validatePath(this.tmpDir, fileName);
+    return await fs.readFile(fullPath, "utf-8");
+  }
+  /**
+   * List all PRD documents
    *
-   * @param sessionId - Session ID
-   * @param agentName - Agent name
    * @returns Array of relative file paths
-   * @throws {WorkspaceError} If listing fails
    *
    * @example
    * ```typescript
-   * const files = await workspaceManager.listSessionFiles('session-123', 'backend');
-   * console.log(files); // ['api-spec.md', 'models/user.ts']
+   * const prdFiles = await workspaceManager.listPRD();
+   * // ['feature-auth.md', 'workflow-ci-cd.md']
    * ```
    */
-  async listSessionFiles(sessionId, agentName) {
-    const agentOutputDir = this.getAgentOutputDir(sessionId, agentName);
+  async listPRD() {
     try {
-      const files = [];
-      await this.collectFiles(agentOutputDir, agentOutputDir, files);
-      return files;
+      await this.ensureDirectories();
+      return await this.listFiles(this.prdDir);
     } catch (error) {
       const err = error;
       if (err.code === "ENOENT") {
         return [];
       }
-      throw new WorkspaceError(
-        `Failed to list files: ${err.message}`,
-        agentOutputDir,
-        "permission_denied"
-      );
+      throw error;
     }
   }
   /**
-   * Recursively collect files from a directory
+   * List all temporary files
    *
-   * @param dir - Directory to scan
-   * @param baseDir - Base directory for relative paths
-   * @param files - Array to collect file paths
+   * @returns Array of relative file paths
    */
-  async collectFiles(dir, baseDir, files) {
+  async listTmp() {
     try {
-      const entries = await fs.readdir(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = path2.join(dir, entry.name);
-        try {
-          if (entry.isDirectory()) {
-            await this.collectFiles(fullPath, baseDir, files);
-          } else {
-            const relativePath = path2.relative(baseDir, fullPath);
-            files.push(relativePath);
-          }
-        } catch (err) {
-          const error = err;
-          if (error.code === "ENOENT") {
-            logger.debug("File removed during traversal", { path: fullPath });
-            continue;
-          }
-          throw err;
-        }
-      }
-    } catch (err) {
-      const error = err;
-      if (error.code === "ENOENT") {
-        logger.debug("Directory removed during traversal", { path: dir });
-        return;
+      await this.ensureDirectories();
+      return await this.listFiles(this.tmpDir);
+    } catch (error) {
+      const err = error;
+      if (err.code === "ENOENT") {
+        return [];
       }
-      throw err;
+      throw error;
     }
   }
   /**
-   * Cleanup old session workspaces
-   *
-   * Removes session workspaces older than specified days.
-   * Should be called in sync with SessionManager cleanup.
+   * Clean up temporary files (recursively)
    *
-   * @param sessionIds - Active session IDs to keep
-   * @returns Number of sessions cleaned up
+   * @param olderThanDays - Optional: Only remove files older than N days
+   * @returns Number of files removed
    *
    * @example
    * ```typescript
-   * const activeSessions = await sessionManager.getActiveSessions();
-   * const activeIds = activeSessions.map(s => s.id);
-   * const removed = await workspaceManager.cleanupSessions(activeIds);
+   * // Remove all temporary files
+   * await workspaceManager.cleanupTmp();
+   *
+   * // Remove files older than 7 days
+   * await workspaceManager.cleanupTmp(7);
    * ```
    */
-  async cleanupSessions(sessionIds) {
+  async cleanupTmp(olderThanDays) {
     try {
-      const sessionDirs = await fs.readdir(this.sessionsRoot);
-      const activeSet = new Set(sessionIds);
-      let removed = 0;
-      for (const sessionId of sessionDirs) {
-        if (!activeSet.has(sessionId)) {
-          try {
-            const sessionDir = this.getSessionDir(sessionId);
-            await fs.rm(sessionDir, { recursive: true, force: true });
-            removed++;
-            logger.debug("Session workspace removed", { sessionId });
-          } catch (err) {
-            if (err instanceof WorkspaceError && err.reason === "invalid_session_id") {
-              logger.warn("Skipping invalid session directory", { sessionId });
-              continue;
-            }
-            throw err;
-          }
-        }
-      }
-      if (removed > 0) {
-        logger.info("Session workspaces cleaned up", { removed });
-      }
-      return removed;
+      await this.ensureDirectories();
+      return await this.cleanupDirectory(this.tmpDir, olderThanDays);
     } catch (error) {
-      logger.warn("Failed to cleanup session workspaces", {
-        error: error.message
+      const err = error;
+      if (err.code === "ENOENT") {
+        return 0;
+      }
+      logger.warn("Failed to cleanup temporary files", {
+        error: err.message
       });
       return 0;
     }
   }
   /**
-   * Cleanup specific session workspaces by session IDs
+   * Helper: Clean up directory recursively
    *
-   * Removes workspace directories for the specified session IDs.
-   * Useful when coordinating with SessionManager cleanup.
-   *
-   * @param sessionIds - Session IDs to remove
-   * @returns Number of workspaces removed
-   *
-   * @example
-   * ```typescript
-   * const result = await sessionManager.cleanupOldSessions(7);
-   * await workspaceManager.cleanupSessionWorkspaces(result.removedSessionIds);
-   * ```
+   * @param dir - Directory to clean
+   * @param olderThanDays - Optional: Only remove files older than N days
+   * @returns Number of files removed
    */
-  async cleanupSessionWorkspaces(sessionIds) {
+  async cleanupDirectory(dir, olderThanDays) {
     let removed = 0;
-    for (const sessionId of sessionIds) {
-      try {
-        const sessionDir = this.getSessionDir(sessionId);
-        await fs.rm(sessionDir, { recursive: true, force: true });
-        removed++;
-        logger.debug("Session workspace removed", { sessionId });
-      } catch (error) {
-        const err = error;
-        if (err.code !== "ENOENT") {
-          logger.warn("Failed to remove session workspace", {
-            sessionId,
-            error: err.message
+    try {
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const filePath = path2.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          removed += await this.cleanupDirectory(filePath, olderThanDays);
+          continue;
+        }
+        if (olderThanDays !== void 0) {
+          try {
+            const stats = await fs.stat(filePath);
+            const ageInDays = (Date.now() - stats.mtimeMs) / (1e3 * 60 * 60 * 24);
+            if (ageInDays < olderThanDays) {
+              continue;
+            }
+          } catch (statError) {
+            continue;
+          }
+        }
+        try {
+          await fs.unlink(filePath);
+          removed++;
+        } catch (rmError) {
+          logger.warn("Failed to remove temporary file", {
+            path: path2.relative(this.tmpDir, filePath),
+            error: rmError.message
           });
         }
       }
-    }
-    if (removed > 0) {
-      logger.info("Session workspaces cleaned up", {
-        removed,
-        total: sessionIds.length
-      });
+      if (removed > 0) {
+        logger.info("Temporary files cleaned up", { removed, olderThanDays });
+      }
+    } catch (error) {
+      const err = error;
+      if (err.code === "ENOENT") {
+        return removed;
+      }
+      throw error;
     }
     return removed;
   }
@@ -6634,70 +6514,95 @@ var WorkspaceManager = class _WorkspaceManager {
    * @example
    * ```typescript
    * const stats = await workspaceManager.getStats();
-   * console.log(`${stats.totalSessions} session workspaces`);
+   * console.log(`PRD files: ${stats.prdFiles}, Tmp files: ${stats.tmpFiles}`);
    * ```
    */
   async getStats() {
     try {
-      const sessionDirs = await fs.readdir(this.sessionsRoot);
-      const agentDirs = await fs.readdir(this.workspacesRoot);
-      const agentWorkspaces = agentDirs.filter(
-        (name) => name !== "shared"
-      ).length;
-      const stats = {
-        totalSessions: sessionDirs.length,
-        totalSizeBytes: 0,
-        agentWorkspaces
+      await this.ensureDirectories();
+      const prdFiles = await this.listFiles(this.prdDir);
+      const tmpFiles = await this.listFiles(this.tmpDir);
+      let prdSize = 0;
+      for (const file of prdFiles) {
+        try {
+          const stats = await fs.stat(path2.join(this.prdDir, file));
+          prdSize += stats.size;
+        } catch {
+        }
+      }
+      let tmpSize = 0;
+      for (const file of tmpFiles) {
+        try {
+          const stats = await fs.stat(path2.join(this.tmpDir, file));
+          tmpSize += stats.size;
+        } catch {
+        }
+      }
+      return {
+        prdFiles: prdFiles.length,
+        tmpFiles: tmpFiles.length,
+        totalSizeBytes: prdSize + tmpSize,
+        prdSizeBytes: prdSize,
+        tmpSizeBytes: tmpSize
       };
-      return stats;
     } catch (error) {
       logger.warn("Failed to get workspace stats", {
         error: error.message
       });
       return {
-        totalSessions: 0,
+        prdFiles: 0,
+        tmpFiles: 0,
         totalSizeBytes: 0,
-        agentWorkspaces: 0
+        prdSizeBytes: 0,
+        tmpSizeBytes: 0
       };
     }
   }
   /**
-   * Create agent's private workspace
+   * Helper: List files recursively in a directory
    *
-   * @param agentName - Agent name
-   *
-   * @example
-   * ```typescript
-   * await workspaceManager.createAgentWorkspace('backend');
-   * ```
+   * @param dir - Directory to scan
+   * @returns Array of relative file paths
    */
-  async createAgentWorkspace(agentName) {
-    const agentDir = this.getAgentWorkspaceDir(agentName);
-    const draftsDir = path2.join(agentDir, "drafts");
-    const tempDir = path2.join(agentDir, "temp");
+  async listFiles(dir) {
+    const files = [];
     try {
-      await fs.mkdir(agentDir, { recursive: true });
-      await fs.mkdir(draftsDir, { recursive: true });
-      await fs.mkdir(tempDir, { recursive: true });
-      logger.debug("Agent workspace created", {
-        agentName,
-        path: agentDir
-      });
-    } catch (error) {
-      throw new WorkspaceError(
-        `Failed to create agent workspace: ${error.message}`,
-        agentDir,
-        "creation_failed"
-      );
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path2.join(dir, entry.name);
+        const relativePath = path2.relative(dir, fullPath);
+        try {
+          if (entry.isDirectory()) {
+            const subFiles = await this.listFiles(fullPath);
+            files.push(...subFiles.map((f) => path2.join(relativePath, f)));
+          } else {
+            files.push(relativePath);
+          }
+        } catch (err) {
+          const error = err;
+          if (error.code === "ENOENT") {
+            logger.debug("File removed during traversal", { path: relativePath });
+            continue;
+          }
+          throw err;
+        }
+      }
+    } catch (err) {
+      const error = err;
+      if (error.code === "ENOENT") {
+        logger.debug("Directory removed during traversal", { path: dir });
+        return files;
+      }
+      throw err;
     }
+    return files;
   }
 };
 
 // src/agents/context-manager.ts
 init_esm_shims();
 init_logger();
-import { mkdir as mkdir4, chmod } from "fs/promises";
-import { join as join4, resolve as resolve5 } from "path";
+import { join as join4 } from "path";
 var PROVIDER_ALIASES = {
   "claude": "claude-code",
   "gemini": "gemini-cli",
@@ -6734,16 +6639,7 @@ var ContextManager = class {
     const workingDir = process.cwd();
     const agentDirName = agent.name.replace(/[^a-zA-Z0-9-]/g, "-").toLowerCase();
     const agentWorkspace = join4(projectDir, ".automatosx", "workspaces", agentDirName);
-    const resolvedWorkspace = resolve5(agentWorkspace);
-    const resolvedProject = resolve5(projectDir);
-    if (!resolvedWorkspace.startsWith(resolvedProject)) {
-      throw PathError.traversal(agentWorkspace);
-    }
-    await mkdir4(agentWorkspace, { recursive: true });
-    if (process.platform !== "win32") {
-      await chmod(agentWorkspace, 448);
-    }
-    logger.debug("Agent workspace created", { workspace: agentWorkspace });
+    logger.debug("Agent workspace path defined (not created)", { workspace: agentWorkspace });
     let session;
     if (options?.sessionId) {
       if (!this.config.sessionManager) {
@@ -6763,7 +6659,7 @@ var ContextManager = class {
     if (this.config.workspaceManager && this.config.profileLoader) {
       const allAgents = await this.config.profileLoader.listProfiles();
       const availableAgents = allAgents.filter((a) => a !== agent.name);
-      const sharedWorkspace = session ? join4(projectDir, ".automatosx", "workspaces", "shared", "sessions", session.id) : join4(projectDir, ".automatosx", "workspaces", "shared", "persistent");
+      const sharedWorkspace = join4(projectDir, "automatosx", "PRD");
       const maxDelegationDepth = agent.orchestration?.maxDelegationDepth ?? 2;
       orchestration = {
         isDelegationEnabled: true,
@@ -7016,19 +6912,20 @@ var ContextManager = class {
     return provider;
   }
   /**
-   * Cleanup context (delete workspace if needed)
+   * Cleanup context
+   *
+   * v5.2: No cleanup needed - agent workspaces no longer created
    */
   async cleanup(context) {
-    logger.debug("Context cleanup", {
-      agent: context.agent.name,
-      workspace: context.agentWorkspace
+    logger.debug("Context cleanup (no-op in v5.2)", {
+      agent: context.agent.name
     });
   }
 };
 
 // src/agents/profile-loader.ts
 init_esm_shims();
-import { readFile as readFile3, readdir as readdir2 } from "fs/promises";
+import { readFile as readFile3, readdir as readdir3 } from "fs/promises";
 import { join as join5, extname as extname2, basename, dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { load as load2 } from "js-yaml";
@@ -7150,7 +7047,7 @@ var ProfileLoader = class {
    */
   async listProfilesFromDir(dir) {
     try {
-      const files = await readdir2(dir);
+      const files = await readdir3(dir);
       return files.filter((file) => extname2(file) === ".yaml" || extname2(file) === ".yml").map((file) => basename(file, extname2(file)));
     } catch (error) {
       if (error.code === "ENOENT") {
@@ -7244,7 +7141,7 @@ var ProfileLoader = class {
   async listProfiles() {
     const profileSet = /* @__PURE__ */ new Set();
     try {
-      const files = await readdir2(this.profilesDir);
+      const files = await readdir3(this.profilesDir);
       const profiles = files.filter((file) => extname2(file) === ".yaml" || extname2(file) === ".yml").map((file) => basename(file, extname2(file)));
       profiles.forEach((p) => profileSet.add(p));
     } catch (error) {
@@ -7253,7 +7150,7 @@ var ProfileLoader = class {
       }
     }
     try {
-      const files = await readdir2(this.fallbackProfilesDir);
+      const files = await readdir3(this.fallbackProfilesDir);
       const profiles = files.filter((file) => extname2(file) === ".yaml" || extname2(file) === ".yml").map((file) => basename(file, extname2(file)));
       profiles.forEach((p) => profileSet.add(p));
     } catch (error) {
@@ -7493,19 +7390,6 @@ var ProfileLoader = class {
           throw new AgentValidationError("orchestration.maxDelegationDepth must be a non-negative integer (0 = no delegation allowed)");
         }
       }
-      if (orch.canReadWorkspaces !== void 0) {
-        if (!Array.isArray(orch.canReadWorkspaces)) {
-          throw new AgentValidationError("orchestration.canReadWorkspaces must be an array");
-        }
-        orch.canReadWorkspaces.forEach((workspace, i) => {
-          if (typeof workspace !== "string") {
-            throw new AgentValidationError(`orchestration.canReadWorkspaces[${i}] must be a string`);
-          }
-        });
-      }
-      if (orch.canWriteToShared !== void 0 && typeof orch.canWriteToShared !== "boolean") {
-        throw new AgentValidationError("orchestration.canWriteToShared must be a boolean");
-      }
     }
     return true;
   }
@@ -7628,7 +7512,7 @@ var ProfileLoader = class {
 init_esm_shims();
 init_logger();
 init_cache();
-import { readFile as readFile4, readdir as readdir3 } from "fs/promises";
+import { readFile as readFile4, readdir as readdir4 } from "fs/promises";
 import { join as join6, extname as extname3, basename as basename2, dirname as dirname7 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var __filename4 = fileURLToPath4(import.meta.url);
@@ -7729,7 +7613,7 @@ ${content}`);
    */
   async listAbilities() {
     try {
-      const files = await readdir3(this.abilitiesDir);
+      const files = await readdir4(this.abilitiesDir);
       const abilities = files.filter((file) => extname3(file) === ".md").map((file) => basename2(file, extname3(file)));
       return abilities.sort();
     } catch (error) {
@@ -7749,7 +7633,7 @@ ${content}`);
 
 // src/core/team-manager.ts
 init_esm_shims();
-import { readFile as readFile5, readdir as readdir4 } from "fs/promises";
+import { readFile as readFile5, readdir as readdir5 } from "fs/promises";
 import { join as join7, extname as extname4, basename as basename3 } from "path";
 import { load as load3 } from "js-yaml";
 
@@ -7817,7 +7701,7 @@ var TeamManager = class {
   async getAllTeams() {
     logger.debug("Loading all teams");
     try {
-      const files = await readdir4(this.teamsDir);
+      const files = await readdir5(this.teamsDir);
       const teamFiles = files.filter((f) => extname4(f) === ".yaml" || extname4(f) === ".yml");
       const teams = [];
       for (const file of teamFiles) {
@@ -7844,7 +7728,7 @@ var TeamManager = class {
    */
   async listTeams() {
     try {
-      const files = await readdir4(this.teamsDir);
+      const files = await readdir5(this.teamsDir);
       return files.filter((f) => extname4(f) === ".yaml" || extname4(f) === ".yml").map((f) => basename3(f, extname4(f)));
     } catch (error) {
       if (error.code === "ENOENT") {
@@ -7919,9 +7803,6 @@ var TeamManager = class {
     if (team.sharedAbilities && !Array.isArray(team.sharedAbilities)) {
       throw new TeamValidationError("sharedAbilities must be an array");
     }
-    if (team.orchestration?.canReadWorkspaces && !Array.isArray(team.orchestration.canReadWorkspaces)) {
-      throw new TeamValidationError("orchestration.canReadWorkspaces must be an array");
-    }
     logger.debug("Team validation passed", { name: team.name });
   }
 };
@@ -8646,7 +8527,7 @@ ${context.task}`;
    * Sleep for specified milliseconds
    */
   sleep(ms) {
-    return new Promise((resolve10) => setTimeout(resolve10, ms));
+    return new Promise((resolve9) => setTimeout(resolve9, ms));
   }
   /**
    * Delegate a task to another agent
@@ -8738,7 +8619,6 @@ ${context.task}`;
           session = await this.sessionManager.createSession(request.task, request.fromAgent);
           sessionId = session.id;
           await this.sessionManager.addAgent(sessionId, request.toAgent);
-          await this.workspaceManager.createSessionWorkspace(sessionId);
         }
       } else {
         logger.debug("Text-only delegation mode (no SessionManager/WorkspaceManager)", {
@@ -8761,13 +8641,7 @@ ${context.task}`;
         verbose: false,
         showProgress: true
       });
-      let files = [];
-      if (this.workspaceManager && sessionId) {
-        files = await this.workspaceManager.listSessionFiles(
-          sessionId,
-          request.toAgent
-        );
-      }
+      const files = [];
       const memoryIds = [];
       const endTime = /* @__PURE__ */ new Date();
       const duration = endTime.getTime() - startTime.getTime();
@@ -8828,7 +8702,7 @@ init_logger();
 
 // src/mcp/utils/validation.ts
 init_esm_shims();
-import { resolve as resolve6, isAbsolute as isAbsolute2, sep as sep2 } from "path";
+import { resolve as resolve5, isAbsolute as isAbsolute2, sep as sep2 } from "path";
 var ValidationError = class extends Error {
   constructor(message, code = -32602 /* InvalidParams */, details) {
     super(message);
@@ -8888,8 +8762,8 @@ function validatePathParameter(path3, paramName, projectRoot = process.cwd()) {
     );
   }
   try {
-    const resolvedPath = resolve6(projectRoot, path3);
-    const normalizedRoot = resolve6(projectRoot);
+    const resolvedPath = resolve5(projectRoot, path3);
+    const normalizedRoot = resolve5(projectRoot);
     if (!resolvedPath.startsWith(normalizedRoot + sep2) && resolvedPath !== normalizedRoot) {
       throw new ValidationError(
         `Invalid ${paramName}: path escapes project boundary`,
@@ -9423,12 +9297,12 @@ function createMemoryDeleteHandler(deps) {
 // src/mcp/tools/memory-export.ts
 init_esm_shims();
 init_logger();
-import { resolve as resolve7, basename as basename4 } from "path";
+import { resolve as resolve6, basename as basename4 } from "path";
 function resolveExportPath(pathResolver, userPath) {
   const exportsDir = pathResolver.resolveProjectPath(".automatosx/memory/exports");
   validatePathParameter(userPath, "export path", exportsDir);
   const filename = basename4(userPath);
-  const absolutePath = resolve7(exportsDir, filename);
+  const absolutePath = resolve6(exportsDir, filename);
   if (!pathResolver.validatePath(absolutePath, exportsDir)) {
     throw new Error("Export path must be within .automatosx/memory/exports directory");
   }
@@ -9461,12 +9335,12 @@ function createMemoryExportHandler(deps) {
 // src/mcp/tools/memory-import.ts
 init_esm_shims();
 init_logger();
-import { resolve as resolve8, basename as basename5 } from "path";
+import { resolve as resolve7, basename as basename5 } from "path";
 function resolveImportPath(pathResolver, userPath) {
   const exportsDir = pathResolver.resolveProjectPath(".automatosx/memory/exports");
   validatePathParameter(userPath, "import path", exportsDir);
   const filename = basename5(userPath);
-  const absolutePath = resolve8(exportsDir, filename);
+  const absolutePath = resolve7(exportsDir, filename);
   if (!pathResolver.validatePath(absolutePath, exportsDir)) {
     throw new Error("Import path must be within .automatosx/memory/exports directory");
   }
@@ -9663,7 +9537,6 @@ var McpServer = class {
     });
     await this.sessionManager.initialize();
     this.workspaceManager = new WorkspaceManager(projectDir);
-    await this.workspaceManager.initialize();
     this.contextManager = new ContextManager({
       profileLoader: this.profileLoader,
       abilitiesManager,
@@ -10372,7 +10245,7 @@ var mcpCommand = {
 
 // src/cli/commands/memory.ts
 init_esm_shims();
-import { resolve as resolve9 } from "path";
+import { resolve as resolve8 } from "path";
 import chalk8 from "chalk";
 import Table from "cli-table3";
 
@@ -10493,7 +10366,7 @@ var DEFAULT_DB_PATH = ".automatosx/memory/memory.db";
 async function getMemoryManager(dbPath) {
   const path3 = dbPath || DEFAULT_DB_PATH;
   return await MemoryManager.create({
-    dbPath: resolve9(path3),
+    dbPath: resolve8(path3),
     maxEntries: 1e5,
     autoCleanup: false,
     trackAccess: true
@@ -10810,8 +10683,8 @@ var deleteCommand = {
           input: process.stdin,
           output: process.stdout
         });
-        const answer = await new Promise((resolve10) => {
-          rl.question(chalk8.yellow("\nAre you sure you want to delete this entry? (y/N): "), resolve10);
+        const answer = await new Promise((resolve9) => {
+          rl.question(chalk8.yellow("\nAre you sure you want to delete this entry? (y/N): "), resolve9);
         });
         rl.close();
         if (answer.toLowerCase() !== "y" && answer.toLowerCase() !== "yes") {
@@ -11885,7 +11758,7 @@ init_logger();
 import chalk12 from "chalk";
 import { join as join9 } from "path";
 import { writeFileSync } from "fs";
-import { mkdir as mkdir5 } from "fs/promises";
+import { mkdir as mkdir4 } from "fs/promises";
 
 // src/utils/output-formatter.ts
 init_esm_shims();
@@ -12146,7 +12019,6 @@ var runCommand = {
       });
       await sessionManager.initialize();
       workspaceManager = new WorkspaceManager(projectDir);
-      await workspaceManager.initialize();
       if (argv2.session) {
         const session = await sessionManager.getSession(argv2.session);
         if (!session) {
@@ -12292,7 +12164,7 @@ var runCommand = {
           try {
             const savePath = argv2.save;
             const saveDir = join9(savePath, "..");
-            await mkdir5(saveDir, { recursive: true });
+            await mkdir4(saveDir, { recursive: true });
             let outputData;
             if (argv2.format === "json") {
               outputData = JSON.stringify({
@@ -12390,7 +12262,7 @@ Result: ${multiStageResult.finalOutput}`;
           try {
             const savePath = argv2.save;
             const saveDir = join9(savePath, "..");
-            await mkdir5(saveDir, { recursive: true });
+            await mkdir4(saveDir, { recursive: true });
             const outputData = formatForSave(result, argv2.format || "text", {
               agent: resolvedAgentName,
               task: argv2.task
@@ -12437,7 +12309,7 @@ Response: ${result.response.content}`;
       if (router) {
         router.destroy();
       }
-      await new Promise((resolve10) => setImmediate(resolve10));
+      await new Promise((resolve9) => setImmediate(resolve9));
       console.log(chalk12.green.bold("\u2705 Complete\n"));
       process.exit(0);
     } catch (error) {
@@ -12464,7 +12336,7 @@ Response: ${result.response.content}`;
             logger.debug("Context cleanup error", { error: errMsg });
           });
         }
-        await new Promise((resolve10) => setImmediate(resolve10));
+        await new Promise((resolve9) => setImmediate(resolve9));
       } catch (cleanupError) {
         const errMsg = cleanupError instanceof Error ? cleanupError.message : String(cleanupError);
         logger.debug("Cleanup error ignored", { error: errMsg });
@@ -12717,8 +12589,8 @@ init_gemini_provider();
 init_openai_provider();
 init_logger();
 import chalk14 from "chalk";
-import { existsSync as existsSync4 } from "fs";
-import { readdir as readdir5, stat } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
+import { readdir as readdir6, stat as stat2 } from "fs/promises";
 import { join as join11 } from "path";
 import { createRequire as createRequire3 } from "module";
 import os from "os";
@@ -12833,17 +12705,17 @@ var statusCommand2 = {
         project: projectInfo,
         configuration: {
           configFile: join11(detectedProjectDir, "automatosx.config.json"),
-          configExists: existsSync4(join11(detectedProjectDir, "automatosx.config.json")),
+          configExists: existsSync5(join11(detectedProjectDir, "automatosx.config.json")),
           logLevel: config.logging.level,
           memoryMaxEntries: config.memory.maxEntries,
           memoryRetentionDays: config.memory.cleanupDays
         },
         directories: {
-          automatosx: { path: automatosxDir, exists: existsSync4(automatosxDir) },
-          agents: { path: agentsDir, exists: existsSync4(agentsDir), count: agentCount },
-          abilities: { path: abilitiesDir, exists: existsSync4(abilitiesDir), count: abilityCount },
-          memory: { path: memoryDir, exists: existsSync4(memoryDir), ...memoryStats },
-          workspaces: { path: workspacesDir, exists: existsSync4(workspacesDir), ...workspaceStats }
+          automatosx: { path: automatosxDir, exists: existsSync5(automatosxDir) },
+          agents: { path: agentsDir, exists: existsSync5(agentsDir), count: agentCount },
+          abilities: { path: abilitiesDir, exists: existsSync5(abilitiesDir), count: abilityCount },
+          memory: { path: memoryDir, exists: existsSync5(memoryDir), ...memoryStats },
+          workspaces: { path: workspacesDir, exists: existsSync5(workspacesDir), ...workspaceStats }
         },
         providers: providerHealth,
         router: {
@@ -12966,11 +12838,11 @@ var statusCommand2 = {
   }
 };
 async function getWorkspaceStatistics(workspacesDir) {
-  if (!existsSync4(workspacesDir)) {
+  if (!existsSync5(workspacesDir)) {
     return { workspaces: 0, totalSizeBytes: 0, files: 0 };
   }
   try {
-    const entries = await readdir5(workspacesDir, { withFileTypes: true });
+    const entries = await readdir6(workspacesDir, { withFileTypes: true });
     const workspaces = entries.filter((e) => e.isDirectory());
     let totalSizeBytes = 0;
     let files = 0;
@@ -12991,7 +12863,7 @@ async function getWorkspaceStatistics(workspacesDir) {
   }
 }
 async function getMemoryStatistics(memoryDir) {
-  if (!existsSync4(memoryDir)) {
+  if (!existsSync5(memoryDir)) {
     return { files: 0, sizeBytes: 0 };
   }
   try {
@@ -13009,7 +12881,7 @@ async function getDirectoryStats(dirPath) {
   let totalSize = 0;
   let totalFiles = 0;
   try {
-    const entries = await readdir5(dirPath, { withFileTypes: true });
+    const entries = await readdir6(dirPath, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = join11(dirPath, entry.name);
       if (entry.isDirectory()) {
@@ -13017,7 +12889,7 @@ async function getDirectoryStats(dirPath) {
         totalSize += subStats.size;
         totalFiles += subStats.files;
       } else if (entry.isFile()) {
-        const stats = await stat(fullPath);
+        const stats = await stat2(fullPath);
         totalSize += stats.size;
         totalFiles++;
       }
@@ -13027,11 +12899,11 @@ async function getDirectoryStats(dirPath) {
   return { size: totalSize, files: totalFiles };
 }
 async function countFiles(dirPath, extensions) {
-  if (!existsSync4(dirPath)) {
+  if (!existsSync5(dirPath)) {
     return 0;
   }
   try {
-    const files = await readdir5(dirPath);
+    const files = await readdir6(dirPath);
     return files.filter((f) => extensions.some((ext) => f.endsWith(ext))).length;
   } catch (error) {
     logger.warn("Failed to count files", { dirPath, error: error.message });
@@ -13040,7 +12912,7 @@ async function countFiles(dirPath, extensions) {
 }
 async function getProjectInfo(projectDir) {
   const packageJsonPath = join11(projectDir, "package.json");
-  if (!existsSync4(packageJsonPath)) {
+  if (!existsSync5(packageJsonPath)) {
     return {};
   }
   try {
@@ -13126,8 +12998,8 @@ var updateCommand = {
             input: process.stdin,
             output: process.stdout
           });
-          const answer = await new Promise((resolve10) => {
-            rl.question(chalk15.yellow("Would you like to update now? (y/N) "), resolve10);
+          const answer = await new Promise((resolve9) => {
+            rl.question(chalk15.yellow("Would you like to update now? (y/N) "), resolve9);
           });
           rl.close();
           if (answer.toLowerCase() !== "y" && answer.toLowerCase() !== "yes") {
@@ -13230,11 +13102,13 @@ init_esm_shims();
 import chalk16 from "chalk";
 var listCommand4 = {
   command: "list",
-  describe: "List workspace files",
+  describe: "List workspace files (PRD or tmp)",
   builder: (yargs2) => {
-    return yargs2.option("session", {
-      describe: "Session ID to list files for",
-      type: "string"
+    return yargs2.option("type", {
+      describe: "Workspace type to list",
+      type: "string",
+      choices: ["prd", "tmp"],
+      default: "prd"
     }).option("json", {
       describe: "Output as JSON",
       type: "boolean",
@@ -13246,42 +13120,23 @@ var listCommand4 = {
       const { detectProjectRoot: detectProjectRoot2 } = await Promise.resolve().then(() => (init_path_resolver(), path_resolver_exports));
       const projectDir = await detectProjectRoot2(process.cwd());
       const workspaceManager = new WorkspaceManager(projectDir);
-      if (argv2.session) {
-        const sessionManager = await createSessionManager();
-        const session = await sessionManager.getSession(argv2.session);
-        if (!session) {
-          console.log(chalk16.red.bold(`
-\u2717 Session not found: ${argv2.session}
-`));
-          process.exit(1);
-        }
-        console.log(chalk16.blue.bold(`
-\u{1F4C1} Session Workspace Files
-`));
-        console.log(chalk16.gray(`Session: ${argv2.session}`));
-        console.log(chalk16.gray(`Task: ${session.task}
+      const files = argv2.type === "tmp" ? await workspaceManager.listTmp() : await workspaceManager.listPRD();
+      if (argv2.json) {
+        console.log(JSON.stringify({ type: argv2.type, files }, null, 2));
+        process.exit(0);
+      }
+      console.log(chalk16.blue.bold(`
+\u{1F4C1} ${argv2.type === "tmp" ? "Temporary" : "PRD"} Files
 `));
-        for (const agentName of session.agents) {
-          const files = await workspaceManager.listSessionFiles(argv2.session, agentName);
-          if (files.length > 0) {
-            console.log(chalk16.cyan(`
-${agentName}:`));
-            files.forEach((file) => {
-              console.log(chalk16.gray(`  - ${file}`));
-            });
-          }
-        }
-        console.log();
+      if (files.length === 0) {
+        console.log(chalk16.gray("  (No files)\n"));
       } else {
-        const stats = await workspaceManager.getStats();
-        if (argv2.json) {
-          console.log(JSON.stringify(stats, null, 2));
-          process.exit(0);
-        }
-        console.log(chalk16.blue.bold("\n\u{1F4CA} Workspace Statistics\n"));
-        console.log(chalk16.gray(`Session workspaces: ${chalk16.white(stats.totalSessions)}`));
-        console.log(chalk16.gray(`Agent workspaces: ${chalk16.white(stats.agentWorkspaces)}`));
-        console.log();
+        files.forEach((file) => {
+          console.log(chalk16.gray(`  - ${file}`));
+        });
+        console.log(chalk16.gray(`
+Total: ${files.length} file(s)
+`));
       }
       process.exit(0);
     } catch (error) {
@@ -13312,9 +13167,9 @@ var statsCommand2 = {
         process.exit(0);
       }
       console.log(chalk16.blue.bold("\n\u{1F4CA} Workspace Statistics\n"));
-      console.log(chalk16.gray(`Session workspaces: ${chalk16.white(stats.totalSessions)}`));
-      console.log(chalk16.gray(`Agent workspaces: ${chalk16.white(stats.agentWorkspaces)}`));
-      console.log(chalk16.gray(`Total size: ${chalk16.white((stats.totalSizeBytes / 1024 / 1024).toFixed(2))} MB`));
+      console.log(chalk16.gray(`PRD files:        ${chalk16.white(stats.prdFiles)}`));
+      console.log(chalk16.gray(`Temporary files:  ${chalk16.white(stats.tmpFiles)}`));
+      console.log(chalk16.gray(`Total size:       ${chalk16.white((stats.totalSizeBytes / 1024 / 1024).toFixed(2))} MB`));
       console.log();
       process.exit(0);
     } catch (error) {
@@ -13326,10 +13181,10 @@ var statsCommand2 = {
 };
 var cleanupCommand = {
   command: "cleanup",
-  describe: "Clean up old session workspaces",
+  describe: "Clean up temporary files",
   builder: (yargs2) => {
     return yargs2.option("older-than", {
-      describe: "Clean up sessions older than N days",
+      describe: "Clean up files older than N days",
       type: "number",
       default: 7
     }).option("confirm", {
@@ -13343,22 +13198,17 @@ var cleanupCommand = {
       const { detectProjectRoot: detectProjectRoot2 } = await Promise.resolve().then(() => (init_path_resolver(), path_resolver_exports));
       const projectDir = await detectProjectRoot2(process.cwd());
       const workspaceManager = new WorkspaceManager(projectDir);
-      const sessionManager = await createSessionManager();
-      const activeSessions = await sessionManager.getActiveSessions();
-      const activeIds = activeSessions.map((s) => s.id);
       if (!argv2.confirm) {
         console.log(chalk16.yellow(`
-\u26A0 This will remove workspace files for inactive sessions`));
-        console.log(chalk16.gray(`Active sessions (${activeIds.length}) will be kept
-`));
+\u26A0 This will remove temporary files older than ${argv2.olderThan} days`));
         console.log(chalk16.gray("Run with --confirm to proceed\n"));
         process.exit(0);
       }
-      const removed = await workspaceManager.cleanupSessions(activeIds);
+      const removed = await workspaceManager.cleanupTmp(argv2.olderThan);
       console.log(chalk16.green.bold(`
 \u2713 Cleanup complete
 `));
-      console.log(chalk16.gray(`Removed ${removed} session workspace(s)
+      console.log(chalk16.gray(`Removed ${removed} temporary file(s)
 `));
       process.exit(0);
     } catch (error) {
@@ -13383,9 +13233,9 @@ init_esm_shims();
 
 // src/cli/commands/agent/templates.ts
 init_esm_shims();
-import { readdir as readdir6 } from "fs/promises";
+import { readdir as readdir7 } from "fs/promises";
 import { join as join12 } from "path";
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 import chalk17 from "chalk";
 var TEMPLATE_DESCRIPTIONS = {
   "basic-agent": {
@@ -13421,9 +13271,9 @@ var templatesCommand = {
     try {
       console.log(chalk17.blue.bold("\n\u{1F4CB} Available Agent Templates\n"));
       const projectTemplatesDir = join12(process.cwd(), ".automatosx", "templates");
-      const hasProjectTemplates = existsSync5(projectTemplatesDir);
+      const hasProjectTemplates = existsSync6(projectTemplatesDir);
       const defaultTemplatesDir = join12(__dirname, "../../../../examples/templates");
-      const hasDefaultTemplates = existsSync5(defaultTemplatesDir);
+      const hasDefaultTemplates = existsSync6(defaultTemplatesDir);
       if (!hasProjectTemplates && !hasDefaultTemplates) {
         console.log(chalk17.yellow("\u26A0 No templates found."));
         console.log(chalk17.gray('\nRun "ax init" to set up default templates.\n'));
@@ -13431,7 +13281,7 @@ var templatesCommand = {
       }
       const templatesDir = hasProjectTemplates ? projectTemplatesDir : defaultTemplatesDir;
       const templateSource = hasProjectTemplates ? "Project" : "Default";
-      const files = await readdir6(templatesDir);
+      const files = await readdir7(templatesDir);
       const templates = files.filter((f) => f.endsWith(".yaml")).map((f) => f.replace(".yaml", ""));
       if (templates.length === 0) {
         console.log(chalk17.yellow("\u26A0 No templates found.\n"));
@@ -13480,8 +13330,8 @@ var templatesCommand = {
 
 // src/cli/commands/agent/create.ts
 init_esm_shims();
-import { readFile as readFile6, writeFile as writeFile5, mkdir as mkdir6 } from "fs/promises";
-import { existsSync as existsSync7 } from "fs";
+import { readFile as readFile6, writeFile as writeFile5, mkdir as mkdir5 } from "fs/promises";
+import { existsSync as existsSync8 } from "fs";
 import { join as join14 } from "path";
 import { load as loadYaml2 } from "js-yaml";
 import chalk18 from "chalk";
@@ -13621,8 +13471,8 @@ var templateEngine = new TemplateEngine();
 
 // src/cli/commands/agent/helpers.ts
 init_esm_shims();
-import { readdir as readdir7 } from "fs/promises";
-import { existsSync as existsSync6 } from "fs";
+import { readdir as readdir8 } from "fs/promises";
+import { existsSync as existsSync7 } from "fs";
 import { join as join13, extname as extname5, dirname as dirname8 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 init_logger();
@@ -13631,9 +13481,9 @@ var __dirname5 = dirname8(__filename5);
 async function listAvailableTemplates() {
   const templates = [];
   const projectTemplatesDir = join13(process.cwd(), ".automatosx", "templates");
-  if (existsSync6(projectTemplatesDir)) {
+  if (existsSync7(projectTemplatesDir)) {
     try {
-      const files = await readdir7(projectTemplatesDir);
+      const files = await readdir8(projectTemplatesDir);
       for (const file of files) {
         if (extname5(file) === ".yaml" || extname5(file) === ".yml") {
           const name = file.replace(/\.(yaml|yml)$/, "");
@@ -13649,9 +13499,9 @@ async function listAvailableTemplates() {
     }
   }
   const builtinTemplatesDir = join13(__dirname5, "../../../../examples/templates");
-  if (existsSync6(builtinTemplatesDir)) {
+  if (existsSync7(builtinTemplatesDir)) {
     try {
-      const files = await readdir7(builtinTemplatesDir);
+      const files = await readdir8(builtinTemplatesDir);
       for (const file of files) {
         if (extname5(file) === ".yaml" || extname5(file) === ".yml") {
           const name = file.replace(/\.(yaml|yml)$/, "");
@@ -13844,14 +13694,14 @@ var createCommand2 = {
         console.log(chalk18.gray("  \u2022 Not contain consecutive hyphens\n"));
         process.exit(1);
       }
-      if (existsSync7(agentFile)) {
+      if (existsSync8(agentFile)) {
         console.log(chalk18.red.bold(`
 \u2717 Agent already exists: ${argv2.agent}
 `));
         console.log(chalk18.gray("Use a different name or remove the existing agent first.\n"));
         process.exit(1);
       }
-      await mkdir6(agentsDir, { recursive: true });
+      await mkdir5(agentsDir, { recursive: true });
       let templateName = argv2.template;
       if (!templateName) {
         if (argv2.interactive) {
@@ -13939,11 +13789,11 @@ var createCommand2 = {
 };
 async function findTemplate(name) {
   const projectTemplate = join14(process.cwd(), ".automatosx", "templates", `${name}.yaml`);
-  if (existsSync7(projectTemplate)) {
+  if (existsSync8(projectTemplate)) {
     return projectTemplate;
   }
   const defaultTemplate = join14(__dirname, "../../../../examples/templates", `${name}.yaml`);
-  if (existsSync7(defaultTemplate)) {
+  if (existsSync8(defaultTemplate)) {
     return defaultTemplate;
   }
   throw new Error(`Template not found: ${name}
@@ -13997,10 +13847,10 @@ function ask(question, defaultValue) {
     output: process.stdout
   });
   const prompt = defaultValue ? `${question} [${chalk18.gray(defaultValue)}]: ` : `${question}: `;
-  return new Promise((resolve10) => {
+  return new Promise((resolve9) => {
     rl.question(prompt, (answer) => {
       rl.close();
-      resolve10(answer.trim() || defaultValue || "");
+      resolve9(answer.trim() || defaultValue || "");
     });
   });
 }
@@ -14158,12 +14008,6 @@ var showCommand = {
         if (orch.maxDelegationDepth !== void 0) {
           console.log(chalk20.white(`  Max Delegation Depth: ${orch.maxDelegationDepth}`));
         }
-        if (orch.canReadWorkspaces && orch.canReadWorkspaces.length > 0) {
-          console.log(chalk20.white(`  Can Read Workspaces:  ${orch.canReadWorkspaces.join(", ")}`));
-        }
-        if (orch.canWriteToShared !== void 0) {
-          console.log(chalk20.white(`  Can Write to Shared:  ${orch.canWriteToShared ? "Yes" : "No"}`));
-        }
         console.log();
       }
       const filePath = join16(agentsDir, `${argv2.agent}.yaml`);
@@ -14204,7 +14048,7 @@ var showCommand = {
 // src/cli/commands/agent/remove.ts
 init_esm_shims();
 import { unlink as unlink2 } from "fs/promises";
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 import { join as join17 } from "path";
 import chalk21 from "chalk";
 import * as readline2 from "readline";
@@ -14257,7 +14101,7 @@ var removeCommand = {
         process.exit(1);
       }
       const agentFile = join17(agentsDir, `${resolvedName}.yaml`);
-      if (!existsSync8(agentFile)) {
+      if (!existsSync9(agentFile)) {
         console.log(chalk21.red.bold(`
 \u2717 Agent file not found: ${resolvedName}
 `));
@@ -14293,11 +14137,11 @@ function askConfirmation(question) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve10) => {
+  return new Promise((resolve9) => {
     rl.question(chalk21.yellow(`
 ${question} (y/N): `), (answer) => {
       rl.close();
-      resolve10(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+      resolve9(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
     });
   });
 }