@duckmind/dm-windows-x64 0.61.4 → 0.61.9

package/extensions/dm-subagents/src/missions/goal-driver.js

@@ -0,0 +1,149 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { listMissions, readMission, updateMission } from "./store.js";
+import { missionStatePath } from "./workflow-state.js";
+const TERMINAL_MISSION_STATUSES = new Set(["completed", "failed", "cancelled"]);
+const ACTIVE_RUN_STATUSES = new Set(["queued", "running", "active"]);
+const MAX_ACTION_LENGTH = 180;
+function bounded(value) {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  return normalized.length > MAX_ACTION_LENGTH ? `${normalized.slice(0, MAX_ACTION_LENGTH - 1)}…` : normalized;
+}
+function tokenUsage(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return;
+  const total = value.total;
+  return Number.isSafeInteger(total) && total >= 0 ? total : undefined;
+}
+function readLinkedRun(run) {
+  if (!run.asyncDir)
+    return run;
+  const statusPath = path.join(run.asyncDir, "status.json");
+  if (!fs.existsSync(statusPath))
+    return run;
+  const status = JSON.parse(fs.readFileSync(statusPath, "utf-8"));
+  if (typeof status.state !== "string" || !status.state.trim())
+    throw new Error(`Linked run status '${statusPath}' is missing state`);
+  const tokens = tokenUsage(status.totalTokens) ?? (Array.isArray(status.steps) ? status.steps.reduce((total, step) => {
+    if (!step || typeof step !== "object")
+      return total;
+    return total + (tokenUsage(step.tokens) ?? 0);
+  }, 0) : undefined);
+  return {
+    ...run,
+    status: status.state,
+    ...!ACTIVE_RUN_STATUSES.has(status.state) && !run.completedAt ? { completedAt: new Date().toISOString() } : {},
+    ...tokens !== undefined ? { usage: { tokens } } : {}
+  };
+}
+function refreshGoalMission(location, record) {
+  const runs = record.runs.map(readLinkedRun);
+  const changed = runs.some((run, index) => JSON.stringify(run) !== JSON.stringify(record.runs[index]));
+  if (!changed)
+    return record;
+  const active = runs.some((run) => run.status && ACTIVE_RUN_STATUSES.has(run.status));
+  return updateMission(location, record.id, {
+    status: active ? "active" : record.goal ? "active" : record.status,
+    addRuns: runs
+  });
+}
+function readyActionFromValue(value, pathLabel = "state", depth = 0) {
+  if (depth > 8 || !value || typeof value !== "object")
+    return;
+  if (Array.isArray(value)) {
+    for (let index = 0;index < value.length; index += 1) {
+      const found = readyActionFromValue(value[index], `${pathLabel}[${index}]`, depth + 1);
+      if (found)
+        return found;
+    }
+    return;
+  }
+  const input = value;
+  for (const key of ["nextReadyAction", "nextAction"]) {
+    if (typeof input[key] === "string" && input[key].trim())
+      return bounded(input[key]);
+  }
+  if (input.status === "ready") {
+    for (const key of ["action", "task", "title", "summary"]) {
+      if (typeof input[key] === "string" && input[key].trim())
+        return bounded(input[key]);
+    }
+    return `Continue ready mission state at ${pathLabel}`;
+  }
+  for (const [key, child] of Object.entries(input)) {
+    const found = readyActionFromValue(child, `${pathLabel}.${key}`, depth + 1);
+    if (found)
+      return found;
+  }
+  return;
+}
+function missionStateAction(location, record) {
+  const statePath = missionStatePath(location, record.id);
+  if (fs.existsSync(statePath)) {
+    const action = readyActionFromValue(JSON.parse(fs.readFileSync(statePath, "utf-8")));
+    if (action)
+      return action;
+  }
+  const decision = record.decisions.find((item) => item.status === "open");
+  if (decision)
+    return bounded(decision.recommendation ?? `Resolve decision: ${decision.title}`);
+  return;
+}
+function retainedResumeTarget(record, retainedChildren) {
+  const latestRun = record.runs.at(-1);
+  if (!latestRun)
+    return;
+  return retainedChildren.find((child) => child.resumability.state === "resumable" && (child.runId === latestRun.runId || child.parentRunId === latestRun.runId));
+}
+function nextReadyAction(location, record, retainedChildren) {
+  const stateAction = missionStateAction(location, record);
+  const latestRun = record.runs.at(-1);
+  const action = stateAction ?? (latestRun?.status === "failed" || latestRun?.status === "paused" ? `Inspect linked run ${latestRun.runId} and continue the mission` : `Continue objective: ${record.objective}`);
+  const retained = retainedResumeTarget(record, retainedChildren);
+  return retained ? `Resume retained child ${retained.runId} (${retained.agent}) for: ${bounded(action)}` : bounded(action);
+}
+export function collectGoalContinuationNotices(input) {
+  const notices = [];
+  const seen = new Set;
+  for (const listed of listMissions(input.location).records) {
+    if (listed.ownerSessionId !== input.ownerSessionId || !listed.goal || TERMINAL_MISSION_STATUSES.has(listed.status))
+      continue;
+    let record = refreshGoalMission(input.location, readMission(input.location, listed.id));
+    if (!record.goal || record.goal.status !== "active" || !record.budget)
+      continue;
+    if ((record.usage?.tokens ?? 0) >= record.budget.tokens) {
+      record = updateMission(input.location, record.id, { usage: record.usage ?? { tokens: 0 } });
+      if (record.goal?.status === "budget-exhausted")
+        continue;
+    }
+    if (record.runs.some((run) => run.status && ACTIVE_RUN_STATUSES.has(run.status)))
+      continue;
+    if (seen.has(record.id) || !record.budget)
+      continue;
+    seen.add(record.id);
+    const budget = record.budget.tokens;
+    const used = record.usage?.tokens ?? 0;
+    const remaining = Math.max(0, budget - used);
+    const message = [
+      `Goal mission needs attention: ${bounded(record.title)}`,
+      `Mission: ${record.id}`,
+      `Remaining budget: ${remaining} tokens (${used}/${budget} used)`,
+      `Next ready action: ${nextReadyAction(input.location, record, input.retainedChildren)}`
+    ].join(`
+`);
+    notices.push({
+      missionId: record.id,
+      message,
+      event: {
+        type: "needs_attention",
+        to: "needs_attention",
+        ts: input.now ?? Date.now(),
+        runId: `goal-${record.id}-turn-${input.turnId}`,
+        agent: "goal mission",
+        message,
+        reason: "idle"
+      }
+    });
+  }
+  return notices;
+}

