@synkro-sh/cli 1.6.95 → 1.6.97

package/dist/bootstrap.js

@@ -1750,7 +1750,7 @@ async function cloudGrade(surface: string, prompt: string, jwt: string, timeoutM
 // to the org's dispatcher /submit), but to the hosted ingress with the gateway
 // JWT (the Worker derives the org from the token and routes to that org's
 // container). Any non-2xx throws so the caller's catch fails open.
-const CONTAINERS_URL = process.env.SYNKRO_CONTAINERS_URL || 'https://containers.synkro.sh';
+const CONTAINERS_URL = process.env.SYNKRO_CONTAINERS_URL || 'https://api.synkro.sh';
 // Cloud grades cross the network and can hit a cold/queued worker, so they get a
 // longer leash than on-device channel grades. The hook chain is sized around it:
 // grade abort (45s) < watchdog (48s) < CC hook budget (50s) \u2014 the grade aborts
@@ -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,65 @@ export async function cloudTaskDrift(envelope: Record<string, unknown>, jwt: str
       body,
       signal: AbortSignal.timeout(timeoutMs),
     });
-    if (!resp.ok) 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;
+  }
+}
+
+// Cloud task COMPLETION sweep \u2014 the end-of-turn FINAL CHECK (fired from the Stop hook).
+// Hits the org container's 'task-complete' surface: verify EVERY requirement against the
+// actual written code (file snapshots + transcript), mark met/open, and retire if all
+// met. Returns the result systemMessage ("complete \u2713 N/N retired" or "N/M \u2014 missing: \u2026").
+// payload.stop_hook_active MUST be falsey or handleTaskComplete bails (stop-loop guard).
+// Fail-silent: any hiccup returns '' so a flaky sweep never blocks the agent stopping.
+export async function cloudTaskComplete(envelope: Record<string, unknown>, jwt: string, timeoutMs = CLOUD_GRADE_TIMEOUT_MS): Promise<string> {
+  const sid = typeof envelope.sessionId === 'string' ? envelope.sessionId : undefined;
+  const repo = typeof envelope.cwd === 'string' ? envelope.cwd : undefined;
+  try {
+    const body = JSON.stringify({ role: 'task-complete', payload: scrubSecrets(JSON.stringify(envelope)), content: '' });
+    const resp = await fetch(CONTAINERS_URL + '/grade/submit', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', Authorization: 'Bearer ' + jwt },
+      body,
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (!resp.ok) {
+      void logGraderUnavailable('taskComplete', 'task-complete', 'http ' + resp.status, undefined, { sessionId: sid, repo }).catch(() => {});
+      return '';
+    }
     const j = await resp.json() as { systemMessage?: unknown };
     return typeof j?.systemMessage === 'string' ? j.systemMessage : '';
-  } catch { return ''; }
+  } catch (e) {
+    const err = e as { name?: string; message?: string };
+    const reason = err?.name === 'TimeoutError'
+      ? 'task-complete timed out after ' + timeoutMs + 'ms'
+      : (err?.message || 'task-complete failed');
+    void logGraderUnavailable('taskComplete', 'task-complete', reason, undefined, { sessionId: sid, repo }).catch(() => {});
+    return '';
+  }
 }
 
 // Option B: when a cloud grade fails (esp. a timeout), the REAL reason lives
@@ -4454,6 +4523,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 +4554,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 +4624,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 +4641,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 +4649,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 +4675,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 +4729,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;
     }
 
