@duckmind/dm-linux-x64 0.65.4 → 0.65.6

package/extensions/dm-subagents/src/runs/shared/llm-intent-arbiter.js

@@ -1,190 +0,0 @@
-import { createHash } from "node:crypto";
-import { Agent } from "@duckmind/dm-agent-core";
-import { convertToLlm } from "@duckmind/dm-coding-agent";
-import { streamSimple } from "@duckmind/dm-ai/compat";
-import { Type } from "typebox";
-import { agentStreamOptions } from "../../shared/agent-stream-options.js";
-const COMPLETION_GUARD_ERROR_PREFIX = "Subagent completed without making edits for an implementation task.";
-const DecisionParams = Type.Object({
-  classification: Type.String({ enum: ["read_only", "implementation"] }),
-  confidence: Type.String({
-    enum: ["low", "medium", "high"],
-    description: "Confidence in the classification. Only read_only with high confidence rescues a failed run."
-  }),
-  reason: Type.String({ description: "One concise reason for this classification." })
-}, { additionalProperties: false });
-export function mapArbiterDecision(decision) {
-  if (!decision)
-    return "unavailable";
-  if (decision.classification === "read_only" && decision.confidence === "high")
-    return "read-only";
-  return "implementation";
-}
-const DEFAULT_ARBITER_TIMEOUT_MS = 1e4;
-function resolveArbiterModel(ctx, options) {
-  const registry = ctx.modelRegistry;
-  const explicit = options?.model?.trim();
-  if (explicit) {
-    const [provider, id] = explicit.split("/");
-    if (provider && id)
-      return registry.find?.(provider, id) ?? null;
-    return null;
-  }
-  if (ctx.model)
-    return ctx.model;
-  const first = registry.getAvailable?.()[0];
-  if (first?.provider && first.id)
-    return registry.find?.(first.provider, first.id) ?? null;
-  return null;
-}
-function resolveArbiterRuntime(ctx, options) {
-  const model = resolveArbiterModel(ctx, options);
-  if (!model?.provider || !model.id)
-    return null;
-  const registry = ctx.modelRegistry;
-  const modelApi = model.api;
-  const registered = registry.getRegisteredProviderConfig?.(model.provider);
-  const baseStreamFn = options?.streamFn ?? (registered?.streamSimple && registered.api === modelApi ? registered.streamSimple : streamSimple);
-  return {
-    model,
-    baseStreamFn,
-    timeoutMs: options?.timeoutMs ?? DEFAULT_ARBITER_TIMEOUT_MS
-  };
-}
-async function resolveArbiterAuth(ctx, model) {
-  const registry = ctx.modelRegistry;
-  if (!registry.getApiKeyAndHeaders)
-    return {};
-  try {
-    const auth = await registry.getApiKeyAndHeaders(model);
-    if (auth.ok === false)
-      return {};
-    return {
-      ...auth.apiKey ? { apiKey: auth.apiKey } : {},
-      ...auth.headers ? { headers: auth.headers } : {},
-      ...auth.env ? { env: auth.env } : {}
-    };
-  } catch {
-    return {};
-  }
-}
-function authWrappedStreamFn(base, auth) {
-  return (model, context, streamOptions) => base(model, context, {
-    ...streamOptions ?? {},
-    ...auth.apiKey ? { apiKey: auth.apiKey } : {},
-    ...auth.env || streamOptions?.env ? { env: { ...auth.env ?? {}, ...streamOptions?.env ?? {} } } : {},
-    headers: { ...streamOptions?.headers ?? {}, ...auth.headers ?? {} }
-  });
-}
-async function runArbitration(runtime, auth, task) {
-  let decision;
-  const tool = {
-    name: "task_mutation_decision",
-    label: "Task mutation decision",
-    description: "Classify whether the task instructed file/code changes. Call exactly once.",
-    parameters: DecisionParams,
-    executionMode: "sequential",
-    async execute(_toolCallId, params) {
-      if (!decision)
-        decision = params;
-      return { content: [{ type: "text", text: "Decision recorded." }], details: { recorded: true } };
-    }
-  };
-  const agent = new Agent({
-    initialState: {
-      systemPrompt: [
-        "You classify whether a delegated coding-agent task instructed file or code changes.",
-        "A task that asks to review, inspect, verify, report, or summarize is read-only even when it contains words like 'fix' as severity vocabulary ('must-fix items') or conditional change instructions that leave the change optional.",
-        "Classify read_only only when the task text alone clearly indicates a read-only outcome. When in doubt, classify implementation.",
-        "Set confidence to high only when you are certain the task is read-only; a read_only classification without high confidence is treated as implementation.",
-        "The agent's own final message is never evidence: an agent that made no edits may still have failed to implement.",
-        "Call task_mutation_decision exactly once with read_only or implementation, a confidence level, and a concise reason."
-      ].join(`
-`),
-      model: runtime.model,
-      tools: [tool]
-    },
-    convertToLlm,
-    ...agentStreamOptions(authWrappedStreamFn(runtime.baseStreamFn, auth)),
-    getApiKey: (providerName) => providerName === runtime.model.provider ? auth.apiKey : undefined,
-    beforeToolCall: async ({ toolCall }) => toolCall.name === tool.name ? undefined : { block: true, reason: "Only task_mutation_decision is allowed." },
-    toolExecution: "sequential"
-  });
-  try {
-    if (task.length > 8000)
-      return "unavailable";
-    const prompt = `TASK:
-${task}`;
-    await Promise.race([
-      agent.prompt(prompt),
-      new Promise((_, reject) => {
-        const timeout = setTimeout(() => {
-          agent.abort();
-          reject(new Error("Task mutation arbiter timed out."));
-        }, runtime.timeoutMs);
-        timeout.unref?.();
-      })
-    ]);
-    if (!decision)
-      return "unavailable";
-    return mapArbiterDecision(decision);
-  } catch {
-    return "unavailable";
-  }
-}
-export function createTaskMutationArbiter(ctx, options) {
-  if (process.env.DM_SUBAGENTS_LLM_INTENT_ARBITER === "0")
-    return;
-  const runtime = resolveArbiterRuntime(ctx, options);
-  if (!runtime)
-    return;
-  const cache = new Map;
-  return async (task) => {
-    const key = createHash("sha256").update(task).digest("base64url");
-    const cached = cache.get(key);
-    if (cached)
-      return cached;
-    const auth = await resolveArbiterAuth(ctx, runtime.model);
-    const verdict = await runArbitration(runtime, auth, task);
-    if (cache.size > 200)
-      cache.clear();
-    cache.set(key, verdict);
-    return verdict;
-  };
-}
-export function isCompletionGuardFailure(result) {
-  return result.error?.startsWith(COMPLETION_GUARD_ERROR_PREFIX) === true;
-}
-export async function arbitrateCompletionGuardRescue(input) {
-  if (!input.guardTriggered || !input.arbiter) {
-    return { triggered: input.guardTriggered, rescued: false };
-  }
-  if (input.task.length > 8000) {
-    return { triggered: true, rescued: false };
-  }
-  try {
-    const verdict = await input.arbiter(input.task);
-    if (verdict === "read-only")
-      return { triggered: false, rescued: true };
-    return { triggered: true, rescued: false };
-  } catch {
-    return { triggered: true, rescued: false };
-  }
-}
-export async function maybeRescueCompletionGuardFailure(result, task, arbiter) {
-  if (!arbiter || !isCompletionGuardFailure(result))
-    return false;
-  const verdict = await arbitrateWithGuard(arbiter, task);
-  if (verdict !== "read-only")
-    return false;
-  result.exitCode = 0;
-  delete result.error;
-  return true;
-}
-async function arbitrateWithGuard(arbiter, task) {
-  try {
-    return await arbiter(task);
-  } catch {
-    return "unavailable";
-  }
-}

