trackops 2.0.5 → 2.1.0

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";
@@ -26,13 +27,24 @@ function runNode(args, cwd, envOverrides = {}) {
   return result.stdout;
 }
 
-function runNodeResult(args, cwd, envOverrides = {}) {
-  return spawnSync(process.execPath, args, {
-    cwd,
-    encoding: "utf8",
-    env: { ...process.env, ...envOverrides },
-  });
-}
+function runNodeResult(args, cwd, envOverrides = {}) {
+  return spawnSync(process.execPath, args, {
+    cwd,
+    encoding: "utf8",
+    env: { ...process.env, ...envOverrides },
+  });
+}
+
+function runNodeWithInput(args, cwd, input, envOverrides = {}) {
+  const result = spawnSync(process.execPath, args, {
+    cwd,
+    encoding: "utf8",
+    input,
+    env: { ...process.env, ...envOverrides },
+  });
+  assert.strictEqual(result.status, 0, result.stderr || result.stdout || `fallo ejecutando ${args.join(" ")}`);
+  return result.stdout;
+}
 
 function runCommand(command, args, cwd, envOverrides = {}) {
   return spawnSync(command, args, {
@@ -61,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+)/);
@@ -232,11 +268,12 @@ async function main() {
   const installedVersion = runNode([installedCli, "--version"], tempRoot);
   assert.strictEqual(installedVersion.trim(), packageVersion);
 
-  const helpOutput = runNode([BIN, "help"], ROOT);
-  assert.doesNotMatch(helpOutput, /\btrackops agent\b/i);
-  assert.match(helpOutput, /workspace status\|migrate/i);
-  assert.match(helpOutput, /env status\|sync/i);
-  assert.match(helpOutput, /release \[--push\]/i);
+  const helpOutput = runNode([BIN, "help"], ROOT);
+  assert.doesNotMatch(helpOutput, /\btrackops agent\b/i);
+  assert.match(helpOutput, /workspace status\|migrate/i);
+  assert.match(helpOutput, /env status\|sync/i);
+  assert.match(helpOutput, /release \[--push\]/i);
+  assert.match(helpOutput, /--plain|--a11y/i);
 
   const versionOutput = runNode([BIN, "--version"], ROOT);
   assert.strictEqual(versionOutput.trim(), packageVersion);
@@ -270,31 +307,38 @@ async function main() {
   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"));
-  const statusFromOps = runNode([BIN, "status"], path.join(splitProject, "ops"));
-  assert.match(statusFromWorkspace, /Layout: split/);
-  assert.match(statusFromApp, /Layout: split/);
-  assert.match(statusFromOps, /Layout: split/);
-
-  const nextOutput = runNode([BIN, "next"], splitProject);
-  assert.match(nextOutput, /ops-bootstrap/);
-
-  runNode([BIN, "sync"], splitProject);
+  const statusFromWorkspace = runNode([BIN, "status"], splitProject);
+  const statusFromApp = runNode([BIN, "status"], path.join(splitProject, "app"));
+  const statusFromOps = runNode([BIN, "status"], path.join(splitProject, "ops"));
+  assert.match(statusFromWorkspace, /Layout: split|Estructura: split/);
+  assert.match(statusFromApp, /Layout: split|Estructura: split/);
+  assert.match(statusFromOps, /Layout: split|Estructura: split/);
+  assert.match(statusFromWorkspace, /Git: not initialized|Git: no inicializado/i);
+  assert.doesNotMatch(statusFromWorkspace, /Branch: detached|Rama: detached/i);
+
+  const nextOutput = runNode([BIN, "next"], splitProject);
+  assert.match(nextOutput, /ops-bootstrap/);
+
+  const rerunInit = runNode([BIN, "init", "--locale", "es"], splitProject, { TRACKOPS_BOOTSTRAP_HOME: bootstrapHome });
+  assert.match(rerunInit, /Updated \.trackops-workspace\.json|Actualizado \.trackops-workspace\.json/);
+
+  runNode([BIN, "sync"], splitProject);
   for (const file of ["task_plan.md", "progress.md", "findings.md"]) {
     assert.ok(fs.existsSync(path.join(splitProject, "ops", file)), `${file} no fue generado en ops/`);
   }
-
-  const envStatus = runNode([BIN, "env", "status"], splitProject);
-  assert.match(envStatus, /Root \.env:/);
-  assert.match(envStatus, /App bridge:/);
-
-  const nonEmptyProject = path.join(tempRoot, "non-empty");
-  fs.mkdirSync(nonEmptyProject, { recursive: true });
-  writeJson(path.join(nonEmptyProject, "package.json"), { name: "existing-app", version: "1.0.0" });
-  const initNonEmpty = runNodeResult([BIN, "init"], nonEmptyProject);
-  assert.notStrictEqual(initNonEmpty.status, 0, "init debe abortar en directorios no vacios");
-  assert.match(`${initNonEmpty.stdout}\n${initNonEmpty.stderr}`, /workspace migrate/i);
+
+  const envStatus = runNode([BIN, "env", "status"], splitProject);
+  assert.match(envStatus, /Root \.env:|\.env raiz:/);
+  assert.match(envStatus, /App bridge:|Puente app:/);
+
+  const nonEmptyProject = path.join(tempRoot, "non-empty");
+  fs.mkdirSync(nonEmptyProject, { recursive: true });
+  writeJson(path.join(nonEmptyProject, "package.json"), { name: "existing-app", version: "1.0.0" });
+  const initNonEmpty = runNode([BIN, "init", "--locale", "en"], nonEmptyProject, { TRACKOPS_BOOTSTRAP_HOME: bootstrapHome });
+  assert.match(initNonEmpty, /adopted into app\/|movio a app\//i);
+  assert.ok(fs.existsSync(path.join(nonEmptyProject, ".trackops-workspace.json")));
+  assert.ok(fs.existsSync(path.join(nonEmptyProject, "app", "package.json")));
+  assert.ok(fs.existsSync(path.join(nonEmptyProject, "ops", "project_control.json")));
 
   writeJson(path.join(splitProject, "app", "package.json"), {
     name: "split-demo",
@@ -361,9 +405,36 @@ async function main() {
     "--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");
+  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");
+  assert.ok(fs.existsSync(path.join(directProject, "ops", "bootstrap", "intake.json")));
+  assert.ok(fs.existsSync(path.join(directProject, "ops", "bootstrap", "spec-dossier.md")));
+  assert.ok(fs.existsSync(path.join(directProject, "ops", "bootstrap", "open-questions.md")));
+  assert.ok(fs.existsSync(path.join(directProject, "ops", "bootstrap", "quality-report.json")));
+  const directOperaStatus = runNode([BIN, "opera", "status"], directProject, { TRACKOPS_BOOTSTRAP_HOME: bootstrapHome });
+  assert.match(directOperaStatus, /Intake:|Intake:/);
+  assert.match(directOperaStatus, /Spec dossier:|Specification brief:|Dossier de especificacion:/i);
+  assert.doesNotMatch(directOperaStatus, /The agent did not include|El agente no incluyo/i);
+  assert.doesNotMatch(directOperaStatus, /Handoff: ops[\\/]+bootstrap[\\/]+agent-handoff\.md/i);
+  const directHandoffSummary = runNode([BIN, "opera", "handoff"], directProject, { TRACKOPS_BOOTSTRAP_HOME: bootstrapHome });
+  assert.match(directHandoffSummary, /Guided bootstrap summary|Resumen del bootstrap guiado/i);
+  assert.doesNotMatch(directHandoffSummary, /Markdown handoff/i);
+
+  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 });
+  runNode([BIN, "init", "--locale", "en"], promptProject, { TRACKOPS_BOOTSTRAP_HOME: bootstrapHome });
+  writeJson(path.join(promptProject, "app", "package.json"), { name: "prompt-demo", version: "1.0.0" });
+  runNodeWithInput([BIN, "opera", "install", "--locale", "en"], promptProject, "\n", { TRACKOPS_BOOTSTRAP_HOME: bootstrapHome });
+  assert.ok(!fs.existsSync(path.join(promptProject, "ops", "bootstrap", "agent-handoff.md")));
 
   writeJson(path.join(splitProject, "ops", "bootstrap", "intake.json"), {
     version: 1,
@@ -399,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"));
@@ -437,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);
@@ -522,28 +794,98 @@ async function main() {
     version: "0.9.0",
   };
   writeJson(legacyUnsupportedControlPath, legacyUnsupportedControl);
-  const legacyStatusOutput = runNode([BIN, "opera", "status"], legacyUnsupportedProject, { TRACKOPS_BOOTSTRAP_HOME: bootstrapHome });
-  assert.match(legacyStatusOutput, /legacy_unsupported/);
+  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);
-  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"));