@@ -6466,6 +6566,7 @@ import {
   loadJwt, detectRepo, loadConfig, tag, readStdin, aggregateUsage, cleanupSessionLog,
   outputJson, outputEmpty, shipCloud, setupCursorHookSignals, hookSessionId, GATEWAY_URL,
   resolveTranscriptPath, emitUsageTick, cursorModelFromPayload, log, synkroFilePresent,
+  cloudTaskComplete,
 } from './_synkro-common.ts';
 
 async function main() {
@@ -6517,10 +6618,20 @@ async function main() {
 
     cleanupSessionLog(sessionId);
 
+    // Cloud FINAL CHECK: the agent stopped after editing \u2014 sweep the active task,
+    // verify EVERY requirement against the actual written code, and retire if all met.
+    // Returns '' when there's no active task (cheap getActiveTask short-circuit) or in
+    // local mode. stop_hook_active passes through so handleTaskComplete's stop-loop guard
+    // works (it bails when already inside a stop loop).
+    const taskMsg = process.env.SYNKRO_DEPLOY_LOCATION === 'cloud'
+      ? await cloudTaskComplete({ payload: { stop_hook_active: payload.stop_hook_active === true }, harness: 'claude_code', cwd: gitRepo, sessionId }, jwt)
+      : '';
+    const taskSuffix = taskMsg ? '\\n' + taskMsg : '';
+
     if (!findings) {
-      outputJson({ systemMessage: tagStr + ' stop \u2192 0 issues across ' + edits + ' edit(s), session complete' });
+      outputJson({ systemMessage: tagStr + ' stop \u2192 0 issues across ' + edits + ' edit(s), session complete' + taskSuffix });
     } else {
-      outputJson({ systemMessage: tagStr + ' stop \u2192 ' + findings + ' finding(s): ' + autoFixed + ' auto-fixed, ' + open + ' open' });
+      outputJson({ systemMessage: tagStr + ' stop \u2192 ' + findings + ' finding(s): ' + autoFixed + ' auto-fixed, ' + open + ' open' + taskSuffix });
     }
   } catch (err) {
     log('stopSummary error: ' + String(err));
@@ -6592,7 +6703,7 @@ async function main() {
 
     const fakeConfig: HookConfig = { captureDepth: 'local_only', tier: 'standard', silent, policyName, rules: [], scanExemptions: [], gradingMode, storageMode: process.env.SYNKRO_STORAGE_MODE || 'local' };
     const tagStr = tag(rt, fakeConfig);
-    const routeLine = tagStr + ' inference: ' + (gradingMode === 'byok' ? 'cloud (BYOK)' : deployCloud ? 'cloud container (containers.synkro.sh)' : isChannelUp ? 'local-cc (channel reachable on 127.0.0.1:18929)' : 'cloud (local-cc channel not reachable)');
+    const routeLine = tagStr + ' inference: ' + (gradingMode === 'byok' ? 'cloud (BYOK)' : deployCloud ? 'cloud container' : isChannelUp ? 'local-cc (channel reachable on 127.0.0.1:18929)' : 'cloud (local-cc channel not reachable)');
 
     if (!jwt) {
       outputJson({ systemMessage: routeLine });
@@ -11299,7 +11410,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.97")}`
   ];
   if (safeSynkroBin) lines.push(`SYNKRO_CLI_BIN=${shellQuoteSingle(safeSynkroBin)}`);
   if (safeUserId) lines.push(`SYNKRO_USER_ID=${shellQuoteSingle(safeUserId)}`);
@@ -11472,7 +11583,7 @@ async function printWorkerDebug(base, jwt2) {
   }
 }
 async function verifyCloudGrader(jwt2) {
-  const base = (process.env.SYNKRO_CONTAINERS_URL || "https://containers.synkro.sh").replace(/\/$/, "");
+  const base = (process.env.SYNKRO_CONTAINERS_URL || "https://api.synkro.sh").replace(/\/$/, "");
   console.log("  Warming the cloud grader (booting container + checking workers)...");
   const deadline = Date.now() + 18e4;
   let healthy = 0;
@@ -11676,7 +11787,7 @@ async function recycleCloudContainer() {
     console.error("No access token \u2014 run `synkro login`.");
     return;
   }
-  const base = (process.env.SYNKRO_CONTAINERS_URL || "https://containers.synkro.sh").replace(/\/$/, "");
+  const base = (process.env.SYNKRO_CONTAINERS_URL || "https://api.synkro.sh").replace(/\/$/, "");
   console.log("Synkro: recycling the cloud grader container (destroy \u2192 fresh boot)\u2026");
   try {
     const r = await fetch(`${base}/recycle`, { method: "POST", headers: { Authorization: `Bearer ${token}` }, signal: AbortSignal.timeout(3e4) });
@@ -15327,7 +15438,7 @@ To change:`);
     console.log("  BYOK grading uses your own provider key \u2014 register one in the");
     console.log("  dashboard under Settings \u2192 Provider Keys if you have not already.");
   } else if (inferenceValue === "cloud") {
-    console.log("  Grading runs on the Synkro cloud worker pool (containers.synkro.sh).");
+    console.log("  Grading runs on the Synkro cloud worker pool.");
   }
   if (inferenceValue !== "cloud") await reconcileContainer();
 }
@@ -15364,7 +15475,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.97");
 }
 function printHelp2() {
   console.log(`Synkro CLI \u2014 runtime safety for AI coding agents