@dcrays/scheduled-task 0.1.6-beta.7 → 0.1.6-beta.8

package/package.json

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

package/plugin/index.d.ts

@@ -54,7 +54,10 @@ export declare class CronAutomationService extends Service {
     private migrateLegacyCronDatabase;
     private importOpenClawJobs;
     stop(): Promise<void>;
-    create(agentId: string, envelope: CronCreateEnvelope): Promise<StoredCronAutomation>;
+    create(agentId: string, envelope: CronCreateEnvelope, options?: {
+        allowDuplicate?: boolean;
+    }): Promise<StoredCronAutomation>;
+    findDuplicates(agentId: string, envelope: CronCreateEnvelope): Promise<StoredCronAutomation[]>;
     list(agentId?: string): Promise<StoredCronAutomation[]>;
     update(cronId: string, patch: CronAutomationPatch): Promise<StoredCronAutomation | undefined>;
     delete(cronId: string): Promise<boolean>;

package/plugin/index.js

@@ -821,6 +821,74 @@ function setNextOccurrence(job, value) {
 function sameRequest(job, envelope) {
   return job.name === envelope.name && job.payload.message === envelope.prompt && job.schedule.kind === "cron" && job.schedule.expr === envelope.cron && timezoneFor(job.schedule) === envelope.timezone;
 }
+function normalizedText(value) {
+  return value.normalize("NFKC").toLocaleLowerCase().replace(/[\p{P}\p{S}\s]+/gu, "");
+}
+function bigramDice(left, right) {
+  if (left === right)
+    return 1;
+  if (left.length < 2 || right.length < 2)
+    return 0;
+  const leftBigrams = /* @__PURE__ */ new Map();
+  for (let index = 0; index < left.length - 1; index += 1) {
+    const bigram = left.slice(index, index + 2);
+    leftBigrams.set(bigram, (leftBigrams.get(bigram) ?? 0) + 1);
+  }
+  let overlap = 0;
+  for (let index = 0; index < right.length - 1; index += 1) {
+    const bigram = right.slice(index, index + 2);
+    const remaining = leftBigrams.get(bigram) ?? 0;
+    if (remaining > 0) {
+      overlap += 1;
+      leftBigrams.set(bigram, remaining - 1);
+    }
+  }
+  return 2 * overlap / (left.length + right.length - 2);
+}
+function similarText(left, right, threshold = 0.82, minimumLength = 8) {
+  const normalizedLeft = normalizedText(left);
+  const normalizedRight = normalizedText(right);
+  if (normalizedLeft === normalizedRight)
+    return true;
+  if (Math.min(normalizedLeft.length, normalizedRight.length) < minimumLength)
+    return false;
+  return bigramDice(normalizedLeft, normalizedRight) >= threshold;
+}
+function longestCommonSubstringLength(left, right) {
+  const previous = new Array(right.length + 1).fill(0);
+  let longest = 0;
+  for (let leftIndex = 1; leftIndex <= left.length; leftIndex += 1) {
+    for (let rightIndex = right.length; rightIndex >= 1; rightIndex -= 1) {
+      if (left[leftIndex - 1] === right[rightIndex - 1]) {
+        const length = (previous[rightIndex - 1] ?? 0) + 1;
+        previous[rightIndex] = length;
+        longest = Math.max(longest, length);
+      } else {
+        previous[rightIndex] = 0;
+      }
+    }
+  }
+  return longest;
+}
+function similarName(left, right) {
+  const normalizedLeft = normalizedText(left);
+  const normalizedRight = normalizedText(right);
+  if (normalizedLeft === normalizedRight)
+    return true;
+  const shorterLength = Math.min(normalizedLeft.length, normalizedRight.length);
+  if (shorterLength < 6)
+    return false;
+  if (bigramDice(normalizedLeft, normalizedRight) >= 0.65)
+    return true;
+  const sharedLength = longestCommonSubstringLength(normalizedLeft, normalizedRight);
+  return sharedLength >= 6 && sharedLength / shorterLength >= 0.5;
+}
+function normalizedCron(value) {
+  return value.trim().split(/\s+/u).join(" ");
+}
+function sameAutomation(job, envelope) {
+  return job.schedule.kind === "cron" && (similarName(job.name, envelope.name) || similarText(job.payload.message, envelope.prompt)) && normalizedCron(job.schedule.expr) === normalizedCron(envelope.cron) && timezoneFor(job.schedule) === envelope.timezone;
+}
 var CronAutomationManager = class {
   repository;
   options;
@@ -883,7 +951,7 @@ var CronAutomationManager = class {
       this.repository.close();
     }
   }
-  async create(agentId, envelope) {
+  async create(agentId, envelope, options = {}) {
     await this.start();
     return this.enqueue(async () => {
       if (this.stopping)
@@ -902,6 +970,9 @@ var CronAutomationManager = class {
       const now = this.now();
       const schedule = { kind: "cron", expr: envelope.cron, tz: envelope.timezone };
       assertMinimumScheduleInterval(schedule);
+      if (!options.allowDuplicate && [...this.jobs.values()].some((job2) => sameAutomation(job2, envelope))) {
+        throw new CronAutomationInputError("duplicate_automation", "a cron automation with the same or similar name or prompt, cron expression, and timezone already exists");
+      }
       const nextRunAtMs = nextOccurrence(now, schedule);
       const job = {
         id,
@@ -931,6 +1002,12 @@ var CronAutomationManager = class {
       return cloneJob(job);
     });
   }
+  /** Matching names are intentionally allowed: the work and schedule define a duplicate. */
+  async findDuplicates(agentId, envelope) {
+    await this.start();
+    const idempotentId = automationId(agentId, envelope.requestId);
+    return [...this.jobs.values()].filter((job) => job.id !== idempotentId && sameAutomation(job, envelope)).sort((left, right) => left.createdAtMs - right.createdAtMs || left.id.localeCompare(right.id)).map(cloneJob);
+  }
   async update(jobId, patch) {
     await this.start();
     return this.enqueue(async () => {
@@ -1652,6 +1729,29 @@ function acknowledgement(cron) {
     }
   });
 }
+function duplicateChoiceRequest(envelope, duplicates) {
+  const choices = duplicates.map((cron) => ({
+    id: cron.id,
+    name: cron.name,
+    enabled: cron.enabled,
+    schedule: cron.schedule,
+    nextRunAt: cron.state.nextRunAtMs === void 0 ? null : new Date(cron.state.nextRunAtMs).toISOString()
+  }));
+  return createUserMessage({
+    content: [
+      {
+        type: "text",
+        text: [
+          "[CRON AUTOMATION DUPLICATE DETECTED]",
+          "Do not create or run the requested task yet. A task with the same or similar name or prompt, cron expression, and timezone already exists. Tell the user which matching task was found and ask them to choose exactly one: update the existing task, create another task anyway, or cancel. Do not make that choice for the user.",
+          `requested_task_json: ${JSON.stringify({ name: envelope.name, prompt: envelope.prompt, cron: envelope.cron, timezone: envelope.timezone })}`,
+          `matching_tasks_json: ${JSON.stringify(choices)}`
+        ].join("\n")
+      }
+    ],
+    source: { kind: "plugin", plugin: name, form: "notice", summary: "Cron automation duplicate detected" }
+  });
+}
 function registrationFailure(error) {
   const message = error instanceof CronAutomationInputError ? error.message : "The cron automation could not be persisted.";
   return createUserMessage({
@@ -1984,8 +2084,11 @@ var CronAutomationService = class extends Service {
     await this.pushTail;
     await this.manager.stop();
   }
-  create(agentId, envelope) {
-    return this.manager.create(agentId, envelope);
+  create(agentId, envelope, options) {
+    return this.manager.create(agentId, envelope, options);
+  }
+  findDuplicates(agentId, envelope) {
+    return this.manager.findDuplicates(agentId, envelope);
   }
   list(agentId) {
     return this.manager.list(agentId);
@@ -2038,11 +2141,21 @@ var CronAutomationService = class extends Service {
       if (typeof body !== "object" || body === null || Array.isArray(body) || !("agentId" in body) || !("cron" in body)) {
         throw new CronAutomationInputError("invalid_envelope", "body must contain agentId and cron");
       }
-      const { agentId, cron, ...extra } = body;
-      if (Object.keys(extra).length > 0 || typeof agentId !== "string" || agentId.length === 0) {
-        throw new CronAutomationInputError("invalid_envelope", "body must contain only a non-empty agentId and cron");
+      const { agentId, cron, duplicateAction, ...extra } = body;
+      if (Object.keys(extra).length > 0 || typeof agentId !== "string" || agentId.length === 0 || duplicateAction !== void 0 && duplicateAction !== "create") {
+        throw new CronAutomationInputError("invalid_envelope", "body must contain agentId, cron, and optionally duplicateAction=create");
       }
-      const created = await this.create(agentId, decodeCronCreateEnvelope(cron));
+      const envelope = decodeCronCreateEnvelope(cron);
+      const duplicates = await this.findDuplicates(agentId, envelope);
+      if (duplicates.length > 0 && duplicateAction !== "create") {
+        sendJson(res, 409, {
+          status: "duplicate",
+          requested: { name: envelope.name, prompt: envelope.prompt, cron: envelope.cron, timezone: envelope.timezone },
+          duplicates
+        });
+        return;
+      }
+      const created = await this.create(agentId, envelope, { allowDuplicate: duplicateAction === "create" });
       sendJson(res, 201, created);
       return;
     }
@@ -2127,7 +2240,7 @@ function apply(ctx, config) {
     const logger = ctx.logger("dsh-cron-automation");
     const unregisterTool = ctx.tools.register(defineTool({
       name: "manage_cron_automation",
-      description: `Create, edit, enable, disable, delete, list, or immediately run persistent cron automations. Use this whenever the user asks to create or edit a scheduled task, including requests from the Mobook scheduled-task editor. Always call this tool for an edit even when prior conversation says the requested schedule is invalid; this tool's current validation is authoritative. Preserve the requested interval and report validation errors instead of silently substituting another schedule. Creating or updating only persists the schedule and prompt; do not execute the prompt, write files, or create other tasks from that content until the job is due or the user asks to run it now. After create or update, tell the user only the task name and next run time; do not mention that you skipped execution or that you only registered the job. Cron expressions have five fields, timezone is an IANA name, and recurring executions must be at least ${MIN_CRON_INTERVAL_SECONDS} seconds (${MIN_CRON_INTERVAL_SECONDS / 60} minutes) apart.`,
+      description: `Create, edit, enable, disable, delete, list, or immediately run persistent cron automations. Use this whenever the user asks to create or edit a scheduled task, including requests from the Mobook scheduled-task editor. Always call this tool for an edit even when prior conversation says the requested schedule is invalid; this tool's current validation is authoritative. Preserve the requested interval and report validation errors instead of silently substituting another schedule. Before creating, inspect the returned duplicate result. If any existing task has a same or similar name or prompt with the same cron expression and timezone, ask the user whether to update it, create another anyway, or cancel; do not choose on their behalf. Use duplicateAction=create only after the user explicitly chose another task. Creating or updating only persists the schedule and prompt; do not execute the prompt, write files, or create other tasks from that content until the job is due or the user asks to run it now. After create or update, tell the user only the task name and next run time; do not mention that you skipped execution or that you only registered the job. Cron expressions have five fields, timezone is an IANA name, and recurring executions must be at least ${MIN_CRON_INTERVAL_SECONDS} seconds (${MIN_CRON_INTERVAL_SECONDS / 60} minutes) apart.`,
       parameters: {
         action: { type: "string", enum: ["create", "update", "list", "delete", "run"], required: true },
         id: { type: "string", description: "Existing cron id for update, delete, or run." },
@@ -2141,7 +2254,12 @@ function apply(ctx, config) {
           description: `Standard five-field cron expression with a minimum interval of ${MIN_CRON_INTERVAL_SECONDS} seconds (${MIN_CRON_INTERVAL_SECONDS / 60} minutes).`
         },
         timezone: { type: "string", description: "IANA timezone, for example Asia/Shanghai." },
-        enabled: { type: "boolean" }
+        enabled: { type: "boolean" },
+        duplicateAction: {
+          type: "string",
+          enum: ["ask", "create"],
+          description: "For create only. Use create only after the user explicitly chose another matching task."
+        }
       },
       output: {
         schema: { type: "json" },
@@ -2156,14 +2274,23 @@ function apply(ctx, config) {
         if (args.action === "create") {
           if (!args.name || !args.prompt || !args.cron || !args.timezone)
             throw new Error("create requires name, prompt, cron, and timezone");
-          const created = await service.create(agentId, {
+          const envelope = {
             type: "dsh/cron.create",
             requestId: `tool-${String(exec.callId).slice(0, 120)}`,
             name: args.name,
             prompt: args.prompt,
             cron: args.cron,
             timezone: args.timezone
-          });
+          };
+          const duplicates = await service.findDuplicates(agentId, envelope);
+          if (duplicates.length > 0 && args.duplicateAction !== "create") {
+            return {
+              status: "duplicate",
+              requested: { name: envelope.name, prompt: envelope.prompt, cron: envelope.cron, timezone: envelope.timezone },
+              duplicates: JSON.parse(JSON.stringify(duplicates))
+            };
+          }
+          const created = await service.create(agentId, envelope, { allowDuplicate: args.duplicateAction === "create" });
           return JSON.parse(JSON.stringify(created));
         }
         if (!args.id)
@@ -2233,6 +2360,11 @@ function apply(ctx, config) {
         }
         handled = true;
         try {
+          const duplicates = await service.findDuplicates(agent.id, envelope);
+          if (duplicates.length > 0) {
+            replacements.push(duplicateChoiceRequest(envelope, duplicates));
+            continue;
+          }
           const cron = await service.create(agent.id, envelope);
           replacements.push(acknowledgement(cron));
           logger.info("registered cron %s for agent %s at %s", cron.id, cron.agentId, cron.state.nextRunAtMs === void 0 ? "none" : new Date(cron.state.nextRunAtMs).toISOString());

package/src/manager.d.ts

@@ -41,7 +41,11 @@ export declare class CronAutomationManager {
     start(): Promise<void>;
     private initialize;
     stop(): Promise<void>;
-    create(agentId: string, envelope: CronCreateEnvelope): Promise<StoredCronAutomation>;
+    create(agentId: string, envelope: CronCreateEnvelope, options?: {
+        allowDuplicate?: boolean;
+    }): Promise<StoredCronAutomation>;
+    /** Matching names are intentionally allowed: the work and schedule define a duplicate. */
+    findDuplicates(agentId: string, envelope: CronCreateEnvelope): Promise<StoredCronAutomation[]>;
     update(jobId: string, patch: CronAutomationPatch): Promise<StoredCronAutomation | undefined>;
     delete(jobId: string): Promise<boolean>;
     runOnceStatus(jobId: string): Promise<CronRunStatus>;

package/src/manager.js

@@ -92,6 +92,82 @@ function sameRequest(job, envelope) {
         job.schedule.expr === envelope.cron &&
         timezoneFor(job.schedule) === envelope.timezone);
 }
+function normalizedText(value) {
+    return value
+        .normalize('NFKC')
+        .toLocaleLowerCase()
+        .replace(/[\p{P}\p{S}\s]+/gu, '');
+}
+function bigramDice(left, right) {
+    if (left === right)
+        return 1;
+    if (left.length < 2 || right.length < 2)
+        return 0;
+    const leftBigrams = new Map();
+    for (let index = 0; index < left.length - 1; index += 1) {
+        const bigram = left.slice(index, index + 2);
+        leftBigrams.set(bigram, (leftBigrams.get(bigram) ?? 0) + 1);
+    }
+    let overlap = 0;
+    for (let index = 0; index < right.length - 1; index += 1) {
+        const bigram = right.slice(index, index + 2);
+        const remaining = leftBigrams.get(bigram) ?? 0;
+        if (remaining > 0) {
+            overlap += 1;
+            leftBigrams.set(bigram, remaining - 1);
+        }
+    }
+    return (2 * overlap) / (left.length + right.length - 2);
+}
+function similarText(left, right, threshold = 0.82, minimumLength = 8) {
+    const normalizedLeft = normalizedText(left);
+    const normalizedRight = normalizedText(right);
+    if (normalizedLeft === normalizedRight)
+        return true;
+    if (Math.min(normalizedLeft.length, normalizedRight.length) < minimumLength)
+        return false;
+    return bigramDice(normalizedLeft, normalizedRight) >= threshold;
+}
+function longestCommonSubstringLength(left, right) {
+    const previous = new Array(right.length + 1).fill(0);
+    let longest = 0;
+    for (let leftIndex = 1; leftIndex <= left.length; leftIndex += 1) {
+        for (let rightIndex = right.length; rightIndex >= 1; rightIndex -= 1) {
+            if (left[leftIndex - 1] === right[rightIndex - 1]) {
+                const length = (previous[rightIndex - 1] ?? 0) + 1;
+                previous[rightIndex] = length;
+                longest = Math.max(longest, length);
+            }
+            else {
+                previous[rightIndex] = 0;
+            }
+        }
+    }
+    return longest;
+}
+function similarName(left, right) {
+    const normalizedLeft = normalizedText(left);
+    const normalizedRight = normalizedText(right);
+    if (normalizedLeft === normalizedRight)
+        return true;
+    const shorterLength = Math.min(normalizedLeft.length, normalizedRight.length);
+    if (shorterLength < 6)
+        return false;
+    if (bigramDice(normalizedLeft, normalizedRight) >= 0.65)
+        return true;
+    const sharedLength = longestCommonSubstringLength(normalizedLeft, normalizedRight);
+    return sharedLength >= 6 && sharedLength / shorterLength >= 0.5;
+}
+function normalizedCron(value) {
+    return value.trim().split(/\s+/u).join(' ');
+}
+/** A new editor submission has a new request id and often a new agent id. */
+function sameAutomation(job, envelope) {
+    return (job.schedule.kind === 'cron' &&
+        (similarName(job.name, envelope.name) || similarText(job.payload.message, envelope.prompt)) &&
+        normalizedCron(job.schedule.expr) === normalizedCron(envelope.cron) &&
+        timezoneFor(job.schedule) === envelope.timezone);
+}
 export class CronAutomationManager {
     repository;
     options;
@@ -155,7 +231,7 @@ export class CronAutomationManager {
             this.repository.close();
         }
     }
-    async create(agentId, envelope) {
+    async create(agentId, envelope, options = {}) {
         await this.start();
         return this.enqueue(async () => {
             if (this.stopping)
@@ -174,6 +250,9 @@ export class CronAutomationManager {
             const now = this.now();
             const schedule = { kind: 'cron', expr: envelope.cron, tz: envelope.timezone };
             assertMinimumScheduleInterval(schedule);
+            if (!options.allowDuplicate && [...this.jobs.values()].some((job) => sameAutomation(job, envelope))) {
+                throw new CronAutomationInputError('duplicate_automation', 'a cron automation with the same or similar name or prompt, cron expression, and timezone already exists');
+            }
             const nextRunAtMs = nextOccurrence(now, schedule);
             const job = {
                 id,
@@ -204,6 +283,15 @@ export class CronAutomationManager {
             return cloneJob(job);
         });
     }
+    /** Matching names are intentionally allowed: the work and schedule define a duplicate. */
+    async findDuplicates(agentId, envelope) {
+        await this.start();
+        const idempotentId = automationId(agentId, envelope.requestId);
+        return [...this.jobs.values()]
+            .filter((job) => job.id !== idempotentId && sameAutomation(job, envelope))
+            .sort((left, right) => left.createdAtMs - right.createdAtMs || left.id.localeCompare(right.id))
+            .map(cloneJob);
+    }
     async update(jobId, patch) {
         await this.start();
         return this.enqueue(async () => {

package/src/protocol.d.ts

@@ -1,4 +1,4 @@
-import type { UserMessage } from "@deepseek-ai/dsh-llm";
+import type { UserMessage } from '@deepseek-ai/dsh-llm';
 export declare const CRON_CREATE_TYPE: "dsh/cron.create";
 export declare const CRON_LIST_TYPE: "dsh/cron.list";
 export interface CronCreateEnvelope {
@@ -14,8 +14,8 @@ export interface CronEditorRequest {
     text: string;
 }
 export declare class CronAutomationInputError extends Error {
-    readonly code: "invalid_envelope" | "invalid_request_id" | "invalid_name" | "invalid_prompt" | "invalid_cron" | "invalid_timezone" | "request_id_conflict";
-    constructor(code: "invalid_envelope" | "invalid_request_id" | "invalid_name" | "invalid_prompt" | "invalid_cron" | "invalid_timezone" | "request_id_conflict", message: string);
+    readonly code: 'invalid_envelope' | 'invalid_request_id' | 'invalid_name' | 'invalid_prompt' | 'invalid_cron' | 'invalid_timezone' | 'request_id_conflict' | 'duplicate_automation';
+    constructor(code: 'invalid_envelope' | 'invalid_request_id' | 'invalid_name' | 'invalid_prompt' | 'invalid_cron' | 'invalid_timezone' | 'request_id_conflict' | 'duplicate_automation', message: string);
 }
 export declare function decodeCronCreateEnvelope(value: unknown): CronCreateEnvelope;
 /** Parse a cron control envelope carried as the sole text block of a direct user message. */

package/src/protocol.js

@@ -1,16 +1,16 @@
-import { assertMinimumCronInterval, CronExpressionError, validTimeZone } from "./cron.js";
-export const CRON_CREATE_TYPE = "dsh/cron.create";
-export const CRON_LIST_TYPE = "dsh/cron.list";
+import { assertMinimumCronInterval, CronExpressionError, validTimeZone } from './cron.js';
+export const CRON_CREATE_TYPE = 'dsh/cron.create';
+export const CRON_LIST_TYPE = 'dsh/cron.list';
 export class CronAutomationInputError extends Error {
     code;
     constructor(code, message) {
         super(message);
         this.code = code;
-        this.name = "CronAutomationInputError";
+        this.name = 'CronAutomationInputError';
     }
 }
 function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 function exactKeys(value, keys) {
     const actual = Object.keys(value).sort();
@@ -19,34 +19,37 @@ function exactKeys(value, keys) {
 }
 export function decodeCronCreateEnvelope(value) {
     if (!isRecord(value) || value.type !== CRON_CREATE_TYPE) {
-        throw new CronAutomationInputError("invalid_envelope", `type must be ${CRON_CREATE_TYPE}`);
+        throw new CronAutomationInputError('invalid_envelope', `type must be ${CRON_CREATE_TYPE}`);
     }
-    if (!exactKeys(value, ["type", "requestId", "name", "prompt", "cron", "timezone"])) {
-        throw new CronAutomationInputError("invalid_envelope", "cron envelope contains unknown or missing fields");
+    if (!exactKeys(value, ['type', 'requestId', 'name', 'prompt', 'cron', 'timezone'])) {
+        throw new CronAutomationInputError('invalid_envelope', 'cron envelope contains unknown or missing fields');
     }
-    if (typeof value.requestId !== "string" || value.requestId.trim() !== value.requestId || value.requestId.length < 1 || value.requestId.length > 128) {
-        throw new CronAutomationInputError("invalid_request_id", "requestId must contain 1-128 characters without surrounding whitespace");
+    if (typeof value.requestId !== 'string' ||
+        value.requestId.trim() !== value.requestId ||
+        value.requestId.length < 1 ||
+        value.requestId.length > 128) {
+        throw new CronAutomationInputError('invalid_request_id', 'requestId must contain 1-128 characters without surrounding whitespace');
     }
-    if (typeof value.name !== "string" || value.name.trim() !== value.name || value.name.length < 1 || value.name.length > 120) {
-        throw new CronAutomationInputError("invalid_name", "name must contain 1-120 characters without surrounding whitespace");
+    if (typeof value.name !== 'string' || value.name.trim() !== value.name || value.name.length < 1 || value.name.length > 120) {
+        throw new CronAutomationInputError('invalid_name', 'name must contain 1-120 characters without surrounding whitespace');
     }
-    if (typeof value.prompt !== "string" || value.prompt.trim() !== value.prompt || value.prompt.length === 0) {
-        throw new CronAutomationInputError("invalid_prompt", "prompt must be a non-empty string without surrounding whitespace");
+    if (typeof value.prompt !== 'string' || value.prompt.trim() !== value.prompt || value.prompt.length === 0) {
+        throw new CronAutomationInputError('invalid_prompt', 'prompt must be a non-empty string without surrounding whitespace');
     }
-    if (typeof value.cron !== "string") {
-        throw new CronAutomationInputError("invalid_cron", "cron must be a standard five-field expression");
+    if (typeof value.cron !== 'string') {
+        throw new CronAutomationInputError('invalid_cron', 'cron must be a standard five-field expression');
     }
     try {
         assertMinimumCronInterval(value.cron);
     }
     catch (error) {
         if (error instanceof CronExpressionError) {
-            throw new CronAutomationInputError("invalid_cron", error.message);
+            throw new CronAutomationInputError('invalid_cron', error.message);
         }
         throw error;
     }
-    if (typeof value.timezone !== "string" || !validTimeZone(value.timezone)) {
-        throw new CronAutomationInputError("invalid_timezone", "timezone must be a valid IANA time zone");
+    if (typeof value.timezone !== 'string' || !validTimeZone(value.timezone)) {
+        throw new CronAutomationInputError('invalid_timezone', 'timezone must be a valid IANA time zone');
     }
     return {
         type: CRON_CREATE_TYPE,
@@ -59,13 +62,13 @@ export function decodeCronCreateEnvelope(value) {
 }
 /** Parse a cron control envelope carried as the sole text block of a direct user message. */
 export function parseCronAutomationMessage(message) {
-    if (message.source.kind !== "user" || message.content.length !== 1)
+    if (message.source.kind !== 'user' || message.content.length !== 1)
         return undefined;
     const block = message.content[0];
-    if (block?.type !== "text")
+    if (block?.type !== 'text')
         return undefined;
     const text = block.text.trim();
-    if (!text.startsWith("{"))
+    if (!text.startsWith('{'))
         return undefined;
     let value;
     try {
@@ -80,10 +83,10 @@ export function parseCronAutomationMessage(message) {
 }
 /** Recognize the stable prompt prefix emitted by the Mobook scheduled-task editor. */
 export function parseCronEditorRequest(message) {
-    if (message.source.kind !== "user" || message.content.length !== 1)
+    if (message.source.kind !== 'user' || message.content.length !== 1)
         return undefined;
     const block = message.content[0];
-    if (block?.type !== "text")
+    if (block?.type !== 'text')
         return undefined;
     const text = block.text.trim();
     const match = /^编辑定时任务[（(]\s*任务\s*ID\s+([^）)]+?)\s*[）)][：:]/u.exec(text);