trackops 1.1.0 → 2.0.0

package/locales/es.json

@@ -101,8 +101,58 @@
   "cli.next.stream": "stream",
   "cli.next.summary": "resumen",
 
-  "cli.help.title": "Control operativo del proyecto",
-  "cli.help.usage": "Uso:",
+  "cli.help.title": "Control operativo del proyecto",
+  "cli.help.usage": "Uso:",
+  "cli.help.commands": "Comandos:",
+  "cli.help.init.desc": "Inicializa TrackOps en el directorio actual.",
+  "cli.help.workspace.desc": "Muestra o migra el layout actual del workspace.",
+  "cli.help.env.desc": "Audita o sincroniza el contrato .env del workspace.",
+  "cli.help.release.desc": "Publica el snapshot configurado de app/.",
+  "cli.help.version.desc": "Imprime la version instalada de TrackOps.",
+  "cli.help.status.desc": "Muestra el estado del proyecto: foco, fase activa, tareas listas, bloqueadores y repo.",
+  "cli.help.next.desc": "Cola priorizada de siguientes tareas ejecutables.",
+  "cli.help.sync.desc": "Regenera task_plan.md, progress.md y findings.md desde project_control.json.",
+  "cli.help.dashboard.desc": "Lanza el dashboard web local en un puerto libre e imprime URLs local/red.",
+  "cli.help.refreshRepo.desc": "Actualiza el snapshot runtime del repo con el estado git.",
+  "cli.help.installHooks.desc": "Configura git core.hooksPath para usar el directorio de hooks de TrackOps.",
+  "cli.help.register.desc": "Registra el proyecto actual en el portfolio multiproyecto.",
+  "cli.help.projects.desc": "Lista los proyectos registrados.",
+  "cli.help.task.desc": "Acciones: start, review, complete, block, pending, cancel, note.",
+  "cli.help.opera.desc": "Gestiona OPERA.",
+  "cli.help.opera.upgradeHint": "Upgrade: trackops opera upgrade --stable [--reset]",
+  "cli.help.locale.desc": "Muestra o actualiza el idioma global de TrackOps.",
+  "cli.help.doctor.desc": "Explica el origen efectivo del idioma para esta maquina/proyecto.",
+  "cli.help.skill.desc": "Gestiona skills.",
+  "cli.help.help.desc": "Muestra esta ayuda.",
+  "cli.help.globalWorkflow": "Flujo global del agente:",
+  "cli.help.globalWorkflow.line1": "Instala con 'npx skills add Baxahaun/trackops'",
+  "cli.help.globalWorkflow.line2": "y los flags globales/de agente que necesites; despues usa 'trackops init' y 'trackops opera install' de forma explicita dentro de cada proyecto.",
+  "cli.usage.workspace": "Uso: trackops workspace <status|migrate>",
+  "cli.usage.env": "Uso: trackops env <status|sync>",
+  "cli.usage.opera": "Uso: trackops opera <install|bootstrap|handoff|status|configure|upgrade>",
+  "cli.usage.skill": "Uso: trackops skill <install|list|remove|catalog> [name]",
+  "cli.usage.locale": "Uso: trackops locale <get|set> [es|en]",
+  "cli.usage.doctor": "Uso: trackops doctor locale",
+  "cli.error.unknownCommand": "Comando desconocido: {command}",
+  "cli.error.runHelp": "Ejecuta 'trackops help' para ver el uso.",
+  "cli.error.noWorkspace": "No se encontro ningun workspace TrackOps en este directorio ni en sus padres.",
+  "locale.effective": "Idioma efectivo",
+  "locale.source": "Origen",
+  "locale.global": "Idioma global",
+  "locale.project": "Idioma del proyecto",
+  "locale.env": "Idioma por entorno",
+  "locale.system": "Idioma del sistema",
+  "locale.runtimeFile": "Archivo runtime",
+  "locale.none": "ninguno",
+  "locale.invalid": "Idioma invalido: {value}.",
+  "locale.updated": "Idioma global actualizado a {locale}.",
+  "locale.source.explicit": "flag explicito",
+  "locale.source.project": "proyecto",
+  "locale.source.global": "global",
+  "locale.source.env": "entorno",
+  "locale.source.system": "sistema",
+  "locale.source.prompt": "prompt",
+  "locale.source.manual": "manual",
 
   "server.ready": "Ops dashboard listo en http://{host}:{port}",
   "server.bannerTitle": "Serving!",
@@ -138,11 +188,34 @@
   "init.defaultTaskTitle": "Configurar proyecto con trackops",
   "init.defaultTaskSummary": "Verificar estructura inicial, ajustar fases y confirmar integracion operativa.",
 
