@duckmind/dm-windows-x64 0.61.4 → 0.61.9

package/extensions/dm-subagents/src/runs/foreground/foreground-control.js

@@ -0,0 +1,133 @@
+import { registerLivePromptAudit, removeLivePromptAudit } from "./prompt-audit.js";
+function copyProgress(target, progress) {
+  if (!progress)
+    return;
+  target.sessionName = progress.sessionName;
+  target.currentActivityState = progress.activityState;
+  target.lastActivityAt = progress.lastActivityAt;
+  target.currentTool = progress.currentTool;
+  target.currentToolStartedAt = progress.currentToolStartedAt;
+  target.currentPath = progress.currentPath;
+  target.turnCount = progress.turnCount;
+  target.tokens = progress.tokens;
+  target.inputTokens = progress.inputTokens;
+  target.outputTokens = progress.outputTokens;
+  target.window = progress.window;
+  target.windowPeak = progress.windowPeak;
+  target.model = progress.model;
+  target.thinking = progress.thinking;
+  target.toolCount = progress.toolCount;
+}
+function syncCurrentChild(control, child) {
+  control.currentAgent = child.agent;
+  control.sessionName = child.sessionName;
+  control.currentIndex = child.index;
+  control.description = child.description;
+  control.currentActivityState = child.currentActivityState;
+  control.lastActivityAt = child.lastActivityAt;
+  control.currentTool = child.currentTool;
+  control.currentToolStartedAt = child.currentToolStartedAt;
+  control.currentPath = child.currentPath;
+  control.turnCount = child.turnCount;
+  control.tokens = child.tokens;
+  control.inputTokens = child.inputTokens;
+  control.outputTokens = child.outputTokens;
+  control.window = child.window;
+  control.windowPeak = child.windowPeak;
+  control.model = child.model;
+  control.thinking = child.thinking;
+  control.toolCount = child.toolCount;
+  control.interrupt = child.interrupt;
+  control.detach = child.detach;
+  control.updatedAt = child.updatedAt;
+}
+function clearCurrentChild(control) {
+  control.currentAgent = undefined;
+  control.sessionName = undefined;
+  control.currentIndex = undefined;
+  control.currentActivityState = undefined;
+  control.lastActivityAt = undefined;
+  control.currentTool = undefined;
+  control.currentToolStartedAt = undefined;
+  control.currentPath = undefined;
+  control.turnCount = undefined;
+  control.tokens = undefined;
+  control.inputTokens = undefined;
+  control.outputTokens = undefined;
+  control.window = undefined;
+  control.windowPeak = undefined;
+  control.model = undefined;
+  control.thinking = undefined;
+  control.toolCount = undefined;
+  control.interrupt = undefined;
+  control.detach = undefined;
+}
+export function retainForegroundSchedulingOwner(control) {
+  control.schedulingOwners = (control.schedulingOwners ?? 0) + 1;
+  control.updatedAt = Date.now();
+}
+export function settleForegroundSchedulingOwner(control) {
+  control.schedulingOwners = Math.max(0, (control.schedulingOwners ?? 0) - 1);
+  control.updatedAt = Date.now();
+}
+export function foregroundSchedulingSettled(control) {
+  return (control.schedulingOwners ?? 0) === 0;
+}
+export function beginForegroundChild(control, input) {
+  const now = Date.now();
+  const child = {
+    index: input.index,
+    agent: input.agent,
+    ...input.description ? { description: input.description } : {},
+    startedAt: now,
+    updatedAt: now,
+    ...input.model ? { model: input.model } : {},
+    ...input.thinking ? { thinking: input.thinking } : {}
+  };
+  child.interrupt = () => {
+    if (!input.interrupt())
+      return false;
+    child.currentActivityState = undefined;
+    child.updatedAt = Date.now();
+    syncCurrentChild(control, child);
+    return true;
+  };
+  if (input.detach) {
+    child.detach = () => {
+      if (!input.detach?.())
+        return false;
+      child.currentActivityState = undefined;
+      child.updatedAt = Date.now();
+      syncCurrentChild(control, child);
+      return true;
+    };
+  }
+  control.activeChildren ??= new Map;
+  control.activeChildren.set(input.index, child);
+  registerLivePromptAudit(control, input.index, input.authoredTask, input.effectivePrompt, {
+    ...input.cwd ? { cwd: input.cwd } : {},
+    ...input.outputPath ? { outputPath: input.outputPath } : {},
+    ...input.rerun ? { rerun: input.rerun } : {}
+  });
+  syncCurrentChild(control, child);
+}
+export function updateForegroundChild(control, index, progress) {
+  const child = control.activeChildren?.get(index);
+  if (!child)
+    return;
+  copyProgress(child, progress);
+  child.updatedAt = Date.now();
+  syncCurrentChild(control, child);
+}
+export function finishForegroundChild(control, index) {
+  removeLivePromptAudit(control, index);
+  control.activeChildren?.delete(index);
+  if (control.currentIndex === index) {
+    const next = [...control.activeChildren?.values() ?? []].sort((left, right) => right.updatedAt - left.updatedAt || left.index - right.index)[0];
+    if (next)
+      syncCurrentChild(control, next);
+    else
+      clearCurrentChild(control);
+  }
+  control.updatedAt = Date.now();
+}

