@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

package/extensions/dm-subagents/src/runs/background/scheduled-runs.js

@@ -1,9 +1,11 @@
 import { spawnSync } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 import { getProjectSubagentsDir } from "../../shared/artifacts.js";
 import { writePrivateAtomicJson } from "../../shared/atomic-json.js";
+import { withFileLease } from "../../shared/file-lease.js";
 import { shortenPath } from "../../shared/formatters.js";
 import { validateExecutionAcceptance } from "../shared/acceptance.js";
 import { previewSimpleWorkflowRun } from "../../workflows/scripted-workflow.js";
@@ -11,6 +13,9 @@ import { resolveGitRepositoryIdentity } from "../../workflows/chat-progress.js";
 import { getConfigDirName } from "../../shared/utils.js";
 import { normalizeWorktreeBaseRef } from "../shared/worktree.js";
 import { deepFreezeWorkflowArgs, normalizeWorkflowArgs } from "../../workflows/workflow-resources.js";
+import { readMission, resolveMissionStoreLocation, validateMissionId } from "../../missions/store.js";
+import { calendarDateAfter, latestCalendarOccurrence, nextCalendarOccurrence, normalizeCalendarRule, restoreCalendarTrigger } from "./calendar-schedule.js";
+import { reconcileAsyncRun } from "./stale-run-reconciler.js";
 export const SCHEDULED_RUN_ACTIONS = [
   "schedule.create",
   "schedule.list",
@@ -175,6 +180,16 @@ function resolveSharedGitConfigRoot(projectCwd) {
   }
   return;
 }
