@duckmind/dm-windows-x64 0.61.4 → 0.61.9

package/extensions/dm-subagents/src/runs/shared/completion-evidence.js

@@ -0,0 +1,40 @@
+export const MISSING_IMPLEMENTATION_MUTATION_MESSAGE = "Subagent completed without making edits for an implementation task.";
+export const MISSING_IMPLEMENTATION_MUTATION_ERROR = `${MISSING_IMPLEMENTATION_MUTATION_MESSAGE}
+It appears to have returned planning or scratchpad output instead of applying changes.`;
+export function planCompletionEvidence(input) {
+  const guardBlocked = input.guard?.blocked === true;
+  const guardTriggered = input.guardTriggered ?? (input.guard?.triggered === true && !input.mutationAttemptObserved);
+  const mutationExpected = input.guard?.expectedMutation ?? (input.completionGuardEnabled && input.mutationCapable && input.implementationMutationExpected);
+  const mutationAttempted = input.guard?.attemptedMutation === true || input.mutationAttemptObserved;
+  const fileMutation = input.guard ? {
+    status: guardBlocked ? "blocked" : input.guard.expectedMutation ? guardTriggered ? "missing" : input.arbiterRescued ? "not-applicable" : "observed" : "not-applicable",
+    expected: input.guard.expectedMutation,
+    attempted: guardBlocked ? false : mutationAttempted,
+    ...input.mutationEvidence ? { evidence: input.mutationEvidence } : {},
+    ...guardBlocked && input.guard.message ? { message: input.guard.message } : {},
+    ...guardTriggered ? { message: MISSING_IMPLEMENTATION_MUTATION_MESSAGE } : {},
+    ...input.arbiterRescued ? { resolvedBy: "llm-intent-arbiter" } : {}
+  } : undefined;
+  return {
+    guardTriggered,
+    guardBlocked,
+    mutationExpected,
+    mutationAttempted,
+    fileMutation,
+    legacyFailureError: guardTriggered && !input.agentContractV1 ? MISSING_IMPLEMENTATION_MUTATION_ERROR : undefined
+  };
+}
+export function projectSettlementDiagnostic(plan, input) {
+  if (!input.terminalFailed && !plan.guardTriggered && !plan.guardBlocked)
+    return;
+  return {
+    finalTextPresent: input.finalTextPresent,
+    mutation: {
+      expected: plan.mutationExpected,
+      attempted: plan.mutationAttempted,
+      observed: input.mutationObserved
+    },
+    ...input.requiredOutput ? { requiredOutput: input.requiredOutput } : {},
+    afterCompactionSettlement: input.afterCompactionSettlement === true
+  };
+}

package/extensions/dm-subagents/src/runs/shared/completion-guard.js

