trackops 1.1.0 → 2.0.0

package/lib/runtime-state.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const { detectSystemLocale, isInteractive, normalizeLocale, promptForLocale } = require("./locale");
+
+function getRuntimeHome() {
+  return process.env.TRACKOPS_BOOTSTRAP_HOME || os.homedir();
+}
+
+function getRuntimeDir() {
+  return path.join(getRuntimeHome(), ".trackops");
+}
+
+function getRuntimeFile() {
+  return path.join(getRuntimeDir(), "runtime.json");
+}
+
+function defaultRuntimeState() {
+  return {
+    locale: null,
+    localeSource: null,
+    skill: null,
+    skillVersion: null,
+    runtimePackage: "trackops",
+    runtimeVersion: null,
+    bootstrapPolicy: null,
+    supportedAgentsV1: [],
+    verifiedAt: null,
+    verifiedWith: null,
+    executable: null,
+  };
+}
+
+function normalizeRuntimeState(state) {
+  const base = defaultRuntimeState();
+  const next = { ...base, ...(state || {}) };
+  next.locale = normalizeLocale(next.locale);
+  next.localeSource = next.localeSource || null;
+  next.supportedAgentsV1 = Array.isArray(next.supportedAgentsV1) ? next.supportedAgentsV1 : [];
+  return next;
+}
+
+function readRuntimeState() {
+  const file = getRuntimeFile();
+  if (!fs.existsSync(file)) return defaultRuntimeState();
+  try {
+    return normalizeRuntimeState(JSON.parse(fs.readFileSync(file, "utf8")));
+  } catch (_error) {
+    return defaultRuntimeState();
+  }
+}
+
+function writeRuntimeState(patch) {
+  const file = getRuntimeFile();
+  const state = normalizeRuntimeState({ ...readRuntimeState(), ...(patch || {}) });
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+  return state;
+}
+
+function getGlobalLocale() {
+  return readRuntimeState().locale || null;
+}
+
+function resolveLocaleState(options = {}) {
+  const runtime = readRuntimeState();
+  const explicit = normalizeLocale(options.explicitLocale);
+  if (explicit) return { locale: explicit, source: "explicit", runtime };
+
+  const project = normalizeLocale(options.projectLocale);
+  if (project) return { locale: project, source: "project", runtime };
+
+  const global = normalizeLocale(runtime.locale);
+  if (global) return { locale: global, source: "global", runtime };
+
+  const envLocale = normalizeLocale(process.env.TRACKOPS_LOCALE);
+  if (envLocale) return { locale: envLocale, source: "env", runtime };
+
+  const system = detectSystemLocale();
+  return { locale: system || "es", source: "system", runtime };
+}
+
+async function ensureGlobalLocale(options = {}) {
+  const current = readRuntimeState();
+  const explicit = normalizeLocale(options.preferredLocale);
+  if (explicit) {
+    return {
+      locale: explicit,
+      source: "explicit",
+      runtime: writeRuntimeState({ locale: explicit, localeSource: "explicit" }),
+    };
+  }
+
+  if (normalizeLocale(current.locale)) {
+    return { locale: current.locale, source: "global", runtime: current };
+  }
+
+  let locale = null;
+  let source = null;
+  if (options.interactive !== false && isInteractive()) {
+    locale = await promptForLocale(detectSystemLocale());
+    source = "prompt";
+  } else {
+    locale = detectSystemLocale() || "es";
+    source = "system";
+  }
+
+  return {
+    locale,
+    source,
+    runtime: writeRuntimeState({ locale, localeSource: source }),
+  };
+}
+
+function doctorLocale(projectLocale = null, explicitLocale = null) {
+  const resolved = resolveLocaleState({ explicitLocale, projectLocale });
+  const runtime = readRuntimeState();
+  return {
+    effectiveLocale: resolved.locale || "es",
+    source: resolved.source,
+    projectLocale: normalizeLocale(projectLocale),
+    globalLocale: normalizeLocale(runtime.locale),
+    envLocale: normalizeLocale(process.env.TRACKOPS_LOCALE),
+    systemLocale: detectSystemLocale() || "es",
+    runtimeFile: getRuntimeFile(),
+  };
+}
+
+module.exports = {
+  getRuntimeHome,
+  getRuntimeDir,
+  getRuntimeFile,
+  defaultRuntimeState,
+  normalizeRuntimeState,
+  readRuntimeState,
+  writeRuntimeState,
+  getGlobalLocale,
+  resolveLocaleState,
+  ensureGlobalLocale,
+  doctorLocale,
+};

