@dcrays/scheduled-task 0.1.0 → 0.1.3

package/cordis.patch.yml

@@ -8,5 +8,7 @@
         - webServer
         - tools
       config:
+        runtimeEnvironment: production
+        legacyDatabaseEnvironment: production
         maxPromptChars: 16384
         listPushIntervalSeconds: 30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcrays/scheduled-task",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "Persistent client-facing cron automation service for DeepSeek Harness (production)",
   "type": "module",
   "main": "plugin/index.js",
@@ -32,16 +32,14 @@
   "engines": {
     "node": ">=24.0.0"
   },
-  "dependencies": {
-    "@deepseek-ai/dsh-home-paths": "0.1.1-rc.2",
-    "@deepseek-ai/dsh-llm": "0.1.1-rc.2",
-    "@deepseek-ai/schemastery": "^3.18.1"
-  },
   "peerDependencies": {
-    "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-agent": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-host-webserver": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-tools": "^0.1.1-rc.2"
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh-agent": "^0.1.2-rc.1",
+    "@deepseek-ai/dsh-home-paths": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-host-webserver": "^0.1.2-rc.1",
+    "@deepseek-ai/dsh-llm": "^0.1.2-rc.1",
+    "@deepseek-ai/dsh-tools": "^0.1.2-rc.1",
+    "@deepseek-ai/schemastery": "^3.18.1"
   },
   "publishConfig": {
     "access": "public"

package/plugin/index.d.ts

@@ -9,6 +9,8 @@ export declare const inject: string[];
 export interface Config {
     databaseFile?: string;
     openclawSqlite?: string;
+    runtimeEnvironment?: string;
+    legacyDatabaseEnvironment?: string;
     maxPromptChars: number;
     listPushIntervalSeconds: number;
 }
@@ -45,9 +47,11 @@ export declare class CronAutomationService extends Service {
     private pendingPushReason;
     private pushQueued;
     private stopping;
+    private readonly runtimeEnvironment;
     constructor(owner: Context, config: Config);
     start(): Promise<void>;
     private initialize;
+    private migrateLegacyCronDatabase;
     private importOpenClawJobs;
     stop(): Promise<void>;
     create(agentId: string, envelope: CronCreateEnvelope): Promise<StoredCronAutomation>;

package/plugin/index.js

@@ -1,14 +1,14 @@
 import { createRequire as __mobookCreateRequire } from 'node:module'; const require = __mobookCreateRequire(import.meta.url);
 
-// plugins/scheduled-task/dist-npm/plugin/index.js
-import path3 from "node:path";
+// dist-npm/plugin/index.js
+import { existsSync as existsSync3 } from "node:fs";
+import path4 from "node:path";
 import { Service } from "@deepseek-ai/cordis";
-import { dshHomePath } from "@deepseek-ai/dsh-home-paths";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
 import { defineTool } from "@deepseek-ai/dsh-tools";
 import z from "@deepseek-ai/schemastery";
 
-// plugins/scheduled-task/dist-npm/src/cron.js
+// dist-npm/src/cron.js
 var FIELD_COUNT = 5;
 var MAX_SEARCH_DAYS = 366 * 8;
 var GREGORIAN_CYCLE_DAYS = 146097;
@@ -208,10 +208,10 @@ function nextCronOccurrence(afterEpochMs, cron, timeZone) {
   throw new CronExpressionError("cron expression has no occurrence within the next eight years");
 }
 
-// plugins/scheduled-task/dist-npm/src/manager.js
+// dist-npm/src/manager.js
 import { createHash } from "node:crypto";
 
-// plugins/scheduled-task/dist-npm/src/protocol.js
+// dist-npm/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 };
 }
 
-// plugins/scheduled-task/dist-npm/src/repository.js
+// dist-npm/src/repository.js
 import fs from "node:fs";
 import path from "node:path";
 import { DatabaseSync } from "node:sqlite";
@@ -515,6 +515,11 @@ var CronAutomationRepository = class {
         imported_at INTEGER NOT NULL,
         PRIMARY KEY (source, job_id)
       );
+
+      CREATE TABLE IF NOT EXISTS cron_migrations (
+        migration_id TEXT PRIMARY KEY,
+        completed_at INTEGER NOT NULL
+      );
     `);
     this.insertJobStatement = this.database.prepare(`
       INSERT INTO cron_jobs (
@@ -622,6 +627,34 @@ var CronAutomationRepository = class {
       return result;
     });
   }
+  async listImportedJobs() {
+    this.assertOpen();
+    const table = this.database.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'cron_imported_jobs'").get();
+    if (!table)
+      return [];
+    return this.database.prepare("SELECT source, job_id FROM cron_imported_jobs").all().map((row) => ({ source: row.source, jobId: row.job_id }));
+  }
+  async migrateLegacy(migrationId, incoming, importedJobs) {
+    this.assertWritable();
+    const decoded = uniqueJobs(incoming);
+    return this.writeTransaction(() => {
+      const completed = this.database.prepare("SELECT 1 FROM cron_migrations WHERE migration_id = ?").get(migrationId);
+      if (completed)
+        return { added: [], skippedIds: [], alreadyMigrated: true };
+      const result = this.planImport(migrationId, decoded);
+      const nextOrder = this.nextSortOrder();
+      result.added.forEach((job, index) => this.insertJob(job, nextOrder + index));
+      const markImported = this.database.prepare(`
+        INSERT OR IGNORE INTO cron_imported_jobs (source, job_id, imported_at)
+        VALUES (?, ?, ?)
+      `);
+      const importedAt = Date.now();
+      for (const job of importedJobs)
+        markImported.run(job.source, job.jobId, importedAt);
+      this.database.prepare("INSERT INTO cron_migrations (migration_id, completed_at) VALUES (?, ?)").run(migrationId, importedAt);
+      return { ...result, alreadyMigrated: false };
+    });
+  }
   close() {
     if (this.closed)
       return;
@@ -681,7 +714,7 @@ var CronAutomationRepository = class {
   }
 };
 