package/extensions/dm-subagents/src/runs/foreground/foreground-history.js

@@ -0,0 +1,148 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { DIRS } from "../../shared/types.js";
+import { writePrivateAtomicJson } from "../../shared/atomic-json.js";
+import { utf8Tail } from "../../shared/utf8.js";
+import { validateAcceptanceInput } from "../shared/acceptance.js";
+export const MAX_REMEMBERED_FOREGROUND_RUNS = 50;
+const HISTORY_VERSION = 1;
+const MAX_INLINE_OUTPUT_BYTES = 64 * 1024;
+const MAX_RESUME_CONTRACT_BYTES = 64 * 1024;
+function historyPath(resultsDir) {
+  return path.join(resultsDir, "foreground-history.json");
+}
+function boundedTail(value) {
+  return utf8Tail(value, MAX_INLINE_OUTPUT_BYTES).text;
+}
+function compactChild(child) {
+  const outputPath = child.artifactPaths?.outputPath ?? child.savedOutputPath;
+  return {
+    agent: child.agent,
+    index: child.index,
+    ...child.sessionName ? { sessionName: child.sessionName } : {},
+    ...child.context ? { context: child.context } : {},
+    ...child.sessionFile ? { sessionFile: child.sessionFile } : {},
+    ...child.model ? { model: child.model } : {},
+    ...child.thinking ? { thinking: child.thinking } : {},
+    status: child.status,
+    ...child.activityState ? { activityState: child.activityState } : {},
+    ...child.lastActivityAt !== undefined ? { lastActivityAt: child.lastActivityAt } : {},
+    ...child.currentTool ? { currentTool: child.currentTool } : {},
+    ...child.currentToolStartedAt !== undefined ? { currentToolStartedAt: child.currentToolStartedAt } : {},
+    ...child.currentPath ? { currentPath: child.currentPath } : {},
+    ...child.turnCount !== undefined ? { turnCount: child.turnCount } : {},
+    ...child.tokens !== undefined ? { tokens: child.tokens } : {},
+    ...child.toolCount !== undefined ? { toolCount: child.toolCount } : {},
+    ...child.exitCode !== undefined ? { exitCode: child.exitCode } : {},
+    ...child.error ? { error: child.error } : {},
+    ...!outputPath && child.finalOutput ? { finalOutput: boundedTail(child.finalOutput) } : {},
+    ...child.outputState ? { outputState: child.outputState } : {},
+    ...child.outputMode ? { outputMode: child.outputMode } : {},
+    ...child.savedOutputPath ? { savedOutputPath: child.savedOutputPath } : {},
+    ...child.outputSaveError ? { outputSaveError: child.outputSaveError } : {},
+    ...child.artifactPaths ? { artifactPaths: child.artifactPaths } : {},
+    ...child.transcriptPath ? { transcriptPath: child.transcriptPath } : {},
+    ...child.transcriptError ? { transcriptError: child.transcriptError } : {},
+    ...child.acceptance ? { acceptance: child.acceptance } : {},
+    ...child.resumeContract ? { resumeContract: child.resumeContract } : {},
+    ...child.launchContractDigest ? { launchContractDigest: child.launchContractDigest } : {},
+    ...child.extensionBindings ? { extensionBindings: child.extensionBindings } : {},
+    ...child.capabilityCeiling ? { capabilityCeiling: child.capabilityCeiling } : {},
+    ...child.updatedAt !== undefined ? { updatedAt: child.updatedAt } : {}
+  };
+}
+function isRestorableForegroundStatus(status) {
+  return status === "completed" || status === "failed" || status === "paused" || status === "stopped";
+}
+function isRestorableResumeContract(value) {
+  if (value === undefined)
+    return true;
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  try {
+    if (Buffer.byteLength(JSON.stringify(value), "utf8") > MAX_RESUME_CONTRACT_BYTES)
+      return false;
+  } catch {
+    return false;
+  }
+  const contract = value;
+  if (Object.keys(contract).some((key) => !["outputSchema", "agentContract", "acceptance", "output", "outputMode"].includes(key)))
+    return false;
+  if (contract.outputSchema !== undefined && (!contract.outputSchema || typeof contract.outputSchema !== "object" || Array.isArray(contract.outputSchema)))
+    return false;
+  if (contract.agentContract !== undefined && (!contract.agentContract || typeof contract.agentContract !== "object" || Array.isArray(contract.agentContract) || contract.agentContract.version !== 1))
+    return false;
+  if (validateAcceptanceInput(contract.acceptance).length > 0)
+    return false;
+  if (contract.output !== undefined && typeof contract.output !== "string" && typeof contract.output !== "boolean")
+    return false;
+  return contract.outputMode === undefined || contract.outputMode === "inline" || contract.outputMode === "file-only";
+}
+function compactRun(run) {
+  if (!run.sessionId)
+    return;
+  if (run.children.length === 0 || !run.children.every((child) => isRestorableForegroundStatus(child.status) && isRestorableResumeContract(child.resumeContract)))
+    return;
+  return {
+    runId: run.runId,
+    mode: run.mode,
+    cwd: run.cwd,
+    sessionId: run.sessionId,
+    updatedAt: run.updatedAt,
+    children: run.children.map(compactChild)
+  };
+}
+function readIndex(resultsDir) {
+  const filePath = historyPath(resultsDir);
+  if (!fs.existsSync(filePath))
+    return { version: HISTORY_VERSION, runs: [] };
+  try {
+    const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      return { version: HISTORY_VERSION, runs: [] };
+    const record = parsed;
+    if (record.version !== HISTORY_VERSION || !Array.isArray(record.runs))
+      return { version: HISTORY_VERSION, runs: [] };
+    return { version: HISTORY_VERSION, runs: record.runs.filter(isRestorableRun) };
+  } catch {
+    return { version: HISTORY_VERSION, runs: [] };
+  }
+}
+function isRestorableRun(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const run = value;
+  return typeof run.runId === "string" && Boolean(run.runId) && (run.mode === "single" || run.mode === "parallel" || run.mode === "chain") && typeof run.cwd === "string" && Boolean(run.cwd) && typeof run.sessionId === "string" && Boolean(run.sessionId) && typeof run.updatedAt === "number" && Number.isFinite(run.updatedAt) && Array.isArray(run.children) && run.children.length > 0 && run.children.every((child) => Boolean(child && typeof child === "object" && !Array.isArray(child) && typeof child.agent === "string" && typeof child.index === "number" && isRestorableResumeContract(child.resumeContract) && isRestorableForegroundStatus(child.status)));
+}
+function sortAndBound(runs, limit) {
+  return [...runs].sort((left, right) => right.updatedAt - left.updatedAt).slice(0, limit);
+}
+export function persistForegroundRunHistory(state, options = {}) {
+  const resultsDir = options.resultsDir ?? DIRS.results;
+  const limit = options.limit ?? MAX_REMEMBERED_FOREGROUND_RUNS;
+  const existing = readIndex(resultsDir);
+  const merged = new Map(existing.runs.map((run) => [run.runId, run]));
+  for (const run of state.foregroundRuns?.values() ?? []) {
+    const compact = compactRun(run);
+    if (compact)
+      merged.set(compact.runId, compact);
+  }
+  const runs = sortAndBound([...merged.values()], limit);
+  writePrivateAtomicJson(historyPath(resultsDir), { version: HISTORY_VERSION, runs });
+}
+export function restoreForegroundRunHistory(state, options = {}) {
+  const sessionId = options.sessionId ?? state.currentSessionId;
+  if (!sessionId)
+    return 0;
+  const index = readIndex(options.resultsDir ?? DIRS.results);
+  const runs = sortAndBound(index.runs.filter((run) => run.sessionId === sessionId), options.limit ?? MAX_REMEMBERED_FOREGROUND_RUNS);
+  state.foregroundRuns ??= new Map;
+  let restored = 0;
+  for (const run of runs) {
+    if (state.foregroundRuns.has(run.runId))
+      continue;
+    state.foregroundRuns.set(run.runId, run);
+    restored += 1;
+  }
+  return restored;
+}