-  "opera.installed": "Metodologia OPERA instalada (v{version}).",
-  "opera.alreadyInstalled": "OPERA ya esta instalado en este proyecto (v{version}).",
-  "opera.notInstalled": "OPERA no esta instalado en este proyecto.",
-  "opera.upgraded": "OPERA actualizado a v{version}.",
-  "opera.primitiveDetected": "Detectada instalacion OPERA existente (sin gestion por Ops).",
+  "opera.installed": "Metodologia OPERA instalada (v{version}).",
+  "opera.alreadyInstalled": "OPERA ya esta instalado en este proyecto (v{version}).",
+  "opera.notInstalled": "OPERA no esta instalado en este proyecto.",
+  "opera.upgraded": "OPERA actualizado a v{version}.",
+  "opera.primitiveDetected": "Detectada instalacion OPERA existente (sin gestion por Ops).",
+  "opera.status.version": "OPERA v{version}",
+  "opera.status.installed": "  Instalado: {value}",
+  "opera.status.skills": "  Skills: {value}",
+  "opera.status.locale": "  Idioma: {locale} ({source})",
+  "opera.status.legacy": "  Legacy: {value}",
+  "opera.status.contractVersion": "  Version de contrato: {value}",
+  "opera.status.contractReadiness": "  Readiness del contrato: {value}",
+  "opera.status.bootstrap": "  Bootstrap: {value}",
+  "opera.status.mode": "  Modo: {value}",
+  "opera.status.route": "  Ruta: {value}",
+  "opera.status.ownership": "  Ownership: {value}",
+  "opera.status.missing": "  Faltan: {value}",
+  "opera.status.resume": "  Reanudar: trackops opera bootstrap --resume",
+  "opera.status.handoff": "  Handoff: {value}",
+  "opera.status.qualityReport": "  Quality report: {value}",
+  "opera.status.structure": "  Estructura:",
+  "opera.configure.invalidPhases": "JSON de fases invalido.",
+  "opera.configure.updated": "Configuracion actualizada.",
+  "opera.upgrade.runInstallFirst": "Ejecuta 'trackops opera install' primero.",
+  "opera.upgrade.usage": "Uso: trackops opera upgrade --stable [--reset]",
+  "opera.upgrade.legacyUnsupported": "Proyecto OPERA legacy detectado. Ejecuta 'trackops opera upgrade --stable --reset' para moverlo al modelo estable actual.",
+  "opera.upgrade.backup": "Backup: {path}",
+  "postinstall.localeSet": "TrackOps ha fijado el idioma en '{locale}' ({source}).",
 
   "skill.installed": "Skill '{name}' instalada.",
   "skill.removed": "Skill '{name}' desinstalada.",
@@ -154,35 +227,47 @@
 
   "cli.status.bootstrap": "Bootstrap: {status} | Idioma: {locale}",
 
-  "bootstrap.header": "Bootstrap OPERA",
-  "bootstrap.subtitle": "Confirma el contexto real del proyecto para convertir OPERA en un framework operativo de verdad.",
-  "bootstrap.question.desiredOutcome": "Resultado singular deseado",
-  "bootstrap.question.externalServices": "Servicios externos (separados por comas)",
-  "bootstrap.question.sourceOfTruth": "Fuente de la verdad",
-  "bootstrap.question.payload": "Payload / objetivo de entrega",
-  "bootstrap.question.behaviorRules": "Reglas de comportamiento (separadas por punto y coma)",
+  "bootstrap.header": "Bootstrap OPERA",
+  "bootstrap.subtitle": "Primero clasifica al usuario y el estado del proyecto. TrackOps decidira si continuar por terminal o derivar el arranque al agente.",
+  "bootstrap.question.technicalLevel": "Nivel tecnico del usuario",
+  "bootstrap.question.projectState": "Estado actual del proyecto",
+  "bootstrap.question.docsState": "Documentacion disponible",
+  "bootstrap.question.decisionOwnership": "Quien debe tomar las decisiones clave",
+  "bootstrap.question.problemStatement": "Problema principal que se quiere resolver",
+  "bootstrap.question.targetUser": "Usuario objetivo principal",
+  "bootstrap.question.desiredOutcome": "Resultado singular deseado",
+  "bootstrap.question.externalServices": "Servicios externos (separados por comas)",
+  "bootstrap.question.sourceOfTruth": "Fuente de la verdad",
+  "bootstrap.question.payload": "Payload / objetivo de entrega",
+  "bootstrap.question.behaviorRules": "Reglas de comportamiento (separadas por punto y coma)",
   "bootstrap.question.inputSchema": "Schema JSON de entrada",
   "bootstrap.question.outputSchema": "Schema JSON de salida",
   "bootstrap.question.invariants": "Invariantes arquitectonicas (separadas por punto y coma)",
   "bootstrap.question.pipeline": "Pasos del pipeline (separados por punto y coma)",
