@duckmind/dm-windows-x64 0.61.4 → 0.61.9

package/extensions/dm-subagents/src/missions/workflow-state.js

@@ -0,0 +1,245 @@
+import { execFileSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { writePrivateAtomicJson } from "../shared/atomic-json.js";
+import { DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS, isRetryableFileSystemError, waitForFileSystemRetry } from "../shared/file-system-retry.js";
+import { assertWorkflowJsonValue } from "../workflows/scripted-workflow.js";
+import { validateMissionId } from "./store.js";
+const STATE_KEY_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+const STATE_LOCK_STALE_MS = 60000;
+export const MISSION_STATE_MAX_BYTES = 256 * 1024;
+export function missionStatePath(location, missionId) {
+  return path.join(location.missionDir, validateMissionId(missionId), "state.json");
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function linuxProcessStartKey(pid) {
+  try {
+    const raw = fs.readFileSync(`/proc/${pid}/stat`, "utf-8");
+    const tail = raw.slice(raw.lastIndexOf(")") + 2).trim().split(/\s+/);
+    return tail[19] ? `linux:${tail[19]}` : undefined;
+  } catch {
+    return;
+  }
+}
+function psProcessStartKey(pid) {
+  try {
+    const raw = execFileSync("ps", ["-p", String(pid), "-o", "lstart="], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"], timeout: 1000 }).trim();
+    return raw ? `ps:${raw}` : undefined;
+  } catch {
+    return;
+  }
+}
+function windowsProcessStartKey(pid) {
+  try {
+    const raw = execFileSync("powershell.exe", ["-NoProfile", "-Command", `(Get-CimInstance Win32_Process -Filter "ProcessId=${pid}").CreationDate`], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"], timeout: 1000, windowsHide: true }).trim();
+    return raw ? `win:${raw}` : undefined;
+  } catch {
+    return;
+  }
+}
+function processStartKey(pid) {
+  if (process.platform === "linux")
+    return linuxProcessStartKey(pid) ?? psProcessStartKey(pid);
+  if (process.platform === "win32")
+    return windowsProcessStartKey(pid);
+  return;
+}
+const CURRENT_PROCESS_KEY = processStartKey(process.pid);
+function readStateLockOwner(lockPath) {
+  try {
+    const owner = JSON.parse(fs.readFileSync(path.join(lockPath, "owner.json"), "utf-8"));
+    if (Number.isSafeInteger(owner.pid) && owner.pid > 0 && typeof owner.token === "string" && owner.token && Number.isSafeInteger(owner.createdAt)) {
+      return {
+        pid: owner.pid,
+        token: owner.token,
+        createdAt: owner.createdAt,
+        ...typeof owner.processKey === "string" && owner.processKey ? { processKey: owner.processKey } : {}
+      };
+    }
+  } catch {
+    return;
+  }
+  return;
+}
+function stateLockIsStale(lockPath, now = Date.now()) {
+  const owner = readStateLockOwner(lockPath);
+  if (owner) {
+    if (!isProcessAlive(owner.pid))
+      return true;
+    if (owner.processKey) {
+      const currentProcessKey = owner.pid === process.pid ? CURRENT_PROCESS_KEY : processStartKey(owner.pid);
+      if (currentProcessKey)
+        return owner.processKey !== currentProcessKey;
+      if (owner.pid === process.pid)
+        return true;
+    }
+    return false;
+  }
+  try {
+    return now - fs.statSync(lockPath).mtimeMs > STATE_LOCK_STALE_MS;
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return false;
+    throw error;
+  }
+}
+function removeOwnedStateLock(lockPath, owner) {
+  const current = readStateLockOwner(lockPath);
+  if (current?.token !== owner.token)
+    return;
+  fs.rmSync(lockPath, { recursive: true, force: true });
+}
+function staleDirectoryExists(dirPath, now = Date.now()) {
+  try {
+    return now - fs.statSync(dirPath).mtimeMs > STATE_LOCK_STALE_MS;
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return false;
+    throw error;
+  }
+}
+function tryMakeDirectory(dirPath, mode) {
+  try {
+    fs.mkdirSync(dirPath, { mode });
+    return true;
+  } catch (error) {
+    if (error.code === "EEXIST")
+      return false;
+    throw error;
+  }
+}
+function waitForStateLock(delayMs, lockPath) {
+  if (delayMs === undefined)
+    throw new Error(`Timed out acquiring mission state lock '${lockPath}'.`);
+  waitForFileSystemRetry(delayMs);
+}
+function reclaimStaleStateLock(lockPath, reclaimPath) {
+  if (!stateLockIsStale(lockPath))
+    return false;
+  if (!tryMakeDirectory(reclaimPath, 448))
+    return false;
+  try {
+    if (!stateLockIsStale(lockPath))
+      return false;
+    fs.rmSync(lockPath, { recursive: true, force: true });
+    return true;
+  } finally {
+    fs.rmSync(reclaimPath, { recursive: true, force: true });
+  }
+}
+function withStateFileLock(filePath, operation) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const lockPath = `${filePath}.lock`;
+  const reclaimPath = `${lockPath}.reclaim`;
+  let owner;
+  for (let attempt = 0;; attempt++) {
+    if (fs.existsSync(reclaimPath)) {
+      if (staleDirectoryExists(reclaimPath)) {
+        fs.rmSync(reclaimPath, { recursive: true, force: true });
+        continue;
+      }
+      waitForStateLock(DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS[attempt], lockPath);
+      continue;
+    }
+    let acquired = false;
+    try {
+      acquired = tryMakeDirectory(lockPath, 448);
+    } catch (error) {
+      if (isRetryableFileSystemError(error)) {
+        waitForStateLock(DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS[attempt], lockPath);
+        continue;
+      }
+      throw new Error(`Failed to acquire mission state lock '${lockPath}': ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!acquired) {
+      if (reclaimStaleStateLock(lockPath, reclaimPath))
+        continue;
+      waitForStateLock(DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS[attempt], lockPath);
+      continue;
+    }
+    owner = { pid: process.pid, token: randomUUID(), createdAt: Date.now(), ...CURRENT_PROCESS_KEY ? { processKey: CURRENT_PROCESS_KEY } : {} };
+    try {
+      fs.writeFileSync(path.join(lockPath, "owner.json"), JSON.stringify(owner), { encoding: "utf-8", mode: 384 });
+    } catch (error) {
+      fs.rmSync(lockPath, { recursive: true, force: true });
+      owner = undefined;
+      throw error;
+    }
+    break;
+  }
+  try {
+    return operation();
+  } finally {
+    if (owner)
+      removeOwnedStateLock(lockPath, owner);
+  }
+}
+function validateStateKey(value) {
+  if (typeof value !== "string" || !STATE_KEY_PATTERN.test(value)) {
+    throw new Error("state key must be 1-128 characters using letters, numbers, '.', '_' or '-', and start with a letter or number.");
+  }
+  return value;
+}
+export function createMissionWorkflowState(location, missionId) {
+  const filePath = missionStatePath(location, missionId);
+  let loaded = false;
+  let values = Object.create(null);
+  const readStateFile = () => {
+    let raw;
+    try {
+      raw = fs.readFileSync(filePath, "utf-8");
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return Object.create(null);
+      throw new Error(`Failed to read mission state '${filePath}': ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const bytes = Buffer.byteLength(raw);
+    if (bytes > MISSION_STATE_MAX_BYTES)
+      throw new Error(`Mission state file '${filePath}' exceeds the 256 KiB limit (${bytes} bytes).`);
+    try {
+      const parsed = JSON.parse(raw);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        throw new Error("root must be a JSON object");
+      assertWorkflowJsonValue(parsed, "mission state");
+      return Object.assign(Object.create(null), parsed);
+    } catch (error) {
+      throw new Error(`Invalid mission state file '${filePath}': ${error instanceof Error ? error.message : String(error)}`);
+    }
+  };
+  const load = () => {
+    if (loaded)
+      return values;
+    values = readStateFile();
+    loaded = true;
+    return values;
+  };
+  return {
+    path: filePath,
+    get(key) {
+      const validKey = validateStateKey(key);
+      const current = load();
+      return Object.hasOwn(current, validKey) ? current[validKey] : undefined;
+    },
+    set(key, value) {
+      const validKey = validateStateKey(key);
+      assertWorkflowJsonValue(value, `state.set('${validKey}') value`);
+      withStateFileLock(filePath, () => {
+        const next = Object.assign(Object.create(null), readStateFile(), { [validKey]: value });
+        const bytes = Buffer.byteLength(JSON.stringify(next, null, 2));
+        if (bytes > MISSION_STATE_MAX_BYTES)
+          throw new Error(`Mission state exceeds the 256 KiB limit (${bytes} bytes; maximum ${MISSION_STATE_MAX_BYTES} bytes).`);
+        writePrivateAtomicJson(filePath, next);
+        values = next;
+        loaded = true;
+      });
+    }
+  };
+}

package/extensions/dm-subagents/src/policy/authority.js

@@ -0,0 +1,37 @@
+export const AUTHORITY_ACTIONS = [
+  "discardWorktree",
+  "destructiveCleanup",
+  "spawnBudgetGrant",
+  "scheduleCreate",
+  "stopRun",
+  "steerRun"
+];
+const DEFAULT_AUTHORITY_POLICY = {
+  discardWorktree: "confirm",
+  destructiveCleanup: "confirm",
+  spawnBudgetGrant: "confirm",
+  scheduleCreate: "auto",
+  stopRun: "auto",
+  steerRun: "auto"
+};
+export function resolveAuthorityDecision(input) {
+  return input.policy?.[input.action] ?? DEFAULT_AUTHORITY_POLICY[input.action];
+}
+export function validateAuthorityPolicy(value, label = "config.authorityPolicy") {
+  if (value === undefined)
+    return;
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be a JSON object`);
+  }
+  const policy = value;
+  const allowedActions = new Set(AUTHORITY_ACTIONS);
+  for (const [action, decision] of Object.entries(policy)) {
+    if (!allowedActions.has(action)) {
+      throw new Error(`${label}.${action} is unknown; expected one of ${AUTHORITY_ACTIONS.join(", ")}`);
+    }
+    if (decision !== "auto" && decision !== "confirm" && decision !== "forbid") {
+      throw new Error(`${label}.${action} must be "auto", "confirm", or "forbid"`);
+    }
+  }
+  return policy;
+}

package/extensions/dm-subagents/src/profiles/profiles.js

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { getPiSpawnCommand } from "../runs/shared/dm-spawn.js";
 import { findModelInfo, getSupportedThinkingLevels, splitKnownThinkingSuffix, toModelInfo } from "../shared/model-info.js";
 import { getAgentDir } from "../shared/utils.js";
 export const DEFAULT_PROVIDER_MODELS_MAX_AGE_DAYS = 7;
@@ -48,10 +49,23 @@ function validateSubagentProfile(filePath, parsed) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
       throw new Error(`Profile '${filePath}' has invalid override '${name}'; expected an object.`);
     }
-    const model = value.model;
+    const override = value;
+    const model = override.model;
     if (model !== undefined && typeof model !== "string") {
       throw new Error(`Profile '${filePath}' has invalid model for '${name}'; expected a string.`);
     }
+    const thinking = override.thinking;
+    if (thinking !== undefined && thinking !== false && typeof thinking !== "string") {
+      throw new Error(`Profile '${filePath}' has invalid thinking for '${name}'; expected a string or false.`);
+    }
+    const fallbackModels = override.fallbackModels;
+    if (fallbackModels !== undefined && fallbackModels !== false && (!Array.isArray(fallbackModels) || fallbackModels.some((item) => typeof item !== "string"))) {
+      throw new Error(`Profile '${filePath}' has invalid fallbackModels for '${name}'; expected an array of strings or false.`);
+    }
+  }
+  const disableBuiltins = subagents.disableBuiltins;
+  if (disableBuiltins !== undefined && typeof disableBuiltins !== "boolean") {
+    throw new Error(`Profile '${filePath}' has invalid subagents.disableBuiltins; expected a boolean.`);
   }
   return parsed;
 }
@@ -137,7 +151,7 @@ function agentsForRoleTier(roleTier) {
   if (roleTier === "cheap")
     return ["scout", "delegate"];
   if (roleTier === "medium")
-    return ["planner", "context-builder", "researcher"];
+    return ["researcher", "reviewer"];
   return ["worker", "reviewer", "oracle"];
 }
 function classifyModel(input, context) {
@@ -192,11 +206,12 @@ function resolveProbeStatus(text, timedOut) {
     return "unavailable";
   return "error";
 }
-async function probeModel(pi, ctx, fullId) {
-  if (typeof pi.exec !== "function") {
-    return { status: "skipped", message: "DM exec is unavailable in this runtime." };
+async function probeModel(dm, fullId) {
+  if (typeof dm.exec !== "function") {
+    return { status: "skipped", message: "dm.exec is unavailable in this runtime." };
   }
-  const result = await pi.exec("dm", ["-p", "--model", fullId, "--no-tools", 'Reply with exactly "OK".'], {
+  const spawnSpec = getPiSpawnCommand(["-p", "--model", fullId, "--no-tools", 'Reply with exactly "OK".']);
+  const result = await dm.exec(spawnSpec.command, spawnSpec.args, {
     cwd: os.tmpdir(),
     timeout: 45000
   });
@@ -250,14 +265,12 @@ function dominatesModel(a, b) {
 function filterDominatedModels(models) {
   return models.filter((candidate, index) => !models.some((other, otherIndex) => otherIndex !== index && dominatesModel(other, candidate)));
 }
-function buildProfileFile(kind, models) {
+function buildProfileFile(models) {
   return {
     subagents: {
       agentOverrides: {
         scout: { model: models.cheap },
         delegate: { model: models.cheap },
-        planner: { model: models.medium },
-        "context-builder": { model: models.medium },
         researcher: { model: models.medium },
         worker: { model: models.strong },
         reviewer: { model: models.strong },
@@ -319,7 +332,12 @@ export function applySubagentProfile(name) {
   const { filePath, profile } = readSubagentProfile(name);
   const settingsPath = getUserSettingsPath();
   const settings = readSettingsFile(settingsPath);
-  settings.subagents = profile.subagents;
+  const existing = settings.subagents && typeof settings.subagents === "object" && !Array.isArray(settings.subagents) ? settings.subagents : {};
+  settings.subagents = {
+    ...existing,
+    ...profile.subagents,
+    agentOverrides: profile.subagents.agentOverrides
+  };
   writeJsonFile(settingsPath, settings);
   return { filePath, settingsPath };
 }
@@ -336,7 +354,7 @@ export function isProviderModelCatalogStale(catalog, maxAgeDays = DEFAULT_PROVID
   const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1000;
   return Date.now() - refreshedAt > maxAgeMs;
 }
-export async function refreshProviderModelCatalog(pi, ctx, provider, options = {}) {
+export async function refreshProviderModelCatalog(dm, ctx, provider, options = {}) {
   const normalizedProvider = normalizeProviderName(provider);
   const maxAgeDays = options.maxAgeDays ?? DEFAULT_PROVIDER_MODELS_MAX_AGE_DAYS;
   const filePath = getProviderModelsPath(normalizedProvider);
@@ -354,7 +372,7 @@ export async function refreshProviderModelCatalog(pi, ctx, provider, options = {
   for (const rawModel of availableModels) {
     const modelRecord = rawModel;
     const fullId = `${modelRecord.provider}/${modelRecord.id}`;
-    const probe = options.probe === false ? { status: "skipped", message: "Live probing disabled." } : await probeModel(pi, ctx, fullId);
+    const probe = options.probe === false ? { status: "skipped", message: "Live probing disabled." } : await probeModel(dm, fullId);
     observedModels.push({ rawModel, modelRecord, fullId, probe });
   }
   const classificationContext = buildClassificationContext(observedModels.map(({ modelRecord }) => ({
@@ -409,9 +427,9 @@ export async function refreshProviderModelCatalog(pi, ctx, provider, options = {
   writeJsonFile(filePath, catalog);
   return { filePath, catalog, reused: false, heuristicFallbackCount: countHeuristicFallbackModels(catalog) };
 }
-export async function generateProfilesForProvider(pi, ctx, provider, options = {}) {
+export async function generateProfilesForProvider(dm, ctx, provider, options = {}) {
   const normalizedProvider = normalizeProviderName(provider);
-  const { filePath: catalogPath, catalog, heuristicFallbackCount } = await refreshProviderModelCatalog(pi, ctx, normalizedProvider, {
+  const { filePath: catalogPath, catalog, heuristicFallbackCount } = await refreshProviderModelCatalog(dm, ctx, normalizedProvider, {
     maxAgeDays: options.maxAgeDays,
     force: options.forceRefresh,
     probe: options.probe
@@ -426,13 +444,13 @@ export async function generateProfilesForProvider(pi, ctx, provider, options = {
   const dir = ensureSubagentProfilesDir();
   const quotaPath = path.join(dir, `${normalizedProvider}.quota.json`);
   const qualityPath = path.join(dir, `${normalizedProvider}.quality.json`);
-  writeJsonFile(quotaPath, buildProfileFile("quota", quotaModels));
-  writeJsonFile(qualityPath, buildProfileFile("quality", qualityModels));
+  writeJsonFile(quotaPath, buildProfileFile(quotaModels));
+  writeJsonFile(qualityPath, buildProfileFile(qualityModels));
   const selectedModels = new Set([...Object.values(quotaModels), ...Object.values(qualityModels)]);
   const selectedHeuristicFallbackCount = profileModels.filter((model) => selectedModels.has(model.fullId) && modelUsesHeuristicClassification(model)).length;
   return { quotaPath, qualityPath, catalogPath, quotaModels, qualityModels, heuristicFallbackCount, selectedHeuristicFallbackCount };
 }
-export async function checkSubagentProfile(pi, ctx, name) {
+export async function checkSubagentProfile(dm, ctx, name) {
   const { filePath, profile } = readSubagentProfile(name);
   const availableModels = ctx.modelRegistry.getAvailable().map(toModelInfo);
   const entries = Object.entries(profile.subagents.agentOverrides).filter(([, value]) => typeof value?.model === "string" && value.model.trim()).map(([agent, value]) => ({ agent, model: value.model.trim() }));
@@ -444,7 +462,7 @@ export async function checkSubagentProfile(pi, ctx, name) {
     const probeModelId = modelInfo ? `${modelInfo.fullId}${thinkingSuffix}` : entry.model;
     let probe = probeCache.get(probeModelId);
     if (!probe) {
-      probe = await probeModel(pi, ctx, probeModelId);
+      probe = await probeModel(dm, probeModelId);
       probeCache.set(probeModelId, probe);
     }
     results.push({