@dcrays/scheduled-task 0.1.1 → 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.1",
+  "version": "0.1.3",
   "description": "Persistent client-facing cron automation service for DeepSeek Harness (production)",
   "type": "module",
   "main": "plugin/index.js",

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,10 +1,9 @@
 import { createRequire as __mobookCreateRequire } from 'node:module'; const require = __mobookCreateRequire(import.meta.url);
 
 // dist-npm/plugin/index.js
-import { existsSync as existsSync2 } from "node:fs";
-import path3 from "node:path";
+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";
@@ -516,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 (
@@ -623,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;
@@ -1044,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());
@@ -1113,13 +1168,12 @@ var CronAutomationManager = class {
 
 // dist-npm/src/openclaw-sqlite.js
 import { existsSync, realpathSync } from "node:fs";
-import { mkdir, rename, unlink, writeFile } from "node:fs/promises";
+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");
-var DEFAULT_OPENCLAW_SQLITE_ALT = path2.join(os.homedir(), ".openclaw", "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);
 }
@@ -1181,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))
@@ -1208,26 +1266,31 @@ 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();
   }
@@ -1235,12 +1298,16 @@ function loadOpenClawSqliteJobs(sqlitePath) {
 async function snapshotOpenClawSqlite(sqlitePath, destination) {
   const database = new DatabaseSync2(sqlitePath, { readOnly: true, timeout: 5e3 });
   try {
-    const serialized = database.serialize();
     const directory = path2.dirname(destination);
     const temporary = path2.join(directory, `.${path2.basename(destination)}.${randomUUID()}.tmp`);
     await mkdir(directory, { recursive: true });
     try {
-      await writeFile(temporary, serialized, { mode: 384 });
+      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);
@@ -1250,12 +1317,55 @@ async function snapshotOpenClawSqlite(sqlitePath, destination) {
     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);
+  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);
   const canonical = existsSync(resolved) ? realpathSync.native(resolved) : resolved;
   return `openclaw-sqlite:${canonical}`;
 }
 
+// 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"];
@@ -1264,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)
 });
@@ -1409,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}`,
@@ -1463,12 +1576,13 @@ 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,
@@ -1511,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)
@@ -1518,37 +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 explicit = this.config.openclawSqlite?.trim() || process.env["OPENCLAW_SQLITE"]?.trim();
     let sqlitePath;
     if (explicit) {
-      sqlitePath = path3.resolve(explicit);
+      sqlitePath = path4.resolve(explicit);
     } else {
-      const stagingPath = dshHomePath("migration", "openclaw.sqlite");
-      const sourceCandidate = [DEFAULT_OPENCLAW_SQLITE, DEFAULT_OPENCLAW_SQLITE_ALT].find(existsSync2);
-      if (!existsSync2(stagingPath) && sourceCandidate) {
+      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 incoming;
+    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

@@ -383,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());

package/src/openclaw-sqlite.d.ts

@@ -1,6 +1,11 @@
 import { type StoredCronAutomation } from './repository.js';
-export declare const DEFAULT_OPENCLAW_SQLITE: string;
-export declare const DEFAULT_OPENCLAW_SQLITE_ALT: string;
+export interface OpenClawSqliteImportResult {
+    jobs: StoredCronAutomation[];
+    skipped: Array<{
+        jobId: string;
+        reason: string;
+    }>;
+}
 interface CronJobRow {
     job_id: string;
     name: string;
@@ -36,11 +41,13 @@ interface CronJobRow {
 }
 export declare function jobFromOpenClawRow(row: CronJobRow): StoredCronAutomation;
 export declare function loadOpenClawSqliteJobs(sqlitePath: string): StoredCronAutomation[];
+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): string;
+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,12 +1,11 @@
 import { existsSync, realpathSync } from 'node:fs';
-import { mkdir, rename, unlink, writeFile } from 'node:fs/promises';
+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 { DatabaseSync } from 'node:sqlite';
+import { backup, DatabaseSync } from 'node:sqlite';
+import { dshHomePath } from '@deepseek-ai/dsh-home-paths';
 import { decodeJob } from './repository.js';
-export const DEFAULT_OPENCLAW_SQLITE = path.join(os.homedir(), '.mobook', 'state', 'openclaw.sqlite');
-export const DEFAULT_OPENCLAW_SQLITE_ALT = path.join(os.homedir(), '.openclaw', 'state', 'openclaw.sqlite');
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -69,18 +68,27 @@ 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 {
+        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))
@@ -98,19 +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 jobs = new Map();
+        const skipped = [];
         for (const row of rows) {
             try {
                 const job = jobFromOpenClawRow(row);
@@ -118,11 +130,16 @@ 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();
@@ -135,14 +152,18 @@ export function loadOpenClawSqliteJobs(sqlitePath) {
 export async function snapshotOpenClawSqlite(sqlitePath, destination) {
     const database = new DatabaseSync(sqlitePath, { readOnly: true, timeout: 5_000 });
     try {
-        // @types/node 24.0 predates DatabaseSync.serialize(), which is available in
-        // the Electron/Node runtime we require. Keep the compatibility shim local.
-        const serialized = database.serialize();
         const directory = path.dirname(destination);
         const temporary = path.join(directory, `.${path.basename(destination)}.${randomUUID()}.tmp`);
         await mkdir(directory, { recursive: true });
         try {
-            await writeFile(temporary, serialized, { mode: 0o600 });
+            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) {
@@ -154,11 +175,21 @@ export async function snapshotOpenClawSqlite(sqlitePath, destination) {
         database.close();
     }
 }
-export function resolveOpenClawSqlitePath(configured) {
+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}`;
+}