-// plugins/scheduled-task/dist-npm/src/manager.js
+// dist-npm/src/manager.js
 var MAX_TIMER_DELAY_MS = 2147483647;
 function automationId(agentId, requestId) {
   return `cron-${createHash("sha256").update(`${agentId}\0${requestId}`).digest("hex").slice(0, 24)}`;
@@ -692,6 +725,9 @@ function cloneJob(job) {
 function dshAgentIdFor(job) {
   return job.dshSessionId ?? job.agentId;
 }
+function hasDshSession(job) {
+  return typeof job.dshSessionId === "string" && job.dshSessionId.length > 0;
+}
 function timezoneFor(schedule) {
   return schedule.tz ?? Intl.DateTimeFormat().resolvedOptions().timeZone ?? "UTC";
 }
@@ -982,6 +1018,8 @@ var CronAutomationManager = class {
         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;
@@ -1038,6 +1076,29 @@ var CronAutomationManager = class {
       return added.map(cloneJob);
     });
   }
+  async migrateLegacy(migrationId, incoming, importedJobs) {
+    await this.start();
+    return this.enqueue(async () => {
+      const prepared = incoming.map((job) => this.prepareImportedJob(job));
+      const result = await this.repository.migrateLegacy(migrationId, prepared, importedJobs);
+      if (result.alreadyMigrated || result.added.length === 0)
+        return { added: [], alreadyMigrated: result.alreadyMigrated };
+      for (const job of result.added) {
+        this.jobs.set(job.id, cloneJob(job));
+        this.options.onCreated?.(cloneJob(job));
+      }
+      this.arm();
+      return { added: result.added.map(cloneJob), alreadyMigrated: false };
+    });
+  }
+  prepareImportedJob(job) {
+    const next = cloneJob(job);
+    delete next.state.runningAtMs;
+    disableIfTooFrequent(next);
+    if (next.enabled && next.state.nextRunAtMs === void 0)
+      setNextOccurrence(next, initialOccurrence(next, this.now()));
+    return next;
+  }
   async deliver(job, occurrenceAtMs) {
     try {
       return await this.options.deliver(cloneJob(job), new Date(occurrenceAtMs).toISOString());
@@ -1061,7 +1122,7 @@ var CronAutomationManager = class {
       clearTimeout(this.timer);
     this.timer = void 0;
     const now = this.now();
-    const target = [...this.jobs.values()].filter((job) => job.enabled && 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))).map((job) => 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));
@@ -1075,7 +1136,7 @@ var CronAutomationManager = class {
     if (this.stopping)
       return;
     const now = this.now();
-    const due = [...this.jobs.values()].filter((job) => job.enabled && job.state.nextRunAtMs !== void 0 && job.state.nextRunAtMs <= now).sort((left, right) => (left.state.nextRunAtMs ?? 0) - (right.state.nextRunAtMs ?? 0) || left.createdAtMs - right.createdAtMs);
+    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;
@@ -1105,12 +1166,14 @@ var CronAutomationManager = class {
   }
 };
 
-// plugins/scheduled-task/dist-npm/src/openclaw-sqlite.js
+// dist-npm/src/openclaw-sqlite.js
 import { existsSync, realpathSync } from "node:fs";
+import { chmod, mkdir, rename, unlink } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
 import os from "node:os";
 import path2 from "node:path";
-import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
-var DEFAULT_OPENCLAW_SQLITE = path2.join(os.homedir(), ".mobook", "state", "openclaw.sqlite");
+import { backup, DatabaseSync as DatabaseSync2 } from "node:sqlite";
+import { dshHomePath } from "@deepseek-ai/dsh-home-paths";
 function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -1172,18 +1235,22 @@ function overlayState(row, jobState, tableState) {
     ...isRecord3(jobState) ? jobState : {},
     ...isRecord3(tableState) ? tableState : {}
   };
-  if (row.next_run_at_ms !== null)
+  if (typeof row.next_run_at_ms === "number")
     state.nextRunAtMs = row.next_run_at_ms;
-  if (row.running_at_ms !== null)
+  if (typeof row.running_at_ms === "number")
     state.runningAtMs = row.running_at_ms;
-  if (row.last_run_at_ms !== null)
+  if (typeof row.last_run_at_ms === "number")
     state.lastRunAtMs = row.last_run_at_ms;
   if (row.last_run_status)
     state.lastRunStatus = row.last_run_status;
   return state;
 }
 function jobFromOpenClawRow(row) {
-  const tableState = parseJson(row.state_json || "{}", "state_json");
+  let tableState = {};
+  try {
+    tableState = parseJson(row.state_json || "{}", "state_json");
+  } catch {
+  }
   try {
     const parsed = parseJson(row.job_json, "job_json");
     if (!isRecord3(parsed))
@@ -1199,35 +1266,70 @@ function jobFromOpenClawRow(row) {
     return decodeJob(jobFromColumns(row, overlayState(row, {}, tableState)));
   }
 }
-function loadOpenClawSqliteJobs(sqlitePath) {
+function loadOpenClawSqliteJobsWithDiagnostics(sqlitePath) {
   if (!existsSync(sqlitePath))
-    return [];
+    return { jobs: [], skipped: [] };
   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 [];
+      return { jobs: [], skipped: [] };
     const rows = database.prepare("SELECT * FROM cron_jobs ORDER BY updated_at ASC, job_id ASC").all();
     const jobs = /* @__PURE__ */ new Map();
+    const skipped = [];
     for (const row of rows) {
       try {
         const job = jobFromOpenClawRow(row);
         const previous = jobs.get(job.id);
         if (!previous || job.updatedAtMs >= previous.updatedAtMs)
           jobs.set(job.id, job);
-      } catch {
+      } catch (error) {
+        skipped.push({
+          jobId: typeof row.job_id === "string" && row.job_id ? row.job_id : "<unknown>",
+          reason: error instanceof Error ? error.message : String(error)
+        });
       }
     }
-    return [...jobs.values()];
+    return { jobs: [...jobs.values()], skipped };
   } finally {
     database.close();
   }
 }
-function resolveOpenClawSqlitePath(configured) {
+async function snapshotOpenClawSqlite(sqlitePath, destination) {
+  const database = new DatabaseSync2(sqlitePath, { readOnly: true, timeout: 5e3 });
+  try {
+    const directory = path2.dirname(destination);
+    const temporary = path2.join(directory, `.${path2.basename(destination)}.${randomUUID()}.tmp`);
+    await mkdir(directory, { recursive: true });
+    try {
+      await backup(database, temporary);
+      await chmod(temporary, 384);
+      await Promise.all([
+        unlink(`${destination}-wal`).catch(() => void 0),
+        unlink(`${destination}-shm`).catch(() => void 0)
+      ]);
+      await rename(temporary, destination);
+    } catch (error) {
+      await unlink(temporary).catch(() => void 0);
+      throw error;
+    }
+  } finally {
+    database.close();
+  }
+}
+function resolveOpenClawSqlitePath(configured, targetHome = dshHomePath("."), userHome = os.homedir()) {
   const explicit = configured?.trim() || process.env.OPENCLAW_SQLITE?.trim();
   if (explicit)
     return path2.resolve(explicit);
-  return DEFAULT_OPENCLAW_SQLITE;
+  const target = path2.basename(path2.resolve(targetHome));
+  if (target === ".mobook-harness")
+    return path2.join(userHome, ".mobook", "state", "openclaw.sqlite");
+  if (target === ".dsh")
+    return path2.join(userHome, ".openclaw", "state", "openclaw.sqlite");
+  throw new Error("Custom DSH home requires an explicit openclawSqlite or OPENCLAW_SQLITE migration source");
+}
+function automaticOpenClawImportSource(targetHome = dshHomePath(".")) {
+  return openClawImportSource(path2.join(targetHome, "migration", "openclaw.sqlite"));
 }
 function openClawImportSource(sqlitePath) {
   const resolved = path2.resolve(sqlitePath);
@@ -1235,7 +1337,36 @@ function openClawImportSource(sqlitePath) {
   return `openclaw-sqlite:${canonical}`;
 }
 
-// plugins/scheduled-task/dist-npm/plugin/index.js
+// dist-npm/src/runtime-environment.js
+import path3 from "node:path";
+import { existsSync as existsSync2, realpathSync as realpathSync2 } from "node:fs";
+import { dshHomePath as dshHomePath2 } from "@deepseek-ai/dsh-home-paths";
+var CRON_RUNTIME_ENVIRONMENTS = ["development", "test", "production"];
+function resolveCronRuntimeEnvironment(value) {
+  const environment = value?.trim() || "development";
+  if (CRON_RUNTIME_ENVIRONMENTS.includes(environment)) {
+    return environment;
+  }
+  throw new Error(`Unsupported cron runtime environment: ${environment}`);
+}
+function cronRuntimePath(environment, ...segments) {
+  return dshHomePath2("cron", environment, ...segments);
+}
+function resolveCronDatabaseFile(configured, environment) {
+  return configured?.trim() ? path3.resolve(configured) : cronRuntimePath(environment, "cron.sqlite");
+}
+function resolveLegacyCronOwner(value) {
+  return resolveCronRuntimeEnvironment(value?.trim() || "production");
+}
+function legacyCronDatabaseFile() {
+  return dshHomePath2("cron", "cron.sqlite");
+}
+function legacyCronMigrationId(file) {
+  const resolved = path3.resolve(file);
+  return `legacy-cron-sqlite:${existsSync2(resolved) ? realpathSync2.native(resolved) : resolved}`;
+}
+
+// dist-npm/plugin/index.js
 var name = "@dcrays/scheduled-task";
 var inject = ["agentDefaultModel", "agents", "sessionPersistence", "webServer", "tools"];
 var API_PREFIX = "/api/cron-automations";
@@ -1243,6 +1374,8 @@ 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)
 });
