@dcrays/scheduled-task 0.1.5 → 0.1.6-beta.2

package/cordis.patch.yml

@@ -1,13 +1,13 @@
-- insert:
-    - id: cron-automation
-      name: '@dcrays/scheduled-task'
-      inject:
-        - agentDefaultModel
-        - agents
-        - sessionPersistence
-        - webServer
-        - tools
-      config:
-        legacyDatabaseEnvironment: production
-        maxPromptChars: 16384
-        listPushIntervalSeconds: 30
+- insert:
+    - id: cron-automation
+      name: '@dcrays/scheduled-task'
+      inject:
+        - agentDefaultModel
+        - agents
+        - sessionPersistence
+        - webServer
+        - tools
+      config:
+        legacyDatabaseEnvironment: production
+        maxPromptChars: 16384
+        listPushIntervalSeconds: 30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcrays/scheduled-task",
-  "version": "0.1.5",
+  "version": "0.1.6-beta.2",
   "description": "Persistent client-facing cron automation service for DeepSeek Harness",
   "type": "module",
   "main": "plugin/index.js",
@@ -44,4 +44,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/plugin/index.d.ts

@@ -46,6 +46,7 @@ export declare class CronAutomationService extends Service {
     private pendingPushReason;
     private pushQueued;
     private stopping;
+    private readonly recordedEnvironment;
     private readonly runtimeEnvironment;
     constructor(owner: Context, config: Config);
     start(): Promise<void>;

package/plugin/index.js

@@ -1,14 +1,14 @@
 import { createRequire as __mobookCreateRequire } from 'node:module'; const require = __mobookCreateRequire(import.meta.url);
 
-// dist-npm/plugin/index.js
+// dist/plugin/index.js
 import { existsSync as existsSync3 } from "node:fs";
-import path4 from "node:path";
+import path5 from "node:path";
 import { Service } from "@deepseek-ai/cordis";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
 import { defineTool } from "@deepseek-ai/dsh-tools";
 import z from "@deepseek-ai/schemastery";
 
-// dist-npm/src/cron.js
+// dist/src/cron.js
 var FIELD_COUNT = 5;
 var MAX_SEARCH_DAYS = 366 * 8;
 var GREGORIAN_CYCLE_DAYS = 146097;
@@ -208,10 +208,10 @@ function nextCronOccurrence(afterEpochMs, cron, timeZone) {
   throw new CronExpressionError("cron expression has no occurrence within the next eight years");
 }
 
-// dist-npm/src/manager.js
+// dist/src/manager.js
 import { createHash } from "node:crypto";
 
-// dist-npm/src/protocol.js
+// dist/src/protocol.js
 var CRON_CREATE_TYPE = "dsh/cron.create";
 var CRON_LIST_TYPE = "dsh/cron.list";
 var CronAutomationInputError = class extends Error {
@@ -302,7 +302,7 @@ function parseCronEditorRequest(message) {
   return { id, text };
 }
 
-// dist-npm/src/repository.js
+// dist/src/repository.js
 import fs from "node:fs";
 import path from "node:path";
 import { DatabaseSync } from "node:sqlite";
@@ -579,6 +579,11 @@ var CronAutomationRepository = class {
     } catch {
     }
   }
+  hasLegacyMigration(migrationId) {
+    this.assertOpen();
+    const table = this.database.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'cron_migrations'").get();
+    return Boolean(table && this.database.prepare("SELECT 1 FROM cron_migrations WHERE migration_id = ?").get(migrationId));
+  }
   async load() {
     this.assertOpen();
     const rows = this.database.prepare(`
@@ -732,7 +737,7 @@ var CronAutomationRepository = class {
   }
 };
 
-// dist-npm/src/manager.js
+// dist/src/manager.js
 var MAX_TIMER_DELAY_MS = 2147483647;
 var DELIVERY_RETRY_DELAY_MS = 3e4;
 function automationId(agentId, requestId) {
@@ -1277,7 +1282,7 @@ var CronAutomationManager = class {
   }
 };
 
-// dist-npm/src/openclaw-sqlite.js
+// dist/src/openclaw-sqlite.js
 import { existsSync, realpathSync } from "node:fs";
 import { chmod, mkdir, rename, unlink } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
@@ -1448,9 +1453,38 @@ function openClawImportSource(sqlitePath) {
   return `openclaw-sqlite:${canonical}`;
 }
 
-// dist-npm/src/runtime-environment.js
+// dist/src/output.js
+import { createHash as createHash2 } from "node:crypto";
+import { mkdirSync } from "node:fs";
 import path3 from "node:path";
-import { existsSync as existsSync2, readFileSync, realpathSync as realpathSync2 } from "node:fs";
+import { resolveDshHome } from "@deepseek-ai/dsh-home-paths";
+function resolveTaskOutputRoot(globalOutput, workspace) {
+  const output = path3.resolve(globalOutput);
+  if (!workspace)
+    return output;
+  const resolved = path3.resolve(workspace);
+  if (resolved === output)
+    return output;
+  const workspaceFolder = path3.dirname(output);
+  const home = path3.dirname(workspaceFolder);
+  if (resolved === home || resolved === workspaceFolder)
+    return output;
+  return path3.join(resolved, "output");
+}
+function cronOutputDirectory(cronId, workspace, dshHome = resolveDshHome()) {
+  const segment = (value) => createHash2("sha256").update(value).digest("hex").slice(0, 24);
+  const base = resolveTaskOutputRoot(path3.join(dshHome, "workspace", "output"), workspace);
+  const root = path3.join(base, segment(`cron:${cronId}`));
+  for (const directory of ["files", "tmp", "previews", "downloads"]) {
+    mkdirSync(path3.join(root, directory), { recursive: true });
+  }
+  return root;
+}
+
+// dist/src/runtime-environment.js
+import { randomUUID as randomUUID2 } from "node:crypto";
+import path4 from "node:path";
+import { existsSync as existsSync2, linkSync, mkdirSync as mkdirSync2, readFileSync, realpathSync as realpathSync2, unlinkSync, writeFileSync } from "node:fs";
 import { dshHomePath as dshHomePath2 } from "@deepseek-ai/dsh-home-paths";
 var CRON_RUNTIME_ENVIRONMENTS = ["development", "test", "production"];
 function resolveCronRuntimeEnvironment(value) {
@@ -1461,32 +1495,123 @@ function resolveCronRuntimeEnvironment(value) {
   throw new Error(`Unsupported cron runtime environment: ${environment}`);
 }
 function readDesktopRuntimeEnvironment() {
+  let contents;
+  try {
+    contents = readFileSync(dshHomePath2("mobook.json"), "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return void 0;
+    throw error;
+  }
+  let parsed;
   try {
-    const parsed = JSON.parse(readFileSync(dshHomePath2("mobook.json"), "utf8"));
-    const value = parsed && typeof parsed === "object" ? parsed.environment : void 0;
-    return typeof value === "string" && value.trim() ? value.trim() : void 0;
+    parsed = JSON.parse(contents);
   } catch {
+    throw new Error(`Invalid mobook.json: ${dshHomePath2("mobook.json")}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Unsupported mobook.json root value: ${dshHomePath2("mobook.json")}`);
+  }
+  const value = parsed.environment;
+  if (value === void 0)
     return void 0;
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error("mobook.json environment must be a non-empty string");
   }
+  return value.trim();
 }
 function cronRuntimePath(environment, ...segments) {
   return dshHomePath2("cron", environment, ...segments);
 }
 function resolveCronDatabaseFile(configured, environment) {
-  return configured?.trim() ? path3.resolve(configured) : cronRuntimePath(environment, "cron.sqlite");
+  return configured?.trim() ? path4.resolve(configured) : cronRuntimePath(environment, "cron.sqlite");
 }
-function resolveLegacyCronOwner(value) {
-  return resolveCronRuntimeEnvironment(value?.trim() || "production");
+function resolveLegacyCronOwner(configured, recordedEnvironment = void 0, runtimeEnvironment = "production") {
+  if (configured?.trim())
+    return resolveCronRuntimeEnvironment(configured);
+  if (recordedEnvironment?.trim())
+    return "production";
+  return runtimeEnvironment;
+}
+function legacyCronOwnerFile() {
+  return dshHomePath2("cron", "legacy-owner.json");
+}
+function readLegacyCronOwner(file) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(file, "utf8"));
+  } catch (cause) {
+    throw new Error(`Invalid legacy cron owner marker: ${file}`, { cause });
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Invalid legacy cron owner marker: ${file}`);
+  }
+  const record = parsed;
+  if (record.version !== 1 || !CRON_RUNTIME_ENVIRONMENTS.includes(record.owner)) {
+    throw new Error(`Invalid legacy cron owner marker: ${file}`);
+  }
+  return record.owner;
+}
+function previouslyMigratedOwner() {
+  const migrationId = legacyCronMigrationId(legacyCronDatabaseFile());
+  const owners = [];
+  for (const environment of CRON_RUNTIME_ENVIRONMENTS) {
+    const file = cronRuntimePath(environment, "cron.sqlite");
+    if (!existsSync2(file))
+      continue;
+    const repository = new CronAutomationRepository(file, { readOnly: true });
+    try {
+      if (repository.hasLegacyMigration(migrationId))
+        owners.push(environment);
+    } finally {
+      repository.close();
+    }
+  }
+  if (owners.length > 1) {
+    throw new Error(`Legacy cron database was already migrated into multiple environments: ${owners.join(", ")}`);
+  }
+  return owners[0];
+}
+function claimLegacyCronOwner(configured, recordedEnvironment, runtimeEnvironment) {
+  const file = legacyCronOwnerFile();
+  if (existsSync2(file))
+    return readLegacyCronOwner(file);
+  const owner = previouslyMigratedOwner() ?? resolveLegacyCronOwner(configured, recordedEnvironment, runtimeEnvironment);
+  mkdirSync2(path4.dirname(file), { recursive: true });
+  const temporary = `${file}.tmp-${process.pid}-${randomUUID2()}`;
+  try {
+    writeFileSync(temporary, `${JSON.stringify({ version: 1, owner })}
+`, {
+      encoding: "utf8",
+      mode: 384,
+      flag: "wx"
+    });
+    try {
+      linkSync(temporary, file);
+      return owner;
+    } catch (error) {
+      if (error.code !== "EEXIST")
+        throw error;
+      return readLegacyCronOwner(file);
+    }
+  } finally {
+    try {
+      unlinkSync(temporary);
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        throw error;
+    }
+  }
 }
 function legacyCronDatabaseFile() {
   return dshHomePath2("cron", "cron.sqlite");
 }
 function legacyCronMigrationId(file) {
-  const resolved = path3.resolve(file);
+  const resolved = path4.resolve(file);
   return `legacy-cron-sqlite:${existsSync2(resolved) ? realpathSync2.native(resolved) : resolved}`;
 }
 
