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

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/output.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveTaskOutputRoot(globalOutput: string, workspace?: string): string;
+export declare function cronOutputDirectory(cronId: string, workspace?: string, dshHome?: string): string;

package/src/output.js

@@ -0,0 +1,26 @@
+import { createHash } from 'node:crypto';
+import { mkdirSync } from 'node:fs';
+import path from 'node:path';
+import { resolveDshHome } from '@deepseek-ai/dsh-home-paths';
+export function resolveTaskOutputRoot(globalOutput, workspace) {
+    const output = path.resolve(globalOutput);
+    if (!workspace)
+        return output;
+    const resolved = path.resolve(workspace);
+    if (resolved === output)
+        return output;
+    const workspaceFolder = path.dirname(output);
+    const home = path.dirname(workspaceFolder);
+    if (resolved === home || resolved === workspaceFolder)
+        return output;
+    return path.join(resolved, 'output');
+}
+export function cronOutputDirectory(cronId, workspace, dshHome = resolveDshHome()) {
+    const segment = (value) => createHash('sha256').update(value).digest('hex').slice(0, 24);
+    const base = resolveTaskOutputRoot(path.join(dshHome, 'workspace', 'output'), workspace);
+    const root = path.join(base, segment(`cron:${cronId}`));
+    for (const directory of ['files', 'tmp', 'previews', 'downloads']) {
+        mkdirSync(path.join(root, directory), { recursive: true });
+    }
+    return root;
+}

package/src/repository.d.ts

@@ -77,12 +77,15 @@ export declare class CronAutomationRepository {
     private readonly readOnly;
     private closed;
     constructor(file: string, options?: CronAutomationRepositoryOptions);
+    hasLegacyMigration(migrationId: string): boolean;
     load(): Promise<StoredCronAutomation[]>;
     upsert(jobs: readonly StoredCronAutomation[]): Promise<void>;
     delete(jobId: string): Promise<boolean>;
     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

@@ -285,6 +285,13 @@ export class CronAutomationRepository {
             // Best effort on filesystems without POSIX modes.
         }
     }
+    hasLegacyMigration(migrationId) {
+        this.assertOpen();
+        const table = this.database
+            .prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'cron_migrations'")
+            .get();
+        return Boolean(table && this.database.prepare('SELECT 1 FROM cron_migrations WHERE migration_id = ?').get(migrationId));
+    }
     async load() {
         this.assertOpen();
         const rows = this.database
@@ -344,6 +351,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);

package/src/runtime-environment.d.ts

@@ -14,7 +14,20 @@ export declare function readDesktopRuntimeEnvironment(): string | undefined;
  */
 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;
+/**
+ * Choose which isolated environment may ingest `$DSH_HOME/cron/cron.sqlite`.
+ *
+ * Desktop always writes `environment` before starting DSH, so production keeps
+ * the pre-split jobs and test/dev cannot steal them. Unmanaged DSH homes such
+ * as `dsh web` leave that field empty; those jobs stay with the current runtime
+ * (development by default) instead of being stranded in the unused file.
+ */
+export declare function resolveLegacyCronOwner(configured: string | undefined, recordedEnvironment?: string | undefined, runtimeEnvironment?: CronRuntimeEnvironment): CronRuntimeEnvironment;
+/**
+ * Persist the existing migration owner, or first selected owner, next to the shared legacy database.
+ * A hard-link publish makes competing process claims atomic without leaving a
+ * partially-written marker visible to the loser.
+ */
+export declare function claimLegacyCronOwner(configured: string | undefined, recordedEnvironment: string | undefined, runtimeEnvironment: CronRuntimeEnvironment): CronRuntimeEnvironment;
 export declare function legacyCronDatabaseFile(): string;
 export declare function legacyCronMigrationId(file: string): string;

package/src/runtime-environment.js

@@ -1,6 +1,8 @@
+import { randomUUID } from 'node:crypto';
 import path from 'node:path';
-import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { existsSync, linkSync, mkdirSync, readFileSync, realpathSync, unlinkSync, writeFileSync } from 'node:fs';
 import { dshHomePath } from '@deepseek-ai/dsh-home-paths';
