@synkro-sh/cli 1.6.73 → 1.6.75

package/dist/bootstrap.js

@@ -1272,7 +1272,7 @@ export function findGitRoot(cwd: string): string {
 export interface SynkroFileConfig {
   version: number;
   harness: ('claude-code' | 'cursor')[];
-  grader: { pool: 'auto' | 'claude' | 'cursor'; mode?: string };
+  grader: { pool: 'auto' | 'claude' | 'cursor'; mode?: string; combinedEditGrade?: boolean };
   workers: { claude?: number; cursor?: number };
   ruleset: string;
   skills: string[];
@@ -1379,6 +1379,7 @@ export function loadSynkroFile(cwd?: string): SynkroFileConfig {
       grader: {
         pool: normalizePoolToken(parsed.grader?.pool),
         mode: ['local', 'byok'].includes(parsed.grader?.mode) ? parsed.grader.mode : undefined,
+        combinedEditGrade: parsed.grader?.combined_edit_grade === true,
       },
       workers: {
         // Counts may live under the grader block (unified form) or the legacy
@@ -1632,7 +1633,7 @@ export function tag(rt: string, config: HookConfig, grader?: string): string {
 
 // \u2500\u2500\u2500 Local Grading (direct channel call) \u2500\u2500\u2500
 
-type GradeRole = 'grade-edit' | 'grade-bash' | 'grade-plan' | 'grade-cwe';
+type GradeRole = 'grade-edit' | 'grade-bash' | 'grade-plan' | 'grade-cwe' | 'grade-edit-cwe';
 
 // Which coding agent fired this grade. The dispatcher routes grades to a
 // worker pool of the matching kind so a Cursor grade is judged by Cursor and
@@ -1642,8 +1643,21 @@ export type AgentKind = 'claude_code' | 'cursor';
 
 const ROLE_MAP: Record<string, GradeRole> = {
   edit: 'grade-edit', bash: 'grade-bash', plan: 'grade-plan', cwe: 'grade-cwe',
+  'edit-cwe': 'grade-edit-cwe',
 };
 
+// Combined edit-time grade (org rules + CWE in one inference). OFF by default;
+// flipped on by env var or synkro.toml [grader] combined_edit_grade = true.
+// When on: the edit-precheck hook runs ONE grade-edit-cwe call and the
+// cwe-precheck hook no-ops (the combined call owns CWE) \u2014 halving inferences
+// per edit. See GRADER_PRIMER_EDIT_CWE.
+export function combinedEditGradeEnabled(synkroFile?: SynkroFileConfig): boolean {
+  const env = process.env.SYNKRO_COMBINED_EDIT_GRADE;
+  if (env === '1' || env === 'true') return true;
+  if (env === '0' || env === 'false') return false;
+  return synkroFile?.grader?.combinedEditGrade === true;
+}
+
 async function channelGrade(role: GradeRole, prompt: string, _jwt: string, port: number, timeoutMs = 30000, agentKind: AgentKind = 'claude_code'): Promise<string> {
   const body = JSON.stringify({ role, payload: prompt, content: prompt, agent_kind: agentKind });
 
@@ -2188,6 +2202,67 @@ export function parseVerdict(resp: string): Verdict {
   return verdict;
 }
 
+export interface CombinedFinding {
+  id: string;
+  reason: string;
+  suggestedFix: string;
+  severity: string;
+  ruleMode: string;
+  codeSnippet: string;
+}
+
+// Splits a grade-edit-cwe verdict (one <synkro-verdict> whose <violation> blocks
+// MIX org-rule ids and cwe-### ids) into (a) a rules Verdict the existing rule
+// enforcement consumes verbatim and (b) a list of CWE findings for the CWE block
+// path. A block whose rule_id starts with "cwe-" is a CWE finding; anything else
+// is an org-rule violation (org rules take precedence). Org-rule verdict is ok
+// UNLESS a non-cwe violation is present \u2014 so a CWE-only failure still passes the
+// rule gate while blocking on CWE.
+export function parseCombinedVerdict(resp: string): { ruleVerdict: Verdict; cweFindings: CombinedFinding[] } {
+  const base = parseVerdict(resp);
+  const ruleVerdict: Verdict = { ok: true, reason: '', suggestedFix: '', ruleId: '', ruleMode: '', severity: 'low', category: 'clean' };
+  const cweFindings: CombinedFinding[] = [];
+  const blocks = resp.match(/<violation>[\\s\\S]*?<\\/violation>/g) || [];
+  let firstRule: CombinedFinding | null = null;
+  for (const b of blocks) {
+    const idRaw = (b.match(/<rule_id>([^<]+)<\\/rule_id>/) || [])[1];
+    if (!idRaw) continue;
+    const id = idRaw.trim();
+    const finding: CombinedFinding = {
+      id,
+      reason: ((b.match(/<reason>([\\s\\S]*?)<\\/reason>/) || [])[1] || '').trim(),
+      suggestedFix: ((b.match(/<suggested_fix>([\\s\\S]*?)<\\/suggested_fix>/) || [])[1] || '').trim(),
+      severity: ((b.match(/<severity>([^<]+)<\\/severity>/) || [])[1] || '').trim(),
+      ruleMode: ((b.match(/<rule_mode>([^<]+)<\\/rule_mode>/) || [])[1] || '').trim(),
+      codeSnippet: ((b.match(/<code_snippet>([\\s\\S]*?)<\\/code_snippet>/) || [])[1] || '').replace(/^\\n+|\\n+$/g, ''),
+    };
+    if (/^cwe-/i.test(id)) {
+      finding.id = id.replace(/^cwe-/i, 'CWE-');
+      if (!cweFindings.some(f => f.id === finding.id)) cweFindings.push(finding);
+    } else if (!firstRule) {
+      firstRule = finding;
+    }
+  }
+  if (firstRule) {
+    ruleVerdict.ok = false;
+    ruleVerdict.ruleId = firstRule.id;
+    ruleVerdict.reason = firstRule.reason;
+    ruleVerdict.suggestedFix = firstRule.suggestedFix;
+    ruleVerdict.ruleMode = firstRule.ruleMode;
+    ruleVerdict.severity = firstRule.severity || 'high';
+    ruleVerdict.category = base.category || 'uncategorized';
+  } else if (base.ok === false && base.ruleId && !/^cwe-/i.test(base.ruleId)) {
+    // No <violation> blocks but a top-level rule_id failure (defensive).
+    ruleVerdict.ok = false;
+    ruleVerdict.ruleId = base.ruleId;
+    ruleVerdict.reason = base.reason;
+    ruleVerdict.suggestedFix = base.suggestedFix;
+    ruleVerdict.ruleMode = base.ruleMode;
+    ruleVerdict.severity = base.severity || 'high';
+  }
+  return { ruleVerdict, cweFindings };
+}
+
 // \u2500\u2500\u2500 Telemetry Dispatch \u2500\u2500\u2500
 
 // Gated cloud telemetry POST \u2014 fires only when storage mode is 'cloud'. The
@@ -3636,7 +3711,7 @@ export function outputEmpty(): void {
     EDIT_PRECHECK_TS = `#!/usr/bin/env bun
 import {
   loadJwt, ensureFreshJwt, detectRepo, loadConfig, route, tag, localGrade,
-  parseVerdict, dispatchCapture, ruleMode, reconstructContent, isPathUnder, postWithRetry,
+  parseVerdict, parseCombinedVerdict, combinedEditGradeEnabled, dispatchCapture, dispatchFinding, ruleMode, reconstructContent, isPathUnder, postWithRetry,
   readStdin, extractTranscript, readLastPrompt, findNearestDeps, filePathFromToolInput,
   appendSessionAction, readSessionLog, compressSessionLog, log,
   outputJson, outputEmpty, setupCursorHookSignals, installHookWatchdog, isEditTool, hookSessionId, GATEWAY_URL,
@@ -3786,6 +3861,90 @@ async function main() {
         'The rules shown were pre-selected as the ones relevant to this edit \u2014 every rule here IS relevant, do not label any "not relevant". When passing (ok=true), give a terse, specific reason each rule passes. Format: "R003: no hardcoded secrets in file. R005: in-repo path only." Cover every rule shown.',
       ].join('\\n');
 
+      // \u2500\u2500\u2500 Combined org-rules + CWE in ONE inference (SYNKRO_COMBINED_EDIT_GRADE) \u2500\u2500\u2500
+      // Self-contained early-return branch \u2014 the default two-grade path below is
+      // left untouched. Appends the CWE rule set to the rules prompt, runs one
+      // grade-edit-cwe call, then splits the verdict: org-rule violations drive
+      // the same ask/fix enforcement; cwe-### violations drive a fix-mode block.
+      // The cwe-precheck hook no-ops when this flag is on (see CWE_PRECHECK_TS).
+      if (combinedEditGradeEnabled(synkroFile)) {
+        const fileExt = (filePath.match(/\\.([^.\\/]+)$/) || ['', ''])[1].toLowerCase();
+        let cweRules: any[] = [];
+        try {
+          const cr = await fetch(GATEWAY_URL + '/api/v1/cwe-rules?ext=' + encodeURIComponent(fileExt), {
+            headers: { Authorization: 'Bearer ' + jwt },
+            signal: AbortSignal.timeout(4000),
+          });
+          if (cr.ok) cweRules = ((await cr.json() as any) || {}).rules || [];
+        } catch { /* CWE rules optional \u2014 rule grading still runs in the combined pass */ }
+
+        const combinedPrompt = graderPrompt
+          + '\\n\\nCWE rules to ALSO check the proposed content against (emit cwe-### violations with a <code_snippet>): '
+          + JSON.stringify(cweRules);
+
+        let cResp: string;
+        try {
+          cResp = await localGrade('edit-cwe', combinedPrompt, undefined, graderPool);
+        } catch (err) {
+          const errMsg = (err as Error).message || String(err);
+          logGraderUnavailable('editGuard', fileShort, errMsg);
+          outputJson({ systemMessage: tagStr + ' ' + graderUnavailableMessage('editGuard', fileShort, errMsg, graderPool) });
+          return;
+        }
+
+        const { ruleVerdict, cweFindings } = parseCombinedVerdict(cResp);
+        const editContent = 'file=' + filePath + ' content=' + proposed.slice(0, 2000);
+        const violatedRules = ruleVerdict.ruleId ? [ruleVerdict.ruleId] : [];
+        const cweBlock = cweFindings.slice(0, 5)
+          .map(f => '[' + f.id + '] ' + (f.reason || 'weakness') + (f.suggestedFix ? ' Fix: ' + f.suggestedFix : ''))
+          .join('\\n');
+        for (const f of cweFindings) {
+          dispatchFinding(jwt, { session_id: sessionId, file_path: filePath, finding_type: 'cwe', finding_id: f.id, status: 'open' }, config.captureDepth);
+        }
+
+        // Org-rule violation \u2192 ask/fix enforcement (CWE findings appended to the deny).
+        if (!ruleVerdict.ok) {
+          const mode = normalizeMode(ruleVerdict.ruleMode || ruleMode(ruleVerdict.ruleId, config.rules));
+          const guardReason = (ruleVerdict.ruleId ? '(' + ruleVerdict.ruleId + ') ' : '') + (ruleVerdict.reason || 'policy violation');
+          let denyReason = mode === 'fix'
+            ? 'Guard: ' + guardReason + '\\nFix all issues before retrying. Do NOT ask the user to make the edit manually \u2014 resolve the violation in code yourself.'
+            : 'Guard: ' + guardReason + '\\nAsk the user for explicit consent before retrying.';
+          if (cweBlock) denyReason += '\\nAlso resolve these CWE weaknesses in code:\\n' + cweBlock;
+          dispatchCapture(jwt, 'edit', 'block', ruleVerdict.severity || 'critical', ruleVerdict.category || 'security',
+            toolName, gitRepo, sessionId, config.captureDepth, {
+              command: editContent, reasoning: guardReason,
+              rulesChecked: relevantRules, violatedRules,
+              ccModel: captureModel, ...lineMetrics,
+            });
+          outputJson({
+            systemMessage: tagStr + ' editGuard ' + fileShort + ' \u2192 blocked: ' + guardReason + (cweFindings.length ? ' (+' + cweFindings.length + ' CWE)' : ''),
+            hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: denyReason, additionalContext: denyReason },
+          });
+          return;
+        }
+
+        // Rules clean but CWE weakness(es) \u2192 fix-mode block (resolve in code).
+        if (cweFindings.length > 0) {
+          const ctx = 'CWE: ' + cweBlock + '\\nFix all issues before retrying. Do NOT ask the user to make the edit manually \u2014 resolve the weakness in code yourself.';
+          outputJson({
+            systemMessage: tagStr + ' editGuard ' + fileShort + ' \u2192 blocked (' + cweFindings.map(f => f.id).join(', ') + ')',
+            hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: ctx, additionalContext: ctx },
+          });
+          return;
+        }
+
+        // Both clean.
+        dispatchCapture(jwt, 'edit', 'pass', 'clean', ruleVerdict.category || 'trivial_edit',
+          toolName, gitRepo, sessionId, config.captureDepth, {
+            command: editContent, reasoning: ruleVerdict.reason || 'no violations (rules + CWE)',
+            rulesChecked: relevantRules, violatedRules: [],
+            ccModel: captureModel, ...lineMetrics,
+          });
+        const cPassLine = tagStr + ' editGuard ' + fileShort + ' \u2192 pass: ' + (ruleVerdict.reason || 'clean (rules + CWE)');
+        outputJson({ systemMessage: cPassLine, hookSpecificOutput: { hookEventName: 'PreToolUse', additionalContext: 'Synkro combined edit judge (rules + CWE). ' + (ruleVerdict.reason || 'clean') } });
+        return;
+      }
+
       let gradeResp: string;
       try {
         gradeResp = await localGrade('edit', graderPrompt, undefined, graderPool);
@@ -3907,7 +4066,7 @@ import {
   outputJson, outputEmpty, setupCursorHookSignals, installHookWatchdog, isEditTool, isShellTool, isCursorHookFormat,
   extractShellCodeWrites, hookSessionId, filePathFromToolInput, emitBlockScanFindings, cweSnippetLines, dispatchFinding, dispatchCapture, GATEWAY_URL,
   logGraderUnavailable, graderUnavailableMessage, resolveTranscriptPath, isCursorInvokingCcHook,
-  loadSynkroFile, effectiveGraderPool, synkroFilePresent, noSynkroSkipMessage,
+  loadSynkroFile, effectiveGraderPool, synkroFilePresent, noSynkroSkipMessage, combinedEditGradeEnabled,
 } from './_synkro-common.ts';
 import { basename, extname, resolve, join, dirname } from 'node:path';
 import { readFileSync, readdirSync, existsSync } from 'node:fs';
@@ -4135,6 +4294,11 @@ async function main() {
     const graderPool = effectiveGraderPool(synkroFile, agentKind);
     const rt = await cweRoute(config, synkroFile);
 
+    // Combined-grade mode: the edit-precheck hook runs CWE inside its single
+    // grade-edit-cwe call, so this standalone CWE scan must no-op — otherwise the
+    // edit would be graded for CWE twice (defeating the inference-merge).
+    if (combinedEditGradeEnabled(synkroFile)) { outputEmpty(); return; }
+
     if (config.silent) {
       outputJson({ systemMessage: '[synkro:' + rt + ':cweScan:' + (graderPool === 'claude_code' ? 'claude' : graderPool) + '] skipped (silent mode)' });
       return;
@@ -4560,14 +4724,16 @@ async function main() {
     jwt = await ensureFreshJwt(jwt);
 
     const config = await loadConfig(jwt);
-    const rt = await route(config);
 
     if (config.silent) {
-      outputJson({ systemMessage: '[synkro:' + rt + ':cveScan] ' + fileShort + ' \u2192 skipped (silent mode)' });
+      outputJson({ systemMessage: '[synkro:cveScan] ' + fileShort + ' \u2192 skipped (silent mode)' });
       return;
     }
 
-    const cveTag = '[synkro:' + rt + ':cveScan]';
+    // CVE scanning has no local/cloud distinction from the user's view \u2014 it's an
+    // OSV database lookup that always runs server-side \u2014 so the tag omits the
+    // location segment that grading/CWE carry. Just [synkro:cveScan].
+    const cveTag = '[synkro:cveScan]';
 
     // Reconstruct proposed content
     const proposed = reconstructContent(toolName, toolInput, filePath, cwd);
@@ -4667,7 +4833,7 @@ async function main() {
               finding_ids: violatedIds, severity: 'critical',
               repo: gitRepo || undefined,
             });
-            const tagStr = '[synkro:' + rt + ':pkgScan]';
+            const tagStr = '[synkro:pkgScan]';
             const denyReason = tagStr + ' BLOCKED: ' + summary + '\\nDo not write this version. Pick a fixed/safe version instead.';
             outputJson({
               systemMessage: denyReason,
@@ -9686,7 +9852,10 @@ function captureClaudeSetupToken() {
   const bin = "script";
   const args2 = isMac ? ["-q", tmpFile, "claude", "setup-token"] : ["-qec", "claude setup-token", tmpFile];
   return new Promise((resolve4, reject) => {
-    const proc = nodeSpawn(bin, args2, { stdio: "inherit" });
+    const proc = nodeSpawn(bin, args2, {
+      stdio: "inherit",
+      env: { ...process.env, FORCE_COLOR: "3", COLORTERM: "truecolor", TERM: "xterm-256color" }
+    });
     proc.on("error", (err) => reject(new Error(`Failed to spawn claude setup-token: ${err.message}`)));
     proc.on("close", (code) => {
       let raw = "";
@@ -9704,27 +9873,48 @@ function captureClaudeSetupToken() {
         reject(new Error(`claude setup-token exited with code ${code}`));
         return;
       }
-      const stripToToken = (s) => s.replace(/\x1B\[[0-9;?]*[a-zA-Z]/g, "").replace(/\x1B\][^\x07]*\x07/g, "").replace(/[\s\x00-\x1F\x7F]/g, "");
-      const yellowRe = /\x1B\[38;2;255;193;7m([^\x1B]*)/g;
-      let yellow = "";
-      let m;
-      while ((m = yellowRe.exec(raw)) !== null) yellow += m[1];
-      const yToken = stripToToken(yellow);
-      let lineMatch = "";
-      const clean = raw.replace(/\x1B\[[0-9;?]*[a-zA-Z]/g, "").replace(/\x1B\][^\x07]*\x07/g, "");
-      const lines = clean.split("\n").map((l) => l.trim());
-      for (let i = 0; i < lines.length; i++) {
-        const idx = lines[i].indexOf("sk-ant-oat01-");
-        if (idx < 0) continue;
-        let tok = (lines[i].slice(idx).match(/^sk-ant-oat01-[A-Za-z0-9_-]*/) || [""])[0];
-        for (let j = i + 1; j < lines.length && /^[A-Za-z0-9_-]+$/.test(lines[j]); j++) tok += lines[j];
-        lineMatch = tok;
-        break;
+      const TOKEN_YELLOW = "2;255;193;7";
+      let fg = "default";
+      let token = "";
+      let i = 0;
+      while (i < raw.length) {
+        if (raw[i] === "\x1B") {
+          const sgr = /^\x1B\[([0-9;?]*)m/.exec(raw.slice(i));
+          if (sgr) {
+            const codes = sgr[1].split(";").map((n) => Number(n) || 0);
+            for (let k = 0; k < codes.length; k++) {
+              const c = codes[k];
+              if (c === 0 || c === 39) fg = "default";
+              else if (c === 38 && codes[k + 1] === 2) {
+                fg = `2;${codes[k + 2]};${codes[k + 3]};${codes[k + 4]}`;
+                k += 4;
+              } else if (c === 38 && codes[k + 1] === 5) {
+                fg = `5;${codes[k + 2]}`;
+                k += 2;
+              } else if (c >= 30 && c <= 37 || c >= 90 && c <= 97) fg = `basic;${c}`;
+            }
+            i += sgr[0].length;
+            continue;
+          }
+          const csi = /^\x1B\[[0-9;?]*[ -/]*[@-~]/.exec(raw.slice(i));
+          const osc = /^\x1B\][^\x07]*(?:\x07|\x1B\\)/.exec(raw.slice(i));
+          if (csi) {
+            i += csi[0].length;
+            continue;
+          }
+          if (osc) {
+            i += osc[0].length;
+            continue;
+          }
+          i += 1;
+          continue;
+        }
+        const ch = raw[i];
+        if (fg === TOKEN_YELLOW && !/[\s\x00-\x1F\x7F]/.test(ch)) token += ch;
+        i += 1;
       }
-      const valid = (t) => /^sk-ant-oat01-[A-Za-z0-9_-]{40,}$/.test(t);
-      const token = valid(yToken) ? yToken : valid(lineMatch) ? lineMatch : "";
       if (!token) {
-        reject(new Error(`Could not capture a full token from claude setup-token output (file=${raw.length}b, yellow=${yellow.length}b, yToken=${yToken.length}b)`));
+        reject(new Error(`Captured no yellow token text from claude setup-token output (raw=${raw.length}b \u2014 is the terminal emitting color?)`));
         return;
       }
       resolve4(token);
@@ -10255,9 +10445,9 @@ function writeHookScripts(mode = "stub") {
   const taskActivateIntentScriptPath = join10(HOOKS_DIR, "cc-task-activate-intent.ts");
   const mcpGateScriptPath = join10(HOOKS_DIR, "cc-mcp-gate.ts");
   if (mode === "stub") {
-    const stubCommonPath = join10(HOOKS_DIR, "_synkro-stub-common.ts");
+    const stubCommonPath2 = join10(HOOKS_DIR, "_synkro-stub-common.ts");
     const stubFiles = [
-      [stubCommonPath, STUB_COMMON_TS],
+      [stubCommonPath2, STUB_COMMON_TS],
       [bashScriptPath, STUB_BASH_JUDGE_TS],
       [bashFollowupScriptPath, STUB_BASH_FOLLOWUP_TS],
       [editPrecheckScriptPath, STUB_EDIT_PRECHECK_TS],
@@ -10328,6 +10518,9 @@ function writeHookScripts(mode = "stub") {
   writeFileSync8(mcpStdioProxyPath, MCP_STDIO_PROXY_SRC, "utf-8");
   writeFileSync8(installExtractCorePath, "/**\n * Deterministic install-command extraction \u2014 no LLM, no network.\n * Shared by the API pkg-scan route and the hook scripts (copied to ~/.synkro/hooks/).\n */\nimport { parse as shellParse } from 'shell-quote';\n\nexport interface DeterministicPkgRequest {\n  name: string;\n  version: string;\n  ecosystem: string;\n}\n\ninterface RawInstall {\n  ecosystem: string;\n  name: string;\n  versionSpec: string | null;\n  source: 'registry' | 'git' | 'local' | 'url' | 'unknown';\n}\n\nconst SEPARATOR_OPS = new Set(['&&', '||', ';', '|', '&', '\\n']);\n\n/** Split a shell command into command segments (each an argv string array). */\nexport function segmentCommand(command: string): string[][] {\n  let tokens: unknown[];\n  try {\n    tokens = shellParse(command) as unknown[];\n  } catch {\n    return [command.split(/\\s+/).filter(Boolean)];\n  }\n  const segments: string[][] = [];\n  let current: string[] = [];\n  for (const tok of tokens) {\n    if (typeof tok === 'string') {\n      current.push(tok);\n      continue;\n    }\n    if (tok && typeof tok === 'object') {\n      const op = (tok as { op?: string }).op;\n      const pattern = (tok as { pattern?: string }).pattern;\n      if (op && SEPARATOR_OPS.has(op)) {\n        if (current.length) segments.push(current);\n        current = [];\n      } else if (typeof pattern === 'string') {\n        current.push(pattern);\n      }\n    }\n  }\n  if (current.length) segments.push(current);\n  return segments;\n}\n\nconst PM_TABLE: Record<string, { subs: Set<string>; ecosystem: string }> = {\n  npm:      { subs: new Set(['install', 'i', 'add', 'ci']),  ecosystem: 'npm' },\n  pnpm:     { subs: new Set(['add', 'install', 'i', 'dlx']), ecosystem: 'npm' },\n  yarn:     { subs: new Set(['add', 'install']),             ecosystem: 'npm' },\n  bun:      { subs: new Set(['add', 'install', 'i']),        ecosystem: 'npm' },\n  pip:      { subs: new Set(['install']),                    ecosystem: 'PyPI' },\n  pip3:     { subs: new Set(['install']),                    ecosystem: 'PyPI' },\n  cargo:    { subs: new Set(['add', 'install']),             ecosystem: 'crates.io' },\n  go:       { subs: new Set(['get', 'install']),             ecosystem: 'Go' },\n  gem:      { subs: new Set(['install']),                    ecosystem: 'RubyGems' },\n  composer: { subs: new Set(['require']),                    ecosystem: 'Packagist' },\n};\nconst SYSTEM_PMS = new Set(['apt', 'apt-get', 'apk', 'brew', 'dnf', 'yum', 'pacman']);\nconst SYSTEM_SUBS = new Set(['install', 'add']);\n\nconst WRAPPERS = new Set(['sudo', 'doas', 'command', 'env', 'xargs', 'nice', 'time']);\nconst VALUE_FLAGS = new Set([\n  '--filter', '-F', '-C', '--dir', '--prefix', '--registry', '--tag', '--features',\n  '-v', '--version', '--index-url', '--extra-index-url', '--target', '-t',\n]);\n\nfunction basename(p: string): string {\n  const i = p.lastIndexOf('/');\n  return i >= 0 ? p.slice(i + 1) : p;\n}\n\nfunction stripPrefixes(argv: string[]): string[] {\n  let i = 0;\n  while (i < argv.length) {\n    const t = argv[i];\n    if (WRAPPERS.has(basename(t).toLowerCase())) { i++; continue; }\n    if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(t)) { i++; continue; }\n    break;\n  }\n  return argv.slice(i);\n}\n\nfunction looksLikePath(tok: string): boolean {\n  return tok === '.' || tok === '..' || /^\\.{0,2}\\//.test(tok) || tok.startsWith('~/') || tok.startsWith('file:');\n}\n\n/** Shell redirect fragments (e.g. `2>&1` \u2192 argv `2`, `1`) \u2014 not package names. */\nfunction isRedirectFragment(tok: string): boolean {\n  if (/^\\d+$/.test(tok)) return true;\n  if (/^[<>]|[<>]$/.test(tok)) return true;\n  if (tok === '&' || tok === '|') return true;\n  if (/^\\d*[<>]/.test(tok)) return true;\n  return false;\n}\n\nfunction parsePackageToken(tok: string, ecosystem: string): RawInstall | null {\n  if (/^(https?:)?\\/\\//.test(tok) || tok.startsWith('git+') || tok.startsWith('git:')) {\n    return { ecosystem, name: tok, versionSpec: null, source: tok.includes('git') ? 'git' : 'url' };\n  }\n  if (looksLikePath(tok)) {\n    return { ecosystem, name: basename(tok.replace(/\\/+$/, '')) || tok, versionSpec: null, source: 'local' };\n  }\n  if (ecosystem === 'PyPI') {\n    const noExtras = tok.replace(/\\[[^\\]]*\\]/g, '');\n    const m = noExtras.match(/^([A-Za-z0-9_.-]+)\\s*([=~!<>].*)?$/);\n    if (!m) return null;\n    return { ecosystem, name: m[1], versionSpec: m[2] ? m[2].trim() : null, source: 'registry' };\n  }\n  if (ecosystem === 'Packagist') {\n    // composer uses vendor/package:version-constraint (e.g. monolog/monolog:1.0.0).\n    // Split on the first ':' after the vendor/ slash; never on the '/'.\n    const ci = tok.indexOf(':');\n    if (ci > 0) return { ecosystem, name: tok.slice(0, ci), versionSpec: tok.slice(ci + 1) || null, source: 'registry' };\n    return { ecosystem, name: tok, versionSpec: null, source: 'registry' };\n  }\n  const at = tok.lastIndexOf('@');\n  if (at > 0) {\n    return { ecosystem, name: tok.slice(0, at), versionSpec: tok.slice(at + 1) || null, source: 'registry' };\n  }\n  return { ecosystem, name: tok, versionSpec: null, source: 'registry' };\n}\n\n/** Deterministic extraction for a single command segment. */\nexport function extractSegment(rawArgv: string[]): RawInstall[] {\n  let argv = stripPrefixes(rawArgv);\n  if (argv.length < 2) return [];\n  let bin = basename(argv[0]).toLowerCase();\n\n  if (bin === 'uv' && argv[1] === 'pip') { argv = argv.slice(1); bin = 'pip'; }\n  if ((bin === 'python' || bin === 'python3') && argv.includes('-m')) {\n    const mi = argv.indexOf('-m');\n    if (argv[mi + 1] === 'pip') { argv = ['pip', ...argv.slice(mi + 2)]; bin = 'pip'; }\n  }\n\n  const isSystem = SYSTEM_PMS.has(bin);\n  const entry = PM_TABLE[bin];\n  if (!entry && !isSystem) return [];\n  const ecosystem = entry ? entry.ecosystem : 'system';\n  const subs = entry ? entry.subs : SYSTEM_SUBS;\n\n  let subIdx = -1;\n  for (let i = 1; i < argv.length; i++) {\n    if (subs.has(argv[i].toLowerCase())) { subIdx = i; break; }\n  }\n  if (subIdx === -1) return [];\n\n  const installs: RawInstall[] = [];\n  // gem pins the version with a separate `-v`/`--version` flag rather than an\n  // inline spec; capture it and apply to the package(s) in this segment.\n  let flagVersion: string | null = null;\n  for (let i = subIdx + 1; i < argv.length; i++) {\n    const tok = argv[i];\n    if (isRedirectFragment(tok)) break;\n    if (tok.startsWith('-')) {\n      const lower = tok.toLowerCase();\n      if (ecosystem === 'RubyGems' && (lower === '-v' || lower === '--version')) {\n        flagVersion = (argv[i + 1] || '').replace(/^[v=\\s]+/, '') || null;\n        i++;\n        continue;\n      }\n      if (VALUE_FLAGS.has(tok)) i++;\n      continue;\n    }\n    const parsed = parsePackageToken(tok, ecosystem);\n    if (parsed) installs.push(parsed);\n  }\n  if (flagVersion) {\n    for (const ins of installs) {\n      if (ins.source === 'registry' && !ins.versionSpec) ins.versionSpec = flagVersion;\n    }\n  }\n  return installs;\n}\n\nconst ECO_TO_OSV: Record<string, string | null> = {\n  npm: 'npm',\n  pypi: 'PyPI', PyPI: 'PyPI',\n  cargo: 'crates.io', 'crates.io': 'crates.io',\n  go: 'Go', Go: 'Go',\n  rubygems: 'RubyGems', RubyGems: 'RubyGems',\n  packagist: 'Packagist', Packagist: 'Packagist',\n  maven: 'Maven', Maven: 'Maven',\n  nuget: 'NuGet', NuGet: 'NuGet',\n  apt: null, brew: null, system: null, other: null,\n};\n\nfunction normalizeName(name: string, osvEco: string): string {\n  const n = name.trim();\n  if (osvEco === 'npm') return n.toLowerCase();\n  if (osvEco === 'PyPI') return n.toLowerCase().replace(/[-_.]+/g, '-');\n  return n;\n}\n\nfunction concretePin(spec: string | null): string | null {\n  if (!spec) return null;\n  const c = spec.trim().replace(/^[v=\\s]+/, '');\n  if (c.toLowerCase() === 'latest' || c === '') return null;\n  if (/[\\^~><|*\\sx]/i.test(c)) return null;\n  return /^\\d[\\w.\\-+]*$/.test(c) ? c : null;\n}\n\nconst PKG_JSON_DEP_FIELDS = ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'];\n\nfunction safeParseObject(text: string): Record<string, any> | null {\n  try {\n    const v = JSON.parse(text);\n    return v && typeof v === 'object' && !Array.isArray(v) ? v : null;\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Diff two package.json contents and return the registry packages that are\n * newly added or whose version spec changed in the new content. The caller\n * scans these against the vuln DB before letting the edit land \u2014 so a bare\n * `pnpm install` afterwards has nothing left to vet. Non-registry sources\n * (file:, link:, workspace:, git, http, relative paths) are skipped.\n */\nexport function extractPackageJsonDelta(oldText: string, newText: string): DeterministicPkgRequest[] {\n  const newJson = safeParseObject(newText);\n  if (!newJson) return [];\n  const oldJson = safeParseObject(oldText) || {};\n\n  const out = new Map<string, DeterministicPkgRequest>();\n  for (const field of PKG_JSON_DEP_FIELDS) {\n    const oldDeps = (oldJson[field] && typeof oldJson[field] === 'object') ? oldJson[field] : {};\n    const newDeps = (newJson[field] && typeof newJson[field] === 'object') ? newJson[field] : {};\n    for (const [rawName, version] of Object.entries(newDeps)) {\n      if (typeof version !== 'string') continue;\n      if (oldDeps[rawName] === version) continue;\n      const spec = version.trim();\n      if (\n        spec.startsWith('file:') || spec.startsWith('link:') ||\n        spec.startsWith('http') || spec.startsWith('git') ||\n        spec.startsWith('workspace:') || spec.startsWith('catalog:') ||\n        spec.startsWith('npm:') ||\n        spec.startsWith('./') || spec.startsWith('../') ||\n        spec === '' || spec === '*'\n      ) continue;\n      const name = rawName.toLowerCase();\n      out.set(name, {\n        name,\n        version: concretePin(spec) ?? '*',\n        ecosystem: 'npm',\n      });\n    }\n  }\n  return [...out.values()];\n}\n\n/**\n * Parse registry installs from a shell command without LLM/network.\n * Unpinned versions use '*' so OSV scans the full advisory history.\n */\nexport function extractDeterministicPkgRequests(command: string): DeterministicPkgRequest[] {\n  const merged = new Map<string, DeterministicPkgRequest>();\n  for (const r of segmentCommand(command).flatMap(extractSegment)) {\n    if (r.source !== 'registry') continue;\n    const osvEco = ECO_TO_OSV[r.ecosystem] ?? ECO_TO_OSV[r.ecosystem.toLowerCase()] ?? null;\n    if (!osvEco) continue;\n    const name = normalizeName(r.name, osvEco);\n    if (!name) continue;\n    const key = osvEco + '|' + name.toLowerCase();\n    const version = concretePin(r.versionSpec) ?? '*';\n    const prev = merged.get(key);\n    if (!prev || (prev.version === '*' && version !== '*')) {\n      merged.set(key, { name, version, ecosystem: osvEco });\n    }\n  }\n  return [...merged.values()];\n}\n", "utf-8");
   writeFileSync8(taskActivateIntentScriptPath, STUB_TASK_ACTIVATE_INTENT_TS, "utf-8");
+  const stubCommonPath = join10(HOOKS_DIR, "_synkro-stub-common.ts");
+  writeFileSync8(stubCommonPath, STUB_COMMON_TS, "utf-8");
+  chmodSync2(stubCommonPath, 493);
   writeFileSync8(mcpGateScriptPath, STUB_MCP_GATE_TS, "utf-8");
   chmodSync2(bashScriptPath, 493);
   chmodSync2(bashFollowupScriptPath, 493);
@@ -10350,10 +10543,6 @@ function writeHookScripts(mode = "stub") {
   chmodSync2(installExtractCorePath, 493);
   chmodSync2(taskActivateIntentScriptPath, 493);
   chmodSync2(mcpGateScriptPath, 493);
-  try {
-    unlinkSync4(join10(HOOKS_DIR, "_synkro-stub-common.ts"));
-  } catch {
-  }
   return {
     bashScript: bashScriptPath,
     bashFollowupScript: bashFollowupScriptPath,
@@ -10403,7 +10592,7 @@ function writeConfigEnv(opts) {
     `SYNKRO_CREDENTIALS_PATH=${shellQuoteSingle(credsPath)}`,
     `SYNKRO_TIER=${shellQuoteSingle(safeTier)}`,
     `SYNKRO_INFERENCE=${shellQuoteSingle(safeInference)}`,
-    `SYNKRO_VERSION=${shellQuoteSingle("1.6.73")}`
+    `SYNKRO_VERSION=${shellQuoteSingle("1.6.75")}`
   ];
   if (safeSynkroBin) lines.push(`SYNKRO_CLI_BIN=${shellQuoteSingle(safeSynkroBin)}`);
   if (safeUserId) lines.push(`SYNKRO_USER_ID=${shellQuoteSingle(safeUserId)}`);
@@ -10466,6 +10655,24 @@ async function provisionCloudContainer(opts) {
     console.error("    Cloud needs a Claude setup-token. Run `claude setup-token` manually, then re-run install.");
     process.exit(1);
   }
+  console.log("  Validating Claude token...");
+  try {
+    const out = execSync6('claude --print --output-format json "say ok"', {
+      env: { ...process.env, CLAUDE_CODE_OAUTH_TOKEN: setupToken },
+      encoding: "utf-8",
+      timeout: 3e4,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const result = JSON.parse(out);
+    if (result.is_error) throw new Error(result.result || "auth failed");
+    console.log("  \u2713 Claude token validated.\n");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`  \u2717 Claude token failed validation: ${msg}`);
+    console.error("    The captured token can't authenticate (truncated capture, wrong account, or no API credits).");
+    console.error("    Re-run install to re-authorize \u2014 nothing was stored.");
+    process.exit(1);
+  }
   const repo = detectGitRepo2() || void 0;
   const sf = readFullSynkroFile();
   const harness = [];
@@ -14055,7 +14262,7 @@ var args = process.argv.slice(2);
 var cmd = args[0] || "";
 var subArgs = args.slice(1);
 function printVersion() {
-  console.log("1.6.73");
+  console.log("1.6.75");
 }
 function printHelp2() {
   console.log(`Synkro CLI \u2014 runtime safety for AI coding agents