package/extensions/dm-subagents/src/runs/shared/model-exclusions.js

@@ -1,207 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { splitKnownThinkingSuffix } from "../../shared/model-info.js";
-import { TEMP_ROOT_DIR } from "../../shared/types.js";
-export const EXCLUSIONS_PATH_ENV = "PI_MODEL_EXCLUSIONS_PATH";
-let exclusions = [];
-let loaded = false;
-export const DEFAULT_MODEL_EXCLUSION_TTL_MS = 24 * 60 * 60000;
-export const MAX_MODEL_EXCLUSION_TTL_MS = 8000000000000000;
-const MAX_DATE_TIMESTAMP_MS = 8640000000000000;
-let defaultTTLMs = DEFAULT_MODEL_EXCLUSION_TTL_MS;
-let loadedTTLCeilingMs;
-let persistTimer = null;
-let persistSeq = 0;
-export function setDefaultTTL(ms, options) {
-  if (!Number.isFinite(ms) || ms <= 0 || ms > MAX_MODEL_EXCLUSION_TTL_MS) {
-    throw new Error(`Default model exclusion TTL must be a finite positive number no greater than ${MAX_MODEL_EXCLUSION_TTL_MS}.`);
-  }
-  defaultTTLMs = ms;
-  loadedTTLCeilingMs = options?.shortenExisting ? ms : undefined;
-  if (loaded && loadedTTLCeilingMs !== undefined && shortenExclusionsToTTL(exclusions, loadedTTLCeilingMs, Date.now()))
-    schedulePersist();
-}
-export function getExclusionsFilePath() {
-  const envPath = process.env[EXCLUSIONS_PATH_ENV];
-  if (typeof envPath === "string" && envPath.trim())
-    return envPath.trim();
-  return path.join(TEMP_ROOT_DIR, "model-exclusions.json");
-}
-export function flushPersist() {
-  const file = getExclusionsFilePath();
-  try {
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    const tmpPath = `${file}.${process.pid}.${persistSeq++}.tmp`;
-    fs.writeFileSync(tmpPath, JSON.stringify({
-      version: 1,
-      exclusions: deduplicate(exclusions)
-    }, null, 2), "utf-8");
-    fs.renameSync(tmpPath, file);
-  } catch (error) {
-    console.error(`[model-exclusions] Failed to persist exclusions to ${file}:`, error);
-  }
-}
-function schedulePersist() {
-  if (persistTimer)
-    clearTimeout(persistTimer);
-  persistTimer = setTimeout(() => {
-    persistTimer = null;
-    flushPersist();
-  }, 5000);
-  persistTimer.unref?.();
-}
-function ensureLoaded() {
-  if (loaded)
-    return;
-  loaded = true;
-  try {
-    const raw = fs.readFileSync(getExclusionsFilePath(), "utf-8");
-    const data = JSON.parse(raw);
-    if (data.version === 1) {
-      if (!Array.isArray(data.exclusions))
-        throw new Error("Model exclusion store version 1 must contain an exclusions array.");
-      for (let index = 0;index < data.exclusions.length; index++) {
-        const entry = data.exclusions[index];
-        if (!entry || typeof entry !== "object" || Array.isArray(entry))
-          throw new Error(`Model exclusion store entry ${index} must be an object.`);
-        if (entry.reason !== undefined && typeof entry.reason !== "string")
-          throw new Error(`Model exclusion store entry ${index} has an invalid reason.`);
-        for (const field of ["recordedAt", "expiresAt"]) {
-          const timestamp = entry[field];
-          if (typeof timestamp !== "number" || !Number.isFinite(timestamp) || timestamp <= 0 || timestamp > MAX_DATE_TIMESTAMP_MS) {
-            throw new Error(`Model exclusion store entry ${index} has an invalid ${field}.`);
-          }
-        }
-      }
-      const now = Date.now();
-      exclusions = (data.exclusions ?? []).filter((e) => e.expiresAt > now);
-      const shortened = loadedTTLCeilingMs !== undefined && shortenExclusionsToTTL(exclusions, loadedTTLCeilingMs, now);
-      exclusions = deduplicate(exclusions);
-      if (shortened)
-        schedulePersist();
-    }
-  } catch (error) {
-    if (error.code !== "ENOENT") {
-      console.error(`[model-exclusions] Failed to load exclusions from ${getExclusionsFilePath()}:`, error);
-    }
-  }
-}
-function dedupKey(entry) {
-  return `${entry.provider ?? ""}|${entry.modelId ?? ""}`;
-}
-function deduplicate(items) {
-  const map = new Map;
-  for (const entry of items) {
-    const key = dedupKey(entry);
-    const existing = map.get(key);
-    if (!existing || entry.recordedAt > existing.recordedAt) {
-      map.set(key, entry);
-    }
-  }
-  return Array.from(map.values());
-}
-export function recordModelFailure(options) {
-  ensureLoaded();
-  const ttl = options.ttlMs ?? defaultTTLMs;
-  const now = Date.now();
-  const target = options.modelId !== undefined ? { modelId: options.modelId, ...options.provider ? { provider: options.provider } : {} } : { provider: options.provider };
-  const exclusion = {
-    ...target,
-    reason: options.reason ?? "runtime-failure",
-    recordedAt: now,
-    expiresAt: now + ttl
-  };
-  exclusions.unshift(exclusion);
-  exclusions = deduplicate(exclusions);
-  if (exclusions.length > 200)
-    exclusions.length = 200;
-  flushPersist();
-}
-export function clearExpiredExclusions() {
-  ensureLoaded();
-  prune(exclusions, Date.now());
-  schedulePersist();
-}
-export function clearExclusions() {
-  ensureLoaded();
-  exclusions.length = 0;
-  schedulePersist();
-}
-function entryMatches(entry, candidateModelId, candidateProvider, now) {
-  if (entry.expiresAt <= now)
-    return false;
-  if (entry.modelId) {
-    if (entry.modelId !== candidateModelId)
-      return false;
-    return !entry.provider || !candidateProvider || entry.provider === candidateProvider;
-  }
-  return Boolean(entry.provider) && entry.provider === candidateProvider;
-}
-export function isExcluded(modelId, provider) {
-  ensureLoaded();
-  return exclusions.some((entry) => entryMatches(entry, modelId, provider, Date.now()));
-}
-export function findModelExclusion(fullId, now = Date.now()) {
-  ensureLoaded();
-  const { provider, modelId } = parseModelKey(fullId);
-  return exclusions.find((entry) => entryMatches(entry, modelId, provider, now));
-}
-export function getExcludedCount() {
-  ensureLoaded();
-  clearExpiredExclusions();
-  return exclusions.length;
-}
-export function parseModelKey(fullId) {
-  const base = splitKnownThinkingSuffix(fullId).baseModel;
-  if (!base.includes("/"))
-    return { modelId: base };
-  const slash = base.indexOf("/");
-  return { provider: base.slice(0, slash), modelId: base.slice(slash + 1) };
-}
-export function filterFallbackCandidates(candidates, opts) {
-  ensureLoaded();
-  const timestamp = opts?.now ?? Date.now();
-  const seen = new Set;
-  const filtered = [];
-  for (const raw of candidates) {
-    if (!raw || seen.has(raw))
-      continue;
-    const { provider: candidateProvider, modelId: candidateModelId } = parseModelKey(raw);
-    const exclusion = exclusions.find((entry) => entryMatches(entry, candidateModelId, candidateProvider, timestamp));
-    if (exclusion) {
-      opts?.onExcluded?.(raw, exclusion);
-      continue;
-    }
-    seen.add(raw);
-    filtered.push(raw);
-  }
-  return filtered;
-}
-export function reloadFromDisk() {
-  loaded = false;
-  exclusions = [];
-  ensureLoaded();
-}
-function prune(items, now) {
-  let write = 0;
-  for (let i = 0;i < items.length; i++) {
-    const entry = items[i];
-    if (entry.expiresAt > now) {
-      items[write++] = entry;
-    }
-  }
-  items.length = write;
-}
-function shortenExclusionsToTTL(items, ttlMs, now) {
-  let changed = false;
-  for (const entry of items) {
-    const configuredExpiry = entry.recordedAt + ttlMs;
-    if (entry.expiresAt > configuredExpiry) {
-      entry.expiresAt = configuredExpiry;
-      changed = true;
-    }
-  }
-  const previousLength = items.length;
-  prune(items, now);
-  return changed || items.length !== previousLength;
-}

