@synkro-sh/cli 1.6.95 → 1.6.96

package/dist/bootstrap.js

@@ -1781,7 +1781,21 @@ async function hostedGrade(role: GradeRole, prompt: string, jwt: string, timeout
 // break grading. The payload IS a ScanEnvelope; the container runs getActiveTask
 // (resolved per (org,user,repo) via active_tasks) + taskDrift and returns the
 // decision. Secrets are scrubbed before the envelope crosses the network.
-export async function cloudTaskDrift(envelope: Record<string, unknown>, jwt: string, timeoutMs = 20000): Promise<string> {
+// Cloud task-drift returns BOTH channels so the hook can STEER the agent, not just
+// narrate to the user: systemMessage \u2192 user terminal; additionalContext \u2192 the agent;
+// decision='deny' \u2192 a contradiction the agent must fix (hard block, matching local).
+// The container ships formatDecision()'s shape ({ systemMessage, hookSpecificOutput:
+// { additionalContext, permissionDecision } }); we surface all three.
+export interface TaskDriftResult { systemMessage: string; additionalContext: string; decision: 'allow' | 'deny' }
+const TASK_DRIFT_NONE: TaskDriftResult = { systemMessage: '', additionalContext: '', decision: 'allow' };
+
+export async function cloudTaskDrift(envelope: Record<string, unknown>, jwt: string, timeoutMs = CLOUD_GRADE_TIMEOUT_MS): Promise<TaskDriftResult> {
+  const sid = typeof envelope.sessionId === 'string' ? envelope.sessionId : undefined;
+  const repo = typeof envelope.cwd === 'string' ? envelope.cwd : undefined;
+  // What was being graded (the action), captured for the failure record so a dead call
+  // still shows WHAT timed out. The fully-assembled grader prompt is captured separately
+  // server-side (grader_failures.grade_input); this is the client's view.
+  const gradeInput = scrubSecrets(JSON.stringify(envelope.payload ?? envelope)).slice(0, 6000);
   try {
     const body = JSON.stringify({ role: 'task-drift', payload: scrubSecrets(JSON.stringify(envelope)), content: '' });
     const resp = await fetch(CONTAINERS_URL + '/grade/submit', {
@@ -1790,10 +1804,32 @@ export async function cloudTaskDrift(envelope: Record<string, unknown>, jwt: str
       body,
       signal: AbortSignal.timeout(timeoutMs),
     });
-    if (!resp.ok) return '';
-    const j = await resp.json() as { systemMessage?: unknown };
-    return typeof j?.systemMessage === 'string' ? j.systemMessage : '';
-  } catch { return ''; }
+    if (!resp.ok) {
+      // Non-2xx \u2014 record it (rule grades log the same way) so the task message
+      // silently not firing is observable, not invisible. Fire-and-forget per
+      // logGraderUnavailable's contract; still fail-OPEN.
+      void logGraderUnavailable('taskGuard', 'task-drift', 'http ' + resp.status, gradeInput, { sessionId: sid, repo }).catch(() => {});
+      return TASK_DRIFT_NONE;
+    }
+    const j = await resp.json() as { systemMessage?: unknown; hookSpecificOutput?: { additionalContext?: unknown; permissionDecision?: unknown } };
+    const hso = j?.hookSpecificOutput || {};
+    return {
+      systemMessage: typeof j?.systemMessage === 'string' ? j.systemMessage : '',
+      additionalContext: typeof hso.additionalContext === 'string' ? hso.additionalContext : '',
+      decision: hso.permissionDecision === 'deny' ? 'deny' : 'allow',
+    };
+  } catch (e) {
+    // Track the failure \u2014 ESP. the 45s timeout, the most likely reason a task message
+    // doesn't fire. AbortSignal.timeout throws TimeoutError on expiry; everything else
+    // (network, parse) carries its own message. Fire-and-forget (don't await \u2014 would
+    // add ~3s on the timeout path and blow the watchdog); fail-open: never block.
+    const err = e as { name?: string; message?: string };
+    const reason = err?.name === 'TimeoutError'
+      ? 'task-drift timed out after ' + timeoutMs + 'ms'
+      : (err?.message || 'task-drift failed');
+    void logGraderUnavailable('taskGuard', 'task-drift', reason, gradeInput, { sessionId: sid, repo }).catch(() => {});
+    return TASK_DRIFT_NONE;
+  }
 }
 
 // Option B: when a cloud grade fails (esp. a timeout), the REAL reason lives
@@ -4454,6 +4490,13 @@ async function main() {
     if (rt === 'local') {
       // \u2500\u2500\u2500 Local grading: org rules ONLY (channel 1, port 18929) \u2500\u2500\u2500
       const proposedShort = proposed.slice(0, 4000);
+      // The TASK grade sees the DIFF for large files, so a contradiction or drift DEEP
+      // in a big file is visible \u2014 the old "first 4KB of the whole file" window missed
+      // any change past ~2KB. Small files keep full content (cleaner for the grader);
+      // editDiff is the already-computed changed-lines summary (- old / + new).
+      const taskGradeContent = (proposed.length <= 3500 || !editDiff)
+        ? proposedShort
+        : ('Changed lines of ' + filePath + ' (- old / + new):\\n' + editDiff).slice(0, 4000);
       const sessionLog = await sessionLogForGrade(sessionId, config.rules);
       const graderContent = 'file=' + filePath + ' content=' + proposedShort;
       const relevantRules = await filterRules(
@@ -4478,9 +4521,9 @@ async function main() {
       // message into the pass output. Fail-silent ('' on any issue). Sent as a
       // synthetic Write of the reconstructed content so the container needs no base
       // bytes. cwd = the repo identifier the container keys active_tasks on.
-      const taskDriftP: Promise<string> = process.env.SYNKRO_DEPLOY_LOCATION === 'cloud'
-        ? cloudTaskDrift({ payload: { tool_name: 'Write', tool_input: { file_path: filePath, content: proposedShort } }, harness: agentKind, cwd: gitRepo, sessionId }, jwt)
-        : Promise.resolve('');
+      const taskDriftP = process.env.SYNKRO_DEPLOY_LOCATION === 'cloud'
+        ? cloudTaskDrift({ payload: { tool_name: 'Write', tool_input: { file_path: filePath, content: taskGradeContent } }, harness: agentKind, cwd: gitRepo, sessionId }, jwt)
+        : Promise.resolve({ systemMessage: '', additionalContext: '', decision: 'allow' as const });
 
       // \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
@@ -4548,6 +4591,15 @@ async function main() {
           dispatchFinding(jwt, { session_id: sessionId, file_path: filePath, finding_type: 'cwe', finding_id: f.id, status: 'open' }, config.captureDepth);
         }
 
+        // Resolve the parallel task grade NOW so a CONTRADICTION folds into the rule/CWE
+        // block too \u2014 the agent gets rules + CWE + task drift in ONE deny instead of
+        // discovering the contradiction a retry later. taskDriftP has been running in
+        // parallel, so this rarely adds wall-clock. Only a contradiction (decision==='deny')
+        // is folded into a block; progress/off-spec messages stay on the pass path below.
+        const cTask = await taskDriftP;
+        const cTaskSys = cTask.systemMessage;
+        const taskDeny = cTask.decision === 'deny' ? (cTask.additionalContext || cTaskSys) : '';
+
         // 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));
@@ -4556,6 +4608,7 @@ async function main() {
             ? '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;
+          if (taskDeny) denyReason += '\\nThis edit ALSO contradicts the active task \u2014 fix that too:\\n' + taskDeny;
           dispatchCapture(jwt, 'edit', 'block', ruleVerdict.severity || 'critical', ruleVerdict.category || 'security',
             toolName, gitRepo, sessionId, config.captureDepth, {
               command: editContent, reasoning: guardReason,
@@ -4563,17 +4616,19 @@ async function main() {
               ccModel: captureModel, codeChange: editDiff, ...lineMetrics,
             });
           outputJson({
-            systemMessage: tagStr + ' editGuard ' + fileShort + ' \u2192 blocked: ' + guardReason + (cweFindings.length ? ' (+' + cweFindings.length + ' CWE)' : ''),
+            systemMessage: tagStr + ' editGuard ' + fileShort + ' \u2192 blocked: ' + guardReason + (cweFindings.length ? ' (+' + cweFindings.length + ' CWE)' : '') + (taskDeny ? ' (+task)' : ''),
             hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: denyReason, additionalContext: denyReason },
           });
           return;
         }
 
-        // Rules clean but CWE weakness(es) \u2192 fix-mode block (resolve in code).
+        // Rules clean but CWE weakness(es) \u2192 fix-mode block (resolve in code; task drift
+        // folded in too if this edit also contradicts the active task).
         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.';
+          let 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.';
+          if (taskDeny) ctx += '\\nThis edit ALSO contradicts the active task \u2014 fix that too:\\n' + taskDeny;
           outputJson({
-            systemMessage: tagStr + ' editGuard ' + fileShort + ' \u2192 blocked (' + cweFindings.map(f => f.id).join(', ') + ')',
+            systemMessage: tagStr + ' editGuard ' + fileShort + ' \u2192 blocked (' + cweFindings.map(f => f.id).join(', ') + ')' + (taskDeny ? ' (+task)' : ''),
             hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: ctx, additionalContext: ctx },
           });
           return;
@@ -4587,8 +4642,15 @@ async function main() {
             ccModel: captureModel, codeChange: editDiff, ...lineMetrics,
           });
         const cPassLine = tagStr + ' editGuard ' + fileShort + ' \u2192 pass: ' + (ruleVerdict.reason || 'clean (rules + CWE)');
-        const cTaskMsg = await taskDriftP;
-        outputJson({ systemMessage: cPassLine + (cTaskMsg ? '\\n' + cTaskMsg : ''), hookSpecificOutput: { hookEventName: 'PreToolUse', additionalContext: 'Synkro combined edit judge (rules + CWE). ' + (ruleVerdict.reason || 'clean') } });
+        if (cTask.decision === 'deny') {
+          // Cloud parity with local: a task CONTRADICTION hard-blocks the edit and
+          // tells the AGENT (additionalContext) to fix it before proceeding.
+          outputJson({ systemMessage: cPassLine + (cTaskSys ? '\\n' + cTaskSys : ''), hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: cTask.additionalContext || cTaskSys, additionalContext: cTask.additionalContext || cTaskSys } });
+        } else {
+          // On-track / off-spec: pass, but pipe any task additionalContext to the AGENT
+          // (not just systemMessage to the user) so drift/regression actually steers.
+          outputJson({ systemMessage: cPassLine + (cTaskSys ? '\\n' + cTaskSys : ''), hookSpecificOutput: { hookEventName: 'PreToolUse', additionalContext: 'Synkro combined edit judge (rules + CWE). ' + (ruleVerdict.reason || 'clean') + (cTask.additionalContext ? '\\n[task] ' + cTask.additionalContext : '') } });
+        }
         return;
       }
 
@@ -4634,8 +4696,13 @@ async function main() {
           ccModel: captureModel, codeChange: editDiff, ...lineMetrics,
         });
       const passLine = tagStr + ' editGuard ' + fileShort + ' \u2192 pass: ' + (verdict.reason || 'no policy violations detected');
-      const rTaskMsg = await taskDriftP;
-      outputJson({ systemMessage: passLine + (rTaskMsg ? '\\n' + rTaskMsg : ''), hookSpecificOutput: { hookEventName: 'PreToolUse', additionalContext: 'Synkro local edit judge. ' + (verdict.reason || 'no policy violations detected') } });
+      const rTask = await taskDriftP;
+      const rTaskSys = rTask.systemMessage;
+      if (rTask.decision === 'deny') {
+        outputJson({ systemMessage: passLine + (rTaskSys ? '\\n' + rTaskSys : ''), hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: rTask.additionalContext || rTaskSys, additionalContext: rTask.additionalContext || rTaskSys } });
+      } else {
+        outputJson({ systemMessage: passLine + (rTaskSys ? '\\n' + rTaskSys : ''), hookSpecificOutput: { hookEventName: 'PreToolUse', additionalContext: 'Synkro local edit judge. ' + (verdict.reason || 'no policy violations detected') + (rTask.additionalContext ? '\\n[task] ' + rTask.additionalContext : '') } });
+      }
       return;
     }
 
@@ -11299,7 +11366,7 @@ function writeConfigEnv(opts) {
     `SYNKRO_CREDENTIALS_PATH=${shellQuoteSingle(credsPath)}`,
     `SYNKRO_TIER=${shellQuoteSingle(safeTier)}`,
     `SYNKRO_INFERENCE=${shellQuoteSingle(safeInference)}`,
-    `SYNKRO_VERSION=${shellQuoteSingle("1.6.95")}`
+    `SYNKRO_VERSION=${shellQuoteSingle("1.6.96")}`
   ];
   if (safeSynkroBin) lines.push(`SYNKRO_CLI_BIN=${shellQuoteSingle(safeSynkroBin)}`);
   if (safeUserId) lines.push(`SYNKRO_USER_ID=${shellQuoteSingle(safeUserId)}`);
@@ -15364,7 +15431,7 @@ var args = process.argv.slice(2);
 var cmd = args[0] || "";
 var subArgs = args.slice(1);
 function printVersion() {
-  console.log("1.6.95");
+  console.log("1.6.96");
 }
 function printHelp2() {
   console.log(`Synkro CLI \u2014 runtime safety for AI coding agents