-  "bootstrap.question.templates": "Archivos template (separados por comas)",
-  "bootstrap.question.repoTasks": "¿Incluir tareas opcionales de repo? [y/n]",
-  "bootstrap.completed": "Bootstrap OPERA completado.",
-  "bootstrap.pending": "Bootstrap OPERA guardado como pendiente. Reanuda con 'trackops opera bootstrap --resume'.",
-  "bootstrap.infer.envSourceHint": "Detectados archivos de entorno",
-  "bootstrap.noneDefined": "Aun no definido.",
-  "bootstrap.pendingValue": "Pendiente de definir.",
-  "bootstrap.servicePending": "pendiente",
-  "bootstrap.defaultFocus": "Completar bootstrap OPERA",
-  "bootstrap.defaultTarget": "Entrega objetivo pendiente de definir",
-  "bootstrap.blocker.missingData": "Todavia faltan datos clave del bootstrap.",
-  "bootstrap.history.seeded": "Sembrada por bootstrap OPERA.",
-  "bootstrap.acceptance.discovery": "Preguntas de descubrimiento respondidas.",
-  "bootstrap.acceptance.schema": "Schema de entrada/salida definido en genesis.md.",
-  "bootstrap.acceptance.rules": "Reglas de comportamiento documentadas.",
-  "bootstrap.acceptance.plan": "Plan revisado y aceptado.",
-  "bootstrap.acceptance.env": "Credenciales requeridas verificadas.",
-  "bootstrap.acceptance.tests": "Checks de conectividad pasando.",
+  "bootstrap.question.templates": "Archivos template (separados por comas)",
+  "bootstrap.question.repoTasks": "¿Incluir tareas opcionales de repo? [y/n]",
+  "bootstrap.completed": "Bootstrap OPERA completado.",
+  "bootstrap.pending": "Bootstrap OPERA guardado como pendiente. Reanuda con 'trackops opera bootstrap --resume'.",
+  "bootstrap.awaitingAgent": "Bootstrap OPERA derivado al agente. Completa el handoff y reanuda con 'trackops opera bootstrap --resume'.",
+  "bootstrap.handoffFile": "Archivo de handoff",
+  "bootstrap.infer.envSourceHint": "Detectados archivos de entorno",
+  "bootstrap.noneDefined": "Aun no definido.",
+  "bootstrap.pendingValue": "Pendiente de definir.",
+  "bootstrap.servicePending": "pendiente",
+  "bootstrap.defaultFocus": "Completar bootstrap OPERA",
+  "bootstrap.defaultTarget": "Entrega objetivo pendiente de definir",
+  "bootstrap.blocker.missingData": "Todavia faltan datos clave del bootstrap.",
+  "bootstrap.blocker.awaitingAgent": "Esperando el resultado del handoff al agente.",
+  "bootstrap.history.seeded": "Sembrada por bootstrap OPERA.",
+  "bootstrap.acceptance.discovery": "Preguntas de descubrimiento respondidas.",
+  "bootstrap.acceptance.schema": "Schema de entrada/salida definido en genesis.md.",
+  "bootstrap.acceptance.rules": "Reglas de comportamiento documentadas.",
+  "bootstrap.acceptance.plan": "Plan revisado y aceptado.",
+  "bootstrap.acceptance.intake": "El agente genero ops/bootstrap/intake.json.",
+  "bootstrap.acceptance.specDossier": "El agente genero ops/bootstrap/spec-dossier.md.",
+  "bootstrap.acceptance.resume": "OPERA pudo ingerir el contexto y continuar.",
+  "bootstrap.acceptance.env": "Credenciales requeridas verificadas.",
+  "bootstrap.acceptance.tests": "Checks de conectividad pasando.",
   "bootstrap.acceptance.shape": "Shapes externos validados contra genesis.md.",
   "bootstrap.acceptance.findings": "Hallazgos documentados.",
   "bootstrap.acceptance.sops": "SOPs documentados.",
@@ -196,9 +281,10 @@
   "bootstrap.acceptance.deploy": "Despliegue completado.",
   "bootstrap.acceptance.triggers": "Triggers configurados.",
   "bootstrap.acceptance.smoke": "Smoke test pasando.",
