@synkro-sh/cli 1.4.65 → 1.4.67

package/dist/bootstrap.js

@@ -283,22 +283,32 @@ var init_ccHookConfig = __esm({
 });
 
 // cli/installer/cursorHookConfig.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2, renameSync as renameSync2, mkdirSync as mkdirSync2 } from "fs";
-import { dirname as dirname2 } from "path";
-function readHooksFile(path) {
-  if (!existsSync3(path)) return { version: 1, hooks: {} };
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, renameSync as renameSync2, mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname2, resolve, normalize } from "path";
+import { homedir as homedir2 } from "os";
+function validateHooksPath(path) {
+  const resolved = resolve(normalize(path));
+  if (!ALLOWED_PARENT_DIRS.some((dir) => resolved.startsWith(dir + "/") || resolved === dir)) {
+    throw new Error(`Hooks path must be under ~/.cursor or ~/.config/cursor, got: ${resolved}`);
+  }
+  return resolved;
+}
+function readHooksFile(rawPath) {
+  const safePath = validateHooksPath(rawPath);
   try {
-    const raw = readFileSync2(path, "utf-8");
+    const raw = readFileSync2(safePath, "utf-8");
     return JSON.parse(raw);
   } catch (err) {
-    throw new Error(`Failed to parse ${path}: ${err.message}`);
+    if (err?.code === "ENOENT") return { version: 1, hooks: {} };
+    throw new Error(`Failed to parse ${safePath}: ${err.message}`);
   }
 }