package/extensions/dm-subagents/src/runs/shared/subagent-startup-retry.js

@@ -1,50 +0,0 @@
-import { formatProcessSignalError } from "./process-signal.js";
-export const SUBAGENT_STARTUP_RETRY_DELAYS_MS = [250, 750, 1500];
-export const MAX_SUBAGENT_STARTUP_FAILURE_DURATION_MS = 2000;
-const SIGKILL_PROCESS_SIGNAL_ERROR = formatProcessSignalError("SIGKILL");
-const EXTENSION_REGISTRATION_CONFLICT_PATTERN = /Failed to load extension\b[^\n]*:\s*(?:Tool|Flag)\s+"[^"]+"\s+conflicts with\b/i;
-export function formatSubagentExtensionConflictError(error, input) {
-  if (!error || !input.ambientExtensionsEnabled || !EXTENSION_REGISTRATION_CONFLICT_PATTERN.test(error))
-    return error;
-  const settings = JSON.stringify({
-    subagents: { agentOverrides: { [input.agent]: { extensions: [] } } }
-  });
-  return `${error}
-
-Subagent startup loaded conflicting ambient DM extensions. Retry this run after disabling ambient extension discovery for agent ${JSON.stringify(input.agent)} in project .dm/settings.json: ${settings}. Replace the empty array with only the required extension entry paths when this agent needs extension tools.`;
-}
-function hasUsage(usage) {
-  return usage.input !== 0 || usage.output !== 0 || usage.cacheRead !== 0 || usage.cacheWrite !== 0 || usage.cost !== 0 || usage.turns !== 0;
-}
-export function isRetryableSubagentStartupFailure(evidence) {
-  return evidence.exitCode !== undefined && evidence.exitCode !== null && evidence.exitCode !== 0 && (!evidence.error?.trim() || evidence.error === SIGKILL_PROCESS_SIGNAL_ERROR) && !evidence.finalOutput?.trim() && evidence.messageCount === 0 && evidence.toolCount === 0 && !hasUsage(evidence.usage) && evidence.durationMs >= 0 && evidence.durationMs <= MAX_SUBAGENT_STARTUP_FAILURE_DURATION_MS && evidence.protocolError === undefined && (evidence.processSignal === undefined || evidence.processSignal === null || evidence.processSignal === "SIGKILL") && evidence.observedMutationAttempt !== true && evidence.detached !== true && evidence.interrupted !== true && evidence.timedOut !== true && evidence.stopped !== true && evidence.turnBudgetExceeded !== true;
-}
-export function formatSubagentStartupRetryNote(input) {
-  return `[startup-retry] ${input.model} exited before model or tool activity (attempt ${input.attempt}/${input.maxAttempts}). Retrying the same model in ${input.delayMs}ms.`;
-}
-export function formatSubagentStartupRetryExhaustedError(input) {
-  return `Subagent failed to start after ${input.attempts} attempts on ${input.model}; no model, tool, output, usage, or diagnostic activity was observed. This may be a concurrent DM startup race. Retry the run or temporarily lower subagent concurrency.`;
-}
-export async function waitForSubagentStartupRetry(delayMs, signals) {
-  const activeSignals = signals.filter((signal) => Boolean(signal));
-  if (activeSignals.some((signal) => signal.aborted))
-    return false;
-  if (delayMs <= 0)
-    return true;
-  return await new Promise((resolve) => {
-    let settled = false;
-    const finish = (shouldRetry) => {
-      if (settled)
-        return;
-      settled = true;
-      clearTimeout(timer);
-      for (const signal of activeSignals)
-        signal.removeEventListener("abort", abort);
-      resolve(shouldRetry);
-    };
-    const abort = () => finish(false);
-    const timer = setTimeout(() => finish(true), delayMs);
-    for (const signal of activeSignals)
-      signal.addEventListener("abort", abort, { once: true });
-  });
-}