package/extensions/dm-subagents/src/missions/lifecycle.js

@@ -0,0 +1,331 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { createHash } from "node:crypto";
+import { writePrivateAtomicJson } from "../shared/atomic-json.js";
+import { PROMPT_REDACTED } from "../shared/utils.js";
+import { validateMissionLaunch } from "./actions.js";
+import { createMission, MissionNotFoundError, missionRecordPath, readMission, resolveMissionStoreLocation, updateMission, validateMissionId } from "./store.js";
+export const MISSION_BINDING_FILE = "mission.json";
+function workflowObjective(params) {
+  const objective = params.task?.trim() || params.tasks?.find((task) => task.task?.trim())?.task?.trim() || params.chain?.find((step) => step.task?.trim())?.task?.trim();
+  if (objective)
+    return objective;
+  for (const step of params.chain ?? []) {
+    const parallel = Array.isArray(step.parallel) ? step.parallel : step.parallel ? [step.parallel] : [];
+    const task = parallel.find((child) => child.task?.trim())?.task?.trim();
+    if (task)
+      return task;
+  }
+  return;
+}
+export function prepareMissionLaunch(input) {
+  const hasMissionId = input.params.missionId !== undefined;
+  if (hasMissionId && input.params.mission !== undefined)
+    throw new Error("Use missionId or mission, not both");
+  if (input.params.mission === false)
+    return;
+  const objective = workflowObjective(input.params);
+  const missionsEnabled = input.config?.enabled !== false;
+  const shouldCreate = input.params.mission !== undefined || missionsEnabled && objective !== undefined;
+  if (!hasMissionId && !shouldCreate)
+    return;
+  const location = resolveMissionStoreLocation({ projectRoot: input.projectRoot, ...input.config ? { config: input.config } : {} });
+  if (hasMissionId) {
+    const missionId = validateMissionId(input.params.missionId);
+    readMission(location, missionId);
+    updateMission(location, missionId, { status: "active" });
+    return { missionId, location, autoCreated: false, announceInContent: true };
+  }
+  const mission = input.params.mission !== undefined ? validateMissionLaunch(input.params.mission) : undefined;
+  const promptDerivedObjective = mission?.objective ?? (mission ? mission.title : objective ? PROMPT_REDACTED : undefined);
+  const title = mission?.title || PROMPT_REDACTED;
+  const record = createMission(location, {
+    title,
+    objective: promptDerivedObjective || title,
+    ...mission?.goal === true ? { goal: true } : {},
+    ...mission?.budget ? { budget: mission.budget } : {},
+    status: "active",
+    ...mission?.labels ? { labels: mission.labels } : {},
+    ...input.ownerSessionId ? { ownerSessionId: input.ownerSessionId } : {}
+  }, new Date, input.config?.retainTerminal);
+  return { missionId: record.id, location, autoCreated: true, announceInContent: true };
+}
+function toolResultIsError(result) {
+  return "isError" in result && result.isError === true;
+}
+function missionRunModeForResult(mode) {
+  return mode === "management" ? "external" : mode;
+}
+function runStatusForResult(result) {
+  if (result.details.asyncDir)
+    return "active";
+  if (result.details.results.some((child) => child.interrupted || child.detached))
+    return "paused";
+  if (toolResultIsError(result) || result.details.results.some((child) => child.exitCode !== 0))
+    return "failed";
+  return "completed";
+}
+function missionStatusForRun(record, runId, runStatus) {
+  if (record.status === "completed" || record.status === "failed" || record.status === "cancelled")
+    return record.status;
+  if (runStatus === "active" || runStatus === "queued" || runStatus === "running")
+    return "active";
+  if (record.goal)
+    return "active";
+  if (runStatus === "paused")
+    return "waiting";
+  const otherActive = record.runs.some((run) => run.runId !== runId && (run.status === "active" || run.status === "queued" || run.status === "running"));
+  if (otherActive)
+    return "active";
+  if (runStatus === "completed" || runStatus === "complete")
+    return "completed";
+  if (runStatus === "stopped" || runStatus === "rejected" || runStatus === "cancelled")
+    return "cancelled";
+  return "failed";
+}
+function usageForResult(result) {
+  const tokens = result.details.results.reduce((total, child) => total + child.usage.input + child.usage.output, 0);
+  return tokens > 0 ? { tokens } : undefined;
+}
+function usageFromUnknown(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return;
+  const total = value.total;
+  return Number.isSafeInteger(total) && total >= 0 ? { tokens: total } : undefined;
+}
+function artifactsForResult(result) {
+  const artifacts = [];
+  if (result.details.asyncDir) {
+    artifacts.push({ kind: "status", path: path.join(result.details.asyncDir, "status.json") }, { kind: "other", path: path.join(result.details.asyncDir, "events.jsonl"), description: "Lifecycle events" });
+  }
+  for (const child of result.details.results) {
+    if (child.artifactPaths?.outputPath)
+      artifacts.push({ kind: "output", path: child.artifactPaths.outputPath });
+    if (child.savedOutputPath)
+      artifacts.push({ kind: "output", path: child.savedOutputPath });
+    if (child.transcriptPath)
+      artifacts.push({ kind: "other", path: child.transcriptPath, description: "Child transcript" });
+    if (child.structuredOutputPath)
+      artifacts.push({ kind: "output", path: child.structuredOutputPath, description: "Structured output" });
+  }
+  if (result.details.parallelHandoff?.path)
+    artifacts.push({ kind: "manifest", path: result.details.parallelHandoff.path });
+  return artifacts;
+}
+function firstText(result) {
+  const text = result.content.find((item) => item.type === "text")?.text.trim();
+  if (!text)
+    return;
+  return text.length > 2000 ? `${text.slice(0, 1997)}...` : text;
+}
+function persistedBinding(binding) {
+  return {
+    schemaVersion: 1,
+    missionId: binding.missionId,
+    projectRoot: binding.location.projectRoot,
+    missionDir: binding.location.missionDir,
+    globalIndexDir: binding.location.globalIndexDir,
+    writeGlobalIndex: binding.location.writeGlobalIndex,
+    ...binding.location.retainTerminal !== undefined ? { retainTerminal: binding.location.retainTerminal } : {}
+  };
+}
+export function writeMissionAsyncBinding(asyncDir, binding) {
+  writePrivateAtomicJson(path.join(asyncDir, MISSION_BINDING_FILE), persistedBinding(binding));
+}
+export function attachMissionToLaunchResult(input) {
+  const runId = input.result.details.runId ?? input.result.details.asyncId;
+  if (!runId) {
+    const current = readMission(input.binding.location, input.binding.missionId);
+    const activeRunExists = current.runs.some((run) => run.status === "active" || run.status === "queued" || run.status === "running");
+    const mission = toolResultIsError(input.result) ? updateMission(input.binding.location, input.binding.missionId, {
+      status: activeRunExists ? "active" : "failed",
+      ...firstText(input.result) ? { summary: firstText(input.result) } : {}
+    }) : current;
+    return {
+      ...input.result,
+      details: {
+        ...input.result.details,
+        missionId: input.binding.missionId,
+        missionPath: missionRecordPath(input.binding.location, input.binding.missionId),
+        mission
+      }
+    };
+  }
+  const runStatus = runStatusForResult(input.result);
+  const current = readMission(input.binding.location, input.binding.missionId);
+  const startedAt = new Date().toISOString();
+  const usage = usageForResult(input.result);
+  const run = {
+    runId,
+    mode: missionRunModeForResult(input.result.details.mode),
+    status: runStatus,
+    startedAt,
+    ...input.result.details.asyncDir ? { asyncDir: input.result.details.asyncDir } : {},
+    ...input.result.details.results.length === 1 && input.result.details.results[0]?.agent ? { agent: input.result.details.results[0].agent } : {},
+    ...runStatus !== "active" ? { completedAt: startedAt } : {},
+    ...usage ? { usage } : {}
+  };
+  let mission = updateMission(input.binding.location, input.binding.missionId, {
+    status: missionStatusForRun(current, runId, runStatus),
+    addRuns: [run],
+    addArtifacts: artifactsForResult(input.result),
+    ...firstText(input.result) && runStatus !== "active" ? { summary: firstText(input.result) } : {},
+    ...input.result.details.results.length === 1 && input.result.details.results[0]?.acceptance ? { acceptance: input.result.details.results[0].acceptance } : {}
+  });
+  if (input.result.details.asyncDir) {
+    writeMissionAsyncBinding(input.result.details.asyncDir, input.binding);
+    const statusPath = path.join(input.result.details.asyncDir, "status.json");
+    if (fs.existsSync(statusPath)) {
+      try {
+        const status = JSON.parse(fs.readFileSync(statusPath, "utf-8"));
+        if (typeof status.state === "string" && !["queued", "running"].includes(status.state)) {
+          mission = syncMissionFromAsyncCompletion({
+            runId,
+            asyncDir: input.result.details.asyncDir,
+            mode: input.result.details.mode,
+            state: status.state,
+            ...firstText(input.result) ? { summary: firstText(input.result) } : {}
+          }) ?? mission;
+        }
+      } catch (error) {
+        throw new Error(`Failed to reconcile mission from terminal async status '${statusPath}': ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
+  const lastTextIndex = input.result.content.findLastIndex((item) => item.type === "text");
+  const hasStructuredOutput = input.result.details.results.some((child) => child.structuredOutputPath !== undefined);
+  const textIsJson = lastTextIndex >= 0 && (() => {
+    try {
+      JSON.parse(input.result.content[lastTextIndex].text);
+      return true;
+    } catch {
+      return false;
+    }
+  })();
+  return {
+    ...input.result,
+    content: input.binding.announceInContent === true && lastTextIndex >= 0 && !hasStructuredOutput && !textIsJson ? input.result.content.map((item, index) => index === lastTextIndex && item.type === "text" ? { ...item, text: `${item.text}
+Mission: ${mission.id} (${mission.status})` } : item) : input.result.content,
+    details: {
+      ...input.result.details,
+      missionId: mission.id,
+      missionPath: missionRecordPath(input.binding.location, mission.id),
+      mission
+    }
+  };
+}
+function parsePersistedBinding(value, source) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`${source} must be an object`);
+  const input = value;
+  if (input.schemaVersion !== 1)
+    throw new Error(`${source}.schemaVersion must be 1`);
+  for (const field of ["projectRoot", "missionDir", "globalIndexDir"]) {
+    if (typeof input[field] !== "string" || !input[field].trim())
+      throw new Error(`${source}.${field} must be a non-empty string`);
+  }
+  if (typeof input.writeGlobalIndex !== "boolean")
+    throw new Error(`${source}.writeGlobalIndex must be boolean`);
+  if (input.retainTerminal !== undefined && (!Number.isInteger(input.retainTerminal) || input.retainTerminal < 1))
+    throw new Error(`${source}.retainTerminal must be a positive integer`);
+  return {
+    missionId: validateMissionId(input.missionId, `${source}.missionId`),
+    autoCreated: false,
+    location: {
+      projectRoot: input.projectRoot,
+      missionDir: input.missionDir,
+      globalIndexDir: input.globalIndexDir,
+      writeGlobalIndex: input.writeGlobalIndex,
+      ...input.retainTerminal !== undefined ? { retainTerminal: input.retainTerminal } : {}
+    }
+  };
+}
+export function readMissionBinding(asyncDir) {
+  const bindingPath = path.join(asyncDir, MISSION_BINDING_FILE);
+  if (!fs.existsSync(bindingPath))
+    return;
+  return parsePersistedBinding(JSON.parse(fs.readFileSync(bindingPath, "utf-8")), bindingPath);
+}
+export function syncMissionFromAsyncCompletion(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return;
+  const event = value;
+  if (typeof event.asyncDir !== "string" || !event.asyncDir.trim())
+    return;
+  const binding = readMissionBinding(event.asyncDir);
+  if (!binding)
+    return;
+  const runId = typeof event.runId === "string" ? event.runId : typeof event.id === "string" ? event.id : undefined;
+  if (!runId)
+    throw new Error("Async mission completion is missing runId");
+  const runStatus = typeof event.state === "string" ? event.state : event.success === true ? "completed" : "failed";
+  let current;
+  try {
+    current = readMission(binding.location, binding.missionId);
+  } catch (error) {
+    if (!(error instanceof MissionNotFoundError))
+      throw error;
+    const reason = "mission-record-missing";
+    const markerId = createHash("sha256").update(JSON.stringify([runId, binding.missionId, reason])).digest("hex");
+    const markerPath = path.join(event.asyncDir, `.mission-sync-skipped-${markerId}.json`);
+    try {
+      fs.writeFileSync(markerPath, `${JSON.stringify({ runId, missionId: binding.missionId, reason })}
+`, { encoding: "utf-8", mode: 384, flag: "wx" });
+      fs.appendFileSync(path.join(event.asyncDir, "events.jsonl"), `${JSON.stringify({
+        type: "subagent.mission.sync.skipped",
+        ts: Date.now(),
+        runId,
+        missionId: binding.missionId,
+        reason,
+        missionPath: missionRecordPath(binding.location, binding.missionId)
+      })}
+`, "utf-8");
+    } catch {}
+    return;
+  }
+  const completedAt = new Date().toISOString();
+  const artifacts = [
+    { kind: "status", path: path.join(event.asyncDir, "status.json") },
+    { kind: "other", path: path.join(event.asyncDir, "events.jsonl"), description: "Lifecycle events" }
+  ];
+  if (event.parallelHandoff && typeof event.parallelHandoff === "object" && typeof event.parallelHandoff.path === "string") {
+    artifacts.push({ kind: "manifest", path: event.parallelHandoff.path });
+  }
+  if (Array.isArray(event.results)) {
+    for (const result of event.results) {
+      if (!result || typeof result !== "object")
+        continue;
+      const child = result;
+      if (typeof child.artifactPath === "string")
+        artifacts.push({ kind: "output", path: child.artifactPath });
+      if (child.artifactPaths && typeof child.artifactPaths === "object" && typeof child.artifactPaths.outputPath === "string") {
+        artifacts.push({ kind: "output", path: child.artifactPaths.outputPath });
+      }
+    }
+  }
+  const summary = typeof event.summary === "string" && event.summary.trim() ? event.summary.slice(0, 2000) : undefined;
+  const usage = usageFromUnknown(event.totalTokens) ?? (Array.isArray(event.results) ? { tokens: event.results.reduce((total, result) => {
+    if (!result || typeof result !== "object")
+      return total;
+    return total + (usageFromUnknown(result.tokens)?.tokens ?? 0);
+  }, 0) } : undefined);
+  const workflowRunId = typeof event.parentWorkflowRunId === "string" && event.parentWorkflowRunId.trim() ? event.parentWorkflowRunId.trim() : undefined;
+  const workflowKey = typeof event.workflowKey === "string" && event.workflowKey.trim() ? event.workflowKey.trim() : undefined;
+  const workflowChildStatus = runStatus === "complete" || runStatus === "completed" || event.success === true ? "completed" : runStatus === "paused" ? "paused" : runStatus === "stopped" ? "stopped" : "failed";
+  const workflowChildTerminal = !["running", "queued", "active", "paused"].includes(workflowChildStatus);
+  return updateMission(binding.location, binding.missionId, {
+    status: missionStatusForRun(current, runId, runStatus),
+    addRuns: [{ runId, mode: typeof event.mode === "string" && ["single", "parallel", "chain", "workflow"].includes(event.mode) ? event.mode : "external", asyncDir: event.asyncDir, status: runStatus, completedAt, ...usage && usage.tokens > 0 ? { usage } : {} }],
+    addArtifacts: artifacts,
+    ...workflowRunId && workflowKey ? { upsertWorkflowChildren: [{
+      workflowRunId,
+      key: workflowKey,
+      runId,
+      status: workflowChildStatus,
+      artifactPaths: artifacts.map((artifact) => artifact.path),
+      ...workflowChildTerminal ? { completedAt } : {},
+      heartbeat: { status: workflowChildStatus, ...summary ? { message: summary } : {} }
+    }] } : {},
+    ...summary ? { summary } : {}
+  });
+}