@synkro-sh/cli 1.6.73 → 1.6.74

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,
@@ -10403,7 +10569,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.74")}`
   ];
   if (safeSynkroBin) lines.push(`SYNKRO_CLI_BIN=${shellQuoteSingle(safeSynkroBin)}`);
   if (safeUserId) lines.push(`SYNKRO_USER_ID=${shellQuoteSingle(safeUserId)}`);
@@ -14055,7 +14221,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.74");
 }
 function printHelp2() {
   console.log(`Synkro CLI \u2014 runtime safety for AI coding agents