trackops 2.0.3 → 2.0.4

package/README.md

@@ -67,6 +67,125 @@ Esta separacion es intencional:
 - el runtime se instala con un paso visible y verificable
 - no hay instalacion transitiva oculta desde la propia skill
 
+Si `npm install -g trackops` se ejecuta en modo interactivo, TrackOps intenta pedir el idioma global en ese momento. Si tu terminal o npm no muestran ese prompt, puedes fijarlo manualmente despues:
+
+```bash
+trackops locale set es
+trackops locale set en
+```
+
+### Flujo completo recomendado
+
+1. Instala la skill global:
+
+```bash
+npx skills add Baxahaun/trackops --skill trackops --agent "*" --global -y
+```
+
+2. Instala el runtime:
+
+```bash
+npm install -g trackops@latest
+trackops --version
+```
+
+3. Entra en el repo que quieres gestionar:
+
+```bash
+cd ruta/a/tu/proyecto
+```
+
+4. Activa TrackOps y elige el idioma del proyecto cuando el CLI lo pida:
+
+```bash
+trackops init
+```
+
+5. Instala OPERA:
+
+```bash
+trackops opera install
+```
+
+6. Responde el intake inicial con estos valores:
+
+- nivel tecnico:
+  `low|medium|high|senior`
+  tambien acepta `bajo|medio|alto`
+- estado del proyecto:
+  `idea|draft|existing_repo|advanced`
+- documentacion:
+  `none|notes|sos|spec_dossier|repo_docs`
+- propiedad de decision:
+  `user|shared|agent`
+  tambien acepta `usuario|compartido|agente`
+
+7. Si OPERA deriva al agente:
+
+```bash
+trackops opera handoff --print
+```
+
+Pega ese contexto en el agente, deja que genere:
+
+- `ops/bootstrap/intake.json`
+- `ops/bootstrap/spec-dossier.md`
+- `ops/bootstrap/open-questions.md` si faltan decisiones
+
+Y despues reanuda:
+
+```bash
+trackops opera bootstrap --resume
+```
+
+8. Si OPERA completa bootstrap directo, revisa estado y continua con:
+
+```bash
+trackops opera status
+trackops next
+trackops sync
+```
+
+### Desinstalacion global y local
+
+#### Quitar la instalacion global
+
+Quita la skill global del agente:
+
+```bash
+npx skills remove --global trackops -y
+```
+
+Quita el runtime global:
+
+```bash
+npm uninstall -g trackops
+```
+
+Verifica:
+
+```bash
+npx skills ls -g
+trackops --version
+```
+
+#### Quitar TrackOps de un proyecto
+
+Hoy no existe un comando `trackops uninstall` para el repo. La retirada local es manual.
+
+En un workspace split, revisa y elimina solo lo que de verdad quieras retirar:
+
+- `.trackops-workspace.json`
+- `ops/`
+- `app/.env` si era solo bridge
+
+Revisa con cuidado antes de borrar:
+
+- `/.env`
+- `/.env.example`
+
+Esos archivos pueden seguir siendo utiles para tu proyecto aunque dejes de usar TrackOps.
+
 ### Activacion local
 
 Dentro de un repo:
