@dcrays/scheduled-task 0.1.4 → 0.1.5

package/cordis.patch.yml

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcrays/scheduled-task",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Persistent client-facing cron automation service for DeepSeek Harness",
   "type": "module",
   "main": "plugin/index.js",

package/plugin/index.d.ts

@@ -9,7 +9,6 @@ export declare const inject: string[];
 export interface Config {
     databaseFile?: string;
     openclawSqlite?: string;
-    runtimeEnvironment?: string;
     legacyDatabaseEnvironment?: string;
     maxPromptChars: number;
     listPushIntervalSeconds: number;

package/plugin/index.js

@@ -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(",")) {
@@ -634,6 +634,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);
@@ -716,6 +734,7 @@ var CronAutomationRepository = class {
 
 // dist-npm/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 +821,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 +871,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 +1043,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 +1059,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 +1134,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,36 +1262,18 @@ 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();
+    });
   }
 };
 
@@ -1268,12 +1379,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 +1401,7 @@ function loadOpenClawSqliteJobsWithDiagnostics(sqlitePath) {
         });
       }
     }
-    return { jobs: [...jobs.values()], skipped };
+    return { jobs: [...jobs.values()], skipped, complete: skipped.length === 0 };
   } finally {
     database.close();
   }
@@ -1383,7 +1494,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)
@@ -1590,11 +1700,12 @@ var CronAutomationService = class extends Service {
     super(owner, "cronAutomations");
     this.owner = owner;
     this.config = config;
-    this.runtimeEnvironment = resolveCronRuntimeEnvironment(readDesktopRuntimeEnvironment() ?? config.runtimeEnvironment);
+    this.runtimeEnvironment = resolveCronRuntimeEnvironment(readDesktopRuntimeEnvironment());
     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);
@@ -1612,6 +1723,7 @@ var CronAutomationService = class extends Service {
           return false;
         }
         agent.followup(dueMessage(cron, occurrenceAt));
+        await agent.whenIdle();
         return true;
       },
       onError: (error) => logger.warn("cron automation runtime failed: %s", error instanceof Error ? error.message : String(error)),
@@ -1636,6 +1748,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;
@@ -1700,11 +1813,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 +1871,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 +1951,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;

package/src/cron.js