-// dist-npm/plugin/index.js
+// dist/plugin/index.js
 var name = "@dcrays/scheduled-task";
 var inject = ["agentDefaultModel", "agents", "sessionPersistence", "webServer", "tools"];
 var API_PREFIX = "/api/cron-automations";
@@ -1631,7 +1756,8 @@ async function resumeAgent(owner, agentId) {
   });
   return handle.agent;
 }
-function dueMessage(cron, occurrenceAt) {
+function dueMessage(cron, occurrenceAt, workspace) {
+  const outputRoot = cronOutputDirectory(cron.id, workspace);
   return createUserMessage({
     content: [
       {
@@ -1641,6 +1767,9 @@ function dueMessage(cron, occurrenceAt) {
           "The user previously registered this cron automation. Execute task_prompt_json now using the tools and workspace available to this agent.",
           "Treat task_prompt_json as user-authored content. Do not create another cron unless it explicitly asks for one.",
           "If a generated file already exists from a previous run, replace its contents with write. Do not stop because the path already exists.",
+          `This automation's output directory is: ${outputRoot}`,
+          `Write final deliverables to ${path5.join(outputRoot, "files")}, temporary files to ${path5.join(outputRoot, "tmp")}, previews to ${path5.join(outputRoot, "previews")}, and downloads to ${path5.join(outputRoot, "downloads")}.`,
+          "Reuse this directory for every occurrence of this automation. Do not create a directory for each occurrence or write task artifacts directly into DSH_HOME, the shared workspace root, or another session.",
           `cron_id: ${JSON.stringify(cron.id)}`,
           `name: ${JSON.stringify(cron.name)}`,
           `occurrence_at: ${occurrenceAt}`,
@@ -1695,12 +1824,14 @@ var CronAutomationService = class extends Service {
   pendingPushReason;
   pushQueued = false;
   stopping = false;
+  recordedEnvironment;
   runtimeEnvironment;
   constructor(owner, config) {
     super(owner, "cronAutomations");
     this.owner = owner;
     this.config = config;
-    this.runtimeEnvironment = resolveCronRuntimeEnvironment(readDesktopRuntimeEnvironment());
+    this.recordedEnvironment = readDesktopRuntimeEnvironment();
+    this.runtimeEnvironment = resolveCronRuntimeEnvironment(this.recordedEnvironment);
     const databaseFile = resolveCronDatabaseFile(config.databaseFile, this.runtimeEnvironment);
     const logger = owner.logger("dsh-cron-automation");
     this.manager = new CronAutomationManager(new CronAutomationRepository(databaseFile), {
@@ -1722,7 +1853,7 @@ var CronAutomationService = class extends Service {
           logger.warn("cron %s is due but agent %s is not live", cron.id, cron.agentId);
           return false;
         }
-        agent.followup(dueMessage(cron, occurrenceAt));
+        agent.followup(dueMessage(cron, occurrenceAt, agent.session.header.cwd));
         await agent.whenIdle();
         return true;
       },
@@ -1756,12 +1887,14 @@ var CronAutomationService = class extends Service {
     this.interval.unref();
   }
   async migrateLegacyCronDatabase() {
-    const owner = resolveLegacyCronOwner(this.config.legacyDatabaseEnvironment);
-    if (owner !== this.runtimeEnvironment)
-      return;
     const legacyFile = legacyCronDatabaseFile();
     if (!existsSync3(legacyFile))
       return;
+    const owner = claimLegacyCronOwner(this.config.legacyDatabaseEnvironment, this.recordedEnvironment, this.runtimeEnvironment);
+    if (owner !== this.runtimeEnvironment) {
+      this.owner.logger("dsh-cron-automation").info("leaving legacy Harness cron database in place; it belongs to %s, current runtime is %s", owner, this.runtimeEnvironment);
+      return;
+    }
     const legacy = new CronAutomationRepository(legacyFile, { readOnly: true });
     try {
       const result = await this.manager.migrateLegacy(legacyCronMigrationId(legacyFile), await legacy.load(), await legacy.listImportedJobs());
@@ -1776,7 +1909,7 @@ var CronAutomationService = class extends Service {
     const explicit = this.config.openclawSqlite?.trim() || process.env["OPENCLAW_SQLITE"]?.trim();
     let sqlitePath;
     if (explicit) {
-      sqlitePath = path4.resolve(explicit);
+      sqlitePath = path5.resolve(explicit);
     } else {
       const stagingPath = cronRuntimePath(this.runtimeEnvironment, "migration", "openclaw.sqlite");
       let sourceCandidate;

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,6 +77,7 @@ 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>;

package/src/repository.js

@@ -130,153 +130,153 @@ export class CronAutomationRepository {
         this.database.exec('PRAGMA journal_mode = WAL');
         this.database.exec('PRAGMA synchronous = FULL');
         this.database.exec('PRAGMA busy_timeout = 5000');
-        this.database.exec(`
-      CREATE TABLE IF NOT EXISTS cron_jobs (
-        store_key TEXT NOT NULL,
-        job_id TEXT NOT NULL,
-        name TEXT NOT NULL,
-        description TEXT,
-        enabled INTEGER NOT NULL,
-        delete_after_run INTEGER,
-        created_at_ms INTEGER NOT NULL,
-        agent_id TEXT,
-        session_key TEXT,
-        schedule_kind TEXT NOT NULL,
-        schedule_expr TEXT,
-        schedule_tz TEXT,
-        every_ms INTEGER,
-        anchor_ms INTEGER,
-        at TEXT,
-        stagger_ms INTEGER,
-        session_target TEXT NOT NULL,
-        wake_mode TEXT NOT NULL,
-        payload_kind TEXT NOT NULL,
-        payload_message TEXT,
-        payload_model TEXT,
-        payload_fallbacks_json TEXT,
-        payload_thinking TEXT,
-        payload_timeout_seconds INTEGER,
-        payload_allow_unsafe_external_content INTEGER,
-        payload_external_content_source_json TEXT,
-        payload_light_context INTEGER,
-        payload_tools_allow_json TEXT,
-        delivery_mode TEXT,
-        delivery_channel TEXT,
-        delivery_to TEXT,
-        delivery_thread_id TEXT,
-        delivery_account_id TEXT,
-        delivery_best_effort INTEGER,
-        delivery_completion_mode TEXT,
-        delivery_completion_to TEXT,
-        failure_delivery_mode TEXT,
-        failure_delivery_channel TEXT,
-        failure_delivery_to TEXT,
-        failure_delivery_account_id TEXT,
-        failure_alert_disabled INTEGER,
-        failure_alert_after INTEGER,
-        failure_alert_channel TEXT,
-        failure_alert_to TEXT,
-        failure_alert_cooldown_ms INTEGER,
-        failure_alert_include_skipped INTEGER,
-        failure_alert_mode TEXT,
-        failure_alert_account_id TEXT,
-        next_run_at_ms INTEGER,
-        running_at_ms INTEGER,
-        last_run_at_ms INTEGER,
-        last_run_status TEXT,
-        last_error TEXT,
-        last_duration_ms INTEGER,
-        consecutive_errors INTEGER,
-        consecutive_skipped INTEGER,
-        schedule_error_count INTEGER,
-        last_delivery_status TEXT,
-        last_delivery_error TEXT,
-        last_delivered INTEGER,
-        last_failure_alert_at_ms INTEGER,
-        job_json TEXT NOT NULL,
-        state_json TEXT NOT NULL DEFAULT '{}',
-        runtime_updated_at_ms INTEGER,
-        schedule_identity TEXT,
-        sort_order INTEGER NOT NULL DEFAULT 0,
-        updated_at INTEGER NOT NULL,
-        PRIMARY KEY (store_key, job_id)
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_cron_jobs_store_updated
-        ON cron_jobs(store_key, sort_order ASC, updated_at DESC, job_id);
-      CREATE INDEX IF NOT EXISTS idx_cron_jobs_store_order
-        ON cron_jobs(store_key, sort_order ASC, updated_at ASC, job_id);
-      CREATE INDEX IF NOT EXISTS idx_cron_jobs_enabled_next_run
-        ON cron_jobs(store_key, enabled, next_run_at_ms, job_id)
-        WHERE next_run_at_ms IS NOT NULL;
-      CREATE INDEX IF NOT EXISTS idx_cron_jobs_agent_session
-        ON cron_jobs(agent_id, session_key, updated_at DESC, job_id)
-        WHERE agent_id IS NOT NULL OR session_key IS NOT NULL;
-
-      CREATE TABLE IF NOT EXISTS cron_imported_jobs (
-        source TEXT NOT NULL,
-        job_id TEXT NOT NULL,
-        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.database.exec(`
+      CREATE TABLE IF NOT EXISTS cron_jobs (
+        store_key TEXT NOT NULL,
+        job_id TEXT NOT NULL,
+        name TEXT NOT NULL,
+        description TEXT,
+        enabled INTEGER NOT NULL,
+        delete_after_run INTEGER,
+        created_at_ms INTEGER NOT NULL,
+        agent_id TEXT,
+        session_key TEXT,
+        schedule_kind TEXT NOT NULL,
+        schedule_expr TEXT,
+        schedule_tz TEXT,
+        every_ms INTEGER,
+        anchor_ms INTEGER,
+        at TEXT,
+        stagger_ms INTEGER,
+        session_target TEXT NOT NULL,
+        wake_mode TEXT NOT NULL,
+        payload_kind TEXT NOT NULL,
+        payload_message TEXT,
+        payload_model TEXT,
+        payload_fallbacks_json TEXT,
+        payload_thinking TEXT,
+        payload_timeout_seconds INTEGER,
+        payload_allow_unsafe_external_content INTEGER,
+        payload_external_content_source_json TEXT,
+        payload_light_context INTEGER,
+        payload_tools_allow_json TEXT,
+        delivery_mode TEXT,
+        delivery_channel TEXT,
+        delivery_to TEXT,
+        delivery_thread_id TEXT,
+        delivery_account_id TEXT,
+        delivery_best_effort INTEGER,
+        delivery_completion_mode TEXT,
+        delivery_completion_to TEXT,
+        failure_delivery_mode TEXT,
+        failure_delivery_channel TEXT,
+        failure_delivery_to TEXT,
+        failure_delivery_account_id TEXT,
+        failure_alert_disabled INTEGER,
+        failure_alert_after INTEGER,
+        failure_alert_channel TEXT,
+        failure_alert_to TEXT,
+        failure_alert_cooldown_ms INTEGER,
+        failure_alert_include_skipped INTEGER,
+        failure_alert_mode TEXT,
+        failure_alert_account_id TEXT,
+        next_run_at_ms INTEGER,
+        running_at_ms INTEGER,
+        last_run_at_ms INTEGER,
+        last_run_status TEXT,
+        last_error TEXT,
+        last_duration_ms INTEGER,
+        consecutive_errors INTEGER,
+        consecutive_skipped INTEGER,
+        schedule_error_count INTEGER,
+        last_delivery_status TEXT,
+        last_delivery_error TEXT,
+        last_delivered INTEGER,
+        last_failure_alert_at_ms INTEGER,
+        job_json TEXT NOT NULL,
+        state_json TEXT NOT NULL DEFAULT '{}',
+        runtime_updated_at_ms INTEGER,
+        schedule_identity TEXT,
+        sort_order INTEGER NOT NULL DEFAULT 0,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (store_key, job_id)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_cron_jobs_store_updated
+        ON cron_jobs(store_key, sort_order ASC, updated_at DESC, job_id);
+      CREATE INDEX IF NOT EXISTS idx_cron_jobs_store_order
+        ON cron_jobs(store_key, sort_order ASC, updated_at ASC, job_id);
+      CREATE INDEX IF NOT EXISTS idx_cron_jobs_enabled_next_run
+        ON cron_jobs(store_key, enabled, next_run_at_ms, job_id)
+        WHERE next_run_at_ms IS NOT NULL;
+      CREATE INDEX IF NOT EXISTS idx_cron_jobs_agent_session
+        ON cron_jobs(agent_id, session_key, updated_at DESC, job_id)
+        WHERE agent_id IS NOT NULL OR session_key IS NOT NULL;
+
+      CREATE TABLE IF NOT EXISTS cron_imported_jobs (
+        source TEXT NOT NULL,
+        job_id TEXT NOT NULL,
+        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 (
-        store_key, job_id, name, description, enabled, delete_after_run,
-        created_at_ms, agent_id, session_key,
-        schedule_kind, schedule_expr, schedule_tz, every_ms, anchor_ms, at,
-        session_target, wake_mode,
-        payload_kind, payload_message, payload_timeout_seconds,
-        delivery_mode, delivery_channel, delivery_to, delivery_account_id, delivery_best_effort,
-        next_run_at_ms, running_at_ms, last_run_at_ms, last_run_status,
-        job_json, state_json, runtime_updated_at_ms, sort_order, updated_at
-      ) VALUES (
-        ?, ?, ?, ?, ?, ?,
-        ?, ?, ?,
-        ?, ?, ?, ?, ?, ?,
-        ?, ?,
-        ?, ?, ?,
-        ?, ?, ?, ?, ?,
-        ?, ?, ?, ?,
-        ?, ?, ?, ?, ?
-      )
-      ON CONFLICT(store_key, job_id) DO UPDATE SET
-        name = excluded.name,
-        description = excluded.description,
-        enabled = excluded.enabled,
-        delete_after_run = excluded.delete_after_run,
-        created_at_ms = excluded.created_at_ms,
-        agent_id = excluded.agent_id,
-        session_key = excluded.session_key,
-        schedule_kind = excluded.schedule_kind,
-        schedule_expr = excluded.schedule_expr,
-        schedule_tz = excluded.schedule_tz,
-        every_ms = excluded.every_ms,
-        anchor_ms = excluded.anchor_ms,
-        at = excluded.at,
-        session_target = excluded.session_target,
-        wake_mode = excluded.wake_mode,
-        payload_kind = excluded.payload_kind,
-        payload_message = excluded.payload_message,
-        payload_timeout_seconds = excluded.payload_timeout_seconds,
-        delivery_mode = excluded.delivery_mode,
-        delivery_channel = excluded.delivery_channel,
-        delivery_to = excluded.delivery_to,
-        delivery_account_id = excluded.delivery_account_id,
-        delivery_best_effort = excluded.delivery_best_effort,
-        next_run_at_ms = excluded.next_run_at_ms,
-        running_at_ms = excluded.running_at_ms,
-        last_run_at_ms = excluded.last_run_at_ms,
-        last_run_status = excluded.last_run_status,
-        job_json = excluded.job_json,
-        state_json = excluded.state_json,
-        runtime_updated_at_ms = excluded.runtime_updated_at_ms,
-        updated_at = excluded.updated_at
+        this.insertJobStatement = this.database.prepare(`
+      INSERT INTO cron_jobs (
+        store_key, job_id, name, description, enabled, delete_after_run,
+        created_at_ms, agent_id, session_key,
+        schedule_kind, schedule_expr, schedule_tz, every_ms, anchor_ms, at,
+        session_target, wake_mode,
+        payload_kind, payload_message, payload_timeout_seconds,
+        delivery_mode, delivery_channel, delivery_to, delivery_account_id, delivery_best_effort,
+        next_run_at_ms, running_at_ms, last_run_at_ms, last_run_status,
+        job_json, state_json, runtime_updated_at_ms, sort_order, updated_at
+      ) VALUES (
+        ?, ?, ?, ?, ?, ?,
+        ?, ?, ?,
+        ?, ?, ?, ?, ?, ?,
+        ?, ?,
+        ?, ?, ?,
+        ?, ?, ?, ?, ?,
+        ?, ?, ?, ?,
+        ?, ?, ?, ?, ?
+      )
+      ON CONFLICT(store_key, job_id) DO UPDATE SET
+        name = excluded.name,
+        description = excluded.description,
+        enabled = excluded.enabled,
+        delete_after_run = excluded.delete_after_run,
+        created_at_ms = excluded.created_at_ms,
+        agent_id = excluded.agent_id,
+        session_key = excluded.session_key,
+        schedule_kind = excluded.schedule_kind,
+        schedule_expr = excluded.schedule_expr,
+        schedule_tz = excluded.schedule_tz,
+        every_ms = excluded.every_ms,
+        anchor_ms = excluded.anchor_ms,
+        at = excluded.at,
+        session_target = excluded.session_target,
+        wake_mode = excluded.wake_mode,
+        payload_kind = excluded.payload_kind,
+        payload_message = excluded.payload_message,
+        payload_timeout_seconds = excluded.payload_timeout_seconds,
+        delivery_mode = excluded.delivery_mode,
+        delivery_channel = excluded.delivery_channel,
+        delivery_to = excluded.delivery_to,
+        delivery_account_id = excluded.delivery_account_id,
+        delivery_best_effort = excluded.delivery_best_effort,
+        next_run_at_ms = excluded.next_run_at_ms,
+        running_at_ms = excluded.running_at_ms,
+        last_run_at_ms = excluded.last_run_at_ms,
+        last_run_status = excluded.last_run_status,
+        job_json = excluded.job_json,
+        state_json = excluded.state_json,
+        runtime_updated_at_ms = excluded.runtime_updated_at_ms,
+        updated_at = excluded.updated_at
     `);
         try {
             fs.chmodSync(file, 0o600);
@@ -285,14 +285,21 @@ 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
-            .prepare(`
-      SELECT job_json
-      FROM cron_jobs
-      WHERE store_key = ?
-      ORDER BY sort_order ASC, updated_at ASC, job_id ASC
+            .prepare(`
+      SELECT job_json
+      FROM cron_jobs
+      WHERE store_key = ?
+      ORDER BY sort_order ASC, updated_at ASC, job_id ASC
     `)
             .all(STORE_KEY);
         return rows.map((row) => decodeJob(JSON.parse(row.job_json)));
@@ -325,9 +332,9 @@ export class CronAutomationRepository {
             const result = this.planImport(source, decoded);
             const nextOrder = this.nextSortOrder();
             result.added.forEach((job, index) => this.insertJob(job, nextOrder + index));
-            const mark = this.database.prepare(`
-        INSERT OR IGNORE INTO cron_imported_jobs (source, job_id, imported_at)
-        VALUES (?, ?, ?)
+            const mark = this.database.prepare(`
+        INSERT OR IGNORE INTO cron_imported_jobs (source, job_id, imported_at)
+        VALUES (?, ?, ?)
       `);
             const importedAt = Date.now();
             for (const job of decoded)
@@ -351,10 +358,10 @@ export class CronAutomationRepository {
             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 = ?
+                .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));
@@ -375,9 +382,9 @@ export class CronAutomationRepository {
             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 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)
@@ -411,10 +418,10 @@ export class CronAutomationRepository {
     }
     nextSortOrder() {
         const row = this.database
-            .prepare(`
-      SELECT COALESCE(MAX(sort_order), -1) + 1 AS next_order
-      FROM cron_jobs
-      WHERE store_key = ?
+            .prepare(`
+      SELECT COALESCE(MAX(sort_order), -1) + 1 AS next_order
+      FROM cron_jobs
+      WHERE store_key = ?
     `)
             .get(STORE_KEY);
         return row.next_order;

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');