trackops 2.0.4 → 2.0.6

package/lib/opera.js

@@ -3,26 +3,59 @@
 const fs = require("fs");
 const path = require("path");
 
-const config = require("./config");
-const env = require("./env");
-const { t, setLocale } = require("./i18n");
-const { promptForLocale, maybePromptForLocale, resolveLocale } = require("./locale");
-const { resolveLocalizedFile, resolveLocalizedDir, resolveSkillFile } = require("./resources");
-const bootstrap = require("./opera-bootstrap");
-const runtimeState = require("./runtime-state");
-
-const TEMPLATES_DIR = path.join(__dirname, "..", "templates", "opera");
-const SKILLS_TEMPLATES_DIR = path.join(__dirname, "..", "templates", "skills");
-const OPERA_VERSION = require("../package.json").version;
-const AUXILIARY_SKILLS = ["project-starter-skill", "opera-contract-auditor", "opera-policy-guard"];
+const config = require("./config");
+const env = require("./env");
+const { t, setLocale } = require("./i18n");
+const { promptForLocale, maybePromptForLocale, resolveLocale } = require("./locale");
+const { resolveLocalizedFile, resolveLocalizedDir, resolveSkillFile } = require("./resources");
+const bootstrap = require("./opera-bootstrap");
+const runtimeState = require("./runtime-state");
+const fmt = require("./cli-format");
+
+const TEMPLATES_DIR = path.join(__dirname, "..", "templates", "opera");
+const SKILLS_TEMPLATES_DIR = path.join(__dirname, "..", "templates", "skills");
+const OPERA_VERSION = require("../package.json").version;
+const AUXILIARY_SKILLS = ["opera-skill", "project-starter-skill", "opera-contract-auditor", "opera-policy-guard"];
+
+function nowIso() {
+  return new Date().toISOString();
+}
 
-function nowIso() {
-  return new Date().toISOString();
-}
-
 function formatLocaleSource(source) {
   return t(`locale.source.${String(source || "").trim()}`) || source || t("locale.none");
 }
+
+function formatBootstrapStatus(status) {
+  return t(`bootstrap.status.${String(status || "").trim()}`) || status || t("locale.none");
+}
+
+function formatBootstrapMode(mode) {
+  return t(`bootstrap.mode.${String(mode || "").trim()}`) || mode || t("locale.none");
+}
+
+function formatBootstrapReason(reason) {
+  return t(`bootstrap.reason.${String(reason || "").trim()}`) || reason || t("locale.none");
+}
+
+function formatDecisionOwnership(value) {
+  return t(`bootstrap.ownership.${String(value || "").trim()}`) || value || t("locale.none");
+}
+
+function formatContractReadiness(value) {
+  return t(`bootstrap.readiness.${String(value || "").trim()}`) || value || t("locale.none");
+}
+
+function formatLegacyStatus(value) {
+  return t(`bootstrap.legacy.${String(value || "").trim()}`) || value || t("locale.none");
+}
+
+function formatMissingFields(fields) {
+  return (fields || []).map((field) => t(`bootstrap.field.${field}`) || field).join(", ");
+}
+
+function relativePathExists(context, relativePath) {
+  return Boolean(relativePath) && fs.existsSync(path.join(context.workspaceRoot, relativePath));
+}
 
 function readText(filePath) {
   return fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf8") : "";
@@ -53,42 +86,61 @@ function copyTemplate(templatePath, targetPath, replacements, options = {}) {
   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);
+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 seedDirRecursive(src, dest, options = {}) {
-  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()) {
-      seedDirRecursive(srcPath, destPath, options);
-    } else if (options.overwrite || !fs.existsSync(destPath)) {
-      fs.mkdirSync(path.dirname(destPath), { recursive: true });
-      fs.copyFileSync(srcPath, destPath);
-    }
-  }
-}
+    }
+  }
+}
 