package/extensions/dm-subagents/src/runs/foreground/prompt-audit.js

@@ -0,0 +1,139 @@
+import { Agent } from "@duckmind/dm-agent-core";
+import { convertToLlm } from "@duckmind/dm-coding-agent";
+import { streamSimple } from "@duckmind/dm-ai/compat";
+import { agentStreamOptions } from "../../shared/agent-stream-options.js";
+const livePrompts = new WeakMap;
+function fullModelId(model) {
+  return `${model.provider}/${model.id}`;
+}
+function textContent(value) {
+  if (typeof value === "string")
+    return value;
+  if (!Array.isArray(value))
+    return "";
+  return value.map((item) => item && typeof item === "object" && item.type === "text" ? String(item.text ?? "") : "").join("");
+}
+function finalAssistantText(agent) {
+  for (let index = agent.state.messages.length - 1;index >= 0; index--) {
+    const message = agent.state.messages[index];
+    if (message && typeof message === "object" && message.role === "assistant") {
+      return textContent(message.content).trim();
+    }
+  }
+  return "";
+}
+async function resolveRewriteAuth(ctx, model) {
+  const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+  if (auth.ok === false)
+    throw new Error(`Prompt redo model auth failed for ${fullModelId(model)}: ${auth.error}`);
+  return {
+    ...auth.apiKey ? { apiKey: auth.apiKey } : {},
+    ...auth.headers ? { headers: auth.headers } : {},
+    ...auth.env ? { env: auth.env } : {}
+  };
+}
+export async function rewritePromptWithGuidance(input) {
+  const model = input.ctx.model;
+  if (!model)
+    throw new Error("Prompt redo needs the current session model to rewrite the authored task.");
+  const auth = await resolveRewriteAuth(input.ctx, model);
+  const registeredProvider = input.ctx.modelRegistry.getRegisteredProviderConfig?.(model.provider);
+  const baseStreamFn = input.streamFn ?? (registeredProvider?.streamSimple && registeredProvider.api === model.api ? registeredProvider.streamSimple : streamSimple);
+  const streamFn = (nextModel, context, streamOptions) => baseStreamFn(nextModel, context, {
+    ...streamOptions,
+    ...auth.apiKey ? { apiKey: auth.apiKey } : {},
+    env: auth.env || streamOptions?.env ? { ...auth.env ?? {}, ...streamOptions?.env ?? {} } : undefined,
+    headers: { ...streamOptions?.headers ?? {}, ...auth.headers ?? {} }
+  });
+  const ctxThinking = input.ctx.getThinkingLevel?.();
+  const agent = new Agent({
+    initialState: {
+      systemPrompt: [
+        "Rewrite one subagent authored task from Prompt Audit context.",
+        "Return only the revised authored task text.",
+        "Do not add Markdown fences, explanations, labels, or commentary.",
+        "Preserve the original intent unless the guidance explicitly changes it.",
+        "Do not include runtime additions unless they are needed as ordinary task context."
+      ].join(`
+`),
+      model,
+      thinkingLevel: ctxThinking ?? "off",
+      tools: []
+    },
+    convertToLlm,
+    ...agentStreamOptions(streamFn),
+    getApiKey: (providerName) => providerName === model.provider ? auth.apiKey : undefined,
+    toolExecution: "sequential"
+  });
+  const abort = () => agent.abort();
+  input.ctx.signal?.addEventListener("abort", abort, { once: true });
+  input.signal?.addEventListener("abort", abort, { once: true });
+  try {
+    await agent.prompt([
+      "Guidance from the human:",
+      input.guidance.trim(),
+      "",
+      "Authored task:",
+      input.authoredTask,
+      "",
+      "Runtime additions for context only:",
+      input.runtimeAdditions,
+      "",
+      "Final effective prompt for context only:",
+      input.finalEffectivePrompt
+    ].join(`
+`));
+  } finally {
+    input.ctx.signal?.removeEventListener("abort", abort);
+    input.signal?.removeEventListener("abort", abort);
+  }
+  const rewritten = finalAssistantText(agent);
+  if (!rewritten)
+    throw new Error("Prompt redo rewrite returned an empty prompt.");
+  return rewritten;
+}
+function runtimeAdditions(authoredTask, effectivePrompt) {
+  if (!authoredTask)
+    return effectivePrompt;
+  const authoredIndex = effectivePrompt.indexOf(authoredTask);
+  if (authoredIndex < 0)
+    return "(runtime additions unavailable)";
+  const before = effectivePrompt.slice(0, authoredIndex).trim();
+  const after = effectivePrompt.slice(authoredIndex + authoredTask.length).trim();
+  return [before, after].filter(Boolean).join(`
+
+`) || "(none)";
+}
+export function registerLivePromptAudit(control, index, authoredTask, effectivePrompt, metadata = {}) {
+  let prompts = livePrompts.get(control);
+  if (!prompts) {
+    prompts = new Map;
+    livePrompts.set(control, prompts);
+  }
+  prompts.set(index, {
+    authoredTask,
+    runtimeAdditions: runtimeAdditions(authoredTask, effectivePrompt),
+    finalEffectivePrompt: effectivePrompt,
+    ...metadata.cwd ? { cwd: metadata.cwd } : {},
+    ...metadata.outputPath ? { outputPath: metadata.outputPath } : {},
+    ...metadata.rerun ? { rerun: metadata.rerun } : {}
+  });
+}
+export function updateLiveEffectivePrompt(control, index, effectivePrompt) {
+  const prompt = livePrompts.get(control)?.get(index);
+  if (!prompt)
+    return;
+  prompt.finalEffectivePrompt = effectivePrompt;
+  prompt.runtimeAdditions = runtimeAdditions(prompt.authoredTask, effectivePrompt);
+}
+export function getLivePromptAudit(control, index) {
+  return livePrompts.get(control)?.get(index);
+}
+export function removeLivePromptAudit(control, index) {
+  const prompts = livePrompts.get(control);
+  if (!prompts)
+    return;
+  prompts.delete(index);
+  if (prompts.size === 0)
+    livePrompts.delete(control);
+}