trackops 2.0.6 → 2.2.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";
@@ -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+)/);
@@ -315,13 +340,18 @@ async function main() {
   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",
-    version: "1.0.0",
-    dependencies: { openai: "^4.0.0" },
-    scripts: { test: "echo ok" },
-  });
-  runNode([BIN, "opera", "install", "--locale", "en", "--non-interactive"], splitProject);
+  writeJson(path.join(splitProject, "app", "package.json"), {
+    name: "split-demo",
+    version: "1.0.0",
+    dependencies: { openai: "^4.0.0" },
+    scripts: { test: "echo ok" },
+  });
+  const skillCatalog = runNode([BIN, "skill", "catalog"], splitProject);
+  assert.match(skillCatalog, /trackops-quality-guard/);
+  assert.doesNotMatch(skillCatalog, /opera-quality-guard/);
+  runNode([BIN, "skill", "install", "trackops-quality-guard"], splitProject);
+  assert.ok(fs.existsSync(path.join(splitProject, "ops", ".agents", "skills", "trackops-quality-guard", "SKILL.md")));
+  runNode([BIN, "opera", "install", "--locale", "en", "--non-interactive"], splitProject);
 
   assert.ok(fs.existsSync(path.join(splitProject, "ops", "genesis.md")));
   assert.ok(fs.existsSync(path.join(splitProject, "ops", ".agent", "hub", "agent.md")));
@@ -342,13 +372,15 @@ async function main() {
   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("opera-skill"));
-  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(fs.existsSync(path.join(splitProject, "ops", ".agents", "skills", "opera-skill", "SKILL.md")));
-  assert.ok(fs.existsSync(path.join(splitProject, "ops", ".agents", "skills", "opera-skill", "references", "phase-dod.md")));
-  assert.ok(fs.existsSync(path.join(splitProject, "ops", ".agents", "skills", "project-starter-skill", "references", "opera-cycle.md")));
+  assert.ok(operaControl.meta.opera.skills.includes("opera-skill"));
+  assert.ok(operaControl.meta.opera.skills.includes("trackops-quality-guard"));
+  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(fs.existsSync(path.join(splitProject, "ops", ".agents", "skills", "opera-skill", "SKILL.md")));
+  assert.ok(fs.existsSync(path.join(splitProject, "ops", ".agents", "skills", "trackops-quality-guard", "SKILL.md")));
+  assert.ok(fs.existsSync(path.join(splitProject, "ops", ".agents", "skills", "opera-skill", "references", "phase-dod.md")));
+  assert.ok(fs.existsSync(path.join(splitProject, "ops", ".agents", "skills", "project-starter-skill", "references", "opera-cycle.md")));
   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=/);
@@ -399,6 +431,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 +477,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 +649,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 +806,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"));

package/scripts/sync-skill-version.js

@@ -1,21 +1,31 @@
 #!/usr/bin/env node
 
-const fs = require("fs");
-const path = require("path");
-
-const ROOT = path.resolve(__dirname, "..");
-const PACKAGE_FILE = path.join(ROOT, "package.json");
-const SKILL_FILE = path.join(ROOT, "skills", "trackops", "skill.json");
-
-function main() {
-  const pkg = JSON.parse(fs.readFileSync(PACKAGE_FILE, "utf8"));
-  const skill = JSON.parse(fs.readFileSync(SKILL_FILE, "utf8"));
-
-  skill.skillVersion = pkg.version;
-  skill.trackopsVersion = pkg.version;
-
-  fs.writeFileSync(SKILL_FILE, `${JSON.stringify(skill, null, 2)}\n`, "utf8");
-  console.log(`Synced skills/trackops/skill.json to version ${pkg.version}.`);
-}
-
-main();
+const fs = require("fs");
+const path = require("path");
+
+const ROOT = path.resolve(__dirname, "..");
+const PACKAGE_FILE = path.join(ROOT, "package.json");
+
+function getSkillFiles() {
+  const skillsRoot = path.join(ROOT, "skills");
+  if (!fs.existsSync(skillsRoot)) return [];
+  return fs.readdirSync(skillsRoot, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => path.join(skillsRoot, entry.name, "skill.json"))
+    .filter((filePath) => fs.existsSync(filePath))
+    .sort((a, b) => a.localeCompare(b));
+}
+
+function main() {
+  const pkg = JSON.parse(fs.readFileSync(PACKAGE_FILE, "utf8"));
+  const skillFiles = getSkillFiles();
+  for (const skillFile of skillFiles) {
+    const skill = JSON.parse(fs.readFileSync(skillFile, "utf8"));
+    skill.skillVersion = pkg.version;
+    skill.trackopsVersion = pkg.version;
+    fs.writeFileSync(skillFile, `${JSON.stringify(skill, null, 2)}\n`, "utf8");
+    console.log(`Synced ${path.relative(ROOT, skillFile)} to version ${pkg.version}.`);
+  }
+}
+
+main();