@synkro-sh/cli 1.6.31 → 1.6.33

package/dist/bootstrap.js

@@ -1131,6 +1131,73 @@ export function detectRepo(
   return '';
 }
 
+// \u2500\u2500\u2500 Git Root \u2500\u2500\u2500
+
+export function findGitRoot(cwd: string): string {
+  if (!cwd) return '';
+  try {
+    return execSync('git rev-parse --show-toplevel 2>/dev/null', { cwd, timeout: 2000, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+  } catch { return ''; }
+}
+
+// \u2500\u2500\u2500 .synkro file \u2500\u2500\u2500
+
+export interface SynkroFileConfig {
+  version: number;
+  harness: ('claude-code' | 'cursor')[];
+  grader: { pool: 'auto' | 'claude' | 'cursor'; mode?: string };
+  ruleset: string;
+  scanning: { cwe: boolean; cve: boolean };
+}
+
+const SYNKRO_FILE_DEFAULTS: SynkroFileConfig = {
+  version: 1,
+  harness: ['claude-code', 'cursor'],
+  grader: { pool: 'auto' },
+  ruleset: 'default',
+  scanning: { cwe: true, cve: true },
+};
+
+let _synkroFileCache: SynkroFileConfig | undefined;
+
+export function loadSynkroFile(cwd?: string): SynkroFileConfig {
+  if (_synkroFileCache) return _synkroFileCache;
+  const root = cwd ? findGitRoot(cwd) : '';
+  if (!root) { _synkroFileCache = SYNKRO_FILE_DEFAULTS; return _synkroFileCache; }
+  const fp = root + '/.synkro';
+  try {
+    if (!existsSync(fp)) { _synkroFileCache = SYNKRO_FILE_DEFAULTS; return _synkroFileCache; }
+    const parsed = JSON.parse(readFileSync(fp, 'utf-8'));
+    const validHarness = ['claude-code', 'cursor'] as const;
+    const harness = Array.isArray(parsed.harness)
+      ? parsed.harness.filter((h: string) => validHarness.includes(h as any))
+      : ['claude-code', 'cursor'];
+    _synkroFileCache = {
+      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',
+        mode: ['local', 'byok'].includes(parsed.grader?.mode) ? parsed.grader.mode : undefined,
+      },
+      ruleset: typeof parsed.ruleset === 'string' ? parsed.ruleset : 'default',
+      scanning: {
+        cwe: parsed.scanning?.cwe !== false,
+        cve: parsed.scanning?.cve !== false,
+      },
+    };
+    return _synkroFileCache;
+  } catch {
+    _synkroFileCache = SYNKRO_FILE_DEFAULTS;
+    return _synkroFileCache;
+  }
+}
+
+export function effectiveGraderPool(synkroFile: SynkroFileConfig, hookAgentKind: AgentKind): AgentKind {
+  if (synkroFile.grader.pool === 'auto') return hookAgentKind;
+  if (synkroFile.grader.pool === 'claude') return 'claude_code';
+  return 'cursor';
+}
+
 // \u2500\u2500\u2500 Channel Health \u2500\u2500\u2500
 
 export async function channelUp(port = 18929): Promise<boolean> {
@@ -1273,14 +1340,16 @@ export async function loadConfig(jwt: string, query?: string): Promise<HookConfi
 
 // \u2500\u2500\u2500 Routing \u2500\u2500\u2500
 
-export async function route(config: HookConfig): Promise<'local' | 'cloud'> {
+export async function route(config: HookConfig, synkroFile?: SynkroFileConfig): Promise<'local' | 'cloud'> {
+  const gradingMode = synkroFile?.grader?.mode || process.env.SYNKRO_GRADING_MODE || config.gradingMode || 'local';
+  if (gradingMode === 'byok') return 'cloud';
   if (config.captureDepth === 'local_only') return 'local';
   if (await channelUp()) return 'local';
   return 'cloud';
 }
 
-export async function cweRoute(config: HookConfig): Promise<'local' | 'byok' | 'skip'> {
-  const gradingMode = process.env.SYNKRO_GRADING_MODE || config.gradingMode || 'local';
+export async function cweRoute(config: HookConfig, synkroFile?: SynkroFileConfig): Promise<'local' | 'byok' | 'skip'> {
+  const gradingMode = synkroFile?.grader?.mode || process.env.SYNKRO_GRADING_MODE || config.gradingMode || 'local';
   if (gradingMode === 'byok') return 'byok';
   if (await cweChannelUp()) return 'local';
   return 'skip';
@@ -1288,10 +1357,11 @@ export async function cweRoute(config: HookConfig): Promise<'local' | 'byok' | '
 
 // \u2500\u2500\u2500 Tag Building \u2500\u2500\u2500
 
-export function tag(rt: string, config: HookConfig): string {
+export function tag(rt: string, config: HookConfig, grader?: string): string {
   if (config.silent) return '[synkro:silent]';
   const rs = config.policyName || 'all';
-  return '[synkro:' + rt + ':' + rs + ']';
+  const g = grader ? ':' + (grader === 'claude_code' ? 'claude' : grader) : '';
+  return '[synkro:' + rt + ':' + rs + g + ']';
 }
 
 // \u2500\u2500\u2500 Local Grading (direct channel call) \u2500\u2500\u2500
@@ -3077,6 +3147,22 @@ function cursorHookExit(): never {
 
 const UNAVAIL_LOG = join(HOME, '.synkro', 'grader-unavailable.log');
 
+export function isGraderNotConfigured(errorMessage: string): boolean {
+  const lower = errorMessage.toLowerCase();
+  return lower.includes('no worker') || lower.includes('not configured') || lower.includes('agent_kind') || lower.includes('no pool');
+}
+
+export function graderUnavailableMessage(hook: string, target: string, errorMessage: string, agentKind: AgentKind = 'claude_code'): string {
+  if (errorMessage === 'SYNKRO_CHANNEL_DOWN') {
+    return hook + ' ' + target + ' \u2192 local grader unavailable (container not running), skipped';
+  }
+  if (isGraderNotConfigured(errorMessage)) {
+    const agent = agentKind === 'cursor' ? 'Cursor' : 'Claude Code';
+    return hook + ' ' + target + ' \u2192 local grader not configured for ' + agent + '. Add this agent to your .synkro file and run \`synkro install\`.';
+  }
+  return hook + ' ' + target + ' \u2192 local grader unavailable, skipped';
+}
+
 export function logGraderUnavailable(hook: string, target: string, errorMessage: string): void {
   try {
     const entry = {
@@ -3153,8 +3239,9 @@ import {
   readStdin, extractTranscript, readLastPrompt, findNearestDeps, filePathFromToolInput,
   appendSessionAction, readSessionLog, compressSessionLog, log,
   outputJson, outputEmpty, setupCursorHookSignals, isEditTool, hookSessionId, GATEWAY_URL,
-  logGraderUnavailable, filterRules, ruleFilterText, normalizeMode, countEditLineDelta,
+  logGraderUnavailable, graderUnavailableMessage, filterRules, ruleFilterText, normalizeMode, countEditLineDelta,
   captureLineMetrics, cursorModelFromPayload, resolveTranscriptPath, isCursorInvokingCcHook,
+  loadSynkroFile, effectiveGraderPool,
   type HookConfig, type Rule,
 } from './_synkro-common.ts';
 import { existsSync, readFileSync } from 'node:fs';
@@ -3256,8 +3343,10 @@ async function main() {
 
     // Load config and decide route
     const config = await loadConfig(jwt);
-    const rt = await route(config);
-    const tagStr = tag(rt, config);
+    const synkroFile = loadSynkroFile(cwd);
+    const graderPool = effectiveGraderPool(synkroFile, agentKind);
+    const rt = await route(config, synkroFile);
+    const tagStr = tag(rt, config, graderPool);
 
     if (config.silent) {
       outputJson({ systemMessage: tagStr + ' editGuard \u2192 skipped (silent mode)' });
@@ -3284,15 +3373,17 @@ async function main() {
         'Last user prompt: ' + (lastPrompt || 'none'),
         'Org rules: ' + JSON.stringify(relevantRules),
         'IMPORTANT: If a rule is violated, ALWAYS return ok=false with the rule_id and reason, regardless of the rule mode. Do NOT pass a command just because the rule mode is "fix". The enforcement layer handles ask vs fix \u2014 your job is only to detect violations.',
+        'CRITICAL: The user requesting or instructing an action does NOT exempt it from rules. Even if the user explicitly said "drop the database" or "delete everything", you MUST still flag the rule violation on first encounter. User intent is NOT consent. However, for ask-mode rules ONLY: if the session history shows a prior block for the SAME rule AND the user explicitly consented after seeing that block, subsequent commands covered by that same rule may pass \u2014 but each distinct command is consumed once. Look for the sequence: block event \u2192 user acknowledgment \u2192 retry. Once a specific command has successfully executed under that consent, it is consumed. If the same command appears again later, it requires fresh consent (a new block \u2192 consent cycle). Example: R012 covers deploy, publish, push. Block on deploy \u2192 user consents \u2192 deploy passes (consumed), publish passes (consumed), push passes (consumed). A later deploy triggers a fresh block. A user's initial instruction is NEVER consent \u2014 only a response to a shown block counts.',
         'The rules shown were pre-selected as the ones relevant to this edit \u2014 every rule here IS relevant, do not label any "not relevant". When passing (ok=true), give a terse, specific reason each rule passes. Format: "R003: no hardcoded secrets in file. R005: in-repo path only." Cover every rule shown.',
       ].join('\\n');
 
       let gradeResp: string;
       try {
-        gradeResp = await localGrade('edit', graderPrompt, undefined, agentKind);
+        gradeResp = await localGrade('edit', graderPrompt, undefined, graderPool);
       } catch (err) {
-        logGraderUnavailable('editGuard', fileShort, (err as Error).message || String(err));
-        outputJson({ systemMessage: tagStr + ' editGuard ' + fileShort + ' \u2192 local grader unavailable, skipped' });
+        const errMsg = (err as Error).message || String(err);
+        logGraderUnavailable('editGuard', fileShort, errMsg);
+        outputJson({ systemMessage: tagStr + ' ' + graderUnavailableMessage('editGuard', fileShort, errMsg, graderPool) });
         return;
       }
 
@@ -3406,7 +3497,8 @@ import {
   localGradeCwe, parseVerdict, reconstructContent, readStdin, log,
   outputJson, outputEmpty, setupCursorHookSignals, isEditTool, isShellTool, isCursorHookFormat,
   extractShellCodeWrites, hookSessionId, filePathFromToolInput, emitBlockScanFindings, dispatchFinding, dispatchCapture, GATEWAY_URL,
-  logGraderUnavailable, resolveTranscriptPath, isCursorInvokingCcHook,
+  logGraderUnavailable, graderUnavailableMessage, resolveTranscriptPath, isCursorInvokingCcHook,
+  loadSynkroFile, effectiveGraderPool,
 } from './_synkro-common.ts';
 import { basename, extname, resolve, join, dirname } from 'node:path';
 import { readFileSync, readdirSync, existsSync } from 'node:fs';
@@ -3619,10 +3711,12 @@ async function main() {
     jwt = await ensureFreshJwt(jwt);
 
     const config = await loadConfig(jwt);
-    const rt = await cweRoute(config);
+    const synkroFile = loadSynkroFile(cwd);
+    const graderPool = effectiveGraderPool(synkroFile, agentKind);
+    const rt = await cweRoute(config, synkroFile);
 
     if (config.silent) {
-      outputJson({ systemMessage: '[synkro:' + rt + ':cweScan] skipped (silent mode)' });
+      outputJson({ systemMessage: '[synkro:' + rt + ':cweScan:' + (graderPool === 'claude_code' ? 'claude' : graderPool) + '] skipped (silent mode)' });
       return;
     }
 
@@ -3643,10 +3737,11 @@ async function main() {
       }
     }
 
-    const cweTag = '[synkro:' + rt + ':cweScan]';
+    const graderLabel = graderPool === 'claude_code' ? 'claude' : graderPool;
+    const cweTag = '[synkro:' + rt + ':cweScan:' + graderLabel + ']';
 
     if (rt === 'skip') {
-      outputJson({ systemMessage: cweTag + ' ' + fileShort + ' \u2192 local CWE grader unavailable, skipped' });
+      outputJson({ systemMessage: cweTag + ' ' + graderUnavailableMessage('cweGuard', fileShort, 'channel down', graderPool) });
       return;
     }
 
@@ -3828,23 +3923,23 @@ async function main() {
         const chunk2 = cweContent.slice(mid - OVERLAP);
         try {
           const [resp1, resp2] = await Promise.all([
-            localGradeCwe(buildCwePrompt(chunk1), agentKind),
-            localGradeCwe(buildCwePrompt(chunk2), agentKind),
+            localGradeCwe(buildCwePrompt(chunk1), graderPool),
+            localGradeCwe(buildCwePrompt(chunk2), graderPool),
           ]);
           gradeResponses = [resp1, resp2];
         } catch (gradeErr: any) {
           const reason = gradeErr?.message || String(gradeErr);
           logGraderUnavailable('cweGuard', fileShort, reason);
-          outputJson({ systemMessage: cweTag + ' ' + fileShort + ' \u2192 grader unavailable (' + reason + '), skipped' });
+          outputJson({ systemMessage: cweTag + ' ' + graderUnavailableMessage('cweGuard', fileShort, reason, graderPool) });
           return;
         }
       } else {
         try {
-          gradeResponses = [await localGradeCwe(buildCwePrompt(cweContent), agentKind)];
+          gradeResponses = [await localGradeCwe(buildCwePrompt(cweContent), graderPool)];
         } catch (gradeErr: any) {
           const reason = gradeErr?.message || String(gradeErr);
           logGraderUnavailable('cweGuard', fileShort, reason);
-          outputJson({ systemMessage: cweTag + ' ' + fileShort + ' \u2192 grader unavailable (' + reason + '), skipped' });
+          outputJson({ systemMessage: cweTag + ' ' + graderUnavailableMessage('cweGuard', fileShort, reason, graderPool) });
           return;
         }
       }
@@ -4244,7 +4339,7 @@ import {
   loadJwt, ensureFreshJwt, detectRepo, loadConfig, route, tag,
   readStdin, runInstallScan, emitBlockScanFindings, dispatchCapture, dispatchScanResult, hashCommand,
   outputJson, outputEmpty, setupCursorHookSignals, isShellTool, hookSessionId, log, GATEWAY_URL,
-  resolveTranscriptPath, isCursorHookFormat,
+  resolveTranscriptPath, isCursorHookFormat, loadSynkroFile, effectiveGraderPool,
 } from './_synkro-common.ts';
 import { writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
@@ -4290,11 +4385,13 @@ async function main() {
     const transcriptPath = resolveTranscriptPath(payload);
     const repo = detectRepo(cwd, transcriptPath, command, workspaceRoots);
     const config = await loadConfig(jwt);
-    const rt = await route(config);
-    const tagStr = tag(rt, config);
+    const isCursor = isCursorHookFormat();
+    const synkroFile = loadSynkroFile(cwd);
+    const graderPool = effectiveGraderPool(synkroFile, isCursor ? 'cursor' : 'claude_code');
+    const rt = await route(config, synkroFile);
+    const tagStr = tag(rt, config, graderPool);
 
     const rawModel = String(payload.model ?? payload.model_id ?? '');
-    const isCursor = isCursorHookFormat();
     const model = isCursor ? (rawModel ? (rawModel.startsWith('cursor/') ? rawModel : 'cursor/' + rawModel) : 'cursor') : (rawModel || '');
 
     if (scan.action === 'block') {
@@ -4362,7 +4459,8 @@ import {
   parseVerdict, dispatchCapture, dispatchFinding, ruleMode, postWithRetry, readStdin,
   extractTranscript, readLastPrompt, appendSessionAction, readSessionLog, compressSessionLog, log,
   outputJson, outputEmpty, setupCursorHookSignals, isShellTool, hookSessionId, GATEWAY_URL,
-  logGraderUnavailable, filterRules, ruleFilterText, normalizeMode, appendLocalTelemetry, isSafeInRepoRead,
+  logGraderUnavailable, graderUnavailableMessage, filterRules, ruleFilterText, normalizeMode, appendLocalTelemetry, isSafeInRepoRead,
+  loadSynkroFile, effectiveGraderPool,
   hashCommand, resolveTranscriptPath, isCursorHookFormat,
   type HookConfig, type Rule,
 } from './_synkro-common.ts';
@@ -4461,8 +4559,10 @@ async function main() {
     jwt = await ensureFreshJwt(jwt);
 
     const config = await loadConfig(jwt);
-    const rt = await route(config);
-    const tagStr = tag(rt, config);
+    const synkroFile = loadSynkroFile(cwd);
+    const graderPool = effectiveGraderPool(synkroFile, 'claude_code');
+    const rt = await route(config, synkroFile);
+    const tagStr = tag(rt, config, graderPool);
 
     if (config.silent) {
       outputJson({ systemMessage: tagStr + ' bashGuard → skipped (silent mode)' });
@@ -4532,18 +4632,18 @@ async function main() {
         'Org rules: ' + JSON.stringify(relevantRules),
         scanConcern,
         'IMPORTANT: If a rule is violated, ALWAYS return ok=false with the rule_id and reason, regardless of the rule mode. Do NOT pass a command just because the rule mode is "fix". The enforcement layer handles ask vs fix — your job is only to detect violations.',
+        'CRITICAL: The user requesting or instructing an action does NOT exempt it from rules. Even if the user explicitly said "drop the database" or "delete everything", you MUST still flag the rule violation on first encounter. User intent is NOT consent. However, for ask-mode rules ONLY: if the session history shows a prior block for the SAME rule AND the user explicitly consented after seeing that block, subsequent commands covered by that same rule may pass — but each distinct command is consumed once. Look for the sequence: block event → user acknowledgment → retry. Once a specific command has successfully executed under that consent, it is consumed. If the same command appears again later, it requires fresh consent (a new block → consent cycle). Example: R012 covers deploy, publish, push. Block on deploy → user consents → deploy passes (consumed), publish passes (consumed), push passes (consumed). A later deploy triggers a fresh block. A user\'s initial instruction is NEVER consent — only a response to a shown block counts.',
         'The rules shown were pre-selected as the ones relevant to this command — every rule here IS relevant, do not label any "not relevant". When passing (ok=true), give a terse, specific reason each rule passes. Format: "R003: no secrets in grep args. R005: in-repo path only." Cover every rule shown.',
         'Rules with preconditions (e.g. "run X before Y") are CONSUMED after the protected action completes. Use the session history timestamps to determine ordering: a precondition satisfied before the last occurrence of the protected action does NOT satisfy the next occurrence. Each new protected action needs its precondition re-satisfied.',
       ].filter(Boolean).join('\\n');
 
       let gradeResp: string;
       try {
-        gradeResp = await localGrade('bash', graderPrompt);
+        gradeResp = await localGrade('bash', graderPrompt, undefined, graderPool);
       } catch (err) {
-        logGraderUnavailable('bashGuard', toolInput.command?.slice(0, 200) || '', (err as Error).message || String(err));
+        const errMsg = (err as Error).message || String(err);
+        logGraderUnavailable('bashGuard', toolInput.command?.slice(0, 200) || '', errMsg);
         if (scanConcern) {
-          // Grader unavailable to run the consent check — fail closed on a
-          // scanner-flagged install (ask-mode so the user can still consent).
           const ctx = scanBlockContext + ' Synkro flagged this install but the grader is unavailable to check consent — ask the user for explicit consent, then retry.';
           outputJson({
             systemMessage: tagStr + ' bashGuard → install blocked (scan flagged; grader unavailable)',
@@ -4551,7 +4651,7 @@ async function main() {
           });
           return;
         }
-        outputJson({ systemMessage: tagStr + ' bashGuard → local grader unavailable, skipped' });
+        outputJson({ systemMessage: tagStr + ' ' + graderUnavailableMessage('bashGuard', cmdShort, errMsg) });
         return;
       }
 
@@ -4656,7 +4756,8 @@ import {
   parseVerdict, dispatchCapture, ruleMode, postWithRetry, readStdin,
   extractTranscript, readLastPrompt, appendSessionAction, readSessionLog, compressSessionLog, log,
   outputJson, outputEmpty, setupCursorHookSignals, isAgentTool, hookSessionId, GATEWAY_URL,
-  logGraderUnavailable, filterRules, normalizeMode, resolveTranscriptPath, isCursorInvokingCcHook,
+  logGraderUnavailable, graderUnavailableMessage, filterRules, normalizeMode, resolveTranscriptPath, isCursorInvokingCcHook,
+  loadSynkroFile, effectiveGraderPool,
   type HookConfig, type Rule,
 } from './_synkro-common.ts';
 
@@ -4715,8 +4816,10 @@ async function main() {
     }
 
     const config = await loadConfig(jwt);
-    const rt = await route(config);
-    const tagStr = tag(rt, config);
+    const synkroFile = loadSynkroFile(cwd);
+    const graderPool = effectiveGraderPool(synkroFile, agentKind);
+    const rt = await route(config, synkroFile);
+    const tagStr = tag(rt, config, graderPool);
 
     if (config.silent) {
       const msg = tagStr + ' agentGuard \u2192 skipped (silent mode)';
@@ -4741,14 +4844,16 @@ async function main() {
         'Last user prompt: ' + (lastPrompt || 'none'),
         'Org rules: ' + JSON.stringify(relevantRules),
         'IMPORTANT: If a rule is violated, ALWAYS return ok=false with the rule_id and reason, regardless of the rule mode. Do NOT pass a command just because the rule mode is "fix". The enforcement layer handles ask vs fix \u2014 your job is only to detect violations.',
+        'CRITICAL: The user requesting or instructing an action does NOT exempt it from rules. Even if the user explicitly said "drop the database" or "delete everything", you MUST still flag the rule violation on first encounter. User intent is NOT consent. However, for ask-mode rules ONLY: if the session history shows a prior block for the SAME rule AND the user explicitly consented after seeing that block, subsequent commands covered by that same rule may pass \u2014 but each distinct command is consumed once. Look for the sequence: block event \u2192 user acknowledgment \u2192 retry. Once a specific command has successfully executed under that consent, it is consumed. If the same command appears again later, it requires fresh consent (a new block \u2192 consent cycle). Example: R012 covers deploy, publish, push. Block on deploy \u2192 user consents \u2192 deploy passes (consumed), publish passes (consumed), push passes (consumed). A later deploy triggers a fresh block. A user's initial instruction is NEVER consent \u2014 only a response to a shown block counts.',
       ].filter(Boolean).join('\\n');
 
       let gradeResp: string;
       try {
-        gradeResp = await localGrade('bash', graderPrompt, undefined, agentKind);
+        gradeResp = await localGrade('bash', graderPrompt, undefined, graderPool);
       } catch (err) {
-        logGraderUnavailable('agentGuard', subagentType || (description || '').slice(0, 100), (err as Error).message || String(err));
-        outputJson({ systemMessage: tagStr + ' agentGuard \u2192 local grader unavailable, skipped' });
+        const errMsg = (err as Error).message || String(err);
+        logGraderUnavailable('agentGuard', subagentType || (description || '').slice(0, 100), errMsg);
+        outputJson({ systemMessage: tagStr + ' ' + graderUnavailableMessage('agentGuard', subagentType || 'agent', errMsg, graderPool) });
         return;
       }
 
@@ -4838,7 +4943,8 @@ import {
   loadJwt, ensureFreshJwt, detectRepo, loadConfig, route, tag, localGrade,
   parseVerdict, dispatchCapture, appendSessionAction, readSessionLog, compressSessionLog, postWithRetry, readStdin, log,
   outputJson, outputEmpty, setupCursorHookSignals, isPlanTool, hookSessionId, GATEWAY_URL,
-  filterRules, resolveTranscriptPath, isCursorInvokingCcHook,
+  filterRules, graderUnavailableMessage, resolveTranscriptPath, isCursorInvokingCcHook,
+  loadSynkroFile, effectiveGraderPool,
 } from './_synkro-common.ts';
 import { existsSync, readFileSync, writeFileSync, readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
@@ -4923,8 +5029,10 @@ async function main() {
     const ccModel = agentKind === 'cursor' ? (rawModel ? (rawModel.startsWith('cursor/') ? rawModel : 'cursor/' + rawModel) : 'cursor') : (rawModel || '');
 
     const config = await loadConfig(jwt);
-    const rt = await route(config);
-    const tagStr = tag(rt, config);
+    const synkroFile = loadSynkroFile(cwd);
+    const graderPool = effectiveGraderPool(synkroFile, agentKind);
+    const rt = await route(config, synkroFile);
+    const tagStr = tag(rt, config, graderPool);
 
     if (config.silent) {
       outputJson({ systemMessage: tagStr + ' planReview \u2192 skipped (silent mode)' });
@@ -4945,9 +5053,9 @@ async function main() {
 
       let gradeResp: string;
       try {
-        gradeResp = await localGrade('plan', graderPrompt, undefined, agentKind);
-      } catch {
-        outputJson({ systemMessage: tagStr + ' planReview \u2192 local grader unavailable, skipped' });
+        gradeResp = await localGrade('plan', graderPrompt, undefined, graderPool);
+      } catch (err) {
+        outputJson({ systemMessage: tagStr + ' ' + graderUnavailableMessage('planReview', 'plan', (err as Error).message || String(err), graderPool) });
         return;
       }
 
@@ -5090,7 +5198,7 @@ main();
 import {
   loadJwt, detectRepo, channelUp, tag, readStdin, writeCachedRepo,
   outputJson, outputEmpty, setupCursorHookSignals, hookSessionId, resolveTranscriptPath, GATEWAY_URL,
-  isLocalStorageMode, log, type HookConfig,
+  isLocalStorageMode, loadSynkroFile, log, type HookConfig,
 } from './_synkro-common.ts';
 
 async function main() {
@@ -5110,7 +5218,9 @@ async function main() {
     let jwt = loadJwt();
 
     const isChannelUp = await channelUp();
-    const rt = isChannelUp ? 'local' : 'cloud';
+    const synkroFile = loadSynkroFile(cwd);
+    const gradingMode = synkroFile.grader.mode || process.env.SYNKRO_GRADING_MODE || 'local';
+    const rt = gradingMode === 'byok' ? 'cloud' : (isChannelUp ? 'local' : 'cloud');
 
     let policyName = '';
     let silent = false;
@@ -5142,15 +5252,24 @@ async function main() {
       } catch {}
     }
 
-    const fakeConfig: HookConfig = { captureDepth: 'local_only', tier: 'standard', silent, policyName, rules: [] };
+    const fakeConfig: HookConfig = { captureDepth: 'local_only', tier: 'standard', silent, policyName, rules: [], scanExemptions: [], gradingMode, storageMode: process.env.SYNKRO_STORAGE_MODE || 'local' };
     const tagStr = tag(rt, fakeConfig);
-    const routeLine = tagStr + ' inference: ' + (isChannelUp ? 'local-cc (channel reachable on 127.0.0.1:18929)' : 'cloud (local-cc channel not reachable)');
+    const routeLine = tagStr + ' inference: ' + (gradingMode === 'byok' ? 'cloud (BYOK)' : isChannelUp ? 'local-cc (channel reachable on 127.0.0.1:18929)' : 'cloud (local-cc channel not reachable)');
 
     if (!jwt) {
       outputJson({ systemMessage: routeLine });
       return;
     }
 
+    // Sync grading mode to API profile so the dashboard reflects the actual config
+    const fastInference = gradingMode === 'byok';
+    fetch(GATEWAY_URL + '/api/v1/cli/me', {
+      method: 'PATCH',
+      headers: { 'Content-Type': 'application/json', Authorization: 'Bearer ' + jwt },
+      body: JSON.stringify({ fast_inference: fastInference }),
+      signal: AbortSignal.timeout(3000),
+    }).catch(() => {});
+
     if (!openFindings) {
       outputJson({ systemMessage: routeLine });
     } else if (openFindings === 1) {
@@ -5342,7 +5461,8 @@ import {
   parseVerdict, dispatchCapture, dispatchFinding, ruleMode, normalizeMode, filterRules, ruleFilterText,
   isSafeInRepoRead, resolveTranscriptPath, postWithRetry, readStdin, hashCommand,
   extractTranscript, readLastPrompt, readSessionLog, compressSessionLog,
-  appendLocalTelemetry, logGraderUnavailable, log, GATEWAY_URL,
+  appendLocalTelemetry, logGraderUnavailable, graderUnavailableMessage, log, GATEWAY_URL,
+  loadSynkroFile, effectiveGraderPool,
   type Rule,
 } from './_synkro-common.ts';
 import { createHash } from 'node:crypto';
@@ -5485,8 +5605,10 @@ async function main() {
     const config = await loadConfig(jwt);
     if (config.silent) finishAllow();
 
-    const rt = await route(config);
-    const tagStr = tag(rt, config);
+    const synkroFile = loadSynkroFile(cwd);
+    const graderPool = effectiveGraderPool(synkroFile, 'cursor');
+    const rt = await route(config, synkroFile);
+    const tagStr = tag(rt, config, graderPool);
 
     // Install protection \u2014 install-scan runs first and owns block traces.
     let scanConcern = '';
@@ -5521,13 +5643,14 @@ async function main() {
         'Org rules: ' + JSON.stringify(relevantRules),
         scanConcern,
         'IMPORTANT: If a rule is violated, ALWAYS return ok=false with the rule_id and reason, regardless of the rule mode. Do NOT pass a command just because the rule mode is "fix". The enforcement layer handles ask vs fix \u2014 your job is only to detect violations.',
+        'CRITICAL: The user requesting or instructing an action does NOT exempt it from rules. Even if the user explicitly said "drop the database" or "delete everything", you MUST still flag the rule violation on first encounter. User intent is NOT consent. However, for ask-mode rules ONLY: if the session history shows a prior block for the SAME rule AND the user explicitly consented after seeing that block, subsequent commands covered by that same rule may pass \u2014 but each distinct command is consumed once. Look for the sequence: block event \u2192 user acknowledgment \u2192 retry. Once a specific command has successfully executed under that consent, it is consumed. If the same command appears again later, it requires fresh consent (a new block \u2192 consent cycle). Example: R012 covers deploy, publish, push. Block on deploy \u2192 user consents \u2192 deploy passes (consumed), publish passes (consumed), push passes (consumed). A later deploy triggers a fresh block. A user's initial instruction is NEVER consent \u2014 only a response to a shown block counts.',
         'The rules shown were pre-selected as the ones relevant to this command \u2014 every rule here IS relevant, do not label any "not relevant". When passing (ok=true), give a terse, specific reason each rule passes. Format: "R003: no secrets in grep args. R005: in-repo path only." Cover every rule shown.',
         'Rules with preconditions (e.g. "run X before Y") are CONSUMED after the protected action completes. Use the session history timestamps to determine ordering: a precondition satisfied before the last occurrence of the protected action does NOT satisfy the next occurrence. Each new protected action needs its precondition re-satisfied.',
       ].filter(Boolean).join('\\n');
 
       let gradeResp: string;
       try {
-        gradeResp = await localGrade('bash', graderPrompt, CURSOR_GRADE_TIMEOUT_MS, 'cursor');
+        gradeResp = await localGrade('bash', graderPrompt, CURSOR_GRADE_TIMEOUT_MS, graderPool);
       } catch (e) {
         logGraderUnavailable('bashGuard', command.slice(0, 200), (e as Error).message || String(e));
         if (scanConcern) {
@@ -5539,8 +5662,9 @@ async function main() {
             agent_message: 'Synkro flagged this install: ' + scanBlockContext + ' The grader is unavailable to check consent \u2014 ask the user for explicit consent, then retry.',
           });
         }
-        log('bashGuard ' + cmdShort + ' \u2192 pass (grade unavailable): ' + String(e));
-        finishWith({ permission: 'allow' });
+        const errMsg = (e as Error).message || String(e);
+        log('bashGuard ' + cmdShort + ' \u2192 pass (grade unavailable): ' + errMsg);
+        finishWith({ permission: 'allow', user_message: tagStr + ' ' + graderUnavailableMessage('bashGuard', cmdShort, errMsg, graderPool) });
       }
 
       const verdict = parseVerdict(gradeResp);
@@ -6908,10 +7032,10 @@ __export(dockerInstall_exports, {
   splitWorkers: () => splitWorkers,
   waitForContainerReady: () => waitForContainerReady
 });
-import { copyFileSync, existsSync as existsSync7, mkdirSync as mkdirSync7, readdirSync as readdirSync2 } from "fs";
+import { copyFileSync, existsSync as existsSync7, mkdirSync as mkdirSync7, readFileSync as readFileSync6, readdirSync as readdirSync2 } from "fs";
 import { homedir as homedir6 } from "os";
 import { join as join6 } from "path";
-import { spawnSync as spawnSync2 } from "child_process";
+import { execSync as execSync4, spawnSync as spawnSync2 } from "child_process";
 function splitWorkers(total, providers) {
   const t = Math.max(0, Math.floor(total));
   const hasClaude = providers.includes("claude_code");
@@ -6929,6 +7053,19 @@ function normalizeProvider(p) {
   if (v === "cursor") return "cursor";
   return null;
 }
+function readSynkroFilePool() {
+  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 "auto";
+    const fp = join6(root, ".synkro");
+    if (!existsSync7(fp)) return "auto";
+    const parsed = JSON.parse(readFileSync6(fp, "utf-8"));
+    const pool = parsed?.grader?.pool;
+    if (pool === "cursor" || pool === "claude") return pool;
+  } catch {
+  }
+  return "auto";
+}
 function resolveWorkerConfig(rest) {
   let workers = 8;
   let explicit = false;
@@ -6962,8 +7099,15 @@ function resolveWorkerConfig(rest) {
   workers = Math.min(workers, 64);
   let provs = providers;
   if (provs.length === 0) {
-    provs = detectAgents().map((a) => a.kind);
-    if (provs.length === 0) provs = ["claude_code"];
+    const synkroPool = readSynkroFilePool();
+    if (synkroPool === "cursor") {
+      provs = ["cursor"];
+    } else if (synkroPool === "claude") {
+      provs = ["claude_code"];
+    } else {
+      provs = detectAgents().map((a) => a.kind);
+      if (provs.length === 0) provs = ["claude_code"];
+    }
   }
   return { ...splitWorkers(workers, provs), explicit };
 }
@@ -7368,15 +7512,15 @@ __export(setupGithub_exports, {
 });
 import { createInterface as createInterface2 } from "readline/promises";
 import { stdin as input, stdout as output } from "process";
-import { execSync as execSync4, spawn as nodeSpawn } from "child_process";
-import { existsSync as existsSync8, readFileSync as readFileSync6, unlinkSync as unlinkSync3 } from "fs";
+import { execSync as execSync5, spawn as nodeSpawn } from "child_process";
+import { existsSync as existsSync8, readFileSync as readFileSync7, unlinkSync as unlinkSync3 } from "fs";
 import { homedir as homedir7, platform as platform3 } from "os";
 import { join as join7 } from "path";
 import { execFile as execFile2 } from "child_process";
 function readConfig() {
   if (!existsSync8(CONFIG_PATH)) return {};
   const out = {};
-  for (const line of readFileSync6(CONFIG_PATH, "utf-8").split("\n")) {
+  for (const line of readFileSync7(CONFIG_PATH, "utf-8").split("\n")) {
     const t = line.trim();
     if (!t || t.startsWith("#")) continue;
     const eq = t.indexOf("=");
@@ -7446,7 +7590,7 @@ function captureClaudeSetupToken() {
     proc.on("close", (code) => {
       let raw = "";
       try {
-        raw = readFileSync6(tmpFile, "utf-8");
+        raw = readFileSync7(tmpFile, "utf-8");
       } catch (e) {
         reject(new Error(`Could not read script output file: ${e.message}`));
         return;
@@ -7578,7 +7722,7 @@ async function setupGithubCommand(opts = {}) {
       }
     } catch {
       try {
-        ghToken = execSync4("gh auth token", { encoding: "utf-8", timeout: 5e3 }).trim();
+        ghToken = execSync5("gh auth token", { encoding: "utf-8", timeout: 5e3 }).trim();
       } catch {
         console.error("GitHub not connected. Run `synkro-cli setup-github` interactively to connect.");
         return;
@@ -7612,7 +7756,7 @@ async function setupGithubCommand(opts = {}) {
     }
     console.log("  Validating token...");
     try {
-      const validateResult = execSync4(
+      const validateResult = execSync5(
         'claude --print --output-format json "say ok"',
         { env: { ...process.env, CLAUDE_CODE_OAUTH_TOKEN: claudeToken }, encoding: "utf-8", timeout: 3e4, stdio: ["ignore", "pipe", "pipe"] }
       );
@@ -7629,7 +7773,7 @@ async function setupGithubCommand(opts = {}) {
   if (opts.nonInteractive) {
     let currentFullName = null;
     try {
-      const remoteUrl = execSync4("git remote get-url origin", { encoding: "utf-8", timeout: 5e3 }).trim();
+      const remoteUrl = execSync5("git remote get-url origin", { encoding: "utf-8", timeout: 5e3 }).trim();
       const m = remoteUrl.match(/(?:github\.com)[:/](.+?)(?:\.git)?$/);
       if (m) currentFullName = m[1];
     } catch {
@@ -7728,12 +7872,14 @@ var install_exports = {};
 __export(install_exports, {
   detectGitRepo: () => detectGitRepo2,
   installCommand: () => installCommand,
-  parseArgs: () => parseArgs
+  parseArgs: () => parseArgs,
+  reconcileHarness: () => reconcileHarness,
+  writeHookScripts: () => writeHookScripts
 });
-import { existsSync as existsSync9, mkdirSync as mkdirSync8, writeFileSync as writeFileSync7, chmodSync as chmodSync2, readFileSync as readFileSync7, readdirSync as readdirSync3 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync8, writeFileSync as writeFileSync7, chmodSync as chmodSync2, readFileSync as readFileSync8, readdirSync as readdirSync3 } from "fs";
 import { homedir as homedir8 } from "os";
 import { join as join8 } from "path";
-import { execSync as execSync5, spawnSync as spawnSync3 } from "child_process";
+import { execSync as execSync6, spawnSync as spawnSync3 } from "child_process";
 import { createInterface as createInterface3 } from "readline";
 function sanitizeGatewayCandidate(raw) {
   if (!raw) return void 0;
@@ -7976,7 +8122,7 @@ function writeConfigEnv(opts) {
     `SYNKRO_CREDENTIALS_PATH=${shellQuoteSingle(credsPath)}`,
     `SYNKRO_TIER=${shellQuoteSingle(safeTier)}`,
     `SYNKRO_INFERENCE=${shellQuoteSingle(safeInference)}`,
-    `SYNKRO_VERSION=${shellQuoteSingle("1.6.31")}`
+    `SYNKRO_VERSION=${shellQuoteSingle("1.6.33")}`
   ];
   if (safeSynkroBin) lines.push(`SYNKRO_CLI_BIN=${shellQuoteSingle(safeSynkroBin)}`);
   if (safeUserId) lines.push(`SYNKRO_USER_ID=${shellQuoteSingle(safeUserId)}`);
@@ -7999,7 +8145,7 @@ function resolveDeploymentMode() {
   if (envOverride === "bare-host" || envOverride === "docker") return envOverride;
   try {
     if (existsSync9(CONFIG_PATH2)) {
-      const m = readFileSync7(CONFIG_PATH2, "utf-8").match(/^SYNKRO_DEPLOYMENT_MODE='([^']*)'/m);
+      const m = readFileSync8(CONFIG_PATH2, "utf-8").match(/^SYNKRO_DEPLOYMENT_MODE='([^']*)'/m);
       const val = m?.[1]?.toLowerCase();
       if (val === "bare-host" || val === "docker") return val;
     }
@@ -8007,40 +8153,41 @@ function resolveDeploymentMode() {
   }
   return "docker";
 }
-function collectLocalMetadata() {
+function collectLocalMetadata(includeClaudeCode = true) {
   const meta = { platform: process.platform };
   try {
-    meta.display_name = execSync5("git config user.name", { encoding: "utf-8", timeout: 3e3 }).trim();
+    meta.display_name = execSync6("git config user.name", { encoding: "utf-8", timeout: 3e3 }).trim();
   } catch {
   }
   try {
-    const remote = execSync5("git remote get-url origin", { encoding: "utf-8", timeout: 3e3, stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const remote = execSync6("git remote get-url origin", { encoding: "utf-8", timeout: 3e3, stdio: ["pipe", "pipe", "pipe"] }).trim();
     const sshMatch = remote.match(/^git@[^:]+:(.+?)(?:\.git)?$/);
     const httpMatch = remote.match(/^https?:\/\/[^/]+\/(.+?)(?:\.git)?$/);
     const m = sshMatch || httpMatch;
     if (m) meta.active_repo = m[1];
   } catch {
   }
+  if (!includeClaudeCode) return meta;
   try {
-    meta.cc_version = execSync5("claude --version", { encoding: "utf-8", timeout: 5e3 }).trim().split("\n")[0];
+    meta.cc_version = execSync6("claude --version", { encoding: "utf-8", timeout: 5e3 }).trim().split("\n")[0];
   } catch {
   }
   const claudeDir = join8(homedir8(), ".claude");
   try {
-    const settings = JSON.parse(readFileSync7(join8(claudeDir, "settings.json"), "utf-8"));
+    const settings = JSON.parse(readFileSync8(join8(claudeDir, "settings.json"), "utf-8"));
     const plugins = Object.keys(settings.enabledPlugins ?? {}).filter((k) => settings.enabledPlugins[k]);
     if (plugins.length) meta.enabled_plugins = plugins;
     if (settings.permissions?.defaultMode) meta.permissions_mode = settings.permissions.defaultMode;
   } catch {
   }
   try {
-    const mcpCache = JSON.parse(readFileSync7(join8(claudeDir, "mcp-needs-auth-cache.json"), "utf-8"));
+    const mcpCache = JSON.parse(readFileSync8(join8(claudeDir, "mcp-needs-auth-cache.json"), "utf-8"));
     const mcpNames = Object.keys(mcpCache);
     if (mcpNames.length) meta.mcp_servers = mcpNames;
   } catch {
   }
   try {
-    const mcpList = execSync5("claude mcp list 2>/dev/null", { encoding: "utf-8", timeout: 1e4 });
+    const mcpList = execSync6("claude mcp list 2>/dev/null", { encoding: "utf-8", timeout: 1e4 });
     const connected = mcpList.split("\n").filter((l) => l.includes("Connected")).map((l) => l.split(":")[0].trim()).filter(Boolean);
     if (connected.length) meta.mcp_servers_connected = connected;
   } catch {
@@ -8049,7 +8196,7 @@ function collectLocalMetadata() {
     const sessionsDir = join8(claudeDir, "sessions");
     const files = readdirSync3(sessionsDir).filter((f) => f.endsWith(".json")).slice(-5);
     for (const f of files) {
-      const s = JSON.parse(readFileSync7(join8(sessionsDir, f), "utf-8"));
+      const s = JSON.parse(readFileSync8(join8(sessionsDir, f), "utf-8"));
       if (s.version) {
         meta.cc_version = meta.cc_version || s.version;
         break;
@@ -8059,14 +8206,14 @@ function collectLocalMetadata() {
   }
   return meta;
 }
-async function fetchUserProfile(gatewayUrl, token) {
+async function fetchUserProfile(gatewayUrl, token, hasClaudeCode = true) {
   try {
     const resp = await fetch(`${gatewayUrl}/api/v1/cli/me`, {
       headers: { "Authorization": `Bearer ${token}` }
     });
     if (!resp.ok) return { tier: "pro", inference: "fast", localInference: false, captureDepth: "full" };
     const data = await resp.json();
-    const meta = collectLocalMetadata();
+    const meta = collectLocalMetadata(hasClaudeCode);
     fetch(`${gatewayUrl}/api/v1/cli/me`, {
       method: "PATCH",
       headers: { "Authorization": `Bearer ${token}`, "Content-Type": "application/json" },
@@ -8177,22 +8324,11 @@ async function installCommand(opts = {}) {
   }
   ensureSynkroDir();
   const scripts = writeHookScripts();
-  console.log("Wrote hook scripts:");
-  console.log(`  ${scripts.bashScript}`);
-  console.log(`  ${scripts.bashFollowupScript}`);
-  console.log(`  ${scripts.editPrecheckScript}`);
-  console.log(`  ${scripts.cwePrecheckScript}`);
-  console.log(`  ${scripts.cvePrecheckScript}`);
-  console.log(`  ${scripts.planJudgeScript}`);
-  console.log(`  ${scripts.agentJudgeScript}`);
-  console.log(`  ${scripts.stopSummaryScript}`);
-  console.log(`  ${scripts.sessionStartScript}`);
-  console.log(`  ${scripts.transcriptSyncScript}
-`);
+  console.log("Wrote hook scripts to ~/.synkro/hooks/\n");
   for (const mode of ["edit", "bash"]) {
     const pidFile = join8(SYNKRO_DIR4, "daemon", mode, "daemon.pid");
     try {
-      const pid = parseInt(readFileSync7(pidFile, "utf-8").trim(), 10);
+      const pid = parseInt(readFileSync8(pidFile, "utf-8").trim(), 10);
       if (pid > 0) {
         process.kill(pid, "SIGTERM");
         console.log(`Stopped stale ${mode} grader daemon (pid ${pid})`);
@@ -8262,7 +8398,7 @@ async function installCommand(opts = {}) {
     email = info.email;
   } catch {
   }
-  const profile = await fetchUserProfile(gatewayUrl, token);
+  const profile = await fetchUserProfile(gatewayUrl, token, hasClaudeCode);
   const cloudOnly = gradingMode === "byok" && storageMode === "cloud";
   const useLocalMcp = !cloudOnly;
   if (cloudOnly) {
@@ -8379,6 +8515,7 @@ async function installCommand(opts = {}) {
   } catch (err) {
     console.warn(`  \u26A0 Could not cache judge prompts: ${err.message}`);
   }
+  writeSynkroFileIfMissing({ hasClaudeCode, hasCursor, gradingMode });
   console.log();
   if (useLocalMcp) {
     const { assertDockerAvailable: assertDockerAvailable2 } = await Promise.resolve().then(() => (init_dockerInstall(), dockerInstall_exports));
@@ -8394,10 +8531,18 @@ async function installCommand(opts = {}) {
     }
     console.log("Installing Synkro server container...");
     const totalWorkers = parseInt(process.env.SYNKRO_WORKERS_PER_POOL || "8", 10);
-    const providers = [];
-    if (hasClaudeCode) providers.push("claude_code");
-    if (hasCursor) providers.push("cursor");
+    const synkroFilePool = readSynkroFilePool2();
+    let providers = [];
+    if (synkroFilePool === "cursor") {
+      providers = ["cursor"];
+    } else if (synkroFilePool === "claude") {
+      providers = ["claude_code"];
+    } else {
+      if (hasClaudeCode) providers.push("claude_code");
+      if (hasCursor) providers.push("cursor");
+    }
     const { claudeWorkers, cursorWorkers } = splitWorkers(totalWorkers, providers);
+    if (synkroFilePool !== "auto") console.log(`  .synkro: grader pool set to ${synkroFilePool}`);
     console.log(`  worker pool: ${claudeWorkers} claude + ${cursorWorkers} cursor`);
     const connectedRepo = detectGitRepo2() || void 0;
     const { image, hostMcpPort, hostGraderPort, hostCwePort, hostPglitePort } = await dockerInstall({ claudeWorkers, cursorWorkers, connectedRepo });
@@ -8407,7 +8552,7 @@ async function installCommand(opts = {}) {
     const ready = await waitForContainerReady(6e4);
     if (ready) {
       console.log("  \u2713 container ready");
-      const mcpJwt = readFileSync7(join8(SYNKRO_DIR4, ".mcp-jwt"), "utf-8").trim();
+      const mcpJwt = readFileSync8(join8(SYNKRO_DIR4, ".mcp-jwt"), "utf-8").trim();
       try {
         const ingestResp = await fetch(`http://127.0.0.1:${hostMcpPort}/api/ingest`, {
           method: "POST",
@@ -8431,14 +8576,14 @@ async function installCommand(opts = {}) {
     }
     console.log();
   }
-  if (transcriptConsent) {
+  if (transcriptConsent && hasClaudeCode) {
     const repo = detectGitRepo2();
     if (repo) {
       if (storageMode === "local") {
         try {
           let mcpToken = "";
           try {
-            mcpToken = readFileSync7(join8(SYNKRO_DIR4, ".mcp-jwt"), "utf-8").trim();
+            mcpToken = readFileSync8(join8(SYNKRO_DIR4, ".mcp-jwt"), "utf-8").trim();
           } catch {
           }
           if (mcpToken) {
@@ -8502,10 +8647,160 @@ async function installCommand(opts = {}) {
   }
   console.log("\u2713 Synkro installed.");
 }
+function writeSynkroFileIfMissing(opts) {
+  try {
+    const root = execSync6("git rev-parse --show-toplevel", { encoding: "utf-8", timeout: 3e3, stdio: ["pipe", "pipe", "pipe"] }).trim();
+    if (!root) return;
+    const fp = join8(root, ".synkro");
+    if (existsSync9(fp)) {
+      console.log(`  .synkro: ${fp} (existing, respected)`);
+      return;
+    }
+    let pool = "auto";
+    const harness = [];
+    if (opts.hasClaudeCode) {
+      harness.push("claude-code");
+      if (!opts.hasCursor) pool = "claude";
+    }
+    if (opts.hasCursor) {
+      harness.push("cursor");
+      if (!opts.hasClaudeCode) pool = "cursor";
+    }
+    const config = {
+      version: 1,
+      harness,
+      grader: {
+        pool,
+        mode: opts.gradingMode === "byok" ? "byok" : "local"
+      },
+      ruleset: "default",
+      scanning: { cwe: true, cve: true }
+    };
+    writeFileSync7(fp, JSON.stringify(config, null, 2) + "\n", "utf-8");
+    console.log(`  .synkro: wrote ${fp} (pool=${pool}, mode=${config.grader.mode})`);
+  } catch {
+  }
+}
+function readSynkroFilePool2() {
+  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 (!existsSync9(fp)) return "auto";
+    const parsed = JSON.parse(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();
+    if (!root) return null;
+    const fp = join8(root, ".synkro");
+    if (!existsSync9(fp)) return null;
+    const parsed = JSON.parse(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"];
+    return {
+      harness: harness.length > 0 ? harness : ["claude-code", "cursor"],
+      grader: {
+        pool: ["auto", "claude", "cursor"].includes(parsed.grader?.pool) ? parsed.grader.pool : "auto",
+        mode: ["local", "byok"].includes(parsed.grader?.mode) ? parsed.grader.mode : "local"
+      },
+      ruleset: parsed.ruleset || "default",
+      scanning: { cwe: parsed.scanning?.cwe !== false, cve: parsed.scanning?.cve !== false }
+    };
+  } catch {
+    return null;
+  }
+}
+function reconcileHarness() {
+  const sf = readFullSynkroFile();
+  if (!sf) {
+    console.log("No .synkro file found in repo root \u2014 skipping harness reconciliation.");
+    return null;
+  }
+  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}`);
+  const scripts = writeHookScripts();
+  console.log("Wrote hook scripts to ~/.synkro/hooks/");
+  const ccSettings = join8(homedir8(), ".claude", "settings.json");
+  if (wantCC) {
+    installCCHooks(ccSettings, {
+      bashJudgeScriptPath: scripts.bashScript,
+      bashFollowupScriptPath: scripts.bashFollowupScript,
+      editPrecheckScriptPath: scripts.editPrecheckScript,
+      cwePrecheckScriptPath: scripts.cwePrecheckScript,
+      cvePrecheckScriptPath: scripts.cvePrecheckScript,
+      planJudgeScriptPath: scripts.planJudgeScript,
+      agentJudgeScriptPath: scripts.agentJudgeScript,
+      stopSummaryScriptPath: scripts.stopSummaryScript,
+      sessionStartScriptPath: scripts.sessionStartScript,
+      transcriptSyncScriptPath: scripts.transcriptSyncScript,
+      userPromptSubmitScriptPath: scripts.userPromptSubmitScript,
+      installScanScriptPath: scripts.installScanScript
+    });
+    console.log("  \u2713 Claude Code hooks registered");
+    try {
+      const mcpJwt = readFileSync8(join8(SYNKRO_DIR4, ".mcp-jwt"), "utf-8").trim();
+      if (mcpJwt) {
+        installMcpConfig({ gatewayUrl: "", bearerToken: mcpJwt, local: true });
+        console.log("  \u2713 Claude Code MCP registered");
+      }
+    } catch {
+    }
+  } else {
+    if (uninstallCCHooks(ccSettings)) console.log("  \u2717 Claude Code hooks removed");
+    if (uninstallMcpConfig()) console.log("  \u2717 Claude Code MCP removed");
+  }
+  const cursorHooks = join8(homedir8(), ".cursor", "hooks.json");
+  if (wantCursor) {
+    installCursorHooks(cursorHooks, {
+      bashJudgeScriptPath: scripts.cursorBashJudgeScript,
+      editCaptureScriptPath: scripts.cursorEditCaptureScript,
+      agentCaptureScriptPath: scripts.cursorAgentCaptureScript,
+      bashFollowupScriptPath: scripts.bashFollowupScript,
+      editPrecheckScriptPath: scripts.editPrecheckScript,
+      cwePrecheckScriptPath: scripts.cwePrecheckScript,
+      cvePrecheckScriptPath: scripts.cvePrecheckScript,
+      planJudgeScriptPath: scripts.planJudgeScript,
+      agentJudgeScriptPath: scripts.agentJudgeScript,
+      stopSummaryScriptPath: scripts.stopSummaryScript,
+      sessionStartScriptPath: scripts.sessionStartScript,
+      userPromptSubmitScriptPath: scripts.userPromptSubmitScript,
+      transcriptSyncScriptPath: scripts.transcriptSyncScript,
+      installScanScriptPath: scripts.installScanScript
+    });
+    console.log("  \u2713 Cursor hooks registered");
+    try {
+      installCursorMcpConfig({ gatewayUrl: "", bearerToken: "", local: true });
+      console.log("  \u2713 Cursor MCP registered");
+    } catch {
+    }
+  } else {
+    if (uninstallCursorHooks(cursorHooks)) console.log("  \u2717 Cursor hooks removed");
+    if (uninstallCursorMcpConfig()) console.log("  \u2717 Cursor MCP removed");
+  }
+  const total = parseInt(process.env.SYNKRO_WORKERS_PER_POOL || "8", 10);
+  const providers = [];
+  if (sf.grader.pool === "cursor") {
+    providers.push("cursor");
+  } else if (sf.grader.pool === "claude") {
+    providers.push("claude_code");
+  } else {
+    if (wantCC) providers.push("claude_code");
+    if (wantCursor) providers.push("cursor");
+  }
+  if (providers.length === 0) providers.push("claude_code");
+  return splitWorkers(total, providers);
+}
 function detectGitRepo2() {
   const run = (cmd2) => {
     try {
-      return execSync5(cmd2, { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }).trim();
+      return execSync6(cmd2, { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }).trim();
     } catch {
       return "";
     }
@@ -8530,7 +8825,7 @@ function extractSessionInsights(projectsDir) {
     const sessionId = file.replace(".jsonl", "");
     const filePath = join8(projectsDir, file);
     try {
-      const content = readFileSync7(filePath, "utf-8");
+      const content = readFileSync8(filePath, "utf-8");
       const lines = content.split("\n").filter(Boolean);
       for (let i = 0; i < lines.length; i++) {
         try {
@@ -8606,7 +8901,7 @@ function extractTextContent(content) {
   return "";
 }
 function parseTranscriptFile(filePath) {
-  const content = readFileSync7(filePath, "utf-8");
+  const content = readFileSync8(filePath, "utf-8");
   const lines = content.split("\n").filter(Boolean);
   const messages = [];
   for (let i = 0; i < lines.length; i++) {
@@ -8676,7 +8971,7 @@ async function syncTranscriptsLocal(mcpPort, mcpToken, repo) {
       process.stdout.write(`\r  Progress: ${i + 1}/${files.length} sessions (${totalMessages} messages embedded)   `);
     }
     try {
-      const content = readFileSync7(join8(projectsDir, file), "utf-8");
+      const content = readFileSync8(join8(projectsDir, file), "utf-8");
       const lineCount = content.split("\n").filter(Boolean).length;
       writeFileSync7(join8(OFFSETS_DIR, sessionId), String(lineCount), "utf-8");
     } catch {
@@ -8730,7 +9025,7 @@ async function syncTranscriptsBulk(gatewayUrl, token, repo) {
       const sessionId = file.replace(".jsonl", "");
       const filePath = join8(projectsDir, file);
       try {
-        const content = readFileSync7(filePath, "utf-8");
+        const content = readFileSync8(filePath, "utf-8");
         const lineCount = content.split("\n").filter(Boolean).length;
         writeFileSync7(join8(OFFSETS_DIR, sessionId), String(lineCount), "utf-8");
       } catch {
@@ -8809,7 +9104,7 @@ rl.on('line', async (line) => {
 });
 
 // cli/local-cc/install.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync9, writeFileSync as writeFileSync8, readFileSync as readFileSync8, chmodSync as chmodSync3, copyFileSync as copyFileSync2, renameSync as renameSync4, unlinkSync as unlinkSync4, openSync, fsyncSync, closeSync } from "fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync9, writeFileSync as writeFileSync8, readFileSync as readFileSync9, chmodSync as chmodSync3, copyFileSync as copyFileSync2, renameSync as renameSync4, unlinkSync as unlinkSync4, openSync, fsyncSync, closeSync } from "fs";
 import { join as join9 } from "path";
 import { homedir as homedir9 } from "os";
 import { spawnSync as spawnSync4 } from "child_process";
@@ -8848,7 +9143,7 @@ function safelyMutateClaudeJson(mutator) {
   if (!existsSync10(CLAUDE_JSON_PATH)) {
     return;
   }
-  const originalText = readFileSync8(CLAUDE_JSON_PATH, "utf-8");
+  const originalText = readFileSync9(CLAUDE_JSON_PATH, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(originalText);
@@ -9418,7 +9713,7 @@ var init_disconnect = __esm({
 });
 
 // cli/local-cc/turnLog.ts
-import { appendFileSync, existsSync as existsSync12, mkdirSync as mkdirSync10, openSync as openSync2, readFileSync as readFileSync9, readSync, closeSync as closeSync2, statSync as statSync2, watchFile, unwatchFile } from "fs";
+import { appendFileSync, existsSync as existsSync12, mkdirSync as mkdirSync10, openSync as openSync2, readFileSync as readFileSync10, readSync, closeSync as closeSync2, statSync as statSync2, watchFile, unwatchFile } from "fs";
 import { dirname as dirname6, join as join11 } from "path";
 import { homedir as homedir11 } from "os";
 function truncate(s, max = PREVIEW_MAX) {
@@ -9460,7 +9755,7 @@ function readRecentTurns(n = 20) {
   try {
     const size = statSync2(TURN_LOG_PATH).size;
     if (size === 0) return [];
-    const text = readFileSync9(TURN_LOG_PATH, "utf-8");
+    const text = readFileSync10(TURN_LOG_PATH, "utf-8");
     const lines = text.split("\n").filter(Boolean);
     const lastN = lines.slice(-n).reverse();
     return lastN.map((line) => {
@@ -9906,13 +10201,13 @@ var init_pueue = __esm({
 });
 
 // cli/local-cc/settings.ts
-import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync11 } from "fs";
 import { homedir as homedir13 } from "os";
 import { join as join13 } from "path";
 function isLocalCCEnabled() {
   if (!existsSync13(CONFIG_PATH3)) return false;
   try {
-    const content = readFileSync10(CONFIG_PATH3, "utf-8");
+    const content = readFileSync11(CONFIG_PATH3, "utf-8");
     const match = content.match(/^SYNKRO_LOCAL_INFERENCE='([^']*)'/m);
     return match?.[1] === "yes";
   } catch {
@@ -9936,7 +10231,7 @@ import { spawnSync as spawnSync7 } from "child_process";
 import { homedir as homedir14 } from "os";
 import { join as join14 } from "path";
 import { readFileSync as fsReadFileSync, existsSync as fsExistsSync } from "fs";
-import { existsSync as existsSync14, readFileSync as readFileSync11, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "fs";
 function deploymentMode() {
   const env = (process.env.SYNKRO_DEPLOYMENT_MODE || "").toLowerCase();
   if (env === "docker") return "docker";
@@ -10043,14 +10338,14 @@ TROUBLESHOOTING
 }
 function readGatewayUrl() {
   if (existsSync14(CONFIG_PATH4)) {
-    const m = readFileSync11(CONFIG_PATH4, "utf-8").match(/^SYNKRO_GATEWAY_URL='([^']*)'/m);
+    const m = readFileSync12(CONFIG_PATH4, "utf-8").match(/^SYNKRO_GATEWAY_URL='([^']*)'/m);
     if (m) return m[1];
   }
   return "https://api.synkro.sh";
 }
 function updateLocalInferenceFlag(enabled) {
   if (!existsSync14(CONFIG_PATH4)) return;
-  let content = readFileSync11(CONFIG_PATH4, "utf-8");
+  let content = readFileSync12(CONFIG_PATH4, "utf-8");
   const flag = enabled ? "yes" : "no";
   if (content.includes("SYNKRO_LOCAL_INFERENCE=")) {
     content = content.replace(/^SYNKRO_LOCAL_INFERENCE='[^']*'/m, `SYNKRO_LOCAL_INFERENCE='${flag}'`);
@@ -10225,7 +10520,19 @@ function cmdStop() {
 }
 async function cmdRestart(rest = []) {
   if (inDockerMode()) {
-    const { claudeWorkers, cursorWorkers } = resolveWorkerConfig(rest);
+    const { explicit } = resolveWorkerConfig(rest);
+    let claudeWorkers;
+    let cursorWorkers;
+    if (explicit) {
+      ({ claudeWorkers, cursorWorkers } = resolveWorkerConfig(rest));
+    } else {
+      const reconciled = reconcileHarness();
+      if (reconciled) {
+        ({ claudeWorkers, cursorWorkers } = reconciled);
+      } else {
+        ({ claudeWorkers, cursorWorkers } = resolveWorkerConfig(rest));
+      }
+    }
     console.log(`Restarting synkro-server container (${claudeWorkers} claude + ${cursorWorkers} cursor, pulling latest image)...`);
     await dockerUpdate({ claudeWorkers, cursorWorkers });
     const ready = await waitForContainerReady(6e4);
@@ -10469,6 +10776,7 @@ var init_localCc = __esm({
     init_settings();
     init_macKeychain();
     init_dockerInstall();
+    init_install();
     init_client();
     init_stub();
     SYNKRO_CONFIG_PATH = join14(homedir14(), ".synkro", "config.env");
@@ -10579,13 +10887,13 @@ var config_exports = {};
 __export(config_exports, {
   configCommand: () => configCommand
 });
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync10, existsSync as existsSync15 } from "fs";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync10, existsSync as existsSync15 } from "fs";
 import { join as join15 } from "path";
 import { homedir as homedir15 } from "os";
 function readConfigEnv() {
   if (!existsSync15(CONFIG_PATH5)) return {};
   const out = {};
-  for (const line of readFileSync12(CONFIG_PATH5, "utf-8").split("\n")) {
+  for (const line of readFileSync13(CONFIG_PATH5, "utf-8").split("\n")) {
     const t = line.trim();
     if (!t || t.startsWith("#")) continue;
     const eq = t.indexOf("=");
@@ -10598,7 +10906,7 @@ function updateConfigValue(key, value) {
     console.error("No config found. Run `synkro install` first.");
     process.exit(1);
   }
-  const lines = readFileSync12(CONFIG_PATH5, "utf-8").split("\n");
+  const lines = readFileSync13(CONFIG_PATH5, "utf-8").split("\n");
   const pattern = new RegExp(`^${key}=`);
   let found = false;
   const updated = lines.map((line) => {
@@ -10725,14 +11033,14 @@ var init_config = __esm({
 });
 
 // cli/bootstrap.js
-import { readFileSync as readFileSync13, existsSync as existsSync16 } from "fs";
+import { readFileSync as readFileSync14, existsSync as existsSync16 } from "fs";
 import { resolve as resolve2 } from "path";
 var envCandidates = [
   resolve2(process.env.HOME ?? "", ".synkro", "config.env")
 ];
 for (const envPath of envCandidates) {
   if (!existsSync16(envPath)) continue;
-  const envContent = readFileSync13(envPath, "utf-8");
+  const envContent = readFileSync14(envPath, "utf-8");
   for (const line of envContent.split("\n")) {
     const trimmed = line.trim();
     if (!trimmed || trimmed.startsWith("#")) continue;
@@ -10747,7 +11055,7 @@ var args = process.argv.slice(2);
 var cmd = args[0] || "";
 var subArgs = args.slice(1);
 function printVersion() {
-  console.log("1.6.31");
+  console.log("1.6.33");
 }
 function printHelp2() {
   console.log(`Synkro CLI \u2014 runtime safety for AI coding agents