package/lib/server.js

@@ -11,8 +11,9 @@ const config = require("./config");
 const control = require("./control");
 const env = require("./env");
 const registry = require("./registry");
-const { t, setLocale, getMessages } = require("./i18n");
-const { normalizeLocale } = require("./locale");
+const { t, setLocale, getMessages } = require("./i18n");
+const { normalizeLocale } = require("./locale");
+const runtimeState = require("./runtime-state");
 
 const UI_DIR = path.join(__dirname, "..", "ui");
 const DEFAULT_HOST = "127.0.0.1";
@@ -41,10 +42,19 @@ function sendJson(res, statusCode, payload) {
   res.end(JSON.stringify(payload));
 }
 
-function sendText(res, statusCode, message) {
-  res.writeHead(statusCode, { "Content-Type": "text/plain; charset=utf-8", "Cache-Control": "no-store" });
-  res.end(message);
-}
+function sendText(res, statusCode, message) {
+  res.writeHead(statusCode, { "Content-Type": "text/plain; charset=utf-8", "Cache-Control": "no-store" });
+  res.end(message);
+}
+
+function readJsonFileSafe(filePath) {
+  if (!filePath || !fs.existsSync(filePath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch (_error) {
+    return null;
+  }
+}
 
 function parseBody(req) {
   return new Promise((resolve, reject) => {
@@ -355,22 +365,50 @@ function loadControlApi(projectRoot) {
   return control.forProject(projectRoot);
 }
 
-function buildI18nPayload(controlState) {
+function buildI18nPayload(controlState) {
   const phases = config.getPhases(controlState);
   const locale = config.getLocale(controlState);
   const statusLabels = {};
   for (const s of control.STATUS_ORDER) {
     statusLabels[s] = control.statusLabel(s);
   }
-  return { locale, statusLabels, phases, messages: getMessages(locale) };
-}
-
+  return { locale, statusLabels, phases, messages: getMessages(locale) };
+}
+
+function buildOperaState(projectRoot, controlState) {
+  const context = config.ensureContext(projectRoot);
+  const operaBootstrap = require("./opera-bootstrap");
+  const bootstrapState =
+    controlState.meta?.opera?.bootstrap ||
+    operaBootstrap.detectLegacyBootstrap(context, controlState) ||
+    operaBootstrap.createAwaitingBootstrapState(context);
+  const qualityReport = readJsonFileSafe(path.join(context.paths.bootstrapDir, "quality-report.json"));
+  const localeDoctor = runtimeState.doctorLocale(controlState.meta?.locale || null);
+
+  return {
+    installed: config.isOperaInstalled(controlState),
+    version: controlState.meta?.opera?.version || null,
+    model: controlState.meta?.opera?.model || null,
+    stableTag: controlState.meta?.opera?.stableTag || null,
+    contractVersion: controlState.meta?.opera?.contractVersion || null,
+    contractReadiness: controlState.meta?.opera?.contractReadiness || qualityReport?.contractReadiness || "hypothesis",
+    qualityStatus: controlState.meta?.opera?.qualityStatus || qualityReport?.status || null,
+    qualityReport,
+    legacyStatus: controlState.meta?.opera?.legacyStatus || bootstrapState?.status || "supported",
+    localeSource: localeDoctor.source,
+    bootstrap: bootstrapState,
+    contractFile: context.paths.contractFile,
+    policyFile: context.paths.autonomyPolicyFile,
+  };
+}
+
 function getStatePayload(projectRef) {
   const project = resolveProjectEntry(projectRef);
   const api = loadControlApi(project.root);
   const controlState = api.loadControl();
   const runtime = api.refreshRepoRuntime({ quiet: true });
   const envState = env.auditEnvironment(project.root, controlState);
+  const operaState = buildOperaState(project.root, controlState);
 
   return {
     project,
@@ -378,6 +416,7 @@ function getStatePayload(projectRef) {
     derived: api.derive(controlState),
     runtime,
     env: envState,
+    opera: operaState,
     docsDirty: api.getDocDrift(controlState),
     i18n: buildI18nPayload(controlState),
     generatedAt: new Date().toISOString(),
@@ -611,18 +650,23 @@ async function handleApi(req, res, url) {
       if (!body.root) { sendJson(res, 400, { ok: false, error: "Project path required." }); return; }
       try {
         const initMod = require("./init");
-        const result = initMod.initProject(body.root, { locale: body.locale || null });
-        if (body.withOpera) {
-          const opera = require("./opera");
-          await opera.install(result.root, {
-            locale: body.locale || null,
-            bootstrap: body.bootstrap !== false,
-            interactive: false,
-            answers: body.bootstrapAnswers || {},
-          });
-        }
-        const project = registry.registerProject(result.root);
-        sendJson(res, 201, { ok: true, project, projects: registry.listProjects() });
+        const result = initMod.initProject(body.root, { locale: body.locale || null });
+        if (body.withOpera) {
+          const opera = require("./opera");
+          await opera.install(result.root, {
+            locale: body.locale || null,
+            bootstrap: body.bootstrap !== false,
+            interactive: false,
+            answers: body.bootstrapAnswers || {},
+            bootstrapMode: body.bootstrapMode || "auto",
+            technicalLevel: body.technicalLevel || null,
+            projectState: body.projectState || null,
+            docsState: body.docsState || null,
+            decisionOwnership: body.decisionOwnership || null,
+          });
+        }
+        const project = registry.registerProject(result.root);
+        sendJson(res, 201, { ok: true, project, projects: registry.listProjects() });
       } catch (err) {
         sendJson(res, 500, { ok: false, error: err.message });
       }
@@ -706,8 +750,94 @@ async function handleApi(req, res, url) {
       sendJson(res, 200, result);
       return;
     }
-
-    if (req.method === "POST" && url.pathname === "/api/commands") {
+
+    if (req.method === "GET" && url.pathname === "/api/opera/bootstrap") {
+      const project = resolveProjectEntry(url.searchParams.get("project"));
+      const api = loadControlApi(project.root);
+      const controlState = api.loadControl();
+      const operaState = buildOperaState(project.root, controlState);
+      const bootstrap = operaState.bootstrap;
+      sendJson(res, 200, {
+        ok: true,
+        mode: bootstrap.mode || null,
+        status: bootstrap.status || "awaiting_intake",
+        technicalLevel: bootstrap.technicalLevel || null,
+        projectState: bootstrap.projectState || null,
+        documentationState: bootstrap.documentationState || null,
+        decisionOwnership: bootstrap.decisionOwnership || null,
+        handoffFiles: bootstrap.handoffFiles || null,
+        intakeFiles: bootstrap.intakeFiles || null,
+        reviewFiles: bootstrap.reviewFiles || null,
+        contractVersion: operaState.contractVersion,
+        contractReadiness: operaState.contractReadiness,
+        legacyStatus: operaState.legacyStatus,
+        qualityReport: operaState.qualityReport,
+      });
+      return;
+    }
+
+    if (req.method === "GET" && url.pathname === "/api/opera/handoff") {
+      const project = resolveProjectEntry(url.searchParams.get("project"));
+      const context = config.ensureContext(project.root);
+      const operaBootstrap = require("./opera-bootstrap");
+      const files = operaBootstrap.bootstrapFilePaths(context);
+      let handoffJson = null;
+      if (fs.existsSync(files.json)) {
+        try {
+          handoffJson = JSON.parse(fs.readFileSync(files.json, "utf8"));
+        } catch (_error) {
+          handoffJson = null;
+        }
+      }
+      sendJson(res, 200, {
+        ok: true,
+        markdownFile: files.markdown,
+        jsonFile: files.json,
+        openQuestionsFile: files.openQuestions,
+        qualityReportFile: files.qualityReport,
+        markdown: fs.existsSync(files.markdown) ? fs.readFileSync(files.markdown, "utf8") : "",
+        json: handoffJson,
+        openQuestions: fs.existsSync(files.openQuestions) ? fs.readFileSync(files.openQuestions, "utf8") : "",
+        qualityReport: readJsonFileSafe(files.qualityReport),
+      });
+      return;
+    }
+
+    if (req.method === "POST" && url.pathname === "/api/opera/bootstrap/intake") {
+      const body = await parseBody(req);
+      const project = resolveProjectEntry(body.projectId || body.project || url.searchParams.get("project"));
+      const opera = require("./opera");
+      const profile = await opera.runBootstrap(project.root, {
+        interactive: false,
+        bootstrapMode: body.bootstrapMode || "auto",
+        technicalLevel: body.technicalLevel || null,
+        projectState: body.projectState || null,
+        docsState: body.documentationState || body.docsState || null,
+        decisionOwnership: body.decisionOwnership || null,
+        answers: body.answers || {},
+      });
+      sendJson(res, 200, { ok: true, profile, state: getStatePayload(project.id) });
+      return;
+    }
+
+    if (req.method === "GET" && url.pathname === "/api/opera/status") {
+      const project = resolveProjectEntry(url.searchParams.get("project"));
+      const api = loadControlApi(project.root);
+      const controlState = api.loadControl();
+      sendJson(res, 200, { ok: true, ...buildOperaState(project.root, controlState) });
+      return;
+    }
+
+    if (req.method === "POST" && url.pathname === "/api/opera/bootstrap/resume") {
+      const body = await parseBody(req);
+      const project = resolveProjectEntry(body.projectId || body.project || url.searchParams.get("project"));
+      const opera = require("./opera");
+      const profile = await opera.runBootstrap(project.root, { interactive: false, resume: true });
+      sendJson(res, 200, { ok: true, profile, state: getStatePayload(project.id) });
+      return;
+    }
+
+    if (req.method === "POST" && url.pathname === "/api/commands") {
       const body = await parseBody(req);
       const project = resolveProjectEntry(body.projectId || body.project || url.searchParams.get("project"));
       const commandText = String(body.command || "").trim();
@@ -831,7 +961,7 @@ async function handleApi(req, res, url) {
       const catalog = [
         { id: "changelog-updater", title: "Changelog Updater", description: "Mantiene automatizado el CHANGELOG basado en commits.", url: "https://skills.sh/changelog-updater.md" },
         { id: "commiter", title: "Git Commiter", description: "Genera mensajes de commit strictos siguiendo Conventional Commits y Emojis.", url: "https://skills.sh/commiter.md" },
-        { id: "project-starter-skill", title: "Project Starter", description: "Skill para inicializar proyectos usando el protocolo O.P.E.R.A.", url: "https://skills.sh/project-starter.md" },
+        { id: "project-starter-skill", title: "Project Starter", description: "Skill para discovery y estructuracion inicial guiada con TrackOps y OPERA.", url: "https://skills.sh/project-starter.md" },
         { id: "tdd-master", title: "TDD Master", description: "Fuerza el ciclo Red-Green-Refactor en las implementaciones.", url: "https://skills.sh/tdd-master.md" },
         { id: "e2e-tester", title: "E2E Tester", description: "Plantillas y comandos para frameworks de Test End-to-End.", url: "https://skills.sh/e2e-tester.md" }
       ];

package/locales/en.json

@@ -101,8 +101,58 @@
   "cli.next.stream": "stream",
   "cli.next.summary": "summary",
 
-  "cli.help.title": "Project operational control",
-  "cli.help.usage": "Usage:",
+  "cli.help.title": "Project operational control",
+  "cli.help.usage": "Usage:",
+  "cli.help.commands": "Commands:",
+  "cli.help.init.desc": "Initialize TrackOps in the current directory.",
+  "cli.help.workspace.desc": "Show or migrate the current workspace layout.",
+  "cli.help.env.desc": "Audit or sync the workspace .env contract.",
+  "cli.help.release.desc": "Publish the configured app/ branch snapshot.",
+  "cli.help.version.desc": "Print the installed TrackOps version.",
+  "cli.help.status.desc": "Show project state: focus, active phase, ready tasks, blockers, repo.",
+  "cli.help.next.desc": "Prioritized queue of next executable tasks.",
+  "cli.help.sync.desc": "Regenerate task_plan.md, progress.md and findings.md from project_control.json.",
+  "cli.help.dashboard.desc": "Launch the local web dashboard on a free port and print local/network URLs.",
+  "cli.help.refreshRepo.desc": "Update the repo runtime snapshot with git state.",
+  "cli.help.installHooks.desc": "Configure git core.hooksPath to use the TrackOps hooks directory.",
+  "cli.help.register.desc": "Register the current project in the multi-project portfolio.",
+  "cli.help.projects.desc": "List registered projects.",
+  "cli.help.task.desc": "Actions: start, review, complete, block, pending, cancel, note.",
+  "cli.help.opera.desc": "Manage OPERA.",
+  "cli.help.opera.upgradeHint": "Upgrade: trackops opera upgrade --stable [--reset]",
+  "cli.help.locale.desc": "Show or update the global TrackOps language.",
+  "cli.help.doctor.desc": "Explain the effective language source for this machine/project.",
+  "cli.help.skill.desc": "Manage skills.",
+  "cli.help.help.desc": "Show this help.",
+  "cli.help.globalWorkflow": "Global agent workflow:",
+  "cli.help.globalWorkflow.line1": "Install with 'npx skills add Baxahaun/trackops'",
+  "cli.help.globalWorkflow.line2": "and the global/agent flags you need; then use 'trackops init' and 'trackops opera install' explicitly inside each project.",
+  "cli.usage.workspace": "Usage: trackops workspace <status|migrate>",
+  "cli.usage.env": "Usage: trackops env <status|sync>",
+  "cli.usage.opera": "Usage: trackops opera <install|bootstrap|handoff|status|configure|upgrade>",
+  "cli.usage.skill": "Usage: trackops skill <install|list|remove|catalog> [name]",
+  "cli.usage.locale": "Usage: trackops locale <get|set> [es|en]",
+  "cli.usage.doctor": "Usage: trackops doctor locale",
+  "cli.error.unknownCommand": "Unknown command: {command}",
+  "cli.error.runHelp": "Run 'trackops help' for usage.",
+  "cli.error.noWorkspace": "No TrackOps workspace found in this directory or any parent.",
+  "locale.effective": "Effective language",
+  "locale.source": "Source",
+  "locale.global": "Global language",
+  "locale.project": "Project language",
+  "locale.env": "Environment language",
+  "locale.system": "System language",
+  "locale.runtimeFile": "Runtime file",
+  "locale.none": "none",
+  "locale.invalid": "Invalid locale: {value}.",
+  "locale.updated": "Global language updated to {locale}.",
+  "locale.source.explicit": "explicit flag",
+  "locale.source.project": "project",
+  "locale.source.global": "global",
+  "locale.source.env": "environment",
+  "locale.source.system": "system",
+  "locale.source.prompt": "prompt",
+  "locale.source.manual": "manual",
 
   "server.ready": "Ops dashboard ready at http://{host}:{port}",
   "server.bannerTitle": "Serving!",
@@ -138,11 +188,34 @@
   "init.defaultTaskTitle": "Set up project with trackops",
   "init.defaultTaskSummary": "Verify initial structure, adjust phases and confirm operational integration.",
 
-  "opera.installed": "OPERA methodology installed (v{version}).",
-  "opera.alreadyInstalled": "OPERA is already installed in this project (v{version}).",
-  "opera.notInstalled": "OPERA is not installed in this project.",
-  "opera.upgraded": "OPERA upgraded to v{version}.",
-  "opera.primitiveDetected": "Existing OPERA installation detected (not managed by Ops).",
+  "opera.installed": "OPERA methodology installed (v{version}).",
+  "opera.alreadyInstalled": "OPERA is already installed in this project (v{version}).",
+  "opera.notInstalled": "OPERA is not installed in this project.",
+  "opera.upgraded": "OPERA upgraded to v{version}.",
+  "opera.primitiveDetected": "Existing OPERA installation detected (not managed by Ops).",
+  "opera.status.version": "OPERA v{version}",
+  "opera.status.installed": "  Installed: {value}",
+  "opera.status.skills": "  Skills: {value}",
+  "opera.status.locale": "  Locale: {locale} ({source})",
+  "opera.status.legacy": "  Legacy: {value}",
+  "opera.status.contractVersion": "  Contract version: {value}",
+  "opera.status.contractReadiness": "  Contract readiness: {value}",
+  "opera.status.bootstrap": "  Bootstrap: {value}",
+  "opera.status.mode": "  Mode: {value}",
+  "opera.status.route": "  Route: {value}",
+  "opera.status.ownership": "  Ownership: {value}",
+  "opera.status.missing": "  Missing: {value}",
+  "opera.status.resume": "  Resume: trackops opera bootstrap --resume",
+  "opera.status.handoff": "  Handoff: {value}",
+  "opera.status.qualityReport": "  Quality report: {value}",
+  "opera.status.structure": "  Structure:",
+  "opera.configure.invalidPhases": "Invalid phases JSON.",
+  "opera.configure.updated": "Configuration updated.",
+  "opera.upgrade.runInstallFirst": "Run 'trackops opera install' first.",
+  "opera.upgrade.usage": "Usage: trackops opera upgrade --stable [--reset]",
+  "opera.upgrade.legacyUnsupported": "Legacy OPERA project detected. Run 'trackops opera upgrade --stable --reset' to move it to the current stable model.",
+  "opera.upgrade.backup": "Backup: {path}",
+  "postinstall.localeSet": "TrackOps set the language to '{locale}' ({source}).",
 
   "skill.installed": "Skill '{name}' installed.",
   "skill.removed": "Skill '{name}' uninstalled.",
@@ -154,35 +227,47 @@
 
   "cli.status.bootstrap": "Bootstrap: {status} | Locale: {locale}",
 
-  "bootstrap.header": "OPERA bootstrap",
-  "bootstrap.subtitle": "Confirm the core project context to turn OPERA from templates into a real operating framework.",
-  "bootstrap.question.desiredOutcome": "Desired outcome",
-  "bootstrap.question.externalServices": "External services (comma separated)",
-  "bootstrap.question.sourceOfTruth": "Source of truth",
-  "bootstrap.question.payload": "Delivery payload / target",
-  "bootstrap.question.behaviorRules": "Behavior rules (semicolon separated)",
+  "bootstrap.header": "OPERA bootstrap",
+  "bootstrap.subtitle": "Classify the user and the project first. TrackOps will decide whether to continue in the terminal or route discovery to the agent.",
+  "bootstrap.question.technicalLevel": "User technical level",
+  "bootstrap.question.projectState": "Current project state",
+  "bootstrap.question.docsState": "Available documentation",
+  "bootstrap.question.decisionOwnership": "Who should own key decisions",
+  "bootstrap.question.problemStatement": "Main problem to solve",
+  "bootstrap.question.targetUser": "Primary target user",
+  "bootstrap.question.desiredOutcome": "Desired outcome",
+  "bootstrap.question.externalServices": "External services (comma separated)",
+  "bootstrap.question.sourceOfTruth": "Source of truth",
+  "bootstrap.question.payload": "Delivery payload / target",
+  "bootstrap.question.behaviorRules": "Behavior rules (semicolon separated)",
   "bootstrap.question.inputSchema": "Input schema JSON",
   "bootstrap.question.outputSchema": "Output schema JSON",
   "bootstrap.question.invariants": "Architectural invariants (semicolon separated)",
   "bootstrap.question.pipeline": "Pipeline steps (semicolon separated)",
-  "bootstrap.question.templates": "Template files (comma separated)",
-  "bootstrap.question.repoTasks": "Include optional repo tasks? [y/n]",
-  "bootstrap.completed": "OPERA bootstrap completed.",
-  "bootstrap.pending": "OPERA bootstrap saved as pending. Resume with 'trackops opera bootstrap --resume'.",
-  "bootstrap.infer.envSourceHint": "Environment files detected",
-  "bootstrap.noneDefined": "Not defined yet.",
-  "bootstrap.pendingValue": "Pending definition.",
-  "bootstrap.servicePending": "pending",
-  "bootstrap.defaultFocus": "Complete OPERA bootstrap",
-  "bootstrap.defaultTarget": "Target delivery pending definition",
-  "bootstrap.blocker.missingData": "Core bootstrap data is still missing.",
-  "bootstrap.history.seeded": "Seeded by OPERA bootstrap.",
-  "bootstrap.acceptance.discovery": "Discovery questions answered.",
-  "bootstrap.acceptance.schema": "Input/output schema defined in genesis.md.",
-  "bootstrap.acceptance.rules": "Behavior rules documented.",
-  "bootstrap.acceptance.plan": "Plan reviewed and accepted.",
-  "bootstrap.acceptance.env": "Required credentials verified.",
-  "bootstrap.acceptance.tests": "Connectivity checks passing.",
+  "bootstrap.question.templates": "Template files (comma separated)",
+  "bootstrap.question.repoTasks": "Include optional repo tasks? [y/n]",
+  "bootstrap.completed": "OPERA bootstrap completed.",
+  "bootstrap.pending": "OPERA bootstrap saved as pending. Resume with 'trackops opera bootstrap --resume'.",
+  "bootstrap.awaitingAgent": "OPERA bootstrap has been routed to the agent. Complete the handoff and resume with 'trackops opera bootstrap --resume'.",
+  "bootstrap.handoffFile": "Handoff file",
+  "bootstrap.infer.envSourceHint": "Environment files detected",
+  "bootstrap.noneDefined": "Not defined yet.",
+  "bootstrap.pendingValue": "Pending definition.",
+  "bootstrap.servicePending": "pending",
+  "bootstrap.defaultFocus": "Complete OPERA bootstrap",
+  "bootstrap.defaultTarget": "Target delivery pending definition",
+  "bootstrap.blocker.missingData": "Core bootstrap data is still missing.",
+  "bootstrap.blocker.awaitingAgent": "Waiting for the agent handoff output.",
+  "bootstrap.history.seeded": "Seeded by OPERA bootstrap.",
+  "bootstrap.acceptance.discovery": "Discovery questions answered.",
+  "bootstrap.acceptance.schema": "Input/output schema defined in genesis.md.",
+  "bootstrap.acceptance.rules": "Behavior rules documented.",
+  "bootstrap.acceptance.plan": "Plan reviewed and accepted.",
+  "bootstrap.acceptance.intake": "The agent generated ops/bootstrap/intake.json.",
+  "bootstrap.acceptance.specDossier": "The agent generated ops/bootstrap/spec-dossier.md.",
+  "bootstrap.acceptance.resume": "OPERA ingested the context and continued.",
+  "bootstrap.acceptance.env": "Required credentials verified.",
+  "bootstrap.acceptance.tests": "Connectivity checks passing.",
   "bootstrap.acceptance.shape": "External shapes validated against genesis.md.",
   "bootstrap.acceptance.findings": "Findings documented.",
   "bootstrap.acceptance.sops": "SOPs documented.",
@@ -196,9 +281,10 @@
   "bootstrap.acceptance.deploy": "Deployment completed.",
   "bootstrap.acceptance.triggers": "Triggers configured.",
   "bootstrap.acceptance.smoke": "Smoke test passing.",
-  "bootstrap.task.bootstrap.title": "Complete OPERA bootstrap",
-  "bootstrap.task.bootstrap.summary": "Turn the installed OPERA structure into a project-specific operating model.",
-  "bootstrap.task.prove.title": "Validate integrations",
+  "bootstrap.task.bootstrap.title": "Complete OPERA bootstrap",
+  "bootstrap.task.bootstrap.summary": "Turn the installed OPERA structure into a project-specific operating model.",
+  "bootstrap.task.bootstrap.handoffSummary": "Prepare the agent handoff so an idea or partial specification becomes structured operational context.",
+  "bootstrap.task.prove.title": "Validate integrations",
   "bootstrap.task.prove.summary": "Verify credentials, connectivity, and response shapes before building further.",
   "bootstrap.task.structure.title": "Structure the system",
   "bootstrap.task.structure.summary": "Document SOPs, implement tools, and capture the dependency graph.",
@@ -214,13 +300,21 @@
   "bootstrap.task.repoChangelog.summary": "Decide how CHANGELOG.md should be maintained in this project.",
   "bootstrap.task.repoGithub.title": "Review GitHub governance tasks",
   "bootstrap.task.repoGithub.summary": "Check whether repository automation or governance tasks should be enabled.",
-  "bootstrap.field.desiredOutcome": "Desired outcome",
-  "bootstrap.field.sourceOfTruth": "Source of truth",
-  "bootstrap.field.payload": "Payload",
-  "bootstrap.field.inputSchema": "Input schema",
-  "bootstrap.field.outputSchema": "Output schema",
-  "bootstrap.decisionImpact": "Required to complete the OPERA bootstrap.",
-  "bootstrap.finding.genesisConflictTitle": "Genesis requires manual review",
+  "bootstrap.field.singularDesiredOutcome": "Desired outcome",
+  "bootstrap.field.desiredOutcome": "Desired outcome",
+  "bootstrap.field.problemStatement": "Problem statement",
+  "bootstrap.field.targetUser": "Target user",
+  "bootstrap.field.decisionOwnership": "Decision ownership",
+  "bootstrap.field.sourceOfTruth": "Source of truth",
+  "bootstrap.field.payload": "Payload",
+  "bootstrap.field.inputSchema": "Input schema",
+  "bootstrap.field.outputSchema": "Output schema",
+  "bootstrap.field.intakeJson": "intake.json file",
+  "bootstrap.field.specDossier": "spec-dossier.md file",
+  "bootstrap.decisionImpact": "Required to complete the OPERA bootstrap.",
+  "bootstrap.pendingDecision.handoff": "Send the TrackOps handoff to the agent",
+  "bootstrap.pendingDecision.handoffImpact": "Required so the agent can generate intake.json and spec-dossier.md.",
+  "bootstrap.finding.genesisConflictTitle": "Genesis requires manual review",
   "bootstrap.finding.genesisConflictDetail": "TrackOps detected a non-template genesis.md and stopped automatic overwrite.",
   "bootstrap.finding.genesisConflictImpact": "Bootstrap cannot be completed until the existing constitution is reviewed.",