-function resolveOperaLocale(control, options = {}) {
-  return resolveLocale(options.locale, config.getLocale(control) || runtimeState.getGlobalLocale());
-}
+function seedDirRecursive(src, dest, options = {}) {
+  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()) {
+      seedDirRecursive(srcPath, destPath, options);
+    } else if (options.overwrite || !fs.existsSync(destPath)) {
+      fs.mkdirSync(path.dirname(destPath), { recursive: true });
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function resolveOperaLocale(control, options = {}) {
+  return resolveLocale(options.locale, config.getLocale(control) || runtimeState.getGlobalLocale());
+}
+
+function seedAuxiliarySkill(skillName, locale, skillsDir, options = {}) {
+  const templateDir = path.join(SKILLS_TEMPLATES_DIR, skillName);
+  if (!fs.existsSync(templateDir)) {
+    process.stderr.write(`[opera] Warning: skill template not found: ${skillName} (${templateDir})\n`);
+    return;
+  }
+  const targetDir = path.join(skillsDir, skillName);
+  seedDirRecursive(templateDir, targetDir, {
+    overwrite: options.rewriteLocalizedTemplates === true,
+  });
+  const localizedSkill = resolveSkillFile(SKILLS_TEMPLATES_DIR, skillName, locale);
+  if (localizedSkill) {
+    const targetSkill = path.join(targetDir, "SKILL.md");
+    if (!fs.existsSync(targetSkill) || options.rewriteLocalizedTemplates === true) {
+      fs.copyFileSync(localizedSkill, targetSkill);
+    }
+  }
+}
 
-function installStructure(root, control, locale, options = {}) {
-  const context = config.ensureContext(root);
-  const projectName = control.meta.projectName || "Project";
+function installStructure(root, control, locale, options = {}) {
+  const context = config.ensureContext(root);
+  const projectName = control.meta.projectName || "Project";
   const replacements = {
     PROJECT_NAME: projectName,
     DESIRED_OUTCOME: t("bootstrap.pendingValue"),
@@ -108,13 +160,13 @@ function installStructure(root, control, locale, options = {}) {
     overwriteIfTemplate: options.rewriteLocalizedTemplates === true,
   };
 
-  const agentHubDir = context.paths.agentHubDir;
-  fs.mkdirSync(agentHubDir, { recursive: true });
-  fs.mkdirSync(context.paths.architectureDir, { recursive: true });
-  fs.mkdirSync(context.paths.contractDir, { recursive: true });
-  fs.mkdirSync(context.paths.policyDir, { recursive: true });
-  fs.mkdirSync(context.paths.bootstrapDir, { recursive: true });
-  fs.mkdirSync(context.paths.reviewsDir, { recursive: true });
+  const agentHubDir = context.paths.agentHubDir;
+  fs.mkdirSync(agentHubDir, { recursive: true });
+  fs.mkdirSync(context.paths.architectureDir, { recursive: true });
+  fs.mkdirSync(context.paths.contractDir, { recursive: true });
+  fs.mkdirSync(context.paths.policyDir, { recursive: true });
+  fs.mkdirSync(context.paths.bootstrapDir, { recursive: true });
+  fs.mkdirSync(context.paths.reviewsDir, { recursive: true });
 
   copyTemplate(
     resolveLocalizedFile(TEMPLATES_DIR, locale, "agent.md"),
@@ -129,8 +181,8 @@ function installStructure(root, control, locale, options = {}) {
     overwriteOptions,
   );
 
-  const skillsRegistryDir = context.paths.skillsDir;
-  fs.mkdirSync(skillsRegistryDir, { recursive: true });
+  const skillsRegistryDir = context.paths.skillsDir;
+  fs.mkdirSync(skillsRegistryDir, { recursive: true });
   copyTemplate(
     resolveLocalizedFile(TEMPLATES_DIR, locale, "registry.md"),
     path.join(skillsRegistryDir, "_registry.md"),
@@ -139,204 +191,259 @@ function installStructure(root, control, locale, options = {}) {
   );
 
   const genesisTemplatePath = resolveLocalizedFile(TEMPLATES_DIR, locale, "genesis.md");
-  const genesisPath = context.paths.genesisFile;
+  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");
-  seedDirRecursive(refsTemplateDir, refsTargetDir, {
-    overwrite: options.rewriteLocalizedTemplates === true,
-  });
-
-  const architectureTemplateDir = resolveLocalizedDir(TEMPLATES_DIR, locale, "architecture");
-  seedDirRecursive(architectureTemplateDir, context.paths.architectureDir, {
-    overwrite: options.rewriteLocalizedTemplates === true,
-  });
-
-  const reviewsTemplateDir = resolveLocalizedDir(TEMPLATES_DIR, locale, "reviews");
-  seedDirRecursive(reviewsTemplateDir, context.paths.reviewsDir, {
-    overwrite: options.rewriteLocalizedTemplates === true,
-  });
-
-  for (const skillName of AUXILIARY_SKILLS) {
-    const skillTarget = path.join(context.paths.skillsDir, skillName, "SKILL.md");
-    const skillTemplate = resolveSkillFile(SKILLS_TEMPLATES_DIR, skillName, locale);
-    if (skillTemplate) {
-      fs.mkdirSync(path.dirname(skillTarget), { recursive: true });
-      if (!fs.existsSync(skillTarget) || options.rewriteLocalizedTemplates === true) {
-        fs.copyFileSync(skillTemplate, skillTarget);
-      }
-    }
-  }
-
-  bootstrap.writeAutonomyPolicy(context);
-}
-
-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.");
-  }
-
-  const control = config.loadControl(context);
-  let locale = resolveOperaLocale(control, options);
-  if (!options.locale && !control.meta?.locale && !runtimeState.getGlobalLocale()) {
-    locale = await promptForLocale(locale);
-    if (!runtimeState.getGlobalLocale()) {
-      await runtimeState.ensureGlobalLocale({ preferredLocale: locale, interactive: false });
-    }
-  } else if (!options.locale) {
-    locale = await maybePromptForLocale(locale, { promptMode: "always" });
-  }
-  control.meta.locale = locale;
-  setLocale(locale);
-
-  const alreadyInstalled = config.isOperaInstalled(control);
-  installStructure(context, control, locale);
-
-  control.meta.opera = {
-    ...(control.meta.opera || {}),
-    installed: true,
-    model: "v3",
-    stableTag: "stable",
-    version: OPERA_VERSION,
-    installedAt: control.meta?.opera?.installedAt || nowIso(),
-    skills: control.meta?.opera?.skills || [],
-    legacyStatus: "supported",
-  };
-  if (!control.meta.opera.bootstrap && options.bootstrap === false) {
-    control.meta.opera.bootstrap = bootstrap.createAwaitingBootstrapState(context);
-  }
-  config.saveControl(context, control);
-  env.syncEnvironment(context, control);
+  const refsTemplateDir = resolveLocalizedDir(TEMPLATES_DIR, locale, "references");
+  const refsTargetDir = path.join(context.paths.skillsDir, "project-starter-skill", "references");
+  seedDirRecursive(refsTemplateDir, refsTargetDir, {
+    overwrite: options.rewriteLocalizedTemplates === true,
+  });
+
+  const architectureTemplateDir = resolveLocalizedDir(TEMPLATES_DIR, locale, "architecture");
+  seedDirRecursive(architectureTemplateDir, context.paths.architectureDir, {
+    overwrite: options.rewriteLocalizedTemplates === true,
+  });
+
+  const reviewsTemplateDir = resolveLocalizedDir(TEMPLATES_DIR, locale, "reviews");
+  seedDirRecursive(reviewsTemplateDir, context.paths.reviewsDir, {
+    overwrite: options.rewriteLocalizedTemplates === true,
+  });
+
+  for (const skillName of AUXILIARY_SKILLS) {
+    seedAuxiliarySkill(skillName, locale, context.paths.skillsDir, options);
+  }
+
+  bootstrap.writeAutonomyPolicy(context);
+}
+
+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.");
+  }
 
+  const control = config.loadControl(context);
+  let locale = resolveOperaLocale(control, options);
+  if (!options.locale && !control.meta?.locale && !runtimeState.getGlobalLocale()) {
+    locale = await promptForLocale(locale);
+    if (!runtimeState.getGlobalLocale()) {
+      await runtimeState.ensureGlobalLocale({ preferredLocale: locale, interactive: false });
+    }
+  } else if (!options.locale) {
+    locale = await maybePromptForLocale(locale, { promptMode: "always" });
+  }
+  control.meta.locale = locale;
+  setLocale(locale);
+
+  const alreadyInstalled = config.isOperaInstalled(control);
+  installStructure(context, control, locale);
+
+  control.meta.opera = {
+    ...(control.meta.opera || {}),
+    installed: true,
+    model: "v3",
+    stableTag: "stable",
+    version: OPERA_VERSION,
+    installedAt: control.meta?.opera?.installedAt || nowIso(),
+    skills: control.meta?.opera?.skills || [],
+    legacyStatus: "supported",
+  };
+  if (!control.meta.opera.bootstrap && options.bootstrap === false) {
+    control.meta.opera.bootstrap = bootstrap.createAwaitingBootstrapState(context);
+  }
+  config.saveControl(context, control);
+  env.syncEnvironment(context, control);
+
+  fmt.blank();
   if (!alreadyInstalled) {
-    console.log(t("opera.installed", { version: OPERA_VERSION }));
+    fmt.success(t("opera.installed", { version: OPERA_VERSION }));
   } else {
-    console.log(t("opera.alreadyInstalled", { version: config.getOperaVersion(control) || OPERA_VERSION }));
+    fmt.info(t("opera.alreadyInstalled", { version: config.getOperaVersion(control) || OPERA_VERSION }));
   }
 
-  const skills = require("./skills");
-  for (const skillName of ["commiter", "changelog-updater"]) {
-    try {
-      skills.installSkill(context, skillName, { locale });
-    } catch (_error) {
-      // ignore
-    }
-  }
-  skills.updateRegistry(context);
-
-  if (options.bootstrap !== false) {
-    await runBootstrap(context, {
-      locale,
-      answers: options.answers,
-      interactive: options.interactive,
-      bootstrapMode: options.bootstrapMode,
-      technicalLevel: options.technicalLevel,
-      projectState: options.projectState,
-      docsState: options.docsState,
-      decisionOwnership: options.decisionOwnership,
+  const skills = require("./skills");
+  for (const skillName of ["commiter", "changelog-updater"]) {
+    try {
+      skills.installSkill(context, skillName, { locale });
+    } catch (error) {
+      fmt.warn(t("skill.installError", { name: skillName, error: error.message }));
+    }
+  }
+  skills.updateRegistry(context);
+
+  if (options.bootstrap !== false && options.interactive !== false) {
+    const readline = require("readline");
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise((resolve) => {
+      rl.question(`  ${t("opera.install.bootstrapConfirm")} `, (ans) => { rl.close(); resolve(ans); });
     });
-  }
-}
-
-function removePath(targetPath) {
-  if (!targetPath || !fs.existsSync(targetPath)) return;
-  fs.rmSync(targetPath, { recursive: true, force: true });
-}
-
-function backupManagedArtifacts(context) {
-  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const backupRoot = path.join(context.paths.tmpDir, "upgrade-backups", timestamp);
-  const items = [
-    context.paths.agentHubDir,
-    context.paths.skillsDir,
-    context.paths.genesisFile,
-    context.paths.contractFile,
-    context.paths.autonomyPolicyFile,
-    context.paths.bootstrapDir,
-  ];
-  fs.mkdirSync(backupRoot, { recursive: true });
-  let copied = 0;
-  for (const item of items) {
-    if (!fs.existsSync(item)) continue;
-    const relative = path.relative(context.workspaceRoot, item);
-    const destination = path.join(backupRoot, relative);
-    if (fs.statSync(item).isDirectory()) {
-      copyDirRecursive(item, destination);
-    } else {
-      fs.mkdirSync(path.dirname(destination), { recursive: true });
-      fs.copyFileSync(item, destination);
+    const normalizedAnswer = String(answer || "").trim().toLowerCase();
+    if (!["y", "yes", "s", "si"].includes(normalizedAnswer)) {
+      fmt.info(t("opera.install.bootstrapSkipped"));
+      fmt.blank();
+      return;
     }
-    copied += 1;
   }
-  return { backupRoot, copied };
-}
-
-async function runBootstrap(root, options = {}) {
-  const context = config.ensureContext(root);
-  const control = config.loadControl(context);
-  const locale = resolveOperaLocale(control, options);
+  if (options.bootstrap !== false) {
+    await runBootstrap(context, {
+      locale,
+      answers: options.answers,
+      interactive: options.interactive,
+      bootstrapMode: options.bootstrapMode,
+      technicalLevel: options.technicalLevel,
+      projectState: options.projectState,
+      docsState: options.docsState,
+      decisionOwnership: options.decisionOwnership,
+    });
+  }
+}
+
+function removePath(targetPath) {
+  if (!targetPath || !fs.existsSync(targetPath)) return;
+  fs.rmSync(targetPath, { recursive: true, force: true });
+}
+
+function backupManagedArtifacts(context) {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const backupRoot = path.join(context.paths.tmpDir, "upgrade-backups", timestamp);
+  const items = [
+    context.paths.agentHubDir,
+    context.paths.skillsDir,
+    context.paths.genesisFile,
+    context.paths.contractFile,
+    context.paths.autonomyPolicyFile,
+    context.paths.bootstrapDir,
+  ];
+  fs.mkdirSync(backupRoot, { recursive: true });
+  let copied = 0;
+  for (const item of items) {
+    if (!fs.existsSync(item)) continue;
+    const relative = path.relative(context.workspaceRoot, item);
+    const destination = path.join(backupRoot, relative);
+    if (fs.statSync(item).isDirectory()) {
+      copyDirRecursive(item, destination);
+    } else {
+      fs.mkdirSync(path.dirname(destination), { recursive: true });
+      fs.copyFileSync(item, destination);
+    }
+    copied += 1;
+  }
+  return { backupRoot, copied };
+}
+
+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);
-  }
-
-  if ((options.resume || options.forceResume) && control.meta?.opera?.bootstrap) {
-    const resumed = bootstrap.resumeBootstrap(context, control);
-    if (resumed.resumed) {
-      const updatedControl = bootstrap.applyBootstrap(context, control, resumed.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(t("bootstrap.completed"));
-      return resumed.profile;
-    }
-    console.log(t("bootstrap.awaitingAgent"));
-    return control.meta.opera.bootstrap;
-  }
-
+  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);
+  }
+
+  if ((options.resume || options.forceResume) && control.meta?.opera?.bootstrap) {
+    const resumed = bootstrap.resumeBootstrap(context, control);
+    if (resumed.resumed) {
+      const profile = resumed.profile;
+      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 });
+      fmt.blank();
+
+      if (profile.status === "completed") {
+        fmt.success(t("bootstrap.completed"));
+        fmt.blank();
+        fmt.step(t("bootstrap.next.label"));
+        fmt.hint(t("bootstrap.next.directCompleted"));
+      } else if (profile.status === "blocked") {
+        fmt.warn(t("bootstrap.resumeBlocked"));
+        for (const field of profile.missingFields || []) {
+          fmt.bullet(t(`bootstrap.field.${field}`) || field);
+        }
+        fmt.blank();
+        fmt.hint(t("bootstrap.next.directPending"));
+      } else if (profile.status === "needs_review") {
+        fmt.info(t("bootstrap.resumeNeedsReview"));
+        for (const field of profile.missingFields || []) {
+          fmt.bullet(t(`bootstrap.field.${field}`) || field);
+        }
+        fmt.blank();
+        fmt.hint(t("bootstrap.next.directPending"));
+      }
+
+      fmt.blank();
+      return profile;
+    }
+    fmt.blank();
+    if (resumed.reason === "missing_agent_artifacts") {
+      fmt.warn(t("bootstrap.resumeAwaitingArtifacts"));
+    } else if (resumed.reason === "empty_intake_and_spec") {
+      fmt.warn(t("bootstrap.resumeEmptyArtifacts"));
+    } else {
+      fmt.info(t("bootstrap.awaitingAgent"));
+    }
+    fmt.hint(t("bootstrap.next.handoff"));
+    fmt.blank();
+    return control.meta.opera.bootstrap;
+  }
+
   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 });