package/extensions/dm-subagents/src/runs/shared/task-intent.js

@@ -1,130 +0,0 @@
-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|implement)\b/i,
-  /\brequired\s+to\s+(?:edit|modify|change|fix|patch|apply|implement)\b/i,
-  /(?:^|[.!?\n]\s*)implement\s+(?:the\s+)?(?:approved|requested|specified|file|code|source|fix(?:es)?|changes?)\b/i,
-  /\bregardless\s+of\s+findings\b/i,
-  /\balways\s+(?:edit|modify|change|fix|patch|apply|implement)\b/i,
-  /\bapply\s+(?:the\s+)?fix(?:es)?\s+directly\b/i,
-  /\bmake\s+(?:the\s+)?code\s+changes\b/i
-];
-const NO_EDIT_PROHIBITION_PATTERN = /\b(?:do not|don't|must not)\s+(?:edit|modify|write(?:\s+to)?|touch|change)\b((?:(?!\b(?:but|and|then)\b)[^.;,:!?\n–—-])*)/gi;
-const GENERIC_PROHIBITION_OBJECT = /^\s*(?:(?:any|all|the|these|those|your|our|existing|project|product|source|sources|config|configs|repo|repository)[\s/,-]*)*(?:files?|code|codebase|sources?|anything|repo(?:sitory)?)?\s*$/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 NO_TOOL_INTENT_PATTERNS = [
-  /\bno tools? needed\b/i,
-  /\bno tools? required\b/i,
-  /\bwithout using tools\b/i,
-  /\bdo not use tools\b/i,
-  /\bdon't use tools\b/i
-];
-const READ_ONLY_DELIVERABLE_PATTERNS = [
-  /\b(?:draft|write|compose|prepare|produce)\s+(?:(?:a|an|the)\s+)?(?:github\s+)?(?:issue|bug report|issue draft|issue body|proposal|plan|report|summary|findings?|analysis|recommendations?)\b/i,
-  /\b(?:issue|bug report)\s+(?:draft|body|template)\b/i,
-  /\b(?:return|provide|produce)\s+(?:text|markdown|answer|findings?|recommendations?)\s+only\b/i
-];
-const RESEARCH_AGENT_PATTERNS = [
-  /\binvestigate\b/i,
-  /\bscout\b/i,
-  /\bresearch(?:er)?\b/i
-];
-const SEVERITY_COMPOUND_PATTERN = /\b(?:must|should|needs)[\-\u2010-\u2015](?:fix|edit|update|add|remove|replace|create|apply|make|do|implement|modify|delete|patch)\b/gi;
-function stripSeverityCompounds(task) {
-  return task.replace(SEVERITY_COMPOUND_PATTERN, " ");
-}
-
-export { stripSeverityCompounds };
-const FIX_OR_PATCH_IMPLEMENTATION_PATTERN = /\b(?:fix|patch)\s+(?:(?:it|this|that|them|each|any|all|these|those)\b|(?:(?:a|an|the|any|all)\s+)?(?:(?:failing|failed|broken|flaky|red|cold|start|current|existing|reported|approved|known|regression|unit|integration|e2e|source|typescript|type-?script|ts|type-?check|compiler)\s+)*(?:bug|defect|issues?|problems?|failures?|regressions?|tests?|errors?|items?|typos?|code|source|implementation|component|function|module|class|method|logic|file|files|readme|docs?|changelog|package\.json|config|manifest|extension|prompt|command|lint(?:ing)?|build|ci|type-?check|type\s+checking)\b)/i;
-const WORKER_IMPLEMENTATION_PATTERNS = [
-  /\b(?:implement|edit|modify|refactor|delete)\b/i,
-  FIX_OR_PATCH_IMPLEMENTATION_PATTERN,
-  /\b(?:update|add|remove|replace|create)\b(?!\s+(?:(?:a|an|the)\s+)?(?:report|summary|findings?)(?:\b|$))/i,
-  /\bapply\s+(?:the\s+)?(?:(?:suggested|proposed|recommended)\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|edit|modify|refactor)\b/i,
-  FIX_OR_PATCH_IMPLEMENTATION_PATTERN,
-  /\bapply\s+(?:the\s+)?(?:(?:suggested|proposed|recommended)\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
-];
-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)?:|Return the complete artifact in your final response\.|The runtime will persist it to exactly this path:|Do not call contact_supervisor merely because no write-capable tool is available\.|This path is authoritative for this run\.|Ignore any other output filename or output path mentioned elsewhere)/i.test(line)).join(`
-`);
-}
-function stripPatterns(task, patterns) {
-  let stripped = task;
-  for (const pattern of patterns) {
-    const flags = pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`;
-    stripped = stripped.replace(new RegExp(pattern.source, flags), " ");
-  }
-  return stripped;
-}
-function analyzeNoEditProhibitions(taskText) {
-  let present = REVIEW_ONLY_PATTERNS.some((pattern) => pattern.test(taskText)) || NO_TOOL_INTENT_PATTERNS.some((pattern) => pattern.test(taskText));
-  let blanket = present;
-  let strippedText = stripPatterns(taskText, [...REVIEW_ONLY_PATTERNS, ...NO_TOOL_INTENT_PATTERNS]);
-  strippedText = strippedText.replace(new RegExp(NO_EDIT_PROHIBITION_PATTERN.source, NO_EDIT_PROHIBITION_PATTERN.flags), (_match, object) => {
-    present = true;
-    if (GENERIC_PROHIBITION_OBJECT.test(object))
-      blanket = true;
-    return " ";
-  });
-  return { present, blanket, strippedText };
-}
-function taskHasReadOnlyDeliverable(taskText) {
-  return READ_ONLY_DELIVERABLE_PATTERNS.some((pattern) => pattern.test(taskText));
-}
-function isReviewerStyleAgent(agent) {
-  return /\b(?:advisor|reviewer|oracle)\b/i.test(agent);
-}
-function hasImplementationIntent(agent, taskText) {
-  if (isReviewerStyleAgent(agent))
-    return REVIEWER_REQUIRED_EDIT_PATTERNS.some((pattern) => pattern.test(taskText));
-  if (agent === "worker")
-    return WORKER_IMPLEMENTATION_PATTERNS.some((pattern) => pattern.test(taskText));
-  return GENERAL_IMPLEMENTATION_PATTERNS.some((pattern) => pattern.test(taskText));
-}
-export function classifyTaskMutationIntent(agent, task) {
-  const taskText = stripSeverityCompounds(stripFrameworkInstructions(task));
-  const taskTextWithoutScopedConstraints = stripPatterns(taskText, SCOPED_NO_EDIT_CONSTRAINT_PATTERNS);
-  const prohibitions = analyzeNoEditProhibitions(taskTextWithoutScopedConstraints);
-  if (prohibitions.present) {
-    if (prohibitions.blanket)
-      return { kind: "read-only" };
-    return hasImplementationIntent(agent, prohibitions.strippedText) ? { kind: "implementation" } : { kind: "read-only" };
-  }
-  if (RESEARCH_AGENT_PATTERNS.some((pattern) => pattern.test(agent)))
-    return { kind: "read-only" };
-  if (hasImplementationIntent(agent, taskText))
-    return { kind: "implementation" };
-  if (isReviewerStyleAgent(agent))
-    return { kind: "read-only" };
-  return taskHasReadOnlyDeliverable(taskTextWithoutScopedConstraints) ? { kind: "read-only" } : { kind: "unknown" };
-}
-export function expectsImplementationMutation(agent, task) {
-  return classifyTaskMutationIntent(agent, task).kind === "implementation";
-}
-const MAY_MUTATE_VERB_PATTERN = /\b(?:fix|implement|update|write|edit|modify|migrate|delete|remove|refactor|commit)\b/i;
-export function taskMayMutate(task) {
-  const taskText = stripPatterns(stripSeverityCompounds(stripFrameworkInstructions(task)), SCOPED_NO_EDIT_CONSTRAINT_PATTERNS);
-  const prohibitions = analyzeNoEditProhibitions(taskText);
-  if (prohibitions.blanket)
-    return false;
-  return MAY_MUTATE_VERB_PATTERN.test(stripPatterns(prohibitions.strippedText, READ_ONLY_DELIVERABLE_PATTERNS));
-}

package/extensions/dm-subagents/src/shared/post-exit-stdio-guard.js

@@ -1,68 +0,0 @@
-export function trySignalChild(child, signal) {
-  try {
-    return child.kill(signal);
-  } catch {
-    return false;
-  }
-}
-export function attachPostExitStdioGuard(child, options) {
-  const { idleMs, hardMs } = options;
-  let exited = false;
-  let stdoutEnded = false;
-  let stderrEnded = false;
-  let idleTimer;
-  let hardTimer;
-  const destroyUnendedStdio = () => {
-    if (!stdoutEnded) {
-      try {
-        child.stdout?.destroy();
-      } catch {}
-    }
-    if (!stderrEnded) {
-      try {
-        child.stderr?.destroy();
-      } catch {}
-    }
-  };
-  const clearTimers = () => {
-    if (idleTimer) {
-      clearTimeout(idleTimer);
-      idleTimer = undefined;
-    }
-    if (hardTimer) {
-      clearTimeout(hardTimer);
-      hardTimer = undefined;
-    }
-  };
-  const armIdleTimer = () => {
-    if (!exited)
-      return;
-    if (idleTimer)
-      clearTimeout(idleTimer);
-    idleTimer = setTimeout(destroyUnendedStdio, idleMs);
-    idleTimer.unref?.();
-  };
-  child.stdout?.on("data", armIdleTimer);
-  child.stderr?.on("data", armIdleTimer);
-  child.stdout?.on("end", () => {
-    stdoutEnded = true;
-    if (stdoutEnded && stderrEnded)
-      clearTimers();
-  });
-  child.stderr?.on("end", () => {
-    stderrEnded = true;
-    if (stdoutEnded && stderrEnded)
-      clearTimers();
-  });
-  child.on("exit", () => {
-    exited = true;
-    armIdleTimer();
-    if (hardTimer)
-      return;
-    hardTimer = setTimeout(destroyUnendedStdio, hardMs);
-    hardTimer.unref?.();
-  });
-  child.on("close", clearTimers);
-  child.on("error", clearTimers);
-  return clearTimers;
-}