+function resolveHomeConfigRoot(projectPath) {
+  const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
+  try {
+    if (!samePath(fs.realpathSync.native(home), projectPath))
+      return;
+    return fs.realpathSync.native(path.join(home, getConfigDirName()));
+  } catch {
+    return;
+  }
+}
 function assertScheduleRoot(root, projectCwd, create) {
   if (!projectCwd) {
     if (create)
@@ -197,8 +212,10 @@ function assertScheduleRoot(root, projectCwd, create) {
     existing = parent;
   }
   const existingPath = fs.realpathSync.native(existing);
-  const sharedGitConfigRoot = pathWithin(projectPath, existingPath) ? undefined : resolveSharedGitConfigRoot(projectCwd);
-  const isTrustedPath = (candidate) => pathWithin(projectPath, candidate) || sharedGitConfigRoot !== undefined && pathWithin(sharedGitConfigRoot, candidate);
+  const withinProject = pathWithin(projectPath, existingPath);
+  const sharedGitConfigRoot = withinProject ? undefined : resolveSharedGitConfigRoot(projectCwd);
+  const homeConfigRoot = withinProject ? undefined : resolveHomeConfigRoot(projectPath);
+  const isTrustedPath = (candidate) => pathWithin(projectPath, candidate) || sharedGitConfigRoot !== undefined && pathWithin(sharedGitConfigRoot, candidate) || homeConfigRoot !== undefined && pathWithin(homeConfigRoot, candidate);
   if (!isTrustedPath(existingPath))
     throw new Error(`Project schedule root '${root}' resolves outside the real project.`);
   if (!create)
@@ -240,25 +257,31 @@ function parseScheduleTarget(value, file) {
   const target = value;
   if (typeof target.workflowScript === "string" && target.workflowScript.trim()) {
     let baseRef;
+    let missionId;
     try {
       baseRef = normalizeWorktreeBaseRef(target.baseRef);
     } catch (error) {
       throw new Error(`Schedule record '${file}' has an invalid baseRef: ${error instanceof Error ? error.message : String(error)}`);
     }
+    try {
+      missionId = target.missionId === undefined ? undefined : validateMissionId(target.missionId);
+    } catch (error) {
+      throw new Error(`Schedule record '${file}' has an invalid missionId: ${error instanceof Error ? error.message : String(error)}`);
+    }
     const normalizedArgs = normalizeWorkflowArgs(target.args);
     if ("error" in normalizedArgs)
       throw new Error(`Schedule record '${file}' has invalid args: ${normalizedArgs.error}`);
-    return { workflowScript: target.workflowScript.trim(), args: deepFreezeWorkflowArgs(normalizedArgs.args), ...baseRef === undefined ? {} : { baseRef } };
+    return { workflowScript: target.workflowScript.trim(), args: deepFreezeWorkflowArgs(normalizedArgs.args), ...baseRef === undefined ? {} : { baseRef }, ...missionId === undefined ? {} : { missionId } };
   }
   if (target.agent !== undefined || target.task !== undefined)
-    throw new Error(`Schedule record '${file}' uses a removed legacy agent target; recreate it with target.workflowScript.`);
+    throw new Error(`Schedule record '${file}' uses a removed legacy agent target; recreate it with schedule.create and workflow: true or a workflow script path.`);
   throw new Error(`Schedule record '${file}' requires a workflowScript target.`);
 }
 function parseSchedule(value, file) {
   if (!value || typeof value !== "object" || Array.isArray(value))
     throw new Error(`Schedule record '${file}' must be a JSON object.`);
   const record = value;
-  if (record.schemaVersion !== 1 || typeof record.id !== "string" || typeof record.name !== "string" || typeof record.cwd !== "string" || typeof record.createdAt !== "string" || typeof record.updatedAt !== "string" || typeof record.paused !== "boolean")
+  if (record.schemaVersion !== 1 && record.schemaVersion !== 2 || typeof record.id !== "string" || typeof record.name !== "string" || typeof record.cwd !== "string" || typeof record.createdAt !== "string" || typeof record.updatedAt !== "string" || typeof record.paused !== "boolean")
     throw new Error(`Schedule record '${file}' has invalid required fields.`);
   validateScheduleId(record.id);
   if (!record.trigger || typeof record.trigger !== "object" || !record.target || typeof record.target !== "object")
@@ -271,6 +294,8 @@ function parseSchedule(value, file) {
   } else if (record.trigger.kind === "interval") {
     if (typeof record.trigger.every !== "string" || typeof record.trigger.everyMs !== "number" || typeof record.trigger.anchorAt !== "string" || typeof record.trigger.nextRunAt !== "string")
       throw new Error(`Schedule record '${file}' has an invalid interval trigger.`);
+  } else if (record.trigger.kind === "calendar") {
+    restoreCalendarTrigger(record.trigger);
   } else
     throw new Error(`Schedule record '${file}' has an unsupported trigger.`);
   if (record.sessionOnly !== undefined && typeof record.sessionOnly !== "boolean")
@@ -279,7 +304,10 @@ function parseSchedule(value, file) {
     throw new Error(`Schedule record '${file}' has invalid quiet.`);
   if (record.sessionOnly === true && (typeof record.ownerSessionFile !== "string" || !record.ownerSessionFile.trim()))
     throw new Error(`Schedule record '${file}' is session-only but has no owner session file.`);
-  return { ...record, target: parseScheduleTarget(record.target, file) };
+  const target = parseScheduleTarget(record.target, file);
+  if (record.schemaVersion === 2 !== (target.missionId !== undefined))
+    throw new Error(`Schedule record '${file}' requires schemaVersion 2 exactly when missionId is present.`);
+  return { ...record, target };
 }
 
 class ScheduleStore {
@@ -328,14 +356,27 @@ class ScheduleStore {
       throw new Error(`Schedule history '${file}' has invalid fields.`);
     return value.runs;
   }
+  getRun(id, runId) {
+    if (!SCHEDULE_ID.test(runId))
+      throw new Error(`Invalid schedule run id '${runId}'.`);
+    const file = path.join(scheduleDir(this.root, id, false, this.projectCwd), "runs", `${runId}.json`);
+    if (!fs.existsSync(file))
+      return;
+    const run = readJson(file, "schedule run");
+    if (run?.id !== runId || run.scheduleId !== id)
+      throw new Error(`Schedule run '${file}' has invalid fields.`);
+    return run;
+  }
   writeRun(schedule, run, event) {
     const dir = scheduleDir(this.root, schedule.id, true, this.projectCwd);
     writePrivateAtomicJson(path.join(dir, "runs", `${run.id}.json`), run);
-    const runs = [run, ...this.history(schedule.id).filter((item) => item.id !== run.id)].slice(0, MAX_HISTORY);
-    writePrivateAtomicJson(path.join(dir, "history.json"), { schemaVersion: 1, runs });
-    fs.mkdirSync(dir, { recursive: true, mode: 448 });
-    fs.appendFileSync(path.join(dir, "events.jsonl"), `${JSON.stringify({ schemaVersion: 1, timestamp: new Date().toISOString(), event, scheduleId: schedule.id, runId: run.id, state: run.state })}
+    withFileLease(path.join(dir, "history.json"), () => {
+      const earlier = this.history(schedule.id).filter((item) => item.id !== run.id).map((item) => item.state === "running" ? this.getRun(schedule.id, item.id) ?? item : item);
+      const runs = [run, ...earlier].slice(0, MAX_HISTORY);
+      writePrivateAtomicJson(path.join(dir, "history.json"), { schemaVersion: 1, runs });
+      fs.appendFileSync(path.join(dir, "events.jsonl"), `${JSON.stringify({ schemaVersion: 1, timestamp: new Date().toISOString(), event, scheduleId: schedule.id, runId: run.id, state: run.state })}
 `, { encoding: "utf-8", mode: 384 });
+    });
   }
   appendEvent(schedule, event) {
     const dir = scheduleDir(this.root, schedule.id, true, this.projectCwd);
@@ -353,11 +394,14 @@ function hasPendingScheduleWork(schedule) {
 }
 function nextAfter(trigger, plannedAt, now) {
   if (trigger.kind === "once")
-    return;
-  let next = plannedAt + trigger.everyMs;
-  while (next <= now)
-    next += trigger.everyMs;
-  return timestamp(next);
+    return { ...trigger, nextRunAt: undefined };
+  if (trigger.kind === "calendar")
+    return {
+      ...trigger,
+      ...nextCalendarOccurrence(trigger, Math.max(plannedAt, now), calendarDateAfter(trigger, plannedAt, trigger.nextLocalDate))
+    };
+  const next = plannedAt + (Math.floor(Math.max(0, now - plannedAt) / trigger.everyMs) + 1) * trigger.everyMs;
+  return { ...trigger, nextRunAt: timestamp(next) };
 }
 function nextRunAt(schedule) {
   const value = schedule.trigger.nextRunAt;
@@ -370,9 +414,18 @@ function nextRunAt(schedule) {
 }
 function duePlannedAt(schedule, now) {
   const next = nextRunAt(schedule);
-  if (next === undefined || next > now || schedule.catchUp !== "latest" || schedule.trigger.kind !== "interval")
+  if (next === undefined || next > now || schedule.catchUp !== "latest")
     return next;
-  return next + Math.floor((now - next) / schedule.trigger.everyMs) * schedule.trigger.everyMs;
+  if (schedule.trigger.kind === "calendar")
+    return Date.parse(latestCalendarOccurrence(schedule.trigger, now, schedule.trigger.nextLocalDate).nextRunAt);
+  if (schedule.trigger.kind === "interval")
+    return next + Math.floor((now - next) / schedule.trigger.everyMs) * schedule.trigger.everyMs;
+  return next;
+}
+function triggerLabel(trigger) {
+  if (trigger.kind === "calendar")
+    return `every ${trigger.every}${trigger.on ? ` (${trigger.on.join(", ")})` : ""} at ${trigger.at} ${trigger.timezone}`;
+  return trigger.kind === "once" ? `at ${trigger.at}` : `every ${trigger.every}`;
 }
 function textResult(text, schedules, runs, isError = false) {
   const publicSchedules = schedules?.map(publicScheduleRecord);
@@ -388,22 +441,24 @@ function publicScheduleRecord(schedule) {
 }
 function targetLabel(target) {
   const preview = previewSimpleWorkflowRun(target.workflowScript);
-  return preview?.agent ? `workflowScript -> agent ${preview.agent}` : "workflowScript (dynamic)";
+  return preview?.agent ? `workflow -> agent ${preview.agent}` : "workflow (dynamic)";
 }
 function sanitizeTarget(params) {
   if (params.tasks || params.chain)
-    return { error: "Recurring schedules require workflowScript; legacy tasks and chain inputs are unsupported." };
+    return { error: "Recurring schedules require a workflow script; legacy tasks and chain inputs are unsupported." };
   if (params.agent !== undefined || params.task !== undefined)
-    return { error: `schedule.create requires workflowScript. Use workflowScript: "return runs.run('main', { agent, task })".` };
+    return { error: "schedule.create requires workflow: true or a workflow script path, e.g. a ```js workflow block containing return runs.run('main', { agent, task })." };
   if (typeof params.workflowScript !== "string" || !params.workflowScript.trim())
-    return { error: "schedule.create requires a non-empty workflowScript." };
+    return { error: "schedule.create requires workflow: true or a workflow script path." };
   if (params.context === "fork")
     return { error: "Scheduled runs require fresh context." };
   if (params.async === false)
     return { error: "Scheduled runs are always async." };
   let baseRef;
+  let missionId;
   try {
     baseRef = normalizeWorktreeBaseRef(params.baseRef);
+    missionId = params.missionId === undefined ? undefined : validateMissionId(params.missionId);
   } catch (error) {
     return { error: error instanceof Error ? error.message : String(error) };
   }
@@ -413,7 +468,7 @@ function sanitizeTarget(params) {
   const normalizedArgs = normalizeWorkflowArgs(params.args);
   if ("error" in normalizedArgs)
     return { error: normalizedArgs.error };
-  return { target: { workflowScript: params.workflowScript.trim(), args: deepFreezeWorkflowArgs(normalizedArgs.args), ...baseRef === undefined ? {} : { baseRef } } };
+  return { target: { workflowScript: params.workflowScript.trim(), args: deepFreezeWorkflowArgs(normalizedArgs.args), ...baseRef === undefined ? {} : { baseRef }, ...missionId === undefined ? {} : { missionId } } };
 }
 function executionParams(schedule, quiet = false) {
   return {
@@ -421,7 +476,7 @@ function executionParams(schedule, quiet = false) {
     async: true,
     context: "fresh",
     cwd: schedule.cwd,
-    mission: false,
+    ...schedule.target.missionId === undefined ? { mission: false } : {},
     scheduleOrigin: { id: schedule.id, ...schedule.name ? { name: schedule.name } : {}, ...quiet ? { quiet: true } : {} },
     ...schedule.timeoutMs === undefined ? {} : { timeoutMs: schedule.timeoutMs }
   };
@@ -551,8 +606,9 @@ export class ScheduledRunManager {
       for (const id of ids) {
         try {
           const schedule = store.get(id);
-          const run = store.history(id).find((item) => item.asyncId === asyncId && item.state === "running");
-          if (!run)
+          const listed = store.history(id).find((item) => item.asyncId === asyncId) ?? this.activeRun(store, schedule);
+          const run = listed && (store.getRun(id, listed.id) ?? listed);
+          if (run?.asyncId !== asyncId || run.state !== "running")
             continue;
           this.finishRun(store, schedule, run, data.success === true, typeof data.summary === "string" ? data.summary : undefined);
           return;
@@ -569,19 +625,20 @@ export class ScheduledRunManager {
       return textResult(target.error, undefined, undefined, true);
     const at = params.at?.trim();
     const every = params.every?.trim();
-    if (Boolean(at) === Boolean(every))
+    const calendar = every === "day" || every === "week";
+    if (!calendar && Boolean(at) === Boolean(every))
       return textResult("schedule.create requires exactly one trigger: at or every.", undefined, undefined, true);
     if (params.overlap !== undefined && params.overlap !== "skip")
       return textResult("This first recurring slice supports overlap='skip' only.", undefined, undefined, true);
     if (params.catchUp !== undefined && params.catchUp !== "none" && params.catchUp !== "latest")
       return textResult("catchUp must be 'none' or 'latest'.", undefined, undefined, true);
-    if (params.missionId !== undefined || params.mission !== undefined || params.missionUpdate !== undefined || params.missionStatus !== undefined || params.missionScope !== undefined)
-      return textResult("Mission attachment is deferred from this first schedule slice.", undefined, undefined, true);
-    if (params.on !== undefined || params.timezone !== undefined || every === "day" || every === "week" || every === "month" || every === "year")
-      return textResult("Calendar schedules are deferred from this first safe slice. Use a fixed interval such as every:'24h' or every:'7d'.", undefined, undefined, true);
+    if (params.mission !== undefined || params.missionUpdate !== undefined || params.missionStatus !== undefined || params.missionScope !== undefined)
+      return textResult("Schedules accept only an existing missionId; mission creation and updates are unsupported.", undefined, undefined, true);
+    if (!calendar && (params.on !== undefined || params.timezone !== undefined))
+      return textResult("on and timezone require every:'day' or every:'week'.", undefined, undefined, true);
     if (params.quiet !== undefined && typeof params.quiet !== "boolean")
       return textResult("quiet must be a boolean.", undefined, undefined, true);
-    if (at && params.quiet === true)
+    if (!calendar && at && params.quiet === true)
       return textResult("quiet is only supported for recurring schedules.", undefined, undefined, true);
     const sessionOnly = params.sessionOnly === true;
     if (sessionOnly && params.cwd !== undefined && !samePath(params.cwd, ctx.cwd))
@@ -589,6 +646,9 @@ export class ScheduledRunManager {
     const ownerSessionFile = sessionOnly ? ctx.sessionManager.getSessionFile() : undefined;
     if (sessionOnly && !ownerSessionFile)
       return textResult("sessionOnly schedules require a persisted current session.", undefined, undefined, true);
+    if (target.target.missionId !== undefined) {
+      readMission(resolveMissionStoreLocation({ projectRoot: path.resolve(params.cwd ?? ctx.cwd), ...this.deps.config.missions ? { config: this.deps.config.missions } : {} }), target.target.missionId);
+    }
     const sessionId = ctx.sessionManager.getSessionId() ?? "unknown";
     if (this.deps.resolveCapabilityCeiling?.(sessionId))
       return textResult("Cannot persist a schedule while a capability ceiling is active.", undefined, undefined, true);
@@ -601,7 +661,10 @@ export class ScheduledRunManager {
       return textResult(`Schedule '${id}' already exists.`, undefined, undefined, true);
     const now = this.now();
     let trigger;
-    if (at) {
+    if (calendar) {
+      const rule = normalizeCalendarRule({ every, at, on: params.on, timezone: params.timezone });
+      trigger = { kind: "calendar", ...rule, ...nextCalendarOccurrence(rule, now) };
+    } else if (at) {
       const planned = parseScheduledRunTime(at, now);
       trigger = { kind: "once", at, nextRunAt: timestamp(planned) };
     } else {
@@ -609,7 +672,7 @@ export class ScheduledRunManager {
       trigger = { kind: "interval", every, everyMs, anchorAt: timestamp(now), nextRunAt: timestamp(now + everyMs) };
     }
     const schedule = {
-      schemaVersion: 1,
+      schemaVersion: target.target.missionId === undefined ? 1 : 2,
       id,
       name: params.name?.trim() || targetLabel(target.target),
       cwd: path.resolve(params.cwd ?? ctx.cwd),
@@ -620,7 +683,7 @@ export class ScheduledRunManager {
       ...params.timeoutMs === undefined ? {} : { timeoutMs: params.timeoutMs },
       paused: false,
       ...sessionOnly ? { sessionOnly: true, ownerSessionFile: path.resolve(ownerSessionFile) } : {},
-      ...trigger.kind === "interval" && params.quiet === true ? { quiet: true } : {},
+      ...trigger.kind !== "once" && params.quiet === true ? { quiet: true } : {},
       createdAt: timestamp(now),
       updatedAt: timestamp(now)
     };
@@ -629,22 +692,23 @@ export class ScheduledRunManager {
     this.arm(schedule, store);
     return textResult(`Created schedule ${id}.
 Name: ${schedule.name}
-Trigger: ${at ? `at ${at}` : `every ${every}`}
+Trigger: ${triggerLabel(trigger)}
 Session only: ${schedule.sessionOnly === true ? "yes" : "no"}
 Quiet: ${schedule.quiet === true ? "yes" : "no"}
 Next: ${schedule.trigger.nextRunAt}
-Target: ${targetLabel(schedule.target)}`, [schedule]);
+Target: ${targetLabel(schedule.target)}${schedule.target.missionId === undefined ? "" : `
+Mission: ${schedule.target.missionId}`}`, [schedule]);
   }
   list() {
     const schedules = this.requireStore().list().sort((a, b) => (a.trigger.nextRunAt ?? "").localeCompare(b.trigger.nextRunAt ?? ""));
     if (!schedules.length)
       return textResult("No project schedules.", []);
-    return textResult([`Project schedules: ${schedules.length}`, ...schedules.map((item) => `- ${item.id} | ${item.paused ? "paused" : item.activeRunId ? "running" : "scheduled"} | ${item.trigger.nextRunAt ?? "no next run"} | ${item.sessionOnly === true ? "session-only" : "project"} | ${item.name}`)].join(`
+    return textResult([`Project schedules: ${schedules.length}`, ...schedules.map((item) => `- ${item.id} | ${item.paused ? "paused" : item.activeRunId ? "running" : "scheduled"} | ${item.trigger.nextRunAt ?? "no next run"} | ${item.sessionOnly === true ? "session-only" : "project"} | ${item.name}${item.target.missionId === undefined ? "" : ` | mission ${item.target.missionId}`}`)].join(`
 `), schedules);
   }
   show(params) {
     const schedule = this.resolve(params);
-    return textResult([`Schedule: ${schedule.id}`, `Name: ${schedule.name}`, `State: ${schedule.paused ? "paused" : schedule.activeRunId ? "running" : "scheduled"}`, `Session only: ${schedule.sessionOnly === true ? "yes" : "no"}`, `Quiet: ${schedule.quiet === true ? "yes" : "no"}`, `Target: ${targetLabel(schedule.target)}`, `CWD: ${shortenPath(schedule.cwd)}`, `Next: ${schedule.trigger.nextRunAt ?? "none"}`, `Catch up: ${schedule.catchUp}`, schedule.activeRunId ? `Active run: ${schedule.activeRunId}` : undefined].filter(Boolean).join(`
+    return textResult([`Schedule: ${schedule.id}`, `Name: ${schedule.name}`, `State: ${schedule.paused ? "paused" : schedule.activeRunId ? "running" : "scheduled"}`, `Session only: ${schedule.sessionOnly === true ? "yes" : "no"}`, `Quiet: ${schedule.quiet === true ? "yes" : "no"}`, `Target: ${targetLabel(schedule.target)}`, schedule.target.missionId === undefined ? undefined : `Mission: ${schedule.target.missionId}`, `CWD: ${shortenPath(schedule.cwd)}`, `Trigger: ${triggerLabel(schedule.trigger)}`, `Next: ${schedule.trigger.nextRunAt ?? "none"}`, `Catch up: ${schedule.catchUp}`, schedule.activeRunId ? `Active run: ${schedule.activeRunId}` : undefined].filter(Boolean).join(`
 `), [schedule]);
   }
   history(params) {
@@ -677,11 +741,19 @@ Target: ${targetLabel(schedule.target)}`, [schedule]);
     }
     if (params.quiet !== undefined && typeof params.quiet !== "boolean")
       return textResult("quiet must be a boolean.", undefined, undefined, true);
+    const manualTrigger = schedule.trigger;
     const run = await this.launch(store, schedule, this.now(), "manual", false, params.quiet === true);
     const updated = store.get(schedule.id);
     if (run.state === "running") {
       const now = this.now();
-      if (updated.trigger.kind === "interval")
+      if (updated.trigger.kind === "calendar") {
+        if (manualTrigger.kind !== "calendar")
+          throw new Error("Schedule trigger changed during manual launch.");
+        const consumed = latestCalendarOccurrence(manualTrigger, now, manualTrigger.nextLocalDate)?.nextRunAt ?? manualTrigger.nextRunAt;
+        const advanced = nextAfter(manualTrigger, Date.parse(consumed), now);
+        if (advanced.nextLocalDate > updated.trigger.nextLocalDate)
+          updated.trigger = advanced;
+      } else if (updated.trigger.kind === "interval")
         updated.trigger.nextRunAt = timestamp(now + updated.trigger.everyMs);
       else
         updated.trigger.nextRunAt = undefined;
@@ -710,7 +782,7 @@ Target: ${targetLabel(schedule.target)}`, [schedule]);
     const schedule = this.resolve(params);
     const store = this.requireStore();
     if (schedule.activeRunId) {
-      const run = store.history(schedule.id).find((item) => item.id === schedule.activeRunId);
+      const run = this.activeRun(store, schedule);
       let terminal = false;
       if (run?.scheduleId === schedule.id && run.state === "running" && run.asyncId && run.asyncDir) {
         const status = readJson(path.join(run.asyncDir, "status.json"), "async status");
@@ -731,20 +803,39 @@ Target: ${targetLabel(schedule.target)}`, [schedule]);
   restoreOne(store, schedule, notBefore, rearm = true) {
     if (!scheduleBelongsToSession(schedule, this.requireContext(store)))
       return;
+    if (schedule.trigger.kind === "calendar") {
+      const refreshed = restoreCalendarTrigger(schedule.trigger);
+      if (JSON.stringify(refreshed) !== JSON.stringify(schedule.trigger)) {
+        schedule.trigger = refreshed;
+        schedule.updatedAt = timestamp(this.now());
+        store.write(schedule);
+      }
+    }
     if (schedule.activeRunId) {
-      const run = store.history(schedule.id).find((item) => item.id === schedule.activeRunId);
+      const run = this.activeRun(store, schedule);
       if (run?.state === "running" && run.asyncId)
         this.observedAsyncIds.add(run.asyncId);
       const startedAt = run?.startedAt ? Date.parse(run.startedAt) : Number.NaN;
-      if (run?.state === "running" && run.asyncDir) {
+      const outcome = this.terminalAsyncOutcome(run);
+      if (run && outcome) {
+        let latest;
         try {
-          const status = readJson(path.join(run.asyncDir, "status.json"), "async status");
-          if (["complete", "failed", "stopped", "rejected"].includes(String(status.state)))
-            this.finishRun(store, schedule, run, status.state === "complete", typeof status.error === "string" ? status.error : undefined);
+          latest = this.finishRun(store, schedule, run, outcome.success, outcome.error, true) ?? store.find(schedule.id);
         } catch (error) {
-          if (error.code !== "ENOENT" && !(error instanceof Error && /ENOENT/.test(error.message)))
-            throw error;
+          if (rearm) {
+            try {
+              const current = store.find(schedule.id);
+              if (current)
+                this.arm(current, store, notBefore);
+            } catch {}
+          }
+          throw error;
+        }
+        if (!latest) {
+          this.clearTimer(store, schedule.id);
+          return;
         }
+        schedule = latest;
       }
       if (schedule.activeRunId && (!run || run.state !== "running" || !run.asyncId && Number.isFinite(startedAt) && startedAt + STALE_LAUNCH_CLAIM_MS <= this.now())) {
         if (run?.state === "running") {
@@ -797,9 +888,9 @@ Target: ${targetLabel(schedule.target)}`, [schedule]);
       if (!schedule)
         return;
       const now = this.now();
-      const planned = schedule.trigger.kind === "interval" ? duePlannedAt(schedule, now) : undefined;
-      const notBefore = planned !== undefined && planned <= now ? Date.parse(nextAfter(schedule.trigger, planned, now)) : undefined;
-      this.restoreOne(store, schedule, notBefore, schedule.trigger.kind === "interval");
+      const planned = schedule.trigger.kind !== "once" ? duePlannedAt(schedule, now) : undefined;
+      const notBefore = planned !== undefined && planned <= now ? Date.parse(nextAfter(schedule.trigger, planned, now).nextRunAt) : undefined;
+      this.restoreOne(store, schedule, notBefore, schedule.trigger.kind !== "once");
     } catch (error) {
       console.warn(`[dm-subagents] Scheduled run '${id}' could not be restored after fire failure: ${error instanceof Error ? error.message : String(error)}`);
     }
@@ -821,12 +912,29 @@ Target: ${targetLabel(schedule.target)}`, [schedule]);
   async launch(store, schedule, planned, dueReason, advance, quiet) {
     const now = this.now();
     const nextRunAtBeforeClaim = schedule.trigger.nextRunAt;
+    const nextLocalDateBeforeClaim = schedule.trigger.kind === "calendar" ? schedule.trigger.nextLocalDate : undefined;
     const run = { schemaVersion: 1, id: this.randomId(), scheduleId: schedule.id, plannedAt: timestamp(planned), dueReason, state: "running", startedAt: timestamp(now) };
+    if (schedule.activeRunId) {
+      let active;
+      let outcome;
+      try {
+        active = this.activeRun(store, schedule);
+        outcome = this.terminalAsyncOutcome(active);
+      } catch (error) {
+        console.warn(`[dm-subagents] Could not reconcile active run '${schedule.activeRunId}' of schedule '${schedule.id}': ${error instanceof Error ? error.message : String(error)}`);
+      }
+      if (active && outcome) {
+        const released = this.finishRun(store, schedule, active, outcome.success, outcome.error, true);
+        if (!released)
+          return this.skipLostClaim(store, schedule.id, run, planned, now);
+        schedule = released;
+      }
+    }
     if (schedule.activeRunId) {
       run.state = "skipped";
       run.completedAt = timestamp(now);
       if (advance) {
-        schedule.trigger.nextRunAt = nextAfter(schedule.trigger, planned, now);
+        schedule.trigger = nextAfter(schedule.trigger, planned, now);
         schedule.updatedAt = timestamp(now);
         store.write(schedule);
       }
@@ -842,26 +950,45 @@ Target: ${targetLabel(schedule.target)}`, [schedule]);
       fs.writeFileSync(lock, run.id, "utf-8");
       fs.closeSync(lock);
     } catch (error) {
-      if (error.code !== "EEXIST")
+      if (lock !== undefined) {
+        try {
+          const owned = fs.fstatSync(lock, { bigint: true });
+          const current = fs.lstatSync(lockPath, { bigint: true });
+          if (owned.ino !== 0n && owned.dev === current.dev && owned.ino === current.ino)
+            fs.rmSync(lockPath);
+        } catch {}
+        try {
+          fs.closeSync(lock);
+        } catch {}
         throw error;
-      run.state = "skipped";
-      run.completedAt = timestamp(now);
-      if (advance) {
-        schedule.trigger.nextRunAt = nextAfter(schedule.trigger, planned, now);
-        schedule.updatedAt = timestamp(now);
-        store.write(schedule);
       }
-      store.writeRun(schedule, run, "schedule.skipped_overlap");
-      this.arm(schedule, store);
-      return run;
+      if (error.code !== "EEXIST")
+        throw error;
+      return this.skipLostClaim(store, schedule.id, run, planned, now);
     }
     schedule.activeRunId = run.id;
     schedule.lastRunId = run.id;
     if (advance)
-      schedule.trigger.nextRunAt = nextAfter(schedule.trigger, planned, now);
+      schedule.trigger = nextAfter(schedule.trigger, planned, now);
     schedule.updatedAt = timestamp(now);
-    store.write(schedule);
-    store.writeRun(schedule, run, "schedule.run.started");
+    try {
+      store.write(schedule);
+      store.writeRun(schedule, run, "schedule.run.started");
+    } catch (error) {
+      try {
+        const latest = store.find(schedule.id);
+        if (latest?.activeRunId === run.id) {
+          latest.activeRunId = undefined;
+          latest.updatedAt = timestamp(this.now());
+          store.write(latest);
+        }
+        if (fs.readFileSync(lockPath, "utf-8") === run.id)
+          fs.rmSync(lockPath);
+      } catch (cleanupError) {
+        console.warn(`[dm-subagents] Could not release schedule claim '${run.id}': ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+      }
+      throw error;
+    }
     try {
       const result = await this.deps.launch(executionParams(schedule, dueReason === "manual" ? quiet === true : schedule.quiet === true), this.requireContext(store), new AbortController().signal);
       const asyncId = result.details?.asyncId ?? result.details?.runId;
@@ -874,27 +1001,48 @@ Target: ${targetLabel(schedule.target)}`, [schedule]);
       this.arm(schedule, store);
       return run;
     } catch (error) {
+      if (run.asyncId)
+        throw new Error(`Scheduled run '${run.id}' attached to async run '${run.asyncId}', but recording it failed: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
       run.state = "failed_launch";
       run.completedAt = timestamp(this.now());
       run.error = error instanceof Error ? error.message : String(error);
       const latest = store.get(schedule.id);
       latest.activeRunId = undefined;
-      if (!advance && nextRunAtBeforeClaim)
-        latest.trigger.nextRunAt = nextRunAtBeforeClaim;
+      if (!advance && nextRunAtBeforeClaim) {
+        if (latest.trigger.kind === "calendar") {
+          if (nextLocalDateBeforeClaim !== undefined) {
+            latest.trigger.nextLocalDate = nextLocalDateBeforeClaim;
+            latest.trigger.nextRunAt = nextRunAtBeforeClaim;
+          }
+        } else
+          latest.trigger.nextRunAt = nextRunAtBeforeClaim;
+      }
       latest.updatedAt = timestamp(this.now());
       store.write(latest);
-      store.writeRun(latest, run, "schedule.run.failed");
       fs.rmSync(lockPath, { force: true });
-      this.arm(latest, store);
+      try {
+        store.writeRun(latest, run, "schedule.run.failed");
+      } finally {
+        this.arm(latest, store);
+      }
       return run;
     }
   }
-  finishRun(store, schedule, run, success, error) {
+  finishRun(store, schedule, run, success, error, releaseOnly = false) {
     const now = this.now();
+    if (run.asyncId)
+      this.observedAsyncIds.delete(run.asyncId);
+    if (releaseOnly) {
+      const latest = store.find(schedule.id);
+      if (latest?.activeRunId !== run.id)
+        return;
+      schedule = latest;
+    }
     const next = nextRunAt(schedule);
-    if (next !== undefined && next <= now) {
+    let skipped;
+    if (!releaseOnly && next !== undefined && next <= now) {
       const planned = duePlannedAt(schedule, now);
-      const skipped = {
+      skipped = {
         schemaVersion: 1,
         id: this.randomId(),
         scheduleId: schedule.id,
@@ -903,11 +1051,8 @@ Target: ${targetLabel(schedule.target)}`, [schedule]);
         state: "skipped",
         completedAt: timestamp(now)
       };
-      schedule.trigger.nextRunAt = nextAfter(schedule.trigger, planned, now);
-      store.writeRun(schedule, skipped, "schedule.skipped_overlap");
+      schedule.trigger = nextAfter(schedule.trigger, planned, now);
     }
-    if (run.asyncId)
-      this.observedAsyncIds.delete(run.asyncId);
     run.state = success ? "completed" : "failed_run";
     run.completedAt = timestamp(now);
     if (!success && error)
@@ -915,9 +1060,41 @@ Target: ${targetLabel(schedule.target)}`, [schedule]);
     schedule.activeRunId = undefined;
     schedule.updatedAt = timestamp(now);
     store.write(schedule);
-    fs.rmSync(path.join(store.directory(schedule.id), "active.lock"), { force: true });
-    store.writeRun(schedule, run, success ? "schedule.run.completed" : "schedule.run.failed");
-    this.arm(schedule, store);
+    const lockPath = path.join(store.directory(schedule.id), "active.lock");
+    let holder;
+    if (releaseOnly)
+      try {
+        holder = fs.readFileSync(lockPath, "utf-8");
+      } catch {}
+    if (!releaseOnly || holder === run.id)
+      fs.rmSync(lockPath, { force: true });
+    try {
+      store.writeRun(schedule, run, success ? "schedule.run.completed" : "schedule.run.failed");
+      if (skipped)
+        store.writeRun(schedule, skipped, "schedule.skipped_overlap");
+    } finally {
+      if (!releaseOnly)
+        this.arm(schedule, store);
+    }
+    return schedule;
+  }
+  skipLostClaim(store, scheduleId, run, planned, now) {
+    run.state = "skipped";
+    run.completedAt = timestamp(now);
+    const latest = store.find(scheduleId);
+    if (!latest) {
+      this.clearTimer(store, scheduleId);
+      return run;
+    }
+    store.writeRun(latest, run, "schedule.skipped_overlap");
+    if (latest.trigger.kind === "once") {
+      this.clearTimer(store, latest.id);
+    } else {
+      const next = nextRunAt(latest);
+      const notBefore = next !== undefined && next <= now ? Date.parse(nextAfter(latest.trigger, duePlannedAt(latest, now) ?? planned, now).nextRunAt) : undefined;
+      this.arm(latest, store, notBefore);
+    }
+    return run;
   }
   recordMissed(store, schedule, planned, dueReason) {
     const run = {
@@ -929,7 +1106,7 @@ Target: ${targetLabel(schedule.target)}`, [schedule]);
       state: "missed",
       completedAt: timestamp(this.now())
     };
-    schedule.trigger.nextRunAt = nextAfter(schedule.trigger, planned, this.now());
+    schedule.trigger = nextAfter(schedule.trigger, planned, this.now());
     schedule.updatedAt = timestamp(this.now());
     store.write(schedule);
     store.writeRun(schedule, run, "schedule.missed");
@@ -972,6 +1149,20 @@ Target: ${targetLabel(schedule.target)}`, [schedule]);
       throw new Error("Schedule runtime context is unavailable.");
     return ctx;
   }
+  activeRun(store, schedule) {
+    if (!schedule.activeRunId)
+      return;
+    return store.getRun(schedule.id, schedule.activeRunId) ?? store.history(schedule.id).find((run) => run.id === schedule.activeRunId);
+  }
+  terminalAsyncOutcome(run) {
+    if (run?.state !== "running" || !run.asyncDir)
+      return;
+    const status = reconcileAsyncRun(run.asyncDir, { now: this.now, kill: this.deps.kill }).status;
+    if (!status || !["complete", "failed", "stopped", "rejected"].includes(status.state))
+      return;
+    const error = [status.error, ...(status.steps ?? []).map((step) => step.error)].find((value) => typeof value === "string");
+    return { success: status.state === "complete", error };
+  }
   timerKey(store, id) {
     return `${store.root}\x00${id}`;
   }