@@ -1388,6 +1521,7 @@ function dueMessage(cron, occurrenceAt) {
           "[CRON AUTOMATION DUE]",
           "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.",
           `cron_id: ${JSON.stringify(cron.id)}`,
           `name: ${JSON.stringify(cron.name)}`,
           `occurrence_at: ${occurrenceAt}`,
@@ -1442,19 +1576,24 @@ var CronAutomationService = class extends Service {
   pendingPushReason;
   pushQueued = false;
   stopping = false;
+  runtimeEnvironment;
   constructor(owner, config) {
     super(owner, "cronAutomations");
     this.owner = owner;
     this.config = config;
-    const configured = config.databaseFile?.trim();
-    const databaseFile = configured ? path3.resolve(configured) : dshHomePath("cron", "cron.sqlite");
+    this.runtimeEnvironment = resolveCronRuntimeEnvironment(config.runtimeEnvironment);
+    const databaseFile = resolveCronDatabaseFile(config.databaseFile, this.runtimeEnvironment);
     const logger = owner.logger("dsh-cron-automation");
     this.manager = new CronAutomationManager(new CronAutomationRepository(databaseFile), {
       maxPromptChars: config.maxPromptChars,
       deliver: async (cron, occurrenceAt) => {
+        if (!cron.dshSessionId) {
+          logger.warn("cron %s is waiting for an MBHChat DSH session binding", cron.id);
+          return false;
+        }
         let agent;
         try {
-          agent = await resumeAgent(owner, cron.dshSessionId ?? cron.agentId);
+          agent = await resumeAgent(owner, cron.dshSessionId);
         } catch (error) {
           logger.warn("could not resume agent %s for cron %s: %s", cron.agentId, cron.id, error instanceof Error ? error.message : String(error));
           return false;
@@ -1486,6 +1625,7 @@ var CronAutomationService = class extends Service {
   }
   async initialize() {
     await this.manager.start();
+    await this.migrateLegacyCronDatabase();
     await this.importOpenClawJobs();
     await this.publishList("startup");
     if (this.stopping)
@@ -1493,21 +1633,70 @@ var CronAutomationService = class extends Service {
     this.interval = setInterval(() => this.requestListPush("interval"), this.config.listPushIntervalSeconds * 1e3);
     this.interval.unref();
   }
+  async migrateLegacyCronDatabase() {
+    const owner = resolveLegacyCronOwner(this.config.legacyDatabaseEnvironment);
+    if (owner !== this.runtimeEnvironment)
+      return;
+    const legacyFile = legacyCronDatabaseFile();
+    if (!existsSync3(legacyFile))
+      return;
+    const legacy = new CronAutomationRepository(legacyFile, { readOnly: true });
+    try {
+      const result = await this.manager.migrateLegacy(legacyCronMigrationId(legacyFile), await legacy.load(), await legacy.listImportedJobs());
+      if (!result.alreadyMigrated) {
+        this.owner.logger("dsh-cron-automation").info("migrated %s legacy Harness cron job(s) into %s", result.added.length, this.runtimeEnvironment);
+      }
+    } finally {
+      legacy.close();
+    }
+  }
   async importOpenClawJobs() {
-    const sqlitePath = resolveOpenClawSqlitePath(this.config.openclawSqlite);
-    let incoming;
+    const explicit = this.config.openclawSqlite?.trim() || process.env["OPENCLAW_SQLITE"]?.trim();
+    let sqlitePath;
+    if (explicit) {
+      sqlitePath = path4.resolve(explicit);
+    } else {
+      const stagingPath = cronRuntimePath(this.runtimeEnvironment, "migration", "openclaw.sqlite");
+      let sourceCandidate;
+      try {
+        sourceCandidate = resolveOpenClawSqlitePath();
+      } catch (error) {
+        this.owner.logger("dsh-cron-automation").warn("%s", String(error));
+        return;
+      }
+      if (!existsSync3(sourceCandidate)) {
+        this.owner.logger("dsh-cron-automation").info("automatic OpenClaw cron migration skipped; source database does not exist: %s", sourceCandidate);
+        return;
+      }
+      if (sourceCandidate) {
+        try {
+          await snapshotOpenClawSqlite(sourceCandidate, stagingPath);
+          this.owner.logger("dsh-cron-automation").info("staged openclaw sqlite from %s to %s", sourceCandidate, stagingPath);
+        } catch (error) {
+          this.owner.logger("dsh-cron-automation").warn("failed to stage openclaw sqlite: %s", error instanceof Error ? error.message : String(error));
+          return;
+        }
+      }
+      sqlitePath = stagingPath;
+    }
+    let result;
     try {
-      incoming = loadOpenClawSqliteJobs(sqlitePath);
+      result = loadOpenClawSqliteJobsWithDiagnostics(sqlitePath);
     } catch (error) {
       this.owner.logger("dsh-cron-automation").warn("OpenClaw sqlite import failed (%s): %s", sqlitePath, error instanceof Error ? error.message : String(error));
       return;
     }
-    if (incoming.length === 0)
+    if (result.skipped.length > 0) {
+      const details = result.skipped.map(({ jobId, reason }) => `${jobId}: ${reason}`).join("; ");
+      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;
+    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(openClawImportSource(sqlitePath), incoming);
-    if (added.length > 0) {
-      this.owner.logger("dsh-cron-automation").info("imported %s OpenClaw cron job(s) from %s", added.length, sqlitePath);
     }
+    const added = await this.manager.importFrom(explicit ? openClawImportSource(sqlitePath) : automaticOpenClawImportSource(), 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() {
     this.stopping = true;

package/src/manager.d.ts

@@ -1,5 +1,5 @@
 import type { CronCreateEnvelope } from './protocol.js';
-import { CronAutomationRepository, type StoredCronAutomation } from './repository.js';
+import { CronAutomationRepository, type CronImportedJob, type StoredCronAutomation } from './repository.js';
 export interface CronAutomationManagerOptions {
     maxPromptChars: number;
     now?: () => number;
@@ -43,6 +43,11 @@ export declare class CronAutomationManager {
     notifyAgentAvailable(agentId: string): void;
     /** Import each source job once. Existing ids win so DSH bindings stay intact. */
     importFrom(source: string, incoming: readonly StoredCronAutomation[]): Promise<StoredCronAutomation[]>;
+    migrateLegacy(migrationId: string, incoming: readonly StoredCronAutomation[], importedJobs: readonly CronImportedJob[]): Promise<{
+        added: StoredCronAutomation[];
+        alreadyMigrated: boolean;
+    }>;
+    private prepareImportedJob;
     private deliver;
     private enqueue;
     private requestDispatch;

package/src/manager.js

@@ -12,6 +12,9 @@ function cloneJob(job) {
 function dshAgentIdFor(job) {
     return job.dshSessionId ?? job.agentId;
 }
+function hasDshSession(job) {
+    return typeof job.dshSessionId === 'string' && job.dshSessionId.length > 0;
+}
 function timezoneFor(schedule) {
     return schedule.tz ?? Intl.DateTimeFormat().resolvedOptions().timeZone ?? 'UTC';
 }
@@ -317,6 +320,10 @@ export class CronAutomationManager {
                 return 'not_found';
             if (job.state.runningAtMs !== undefined)
                 return 'already_running';
+            // Imported OpenClaw jobs refer to an OpenClaw agent id, not a DSH session.
+            // They must wait until mbh-chat supplies a verified DSH session binding.
+            if (!hasDshSession(job))
+                return 'delivery_unavailable';
             const occurrenceAtMs = this.now();
             job.state.runningAtMs = occurrenceAtMs;
             job.updatedAtMs = occurrenceAtMs;
@@ -376,6 +383,29 @@ export class CronAutomationManager {
             return added.map(cloneJob);
         });
     }
+    async migrateLegacy(migrationId, incoming, importedJobs) {
+        await this.start();
+        return this.enqueue(async () => {
+            const prepared = incoming.map((job) => this.prepareImportedJob(job));
+            const result = await this.repository.migrateLegacy(migrationId, prepared, importedJobs);
+            if (result.alreadyMigrated || result.added.length === 0)
+                return { added: [], alreadyMigrated: result.alreadyMigrated };
+            for (const job of result.added) {
+                this.jobs.set(job.id, cloneJob(job));
+                this.options.onCreated?.(cloneJob(job));
+            }
+            this.arm();
+            return { added: result.added.map(cloneJob), alreadyMigrated: false };
+        });
+    }
+    prepareImportedJob(job) {
+        const next = cloneJob(job);
+        delete next.state.runningAtMs;
+        disableIfTooFrequent(next);
+        if (next.enabled && next.state.nextRunAtMs === undefined)
+            setNextOccurrence(next, initialOccurrence(next, this.now()));
+        return next;
+    }
     async deliver(job, occurrenceAtMs) {
         try {
             return await this.options.deliver(cloneJob(job), new Date(occurrenceAtMs).toISOString());
@@ -401,7 +431,10 @@ export class CronAutomationManager {
         this.timer = undefined;
         const now = this.now();
         const target = [...this.jobs.values()]
-            .filter((job) => job.enabled && job.state.runningAtMs === undefined && !this.blockedAgents.has(dshAgentIdFor(job)))
+            .filter((job) => job.enabled &&
+            hasDshSession(job) &&
+            job.state.runningAtMs === undefined &&
+            !this.blockedAgents.has(dshAgentIdFor(job)))
             .map((job) => job.state.nextRunAtMs)
             .filter((value) => value !== undefined)
             .reduce((earliest, candidate) => (earliest === undefined || candidate < earliest ? candidate : earliest), undefined);
@@ -419,7 +452,7 @@ export class CronAutomationManager {
             return;
         const now = this.now();
         const due = [...this.jobs.values()]
-            .filter((job) => job.enabled && job.state.nextRunAtMs !== undefined && job.state.nextRunAtMs <= now)
+            .filter((job) => job.enabled && hasDshSession(job) && job.state.nextRunAtMs !== undefined && 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;

package/src/openclaw-sqlite.d.ts

@@ -1,5 +1,11 @@
-import { type StoredCronAutomation } from "./repository.js";
-export declare const DEFAULT_OPENCLAW_SQLITE: string;
+import { type StoredCronAutomation } from './repository.js';
+export interface OpenClawSqliteImportResult {
+    jobs: StoredCronAutomation[];
+    skipped: Array<{
+        jobId: string;
+        reason: string;
+    }>;
+}
 interface CronJobRow {
     job_id: string;
     name: string;
@@ -35,6 +41,13 @@ interface CronJobRow {
 }
 export declare function jobFromOpenClawRow(row: CronJobRow): StoredCronAutomation;
 export declare function loadOpenClawSqliteJobs(sqlitePath: string): StoredCronAutomation[];
-export declare function resolveOpenClawSqlitePath(configured?: string): string;
+export declare function loadOpenClawSqliteJobsWithDiagnostics(sqlitePath: string): OpenClawSqliteImportResult;
+/**
+ * Materialize a consistent OpenClaw database snapshot. Copying only the main
+ * SQLite file loses transactions which are still in the source database WAL.
+ */
+export declare function snapshotOpenClawSqlite(sqlitePath: string, destination: string): Promise<void>;
+export declare function resolveOpenClawSqlitePath(configured?: string, targetHome?: string, userHome?: string): string;
+export declare function automaticOpenClawImportSource(targetHome?: string): string;
 export declare function openClawImportSource(sqlitePath: string): string;
 export {};

package/src/openclaw-sqlite.js

@@ -1,11 +1,13 @@
-import { existsSync, realpathSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { DatabaseSync } from "node:sqlite";
-import { decodeJob } from "./repository.js";
-export const DEFAULT_OPENCLAW_SQLITE = path.join(os.homedir(), ".mobook", "state", "openclaw.sqlite");
+import { existsSync, realpathSync } from 'node:fs';
+import { chmod, mkdir, rename, unlink } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import os from 'node:os';
+import path from 'node:path';
+import { backup, DatabaseSync } from 'node:sqlite';
+import { dshHomePath } from '@deepseek-ai/dsh-home-paths';
+import { decodeJob } from './repository.js';
 function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 function parseJson(raw, label) {
     try {
@@ -16,18 +18,18 @@ function parseJson(raw, label) {
     }
 }
 function scheduleFromRow(row) {
-    if (row.schedule_kind === "every") {
+    if (row.schedule_kind === 'every') {
         return {
-            kind: "every",
+            kind: 'every',
             everyMs: row.every_ms,
             ...(row.anchor_ms === null ? {} : { anchorMs: row.anchor_ms })
         };
     }
-    if (row.schedule_kind === "at") {
-        return { kind: "at", ...(row.at === null ? {} : { at: row.at }) };
+    if (row.schedule_kind === 'at') {
+        return { kind: 'at', ...(row.at === null ? {} : { at: row.at }) };
     }
     return {
-        kind: "cron",
+        kind: 'cron',
         expr: row.schedule_expr,
         ...(row.schedule_tz === null ? {} : { tz: row.schedule_tz })
     };
@@ -42,17 +44,17 @@ function jobFromColumns(row, state) {
         updatedAtMs: row.updated_at,
         schedule: scheduleFromRow(row),
         payload: {
-            kind: row.payload_kind || "agentTurn",
-            message: row.payload_message ?? "",
+            kind: row.payload_kind || 'agentTurn',
+            message: row.payload_message ?? '',
             ...(row.payload_timeout_seconds === null ? {} : { timeoutSeconds: row.payload_timeout_seconds })
         },
-        agentId: row.agent_id ?? "main",
+        agentId: row.agent_id ?? 'main',
         ...(row.session_key ? { sessionKey: row.session_key } : {}),
-        sessionTarget: row.session_target || "isolated",
-        wakeMode: row.wake_mode || "now",
+        sessionTarget: row.session_target || 'isolated',
+        wakeMode: row.wake_mode || 'now',
         ...(row.delete_after_run === 1 ? { deleteAfterRun: true } : {}),
         delivery: {
-            mode: row.delivery_mode ?? "announce",
+            mode: row.delivery_mode ?? 'announce',
             ...(row.delivery_channel ? { channel: row.delivery_channel } : {}),
             ...(row.delivery_to ? { to: row.delivery_to } : {}),
             ...(row.delivery_account_id ? { accountId: row.delivery_account_id } : {}),
@@ -66,27 +68,36 @@ function overlayState(row, jobState, tableState) {
         ...(isRecord(jobState) ? jobState : {}),
         ...(isRecord(tableState) ? tableState : {})
     };
-    if (row.next_run_at_ms !== null)
+    // Older OpenClaw schemas do not expose these projection columns. In that
+    // case job_json/state_json remains the authoritative state.
+    if (typeof row.next_run_at_ms === 'number')
         state.nextRunAtMs = row.next_run_at_ms;
-    if (row.running_at_ms !== null)
+    if (typeof row.running_at_ms === 'number')
         state.runningAtMs = row.running_at_ms;
-    if (row.last_run_at_ms !== null)
+    if (typeof row.last_run_at_ms === 'number')
         state.lastRunAtMs = row.last_run_at_ms;
     if (row.last_run_status)
         state.lastRunStatus = row.last_run_status;
     return state;
 }
 export function jobFromOpenClawRow(row) {
-    const tableState = parseJson(row.state_json || "{}", "state_json");
+    let tableState = {};
     try {
-        const parsed = parseJson(row.job_json, "job_json");
+        tableState = parseJson(row.state_json || '{}', 'state_json');
+    }
+    catch {
+        // A valid job_json must remain importable when an ancillary state column
+        // is corrupt. The scheduler will safely calculate a fresh next run.
+    }
+    try {
+        const parsed = parseJson(row.job_json, 'job_json');
         if (!isRecord(parsed))
-            throw new Error("job_json must be an object");
+            throw new Error('job_json must be an object');
         return decodeJob({
             ...parsed,
-            id: typeof parsed.id === "string" && parsed.id ? parsed.id : row.job_id,
-            updatedAtMs: typeof parsed.updatedAtMs === "number" ? parsed.updatedAtMs : row.updated_at,
-            createdAtMs: typeof parsed.createdAtMs === "number" ? parsed.createdAtMs : row.created_at_ms,
+            id: typeof parsed.id === 'string' && parsed.id ? parsed.id : row.job_id,
+            updatedAtMs: typeof parsed.updatedAtMs === 'number' ? parsed.updatedAtMs : row.updated_at,
+            createdAtMs: typeof parsed.createdAtMs === 'number' ? parsed.createdAtMs : row.created_at_ms,
             state: overlayState(row, parsed.state, tableState)
         });
     }
@@ -95,17 +106,23 @@ export function jobFromOpenClawRow(row) {
     }
 }
 export function loadOpenClawSqliteJobs(sqlitePath) {
+    return loadOpenClawSqliteJobsWithDiagnostics(sqlitePath).jobs;
+}
+export function loadOpenClawSqliteJobsWithDiagnostics(sqlitePath) {
     if (!existsSync(sqlitePath))
-        return [];
+        return { jobs: [], skipped: [] };
     const database = new DatabaseSync(sqlitePath, { readOnly: true, timeout: 5_000 });
     try {
         const table = database.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'cron_jobs'").get();
         if (!table)
-            return [];
+            return { jobs: [], skipped: [] };
         // SELECT * deliberately tolerates OpenClaw schema additions and older schemas
         // that omit newer nullable projection columns. job_json remains authoritative.
-        const rows = database.prepare("SELECT * FROM cron_jobs ORDER BY updated_at ASC, job_id ASC").all();
+        const rows = database
+            .prepare('SELECT * FROM cron_jobs ORDER BY updated_at ASC, job_id ASC')
+            .all();
         const jobs = new Map();
+        const skipped = [];
         for (const row of rows) {
             try {
                 const job = jobFromOpenClawRow(row);
@@ -113,21 +130,66 @@ export function loadOpenClawSqliteJobs(sqlitePath) {
                 if (!previous || job.updatedAtMs >= previous.updatedAtMs)
                     jobs.set(job.id, job);
             }
-            catch {
-                // Skip a corrupt row so one bad job cannot block the rest of the import.
+            catch (error) {
+                // Skip a corrupt row so one bad job cannot block the rest of the import,
+                // but retain enough information for the host to report the omission.
+                skipped.push({
+                    jobId: typeof row.job_id === 'string' && row.job_id ? row.job_id : '<unknown>',
+                    reason: error instanceof Error ? error.message : String(error)
+                });
             }
         }
-        return [...jobs.values()];
+        return { jobs: [...jobs.values()], skipped };
     }
     finally {
         database.close();
     }
 }
-export function resolveOpenClawSqlitePath(configured) {
+/**
+ * Materialize a consistent OpenClaw database snapshot. Copying only the main
+ * SQLite file loses transactions which are still in the source database WAL.
+ */
+export async function snapshotOpenClawSqlite(sqlitePath, destination) {
+    const database = new DatabaseSync(sqlitePath, { readOnly: true, timeout: 5_000 });
+    try {
+        const directory = path.dirname(destination);
+        const temporary = path.join(directory, `.${path.basename(destination)}.${randomUUID()}.tmp`);
+        await mkdir(directory, { recursive: true });
+        try {
+            await backup(database, temporary);
+            await chmod(temporary, 0o600);
+            // The destination is a private staging database. Remove any stale WAL
+            // sidecars before replacing its main database file.
+            await Promise.all([
+                unlink(`${destination}-wal`).catch(() => undefined),
+                unlink(`${destination}-shm`).catch(() => undefined)
+            ]);
+            await rename(temporary, destination);
+        }
+        catch (error) {
+            await unlink(temporary).catch(() => undefined);
+            throw error;
+        }
+    }
+    finally {
+        database.close();
+    }
+}
+export function resolveOpenClawSqlitePath(configured, targetHome = dshHomePath('.'), userHome = os.homedir()) {
     const explicit = configured?.trim() || process.env.OPENCLAW_SQLITE?.trim();
     if (explicit)
         return path.resolve(explicit);
-    return DEFAULT_OPENCLAW_SQLITE;
+    const target = path.basename(path.resolve(targetHome));
+    if (target === '.mobook-harness')
+        return path.join(userHome, '.mobook', 'state', 'openclaw.sqlite');
+    if (target === '.dsh')
+        return path.join(userHome, '.openclaw', 'state', 'openclaw.sqlite');
+    throw new Error('Custom DSH home requires an explicit openclawSqlite or OPENCLAW_SQLITE migration source');
+}
+// Keep the automatic import ledger identity, including on the CLI, so switching
+// entry points cannot re-import tasks that were deliberately deleted.
+export function automaticOpenClawImportSource(targetHome = dshHomePath('.')) {
+    return openClawImportSource(path.join(targetHome, 'migration', 'openclaw.sqlite'));
 }
 export function openClawImportSource(sqlitePath) {
     const resolved = path.resolve(sqlitePath);

package/src/repository.d.ts

@@ -59,6 +59,13 @@ export interface CronImportResult {
     added: StoredCronAutomation[];
     skippedIds: string[];
 }
+export interface CronImportedJob {
+    source: string;
+    jobId: string;
+}
+export interface CronLegacyMigrationResult extends CronImportResult {
+    alreadyMigrated: boolean;
+}
 export interface CronAutomationRepositoryOptions {
     readOnly?: boolean;
 }
@@ -75,6 +82,8 @@ export declare class CronAutomationRepository {
     delete(jobId: string): Promise<boolean>;
     previewImport(source: string, incoming: readonly StoredCronAutomation[]): Promise<CronImportResult>;
     import(source: string, incoming: readonly StoredCronAutomation[]): Promise<CronImportResult>;
+    listImportedJobs(): Promise<CronImportedJob[]>;
+    migrateLegacy(migrationId: string, incoming: readonly StoredCronAutomation[], importedJobs: readonly CronImportedJob[]): Promise<CronLegacyMigrationResult>;
     close(): void;
     private planImport;
     private nextSortOrder;

package/src/repository.js

@@ -219,6 +219,11 @@ export class CronAutomationRepository {
         imported_at INTEGER NOT NULL,
         PRIMARY KEY (source, job_id)
       );
+
+      CREATE TABLE IF NOT EXISTS cron_migrations (
+        migration_id TEXT PRIMARY KEY,
+        completed_at INTEGER NOT NULL
+      );
     `);
         this.insertJobStatement = this.database.prepare(`
       INSERT INTO cron_jobs (
@@ -330,6 +335,38 @@ export class CronAutomationRepository {
             return result;
         });
     }
+    async listImportedJobs() {
+        this.assertOpen();
+        const table = this.database
+            .prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'cron_imported_jobs'")
+            .get();
+        if (!table)
+            return [];
+        return this.database.prepare('SELECT source, job_id FROM cron_imported_jobs').all().map((row) => ({ source: row.source, jobId: row.job_id }));
+    }
+    async migrateLegacy(migrationId, incoming, importedJobs) {
+        this.assertWritable();
+        const decoded = uniqueJobs(incoming);
+        return this.writeTransaction(() => {
+            const completed = this.database.prepare('SELECT 1 FROM cron_migrations WHERE migration_id = ?').get(migrationId);
+            if (completed)
+                return { added: [], skippedIds: [], alreadyMigrated: true };
+            const result = this.planImport(migrationId, decoded);
+            const nextOrder = this.nextSortOrder();
+            result.added.forEach((job, index) => this.insertJob(job, nextOrder + index));
+            const markImported = this.database.prepare(`
+        INSERT OR IGNORE INTO cron_imported_jobs (source, job_id, imported_at)
+        VALUES (?, ?, ?)
+      `);
+            const importedAt = Date.now();
+            for (const job of importedJobs)
+                markImported.run(job.source, job.jobId, importedAt);
+            this.database
+                .prepare('INSERT INTO cron_migrations (migration_id, completed_at) VALUES (?, ?)')
+                .run(migrationId, importedAt);
+            return { ...result, alreadyMigrated: false };
+        });
+    }
     close() {
         if (this.closed)
             return;

package/src/runtime-environment.d.ts

@@ -0,0 +1,13 @@
+export declare const CRON_RUNTIME_ENVIRONMENTS: readonly ["development", "test", "production"];
+export type CronRuntimeEnvironment = (typeof CRON_RUNTIME_ENVIRONMENTS)[number];
+export declare function resolveCronRuntimeEnvironment(value: string | undefined): CronRuntimeEnvironment;
+/**
+ * Keep scheduled tasks and the import ledger isolated between desktop build
+ * environments even though they intentionally share one DSH_HOME.
+ */
+export declare function cronRuntimePath(environment: CronRuntimeEnvironment, ...segments: string[]): string;
+export declare function resolveCronDatabaseFile(configured: string | undefined, environment: CronRuntimeEnvironment): string;
+/** The pre-environment database is owned by production unless explicitly reassigned. */
+export declare function resolveLegacyCronOwner(value: string | undefined): CronRuntimeEnvironment;
+export declare function legacyCronDatabaseFile(): string;
+export declare function legacyCronMigrationId(file: string): string;

package/src/runtime-environment.js

@@ -0,0 +1,32 @@
+import path from 'node:path';
+import { existsSync, realpathSync } from 'node:fs';
+import { dshHomePath } from '@deepseek-ai/dsh-home-paths';
+export const CRON_RUNTIME_ENVIRONMENTS = ['development', 'test', 'production'];
+export function resolveCronRuntimeEnvironment(value) {
+    const environment = value?.trim() || 'development';
+    if (CRON_RUNTIME_ENVIRONMENTS.includes(environment)) {
+        return environment;
+    }
+    throw new Error(`Unsupported cron runtime environment: ${environment}`);
+}
+/**
+ * Keep scheduled tasks and the import ledger isolated between desktop build
+ * environments even though they intentionally share one DSH_HOME.
+ */
+export function cronRuntimePath(environment, ...segments) {
+    return dshHomePath('cron', environment, ...segments);
+}
+export function resolveCronDatabaseFile(configured, environment) {
+    return configured?.trim() ? path.resolve(configured) : cronRuntimePath(environment, 'cron.sqlite');
+}
+/** The pre-environment database is owned by production unless explicitly reassigned. */
+export function resolveLegacyCronOwner(value) {
+    return resolveCronRuntimeEnvironment(value?.trim() || 'production');
+}
+export function legacyCronDatabaseFile() {
+    return dshHomePath('cron', 'cron.sqlite');
+}
+export function legacyCronMigrationId(file) {
+    const resolved = path.resolve(file);
+    return `legacy-cron-sqlite:${existsSync(resolved) ? realpathSync.native(resolved) : resolved}`;
+}