@@ -138,6 +257,8 @@ Si el usuario no es tecnico, el proyecto esta en fase idea, o no hay documentaci
 trackops opera bootstrap --resume
 ```
 
+La terminal tambien debe decirte este siguiente paso al terminar el handoff.
+
 #### Ya tengo un repo
 
 Si el usuario es tecnico y el proyecto ya tiene suficiente contexto, OPERA sigue por bootstrap directo, compila `ops/contract/operating-contract.json` y recompila `ops/genesis.md`.
@@ -288,6 +409,83 @@ This split is intentional:
 - the runtime is installed through a visible and verifiable step
 - there is no hidden transitive install from the skill itself
 
+If `npm install -g trackops` runs interactively, TrackOps tries to ask for the global language at that moment. If your terminal or npm do not show that prompt, set it manually afterwards:
+
+```bash
+trackops locale set es
+trackops locale set en
+```
+
+### Recommended full flow
+
+1. Install the global skill:
+
+```bash
+npx skills add Baxahaun/trackops --skill trackops --agent "*" --global -y
+```
+
+2. Install the runtime:
+
+```bash
+npm install -g trackops@latest
+trackops --version
+```
+
+3. Enter the repository you want to manage:
+
+```bash
+cd path/to/your/project
+```
+
+4. Activate TrackOps and choose the project language when the CLI asks:
+
+```bash
+trackops init
+```
+
+5. Install OPERA:
+
+```bash
+trackops opera install
+```
+
+6. Answer the initial intake with these values:
+
+- technical level:
+  `low|medium|high|senior`
+- project state:
+  `idea|draft|existing_repo|advanced`
+- documentation:
+  `none|notes|sos|spec_dossier|repo_docs`
+- decision ownership:
+  `user|shared|agent`
+
+7. If OPERA routes to the agent:
+
+```bash
+trackops opera handoff --print
+```
+
+Paste that context into the agent and let it generate:
+
+- `ops/bootstrap/intake.json`
+- `ops/bootstrap/spec-dossier.md`
+- `ops/bootstrap/open-questions.md` when decisions are still missing
+
+Then resume with:
+
+```bash
+trackops opera bootstrap --resume
+```
+
+8. If OPERA completes direct bootstrap, review status and continue with:
+
+```bash
+trackops opera status
+trackops next
+trackops sync
+```
+
 ### Local activation
 
 Inside a repository:
@@ -358,6 +556,46 @@ trackops opera install --bootstrap-mode handoff
 trackops opera install --bootstrap-mode direct
 ```
 
+### Global and local removal
+
+#### Remove the global install
+
+Remove the global skill from the agent:
+
+```bash
+npx skills remove --global trackops -y
+```
+
+Remove the global runtime:
+
+```bash
+npm uninstall -g trackops
+```
+
+Verify:
+
+```bash
+npx skills ls -g
+trackops --version
+```
+
+#### Remove TrackOps from a project
+
+There is no `trackops uninstall` command for the repository yet. Local removal is manual.
+
+In a split workspace, review and remove only what you really want to retire:
+
+- `.trackops-workspace.json`
+- `ops/`
+- `app/.env` if it was only the compatibility bridge
+
+Review carefully before deleting:
+
+- `/.env`
+- `/.env.example`
+
+Those files may still be useful to the project even if you stop using TrackOps.
+
 ### Environment and secrets
 
 TrackOps manages:

package/lib/init.js

@@ -9,7 +9,7 @@ const registry = require("./registry");
 const env = require("./env");
 const workspace = require("./workspace");
 const { t, setLocale } = require("./i18n");