-
-  if (profile.mode === "agent_handoff") {
-    console.log(t("bootstrap.awaitingAgent"));
-    console.log(`${t("bootstrap.handoffFile")}: ${profile.handoffFiles?.markdown || bootstrap.bootstrapRelativePaths(context).markdown}`);
-    console.log(t("bootstrap.next.handoff"));
-  } else {
-    console.log(profile.status === "completed" ? t("bootstrap.completed") : t("bootstrap.pending"));
-    console.log(
-      profile.status === "completed"
-        ? t("bootstrap.next.directCompleted")
-        : t("bootstrap.next.directPending"),
-    );
+  if (profile.mode && profile.routeReason) {
+    fmt.blank();
+    fmt.info(t("bootstrap.routingMode", {
+      mode: formatBootstrapMode(profile.mode),
+      reason: formatBootstrapReason(profile.routeReason),
+    }));
   }
-  return profile;
-}
-
-function status(root) {
-  const context = config.ensureContext(root);
-  const control = config.loadControl(context);
-  setLocale(config.getLocale(control));
+  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 });
+
+  fmt.header(t("bootstrap.resultHeader"));
+
+  if (profile.mode === "agent_handoff") {
+    fmt.info(t("bootstrap.awaitingAgent"));
+    fmt.blank();
+    fmt.step(t("bootstrap.handoffFile"), profile.handoffFiles?.markdown || bootstrap.bootstrapRelativePaths(context).markdown);
+    fmt.blank();
+    fmt.step(t("bootstrap.next.label"));
+    fmt.hint(t("bootstrap.next.handoff"));
+  } else {
+    fmt.success(profile.status === "completed" ? t("bootstrap.completed") : t("bootstrap.pending"));
+    fmt.blank();
+    fmt.step(t("bootstrap.next.label"));
+    fmt.hint(
+      profile.status === "completed"
+        ? t("bootstrap.next.directCompleted")
+        : t("bootstrap.next.directPending"),
+    );
+  }
+  fmt.blank();
+  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);
   const localeDoctor = runtimeState.doctorLocale(control.meta?.locale || null);
