trackops 2.0.5 → 2.0.6

package/lib/control.js

@@ -4,21 +4,22 @@ const fs = require("fs");
 const path = require("path");
 const { spawnSync } = require("child_process");
 
-const config = require("./config");
-const env = require("./env");
-const { t, setLocale, getLocale } = require("./i18n");
-
-const PRIORITY_ORDER = ["P0", "P1", "P2", "P3"];
-const STATUS_ORDER = ["in_progress", "in_review", "pending", "blocked", "completed", "cancelled"];
-const STATUS_ICONS = {
-  pending: "\u23F3",
-  in_progress: "\uD83D\uDEA7",
-  in_review: "\uD83D\uDC40",
-  blocked: "\u26D4",
-  completed: "\u2705",
-  cancelled: "\uD83D\uDDD1\uFE0F",
-};
-const CHECK_ICONS = {
+const config = require("./config");
+const env = require("./env");
+const { t, setLocale, getLocale } = require("./i18n");
+const fmt = require("./cli-format");
+
+const PRIORITY_ORDER = ["P0", "P1", "P2", "P3"];
+const STATUS_ORDER = ["in_progress", "in_review", "pending", "blocked", "completed", "cancelled"];
+const STATUS_ICONS = {
+  pending: "\u23F3",
+  in_progress: "\uD83D\uDEA7",
+  in_review: "\uD83D\uDC40",
+  blocked: "\u26D4",
+  completed: "\u2705",
+  cancelled: "\uD83D\uDDD1\uFE0F",
+};
+const CHECK_ICONS = {
   pass: "\u2705",
   warn: "\u26A0\uFE0F",
   fail: "\u274C",
@@ -39,29 +40,79 @@ function nowIso() {
   return new Date().toISOString();
 }
 
-function git(args, root) {
-  const result = spawnSync("git", args, { cwd: root, encoding: "utf8" });
-  if (result.error || result.status !== 0) return null;
-  return result.stdout.replace(/\s+$/, "");
-}
-
-function statusLabel(status) {
-  return t(`status.${status}`);
-}
-
-/* ── repo snapshot ── */
-
-function getRepoSnapshot(contextOrRoot) {
-  const context = config.ensureContext(contextOrRoot);
-  const repoRoot = context.workspaceRoot;
-  const branch = git(["branch", "--show-current"], repoRoot) || "detached";
-  const status = git(["status", "--short"], repoRoot) || "";
-  const lines = status.split(/\r?\n/).filter(Boolean);
-  const lastCommitRaw = git(["log", "-1", "--pretty=format:%H%n%cs%n%s"], repoRoot);
-  const divergenceRaw = git(["rev-list", "--left-right", "--count", "@{upstream}...HEAD"], repoRoot);
-
-  let staged = 0;
-  let unstaged = 0;
+function git(args, root) {
+  const result = spawnSync("git", args, { cwd: root, encoding: "utf8" });
+  if (result.error || result.status !== 0) return null;
+  return result.stdout.replace(/\s+$/, "");
+}
+
+function gitResult(args, root) {
+  const result = spawnSync("git", args, { cwd: root, encoding: "utf8" });
+  return {
+    ok: !result.error && result.status === 0,
+    status: result.status,
+    stdout: String(result.stdout || "").replace(/\s+$/, ""),
+    stderr: String(result.stderr || "").replace(/\s+$/, ""),
+    error: result.error || null,
+  };
+}
+
+function statusLabel(status) {
+  return t(`status.${status}`);
+}
+
+function formatBootstrapStatus(status) {
+  return t(`bootstrap.status.${String(status || "").trim()}`) || status || t("locale.none");
+}
+
+function formatBootstrapMode(mode) {
+  return t(`bootstrap.mode.${String(mode || "").trim()}`) || mode || t("locale.none");
+}
+
+function formatBootstrapReason(reason) {
+  return t(`bootstrap.reason.${String(reason || "").trim()}`) || reason || t("locale.none");
+}
+
+function listOrNone(items) {
+  const values = (items || []).filter(Boolean);
+  return values.length ? values.join(", ") : t("locale.none");
+}
+
+/* ── repo snapshot ── */
+
+function getRepoSnapshot(contextOrRoot) {
+  const context = config.ensureContext(contextOrRoot);
+  const repoRoot = context.workspaceRoot;
+  const insideWorkTree = gitResult(["rev-parse", "--is-inside-work-tree"], repoRoot);
+  if (!insideWorkTree.ok || insideWorkTree.stdout.trim() !== "true") {
+    return {
+      generatedAt: nowIso(),
+      available: false,
+      state: "not_initialized",
+      branch: null,
+      clean: null,
+      staged: 0,
+      unstaged: 0,
+      untracked: 0,
+      ahead: 0,
+      behind: 0,
+      hasUpstream: false,
+      lastCommit: null,
+    };
+  }
+
+  const branchResult = gitResult(["branch", "--show-current"], repoRoot);
+  const branch = branchResult.ok ? branchResult.stdout.trim() : "";
+  const status = git(["status", "--short"], repoRoot) || "";
+  const lines = status.split(/\r?\n/).filter(Boolean);
+  const lastCommitRaw = git(["log", "-1", "--pretty=format:%H%n%cs%n%s"], repoRoot);
+  const upstream = gitResult(["rev-parse", "--abbrev-ref", "@{upstream}"], repoRoot);
+  const divergenceRaw = upstream.ok
+    ? git(["rev-list", "--left-right", "--count", "@{upstream}...HEAD"], repoRoot)
+    : null;
+
+  let staged = 0;
+  let unstaged = 0;
   let untracked = 0;
 
   lines.forEach((line) => {
@@ -78,14 +129,27 @@ function getRepoSnapshot(contextOrRoot) {
 
   let ahead = 0;
   let behind = 0;
-  if (divergenceRaw) {
-    const [left, right] = divergenceRaw.split(/\s+/).map(Number);
-    behind = Number.isFinite(left) ? left : 0;
-    ahead = Number.isFinite(right) ? right : 0;
-  }
-
-  return { generatedAt: nowIso(), branch, clean: lines.length === 0, staged, unstaged, untracked, ahead, behind, lastCommit };
-}
+  if (divergenceRaw) {
+    const [left, right] = divergenceRaw.split(/\s+/).map(Number);
+    behind = Number.isFinite(left) ? left : 0;
+    ahead = Number.isFinite(right) ? right : 0;
+  }
+
+  return {
+    generatedAt: nowIso(),
+    available: true,
+    state: branch ? "ready" : "detached",
+    branch: branch || null,
+    clean: lines.length === 0,
+    staged,
+    unstaged,
+    untracked,
+    ahead,
+    behind,
+    hasUpstream: upstream.ok,
+    lastCommit,
+  };
+}
 
 function refreshRepoRuntime(root, options = {}) {
   const context = config.ensureContext(root);
@@ -115,16 +179,42 @@ function compareTasks(a, b, phases) {
   return a.title.localeCompare(b.title, getLocale());
 }
 
+function detectCircularDeps(tasks) {
+  const visited = new Set();
+  const inStack = new Set();
+  const cycles = [];
+  function dfs(id) {
+    if (inStack.has(id)) { cycles.push(id); return; }
+    if (visited.has(id)) return;
+    visited.add(id);
+    inStack.add(id);
+    const task = tasks.find((t) => t.id === id);
+    if (task) (task.dependsOn || []).forEach((dep) => dfs(dep));
+    inStack.delete(id);
+  }
+  tasks.forEach((t) => dfs(t.id));
+  return cycles;
+}
+
 function derive(control) {
   const phases = config.getPhases(control);
   const tasks = [...control.tasks].sort((a, b) => compareTasks(a, b, phases));
   const completedIds = new Set(tasks.filter((t) => t.status === "completed").map((t) => t.id));
+  const allIds = new Set(tasks.map((t) => t.id));
   const closedStatuses = new Set(["completed", "cancelled"]);
+  const phantomDeps = [];
 
   const readyTasks = tasks
     .filter((task) => {
       if (task.status !== "pending") return false;
-      return (task.dependsOn || []).every((dep) => completedIds.has(dep));
+      const validDeps = (task.dependsOn || []).filter((dep) => {
+        if (!allIds.has(dep)) {
+          phantomDeps.push({ taskId: task.id, missingDep: dep });
+          return false;
+        }
+        return true;
+      });
+      return validDeps.every((dep) => completedIds.has(dep));
     })
     .sort((a, b) => {
       const focusPhase = control.meta.focusPhase || "";
@@ -139,10 +229,11 @@ function derive(control) {
   const reviewTasks = tasks.filter((t) => t.status === "in_review");
   const openTasks = tasks.filter((t) => !["completed", "cancelled"].includes(t.status));
   const requiredOpenTasks = tasks.filter((t) => t.required !== false && !["completed", "cancelled"].includes(t.status));
+  const projectCompleted = requiredOpenTasks.length === 0 && tasks.length > 0;
 
   const activePhase =
     phases.find((p) => requiredOpenTasks.some((t) => t.phase === p.id)) ||
-    phases[phases.length - 1];
+    (projectCompleted ? phases[phases.length - 1] : phases[0]);
 
   const phaseStats = phases.map((phase) => {
     const phaseTasks = tasks.filter((t) => t.phase === phase.id && t.required !== false);
@@ -152,9 +243,13 @@ function derive(control) {
   });
 
   const nextTask = activeTasks[0] || readyTasks[0] || blockers[0] || openTasks[0] || null;
+  const circularDeps = detectCircularDeps(tasks);
 
   return {
     tasks, blockers, activeTasks, reviewTasks, readyTasks, nextTask, activePhase, phaseStats,
+    projectCompleted,
+    circularDeps,
+    phantomDeps,
     openFindings: (control.findings || []).filter((f) => f.status === "open"),
     resolvedFindings: (control.findings || []).filter((f) => f.status === "resolved"),
     totals: {
@@ -171,12 +266,13 @@ function derive(control) {
 
 /* ── render ── */
 
-function renderTask(task, phases) {
-  const phase = getPhaseInfo(task.phase, phases);
-  const detail = task.blocker || task.summary || "";
-  const detailSuffix = detail ? ` — ${detail}` : "";
-  return `- ${STATUS_ICONS[task.status]} \`${task.id}\` [${task.priority}] ${task.title} (${phase.id} · ${phase.label} · ${task.stream})${detailSuffix}`;
-}
+function renderTask(task, phases, options = {}) {
+  const phase = getPhaseInfo(task.phase, phases);
+  const detail = task.blocker || task.summary || "";
+  const detailSuffix = detail ? ` — ${detail}` : "";
+  const token = options.cli ? fmt.statusToken(task.status) : STATUS_ICONS[task.status];
+  return `- ${token} \`${task.id}\` [${task.priority}] ${task.title} (${phase.id} · ${phase.label} · ${task.stream})${detailSuffix}`;
+}
 
 function renderTaskPlan(control) {
   const phases = config.getPhases(control);
@@ -284,7 +380,7 @@ function renderProgress(control) {
     `## ${t("doc.section.currentState")}`,
     `- ${t("doc.label.phase")}: ${state.activePhase.label} (${state.activePhase.index}/${phases.length})`,
     `- ${t("doc.label.blockers")}: ${blockersLabel}`,
-    `- ${t("doc.label.lastTest")}: ${CHECK_ICONS[lastTest.status]} ${lastTest.date || t("status.pending")}${lastTest.note ? ` — ${lastTest.note}` : ""}`,
+    `- ${t("doc.label.lastTest")}: ${CHECK_ICONS[lastTest.status]} ${lastTest.date || t("status.pending")}${lastTest.note ? ` — ${lastTest.note}` : ""}`,
     `- ${t("doc.label.nextStepShort")}: ${nextStep}`,
     `- ${t("doc.label.lastUpdate")}: ${(control.meta.updatedAt || "").slice(0, 10)}`,
     "",
@@ -371,13 +467,26 @@ function getDocDrift(root, control) {
     .map(([name]) => name);
 }
 
-function syncDocs(root, control) {
+function syncDocs(root, control, options = {}) {
   const context = config.ensureContext(root);
   const docs = buildDocMap(control);
   const docFiles = config.docFilePaths(context);
-  writeText(docFiles.taskPlan, `${docs.taskPlan}\n`);
-  writeText(docFiles.progress, `${docs.progress}\n`);
-  writeText(docFiles.findings, `${docs.findings}\n`);
+  const pairs = [
+    [docFiles.taskPlan, docs.taskPlan],
+    [docFiles.progress, docs.progress],
+    [docFiles.findings, docs.findings],
+  ];
+  for (const [filePath, content] of pairs) {
+    if (!options.force && fs.existsSync(filePath)) {
+      const existing = fs.readFileSync(filePath, "utf8");
+      const isAutoGenerated = existing.includes(t("doc.autogenerated"));
+      if (!isAutoGenerated && existing.trim()) {
+        console.log(t("control.docsOverwriteWarning", { file: path.basename(filePath) }));
+        continue;
+      }
+    }
+    writeText(filePath, `${content}\n`);
+  }
 }
 
 /* ── task management ── */
@@ -396,6 +505,10 @@ function updateTask(root, control, action, taskId, note) {
     const nextStatus = actionMap[action];
     if (!nextStatus) throw new Error(t("cli.actionNotSupported", { action }));
 
+    if (task.status === nextStatus) {
+      console.log(t("control.taskAlreadyStatus", { taskId, status: nextStatus }));
+      return;
+    }
     task.status = nextStatus;
     if (nextStatus === "blocked") {
       task.blocker = note || task.blocker || t("cli.undocumentedBlocker");
@@ -432,66 +545,77 @@ function cmdStatus(root) {
   const drift = getDocDrift(context, control);
   const envAudit = env.auditEnvironment(context, control);
 
-  console.log(t("cli.status.title", { projectName: control.meta.projectName }));
-  console.log(t("cli.status.focus", { focus: control.meta.currentFocus }));
-  console.log(t("cli.status.activePhase", { phaseId: state.activePhase.id, phaseLabel: state.activePhase.label }));
-  console.log(`Layout: ${context.layout} | Workspace: ${context.workspaceRoot}`);
-  if (context.layout === "split") {
-    console.log(`App: ${context.appRoot}`);
-    console.log(`Ops: ${context.opsRoot}`);
-  }
-  if (control.meta?.opera?.bootstrap?.status) {
-    console.log(t("cli.status.bootstrap", { status: control.meta.opera.bootstrap.status, locale: config.getLocale(control) }));
-    if (control.meta.opera.bootstrap.mode) {
-      console.log(`Bootstrap mode: ${control.meta.opera.bootstrap.mode}`);
-    }
-    if (control.meta.opera.bootstrap.routeReason) {
-      console.log(`Bootstrap route: ${control.meta.opera.bootstrap.routeReason}`);
-    }
-  }
+  console.log(t("cli.status.title", { projectName: control.meta.projectName }));
+  console.log(t("cli.status.focus", { focus: control.meta.currentFocus }));
+  console.log(t("cli.status.activePhase", { phaseId: state.activePhase.id, phaseLabel: state.activePhase.label }));
+  console.log(t("cli.status.layout", { layout: context.layout, workspace: context.workspaceRoot }));
+  if (context.layout === "split") {
+    console.log(t("cli.status.appRoot", { path: context.appRoot }));
+    console.log(t("cli.status.opsRoot", { path: context.opsRoot }));
+  }
+  if (control.meta?.opera?.bootstrap?.status) {
+    console.log(t("cli.status.bootstrap", {
+      status: formatBootstrapStatus(control.meta.opera.bootstrap.status),
+      locale: config.getLocale(control),
+    }));
+    if (control.meta.opera.bootstrap.mode) {
+      console.log(t("cli.status.bootstrapMode", { value: formatBootstrapMode(control.meta.opera.bootstrap.mode) }));
+    }
+    if (control.meta.opera.bootstrap.routeReason) {
+      console.log(t("cli.status.bootstrapReason", { value: formatBootstrapReason(control.meta.opera.bootstrap.routeReason) }));
+    }
+  }
   console.log(t("cli.status.tasks", {
     completed: state.totals.completed, inProgress: state.totals.inProgress,
     inReview: state.totals.inReview, pending: state.totals.pending, blocked: state.totals.blocked,
   }));
   console.log("");
-  console.log(t("cli.status.readyTasks"));
-  if (state.readyTasks.length) {
-    state.readyTasks.slice(0, 5).forEach((task) => console.log(renderTask(task, phases)));
-  } else {
-    console.log(t("cli.status.noReadyTasks"));
-  }
+  console.log(t("cli.status.readyTasks"));
+  if (state.readyTasks.length) {
+    state.readyTasks.slice(0, 5).forEach((task) => console.log(renderTask(task, phases, { cli: true })));
+  } else {
+    console.log(t("cli.status.noReadyTasks"));
+  }
   console.log("");
-  console.log(t("cli.status.blockers"));
-  if (state.blockers.length) {
-    state.blockers.forEach((task) => console.log(renderTask(task, phases)));
-  } else {
-    console.log(t("cli.status.noBlockers"));
-  }
+  console.log(t("cli.status.blockers"));
+  if (state.blockers.length) {
+    state.blockers.forEach((task) => console.log(renderTask(task, phases, { cli: true })));
+  } else {
+    console.log(t("cli.status.noBlockers"));
+  }
   console.log("");
   console.log(t("cli.status.decisions"));
   if ((control.decisionsPending || []).length) {
     control.decisionsPending.forEach((d) => console.log(`- ${d.title} (${d.owner}) — ${d.impact}`));
   } else {
     console.log(`- ${t("cli.status.noDecisions")}`);
-  }
-  console.log("");
-  console.log(t("cli.status.repo"));
-  const treeStatus = repo.clean
-    ? t("cli.status.treeClean")
-    : t("cli.status.treeDirty", { staged: repo.staged, unstaged: repo.unstaged, untracked: repo.untracked });
-  console.log(`- ${t("cli.status.branch", { branch: repo.branch, treeStatus })}`);
-  if (repo.lastCommit) {
-    console.log(`- ${t("cli.status.lastCommit", { hash: repo.lastCommit.shortHash, subject: repo.lastCommit.subject })}`);
-  }
-  if (repo.ahead || repo.behind) {
-    console.log(`- ${t("cli.status.divergence", { ahead: repo.ahead, behind: repo.behind })}`);
-  }
-  console.log(`- ${t("cli.status.runtime", { path: path.relative(context.workspaceRoot, config.runtimeFilePath(context)) })}`);
-  console.log(`- Env present: ${envAudit.presentKeys.length ? envAudit.presentKeys.join(", ") : "none"}`);
-  console.log(`- Env missing: ${envAudit.missingKeys.length ? envAudit.missingKeys.join(", ") : "none"}`);
-  console.log("");
-  const syncStatus = drift.length
-    ? t("cli.status.docsSyncedNo", { files: drift.join(", ") })
+  }
+  console.log("");
+  console.log(t("cli.status.repo"));
+  if (!repo.available) {
+    console.log(`- ${t("cli.status.gitState", { state: t("cli.status.gitNotInitialized") })}`);
+    console.log(`- ${t("cli.status.gitAction")}`);
+  } else {
+    const branchLabel = repo.state === "detached" ? t("cli.status.branchDetached") : repo.branch;
+    const treeStatus = repo.clean
+      ? t("cli.status.treeClean")
+      : t("cli.status.treeDirty", { staged: repo.staged, unstaged: repo.unstaged, untracked: repo.untracked });
+    console.log(`- ${t("cli.status.branch", { branch: branchLabel, treeStatus })}`);
+    if (repo.lastCommit) {
+      console.log(`- ${t("cli.status.lastCommit", { hash: repo.lastCommit.shortHash, subject: repo.lastCommit.subject })}`);
+    }
+    if (!repo.hasUpstream) {
+      console.log(`- ${t("cli.status.noUpstream")}`);
+    } else if (repo.ahead || repo.behind) {
+      console.log(`- ${t("cli.status.divergence", { ahead: repo.ahead, behind: repo.behind })}`);
+    }
+  }
+  console.log(`- ${t("cli.status.runtime", { path: path.relative(context.workspaceRoot, config.runtimeFilePath(context)) })}`);
+  console.log(`- ${t("cli.status.envPresent", { value: listOrNone(envAudit.presentKeys) })}`);
+  console.log(`- ${t("cli.status.envMissing", { value: listOrNone(envAudit.missingKeys) })}`);
+  console.log("");
+  const syncStatus = drift.length
+    ? t("cli.status.docsSyncedNo", { files: drift.join(", ") })
     : t("cli.status.docsSyncedYes");
   console.log(t("cli.status.docsSynced", { status: syncStatus }));
 }
@@ -500,9 +624,22 @@ function cmdNext(root) {
   const context = config.ensureContext(root);
   initLocale(context);
   const control = config.loadControl(context);
-  const ready = derive(control).readyTasks.slice(0, 10);
+  const state = derive(control);
+  if (state.circularDeps.length) {
+    console.log(t("control.circularDependency", { taskIds: state.circularDeps.join(", ") }));
+  }
+  const ready = state.readyTasks.slice(0, 10);
   if (!ready.length) {
-    console.log(t("cli.noReadyTasks"));
+    if (state.projectCompleted) {
+      console.log(t("cli.noReadyTasks.allDone"));
+    } else if (state.blockers.length) {
+      console.log(t("cli.noReadyTasks.blocked", { count: state.blockers.length }));
+      for (const task of state.blockers.slice(0, 5)) {
+        console.log(`  - ${task.id}: ${task.blocker || task.title}`);
+      }
+    } else {
+      console.log(t("cli.noReadyTasks"));
+    }
     return;
   }
   ready.forEach((task, i) => {
@@ -513,12 +650,34 @@ function cmdNext(root) {
   });
 }
 
-function cmdSync(root) {
+function cmdSync(root, args) {
   const context = config.ensureContext(root);
   initLocale(context);
   const control = config.loadControl(context);
+  if ((args || []).includes("--dry-run")) {
+    const drift = getDocDrift(context, control);
+    if (drift.length) {
+      console.log(t("cli.sync.dryRunWouldUpdate", { files: drift.join(", ") }));
+    } else {
+      console.log(t("cli.sync.dryRunInSync"));
+    }
+    return;
+  }
+  const state = derive(control);
+  if (state.activePhase && control.meta.focusPhase !== state.activePhase.id) {
+    control.meta.focusPhase = state.activePhase.id;
+    config.saveControl(context, control);
+  }
   env.syncEnvironment(context, control);
-  syncDocs(context, control);
+  if (config.isOperaInstalled(control)) {
+    const bootstrap = require("./opera-bootstrap");
+    const result = bootstrap.revalidateContract(context, control);
+    if (result.changed) {
+      console.log(t("control.contractStale"));
+    }
+  }
+  const force = (args || []).includes("--force");
+  syncDocs(context, control, { force });
   refreshRepoRuntime(context, { quiet: true });
   console.log(t("cli.docsSynced"));
 }
@@ -593,11 +752,14 @@ function cmdHelp() {
   console.log("  skill install|list|remove|catalog <name>");
   console.log(`    ${t("cli.help.skill.desc")}`);
   console.log("  help");
-  console.log(`    ${t("cli.help.help.desc")}`);
-  console.log("");
-  console.log(t("cli.help.globalWorkflow"));
-  console.log(`  ${t("cli.help.globalWorkflow.line1")}`);
-  console.log(`  ${t("cli.help.globalWorkflow.line2")}`);
+  console.log(`    ${t("cli.help.help.desc")}`);
+  console.log("");
+  console.log(t("cli.help.globalFlags"));
+  console.log(`  ${t("cli.help.globalFlags.line1")}`);
+  console.log("");
+  console.log(t("cli.help.globalWorkflow"));
+  console.log(`  ${t("cli.help.globalWorkflow.line1")}`);
+  console.log(`  ${t("cli.help.globalWorkflow.line2")}`);
 }
 
 /* ── project-scoped API (used by server) ── */

package/lib/env.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 
-const fs = require("fs");
-const path = require("path");
-const config = require("./config");
+const fs = require("fs");
+const path = require("path");
+const config = require("./config");
+const { t, setLocale } = require("./i18n");
 
 const SERVICE_ENV_KEYS = {
   OpenAI: ["OPENAI_API_KEY"],
@@ -184,7 +185,7 @@ function syncEnvironment(contextOrRoot, controlState, options = {}) {
   return auditEnvironment(context, control);
 }
 
-function auditEnvironment(contextOrRoot, controlState) {
+function auditEnvironment(contextOrRoot, controlState) {
   const context = config.ensureContext(contextOrRoot);
   const control = controlState || config.loadControl(context);
   const envMeta = normalizeEnvironmentMeta(control, context);
@@ -206,30 +207,41 @@ function auditEnvironment(contextOrRoot, controlState) {
     presentKeys,
     missingKeys,
     lastAuditAt: envMeta.lastAuditAt,
-  };
-}
-
-function cmdStatus(contextOrRoot) {
-  const audit = auditEnvironment(contextOrRoot);
-  console.log("Environment:");
-  console.log(`  Root .env: ${audit.files.rootEnv}`);
-  console.log(`  Example: ${audit.files.rootExample}`);
-  console.log(`  App bridge: ${audit.files.appBridge}`);
-  console.log(`  Bridge mode: ${audit.bridgeMode}`);
-  console.log(`  Required keys: ${audit.requiredKeys.length ? audit.requiredKeys.join(", ") : "none"}`);
-  console.log(`  Present: ${audit.presentKeys.length ? audit.presentKeys.join(", ") : "none"}`);
-  console.log(`  Missing: ${audit.missingKeys.length ? audit.missingKeys.join(", ") : "none"}`);
-}
-
-function cmdSync(contextOrRoot) {
-  const context = config.ensureContext(contextOrRoot);
-  const control = config.loadControl(context);
-  const audit = syncEnvironment(context, control);
-  console.log(`Environment synced at ${path.relative(context.workspaceRoot, context.env.rootFile)}`);
-  if (audit.missingKeys.length) {
-    console.log(`Missing required keys: ${audit.missingKeys.join(", ")}`);
-  }
-}
+  };
+}
+
+function initLocale(contextOrRoot) {
+  try {
+    const control = config.loadControl(config.ensureContext(contextOrRoot));
+    setLocale(config.getLocale(control));
+  } catch (_error) {
+    setLocale("es");
+  }
+}
+
+function cmdStatus(contextOrRoot) {
+  initLocale(contextOrRoot);
+  const audit = auditEnvironment(contextOrRoot);
+  console.log(t("env.status.title"));
+  console.log(t("env.status.rootEnv", { path: audit.files.rootEnv }));
+  console.log(t("env.status.example", { path: audit.files.rootExample }));
+  console.log(t("env.status.appBridge", { path: audit.files.appBridge }));
+  console.log(t("env.status.bridgeMode", { value: audit.bridgeMode }));
+  console.log(t("env.status.required", { value: audit.requiredKeys.length ? audit.requiredKeys.join(", ") : t("locale.none") }));
+  console.log(t("env.status.present", { value: audit.presentKeys.length ? audit.presentKeys.join(", ") : t("locale.none") }));
+  console.log(t("env.status.missing", { value: audit.missingKeys.length ? audit.missingKeys.join(", ") : t("locale.none") }));
+}
+
+function cmdSync(contextOrRoot) {
+  initLocale(contextOrRoot);
+  const context = config.ensureContext(contextOrRoot);
+  const control = config.loadControl(context);
+  const audit = syncEnvironment(context, control);
+  console.log(t("env.sync.updated", { path: path.relative(context.workspaceRoot, context.env.rootFile) }));
+  if (audit.missingKeys.length) {
+    console.log(t("env.sync.missing", { value: audit.missingKeys.join(", ") }));
+  }
+}
 
 module.exports = {
   SERVICE_ENV_KEYS,

package/lib/i18n.js

@@ -38,10 +38,11 @@ function getLocale() {
 
 function t(key, params) {
   ensureLoaded();
-  let message =
-    currentMessages[key] ||
-    (fallbackMessages && fallbackMessages[key]) ||
-    key;
+  const found = currentMessages[key] || (fallbackMessages && fallbackMessages[key]);
+  let message = found || key;
+  if (!found && process.env.NODE_ENV !== "production" && process.env.TRACKOPS_DEBUG) {
+    process.stderr.write(`[i18n] Missing key: ${key}\n`);
+  }
   if (params) {
     message = message.replace(/\{(\w+)\}/g, (match, paramKey) =>
       params[paramKey] !== undefined ? String(params[paramKey]) : match