@duckmind/dm-darwin-x64 0.66.5 → 0.66.7

package/extensions/dm-subagents/src/runs/background/async-job-tracker.js

@@ -28,6 +28,7 @@ const MAX_RECENT_FLEET_JOBS = 20;
 const DEFAULT_LIVENESS_INTERVAL_MS = 5000;
 const EVENT_REFRESH_DEBOUNCE_MS = 25;
 const WATCH_ATTACHMENT_RETRY_MS = 100;
+const SUPERVISOR_NOTICE_GRACE_MS = 60000;
 const isTerminalJobStatus = (status) => status === "complete" || status === "failed" || status === "partial" || status === "paused" || status === "rejected" || status === "stopped";
 function rememberFleetJob(state, job) {
   state.fleetJobs ??= new Map;
@@ -47,6 +48,7 @@ export function createAsyncJobTracker(dm, state, asyncDirRoot, options = {}) {
   const runningJobIds = new Set;
   const externalJobBridgeRuns = new Set;
   const terminalPublications = new Map;
+  const supervisorNoticeTimers = new Map;
   let rootWatcher;
   let nextLivenessAt = Date.now() + livenessIntervalMs;
   let nextWidgetAnimationAt = Date.now() + WIDGET_ANIMATION_INTERVAL_MS;
@@ -60,9 +62,10 @@ export function createAsyncJobTracker(dm, state, asyncDirRoot, options = {}) {
     }, run);
   };
   const rerenderWidget = (ctx, jobs = Array.from(state.asyncJobs.values())) => {
+    options.onJobsChanged?.();
     if (state.widgetsSuspended)
       return;
-    renderWidget(ctx, options.widgetEnabled === false ? [] : jobs);
+    renderWidget(ctx, options.widgetEnabled === false ? [] : jobs, options.widgetCollapsed, options.widgetLayout);
     ctx.ui.requestRender?.();
   };
   const rerenderLastWidget = (jobs = Array.from(state.asyncJobs.values())) => {
@@ -87,7 +90,7 @@ export function createAsyncJobTracker(dm, state, asyncDirRoot, options = {}) {
       if (requestRender)
         requestRender.call(ctx.ui);
       else
-        renderWidget(ctx, Array.from(state.asyncJobs.values()));
+        renderWidget(ctx, Array.from(state.asyncJobs.values()), options.widgetCollapsed, options.widgetLayout);
     });
   };
   const refreshWidget = (ctx) => rerenderWidget(ctx);
@@ -180,10 +183,55 @@ export function createAsyncJobTracker(dm, state, asyncDirRoot, options = {}) {
       const job = state.asyncJobs.get(asyncId);
       retainNestedLookupRoute(state, job?.nestedRoute, job?.sessionId);
       state.asyncJobs.delete(asyncId);
+      options.onJobCleanup?.(asyncId);
       rerenderLastWidget();
     }, completionRetentionMs);
     state.cleanupTimers.set(asyncId, timer);
   };