-  "bootstrap.task.bootstrap.title": "Completar bootstrap OPERA",
-  "bootstrap.task.bootstrap.summary": "Convertir la estructura OPERA instalada en un modelo operativo especifico del proyecto.",
-  "bootstrap.task.prove.title": "Validar integraciones",
+  "bootstrap.task.bootstrap.title": "Completar bootstrap OPERA",
+  "bootstrap.task.bootstrap.summary": "Convertir la estructura OPERA instalada en un modelo operativo especifico del proyecto.",
+  "bootstrap.task.bootstrap.handoffSummary": "Preparar el handoff al agente para convertir una idea o especificacion parcial en contexto operativo estructurado.",
+  "bootstrap.task.prove.title": "Validar integraciones",
   "bootstrap.task.prove.summary": "Verificar credenciales, conectividad y shape de respuestas antes de seguir construyendo.",
   "bootstrap.task.structure.title": "Estructurar el sistema",
   "bootstrap.task.structure.summary": "Documentar SOPs, implementar herramientas y capturar el grafo de dependencias.",
@@ -214,13 +300,21 @@
   "bootstrap.task.repoChangelog.summary": "Decidir como se mantendra CHANGELOG.md en este proyecto.",
   "bootstrap.task.repoGithub.title": "Revisar tareas de gobernanza GitHub",
   "bootstrap.task.repoGithub.summary": "Comprobar si deben activarse tareas de automatizacion o gobernanza del repositorio.",
