@duckmind/dm-linux-x64 0.65.5 → 0.65.7

package/extensions/dm-subagents/src/runs/shared/child-protocol.js

@@ -1,447 +0,0 @@
-import { Buffer } from "node:buffer";
-export const MAX_CHILD_PENDING_LINE_BYTES = 16 * 1024 * 1024;
-export const MAX_CHILD_STDERR_BYTES = 128 * 1024;
-const MAX_PROTOCOL_DIAGNOSTIC_BYTES = 4096;
-const MAX_PROJECTED_JSON_DEPTH = 256;
-function createPiAggregateProjection() {
-  const decoder = new TextDecoder("utf-8", { fatal: true });
-  const stack = [];
-  let rootState = "value";
-  let token;
-  let valid = true;
-  let eventType;
-  let willRetry;
-  const parent = () => stack.at(-1);
-  const isTopLevelField = (key) => stack.length === 1 && parent()?.type === "object" && (key === "type" || key === "willRetry");
-  const completeValue = (value) => {
-    const container = parent();
-    if (!container) {
-      rootState = "end";
-      return;
-    }
-    if (container.type === "object") {
-      if (stack.length === 1 && container.key === "type" && typeof value === "string")
-        eventType = value;
-      if (stack.length === 1 && container.key === "willRetry" && typeof value === "boolean")
-        willRetry = value;
-      container.key = undefined;
-      container.state = "comma-or-end";
-    } else
-      container.state = "comma-or-end";
-  };
-  const startValue = (char) => {
-    const container = parent();
-    const key = container?.type === "object" ? container.key : undefined;
-    if (isTopLevelField(key)) {
-      if (key === "type")
-        eventType = undefined;
-      else
-        willRetry = undefined;
-    }
-    if (char === "{" || char === "[") {
-      if (stack.length >= MAX_PROJECTED_JSON_DEPTH)
-        return false;
-      stack.push(char === "{" ? { type: "object", state: "key-or-end" } : { type: "array", state: "value-or-end" });
-      return true;
-    }
-    if (char === '"') {
-      token = { type: "string", role: "value", value: "", capture: key === "type" && stack.length === 1, escape: false, unicodeDigits: 0, unicodeValue: "" };
-      return true;
-    }
-    if (char === "t")
-      token = { type: "literal", expected: "true", index: 1, value: true };
-    else if (char === "f")
-      token = { type: "literal", expected: "false", index: 1, value: false };
-    else if (char === "n")
-      token = { type: "literal", expected: "null", index: 1, value: null };
-    else if (char === "-")
-      token = { type: "number", phase: "minus" };
-    else if (char === "0")
-      token = { type: "number", phase: "zero" };
-    else if (char >= "1" && char <= "9")
-      token = { type: "number", phase: "int" };
-    else
-      return false;
-    return true;
-  };
-  const closeContainer = () => {
-    stack.pop();
-    completeValue();
-    return true;
-  };
-  const processChar = (char) => {
-    if (token?.type === "string") {
-      if (token.unicodeDigits > 0) {
-        if (!/[0-9a-fA-F]/.test(char))
-          return false;
-        token.unicodeValue += char;
-        token.unicodeDigits--;
-        if (token.unicodeDigits === 0 && token.capture) {
-          if (token.value.length >= 64)
-            return false;
-          token.value += String.fromCharCode(Number.parseInt(token.unicodeValue, 16));
-        }
-        return true;
-      }
-      if (token.escape) {
-        token.escape = false;
-        if (char === "u") {
-          token.unicodeDigits = 4;
-          token.unicodeValue = "";
-          return true;
-        }
-        if (!'"\\/bfnrt'.includes(char))
-          return false;
-        if (token.capture) {
-          if (token.value.length >= 64)
-            return false;
-          token.value += { b: "\b", f: "\f", n: `
-`, r: "\r", t: "\t" }[char] ?? char;
-        }
-        return true;
-      }
-      if (char === "\\") {
-        token.escape = true;
-        return true;
-      }
-      if (char === '"') {
-        const finished = token;
-        token = undefined;
-        if (finished.role === "key") {
-          const container = parent();
-          if (!container || container.type !== "object")
-            return false;
-          container.key = finished.value;
-          container.state = "colon";
-        } else
-          completeValue(finished.capture ? finished.value : undefined);
-        return true;
-      }
-      if (char.charCodeAt(0) < 32)
-        return false;
-      if (token.capture) {
-        if (token.value.length >= 64)
-          return false;
-        token.value += char;
-      }
-      return true;
-    }
-    if (token?.type === "literal") {
-      if (char !== token.expected[token.index])
-        return false;
-      token.index++;
-      if (token.index === token.expected.length) {
-        const value = token.value;
-        token = undefined;
-        completeValue(value);
-      }
-      return true;
-    }
-    if (token?.type === "number") {
-      const phase = token.phase;
-      if (phase === "minus") {
-        if (char === "0")
-          token.phase = "zero";
-        else if (char >= "1" && char <= "9")
-          token.phase = "int";
-        else
-          return false;
-        return true;
-      }
-      if (phase === "zero" || phase === "int") {
-        if (char >= "0" && char <= "9") {
-          if (phase === "zero")
-            return false;
-          return true;
-        }
-        if (char === ".") {
-          token.phase = "dot";
-          return true;
-        }
-        if (char === "e" || char === "E") {
-          token.phase = "exp";
-          return true;
-        }
-      } else if (phase === "dot") {
-        if (char >= "0" && char <= "9") {
-          token.phase = "frac";
-          return true;
-        }
-        return false;
-      } else if (phase === "frac") {
-        if (char >= "0" && char <= "9")
-          return true;
-        if (char === "e" || char === "E") {
-          token.phase = "exp";
-          return true;
-        }
-      } else if (phase === "exp") {
-        if (char === "+" || char === "-") {
-          token.phase = "exp-sign";
-          return true;
-        }
-        if (char >= "0" && char <= "9") {
-          token.phase = "exp-digits";
-          return true;
-        }
-        return false;
-      } else if (phase === "exp-sign") {
-        if (char >= "0" && char <= "9") {
-          token.phase = "exp-digits";
-          return true;
-        }
-        return false;
-      } else if (phase === "exp-digits" && char >= "0" && char <= "9")
-        return true;
-      if (!["zero", "int", "frac", "exp-digits"].includes(phase))
-        return false;
-      token = undefined;
-      completeValue();
-      return processChar(char);
-    }
-    if (char === " " || char === "\t" || char === "\r" || char === `
-`)
-      return true;
-    const container = parent();
-    if (!container)
-      return rootState === "value" ? startValue(char) : false;
-    if (container.type === "object") {
-      if (container.state === "key-or-end" || container.state === "key") {
-        if (char === "}" && container.state === "key-or-end")
-          return closeContainer();
-        if (char !== '"')
-          return false;
-        token = { type: "string", role: "key", value: "", capture: stack.length === 1, escape: false, unicodeDigits: 0, unicodeValue: "" };
-        return true;
-      }
-      if (container.state === "colon") {
-        if (char !== ":")
-          return false;
-        container.state = "value";
-        return true;
-      }
-      if (container.state === "value")
-        return startValue(char);
-      if (char === ",") {
-        container.state = "key";
-        return true;
-      }
-      if (char === "}")
-        return closeContainer();
-      return false;
-    }
-    if (container.state === "value-or-end" || container.state === "value") {
-      if (char === "]" && container.state === "value-or-end")
-        return closeContainer();
-      return startValue(char);
-    }
-    if (char === ",") {
-      container.state = "value";
-      return true;
-    }
-    if (char === "]")
-      return closeContainer();
-    return false;
-  };
-  const processText = (text) => {
-    for (const char of text)
-      if (!processChar(char))
-        return false;
-    return true;
-  };
-  return {
-    push(chunk) {
-      if (!valid)
-        return false;
-      try {
-        valid = processText(decoder.decode(chunk, { stream: true }));
-      } catch {
-        valid = false;
-      }
-      return valid;
-    },
-    finish() {
-      try {
-        valid = valid && processText(decoder.decode());
-      } catch {
-        valid = false;
-      }
-      if (token?.type === "number" && ["zero", "int", "frac", "exp-digits"].includes(token.phase)) {
-        token = undefined;
-        completeValue();
-      }
-      if (!valid || token || stack.length !== 0 || rootState !== "end")
-        return;
-      if (eventType === "turn_end")
-        return '{"type":"turn_end"}';
-      if (eventType === "agent_end" && typeof willRetry === "boolean")
-        return JSON.stringify({ type: "agent_end", willRetry });
-      if (eventType === "compaction_end" && typeof willRetry === "boolean")
-        return JSON.stringify({ type: "compaction_end", willRetry });
-      return;
-    }
-  };
-}
-export const PI_AGGREGATE_EVENT_PROJECTOR = {
-  accepts(prefix) {
-    return prefix.startsWith('{"type":"turn_end"') || prefix.startsWith('{"type":"agent_end"') || prefix.startsWith('{"type":"compaction_end"');
-  },
-  create: createPiAggregateProjection
-};
-export function formatProtocolOutputLimit(limit) {
-  return `${limit.code}: child ${limit.stream} line exceeded ${limit.limitBytes} bytes (observed at least ${limit.observedBytes} bytes without a newline).`;
-}
-export function createBoundedLineReader(options) {
-  const maxPendingLineBytes = options.maxPendingLineBytes ?? MAX_CHILD_PENDING_LINE_BYTES;
-  if (!Number.isInteger(maxPendingLineBytes) || maxPendingLineBytes < 1) {
-    throw new Error("maxPendingLineBytes must be a positive integer.");
-  }
-  let pending = [];
-  let pendingBytes = 0;
-  let projectedPrefix = Buffer.alloc(0);
-  let projectedTail = Buffer.alloc(0);
-  let projectedBytes = 0;
-  let projection;
-  let projectingOversizedLine = false;
-  let limitExceeded = false;
-  const diagnosticTail = (prior, segment) => {
-    const tailFromSegment = segment.subarray(Math.max(0, segment.length - MAX_PROTOCOL_DIAGNOSTIC_BYTES));
-    return tailFromSegment.length === MAX_PROTOCOL_DIAGNOSTIC_BYTES ? tailFromSegment : Buffer.concat([prior.subarray(Math.max(0, prior.length - (MAX_PROTOCOL_DIAGNOSTIC_BYTES - tailFromSegment.length))), tailFromSegment]);
-  };
-  const failLimit = (observedBytes, prefix, tail) => {
-    limitExceeded = true;
-    pending = [];
-    pendingBytes = 0;
-    projectingOversizedLine = false;
-    projection = undefined;
-    projectedPrefix = Buffer.alloc(0);
-    projectedTail = Buffer.alloc(0);
-    projectedBytes = 0;
-    options.onLimit({
-      code: "protocol_output_limit",
-      stream: options.stream ?? "stdout",
-      limitBytes: maxPendingLineBytes,
-      observedBytes,
-      diagnosticPrefix: prefix.toString("utf8"),
-      diagnosticTail: tail.toString("utf8")
-    });
-    return false;
-  };
-  const finishLine = () => {
-    if (projectingOversizedLine) {
-      const projected = projection?.finish();
-      if (projected === undefined) {
-        failLimit(projectedBytes, projectedPrefix, projectedTail);
-      } else {
-        options.onLine(projected);
-      }
-    } else if (pendingBytes > 0) {
-      options.onLine(Buffer.concat(pending, pendingBytes).toString("utf8"));
-    }
-    pending = [];
-    pendingBytes = 0;
-    projectingOversizedLine = false;
-    projection = undefined;
-    projectedPrefix = Buffer.alloc(0);
-    projectedTail = Buffer.alloc(0);
-    projectedBytes = 0;
-  };
-  const append = (segment) => {
-    if (segment.length === 0)
-      return true;
-    if (projectingOversizedLine) {
-      projectedBytes += segment.length;
-      projectedTail = diagnosticTail(projectedTail, segment);
-      return projection?.push(segment) === true || failLimit(projectedBytes, projectedPrefix, projectedTail);
-    }
-    const observedBytes = pendingBytes + segment.length;
-    if (observedBytes > maxPendingLineBytes) {
-      const prior = pendingBytes > 0 ? Buffer.concat(pending, pendingBytes) : Buffer.alloc(0);
-      const prefixFromPrior = prior.subarray(0, MAX_PROTOCOL_DIAGNOSTIC_BYTES);
-      const prefix = prefixFromPrior.length === MAX_PROTOCOL_DIAGNOSTIC_BYTES ? prefixFromPrior : Buffer.concat([prefixFromPrior, segment.subarray(0, MAX_PROTOCOL_DIAGNOSTIC_BYTES - prefixFromPrior.length)]);
-      const tail = diagnosticTail(prior, segment);
-      if (options.oversizedLineProjector?.accepts(prefix.toString("utf8"))) {
-        const candidate = options.oversizedLineProjector.create();
-        if (!candidate.push(prior) || !candidate.push(segment))
-          return failLimit(observedBytes, prefix, tail);
-        pending = [];
-        pendingBytes = 0;
-        projectingOversizedLine = true;
-        projection = candidate;
-        projectedPrefix = prefix;
-        projectedTail = tail;
-        projectedBytes = observedBytes;
-        return true;
-      }
-      return failLimit(observedBytes, prefix, tail);
-    }
-    pending.push(segment);
-    pendingBytes = observedBytes;
-    return true;
-  };
-  return {
-    push(chunk) {
-      if (limitExceeded)
-        return;
-      const bytes = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
-      let start = 0;
-      for (let index = 0;index < bytes.length; index++) {
-        if (bytes[index] !== 10)
-          continue;
-        if (!append(bytes.subarray(start, index)))
-          return;
-        finishLine();
-        if (limitExceeded)
-          return;
-        start = index + 1;
-      }
-      append(bytes.subarray(start));
-    },
-    end() {
-      if (!limitExceeded)
-        finishLine();
-    },
-    exceeded: () => limitExceeded
-  };
-}
-function trimToUtf8Boundary(buffer, maxBytes) {
-  if (buffer.length <= maxBytes)
-    return buffer;
-  let start = buffer.length - maxBytes;
-  while (start < buffer.length && (buffer[start] & 192) === 128)
-    start++;
-  return buffer.subarray(start);
-}
-export function createBoundedByteTail(maxBytes = MAX_CHILD_STDERR_BYTES) {
-  if (!Number.isInteger(maxBytes) || maxBytes < 1)
-    throw new Error("maxBytes must be a positive integer.");
-  let tail = Buffer.alloc(0);
-  return {
-    push(chunk) {
-      const bytes = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
-      tail = trimToUtf8Boundary(Buffer.concat([tail, bytes]), maxBytes);
-    },
-    text: () => tail.toString("utf8"),
-    byteLength: () => tail.length
-  };
-}
-export function projectChildLifecycle(event, terminalAssistantStop = false, state) {
-  if (event.type === "compaction_end") {
-    if (state)
-      state.compactionRetryActive = event.willRetry === true;
-    return event.willRetry === true ? "cancel-drain" : "none";
-  }
-  if (event.type === "agent_start" || event.type === "auto_retry_start") {
-    if (state)
-      state.compactionRetryActive = false;
-  }
-  if (event.type === "agent_end" && event.willRetry === true)
-    return "cancel-drain";
-  if (event.type === "agent_end" && state)
-    state.compactionRetryActive = false;
-  if (event.type === "agent_settled")
-    return state?.compactionRetryActive ? "none" : "start-drain";
-  if (terminalAssistantStop)
-    return "start-drain";
-  return "none";
-}

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

@@ -1,40 +0,0 @@
-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,173 +0,0 @@
-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",
-  "find",
-  "ls",
-  "web_search",
-  "fetch_content",
-  "get_search_content",
-  "intercom",
-  "contact_supervisor",
-  "structured_output"
-]);
-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 hasBuiltinMutationTool(tools) {
-  return tools === undefined || tools.some((tool) => !READ_ONLY_BUILTIN_TOOLS.has(tool));
-}
-function isWriterRole(agent, acceptanceRole) {
-  return acceptanceRole === "writer" || acceptanceRole === undefined && /\bworker\b/i.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;
-  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, 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 === "thinking" && CURSOR_FILE_MUTATION_THINKING.test(part.thinking))
-        return true;
-      if (part.type !== "toolCall")
-        continue;
-      const args = typeof part.arguments === "object" && part.arguments !== null && !Array.isArray(part.arguments) ? part.arguments : {};
-      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) {
-  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 && !noEditChallengeComplete,
-    blocked: false
-  };
-}