-const { detectSystemLocale, promptForLocale, resolveLocale } = require("./locale");
+const { detectSystemLocale, promptForLocale, maybePromptForLocale, resolveLocale } = require("./locale");
 const runtimeState = require("./runtime-state");
 
 const GENERATED_SCRIPT_COMMANDS = {
@@ -299,7 +299,7 @@ async function cmdInit(args) {
   } else if (!globalLocale) {
     options.locale = await promptForLocale(detectSystemLocale());
   } else {
-    options.locale = globalLocale;
+    options.locale = await maybePromptForLocale(globalLocale, { promptMode: "always" });
   }
   if (!globalLocale) {
     await runtimeState.ensureGlobalLocale({ preferredLocale: options.locale, interactive: false });

package/lib/locale.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
-const readline = require("readline/promises");
-
-const SUPPORTED_LOCALES = ["es", "en"];
+const readline = require("readline/promises");
+
+const SUPPORTED_LOCALES = ["es", "en"];
 
 function normalizeLocale(value) {
   const raw = String(value || "").trim().toLowerCase();
@@ -32,9 +32,9 @@ function isInteractive() {
   return Boolean(process.stdin.isTTY && process.stdout.isTTY);
 }
 
-async function promptForLocale(defaultLocale) {
-  const initial = normalizeLocale(defaultLocale) || detectSystemLocale();
-  if (!isInteractive()) return initial;
+async function promptForLocale(defaultLocale) {
+  const initial = normalizeLocale(defaultLocale) || detectSystemLocale();
+  if (!isInteractive()) return initial;
 
   const rl = readline.createInterface({
     input: process.stdin,
@@ -46,18 +46,42 @@ async function promptForLocale(defaultLocale) {
     return normalizeLocale(answer) || initial;
   } finally {
     rl.close();
-  }
-}
-
-function resolveLocale(preferred, fallback) {
-  return normalizeLocale(preferred) || normalizeLocale(fallback) || detectSystemLocale();
-}
+  }
+}
+
+async function maybePromptForLocale(defaultLocale, options = {}) {
+  const initial = normalizeLocale(defaultLocale) || detectSystemLocale();
+  if (!isInteractive()) return initial;
+
+  const promptMode = String(options.promptMode || "always").trim().toLowerCase();
+  if (promptMode === "never") return initial;
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  try {
+    const answer = await rl.question(
+      `Choose project language / Elige idioma del proyecto [es/en] (${initial}, Enter = keep): `,
+    );
+    const normalized = normalizeLocale(answer);
+    return normalized || initial;
+  } finally {
+    rl.close();
+  }
+}
+
+function resolveLocale(preferred, fallback) {
+  return normalizeLocale(preferred) || normalizeLocale(fallback) || detectSystemLocale();
+}
 
 module.exports = {
   SUPPORTED_LOCALES,
   normalizeLocale,
-  detectSystemLocale,
-  isInteractive,
-  promptForLocale,
-  resolveLocale,
-};
+  detectSystemLocale,
+  isInteractive,
+  promptForLocale,
+  maybePromptForLocale,
+  resolveLocale,
+};

package/lib/opera-bootstrap.js

@@ -35,6 +35,49 @@ const BOOTSTRAP_MODES = ["auto", "direct", "handoff"];
 const QUALITY_STATUSES = ["ready", "needs_review", "blocked"];
 const CONTRACT_READINESS = ["hypothesis", "provisional", "verified", "locked"];
 const CONTRACT_VERSION = 3;
+const ENUM_ALIASES = {
+  low: "low",
+  bajo: "low",
+  basic: "low",
+  beginner: "low",
+  medium: "medium",
+  medio: "medium",
+  mid: "medium",
+  high: "high",
+  alto: "high",
+  advanced: "high",
+  senior: "senior",
+  idea: "idea",
+  ideacion: "idea",
+  ideation: "idea",
+  draft: "draft",
+  borrador: "draft",
+  existing_repo: "existing_repo",
+  existingrepo: "existing_repo",
+  existing: "existing_repo",
+  repo_existente: "existing_repo",
+  "repo existente": "existing_repo",
+  advanced_project: "advanced",
+  avanzado: "advanced",
+  advancedrepo: "advanced",
+  none: "none",
+  ninguna: "none",
+  notes: "notes",
+  notas: "notes",
+  sos: "sos",
+  spec_dossier: "spec_dossier",
+  spec: "spec_dossier",
+  dossier: "spec_dossier",
+  repo_docs: "repo_docs",
+  repodocs: "repo_docs",
+  docs_repo: "repo_docs",
+  user: "user",
+  usuario: "user",
+  shared: "shared",
+  compartido: "shared",
+  agent: "agent",
+  agente: "agent",
+};
 
 function nowIso() {
   return new Date().toISOString();
@@ -81,8 +124,17 @@ function unique(items) {
 }
 
 function normalizeEnum(value, allowed) {
-  const normalized = String(value || "").trim().toLowerCase();
-  return allowed.includes(normalized) ? normalized : null;
+  const normalized = String(value || "").trim().toLowerCase().replace(/\s+/g, "_");
+  const alias = ENUM_ALIASES[normalized] || normalized;
+  return allowed.includes(alias) ? alias : null;
+}
+
+function choiceHint(allowed) {
+  if (allowed === TECHNICAL_LEVELS) return "low|medium|high|senior (o bajo|medio|alto)";
+  if (allowed === PROJECT_STATES) return "idea|draft|existing_repo|advanced";
+  if (allowed === DOC_STATES) return "none|notes|sos|spec_dossier|repo_docs";
+  if (allowed === DECISION_OWNERSHIPS) return "user|shared|agent (o usuario|compartido|agente)";
+  return Array.isArray(allowed) ? allowed.join("|") : null;
 }
 
 function explanationModeFor(technicalLevel) {
@@ -384,6 +436,14 @@ async function askQuestion(rl, message, defaultValue) {
   return String(answer || "").trim() || String(defaultValue || "").trim();
 }
 
+async function askEnumQuestion(rl, message, defaultValue, allowed) {
+  const hint = choiceHint(allowed);
+  const suffix = defaultValue ? ` (${defaultValue})` : "";
+  const answer = await rl.question(`${message}${hint ? ` [${hint}]` : ""}${suffix}: `);
+  const normalized = normalizeEnum(answer || defaultValue, allowed);
+  return normalized || normalizeEnum(defaultValue, allowed);
+}
+
 async function collectBootstrapProfile(root, control, options = {}) {
   const context = config.ensureContext(root);
   const locale = config.getLocale(control);
@@ -427,15 +487,16 @@ async function collectBootstrapProfile(root, control, options = {}) {
   const answers = { ...defaults };
 
   if (interactive) {
-    console.log("");
+    console.log("");
     console.log(t("bootstrap.header"));
     console.log(t("bootstrap.subtitle"));
+    console.log(t("bootstrap.instructions"));
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     try {
-      answers.technicalLevel = normalizeEnum(await askQuestion(rl, t("bootstrap.question.technicalLevel"), defaults.technicalLevel || "medium"), TECHNICAL_LEVELS) || "medium";
-      answers.projectState = normalizeEnum(await askQuestion(rl, t("bootstrap.question.projectState"), defaults.projectState || "idea"), PROJECT_STATES) || "idea";
-      answers.documentationState = normalizeEnum(await askQuestion(rl, t("bootstrap.question.docsState"), defaults.documentationState || "none"), DOC_STATES) || "none";
-      answers.decisionOwnership = normalizeEnum(await askQuestion(rl, t("bootstrap.question.decisionOwnership"), defaults.decisionOwnership || "shared"), DECISION_OWNERSHIPS) || "shared";
+      answers.technicalLevel = await askEnumQuestion(rl, t("bootstrap.question.technicalLevel"), defaults.technicalLevel || "medium", TECHNICAL_LEVELS) || "medium";
+      answers.projectState = await askEnumQuestion(rl, t("bootstrap.question.projectState"), defaults.projectState || "idea", PROJECT_STATES) || "idea";
+      answers.documentationState = await askEnumQuestion(rl, t("bootstrap.question.docsState"), defaults.documentationState || "none", DOC_STATES) || "none";
+      answers.decisionOwnership = await askEnumQuestion(rl, t("bootstrap.question.decisionOwnership"), defaults.decisionOwnership || "shared", DECISION_OWNERSHIPS) || "shared";
     } finally {
       rl.close();
     }

package/lib/opera.js

@@ -6,7 +6,7 @@ const path = require("path");
 const config = require("./config");
 const env = require("./env");
 const { t, setLocale } = require("./i18n");
-const { promptForLocale, resolveLocale } = require("./locale");
+const { promptForLocale, maybePromptForLocale, resolveLocale } = require("./locale");
 const { resolveLocalizedFile, resolveLocalizedDir, resolveSkillFile } = require("./resources");
 const bootstrap = require("./opera-bootstrap");
 const runtimeState = require("./runtime-state");
@@ -188,8 +188,10 @@ async function install(root, options = {}) {
     if (!runtimeState.getGlobalLocale()) {
       await runtimeState.ensureGlobalLocale({ preferredLocale: locale, interactive: false });
     }
+  } else if (!options.locale) {
+    locale = await maybePromptForLocale(locale, { promptMode: "always" });
   }
-  control.meta.locale = locale;
+  control.meta.locale = locale;
   setLocale(locale);
 
   const alreadyInstalled = config.isOperaInstalled(control);
@@ -313,8 +315,14 @@ async function runBootstrap(root, options = {}) {
   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"),
+    );
   }
   return profile;
 }

package/lib/registry.js

@@ -122,6 +122,22 @@ function unregisterProject(rootDir) {
   return registry;
 }
 
+function unregisterById(projectId) {
+  const registry = loadRegistry();
+  registry.projects = registry.projects.filter((p) => p.id !== projectId);
+  saveRegistry(registry);
+  return registry;
+}
+
+function purgeUnavailable() {
+  const registry = loadRegistry();
+  const before = registry.projects.length;
+  registry.projects = registry.projects.filter((p) => isProjectInstalled(p.workspaceRoot || p.root));
+  const removed = before - registry.projects.length;
+  saveRegistry(registry);
+  return { removed, registry };
+}
+
 function listProjects() {
   const registry = loadRegistry();
   return registry.projects.map((project) => {
@@ -185,10 +201,12 @@ module.exports = {
   isProjectInstalled,
   listProjects,
   loadRegistry,
+  purgeUnavailable,
   registerProject,
   resolveProject,
   saveRegistry,
   slugify,
+  unregisterById,
   unregisterProject,
   cmdRegister,
   cmdList,