+import { CronAutomationRepository } from './repository.js';
 export const CRON_RUNTIME_ENVIRONMENTS = ['development', 'test', 'production'];
 export function resolveCronRuntimeEnvironment(value) {
     const environment = value?.trim() || 'development';
@@ -16,14 +18,32 @@ export function resolveCronRuntimeEnvironment(value) {
  * though all builds share one DSH_HOME.
  */
 export function readDesktopRuntimeEnvironment() {
+    let contents;
     try {
-        const parsed = JSON.parse(readFileSync(dshHomePath('mobook.json'), 'utf8'));
-        const value = parsed && typeof parsed === 'object' ? parsed.environment : undefined;
-        return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+        contents = readFileSync(dshHomePath('mobook.json'), 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(contents);
     }
     catch {
+        throw new Error(`Invalid mobook.json: ${dshHomePath('mobook.json')}`);
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`Unsupported mobook.json root value: ${dshHomePath('mobook.json')}`);
+    }
+    const value = parsed.environment;
+    if (value === undefined)
         return undefined;
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new Error('mobook.json environment must be a non-empty string');
     }
+    return value.trim();
 }
 /**
  * Keep scheduled tasks and the import ledger isolated between desktop build
@@ -35,9 +55,99 @@ export function cronRuntimePath(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');
+/**
+ * Choose which isolated environment may ingest `$DSH_HOME/cron/cron.sqlite`.
+ *
+ * Desktop always writes `environment` before starting DSH, so production keeps
+ * the pre-split jobs and test/dev cannot steal them. Unmanaged DSH homes such
+ * as `dsh web` leave that field empty; those jobs stay with the current runtime
+ * (development by default) instead of being stranded in the unused file.
+ */
+export function resolveLegacyCronOwner(configured, recordedEnvironment = undefined, runtimeEnvironment = 'production') {
+    if (configured?.trim())
+        return resolveCronRuntimeEnvironment(configured);
+    if (recordedEnvironment?.trim())
+        return 'production';
+    return runtimeEnvironment;
+}
+function legacyCronOwnerFile() {
+    return dshHomePath('cron', 'legacy-owner.json');
+}
+function readLegacyCronOwner(file) {
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch (cause) {
+        throw new Error(`Invalid legacy cron owner marker: ${file}`, { cause });
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`Invalid legacy cron owner marker: ${file}`);
+    }
+    const record = parsed;
+    if (record.version !== 1 || !CRON_RUNTIME_ENVIRONMENTS.includes(record.owner)) {
+        throw new Error(`Invalid legacy cron owner marker: ${file}`);
+    }
+    return record.owner;
+}
+function previouslyMigratedOwner() {
+    const migrationId = legacyCronMigrationId(legacyCronDatabaseFile());
+    const owners = [];
+    for (const environment of CRON_RUNTIME_ENVIRONMENTS) {
+        const file = cronRuntimePath(environment, 'cron.sqlite');
+        if (!existsSync(file))
+            continue;
+        const repository = new CronAutomationRepository(file, { readOnly: true });
+        try {
+            if (repository.hasLegacyMigration(migrationId))
+                owners.push(environment);
+        }
+        finally {
+            repository.close();
+        }
+    }
+    if (owners.length > 1) {
+        throw new Error(`Legacy cron database was already migrated into multiple environments: ${owners.join(', ')}`);
+    }
+    return owners[0];
+}
+/**
+ * Persist the existing migration owner, or first selected owner, next to the shared legacy database.
+ * A hard-link publish makes competing process claims atomic without leaving a
+ * partially-written marker visible to the loser.
+ */
+export function claimLegacyCronOwner(configured, recordedEnvironment, runtimeEnvironment) {
+    const file = legacyCronOwnerFile();
+    if (existsSync(file))
+        return readLegacyCronOwner(file);
+    const owner = previouslyMigratedOwner() ?? resolveLegacyCronOwner(configured, recordedEnvironment, runtimeEnvironment);
+    mkdirSync(path.dirname(file), { recursive: true });
+    const temporary = `${file}.tmp-${process.pid}-${randomUUID()}`;
+    try {
+        writeFileSync(temporary, `${JSON.stringify({ version: 1, owner })}\n`, {
+            encoding: 'utf8',
+            mode: 0o600,
+            flag: 'wx'
+        });
+        try {
+            linkSync(temporary, file);
+            return owner;
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            return readLegacyCronOwner(file);
+        }
+    }
+    finally {
+        try {
+            unlinkSync(temporary);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    }
 }
 export function legacyCronDatabaseFile() {
     return dshHomePath('cron', 'cron.sqlite');