@@ -24,7 +24,9 @@ function parseInteger(value, label) {
 }
 function parseField(raw, min, max, label, normalize) {
     const values = new Set();
-    const wildcard = raw === "*" || raw.startsWith("*/");
+    // A stepped field such as */2 selects a subset of values.  It must remain
+    // restricted for cron's day-of-month/day-of-week matching rule.
+    const wildcard = raw === "*";
     if (raw.length === 0)
         throw new CronExpressionError(`${label} is empty`);
     for (const segment of raw.split(",")) {

package/src/manager.d.ts

@@ -2,6 +2,7 @@ import type { CronCreateEnvelope } from './protocol.js';
 import { CronAutomationRepository, type CronImportedJob, type StoredCronAutomation } from './repository.js';
 export interface CronAutomationManagerOptions {
     maxPromptChars: number;
+    startPaused?: boolean;
     now?: () => number;
     deliver(job: StoredCronAutomation, occurrenceAt: string): boolean | Promise<boolean>;
     onError?(error: unknown): void;
@@ -25,12 +26,18 @@ export declare class CronAutomationManager {
     private readonly options;
     private readonly jobs;
     private readonly blockedAgents;
+    private readonly blockedUntil;
+    private readonly activeJobs;
+    private readonly inflight;
     private readonly now;
     private started?;
     private tail;
+    private dispatchLoop;
     private timer;
     private stopping;
+    private schedulingPaused;
     constructor(repository: CronAutomationRepository, options: CronAutomationManagerOptions);
+    resumeScheduling(): void;
     start(): Promise<void>;
     private initialize;
     stop(): Promise<void>;
@@ -41,6 +48,8 @@ export declare class CronAutomationManager {
     runOnce(jobId: string): Promise<boolean>;
     list(agentId?: string): Promise<StoredCronAutomation[]>;
     notifyAgentAvailable(agentId: string): void;
+    /** Reflect deletions only for ids recorded in this source's import ledger. */
+    reconcileImportedDeletions(source: string, presentIds: ReadonlySet<string>): Promise<string[]>;
     /** 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<{
@@ -49,6 +58,11 @@ export declare class CronAutomationManager {
     }>;
     private prepareImportedJob;
     private deliver;
+    private deliverTracked;
+    private claimManualRun;
+    private finalizeManualRun;
+    private claimNextDueJob;
+    private finalizeScheduledRun;
     private enqueue;
     private requestDispatch;
     private arm;

package/src/manager.js

@@ -3,6 +3,7 @@ import { assertMinimumCronInterval, CronExpressionError, MIN_CRON_INTERVAL_SECON
 import { CronAutomationInputError } from './protocol.js';
 import { CronAutomationRepository } from './repository.js';
 const MAX_TIMER_DELAY_MS = 2_147_483_647;
+const DELIVERY_RETRY_DELAY_MS = 30_000;
 function automationId(agentId, requestId) {
     return `cron-${createHash('sha256').update(`${agentId}\0${requestId}`).digest('hex').slice(0, 24)}`;
 }
@@ -96,15 +97,25 @@ export class CronAutomationManager {
     options;
     jobs = new Map();
     blockedAgents = new Set();
+    blockedUntil = new Map();
+    activeJobs = new Set();
+    inflight = 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());
@@ -136,6 +147,8 @@ export class CronAutomationManager {
             clearTimeout(this.timer);
         this.timer = undefined;
         try {
+            await this.dispatchLoop.catch(() => undefined);
+            await Promise.all([...this.inflight]);
             await this.tail;
         }
         finally {
@@ -314,33 +327,12 @@ export class CronAutomationManager {
     }
     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 !== 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;
-            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';
@@ -354,10 +346,25 @@ export class CronAutomationManager {
             .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();
@@ -415,16 +422,129 @@ export class CronAutomationManager {
             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 !== undefined)
+            return { kind: 'status', status: '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 { 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 undefined;
+        const now = this.now();
+        const job = [...this.jobs.values()]
+            .filter((candidate) => candidate.enabled &&
+            hasDshSession(candidate) &&
+            candidate.state.runningAtMs === undefined &&
+            !this.activeJobs.has(candidate.id) &&
+            candidate.state.nextRunAtMs !== undefined &&
+            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 undefined;
+        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(() => undefined, () => undefined);
         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);
@@ -434,8 +554,11 @@ export class CronAutomationManager {
             .filter((job) => job.enabled &&
             hasDshSession(job) &&
             job.state.runningAtMs === undefined &&
-            !this.blockedAgents.has(dshAgentIdFor(job)))
-            .map((job) => job.state.nextRunAtMs)
+            (!this.blockedAgents.has(dshAgentIdFor(job)) || (this.blockedUntil.get(dshAgentIdFor(job)) ?? 0) <= now))
+            .map((job) => {
+            const retryAt = this.blockedUntil.get(dshAgentIdFor(job));
+            return retryAt !== undefined && retryAt > now ? retryAt : job.state.nextRunAtMs;
+        })
             .filter((value) => value !== undefined)
             .reduce((earliest, candidate) => (earliest === undefined || candidate < earliest ? candidate : earliest), undefined);
         if (target === undefined)
@@ -448,38 +571,17 @@ export class CronAutomationManager {
         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 !== 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;
-            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();
+        });
     }
 }

package/src/openclaw-sqlite.d.ts

@@ -5,6 +5,8 @@ export interface OpenClawSqliteImportResult {
         jobId: string;
         reason: string;
     }>;
+    /** False for a missing source/table or an unreadable row; never infer deletions then. */
+    complete: boolean;
 }
 interface CronJobRow {
     job_id: string;

package/src/openclaw-sqlite.js

@@ -110,12 +110,12 @@ export function loadOpenClawSqliteJobs(sqlitePath) {
 }
 export function loadOpenClawSqliteJobsWithDiagnostics(sqlitePath) {
     if (!existsSync(sqlitePath))
-        return { jobs: [], skipped: [] };
+        return { jobs: [], skipped: [], complete: false };
     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 { jobs: [], skipped: [] };
+            return { jobs: [], skipped: [], complete: false };
         // SELECT * deliberately tolerates OpenClaw schema additions and older schemas
         // that omit newer nullable projection columns. job_json remains authoritative.
         const rows = database
@@ -139,7 +139,7 @@ export function loadOpenClawSqliteJobsWithDiagnostics(sqlitePath) {
                 });
             }
         }
-        return { jobs: [...jobs.values()], skipped };
+        return { jobs: [...jobs.values()], skipped, complete: skipped.length === 0 };
     }
     finally {
         database.close();

package/src/repository.d.ts

@@ -83,6 +83,8 @@ export declare class CronAutomationRepository {
     previewImport(source: string, incoming: readonly StoredCronAutomation[]): Promise<CronImportResult>;
     import(source: string, incoming: readonly StoredCronAutomation[]): Promise<CronImportResult>;
     listImportedJobs(): Promise<CronImportedJob[]>;
+    /** Only a verified complete source snapshot may authorize these deletions. */
+    removeMissingImportedJobs(source: string, presentIds: ReadonlySet<string>): Promise<string[]>;
     migrateLegacy(migrationId: string, incoming: readonly StoredCronAutomation[], importedJobs: readonly CronImportedJob[]): Promise<CronLegacyMigrationResult>;
     close(): void;
     private planImport;

package/src/repository.js

@@ -344,6 +344,27 @@ export class CronAutomationRepository {
             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);
+            // Keep the import ledger: an old snapshot must not resurrect a deletion.
+            return removed;
+        });
+    }
     async migrateLegacy(migrationId, incoming, importedJobs) {
         this.assertWritable();
         const decoded = uniqueJobs(incoming);