trackops 2.0.6 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trackops",
-  "version": "2.0.6",
+  "version": "2.1.0",
   "description": "Local control and coordination system for AI-agent software development",
   "main": "lib/control.js",
   "bin": {
@@ -49,10 +49,11 @@
   "engines": {
     "node": ">=18"
   },
-  "scripts": {
-    "postinstall": "node scripts/postinstall-locale.js",
-    "test": "node scripts/smoke-tests.js",
-    "test:smoke": "node scripts/smoke-tests.js",
+  "scripts": {
+    "postinstall": "node scripts/postinstall-locale.js",
+    "test": "node --test scripts/quality-unit-tests.js && node scripts/smoke-tests.js",
+    "test:unit": "node --test scripts/quality-unit-tests.js",
+    "test:smoke": "node scripts/smoke-tests.js",
     "skill:sync-version": "node scripts/sync-skill-version.js",
     "skill:validate": "node scripts/validate-skill.js",
     "skill:smoke": "node scripts/skills-marketplace-smoke.js",

package/scripts/quality-unit-tests.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { spawnSync } = require("child_process");
+const test = require("node:test");
+
+const ROOT = path.resolve(__dirname, "..");
+const BIN = path.join(ROOT, "bin", "trackops.js");
+
+function runNode(args, cwd, envOverrides = {}) {
+  const result = spawnSync(process.execPath, args, {
+    cwd,
+    encoding: "utf8",
+    env: { ...process.env, ...envOverrides },
+  });
+  assert.strictEqual(result.status, 0, result.stderr || result.stdout || `fallo ejecutando ${args.join(" ")}`);
+  return result.stdout;
+}
+
+function runNodeResult(args, cwd, envOverrides = {}) {
+  return spawnSync(process.execPath, args, {
+    cwd,
+    encoding: "utf8",
+    env: { ...process.env, ...envOverrides },
+  });
+}
+
+function writeJson(filePath, data) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+}
+
+function createProject(name) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), `trackops-quality-${name}-`));
+  runNode([BIN, "init", "--locale", "en"], dir);
+  return dir;
+}
+
+function readProbe(projectRoot, probeId) {
+  const output = runNode([BIN, "quality", "status", "--json"], projectRoot);
+  const report = JSON.parse(output);
+  return report.probes.find((probe) => probe.id === probeId);
+}
+
+test("quality read-only commands do not create ops/quality storage", () => {
+  const projectRoot = createProject("readonly");
+  const qualityDir = path.join(projectRoot, "ops", "quality");
+
+  const commands = [
+    [BIN, "quality", "status", "--json"],
+    [BIN, "quality", "phase-readiness", "--json"],
+    [BIN, "quality", "release-readiness", "--json"],
+    [BIN, "quality", "promote-readiness", "--target", "production", "--json"],
+    [BIN, "quality", "waiver", "list", "--json"],
+  ];
+
+  for (const command of commands) {
+    runNodeResult(command, projectRoot);
+    assert.ok(!fs.existsSync(qualityDir), `el comando ${command.join(" ")} no debe crear ops/quality`);
+  }
+});
+
+test("quality verify build without commands fails with not_configured", () => {
+  const projectRoot = createProject("verify-build");
+  writeJson(path.join(projectRoot, "app", "package.json"), {
+    name: "verify-build",
+    version: "1.0.0",
+    scripts: {
+      test: `node -e "console.log('test ok')"`,
+    },
+  });
+
+  const result = runNodeResult([BIN, "quality", "verify", "--scope", "build", "--json"], projectRoot);
+  assert.notStrictEqual(result.status, 0);
+  const payload = JSON.parse(result.stdout);
+  assert.strictEqual(payload.status, "failed");
+  assert.strictEqual(payload.results[0].scope, "build");
+  assert.strictEqual(payload.results[0].status, "not_configured");
+});
+
+test("quality verify smoke uses app package cwd when inferred from release:check", () => {
+  const projectRoot = createProject("verify-smoke");
+  writeJson(path.join(projectRoot, "app", "package.json"), {
+    name: "verify-smoke",
+    version: "1.0.0",
+    scripts: {
+      "release:check": `node -e "console.log(process.cwd())"`,
+    },
+  });
+
+  const result = runNodeResult([BIN, "quality", "verify", "--scope", "smoke", "--json"], projectRoot);
+  assert.strictEqual(result.status, 0, result.stderr || result.stdout);
+  const payload = JSON.parse(result.stdout);
+  assert.strictEqual(payload.status, "passed");
+  assert.strictEqual(payload.results[0].scope, "smoke");
+  assert.strictEqual(payload.results[0].status, "passed");
+  assert.strictEqual(payload.results[0].commands[0].cwd, path.join(projectRoot, "app"));
+  assert.match(payload.results[0].commands[0].stdout, /trackops-quality-verify-smoke-.*[\\/]app/);
+});
+
+test("phase-readiness is advisory and returns structured DoD checks", () => {
+  const projectRoot = createProject("phase-readiness");
+  runNode([BIN, "opera", "install", "--locale", "en", "--no-bootstrap"], projectRoot);
+
+  const result = runNodeResult([BIN, "quality", "phase-readiness", "--json"], projectRoot);
+  assert.strictEqual(result.status, 0);
+  const payload = JSON.parse(result.stdout);
+  assert.strictEqual(payload.kind, "phase");
+  assert.ok(payload.definition);
+  assert.ok(Array.isArray(payload.checks));
+  assert.ok(payload.checks.length > 0);
+});
+
+test("env.bridge-sync reports pass and mismatch correctly", () => {
+  const projectRoot = createProject("bridge-sync");
+  fs.writeFileSync(path.join(projectRoot, ".env"), "OPENAI_API_KEY=test\n", "utf8");
+  fs.writeFileSync(path.join(projectRoot, ".env.example"), "OPENAI_API_KEY=\n", "utf8");
+  runNode([BIN, "env", "sync"], projectRoot);
+
+  const okProbe = readProbe(projectRoot, "env.bridge-sync");
+  assert.strictEqual(okProbe.status, "pass");
+
+  fs.rmSync(path.join(projectRoot, "app", ".env"), { force: true });
+  fs.writeFileSync(path.join(projectRoot, "app", ".env"), "OPENAI_API_KEY=broken\n", "utf8");
+  const mismatchProbe = readProbe(projectRoot, "env.bridge-sync");
+  assert.strictEqual(mismatchProbe.status, "fail");
+});