@@ -344,51 +451,71 @@ function status(root) {
   console.log(t("opera.status.installed", { value: opera.installedAt }));
   console.log(t("opera.status.skills", { value: (opera.skills || []).join(", ") || t("locale.none") }));
   console.log(t("opera.status.locale", { locale: config.getLocale(control), source: formatLocaleSource(localeDoctor.source) }));
-  console.log(t("opera.status.legacy", { value: opera.legacyStatus || bootstrapState?.status || "supported" }));
+  console.log(t("opera.status.legacy", { value: formatLegacyStatus(opera.legacyStatus || bootstrapState?.status || "supported") }));
   console.log(t("opera.status.contractVersion", { value: opera.contractVersion || t("locale.none") }));
-  console.log(t("opera.status.contractReadiness", { value: opera.contractReadiness || "hypothesis" }));
+  console.log(t("opera.status.contractReadiness", { value: formatContractReadiness(opera.contractReadiness || "hypothesis") }));
 
   if (bootstrapState) {
-    console.log(t("opera.status.bootstrap", { value: bootstrapState.status }));
+    console.log(t("opera.status.bootstrap", { value: formatBootstrapStatus(bootstrapState.status) }));
     if (bootstrapState.mode) {
-      console.log(t("opera.status.mode", { value: bootstrapState.mode }));
+      console.log(t("opera.status.mode", { value: formatBootstrapMode(bootstrapState.mode) }));
     }
     if (bootstrapState.routeReason) {
-      console.log(t("opera.status.route", { value: bootstrapState.routeReason }));
+      console.log(t("opera.status.route", { value: formatBootstrapReason(bootstrapState.routeReason) }));
     }
     if (bootstrapState.decisionOwnership) {
-      console.log(t("opera.status.ownership", { value: bootstrapState.decisionOwnership }));
+      console.log(t("opera.status.ownership", { value: formatDecisionOwnership(bootstrapState.decisionOwnership) }));
     }
     if ((bootstrapState.missingFields || []).length) {
-      console.log(t("opera.status.missing", { value: bootstrapState.missingFields.join(", ") }));
+      console.log(t("opera.status.missing", { value: formatMissingFields(bootstrapState.missingFields) }));
+      if (bootstrapState.mode === "agent_handoff") {
+        console.log(t("opera.status.awaitingAgentExplanation"));
+        console.log(t("opera.status.awaitingAgentAction"));
+      } else {
+        console.log(t("opera.status.directExplanation"));
+        console.log(t("opera.status.directAction", {
+          intake: bootstrapState.intakeFiles?.json || bootstrap.bootstrapRelativePaths(context).intakeJson,
+          spec: bootstrapState.intakeFiles?.specDossier || bootstrap.bootstrapRelativePaths(context).specDossier,
+        }));
+      }
+      console.log(t("opera.status.contractNotGenerated"));
       console.log(t("opera.status.resume"));
     }
-    if (bootstrapState.handoffFiles?.markdown) {
+    if (bootstrapState.mode === "agent_handoff" && relativePathExists(context, bootstrapState.handoffFiles?.markdown)) {
       console.log(t("opera.status.handoff", { value: bootstrapState.handoffFiles.markdown }));
     }
-    if (bootstrapState.reviewFiles?.qualityReport) {
+    if (relativePathExists(context, bootstrapState.intakeFiles?.json)) {
+      console.log(t("opera.status.intake", { value: bootstrapState.intakeFiles.json }));
+    }
+    if (relativePathExists(context, bootstrapState.intakeFiles?.specDossier)) {
+      console.log(t("opera.status.specDossier", { value: bootstrapState.intakeFiles.specDossier }));
+    }
+    if (relativePathExists(context, bootstrapState.reviewFiles?.openQuestions)) {
+      console.log(t("opera.status.openQuestions", { value: bootstrapState.reviewFiles.openQuestions }));
+    }
+    if (relativePathExists(context, bootstrapState.reviewFiles?.qualityReport)) {
       console.log(t("opera.status.qualityReport", { value: bootstrapState.reviewFiles.qualityReport }));
     }
   }
-
-  const checks = [
-    [context.layout === "split" ? "ops/.agent/hub/agent.md" : ".agent/hub/agent.md", fs.existsSync(path.join(context.paths.agentHubDir, "agent.md"))],
-    [context.layout === "split" ? "ops/.agent/hub/router.md" : ".agent/hub/router.md", fs.existsSync(path.join(context.paths.agentHubDir, "router.md"))],
-    [context.layout === "split" ? "ops/.agents/skills/_registry.md" : ".agents/skills/_registry.md", fs.existsSync(context.paths.registryPath)],
-    [context.layout === "split" ? "ops/genesis.md" : "genesis.md", fs.existsSync(context.paths.genesisFile)],
-    [context.layout === "split" ? "ops/contract/operating-contract.json" : "contract/operating-contract.json", fs.existsSync(context.paths.contractFile)],
-    [context.layout === "split" ? "ops/policy/autonomy.json" : "policy/autonomy.json", fs.existsSync(context.paths.autonomyPolicyFile)],
-  ];
+
+  const checks = [
+    [context.layout === "split" ? "ops/.agent/hub/agent.md" : ".agent/hub/agent.md", fs.existsSync(path.join(context.paths.agentHubDir, "agent.md"))],
+    [context.layout === "split" ? "ops/.agent/hub/router.md" : ".agent/hub/router.md", fs.existsSync(path.join(context.paths.agentHubDir, "router.md"))],
+    [context.layout === "split" ? "ops/.agents/skills/_registry.md" : ".agents/skills/_registry.md", fs.existsSync(context.paths.registryPath)],
+    [context.layout === "split" ? "ops/genesis.md" : "genesis.md", fs.existsSync(context.paths.genesisFile)],
+    [context.layout === "split" ? "ops/contract/operating-contract.json" : "contract/operating-contract.json", fs.existsSync(context.paths.contractFile)],
+    [context.layout === "split" ? "ops/policy/autonomy.json" : "policy/autonomy.json", fs.existsSync(context.paths.autonomyPolicyFile)],
+  ];
 
   console.log(t("opera.status.structure"));
-  for (const [file, exists] of checks) {
-    console.log(`    ${exists ? "\u2705" : "\u274C"} ${file}`);
-  }
-}
+  for (const [file, exists] of checks) {
+    console.log(`    ${fmt.boolToken(exists)} ${file}`);
+  }
+}
 
-function configure(root, args) {
-  const context = config.ensureContext(root);
-  const control = config.loadControl(context);
+function configure(root, args) {
+  const context = config.ensureContext(root);
+  const control = config.loadControl(context);
   setLocale(config.getLocale(control));
   let nextLocale = config.getLocale(control);
 
@@ -398,212 +525,256 @@ function configure(root, args) {
       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(t("opera.configure.invalidPhases"));
-        return;
-      }
+    if (args[i] === "--phases" && args[i + 1]) {
+      try {
+        control.meta.phases = JSON.parse(args[i + 1]);
+      } catch (_e) {
+        console.error(t("opera.configure.invalidPhases"));
+        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);
-  }
-  console.log(t("opera.configure.updated"));
-}
-
-function upgrade(root, args = []) {
-  const context = config.ensureContext(root);
-  const control = config.loadControl(context);
-  const locale = config.getLocale(control);
-  setLocale(locale);
-  const wantsStable = (args || []).includes("--stable");
-  const wantsReset = (args || []).includes("--reset");
-
-  if (!config.isOperaInstalled(control)) {
-    console.log(t("opera.notInstalled"));
-    console.log(t("opera.upgrade.runInstallFirst"));
-    return;
-  }
-
-  if (!wantsStable) {
-    console.log(t("opera.upgrade.usage"));
-    return;
-  }
-
-  const legacy = bootstrap.detectLegacyBootstrap(context, control);
-  const isLegacyUnsupported = legacy?.status === "legacy_unsupported";
-  if (isLegacyUnsupported && !wantsReset) {
-    control.meta.opera = control.meta.opera || {};
-    control.meta.opera.legacyStatus = "legacy_unsupported";
-    config.saveControl(context, control);
-    console.log(t("opera.upgrade.legacyUnsupported"));
-    return;
-  }
-
-  const backup = backupManagedArtifacts(context);
-  if (wantsReset) {
-    removePath(context.paths.agentHubDir);
-    removePath(context.paths.skillsDir);
-    removePath(context.paths.genesisFile);
-    removePath(context.paths.contractFile);
-    removePath(context.paths.autonomyPolicyFile);
-    removePath(context.paths.bootstrapDir);
-  }
-
-  installStructure(context, control, locale, { rewriteLocalizedTemplates: true });
-  control.meta.opera = {
-    ...(control.meta.opera || {}),
-    installed: true,
-    model: "v3",
-    stableTag: "stable",
-    version: OPERA_VERSION,
-    legacyStatus: "supported",
-    contractVersion: fs.existsSync(context.paths.contractFile) ? bootstrap.CONTRACT_VERSION : null,
-    contractReadiness: fs.existsSync(context.paths.contractFile)
-      ? (control.meta?.opera?.contractReadiness || "verified")
-      : "hypothesis",
-    bootstrap: wantsReset
-      ? bootstrap.createAwaitingBootstrapState(context)
-      : (control.meta?.opera?.bootstrap || bootstrap.createAwaitingBootstrapState(context)),
-  };
-  config.saveControl(context, control);
-  env.syncEnvironment(context, control);
-  require("./skills").updateRegistry(context);
-  console.log(t("opera.upgrade.backup", { path: path.relative(context.workspaceRoot, backup.backupRoot) }));
-  console.log(t("opera.upgraded", { version: OPERA_VERSION }));
-}
-
-function cmdInstall(root, args) {
-  const options = {
-    bootstrap: true,
-    answers: {},
-    interactive: true,
-    locale: null,
-    bootstrapMode: "auto",
-    technicalLevel: null,
-    projectState: null,
-    docsState: null,
-    decisionOwnership: 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;
-    } else if (args[i] === "--bootstrap-mode" && args[i + 1]) {
-      options.bootstrapMode = args[i + 1];
-      i += 1;
-    } else if (args[i] === "--technical-level" && args[i + 1]) {
-      options.technicalLevel = args[i + 1];
-      i += 1;
-    } else if (args[i] === "--project-state" && args[i + 1]) {
-      options.projectState = args[i + 1];
-      i += 1;
-    } else if (args[i] === "--docs-state" && args[i + 1]) {
-      options.docsState = args[i + 1];
-      i += 1;
-    } else if (args[i] === "--decision-ownership" && args[i + 1]) {
-      options.decisionOwnership = args[i + 1];
-      i += 1;
-    }
-  }
-  return install(root, options);
-}
-
-function cmdStatus(root) { status(root); }
-function cmdConfigure(root, args) { configure(root, args); }
-function cmdUpgrade(root, args) { upgrade(root, args); }
-
-async function cmdBootstrap(root, args) {
-  const options = {
-    locale: null,
-    interactive: true,
-    answers: {},
-    resume: false,
-    bootstrapMode: "auto",
-    technicalLevel: null,
-    projectState: null,
-    docsState: null,
-    decisionOwnership: 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] === "--non-interactive") {
-      options.interactive = false;
-    } else if (args[i] === "--resume") {
-      options.resume = true;
-    } else if (args[i] === "--bootstrap-mode" && args[i + 1]) {
-      options.bootstrapMode = args[i + 1];
-      i += 1;
-    } else if (args[i] === "--technical-level" && args[i + 1]) {
-      options.technicalLevel = args[i + 1];
-      i += 1;
-    } else if (args[i] === "--project-state" && args[i + 1]) {
-      options.projectState = args[i + 1];
-      i += 1;
-    } else if (args[i] === "--docs-state" && args[i + 1]) {
-      options.docsState = args[i + 1];
-      i += 1;
-    } else if (args[i] === "--decision-ownership" && args[i + 1]) {
-      options.decisionOwnership = args[i + 1];
-      i += 1;
-    }
-  }
-  return runBootstrap(root, options);
-}
-
+  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);
+  }
+  console.log(t("opera.configure.updated"));
+}
+
+function upgrade(root, args = []) {
+  const context = config.ensureContext(root);
+  const control = config.loadControl(context);
+  const locale = config.getLocale(control);
+  setLocale(locale);
+  const wantsStable = (args || []).includes("--stable");
+  const wantsReset = (args || []).includes("--reset");
+
+  if (!config.isOperaInstalled(control)) {
+    console.log(t("opera.notInstalled"));
+    console.log(t("opera.upgrade.runInstallFirst"));
+    return;
+  }
+
+  if (!wantsStable) {
+    console.log(t("opera.upgrade.usage"));
+    return;
+  }
+
+  const legacy = bootstrap.detectLegacyBootstrap(context, control);
+  const isLegacyUnsupported = legacy?.status === "legacy_unsupported";
+  if (isLegacyUnsupported && !wantsReset) {
+    control.meta.opera = control.meta.opera || {};
+    control.meta.opera.legacyStatus = "legacy_unsupported";
+    config.saveControl(context, control);
+    console.log(t("opera.upgrade.legacyUnsupported"));
+    return;
+  }
+
+  const backup = backupManagedArtifacts(context);
+  if (wantsReset) {
+    removePath(context.paths.agentHubDir);
+    removePath(context.paths.skillsDir);
+    removePath(context.paths.genesisFile);
+    removePath(context.paths.contractFile);
+    removePath(context.paths.autonomyPolicyFile);
+    removePath(context.paths.bootstrapDir);
+  }
+
+  installStructure(context, control, locale, { rewriteLocalizedTemplates: true });
+  control.meta.opera = {
+    ...(control.meta.opera || {}),
+    installed: true,
+    model: "v3",
+    stableTag: "stable",
+    version: OPERA_VERSION,
+    legacyStatus: "supported",
+    contractVersion: fs.existsSync(context.paths.contractFile) ? bootstrap.CONTRACT_VERSION : null,
+    contractReadiness: fs.existsSync(context.paths.contractFile)
+      ? (control.meta?.opera?.contractReadiness || "verified")
+      : "hypothesis",
+    bootstrap: wantsReset
+      ? bootstrap.createAwaitingBootstrapState(context)
+      : (control.meta?.opera?.bootstrap || bootstrap.createAwaitingBootstrapState(context)),
+  };
+  config.saveControl(context, control);
+  env.syncEnvironment(context, control);
+  require("./skills").updateRegistry(context);
+  console.log(t("opera.upgrade.backup", { path: path.relative(context.workspaceRoot, backup.backupRoot) }));
+  console.log(t("opera.upgraded", { version: OPERA_VERSION }));
+}
+
+function cmdInstall(root, args) {
+  const options = {
+    bootstrap: true,
+    answers: {},
+    interactive: true,
+    locale: null,
+    bootstrapMode: "auto",
+    technicalLevel: null,
+    projectState: null,
+    docsState: null,
+    decisionOwnership: 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;
+    } else if (args[i] === "--bootstrap-mode" && args[i + 1]) {
+      options.bootstrapMode = args[i + 1];
+      i += 1;
+    } else if (args[i] === "--technical-level" && args[i + 1]) {
+      options.technicalLevel = args[i + 1];
+      i += 1;
+    } else if (args[i] === "--project-state" && args[i + 1]) {
+      options.projectState = args[i + 1];
+      i += 1;
+    } else if (args[i] === "--docs-state" && args[i + 1]) {
+      options.docsState = args[i + 1];
+      i += 1;
+    } else if (args[i] === "--decision-ownership" && args[i + 1]) {
+      options.decisionOwnership = args[i + 1];
+      i += 1;
+    }
+  }
+  return install(root, options);
+}
+
+function cmdStatus(root) { status(root); }
+function cmdConfigure(root, args) { configure(root, args); }
+function cmdUpgrade(root, args) { upgrade(root, args); }
+
+async function cmdBootstrap(root, args) {
+  const options = {
+    locale: null,
+    interactive: true,
+    answers: {},
+    resume: false,
+    bootstrapMode: "auto",
+    technicalLevel: null,
+    projectState: null,
+    docsState: null,
+    decisionOwnership: 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] === "--non-interactive") {
+      options.interactive = false;
+    } else if (args[i] === "--resume") {
+      options.resume = true;
+    } else if (args[i] === "--bootstrap-mode" && args[i + 1]) {
+      options.bootstrapMode = args[i + 1];
+      i += 1;
+    } else if (args[i] === "--technical-level" && args[i + 1]) {
+      options.technicalLevel = args[i + 1];
+      i += 1;
+    } else if (args[i] === "--project-state" && args[i + 1]) {
+      options.projectState = args[i + 1];
+      i += 1;
+    } else if (args[i] === "--docs-state" && args[i + 1]) {
+      options.docsState = args[i + 1];
+      i += 1;
+    } else if (args[i] === "--decision-ownership" && args[i + 1]) {
+      options.decisionOwnership = args[i + 1];
+      i += 1;
+    }
+  }
+  return runBootstrap(root, options);
+}
+
 function cmdHandoff(root, args) {
-  const context = config.ensureContext(root);
-  const control = config.loadControl(context);
-  const state = bootstrap.getBootstrapState(control, context) || bootstrap.detectLegacyBootstrap(context, control);
-  if (!state) {
-    throw new Error("OPERA bootstrap is not initialized.");
-  }
+  const context = config.ensureContext(root);
+  const control = config.loadControl(context);
+  const state = bootstrap.getBootstrapState(control, context) || bootstrap.detectLegacyBootstrap(context, control);
+  if (!state) {
+    throw new Error("OPERA bootstrap is not initialized.");
+  }
   const files = bootstrap.bootstrapFilePaths(context);
   const printMode = (args || []).includes("--print");
   const jsonMode = (args || []).includes("--json");
+  if (state.mode !== "agent_handoff") {
+    const payload = {
+      mode: state.mode,
+      status: state.status,
+      files: {
+        intakeJson: state.intakeFiles?.json || bootstrap.bootstrapRelativePaths(context).intakeJson,
+        specDossier: state.intakeFiles?.specDossier || bootstrap.bootstrapRelativePaths(context).specDossier,
+        openQuestions: state.reviewFiles?.openQuestions || bootstrap.bootstrapRelativePaths(context).openQuestions,
+        qualityReport: state.reviewFiles?.qualityReport || bootstrap.bootstrapRelativePaths(context).qualityReport,
+      },
+      nextStep: t("opera.handoff.directNext"),
+    };
+    if (jsonMode) {
+      process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+      return;
+    }
+    if (printMode) {
+      process.stdout.write([
+        `# ${t("opera.handoff.directTitle")}`,
+        "",
+        `- ${t("opera.handoff.directStatus")}: ${formatBootstrapStatus(state.status)}`,
+        `- ${t("opera.handoff.directIntake")}: ${payload.files.intakeJson}`,
+        `- ${t("opera.handoff.directSpec")}: ${payload.files.specDossier}`,
+        `- ${t("opera.handoff.directQuestions")}: ${payload.files.openQuestions}`,
+        `- ${t("opera.handoff.directQuality")}: ${payload.files.qualityReport}`,
+        "",
+        t("opera.handoff.directNext"),
+        "",
+      ].join("\n"));
+      return;
+    }
+    console.log(t("opera.handoff.directSummary", { status: formatBootstrapStatus(state.status) }));
+    console.log(t("opera.status.intake", { value: payload.files.intakeJson }));
+    console.log(t("opera.status.specDossier", { value: payload.files.specDossier }));
+    if (relativePathExists(context, payload.files.openQuestions)) {
+      console.log(t("opera.status.openQuestions", { value: payload.files.openQuestions }));
+    }
+    if (relativePathExists(context, payload.files.qualityReport)) {
+      console.log(t("opera.status.qualityReport", { value: payload.files.qualityReport }));
+    }
+    console.log(t("opera.status.resume"));
+    console.log(t("opera.handoff.directNext"));
+    return;
+  }
   if (jsonMode) {
     const payload = readText(files.json);
     process.stdout.write(payload || "{}\n");
     return;
   }
-  if (printMode) {
-    process.stdout.write(readText(files.markdown) || "");
-    return;
-  }
-  console.log(`Bootstrap: ${state.status}`);
-  console.log(`Mode: ${state.mode}`);
-  console.log(`Markdown handoff: ${state.handoffFiles?.markdown || bootstrap.bootstrapRelativePaths(context).markdown}`);
-  console.log(`JSON handoff: ${state.handoffFiles?.json || bootstrap.bootstrapRelativePaths(context).json}`);
-  if (state.reviewFiles?.openQuestions) {
-    console.log(`Open questions: ${state.reviewFiles.openQuestions}`);
+  if (printMode) {
+    process.stdout.write(readText(files.markdown) || "");
+    return;
+  }
+  console.log(t("opera.handoff.summary", { status: formatBootstrapStatus(state.status) }));
+  console.log(t("opera.handoff.mode", { mode: formatBootstrapMode(state.mode) }));
+  console.log(t("opera.handoff.markdown", { value: state.handoffFiles?.markdown || bootstrap.bootstrapRelativePaths(context).markdown }));
+  console.log(t("opera.handoff.json", { value: state.handoffFiles?.json || bootstrap.bootstrapRelativePaths(context).json }));
+  if (relativePathExists(context, state.reviewFiles?.openQuestions)) {
+    console.log(t("opera.status.openQuestions", { value: state.reviewFiles.openQuestions }));
   }
 }
-
-module.exports = {
-  installStructure,
-  install,
-  runBootstrap,
+
+module.exports = {
+  installStructure,
+  install,
+  runBootstrap,
   status,
   configure,
   upgrade,
   cmdInstall,
   cmdStatus,
-  cmdConfigure,
-  cmdUpgrade,
-  cmdBootstrap,
-  cmdHandoff,
-};
+  cmdConfigure,
+  cmdUpgrade,
+  cmdBootstrap,
+  cmdHandoff,
+};