trackops 1.0.1 → 1.1.0

package/lib/opera.js

@@ -1,202 +1,351 @@
-#!/usr/bin/env node
-
-const fs = require("fs");
-const path = require("path");
-
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+
 const config = require("./config");
+const env = require("./env");
 const { t, setLocale } = require("./i18n");
+const { promptForLocale, resolveLocale } = require("./locale");
+const { resolveLocalizedFile, resolveLocalizedDir, resolveSkillFile } = require("./resources");
+const bootstrap = require("./opera-bootstrap");
 
 const TEMPLATES_DIR = path.join(__dirname, "..", "templates", "opera");
 const SKILLS_TEMPLATES_DIR = path.join(__dirname, "..", "templates", "skills");
 const OPERA_VERSION = require("../package.json").version;
-
-function nowIso() {
-  return new Date().toISOString();
-}
-
-function copyTemplate(templatePath, targetPath, replacements) {
-  fs.mkdirSync(path.dirname(targetPath), { recursive: true });
-  let content = fs.readFileSync(templatePath, "utf8");
-  if (replacements) {
-    for (const [key, value] of Object.entries(replacements)) {
-      content = content.replace(new RegExp(`\\{\\{${key}\\}\\}`, "g"), value);
-    }
-  }
-  fs.writeFileSync(targetPath, content, "utf8");
-}
-
-function copyDirRecursive(src, dest) {
-  fs.mkdirSync(dest, { recursive: true });
-  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
-    const srcPath = path.join(src, entry.name);
-    const destPath = path.join(dest, entry.name);
-    if (entry.isDirectory()) {
-      copyDirRecursive(srcPath, destPath);
-    } else {
-      fs.copyFileSync(srcPath, destPath);
-    }
-  }
-}
-
-function install(root, options) {
-  const controlFile = config.controlFilePath(root);
-  if (!fs.existsSync(controlFile)) {
-    throw new Error("project_control.json not found. Run 'trackops init' first.");
-  }
-
-  const control = config.loadControl(root);
-  setLocale(config.getLocale(control));
-
-  if (config.isOperaInstalled(control)) {
-    console.log(t("opera.alreadyInstalled", { version: config.getOperaVersion(control) }));
-    return;
-  }
-
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function readText(filePath) {
+  return fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf8") : "";
+}
+
+function renderTemplate(templatePath, replacements) {
+  let content = fs.readFileSync(templatePath, "utf8");
+  for (const [key, value] of Object.entries(replacements || {})) {
+    content = content.replace(new RegExp(`\\{\\{${key}\\}\\}`, "g"), value);
+  }
+  return content;
+}
+
+function matchesKnownTemplate(filePath, templatePath, replacements) {
+  if (!fs.existsSync(filePath) || !fs.existsSync(templatePath)) return false;
+  return readText(filePath).replace(/\r\n/g, "\n") === renderTemplate(templatePath, replacements).replace(/\r\n/g, "\n");
+}
+
+function copyTemplate(templatePath, targetPath, replacements, options = {}) {
+  fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+  const shouldWrite =
+    !fs.existsSync(targetPath) ||
+    options.overwrite === true ||
+    (options.overwriteIfTemplate && matchesKnownTemplate(targetPath, templatePath, replacements));
+
+  if (!shouldWrite) return false;
+  fs.writeFileSync(targetPath, renderTemplate(templatePath, replacements), "utf8");
+  return true;
+}
+
+function copyDirRecursive(src, dest) {
+  if (!src || !fs.existsSync(src)) return;
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function resolveOperaLocale(control, options = {}) {
+  return resolveLocale(options.locale, config.getLocale(control));
+}
+
+function installStructure(root, control, locale, options = {}) {
+  const context = config.ensureContext(root);
   const projectName = control.meta.projectName || "Project";
-
-  // Create .agent/hub/ with agent.md and router.md
-  const agentHubDir = path.join(root, ".agent", "hub");
+  const replacements = {
+    PROJECT_NAME: projectName,
+    DESIRED_OUTCOME: t("bootstrap.pendingValue"),
+    SERVICES_TABLE: "| — | — | — |",
+    SOURCE_OF_TRUTH: t("bootstrap.pendingValue"),
+    PAYLOAD: t("bootstrap.pendingValue"),
+    BEHAVIOR_RULES: `- ${t("bootstrap.noneDefined")}`,
+    DATA_SCHEMA: JSON.stringify({
+      input: { source: "", schema: {} },
+      output: { destination: "", schema: {} },
+    }, null, 2),
+    ARCHITECTURAL_INVARIANTS: `- ${t("bootstrap.noneDefined")}`,
+    PIPELINE_ITEMS: `- ${t("bootstrap.noneDefined")}`,
+    TEMPLATE_ITEMS: `- ${t("bootstrap.noneDefined")}`,
+  };
+  const overwriteOptions = {
+    overwriteIfTemplate: options.rewriteLocalizedTemplates === true,
+  };
+
+  const agentHubDir = context.paths.agentHubDir;
   fs.mkdirSync(agentHubDir, { recursive: true });
-
-  const agentTemplatePath = path.join(TEMPLATES_DIR, "agent.md");
-  const routerTemplatePath = path.join(TEMPLATES_DIR, "router.md");
-
-  if (fs.existsSync(agentTemplatePath) && !fs.existsSync(path.join(agentHubDir, "agent.md"))) {
-    copyTemplate(agentTemplatePath, path.join(agentHubDir, "agent.md"), { PROJECT_NAME: projectName });
-  }
-  if (fs.existsSync(routerTemplatePath) && !fs.existsSync(path.join(agentHubDir, "router.md"))) {
-    copyTemplate(routerTemplatePath, path.join(agentHubDir, "router.md"), { PROJECT_NAME: projectName });
-  }
-
-  // Create .agents/skills/_registry.md
-  const skillsRegistryDir = path.join(root, ".agents", "skills");
+
+  copyTemplate(
+    resolveLocalizedFile(TEMPLATES_DIR, locale, "agent.md"),
+    path.join(agentHubDir, "agent.md"),
+    replacements,
+    overwriteOptions,
+  );
+  copyTemplate(
+    resolveLocalizedFile(TEMPLATES_DIR, locale, "router.md"),
+    path.join(agentHubDir, "router.md"),
+    replacements,
+    overwriteOptions,
+  );
+
+  const skillsRegistryDir = context.paths.skillsDir;
   fs.mkdirSync(skillsRegistryDir, { recursive: true });
-  const registryPath = path.join(skillsRegistryDir, "_registry.md");
-  const registryTemplatePath = path.join(TEMPLATES_DIR, "registry.md");
-  if (fs.existsSync(registryTemplatePath) && !fs.existsSync(registryPath)) {
-    copyTemplate(registryTemplatePath, registryPath, { PROJECT_NAME: projectName });
+  copyTemplate(
+    resolveLocalizedFile(TEMPLATES_DIR, locale, "registry.md"),
+    path.join(skillsRegistryDir, "_registry.md"),
+    replacements,
+    overwriteOptions,
+  );
+
+  const genesisTemplatePath = resolveLocalizedFile(TEMPLATES_DIR, locale, "genesis.md");
+  const genesisPath = context.paths.genesisFile;
+  if (!fs.existsSync(genesisPath) || bootstrap.isVirginGenesis(readText(genesisPath))) {
+    copyTemplate(genesisTemplatePath, genesisPath, replacements, { overwrite: true });
+  }
+
+  const refsTemplateDir = resolveLocalizedDir(TEMPLATES_DIR, locale, "references");
+  const refsTargetDir = path.join(context.paths.skillsDir, "project-starter-skill", "references");
+  copyDirRecursive(refsTemplateDir, refsTargetDir);
+
+  const starterSkillTarget = path.join(context.paths.skillsDir, "project-starter-skill", "SKILL.md");
+  const starterSkillTemplate = resolveSkillFile(SKILLS_TEMPLATES_DIR, "project-starter-skill", locale);
+  if (starterSkillTemplate) {
+    fs.mkdirSync(path.dirname(starterSkillTarget), { recursive: true });
+    if (!fs.existsSync(starterSkillTarget) || options.rewriteLocalizedTemplates === true) {
+      fs.copyFileSync(starterSkillTemplate, starterSkillTarget);
+    }
+  }
+}
+
+async function install(root, options = {}) {
+  const context = config.ensureContext(root);
+  const controlFile = config.controlFilePath(context);
+  if (!fs.existsSync(controlFile)) {
+    throw new Error("project_control.json not found. Run 'trackops init' first.");
   }
 
-  // Create genesis.md if not exists
-  const genesisTemplatePath = path.join(TEMPLATES_DIR, "genesis.md");
-  const genesisPath = path.join(root, "genesis.md");
-  if (fs.existsSync(genesisTemplatePath) && !fs.existsSync(genesisPath)) {
-    copyTemplate(genesisTemplatePath, genesisPath, { PROJECT_NAME: projectName });
-  }
+  const control = config.loadControl(context);
+  let locale = resolveOperaLocale(control, options);
+  if (!options.locale && !control.meta?.locale) {
+    locale = await promptForLocale(locale);
+  }
+  control.meta.locale = locale;
+  setLocale(locale);
 
-  // Copy OPERA references
-  const refsTemplateDir = path.join(TEMPLATES_DIR, "references");
-  if (fs.existsSync(refsTemplateDir)) {
-    const starterSkillDir = path.join(root, ".agents", "skills", "project-starter-skill", "references");
-    copyDirRecursive(refsTemplateDir, starterSkillDir);
-  }
+  const alreadyInstalled = config.isOperaInstalled(control);
+  installStructure(context, control, locale);
 
-  // Install project-starter-skill SKILL.md
-  const starterSkillTemplate = path.join(SKILLS_TEMPLATES_DIR, "project-starter-skill", "SKILL.md");
-  const starterSkillTarget = path.join(root, ".agents", "skills", "project-starter-skill", "SKILL.md");
-  if (fs.existsSync(starterSkillTemplate) && !fs.existsSync(starterSkillTarget)) {
-    fs.mkdirSync(path.dirname(starterSkillTarget), { recursive: true });
-    fs.copyFileSync(starterSkillTemplate, starterSkillTarget);
-  }
-
-  // Mark as installed in control
   control.meta.opera = {
-    installed: true,
-    version: OPERA_VERSION,
-    installedAt: nowIso(),
-    skills: [],
-  };
-  config.saveControl(root, control);
-
-  console.log(t("opera.installed", { version: OPERA_VERSION }));
-
-  // Auto-install base skills (commiter, changelog-updater)
+    ...(control.meta.opera || {}),
+    installed: true,
+    version: OPERA_VERSION,
+    installedAt: control.meta?.opera?.installedAt || nowIso(),
+    skills: control.meta?.opera?.skills || [],
+  };
+  config.saveControl(context, control);
+  env.syncEnvironment(context, control);
+
+  if (!alreadyInstalled) {
+    console.log(t("opera.installed", { version: OPERA_VERSION }));
+  } else {
+    console.log(t("opera.alreadyInstalled", { version: config.getOperaVersion(control) || OPERA_VERSION }));
+  }
+
   const skills = require("./skills");
   for (const skillName of ["commiter", "changelog-updater"]) {
-    try { skills.installSkill(root, skillName); }
-    catch (_e) { /* already installed or not in catalog — skip silently */ }
+    try {
+      skills.installSkill(context, skillName, { locale });
+    } catch (_error) {
+      // ignore
+    }
   }
-}
-
-function status(root) {
-  const control = config.loadControl(root);
-  setLocale(config.getLocale(control));
 
-  if (!config.isOperaInstalled(control)) {
-    console.log(t("opera.notInstalled"));
-    return;
+  if (options.bootstrap !== false) {
+    await runBootstrap(context, { locale, answers: options.answers, interactive: options.interactive });
   }
+}
 
-  const opera = control.meta.opera;
-  console.log(`OPERA v${opera.version}`);
-  console.log(`  Installed: ${opera.installedAt}`);
-  console.log(`  Skills: ${(opera.skills || []).join(", ") || "none"}`);
+async function runBootstrap(root, options = {}) {
+  const context = config.ensureContext(root);
+  const control = config.loadControl(context);
+  const locale = resolveOperaLocale(control, options);
+  control.meta.locale = locale;
+  setLocale(locale);
+
+  const legacyBootstrap = bootstrap.detectLegacyBootstrap(context, control);
+  if (legacyBootstrap && !control.meta.opera?.bootstrap) {
+    control.meta.opera = control.meta.opera || {};
+    control.meta.opera.bootstrap = legacyBootstrap;
+    config.saveControl(context, control);
+  }
 
-  // Check structural integrity
+  const profile = await bootstrap.collectBootstrapProfile(context, control, options);
+  const updatedControl = bootstrap.applyBootstrap(context, control, profile);
+  env.syncEnvironment(context, updatedControl, { requiredKeys: env.inferRequiredKeys(updatedControl, context) });
+  const ops = require("./control");
+  ops.syncDocs(context, updatedControl);
+  ops.refreshRepoRuntime(context, { quiet: true });
+
+  console.log(profile.status === "completed" ? t("bootstrap.completed") : t("bootstrap.pending"));
+  return profile;
+}
+
+function status(root) {
+  const context = config.ensureContext(root);
+  const control = config.loadControl(context);
+  setLocale(config.getLocale(control));
+
+  if (!config.isOperaInstalled(control)) {
+    console.log(t("opera.notInstalled"));
+    return;
+  }
+
+  const opera = control.meta.opera;
+  const bootstrapState = opera.bootstrap || bootstrap.detectLegacyBootstrap(context, control);
+  console.log(`OPERA v${opera.version}`);
+  console.log(`  Installed: ${opera.installedAt}`);
+  console.log(`  Skills: ${(opera.skills || []).join(", ") || "none"}`);
+  console.log(`  Locale: ${config.getLocale(control)}`);
+
+  if (bootstrapState) {
+    console.log(`  Bootstrap: ${bootstrapState.status}`);
+    if ((bootstrapState.missingFields || []).length) {
+      console.log(`  Missing: ${bootstrapState.missingFields.join(", ")}`);
+      console.log("  Resume: trackops opera bootstrap --resume");
+    }
+  }
+
   const checks = [
-    [".agent/hub/agent.md", fs.existsSync(path.join(root, ".agent", "hub", "agent.md"))],
-    [".agent/hub/router.md", fs.existsSync(path.join(root, ".agent", "hub", "router.md"))],
-    [".agents/skills/_registry.md", fs.existsSync(path.join(root, ".agents", "skills", "_registry.md"))],
-    ["genesis.md", fs.existsSync(path.join(root, "genesis.md"))],
+    [".agent/hub/agent.md", fs.existsSync(path.join(context.paths.agentHubDir, "agent.md"))],
+    [".agent/hub/router.md", fs.existsSync(path.join(context.paths.agentHubDir, "router.md"))],
+    [".agents/skills/_registry.md", fs.existsSync(context.paths.registryPath)],
+    ["genesis.md", fs.existsSync(context.paths.genesisFile)],
   ];
-
-  console.log("  Structure:");
-  for (const [file, exists] of checks) {
-    console.log(`    ${exists ? "\u2705" : "\u274C"} ${file}`);
-  }
-}
-
+
+  console.log("  Structure:");
+  for (const [file, exists] of checks) {
+    console.log(`    ${exists ? "\u2705" : "\u274C"} ${file}`);
+  }
+}
+
 function configure(root, args) {
-  const control = config.loadControl(root);
-  setLocale(config.getLocale(control));
-
-  for (let i = 0; i < args.length; i += 1) {
-    if (args[i] === "--locale" && args[i + 1]) {
-      control.meta.locale = args[i + 1];
-      i += 1;
-    }
-    if (args[i] === "--phases" && args[i + 1]) {
-      try {
-        control.meta.phases = JSON.parse(args[i + 1]);
-      } catch (_e) {
-        console.error("Invalid phases JSON.");
-        return;
-      }
-      i += 1;
-    }
+  const context = config.ensureContext(root);
+  const control = config.loadControl(context);
+  setLocale(config.getLocale(control));
+  let nextLocale = config.getLocale(control);
+
+  for (let i = 0; i < args.length; i += 1) {
+    if (args[i] === "--locale" && args[i + 1]) {
+      nextLocale = resolveLocale(args[i + 1], nextLocale);
+      control.meta.locale = nextLocale;
+      i += 1;
+    }
+    if (args[i] === "--phases" && args[i + 1]) {
+      try {
+        control.meta.phases = JSON.parse(args[i + 1]);
+      } catch (_e) {
+        console.error("Invalid phases JSON.");
+        return;
+      }
+      i += 1;
+    }
+  }
+
+  config.saveControl(context, control);
+  if (config.isOperaInstalled(control)) {
+    installStructure(context, control, nextLocale, { rewriteLocalizedTemplates: true });
+    env.syncEnvironment(context, control);
+    const ops = require("./control");
+    ops.syncDocs(context, control);
   }
-
-  config.saveControl(root, control);
   console.log("Configuration updated.");
 }
 
 function upgrade(root) {
-  const control = config.loadControl(root);
-  setLocale(config.getLocale(control));
-
-  if (!config.isOperaInstalled(control)) {
-    console.log(t("opera.notInstalled"));
-    console.log("Run 'trackops opera install' first.");
-    return;
-  }
-
-  // Re-copy reference files
-  const refsTemplateDir = path.join(TEMPLATES_DIR, "references");
-  if (fs.existsSync(refsTemplateDir)) {
-    const starterSkillDir = path.join(root, ".agents", "skills", "project-starter-skill", "references");
-    copyDirRecursive(refsTemplateDir, starterSkillDir);
-  }
-
+  const context = config.ensureContext(root);
+  const control = config.loadControl(context);
+  const locale = config.getLocale(control);
+  setLocale(locale);
+
+  if (!config.isOperaInstalled(control)) {
+    console.log(t("opera.notInstalled"));
+    console.log("Run 'trackops opera install' first.");
+    return;
+  }
+
+  installStructure(context, control, locale, { rewriteLocalizedTemplates: true });
   control.meta.opera.version = OPERA_VERSION;
-  config.saveControl(root, control);
+  config.saveControl(context, control);
+  env.syncEnvironment(context, control);
   console.log(t("opera.upgraded", { version: OPERA_VERSION }));
 }
-
-/* ── CLI commands ── */
-
-function cmdInstall(root, args) { install(root, {}); }
-function cmdStatus(root) { status(root); }
-function cmdConfigure(root, args) { configure(root, args); }
-function cmdUpgrade(root) { upgrade(root); }
-
-module.exports = { install, status, configure, upgrade, cmdInstall, cmdStatus, cmdConfigure, cmdUpgrade };
+
+function cmdInstall(root, args) {
+  const options = {
+    bootstrap: true,
+    answers: {},
+    interactive: true,
+    locale: null,
+  };
+  for (let i = 0; i < (args || []).length; i += 1) {
+    if (args[i] === "--locale" && args[i + 1]) {
+      options.locale = args[i + 1];
+      i += 1;
+    } else if (args[i] === "--no-bootstrap") {
+      options.bootstrap = false;
+    } else if (args[i] === "--non-interactive") {
+      options.interactive = false;
+    }
+  }
+  return install(root, options);
+}
+
+function cmdStatus(root) { status(root); }
+function cmdConfigure(root, args) { configure(root, args); }
+function cmdUpgrade(root) { upgrade(root); }
+
+async function cmdBootstrap(root, args) {
+  const options = { locale: null, interactive: true, answers: {} };
+  for (let i = 0; i < (args || []).length; i += 1) {
+    if (args[i] === "--locale" && args[i + 1]) {
+      options.locale = args[i + 1];
+      i += 1;
+    } else if (args[i] === "--non-interactive") {
+      options.interactive = false;
+    } else if (args[i] === "--skip-repo-tasks") {
+      options.answers.repoTaskPolicy = "skip";
+    } else if (args[i] === "--include-repo-tasks") {
+      options.answers.repoTaskPolicy = "optional_pending";
+    }
+  }
+  return runBootstrap(root, options);
+}
+
+module.exports = {
+  installStructure,
+  install,
+  runBootstrap,
+  status,
+  configure,
+  upgrade,
+  cmdInstall,
+  cmdStatus,
+  cmdConfigure,
+  cmdUpgrade,
+  cmdBootstrap,
+};

package/lib/registry.js

@@ -4,6 +4,7 @@ const fs = require("fs");
 const os = require("os");
 const path = require("path");
 
+const config = require("./config");
 const { t } = require("./i18n");
 
 const REGISTRY_DIR = path.join(os.homedir(), ".codex", "trackops");
@@ -39,9 +40,11 @@ function ensureRegistryDir() {
 function loadRegistry() {
   ensureRegistryDir();
   if (!fs.existsSync(REGISTRY_FILE)) {
-    return { version: 1, updatedAt: nowIso(), projects: [] };
+    return { version: 2, updatedAt: nowIso(), projects: [] };
   }
-  return JSON.parse(fs.readFileSync(REGISTRY_FILE, "utf8"));
+  const registry = JSON.parse(fs.readFileSync(REGISTRY_FILE, "utf8"));
+  if (!registry.version) registry.version = 1;
+  return registry;
 }
 
 function saveRegistry(registry) {
@@ -51,19 +54,21 @@ function saveRegistry(registry) {
 }
 
 function isProjectInstalled(rootDir) {
-  return fs.existsSync(path.join(rootDir, "project_control.json"));
+  const context = config.resolveWorkspaceContext(rootDir);
+  return Boolean(context && fs.existsSync(context.controlFile));
 }
 
 function inspectProject(rootDir) {
-  const root = path.resolve(rootDir);
-  const controlStateFile = path.join(root, "project_control.json");
+  const context = config.resolveWorkspaceContext(rootDir) || config.createLegacyContext(rootDir);
+  const root = context.workspaceRoot;
+  const controlStateFile = context.controlFile;
 
   if (!fs.existsSync(controlStateFile)) {
     throw new Error(`Project '${root}' does not have trackops installed.`);
   }
 
   let packageJson = {};
-  const packageFile = path.join(root, "package.json");
+  const packageFile = context.packageFile;
   if (fs.existsSync(packageFile)) {
     packageJson = JSON.parse(fs.readFileSync(packageFile, "utf8"));
   }
@@ -76,6 +81,10 @@ function inspectProject(rootDir) {
     id: `${slugify(projectName) || "project"}-${shortHash(root)}`,
     name: projectName,
     root,
+    workspaceRoot: root,
+    appRoot: context.appRoot,
+    opsRoot: context.opsRoot,
+    layout: context.layout,
     packageName: packageJson.name || null,
     controlStateFile,
     registeredAt: nowIso(),
@@ -86,7 +95,7 @@ function inspectProject(rootDir) {
 function registerProject(rootDir) {
   const registry = loadRegistry();
   const entry = inspectProject(rootDir);
-  const existingIndex = registry.projects.findIndex((p) => p.root === entry.root);
+  const existingIndex = registry.projects.findIndex((p) => (p.workspaceRoot || p.root) === entry.workspaceRoot);
 
   if (existingIndex >= 0) {
     registry.projects[existingIndex] = {
@@ -101,13 +110,14 @@ function registerProject(rootDir) {
 
   registry.projects.sort((a, b) => a.name.localeCompare(b.name));
   saveRegistry(registry);
-  return registry.projects.find((p) => p.root === entry.root);
+  return registry.projects.find((p) => (p.workspaceRoot || p.root) === entry.workspaceRoot);
 }
 
 function unregisterProject(rootDir) {
-  const root = path.resolve(rootDir);
+  const context = config.resolveWorkspaceContext(rootDir) || config.createLegacyContext(rootDir);
+  const root = context.workspaceRoot;
   const registry = loadRegistry();
-  registry.projects = registry.projects.filter((p) => p.root !== root);
+  registry.projects = registry.projects.filter((p) => (p.workspaceRoot || p.root) !== root);
   saveRegistry(registry);
   return registry;
 }
@@ -125,7 +135,9 @@ function resolveProject(projectRef, fallbackRoot) {
 
   if (!projectRef) {
     if (fallbackRoot) {
-      return projects.find((p) => p.root === path.resolve(fallbackRoot)) || null;
+      const resolved = config.resolveWorkspaceContext(fallbackRoot);
+      const target = resolved ? resolved.workspaceRoot : path.resolve(fallbackRoot);
+      return projects.find((p) => (p.workspaceRoot || p.root) === target) || null;
     }
     return projects[0] || null;
   }
@@ -133,7 +145,7 @@ function resolveProject(projectRef, fallbackRoot) {
   const normalizedRef = path.resolve(projectRef);
   return (
     projects.find((p) => p.id === projectRef) ||
-    projects.find((p) => p.root === normalizedRef) ||
+    projects.find((p) => (p.workspaceRoot || p.root) === normalizedRef) ||
     null
   );
 }
@@ -155,7 +167,9 @@ function cmdList() {
   projects.forEach((project, index) => {
     console.log(`${index + 1}. ${project.name}`);
     console.log(`   id: ${project.id}`);
-    console.log(`   root: ${project.root}`);
+    console.log(`   root: ${project.workspaceRoot || project.root}`);
+    console.log(`   app: ${project.appRoot}`);
+    console.log(`   ops: ${project.opsRoot}`);
     console.log(`   available: ${project.available ? "yes" : "no"}`);
   });
 }