@dcrays/scheduled-task 0.1.4 → 0.1.6-beta.1

package/plugin/index.js

@@ -1,14 +1,14 @@
 import { createRequire as __mobookCreateRequire } from 'node:module'; const require = __mobookCreateRequire(import.meta.url);
 
-// dist-npm/plugin/index.js
+// dist/plugin/index.js
 import { existsSync as existsSync3 } from "node:fs";
-import path4 from "node:path";
+import path5 from "node:path";
 import { Service } from "@deepseek-ai/cordis";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
 import { defineTool } from "@deepseek-ai/dsh-tools";
 import z from "@deepseek-ai/schemastery";
 
-// dist-npm/src/cron.js
+// dist/src/cron.js
 var FIELD_COUNT = 5;
 var MAX_SEARCH_DAYS = 366 * 8;
 var GREGORIAN_CYCLE_DAYS = 146097;
@@ -34,7 +34,7 @@ function parseInteger(value, label) {
 }
 function parseField(raw, min, max, label, normalize) {
   const values = /* @__PURE__ */ new Set();
-  const wildcard = raw === "*" || raw.startsWith("*/");
+  const wildcard = raw === "*";
   if (raw.length === 0)
     throw new CronExpressionError(`${label} is empty`);
   for (const segment of raw.split(",")) {
@@ -208,10 +208,10 @@ function nextCronOccurrence(afterEpochMs, cron, timeZone) {
   throw new CronExpressionError("cron expression has no occurrence within the next eight years");
 }
 
-// dist-npm/src/manager.js
+// dist/src/manager.js
 import { createHash } from "node:crypto";
 
-// dist-npm/src/protocol.js
+// dist/src/protocol.js
 var CRON_CREATE_TYPE = "dsh/cron.create";
 var CRON_LIST_TYPE = "dsh/cron.list";
 var CronAutomationInputError = class extends Error {
@@ -302,7 +302,7 @@ function parseCronEditorRequest(message) {
   return { id, text };
 }
 
-// dist-npm/src/repository.js
+// dist/src/repository.js
 import fs from "node:fs";
 import path from "node:path";
 import { DatabaseSync } from "node:sqlite";
@@ -579,6 +579,11 @@ var CronAutomationRepository = class {
     } catch {
     }
   }
+  hasLegacyMigration(migrationId) {
+    this.assertOpen();
+    const table = this.database.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'cron_migrations'").get();
+    return Boolean(table && this.database.prepare("SELECT 1 FROM cron_migrations WHERE migration_id = ?").get(migrationId));
+  }
   async load() {
     this.assertOpen();
     const rows = this.database.prepare(`
@@ -634,6 +639,24 @@ var CronAutomationRepository = class {
       return [];
     return this.database.prepare("SELECT source, job_id FROM cron_imported_jobs").all().map((row) => ({ source: row.source, jobId: row.job_id }));
   }
+  /** Only a verified complete source snapshot may authorize these deletions. */
+  async removeMissingImportedJobs(source, presentIds) {
+    this.assertWritable();
+    if (!source.trim())
+      throw new Error("cron import source must be non-empty");
+    return this.writeTransaction(() => {
+      const rows = this.database.prepare(`
+        SELECT jobs.job_id FROM cron_jobs AS jobs
+        INNER JOIN cron_imported_jobs AS imported ON imported.job_id = jobs.job_id
+        WHERE jobs.store_key = ? AND imported.source = ?
+      `).all(STORE_KEY, source);
+      const removed = rows.map((row) => row.job_id).filter((id) => !presentIds.has(id));
+      const statement = this.database.prepare("DELETE FROM cron_jobs WHERE store_key = ? AND job_id = ?");
+      for (const id of removed)
+        statement.run(STORE_KEY, id);
+      return removed;
+    });
+  }
   async migrateLegacy(migrationId, incoming, importedJobs) {
     this.assertWritable();
     const decoded = uniqueJobs(incoming);
@@ -714,8 +737,9 @@ var CronAutomationRepository = class {
   }
 };
 
-// dist-npm/src/manager.js
+// dist/src/manager.js
 var MAX_TIMER_DELAY_MS = 2147483647;
+var DELIVERY_RETRY_DELAY_MS = 3e4;
 function automationId(agentId, requestId) {
   return `cron-${createHash("sha256").update(`${agentId}\0${requestId}`).digest("hex").slice(0, 24)}`;
 }
@@ -802,15 +826,25 @@ var CronAutomationManager = class {
   options;
   jobs = /* @__PURE__ */ new Map();
   blockedAgents = /* @__PURE__ */ new Set();
+  blockedUntil = /* @__PURE__ */ new Map();
+  activeJobs = /* @__PURE__ */ new Set();
+  inflight = /* @__PURE__ */ new Set();
   now;
   started;
   tail = Promise.resolve();
+  dispatchLoop = Promise.resolve();
   timer;
   stopping = false;
+  schedulingPaused;
   constructor(repository, options) {
     this.repository = repository;
     this.options = options;
     this.now = options.now ?? Date.now;
+    this.schedulingPaused = options.startPaused ?? false;
+  }
+  resumeScheduling() {
+    this.schedulingPaused = false;
+    this.arm();
   }
   start() {
     return this.started ??= this.initialize();
@@ -842,6 +876,8 @@ var CronAutomationManager = class {
       clearTimeout(this.timer);
     this.timer = void 0;
     try {
+      await this.dispatchLoop.catch(() => void 0);
+      await Promise.all([...this.inflight]);
       await this.tail;
     } finally {
       this.repository.close();
@@ -1012,31 +1048,12 @@ var CronAutomationManager = class {
   }
   async runOnceStatus(jobId) {
     await this.start();
-    return this.enqueue(async () => {
-      const job = this.jobs.get(jobId);
-      if (!job)
-        return "not_found";
-      if (job.state.runningAtMs !== void 0)
-        return "already_running";
-      if (!hasDshSession(job))
-        return "delivery_unavailable";
-      const occurrenceAtMs = this.now();
-      job.state.runningAtMs = occurrenceAtMs;
-      job.updatedAtMs = occurrenceAtMs;
-      await this.repository.upsert([job]);
-      const delivered = await this.deliver(job, occurrenceAtMs);
-      delete job.state.runningAtMs;
-      job.state.lastRunAtMs = occurrenceAtMs;
-      job.state.lastRunStatus = delivered ? "ok" : "skipped";
-      job.updatedAtMs = this.now();
-      await this.repository.upsert([job]);
-      if (delivered) {
-        this.options.onDispatched?.(cloneJob(job), new Date(occurrenceAtMs).toISOString());
-        return "dispatched";
-      }
-      this.options.onChanged?.(cloneJob(job));
-      return "delivery_unavailable";
-    });
+    const claimed = await this.enqueue(() => this.claimManualRun(jobId));
+    if (claimed.kind === "status")
+      return claimed.status;
+    const delivered = await this.deliverTracked(claimed.job, claimed.occurrenceAtMs);
+    await this.enqueue(() => this.finalizeManualRun(claimed.job.id, claimed.occurrenceAtMs, delivered));
+    return delivered ? "dispatched" : "delivery_unavailable";
   }
   async runOnce(jobId) {
     return await this.runOnceStatus(jobId) === "dispatched";
@@ -1047,10 +1064,25 @@ var CronAutomationManager = class {
     return [...this.jobs.values()].filter((job) => agentId === void 0 || dshAgentIdFor(job) === agentId).sort((left, right) => left.createdAtMs - right.createdAtMs || left.id.localeCompare(right.id)).map(cloneJob);
   }
   notifyAgentAvailable(agentId) {
-    if (!this.blockedAgents.delete(agentId))
-      return;
+    this.blockedAgents.delete(agentId);
+    this.blockedUntil.delete(agentId);
     this.requestDispatch();
   }
+  /** Reflect deletions only for ids recorded in this source's import ledger. */
+  async reconcileImportedDeletions(source, presentIds) {
+    await this.start();
+    return this.enqueue(async () => {
+      const removed = await this.repository.removeMissingImportedJobs(source, presentIds);
+      for (const id of removed) {
+        const job = this.jobs.get(id);
+        this.jobs.delete(id);
+        if (job)
+          this.options.onChanged?.(cloneJob(job));
+      }
+      this.arm();
+      return removed;
+    });
+  }
   /** Import each source job once. Existing ids win so DSH bindings stay intact. */
   async importFrom(source, incoming) {
     await this.start();
@@ -1107,22 +1139,124 @@ var CronAutomationManager = class {
       return false;
     }
   }
+  async deliverTracked(job, occurrenceAtMs) {
+    const work = this.deliver(job, occurrenceAtMs);
+    this.inflight.add(work);
+    try {
+      return await work;
+    } finally {
+      this.inflight.delete(work);
+    }
+  }
+  async claimManualRun(jobId) {
+    if (this.stopping)
+      return { kind: "status", status: "delivery_unavailable" };
+    if (this.activeJobs.has(jobId))
+      return { kind: "status", status: "already_running" };
+    const job = this.jobs.get(jobId);
+    if (!job)
+      return { kind: "status", status: "not_found" };
+    if (job.state.runningAtMs !== void 0)
+      return { kind: "status", status: "already_running" };
+    if (!hasDshSession(job))
+      return { kind: "status", status: "delivery_unavailable" };
+    const occurrenceAtMs = this.now();
+    this.activeJobs.add(jobId);
+    job.state.runningAtMs = occurrenceAtMs;
+    job.updatedAtMs = occurrenceAtMs;
+    try {
+      await this.repository.upsert([job]);
+    } catch (error) {
+      this.activeJobs.delete(jobId);
+      delete job.state.runningAtMs;
+      throw error;
+    }
+    return { kind: "ready", job: cloneJob(job), occurrenceAtMs };
+  }
+  async finalizeManualRun(jobId, occurrenceAtMs, delivered) {
+    this.activeJobs.delete(jobId);
+    const job = this.jobs.get(jobId);
+    if (!job)
+      return;
+    delete job.state.runningAtMs;
+    job.state.lastRunAtMs = occurrenceAtMs;
+    job.state.lastRunStatus = delivered ? "ok" : "skipped";
+    job.updatedAtMs = this.now();
+    await this.repository.upsert([job]);
+    if (delivered)
+      this.options.onDispatched?.(cloneJob(job), new Date(occurrenceAtMs).toISOString());
+    else
+      this.options.onChanged?.(cloneJob(job));
+  }
+  async claimNextDueJob() {
+    if (this.stopping || this.schedulingPaused)
+      return void 0;
+    const now = this.now();
+    const job = [...this.jobs.values()].filter((candidate) => candidate.enabled && hasDshSession(candidate) && candidate.state.runningAtMs === void 0 && !this.activeJobs.has(candidate.id) && candidate.state.nextRunAtMs !== void 0 && candidate.state.nextRunAtMs <= now && (!this.blockedAgents.has(dshAgentIdFor(candidate)) || (this.blockedUntil.get(dshAgentIdFor(candidate)) ?? 0) <= now)).sort((left, right) => (left.state.nextRunAtMs ?? 0) - (right.state.nextRunAtMs ?? 0) || left.createdAtMs - right.createdAtMs)[0];
+    if (!job)
+      return void 0;
+    const occurrenceAtMs = job.state.nextRunAtMs ?? now;
+    this.activeJobs.add(job.id);
+    job.state.runningAtMs = now;
+    job.updatedAtMs = now;
+    try {
+      await this.repository.upsert([job]);
+    } catch (error) {
+      this.activeJobs.delete(job.id);
+      delete job.state.runningAtMs;
+      throw error;
+    }
+    return { job: cloneJob(job), occurrenceAtMs };
+  }
+  async finalizeScheduledRun(jobId, occurrenceAtMs, delivered) {
+    this.activeJobs.delete(jobId);
+    const job = this.jobs.get(jobId);
+    if (!job)
+      return;
+    const now = this.now();
+    delete job.state.runningAtMs;
+    job.state.lastRunAtMs = now;
+    job.state.lastRunStatus = delivered ? "ok" : "skipped";
+    job.updatedAtMs = now;
+    if (!delivered) {
+      this.blockedAgents.add(dshAgentIdFor(job));
+      this.blockedUntil.set(dshAgentIdFor(job), now + DELIVERY_RETRY_DELAY_MS);
+      await this.repository.upsert([job]);
+      this.options.onChanged?.(cloneJob(job));
+      return;
+    }
+    this.blockedAgents.delete(dshAgentIdFor(job));
+    this.blockedUntil.delete(dshAgentIdFor(job));
+    if (job.deleteAfterRun === true || job.schedule.kind === "at") {
+      this.jobs.delete(jobId);
+      await this.repository.delete(jobId);
+    } else {
+      if (job.enabled)
+        setNextOccurrence(job, nextOccurrence(now, job.schedule));
+      await this.repository.upsert([job]);
+    }
+    this.options.onDispatched?.(cloneJob(job), new Date(occurrenceAtMs).toISOString());
+  }
   enqueue(operation) {
     const run = this.tail.then(operation);
     this.tail = run.then(() => void 0, () => void 0);
     return run;
   }
   requestDispatch() {
-    void this.enqueue(() => this.dispatchDue()).catch((error) => this.options.onError?.(error));
+    this.dispatchLoop = this.dispatchLoop.then(() => this.dispatchDue(), () => this.dispatchDue());
+    void this.dispatchLoop.catch((error) => this.options.onError?.(error));
   }
   arm() {
-    if (this.stopping)
+    if (this.stopping || this.schedulingPaused)
       return;
     if (this.timer)
       clearTimeout(this.timer);
     this.timer = void 0;
     const now = this.now();
-    const target = [...this.jobs.values()].filter((job) => job.enabled && hasDshSession(job) && job.state.runningAtMs === void 0 && !this.blockedAgents.has(dshAgentIdFor(job))).map((job) => job.state.nextRunAtMs).filter((value) => value !== void 0).reduce((earliest, candidate) => earliest === void 0 || candidate < earliest ? candidate : earliest, void 0);
+    const target = [...this.jobs.values()].filter((job) => job.enabled && hasDshSession(job) && job.state.runningAtMs === void 0 && (!this.blockedAgents.has(dshAgentIdFor(job)) || (this.blockedUntil.get(dshAgentIdFor(job)) ?? 0) <= now)).map((job) => {
+      const retryAt = this.blockedUntil.get(dshAgentIdFor(job));
+      return retryAt !== void 0 && retryAt > now ? retryAt : job.state.nextRunAtMs;
+    }).filter((value) => value !== void 0).reduce((earliest, candidate) => earliest === void 0 || candidate < earliest ? candidate : earliest, void 0);
     if (target === void 0)
       return;
     const delay = Math.max(0, Math.min(target - now, MAX_TIMER_DELAY_MS));
@@ -1133,40 +1267,22 @@ var CronAutomationManager = class {
     this.timer.unref();
   }
   async dispatchDue() {
-    if (this.stopping)
+    if (this.stopping || this.schedulingPaused)
       return;
-    const now = this.now();
-    const due = [...this.jobs.values()].filter((job) => job.enabled && hasDshSession(job) && job.state.nextRunAtMs !== void 0 && job.state.nextRunAtMs <= now).sort((left, right) => (left.state.nextRunAtMs ?? 0) - (right.state.nextRunAtMs ?? 0) || left.createdAtMs - right.createdAtMs);
-    for (const job of due) {
-      const occurrenceAtMs = job.state.nextRunAtMs ?? now;
-      job.state.runningAtMs = now;
-      job.updatedAtMs = now;
-      await this.repository.upsert([job]);
-      const delivered = await this.deliver(job, occurrenceAtMs);
-      delete job.state.runningAtMs;
-      job.state.lastRunAtMs = now;
-      job.state.lastRunStatus = delivered ? "ok" : "skipped";
-      job.updatedAtMs = now;
-      if (!delivered) {
-        this.blockedAgents.add(dshAgentIdFor(job));
-        await this.repository.upsert([job]);
-        this.options.onChanged?.(cloneJob(job));
-        continue;
-      }
-      if (job.deleteAfterRun === true || job.schedule.kind === "at") {
-        this.jobs.delete(job.id);
-        await this.repository.delete(job.id);
-      } else {
-        setNextOccurrence(job, nextOccurrence(now, job.schedule));
-        await this.repository.upsert([job]);
-      }
-      this.options.onDispatched?.(cloneJob(job), new Date(occurrenceAtMs).toISOString());
+    for (; ; ) {
+      const claimed = await this.enqueue(() => this.claimNextDueJob());
+      if (!claimed)
+        break;
+      const delivered = await this.deliverTracked(claimed.job, claimed.occurrenceAtMs);
+      await this.enqueue(() => this.finalizeScheduledRun(claimed.job.id, claimed.occurrenceAtMs, delivered));
     }
-    this.arm();
+    await this.enqueue(async () => {
+      this.arm();
+    });
   }
 };
 
-// dist-npm/src/openclaw-sqlite.js
+// dist/src/openclaw-sqlite.js
 import { existsSync, realpathSync } from "node:fs";
 import { chmod, mkdir, rename, unlink } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
@@ -1268,12 +1384,12 @@ function jobFromOpenClawRow(row) {
 }
 function loadOpenClawSqliteJobsWithDiagnostics(sqlitePath) {
   if (!existsSync(sqlitePath))
-    return { jobs: [], skipped: [] };
+    return { jobs: [], skipped: [], complete: false };
   const database = new DatabaseSync2(sqlitePath, { readOnly: true, timeout: 5e3 });
   try {
     const table = database.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'cron_jobs'").get();
     if (!table)
-      return { jobs: [], skipped: [] };
+      return { jobs: [], skipped: [], complete: false };
     const rows = database.prepare("SELECT * FROM cron_jobs ORDER BY updated_at ASC, job_id ASC").all();
     const jobs = /* @__PURE__ */ new Map();
     const skipped = [];
@@ -1290,7 +1406,7 @@ function loadOpenClawSqliteJobsWithDiagnostics(sqlitePath) {
         });
       }
     }
-    return { jobs: [...jobs.values()], skipped };
+    return { jobs: [...jobs.values()], skipped, complete: skipped.length === 0 };
   } finally {
     database.close();
   }
@@ -1337,9 +1453,38 @@ function openClawImportSource(sqlitePath) {
   return `openclaw-sqlite:${canonical}`;
 }
 
-// dist-npm/src/runtime-environment.js
+// dist/src/output.js
+import { createHash as createHash2 } from "node:crypto";
+import { mkdirSync } from "node:fs";
 import path3 from "node:path";
-import { existsSync as existsSync2, readFileSync, realpathSync as realpathSync2 } from "node:fs";
+import { resolveDshHome } from "@deepseek-ai/dsh-home-paths";
+function resolveTaskOutputRoot(globalOutput, workspace) {
+  const output = path3.resolve(globalOutput);
+  if (!workspace)
+    return output;
+  const resolved = path3.resolve(workspace);
+  if (resolved === output)
+    return output;
+  const workspaceFolder = path3.dirname(output);
+  const home = path3.dirname(workspaceFolder);
+  if (resolved === home || resolved === workspaceFolder)
+    return output;
+  return path3.join(resolved, "output");
+}
+function cronOutputDirectory(cronId, workspace, dshHome = resolveDshHome()) {
+  const segment = (value) => createHash2("sha256").update(value).digest("hex").slice(0, 24);
+  const base = resolveTaskOutputRoot(path3.join(dshHome, "workspace", "output"), workspace);
+  const root = path3.join(base, segment(`cron:${cronId}`));
+  for (const directory of ["files", "tmp", "previews", "downloads"]) {
+    mkdirSync(path3.join(root, directory), { recursive: true });
+  }
+  return root;
+}
+
+// dist/src/runtime-environment.js
+import { randomUUID as randomUUID2 } from "node:crypto";
+import path4 from "node:path";
+import { existsSync as existsSync2, linkSync, mkdirSync as mkdirSync2, readFileSync, realpathSync as realpathSync2, unlinkSync, writeFileSync } from "node:fs";
 import { dshHomePath as dshHomePath2 } from "@deepseek-ai/dsh-home-paths";
 var CRON_RUNTIME_ENVIRONMENTS = ["development", "test", "production"];
 function resolveCronRuntimeEnvironment(value) {
@@ -1350,32 +1495,123 @@ function resolveCronRuntimeEnvironment(value) {
   throw new Error(`Unsupported cron runtime environment: ${environment}`);
 }
 function readDesktopRuntimeEnvironment() {
+  let contents;
+  try {
+    contents = readFileSync(dshHomePath2("mobook.json"), "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return void 0;
+    throw error;
+  }
+  let parsed;
   try {
-    const parsed = JSON.parse(readFileSync(dshHomePath2("mobook.json"), "utf8"));
-    const value = parsed && typeof parsed === "object" ? parsed.environment : void 0;
-    return typeof value === "string" && value.trim() ? value.trim() : void 0;
+    parsed = JSON.parse(contents);
   } catch {
+    throw new Error(`Invalid mobook.json: ${dshHomePath2("mobook.json")}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Unsupported mobook.json root value: ${dshHomePath2("mobook.json")}`);
+  }
+  const value = parsed.environment;
+  if (value === void 0)
     return void 0;
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error("mobook.json environment must be a non-empty string");
   }
+  return value.trim();
 }
 function cronRuntimePath(environment, ...segments) {
   return dshHomePath2("cron", environment, ...segments);
 }
 function resolveCronDatabaseFile(configured, environment) {
-  return configured?.trim() ? path3.resolve(configured) : cronRuntimePath(environment, "cron.sqlite");
+  return configured?.trim() ? path4.resolve(configured) : cronRuntimePath(environment, "cron.sqlite");
+}
+function resolveLegacyCronOwner(configured, recordedEnvironment = void 0, runtimeEnvironment = "production") {
+  if (configured?.trim())
+    return resolveCronRuntimeEnvironment(configured);
+  if (recordedEnvironment?.trim())
+    return "production";
+  return runtimeEnvironment;
 }
-function resolveLegacyCronOwner(value) {
-  return resolveCronRuntimeEnvironment(value?.trim() || "production");
+function legacyCronOwnerFile() {
+  return dshHomePath2("cron", "legacy-owner.json");
+}
+function readLegacyCronOwner(file) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(file, "utf8"));
+  } catch (cause) {
+    throw new Error(`Invalid legacy cron owner marker: ${file}`, { cause });
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Invalid legacy cron owner marker: ${file}`);
+  }
+  const record = parsed;
+  if (record.version !== 1 || !CRON_RUNTIME_ENVIRONMENTS.includes(record.owner)) {
+    throw new Error(`Invalid legacy cron owner marker: ${file}`);
+  }
+  return record.owner;
+}
+function previouslyMigratedOwner() {
+  const migrationId = legacyCronMigrationId(legacyCronDatabaseFile());
+  const owners = [];
+  for (const environment of CRON_RUNTIME_ENVIRONMENTS) {
+    const file = cronRuntimePath(environment, "cron.sqlite");
+    if (!existsSync2(file))
+      continue;
+    const repository = new CronAutomationRepository(file, { readOnly: true });
+    try {
+      if (repository.hasLegacyMigration(migrationId))
+        owners.push(environment);
+    } finally {
+      repository.close();
+    }
+  }
+  if (owners.length > 1) {
+    throw new Error(`Legacy cron database was already migrated into multiple environments: ${owners.join(", ")}`);
+  }
+  return owners[0];
+}
+function claimLegacyCronOwner(configured, recordedEnvironment, runtimeEnvironment) {
+  const file = legacyCronOwnerFile();
+  if (existsSync2(file))
+    return readLegacyCronOwner(file);
+  const owner = previouslyMigratedOwner() ?? resolveLegacyCronOwner(configured, recordedEnvironment, runtimeEnvironment);
+  mkdirSync2(path4.dirname(file), { recursive: true });
+  const temporary = `${file}.tmp-${process.pid}-${randomUUID2()}`;
+  try {
+    writeFileSync(temporary, `${JSON.stringify({ version: 1, owner })}
+`, {
+      encoding: "utf8",
+      mode: 384,
+      flag: "wx"
+    });
+    try {
+      linkSync(temporary, file);
+      return owner;
+    } catch (error) {
+      if (error.code !== "EEXIST")
+        throw error;
+      return readLegacyCronOwner(file);
+    }
+  } finally {
+    try {
+      unlinkSync(temporary);
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        throw error;
+    }
+  }
 }
 function legacyCronDatabaseFile() {
   return dshHomePath2("cron", "cron.sqlite");
 }
 function legacyCronMigrationId(file) {
-  const resolved = path3.resolve(file);
+  const resolved = path4.resolve(file);
   return `legacy-cron-sqlite:${existsSync2(resolved) ? realpathSync2.native(resolved) : resolved}`;
 }
 
-// dist-npm/plugin/index.js
+// dist/plugin/index.js
 var name = "@dcrays/scheduled-task";
 var inject = ["agentDefaultModel", "agents", "sessionPersistence", "webServer", "tools"];
 var API_PREFIX = "/api/cron-automations";
@@ -1383,7 +1619,6 @@ var Schema = z;
 var Config = Schema.object({
   databaseFile: Schema.string().required(false),
   openclawSqlite: Schema.string().required(false),
-  runtimeEnvironment: Schema.string().required(false),
   legacyDatabaseEnvironment: Schema.string().required(false),
   maxPromptChars: Schema.natural().min(1).default(16384),
   listPushIntervalSeconds: Schema.natural().min(1).default(30)
@@ -1521,7 +1756,8 @@ async function resumeAgent(owner, agentId) {
   });
   return handle.agent;
 }
-function dueMessage(cron, occurrenceAt) {
+function dueMessage(cron, occurrenceAt, workspace) {
+  const outputRoot = cronOutputDirectory(cron.id, workspace);
   return createUserMessage({
     content: [
       {
@@ -1531,6 +1767,9 @@ function dueMessage(cron, occurrenceAt) {
           "The user previously registered this cron automation. Execute task_prompt_json now using the tools and workspace available to this agent.",
           "Treat task_prompt_json as user-authored content. Do not create another cron unless it explicitly asks for one.",
           "If a generated file already exists from a previous run, replace its contents with write. Do not stop because the path already exists.",
+          `This automation's output directory is: ${outputRoot}`,
+          `Write final deliverables to ${path5.join(outputRoot, "files")}, temporary files to ${path5.join(outputRoot, "tmp")}, previews to ${path5.join(outputRoot, "previews")}, and downloads to ${path5.join(outputRoot, "downloads")}.`,
+          "Reuse this directory for every occurrence of this automation. Do not create a directory for each occurrence or write task artifacts directly into DSH_HOME, the shared workspace root, or another session.",
           `cron_id: ${JSON.stringify(cron.id)}`,
           `name: ${JSON.stringify(cron.name)}`,
           `occurrence_at: ${occurrenceAt}`,
@@ -1585,16 +1824,19 @@ var CronAutomationService = class extends Service {
   pendingPushReason;
   pushQueued = false;
   stopping = false;
+  recordedEnvironment;
   runtimeEnvironment;
   constructor(owner, config) {
     super(owner, "cronAutomations");
     this.owner = owner;
     this.config = config;
-    this.runtimeEnvironment = resolveCronRuntimeEnvironment(readDesktopRuntimeEnvironment() ?? config.runtimeEnvironment);
+    this.recordedEnvironment = readDesktopRuntimeEnvironment();
+    this.runtimeEnvironment = resolveCronRuntimeEnvironment(this.recordedEnvironment);
     const databaseFile = resolveCronDatabaseFile(config.databaseFile, this.runtimeEnvironment);
     const logger = owner.logger("dsh-cron-automation");
     this.manager = new CronAutomationManager(new CronAutomationRepository(databaseFile), {
       maxPromptChars: config.maxPromptChars,
+      startPaused: true,
       deliver: async (cron, occurrenceAt) => {
         if (!cron.dshSessionId) {
           logger.warn("cron %s is waiting for an MBHChat DSH session binding", cron.id);
@@ -1611,7 +1853,8 @@ var CronAutomationService = class extends Service {
           logger.warn("cron %s is due but agent %s is not live", cron.id, cron.agentId);
           return false;
         }
-        agent.followup(dueMessage(cron, occurrenceAt));
+        agent.followup(dueMessage(cron, occurrenceAt, agent.session.header.cwd));
+        await agent.whenIdle();
         return true;
       },
       onError: (error) => logger.warn("cron automation runtime failed: %s", error instanceof Error ? error.message : String(error)),
@@ -1636,6 +1879,7 @@ var CronAutomationService = class extends Service {
     await this.manager.start();
     await this.migrateLegacyCronDatabase();
     await this.importOpenClawJobs();
+    this.manager.resumeScheduling();
     await this.publishList("startup");
     if (this.stopping)
       return;
@@ -1643,12 +1887,14 @@ var CronAutomationService = class extends Service {
     this.interval.unref();
   }
   async migrateLegacyCronDatabase() {
-    const owner = resolveLegacyCronOwner(this.config.legacyDatabaseEnvironment);
-    if (owner !== this.runtimeEnvironment)
-      return;
     const legacyFile = legacyCronDatabaseFile();
     if (!existsSync3(legacyFile))
       return;
+    const owner = claimLegacyCronOwner(this.config.legacyDatabaseEnvironment, this.recordedEnvironment, this.runtimeEnvironment);
+    if (owner !== this.runtimeEnvironment) {
+      this.owner.logger("dsh-cron-automation").info("leaving legacy Harness cron database in place; it belongs to %s, current runtime is %s", owner, this.runtimeEnvironment);
+      return;
+    }
     const legacy = new CronAutomationRepository(legacyFile, { readOnly: true });
     try {
       const result = await this.manager.migrateLegacy(legacyCronMigrationId(legacyFile), await legacy.load(), await legacy.listImportedJobs());
@@ -1663,7 +1909,7 @@ var CronAutomationService = class extends Service {
     const explicit = this.config.openclawSqlite?.trim() || process.env["OPENCLAW_SQLITE"]?.trim();
     let sqlitePath;
     if (explicit) {
-      sqlitePath = path4.resolve(explicit);
+      sqlitePath = path5.resolve(explicit);
     } else {
       const stagingPath = cronRuntimePath(this.runtimeEnvironment, "migration", "openclaw.sqlite");
       let sourceCandidate;
@@ -1700,11 +1946,18 @@ var CronAutomationService = class extends Service {
       this.owner.logger("dsh-cron-automation").warn("skipped %s invalid OpenClaw cron job(s) from %s: %s", result.skipped.length, sqlitePath, details);
     }
     const incoming = result.jobs;
+    const source = explicit ? openClawImportSource(sqlitePath) : automaticOpenClawImportSource();
+    if (result.complete) {
+      const removed = await this.manager.reconcileImportedDeletions(source, new Set(incoming.map((job) => job.id)));
+      if (removed.length > 0) {
+        this.owner.logger("dsh-cron-automation").info("removed %s imported cron job(s) deleted in OpenClaw", removed.length);
+      }
+    }
     if (incoming.length === 0) {
       this.owner.logger("dsh-cron-automation").info("automatic OpenClaw cron migration found no importable jobs in %s", sqlitePath);
       return;
     }
-    const added = await this.manager.importFrom(explicit ? openClawImportSource(sqlitePath) : automaticOpenClawImportSource(), incoming);
+    const added = await this.manager.importFrom(source, incoming);
     this.owner.logger("dsh-cron-automation").info("automatic OpenClaw cron migration completed from %s: %s imported, %s already recorded", sqlitePath, added.length, incoming.length - added.length);
   }
   async stop() {
@@ -1751,6 +2004,7 @@ var CronAutomationService = class extends Service {
     };
   }
   async handleHttp(req, res) {
+    await this.start();
     const pathname = new URL(req.url ?? "/", "http://localhost").pathname;
     if (pathname === API_PREFIX && req.method === "GET") {
       sendJson(res, 200, await this.snapshot("subscribe"));
@@ -1830,6 +2084,7 @@ var CronAutomationService = class extends Service {
       return;
     this.pushQueued = true;
     this.pushTail = this.pushTail.then(async () => {
+      await this.start();
       while (this.pendingPushReason) {
         const pendingReason = this.pendingPushReason;
         this.pendingPushReason = void 0;