+  const deliverControlRecord = (record, payload) => {
+    if (record.channels.includes("event")) {
+      dm.events.emit(SUBAGENT_CONTROL_EVENT, payload);
+    }
+    if (record.event.type !== "active_long_running" && record.channels.includes("intercom") && record.intercom?.to && record.intercom.message) {
+      dm.events.emit(SUBAGENT_CONTROL_INTERCOM_EVENT, {
+        ...payload,
+        to: record.intercom.to,
+        message: record.intercom.message
+      });
+    }
+  };
+  const readSupervisorRequestState = (event, asyncDir) => {
+    try {
+      return options.supervisorRequestState?.(event) ?? "unknown";
+    } catch (error) {
+      console.error(`Failed to resolve supervisor request state for async control event in '${asyncDir}':`, error);
+      return "unknown";
+    }
+  };
+  const scheduleSupervisorNotice = (asyncId, record, payload) => {
+    const key = `${asyncId}:${record.event.index}:${record.event.toolCallId}`;
+    if (supervisorNoticeTimers.has(key))
+      return;
+    const timer = setTimeout(() => {
+      supervisorNoticeTimers.delete(key);
+      const job = state.asyncJobs.get(asyncId);
+      if (job?.status !== "running" && job?.status !== "queued")
+        return;
+      if (readSupervisorRequestState(record.event, payload.asyncDir) === "resolved")
+        return;
+      deliverControlRecord(record, payload);
+    }, SUPERVISOR_NOTICE_GRACE_MS);
+    timer.unref?.();
+    supervisorNoticeTimers.set(key, { asyncId, timer });
+  };
+  const clearSupervisorNotices = (asyncId) => {
+    for (const [key, entry] of supervisorNoticeTimers) {
+      if (asyncId !== undefined && entry.asyncId !== asyncId)
+        continue;
+      clearTimeout(entry.timer);
+      supervisorNoticeTimers.delete(key);
+    }
+  };
   const emitNewControlEvents = (job) => {
     const eventsPath = path.join(job.asyncDir, "events.jsonl");
     let fd;
@@ -268,19 +316,13 @@ export function createAsyncJobTracker(dm, state, asyncDirRoot, options = {}) {
         }
         if (parsed.type !== "subagent.control")
           return;
-        const record = parsed;
-        if (!record.event || !Array.isArray(record.channels))
+        const candidate = parsed;
+        if (!candidate.event || !Array.isArray(candidate.channels))
+          return;
+        const record = candidate;
+        const supervisorRequest = record.event.type === "needs_attention" && record.event.reason === "supervisor_request" && options.supervisorRequestState !== undefined;
+        if (supervisorRequest && readSupervisorRequestState(record.event, job.asyncDir) === "resolved")
           return;
-        if (record.event.type === "needs_attention" && record.event.reason === "supervisor_request" && options.supervisorRequestState) {
-          let requestState = "unknown";
-          try {
-            requestState = options.supervisorRequestState(record.event);
-          } catch (error) {
-            console.error(`Failed to resolve supervisor request state for async control event in '${job.asyncDir}':`, error);
-          }
-          if (requestState === "resolved")
-            return;
-        }
         const payload = {
           event: record.event,
           source: "async",
@@ -288,16 +330,13 @@ export function createAsyncJobTracker(dm, state, asyncDirRoot, options = {}) {
           childIntercomTarget: record.childIntercomTarget,
           noticeText: record.noticeText ?? formatControlNoticeMessage(record.event, record.childIntercomTarget)
         };
-        if (record.channels.includes("event")) {
-          dm.events.emit(SUBAGENT_CONTROL_EVENT, payload);
-        }
-        if (record.event.type !== "active_long_running" && record.channels.includes("intercom") && record.intercom?.to && record.intercom.message) {
-          dm.events.emit(SUBAGENT_CONTROL_INTERCOM_EVENT, {
-            ...payload,
-            to: record.intercom.to,
-            message: record.intercom.message
-          });
+        if (supervisorRequest && record.event.currentTool !== "intercom") {
+          if (record.channels.includes("event"))
+            dm.events.emit(SUBAGENT_CONTROL_EVENT, { ...payload, noticeDeferred: true });
+          scheduleSupervisorNotice(job.asyncId, record, payload);
+          return;
         }
+        deliverControlRecord(record, payload);
       };
       let readCursor = cursor;
       let lastCompleteCursor = cursor;
@@ -366,6 +405,7 @@ export function createAsyncJobTracker(dm, state, asyncDirRoot, options = {}) {
     runningJobIds.delete(asyncId);
     externalJobBridgeRuns.delete(asyncId);
     terminalPublications.delete(asyncId);
+    clearSupervisorNotices(asyncId);
   };
   const refreshJob = (job) => {
     const widgetExpanded = withLastUiContext((ctx) => ctx.ui.getToolsExpanded?.() ?? false) ?? false;
@@ -507,7 +547,7 @@ export function createAsyncJobTracker(dm, state, asyncDirRoot, options = {}) {
               cancelCleanup(job.asyncId);
           }
           if (!isTerminalJobStatus(previousStatus) || wasPending && !publication?.pending)
-            options.onJobTerminal?.();
+            options.onJobTerminal?.(job);
           rememberFleetJob(state, job);
           if (!publication?.pending && !nestedRefreshFailed && !hasLiveNestedDescendants(job.nestedChildren) && (previousStatus !== job.status || !state.cleanupTimers.has(job.asyncId))) {
             scheduleCleanup(job.asyncId);
@@ -777,6 +817,7 @@ export function createAsyncJobTracker(dm, state, asyncDirRoot, options = {}) {
     runningJobIds.clear();
     externalJobBridgeRuns.clear();
     terminalPublications.clear();
+    clearSupervisorNotices();
   };
   const resetJobs = (ctx) => {
     dispose();

package/extensions/dm-subagents/src/runs/background/async-resume.js

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { DIRS } from "../../shared/types.js";
+import { DIRS, RUNNER_LAUNCHER_NAME_PATTERN } from "../../shared/types.js";
 import { normalizeExtensionBindings } from "../shared/extension-bindings.js";
 import { snapshotRequiredChildExtensions } from "../../shared/required-child-extensions.js";
 import { normalizeWorkflowLaneMetadata } from "../shared/lane-metadata.js";
@@ -226,6 +226,8 @@ function validateStatusForResume(status, source) {
         throw new Error(`Invalid async status '${source}': steps[${index}].sessionName must be a string.`);
       if (stepRecord.model !== undefined && typeof stepRecord.model !== "string")
         throw new Error(`Invalid async status '${source}': steps[${index}].model must be a string.`);
+      if (stepRecord.launchModel !== undefined && typeof stepRecord.launchModel !== "string")
+        throw new Error(`Invalid async status '${source}': steps[${index}].launchModel must be a string.`);
       if (stepRecord.thinking !== undefined && typeof stepRecord.thinking !== "string")
         throw new Error(`Invalid async status '${source}': steps[${index}].thinking must be a string.`);
       if (stepRecord.thinkingCeiling !== undefined)
@@ -324,6 +326,7 @@ export function readAsyncRecoveryDescriptor(asyncDir) {
     "runFanoutBudget",
     "lane",
     "baseRef",
+    "launcher",
     "extensionBindings",
     "requiredExtensions"
   ]);
@@ -338,6 +341,8 @@ export function readAsyncRecoveryDescriptor(asyncDir) {
   }
   if (parsed.version !== 1)
     throw new Error(`Invalid async recovery descriptor '${descriptorPath}': version must be 1.`);
+  if (parsed.launcher !== undefined && (typeof parsed.launcher !== "string" || !RUNNER_LAUNCHER_NAME_PATTERN.test(parsed.launcher)))
+    throw new Error(`Invalid async recovery descriptor '${descriptorPath}': launcher must be a launcher name.`);
   try {
     parsed.runFanoutBudget = validateRunFanoutBudgetDescriptor(parsed.runFanoutBudget);
   } catch (error) {
@@ -622,7 +627,7 @@ export function resolveAsyncResumeTarget(params, deps = {}, options = {}) {
   if (!sessionFile && requireSessionFile)
     throw new Error(`Async run '${runId}' child ${index} does not have a persisted session file to resume from.`);
   const resolvedSessionFile = sessionFile ? validateResumeSessionFile(runId, sessionFile) : undefined;
-  const stepModel = statusSteps[index]?.model ?? resultSteps[index]?.model ?? (stepCount === 1 ? result?.model : undefined);
+  const stepModel = statusSteps[index]?.launchModel ?? statusSteps[index]?.model ?? resultSteps[index]?.model ?? (stepCount === 1 ? result?.model : undefined);
   const stepThinking = statusSteps[index]?.thinking ?? resultSteps[index]?.thinking ?? (stepCount === 1 ? result?.thinking : undefined);
   const thinkingCeiling = statusSteps[index]?.thinkingCeiling ?? (stepCount === 1 ? recoveryDescriptor?.thinkingCeiling : undefined);
   const capabilityCeiling = mode === "workflow" ? intersectSubagentCapabilityCeilings(status?.admissionCapabilityCeiling, result?.admissionCapabilityCeiling) : intersectSubagentCapabilityCeilings(status?.capabilityCeiling, statusSteps[index]?.capabilityCeiling, result?.capabilityCeiling, resultSteps[index]?.capabilityCeiling);
@@ -676,7 +681,8 @@ export function applySteeringRecoveryAgentConfig(agentConfig, descriptor) {
     memory: descriptor.memory ? { ...descriptor.memory } : undefined,
     output: descriptor.outputPath,
     toolBudget: descriptor.initialToolBudget,
-    maxSubagentDepth: descriptor.maxSubagentDepth
+    maxSubagentDepth: descriptor.maxSubagentDepth,
+    launcher: descriptor.launcher
   };
 }
 export function buildRevivedAsyncTask(target, message) {

package/extensions/dm-subagents/src/runs/background/async-retention.js

@@ -1,11 +1,13 @@
-import { spawnSync } from "node:child_process";
+import { execFile } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { randomUUID } from "node:crypto";
 import { Worker } from "node:worker_threads";
 import { writeAtomicJson } from "../../shared/atomic-json.js";
-import { MISSION_BINDING_FILE } from "../../missions/lifecycle.js";
+import { readMissionBinding } from "../../missions/lifecycle.js";
+import { MissionNotFoundError, readMission } from "../../missions/store.js";
+import { REVIVAL_ORIGIN_FILE } from "../../workflows/workflow-revival.js";
 import { ACTIVE_RUN_INDEX_DIR } from "./active-run-index.js";
 import { encodeIndexSegment } from "./index-segment.js";
 import { reconcileAsyncRun } from "./stale-run-reconciler.js";
@@ -23,6 +25,7 @@ const RUN_TOMBSTONE_MARKERS_DIR = "async-retention-run-tombstones";
 const LOCK_STALE_MS = 24 * 60 * 60 * 1000;
 const RUN_MODES = new Set(["single", "parallel", "chain", "workflow"]);
 const TERMINAL_STATES = new Set(["complete", "failed", "stopped", "rejected"]);
+const TERMINAL_MISSION_STATUSES = new Set(["completed", "failed", "cancelled"]);
 const RESULT_TIMESTAMP_FIELDS = ["endedAt", "completedAt", "createdAt", "writtenAt", "expiresAt", "timestamp"];
 function isNotFound(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
@@ -107,6 +110,24 @@ function activeMarkerExists(asyncDirRoot, runId) {
 function missionObserverIndexExists(resultsDir, runId) {
   return fs.existsSync(path.join(resultsDir, "result-index", "observers", "mission", `${encodeIndexSegment(runId)}.json`));
 }
+function missionReferenceBlocksReclaim(runDir, resultsDir, runId) {
+  if (missionObserverIndexExists(resultsDir, runId))
+    return true;
+  let binding;
+  try {
+    binding = readMissionBinding(runDir);
+  } catch {
+    return true;
+  }
+  if (!binding)
+    return false;
+  try {
+    const mission = readMission(binding.location, binding.missionId);
+    return !TERMINAL_MISSION_STATUSES.has(mission.status);
+  } catch (error) {
+    return !(error instanceof MissionNotFoundError);
+  }
+}
 function runTombstoneMarkerPath(maintenanceRoot, runId) {
   return path.join(maintenanceRoot, RUN_TOMBSTONE_MARKERS_DIR, `${encodeIndexSegment(runId)}.json`);
 }
@@ -192,9 +213,11 @@ function runSkipReason(input) {
     return "non-terminal";
   if (status.mode === "workflow" || status.parentWorkflowRunId || status.workflowKey)
     return "workflow-reference";
+  if (fs.existsSync(path.join(runDir, REVIVAL_ORIGIN_FILE)))
+    return "workflow-reference";
   if (hasNestedReferences(status))
     return "nested-reference";
-  if (fs.existsSync(path.join(runDir, MISSION_BINDING_FILE)) || missionObserverIndexExists(input.resultsDir, status.runId))
+  if (missionReferenceBlocksReclaim(runDir, input.resultsDir, status.runId))
     return "mission-reference";
   if (hasUnresolvedRunHandoff(runDir, status))
     return "handoff-reference";
@@ -223,15 +246,14 @@ function readCursor(root) {
   const value = readJson(path.join(root, CURSOR_NAME));
   return value?.version === 1 ? value : { version: 1 };
 }
-let currentProcessStartIdentity = null;
+let currentProcessStartIdentity;
 function processStartIdentity(pid) {
   if (pid !== process.pid)
     return computeProcessStartIdentity(pid);
-  if (currentProcessStartIdentity === null)
-    currentProcessStartIdentity = computeProcessStartIdentity(pid);
+  currentProcessStartIdentity ??= computeProcessStartIdentity(pid);
   return currentProcessStartIdentity;
 }
-function computeProcessStartIdentity(pid) {
+async function computeProcessStartIdentity(pid) {
   if (process.platform === "linux") {
     try {
       const stat = fs.readFileSync(`/proc/${pid}/stat`).toString("utf8");
@@ -245,8 +267,11 @@ function computeProcessStartIdentity(pid) {
     }
   }
   if (process.platform === "win32") {
-    const result = spawnSync("powershell.exe", ["-NoProfile", "-Command", `(Get-CimInstance Win32_Process -Filter "ProcessId=${pid}").CreationDate`], { encoding: "utf-8", windowsHide: true });
-    const started = result.status === 0 ? result.stdout.trim() : "";
+    const started = await new Promise((resolve) => {
+      execFile("powershell.exe", ["-NoProfile", "-Command", `(Get-CimInstance Win32_Process -Filter "ProcessId=${pid}").CreationDate`], { encoding: "utf-8", windowsHide: true, timeout: 5000 }, (error, stdout) => {
+        resolve(error ? "" : stdout.trim());
+      });
+    });
     return started ? `win:${started}` : undefined;
   }
   return;
@@ -272,7 +297,7 @@ function parseLockOwner(lockDir) {
     return;
   return owner;
 }
-function staleLock(lockDir, now, options) {
+async function staleLock(lockDir, now, options) {
   const owner = parseLockOwner(lockDir);
   if (!owner) {
     try {
@@ -287,7 +312,7 @@ function staleLock(lockDir, now, options) {
   if (alive === false)
     return { stale: true, token: owner.token };
   if (alive === true && owner.processStartIdentity) {
-    const currentIdentity = options.getProcessStartIdentity(owner.pid);
+    const currentIdentity = await options.getProcessStartIdentity(owner.pid);
     if (currentIdentity !== undefined && currentIdentity !== owner.processStartIdentity)
       return { stale: true, token: owner.token };
   }
@@ -309,11 +334,11 @@ function createLockDirectory(lockDir, owner) {
     throw error;
   }
 }
-function acquireRetentionLock(lockDir, owner, options) {
+async function acquireRetentionLock(lockDir, owner, options) {
   for (let attempt = 0;attempt < 4; attempt += 1) {
     if (createLockDirectory(lockDir, owner))
       return true;
-    const stale = staleLock(lockDir, owner.startedAt, options);
+    const stale = await staleLock(lockDir, owner.startedAt, options);
     if (!stale.stale)
       return false;
     const staleKey = (stale.token ?? owner.token).replace(/[^A-Za-z0-9._-]/g, "-");
@@ -575,7 +600,7 @@ export async function cleanupAsyncRetention(options) {
   const pid = options.pid ?? process.pid;
   const hostname = options.hostname ?? os.hostname();
   const getProcessStartIdentity = options.getProcessStartIdentity ?? processStartIdentity;
-  const currentProcessStartIdentity = options.processStartIdentity ?? getProcessStartIdentity(pid) ?? (pid === process.pid ? `runtime:${Math.round(Date.now() - process.uptime() * 1000)}` : undefined);
+  const currentProcessStartIdentity = options.processStartIdentity ?? await getProcessStartIdentity(pid) ?? (pid === process.pid ? `runtime:${Math.round(Date.now() - process.uptime() * 1000)}` : undefined);
   const lockOwner = { version: 1, token: lockToken, pid, hostname, startedAt: currentTime, ...currentProcessStartIdentity ? { processStartIdentity: currentProcessStartIdentity } : {} };
   const lockOptions = { hostname, isProcessAlive: options.isProcessAlive ?? processIsAlive, getProcessStartIdentity };
   const result = {
@@ -614,7 +639,7 @@ export async function cleanupAsyncRetention(options) {
     return true;
   };
   fs.mkdirSync(maintenanceRoot, { recursive: true });
-  if (!acquireRetentionLock(lockDir, lockOwner, lockOptions)) {
+  if (!await acquireRetentionLock(lockDir, lockOwner, lockOptions)) {
     increment(result.skipped, "lock-busy");
     return finish();
   }

package/extensions/dm-subagents/src/runs/background/await-async-run.js

@@ -0,0 +1,68 @@
+import * as fs from "node:fs";
+import { readStatus } from "../../shared/utils.js";
+import { workflowAwaitedAsyncResultPath } from "./async-execution.js";
+import { waitForImportedAsyncRoot } from "./chain-root-attachment.js";
+import { currentPidNamespaceScope } from "./pid-namespace.js";
+import { resultPayloadPathForSessionRun, resultSnapshotReplaced, withResultRunLease } from "./result-files.js";
+import { checkPidLiveness } from "./stale-run-reconciler.js";
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function runnerExitedWithoutResult(asyncDir, runId, resultPath) {
+  const status = readStatus(asyncDir);
+  if (!status || status.state !== "running" && status.state !== "queued" || typeof status.pid !== "number")
+    return false;
+  const observedScope = currentPidNamespaceScope();
+  if (status.pidNamespaceScope !== undefined && status.pidNamespaceScope !== observedScope)
+    return false;
+  const pidScopeVerified = status.pidNamespaceScope !== undefined && status.pidNamespaceScope === observedScope;
+  if (checkPidLiveness(status.pid, undefined, pidScopeVerified) !== "dead")
+    return false;
+  return !fs.existsSync(resultPath) && !(status.sessionId && resultPayloadPathForSessionRun(asyncDir, status.sessionId, runId));
+}
+export async function awaitExistingAsyncRun(asyncDir, runId, signal) {
+  signal.throwIfAborted();
+  let status;
+  try {
+    status = readStatus(asyncDir);
+  } catch (error) {
+    return { status: "unavailable", reason: `Async status for run '${runId}' is unreadable: ${errorMessage(error)}` };
+  }
+  if (!status)
+    return { status: "unavailable", reason: `No async status exists for run '${runId}' at ${asyncDir}.` };
+  if (status.runId !== runId)
+    return { status: "unavailable", reason: `Async status at ${asyncDir} belongs to run '${status.runId}', not '${runId}'.` };
+  if (status.mode !== "single")
+    return { status: "unavailable", reason: `Async run '${runId}' is not a single-agent run.` };
+  const resultPath = workflowAwaitedAsyncResultPath(asyncDir);
+  let runnerExited = false;
+  let completed;
+  try {
+    completed = await waitForImportedAsyncRoot({ runId, asyncDir, resultPath, index: 0 }, {
+      shouldAbort: () => signal.aborted || (runnerExited = runnerExitedWithoutResult(asyncDir, runId, resultPath))
+    });
+  } catch (error) {
+    signal.throwIfAborted();
+    return { status: "unavailable", reason: `Could not await async run '${runId}': ${errorMessage(error)}` };
+  }
+  signal.throwIfAborted();
+  if (runnerExited)
+    return { status: "unavailable", reason: `Async runner for run '${runId}' exited without publishing a result.` };
+  if (!completed.importedPublication)
+    return { status: "unavailable", reason: `Async run '${runId}' ended without a result file at ${resultPath}.` };
+  return { status: "settled", result: { ...completed, importedPublication: completed.importedPublication } };
+}
+export function claimWorkflowAwaitedResult(asyncDir, claimant, read) {
+  const resultPath = workflowAwaitedAsyncResultPath(asyncDir);
+  const claimedPath = `${resultPath}.${claimant}.claimed`;
+  try {
+    return withResultRunLease(asyncDir, read.runId, () => {
+      if (resultSnapshotReplaced(resultPath, read))
+        return;
+      fs.renameSync(resultPath, claimedPath);
+      return claimedPath;
+    });
+  } catch {
+    return;
+  }
+}

package/extensions/dm-subagents/src/runs/background/binary-bootstrap.js

@@ -10,6 +10,7 @@ import * as typebox from "typebox";
 import * as typeboxCompile from "typebox/compile";
 import * as typeboxValue from "typebox/value";
 import { installRunnerHttpDispatcher } from "./runner-http-dispatcher.js";
+import { resolveRuntimeModuleExtension } from "../../shared/runtime-module-path.js";
 import { runConfiguredSubagent, validateSubagentRunConfig } from "./subagent-runner-bootstrap.js";
 import { getAgentDir } from "../../shared/utils.js";
 export default async function runBinaryBootstrap() {
@@ -42,7 +43,7 @@ export default async function runBinaryBootstrap() {
             "typebox/value": typeboxValue
           }
         });
-        const runner = `./subagent-runner${path.extname(fileURLToPath(import.meta.url))}`;
+        const runner = `./subagent-runner${resolveRuntimeModuleExtension(path.dirname(fileURLToPath(import.meta.url)), "subagent-runner")}`;
         return jiti.import(runner);
       }
     });

package/extensions/dm-subagents/src/runs/background/calendar-schedule.js

@@ -0,0 +1,90 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+let cachedTemporal;
+function getTemporal() {
+  return cachedTemporal ??= require("@js-temporal/polyfill").Temporal;
+}
+export const CALENDAR_WEEKDAYS = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"];
+const SEARCH_DAYS = 32;
+export function normalizeCalendarRule(input) {
+  if (input.every !== "day" && input.every !== "week")
+    throw new Error("Calendar every must be 'day' or 'week'.");
+  if (typeof input.at !== "string" || !/^(?:[01]\d|2[0-3]):[0-5]\d$/.test(input.at))
+    throw new Error("Calendar at must use HH:mm (00:00-23:59).");
+  if (typeof input.timezone !== "string" || !input.timezone.trim() || /^[+-]/.test(input.timezone.trim()))
+    throw new Error("Calendar timezone requires an IANA name, such as 'Asia/Taipei', or 'UTC'.");
+  let timezone;
+  try {
+    timezone = new Intl.DateTimeFormat("en", { timeZone: input.timezone.trim() }).resolvedOptions().timeZone;
+  } catch {
+    throw new Error(`Invalid calendar timezone '${input.timezone}'. Use an IANA name or 'UTC'.`);
+  }
+  if (input.every === "day") {
+    if (input.on !== undefined)
+      throw new Error("Daily schedules do not accept on; use every:'week' with a weekday array.");
+    return { every: "day", at: input.at, timezone };
+  }
+  if (!Array.isArray(input.on) || input.on.length === 0 || input.on.some((day) => !CALENDAR_WEEKDAYS.includes(day)))
+    throw new Error("Weekly on must be a non-empty array of mon/tue/wed/thu/fri/sat/sun.");
+  const selected = input.on;
+  return { every: "week", at: input.at, timezone, on: CALENDAR_WEEKDAYS.filter((day) => selected.includes(day)) };
+}
+function localDate(value) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(value))
+    throw new Error("Calendar nextLocalDate must use YYYY-MM-DD.");
+  return getTemporal().PlainDate.from(value, { overflow: "reject" });
+}
+function referenceDate(rule, reference) {
+  return getTemporal().Instant.fromEpochMilliseconds(reference).toZonedDateTimeISO(rule.timezone).toPlainDate();
+}
+function occurrence(rule, date) {
+  if (rule.every === "week" && !rule.on.includes(CALENDAR_WEEKDAYS[date.dayOfWeek - 1]))
+    return;
+  const requested = date.toPlainDateTime(rule.at);
+  const zoned = requested.toZonedDateTime(rule.timezone, { disambiguation: "earlier" });
+  if (!zoned.toPlainDateTime().equals(requested))
+    return;
+  return { nextLocalDate: date.toString(), nextRunAt: new Date(zoned.epochMilliseconds).toISOString() };
+}
+export function nextCalendarOccurrence(rule, after, minimumDate) {
+  let date = referenceDate(rule, after);
+  if (minimumDate && getTemporal().PlainDate.compare(date, localDate(minimumDate)) < 0)
+    date = localDate(minimumDate);
+  for (let i = 0;i < SEARCH_DAYS; i++, date = date.add({ days: 1 })) {
+    const candidate = occurrence(rule, date);
+    if (candidate && Date.parse(candidate.nextRunAt) > after)
+      return candidate;
+  }
+  throw new Error("No valid calendar occurrence within 32 local dates; check the timezone and rule.");
+}
+export function latestCalendarOccurrence(rule, now, minimumDate) {
+  const floor = localDate(minimumDate);
+  let date = referenceDate(rule, now);
+  for (let i = 0;i < SEARCH_DAYS; i++, date = date.subtract({ days: 1 })) {
+    if (getTemporal().PlainDate.compare(date, floor) < 0)
+      return;
+    const candidate = occurrence(rule, date);
+    if (candidate && Date.parse(candidate.nextRunAt) <= now)
+      return candidate;
+  }
+  throw new Error("No valid calendar occurrence within 32 local dates; check the timezone and rule.");
+}
+export function calendarDateAfter(rule, consumedAt, pendingDate) {
+  const consumed = referenceDate(rule, consumedAt);
+  const pending = localDate(pendingDate);
+  return (getTemporal().PlainDate.compare(consumed, pending) > 0 ? consumed : pending).add({ days: 1 }).toString();
+}
+export function restoreCalendarTrigger(input) {
+  const rule = normalizeCalendarRule(input);
+  let date = localDate(input.nextLocalDate);
+  if (rule.every === "week" && !rule.on.includes(CALENDAR_WEEKDAYS[date.dayOfWeek - 1]))
+    throw new Error("Calendar nextLocalDate is outside the selected weekdays.");
+  if (typeof input.nextRunAt !== "string" || !Number.isFinite(Date.parse(input.nextRunAt)))
+    throw new Error("Calendar nextRunAt must be a valid timestamp.");
+  for (let i = 0;i < SEARCH_DAYS; i++, date = date.add({ days: 1 })) {
+    const candidate = occurrence(rule, date);
+    if (candidate)
+      return { kind: "calendar", ...rule, ...candidate };
+  }
+  throw new Error("No valid pending calendar occurrence within 32 local dates.");
+}

package/extensions/dm-subagents/src/runs/background/chain-root-attachment.js

@@ -5,14 +5,16 @@ import { readStatus } from "../../shared/utils.js";
 const TERMINAL_STATES = new Set(["complete", "failed", "partial", "paused", "stopped"]);
 const TERMINAL_STEP_STATUSES = new Set(["complete", "completed", "failed", "partial", "paused", "stopped"]);
 function readResultFile(resultPath) {
+  let raw;
   try {
-    return JSON.parse(fs.readFileSync(resultPath, "utf-8"));
+    raw = fs.readFileSync(resultPath, "utf-8");
   } catch (error) {
     if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
       return;
     }
     throw error;
   }
+  return { data: JSON.parse(raw), raw };
 }
 function readImportedResultFile(root, status) {
   const direct = readResultFile(root.resultPath);
@@ -55,7 +57,7 @@ function outputFromTerminalStatus(root, status, step) {
   const agent = step?.agent ?? status.steps?.[root.index]?.agent ?? "subagent";
   const timedOut = step?.timedOut === true || status.timedOut === true;
   const stopped = step?.stopped === true || status.stopped === true || status.state === "stopped";
-  const message = step?.error ?? status.error ?? (stopped ? "Subagent stopped by user." : `Attached async root ${root.runId} ended without a result file at ${root.resultPath}.`);
+  const message = step?.error ?? status.error ?? (stopped ? "Subagent stopped." : `Attached async root ${root.runId} ended without a result file at ${root.resultPath}.`);
   const partialStatus = status.state === "partial" || step?.status === "partial";
   const execution = step?.execution ?? (partialStatus ? { status: "partial", success: false, exitCode: 1, error: message } : undefined);
   return {
@@ -81,7 +83,7 @@ function outputFromTerminalStatus(root, status, step) {
     ...step?.transcriptPath ? { transcriptPath: step.transcriptPath } : {}
   };
 }
-function outputFromTimeout(root, status, message) {
+function outputFromTimeout(root, status, message, stopped = false) {
   const step = selectedStatusStep(status, root.index);
   return {
     agent: step?.agent ?? status?.steps?.[root.index]?.agent ?? "subagent",
@@ -89,7 +91,7 @@ function outputFromTimeout(root, status, message) {
     success: false,
     exitCode: 1,
     error: message,
-    timedOut: true,
+    ...stopped ? { stopped: true } : { timedOut: true },
     ...step?.sessionName ? { sessionName: step.sessionName } : {},
     ...step?.sessionFile ?? status?.sessionFile ? { sessionFile: step?.sessionFile ?? status?.sessionFile } : {},
     ...step?.model ? { model: step.model } : {},
@@ -99,7 +101,7 @@ function outputFromTimeout(root, status, message) {
     ...step?.transcriptPath ? { transcriptPath: step.transcriptPath } : {}
   };
 }
-function buildImportedResult(root, status, result) {
+function buildImportedResult(root, status, { data: result, raw }) {
   const child = result.results?.[root.index];
   const step = selectedStatusStep(status, root.index);
   const state = resultState(result, child);
@@ -108,14 +110,15 @@ function buildImportedResult(root, status, result) {
   const timedOut = child?.timedOut === true || step?.timedOut === true || result.timedOut === true || status?.timedOut === true;
   const stopped = child?.stopped === true || step?.stopped === true || result.stopped === true || status?.stopped === true || state === "stopped";
   const success = state === "complete" && !timedOut && !stopped;
-  const error = child?.error ?? (success ? undefined : stopped ? "Subagent stopped by user." : result.error ?? result.summary ?? status?.error ?? `Attached async root ${root.runId} did not complete successfully.`);
+  const error = child?.error ?? (success ? undefined : stopped ? "Subagent stopped." : result.error ?? result.summary ?? status?.error ?? `Attached async root ${root.runId} did not complete successfully.`);
   const execution = state ? { status: state === "complete" ? "completed" : state, success, exitCode: success ? 0 : 1, ...error ? { error } : {} } : undefined;
   const usage = child?.usage;
   return {
     agent,
     importedPublication: {
       ...typeof result.sessionId === "string" ? { sessionId: result.sessionId } : {},
-      ...typeof result.toolCallId === "string" ? { toolCallId: result.toolCallId } : {}
+      ...typeof result.toolCallId === "string" ? { toolCallId: result.toolCallId } : {},
+      snapshot: raw
     },
     output: success ? output : output || error || "",
     success,
@@ -152,7 +155,7 @@ export async function waitForImportedAsyncRoot(root, options = {}) {
   for (;; ) {
     const status = readStatus(root.asyncDir);
     if (options.shouldAbort?.())
-      return outputFromTimeout(root, status, options.timeoutMessage ?? "Subagent timed out.");
+      return outputFromTimeout(root, status, options.timeoutMessage ?? "Subagent timed out.", options.abortedAsStopped === true);
     const result = readImportedResultFile(root, status);
     if (result)
       return buildImportedResult(root, status, result);