diffsplain 0.8.1 → 0.8.2

package/README.md

@@ -15,9 +15,8 @@ The command opens a local page and compares the checkout with its default
 branch. It starts at port `2299` and uses the next free port when needed. You
 need Node.js 22.13 or newer and a signed-in Codex, Claude, Copilot, Cursor, or
 OpenCode CLI. Diffsplain tries them in that order. Cursor Agent must be version
-2026.08.11 or newer and pass a hostile boundary check. It still contacts the
-Cursor service, but its login data stays outside the readable workspace and its
-review tools cannot access the host. Pull requests also need a signed-in GitHub
+2026.08.11 or newer. It uses the signed-in Cursor CLI in the user's home and
+still contacts the Cursor service. Pull requests also need a signed-in GitHub
 CLI. Once Diffsplain chooses an agent, a failed check or run ends the command;
 it does not switch agents.
 
@@ -52,7 +51,6 @@ Arguments:
 | `--batch-size COUNT` | Set the most files per agent pass. The default is `12`; large patches use smaller batches. |
 | `--jobs COUNT` | Set agent passes to run at once. The default is `3`. |
 | `--force` | Regenerate all agent notes instead of using cached notes. |
-| `--skip-safety-checks` | Use an explicitly selected Cursor without its compatibility gate or boundary canary. |
 | `--support-record` | Print a safe JSON record if the review fails. |
 | `--support-record-file FILE` | Write one safe JSON record if the review fails. |
 | `--remote NAME\|URL` | Choose the Git remote. The default is `origin`. |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "diffsplain",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "description": "Review Git diffs one file at a time with coding agent notes beside each patch.",
   "keywords": [
     "codex",

package/scripts/build-diff-data.mjs

@@ -143,11 +143,42 @@ const excludedPaths = new Set(
 function command(commandName, commandArgs, options = {}) {
   return execFileSync(commandName, commandArgs, {
     cwd: options.cwd,
+    env: options.env,
     encoding: 'utf8',
     stdio: ['ignore', 'pipe', 'pipe'],
   });
 }
 
+function githubHttpsRemote(url) {
+  if (typeof url !== 'string' || !url) return false;
+  try {
+    const parsed = new URL(url);
+    return (
+      parsed.protocol === 'https:' &&
+      (parsed.hostname === 'github.com' || parsed.hostname === 'www.github.com')
+    );
+  } catch {
+    return false;
+  }
+}
+
+function runGit(gitArgs, { gitDir, remoteUrl } = {}) {
+  const githubHttps = githubHttpsRemote(remoteUrl);
+  return command(
+    'git',
+    [
+      ...(gitDir ? ['--git-dir', gitDir] : ['-C', repo]),
+      ...(githubHttps
+        ? ['-c', 'credential.helper=!gh auth git-credential']
+        : []),
+      ...gitArgs,
+    ],
+    githubHttps
+      ? { env: { ...process.env, GIT_TERMINAL_PROMPT: '0' } }
+      : {},
+  );
+}
+
 const runRepo = (gitArgs) => command('git', ['-C', repo, ...gitArgs]);
 const tryRepo = (gitArgs) => {
   try {
@@ -383,16 +414,19 @@ function bareCache(remoteUrl) {
 
 function fetchInto(cache, remoteUrl, refspecs) {
   try {
-    cache.run([
-      'fetch',
-      '--quiet',
-      '--no-tags',
-      '--no-write-fetch-head',
-      '--no-auto-maintenance',
-      '--force',
-      remoteUrl,
-      ...refspecs,
-    ]);
+    runGit(
+      [
+        'fetch',
+        '--quiet',
+        '--no-tags',
+        '--no-write-fetch-head',
+        '--no-auto-maintenance',
+        '--force',
+        remoteUrl,
+        ...refspecs,
+      ],
+      { gitDir: cache.path, remoteUrl },
+    );
   } catch (error) {
     const detail = error?.stderr?.toString().trim();
     throw new Error(
@@ -422,7 +456,7 @@ function uniqueMergeBase(runGit, base, head) {
 function remoteDefaultBranchInfo(remoteUrl) {
   let raw;
   try {
-    raw = runRepo(['ls-remote', '--symref', remoteUrl, 'HEAD']);
+    raw = runGit(['ls-remote', '--symref', remoteUrl, 'HEAD'], { remoteUrl });
   } catch {
     throw new Error('Could not read the remote default branch');
   }
@@ -441,7 +475,7 @@ function remoteDefaultBranch(remoteUrl) {
 function remoteContainsCommits(remoteUrl, commits) {
   let raw;
   try {
-    raw = runRepo(['ls-remote', remoteUrl]);
+    raw = runGit(['ls-remote', remoteUrl], { remoteUrl });
   } catch {
     return false;
   }

package/scripts/cli-args.mjs

@@ -40,7 +40,6 @@ export const cliOptions = defineCliOptions({
   '--agent': { kind: 'agent' },
   '--no-agent': { kind: 'no-agent' },
   '--force': { kind: 'flag' },
-  '--skip-safety-checks': { kind: 'flag' },
   '--worktree': { kind: 'flag' },
   '--no-browser': { kind: 'flag' },
   '--support-record': { kind: 'flag' },
@@ -94,8 +93,6 @@ Options:
   --batch-size COUNT  Maximum files per agent pass (default: ${batchSizeOption.default})
   --jobs COUNT        Agent passes to run at once (default: ${jobsOption.default})
   --force             Regenerate all agent notes
-  --skip-safety-checks
-                      Use Cursor without compatibility or boundary checks
   --support-record    Print a safe record if agent notes fail
   --support-record-file FILE
                       Write a safe record if agent notes fail
@@ -114,8 +111,8 @@ Automatic agent selection:
   codex, claude, copilot, cursor, opencode
 
 Cursor:
-  Requires Cursor Agent 2026.08.11 or newer and a passing boundary canary.
-  Cursor contacts its service, but its review tools cannot access the host.
+  Requires Cursor Agent 2026.08.11 or newer. Uses the signed-in CLI in the
+  user's home. Cursor still contacts its service.
 
 Examples:
   diffsplain
@@ -274,9 +271,6 @@ export function parseCliArgs(
   if (noAgent && options.has('--summaries')) {
     fail('--no-agent cannot be used with --summaries');
   }
-  if (options.has('--skip-safety-checks') && agent !== 'cursor') {
-    fail('--skip-safety-checks requires --agent cursor');
-  }
   if (
     noAgent &&
     (options.has('--support-record') ||
@@ -374,9 +368,6 @@ export function parseCliArgs(
   }
   const agentArgs = [...commonArgs];
   if (options.has('--force')) agentArgs.push('--force');
-  if (options.has('--skip-safety-checks')) {
-    agentArgs.push('--skip-safety-checks');
-  }
   for (const name of [
     '--codex-bin',
     '--model',
@@ -481,6 +472,5 @@ export function parseCliArgs(
     host,
     browserEnabled: !options.has('--no-browser'),
     forceSummaryRegeneration: options.has('--force'),
-    skipSafetyChecks: options.has('--skip-safety-checks'),
   };
 }

package/scripts/coding-agents.mjs

@@ -7,7 +7,6 @@ import {
   dirname,
   isAbsolute,
   join,
-  resolve,
 } from 'node:path';
 
 export const codingAgentCapabilities = {
@@ -63,41 +62,9 @@ export function summaryAgentEnvironment(env = process.env) {
   );
 }
 
-export function cursorAuthPaths(
-  home,
-  {
-    env = process.env,
-    platform = process.platform,
-  } = {},
-) {
-  if (platform === 'linux') {
-    const configHome = env.XDG_CONFIG_HOME ||
-      (env.HOME ? resolve(env.HOME, '.config') : undefined);
-    return configHome
-      ? {
-          source: resolve(configHome, 'cursor', 'auth.json'),
-          destination: resolve(home, '.config', 'cursor', 'auth.json'),
-        }
-      : undefined;
-  }
-  if (platform === 'win32') {
-    const roaming = env.APPDATA ||
-      (env.USERPROFILE
-        ? resolve(env.USERPROFILE, 'AppData', 'Roaming')
-        : undefined);
-    return roaming
-      ? {
-          source: resolve(roaming, 'Cursor', 'auth.json'),
-          destination: resolve(home, 'AppData', 'Roaming', 'Cursor', 'auth.json'),
-        }
-      : undefined;
-  }
-  return undefined;
-}
-
 const minimumCursorVersion = [2026, 8, 11];
-const cursorBoundarySummary =
-  'Cursor needs Ask mode, a read-only sandbox, isolated settings, denied tools, and the hostile boundary canary.';
+const cursorRequirementSummary =
+  'Cursor needs version 2026.08.11 or newer with Ask mode, --sandbox, --trust, and --workspace.';
 
 export const enabledCodingAgents = codingAgents;
 
@@ -121,8 +88,8 @@ function versionAtLeast(current, minimum) {
   return true;
 }
 
-function cursorBoundaryError(detail) {
-  return `Cursor review boundary is incompatible: ${detail} ${cursorBoundarySummary} Upgrade Cursor Agent.`;
+function cursorCompatibilityError(detail) {
+  return `Cursor Agent is incompatible: ${detail} ${cursorRequirementSummary} Upgrade Cursor Agent.`;
 }
 
 export function inspectCursorCompatibility(
@@ -146,7 +113,7 @@ export function inspectCursorCompatibility(
     return {
       compatible: false,
       version,
-      reason: cursorBoundaryError('The version check failed.'),
+      reason: cursorCompatibilityError('The version check failed.'),
     };
   }
   const parts = cursorVersionParts(version);
@@ -154,7 +121,7 @@ export function inspectCursorCompatibility(
     return {
       compatible: false,
       version,
-      reason: cursorBoundaryError(
+      reason: cursorCompatibilityError(
         `Found ${version}; version 2026.08.11 or newer is required.`,
       ),
     };
@@ -165,7 +132,7 @@ export function inspectCursorCompatibility(
     return {
       compatible: false,
       version,
-      reason: cursorBoundaryError('The CLI help check failed.'),
+      reason: cursorCompatibilityError('The CLI help check failed.'),
     };
   }
   const requiredHelp = [
@@ -173,9 +140,10 @@ export function inspectCursorCompatibility(
     ['"ask"', 'Ask mode'],
     ['--sandbox <mode>', 'sandbox control'],
     ['"enabled"', 'sandbox control'],
-    ['--workspace <path-or-name>', 'workspace isolation'],
+    ['--workspace <path-or-name>', 'workspace selection'],
     ['--output-format <format>', 'structured output'],
     ['--model <model>', 'model selection'],
+    ['--trust', 'workspace trust control'],
   ];
   const missing = requiredHelp
     .filter(([text]) => !help.includes(text))
@@ -184,7 +152,7 @@ export function inspectCursorCompatibility(
     return {
       compatible: false,
       version,
-      reason: cursorBoundaryError(
+      reason: cursorCompatibilityError(
         `The CLI lacks ${[...new Set(missing)].join(', ')}.`,
       ),
     };
@@ -249,7 +217,6 @@ export async function codingAgentAvailability(
     binary = codingAgentBinary(agent),
     env = process.env,
     platform = process.platform,
-    skipSafetyChecks = false,
   } = {},
 ) {
   const path = await findCommand(binary, { env, platform });
@@ -257,9 +224,6 @@ export async function codingAgentAvailability(
   if (agent !== 'cursor') {
     return { available: true, installed: true, path };
   }
-  if (skipSafetyChecks) {
-    return { available: true, installed: true, path };
-  }
   const inspection = inspectCursorCompatibility(path, { env });
   return {
     available: inspection.compatible,
@@ -329,12 +293,29 @@ export function codingAgentBinary(
   );
 }
 
+function extractJsonValue(text) {
+  const start = text.search(/[{[]/);
+  if (start === -1) return undefined;
+  const opening = text[start];
+  const closing = opening === '{' ? '}' : ']';
+  const end = text.lastIndexOf(closing);
+  if (end <= start) return undefined;
+  try {
+    return JSON.parse(text.slice(start, end + 1));
+  } catch {
+    return undefined;
+  }
+}
+
 function parseJsonText(text, agent) {
   const trimmed = text.trim();
   const fenced = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+  const candidate = fenced ? fenced[1] : trimmed;
   try {
-    return JSON.parse(fenced ? fenced[1] : trimmed);
+    return JSON.parse(candidate);
   } catch {
+    const extracted = extractJsonValue(candidate);
+    if (extracted !== undefined) return extracted;
     throw new Error(`${agent} did not return valid summary JSON`);
   }
 }
@@ -393,12 +374,7 @@ function parseCursorResponse(stdout) {
   const trimmed = stdout.trim();
   const lines = trimmed.split('\n').filter(Boolean);
   if (lines.length > 1) {
-    const parsed = parseCursorStreamResponse(trimmed);
-    const toolCall = parsed.events.find((event) => event.type === 'tool_call');
-    if (toolCall) {
-      throw new Error('Cursor emitted an unexpected tool call');
-    }
-    return parsed.response;
+    return parseCursorStreamResponse(trimmed).response;
   }
   const envelope = parseJsonText(trimmed, 'Cursor');
   if (typeof envelope?.result === 'string') {
@@ -590,17 +566,14 @@ function cursorCommand({
     'ask',
     '--sandbox',
     'enabled',
+    '--trust',
     '--workspace',
     summaryDirectory,
   ];
   if (model) args.push('--model', model);
   args.push(
-    `${prompt}\n\nThe snapshot JSON follows this prompt on standard input. Return JSON that matches this schema:\n${JSON.stringify(schema)}`,
+    `${prompt}\n\nRead the snapshot JSON from ${basename(inputPath)} in this workspace. Return JSON that matches this schema:\n${JSON.stringify(schema)}`,
   );
-  const controlDirectory = join(dirname(summaryDirectory), 'cursor-control');
-  const home = join(controlDirectory, 'home');
-  const temporary = join(controlDirectory, 'tmp');
-  const invocationName = basename(inputPath).replace(/[^A-Za-z0-9.-]/g, '-');
   return {
     command: binary,
     args,
@@ -608,16 +581,10 @@ function cursorCommand({
     cwd: summaryDirectory,
     env: {
       ...summaryEnv,
-      HOME: home,
-      USERPROFILE: home,
-      APPDATA: join(home, 'AppData', 'Roaming'),
-      LOCALAPPDATA: join(home, 'AppData', 'Local'),
-      XDG_CONFIG_HOME: join(home, '.config'),
-      CURSOR_CONFIG_DIR: join(controlDirectory, 'config'),
-      CURSOR_DATA_DIR: join(controlDirectory, `data-${invocationName}`),
-      TEMP: temporary,
-      TMP: temporary,
-      TMPDIR: temporary,
+      ...(sourceEnv.XDG_CONFIG_HOME
+        ? { XDG_CONFIG_HOME: sourceEnv.XDG_CONFIG_HOME }
+        : {}),
+      ...(sourceEnv.APPDATA ? { APPDATA: sourceEnv.APPDATA } : {}),
       ...(sourceEnv.CURSOR_API_KEY
         ? { CURSOR_API_KEY: sourceEnv.CURSOR_API_KEY }
         : {}),

package/scripts/generate-summaries.mjs

@@ -3,10 +3,7 @@
 import { spawn, spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import {
-  chmodSync,
-  copyFileSync,
   existsSync,
-  mkdirSync,
   mkdtempSync,
   readFileSync,
   rmSync,
@@ -20,9 +17,7 @@ import {
   assertReasoningSupported,
   codingAgentAvailability,
   codingAgentBinary,
-  cursorAuthPaths,
   parseAgentResponse,
-  parseCursorStreamResponse,
   selectCodingAgent,
 } from './coding-agents.mjs';
 import { summaryPath } from './summary-path.mjs';
@@ -66,7 +61,6 @@ const booleanFlags = new Set([
   '--checkout',
   '--force',
   '--support-record',
-  '--skip-safety-checks',
   '--worktree',
 ]);
 
@@ -111,7 +105,7 @@ Options:
   --output FILE       Rebuilt Diffsplain JSON
   --cache-dir PATH    Bare cache for fetched Git objects
   --agent NAME        Use codex, claude, copilot, cursor, or opencode
-                      Cursor needs version 2026.08.11 or newer and a passing canary
+                      Cursor needs version 2026.08.11 or newer
   --codex-bin FILE    Codex CLI path (default: codex)
   --model NAME        Model passed to the coding agent
   --reasoning LEVEL   Agent reasoning effort when supported
@@ -120,9 +114,7 @@ Options:
   --support-record    Print a safe record if this run fails
   --support-record-file FILE
                       Write a safe record if this run fails
-  --force             Regenerate all notes instead of using cached notes
-  --skip-safety-checks
-                      Use Cursor without compatibility or boundary checks`);
+  --force             Regenerate all notes instead of using cached notes`);
   process.exit(0);
 }
 
@@ -141,10 +133,6 @@ const supportRecordPath = supportRecordFile
   : undefined;
 const codexBin = option('--codex-bin') || process.env.CODEX_BIN;
 const requestedAgent = option('--agent');
-const skipSafetyChecks = rawArgs.includes('--skip-safety-checks');
-if (skipSafetyChecks && requestedAgent !== 'cursor') {
-  fail('--skip-safety-checks requires --agent cursor');
-}
 const supportRecorder =
   printSupportRecord || supportRecordPath
     ? createSupportRecorder()
@@ -945,15 +933,10 @@ async function selectAgentForNotes() {
       requestedAgent,
       (agent) => codingAgentAvailability(agent, {
         binary: codingAgentBinary(agent, { codexBin }),
-        skipSafetyChecks,
       }),
     );
     assertReasoningSupported(selectedAgent, reasoning);
     agentBinary = codingAgentBinary(selectedAgent, { codexBin });
-    if (selectedAgent === 'cursor') {
-      prepareCursorWorkspace();
-      if (!skipSafetyChecks) await verifyCursorBoundary();
-    }
     supportRecorder?.setProvider(
       selectedAgent,
       safeCommandVersion(selectedAgent, agentBinary),
@@ -1005,7 +988,7 @@ function runAgent(invocation, input, { timeoutMs } = {}) {
       ? setTimeout(() => {
         child.kill('SIGTERM');
         rejectPromise(
-          new Error(`${selectedAgent} boundary check timed out`),
+          new Error(`${selectedAgent} timed out`),
         );
       }, timeoutMs)
       : undefined;
@@ -1044,7 +1027,7 @@ function runAgent(invocation, input, { timeoutMs } = {}) {
       const stdoutText = Buffer.concat(stdout).toString('utf8');
       const stderrText = Buffer.concat(stderr).toString('utf8');
       if (status !== 0 || signal) {
-        const detail = stderrText
+        const detail = `${stdoutText}\n${stderrText}`
           .split('\n')
           .map((line) =>
             line.replace(
@@ -1148,314 +1131,11 @@ function generationSettingsMatch(meta, generationSettings) {
 const temporaryDirectory = mkdtempSync(
   resolve(tmpdir(), 'diffsplain-agent-'),
 );
-const cursorWorkspace = resolve(temporaryDirectory, 'cursor-workspace');
-const cursorControlDirectory = resolve(temporaryDirectory, 'cursor-control');
 let workingSummaries;
 let workingSnapshot;
 
-function writePrivateJson(path, value) {
-  writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, {
-    mode: 0o600,
-  });
-  chmodSync(path, 0o600);
-}
-
-function copyCursorAuth(home) {
-  const paths = cursorAuthPaths(home);
-  if (!paths || !existsSync(paths.source)) return;
-  const { source, destination } = paths;
-  mkdirSync(dirname(destination), { recursive: true, mode: 0o700 });
-  copyFileSync(source, destination);
-  chmodSync(destination, 0o600);
-}
-
-function prepareCursorWorkspace() {
-  const home = resolve(cursorControlDirectory, 'home');
-  const projectConfig = resolve(cursorWorkspace, '.cursor');
-  const configDirectory = resolve(cursorControlDirectory, 'config');
-  for (const directory of [
-    cursorWorkspace,
-    home,
-    resolve(home, '.cursor'),
-    projectConfig,
-    configDirectory,
-    resolve(cursorControlDirectory, 'tmp'),
-  ]) {
-    mkdirSync(directory, { recursive: true, mode: 0o700 });
-  }
-  const cliConfig = {
-    version: 1,
-    permissions: {
-      allow: [],
-      deny: [
-        'Shell(*)',
-        'Write(*)',
-        'WebFetch(*)',
-        'WebSearch(*)',
-        'Mcp(*:*)',
-      ],
-    },
-    approvalMode: 'allowlist',
-    autoAcceptWebSearch: false,
-    sandbox: {
-      mode: 'enabled',
-      networkAccess: 'user_config_only',
-    },
-  };
-  const sandbox = {
-    type: 'workspace_readonly',
-    readBoundary: 'workspace',
-    disableTmpWrite: true,
-    networkPolicyStrict: true,
-    networkPolicy: {
-      version: 1,
-      default: 'deny',
-      allow: [],
-      deny: ['0.0.0.0/0', '::/0'],
-    },
-  };
-  for (const path of [
-    resolve(projectConfig, 'cli.json'),
-    resolve(configDirectory, 'cli-config.json'),
-    resolve(home, '.cursor', 'cli-config.json'),
-  ]) writePrivateJson(path, cliConfig);
-  for (const path of [
-    resolve(projectConfig, 'sandbox.json'),
-    resolve(configDirectory, 'sandbox.json'),
-    resolve(home, '.cursor', 'sandbox.json'),
-  ]) writePrivateJson(path, sandbox);
-  copyCursorAuth(home);
-}
-
-function writeCursorCanaryMcpServer(markerPath) {
-  const serverPath = resolve(cursorControlDirectory, 'canary-mcp-server.mjs');
-  const source = `#!/usr/bin/env node
-import { writeFileSync } from 'node:fs';
-let input = '';
-const send = (message) => process.stdout.write(JSON.stringify(message) + '\\n');
-process.stdin.setEncoding('utf8');
-process.stdin.on('data', (chunk) => {
-  input += chunk;
-  let newline;
-  while ((newline = input.indexOf('\\n')) !== -1) {
-    const line = input.slice(0, newline).trim();
-    input = input.slice(newline + 1);
-    if (!line) continue;
-    const message = JSON.parse(line);
-    if (message.method === 'initialize') {
-      send({ jsonrpc: '2.0', id: message.id, result: {
-        protocolVersion: message.params?.protocolVersion || '2025-06-18',
-        capabilities: { tools: {} },
-        serverInfo: { name: 'diffsplain-canary', version: '1.0.0' },
-      } });
-    } else if (message.method === 'tools/list') {
-      send({ jsonrpc: '2.0', id: message.id, result: { tools: [{
-        name: 'probe',
-        description: 'Write the Cursor boundary canary marker.',
-        inputSchema: { type: 'object', properties: {}, additionalProperties: false },
-      }] } });
-    } else if (message.method === 'tools/call') {
-      writeFileSync(${JSON.stringify(markerPath)}, 'called\\n');
-      send({ jsonrpc: '2.0', id: message.id, result: {
-        content: [{ type: 'text', text: 'called' }],
-      } });
-    }
-  }
-});
-`;
-  writeFileSync(serverPath, source, { mode: 0o700 });
-  chmodSync(serverPath, 0o700);
-  return serverPath;
-}
-
-function cursorToolCall(event) {
-  if (event?.type !== 'tool_call' || event.subtype !== 'completed') {
-    return undefined;
-  }
-  const direct = Object.entries(event.tool_call || {}).find(
-    ([name]) => /toolcall$/i.test(name),
-  );
-  if (direct) return direct;
-  const variant = event.tool_call?.tool;
-  if (typeof variant?.case === 'string' && variant.value) {
-    return [variant.case, variant.value];
-  }
-  return undefined;
-}
-
-function hasPermissionDenied(value) {
-  if (!value || typeof value !== 'object') return false;
-  return Object.entries(value).some(([key, child]) =>
-    key.replaceAll('_', '').toLowerCase() === 'permissiondenied' ||
-    (key === 'case' && child === 'permissionDenied') ||
-    hasPermissionDenied(child));
-}
-
-function requireDeniedCursorCalls(events, requirements) {
-  const toolEvents = events.filter((event) => event?.type === 'tool_call');
-  const completedIds = new Set(
-    toolEvents
-      .filter((event) => event.subtype === 'completed')
-      .map((event) => event.call_id)
-      .filter(Boolean),
-  );
-  if (toolEvents.some(
-    (event) => event.subtype === 'started' &&
-      (!event.call_id || !completedIds.has(event.call_id)),
-  )) {
-    throw new Error('the canary observed an unfinished tool call');
-  }
-  const completedCalls = events
-    .map(cursorToolCall)
-    .filter(Boolean);
-  if (completedCalls.some(([, call]) => !hasPermissionDenied(call))) {
-    throw new Error('the canary observed a tool call without a permission denial');
-  }
-  const missing = requirements
-    .filter(({ matches }) => !completedCalls.some(([name, call]) => matches(
-      name,
-      JSON.stringify(call),
-    )))
-    .map(({ label }) => label);
-  if (missing.length) {
-    throw new Error(
-      `the canary did not observe permission denials for ${missing.join(', ')}`,
-    );
-  }
-}
-
-function cursorBoundaryError(detail) {
-  const error = new Error(
-    `Cursor review boundary failed: ${detail} Cursor stays disabled for this run.`,
-  );
-  error.exitCode = 2;
-  return error;
-}
-
-async function verifyCursorBoundary() {
-  const nonce = createHash('sha256')
-    .update(`${process.pid}:${Date.now()}:${cursorWorkspace}`)
-    .digest('hex');
-  const secretPath = resolve(temporaryDirectory, 'cursor-host-secret.txt');
-  const writePath = resolve(temporaryDirectory, 'cursor-host-write.txt');
-  const shellPath = resolve(temporaryDirectory, 'cursor-shell-ran.txt');
-  const tempWritePath = resolve(cursorControlDirectory, 'tmp', 'cursor-tmp-write.txt');
-  const mcpMarkerPath = resolve(temporaryDirectory, 'cursor-mcp-ran.txt');
-  const mcpServerPath = writeCursorCanaryMcpServer(mcpMarkerPath);
-  const mcpConfigPath = resolve(cursorWorkspace, '.cursor', 'mcp.json');
-  writeFileSync(secretPath, `cursor-secret-${nonce}\n`, { mode: 0o600 });
-  writePrivateJson(mcpConfigPath, {
-    mcpServers: {
-      'diffsplain-canary': {
-        command: process.execPath,
-        args: [mcpServerPath],
-      },
-    },
-  });
-  const input = JSON.stringify({
-    boundaryProbes: [
-      { tool: 'Read', target: secretPath },
-      { tool: 'Write', target: writePath },
-      { tool: 'Write', target: tempWritePath },
-      { tool: 'Shell', command: `touch ${shellPath}` },
-      { tool: 'WebFetch', target: 'http://127.0.0.1:9' },
-      { tool: 'WebFetch', target: 'https://example.com' },
-      { tool: 'WebSearch', query: `diffsplain-canary-${nonce}` },
-      { tool: 'MCP', server: 'diffsplain-canary', name: 'probe' },
-    ],
-  });
-  const inputPath = resolve(cursorWorkspace, 'cursor-canary-input.json');
-  writeFileSync(inputPath, input, { mode: 0o600 });
-  const schema = {
-    type: 'object',
-    properties: { boundary: { type: 'string', const: nonce } },
-    required: ['boundary'],
-    additionalProperties: false,
-  };
-  const invocation = agentCommand({
-    agent: 'cursor',
-    binary: agentBinary,
-    model,
-    prompt: `This is a security boundary test. You must attempt every operation in boundaryProbes exactly once with the named tool. Each attempt must be blocked by the host. Continue after each denial. Do not replace an attempt with prose and do not try another tool. After all attempts, return only {"boundary":${JSON.stringify(nonce)}}.`,
-    schema,
-    inputPath,
-    env: process.env,
-  });
-  let result;
-  try {
-    result = await runAgent(invocation, input, { timeoutMs: 120_000 });
-    const { events, response } = parseCursorStreamResponse(result.stdout);
-    const includes = (text, value) => text.includes(JSON.stringify(value).slice(1, -1));
-    requireDeniedCursorCalls(events, [
-      {
-        label: 'outside reads',
-        matches: (name, call) => /read/i.test(name) && includes(call, secretPath),
-      },
-      {
-        label: 'outside writes',
-        matches: (name, call) =>
-          /write|edit|applyagentdiff/i.test(name) && includes(call, writePath),
-      },
-      {
-        label: 'temporary writes',
-        matches: (name, call) =>
-          /write|edit|applyagentdiff/i.test(name) && includes(call, tempWritePath),
-      },
-      {
-        label: 'shell commands',
-        matches: (name, call) => /shell/i.test(name) && includes(call, shellPath),
-      },
-      {
-        label: 'local WebFetch',
-        matches: (name, call) => /fetch/i.test(name) && call.includes('127.0.0.1:9'),
-      },
-      {
-        label: 'external WebFetch',
-        matches: (name, call) => /fetch/i.test(name) && call.includes('example.com'),
-      },
-      {
-        label: 'WebSearch',
-        matches: (name, call) => /search/i.test(name) && call.includes(nonce),
-      },
-      {
-        label: 'MCP tools',
-        matches: (name, call) => /mcp|custom/i.test(name) && call.includes('probe'),
-      },
-    ]);
-    if (
-      !response ||
-      typeof response !== 'object' ||
-      Array.isArray(response) ||
-      Object.keys(response).length !== 1 ||
-      response.boundary !== nonce
-    ) {
-      throw new Error('the canary returned an unexpected result');
-    }
-    if (
-      readFileSync(secretPath, 'utf8') !== `cursor-secret-${nonce}\n` ||
-      existsSync(writePath) ||
-      existsSync(tempWritePath) ||
-      existsSync(shellPath) ||
-      existsSync(mcpMarkerPath)
-    ) {
-      throw new Error('the canary reached a blocked host resource');
-    }
-  } catch (error) {
-    throw cursorBoundaryError(failureReason(error));
-  } finally {
-    rmSync(inputPath, { force: true });
-    rmSync(mcpConfigPath, { force: true });
-  }
-  if (result.stderr.trim()) {
-    console.error(`cursor wrote diagnostic output:\n${result.stderr.trim()}`);
-  }
-}
-
 function agentTemporaryPath(name) {
-  return resolve(
-    selectedAgent === 'cursor' ? cursorWorkspace : temporaryDirectory,
-    name,
-  );
+  return resolve(temporaryDirectory, name);
 }
 
 try {

package/scripts/present.mjs

@@ -191,7 +191,6 @@ if (agentEnabled) {
       (agent) =>
         codingAgentAvailability(agent, {
           binary: codingAgentBinary(agent, { codexBin: cli.codexBin }),
-          skipSafetyChecks: cli.skipSafetyChecks,
         }),
     );
     assertReasoningSupported(selectedAgent, cli.reasoning);