-function writeHooksFileAtomic(path, data) {
-  mkdirSync2(dirname2(path), { recursive: true });
-  const tmpPath = `${path}.synkro.tmp`;
-  writeFileSync2(tmpPath, JSON.stringify(data, null, 2) + "\n", "utf-8");
-  renameSync2(tmpPath, path);
+function writeHooksFileAtomic(rawPath, data) {
+  const safePath = validateHooksPath(rawPath);
+  mkdirSync2(dirname2(safePath), { recursive: true });
+  const tmpPath = `${safePath}.synkro.tmp`;
+  writeFileSync2(tmpPath, JSON.stringify(data, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
+  renameSync2(tmpPath, safePath);
 }
 function isSynkroEntry2(entry) {
   if (entry?.[SYNKRO_MARKER2]) return true;
@@ -314,10 +324,15 @@ function installCursorHooks(hooksJsonPath, config) {
   const file = readHooksFile(hooksJsonPath);
   file.version = file.version ?? 1;
   file.hooks = file.hooks ?? {};
-  const events = ["beforeShellExecution", "preToolUse", "afterFileEdit", "postToolUse"];
-  for (const evt of events) {
+  for (const evt of ALL_EVENTS) {
     removeSynkroEntries2(file.hooks, evt);
   }
+  file.hooks.sessionStart = file.hooks.sessionStart ?? [];
+  file.hooks.sessionStart.push({
+    command: config.sessionStartScriptPath,
+    timeout: 5,
+    [SYNKRO_MARKER2]: true
+  });
   file.hooks.beforeShellExecution = file.hooks.beforeShellExecution ?? [];
   file.hooks.beforeShellExecution.push({
     command: config.bashJudgeScriptPath,
@@ -346,14 +361,17 @@ function installCursorHooks(hooksJsonPath, config) {
   writeHooksFileAtomic(hooksJsonPath, file);
 }
 function uninstallCursorHooks(hooksJsonPath) {
-  if (!existsSync3(hooksJsonPath)) return false;
-  const file = readHooksFile(hooksJsonPath);
+  let file;
+  try {
+    file = readHooksFile(hooksJsonPath);
+  } catch {
+    return false;
+  }
   if (!file.hooks) return false;
-  const events = ["beforeShellExecution", "preToolUse", "afterFileEdit", "postToolUse"];
-  for (const evt of events) {
+  for (const evt of ALL_EVENTS) {
     removeSynkroEntries2(file.hooks, evt);
   }
-  for (const evt of events) {
+  for (const evt of ALL_EVENTS) {
     if (Array.isArray(file.hooks[evt]) && file.hooks[evt].length === 0) {
       delete file.hooks[evt];
     }
@@ -365,37 +383,46 @@ function uninstallCursorHooks(hooksJsonPath) {
   return true;
 }
 function inspectCursorHooks(hooksJsonPath) {
-  if (!existsSync3(hooksJsonPath)) {
-    return { installed: false, beforeShellExecution: false, preToolUse: false, afterFileEdit: false, postToolUse: false };
+  let file;
+  try {
+    file = readHooksFile(hooksJsonPath);
+  } catch {
+    return { installed: false, sessionStart: false, beforeShellExecution: false, preToolUse: false, afterFileEdit: false, postToolUse: false };
   }
-  const file = readHooksFile(hooksJsonPath);
   const h = file.hooks ?? {};
+  const sessionStart = (h.sessionStart ?? []).some((e) => isSynkroEntry2(e));
   const beforeShellExecution = (h.beforeShellExecution ?? []).some((e) => isSynkroEntry2(e));
   const preToolUse = (h.preToolUse ?? []).some((e) => isSynkroEntry2(e));
   const afterFileEdit = (h.afterFileEdit ?? []).some((e) => isSynkroEntry2(e));
   const postToolUse = (h.postToolUse ?? []).some((e) => isSynkroEntry2(e));
   return {
-    installed: beforeShellExecution || preToolUse || afterFileEdit || postToolUse,
+    installed: sessionStart || beforeShellExecution || preToolUse || afterFileEdit || postToolUse,
+    sessionStart,
     beforeShellExecution,
     preToolUse,
     afterFileEdit,
     postToolUse
   };
 }
-var SYNKRO_MARKER2;
+var SYNKRO_MARKER2, ALLOWED_PARENT_DIRS, ALL_EVENTS;
 var init_cursorHookConfig = __esm({
   "cli/installer/cursorHookConfig.ts"() {
     "use strict";
     SYNKRO_MARKER2 = "__synkro_managed__";
+    ALLOWED_PARENT_DIRS = [
+      resolve(homedir2(), ".cursor"),
+      resolve(homedir2(), ".config", "cursor")
+    ];
+    ALL_EVENTS = ["sessionStart", "beforeShellExecution", "preToolUse", "afterFileEdit", "postToolUse"];
   }
 });
 
 // cli/installer/mcpConfig.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync3, renameSync as renameSync3, mkdirSync as mkdirSync3 } from "fs";
-import { homedir as homedir2 } from "os";
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, renameSync as renameSync3, mkdirSync as mkdirSync3 } from "fs";
+import { homedir as homedir3 } from "os";
 import { dirname as dirname3, join as join2 } from "path";
 function readClaudeJson() {
-  if (!existsSync4(CC_CONFIG_PATH)) return {};
+  if (!existsSync3(CC_CONFIG_PATH)) return {};
   try {
     const raw = readFileSync3(CC_CONFIG_PATH, "utf-8");
     return JSON.parse(raw);
@@ -415,6 +442,23 @@ function installMcpConfig(opts) {
   for (const [name, entry] of Object.entries(config.mcpServers)) {
     if (entry?.[SYNKRO_MARKER3] === true) delete config.mcpServers[name];
   }
+  if (opts.local) {
+    const url2 = "http://127.0.0.1:8931/";
+    const tokenPath = join2(homedir3(), ".synkro", ".mcp-local-token");
+    let localToken = "";
+    try {
+      localToken = readFileSync3(tokenPath, "utf-8").trim();
+    } catch {
+    }
+    config.mcpServers[SYNKRO_SERVER_NAME] = {
+      type: "http",
+      url: url2,
+      ...localToken ? { headers: { Authorization: `Bearer ${localToken}` } } : {},
+      [SYNKRO_MARKER3]: true
+    };
+    writeClaudeJsonAtomic(config);
+    return { path: CC_CONFIG_PATH, url: url2 };
+  }
   const url = `${opts.gatewayUrl.replace(/\/$/, "")}/api/v1/mcp/guardrails`;
   config.mcpServers[SYNKRO_SERVER_NAME] = {
     type: "http",
@@ -426,7 +470,7 @@ function installMcpConfig(opts) {
   return { path: CC_CONFIG_PATH, url };
 }
 function uninstallMcpConfig() {
-  if (!existsSync4(CC_CONFIG_PATH)) return false;
+  if (!existsSync3(CC_CONFIG_PATH)) return false;
   const config = readClaudeJson();
   if (!config.mcpServers || Object.keys(config.mcpServers).length === 0) return false;
   let removed = false;
@@ -442,7 +486,7 @@ function uninstallMcpConfig() {
   return true;
 }
 function inspectMcpConfig() {
-  if (!existsSync4(CC_CONFIG_PATH)) {
+  if (!existsSync3(CC_CONFIG_PATH)) {
     return { installed: false, configPath: CC_CONFIG_PATH };
   }
   const config = readClaudeJson();
@@ -458,12 +502,12 @@ var init_mcpConfig = __esm({
     "use strict";
     SYNKRO_MARKER3 = "__synkro_managed__";
     SYNKRO_SERVER_NAME = "synkro-guardrails";
-    CC_CONFIG_PATH = join2(homedir2(), ".claude.json");
+    CC_CONFIG_PATH = join2(homedir3(), ".claude.json");
   }
 });
 
 // cli/installer/hookScripts.ts
-var SYNKRO_COMMON_SCRIPT, CURSOR_BASH_JUDGE_SCRIPT, CURSOR_EDIT_PRECHECK_SCRIPT, CURSOR_EDIT_CAPTURE_SCRIPT, CURSOR_BASH_FOLLOWUP_SCRIPT;
+var SYNKRO_COMMON_SCRIPT;
 var init_hookScripts = __esm({
   "cli/installer/hookScripts.ts"() {
     "use strict";
@@ -555,7 +599,32 @@ synkro_channel_up() {
 }
 
 # Fetch hook config. Sets SYNKRO_CAPTURE_DEPTH, SYNKRO_TIER, SYNKRO_RULES, SYNKRO_SILENT, SYNKRO_POLICY_NAME.
+_SYNKRO_RULES_FILE="$HOME/.synkro/rules.json"
+_SYNKRO_TELEMETRY_FILE="$HOME/.synkro/telemetry.jsonl"
+
 synkro_load_config() {
+  # Local-first: read from ~/.synkro/rules.json if it exists (zero latency, no network)
+  if [ -f "$_SYNKRO_RULES_FILE" ]; then
+    local rdata
+    rdata=$(cat "$_SYNKRO_RULES_FILE" 2>/dev/null)
+    if [ -n "$rdata" ]; then
+      SYNKRO_CAPTURE_DEPTH="local_only"
+      SYNKRO_TIER="standard"
+      SYNKRO_SILENT=$(echo "$rdata" | jq -r '.config.silent // false' 2>/dev/null)
+      local active_id
+      active_id=$(echo "$rdata" | jq -r '.config.activePolicyId // empty' 2>/dev/null)
+      if [ -n "$active_id" ]; then
+        SYNKRO_POLICY_NAME=$(echo "$rdata" | jq -r --arg id "$active_id" '.policies[]? | select(.id == $id) | .name // empty' 2>/dev/null)
+        SYNKRO_RULES=$(echo "$rdata" | jq -c --arg id "$active_id" '[.policies[]? | select(.id == $id) | .rules[]? | select(.hook_stage == "pre" or .hook_stage == "both" or .hook_stage == null) | {rule_id,text,severity,category,mode}]' 2>/dev/null || echo "[]")
+      else
+        SYNKRO_POLICY_NAME=$(echo "$rdata" | jq -r '.policies[0]?.name // empty' 2>/dev/null)
+        SYNKRO_RULES=$(echo "$rdata" | jq -c '[.policies[0]?.rules[]? | select(.hook_stage == "pre" or .hook_stage == "both" or .hook_stage == null) | {rule_id,text,severity,category,mode}]' 2>/dev/null || echo "[]")
+      fi
+      return
+    fi
+  fi
+
+  # Fallback: fetch from cloud API
   local resp
   resp=$(curl -sS "\${GATEWAY_URL}/api/v1/hook/config\${1:+?$1}" -H "Authorization: Bearer $JWT" --max-time 4 2>/dev/null || echo "")
   if [ -z "$resp" ]; then return; fi
@@ -566,6 +635,15 @@ synkro_load_config() {
   SYNKRO_RULES=$(echo "$resp" | jq -c '[.rules[]? | select(.hook_stage == "pre" or .hook_stage == "both" or .hook_stage == null) | {rule_id,text,severity,category,mode}]' 2>/dev/null || echo "[]")
 }
 
+synkro_local_capture() {
+  local event_json="$1"
+  local ts
+  ts=$(date -u +"%Y-%m-%dT%H:%M:%S.000Z")
+  local line
+  line=$(echo "$event_json" | jq -c --arg ts "$ts" '. + {_ts: $ts}' 2>/dev/null)
+  [ -n "$line" ] && printf '%s\\n' "$line" >> "$_SYNKRO_TELEMETRY_FILE" 2>/dev/null
+}
+
 synkro_tag() {
   if [ "$SYNKRO_SILENT" = "true" ]; then echo "[synkro:silent]"; return; fi
   local route="\${1:-$(synkro_route)}"
@@ -619,227 +697,12 @@ synkro_post_with_retry() {
   fi
   echo "$resp"
 }
-`;
-    CURSOR_BASH_JUDGE_SCRIPT = `#!/bin/bash
-SCRIPT_DIR="$(cd "$(dirname "\${BASH_SOURCE[0]}")" && pwd)"
-. "$SCRIPT_DIR/_synkro-common.sh"
-
-JWT=$(synkro_load_jwt)
-if [ -z "$JWT" ]; then echo '{}'; exit 0; fi
-synkro_ensure_fresh_jwt
-
-PAYLOAD=$(cat)
-if [ -z "$PAYLOAD" ]; then echo '{}'; exit 0; fi
-
-COMMAND=$(echo "$PAYLOAD" | jq -r '.command // empty' 2>/dev/null)
-if [ -z "$COMMAND" ]; then echo '{}'; exit 0; fi
-
-CWD=$(echo "$PAYLOAD" | jq -r '.cwd // empty' 2>/dev/null)
-SESSION_ID=$(echo "$PAYLOAD" | jq -r '.conversation_id // empty' 2>/dev/null)
-GIT_REPO=$(synkro_detect_repo "\${CWD:-.}")
-
-CMD_SHORT=$(printf '%s' "$COMMAND" | head -c 80)
-synkro_log "bashGuard checking: $CMD_SHORT"
-
-synkro_load_config
-if [ "$SYNKRO_SILENT" = "true" ]; then
-  echo '{}'; exit 0
-fi
-
-BODY=$(jq -n \\
-  --arg cmd "$COMMAND" \\
-  --arg session_id "$SESSION_ID" \\
-  --arg cwd "$CWD" \\
-  --arg repo "$GIT_REPO" \\
-  '{
-    hook_event: "PreToolUse",
-    tool_name: "Bash",
-    tool_input: {command: $cmd},
-    response_format: "cursor",
-    session_id: (if ($session_id | length) > 0 then $session_id else null end),
-    cwd: (if ($cwd | length) > 0 then $cwd else null end),
-    repo: (if ($repo | length) > 0 then $repo else null end)
-  }')
-
-RESP=$(synkro_post_with_retry "\${GATEWAY_URL}/api/v1/hook/judge" "$BODY" 6)
-
-if [ -z "$RESP" ]; then
-  synkro_log "bashGuard $CMD_SHORT \u2192 error (timeout)"
-  echo '{}'; exit 0
-fi
-
-# Server returns cursor-format directly in hook_response
-if echo "$RESP" | jq -e '.hook_response' >/dev/null 2>&1; then
-  echo "$RESP" | jq -c '.hook_response'
-else
-  echo '{}'
-fi
-exit 0
-`;
-    CURSOR_EDIT_PRECHECK_SCRIPT = `#!/bin/bash
-SCRIPT_DIR="$(cd "$(dirname "\${BASH_SOURCE[0]}")" && pwd)"
-. "$SCRIPT_DIR/_synkro-common.sh"
-
-JWT=$(synkro_load_jwt)
-if [ -z "$JWT" ]; then echo '{}'; exit 0; fi
-synkro_ensure_fresh_jwt
-
-PAYLOAD=$(cat)
-if [ -z "$PAYLOAD" ]; then echo '{}'; exit 0; fi
-
-TOOL_NAME=$(echo "$PAYLOAD" | jq -r '.tool_name // empty' 2>/dev/null)
-CWD=$(echo "$PAYLOAD" | jq -r '.cwd // empty' 2>/dev/null)
-SESSION_ID=$(echo "$PAYLOAD" | jq -r '.conversation_id // empty' 2>/dev/null)
-GIT_REPO=$(synkro_detect_repo "\${CWD:-.}")
-
-FILE_PATH=$(echo "$PAYLOAD" | jq -r '.tool_input.file_path // .tool_input.path // .tool_input.target_file // empty' 2>/dev/null)
-CONTENT=$(echo "$PAYLOAD" | jq -r '.tool_input.content // .tool_input.new_string // .tool_input.code_edit // empty' 2>/dev/null)
-if [ -z "$FILE_PATH" ]; then echo '{}'; exit 0; fi
-
-BASENAME=$(basename "$FILE_PATH" 2>/dev/null || echo "$FILE_PATH")
-synkro_log "editGuard checking: $BASENAME"
-
-synkro_load_config
-if [ "$SYNKRO_SILENT" = "true" ]; then
-  echo '{}'; exit 0
-fi
-
-BODY=$(jq -n \\
-  --arg file_path "$FILE_PATH" \\
-  --arg content "$CONTENT" \\
-  --arg session_id "$SESSION_ID" \\
-  --arg cwd "$CWD" \\
-  --arg repo "$GIT_REPO" \\
-  '{
-    hook_event: "PreToolUse",
-    tool_name: "Edit",
-    tool_input: {file_path: $file_path, content: $content},
-    file_path: $file_path,
-    content: $content,
-    response_format: "cursor",
-    session_id: (if ($session_id | length) > 0 then $session_id else null end),
-    cwd: (if ($cwd | length) > 0 then $cwd else null end),
-    repo: (if ($repo | length) > 0 then $repo else null end)
-  }')
-
-RESP=$(synkro_post_with_retry "\${GATEWAY_URL}/api/v1/hook/judge" "$BODY" 8)
-
-if [ -z "$RESP" ]; then
-  synkro_log "editGuard $BASENAME \u2192 error (timeout)"
-  echo '{}'; exit 0
-fi
-
-if echo "$RESP" | jq -e '.hook_response' >/dev/null 2>&1; then
-  echo "$RESP" | jq -c '.hook_response'
-else
-  echo '{}'
-fi
-exit 0
-`;
-    CURSOR_EDIT_CAPTURE_SCRIPT = `#!/bin/bash
-SCRIPT_DIR="$(cd "$(dirname "\${BASH_SOURCE[0]}")" && pwd)"
-. "$SCRIPT_DIR/_synkro-common.sh"
-
-JWT=$(synkro_load_jwt)
-if [ -z "$JWT" ]; then echo '{}'; exit 0; fi
-
-PAYLOAD=$(cat)
-if [ -z "$PAYLOAD" ]; then echo '{}'; exit 0; fi
-
-FILE_PATH=$(echo "$PAYLOAD" | jq -r '.file_path // empty' 2>/dev/null)
-if [ -z "$FILE_PATH" ]; then echo '{}'; exit 0; fi
-
-CWD=$(echo "$PAYLOAD" | jq -r '.cwd // .workspace_roots[0] // empty' 2>/dev/null)
-SESSION_ID=$(echo "$PAYLOAD" | jq -r '.conversation_id // empty' 2>/dev/null)
-GIT_REPO=$(synkro_detect_repo "\${CWD:-.}")
-BASENAME=$(basename "$FILE_PATH" 2>/dev/null || echo "$FILE_PATH")
-
-FULL_PATH="$FILE_PATH"
-[ -n "$CWD" ] && FULL_PATH="$CWD/$FILE_PATH"
-FULL_CONTENT=""
-[ -f "$FULL_PATH" ] && FULL_CONTENT=$(head -c 50000 "$FULL_PATH" 2>/dev/null || true)
-
-DEPS_JSON="{}"
-_PKG_DIR="\${CWD:-.}"
-while [ "$_PKG_DIR" != "/" ]; do
-  if [ -f "$_PKG_DIR/package.json" ]; then
-    DEPS_JSON=$(jq -c '(.dependencies // {}) + (.devDependencies // {})' "$_PKG_DIR/package.json" 2>/dev/null || echo "{}")
-    break
-  fi
-  _PKG_DIR=$(dirname "$_PKG_DIR")
-done
-
-synkro_log "editScan $BASENAME"
-
-(
-  BODY=$(jq -n \\
-    --arg file_path "$FILE_PATH" --arg content "$FULL_CONTENT" \\
-    --arg session_id "$SESSION_ID" --arg cwd "$CWD" --arg repo "$GIT_REPO" \\
-    --argjson deps "$DEPS_JSON" \\
-    '{capture_type:"edit_scan",tool_input:{file_path:$file_path,content:$content},edit_verdict:{ok:true},dependencies:$deps}
-      + (if ($session_id | length) > 0 then {session_id:$session_id} else {} end)
-      + (if ($cwd | length) > 0 then {cwd:$cwd} else {} end)
-      + (if ($repo | length) > 0 then {repo:$repo} else {} end)')
-  curl -sS -X POST "\${GATEWAY_URL}/api/v1/hook/capture" \\
-    -H "Content-Type: application/json" -H "Authorization: Bearer $JWT" \\
-    -d "$BODY" --max-time 10 >/dev/null 2>&1 || true
-) &
-disown 2>/dev/null || true
-
-echo '{}'
-exit 0
-`;
-    CURSOR_BASH_FOLLOWUP_SCRIPT = `#!/bin/bash
-SCRIPT_DIR="$(cd "$(dirname "\${BASH_SOURCE[0]}")" && pwd)"
-. "$SCRIPT_DIR/_synkro-common.sh"
-
-JWT=$(synkro_load_jwt)
-if [ -z "$JWT" ]; then echo '{}'; exit 0; fi
-
-PAYLOAD=$(cat)
-TOOL_NAME=$(echo "$PAYLOAD" | jq -r '.tool_name // empty' 2>/dev/null)
-case "$TOOL_NAME" in Shell|Bash|terminal|run_terminal_cmd|execute_command) ;; *) echo '{}'; exit 0 ;; esac
-
-SESSION_ID=$(echo "$PAYLOAD" | jq -r '.conversation_id // empty' 2>/dev/null)
-TOOL_USE_ID=$(echo "$PAYLOAD" | jq -r '.tool_use_id // empty' 2>/dev/null)
-
-IS_ERROR=$(echo "$PAYLOAD" | jq -r '.tool_result.is_error // false' 2>/dev/null)
-CMD=$(echo "$PAYLOAD" | jq -r '.tool_input.command // empty' 2>/dev/null)
-CMD_HASH=""
-if [ -n "$CMD" ]; then
-  CMD_HASH=$(printf '%s' "$CMD" | shasum -a 256 | cut -c1-16)
-fi
-
-if [ -n "$CMD_HASH" ] && [ -n "$SESSION_ID" ]; then
-  if [ "$IS_ERROR" = "false" ]; then
-    synkro_consent_consume "$SESSION_ID" "$CMD_HASH"
-  else
-    if ! synkro_consent_has_active "$SESSION_ID" "$CMD_HASH"; then
-      synkro_consent_grant "$SESSION_ID" "$CMD_HASH"
-    fi
-  fi
-fi
-
-if [ -n "$SESSION_ID" ] && [ -n "$TOOL_USE_ID" ]; then
-  (
-    BODY=$(jq -n --arg sid "$SESSION_ID" --arg tid "$TOOL_USE_ID" \\
-      --argjson err "$IS_ERROR" --arg ch "$CMD_HASH" \\
-      '{capture_type:"bash_followup",session_id:$sid,tool_use_id:$tid,is_error:$err,command_hash:$ch}')
-    curl -sS -X POST "\${GATEWAY_URL}/api/v1/hook/capture" \\
-      -H "Content-Type: application/json" -H "Authorization: Bearer $JWT" \\
-      -d "$BODY" --max-time 3 >/dev/null 2>&1 || true
-  ) &
-  disown 2>/dev/null || true
-fi
-
-echo '{}'
-exit 0
 `;
   }
 });
 
 // cli/installer/hookScriptsTs.ts
-var SYNKRO_COMMON_TS, EDIT_PRECHECK_TS, CWE_PRECHECK_TS, CVE_PRECHECK_TS, BASH_JUDGE_TS, AGENT_JUDGE_TS, PLAN_JUDGE_TS, STOP_SUMMARY_TS, SESSION_START_TS, BASH_FOLLOWUP_TS, TRANSCRIPT_SYNC_TS, USER_PROMPT_SUBMIT_TS;
+var SYNKRO_COMMON_TS, EDIT_PRECHECK_TS, CWE_PRECHECK_TS, CVE_PRECHECK_TS, BASH_JUDGE_TS, AGENT_JUDGE_TS, PLAN_JUDGE_TS, STOP_SUMMARY_TS, SESSION_START_TS, BASH_FOLLOWUP_TS, TRANSCRIPT_SYNC_TS, USER_PROMPT_SUBMIT_TS, CURSOR_BASH_JUDGE_TS, CURSOR_EDIT_PRECHECK_TS, CURSOR_EDIT_CAPTURE_TS, CURSOR_BASH_FOLLOWUP_TS, CURSOR_SESSION_START_TS;
 var init_hookScriptsTs = __esm({
   "cli/installer/hookScriptsTs.ts"() {
     "use strict";
@@ -1019,7 +882,7 @@ export async function ensureFreshJwt(jwt: string): Promise<string> {
 
 export function detectRepo(cwd: string): string {
   try {
-    const url = execSync('git remote get-url origin', { cwd, timeout: 3000, encoding: 'utf-8' }).trim();
+    const url = execSync('git remote get-url origin 2>/dev/null', { cwd, timeout: 3000, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
     if (!url) return '';
     return url
       .replace(/^git@[^:]+:/, '')
@@ -1074,6 +937,37 @@ export async function loadConfig(jwt: string, query?: string): Promise<HookConfi
     rules: [],
     scanExemptions: [],
   };
+
+  // Local-first: read from ~/.synkro/rules.json if it exists (zero latency, no network)
+  const localRulesPath = join(HOME, '.synkro', 'rules.json');
+  try {
+    if (existsSync(localRulesPath)) {
+      const raw = JSON.parse(readFileSync(localRulesPath, 'utf-8'));
+      const activePolicyId = raw.config?.activePolicyId || 'local-policy';
+      const policy = (raw.policies || []).find((p: any) => p.id === activePolicyId) || raw.policies?.[0];
+      if (policy) {
+        config.policyName = policy.name || '';
+        config.rules = (policy.rules || [])
+          .filter((r: any) => r.hook_stage === 'pre' || r.hook_stage === 'both' || r.hook_stage == null)
+          .map((r: any) => ({
+            rule_id: r.rule_id || '',
+            text: r.text || '',
+            severity: r.severity || '',
+            category: r.category || '',
+            mode: r.mode || 'blocking',
+          }));
+      }
+      config.silent = raw.config?.silent === true;
+      if (Array.isArray(raw.scanExemptions)) {
+        config.scanExemptions = raw.scanExemptions
+          .filter((e: any) => e && typeof e.path === 'string')
+          .map((e: any) => ({ path: e.path, cwe_id: e.cwe_id || '' }));
+      }
+      return config;
+    }
+  } catch {}
+
+  // Fallback: fetch from cloud API
   try {
     const url = GATEWAY_URL + '/api/v1/hook/config' + (query ? '?' + query : '');
     const resp = await fetch(url, {
@@ -2283,6 +2177,77 @@ import {
   type HookConfig, type Rule,
 } from './_synkro-common.ts';
 
+const TOP_NPM_PKGS = new Set([
+  'express','react','lodash','axios','chalk','commander','debug','dotenv','webpack',
+  'typescript','moment','uuid','cors','body-parser','mongoose','jsonwebtoken','bcrypt',
+  'nodemon','eslint','prettier','jest','mocha','chai','sinon','supertest','request',
+  'async','bluebird','underscore','ramda','rxjs','socket.io','redis','pg','mysql',
+  'sequelize','knex','prisma','next','nuxt','vue','svelte','angular','ember',
+  'react-dom','react-router','react-redux','redux','mobx','formik','yup','zod',
+  'ajv','joi','helmet','morgan','passport','cookie-parser','express-session',
+  'multer','sharp','jimp','puppeteer','playwright','cheerio','got','node-fetch',
+  'superagent','inquirer','ora','yargs','minimist','glob','rimraf','mkdirp',
+  'fs-extra','chokidar','ws','graphql','apollo-server','fastify','koa','hapi',
+  'nest','drizzle-orm','typeorm','mikro-orm','bull','bullmq','ioredis','kafkajs',
+  'amqplib','nodemailer','handlebars','ejs','pug','marked','highlight.js',
+  'dayjs','date-fns','luxon','nanoid','cuid','short-uuid','colors','picocolors',
+  'winston','pino','bunyan','semver','tar','archiver','unzipper','crypto-js',
+  'bcryptjs','argon2','jose','openai','anthropic','langchain','tensorflow',
+  'onnxruntime-node','sharp','canvas','three','d3','chart.js','echarts',
+  'tailwindcss','postcss','autoprefixer','sass','less','styled-components',
+  'emotion','framer-motion','gsap','lottie-web','swiper','i18next',
+]);
+
+const TOP_PYPI_PKGS = new Set([
+  'requests','flask','django','numpy','pandas','scipy','matplotlib','scikit-learn',
+  'tensorflow','torch','pytorch','keras','fastapi','uvicorn','gunicorn','celery',
+  'redis','sqlalchemy','alembic','pydantic','httpx','aiohttp','beautifulsoup4',
+  'scrapy','selenium','playwright','pillow','opencv-python','boto3','awscli',
+  'google-cloud-storage','azure-storage-blob','psycopg2','pymongo','motor',
+  'pytest','unittest2','mock','coverage','tox','black','flake8','mypy','ruff',
+  'isort','pylint','bandit','cryptography','paramiko','fabric','click','typer',
+  'rich','colorama','tqdm','loguru','python-dotenv','pyyaml','toml','orjson',
+  'ujson','marshmallow','attrs','dataclasses-json','jinja2','mako','arrow',
+  'pendulum','dateutil','pytz','regex','chardet','charset-normalizer',
+  'langchain','openai','anthropic','transformers','huggingface-hub','tokenizers',
+  'gradio','streamlit','dash','plotly','seaborn','bokeh','altair',
+]);
+
+function levenshtein(a: string, b: string): number {
+  const m = a.length, n = b.length;
+  if (Math.abs(m - n) > 2) return 3;
+  const dp: number[][] = Array.from({ length: m + 1 }, (_, i) => {
+    const row = new Array(n + 1).fill(0);
+    row[0] = i;
+    return row;
+  });
+  for (let j = 1; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      dp[i][j] = a[i - 1] === b[j - 1]
+        ? dp[i - 1][j - 1]
+        : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+    }
+  }
+  return dp[m][n];
+}
+
+function checkTyposquat(pkg: string, isPip: boolean): string | null {
+  const topPkgs = isPip ? TOP_PYPI_PKGS : TOP_NPM_PKGS;
+  if (topPkgs.has(pkg)) return null;
+  const pkgLower = pkg.toLowerCase();
+  for (const known of topPkgs) {
+    const dist = levenshtein(pkgLower, known);
+    if (dist > 0 && dist <= 2) return known;
+  }
+  return null;
+}
+
+interface PkgMeta {
+  deprecated?: string;
+  weeklyDownloads?: number;
+}
+
 async function main() {
   try {
     const input = await readStdin();
@@ -2319,11 +2284,11 @@ async function main() {
     if (!jwt) { outputEmpty(); return; }
     jwt = await ensureFreshJwt(jwt);
 
-    // \u2500\u2500\u2500 CVE scan for package install commands \u2500\u2500\u2500
-    let cveScanMsg = '';
+    // \u2500\u2500\u2500 Install protection: CVE + typosquat + deprecated + popularity \u2500\u2500\u2500
+    let installScanMsg = '';
     if (toolName === 'Bash') {
       const pkgInstallMatch = command.match(
-        /(?:npm\\s+(?:install|i|add)|pnpm\\s+(?:add|install|i)|yarn\\s+add|bun\\s+(?:add|install|i)|(?:uv\\s+)?pip3?\\s+install|go\\s+get|cargo\\s+add|gem\\s+install|composer\\s+require)\\s+(.+)/
+        /(?:npm\\s+(?:install|i|add)|pnpm\\s+(?:add|install|i)|yarn\\s+add|bun\\s+(?:add|install|i)|(?:uv\\s+)?pip3?\\s+install|go\\s+get|cargo\\s+add|gem\\s+install|composer\\s+require)\\s+([^|;&><]+)/
       );
       const isPip = /(?:uv\\s+)?pip3?\\s+install/.test(command);
       const isGo = command.match(/^go\\s+get/);
@@ -2337,6 +2302,7 @@ async function main() {
         let skipNext = false;
         for (const token of tokens) {
           if (skipNext) { skipNext = false; continue; }
+          if (!token || !/^[@a-zA-Z]/.test(token)) continue;
           if (token.startsWith('-')) {
             if (/^--(python|target|prefix|root|constraint|requirement|index-url|extra-index-url|find-links|build|src|cache-dir|filter|workspace)$/.test(token)) skipNext = true;
             continue;
@@ -2348,7 +2314,6 @@ async function main() {
               continue;
             }
           }
-          // npm/yarn: pkg@1.0
           const atIdx = token.lastIndexOf('@');
           if (atIdx > 0) {
             deps[token.slice(0, atIdx)] = token.slice(atIdx + 1);
@@ -2356,33 +2321,81 @@ async function main() {
             deps[token] = '*';
           }
         }
-        const unversioned = Object.keys(deps).filter(k => deps[k] === '*');
-        if (unversioned.length > 0) {
-          const lookups = unversioned.map(async (pkg) => {
+
+        if (Object.keys(deps).length > 0) {
+          const warnings: string[] = [];
+          const pkgMeta: Record<string, PkgMeta> = {};
+
+          const metaLookups = Object.keys(deps).map(async (pkg) => {
             try {
-              let ver: string | null = null;
               if (isPip) {
                 const r = await fetch('https://pypi.org/pypi/' + encodeURIComponent(pkg) + '/json', { signal: AbortSignal.timeout(4000) });
-                if (r.ok) { const d = await r.json() as any; ver = d?.info?.version || null; }
+                if (r.ok) {
+                  const d = await r.json() as any;
+                  if (deps[pkg] === '*' && d?.info?.version) deps[pkg] = d.info.version;
+                  const classifiers: string[] = d?.info?.classifiers || [];
+                  const isInactive = classifiers.some((c: string) => /Development Status :: [67]/.test(c));
+                  if (isInactive) pkgMeta[pkg] = { ...pkgMeta[pkg], deprecated: 'package marked as inactive/obsolete' };
+                  if (d?.info?.yanked) pkgMeta[pkg] = { ...pkgMeta[pkg], deprecated: d.info.yanked_reason || 'yanked from PyPI' };
+                } else if (r.status === 404) {
+                  warnings.push('\\u26a0 ' + pkg + ': package not found on PyPI \\u2014 may not exist');
+                }
               } else {
-                const r = await fetch('https://registry.npmjs.org/' + encodeURIComponent(pkg) + '/latest', { signal: AbortSignal.timeout(4000) });
-                if (r.ok) { const d = await r.json() as any; ver = d?.version || null; }
+                const verSlug = deps[pkg] !== '*' ? deps[pkg] : 'latest';
+                const [metaResp, dlResp] = await Promise.all([
+                  fetch('https://registry.npmjs.org/' + encodeURIComponent(pkg) + '/' + verSlug, { signal: AbortSignal.timeout(4000) }),
+                  fetch('https://api.npmjs.org/downloads/point/last-week/' + encodeURIComponent(pkg), { signal: AbortSignal.timeout(4000) }),
+                ]);
+                if (metaResp.ok) {
+                  const d = await metaResp.json() as any;
+                  if (deps[pkg] === '*' && d?.version) deps[pkg] = d.version;
+                  if (d?.deprecated) pkgMeta[pkg] = { ...pkgMeta[pkg], deprecated: d.deprecated };
+                } else if (metaResp.status === 404) {
+                  warnings.push('\\u26a0 ' + pkg + ': package not found on npm \\u2014 may not exist');
+                }
+                if (dlResp.ok) {
+                  const d = await dlResp.json() as any;
+                  if (typeof d?.downloads === 'number') pkgMeta[pkg] = { ...pkgMeta[pkg], weeklyDownloads: d.downloads };
+                }
               }
-              if (ver) deps[pkg] = ver;
             } catch {}
           });
-          await Promise.all(lookups);
-        }
-        const manifestFile = isPip ? 'requirements.txt'
-          : isGo ? 'go.mod'
-          : isCargo ? 'Cargo.toml'
-          : isGem ? 'Gemfile'
-          : isComposer ? 'composer.json'
-          : 'package.json';
-        const manifestContent = isPip
-          ? Object.entries(deps).map(([k, v]) => v === '*' ? k : k + '==' + v).join('\\n')
-          : JSON.stringify({ dependencies: deps });
-        if (Object.keys(deps).length > 0) {
+          await Promise.all(metaLookups);
+
+          for (const pkg of Object.keys(deps)) {
+            const similar = checkTyposquat(pkg, isPip);
+            if (similar) {
+              const dl = pkgMeta[pkg]?.weeklyDownloads;
+              if (dl === undefined || dl < 1000) {
+                warnings.push('\\u26a0 ' + pkg + ': possible typosquat of "' + similar + '"' + (dl !== undefined ? ' (' + dl + ' weekly downloads)' : '') + ' \\u2014 verify package name');
+              }
+            }
+          }
+
+          for (const [pkg, meta] of Object.entries(pkgMeta)) {
+            if (meta.deprecated) {
+              warnings.push('\\u26a0 ' + pkg + ': deprecated \\u2014 ' + meta.deprecated);
+            }
+          }
+
+          if (!isPip) {
+            for (const [pkg, meta] of Object.entries(pkgMeta)) {
+              if (meta.weeklyDownloads !== undefined && meta.weeklyDownloads < 50 && !warnings.some(w => w.includes(pkg))) {
+                warnings.push('\\u26a0 ' + pkg + ': very low adoption (' + meta.weeklyDownloads + ' weekly downloads) \\u2014 consider a more established alternative');
+              }
+            }
+          }
+
+          const manifestFile = isPip ? 'requirements.txt'
+            : isGo ? 'go.mod'
+            : isCargo ? 'Cargo.toml'
+            : isGem ? 'Gemfile'
+            : isComposer ? 'composer.json'
+            : 'package.json';
+          const manifestContent = isPip
+            ? Object.entries(deps).map(([k, v]) => v === '*' ? k : k + '==' + v).join('\\n')
+            : JSON.stringify({ dependencies: deps });
+
           try {
             const cveBody = { file_path: manifestFile, content: manifestContent, dependencies: deps };
             const cveResp = await fetch(GATEWAY_URL + '/api/v1/cve-scan', {
@@ -2394,10 +2407,8 @@ async function main() {
 
             const findings = Array.isArray(cveResp?.findings) ? cveResp.findings : [];
             const scannedPkgs = Object.entries(deps).map(([k, v]) => k + '@' + v).join(', ');
-            if (findings.length === 0) {
-              cveScanMsg = '[synkro:cveScan] ' + scannedPkgs + ' \\u2192 clean, no known vulnerabilities';
-            }
-            else if (findings.length > 0) {
+
+            if (findings.length > 0) {
               const top3 = findings.slice(0, 3).map((f: any) => {
                 const id = f.cve || f.id || '?';
                 const pkg = f.package || '?';
@@ -2407,8 +2418,9 @@ async function main() {
               }).join('; ');
               const count = findings.length;
               const label = count === 1 ? 'advisory' : 'advisories';
-              const cveMsg = '[synkro:cveScan] ' + cmdShort + ' \\u2192 ' + count + ' ' + label;
-              const ctx = 'CVE: ' + top3 + '\\nDo NOT install packages with known vulnerabilities. Use a patched version or a different package.';
+              const cveMsg = '[synkro:installScan] ' + cmdShort + ' \\u2192 ' + count + ' ' + label;
+              const ctx = 'CVE: ' + top3 + '\\nDo NOT install packages with known vulnerabilities. Use a patched version or a different package.'
+                + (warnings.length > 0 ? '\\n' + warnings.join('\\n') : '');
 
               const config = await loadConfig(jwt);
               for (const f of findings) {
@@ -2435,8 +2447,15 @@ async function main() {
               });
               return;
             }
+
+            const parts: string[] = ['[synkro:installScan] ' + scannedPkgs + ' \\u2192 clean, no known vulnerabilities'];
+            if (warnings.length > 0) parts.push(...warnings);
+            installScanMsg = parts.join('\\n');
           } catch (e) {
-            log('bashGuard CVE check failed: ' + String(e));
+            log('bashGuard install scan failed: ' + String(e));
+            if (warnings.length > 0) {
+              installScanMsg = '[synkro:installScan] ' + warnings.join('\\n');
+            }
           }
         }
       }
@@ -2450,7 +2469,7 @@ async function main() {
     const tagStr = tag(rt, config);
 
     if (config.silent) {
-      const msg = (cveScanMsg ? cveScanMsg + '\\n' : '') + tagStr + ' bashGuard \\u2192 skipped (silent mode)';
+      const msg = (installScanMsg ? installScanMsg + '\\n' : '') + tagStr + ' bashGuard \\u2192 skipped (silent mode)';
       outputJson({ systemMessage: msg, hookSpecificOutput: { hookEventName: 'PreToolUse', additionalContext: msg } });
       return;
     }
@@ -2482,7 +2501,7 @@ async function main() {
 
         if (mode === 'audit') {
           const reason = tagStr + ' bashGuard \\u2192 warning' + (verdict.ruleId ? ' (' + verdict.ruleId + ')' : '') + ': ' + (verdict.reason || 'policy violation');
-          const combined = (cveScanMsg ? cveScanMsg + '\\n' : '') + reason;
+          const combined = (installScanMsg ? installScanMsg + '\\n' : '') + reason;
           outputJson({ systemMessage: combined, hookSpecificOutput: { hookEventName: 'PreToolUse', additionalContext: combined } });
           dispatchCapture(jwt, 'bash', 'warning', verdict.severity || 'medium', verdict.category || 'security',
             toolName, gitRepo, sessionId, config.captureDepth, {
@@ -2491,7 +2510,7 @@ async function main() {
             });
         } else {
           const reason = tagStr + ' bashGuard \\u2192 blocked' + (verdict.ruleId ? ' (' + verdict.ruleId + ')' : '') + ': ' + (verdict.reason || 'policy violation') + '. Ask the user for explicit consent before retrying.';
-          const combined = (cveScanMsg ? cveScanMsg + '\\n' : '') + reason;
+          const combined = (installScanMsg ? installScanMsg + '\\n' : '') + reason;
           outputJson({
             systemMessage: combined,
             hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: reason, additionalContext: combined },
@@ -2504,7 +2523,7 @@ async function main() {
         }
       } else {
         const reason = tagStr + ' bashGuard \\u2192 pass: ' + (verdict.reason || 'no policy violations detected');
-        const combined = (cveScanMsg ? cveScanMsg + '\\n' : '') + reason;
+        const combined = (installScanMsg ? installScanMsg + '\\n' : '') + reason;
         outputJson({ systemMessage: combined, hookSpecificOutput: { hookEventName: 'PreToolUse', additionalContext: combined } });
         dispatchCapture(jwt, 'bash', 'pass', 'audit', verdict.category || 'trivial_utility',
           toolName, gitRepo, sessionId, config.captureDepth, {
@@ -2544,26 +2563,26 @@ async function main() {
 
     if (!resp) {
       log('bashGuard ' + cmdShort + ' \\u2192 error (timeout)');
-      if (cveScanMsg) {
-        outputJson({ systemMessage: cveScanMsg, hookSpecificOutput: { hookEventName: 'PreToolUse', additionalContext: cveScanMsg } });
+      if (installScanMsg) {
+        outputJson({ systemMessage: installScanMsg, hookSpecificOutput: { hookEventName: 'PreToolUse', additionalContext: installScanMsg } });
       } else { outputEmpty(); }
       return;
     }
 
     if (!resp.hook_response || typeof resp.hook_response !== 'object') {
       log('bashGuard ' + cmdShort + ' \\u2192 pass (no hook_response)');
-      if (cveScanMsg) {
-        outputJson({ systemMessage: cveScanMsg, hookSpecificOutput: { hookEventName: 'PreToolUse', additionalContext: cveScanMsg } });
+      if (installScanMsg) {
+        outputJson({ systemMessage: installScanMsg, hookSpecificOutput: { hookEventName: 'PreToolUse', additionalContext: installScanMsg } });
       } else { outputEmpty(); }
       return;
     }
 
-    if (cveScanMsg) {
+    if (installScanMsg) {
       const existing = resp.hook_response.systemMessage || '';
-      resp.hook_response.systemMessage = cveScanMsg + (existing ? '\\n' + existing : '');
+      resp.hook_response.systemMessage = installScanMsg + (existing ? '\\n' + existing : '');
       if (resp.hook_response.hookSpecificOutput) {
         const existingCtx = resp.hook_response.hookSpecificOutput.additionalContext || '';
-        resp.hook_response.hookSpecificOutput.additionalContext = cveScanMsg + (existingCtx ? '\\n' + existingCtx : '');
+        resp.hook_response.hookSpecificOutput.additionalContext = installScanMsg + (existingCtx ? '\\n' + existingCtx : '');
       } else {
         resp.hook_response.hookSpecificOutput = { hookEventName: 'PreToolUse', additionalContext: resp.hook_response.systemMessage };
       }
@@ -3292,102 +3311,595 @@ async function main() {
 
 main();
 `;
-  }
-});
+    CURSOR_BASH_JUDGE_TS = `#!/usr/bin/env bun
+import {
+  loadJwt, ensureFreshJwt, detectRepo, loadConfig, route, tag, localGrade,
+  parseVerdict, dispatchCapture, ruleMode, postWithRetry, readStdin,
+  appendLocalTelemetry, log, GATEWAY_URL,
+  type HookConfig, type Rule,
+} from './_synkro-common.ts';
 
-// cli/auth/stub.ts
-import { createServer } from "http";
-import { writeFileSync as writeFileSync4, readFileSync as readFileSync4, existsSync as existsSync5, mkdirSync as mkdirSync4, unlinkSync as unlinkSync2 } from "fs";
-import { homedir as homedir3, platform } from "os";
-import { join as join3, dirname as dirname4 } from "path";
-import { execFile } from "child_process";
-import jwt from "jsonwebtoken";
-function openBrowser(url) {
-  const os = platform();
-  let bin;
-  let args2;
-  switch (os) {
-    case "darwin":
-      bin = "open";
-      args2 = [url];
-      break;
-    case "win32":
-      bin = "cmd";
-      args2 = ["/c", "start", "", url];
-      break;
-    default:
-      bin = "xdg-open";
-      args2 = [url];
-  }
-  execFile(bin, args2, (error) => {
-    if (error) {
-      console.error("Failed to open browser automatically.");
-      console.log(`Please open this URL manually: ${url}`);
-    }
-  });
-}
-function saveCredentials(data) {
-  const dir = dirname4(AUTH_FILE);
-  if (!existsSync5(dir)) {
-    mkdirSync4(dir, { recursive: true, mode: 448 });
-  }
-  writeFileSync4(AUTH_FILE, JSON.stringify(data, null, 2), { mode: 384 });
-}
-function loadCredentials() {
-  if (!existsSync5(AUTH_FILE)) {
-    return null;
-  }
+async function main() {
   try {
-    const content = readFileSync4(AUTH_FILE, "utf8");
-    return JSON.parse(content);
-  } catch (error) {
-    return null;
-  }
-}
-function createCallbackServer() {
-  const CORS_HEADERS = {
-    "Access-Control-Allow-Origin": SYNKRO_WEB_AUTH_URL,
-    "Access-Control-Allow-Methods": "POST, OPTIONS",
-    "Access-Control-Allow-Headers": "Content-Type",
-    "Vary": "Origin"
-  };
-  return new Promise((resolve2, reject) => {
-    const server = createServer((req, res) => {
-      if (req.method === "OPTIONS") {
-        const origin = req.headers.origin;
-        if (origin === SYNKRO_WEB_AUTH_URL) {
-          res.writeHead(204, CORS_HEADERS);
-        } else {
-          res.writeHead(204, {
-            "Access-Control-Allow-Methods": "POST, OPTIONS",
-            "Access-Control-Allow-Headers": "Content-Type",
-            "Vary": "Origin"
-          });
-        }
-        res.end();
-        return;
-      }
-      const reqOrigin = req.headers.origin;
-      if (reqOrigin && reqOrigin !== SYNKRO_WEB_AUTH_URL) {
-        res.writeHead(403, { "Vary": "Origin" });
-        res.end();
-        return;
-      }
-      if (!req.url) {
-        res.writeHead(404, CORS_HEADERS);
-        res.end();
-        return;
-      }
-      const url = new URL(req.url, `http://localhost:${PORT}`);
-      if (url.pathname !== "/auth") {
-        res.writeHead(404, CORS_HEADERS);
-        res.end();
+    const input = await readStdin();
+    if (!input.trim()) { process.stdout.write('{}\\n'); return; }
+
+    const payload = JSON.parse(input);
+    const command = payload.command || '';
+    if (!command) { process.stdout.write('{}\\n'); return; }
+
+    const cwd = payload.cwd || '';
+    const sessionId = payload.conversation_id || '';
+    const repo = detectRepo(cwd || '.');
+
+    const cmdShort = command.slice(0, 80);
+    log('bashGuard checking: ' + cmdShort);
+
+    let jwt = loadJwt();
+    if (!jwt) { process.stdout.write('{}\\n'); return; }
+    jwt = await ensureFreshJwt(jwt);
+
+    const config = await loadConfig(jwt);
+    if (config.silent) { process.stdout.write('{}\\n'); return; }
+
+    const rt = await route(config);
+    const tagStr = tag(rt, config);
+
+    if (rt === 'local') {
+      // Build grading prompt with rules
+      const rulesBlock = config.rules.map((r: Rule, i: number) =>
+        (i + 1) + '. [' + r.rule_id + '] (' + r.severity + '/' + r.mode + ') ' + r.text
+      ).join('\\n');
+
+      const graderPrompt = [
+        'RULES:',
+        rulesBlock || '(none)',
+        '',
+        'COMMAND TO EVALUATE:',
+        command,
+      ].join('\\n');
+
+      let gradeResp: string;
+      try {
+        gradeResp = await localGrade('bash', graderPrompt);
+      } catch {
+        process.stdout.write('{}\\n');
         return;
       }
-      if (req.method !== "POST") {
-        res.writeHead(405, { ...CORS_HEADERS, "Allow": "POST, OPTIONS", "Content-Type": "text/html" });
-        res.end(ERROR_HTML);
-        return;
+
+      const verdict = parseVerdict(gradeResp);
+
+      if (!verdict.ok) {
+        const mode = verdict.ruleMode || ruleMode(verdict.ruleId, config.rules);
+        const guardReason = (verdict.ruleId ? '(' + verdict.ruleId + ') ' : '') + (verdict.reason || 'policy violation');
+
+        if (mode !== 'audit') {
+          dispatchCapture(jwt, 'bash', 'block', verdict.severity || 'critical', verdict.category || 'security',
+            'Bash', repo, sessionId, config.captureDepth, {
+              command, reasoning: guardReason,
+              rulesChecked: config.rules, violatedRules: verdict.ruleId ? [verdict.ruleId] : [],
+            });
+          const result = {
+            permission: 'deny',
+            user_message: tagStr + ' bashGuard \\u2192 block: ' + guardReason,
+            agent_message: 'Synkro safety judge. Reasoning: ' + (verdict.reason || guardReason),
+          };
+          process.stdout.write(JSON.stringify(result) + '\\n');
+          return;
+        }
+
+        // Audit mode \u2014 warn but allow
+        dispatchCapture(jwt, 'bash', 'warning', verdict.severity || 'medium', verdict.category || 'security',
+          'Bash', repo, sessionId, config.captureDepth, {
+            command, reasoning: guardReason,
+            rulesChecked: config.rules, violatedRules: verdict.ruleId ? [verdict.ruleId] : [],
+          });
+      } else {
+        dispatchCapture(jwt, 'bash', 'pass', 'audit', verdict.category || 'clean',
+          'Bash', repo, sessionId, config.captureDepth, {
+            command, reasoning: verdict.reason || 'no policy violations detected',
+            rulesChecked: config.rules, violatedRules: [],
+          });
+      }
+
+      process.stdout.write('{}\\n');
+      return;
+    }
+
+    // \u2500\u2500\u2500 Cloud grading \u2500\u2500\u2500
+    const body = {
+      hook_event: 'PreToolUse',
+      tool_name: 'Bash',
+      tool_input: { command },
+      response_format: 'cursor',
+      session_id: sessionId || null,
+      cwd: cwd || null,
+      repo: repo || null,
+    };
+
+    const resp = await postWithRetry(GATEWAY_URL + '/api/v1/hook/judge', body, jwt, 6000);
+
+    if (!resp) {
+      log('bashGuard ' + cmdShort + ' \\u2192 error (timeout)');
+      process.stdout.write('{}\\n');
+      return;
+    }
+
+    if (resp.hook_response) {
+      process.stdout.write(JSON.stringify(resp.hook_response) + '\\n');
+    } else {
+      process.stdout.write('{}\\n');
+    }
+  } catch {
+    process.stdout.write('{}\\n');
+  }
+}
+
+main();
+`;
+    CURSOR_EDIT_PRECHECK_TS = `#!/usr/bin/env bun
+import {
+  loadJwt, ensureFreshJwt, detectRepo, loadConfig, route, tag, localGrade,
+  parseVerdict, dispatchCapture, ruleMode, postWithRetry, readStdin,
+  appendLocalTelemetry, log, GATEWAY_URL,
+  type HookConfig, type Rule,
+} from './_synkro-common.ts';
+import { basename } from 'node:path';
+
+async function main() {
+  try {
+    const input = await readStdin();
+    if (!input.trim()) { process.stdout.write('{}\\n'); return; }
+
+    const payload = JSON.parse(input);
+    const toolName = payload.tool_name || '';
+    const toolInput = payload.tool_input || {};
+    const cwd = payload.cwd || '';
+    const sessionId = payload.conversation_id || '';
+
+    const filePath = toolInput.file_path || toolInput.path || toolInput.target_file || '';
+    const content = toolInput.content || toolInput.new_string || toolInput.code_edit || '';
+    if (!filePath) { process.stdout.write('{}\\n'); return; }
+
+    const fileShort = basename(filePath);
+    log('editGuard checking: ' + fileShort);
+
+    const repo = detectRepo(cwd || '.');
+
+    let jwt = loadJwt();
+    if (!jwt) { process.stdout.write('{}\\n'); return; }
+    jwt = await ensureFreshJwt(jwt);
+
+    const config = await loadConfig(jwt);
+    if (config.silent) { process.stdout.write('{}\\n'); return; }
+
+    const rt = await route(config);
+    const tagStr = tag(rt, config);
+
+    if (rt === 'local') {
+      const contentShort = content.slice(0, 4000);
+      const rulesBlock = config.rules.map((r: Rule, i: number) =>
+        (i + 1) + '. [' + r.rule_id + '] (' + r.severity + '/' + r.mode + ') ' + r.text
+      ).join('\\n');
+
+      const graderPrompt = [
+        'RULES:',
+        rulesBlock || '(none)',
+        '',
+        'FILE: ' + filePath,
+        '',
+        'CONTENT TO EVALUATE (first 4000 chars):',
+        contentShort,
+      ].join('\\n');
+
+      let gradeResp: string;
+      try {
+        gradeResp = await localGrade('edit', graderPrompt);
+      } catch {
+        process.stdout.write('{}\\n');
+        return;
+      }
+
+      const verdict = parseVerdict(gradeResp);
+      const editContent = 'file=' + filePath + ' content=' + content.slice(0, 2000);
+
+      if (!verdict.ok) {
+        const mode = verdict.ruleMode || ruleMode(verdict.ruleId, config.rules);
+        const guardReason = (verdict.ruleId ? '(' + verdict.ruleId + ') ' : '') + (verdict.reason || 'policy violation');
+
+        if (mode !== 'audit') {
+          dispatchCapture(jwt, 'edit', 'block', verdict.severity || 'critical', verdict.category || 'security',
+            toolName || 'Edit', repo, sessionId, config.captureDepth, {
+              command: editContent, reasoning: guardReason,
+              rulesChecked: config.rules, violatedRules: verdict.ruleId ? [verdict.ruleId] : [],
+            });
+          const result = {
+            permission: 'deny',
+            user_message: tagStr + ' editGuard ' + fileShort + ' \\u2192 block: ' + guardReason,
+            agent_message: 'Synkro safety judge. Reasoning: ' + (verdict.reason || guardReason),
+          };
+          process.stdout.write(JSON.stringify(result) + '\\n');
+          return;
+        }
+
+        // Audit mode
+        dispatchCapture(jwt, 'edit', 'warning', verdict.severity || 'medium', verdict.category || 'security',
+          toolName || 'Edit', repo, sessionId, config.captureDepth, {
+            command: editContent, reasoning: guardReason,
+            rulesChecked: config.rules, violatedRules: verdict.ruleId ? [verdict.ruleId] : [],
+          });
+      } else {
+        dispatchCapture(jwt, 'edit', 'pass', 'audit', verdict.category || 'trivial_edit',
+          toolName || 'Edit', repo, sessionId, config.captureDepth, {
+            command: editContent, reasoning: verdict.reason || 'no policy violations detected',
+            rulesChecked: config.rules, violatedRules: [],
+          });
+      }
+
+      process.stdout.write('{}\\n');
+      return;
+    }
+
+    // \u2500\u2500\u2500 Cloud grading \u2500\u2500\u2500
+    const body = {
+      hook_event: 'PreToolUse',
+      tool_name: toolName || 'Edit',
+      tool_input: { file_path: filePath, content },
+      file_path: filePath,
+      content,
+      response_format: 'cursor',
+      session_id: sessionId || null,
+      cwd: cwd || null,
+      repo: repo || null,
+    };
+
+    const resp = await postWithRetry(GATEWAY_URL + '/api/v1/hook/judge', body, jwt, 8000);
+
+    if (!resp) {
+      log('editGuard ' + fileShort + ' \\u2192 error (timeout)');
+      process.stdout.write('{}\\n');
+      return;
+    }
+
+    if (resp.hook_response) {
+      process.stdout.write(JSON.stringify(resp.hook_response) + '\\n');
+    } else {
+      process.stdout.write('{}\\n');
+    }
+  } catch {
+    process.stdout.write('{}\\n');
+  }
+}
+
+main();
+`;
+    CURSOR_EDIT_CAPTURE_TS = `#!/usr/bin/env bun
+import {
+  loadJwt, ensureFreshJwt, detectRepo, readStdin,
+  appendLocalTelemetry, log, GATEWAY_URL,
+} from './_synkro-common.ts';
+import { existsSync, readFileSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+
+async function main() {
+  try {
+    const input = await readStdin();
+    if (!input.trim()) { process.stdout.write('{}\\n'); return; }
+
+    const payload = JSON.parse(input);
+    const filePath = payload.file_path || '';
+    if (!filePath) { process.stdout.write('{}\\n'); return; }
+
+    const cwd = payload.cwd || '';
+    const sessionId = payload.conversation_id || '';
+    const repo = detectRepo(cwd || '.');
+
+    log('editScan ' + basename(filePath));
+
+    let jwt = loadJwt();
+    if (!jwt) { process.stdout.write('{}\\n'); return; }
+    jwt = await ensureFreshJwt(jwt);
+
+    // Read actual file content (up to 50KB)
+    let fileContent = '';
+    const fullPath = filePath.startsWith('/') ? filePath : (cwd ? join(cwd, filePath) : filePath);
+    try {
+      if (existsSync(fullPath)) {
+        const buf = readFileSync(fullPath);
+        fileContent = buf.slice(0, 50000).toString('utf-8');
+      }
+    } catch {}
+
+    // Walk up to find package.json dependencies
+    let dependencies: Record<string, string> = {};
+    let pkgDir = cwd || dirname(fullPath);
+    while (pkgDir !== '/' && pkgDir !== '.') {
+      const pkgPath = join(pkgDir, 'package.json');
+      if (existsSync(pkgPath)) {
+        try {
+          const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+          dependencies = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+        } catch {}
+        break;
+      }
+      const parent = dirname(pkgDir);
+      if (parent === pkgDir) break;
+      pkgDir = parent;
+    }
+
+    const captureBody: Record<string, any> = {
+      capture_type: 'edit_scan',
+      tool_input: { file_path: filePath, content: fileContent },
+      edit_verdict: { ok: true },
+      dependencies,
+    };
+    if (sessionId) captureBody.session_id = sessionId;
+    if (cwd) captureBody.cwd = cwd;
+    if (repo) captureBody.repo = repo;
+
+    // Check if local_only
+    const rulesPath = join(homedir(), '.synkro', 'rules.json');
+    if (existsSync(rulesPath)) {
+      appendLocalTelemetry(captureBody);
+    } else {
+      // Fire-and-forget to cloud
+      fetch(GATEWAY_URL + '/api/v1/hook/capture', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', Authorization: 'Bearer ' + jwt },
+        body: JSON.stringify(captureBody),
+        signal: AbortSignal.timeout(10000),
+      }).catch(() => {});
+      appendLocalTelemetry(captureBody);
+    }
+
+    process.stdout.write('{}\\n');
+  } catch {
+    process.stdout.write('{}\\n');
+  }
+}
+
+main();
+`;
+    CURSOR_BASH_FOLLOWUP_TS = `#!/usr/bin/env bun
+import {
+  loadJwt, readStdin, appendLocalTelemetry, log, GATEWAY_URL,
+} from './_synkro-common.ts';
+import { existsSync, readFileSync, writeFileSync, appendFileSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { createHash } from 'node:crypto';
+import { homedir } from 'node:os';
+
+const CONSENT_FILE = join(homedir(), '.synkro', '.local-consent');
+
+function hashCmd(cmd: string): string {
+  return createHash('sha256').update(cmd).digest('hex').slice(0, 16);
+}
+
+function consentGrant(sid: string, hash: string): void {
+  try {
+    const dir = dirname(CONSENT_FILE);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    appendFileSync(CONSENT_FILE, sid + '\\t' + hash + '\\tactive\\n', 'utf-8');
+  } catch {}
+}
+
+function consentHasActive(sid: string, hash: string): boolean {
+  try {
+    if (!existsSync(CONSENT_FILE)) return false;
+    const content = readFileSync(CONSENT_FILE, 'utf-8');
+    return content.includes(sid + '\\t' + hash + '\\tactive');
+  } catch {
+    return false;
+  }
+}
+
+function consentConsume(sid: string, hash: string): void {
+  try {
+    if (!existsSync(CONSENT_FILE)) return;
+    const content = readFileSync(CONSENT_FILE, 'utf-8');
+    const target = sid + '\\t' + hash + '\\tactive';
+    const replacement = sid + '\\t' + hash + '\\tconsumed';
+    const updated = content.split('\\n').map((l: string) => l === target ? replacement : l).join('\\n');
+    writeFileSync(CONSENT_FILE, updated, 'utf-8');
+  } catch {}
+}
+
+async function main() {
+  try {
+    const input = await readStdin();
+    if (!input.trim()) { process.stdout.write('{}\\n'); return; }
+
+    const payload = JSON.parse(input);
+    const toolName = payload.tool_name || '';
+
+    // Only process shell/bash tool types
+    const shellTools = ['Shell', 'Bash', 'terminal', 'run_terminal_cmd', 'execute_command'];
+    if (!shellTools.includes(toolName)) { process.stdout.write('{}\\n'); return; }
+
+    const sessionId = payload.conversation_id || '';
+    const toolUseId = payload.tool_use_id || '';
+    const isError = payload.tool_result?.is_error === true;
+    const command = payload.tool_input?.command || '';
+    const cmdHash = command ? hashCmd(command) : '';
+
+    // Consent tracking
+    if (cmdHash && sessionId) {
+      if (!isError) {
+        consentConsume(sessionId, cmdHash);
+      } else {
+        if (!consentHasActive(sessionId, cmdHash)) {
+          consentGrant(sessionId, cmdHash);
+        }
+      }
+    }
+
+    // Build capture body
+    const captureBody: Record<string, any> = {
+      capture_type: 'bash_followup',
+      session_id: sessionId || null,
+      tool_use_id: toolUseId || null,
+      is_error: isError,
+      command_hash: cmdHash,
+    };
+
+    // Check if local_only
+    const rulesPath = join(homedir(), '.synkro', 'rules.json');
+    if (existsSync(rulesPath)) {
+      appendLocalTelemetry(captureBody);
+    } else {
+      const jwt = loadJwt();
+      if (jwt && sessionId && toolUseId) {
+        fetch(GATEWAY_URL + '/api/v1/hook/capture', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json', Authorization: 'Bearer ' + jwt },
+          body: JSON.stringify(captureBody),
+          signal: AbortSignal.timeout(3000),
+        }).catch(() => {});
+      }
+      appendLocalTelemetry(captureBody);
+    }
+
+    process.stdout.write('{}\\n');
+  } catch {
+    process.stdout.write('{}\\n');
+  }
+}
+
+main();
+`;
+    CURSOR_SESSION_START_TS = `#!/usr/bin/env bun
+import {
+  loadJwt, loadConfig, readStdin,
+  type HookConfig,
+} from './_synkro-common.ts';
+
+async function main() {
+  try {
+    const input = await readStdin();
+
+    let jwt = loadJwt();
+    const config: HookConfig = jwt ? await loadConfig(jwt) : {
+      captureDepth: 'local_only', tier: 'standard', silent: false,
+      policyName: '', rules: [], scanExemptions: [],
+    };
+
+    const policyName = config.policyName || 'default';
+    const ruleCount = config.rules.length;
+    const mode = config.silent ? 'silent' : 'active';
+
+    const context = [
+      'This session is monitored by Synkro (' + mode + ' mode, policy: "' + policyName + '", ' + ruleCount + ' rules).',
+      'Synkro enforces security and compliance rules on tool calls (shell commands, file edits).',
+      'If a tool call is blocked, Synkro will explain which rule was violated and why.',
+      'Do not suggest workarounds to bypass Synkro hooks \u2014 fix the underlying issue instead.',
+    ].join(' ');
+
+    const result = { additional_context: context };
+    process.stdout.write(JSON.stringify(result) + '\\n');
+  } catch {
+    process.stdout.write('{}\\n');
+  }
+}
+
+main();
+`;
+  }
+});
+
+// cli/auth/stub.ts
+import { createServer } from "http";
+import { writeFileSync as writeFileSync4, readFileSync as readFileSync4, existsSync as existsSync4, mkdirSync as mkdirSync4, unlinkSync as unlinkSync2 } from "fs";
+import { homedir as homedir4, platform } from "os";
+import { join as join3, dirname as dirname4 } from "path";
+import { execFile } from "child_process";
+import jwt from "jsonwebtoken";
+function openBrowser(url) {
+  const os = platform();
+  let bin;
+  let args2;
+  switch (os) {
+    case "darwin":
+      bin = "open";
+      args2 = [url];
+      break;
+    case "win32":
+      bin = "cmd";
+      args2 = ["/c", "start", "", url];
+      break;
+    default:
+      bin = "xdg-open";
+      args2 = [url];
+  }
+  execFile(bin, args2, (error) => {
+    if (error) {
+      console.error("Failed to open browser automatically.");
+      console.log(`Please open this URL manually: ${url}`);
+    }
+  });
+}
+function saveCredentials(data) {
+  const dir = dirname4(AUTH_FILE);
+  if (!existsSync4(dir)) {
+    mkdirSync4(dir, { recursive: true, mode: 448 });
+  }
+  writeFileSync4(AUTH_FILE, JSON.stringify(data, null, 2), { mode: 384 });
+}
+function loadCredentials() {
+  if (!existsSync4(AUTH_FILE)) {
+    return null;
+  }
+  try {
+    const content = readFileSync4(AUTH_FILE, "utf8");
+    return JSON.parse(content);
+  } catch (error) {
+    return null;
+  }
+}
+function createCallbackServer() {
+  const CORS_HEADERS = {
+    "Access-Control-Allow-Origin": SYNKRO_WEB_AUTH_URL,
+    "Access-Control-Allow-Methods": "POST, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type",
+    "Vary": "Origin"
+  };
+  return new Promise((resolve3, reject) => {
+    const server = createServer((req, res) => {
+      if (req.method === "OPTIONS") {
+        const origin = req.headers.origin;
+        if (origin === SYNKRO_WEB_AUTH_URL) {
+          res.writeHead(204, CORS_HEADERS);
+        } else {
+          res.writeHead(204, {
+            "Access-Control-Allow-Methods": "POST, OPTIONS",
+            "Access-Control-Allow-Headers": "Content-Type",
+            "Vary": "Origin"
+          });
+        }
+        res.end();
+        return;
+      }
+      const reqOrigin = req.headers.origin;
+      if (reqOrigin && reqOrigin !== SYNKRO_WEB_AUTH_URL) {
+        res.writeHead(403, { "Vary": "Origin" });
+        res.end();
+        return;
+      }
+      if (!req.url) {
+        res.writeHead(404, CORS_HEADERS);
+        res.end();
+        return;
+      }
+      const url = new URL(req.url, `http://localhost:${PORT}`);
+      if (url.pathname !== "/auth") {
+        res.writeHead(404, CORS_HEADERS);
+        res.end();
+        return;
+      }
+      if (req.method !== "POST") {
+        res.writeHead(405, { ...CORS_HEADERS, "Allow": "POST, OPTIONS", "Content-Type": "text/html" });
+        res.end(ERROR_HTML);
+        return;
       }
       const MAX_BODY = 16 * 1024;
       const chunks = [];
@@ -3440,7 +3952,7 @@ function createCallbackServer() {
         res.end(JSON.stringify({ ok: true }));
         setTimeout(() => {
           server.close();
-          resolve2(authData);
+          resolve3(authData);
         }, 200);
       });
       req.on("error", (e) => {
@@ -3582,7 +4094,7 @@ async function ensureValidToken() {
   return true;
 }
 function clearCredentials() {
-  if (existsSync5(AUTH_FILE)) {
+  if (existsSync4(AUTH_FILE)) {
     unlinkSync2(AUTH_FILE);
   }
 }
@@ -3593,7 +4105,7 @@ var init_stub = __esm({
     PORT = 8100;
     RAW_WEB_AUTH_URL = process.env.SYNKRO_WEB_AUTH_URL;
     SYNKRO_WEB_AUTH_URL = RAW_WEB_AUTH_URL && /^https?:\/\//.test(RAW_WEB_AUTH_URL) ? RAW_WEB_AUTH_URL : "https://app.synkro.sh";
-    AUTH_FILE = process.env.SYNKRO_AUTH_FILE || join3(homedir3(), ".synkro", "credentials.json");
+    AUTH_FILE = process.env.SYNKRO_AUTH_FILE || join3(homedir4(), ".synkro", "credentials.json");
     RAW_API_URL = process.env.SYNKRO_CRUD_URL || process.env.SYNKRO_API_URL;
     SYNKRO_API_URL = RAW_API_URL && /^https?:\/\//.test(RAW_API_URL) ? RAW_API_URL : "https://api.synkro.sh";
     ERROR_HTML = `
@@ -3756,7 +4268,7 @@ jobs:
 });
 
 // cli/installer/githubSetup.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
 import { execSync as execSync2 } from "child_process";
 import { join as join4 } from "path";
 function ghSecretSet(token, owner, repo, name, value) {
@@ -3813,7 +4325,7 @@ function writeWorkflowFile(repoRootPath) {
 function findGitRoot(startCwd) {
   let cur = startCwd;
   while (cur && cur !== "/") {
-    if (existsSync6(join4(cur, ".git"))) return cur;
+    if (existsSync5(join4(cur, ".git"))) return cur;
     const parent = join4(cur, "..");
     if (parent === cur) break;
     cur = parent;
@@ -3851,10 +4363,10 @@ function detectGitRepo() {
   }
 }
 function ask(rl, question) {
-  return new Promise((resolve2) => rl.question(question, resolve2));
+  return new Promise((resolve3) => rl.question(question, resolve3));
 }
 function waitForGithubToken() {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const server = createServer2((req, res) => {
       if (req.method === "OPTIONS") {
         res.writeHead(204, {
@@ -3891,7 +4403,7 @@ function waitForGithubToken() {
           });
           res.end(JSON.stringify({ ok: true }));
           setTimeout(() => server.close(), 200);
-          resolve2(parsed.github_token);
+          resolve3(parsed.github_token);
         } catch {
           res.writeHead(400, { "Content-Type": "application/json" });
           res.end(JSON.stringify({ error: "invalid json" }));
@@ -4056,12 +4568,12 @@ __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 existsSync7, readFileSync as readFileSync5, unlinkSync as unlinkSync3 } from "fs";
-import { homedir as homedir4, platform as platform2 } from "os";
+import { existsSync as existsSync6, readFileSync as readFileSync5, unlinkSync as unlinkSync3 } from "fs";
+import { homedir as homedir5, platform as platform2 } from "os";
 import { join as join5 } from "path";
 import { execFile as execFile2 } from "child_process";
 function readConfig() {
-  if (!existsSync7(CONFIG_PATH)) return {};
+  if (!existsSync6(CONFIG_PATH)) return {};
   const out = {};
   for (const line of readFileSync5(CONFIG_PATH, "utf-8").split("\n")) {
     const t = line.trim();
@@ -4076,7 +4588,7 @@ async function prompt(rl, q, opts = {}) {
     process.stdout.write(q);
     const wasRaw = process.stdin.isRaw;
     if (process.stdin.setRawMode) process.stdin.setRawMode(true);
-    return await new Promise((resolve2) => {
+    return await new Promise((resolve3) => {
       let chunk = "";
       const onData = (data) => {
         const s = data.toString("utf-8");
@@ -4084,7 +4596,7 @@ async function prompt(rl, q, opts = {}) {
           process.stdin.removeListener("data", onData);
           if (process.stdin.setRawMode) process.stdin.setRawMode(wasRaw ?? false);
           process.stdout.write("\n");
-          resolve2(chunk);
+          resolve3(chunk);
           return;
         }
         if (s === "") process.exit(130);
@@ -4125,7 +4637,7 @@ function sleep(ms) {
 }
 function captureClaudeSetupToken() {
   const tmpFile = join5(SYNKRO_DIR, `token-capture-${Date.now()}.raw`);
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const proc = nodeSpawn("script", ["-q", tmpFile, "claude", "setup-token"], {
       stdio: "inherit"
     });
@@ -4155,7 +4667,7 @@ function captureClaudeSetupToken() {
         reject(new Error(`Could not find token in claude setup-token output (file=${raw.length}b, yellow=${yellow.length}b)`));
         return;
       }
-      resolve2(token[0]);
+      resolve3(token[0]);
     });
   });
 }
@@ -4405,7 +4917,7 @@ var init_setupGithub = __esm({
     "use strict";
     init_githubSetup();
     init_stub();
-    SYNKRO_DIR = join5(homedir4(), ".synkro");
+    SYNKRO_DIR = join5(homedir5(), ".synkro");
     CONFIG_PATH = join5(SYNKRO_DIR, "config.env");
   }
 });
@@ -4434,11 +4946,11 @@ var init_promptFetcher = __esm({
 });
 
 // cli/local-cc/settings.ts
-import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
-import { homedir as homedir5 } from "os";
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
+import { homedir as homedir6 } from "os";
 import { join as join6 } from "path";
 function isLocalCCEnabled() {
-  if (!existsSync8(CONFIG_PATH2)) return false;
+  if (!existsSync7(CONFIG_PATH2)) return false;
   try {
     const content = readFileSync6(CONFIG_PATH2, "utf-8");
     const match = content.match(/^SYNKRO_LOCAL_INFERENCE='([^']*)'/m);
@@ -4451,7 +4963,7 @@ var CONFIG_PATH2;
 var init_settings = __esm({
   "cli/local-cc/settings.ts"() {
     "use strict";
-    CONFIG_PATH2 = join6(homedir5(), ".synkro", "config.env");
+    CONFIG_PATH2 = join6(homedir6(), ".synkro", "config.env");
   }
 });
 
@@ -4605,9 +5117,9 @@ await mcp.connect(new StdioServerTransport());
 });
 
 // cli/local-cc/install.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync6, writeFileSync as writeFileSync6, readFileSync as readFileSync7, chmodSync, copyFileSync, renameSync as renameSync4, unlinkSync as unlinkSync4, openSync, fsyncSync, closeSync } from "fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync6, writeFileSync as writeFileSync6, readFileSync as readFileSync7, chmodSync, copyFileSync, renameSync as renameSync4, unlinkSync as unlinkSync4, openSync, fsyncSync, closeSync } from "fs";
 import { join as join7 } from "path";
-import { homedir as homedir6 } from "os";
+import { homedir as homedir7 } from "os";
 import { spawnSync } from "child_process";
 function writePluginFiles() {
   mkdirSync6(SESSION_DIR, { recursive: true });
@@ -4656,7 +5168,7 @@ function runBunInstall() {
   }
 }
 function safelyMutateClaudeJson(mutator) {
-  if (!existsSync9(CLAUDE_JSON_PATH)) {
+  if (!existsSync8(CLAUDE_JSON_PATH)) {
     return;
   }
   const originalText = readFileSync7(CLAUDE_JSON_PATH, "utf-8");
@@ -4809,17 +5321,17 @@ var init_install = __esm({
   "cli/local-cc/install.ts"() {
     "use strict";
     init_channelSource();
-    CLAUDE_JSON_BACKUP_PATH = join7(homedir6(), ".claude.json.synkro-bak");
-    SESSION_DIR = join7(homedir6(), ".synkro", "cc_sessions");
+    CLAUDE_JSON_BACKUP_PATH = join7(homedir7(), ".claude.json.synkro-bak");
+    SESSION_DIR = join7(homedir7(), ".synkro", "cc_sessions");
     PLUGIN_PATH = join7(SESSION_DIR, "synkro-channel.ts");
     PLUGIN_PKG_PATH = join7(SESSION_DIR, "package.json");
     PLUGIN_SETTINGS_DIR = join7(SESSION_DIR, ".claude");
     PLUGIN_SETTINGS_PATH = join7(PLUGIN_SETTINGS_DIR, "settings.json");
     PROJECT_MCP_PATH = join7(SESSION_DIR, ".mcp.json");
-    CLAUDE_JSON_PATH = join7(homedir6(), ".claude.json");
+    CLAUDE_JSON_PATH = join7(homedir7(), ".claude.json");
     RUN_SCRIPT_PATH = join7(SESSION_DIR, "run-claude.sh");
     TMUX_SESSION_NAME = "synkro-local-cc";
-    SESSION_DIR_2 = join7(homedir6(), ".synkro", "cc_sessions_2");
+    SESSION_DIR_2 = join7(homedir7(), ".synkro", "cc_sessions_2");
     PLUGIN_PATH_2 = join7(SESSION_DIR_2, "synkro-channel.ts");
     PLUGIN_PKG_PATH_2 = join7(SESSION_DIR_2, "package.json");
     PLUGIN_SETTINGS_DIR_2 = join7(SESSION_DIR_2, ".claude");
@@ -4978,7 +5490,7 @@ log "tmux session ended."
 
 // cli/local-cc/pueue.ts
 import { execFileSync, spawnSync as spawnSync2, spawn } from "child_process";
-import { homedir as homedir7 } from "os";
+import { homedir as homedir8 } from "os";
 import { join as join8 } from "path";
 import { connect } from "net";
 function pueueAvailable() {
@@ -4994,568 +5506,1377 @@ function statusJson() {
     throw new PueueError(`pueue status failed: ${r.stderr || r.stdout || "unknown error"} \u2014 is pueued running?`);
   }
   try {
-    return JSON.parse(r.stdout);
-  } catch (err) {
-    throw new PueueError(`pueue status returned non-JSON output: ${r.stdout.slice(0, 200)}`, err);
+    return JSON.parse(r.stdout);
+  } catch (err) {
+    throw new PueueError(`pueue status returned non-JSON output: ${r.stdout.slice(0, 200)}`, err);
+  }
+}
+function statusName(s) {
+  if (typeof s === "string") return s;
+  if (s && typeof s === "object") {
+    if ("Running" in s) return "Running";
+    if ("Done" in s) {
+      const result = s.Done?.result;
+      if (typeof result === "string") return `Done (${result})`;
+      if (result && typeof result === "object") return `Done (${Object.keys(result)[0] ?? "unknown"})`;
+      return "Done";
+    }
+    return Object.keys(s)[0] ?? "unknown";
+  }
+  return "unknown";
+}
+function findTask(channel = CHANNEL_PRIMARY) {
+  const data = statusJson();
+  for (const [id, t] of Object.entries(data.tasks)) {
+    if (t.label === channel.taskLabel) {
+      return {
+        id: Number(id),
+        label: t.label,
+        status: statusName(t.status),
+        command: t.command,
+        cwd: t.path
+      };
+    }
+  }
+  return null;
+}
+function startTask(opts = {}) {
+  const ch = opts.channel ?? CHANNEL_PRIMARY;
+  const cwd = opts.cwd ?? ch.sessionDir;
+  let existing = findTask(ch);
+  while (existing) {
+    if (existing.status === "Running" || existing.status === "Queued") {
+      spawnSync2("tmux", ["kill-session", "-t", `=${ch.tmuxSession}`], { encoding: "utf-8" });
+      spawnSync2("pueue", ["kill", String(existing.id)], { encoding: "utf-8" });
+      for (let i = 0; i < 10; i++) {
+        const check = findTask(ch);
+        if (!check || check.id !== existing.id || check.status !== "Running" && check.status !== "Queued") break;
+        spawnSync2("sleep", ["0.5"], { encoding: "utf-8" });
+      }
+    }
+    spawnSync2("pueue", ["remove", String(existing.id)], { encoding: "utf-8" });
+    existing = findTask(ch);
+  }
+  const runScript = join8(cwd, "run-claude.sh");
+  const args2 = [
+    "add",
+    "--label",
+    ch.taskLabel,
+    "--working-directory",
+    cwd,
+    "--",
+    "bash",
+    runScript
+  ];
+  const r = spawnSync2("pueue", args2, { encoding: "utf-8" });
+  if (r.status !== 0) {
+    throw new PueueError(`pueue add failed: ${r.stderr || r.stdout}`);
+  }
+  const created = findTask(ch);
+  if (!created) {
+    throw new PueueError(`pueue add succeeded but no task with label ${ch.taskLabel} found`);
+  }
+  return created;
+}
+function stopTask(channel = CHANNEL_PRIMARY) {
+  spawnSync2("tmux", ["kill-session", "-t", `=${channel.tmuxSession}`], { encoding: "utf-8" });
+  let t = findTask(channel);
+  while (t) {
+    if (t.status === "Running" || t.status === "Queued") {
+      spawnSync2("pueue", ["kill", String(t.id)], { encoding: "utf-8" });
+      for (let i = 0; i < 10; i++) {
+        const check = findTask(channel);
+        if (!check || check.id !== t.id || check.status !== "Running" && check.status !== "Queued") break;
+        spawnSync2("sleep", ["0.5"], { encoding: "utf-8" });
+      }
+    }
+    spawnSync2("pueue", ["remove", String(t.id)], { encoding: "utf-8" });
+    t = findTask(channel);
+  }
+}
+function tailLogs(lines = 80, channel = CHANNEL_PRIMARY) {
+  const t = findTask(channel);
+  if (!t) return `(no ${channel.taskLabel} task)`;
+  const r = spawnSync2("pueue", ["log", "--lines", String(lines), String(t.id)], { encoding: "utf-8" });
+  return r.stdout || r.stderr || "(no output)";
+}
+function ensureRunning(opts = {}) {
+  const ch = opts.channel ?? CHANNEL_PRIMARY;
+  const t = findTask(ch);
+  if (t && t.status === "Running") return t;
+  return startTask(opts);
+}
+function probePort(host, port, timeoutMs = 500) {
+  return new Promise((resolve3) => {
+    const sock = connect(port, host);
+    const done = (ok) => {
+      try {
+        sock.destroy();
+      } catch {
+      }
+      resolve3(ok);
+    };
+    sock.once("connect", () => done(true));
+    sock.once("error", () => done(false));
+    sock.setTimeout(timeoutMs, () => done(false));
+  });
+}
+function tmuxDismissPrompts(tmuxSession = TMUX_SESSION) {
+  spawnSync2("tmux", ["send-keys", "-t", tmuxSession, "1"], { encoding: "utf-8" });
+  spawnSync2("tmux", ["send-keys", "-t", tmuxSession, "Enter"], { encoding: "utf-8" });
+}
+async function waitForChannelReady(port, timeoutMs = 6e4, host = "127.0.0.1", tmuxSession = TMUX_SESSION) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await probePort(host, port)) return true;
+    tmuxDismissPrompts(tmuxSession);
+    await new Promise((r) => setTimeout(r, 1e3));
+  }
+  return probePort(host, port);
+}
+function brewInstall(pkg) {
+  const brew = spawnSync2("brew", ["--version"], { encoding: "utf-8" });
+  if (brew.status !== 0) return false;
+  console.log(`  Installing ${pkg} via brew...`);
+  const r = spawnSync2("brew", ["install", pkg], { encoding: "utf-8", stdio: "inherit", timeout: 12e4 });
+  return r.status === 0;
+}
+function assertPueueInstalled() {
+  let r = spawnSync2("pueue", ["--version"], { encoding: "utf-8" });
+  if (r.status !== 0) {
+    if (process.platform === "darwin" && brewInstall("pueue")) {
+      r = spawnSync2("pueue", ["--version"], { encoding: "utf-8" });
+      if (r.status !== 0) throw new PueueError("pueue install succeeded but binary not found on PATH.");
+    } else {
+      throw new PueueError("pueue not found. Install it: brew install pueue (macOS) or https://github.com/Nukesor/pueue");
+    }
+  }
+  const status = spawnSync2("pueue", ["status", "--json"], { encoding: "utf-8", timeout: 5e3 });
+  if (status.status !== 0) {
+    console.log("  Starting pueued daemon...");
+    const child = spawn("pueued", ["-d"], { stdio: "ignore", detached: true });
+    child.unref();
+    spawnSync2("sleep", ["1"]);
+    const retry = spawnSync2("pueue", ["status", "--json"], { encoding: "utf-8", timeout: 5e3 });
+    if (retry.status !== 0) {
+      throw new PueueError("pueue daemon not reachable after starting pueued. Check `pueued` manually.");
+    }
+  }
+  spawnSync2("pueue", ["parallel", "2"], { encoding: "utf-8" });
+}
+function assertClaudeInstalled() {
+  const r = spawnSync2("claude", ["--version"], { encoding: "utf-8" });
+  if (r.status !== 0) {
+    throw new PueueError("claude CLI not found on PATH. Install Claude Code first: https://docs.claude.com/claude-code");
+  }
+}
+function assertTmuxInstalled() {
+  let r = spawnSync2("tmux", ["-V"], { encoding: "utf-8" });
+  if (r.status !== 0) {
+    if (process.platform === "darwin" && brewInstall("tmux")) {
+      r = spawnSync2("tmux", ["-V"], { encoding: "utf-8" });
+      if (r.status !== 0) throw new PueueError("tmux install succeeded but binary not found on PATH.");
+    } else {
+      throw new PueueError("tmux not found. Install it: brew install tmux (macOS) or apt install tmux (Linux)");
+    }
+  }
+}
+var TASK_LABEL, TMUX_SESSION, SESSION_DIR2, TASK_LABEL_2, TMUX_SESSION_2, SESSION_DIR_22, PueueError, CHANNEL_PRIMARY, CHANNEL_SECONDARY;
+var init_pueue = __esm({
+  "cli/local-cc/pueue.ts"() {
+    "use strict";
+    TASK_LABEL = "synkro-local-cc";
+    TMUX_SESSION = "synkro-local-cc";
+    SESSION_DIR2 = join8(homedir8(), ".synkro", "cc_sessions");
+    TASK_LABEL_2 = "synkro-local-cc-2";
+    TMUX_SESSION_2 = "synkro-local-cc-2";
+    SESSION_DIR_22 = join8(homedir8(), ".synkro", "cc_sessions_2");
+    PueueError = class extends Error {
+      constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = "PueueError";
+      }
+      cause;
+    };
+    CHANNEL_PRIMARY = { taskLabel: TASK_LABEL, tmuxSession: TMUX_SESSION, sessionDir: SESSION_DIR2 };
+    CHANNEL_SECONDARY = { taskLabel: TASK_LABEL_2, tmuxSession: TMUX_SESSION_2, sessionDir: SESSION_DIR_22 };
+  }
+});
+
+// cli/local-cc/prompts.ts
+import { readFileSync as readFileSync8 } from "fs";
+import { homedir as homedir9 } from "os";
+import { join as join9 } from "path";
+async function fetchPrimers() {
+  let jwt2 = "";
+  let gatewayUrl = "";
+  try {
+    const creds = JSON.parse(readFileSync8(CREDS_PATH, "utf-8"));
+    jwt2 = creds.access_token || "";
+    gatewayUrl = creds.gateway_url || "https://api.synkro.sh";
+  } catch {
+    throw new Error("No credentials found. Run `synkro install` first.");
+  }
+  if (!jwt2) throw new Error("No access token. Run `synkro install` first.");
+  const resp = await fetch(`${gatewayUrl}/api/v1/cli/judge-prompts`, {
+    headers: { Authorization: `Bearer ${jwt2}` },
+    signal: AbortSignal.timeout(5e3)
+  });
+  if (!resp.ok) throw new Error(`Failed to fetch prompts: ${resp.status}`);
+  return resp.json();
+}
+async function getPrimer(role) {
+  const prompts = await fetchPrimers();
+  const primer = role === "grade-edit" ? prompts.grader_primer_edit : role === "grade-plan" ? prompts.grader_primer_plan : role === "grade-cwe" ? prompts.grader_primer_cwe : prompts.grader_primer_bash;
+  if (!primer) {
+    throw new Error(`No primer for role "${role}" returned from API.`);
+  }
+  return primer;
+}
+async function buildChannelContent(role, payload) {
+  const primer = await getPrimer(role);
+  return `${primer}
+
+${CHANNEL_REPLY_INSTRUCTIONS}
+
+---
+PAYLOAD (the input to evaluate):
+
+${payload}`;
+}
+var CREDS_PATH, CHANNEL_REPLY_INSTRUCTIONS;
+var init_prompts = __esm({
+  "cli/local-cc/prompts.ts"() {
+    "use strict";
+    CREDS_PATH = join9(homedir9(), ".synkro", "credentials.json");
+    CHANNEL_REPLY_INSTRUCTIONS = `
+DELIVERY METHOD \u2014 MANDATORY, OVERRIDES ALL OTHER OUTPUT RULES:
+You are running inside a Synkro MCP channel. Do NOT output your verdict as text.
+Instead, after generating your verdict, call the \`reply\` tool EXACTLY ONCE with:
+  - req_id: the req_id from this channel event's meta
+  - result: your complete verdict block as a string (the <synkro-verdict>\u2026</synkro-verdict> XML)
+Any text output is silently discarded. Only the reply tool call is captured.`;
+  }
+});
+
+// cli/local-cc/turnLog.ts
+import { appendFileSync, existsSync as existsSync9, mkdirSync as mkdirSync7, openSync as openSync2, readFileSync as readFileSync9, readSync, closeSync as closeSync2, statSync, watchFile, unwatchFile } from "fs";
+import { dirname as dirname5, join as join10 } from "path";
+import { homedir as homedir10 } from "os";
+function truncate(s, max = PREVIEW_MAX) {
+  if (s.length <= max) return s;
+  return s.slice(0, max) + "\u2026 [+" + (s.length - max) + " chars]";
+}
+function extractSeverity(result) {
+  const m = result.match(/<synkro-(?:verdict|intent)>([\s\S]*?)<\/synkro-(?:verdict|intent)>/);
+  if (!m) return void 0;
+  try {
+    const obj = JSON.parse(m[1]);
+    if (obj.severity) return String(obj.severity);
+    if (typeof obj.ok === "boolean") return obj.ok ? "ok" : "violations";
+    if (obj.type) return String(obj.type);
+    if (obj.verdict) return String(obj.verdict);
+  } catch {
   }
+  return void 0;
 }
-function statusName(s) {
-  if (typeof s === "string") return s;
-  if (s && typeof s === "object") {
-    if ("Running" in s) return "Running";
-    if ("Done" in s) {
-      const result = s.Done?.result;
-      if (typeof result === "string") return `Done (${result})`;
-      if (result && typeof result === "object") return `Done (${Object.keys(result)[0] ?? "unknown"})`;
-      return "Done";
-    }
-    return Object.keys(s)[0] ?? "unknown";
+function appendTurn(args2) {
+  try {
+    mkdirSync7(dirname5(TURN_LOG_PATH), { recursive: true });
+    const entry = {
+      ts: new Date(args2.startedAt).toISOString(),
+      role: args2.role,
+      duration_ms: Date.now() - args2.startedAt,
+      status: args2.status,
+      request_preview: truncate(args2.request),
+      response_preview: args2.result ? truncate(args2.result) : "",
+      severity: args2.result ? extractSeverity(args2.result) : void 0,
+      error: args2.error
+    };
+    appendFileSync(TURN_LOG_PATH, JSON.stringify(entry) + "\n", "utf-8");
+  } catch {
   }
-  return "unknown";
 }
-function findTask(channel = CHANNEL_PRIMARY) {
-  const data = statusJson();
-  for (const [id, t] of Object.entries(data.tasks)) {
-    if (t.label === channel.taskLabel) {
-      return {
-        id: Number(id),
-        label: t.label,
-        status: statusName(t.status),
-        command: t.command,
-        cwd: t.path
-      };
-    }
+function readRecentTurns(n = 20) {
+  if (!existsSync9(TURN_LOG_PATH)) return [];
+  try {
+    const size = statSync(TURN_LOG_PATH).size;
+    if (size === 0) return [];
+    const text = readFileSync9(TURN_LOG_PATH, "utf-8");
+    const lines = text.split("\n").filter(Boolean);
+    const lastN = lines.slice(-n).reverse();
+    return lastN.map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter((x) => x !== null);
+  } catch {
+    return [];
   }
-  return null;
 }
-function startTask(opts = {}) {
-  const ch = opts.channel ?? CHANNEL_PRIMARY;
-  const cwd = opts.cwd ?? ch.sessionDir;
-  let existing = findTask(ch);
-  while (existing) {
-    if (existing.status === "Running" || existing.status === "Queued") {
-      spawnSync2("tmux", ["kill-session", "-t", `=${ch.tmuxSession}`], { encoding: "utf-8" });
-      spawnSync2("pueue", ["kill", String(existing.id)], { encoding: "utf-8" });
-      for (let i = 0; i < 10; i++) {
-        const check = findTask(ch);
-        if (!check || check.id !== existing.id || check.status !== "Running" && check.status !== "Queued") break;
-        spawnSync2("sleep", ["0.5"], { encoding: "utf-8" });
-      }
+function followTurns(onEntry) {
+  try {
+    mkdirSync7(dirname5(TURN_LOG_PATH), { recursive: true });
+    if (!existsSync9(TURN_LOG_PATH)) {
+      appendFileSync(TURN_LOG_PATH, "", "utf-8");
     }
-    spawnSync2("pueue", ["remove", String(existing.id)], { encoding: "utf-8" });
-    existing = findTask(ch);
-  }
-  const runScript = join8(cwd, "run-claude.sh");
-  const args2 = [
-    "add",
-    "--label",
-    ch.taskLabel,
-    "--working-directory",
-    cwd,
-    "--",
-    "bash",
-    runScript
-  ];
-  const r = spawnSync2("pueue", args2, { encoding: "utf-8" });
-  if (r.status !== 0) {
-    throw new PueueError(`pueue add failed: ${r.stderr || r.stdout}`);
-  }
-  const created = findTask(ch);
-  if (!created) {
-    throw new PueueError(`pueue add succeeded but no task with label ${ch.taskLabel} found`);
+  } catch {
   }
-  return created;
-}
-function stopTask(channel = CHANNEL_PRIMARY) {
-  spawnSync2("tmux", ["kill-session", "-t", `=${channel.tmuxSession}`], { encoding: "utf-8" });
-  let t = findTask(channel);
-  while (t) {
-    if (t.status === "Running" || t.status === "Queued") {
-      spawnSync2("pueue", ["kill", String(t.id)], { encoding: "utf-8" });
-      for (let i = 0; i < 10; i++) {
-        const check = findTask(channel);
-        if (!check || check.id !== t.id || check.status !== "Running" && check.status !== "Queued") break;
-        spawnSync2("sleep", ["0.5"], { encoding: "utf-8" });
+  let lastSize = (() => {
+    try {
+      return statSync(TURN_LOG_PATH).size;
+    } catch {
+      return 0;
+    }
+  })();
+  let pendingPartial = "";
+  const drainNewBytes = (from, to) => {
+    if (to <= from) return;
+    let fd = null;
+    try {
+      fd = openSync2(TURN_LOG_PATH, "r");
+      const len = to - from;
+      const buf = Buffer.alloc(len);
+      readSync(fd, buf, 0, len, from);
+      const text = pendingPartial + buf.toString("utf-8");
+      const lastNewline = text.lastIndexOf("\n");
+      if (lastNewline === -1) {
+        pendingPartial = text;
+        return;
+      }
+      const complete = text.slice(0, lastNewline);
+      pendingPartial = text.slice(lastNewline + 1);
+      for (const line of complete.split("\n")) {
+        if (!line) continue;
+        try {
+          onEntry(JSON.parse(line));
+        } catch {
+        }
+      }
+    } catch {
+    } finally {
+      if (fd !== null) {
+        try {
+          closeSync2(fd);
+        } catch {
+        }
       }
     }
-    spawnSync2("pueue", ["remove", String(t.id)], { encoding: "utf-8" });
-    t = findTask(channel);
-  }
-}
-function tailLogs(lines = 80, channel = CHANNEL_PRIMARY) {
-  const t = findTask(channel);
-  if (!t) return `(no ${channel.taskLabel} task)`;
-  const r = spawnSync2("pueue", ["log", "--lines", String(lines), String(t.id)], { encoding: "utf-8" });
-  return r.stdout || r.stderr || "(no output)";
+  };
+  watchFile(TURN_LOG_PATH, { interval: 250 }, (curr, prev) => {
+    if (curr.size < lastSize) {
+      lastSize = 0;
+      pendingPartial = "";
+    }
+    if (curr.size > lastSize) {
+      drainNewBytes(lastSize, curr.size);
+      lastSize = curr.size;
+    }
+  });
+  return () => unwatchFile(TURN_LOG_PATH);
 }
-function ensureRunning(opts = {}) {
-  const ch = opts.channel ?? CHANNEL_PRIMARY;
-  const t = findTask(ch);
-  if (t && t.status === "Running") return t;
-  return startTask(opts);
+var TURN_LOG_PATH, PREVIEW_MAX;
+var init_turnLog = __esm({
+  "cli/local-cc/turnLog.ts"() {
+    "use strict";
+    TURN_LOG_PATH = join10(homedir10(), ".synkro", "cc_sessions", "turns.log");
+    PREVIEW_MAX = 400;
+  }
+});
+
+// cli/local-cc/client.ts
+import { request as httpRequest } from "http";
+import { connect as connect2 } from "net";
+async function submitToChannel(role, payload, opts = {}) {
+  const content = await buildChannelContent(role, payload);
+  const body = JSON.stringify({ role, content });
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const port = opts.port ?? CHANNEL_PORT;
+  const startedAt = Date.now();
+  try {
+    const result = await new Promise((resolve3, reject) => {
+      const req = httpRequest({
+        host: CHANNEL_HOST,
+        port,
+        method: "POST",
+        path: "/submit",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(body)
+        },
+        timeout: timeoutMs
+      }, (res) => {
+        const chunks = [];
+        res.on("data", (c) => chunks.push(c));
+        res.on("end", () => {
+          const text = Buffer.concat(chunks).toString("utf-8");
+          if (res.statusCode !== 200) {
+            reject(new LocalCCError(`channel returned ${res.statusCode}: ${text.slice(0, 500)}`));
+            return;
+          }
+          try {
+            const parsed = JSON.parse(text);
+            if (parsed.error) {
+              reject(new LocalCCError(parsed.error));
+              return;
+            }
+            resolve3(String(parsed.result ?? ""));
+          } catch (err) {
+            reject(new LocalCCError(`malformed channel response: ${text.slice(0, 200)}`, err));
+          }
+        });
+      });
+      req.on("timeout", () => {
+        req.destroy(new LocalCCError(`channel request timed out after ${timeoutMs}ms`));
+      });
+      req.on("error", (err) => {
+        const msg = err.code === "ECONNREFUSED" ? `channel connection refused at ${CHANNEL_HOST}:${CHANNEL_PORT} (is the pueue task running?)` : `channel request failed: ${err.message}`;
+        reject(new LocalCCError(msg, err));
+      });
+      req.write(body);
+      req.end();
+    });
+    appendTurn({ startedAt, role, request: payload, result, status: "ok" });
+    return result;
+  } catch (err) {
+    const message = err.message ?? String(err);
+    const status = /timed out/i.test(message) ? "timeout" : "error";
+    appendTurn({ startedAt, role, request: payload, status, error: message });
+    throw err;
+  }
 }
-function probePort(host, port, timeoutMs = 500) {
-  return new Promise((resolve2) => {
-    const sock = connect(port, host);
+function isChannelAvailable(port = CHANNEL_PORT, timeoutMs = 500) {
+  return new Promise((resolve3) => {
+    const sock = connect2(port, CHANNEL_HOST);
     const done = (ok) => {
       try {
         sock.destroy();
       } catch {
       }
-      resolve2(ok);
+      resolve3(ok);
     };
     sock.once("connect", () => done(true));
     sock.once("error", () => done(false));
     sock.setTimeout(timeoutMs, () => done(false));
   });
 }
-function tmuxDismissPrompts(tmuxSession = TMUX_SESSION) {
-  spawnSync2("tmux", ["send-keys", "-t", tmuxSession, "1"], { encoding: "utf-8" });
-  spawnSync2("tmux", ["send-keys", "-t", tmuxSession, "Enter"], { encoding: "utf-8" });
-}
-async function waitForChannelReady(port, timeoutMs = 6e4, host = "127.0.0.1", tmuxSession = TMUX_SESSION) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    if (await probePort(host, port)) return true;
-    tmuxDismissPrompts(tmuxSession);
-    await new Promise((r) => setTimeout(r, 1e3));
-  }
-  return probePort(host, port);
-}
-function brewInstall(pkg) {
-  const brew = spawnSync2("brew", ["--version"], { encoding: "utf-8" });
-  if (brew.status !== 0) return false;
-  console.log(`  Installing ${pkg} via brew...`);
-  const r = spawnSync2("brew", ["install", pkg], { encoding: "utf-8", stdio: "inherit", timeout: 12e4 });
-  return r.status === 0;
-}
-function assertPueueInstalled() {
-  let r = spawnSync2("pueue", ["--version"], { encoding: "utf-8" });
-  if (r.status !== 0) {
-    if (process.platform === "darwin" && brewInstall("pueue")) {
-      r = spawnSync2("pueue", ["--version"], { encoding: "utf-8" });
-      if (r.status !== 0) throw new PueueError("pueue install succeeded but binary not found on PATH.");
-    } else {
-      throw new PueueError("pueue not found. Install it: brew install pueue (macOS) or https://github.com/Nukesor/pueue");
-    }
-  }
-  const status = spawnSync2("pueue", ["status", "--json"], { encoding: "utf-8", timeout: 5e3 });
-  if (status.status !== 0) {
-    console.log("  Starting pueued daemon...");
-    const child = spawn("pueued", ["-d"], { stdio: "ignore", detached: true });
-    child.unref();
-    spawnSync2("sleep", ["1"]);
-    const retry = spawnSync2("pueue", ["status", "--json"], { encoding: "utf-8", timeout: 5e3 });
-    if (retry.status !== 0) {
-      throw new PueueError("pueue daemon not reachable after starting pueued. Check `pueued` manually.");
-    }
-  }
-  spawnSync2("pueue", ["parallel", "2"], { encoding: "utf-8" });
-}
-function assertClaudeInstalled() {
-  const r = spawnSync2("claude", ["--version"], { encoding: "utf-8" });
-  if (r.status !== 0) {
-    throw new PueueError("claude CLI not found on PATH. Install Claude Code first: https://docs.claude.com/claude-code");
-  }
-}
-function assertTmuxInstalled() {
-  let r = spawnSync2("tmux", ["-V"], { encoding: "utf-8" });
-  if (r.status !== 0) {
-    if (process.platform === "darwin" && brewInstall("tmux")) {
-      r = spawnSync2("tmux", ["-V"], { encoding: "utf-8" });
-      if (r.status !== 0) throw new PueueError("tmux install succeeded but binary not found on PATH.");
-    } else {
-      throw new PueueError("tmux not found. Install it: brew install tmux (macOS) or apt install tmux (Linux)");
-    }
-  }
-}
-var TASK_LABEL, TMUX_SESSION, SESSION_DIR2, TASK_LABEL_2, TMUX_SESSION_2, SESSION_DIR_22, PueueError, CHANNEL_PRIMARY, CHANNEL_SECONDARY;
-var init_pueue = __esm({
-  "cli/local-cc/pueue.ts"() {
+var CHANNEL_HOST, CHANNEL_PORT, DEFAULT_TIMEOUT_MS, LocalCCError;
+var init_client = __esm({
+  "cli/local-cc/client.ts"() {
     "use strict";
-    TASK_LABEL = "synkro-local-cc";
-    TMUX_SESSION = "synkro-local-cc";
-    SESSION_DIR2 = join8(homedir7(), ".synkro", "cc_sessions");
-    TASK_LABEL_2 = "synkro-local-cc-2";
-    TMUX_SESSION_2 = "synkro-local-cc-2";
-    SESSION_DIR_22 = join8(homedir7(), ".synkro", "cc_sessions_2");
-    PueueError = class extends Error {
+    init_prompts();
+    init_turnLog();
+    CHANNEL_HOST = "127.0.0.1";
+    CHANNEL_PORT = parseInt(process.env.SYNKRO_CHANNEL_PORT || "8929", 10);
+    DEFAULT_TIMEOUT_MS = 9e4;
+    LocalCCError = class extends Error {
       constructor(message, cause) {
         super(message);
         this.cause = cause;
-        this.name = "PueueError";
+        this.name = "LocalCCError";
       }
       cause;
     };
-    CHANNEL_PRIMARY = { taskLabel: TASK_LABEL, tmuxSession: TMUX_SESSION, sessionDir: SESSION_DIR2 };
-    CHANNEL_SECONDARY = { taskLabel: TASK_LABEL_2, tmuxSession: TMUX_SESSION_2, sessionDir: SESSION_DIR_22 };
   }
 });
 
-// cli/local-cc/prompts.ts
-import { readFileSync as readFileSync8 } from "fs";
-import { homedir as homedir8 } from "os";
-import { join as join9 } from "path";
-async function fetchPrimers() {
-  let jwt2 = "";
-  let gatewayUrl = "";
-  try {
-    const creds = JSON.parse(readFileSync8(CREDS_PATH, "utf-8"));
-    jwt2 = creds.access_token || "";
-    gatewayUrl = creds.gateway_url || "https://api.synkro.sh";
-  } catch {
-    throw new Error("No credentials found. Run `synkro install` first.");
+// cli/commands/install.ts
+var install_exports = {};
+__export(install_exports, {
+  installCommand: () => installCommand,
+  parseArgs: () => parseArgs
+});
+import { existsSync as existsSync10, mkdirSync as mkdirSync8, writeFileSync as writeFileSync7, chmodSync as chmodSync2, readFileSync as readFileSync10, readdirSync, appendFileSync as appendFileSync2, renameSync as renameSync5 } from "fs";
+import { homedir as homedir11 } from "os";
+import { join as join11 } from "path";
+import { execSync as execSync5, spawnSync as spawnSync3, spawn as spawn2 } from "child_process";
+import { createInterface as createInterface3 } from "readline";
+function sanitizeGatewayCandidate(raw) {
+  if (!raw) return void 0;
+  return /^https?:\/\//.test(raw) ? raw : void 0;
+}
+function parseArgs(argv) {
+  const opts = {};
+  for (const a of argv) {
+    if (a.startsWith("--api-key=")) opts.apiKey = a.slice("--api-key=".length);
+    else if (a.startsWith("--gateway=")) opts.gatewayUrl = a.slice("--gateway=".length);
+    else if (a === "--skip-auth") opts.skipAuth = true;
+    else if (a === "--no-mcp") opts.noMcp = true;
+    else if (a === "--force" || a === "-f") opts.force = true;
+    else if (a === "--link-repo") opts.linkRepo = true;
   }
-  if (!jwt2) throw new Error("No access token. Run `synkro install` first.");
-  const resp = await fetch(`${gatewayUrl}/api/v1/cli/judge-prompts`, {
-    headers: { Authorization: `Bearer ${jwt2}` },
-    signal: AbortSignal.timeout(5e3)
+  if (!opts.gatewayUrl) {
+    const fromEnv = sanitizeGatewayCandidate(process.env.SYNKRO_GATEWAY_URL);
+    if (fromEnv) opts.gatewayUrl = fromEnv;
+  }
+  return opts;
+}
+async function promptTranscriptConsent() {
+  const rl = createInterface3({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve3) => {
+    rl.question(
+      "Would you like Synkro to use Claude Code session transcripts\nto generate guardrail rules and policies for your team? (Y/n) ",
+      (answer) => {
+        rl.close();
+        const trimmed = answer.trim().toLowerCase();
+        resolve3(trimmed === "" || trimmed === "y" || trimmed === "yes");
+      }
+    );
   });
-  if (!resp.ok) throw new Error(`Failed to fetch prompts: ${resp.status}`);
-  return resp.json();
 }
-async function getPrimer(role) {
-  const prompts = await fetchPrimers();
-  const primer = role === "grade-edit" ? prompts.grader_primer_edit : role === "grade-plan" ? prompts.grader_primer_plan : role === "grade-cwe" ? prompts.grader_primer_cwe : prompts.grader_primer_bash;
-  if (!primer) {
-    throw new Error(`No primer for role "${role}" returned from API.`);
-  }
-  return primer;
+function ensureSynkroDir() {
+  mkdirSync8(SYNKRO_DIR2, { recursive: true });
+  mkdirSync8(HOOKS_DIR, { recursive: true });
+  mkdirSync8(BIN_DIR, { recursive: true });
+  mkdirSync8(OFFSETS_DIR, { recursive: true });
 }
-async function buildChannelContent(role, payload) {
-  const primer = await getPrimer(role);
-  return `${primer}
+function writeHookScripts() {
+  const bashScriptPath = join11(HOOKS_DIR, "cc-bash-judge.ts");
+  const bashFollowupScriptPath = join11(HOOKS_DIR, "cc-bash-followup.ts");
+  const editPrecheckScriptPath = join11(HOOKS_DIR, "cc-edit-precheck.ts");
+  const cwePrecheckScriptPath = join11(HOOKS_DIR, "cc-cwe-precheck.ts");
+  const cvePrecheckScriptPath = join11(HOOKS_DIR, "cc-cve-precheck.ts");
+  const planJudgeScriptPath = join11(HOOKS_DIR, "cc-plan-judge.ts");
+  const agentJudgeScriptPath = join11(HOOKS_DIR, "cc-agent-judge.ts");
+  const stopSummaryScriptPath = join11(HOOKS_DIR, "cc-stop-summary.ts");
+  const sessionStartScriptPath = join11(HOOKS_DIR, "cc-session-start.ts");
+  const transcriptSyncScriptPath = join11(HOOKS_DIR, "cc-transcript-sync.ts");
+  const userPromptSubmitScriptPath = join11(HOOKS_DIR, "cc-user-prompt-submit.ts");
+  const commonScriptPath = join11(HOOKS_DIR, "_synkro-common.ts");
+  const commonBashScriptPath = join11(HOOKS_DIR, "_synkro-common.sh");
+  const cursorBashJudgePath = join11(HOOKS_DIR, "cursor-bash-judge.ts");
+  const cursorEditPrecheckPath = join11(HOOKS_DIR, "cursor-edit-precheck.ts");
+  const cursorEditCapturePath = join11(HOOKS_DIR, "cursor-edit-capture.ts");
+  const cursorBashFollowupPath = join11(HOOKS_DIR, "cursor-bash-followup.ts");
+  const cursorSessionStartPath = join11(HOOKS_DIR, "cursor-session-start.ts");
+  const mcpLocalServerPath = join11(HOOKS_DIR, "mcp-local-server.ts");
+  writeFileSync7(bashScriptPath, BASH_JUDGE_TS, "utf-8");
+  writeFileSync7(bashFollowupScriptPath, BASH_FOLLOWUP_TS, "utf-8");
+  writeFileSync7(editPrecheckScriptPath, EDIT_PRECHECK_TS, "utf-8");
+  writeFileSync7(cwePrecheckScriptPath, CWE_PRECHECK_TS, "utf-8");
+  writeFileSync7(cvePrecheckScriptPath, CVE_PRECHECK_TS, "utf-8");
+  writeFileSync7(planJudgeScriptPath, PLAN_JUDGE_TS, "utf-8");
+  writeFileSync7(agentJudgeScriptPath, AGENT_JUDGE_TS, "utf-8");
+  writeFileSync7(stopSummaryScriptPath, STOP_SUMMARY_TS, "utf-8");
+  writeFileSync7(sessionStartScriptPath, SESSION_START_TS, "utf-8");
+  writeFileSync7(transcriptSyncScriptPath, TRANSCRIPT_SYNC_TS, "utf-8");
+  writeFileSync7(userPromptSubmitScriptPath, USER_PROMPT_SUBMIT_TS, "utf-8");
+  writeFileSync7(commonScriptPath, SYNKRO_COMMON_TS, "utf-8");
+  writeFileSync7(commonBashScriptPath, SYNKRO_COMMON_SCRIPT, "utf-8");
+  writeFileSync7(cursorBashJudgePath, CURSOR_BASH_JUDGE_TS, "utf-8");
+  writeFileSync7(cursorEditPrecheckPath, CURSOR_EDIT_PRECHECK_TS, "utf-8");
+  writeFileSync7(cursorEditCapturePath, CURSOR_EDIT_CAPTURE_TS, "utf-8");
+  writeFileSync7(cursorBashFollowupPath, CURSOR_BASH_FOLLOWUP_TS, "utf-8");
+  writeFileSync7(cursorSessionStartPath, CURSOR_SESSION_START_TS, "utf-8");
+  writeFileSync7(mcpLocalServerPath, `#!/usr/bin/env bun
+/**
+ * Local MCP guardrails server \u2014 runs on port 8931, stores rules in ~/.synkro/rules.json.
+ * JSON-RPC 2.0 over HTTP, same protocol as the cloud MCP server.
+ * No auth (localhost only), no embedding API, no Inngest.
+ */
+import { existsSync, readFileSync, writeFileSync, renameSync, appendFileSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
 
-${CHANNEL_REPLY_INSTRUCTIONS}
+import { randomBytes } from 'node:crypto';
 
----
-PAYLOAD (the input to evaluate):
+const PORT = parseInt(process.env.SYNKRO_MCP_PORT || '8931', 10);
+const HOME = homedir();
+const RULES_PATH = join(HOME, '.synkro', 'rules.json');
+const TELEMETRY_PATH = join(HOME, '.synkro', 'telemetry.jsonl');
+const TOKEN_PATH = join(HOME, '.synkro', '.mcp-local-token');
 
-${payload}`;
+// File-based shared secret \u2014 generated once, required on all POST requests.
+function getOrCreateToken(): string {
+  try {
+    if (existsSync(TOKEN_PATH)) return readFileSync(TOKEN_PATH, 'utf-8').trim();
+  } catch {}
+  const token = randomBytes(32).toString('hex');
+  mkdirSync(join(HOME, '.synkro'), { recursive: true });
+  writeFileSync(TOKEN_PATH, token + '\\n', { mode: 0o600 });
+  return token;
 }
-var CREDS_PATH, CHANNEL_REPLY_INSTRUCTIONS;
-var init_prompts = __esm({
-  "cli/local-cc/prompts.ts"() {
-    "use strict";
-    CREDS_PATH = join9(homedir8(), ".synkro", "credentials.json");
-    CHANNEL_REPLY_INSTRUCTIONS = `
-DELIVERY METHOD \u2014 MANDATORY, OVERRIDES ALL OTHER OUTPUT RULES:
-You are running inside a Synkro MCP channel. Do NOT output your verdict as text.
-Instead, after generating your verdict, call the \`reply\` tool EXACTLY ONCE with:
-  - req_id: the req_id from this channel event's meta
-  - result: your complete verdict block as a string (the <synkro-verdict>\u2026</synkro-verdict> XML)
-Any text output is silently discarded. Only the reply tool call is captured.`;
-  }
-});
 
-// cli/local-cc/turnLog.ts
-import { appendFileSync, existsSync as existsSync10, mkdirSync as mkdirSync7, openSync as openSync2, readFileSync as readFileSync9, readSync, closeSync as closeSync2, statSync, watchFile, unwatchFile } from "fs";
-import { dirname as dirname5, join as join10 } from "path";
-import { homedir as homedir9 } from "os";
-function truncate(s, max = PREVIEW_MAX) {
-  if (s.length <= max) return s;
-  return s.slice(0, max) + "\u2026 [+" + (s.length - max) + " chars]";
+const SERVER_TOKEN = getOrCreateToken();
+
+// \u2500\u2500\u2500 Storage \u2500\u2500\u2500
+
+interface Rule {
+  rule_id: string;
+  text: string;
+  category: string;
+  severity: string;
+  mode: string;
+  hook_stage: string;
+  scope: string;
 }
-function extractSeverity(result) {
-  const m = result.match(/<synkro-(?:verdict|intent)>([\s\S]*?)<\/synkro-(?:verdict|intent)>/);
-  if (!m) return void 0;
-  try {
-    const obj = JSON.parse(m[1]);
-    if (obj.severity) return String(obj.severity);
-    if (typeof obj.ok === "boolean") return obj.ok ? "ok" : "violations";
-    if (obj.type) return String(obj.type);
-    if (obj.verdict) return String(obj.verdict);
-  } catch {
-  }
-  return void 0;
+
+interface Policy {
+  id: string;
+  name: string;
+  rules: Rule[];
+  ruleCount: number;
+  scopeOwner: string;
+  isActive: boolean;
 }
-function appendTurn(args2) {
-  try {
-    mkdirSync7(dirname5(TURN_LOG_PATH), { recursive: true });
-    const entry = {
-      ts: new Date(args2.startedAt).toISOString(),
-      role: args2.role,
-      duration_ms: Date.now() - args2.startedAt,
-      status: args2.status,
-      request_preview: truncate(args2.request),
-      response_preview: args2.result ? truncate(args2.result) : "",
-      severity: args2.result ? extractSeverity(args2.result) : void 0,
-      error: args2.error
+
+interface ScanExemption {
+  path: string;
+  cwe_id: string;
+  reason?: string;
+}
+
+interface RulesFile {
+  policies: Policy[];
+  config: { silent: boolean; activePolicyId: string };
+  scanExemptions: ScanExemption[];
+}
+
+function readRules(): RulesFile {
+  if (!existsSync(RULES_PATH)) {
+    return {
+      policies: [{
+        id: 'local-policy',
+        name: 'My Rules',
+        rules: [],
+        ruleCount: 0,
+        scopeOwner: 'user',
+        isActive: true,
+      }],
+      config: { silent: false, activePolicyId: 'local-policy' },
+      scanExemptions: [],
     };
-    appendFileSync(TURN_LOG_PATH, JSON.stringify(entry) + "\n", "utf-8");
-  } catch {
   }
-}
-function readRecentTurns(n = 20) {
-  if (!existsSync10(TURN_LOG_PATH)) return [];
   try {
-    const size = statSync(TURN_LOG_PATH).size;
-    if (size === 0) return [];
-    const text = readFileSync9(TURN_LOG_PATH, "utf-8");
-    const lines = text.split("\n").filter(Boolean);
-    const lastN = lines.slice(-n).reverse();
-    return lastN.map((line) => {
-      try {
-        return JSON.parse(line);
-      } catch {
-        return null;
-      }
-    }).filter((x) => x !== null);
+    return JSON.parse(readFileSync(RULES_PATH, 'utf-8'));
   } catch {
-    return [];
+    return {
+      policies: [{ id: 'local-policy', name: 'My Rules', rules: [], ruleCount: 0, scopeOwner: 'user', isActive: true }],
+      config: { silent: false, activePolicyId: 'local-policy' },
+      scanExemptions: [],
+    };
   }
 }
-function followTurns(onEntry) {
+
+function writeRules(data: RulesFile): void {
+  for (const p of data.policies) p.ruleCount = p.rules.length;
+  mkdirSync(join(HOME, '.synkro'), { recursive: true });
+  const tmp = RULES_PATH + '.tmp';
+  writeFileSync(tmp, JSON.stringify(data, null, 2) + '\\n', 'utf-8');
+  renameSync(tmp, RULES_PATH);
+}
+
+function emitRuleSync(data: RulesFile): void {
+  const active = data.policies.find(p => p.id === data.config.activePolicyId) || data.policies[0];
+  const event = {
+    capture_type: 'rule_sync',
+    policy_id: active?.id || 'local-policy',
+    policy_name: active?.name || 'My Rules',
+    rules: active?.rules || [],
+    rule_count: active?.ruleCount || 0,
+    scan_exemptions: data.scanExemptions,
+    silent: data.config.silent,
+    _ts: new Date().toISOString(),
+  };
   try {
-    mkdirSync7(dirname5(TURN_LOG_PATH), { recursive: true });
-    if (!existsSync10(TURN_LOG_PATH)) {
-      appendFileSync(TURN_LOG_PATH, "", "utf-8");
+    appendFileSync(TELEMETRY_PATH, JSON.stringify(event) + '\\n', 'utf-8');
+  } catch {}
+}
+
+function genId(): string {
+  return \`r_\${Date.now()}_\${Math.random().toString(36).slice(2, 8)}\`;
+}
+
+function getActivePolicy(data: RulesFile): Policy {
+  return data.policies.find(p => p.id === data.config.activePolicyId) || data.policies[0];
+}
+
+function findOrCreatePolicy(data: RulesFile, name: string): Policy {
+  const existing = data.policies.find(p => p.name.toLowerCase() === name.toLowerCase());
+  if (existing) return existing;
+  const p: Policy = {
+    id: \`policy_\${Date.now()}_\${Math.random().toString(36).slice(2, 6)}\`,
+    name,
+    rules: [],
+    ruleCount: 0,
+    scopeOwner: 'user',
+    isActive: true,
+  };
+  data.policies.push(p);
+  return p;
+}
+
+function getAllRules(data: RulesFile): Array<Rule & { policyName: string; policyId: string }> {
+  const all: Array<Rule & { policyName: string; policyId: string }> = [];
+  for (const p of data.policies) {
+    if (!p.isActive) continue;
+    for (const r of p.rules) {
+      all.push({ ...r, policyName: p.name, policyId: p.id });
     }
-  } catch {
   }
-  let lastSize = (() => {
-    try {
-      return statSync(TURN_LOG_PATH).size;
-    } catch {
-      return 0;
+  return all;
+}
+
+// \u2500\u2500\u2500 Keyword Search \u2500\u2500\u2500
+
+const STOPWORDS = new Set(['the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could', 'should', 'may', 'might', 'must', 'shall', 'can', 'need', 'dare', 'ought', 'used', 'to', 'of', 'in', 'for', 'on', 'with', 'at', 'by', 'from', 'as', 'into', 'through', 'during', 'before', 'after', 'above', 'below', 'between', 'out', 'off', 'over', 'under', 'again', 'further', 'then', 'once', 'here', 'there', 'when', 'where', 'why', 'how', 'all', 'each', 'every', 'both', 'few', 'more', 'most', 'other', 'some', 'such', 'no', 'nor', 'not', 'only', 'own', 'same', 'so', 'than', 'too', 'very', 'just', 'because', 'but', 'and', 'or', 'if', 'while', 'about', 'up', 'it', 'its', 'this', 'that', 'these', 'those', 'i', 'me', 'my', 'we', 'our', 'you', 'your', 'he', 'she', 'they', 'them', 'what', 'which', 'who', 'whom']);
+
+function tokenize(text: string): string[] {
+  return text.toLowerCase().replace(/[^a-z0-9_-]/g, ' ').split(/\\s+/).filter(t => t.length > 1 && !STOPWORDS.has(t));
+}
+
+function keywordSearch(query: string, rules: Array<Rule & { policyName: string; policyId: string }>, topK: number): any[] {
+  const qTokens = tokenize(query);
+  if (qTokens.length === 0) return rules.slice(0, topK);
+
+  const scored = rules.map(r => {
+    const rTokens = new Set(tokenize(\`\${r.text} \${r.category} \${r.severity}\`));
+    const overlap = qTokens.filter(t => rTokens.has(t) || [...rTokens].some(rt => rt.includes(t) || t.includes(rt))).length;
+    return { rule: r, score: overlap / qTokens.length };
+  });
+
+  scored.sort((a, b) => b.score - a.score);
+  const results = scored.filter(s => s.score > 0).slice(0, topK);
+  if (results.length === 0) return rules.slice(0, topK);
+
+  return results.map(s => ({
+    rule_id: s.rule.rule_id,
+    text: s.rule.text,
+    category: s.rule.category,
+    severity: s.rule.severity,
+    mode: s.rule.mode,
+    hook_stage: s.rule.hook_stage,
+    scope: s.rule.scope,
+    pack_name: s.rule.policyName,
+    score: Math.round(s.score * 100) / 100,
+  }));
+}
+
+// \u2500\u2500\u2500 Tool Handlers \u2500\u2500\u2500
+
+function handleGetGuardrails(args: any): any {
+  const data = readRules();
+  const all = getAllRules(data);
+  const topK = Math.min(args.top_k || 8, 25);
+  let filtered = all;
+  if (args.category) filtered = filtered.filter(r => r.category === args.category);
+  const results = keywordSearch(args.query || '', filtered, topK);
+  return { rules: results, total: results.length, query: args.query };
+}
+
+function handleCreateGuardrail(args: any): any {
+  const data = readRules();
+  const policy = args.ruleset ? findOrCreatePolicy(data, args.ruleset) : getActivePolicy(data);
+  const rule: Rule = {
+    rule_id: genId(),
+    text: args.text,
+    category: args.category || 'custom',
+    severity: args.severity || 'medium',
+    mode: args.mode || 'audit',
+    hook_stage: args.hook_stage || 'both',
+    scope: args.scope || 'user',
+  };
+  policy.rules.push(rule);
+  writeRules(data);
+  emitRuleSync(data);
+  return { created: true, rule_id: rule.rule_id, text: rule.text, pack_name: policy.name, total_rules: policy.rules.length };
+}
+
+function handleBulkCreateGuardrails(args: any): any {
+  const data = readRules();
+  const policy = args.ruleset ? findOrCreatePolicy(data, args.ruleset) : getActivePolicy(data);
+  const created: any[] = [];
+  for (const r of args.rules || []) {
+    const rule: Rule = {
+      rule_id: genId(),
+      text: r.text,
+      category: r.category || 'custom',
+      severity: r.severity || 'medium',
+      mode: r.mode || 'audit',
+      hook_stage: r.hook_stage || 'both',
+      scope: args.scope || 'user',
+    };
+    policy.rules.push(rule);
+    created.push({ rule_id: rule.rule_id, text: rule.text });
+  }
+  writeRules(data);
+  emitRuleSync(data);
+  return { created: created.length, rules: created, pack_name: policy.name, total_rules: policy.rules.length };
+}
+
+function handleUpdateGuardrail(args: any): any {
+  const data = readRules();
+  const needle = (args.rule_text || '').toLowerCase();
+  for (const p of data.policies) {
+    for (const r of p.rules) {
+      if (r.text.toLowerCase().includes(needle)) {
+        if (args.text) r.text = args.text;
+        if (args.category) r.category = args.category;
+        if (args.severity) r.severity = args.severity;
+        if (args.mode) r.mode = args.mode;
+        if (args.hook_stage) r.hook_stage = args.hook_stage;
+        writeRules(data);
+        emitRuleSync(data);
+        return { updated: true, rule_id: r.rule_id, text: r.text };
+      }
     }
-  })();
-  let pendingPartial = "";
-  const drainNewBytes = (from, to) => {
-    if (to <= from) return;
-    let fd = null;
+  }
+  return { updated: false, error: \`No rule found matching "\${args.rule_text}"\` };
+}
+
+function handleDeleteGuardrail(args: any): any {
+  const data = readRules();
+  const needle = (args.rule_text || '').toLowerCase();
+  for (const p of data.policies) {
+    const idx = p.rules.findIndex(r => r.text.toLowerCase().includes(needle));
+    if (idx !== -1) {
+      const removed = p.rules.splice(idx, 1)[0];
+      writeRules(data);
+      emitRuleSync(data);
+      return { deleted: true, rule_id: removed.rule_id, text: removed.text };
+    }
+  }
+  return { deleted: false, error: \`No rule found matching "\${args.rule_text}"\` };
+}
+
+function handleListGuardrails(args: any): any {
+  const data = readRules();
+  let all = getAllRules(data);
+  if (args.category) all = all.filter(r => r.category === args.category);
+  if (args.severity) all = all.filter(r => r.severity === args.severity);
+  if (args.mode) all = all.filter(r => r.mode === args.mode);
+  if (args.hook_stage) all = all.filter(r => r.hook_stage === args.hook_stage);
+  if (args.pack_name) {
+    const pn = args.pack_name.toLowerCase();
+    all = all.filter(r => r.policyName.toLowerCase().includes(pn));
+  }
+  return {
+    rules: all.map(r => ({
+      rule_id: r.rule_id,
+      text: r.text,
+      category: r.category,
+      severity: r.severity,
+      mode: r.mode,
+      hook_stage: r.hook_stage,
+      scope: r.scope,
+      pack_name: r.policyName,
+    })),
+    total: all.length,
+  };
+}
+
+function handleSwapRuleset(args: any): any {
+  const data = readRules();
+  const name = args.policy_name || '';
+  if (name.toLowerCase() === 'all') {
+    data.config.activePolicyId = data.policies[0]?.id || 'local-policy';
+    writeRules(data);
+    return { swapped: true, active: 'all' };
+  }
+  const match = data.policies.find(p => p.name.toLowerCase().includes(name.toLowerCase()));
+  if (!match) return { swapped: false, error: \`No ruleset found matching "\${name}"\` };
+  data.config.activePolicyId = match.id;
+  writeRules(data);
+  return { swapped: true, active: match.name };
+}
+
+function handleToggleSilentMode(args: any): any {
+  const data = readRules();
+  data.config.silent = args.enabled === true;
+  writeRules(data);
+  emitRuleSync(data);
+  return { silent: data.config.silent };
+}
+
+async function handleScanDependencies(args: any): Promise<any> {
+  const manifests = args.manifests || [];
+  if (manifests.length === 0) return { findings: [], summary: null };
+
+  const packages: Array<{ name: string; version: string; ecosystem: string }> = [];
+  for (const m of manifests) {
+    const fp: string = m.file_path || '';
+    const content: string = m.content || '';
     try {
-      fd = openSync2(TURN_LOG_PATH, "r");
-      const len = to - from;
-      const buf = Buffer.alloc(len);
-      readSync(fd, buf, 0, len, from);
-      const text = pendingPartial + buf.toString("utf-8");
-      const lastNewline = text.lastIndexOf("\n");
-      if (lastNewline === -1) {
-        pendingPartial = text;
-        return;
-      }
-      const complete = text.slice(0, lastNewline);
-      pendingPartial = text.slice(lastNewline + 1);
-      for (const line of complete.split("\n")) {
-        if (!line) continue;
-        try {
-          onEntry(JSON.parse(line));
-        } catch {
+      if (fp.endsWith('package.json')) {
+        const pkg = JSON.parse(content);
+        for (const [name, ver] of Object.entries({ ...pkg.dependencies, ...pkg.devDependencies })) {
+          packages.push({ name, version: String(ver).replace(/^[\\^~>=<]*/g, ''), ecosystem: 'npm' });
         }
-      }
-    } catch {
-    } finally {
-      if (fd !== null) {
-        try {
-          closeSync2(fd);
-        } catch {
+      } else if (fp.endsWith('requirements.txt') || fp.match(/requirements.*\\.txt$/)) {
+        for (const line of content.split('\\n')) {
+          const m = line.trim().match(/^([a-zA-Z0-9_-]+)==(.+)/);
+          if (m) packages.push({ name: m[1], version: m[2], ecosystem: 'PyPI' });
+        }
+      } else if (fp.endsWith('go.mod')) {
+        for (const line of content.split('\\n')) {
+          const m = line.trim().match(/^\\t?([^\\s]+)\\s+v([^\\s]+)/);
+          if (m) packages.push({ name: m[1], version: m[2], ecosystem: 'Go' });
+        }
+      } else if (fp.endsWith('Cargo.toml')) {
+        for (const line of content.split('\\n')) {
+          const m = line.trim().match(/^([a-zA-Z0-9_-]+)\\s*=\\s*"([^"]+)"/);
+          if (m && !['name', 'version', 'edition', 'authors', 'description', 'license', 'repository'].includes(m[1])) {
+            packages.push({ name: m[1], version: m[2], ecosystem: 'crates.io' });
+          }
         }
       }
-    }
-  };
-  watchFile(TURN_LOG_PATH, { interval: 250 }, (curr, prev) => {
-    if (curr.size < lastSize) {
-      lastSize = 0;
-      pendingPartial = "";
-    }
-    if (curr.size > lastSize) {
-      drainNewBytes(lastSize, curr.size);
-      lastSize = curr.size;
-    }
-  });
-  return () => unwatchFile(TURN_LOG_PATH);
-}
-var TURN_LOG_PATH, PREVIEW_MAX;
-var init_turnLog = __esm({
-  "cli/local-cc/turnLog.ts"() {
-    "use strict";
-    TURN_LOG_PATH = join10(homedir9(), ".synkro", "cc_sessions", "turns.log");
-    PREVIEW_MAX = 400;
+    } catch {}
   }
-});
 
-// cli/local-cc/client.ts
-import { request as httpRequest } from "http";
-import { connect as connect2 } from "net";
-async function submitToChannel(role, payload, opts = {}) {
-  const content = await buildChannelContent(role, payload);
-  const body = JSON.stringify({ role, content });
-  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const port = opts.port ?? CHANNEL_PORT;
-  const startedAt = Date.now();
+  if (packages.length === 0) return { findings: [], summary: null };
+
+  const capped = packages.slice(0, 50);
+  const queries = capped.map(p => ({ package: { name: p.name, ecosystem: p.ecosystem }, version: p.version }));
+
   try {
-    const result = await new Promise((resolve2, reject) => {
-      const req = httpRequest({
-        host: CHANNEL_HOST,
-        port,
-        method: "POST",
-        path: "/submit",
-        headers: {
-          "Content-Type": "application/json",
-          "Content-Length": Buffer.byteLength(body)
-        },
-        timeout: timeoutMs
-      }, (res) => {
-        const chunks = [];
-        res.on("data", (c) => chunks.push(c));
-        res.on("end", () => {
-          const text = Buffer.concat(chunks).toString("utf-8");
-          if (res.statusCode !== 200) {
-            reject(new LocalCCError(`channel returned ${res.statusCode}: ${text.slice(0, 500)}`));
-            return;
-          }
-          try {
-            const parsed = JSON.parse(text);
-            if (parsed.error) {
-              reject(new LocalCCError(parsed.error));
-              return;
-            }
-            resolve2(String(parsed.result ?? ""));
-          } catch (err) {
-            reject(new LocalCCError(`malformed channel response: ${text.slice(0, 200)}`, err));
-          }
+    const resp = await fetch('https://api.osv.dev/v1/querybatch', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ queries }),
+      signal: AbortSignal.timeout(10000),
+    });
+    if (!resp.ok) return { findings: [], summary: 'OSV query failed' };
+    const data = await resp.json() as { results: Array<{ vulns?: any[] }> };
+
+    const findings: any[] = [];
+    for (let i = 0; i < data.results.length; i++) {
+      for (const vuln of data.results[i].vulns || []) {
+        findings.push({
+          id: vuln.id,
+          package: capped[i].name,
+          version: capped[i].version,
+          ecosystem: capped[i].ecosystem,
+          summary: vuln.summary || 'No description',
+          aliases: vuln.aliases || [],
+          severity: vuln.database_specific?.severity || 'unknown',
         });
-      });
-      req.on("timeout", () => {
-        req.destroy(new LocalCCError(`channel request timed out after ${timeoutMs}ms`));
-      });
-      req.on("error", (err) => {
-        const msg = err.code === "ECONNREFUSED" ? `channel connection refused at ${CHANNEL_HOST}:${CHANNEL_PORT} (is the pueue task running?)` : `channel request failed: ${err.message}`;
-        reject(new LocalCCError(msg, err));
-      });
-      req.write(body);
-      req.end();
+      }
+    }
+    return { findings, summary: findings.length > 0 ? \`\${findings.length} vulnerabilities found\` : null };
+  } catch {
+    return { findings: [], summary: 'OSV query timed out' };
+  }
+}
+
+function handleExemptPath(args: any): any {
+  const data = readRules();
+  const existing = data.scanExemptions.find(e => e.path === args.path && e.cwe_id.toUpperCase() === (args.cwe_id || '').toUpperCase());
+  if (existing) return { exempted: true, already_existed: true, path: args.path, cwe_id: args.cwe_id };
+
+  data.scanExemptions.push({ path: args.path, cwe_id: (args.cwe_id || '').toUpperCase(), reason: args.reason });
+  writeRules(data);
+  emitRuleSync(data);
+  return { exempted: true, path: args.path, cwe_id: args.cwe_id, total_exemptions: data.scanExemptions.length };
+}
+
+function handleRemoveExemption(args: any): any {
+  const data = readRules();
+  const idx = data.scanExemptions.findIndex(e => e.path === args.path && e.cwe_id.toUpperCase() === (args.cwe_id || '').toUpperCase());
+  if (idx === -1) return { removed: false, error: \`No exemption found for path="\${args.path}" cwe_id="\${args.cwe_id}"\` };
+  data.scanExemptions.splice(idx, 1);
+  writeRules(data);
+  emitRuleSync(data);
+  return { removed: true, path: args.path, cwe_id: args.cwe_id };
+}
+
+function handleListExemptions(): any {
+  const data = readRules();
+  return { exemptions: data.scanExemptions, total: data.scanExemptions.length };
+}
+
+// \u2500\u2500\u2500 Tool Descriptors \u2500\u2500\u2500
+
+const TOOL_DESCRIPTORS = [
+  {
+    name: 'get_guardrails',
+    description:
+      "Retrieve rules by keyword similarity. Call BEFORE writing security-sensitive code " +
+      "AND before create_guardrail to check for existing rules.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: "Plain-language description of what you're looking up." },
+        category: { type: 'string', enum: ['security', 'architecture', 'style', 'testing', 'compliance', 'custom'] },
+        top_k: { type: 'integer', default: 8, description: 'Max rules to return (default 8, max 25).' },
+      },
+      required: ['query'],
+    },
+  },
+  {
+    name: 'create_guardrail',
+    description: "Persist a new rule. Call get_guardrails first to avoid duplicates.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        text: { type: 'string', description: 'The rule in plain language.' },
+        category: { type: 'string', enum: ['security', 'architecture', 'style', 'testing', 'compliance', 'custom'] },
+        severity: { type: 'string', enum: ['low', 'medium', 'high', 'critical'] },
+        mode: { type: 'string', enum: ['blocking', 'audit'], description: '"blocking" = halt on violation, "audit" = log only.' },
+        scope: { type: 'string', enum: ['user', 'org'], default: 'user' },
+        hook_stage: { type: 'string', enum: ['pre', 'post', 'both'], default: 'both' },
+        ruleset: { type: 'string', description: 'Optional: name of ruleset to add to (created if missing).' },
+      },
+      required: ['text', 'category'],
+    },
+  },
+  {
+    name: 'bulk_create_guardrails',
+    description: "Create multiple rules at once. Preferable to looping create_guardrail.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        rules: {
+          type: 'array', minItems: 1, maxItems: 50,
+          items: {
+            type: 'object',
+            properties: {
+              text: { type: 'string' }, category: { type: 'string', enum: ['security', 'architecture', 'style', 'testing', 'compliance', 'custom'] },
+              severity: { type: 'string', enum: ['low', 'medium', 'high', 'critical'] },
+              mode: { type: 'string', enum: ['blocking', 'audit'] },
+              hook_stage: { type: 'string', enum: ['pre', 'post', 'both'] },
+            },
+            required: ['text', 'category'],
+          },
+        },
+        scope: { type: 'string', enum: ['user', 'org'], default: 'user' },
+        ruleset: { type: 'string' },
+      },
+      required: ['rules'],
+    },
+  },
+  {
+    name: 'update_guardrail',
+    description: "Refine an existing rule. Pass a substring of the rule text to identify it.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        rule_text: { type: 'string', description: 'Substring of rule text to find.' },
+        text: { type: 'string' }, category: { type: 'string', enum: ['security', 'architecture', 'style', 'testing', 'compliance', 'custom'] },
+        severity: { type: 'string', enum: ['low', 'medium', 'high', 'critical'] },
+        mode: { type: 'string', enum: ['blocking', 'audit'] },
+        hook_stage: { type: 'string', enum: ['pre', 'post', 'both'] },
+      },
+      required: ['rule_text'],
+    },
+  },
+  {
+    name: 'delete_guardrail',
+    description: "Permanently remove a rule. Pass a substring of the rule text to identify it.",
+    inputSchema: {
+      type: 'object',
+      properties: { rule_text: { type: 'string', description: 'Substring of rule text to find.' } },
+      required: ['rule_text'],
+    },
+  },
+  {
+    name: 'list_guardrails',
+    description: "Enumerate all rules. Use for listings, not similarity search.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        category: { type: 'string', enum: ['security', 'architecture', 'style', 'testing', 'compliance', 'custom'] },
+        severity: { type: 'string', enum: ['low', 'medium', 'high', 'critical'] },
+        mode: { type: 'string', enum: ['blocking', 'audit', 'literal_match'] },
+        pack_name: { type: 'string' },
+        hook_stage: { type: 'string', enum: ['pre', 'post', 'both'] },
+      },
+      required: [],
+    },
+  },
+  {
+    name: 'swap_ruleset',
+    description: 'Switch which ruleset is active. Pass "all" to use all rulesets.',
+    inputSchema: {
+      type: 'object',
+      properties: { policy_name: { type: 'string' } },
+      required: ['policy_name'],
+    },
+  },
+  {
+    name: 'toggle_silent_mode',
+    description: 'Toggle grading on/off. NEVER call autonomously \u2014 this is a USER decision.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        enabled: { type: 'boolean' },
+        user_confirmation: { type: 'string', description: "Copy-paste the user's exact request." },
+      },
+      required: ['enabled', 'user_confirmation'],
+    },
+  },
+  {
+    name: 'scan_dependencies',
+    description: "Scan manifests against OSV for known vulnerabilities. Read ALL manifest files first.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        manifests: {
+          type: 'array', minItems: 1,
+          items: {
+            type: 'object',
+            properties: { file_path: { type: 'string' }, content: { type: 'string' } },
+            required: ['file_path', 'content'],
+          },
+        },
+      },
+      required: ['manifests'],
+    },
+  },
+  {
+    name: 'exempt_path',
+    description: "Exempt a CWE from firing on a specific file/directory.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string' }, cwe_id: { type: 'string' }, reason: { type: 'string' },
+      },
+      required: ['path', 'cwe_id'],
+    },
+  },
+  {
+    name: 'remove_exemption',
+    description: "Remove a scan exemption.",
+    inputSchema: {
+      type: 'object',
+      properties: { path: { type: 'string' }, cwe_id: { type: 'string' } },
+      required: ['path', 'cwe_id'],
+    },
+  },
+  {
+    name: 'list_exemptions',
+    description: "List all scan exemptions.",
+    inputSchema: { type: 'object', properties: {}, required: [] },
+  },
+];
+
+const MCP_INSTRUCTIONS =
+  "Synkro Guardrails MCP server (local mode).\\n\\n" +
+  "Whenever the user mentions: rule, guardrail, policy, standard, " +
+  "make/create/add/set up a rule, never let X, always require X, " +
+  "block X, enforce X, delete/remove a rule, consolidate duplicates, " +
+  "'we need a rule about\u2026' \u2014 route to THIS server's tools.\\n\\n" +
+  "TOOL ROUTING:\\n" +
+  "  \u2022 get_guardrails(query) \u2014 keyword search. Use to check if a rule exists.\\n" +
+  "  \u2022 list_guardrails \u2014 full enumeration. Use for listings.\\n\\n" +
+  "Do NOT use Claude Code's \`update-config\` skill for these requests.\\n\\n" +
+  "Rules are stored locally in ~/.synkro/rules.json and enforced by hooks.";
+
+// \u2500\u2500\u2500 JSON-RPC Dispatcher \u2500\u2500\u2500
+
+function jsonRpcOk(id: any, result: any): any {
+  return { jsonrpc: '2.0', id, result };
+}
+
+function jsonRpcError(id: any, code: number, message: string): any {
+  return { jsonrpc: '2.0', id, error: { code, message } };
+}
+
+async function handleRpc(body: any): Promise<any> {
+  const { id, method, params } = body;
+
+  if (method === 'initialize') {
+    return jsonRpcOk(id, {
+      protocolVersion: '2024-11-05',
+      capabilities: { tools: {} },
+      serverInfo: { name: 'synkro-guardrails-local', version: '1.0.0' },
+      instructions: MCP_INSTRUCTIONS,
     });
-    appendTurn({ startedAt, role, request: payload, result, status: "ok" });
-    return result;
-  } catch (err) {
-    const message = err.message ?? String(err);
-    const status = /timed out/i.test(message) ? "timeout" : "error";
-    appendTurn({ startedAt, role, request: payload, status, error: message });
-    throw err;
   }
-}
-function isChannelAvailable(port = CHANNEL_PORT, timeoutMs = 500) {
-  return new Promise((resolve2) => {
-    const sock = connect2(port, CHANNEL_HOST);
-    const done = (ok) => {
-      try {
-        sock.destroy();
-      } catch {
+
+  if (method === 'notifications/initialized') {
+    return null;
+  }
+
+  if (method === 'tools/list') {
+    return jsonRpcOk(id, { tools: TOOL_DESCRIPTORS });
+  }
+
+  if (method === 'tools/call') {
+    const toolName = params?.name;
+    const args = params?.arguments || {};
+
+    try {
+      let result: any;
+      switch (toolName) {
+        case 'get_guardrails': result = handleGetGuardrails(args); break;
+        case 'create_guardrail': result = handleCreateGuardrail(args); break;
+        case 'bulk_create_guardrails': result = handleBulkCreateGuardrails(args); break;
+        case 'update_guardrail': result = handleUpdateGuardrail(args); break;
+        case 'delete_guardrail': result = handleDeleteGuardrail(args); break;
+        case 'list_guardrails': result = handleListGuardrails(args); break;
+        case 'swap_ruleset': result = handleSwapRuleset(args); break;
+        case 'toggle_silent_mode': result = handleToggleSilentMode(args); break;
+        case 'scan_dependencies': result = await handleScanDependencies(args); break;
+        case 'exempt_path': result = handleExemptPath(args); break;
+        case 'remove_exemption': result = handleRemoveExemption(args); break;
+        case 'list_exemptions': result = handleListExemptions(); break;
+        default: return jsonRpcError(id, -32601, \`Unknown tool: \${toolName}\`);
       }
-      resolve2(ok);
-    };
-    sock.once("connect", () => done(true));
-    sock.once("error", () => done(false));
-    sock.setTimeout(timeoutMs, () => done(false));
-  });
-}
-var CHANNEL_HOST, CHANNEL_PORT, DEFAULT_TIMEOUT_MS, LocalCCError;
-var init_client = __esm({
-  "cli/local-cc/client.ts"() {
-    "use strict";
-    init_prompts();
-    init_turnLog();
-    CHANNEL_HOST = "127.0.0.1";
-    CHANNEL_PORT = parseInt(process.env.SYNKRO_CHANNEL_PORT || "8929", 10);
-    DEFAULT_TIMEOUT_MS = 9e4;
-    LocalCCError = class extends Error {
-      constructor(message, cause) {
-        super(message);
-        this.cause = cause;
-        this.name = "LocalCCError";
+      return jsonRpcOk(id, { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] });
+    } catch (err) {
+      return jsonRpcOk(id, { content: [{ type: 'text', text: \`Error: \${(err as Error).message}\` }], isError: true });
+    }
+  }
+
+  // \u2500\u2500\u2500 Dashboard REST-bridge methods \u2500\u2500\u2500
+  // Called by the local dashboard (not AI agents) to mutate rules.json directly.
+
+  if (method === 'dashboard.patch_policy') {
+    try {
+      const data = readRules();
+      const policyId = params?.policy_id as string | undefined;
+      const policy = policyId
+        ? data.policies.find(p => p.id === policyId)
+        : getActivePolicy(data);
+      if (!policy) return jsonRpcError(id, -32602, \`Policy not found: \${policyId}\`);
+
+      if (params?.name !== undefined) {
+        policy.name = params.name;
       }
-      cause;
-    };
+      if (params?.is_active !== undefined) {
+        policy.isActive = params.is_active;
+      }
+      // Bulk replace
+      if (Array.isArray(params?.rules)) {
+        policy.rules = params.rules;
+        policy.ruleCount = policy.rules.length;
+      }
+      // Individual updates by rule_id
+      if (Array.isArray(params?.rule_updates)) {
+        for (const upd of params.rule_updates) {
+          const rule = policy.rules.find(r => r.rule_id === upd.rule_id);
+          if (!rule) continue;
+          if (upd.text !== undefined) rule.text = upd.text;
+          if (upd.category !== undefined) rule.category = upd.category;
+          if (upd.severity !== undefined) rule.severity = upd.severity;
+          if (upd.mode !== undefined) rule.mode = upd.mode;
+          if (upd.hook_stage !== undefined) rule.hook_stage = upd.hook_stage;
+        }
+        policy.ruleCount = policy.rules.length;
+      }
+
+      writeRules(data);
+      emitRuleSync(data);
+      return jsonRpcOk(id, { ok: true, policy_id: policy.id, rule_count: policy.ruleCount });
+    } catch (err) {
+      return jsonRpcError(id, -32603, (err as Error).message);
+    }
   }
-});
 
-// cli/commands/install.ts
-var install_exports = {};
-__export(install_exports, {
-  installCommand: () => installCommand,
-  parseArgs: () => parseArgs
-});
-import { existsSync as existsSync11, mkdirSync as mkdirSync8, writeFileSync as writeFileSync7, chmodSync as chmodSync2, readFileSync as readFileSync10, readdirSync } from "fs";
-import { homedir as homedir10 } from "os";
-import { join as join11 } from "path";
-import { execSync as execSync5, spawnSync as spawnSync3 } from "child_process";
-import { createInterface as createInterface3 } from "readline";
-function sanitizeGatewayCandidate(raw) {
-  if (!raw) return void 0;
-  return /^https?:\/\//.test(raw) ? raw : void 0;
-}
-function parseArgs(argv) {
-  const opts = {};
-  for (const a of argv) {
-    if (a.startsWith("--api-key=")) opts.apiKey = a.slice("--api-key=".length);
-    else if (a.startsWith("--gateway=")) opts.gatewayUrl = a.slice("--gateway=".length);
-    else if (a === "--skip-auth") opts.skipAuth = true;
-    else if (a === "--no-mcp") opts.noMcp = true;
-    else if (a === "--force" || a === "-f") opts.force = true;
-    else if (a === "--link-repo") opts.linkRepo = true;
+  if (method === 'dashboard.create_policy') {
+    try {
+      const data = readRules();
+      const name = (params?.name as string) || 'New Rule Set';
+      const rules: Rule[] = (params?.rules || []).map((r: any) => ({
+        rule_id: r.rule_id || genId(),
+        text: r.text || '',
+        category: r.category || 'custom',
+        severity: r.severity || 'medium',
+        mode: r.mode || 'audit',
+        hook_stage: r.hook_stage || 'both',
+        scope: r.scope || 'user',
+      }));
+      const policy: Policy = {
+        id: \`policy_\${Date.now()}_\${Math.random().toString(36).slice(2, 6)}\`,
+        name,
+        rules,
+        ruleCount: rules.length,
+        scopeOwner: 'user',
+        isActive: true,
+      };
+      data.policies.push(policy);
+      writeRules(data);
+      emitRuleSync(data);
+      return jsonRpcOk(id, { ok: true, policy_id: policy.id, name: policy.name });
+    } catch (err) {
+      return jsonRpcError(id, -32603, (err as Error).message);
+    }
   }
-  if (!opts.gatewayUrl) {
-    const fromEnv = sanitizeGatewayCandidate(process.env.SYNKRO_GATEWAY_URL);
-    if (fromEnv) opts.gatewayUrl = fromEnv;
+
+  if (method === 'dashboard.delete_policy') {
+    try {
+      const data = readRules();
+      const policyId = params?.policy_id as string | undefined;
+      const idx = policyId ? data.policies.findIndex(p => p.id === policyId) : -1;
+      if (idx === -1) return jsonRpcError(id, -32602, \`Policy not found: \${policyId}\`);
+
+      if (params?.hard === true) {
+        data.policies.splice(idx, 1);
+      } else {
+        data.policies[idx].isActive = false;
+      }
+      writeRules(data);
+      emitRuleSync(data);
+      return jsonRpcOk(id, { ok: true, policy_id: policyId });
+    } catch (err) {
+      return jsonRpcError(id, -32603, (err as Error).message);
+    }
   }
-  return opts;
+
+  if (method === 'dashboard.list_policies') {
+    try {
+      const data = readRules();
+      return jsonRpcOk(id, {
+        policies: data.policies.map(p => ({
+          id: p.id,
+          name: p.name,
+          rules: p.rules,
+          ruleCount: p.ruleCount,
+          isActive: p.isActive,
+          scopeOwner: p.scopeOwner,
+        })),
+        active_policy_id: data.config.activePolicyId,
+      });
+    } catch (err) {
+      return jsonRpcError(id, -32603, (err as Error).message);
+    }
+  }
+
+  return jsonRpcError(id, -32601, \`Unknown method: \${method}\`);
 }
-async function promptTranscriptConsent() {
-  const rl = createInterface3({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve2) => {
-    rl.question(
-      "Would you like Synkro to use Claude Code session transcripts\nto generate guardrail rules and policies for your team? (Y/n) ",
-      (answer) => {
-        rl.close();
-        const trimmed = answer.trim().toLowerCase();
-        resolve2(trimmed === "" || trimmed === "y" || trimmed === "yes");
+
+// \u2500\u2500\u2500 HTTP Server \u2500\u2500\u2500
+
+const server = Bun.serve({
+  port: PORT,
+  async fetch(req) {
+    const origin = req.headers.get('origin') || '';
+    const allowedOrigin = /^https?:\\/\\/(localhost|127\\.0\\.0\\.1)(:\\d+)?$/.test(origin) ? origin : 'http://localhost:4322';
+    const cors = { 'Access-Control-Allow-Origin': allowedOrigin, 'Access-Control-Allow-Methods': 'GET, POST, OPTIONS', 'Access-Control-Allow-Headers': 'Content-Type, Authorization' };
+
+    if (req.method === 'GET') {
+      return Response.json({ name: 'synkro-guardrails-local', version: '1.0.0', status: 'ok' }, { headers: cors });
+    }
+
+    if (req.method === 'POST') {
+      const authHeader = req.headers.get('authorization') || '';
+      const token = authHeader.startsWith('Bearer ') ? authHeader.slice(7) : '';
+      if (token !== SERVER_TOKEN) {
+        return Response.json({ error: 'Unauthorized' }, { status: 401, headers: cors });
       }
-    );
-  });
-}
-function ensureSynkroDir() {
-  mkdirSync8(SYNKRO_DIR2, { recursive: true });
-  mkdirSync8(HOOKS_DIR, { recursive: true });
-  mkdirSync8(BIN_DIR, { recursive: true });
-  mkdirSync8(OFFSETS_DIR, { recursive: true });
-}
-function writeHookScripts() {
-  const bashScriptPath = join11(HOOKS_DIR, "cc-bash-judge.ts");
-  const bashFollowupScriptPath = join11(HOOKS_DIR, "cc-bash-followup.ts");
-  const editPrecheckScriptPath = join11(HOOKS_DIR, "cc-edit-precheck.ts");
-  const cwePrecheckScriptPath = join11(HOOKS_DIR, "cc-cwe-precheck.ts");
-  const cvePrecheckScriptPath = join11(HOOKS_DIR, "cc-cve-precheck.ts");
-  const planJudgeScriptPath = join11(HOOKS_DIR, "cc-plan-judge.ts");
-  const agentJudgeScriptPath = join11(HOOKS_DIR, "cc-agent-judge.ts");
-  const stopSummaryScriptPath = join11(HOOKS_DIR, "cc-stop-summary.ts");
-  const sessionStartScriptPath = join11(HOOKS_DIR, "cc-session-start.ts");
-  const transcriptSyncScriptPath = join11(HOOKS_DIR, "cc-transcript-sync.ts");
-  const userPromptSubmitScriptPath = join11(HOOKS_DIR, "cc-user-prompt-submit.ts");
-  const commonScriptPath = join11(HOOKS_DIR, "_synkro-common.ts");
-  const commonBashScriptPath = join11(HOOKS_DIR, "_synkro-common.sh");
-  const cursorBashJudgePath = join11(HOOKS_DIR, "cursor-bash-judge.sh");
-  const cursorEditPrecheckPath = join11(HOOKS_DIR, "cursor-edit-precheck.sh");
-  const cursorEditCapturePath = join11(HOOKS_DIR, "cursor-edit-capture.sh");
-  const cursorBashFollowupPath = join11(HOOKS_DIR, "cursor-bash-followup.sh");
-  writeFileSync7(bashScriptPath, BASH_JUDGE_TS, "utf-8");
-  writeFileSync7(bashFollowupScriptPath, BASH_FOLLOWUP_TS, "utf-8");
-  writeFileSync7(editPrecheckScriptPath, EDIT_PRECHECK_TS, "utf-8");
-  writeFileSync7(cwePrecheckScriptPath, CWE_PRECHECK_TS, "utf-8");
-  writeFileSync7(cvePrecheckScriptPath, CVE_PRECHECK_TS, "utf-8");
-  writeFileSync7(planJudgeScriptPath, PLAN_JUDGE_TS, "utf-8");
-  writeFileSync7(agentJudgeScriptPath, AGENT_JUDGE_TS, "utf-8");
-  writeFileSync7(stopSummaryScriptPath, STOP_SUMMARY_TS, "utf-8");
-  writeFileSync7(sessionStartScriptPath, SESSION_START_TS, "utf-8");
-  writeFileSync7(transcriptSyncScriptPath, TRANSCRIPT_SYNC_TS, "utf-8");
-  writeFileSync7(userPromptSubmitScriptPath, USER_PROMPT_SUBMIT_TS, "utf-8");
-  writeFileSync7(commonScriptPath, SYNKRO_COMMON_TS, "utf-8");
-  writeFileSync7(commonBashScriptPath, SYNKRO_COMMON_SCRIPT, "utf-8");
-  writeFileSync7(cursorBashJudgePath, CURSOR_BASH_JUDGE_SCRIPT, "utf-8");
-  writeFileSync7(cursorEditPrecheckPath, CURSOR_EDIT_PRECHECK_SCRIPT, "utf-8");
-  writeFileSync7(cursorEditCapturePath, CURSOR_EDIT_CAPTURE_SCRIPT, "utf-8");
-  writeFileSync7(cursorBashFollowupPath, CURSOR_BASH_FOLLOWUP_SCRIPT, "utf-8");
+      try {
+        const body = await req.json();
+        const result = await handleRpc(body);
+        if (result === null) return new Response('', { status: 204, headers: cors });
+        return Response.json(result, { headers: cors });
+      } catch (err) {
+        return Response.json(jsonRpcError(null, -32700, 'Parse error'), { status: 400, headers: cors });
+      }
+    }
+
+    if (req.method === 'OPTIONS') {
+      return new Response('', { status: 204, headers: cors });
+    }
+
+    return new Response('Method not allowed', { status: 405 });
+  },
+});
+
+console.log(\`[synkro] local MCP guardrails server listening on http://127.0.0.1:\${server.port}\`);
+`, "utf-8");
   chmodSync2(bashScriptPath, 493);
   chmodSync2(bashFollowupScriptPath, 493);
   chmodSync2(editPrecheckScriptPath, 493);
@@ -5573,6 +6894,8 @@ function writeHookScripts() {
   chmodSync2(cursorEditPrecheckPath, 493);
   chmodSync2(cursorEditCapturePath, 493);
   chmodSync2(cursorBashFollowupPath, 493);
+  chmodSync2(cursorSessionStartPath, 493);
+  chmodSync2(mcpLocalServerPath, 493);
   return {
     bashScript: bashScriptPath,
     bashFollowupScript: bashFollowupScriptPath,
@@ -5588,7 +6911,9 @@ function writeHookScripts() {
     cursorBashJudgeScript: cursorBashJudgePath,
     cursorEditPrecheckScript: cursorEditPrecheckPath,
     cursorEditCaptureScript: cursorEditCapturePath,
-    cursorBashFollowupScript: cursorBashFollowupPath
+    cursorBashFollowupScript: cursorBashFollowupPath,
+    cursorSessionStartScript: cursorSessionStartPath,
+    mcpLocalServerScript: mcpLocalServerPath
   };
 }
 function sanitizeConfigValue(raw, maxLen = 256) {
@@ -5600,7 +6925,7 @@ function shellQuoteSingle(value) {
 }
 function resolveSynkroBundle() {
   const scriptPath = process.argv[1];
-  if (scriptPath && existsSync11(scriptPath)) return scriptPath;
+  if (scriptPath && existsSync10(scriptPath)) return scriptPath;
   return null;
 }
 function writeConfigEnv(opts) {
@@ -5620,7 +6945,7 @@ function writeConfigEnv(opts) {
     `SYNKRO_CREDENTIALS_PATH=${shellQuoteSingle(credsPath)}`,
     `SYNKRO_TIER=${shellQuoteSingle(safeTier)}`,
     `SYNKRO_INFERENCE=${shellQuoteSingle(safeInference)}`,
-    `SYNKRO_VERSION=${shellQuoteSingle("1.4.65")}`
+    `SYNKRO_VERSION=${shellQuoteSingle("1.4.67")}`
   ];
   if (safeSynkroBin) lines.push(`SYNKRO_CLI_BIN=${shellQuoteSingle(safeSynkroBin)}`);
   if (safeUserId) lines.push(`SYNKRO_USER_ID=${shellQuoteSingle(safeUserId)}`);
@@ -5635,7 +6960,7 @@ function writeConfigEnv(opts) {
   chmodSync2(CONFIG_PATH3, 384);
 }
 function updateLocalInferenceFlag(enabled) {
-  if (!existsSync11(CONFIG_PATH3)) return;
+  if (!existsSync10(CONFIG_PATH3)) return;
   let content = readFileSync10(CONFIG_PATH3, "utf-8");
   const flag = enabled ? "yes" : "no";
   if (content.includes("SYNKRO_LOCAL_INFERENCE=")) {
@@ -5665,7 +6990,7 @@ function collectLocalMetadata() {
     meta.cc_version = execSync5("claude --version", { encoding: "utf-8", timeout: 5e3 }).trim().split("\n")[0];
   } catch {
   }
-  const claudeDir = join11(homedir10(), ".claude");
+  const claudeDir = join11(homedir11(), ".claude");
   try {
     const settings = JSON.parse(readFileSync10(join11(claudeDir, "settings.json"), "utf-8"));
     const plugins = Object.keys(settings.enabledPlugins ?? {}).filter((k) => settings.enabledPlugins[k]);
@@ -5704,7 +7029,7 @@ async function fetchUserProfile(gatewayUrl, token) {
     const resp = await fetch(`${gatewayUrl}/api/v1/cli/me`, {
       headers: { "Authorization": `Bearer ${token}` }
     });
-    if (!resp.ok) return { tier: "pro", inference: "fast", localInference: false };
+    if (!resp.ok) return { tier: "pro", inference: "fast", localInference: false, captureDepth: "full" };
     const data = await resp.json();
     const meta = collectLocalMetadata();
     fetch(`${gatewayUrl}/api/v1/cli/me`, {
@@ -5716,10 +7041,11 @@ async function fetchUserProfile(gatewayUrl, token) {
     return {
       tier: data.plan_tier ?? "pro",
       inference: data.fast_inference ? "fast" : "standard",
-      localInference: !!data.local_inference
+      localInference: !!data.local_inference,
+      captureDepth: data.capture_depth ?? "full"
     };
   } catch {
-    return { tier: "pro", inference: "fast", localInference: false };
+    return { tier: "pro", inference: "fast", localInference: false, captureDepth: "full" };
   }
 }
 function assertGatewayAllowed(gatewayUrl) {
@@ -5754,10 +7080,10 @@ function isAlreadyInstalled() {
     join11(HOOKS_DIR, "cc-stop-summary.ts"),
     join11(HOOKS_DIR, "cc-session-start.ts")
   ];
-  if (!requiredScripts.every((p) => existsSync11(p))) return false;
-  if (!existsSync11(CONFIG_PATH3)) return false;
-  const settingsPath = join11(homedir10(), ".claude", "settings.json");
-  if (!existsSync11(settingsPath)) return false;
+  if (!requiredScripts.every((p) => existsSync10(p))) return false;
+  if (!existsSync10(CONFIG_PATH3)) return false;
+  const settingsPath = join11(homedir11(), ".claude", "settings.json");
+  if (!existsSync10(settingsPath)) return false;
   try {
     const settings = JSON.parse(readFileSync10(settingsPath, "utf-8"));
     const hooks = settings?.hooks;
@@ -5791,8 +7117,8 @@ function printChannelDiagnostics() {
         }
       }
     }
-    const logPath = join11(homedir10(), ".synkro", "cc_sessions", "run-claude.log");
-    if (existsSync11(logPath)) {
+    const logPath = join11(homedir11(), ".synkro", "cc_sessions", "run-claude.log");
+    if (existsSync10(logPath)) {
       const logContent = readFileSync10(logPath, "utf-8").trim().split("\n").slice(-10);
       console.warn(`    run-claude.log:`);
       for (const line of logContent) console.warn(`      ${line}`);
@@ -5801,6 +7127,101 @@ function printChannelDiagnostics() {
   }
   console.warn(`    Run \`synkro local-cc status\` and \`synkro local-cc logs --tmux\` to debug.`);
 }
+async function backfillLocalRules(gatewayUrl, token) {
+  if (existsSync10(RULES_PATH)) {
+    console.log("  Local rules already exist \u2014 skipping cloud backfill.");
+    return;
+  }
+  try {
+    const resp = await fetch(`${gatewayUrl}/api/v1/hook/config`, {
+      headers: { "Authorization": `Bearer ${token}` },
+      signal: AbortSignal.timeout(8e3)
+    });
+    if (!resp.ok) {
+      console.log("  No cloud rules to backfill.");
+      return;
+    }
+    const data = await resp.json();
+    const rules = (data.rules || []).map((r) => ({
+      rule_id: r.rule_id || `r_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      text: r.text || "",
+      category: r.category || "custom",
+      severity: r.severity || "medium",
+      mode: r.mode || "blocking",
+      hook_stage: r.hook_stage || "both",
+      scope: r.scope || "user"
+    }));
+    const policyName = data.active_policy_name || "My Rules";
+    const policyId = data.active_policy_id || "local-policy";
+    const scanExemptions = (data.scan_exemptions || []).filter((e) => e && typeof e.path === "string").map((e) => ({ path: e.path, cwe_id: e.cwe_id || "", reason: e.reason }));
+    const silent = data.silent_mode === true || data.silent_mode === "true";
+    const rulesFile = {
+      policies: [{
+        id: policyId,
+        name: policyName,
+        rules,
+        ruleCount: rules.length,
+        scopeOwner: "user",
+        isActive: true
+      }],
+      config: { silent, activePolicyId: policyId },
+      scanExemptions
+    };
+    const tmp = RULES_PATH + ".tmp";
+    writeFileSync7(tmp, JSON.stringify(rulesFile, null, 2) + "\n", "utf-8");
+    renameSync5(tmp, RULES_PATH);
+    const telemetryPath = join11(SYNKRO_DIR2, "telemetry.jsonl");
+    const event = {
+      capture_type: "rule_sync",
+      policy_id: policyId,
+      policy_name: policyName,
+      rules,
+      rule_count: rules.length,
+      scan_exemptions: scanExemptions,
+      silent,
+      _ts: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    try {
+      appendFileSync2(telemetryPath, JSON.stringify(event) + "\n", "utf-8");
+    } catch {
+    }
+    console.log(`  Backfilled ${rules.length} rules from cloud to ~/.synkro/rules.json`);
+  } catch (err) {
+    console.warn(`  \u26A0 Cloud backfill failed: ${err.message}`);
+  }
+}
+async function startLocalMcpServer() {
+  const serverScript = join11(HOOKS_DIR, "mcp-local-server.ts");
+  if (!existsSync10(serverScript)) {
+    console.warn("  \u26A0 Local MCP server script not found \u2014 skipping.");
+    return;
+  }
+  try {
+    const probe = await fetch(`http://127.0.0.1:${MCP_LOCAL_PORT}/`, { signal: AbortSignal.timeout(1e3) });
+    if (probe.ok) {
+      console.log(`  Local MCP server already running on port ${MCP_LOCAL_PORT}`);
+      return;
+    }
+  } catch {
+  }
+  const proc = spawn2("bun", ["run", serverScript], {
+    stdio: "ignore",
+    detached: true
+  });
+  proc.unref();
+  for (let i = 0; i < 25; i++) {
+    await new Promise((r) => setTimeout(r, 200));
+    try {
+      const probe = await fetch(`http://127.0.0.1:${MCP_LOCAL_PORT}/`, { signal: AbortSignal.timeout(500) });
+      if (probe.ok) {
+        console.log(`  Local MCP server started on port ${MCP_LOCAL_PORT}`);
+        return;
+      }
+    } catch {
+    }
+  }
+  console.warn(`  \u26A0 Local MCP server did not start within 5s \u2014 it may need to be started manually.`);
+}
 async function installCommand(opts = {}) {
   const gatewayUrl = opts.gatewayUrl || sanitizeGatewayCandidate(process.env.SYNKRO_GATEWAY_URL) || "https://api.synkro.sh";
   try {
@@ -5977,39 +7398,13 @@ async function installCommand(opts = {}) {
         bashJudgeScriptPath: scripts.cursorBashJudgeScript,
         editPrecheckScriptPath: scripts.cursorEditPrecheckScript,
         editCaptureScriptPath: scripts.cursorEditCaptureScript,
-        bashFollowupScriptPath: scripts.cursorBashFollowupScript
+        bashFollowupScriptPath: scripts.cursorBashFollowupScript,
+        sessionStartScriptPath: scripts.cursorSessionStartScript
       });
       console.log(`Configured ${agent.name} hooks at ${agent.settingsPath}`);
     }
   }
   console.log();
-  if (hasClaudeCode && !opts.noMcp) {
-    try {
-      const mintResp = await fetch(`${gatewayUrl}/api/v1/cli/mcp-token`, {
-        method: "POST",
-        headers: {
-          "Authorization": `Bearer ${token}`,
-          "Content-Type": "application/json"
-        },
-        body: "{}"
-      });
-      if (!mintResp.ok) {
-        const errText = await mintResp.text().catch(() => "");
-        throw new Error(`mcp-token mint failed (${mintResp.status}): ${errText.slice(0, 200)}`);
-      }
-      const minted = await mintResp.json();
-      const mcp = installMcpConfig({ gatewayUrl, bearerToken: minted.token });
-      console.log(`Registered Synkro guardrails MCP server in ${mcp.path}`);
-      console.log(`  url:        ${mcp.url}`);
-      console.log(`  expires:    ${minted.expires_at} (~1 year)`);
-      console.log("  (restart any running Claude Code session for it to load)");
-      console.log();
-    } catch (err) {
-      console.warn(`  \u26A0 MCP registration failed: ${err.message}`);
-      console.warn("  Hooks are still installed. Re-run `synkro-cli install` to retry MCP setup.");
-      console.log();
-    }
-  }
   let userId;
   let orgId;
   let email;
@@ -6021,6 +7416,50 @@ async function installCommand(opts = {}) {
   } catch {
   }
   const profile = await fetchUserProfile(gatewayUrl, token);
+  const useLocalMcp = profile.captureDepth === "local_only" || profile.localInference;
+  if (hasClaudeCode && !opts.noMcp) {
+    if (useLocalMcp) {
+      try {
+        const mcp = installMcpConfig({ gatewayUrl, bearerToken: "", local: true });
+        console.log(`Registered local MCP guardrails server in ${mcp.path}`);
+        console.log(`  url:        ${mcp.url}`);
+        console.log("  (rules stored in ~/.synkro/rules.json)");
+        console.log();
+        await backfillLocalRules(gatewayUrl, token);
+        await startLocalMcpServer();
+      } catch (err) {
+        console.warn(`  \u26A0 Local MCP setup failed: ${err.message}`);
+        console.warn("  Hooks are still installed. Re-run `synkro-cli install` to retry.");
+        console.log();
+      }
+    } else {
+      try {
+        const mintResp = await fetch(`${gatewayUrl}/api/v1/cli/mcp-token`, {
+          method: "POST",
+          headers: {
+            "Authorization": `Bearer ${token}`,
+            "Content-Type": "application/json"
+          },
+          body: "{}"
+        });
+        if (!mintResp.ok) {
+          const errText = await mintResp.text().catch(() => "");
+          throw new Error(`mcp-token mint failed (${mintResp.status}): ${errText.slice(0, 200)}`);
+        }
+        const minted = await mintResp.json();
+        const mcp = installMcpConfig({ gatewayUrl, bearerToken: minted.token });
+        console.log(`Registered Synkro guardrails MCP server in ${mcp.path}`);
+        console.log(`  url:        ${mcp.url}`);
+        console.log(`  expires:    ${minted.expires_at} (~1 year)`);
+        console.log("  (restart any running Claude Code session for it to load)");
+        console.log();
+      } catch (err) {
+        console.warn(`  \u26A0 MCP registration failed: ${err.message}`);
+        console.warn("  Hooks are still installed. Re-run `synkro-cli install` to retry MCP setup.");
+        console.log();
+      }
+    }
+  }
   const priorLocalFlag = (() => {
     try {
       const content = readFileSync10(CONFIG_PATH3, "utf-8");
@@ -6173,8 +7612,8 @@ function detectGitRepo2() {
 function getClaudeProjectsFolder() {
   const cwd = process.cwd();
   const sanitized = "-" + cwd.replace(/\//g, "-");
-  const projectsDir = join11(homedir10(), ".claude", "projects", sanitized);
-  return existsSync11(projectsDir) ? projectsDir : null;
+  const projectsDir = join11(homedir11(), ".claude", "projects", sanitized);
+  return existsSync10(projectsDir) ? projectsDir : null;
 }
 function extractSessionInsights(projectsDir) {
   const insights = [];
@@ -6350,7 +7789,7 @@ async function syncTranscriptsBulk(gatewayUrl, token, repo) {
   }
   return { sessions: totalSessions, messages: totalMessages };
 }
-var SYNKRO_DIR2, HOOKS_DIR, BIN_DIR, CONFIG_PATH3, OFFSETS_DIR;
+var SYNKRO_DIR2, HOOKS_DIR, BIN_DIR, CONFIG_PATH3, OFFSETS_DIR, RULES_PATH, MCP_LOCAL_PORT;
 var init_install2 = __esm({
   "cli/commands/install.ts"() {
     "use strict";
@@ -6369,11 +7808,13 @@ var init_install2 = __esm({
     init_install();
     init_pueue();
     init_client();
-    SYNKRO_DIR2 = join11(homedir10(), ".synkro");
+    SYNKRO_DIR2 = join11(homedir11(), ".synkro");
     HOOKS_DIR = join11(SYNKRO_DIR2, "hooks");
     BIN_DIR = join11(SYNKRO_DIR2, "bin");
     CONFIG_PATH3 = join11(SYNKRO_DIR2, "config.env");
     OFFSETS_DIR = join11(SYNKRO_DIR2, ".transcript-offsets");
+    RULES_PATH = join11(SYNKRO_DIR2, "rules.json");
+    MCP_LOCAL_PORT = 8931;
   }
 });
 
@@ -6449,11 +7890,11 @@ var status_exports = {};
 __export(status_exports, {
   statusCommand: () => statusCommand
 });
-import { existsSync as existsSync12, readFileSync as readFileSync11 } from "fs";
-import { homedir as homedir11 } from "os";
+import { existsSync as existsSync11, readFileSync as readFileSync11 } from "fs";
+import { homedir as homedir12 } from "os";
 import { join as join12 } from "path";
 function readConfigEnv() {
-  if (!existsSync12(CONFIG_PATH4)) return {};
+  if (!existsSync11(CONFIG_PATH4)) return {};
   const out = {};
   const raw = readFileSync11(CONFIG_PATH4, "utf-8");
   for (const line of raw.split("\n")) {
@@ -6562,12 +8003,12 @@ async function statusCommand() {
   console.log("Hook scripts (Claude Code):");
   for (const f of ccHooks) {
     const p = join12(HOOKS_DIR2, f);
-    console.log(`  ${existsSync12(p) ? "\u2713" : "\u2717"} ${p}`);
+    console.log(`  ${existsSync11(p) ? "\u2713" : "\u2717"} ${p}`);
   }
   console.log("Hook scripts (Cursor):");
   for (const f of cursorHooks) {
     const p = join12(HOOKS_DIR2, f);
-    console.log(`  ${existsSync12(p) ? "\u2713" : "\u2717"} ${p}`);
+    console.log(`  ${existsSync11(p) ? "\u2713" : "\u2717"} ${p}`);
   }
   console.log();
   if (localInference) {
@@ -6610,7 +8051,7 @@ var init_status = __esm({
     init_cursorHookConfig();
     init_mcpConfig();
     init_pueue();
-    SYNKRO_DIR3 = join12(homedir11(), ".synkro");
+    SYNKRO_DIR3 = join12(homedir12(), ".synkro");
     CONFIG_PATH4 = join12(SYNKRO_DIR3, "config.env");
   }
 });
@@ -6643,7 +8084,7 @@ __export(unlink_exports, {
 });
 import { createInterface as createInterface4 } from "readline";
 function ask2(rl, question) {
-  return new Promise((resolve2) => rl.question(question, resolve2));
+  return new Promise((resolve3) => rl.question(question, resolve3));
 }
 async function unlinkCommand() {
   if (!isAuthenticated()) {
@@ -6700,11 +8141,11 @@ var config_exports = {};
 __export(config_exports, {
   configCommand: () => configCommand
 });
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync8, existsSync as existsSync13 } from "fs";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync8, existsSync as existsSync12 } from "fs";
 import { join as join13 } from "path";
-import { homedir as homedir12 } from "os";
+import { homedir as homedir13 } from "os";
 function readConfigEnv2() {
-  if (!existsSync13(CONFIG_PATH5)) return {};
+  if (!existsSync12(CONFIG_PATH5)) return {};
   const out = {};
   for (const line of readFileSync12(CONFIG_PATH5, "utf-8").split("\n")) {
     const t = line.trim();
@@ -6715,7 +8156,7 @@ function readConfigEnv2() {
   return out;
 }
 function updateConfigValue(key, value) {
-  if (!existsSync13(CONFIG_PATH5)) {
+  if (!existsSync12(CONFIG_PATH5)) {
     console.error("No config found. Run `synkro install` first.");
     process.exit(1);
   }
@@ -6786,7 +8227,7 @@ var init_config = __esm({
   "cli/commands/config.ts"() {
     "use strict";
     init_stub();
-    SYNKRO_DIR4 = join13(homedir12(), ".synkro");
+    SYNKRO_DIR4 = join13(homedir13(), ".synkro");
     CONFIG_PATH5 = join13(SYNKRO_DIR4, "config.env");
   }
 });
@@ -6796,8 +8237,8 @@ var scanPr_exports = {};
 __export(scanPr_exports, {
   scanPrCommand: () => scanPrCommand
 });
-import { execSync as execSync6, spawn as spawn2 } from "child_process";
-import { readFileSync as readFileSync13, existsSync as existsSync14 } from "fs";
+import { execSync as execSync6, spawn as spawn3 } from "child_process";
+import { readFileSync as readFileSync13, existsSync as existsSync13 } from "fs";
 import { join as join14 } from "path";
 function parseMatchSpec(condition) {
   if (!condition.startsWith("match_spec:")) return null;
@@ -7005,9 +8446,9 @@ function spawnClaudeJudge(file, claudeToken, promptHeader) {
 Diff:
 ${hunks}`;
   const fullPrompt = promptHeader + userMessage;
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const t0 = Date.now();
-    const proc = spawn2(
+    const proc = spawn3(
       "claude",
       ["--print", "--model", "claude-sonnet-4-6", "--output-format", "json", "--no-session-persistence"],
       {
@@ -7033,7 +8474,7 @@ ${hunks}`;
       const latencyMs = Date.now() - t0;
       if (code !== 0) {
         console.warn(`  claude exited ${code}: ${(stderr || stdout).slice(0, 500)}`);
-        resolve2({ findings: [], latencyMs });
+        resolve3({ findings: [], latencyMs });
         return;
       }
       try {
@@ -7052,10 +8493,10 @@ ${hunks}`;
           description: f.description,
           fix: f.fix
         }));
-        resolve2({ findings, latencyMs });
+        resolve3({ findings, latencyMs });
       } catch (parseErr) {
         console.warn(`  failed to parse claude response: ${stdout.slice(0, 300)}`);
-        resolve2({ findings: [], latencyMs });
+        resolve3({ findings: [], latencyMs });
       }
     });
   });
@@ -7104,9 +8545,9 @@ ${JSON.stringify(findings, null, 2)}
 `;
 }
 function spawnOpusConsolidator(findings, claudeToken) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const prompt2 = buildConsolidationPrompt(findings);
-    const proc = spawn2(
+    const proc = spawn3(
       "claude",
       ["--print", "--model", "claude-opus-4-7", "--output-format", "json", "--no-session-persistence"],
       {
@@ -7131,7 +8572,7 @@ function spawnOpusConsolidator(findings, claudeToken) {
     proc.on("close", (code) => {
       if (code !== 0) {
         console.warn(`  opus consolidation exited ${code}: ${(stderr || stdout).slice(0, 300)}`);
-        resolve2(fallbackReview(findings));
+        resolve3(fallbackReview(findings));
         return;
       }
       try {
@@ -7152,10 +8593,10 @@ function spawnOpusConsolidator(findings, claudeToken) {
           const order = ["low", "medium", "high", "critical"];
           return order.indexOf(f.severity) > order.indexOf(max) ? f.severity : max;
         }, "low");
-        resolve2({ summary: review.summary || "", comments, severity: maxSeverity });
+        resolve3({ summary: review.summary || "", comments, severity: maxSeverity });
       } catch {
         console.warn(`  failed to parse opus response, using fallback`);
-        resolve2(fallbackReview(findings));
+        resolve3(fallbackReview(findings));
       }
     });
   });
@@ -7278,7 +8719,7 @@ function shouldFail(findings, threshold) {
 }
 function readRepoDeps() {
   const pkgPath = join14(process.cwd(), "package.json");
-  if (!existsSync14(pkgPath)) return {};
+  if (!existsSync13(pkgPath)) return {};
   try {
     const pkg = JSON.parse(readFileSync13(pkgPath, "utf-8"));
     return { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
@@ -7542,8 +8983,8 @@ var disconnect_exports = {};
 __export(disconnect_exports, {
   disconnectCommand: () => disconnectCommand
 });
-import { existsSync as existsSync15, rmSync } from "fs";
-import { homedir as homedir13 } from "os";
+import { existsSync as existsSync14, rmSync } from "fs";
+import { homedir as homedir14 } from "os";
 import { join as join15 } from "path";
 function tearDownLocalCC() {
   let hadTask = false;
@@ -7580,13 +9021,13 @@ function disconnectCommand(args2 = []) {
     console.log(`${mcpRemoved ? "\u2713" : "\xB7"} MCP guardrails server: ${mcpRemoved ? "removed entry from ~/.claude.json" : "no Synkro MCP entry found"}`);
   }
   if (purge) {
-    if (existsSync15(SYNKRO_DIR5)) {
+    if (existsSync14(SYNKRO_DIR5)) {
       rmSync(SYNKRO_DIR5, { recursive: true, force: true });
       console.log(`\u2713 Removed ${SYNKRO_DIR5}`);
     } else {
       console.log(`\xB7 ${SYNKRO_DIR5} already gone, nothing to remove`);
     }
-  } else if (existsSync15(SYNKRO_DIR5)) {
+  } else if (existsSync14(SYNKRO_DIR5)) {
     console.log(`Config preserved at ${SYNKRO_DIR5}. Run with --purge to remove.`);
   }
   console.log("\nSynkro disconnected.");
@@ -7601,7 +9042,7 @@ var init_disconnect = __esm({
     init_mcpConfig();
     init_pueue();
     init_install();
-    SYNKRO_DIR5 = join15(homedir13(), ".synkro");
+    SYNKRO_DIR5 = join15(homedir14(), ".synkro");
   }
 });
 
@@ -7648,9 +9089,9 @@ __export(localCc_exports, {
   localCcCommand: () => localCcCommand
 });
 import { spawnSync as spawnSync4 } from "child_process";
-import { homedir as homedir14 } from "os";
+import { homedir as homedir15 } from "os";
 import { join as join16 } from "path";
-import { existsSync as existsSync16, readFileSync as readFileSync14, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync14, writeFileSync as writeFileSync9 } from "fs";
 function printHelp() {
   console.log(`synkro local-cc \u2014 manage the local Claude Code inference session
 
@@ -7740,14 +9181,14 @@ TROUBLESHOOTING
 `);
 }
 function readGatewayUrl() {
-  if (existsSync16(CONFIG_PATH6)) {
+  if (existsSync15(CONFIG_PATH6)) {
     const m = readFileSync14(CONFIG_PATH6, "utf-8").match(/^SYNKRO_GATEWAY_URL='([^']*)'/m);
     if (m) return m[1];
   }
   return "https://api.synkro.sh";
 }
 function updateLocalInferenceFlag2(enabled) {
-  if (!existsSync16(CONFIG_PATH6)) return;
+  if (!existsSync15(CONFIG_PATH6)) return;
   let content = readFileSync14(CONFIG_PATH6, "utf-8");
   const flag = enabled ? "yes" : "no";
   if (content.includes("SYNKRO_LOCAL_INFERENCE=")) {
@@ -7977,7 +9418,7 @@ function cmdLogs(rest) {
     if (!raw) console.log("  " + colorize("(use --raw / -r to see full payloads, --live / -f to follow)", 90));
     return;
   }
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     console.log("  " + colorize("\u2014 following new turns (Ctrl-C to exit) \u2014", 90));
     const stop = followTurns((t) => {
       console.log("  " + formatTurn(t, raw));
@@ -7985,7 +9426,7 @@ function cmdLogs(rest) {
     const onSigint = () => {
       stop();
       process.removeListener("SIGINT", onSigint);
-      resolve2();
+      resolve3();
     };
     process.on("SIGINT", onSigint);
   });
@@ -8082,7 +9523,7 @@ var init_localCc = __esm({
     init_settings();
     init_client();
     init_stub();
-    CONFIG_PATH6 = join16(homedir14(), ".synkro", "config.env");
+    CONFIG_PATH6 = join16(homedir15(), ".synkro", "config.env");
   }
 });
 
@@ -8092,10 +9533,10 @@ __export(grade_exports, {
   gradeCommand: () => gradeCommand
 });
 async function readStdin() {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const chunks = [];
     process.stdin.on("data", (c) => chunks.push(c));
-    process.stdin.on("end", () => resolve2(Buffer.concat(chunks).toString("utf-8")));
+    process.stdin.on("end", () => resolve3(Buffer.concat(chunks).toString("utf-8")));
     process.stdin.on("error", reject);
   });
 }
@@ -8136,14 +9577,14 @@ var init_grade = __esm({
 });
 
 // cli/bootstrap.js
-import { readFileSync as readFileSync15, existsSync as existsSync17 } from "fs";
-import { resolve } from "path";
+import { readFileSync as readFileSync15, existsSync as existsSync16 } from "fs";
+import { resolve as resolve2 } from "path";
 var envCandidates = [
-  resolve(process.cwd(), ".env"),
-  resolve(process.env.HOME ?? "", ".synkro", "config.env")
+  resolve2(process.cwd(), ".env"),
+  resolve2(process.env.HOME ?? "", ".synkro", "config.env")
 ];
 for (const envPath of envCandidates) {
-  if (!existsSync17(envPath)) continue;
+  if (!existsSync16(envPath)) continue;
   const envContent = readFileSync15(envPath, "utf-8");
   for (const line of envContent.split("\n")) {
     const trimmed = line.trim();