-  "bootstrap.field.desiredOutcome": "Resultado deseado",
-  "bootstrap.field.sourceOfTruth": "Fuente de la verdad",
-  "bootstrap.field.payload": "Payload",
-  "bootstrap.field.inputSchema": "Schema de entrada",
-  "bootstrap.field.outputSchema": "Schema de salida",
-  "bootstrap.decisionImpact": "Necesario para completar el bootstrap OPERA.",
-  "bootstrap.finding.genesisConflictTitle": "Genesis requiere revision manual",
+  "bootstrap.field.singularDesiredOutcome": "Resultado deseado",
+  "bootstrap.field.desiredOutcome": "Resultado deseado",
+  "bootstrap.field.problemStatement": "Problema principal",
+  "bootstrap.field.targetUser": "Usuario objetivo",
+  "bootstrap.field.decisionOwnership": "Propiedad de decision",
+  "bootstrap.field.sourceOfTruth": "Fuente de la verdad",
+  "bootstrap.field.payload": "Payload",
+  "bootstrap.field.inputSchema": "Schema de entrada",
+  "bootstrap.field.outputSchema": "Schema de salida",
+  "bootstrap.field.intakeJson": "Archivo intake.json",
+  "bootstrap.field.specDossier": "Archivo spec-dossier.md",
+  "bootstrap.decisionImpact": "Necesario para completar el bootstrap OPERA.",
+  "bootstrap.pendingDecision.handoff": "Enviar el handoff de TrackOps al agente",
+  "bootstrap.pendingDecision.handoffImpact": "Necesario para que el agente genere intake.json y spec-dossier.md.",
+  "bootstrap.finding.genesisConflictTitle": "Genesis requiere revision manual",
   "bootstrap.finding.genesisConflictDetail": "TrackOps detecto un genesis.md no plantilla y detuvo la sobreescritura automatica.",
   "bootstrap.finding.genesisConflictImpact": "El bootstrap no puede completarse hasta revisar la constitucion existente.",
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trackops",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "description": "Operational project control with task management, document generation, multi-project dashboard, and optional OPERA methodology",
   "main": "lib/control.js",
   "bin": {
@@ -47,6 +47,7 @@
     "node": ">=18"
   },
   "scripts": {
+    "postinstall": "node scripts/postinstall-locale.js",
     "test": "node scripts/smoke-tests.js",
     "test:smoke": "node scripts/smoke-tests.js",
     "skill:sync-version": "node scripts/sync-skill-version.js",

package/scripts/postinstall-locale.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+
+const runtimeState = require("../lib/runtime-state");
+const { setLocale, t } = require("../lib/i18n");
+
+function isGlobalInstall() {
+  return String(process.env.npm_config_global || "").toLowerCase() === "true";
+}
+
+async function main() {
+  if (!isGlobalInstall()) return;
+  const result = await runtimeState.ensureGlobalLocale({ interactive: true });
+  if (!result?.locale) return;
+  setLocale(result.locale);
+  process.stdout.write(`${t("postinstall.localeSet", { locale: result.locale, source: t(`locale.source.${result.source}`) })}\n`);
+}
+
+main().catch((error) => {
+  process.stderr.write(`${error.message}\n`);
+  process.exit(0);
+});

package/scripts/smoke-tests.js

@@ -231,6 +231,7 @@ async function main() {
   assert.strictEqual(runtimeStamp.runtimeVersion, packageVersion);
   assert.strictEqual(runtimeStamp.skill, "trackops");
   assert.strictEqual(runtimeStamp.bootstrapPolicy, "first_use");
+  assert.ok(["es", "en"].includes(runtimeStamp.locale), "el bootstrap global debe fijar un idioma");
 
   const installedCli = path.join(bootstrapPrefix, "node_modules", "trackops", "bin", "trackops.js");
   assert.ok(fs.existsSync(installedCli), "el runtime instalado debe existir dentro del prefijo aislado");
@@ -256,9 +257,15 @@ async function main() {
   const versionOutput = runNode([BIN, "--version"], ROOT);
   assert.strictEqual(versionOutput.trim(), packageVersion);
 
+  runNode([BIN, "locale", "set", "en"], tempRoot, { TRACKOPS_BOOTSTRAP_HOME: bootstrapHome });
+  const localeGet = runNode([BIN, "locale", "get"], tempRoot, { TRACKOPS_BOOTSTRAP_HOME: bootstrapHome });
+  assert.match(localeGet, /Effective language: en|Idioma efectivo: en/);
+  const localeDoctor = runNode([BIN, "doctor", "locale"], tempRoot, { TRACKOPS_BOOTSTRAP_HOME: bootstrapHome });
+  assert.match(localeDoctor, /Source: global|Origen: global/);
+
   const splitProject = path.join(tempRoot, "split-demo");
   fs.mkdirSync(splitProject, { recursive: true });
-  runNode([BIN, "init"], splitProject);
+  runNode([BIN, "init", "--locale", "es"], splitProject, { TRACKOPS_BOOTSTRAP_HOME: bootstrapHome });
 
   assert.ok(fs.existsSync(path.join(splitProject, ".trackops-workspace.json")));
   assert.ok(fs.existsSync(path.join(splitProject, ".env")));
@@ -273,6 +280,11 @@ async function main() {
   const splitControl = readJson(path.join(splitProject, "ops", "project_control.json"));
   assert.strictEqual(splitControl.meta.workspace.layout, "split");
   assert.strictEqual(splitControl.meta.environment.rootEnvFile, ".env");
+  assert.strictEqual(splitControl.meta.locale, "es");
+
+  const projectLocaleDoctor = runNode([BIN, "doctor", "locale"], splitProject, { TRACKOPS_BOOTSTRAP_HOME: bootstrapHome });
+  assert.match(projectLocaleDoctor, /Project language: es|Idioma del proyecto: es/);
+  assert.match(projectLocaleDoctor, /Source: project|Origen: proyecto/);
 
   const statusFromWorkspace = runNode([BIN, "status"], splitProject);
   const statusFromApp = runNode([BIN, "status"], path.join(splitProject, "app"));
@@ -311,27 +323,113 @@ async function main() {
   assert.ok(fs.existsSync(path.join(splitProject, "ops", "genesis.md")));
   assert.ok(fs.existsSync(path.join(splitProject, "ops", ".agent", "hub", "agent.md")));
   assert.ok(fs.existsSync(path.join(splitProject, "ops", ".agents", "skills", "_registry.md")));
+  assert.ok(fs.existsSync(path.join(splitProject, "ops", "bootstrap", "agent-handoff.md")));
+  assert.ok(fs.existsSync(path.join(splitProject, "ops", "bootstrap", "agent-handoff.json")));
+  assert.ok(fs.existsSync(path.join(splitProject, "ops", "bootstrap", "open-questions.md")));
+  assert.ok(fs.existsSync(path.join(splitProject, "ops", "architecture", "runtime-operations.md")));
+  assert.ok(fs.existsSync(path.join(splitProject, "ops", "architecture", "dependency-graph.md")));
+  assert.ok(fs.existsSync(path.join(splitProject, "ops", "architecture", "runtime-automation.md")));
+  assert.ok(fs.existsSync(path.join(splitProject, "ops", "policy", "autonomy.json")));
+  assert.ok(fs.existsSync(path.join(splitProject, "ops", "reviews", "integration-audit.md")));
+  assert.ok(fs.existsSync(path.join(splitProject, "ops", "reviews", "delivery-audit.md")));
   assert.ok(!fs.existsSync(path.join(splitProject, "genesis.md")));
 
   const operaControl = readJson(path.join(splitProject, "ops", "project_control.json"));
   assert.strictEqual(operaControl.meta.locale, "en");
   assert.strictEqual(operaControl.meta.opera.installed, true);
+  assert.strictEqual(operaControl.meta.opera.bootstrap.mode, "agent_handoff");
+  assert.strictEqual(operaControl.meta.opera.bootstrap.status, "awaiting_agent");
+  assert.ok(operaControl.meta.opera.skills.includes("project-starter-skill"));
+  assert.ok(operaControl.meta.opera.skills.includes("opera-contract-auditor"));
+  assert.ok(operaControl.meta.opera.skills.includes("opera-policy-guard"));
   assert.ok(operaControl.meta.environment.requiredKeys.includes("OPENAI_API_KEY"));
   const envRootText = fs.readFileSync(path.join(splitProject, ".env"), "utf8");
   assert.match(envRootText, /OPENAI_API_KEY=/);
 
-  const defaultPortFree = await isPortFree(4173);
+  const handoffPrint = runNode([BIN, "opera", "handoff", "--print"], splitProject);
+  assert.match(handoffPrint, /project-starter-skill/);
+  const handoffJson = JSON.parse(runNode([BIN, "opera", "handoff", "--json"], splitProject));
+  assert.strictEqual(handoffJson.skill, "project-starter-skill");
+
+  const directProject = path.join(tempRoot, "direct-demo");
+  fs.mkdirSync(directProject, { recursive: true });
+  runNode([BIN, "init", "--locale", "en"], directProject, { TRACKOPS_BOOTSTRAP_HOME: bootstrapHome });
+  writeJson(path.join(directProject, "app", "package.json"), { name: "direct-demo", version: "1.0.0" });
+  runNode([
+    BIN,
+    "opera",
+    "install",
+    "--locale",
+    "en",
+    "--non-interactive",
+    "--bootstrap-mode",
+    "direct",
+    "--technical-level",
+    "senior",
+    "--project-state",
+    "existing_repo",
+    "--docs-state",
+    "spec_dossier",
+    "--decision-ownership",
+    "user",
+  ], directProject, { TRACKOPS_BOOTSTRAP_HOME: bootstrapHome });
+  const directControl = readJson(path.join(directProject, "ops", "project_control.json"));
+  assert.strictEqual(directControl.meta.opera.bootstrap.mode, "direct_cli");
+  assert.strictEqual(directControl.meta.opera.bootstrap.status, "awaiting_intake");
+
+  writeJson(path.join(splitProject, "ops", "bootstrap", "intake.json"), {
+    version: 1,
+    technicalLevel: "low",
+    projectState: "idea",
+    documentationState: "none",
+    decisionOwnership: "agent",
+    problemStatement: "users need a simple way to book and pay online",
+    targetUser: "small studio owners",
+    singularDesiredOutcome: "let users create and pay for bookings",
+    userLanguage: "en",
+    needsPlainLanguage: true,
+    recommendedStack: ["nextjs"],
+    externalServices: ["OpenAI", "Stripe"],
+    sourceOfTruth: "primary bookings database",
+    payload: "bookings dashboard",
+    behaviorRules: ["keep explanations simple"],
+    architecturalInvariants: ["keep app and ops separated"],
+    inputSchema: { booking: { email: "string" } },
+    outputSchema: { confirmation: { id: "string" } },
+    pipeline: ["create booking", "confirm payment"],
+    templates: ["booking-confirmation"],
+  });
+  fs.writeFileSync(
+    path.join(splitProject, "ops", "bootstrap", "spec-dossier.md"),
+    "# Spec dossier\n\n## Problem statement\nusers need a simple way to book and pay online\n\n## Target user\nsmall studio owners\n\n## Singular desired outcome\nlet users create and pay for bookings\n\n## Delivery target\nbookings dashboard\n\n## Source of truth\nprimary bookings database\n",
+    "utf8",
+  );
+  runNode([BIN, "opera", "bootstrap", "--resume"], splitProject);
+  const resumedControl = readJson(path.join(splitProject, "ops", "project_control.json"));
+  assert.strictEqual(resumedControl.meta.opera.bootstrap.status, "completed");
+  assert.strictEqual(resumedControl.meta.currentFocus, "let users create and pay for bookings");
+  assert.ok(resumedControl.meta.environment.requiredKeys.includes("STRIPE_SECRET_KEY"));
+  assert.ok(fs.existsSync(path.join(splitProject, "ops", "contract", "operating-contract.json")));
+  const operatingContract = readJson(path.join(splitProject, "ops", "contract", "operating-contract.json"));
+  assert.strictEqual(operatingContract.version, 3);
+  assert.strictEqual(operatingContract.userModel.language, "en");
+  assert.strictEqual(operatingContract.userModel.decisionOwnership, "agent");
+
   const defaultDashboard = startDashboard(splitProject);
 
   try {
     const ready = await waitForDashboard(defaultDashboard);
     const state = await get(ready.port, "/api/state");
     const envPayload = await get(ready.port, "/api/env");
+    const operaBootstrapPayload = await get(ready.port, "/api/opera/bootstrap");
+    const operaHandoffPayload = await get(ready.port, "/api/opera/handoff");
     const localSkills = await get(ready.port, "/api/skills/local");
     const discoverSkills = await get(ready.port, "/api/skills/discover");
 
     assert.strictEqual(state.status, 200);
     assert.strictEqual(envPayload.status, 200);
+    assert.strictEqual(operaBootstrapPayload.status, 200);
+    assert.strictEqual(operaHandoffPayload.status, 200);
     assert.strictEqual(localSkills.status, 200);
     assert.strictEqual(discoverSkills.status, 200);
 
@@ -347,9 +445,14 @@ async function main() {
     assert.ok(envState.requiredKeys.includes("OPENAI_API_KEY"));
     assert.ok(envState.missingKeys.includes("OPENAI_API_KEY"));
 
-    if (defaultPortFree) {
-      assert.strictEqual(ready.port, 4173, `se esperaba usar 4173 cuando estaba libre:\n${ready.output}`);
-    }
+    const bootstrapState = JSON.parse(operaBootstrapPayload.body);
+    assert.strictEqual(bootstrapState.status, "completed");
+    assert.strictEqual(bootstrapState.contractVersion, 3);
+    assert.strictEqual(bootstrapState.contractReadiness, "verified");
+    const handoffState = JSON.parse(operaHandoffPayload.body);
+    assert.ok(handoffState.markdown.includes("project-starter-skill"));
+    assert.ok(handoffState.openQuestionsFile.endsWith("open-questions.md"));
+
   } finally {
     await stopDashboard(defaultDashboard);
   }
@@ -420,6 +523,28 @@ async function main() {
   assert.ok(!migratedPackage.scripts || !migratedPackage.scripts["ops:status"]);
   assert.match(git(["branch", "--list"], legacyProject), /backup\/trackops-workspace-/);
 
+  const legacyUnsupportedProject = path.join(tempRoot, "legacy-unsupported");
+  fs.mkdirSync(legacyUnsupportedProject, { recursive: true });
+  initGitRepo(legacyUnsupportedProject);
+  runNode([BIN, "init", "--locale", "en"], legacyUnsupportedProject, { TRACKOPS_BOOTSTRAP_HOME: bootstrapHome });
+  const legacyUnsupportedControlPath = path.join(legacyUnsupportedProject, "ops", "project_control.json");
+  const legacyUnsupportedControl = readJson(legacyUnsupportedControlPath);
+  legacyUnsupportedControl.meta.opera = {
+    installed: true,
+    version: "0.9.0",
+  };
+  writeJson(legacyUnsupportedControlPath, legacyUnsupportedControl);
+  const legacyStatusOutput = runNode([BIN, "opera", "status"], legacyUnsupportedProject, { TRACKOPS_BOOTSTRAP_HOME: bootstrapHome });
+  assert.match(legacyStatusOutput, /legacy_unsupported/);
+  const upgradeWithoutReset = runNodeResult([BIN, "opera", "upgrade", "--stable"], legacyUnsupportedProject, { TRACKOPS_BOOTSTRAP_HOME: bootstrapHome });
+  assert.strictEqual(upgradeWithoutReset.status, 0);
+  assert.match(`${upgradeWithoutReset.stdout}\n${upgradeWithoutReset.stderr}`, /legacy/i);
+  runNode([BIN, "opera", "upgrade", "--stable", "--reset"], legacyUnsupportedProject, { TRACKOPS_BOOTSTRAP_HOME: bootstrapHome });
+  const upgradedLegacyControl = readJson(legacyUnsupportedControlPath);
+  assert.strictEqual(upgradedLegacyControl.meta.opera.legacyStatus, "supported");
+  assert.strictEqual(upgradedLegacyControl.meta.opera.stableTag, "stable");
+  assert.ok(fs.existsSync(path.join(legacyUnsupportedProject, "ops", ".tmp", "upgrade-backups")));
+
   const releaseProject = path.join(tempRoot, "release-demo");
   fs.mkdirSync(releaseProject, { recursive: true });
   initGitRepo(releaseProject);

package/scripts/validate-skill.js

@@ -72,10 +72,11 @@ function main() {
   }
 
   for (const requiredPhrase of [
-    "npx skills add Baxahaun/trackops --skill trackops --full-depth",
+    "npx skills add Baxahaun/trackops",
     "node scripts/bootstrap-trackops.js",
     "trackops init",
     "trackops opera install",
+    "trackops opera bootstrap --resume",
   ]) {
     if (!skillMd.includes(requiredPhrase)) {
       fail(`skills/trackops/SKILL.md must mention '${requiredPhrase}'.`);

package/skills/trackops/SKILL.md

@@ -2,63 +2,88 @@
 name: "trackops"
 description: "Global TrackOps skill that prepares your agent for local project orchestration and operational automation, ensures the runtime on first use, and guides per-project activation with optional OPERA."
 metadata:
-  version: "1.1.0"
+  version: "2.0.0"
   type: "global"
   triggers:
     - "install trackops"
     - "skills.sh"
-    - "bootstrap trackops"
     - "trackops init"
     - "trackops opera install"
+    - "opera handoff"
 ---
 
 # TrackOps
 
-Use this skill in two layers:
+Use this skill in two layers.
 
-1. Global skill layer
-   Install it with:
+## 1. Global skill layer
 
-   ```bash
-   npx skills add Baxahaun/trackops --skill trackops --full-depth --global --agent codex -y
-   ```
+Install it with:
 
-   Replace `codex` with any supported target: `antigravity`, `claude-code`, `codex`, `cursor`, `gemini-cli`, `github-copilot`, or `kiro-cli`.
+```bash
+npx skills add Baxahaun/trackops
+```
 
-   Before relying on the CLI, run:
+Before relying on the CLI, run:
 
-   ```bash
-   node scripts/bootstrap-trackops.js
-   ```
+```bash
+node scripts/bootstrap-trackops.js
+```
 
-2. Local project layer
-   Activate TrackOps inside the current repository with:
+That bootstrap ensures the `trackops` runtime and records state in `~/.trackops/runtime.json`.
 
-   ```bash
-   trackops init
-   ```
+## 2. Local project layer
 
-   Add OPERA only when explicitly requested:
+Inside a repository:
 
-   ```bash
-   trackops opera install
-   ```
+```bash
+trackops init
+trackops opera install
+```
 
 Core rules:
 
-- Treat the global skill install as non-invasive.
-- In split workspaces, use `ops/project_control.json` as the operational source of truth.
-- In legacy repos, use `project_control.json` at the repository root.
-- Prefer `trackops status`, `trackops next`, and `trackops sync` over hand-editing generated docs.
-- Treat `trackops init --with-opera` as a shortcut, not as the primary mental model.
-- TrackOps manages `/.env` and `/.env.example` at workspace root. Do not print or persist secret values.
-- Remember that skills installs from committed Git state.
+- treat the global skill install as non-invasive
+- use `ops/contract/operating-contract.json` as the machine contract when it exists
+- use `ops/project_control.json` as the operational source of truth for backlog and state
+- use `ops/policy/autonomy.json` before approval-sensitive actions
+- use `/.env` and `/.env.example` as the environment contract
+- keep generated operational docs under `ops/`
+- support `trackops locale get|set` and `trackops doctor locale` when language matters
+
+## OPERA onboarding
+
+OPERA no longer assumes every user is technical.
+
+When OPERA starts, TrackOps classifies:
+
+- user technical level
+- current project state
+- available documentation
+
+Then it chooses one of two routes:
+
+- `direct bootstrap`
+  for technical users and already-defined repositories
+- `agent handoff`
+  for early ideas, non-technical users, or weak documentation
+
+If TrackOps routes bootstrap to the agent:
+
+- read `ops/bootstrap/agent-handoff.md`
+- or print it with `trackops opera handoff --print`
+- the agent must produce:
+  - `ops/bootstrap/intake.json`
+  - `ops/bootstrap/spec-dossier.md`
+  - `ops/bootstrap/open-questions.md` when important gaps remain
+- then resume with:
+
+```bash
+trackops opera bootstrap --resume
+```
 
 Read references only when needed:
 
 - `references/activation.md`
-  for install and activation flow
 - `references/workflow.md`
-  for day-to-day repo operation
 - `references/troubleshooting.md`
-  for bootstrap or environment issues

package/skills/trackops/agents/openai.yaml

@@ -1,3 +1,3 @@
 interface:
   display_name: "TrackOps"
-  short_description: "Global TrackOps skill for local project orchestration and operational automation"
+  short_description: "Global TrackOps skill for local project orchestration, bilingual onboarding, agent coordination, and operational automation"