@@ -1,50 +1,7 @@
-import { isMutatingBashCommand } from "./long-running-guard.js";
-const REVIEW_ONLY_PATTERNS = [
-  /\breview only\b/i,
-  /\bsuggest fixes only\b/i,
-  /\bonly return findings\b/i,
-  /\breturn findings only\b/i
-];
-const REVIEWER_REQUIRED_EDIT_PATTERNS = [
-  /\bmust\s+(?:edit|modify|change|fix|patch|apply)\b/i,
-  /\brequired\s+to\s+(?:edit|modify|change|fix|patch|apply)\b/i,
-  /\bregardless\s+of\s+findings\b/i,
-  /\balways\s+(?:edit|modify|change|fix|patch|apply)\b/i,
-  /\bapply\s+(?:the\s+)?fix(?:es)?\s+directly\b/i,
-  /\bmake\s+(?:the\s+)?code\s+changes\b/i
-];
-const EXPLICIT_NO_EDIT_PATTERNS = [
-  /\bdo not edit\b/i,
-  /\bdon't edit\b/i,
-  /\bdo not modify\b/i,
-  /\bdo not change files\b/i
-];
-const SCOPED_NO_EDIT_CONSTRAINT_PATTERNS = [
-  /\bdo not edit files?\s+outside\b/i,
-  /\bdo not edit\s+outside\b/i,
-  /\bdo not edit\s+unrelated files?\b/i,
-  /\bdo not change\s+unrelated files?\b/i,
-  /\bdo not modify\s+unrelated files?\b/i
-];
-const RESEARCH_AGENT_PATTERNS = [
-  /\binvestigate\b/i,
-  /\bscout\b/i,
-  /\bresearch(?:er)?\b/i
-];
-const WORKER_IMPLEMENTATION_PATTERNS = [
-  /\b(?:implement|fix|edit|modify|patch|refactor|delete)\b/i,
-  /\b(?:update|add|remove|replace|create)\b(?!\s+(?:(?:a|an|the)\s+)?(?:report|summary|findings?)(?:\b|$))/i,
-  /\bapply\s+(?:the\s+)?(?:changes?|fix(?:es)?|patch)\b/i,
-  /\bmake\s+(?:the\s+)?changes\b/i,
-  /\bdo those fixes\b/i
-];
-const GENERAL_IMPLEMENTATION_PATTERNS = [
-  /\b(?:implement|fix|edit|modify|patch|refactor)\b/i,
-  /\bapply\s+(?:the\s+)?(?:changes?|fix(?:es)?|patch)\b/i,
-  /\bmake\s+(?:the\s+)?changes\b/i,
-  /\bdo those fixes\b/i,
-  /\b(?:update|add|remove|replace|delete|create)\s+(?:the\s+)?(?:file|files|code|source|implementation|test|tests|component|function|module|class|method|logic|import|imports|readme|docs?|changelog|package\.json|config|manifest|extension|prompt|command)\b/i
-];
+import { isMutatingTool } from "./long-running-guard.js";
+import { classifyTaskMutationIntent, expectsImplementationMutation, taskMayMutate } from "./task-intent.js";
+
+export { expectsImplementationMutation };
 const READ_ONLY_BUILTIN_TOOLS = new Set([
   "read",
   "grep",
@@ -54,63 +11,163 @@ const READ_ONLY_BUILTIN_TOOLS = new Set([
   "fetch_content",
   "get_search_content",
   "intercom",
-  "contact_supervisor"
+  "contact_supervisor",
+  "structured_output"
 ]);
-function stripFrameworkInstructions(task) {
-  return task.split(`
-`).filter((line) => !/^\s*\[(?:Write to|Read from):/i.test(line)).filter((line) => !/^\s*(?:Create and maintain progress at:|Update progress at:|\*\*Output:\*\*|Write your findings to(?: exactly this path)?:|This path is authoritative for this run\.|Ignore any other output filename or output path mentioned elsewhere)/i.test(line)).join(`
-`);
+const CURSOR_FILE_MUTATION_THINKING = /(?:^|\n)\s*Cursor (?:edit|write)\s*:/i;
+const REVIVED_TASK_PREFIX = /^You are reviving a previous subagent conversation\.\n\nOriginal run: .+\nOriginal agent: .+(?:\nOriginal session file: .+)?\n\nUse the stored session context as background\. Answer the orchestrator's follow-up below\. Do not assume the original child process is still alive\.\n\nFollow-up:\n/;
+const IMPLEMENTATION_CHALLENGE_FOLLOW_UP_PATTERN = /^(?:Run )?implementation challenge pass (?:one|two|\d+)(?:\s+and implement any better current[- ]scope change\.?|\s+for the accepted candidate\.\s+Reconsider it and implement any better current[- ]scope change\.?)?$/i;
+const NO_BETTER_CHANGE_NEEDED_PATTERN = /^\s*no (?:better|further|additional) (?:current[- ]scope )?(?:code |source |file )?(?:change|changes|edit|edits|patch|patches) (?:is|are) needed\b/i;
+const KEPT_CURRENT_IMPLEMENTATION_PATTERN = /\b(?:kept (?:the )?current (?:implementation|candidate|shape)|(?:the )?current (?:implementation|candidate|shape) was kept)\b/i;
+const NO_CHANGE_MADE_PATTERN = /\bno (?:new )?(?:(?:code|source|file|test)(?:\s*(?:,\s*or|,|\/|or)\s*(?:code|source|file|test))* changes?|changes?) (?:were|was) made\b/i;
+const NO_BETTER_CHANGE_QUALIFIER_PATTERN = /\b(?:do\s+not|don't|dont|not|never|cannot|can't|cant|unable|uncertain|unsure|unclear|disagree|wrong|false|reject|rejected|rejecting|maybe|might|may|\w+n['’]t)\b/i;
+const REPORT_SENTENCE_PATTERN = /[^.!?]+(?:[.!?]+(?=(?:["”'’]?\s)|["”'’]?$)|$)/g;
+const QUOTED_CLAIM_PATTERN = /["“]([^"”]+)["”]([.!?]?\s*[^.!?]*)/g;
+const QUOTED_CLAIM_REFERENCE_PATTERN = /\b(?:that|this|it|claim|report|message|disagree)\b/i;
+const CLAIM_CONTRADICTION_PATTERN = /\bbut\b[^.!?]*\b(?:uncertain|unsure|unclear|disagree|wrong|false|reject|rejected|rejecting)\b/i;
+const IMPLEMENTATION_RETRACTION_PATTERN = /\b(?:found|identified)\s+(?:(?:a|an|the)\s+)?(?:required|necessary|additional|better)?\s*(?:(?:code|source|file|test)\s+)?(?:changes?|edits?|patches?)\b|\b(?:(?:implementation|code|source|file|test)\s+)?work\s+(?:remains?|is\s+(?:needed|required))\b|\b(?:(?:a|an|the)\s+)?(?:(?:code|source|file|test)\s+)?(?:changes?|edits?|patches?)\s+(?:are|is)\s+(?:needed|required)\b|\b(?:required|necessary|additional|better)\s+(?:(?:code|source|file|test)\s+)?(?:changes?|edits?|patches?)\b|\b(?:I|we)?\s*need\s+(?:(?:code|source|file|test)\s+)?(?:changes?|edits?|patches?)\b|\b(?:need|needs|require|requires)\s+(?:to\s+)?(?:implement|make|apply)\b/i;
+const IMPLEMENTATION_RETRACTION_GLOBAL_PATTERN = new RegExp(IMPLEMENTATION_RETRACTION_PATTERN.source, "gi");
+const DIRECT_CLAIM_RETRACTION_PATTERN = /^\s*(?:I\s+)?(?:disagree|reject|retract)\b|\b(?:disagree|retract|retracted|retracting|reject|rejected|rejecting)\b[^.!?]*\b(?:that|this|it|claim|report|message)\b|\b(?:that|this|it|claim|report|message)\b[^.!?]*\b(?:is|was)\s+(?:rejected|retracted)\b/i;
+const NEGATED_RETRACTION_PREFIX_PATTERN = /\b(?:no|not|\w+n['’]t)\b(?:\s+\w+){0,2}\s*$/i;
+const REPORTED_CLAIM_PREFIX_PATTERN = /["“]|\b(?:prior|previous)\s+(?:message|report)\b|\b(?:said|stated|reported)\b/i;
+const POST_CLAIM_SEPARATOR_PATTERN = /^[\s,;:.—–'"“‘’-]+/;
+export function hasMutationToolCapability(tools, mcpDirectTools) {
+  if ((mcpDirectTools?.length ?? 0) > 0)
+    return true;
+  if (tools === undefined)
+    return true;
+  return !tools.every((tool) => READ_ONLY_BUILTIN_TOOLS.has(tool));
 }
-function stripScopedNoEditConstraints(task) {
-  let stripped = task;
-  for (const pattern of SCOPED_NO_EDIT_CONSTRAINT_PATTERNS) {
-    stripped = stripped.replace(pattern, " ");
-  }
-  return stripped;
+function hasBuiltinMutationTool(tools) {
+  return tools === undefined || tools.some((tool) => !READ_ONLY_BUILTIN_TOOLS.has(tool));
 }
-function declaresOnlyReadOnlyTools(tools, mcpDirectTools) {
-  return tools !== undefined && tools.length > 0 && (mcpDirectTools?.length ?? 0) === 0 && tools.every((tool) => READ_ONLY_BUILTIN_TOOLS.has(tool));
+function isWriterRole(agent, acceptanceRole) {
+  return acceptanceRole === "writer" || acceptanceRole === undefined && /\bworker\b/i.test(agent);
 }
-export function expectsImplementationMutation(agent, task) {
-  const taskText = stripFrameworkInstructions(task);
-  const taskTextWithoutScopedConstraints = stripScopedNoEditConstraints(taskText);
-  if (REVIEW_ONLY_PATTERNS.some((pattern) => pattern.test(taskTextWithoutScopedConstraints)))
-    return false;
-  if (EXPLICIT_NO_EDIT_PATTERNS.some((pattern) => pattern.test(taskTextWithoutScopedConstraints)))
-    return false;
-  if (RESEARCH_AGENT_PATTERNS.some((pattern) => pattern.test(agent)))
+const WRITER_DELIVERY_PATTERN = /\b(?:address|resolve|work)\s+(?:backlog\s+)?(?:item|issue)\b|\b(?:land|ship)\s+(?:the\s+)?(?:change|changes|fix|feature|implementation)\b/i;
+export function validateImplementationToolContract(input) {
+  if (input.completionGuard === false)
+    return;
+  const requestedMutationTools = input.requestedTools?.filter((tool) => !READ_ONLY_BUILTIN_TOOLS.has(tool)) ?? [];
+  const declaredMutationToolsWereRemoved = requestedMutationTools.length > 0 && !hasBuiltinMutationTool(input.tools);
+  const configuredExtensionCapability = (input.configuredExtensions?.length ?? 0) > 0 && !declaredMutationToolsWereRemoved;
+  if (hasMutationToolCapability(input.tools, input.mcpDirectTools) || configuredExtensionCapability)
+    return;
+  const intent = classifyTaskMutationIntent(input.agent, input.task);
+  if (intent.kind === "read-only")
+    return;
+  const writerTaskMayMutate = isWriterRole(input.agent, input.acceptanceRole) && (taskMayMutate(input.task) || WRITER_DELIVERY_PATTERN.test(input.task));
+  if (intent.kind !== "implementation" && !writerTaskMayMutate && !declaredMutationToolsWereRemoved)
+    return;
+  return `Agent '${input.agent}' was given an implementation task, but its tool allowlist has no mutation-capable tools. Add bash, edit, write, or another mutation-capable tool to the agent, or use a read-only task/agent.`;
+}
+function hasCheckpointMutationEvidence(message) {
+  const record = message;
+  if (record.role !== "custom" && record.type !== "custom" || record.customType !== "dm-checkpoint")
     return false;
-  if (/\breviewer\b/i.test(agent))
-    return REVIEWER_REQUIRED_EDIT_PATTERNS.some((pattern) => pattern.test(taskText));
-  const workerIntent = agent === "worker" && WORKER_IMPLEMENTATION_PATTERNS.some((pattern) => pattern.test(taskText));
-  if (workerIntent)
-    return true;
-  return GENERAL_IMPLEMENTATION_PATTERNS.some((pattern) => pattern.test(taskText));
+  const details = typeof record.details === "object" && record.details !== null && !Array.isArray(record.details) ? record.details : undefined;
+  const data = typeof record.data === "object" && record.data !== null && !Array.isArray(record.data) ? record.data : typeof details?.beforeCommit === "string" || typeof details?.afterCommit === "string" ? details : details?.data && typeof details.data === "object" && !Array.isArray(details.data) ? details.data : undefined;
+  return typeof data?.beforeCommit === "string" && typeof data.afterCommit === "string" && data.beforeCommit !== data.afterCommit;
 }
-export function hasMutationToolCall(messages) {
+export function hasMutationToolCall(messages, mutationTools) {
   for (const message of messages) {
+    if (hasCheckpointMutationEvidence(message))
+      return true;
     if (message.role !== "assistant")
       continue;
     for (const part of message.content) {
-      if (part.type !== "toolCall")
-        continue;
-      if (part.name === "edit" || part.name === "write")
+      if (part.type === "thinking" && CURSOR_FILE_MUTATION_THINKING.test(part.thinking))
         return true;
-      if (part.name !== "bash")
+      if (part.type !== "toolCall")
         continue;
       const args = typeof part.arguments === "object" && part.arguments !== null && !Array.isArray(part.arguments) ? part.arguments : {};
-      if (typeof args.command === "string" && isMutatingBashCommand(args.command))
+      if (isMutatingTool(part.name, args, mutationTools))
         return true;
     }
   }
   return false;
 }
+function hasImplementationRetraction(text) {
+  return Array.from(text.matchAll(IMPLEMENTATION_RETRACTION_GLOBAL_PATTERN)).some((retraction) => !NEGATED_RETRACTION_PREFIX_PATTERN.test(text.slice(0, retraction.index)));
+}
+function hasDirectClaimRetraction(text) {
+  return DIRECT_CLAIM_RETRACTION_PATTERN.test(text.replace(POST_CLAIM_SEPARATOR_PATTERN, ""));
+}
+function isInsideQuotedText(report, index) {
+  let quote;
+  for (const char of report.slice(0, index)) {
+    if (quote === "double") {
+      if (char === '"' || char === "”")
+        quote = undefined;
+    } else if (quote === "single") {
+      if (char === "’")
+        quote = undefined;
+    } else if (char === '"' || char === "“") {
+      quote = "double";
+    } else if (char === "‘") {
+      quote = "single";
+    }
+  }
+  return quote !== undefined;
+}
+function unqualifiedClaimIndex(report, sentences, pattern) {
+  return sentences.findIndex((sentence) => {
+    const claim = sentence.text.match(pattern);
+    if (claim === null)
+      return false;
+    const before = sentence.text.slice(0, claim.index);
+    const after = sentence.text.slice(claim.index + claim[0].length);
+    const previous = before.trimEnd().at(-1);
+    return previous !== "'" && previous !== "‘" && !isInsideQuotedText(report, sentence.offset + claim.index) && !REPORTED_CLAIM_PREFIX_PATTERN.test(before) && !NO_BETTER_CHANGE_QUALIFIER_PATTERN.test(before) && !CLAIM_CONTRADICTION_PATTERN.test(after) && !hasImplementationRetraction(after) && !hasDirectClaimRetraction(after);
+  });
+}
+function hasLaterClaimRetraction(sentences, claimIndex) {
+  return sentences.slice(claimIndex + 1).some((sentence) => hasImplementationRetraction(sentence.text) || hasDirectClaimRetraction(sentence.text));
+}
+function explicitlyRejectsQuotedClaim(report) {
+  for (const [, claim, response] of report.matchAll(QUOTED_CLAIM_PATTERN)) {
+    if ((KEPT_CURRENT_IMPLEMENTATION_PATTERN.test(claim) || NO_CHANGE_MADE_PATTERN.test(claim)) && NO_BETTER_CHANGE_QUALIFIER_PATTERN.test(response) && QUOTED_CLAIM_REFERENCE_PATTERN.test(response))
+      return true;
+  }
+  return false;
+}
+function isImplementationChallengeTask(task) {
+  const followUp = task.replace(REVIVED_TASK_PREFIX, "");
+  return followUp !== task && IMPLEMENTATION_CHALLENGE_FOLLOW_UP_PATTERN.test(followUp.trim());
+}
+function reportsNoBetterChallengeChange(messages) {
+  const report = messages.filter((message) => message.role === "assistant").flatMap((message) => message.content).flatMap((part) => part.type === "text" ? [part.text] : []).join(`
+`);
+  if (explicitlyRejectsQuotedClaim(report))
+    return false;
+  const sentences = Array.from(report.matchAll(REPORT_SENTENCE_PATTERN), (match) => ({
+    text: match[0],
+    offset: match.index
+  }));
+  const noBetterIndex = unqualifiedClaimIndex(report, sentences, NO_BETTER_CHANGE_NEEDED_PATTERN);
+  if (noBetterIndex >= 0)
+    return !hasLaterClaimRetraction(sentences, noBetterIndex);
+  const keptIndex = unqualifiedClaimIndex(report, sentences, KEPT_CURRENT_IMPLEMENTATION_PATTERN);
+  const noChangeIndex = unqualifiedClaimIndex(report, sentences, NO_CHANGE_MADE_PATTERN);
+  return keptIndex >= 0 && noChangeIndex >= 0 && !hasLaterClaimRetraction(sentences, Math.min(keptIndex, noChangeIndex));
+}
 export function evaluateCompletionMutationGuard(input) {
-  const expectedMutation = declaresOnlyReadOnlyTools(input.tools, input.mcpDirectTools) ? false : expectsImplementationMutation(input.agent, input.task);
-  const attemptedMutation = hasMutationToolCall(input.messages);
+  if (input.toolAvailabilityError && expectsImplementationMutation(input.agent, input.task)) {
+    return {
+      expectedMutation: true,
+      attemptedMutation: false,
+      triggered: false,
+      blocked: true,
+      message: input.toolAvailabilityError
+    };
+  }
+  const expectedMutation = hasMutationToolCapability(input.tools, input.mcpDirectTools) ? expectsImplementationMutation(input.agent, input.task) : false;
+  const attemptedMutation = hasMutationToolCall(input.messages, input.mutationTools) || input.mutationEvidence?.attemptedMutation === true;
+  const noEditChallengeComplete = isImplementationChallengeTask(input.task) && reportsNoBetterChallengeChange(input.messages);
   return {
     expectedMutation,
     attemptedMutation,
-    triggered: expectedMutation && !attemptedMutation
+    triggered: expectedMutation && !attemptedMutation && !noEditChallengeComplete,
+    blocked: false
   };
 }

package/extensions/dm-subagents/src/runs/shared/context-mode.js

@@ -0,0 +1,38 @@
+export function isContextMode(value) {
+  return value === "fresh" || value === "fork";
+}
+export function isContextSummary(value) {
+  return isContextMode(value) || value === "mixed";
+}
+export function summarizeContextModes(modes) {
+  const resolved = modes.filter(isContextMode);
+  if (resolved.length === 0)
+    return;
+  const first = resolved[0];
+  return resolved.every((mode) => mode === first) ? first : "mixed";
+}
+export function contextModeLabel(mode) {
+  if (mode === "fork")
+    return "[fork]";
+  if (mode === "fresh")
+    return "[fresh]";
+  if (mode === "mixed")
+    return "[mixed]";
+  return "";
+}
+export function contextModeBadge(theme, mode) {
+  const label = contextModeLabel(mode);
+  if (!label)
+    return "";
+  if (mode === "fork")
+    return theme.fg("warning", ` ${label}`);
+  return theme.fg("dim", ` ${label}`);
+}
+export function contextModePrefix(theme, mode) {
+  const label = contextModeLabel(mode);
+  if (!label)
+    return "";
+  if (mode === "fork")
+    return `${theme.fg("warning", label)} `;
+  return `${theme.fg("dim", label)} `;
+}

package/extensions/dm-subagents/src/runs/shared/cursor-agent-adapter.js

@@ -0,0 +1,101 @@
+import * as path from "node:path";
+import { parseExternalCliJsonlEvent } from "./external-cli-runner.js";
+const MAX_EVENT_TYPE_LENGTH = 128;
+const MAX_ERROR_LENGTH = 4096;
+const MAX_OVERSIZED_TOOL_CALL_BYTES = 1024 * 1024;
+export const CURSOR_AGENT_ADAPTER_ID = "cursor-agent";
+export const CURSOR_AGENT_WRITER_ADAPTER_ID = "cursor-agent-writer";
+export const CURSOR_AGENT_ENV_ALLOWLIST = [
+  "PATH",
+  "HOME",
+  "USERPROFILE",
+  "CURSOR_API_KEY",
+  "HTTP_PROXY",
+  "HTTPS_PROXY",
+  "NO_PROXY",
+  "http_proxy",
+  "https_proxy",
+  "no_proxy",
+  "SSL_CERT_FILE",
+  "SSL_CERT_DIR"
+];
+function terminalError(event) {
+  for (const value of [event.result, event.error, event.message]) {
+    if (typeof value === "string" && value.trim())
+      return value.trim().slice(0, MAX_ERROR_LENGTH);
+  }
+  const subtype = typeof event.subtype === "string" && event.subtype ? event.subtype : "unknown";
+  return `Cursor Agent reported terminal result ${subtype}.`;
+}
+export function createCursorAgentJsonlParser() {
+  let eventCount = 0;
+  let terminal;
+  return {
+    parseLine(line) {
+      const event = parseExternalCliJsonlEvent(line, "Cursor Agent", MAX_EVENT_TYPE_LENGTH);
+      if (terminal)
+        throw new Error("Cursor Agent emitted an event after its terminal state.");
+      eventCount += 1;
+      if (event.type === "error")
+        terminal = { state: "failed", error: terminalError(event) };
+      else if (event.type === "result") {
+        if (event.subtype === "success" && event.is_error === false && typeof event.result === "string" && event.result.trim()) {
+          terminal = { state: "completed", output: event.result.trim() };
+        } else
+          terminal = { state: "failed", error: terminalError(event) };
+      }
+      return { phase: terminal ? terminal.state : "streaming", eventCount };
+    },
+    skipOversizedLine(prefix, byteLength) {
+      if (terminal || byteLength > MAX_OVERSIZED_TOOL_CALL_BYTES || !/^\s*\{\s*"type"\s*:\s*"tool_call"\s*,/.test(prefix))
+        return;
+      eventCount += 1;
+      return { phase: "streaming", eventCount };
+    },
+    finish() {
+      return terminal;
+    }
+  };
+}
+export function resolveCursorAgentLaunch(input) {
+  const writer = input.adapter === CURSOR_AGENT_WRITER_ADAPTER_ID;
+  const promptDirectory = path.join(input.asyncDir, `external-${input.stepIndex}.cursor-prompt`);
+  const promptFilePath = path.join(promptDirectory, "handoff.txt");
+  const promptRelative = path.relative(input.cwd, promptDirectory);
+  const promptOutsideWorkspace = promptRelative.startsWith("..") || path.isAbsolute(promptRelative);
+  const prefix = [...input.commandPrefixArgs ?? []];
+  const args = [
+    ...prefix,
+    "-p",
+    "--output-format",
+    "stream-json",
+    ...writer ? [] : ["--mode", "ask"],
+    "--sandbox",
+    "enabled",
+    "--workspace",
+    input.cwd,
+    ...promptOutsideWorkspace ? ["--add-dir", promptDirectory] : [],
+    `Read the complete handoff from the private file at ${promptFilePath}. Follow it and return only the final answer.`
+  ];
+  return {
+    command: input.command,
+    args,
+    promptFilePath,
+    temporaryDirectories: [promptDirectory],
+    environment: { allowlist: CURSOR_AGENT_ENV_ALLOWLIST },
+    preflight: {
+      id: input.adapter,
+      versionArgs: [...prefix, "--version"],
+      helpArgs: [...prefix, "--help"],
+      validate(result) {
+        if (!/^\d{4}\.\d{2}\.\d{2}-[0-9a-f]+$/.test(result.version))
+          throw new Error(`Unsupported Cursor Agent version response: ${JSON.stringify(result.version)}.`);
+        for (const required of ["Start the Cursor Agent", "--print", "stream-json", "--sandbox <mode>", "enabled", "--workspace <path-or-name>", "--add-dir <path>", ...writer ? ["all tools", "including write and shell"] : ["--mode <mode>", "ask:", "read-only"]]) {
+          if (!result.help.includes(required))
+            throw new Error(`Cursor Agent help does not document required option ${JSON.stringify(required)}.`);
+        }
+      }
+    },
+    parser: createCursorAgentJsonlParser()
+  };
+}