@duckmind/dm-windows-x64 0.61.4 → 0.61.9

package/extensions/dm-subagents/src/runs/shared/parallel-utils.js

@@ -44,26 +44,43 @@ export class Semaphore {
     }
   }
 }
-export async function mapConcurrent(items, limit, fn, globalSemaphore) {
+export async function mapConcurrent(items, limit, fn, globalSemaphore, onSchedulingSettled) {
   const safeLimit = Math.max(1, Math.floor(limit) || 1);
   const results = new Array(items.length);
   let next = 0;
+  let liveWorkers = Math.min(safeLimit, items.length);
+  const notifySchedulingSettled = () => {
+    try {
+      onSchedulingSettled?.();
+    } catch {}
+  };
   async function worker(_workerIndex) {
-    while (next < items.length) {
-      const i = next++;
-      if (globalSemaphore) {
-        await globalSemaphore.acquire();
-        try {
-          results[i] = await fn(items[i], i);
-        } finally {
-          globalSemaphore.release();
+    try {
+      while (next < items.length) {
+        const i = next++;
+        if (!(i in items))
+          throw new Error(`Missing parallel item at index ${i}`);
+        const item = items[i];
+        if (globalSemaphore) {
+          await globalSemaphore.acquire();
+          try {
+            results[i] = await fn(item, i);
+          } finally {
+            globalSemaphore.release();
+          }
+        } else {
+          results[i] = await fn(item, i);
         }
-      } else {
-        results[i] = await fn(items[i], i);
       }
+    } finally {
+      liveWorkers--;
+      if (liveWorkers === 0)
+        notifySchedulingSettled();
     }
   }
-  await Promise.all(Array.from({ length: Math.min(safeLimit, items.length) }, (_, wi) => worker(wi)));
+  if (liveWorkers === 0)
+    notifySchedulingSettled();
+  await Promise.all(Array.from({ length: liveWorkers }, (_, wi) => worker(wi)));
   return results;
 }
 export function aggregateParallelOutputs(results, headerFormat = (i, agent) => `=== Parallel Task ${i + 1} (${agent}) ===`) {

package/extensions/dm-subagents/src/runs/shared/permissions.js

@@ -0,0 +1,108 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+export const PERMISSION_POLICY_ENV = "DM_SUBAGENT_PERMISSION_POLICY";
+export const PERMISSION_AUDIT_PATH_ENV = "DM_SUBAGENT_PERMISSION_AUDIT_PATH";
+const INTERNAL_TOOLS = new Set(["contact_supervisor", "intercom", "bg_wait", "subagent_wait", "structured_output"]);
+const DECISIONS = new Set(["allow", "ask", "deny"]);
+const MAX_POLICY_BYTES = 16 * 1024;
+const MAX_PREVIEW_BYTES = 2048;
+const SECRET_KEY = /(?:authorization|cookie|credential|password|secret|token|api[-_]?key)/i;
+const SECRET_VALUE = /\b(?:Bearer\s+\S+|(?:sk|ghp|github_pat|xox[baprs])[-_A-Za-z0-9]{8,})\b/gi;
+export function redactSecretValues(value) {
+  return value.replace(SECRET_VALUE, "[redacted]");
+}
+export function validatePermissionRules(value, label) {
+  if (value === undefined)
+    return;
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`${label} must be an object mapping tool names to allow, ask, or deny.`);
+  const result = {};
+  for (const [tool, decision] of Object.entries(value)) {
+    if (!tool.trim())
+      throw new Error(`${label} contains an empty tool name.`);
+    if (tool === "bash")
+      throw new Error(`${label}.bash is unsupported; dm-subagents leaves bash policy to dm-guard.`);
+    if (INTERNAL_TOOLS.has(tool))
+      throw new Error(`${label}.${tool} is reserved for child coordination and cannot be gated.`);
+    if (!DECISIONS.has(decision))
+      throw new Error(`${label}.${tool} must be allow, ask, or deny.`);
+    result[tool] = decision;
+  }
+  return Object.keys(result).length ? result : undefined;
+}
+export function validatePermissionConfig(value, label = "config.permissions") {
+  if (value === undefined)
+    return;
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`${label} must be an object.`);
+  const object = value;
+  const unknown = Object.keys(object).filter((key) => key !== "rules");
+  if (unknown.length)
+    throw new Error(`${label} has unsupported fields: ${unknown.join(", ")}.`);
+  return { rules: validatePermissionRules(object.rules, `${label}.rules`) };
+}
+export function resolvePermissionRules(globalConfig, agentRules) {
+  const merged = { ...globalConfig?.rules ?? {}, ...agentRules ?? {} };
+  for (const [tool, decision] of Object.entries(merged))
+    if (decision === "allow")
+      delete merged[tool];
+  return Object.keys(merged).length ? merged : undefined;
+}
+export function permissionDecision(rules, toolName) {
+  if (toolName === "bash" || INTERNAL_TOOLS.has(toolName))
+    return "allow";
+  return rules?.[toolName] ?? "allow";
+}
+export function encodePermissionRules(rules) {
+  if (!rules || Object.keys(rules).length === 0)
+    return;
+  const encoded = JSON.stringify(rules);
+  if (Buffer.byteLength(encoded, "utf-8") > MAX_POLICY_BYTES)
+    throw new Error("Resolved permission policy is too large.");
+  return encoded;
+}
+export function decodePermissionRules(encoded) {
+  if (!encoded?.trim())
+    return;
+  return validatePermissionRules(JSON.parse(encoded), PERMISSION_POLICY_ENV);
+}
+function redact(value, key = "", depth = 0) {
+  if (SECRET_KEY.test(key))
+    return "[redacted]";
+  if (depth >= 3)
+    return "[truncated]";
+  if (Array.isArray(value))
+    return value.slice(0, 10).map((item) => redact(item, "", depth + 1));
+  if (value && typeof value === "object")
+    return Object.fromEntries(Object.entries(value).slice(0, 20).map(([entryKey, entryValue]) => [entryKey, redact(entryValue, entryKey, depth + 1)]));
+  if (typeof value === "string") {
+    const redacted = redactSecretValues(value);
+    return redacted.length > 500 ? `${redacted.slice(0, 500)}…` : redacted;
+  }
+  return value;
+}
+export function permissionArgsPreview(input) {
+  const serialized = JSON.stringify(redact(input));
+  if (!serialized)
+    return "{}";
+  if (Buffer.byteLength(serialized, "utf-8") <= MAX_PREVIEW_BYTES)
+    return serialized;
+  const maxContentBytes = MAX_PREVIEW_BYTES - Buffer.byteLength("…", "utf-8");
+  let preview = "";
+  let previewBytes = 0;
+  for (const character of serialized) {
+    const characterBytes = Buffer.byteLength(character, "utf-8");
+    if (previewBytes + characterBytes > maxContentBytes)
+      break;
+    preview += character;
+    previewBytes += characterBytes;
+  }
+  return `${preview}…`;
+}
+export function appendPermissionAudit(filePath, record) {
+  if (!filePath)
+    return;
+  fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 448 });
+  fs.appendFileSync(filePath, `${JSON.stringify(record)}
+`, { encoding: "utf-8", mode: 384 });
+}

package/extensions/dm-subagents/src/runs/shared/process-signal.js

@@ -0,0 +1,13 @@
+export function formatProcessSignalError(signal) {
+  return `Subagent process terminated by signal ${signal}.`;
+}
+export function formatMidToolExitError(input) {
+  const terminal = [`exit ${input.exitCode ?? "unknown"}`, ...input.processSignal ? [`signal ${input.processSignal}`] : []].join(", ");
+  return `Subagent process exited during '${input.toolName}' tool execution (${terminal}) before the tool completed. Earlier assistant output is not a terminal result.`;
+}
+export function isOrdinaryToolForMidToolExit(toolName) {
+  return toolName !== "intercom" && toolName !== "contact_supervisor";
+}
+export function isUnexplainedProcessSignal(input) {
+  return Boolean(input.processSignal) && input.interrupted !== true && input.timedOut !== true && input.stopped !== true && input.turnBudgetExceeded !== true && input.forcedDrainAfterFinalSuccess !== true;
+}

package/extensions/dm-subagents/src/runs/shared/run-fanout-budget.js

@@ -0,0 +1,257 @@
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS, waitForFileSystemRetry } from "../../shared/file-system-retry.js";
+import {
+  TEMP_ROOT_DIR
+} from "../../shared/types.js";
+export const RUN_FANOUT_BUDGET_ENV = "DM_SUBAGENT_RUN_FANOUT_BUDGET";
+const RUN_FANOUT_ROOT = path.join(TEMP_ROOT_DIR, "run-fanout-budgets");
+
+export class RunFanoutLimitError extends Error {
+  rejection;
+  snapshot;
+  constructor(rejection) {
+    super(formatRunFanoutRejection(rejection));
+    this.name = "RunFanoutLimitError";
+    this.rejection = rejection;
+    this.snapshot = { used: rejection.used, limit: rejection.limit, remaining: rejection.remaining };
+  }
+}
+function safeRootRunId(rootRunId) {
+  return rootRunId.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 120) || randomUUID();
+}
+function parseManifest(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return;
+  const manifest = value;
+  if (manifest.version !== 1 || typeof manifest.rootRunId !== "string" || !manifest.rootRunId || !Number.isInteger(manifest.limit) || (manifest.limit ?? 0) <= 0 || typeof manifest.createdAt !== "number" || !Number.isFinite(manifest.createdAt))
+    return;
+  return manifest;
+}
+function readManifest(directory) {
+  let parsed;
+  try {
+    parsed = JSON.parse(fs.readFileSync(path.join(directory, "manifest.json"), "utf-8"));
+  } catch (error) {
+    throw new Error(`Run fan-out budget manifest is unreadable at '${directory}': ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const manifest = parseManifest(parsed);
+  if (!manifest)
+    throw new Error(`Run fan-out budget manifest is invalid at '${directory}'.`);
+  return manifest;
+}
+function validateDirectory(directory) {
+  let realDirectory;
+  let realRoot;
+  try {
+    realDirectory = fs.realpathSync(path.resolve(directory));
+    realRoot = fs.realpathSync(path.resolve(RUN_FANOUT_ROOT));
+  } catch (error) {
+    throw new Error(`Run fan-out budget directory is unavailable: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (realDirectory !== realRoot && !realDirectory.startsWith(`${realRoot}${path.sep}`)) {
+    throw new Error("Run fan-out budget directory resolves outside the managed budget root.");
+  }
+  return realDirectory;
+}
+export function createRunFanoutBudget(rootRunId, limit) {
+  if (!Number.isInteger(limit) || limit <= 0)
+    throw new Error("Run fan-out limit must be a positive integer.");
+  fs.mkdirSync(RUN_FANOUT_ROOT, { recursive: true, mode: 448 });
+  let directory;
+  do
+    directory = path.join(RUN_FANOUT_ROOT, `${safeRootRunId(rootRunId)}-${randomUUID()}`);
+  while (fs.existsSync(directory));
+  fs.mkdirSync(path.join(directory, "claims"), { recursive: true, mode: 448 });
+  const manifest = { version: 1, rootRunId, limit, createdAt: Date.now() };
+  fs.writeFileSync(path.join(directory, "manifest.json"), `${JSON.stringify(manifest)}
+`, { mode: 384, flag: "wx" });
+  return { version: 1, rootRunId, directory, limit };
+}
+export function validateRunFanoutBudgetDescriptor(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("Run fan-out budget descriptor is missing or invalid.");
+  const descriptor = value;
+  if (descriptor.version !== 1 || typeof descriptor.rootRunId !== "string" || !descriptor.rootRunId || typeof descriptor.directory !== "string" || !descriptor.directory || !Number.isInteger(descriptor.limit) || (descriptor.limit ?? 0) <= 0 || descriptor.parentPath !== undefined && typeof descriptor.parentPath !== "string") {
+    throw new Error("Run fan-out budget descriptor is invalid.");
+  }
+  const directory = validateDirectory(descriptor.directory);
+  const manifest = readManifest(directory);
+  if (manifest.rootRunId !== descriptor.rootRunId || manifest.limit !== descriptor.limit) {
+    throw new Error("Run fan-out budget descriptor does not match its manifest.");
+  }
+  return { version: 1, rootRunId: descriptor.rootRunId, directory, limit: descriptor.limit, ...descriptor.parentPath ? { parentPath: descriptor.parentPath } : {} };
+}
+export function writeRunFanoutBudgetDescriptor(asyncDir, descriptor) {
+  const valid = validateRunFanoutBudgetDescriptor(descriptor);
+  fs.mkdirSync(asyncDir, { recursive: true });
+  fs.writeFileSync(path.join(asyncDir, "run-fanout-budget.json"), `${JSON.stringify(valid)}
+`, { mode: 384 });
+}
+export function readRunFanoutBudgetDescriptor(asyncDir) {
+  if (!asyncDir)
+    return;
+  const descriptorPath = path.join(asyncDir, "run-fanout-budget.json");
+  if (!fs.existsSync(descriptorPath))
+    return;
+  try {
+    return validateRunFanoutBudgetDescriptor(JSON.parse(fs.readFileSync(descriptorPath, "utf-8")));
+  } catch (error) {
+    throw new Error(`Invalid persisted run fan-out budget '${descriptorPath}': ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+export function encodeRunFanoutBudgetDescriptor(descriptor) {
+  return Buffer.from(JSON.stringify(validateRunFanoutBudgetDescriptor(descriptor)), "utf-8").toString("base64url");
+}
+export function decodeRunFanoutBudgetDescriptor(encoded) {
+  if (!encoded)
+    return;
+  try {
+    return validateRunFanoutBudgetDescriptor(JSON.parse(Buffer.from(encoded, "base64url").toString("utf-8")));
+  } catch (error) {
+    throw new Error(`Invalid inherited run fan-out budget: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+const ADMISSION_LOCK_STALE_MS = 60000;
+function readAdmissionLockOwner(lockPath) {
+  try {
+    const owner = JSON.parse(fs.readFileSync(path.join(lockPath, "owner.json"), "utf-8"));
+    if (Number.isSafeInteger(owner.pid) && (owner.pid ?? 0) > 0 && typeof owner.token === "string" && owner.token)
+      return owner;
+  } catch {}
+  return;
+}
+function admissionLockIsStale(lockPath) {
+  const owner = readAdmissionLockOwner(lockPath);
+  if (owner) {
+    try {
+      process.kill(owner.pid, 0);
+      return false;
+    } catch (error) {
+      return error.code !== "EPERM";
+    }
+  }
+  try {
+    return Date.now() - fs.statSync(lockPath).mtimeMs > ADMISSION_LOCK_STALE_MS;
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return false;
+    throw error;
+  }
+}
+function withAdmissionLock(directory, operation) {
+  const lockPath = path.join(directory, "admission.lock");
+  const owner = { pid: process.pid, token: randomUUID() };
+  for (let attempt = 0;; attempt++) {
+    try {
+      fs.mkdirSync(lockPath, { mode: 448 });
+      try {
+        fs.writeFileSync(path.join(lockPath, "owner.json"), JSON.stringify(owner), { mode: 384 });
+      } catch (error) {
+        fs.rmSync(lockPath, { recursive: true, force: true });
+        throw error;
+      }
+      break;
+    } catch (error) {
+      if (error.code !== "EEXIST")
+        throw error;
+      if (admissionLockIsStale(lockPath)) {
+        const stalePath = path.join(directory, `admission.stale-${randomUUID()}`);
+        try {
+          fs.renameSync(lockPath, stalePath);
+          fs.rmSync(stalePath, { recursive: true, force: true });
+          continue;
+        } catch (reclaimError) {
+          if (reclaimError.code !== "ENOENT")
+            throw reclaimError;
+        }
+      }
+      const delay = DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS[attempt];
+      if (delay === undefined)
+        throw new Error(`Timed out acquiring run fan-out admission lock at '${directory}'.`);
+      waitForFileSystemRetry(delay);
+    }
+  }
+  try {
+    return operation();
+  } finally {
+    if (readAdmissionLockOwner(lockPath)?.token === owner.token)
+      fs.rmSync(lockPath, { recursive: true, force: true });
+  }
+}
+function claimCount(directory) {
+  const claimsDir = path.join(directory, "claims");
+  let entries;
+  try {
+    entries = fs.readdirSync(claimsDir, { withFileTypes: true });
+  } catch (error) {
+    throw new Error(`Run fan-out claims directory is unreadable at '${claimsDir}': ${error instanceof Error ? error.message : String(error)}`);
+  }
+  return entries.filter((entry) => /^\d{6}\.json$/.test(entry.name)).length;
+}
+export function getRunFanoutBudgetSnapshot(descriptor) {
+  const valid = validateRunFanoutBudgetDescriptor(descriptor);
+  const used = claimCount(valid.directory);
+  return { used, limit: valid.limit, remaining: Math.max(0, valid.limit - used) };
+}
+function qualifyRunFanoutPaths(descriptor, paths) {
+  const prefix = descriptor.parentPath?.trim();
+  return paths.map((item) => prefix ? `${prefix}/${item}` : item);
+}
+function commitRunFanoutBatch(descriptor, paths, commit) {
+  const valid = validateRunFanoutBudgetDescriptor(descriptor);
+  if (paths.length === 0)
+    return commit(getRunFanoutBudgetSnapshot(valid));
+  const qualified = qualifyRunFanoutPaths(valid, paths);
+  return withAdmissionLock(valid.directory, () => {
+    const before = getRunFanoutBudgetSnapshot(valid);
+    if (qualified.length > before.remaining) {
+      throw new RunFanoutLimitError({ code: "RUN_FANOUT_LIMIT", path: qualified[before.remaining] ?? qualified[0], requested: qualified.length, ...before });
+    }
+    const created = [];
+    try {
+      for (const claimPath of qualified) {
+        for (let slot = 0;slot < valid.limit; slot++) {
+          const slotPath = path.join(valid.directory, "claims", `${String(slot).padStart(6, "0")}.json`);
+          try {
+            const fd = fs.openSync(slotPath, "wx", 384);
+            created.push(slotPath);
+            try {
+              const claim = { version: 1, claimId: randomUUID(), path: claimPath, claimedAt: Date.now() };
+              fs.writeFileSync(fd, `${JSON.stringify(claim)}
+`, "utf-8");
+            } finally {
+              fs.closeSync(fd);
+            }
+            break;
+          } catch (error) {
+            if (error.code === "EEXIST")
+              continue;
+            throw error;
+          }
+        }
+      }
+      return commit(getRunFanoutBudgetSnapshot(valid));
+    } catch (error) {
+      for (const slotPath of created) {
+        try {
+          fs.unlinkSync(slotPath);
+        } catch {}
+      }
+      throw error;
+    }
+  });
+}
+export function claimRunFanoutBatch(descriptor, paths) {
+  return commitRunFanoutBatch(descriptor, paths, (snapshot) => snapshot);
+}
+export function claimRunFanoutBatchWithCommit(descriptor, paths, commit) {
+  return commitRunFanoutBatch(descriptor, paths, commit);
+}
+export function formatRunFanoutBudget(snapshot) {
+  return `Run fan-out: ${snapshot.used}/${snapshot.limit} used, ${snapshot.remaining} remaining`;
+}
+function formatRunFanoutRejection(rejection) {
+  return `Run fan-out limit reached at ${rejection.path} (${rejection.used}/${rejection.limit} used; ${rejection.requested} requested, ${rejection.remaining} remaining). No children from this admission group were started. Start a new top-level run or raise config.maxSubagentSpawnsPerRun.`;
+}

package/extensions/dm-subagents/src/runs/shared/run-history.js

@@ -1,29 +1,149 @@
+import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { getAgentDir } from "../../shared/utils.js";
+import { isUnexplainedProcessSignal } from "./process-signal.js";
 const ROTATE_READ_THRESHOLD = 1200;
 const ROTATE_KEEP = 1000;
+const PRIVATE_DIR_MODE = 448;
+const PRIVATE_FILE_MODE = 384;
+const REDACTED_TASK = "[redacted]";
+const historyFileStates = new Map;
 function getHistoryPath() {
   return path.join(getAgentDir(), "run-history.jsonl");
 }
-export function recordRun(agent, task, exitCode, durationMs) {
+function hashTask(task) {
+  return createHash("sha256").update(task).digest("hex");
+}
+function hardenHistoryStorage(historyPath) {
+  const historyDir = path.dirname(historyPath);
+  fs.mkdirSync(historyDir, { recursive: true, mode: PRIVATE_DIR_MODE });
+  try {
+    if ((fs.statSync(historyDir).mode & 511) !== PRIVATE_DIR_MODE)
+      fs.chmodSync(historyDir, PRIVATE_DIR_MODE);
+  } catch {}
+  try {
+    if ((fs.statSync(historyPath).mode & 511) !== PRIVATE_FILE_MODE)
+      fs.chmodSync(historyPath, PRIVATE_FILE_MODE);
+  } catch {}
+}
+function sanitizeHistoryLine(line) {
+  let value;
+  try {
+    value = JSON.parse(line);
+  } catch {
+    return;
+  }
+  if (!value || typeof value !== "object")
+    return;
+  const record = value;
+  const task = typeof record.task === "string" ? record.task : "";
+  const taskHash = typeof record.taskHash === "string" && record.taskHash ? record.taskHash : task && task !== REDACTED_TASK ? hashTask(task) : undefined;
+  return JSON.stringify({
+    ...record,
+    task: REDACTED_TASK,
+    ...taskHash ? { taskHash } : {}
+  });
+}
+function sanitizeHistoryLines(raw) {
+  const lines = [];
+  let changed = false;
+  for (const line of raw.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    const sanitized = sanitizeHistoryLine(trimmed);
+    if (!sanitized) {
+      changed = true;
+      continue;
+    }
+    if (sanitized !== trimmed)
+      changed = true;
+    lines.push(sanitized);
+  }
+  return { lines, changed };
+}
+function writePrivateHistory(historyPath, lines) {
+  fs.writeFileSync(historyPath, lines.length ? `${lines.join(`
+`)}
+` : "", { encoding: "utf-8", mode: PRIVATE_FILE_MODE });
+  try {
+    fs.chmodSync(historyPath, PRIVATE_FILE_MODE);
+  } catch {}
+}
+function rememberHistoryFile(historyPath, lineCount) {
+  const stat = fs.statSync(historyPath);
+  historyFileStates.set(historyPath, {
+    mtimeMs: stat.mtimeMs,
+    ctimeMs: stat.ctimeMs,
+    size: stat.size,
+    ino: stat.ino,
+    lineCount
+  });
+  if (historyFileStates.size > 8)
+    historyFileStates.delete(historyFileStates.keys().next().value);
+}
+function sanitizeHistoryFile(historyPath) {
+  let stat;
   try {
+    stat = fs.statSync(historyPath);
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return 0;
+    throw error;
+  }
+  const cached = historyFileStates.get(historyPath);
+  if (cached && cached.mtimeMs === stat.mtimeMs && cached.ctimeMs === stat.ctimeMs && cached.size === stat.size && cached.ino === stat.ino) {
+    return cached.lineCount;
+  }
+  const raw = fs.readFileSync(historyPath, "utf-8");
+  const { lines, changed } = sanitizeHistoryLines(raw);
+  if (changed)
+    writePrivateHistory(historyPath, lines);
+  rememberHistoryFile(historyPath, lines.length);
+  return lines.length;
+}
+function appendPrivateHistoryLine(historyPath, line) {
+  const fd = fs.openSync(historyPath, fs.constants.O_APPEND | fs.constants.O_CREAT | fs.constants.O_WRONLY, PRIVATE_FILE_MODE);
+  try {
+    fs.writeSync(fd, `${line}
+`);
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+export function recordRun(agent, task, exitCode, durationMs, terminal = {}) {
+  try {
+    const outcome = terminal.stopped ? "stopped" : terminal.interrupted ? "interrupted" : terminal.timedOut ? "timed_out" : exitCode !== 0 && isUnexplainedProcessSignal(terminal) ? "stopped" : exitCode === 0 ? "completed" : "failed";
     const entry = {
       agent,
-      task: task.slice(0, 200),
+      task: REDACTED_TASK,
+      taskHash: hashTask(task),
       ts: Math.floor(Date.now() / 1000),
       status: exitCode === 0 ? "ok" : "error",
+      outcome,
       duration: durationMs,
       ...exitCode !== 0 ? { exit: exitCode } : {}
     };
     const historyPath = getHistoryPath();
-    fs.mkdirSync(path.dirname(historyPath), { recursive: true });
-    fs.appendFileSync(historyPath, `${JSON.stringify(entry)}
-`);
+    hardenHistoryStorage(historyPath);
+    let lineCount;
+    try {
+      lineCount = sanitizeHistoryFile(historyPath);
+    } catch {}
+    appendPrivateHistoryLine(historyPath, JSON.stringify(entry));
+    if (lineCount === undefined)
+      historyFileStates.delete(historyPath);
+    else
+      rememberHistoryFile(historyPath, lineCount + 1);
   } catch {}
 }
 export function loadRunsForAgent(agent) {
   const historyPath = getHistoryPath();
+  try {
+    hardenHistoryStorage(historyPath);
+  } catch {}
   if (!fs.existsSync(historyPath))
     return [];
   let raw;
@@ -32,21 +152,21 @@ export function loadRunsForAgent(agent) {
   } catch {
     return [];
   }
-  let lines = raw.split(`
-`).map((line) => line.trim()).filter((line) => line.length > 0);
+  let { lines, changed } = sanitizeHistoryLines(raw);
   if (lines.length > ROTATE_READ_THRESHOLD) {
     lines = lines.slice(-ROTATE_KEEP);
-    try {
-      fs.writeFileSync(historyPath, `${lines.join(`
-`)}
-`, "utf-8");
-    } catch {}
+    changed = true;
   }
+  try {
+    if (changed)
+      writePrivateHistory(historyPath, lines);
+    rememberHistoryFile(historyPath, lines.length);
+  } catch {}
   return lines.map((line) => {
     try {
       return JSON.parse(line);
     } catch {
       return;
     }
-  }).filter((entry) => Boolean(entry) && entry.agent === agent).reverse();
+  }).filter((entry) => entry !== undefined && entry.agent === agent).reverse();
 }

package/extensions/dm-subagents/src/runs/shared/runtime-acknowledged-extensions.js

@@ -0,0 +1,62 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+export const RUNTIME_EXTENSION_ACK_EVENT = "subagent:acknowledge-extension";
+export const RUNTIME_EXTENSION_ACK_PATH_ENV = "DM_SUBAGENT_RUNTIME_ACKNOWLEDGED_EXTENSIONS";
+export const MAX_RUNTIME_ACKNOWLEDGED_EXTENSION_IDS = 32;
+export const MAX_RUNTIME_ACKNOWLEDGED_EXTENSION_ID_LENGTH = 128;
+export const MAX_RUNTIME_ACKNOWLEDGED_EXTENSION_FILE_BYTES = 64 * 1024;
+export function isRuntimeAcknowledgedExtensionId(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= MAX_RUNTIME_ACKNOWLEDGED_EXTENSION_ID_LENGTH && /^[A-Za-z0-9._:@+-]+$/.test(value) && !value.includes("..") && !value.includes("/") && !value.includes("\\");
+}
+export function projectRuntimeAcknowledgedExtensions(ids) {
+  const unique = [];
+  const seen = new Set;
+  for (const id of ids) {
+    if (!isRuntimeAcknowledgedExtensionId(id) || seen.has(id))
+      continue;
+    seen.add(id);
+    unique.push(id);
+  }
+  if (unique.length === 0)
+    return;
+  return {
+    version: 1,
+    source: "child-runtime",
+    ids: unique.slice(0, MAX_RUNTIME_ACKNOWLEDGED_EXTENSION_IDS),
+    omitted: Math.max(0, unique.length - MAX_RUNTIME_ACKNOWLEDGED_EXTENSION_IDS)
+  };
+}
+export function sanitizeRuntimeAcknowledgedExtensions(value) {
+  if (!value || typeof value !== "object")
+    return;
+  const raw = value;
+  if (raw.version !== 1 || raw.source !== "child-runtime" || !Array.isArray(raw.ids))
+    return;
+  const projected = projectRuntimeAcknowledgedExtensions(raw.ids);
+  if (!projected)
+    return;
+  const omitted = typeof raw.omitted === "number" && Number.isFinite(raw.omitted) ? Math.max(0, Math.floor(raw.omitted)) : 0;
+  return { ...projected, omitted: projected.omitted + omitted };
+}
+export function readRuntimeAcknowledgedExtensions(filePath) {
+  if (!filePath)
+    return;
+  try {
+    if (fs.statSync(filePath).size > MAX_RUNTIME_ACKNOWLEDGED_EXTENSION_FILE_BYTES)
+      return;
+    const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    return sanitizeRuntimeAcknowledgedExtensions(parsed);
+  } catch {
+    return;
+  }
+}
+export function writeRuntimeAcknowledgedExtensions(filePath, ids) {
+  const projection = projectRuntimeAcknowledgedExtensions(ids);
+  try {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    if (projection)
+      fs.writeFileSync(filePath, JSON.stringify(projection), { mode: 384 });
+    else
+      fs.rmSync(filePath, { force: true });
+  } catch {}
+}