@synkro-sh/cli 1.6.50 → 1.6.51

package/dist/bootstrap.js

@@ -1239,6 +1239,29 @@ function parseSynkroYaml(raw: string): Record<string, any> {
 
 let _synkroFileCache: SynkroFileConfig | undefined;
 
+/** Map any provider alias to the internal pool token. */
+function normalizePoolToken(p: unknown): 'auto' | 'claude' | 'cursor' {
+  if (p === 'cursor') return 'cursor';
+  if (p === 'claude' || p === 'claude-code' || p === 'cc' || p === 'claude_code') return 'claude';
+  return 'auto';
+}
+
+/**
+ * Pull an explicit worker count for a provider, accepting both the unified
+ * grader-block form (grader: claude-code: N) and the legacy workers block
+ * (workers: claude: N). Provider aliases (claude / claude-code / cc) all match.
+ */
+function pickWorkerCount(parsed: any, kind: 'claude_code' | 'cursor'): number | undefined {
+  const keys = kind === 'cursor' ? ['cursor'] : ['claude-code', 'claude', 'cc', 'claude_code'];
+  for (const src of [parsed?.grader, parsed?.workers]) {
+    if (!src || typeof src !== 'object') continue;
+    for (const k of keys) {
+      if (typeof src[k] === 'number') return Math.max(0, Math.floor(src[k]));
+    }
+  }
+  return undefined;
+}
+
 export function loadSynkroFile(cwd?: string): SynkroFileConfig {
   if (_synkroFileCache) return _synkroFileCache;
   const root = cwd ? findGitRoot(cwd) : '';
@@ -1256,12 +1279,14 @@ export function loadSynkroFile(cwd?: string): SynkroFileConfig {
       version: parsed.version || 1,
       harness: harness.length > 0 ? harness : ['claude-code', 'cursor'],
       grader: {
-        pool: ['auto', 'claude', 'cursor'].includes(parsed.grader?.pool) ? parsed.grader.pool : 'auto',
+        pool: normalizePoolToken(parsed.grader?.pool),
         mode: ['local', 'byok'].includes(parsed.grader?.mode) ? parsed.grader.mode : undefined,
       },
       workers: {
-        ...(typeof parsed.workers?.claude === 'number' ? { claude: parsed.workers.claude } : {}),
-        ...(typeof parsed.workers?.cursor === 'number' ? { cursor: parsed.workers.cursor } : {}),
+        // Counts may live under the grader block (unified form) or the legacy
+        // workers block, keyed by claude / claude-code / cc / cursor.
+        ...(pickWorkerCount(parsed, 'claude_code') != null ? { claude: pickWorkerCount(parsed, 'claude_code') } : {}),
+        ...(pickWorkerCount(parsed, 'cursor') != null ? { cursor: pickWorkerCount(parsed, 'cursor') } : {}),
       },
       ruleset: typeof parsed.ruleset === 'string' ? parsed.ruleset : 'default',
       skills: Array.isArray(parsed.skills) ? parsed.skills.filter((s: unknown) => typeof s === 'string') : [],
@@ -1278,8 +1303,9 @@ export function loadSynkroFile(cwd?: string): SynkroFileConfig {
 }
 
 export function effectiveGraderPool(synkroFile: SynkroFileConfig, hookAgentKind: AgentKind): AgentKind {
-  if (synkroFile.grader.pool === 'auto') return hookAgentKind;
-  if (synkroFile.grader.pool === 'claude') return 'claude_code';
+  const pool = normalizePoolToken(synkroFile.grader.pool);
+  if (pool === 'auto') return hookAgentKind;
+  if (pool === 'claude') return 'claude_code';
   return 'cursor';
 }
 
@@ -1294,7 +1320,16 @@ export function synkroFilePresent(cwd?: string): boolean {
   try {
     const root = cwd ? findGitRoot(cwd) : '';
     if (!root) return false;
-    return existsSync(root + '/.synkro');
+    // ~/.synkro is Synkro's CONFIG DIRECTORY, not a repo marker. If the git root
+    // resolves to HOME (dotfiles tracked in git, or working in a non-git folder
+    // under ~), never treat it as onboarded \u2014 otherwise grading fires in every
+    // directory under home.
+    if (root === HOME) return false;
+    // A repo is onboarded ONLY via a regular .synkro FILE at its root. statSync +
+    // isFile is required because existsSync also matches a DIRECTORY named
+    // .synkro (exactly what ~/.synkro is) \u2014 the root cause of grading running in
+    // repos that have no .synkro file.
+    return statSync(root + '/.synkro').isFile();
   } catch { return false; }
 }
 
@@ -7396,7 +7431,10 @@ __export(dockerInstall_exports, {
   dockerStop: () => dockerStop,
   dockerUpdate: () => dockerUpdate,
   imageTag: () => imageTag,
+  normalizeProvider: () => normalizeProvider,
+  poolLabel: () => poolLabel,
   readContainerConfig: () => readContainerConfig,
+  resolveGraderPool: () => resolveGraderPool,
   resolveWorkerConfig: () => resolveWorkerConfig,
   splitWorkers: () => splitWorkers,
   waitForContainerReady: () => waitForContainerReady,
@@ -7423,6 +7461,39 @@ function normalizeProvider(p) {
   if (v === "cursor") return "cursor";
   return null;
 }
+function resolveGraderPool(parsed) {
+  const warnings = [];
+  const grader = parsed?.grader && typeof parsed.grader === "object" ? parsed.grader : {};
+  const counts = {};
+  const collect = (obj, where, flagUnknown) => {
+    if (!obj || typeof obj !== "object") return;
+    for (const [k, v] of Object.entries(obj)) {
+      if (typeof v !== "number") continue;
+      const np = normalizeProvider(k);
+      if (np === "claude_code") counts.claude_code = Math.max(0, Math.floor(v));
+      else if (np === "cursor") counts.cursor = Math.max(0, Math.floor(v));
+      else if (flagUnknown) {
+        warnings.push(`.synkro: ${where}.${k} is not a known provider (use claude-code or cursor) \u2014 ignored`);
+      }
+    }
+  };
+  collect(grader, "grader", true);
+  collect(parsed?.workers, "workers", false);
+  let pool = "auto";
+  const rawPool = grader.pool;
+  if (rawPool != null && rawPool !== "auto") {
+    const np = normalizeProvider(String(rawPool));
+    if (np) pool = np;
+    else warnings.push(`.synkro: grader.pool="${rawPool}" is not recognized (use auto | claude-code | cursor) \u2014 falling back to auto`);
+  }
+  if (counts.claude_code != null || counts.cursor != null) {
+    return { claudeWorkers: counts.claude_code, cursorWorkers: counts.cursor, pool, warnings };
+  }
+  return { pool, warnings };
+}
+function poolLabel(pool) {
+  return pool === "claude_code" ? "claude-code" : pool;
+}
 function parseSynkroYaml(raw) {
   const result = {};
   const lines = raw.split("\n");
@@ -7469,18 +7540,15 @@ function parseSynkroYaml(raw) {
 function readSynkroFileConfig() {
   try {
     const root = execSync4("git rev-parse --show-toplevel 2>/dev/null", { encoding: "utf-8", timeout: 3e3, stdio: ["pipe", "pipe", "pipe"] }).trim();
-    if (!root) return { pool: "auto" };
+    if (!root) return { pool: "auto", warnings: [] };
     const fp = join6(root, ".synkro");
-    if (!existsSync8(fp)) return { pool: "auto" };
+    if (!existsSync8(fp)) return { pool: "auto", warnings: [] };
     const raw = readFileSync6(fp, "utf-8");
     const parsed = raw.trimStart().startsWith("{") ? JSON.parse(raw) : parseSynkroYaml(raw);
-    const pool = ["auto", "claude", "cursor"].includes(parsed?.grader?.pool) ? parsed.grader.pool : "auto";
-    const cw = typeof parsed?.workers?.claude === "number" ? Math.max(0, Math.floor(parsed.workers.claude)) : void 0;
-    const curw = typeof parsed?.workers?.cursor === "number" ? Math.max(0, Math.floor(parsed.workers.cursor)) : void 0;
-    return { pool, claudeWorkers: cw, cursorWorkers: curw };
+    return resolveGraderPool(parsed);
   } catch {
   }
-  return { pool: "auto" };
+  return { pool: "auto", warnings: [] };
 }
 function resolveWorkerConfig(rest) {
   let workers = 8;
@@ -7516,6 +7584,7 @@ function resolveWorkerConfig(rest) {
   let provs = providers;
   if (provs.length === 0) {
     const sc = readSynkroFileConfig();
+    for (const w of sc.warnings) console.warn(`  \u26A0 ${w}`);
     if (sc.claudeWorkers != null || sc.cursorWorkers != null) {
       const cw = sc.claudeWorkers || 0;
       const curw = sc.cursorWorkers || 0;
@@ -7523,7 +7592,7 @@ function resolveWorkerConfig(rest) {
     }
     if (sc.pool === "cursor") {
       provs = ["cursor"];
-    } else if (sc.pool === "claude") {
+    } else if (sc.pool === "claude_code") {
       provs = ["claude_code"];
     } else {
       provs = detectAgents().map((a) => a.kind);
@@ -8647,7 +8716,7 @@ function writeConfigEnv(opts) {
     `SYNKRO_CREDENTIALS_PATH=${shellQuoteSingle(credsPath)}`,
     `SYNKRO_TIER=${shellQuoteSingle(safeTier)}`,
     `SYNKRO_INFERENCE=${shellQuoteSingle(safeInference)}`,
-    `SYNKRO_VERSION=${shellQuoteSingle("1.6.50")}`
+    `SYNKRO_VERSION=${shellQuoteSingle("1.6.51")}`
   ];
   if (safeSynkroBin) lines.push(`SYNKRO_CLI_BIN=${shellQuoteSingle(safeSynkroBin)}`);
   if (safeUserId) lines.push(`SYNKRO_USER_ID=${shellQuoteSingle(safeUserId)}`);
@@ -8842,8 +8911,9 @@ async function installCommand(opts = {}) {
     gradingMode = existingSynkro.grader.mode === "byok" ? "byok" : "local";
     storageMode = "local";
     console.log(`Using .synkro config:`);
+    for (const w of existingSynkro.warnings) console.warn(`  \u26A0 ${w}`);
     console.log(`  harness: ${existingSynkro.harness.join(", ")}`);
-    console.log(`  grading: ${gradingMode}    pool: ${existingSynkro.grader.pool}`);
+    console.log(`  grading: ${gradingMode}    pool: ${poolLabel(existingSynkro.grader.pool)}`);
     for (const a of agents) {
       console.log(`  \u2713 ${a.name}${a.version ? ` (${a.version})` : ""}`);
     }
@@ -9092,6 +9162,7 @@ async function installCommand(opts = {}) {
     }
     console.log("Installing Synkro server container...");
     const sf = readFullSynkroFile();
+    for (const w of sf?.warnings || []) console.warn(`  \u26A0 ${w}`);
     let claudeWorkers;
     let cursorWorkers;
     if (sf && (sf.workers.claude != null || sf.workers.cursor != null)) {
@@ -9104,18 +9175,18 @@ async function installCommand(opts = {}) {
       console.log(`  .synkro: explicit workers \u2014 ${claudeWorkers} claude + ${cursorWorkers} cursor`);
     } else {
       const totalWorkers = parseInt(process.env.SYNKRO_WORKERS_PER_POOL || "8", 10);
-      const synkroFilePool = sf?.grader?.pool || readSynkroFilePool();
+      const synkroFilePool = sf?.grader?.pool || "auto";
       let providers = [];
       if (synkroFilePool === "cursor") {
         providers = ["cursor"];
-      } else if (synkroFilePool === "claude") {
+      } else if (synkroFilePool === "claude_code") {
         providers = ["claude_code"];
       } else {
         if (hasClaudeCode) providers.push("claude_code");
         if (hasCursor) providers.push("cursor");
       }
       ({ claudeWorkers, cursorWorkers } = splitWorkers(totalWorkers, providers));
-      if (synkroFilePool !== "auto") console.log(`  .synkro: grader pool set to ${synkroFilePool}`);
+      if (synkroFilePool !== "auto") console.log(`  .synkro: grader pool set to ${poolLabel(synkroFilePool)}`);
     }
     console.log(`  worker pool: ${claudeWorkers} claude + ${cursorWorkers} cursor`);
     const connectedRepo = detectGitRepo2() || void 0;
@@ -9336,19 +9407,6 @@ function writeSynkroFileIfMissing(opts) {
   } catch {
   }
 }
-function readSynkroFilePool() {
-  try {
-    const root = execSync6("git rev-parse --show-toplevel", { encoding: "utf-8", timeout: 3e3, stdio: ["pipe", "pipe", "pipe"] }).trim();
-    if (!root) return "auto";
-    const fp = join8(root, ".synkro");
-    if (!existsSync10(fp)) return "auto";
-    const parsed = parseSynkroFileRaw(readFileSync8(fp, "utf-8"));
-    const pool = parsed?.grader?.pool;
-    if (pool === "cursor" || pool === "claude") return pool;
-  } catch {
-  }
-  return "auto";
-}
 function readFullSynkroFile() {
   try {
     const root = execSync6("git rev-parse --show-toplevel", { encoding: "utf-8", timeout: 3e3, stdio: ["pipe", "pipe", "pipe"] }).trim();
@@ -9358,16 +9416,18 @@ function readFullSynkroFile() {
     const parsed = parseSynkroFileRaw(readFileSync8(fp, "utf-8"));
     const valid = ["claude-code", "cursor"];
     const harness = Array.isArray(parsed.harness) ? parsed.harness.filter((h) => valid.includes(h)) : ["claude-code", "cursor"];
+    const resolved = resolveGraderPool(parsed);
     return {
       harness: harness.length > 0 ? harness : ["claude-code", "cursor"],
       grader: {
-        pool: ["auto", "claude", "cursor"].includes(parsed.grader?.pool) ? parsed.grader.pool : "auto",
+        pool: resolved.pool,
         mode: ["local", "byok"].includes(parsed.grader?.mode) ? parsed.grader.mode : "local"
       },
       workers: {
-        ...typeof parsed.workers?.claude === "number" ? { claude: parsed.workers.claude } : {},
-        ...typeof parsed.workers?.cursor === "number" ? { cursor: parsed.workers.cursor } : {}
+        ...resolved.claudeWorkers != null ? { claude: resolved.claudeWorkers } : {},
+        ...resolved.cursorWorkers != null ? { cursor: resolved.cursorWorkers } : {}
       },
+      warnings: resolved.warnings,
       ruleset: parsed.ruleset || "default",
       skills: Array.isArray(parsed.skills) ? parsed.skills.filter((s) => typeof s === "string" && s.endsWith(".md")) : [],
       scanning: { cwe: parsed.scanning?.cwe !== false, cve: parsed.scanning?.cve !== false },
@@ -9385,7 +9445,8 @@ function reconcileHarness() {
   }
   const wantCC = sf.harness.includes("claude-code");
   const wantCursor = sf.harness.includes("cursor");
-  console.log(`.synkro: harness=[${sf.harness.join(", ")}] pool=${sf.grader.pool} mode=${sf.grader.mode}`);
+  for (const w of sf.warnings) console.warn(`  \u26A0 ${w}`);
+  console.log(`.synkro: harness=[${sf.harness.join(", ")}] pool=${poolLabel(sf.grader.pool)} mode=${sf.grader.mode}`);
   const scripts = writeHookScripts(resolvePersistedHookMode());
   console.log("Wrote hook scripts to ~/.synkro/hooks/");
   const ccSettings = join8(homedir8(), ".claude", "settings.json");
@@ -9454,7 +9515,7 @@ function reconcileHarness() {
   const providers = [];
   if (sf.grader.pool === "cursor") {
     providers.push("cursor");
-  } else if (sf.grader.pool === "claude") {
+  } else if (sf.grader.pool === "claude_code") {
     providers.push("claude_code");
   } else {
     if (wantCC) providers.push("claude_code");
@@ -11839,7 +11900,7 @@ var args = process.argv.slice(2);
 var cmd = args[0] || "";
 var subArgs = args.slice(1);
 function printVersion() {
-  console.log("1.6.50");
+  console.log("1.6.51");
 }
 function printHelp2() {
   console.log(`Synkro CLI \u2014 runtime safety for AI coding agents