package/scripts/smoke-tests.js

@@ -8,9 +8,10 @@ const os = require("os");
 const path = require("path");
 const { spawn, spawnSync } = require("child_process");
 
-const ROOT = path.resolve(__dirname, "..");
-const BIN = path.join(ROOT, "bin", "trackops.js");
-const SKILL_VALIDATE = path.join(ROOT, "scripts", "validate-skill.js");
+const ROOT = path.resolve(__dirname, "..");
+const BIN = path.join(ROOT, "bin", "trackops.js");
+const SKILL_VALIDATE = path.join(ROOT, "scripts", "validate-skill.js");
+const controlLib = require(path.join(ROOT, "lib", "control.js"));
 
 function getNpmCommand() {
   return process.platform === "win32" ? "npm.cmd" : "npm";
@@ -72,17 +73,41 @@ function wait(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-function get(port, pathname, host = "127.0.0.1") {
-  return new Promise((resolve, reject) => {
-    const req = http.get({ host, port, path: pathname }, (res) => {
-      let body = "";
-      res.setEncoding("utf8");
+function get(port, pathname, host = "127.0.0.1") {
+  return new Promise((resolve, reject) => {
+    const req = http.get({ host, port, path: pathname }, (res) => {
+      let body = "";
+      res.setEncoding("utf8");
       res.on("data", (chunk) => { body += chunk; });
       res.on("end", () => resolve({ status: res.statusCode, body }));
     });
-    req.on("error", reject);
-  });
-}
+    req.on("error", reject);
+  });
+}
+
+function requestJson(method, port, pathname, payload = null, host = "127.0.0.1") {
+  return new Promise((resolve, reject) => {
+    const body = payload == null ? "" : JSON.stringify(payload);
+    const req = http.request({
+      host,
+      port,
+      path: pathname,
+      method,
+      headers: {
+        "Content-Type": "application/json; charset=utf-8",
+        "Content-Length": Buffer.byteLength(body),
+      },
+    }, (res) => {
+      let responseBody = "";
+      res.setEncoding("utf8");
+      res.on("data", (chunk) => { responseBody += chunk; });
+      res.on("end", () => resolve({ status: res.statusCode, body: responseBody }));
+    });
+    req.on("error", reject);
+    if (body) req.write(body);
+    req.end();
+  });
+}
 
 function extractLocalPort(output) {
   const match = String(output || "").match(/- Local:\s+http:\/\/[^\s:]+:(\d+)/);
@@ -399,6 +424,10 @@ async function main() {
   const plainStatus = runNode([BIN, "--plain", "status"], directProject, { TRACKOPS_BOOTSTRAP_HOME: bootstrapHome });
   assert.match(plainStatus, /\[BLOCKED\]|\[PENDING\]/);
   assert.doesNotMatch(plainStatus, /\u2500|\u23F3|\u26D4|\u2705/);
+  const blockedResume = runNode([BIN, "opera", "bootstrap", "--resume"], directProject, { TRACKOPS_BOOTSTRAP_HOME: bootstrapHome });
+  assert.match(blockedResume, /quality is BLOCKED|calidad esta BLOQUEADA/i);
+  assert.match(blockedResume, /Problem statement|Problema principal/i);
+  assert.match(blockedResume, /Target user|Usuario objetivo/i);
 
   const promptProject = path.join(tempRoot, "prompt-demo");
   fs.mkdirSync(promptProject, { recursive: true });
@@ -441,30 +470,164 @@ async function main() {
   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);
+  assert.strictEqual(operatingContract.version, 3);
+  assert.strictEqual(operatingContract.userModel.language, "en");
+  assert.strictEqual(operatingContract.userModel.decisionOwnership, "agent");
+
+  const planFile = path.join(splitProject, "docs", "implementation-plan.md");
+  fs.mkdirSync(path.dirname(planFile), { recursive: true });
+  fs.writeFileSync(
+    planFile,
+    "# Implementation plan\n\n## Booking delivery\n- [P0] Booking orchestration [phase: E]\n  - [P1] Define payment payload [phase: P]\n  - [P0] Implement Stripe checkout [phase: E]\n- [P2] Release automation [phase: A]\n",
+    "utf8",
+  );
+
+  const scanPlans = JSON.parse(runNode([BIN, "plan", "scan", "--json"], splitProject));
+  assert.ok(scanPlans.candidates.some((candidate) => candidate.path === "docs/implementation-plan.md"));
+
+  const importedPlan = JSON.parse(runNode([BIN, "plan", "import", "--file", "docs/implementation-plan.md", "--source-id", "booking-plan", "--json"], splitProject));
+  assert.strictEqual(importedPlan.source.id, "booking-plan");
+  assert.ok(importedPlan.preview.summary.create >= 3);
+  const controlAfterImport = readJson(path.join(splitProject, "ops", "project_control.json"));
+  assert.strictEqual(controlAfterImport.meta.controlVersion, 3);
+  assert.ok(controlAfterImport.meta.plans.sources.some((source) => source.id === "booking-plan"));
+  assert.ok(!controlAfterImport.tasks.some((task) => task.origin?.sourceId === "booking-plan"));
+
+  const appliedPlan = JSON.parse(runNode([BIN, "plan", "apply", "booking-plan", "--json"], splitProject));
+  assert.strictEqual(appliedPlan.source.id, "booking-plan");
+  assert.ok(appliedPlan.preview.summary.managedTaskCount >= 3);
+  const controlAfterPlan = readJson(path.join(splitProject, "ops", "project_control.json"));
+  const importedTasks = controlAfterPlan.tasks.filter((task) => task.origin?.sourceId === "booking-plan");
+  assert.ok(importedTasks.length >= 3);
+  assert.ok(importedTasks.some((task) => task.parentId));
+  assert.ok(importedTasks.some((task) => Number.isFinite(Number(task.sequence))));
+  const derivedAfterPlan = controlLib.derive(controlAfterPlan);
+  assert.ok(derivedAfterPlan.tasks.some((task) => task.isParent));
+  assert.ok(derivedAfterPlan.actionableTasks.every((task) => task.isLeaf));
+  assert.ok(derivedAfterPlan.readyTasks.every((task) => task.isLeaf));
+
+  controlAfterPlan.tasks.push(
+    {
+      id: "next-leaf-a",
+      title: "Prepare active work regression",
+      phase: "E",
+      stream: "Operations",
+      priority: "P1",
+      status: "pending",
+      required: true,
+      dependsOn: [],
+      acceptance: [],
+      history: [],
+      origin: { kind: "manual" },
+    },
+    {
+      id: "next-leaf-b",
+      title: "Follow-up ready task",
+      phase: "E",
+      stream: "Operations",
+      priority: "P1",
+      status: "pending",
+      required: true,
+      dependsOn: ["next-leaf-a"],
+      acceptance: [],
+      history: [],
+      origin: { kind: "manual" },
+    },
+  );
+  writeJson(path.join(splitProject, "ops", "project_control.json"), controlAfterPlan);
+  runNode([BIN, "task", "start", "next-leaf-a"], splitProject);
+  const nextWithActiveWork = runNode([BIN, "next"], splitProject);
+  assert.match(nextWithActiveWork, /Active work:|Trabajo activo:/);
+  assert.match(nextWithActiveWork, /next-leaf-a/);
+  runNode([BIN, "task", "complete", "next-leaf-a"], splitProject);
+  const nextAfterActiveComplete = runNode([BIN, "next"], splitProject);
+  assert.match(nextAfterActiveComplete, /next-leaf-b/);
+
+  const coordinationControl = readJson(path.join(splitProject, "ops", "project_control.json"));
+  coordinationControl.tasks.push(
+    {
+      id: "user-exec-task",
+      title: "User-owned execution flow",
+      phase: "E",
+      stream: "Operations",
+      priority: "P1",
+      status: "pending",
+      required: true,
+      dependsOn: [],
+      acceptance: [],
+      history: [],
+      origin: { kind: "manual" },
+      execution: { owner: "user" },
+    },
+    {
+      id: "dashboard-verify-task",
+      title: "Dashboard verification flow",
+      phase: "E",
+      stream: "Operations",
+      priority: "P1",
+      status: "pending",
+      required: true,
+      dependsOn: [],
+      acceptance: [],
+      history: [],
+      origin: { kind: "manual" },
+      execution: { owner: "shared" },
+    },
+    {
+      id: "agent-exec-task",
+      title: "Agent execution flow",
+      phase: "E",
+      stream: "Operations",
+      priority: "P1",
+      status: "pending",
+      required: true,
+      dependsOn: [],
+      acceptance: [],
+      history: [],
+      origin: { kind: "manual" },
+      execution: { owner: "agent" },
+    },
+  );
+  writeJson(path.join(splitProject, "ops", "project_control.json"), coordinationControl);
+
+  runNode([BIN, "task", "start", "user-exec-task"], splitProject);
+  const controlAfterUserExec = readJson(path.join(splitProject, "ops", "project_control.json"));
+  assert.ok(controlAfterUserExec.meta.agentInbox.pending.some((item) => item.taskId === "user-exec-task" && item.kind === "await_user_report"));
+
+  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);
-
-    const statePayload = JSON.parse(state.body);
-    assert.strictEqual(statePayload.project.layout, "split");
+    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");
+    const plansPayload = await get(ready.port, "/api/plans");
+    const planSourcePayload = await get(ready.port, "/api/plans/booking-plan");
+    const qualityPayload = await get(ready.port, "/api/quality");
+    const phaseReadinessPayload = await get(ready.port, "/api/quality/phase-readiness");
+    const releaseReadinessPayload = await get(ready.port, "/api/quality/release-readiness");
+    const promotionReadinessPayload = await get(ready.port, "/api/quality/promotion-readiness?target=production");
+    const waiversPayload = await get(ready.port, "/api/quality/waivers");
+
+    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);
+    assert.strictEqual(plansPayload.status, 200);
+    assert.strictEqual(planSourcePayload.status, 200);
+    assert.strictEqual(qualityPayload.status, 200);
+    assert.strictEqual(phaseReadinessPayload.status, 200);
+    assert.strictEqual(releaseReadinessPayload.status, 200);
+    assert.strictEqual(promotionReadinessPayload.status, 200);
+    assert.strictEqual(waiversPayload.status, 200);
+
+    const statePayload = JSON.parse(state.body);
+    assert.strictEqual(statePayload.project.layout, "split");
     assert.strictEqual(statePayload.project.workspaceRoot, splitProject);
     assert.strictEqual(statePayload.project.appRoot, path.join(splitProject, "app"));
     assert.strictEqual(statePayload.project.opsRoot, path.join(splitProject, "ops"));
@@ -479,13 +642,80 @@ async function main() {
     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);
-  }
+    const handoffState = JSON.parse(operaHandoffPayload.body);
+    assert.ok(handoffState.markdown.includes("project-starter-skill"));
+    assert.ok(handoffState.openQuestionsFile.endsWith("open-questions.md"));
+    const plansState = JSON.parse(plansPayload.body);
+    assert.ok(plansState.sources.some((source) => source.id === "booking-plan"));
+    const planState = JSON.parse(planSourcePayload.body);
+    assert.strictEqual(planState.source.id, "booking-plan");
+    assert.ok(planState.preview.summary.managedTaskCount >= 3);
+    const qualityState = JSON.parse(qualityPayload.body);
+    assert.ok(qualityState.report.summary);
+    assert.ok(Array.isArray(qualityState.report.probes));
+    assert.ok(qualityState.releaseReadiness.status);
+    assert.ok(statePayload.quality.releaseReadiness.status);
+    assert.ok(!fs.existsSync(path.join(splitProject, "ops", "quality")), "las rutas GET de quality no deben crear storage");
+
+    const reviewVerify = await requestJson("POST", ready.port, "/api/quality/verify", {
+      projectId: statePayload.project.id,
+      scope: "review",
+      note: "dashboard smoke review",
+    });
+    assert.strictEqual(reviewVerify.status, 200);
+    const verifyState = JSON.parse(reviewVerify.body);
+    assert.strictEqual(verifyState.run.status, "skipped");
+    assert.ok(fs.existsSync(path.join(splitProject, "ops", "quality", "latest.json")));
+
+    const timerTask = statePayload.derived.tasks.find((task) => task.isLeaf && task.status === "pending");
+    assert.ok(timerTask, "deberia existir una tarea hoja pendiente para probar time tracking");
+    const timeStart = await requestJson("POST", ready.port, "/api/time/start", {
+      projectId: statePayload.project.id,
+      taskId: timerTask.id,
+      taskTitle: timerTask.title,
+    });
+    assert.strictEqual(timeStart.status, 201);
+    const timeStartPayload = JSON.parse(timeStart.body);
+    assert.strictEqual(timeStartPayload.autoTaskStarted, true);
+    const controlAfterTimerStart = readJson(path.join(splitProject, "ops", "project_control.json"));
+    const timedTask = controlAfterTimerStart.tasks.find((task) => task.id === timerTask.id);
+    assert.strictEqual(timedTask.status, "in_progress");
+    assert.ok((timedTask.history || []).some((entry) => entry.action === "start"));
+
+    const timeStop = await requestJson("POST", ready.port, "/api/time/stop", {
+      projectId: statePayload.project.id,
+      entryId: timeStartPayload.entry.id,
+    });
+    assert.strictEqual(timeStop.status, 200);
+
+    const dashboardVerify = await requestJson("POST", ready.port, "/api/tasks/dashboard-verify-task/action", {
+      projectId: statePayload.project.id,
+      action: "complete",
+      note: "user finished work",
+      actor: "user",
+      source: "dashboard_test",
+    });
+    assert.strictEqual(dashboardVerify.status, 200);
+    const controlAfterDashboardVerify = readJson(path.join(splitProject, "ops", "project_control.json"));
+    assert.ok(controlAfterDashboardVerify.meta.agentInbox.pending.some((item) => item.taskId === "dashboard-verify-task" && item.kind === "verify_status"));
+
+    const linkedCommand = await requestJson("POST", ready.port, "/api/commands", {
+      projectId: statePayload.project.id,
+      command: "echo agent-linked-task",
+      taskId: "agent-exec-task",
+      source: "execution_console",
+    });
+    assert.strictEqual(linkedCommand.status, 201);
+    await wait(400);
+    const controlAfterLinkedCommand = readJson(path.join(splitProject, "ops", "project_control.json"));
+    const linkedTask = controlAfterLinkedCommand.tasks.find((task) => task.id === "agent-exec-task");
+    assert.strictEqual(linkedTask.status, "in_progress");
+    assert.strictEqual(linkedTask.execution.lastActor, "agent");
+    assert.ok(linkedTask.execution.lastSessionId);
+
+  } finally {
+    await stopDashboard(defaultDashboard);
+  }
 
   const blocked4173 = await isPortFree(4173) ? await occupyPort(4173) : null;
   const fallbackDashboard = startDashboard(splitProject);
@@ -569,23 +799,93 @@ async function main() {
   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);
-  runNode([BIN, "init"], releaseProject);
-  writeJson(path.join(releaseProject, "app", "package.json"), { name: "release-demo", version: "1.0.0" });
-  fs.writeFileSync(path.join(releaseProject, "app", "index.js"), "console.log('release');\n", "utf8");
-  commitAll(releaseProject, "split fixture");
-  git(["checkout", "-b", "develop"], releaseProject);
-  runNode([BIN, "release"], releaseProject);
-  const publishFiles = git(["ls-tree", "--name-only", "master"], releaseProject).split(/\r?\n/).filter(Boolean);
-  assert.ok(publishFiles.includes("package.json"));
+  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 upgradeBackfillProject = path.join(tempRoot, "upgrade-backfill");
+  fs.mkdirSync(upgradeBackfillProject, { recursive: true });
+  initGitRepo(upgradeBackfillProject);
+  runNode([BIN, "init", "--locale", "en"], upgradeBackfillProject);
+  git(["checkout", "-b", "develop"], upgradeBackfillProject);
+  git(["remote", "add", "origin", "https://github.com/example/upgrade-backfill.git"], upgradeBackfillProject);
+  runNode([BIN, "opera", "install", "--locale", "en", "--no-bootstrap"], upgradeBackfillProject);
+  writeJson(path.join(upgradeBackfillProject, "ops", "bootstrap", "intake.json"), {
+    problemStatement: "Backfill test",
+    targetUser: "Developers",
+    singularDesiredOutcome: "Persist inferred metadata",
+    sourceOfTruth: "workspace",
+    payload: "release bundle",
+  });
+  writeJson(path.join(upgradeBackfillProject, "app", "package.json"), {
+    name: "upgrade-backfill",
+    version: "1.0.0",
+    scripts: {
+      test: `node -e "console.log('ok')"`,
+      "release:check": `node -e "console.log('release check ok')"`,
+    },
+  });
+  runNode([BIN, "opera", "upgrade", "--stable"], upgradeBackfillProject);
+  const backfilledIntake = readJson(path.join(upgradeBackfillProject, "ops", "bootstrap", "intake.json"));
+  const backfilledControl = readJson(path.join(upgradeBackfillProject, "ops", "project_control.json"));
+  assert.strictEqual(backfilledIntake.versionControl.provider, "github");
+  assert.strictEqual(backfilledIntake.versionControl.developmentBranch, "develop");
+  assert.strictEqual(backfilledIntake.deployment.mode, "manual");
+  assert.ok(backfilledIntake.deployment.smokeCommand);
+  assert.strictEqual(backfilledControl.meta.opera.bootstrap.discovery.versionControl.provider, "github");
+
+  const localeProjectEs = path.join(tempRoot, "locale-es");
+  fs.mkdirSync(localeProjectEs, { recursive: true });
+  runNode([BIN, "init", "--locale", "es"], localeProjectEs);
+  const localeEsQuality = runNode([BIN, "quality", "status"], localeProjectEs);
+  const localeEsStatus = runNode([BIN, "status"], localeProjectEs);
+  assert.match(localeEsQuality, /Estado de calidad/i);
+  assert.match(localeEsStatus, /Calidad/i);
+
+  const localeProjectEn = path.join(tempRoot, "locale-en");
+  fs.mkdirSync(localeProjectEn, { recursive: true });
+  runNode([BIN, "init", "--locale", "en"], localeProjectEn);
+  const localeEnQuality = runNode([BIN, "quality", "status"], localeProjectEn);
+  const localeEnStatus = runNode([BIN, "status"], localeProjectEn);
+  assert.match(localeEnQuality, /Quality status/i);
+  assert.match(localeEnStatus, /Quality/i);
+
+  const releaseProject = path.join(tempRoot, "release-demo");
+  fs.mkdirSync(releaseProject, { recursive: true });
+  initGitRepo(releaseProject);
+  runNode([BIN, "init"], releaseProject);
+  writeJson(path.join(releaseProject, "app", "package.json"), {
+    name: "release-demo",
+    version: "1.0.0",
+    scripts: {
+      test: `node -e "console.log('test ok')"`,
+      smoke: `node -e "console.log('smoke ok')"`,
+      "release:check": `node -e "console.log('release check ok')"`,
+    },
+  });
+  fs.writeFileSync(path.join(releaseProject, "app", "index.js"), "console.log('release');\n", "utf8");
+  const releaseControlPath = path.join(releaseProject, "ops", "project_control.json");
+  const releaseControl = readJson(releaseControlPath);
+  releaseControl.meta.quality = releaseControl.meta.quality || {};
+  releaseControl.meta.quality.verification = releaseControl.meta.quality.verification || {};
+  releaseControl.meta.quality.verification.smokeCommands = [`node -e "console.log('smoke ok')"`];
+  writeJson(releaseControlPath, releaseControl);
+  commitAll(releaseProject, "split fixture");
+  git(["checkout", "-b", "develop"], releaseProject);
+  const blockedRelease = runNodeResult([BIN, "release"], releaseProject);
+  assert.notStrictEqual(blockedRelease.status, 0, "release debe bloquearse si no hay evidencia de quality verify");
+  assert.match(`${blockedRelease.stdout}\n${blockedRelease.stderr}`, /quality readiness/i);
+  const missingBuildVerify = runNodeResult([BIN, "quality", "verify", "--scope", "build", "--json"], releaseProject);
+  assert.notStrictEqual(missingBuildVerify.status, 0, "verify --scope build debe fallar si no hay build configurado");
+  const missingBuildPayload = JSON.parse(missingBuildVerify.stdout);
+  assert.strictEqual(missingBuildPayload.results[0].status, "not_configured");
+  runNode([BIN, "quality", "verify", "--scope", "all"], releaseProject);
+  commitAll(releaseProject, "quality evidence");
+  runNode([BIN, "release"], releaseProject);
+  const publishFiles = git(["ls-tree", "--name-only", "master"], releaseProject).split(/\r?\n/).filter(Boolean);
+  assert.ok(publishFiles.includes("package.json"));
   assert.ok(publishFiles.includes(".env.example"));
   assert.ok(!publishFiles.includes("ops"));
   assert.ok(!publishFiles.includes(".trackops-workspace.json"));