@trevonistrevon/pi-loop 0.5.9 → 0.6.1

package/src/commands/loop-command.ts

@@ -3,13 +3,21 @@ import type {
   ExtensionCommandContext,
   ExtensionUIContext,
 } from "@earendil-works/pi-coding-agent";
-import { parseInterval } from "../loop-parse.js";
-import type { LoopEntry, Trigger } from "../types.js";
+import { formatTrigger } from "../loop-format.js";
+import { isValidCronExpression, parseInterval } from "../loop-parse.js";
+import type { DynamicLoopState, LoopEntry, Trigger } from "../types.js";
 
 interface LoopStoreLike {
   list(): LoopEntry[];
   get(id: string): LoopEntry | undefined;
-  create(trigger: Trigger, prompt: string, options?: Partial<LoopEntry>): LoopEntry;
+  create(trigger: Trigger, prompt: string, options: {
+    recurring: boolean;
+    autoTask?: boolean;
+    taskBacklog?: boolean;
+    readOnly?: boolean;
+    maxFires?: number;
+    dynamic?: Partial<DynamicLoopState>;
+  }): LoopEntry;
   pause(id: string): LoopEntry | undefined;
   resume(id: string): LoopEntry | undefined;
   delete(id: string): boolean;
@@ -27,33 +35,82 @@ export interface LoopCommandOptions {
   updateWidget: () => void;
 }
 
-export function registerLoopCommand(options: LoopCommandOptions): void {
-  const { pi, getStore, getTriggerSystem, updateWidget } = options;
+type LoopCommandRoute =
+  | { type: "menu" }
+  | { type: "event"; source: string; prompt: string }
+  | { type: "cron"; interval: string; prompt: string; notifyEvery: boolean }
+  | { type: "invalid-cron"; interval: string }
+  | { type: "missing-interval-prompt" }
+  | { type: "dynamic"; goal: string };
+
+function parseLoopCommandRoute(input: string): LoopCommandRoute {
+  const trimmed = input.trim();
+  if (!trimmed) return { type: "menu" };
+
+  const eventMatch = trimmed.match(/^(?:event|when)\s+(\S+)\s+(.+)$/i);
+  if (eventMatch?.[1] && eventMatch[2]) {
+    return { type: "event", source: eventMatch[1], prompt: eventMatch[2].trim() };
+  }
 
-  async function scheduleLoop(ui: ExtensionUIContext, prompt?: string) {
-    const p = prompt || await ui.input("Prompt (what should the agent check?)");
-    if (!p) return;
+  const parts = trimmed.split(/\s+/);
+  if (parts.length > 5) {
+    const interval = parts.slice(0, 5).join(" ");
+    const cronShaped = parts.slice(0, 5).every((part) => /^[\d*/,-]+$/.test(part));
+    if (cronShaped) {
+      if (!isValidCronExpression(interval)) return { type: "invalid-cron", interval };
+      return { type: "cron", interval, prompt: parts.slice(5).join(" "), notifyEvery: false };
+    }
+  }
 
-    const interval = await ui.input("Interval (e.g., 5m, 2h, 1d)");
-    if (!interval) return;
+  const intervalMatch = trimmed.match(/^(\d+\s*[smhdS]\b)/i);
+  if (intervalMatch) {
+    const interval = intervalMatch[1] ?? intervalMatch[0];
+    const prompt = trimmed.slice(intervalMatch[0].length).trim();
+    if (!prompt) return { type: "missing-interval-prompt" };
+    return { type: "cron", interval, prompt, notifyEvery: true };
+  }
 
+  return { type: "dynamic", goal: trimmed };
+}
+
+export function registerLoopCommand(options: LoopCommandOptions): void {
+  const { pi, getStore, getTriggerSystem, updateWidget } = options;
+
+  function createCronLoop(ui: ExtensionUIContext, interval: string, prompt: string, notifyEvery: boolean) {
+    let entry: LoopEntry | undefined;
     try {
       const parsed = parseInterval(interval);
       const trigger: Trigger = { type: "cron", schedule: parsed.cron };
-      const entry = getStore().create(trigger, p, { recurring: true });
+      entry = getStore().create(trigger, prompt, { recurring: true });
       getTriggerSystem().add(entry);
       updateWidget();
-      ui.notify(`Loop #${entry.id} created: every ${parsed.description}`, "info");
+      const cadence = notifyEvery ? `every ${parsed.description}` : parsed.description;
+      ui.notify(`Loop #${entry.id} created: ${cadence} — ${prompt.slice(0, 50)}`, "info");
     } catch (err: unknown) {
+      if (entry) {
+        getTriggerSystem().remove(entry.id);
+        getStore().delete(entry.id);
+        updateWidget();
+      }
       ui.notify((err as Error).message, "error");
     }
   }
 
-  async function eventLoop(ui: ExtensionUIContext, prompt?: string) {
+  async function scheduleLoop(ui: ExtensionUIContext, prompt?: string) {
+    const p = prompt || await ui.input("Prompt (what should the agent check?)");
+    if (!p) return;
+
+    const interval = await ui.input("Interval (e.g., 5m, 2h, 1d)");
+    if (!interval) return;
+
+    createCronLoop(ui, interval, p, true);
+  }
+
+  async function eventLoop(ui: ExtensionUIContext, prompt?: string, sourceOverride?: string) {
     const p = prompt || await ui.input("Prompt");
     if (!p) return;
 
-    const source = await ui.input("Pi event source (e.g., tool_execution_start, before_agent_start)");
+    const source = sourceOverride || await ui.input("Pi event source (e.g., tool_execution_start, before_agent_start)");
     if (!source) return;
 
     const trigger: Trigger = { type: "event", source };
@@ -63,6 +120,18 @@ export function registerLoopCommand(options: LoopCommandOptions): void {
     ui.notify(`Event loop #${entry.id} created: fires on "${source}"`, "info");
   }
 
+  function dynamicLoop(ui: ExtensionUIContext, goal: string) {
+    const trigger: Trigger = { type: "dynamic" };
+    const entry = getStore().create(trigger, goal, {
+      recurring: true,
+      maxFires: 20,
+      dynamic: { goal, iteration: 0 },
+    });
+    getTriggerSystem().add(entry);
+    updateWidget();
+    ui.notify(`Dynamic loop #${entry.id} created — ${goal.slice(0, 50)}`, "info");
+  }
+
   async function viewLoops(ui: ExtensionUIContext) {
     const loops = getStore().list();
     if (loops.length === 0) {
@@ -72,12 +141,7 @@ export function registerLoopCommand(options: LoopCommandOptions): void {
 
     const choices = loops.map((l) => {
       const icon = l.status === "active" ? "*" : l.status === "paused" ? "-" : "x";
-      const triggerDesc = l.trigger.type === "cron"
-        ? `cron: ${l.trigger.schedule}`
-        : l.trigger.type === "event"
-          ? `event: ${l.trigger.source}`
-          : `hybrid: ${l.trigger.cron}`;
-      return `${icon} #${l.id} [${l.status}] ${l.prompt.slice(0, 50)} (${triggerDesc})`;
+      return `${icon} #${l.id} [${l.status}] ${l.prompt.slice(0, 50)} (${formatTrigger(l.trigger, "command")})`;
     });
     choices.push("< Back");
 
@@ -85,7 +149,7 @@ export function registerLoopCommand(options: LoopCommandOptions): void {
     if (!selected || selected === "< Back") return;
 
     const match = selected.match(/#(\d+)/);
-    if (match) {
+    if (match?.[1]) {
       const entry = getStore().get(match[1]);
       if (entry) {
         const actions = ["x Delete"];
@@ -109,8 +173,9 @@ export function registerLoopCommand(options: LoopCommandOptions): void {
           updateWidget();
           ui.notify(`Loop #${entry.id} paused`, "info");
         } else if (action === "* Resume") {
-          getStore().resume(entry.id);
-          getTriggerSystem().add(entry);
+          const resumed = getStore().resume(entry.id);
+          if (!resumed) return viewLoops(ui);
+          getTriggerSystem().add(resumed);
           updateWidget();
           ui.notify(`Loop #${entry.id} resumed`, "info");
         }
@@ -127,12 +192,12 @@ export function registerLoopCommand(options: LoopCommandOptions): void {
   }
 
   pi.registerCommand("loop", {
-    description: "Create a repeating scheduled task: /loop [interval] [prompt]. E.g., /loop 5m check the deploy, /loop 30s am I still here",
+    description: "Create a loop. Use /loop [interval] [prompt] for scheduled loops, /loop event <source> <prompt> for event loops, or /loop <goal> for a dynamic goal loop.",
     handler: async (args: string, ctx: ExtensionCommandContext) => {
-      const trimmed = args.trim();
       const ui = ctx.ui;
+      const route = parseLoopCommandRoute(args);
 
-      if (!trimmed) {
+      if (route.type === "menu") {
         const choice = await ui.select("Loop", [
           "Create scheduled loop",
           "Create event-triggered loop",
@@ -147,37 +212,17 @@ export function registerLoopCommand(options: LoopCommandOptions): void {
         return settings(ui);
       }
 
-      const intervalMatch = trimmed.match(/^(\d+\s*[smhdS]\b)/i);
-      if (intervalMatch) {
-        const interval = intervalMatch[1];
-        const prompt = trimmed.slice(intervalMatch[0].length).trim();
-
-        if (!prompt) {
-          ui.notify("Provide a prompt after the interval, e.g., /loop 5m check the deploy", "warning");
-          return;
-        }
-
-        try {
-          const parsed = parseInterval(interval);
-          const trigger: Trigger = { type: "cron", schedule: parsed.cron };
-          const entry = getStore().create(trigger, prompt, { recurring: true });
-          getTriggerSystem().add(entry);
-          updateWidget();
-          ui.notify(`Loop #${entry.id} created: every ${parsed.description} — ${prompt.slice(0, 50)}`, "info");
-        } catch (err: unknown) {
-          ui.notify((err as Error).message, "error");
-        }
+      if (route.type === "event") return eventLoop(ui, route.prompt, route.source);
+      if (route.type === "cron") return createCronLoop(ui, route.interval, route.prompt, route.notifyEvery);
+      if (route.type === "invalid-cron") {
+        ui.notify(`Invalid cron expression: ${route.interval}`, "error");
         return;
       }
-
-      const choice = await ui.select("Loop mode", [
-        `Scheduled: "${trimmed.slice(0, 50)}"`,
-        `Event-triggered: "${trimmed.slice(0, 50)}"`,
-      ]);
-
-      if (!choice) return;
-      if (choice.startsWith("Event")) return eventLoop(ui, trimmed);
-      return scheduleLoop(ui, trimmed);
+      if (route.type === "missing-interval-prompt") {
+        ui.notify("Provide a prompt after the interval, e.g., /loop 5m check the deploy", "warning");
+        return;
+      }
+      return dynamicLoop(ui, route.goal);
     },
   });
 }

package/src/commands/tasks-command.ts

@@ -67,10 +67,10 @@ export function registerTasksCommand(options: TasksCommandOptions): void {
       return viewNativeTasks(ui);
     }
 
-    const match = selected.match(/#(\d+)/);
-    if (!match) return viewNativeTasks(ui);
+    const taskId = selected.match(/#(\d+)/)?.[1];
+    if (!taskId) return viewNativeTasks(ui);
 
-    const task = taskStore.get(match[1]);
+    const task = taskStore.get(taskId);
     if (!task) return viewNativeTasks(ui);
 
     const actions = ["x Delete"];

package/src/coordinator.ts

@@ -8,7 +8,7 @@ export type ReducerSource =
   | "coordinator"
   | "system";
 
-export type ReducerEntityType = "task" | "loop" | "monitor" | "notification" | "goal";
+export type ReducerEntityType = "task" | "loop" | "monitor" | "notification";
 
 export interface ReducerEvent<TType extends string = string, TPayload = unknown> {
   type: TType;

package/src/index.ts

@@ -4,13 +4,14 @@
  * Tools:
  *   LoopCreate    — Create a scheduled or event-triggered re-wake loop
  *   LoopList      — List all active loops with status and next-fire times
+ *   LoopUpdate    — Continue, pause, or complete a dynamic goal loop
  *   LoopDelete    — Delete or pause a loop by ID
  *   MonitorCreate — Start a background command that streams output via pi events
  *   MonitorList   — List running monitors
  *   MonitorStop   — Stop a running monitor
  *
  * Commands:
- *   /loop    — Schedule or manage re-wake loops: /loop [interval] [prompt]
+ *   /loop    — Schedule or manage re-wake loops, including /loop <goal>
  *   /tasks   — View or manage native fallback tasks when pi-tasks is absent
  */
 
@@ -20,6 +21,7 @@ import { registerTasksCommand } from "./commands/tasks-command.js";
 import { atMaxFires } from "./loop-reducer.js";
 import { MonitorManager } from "./monitor-manager.js";
 import { createMonitorOnDoneRuntime } from "./runtime/monitor-ondone-runtime.js";
+import { registerNativeTaskRpc } from "./runtime/native-task-rpc.js";
 import {
   createNotificationRuntime,
   type LoopFireEvent,
@@ -63,16 +65,29 @@ export default function (pi: ExtensionAPI) {
   // call), so stale monitors don't linger in the count between turns.
   monitorManager.setOnChange(() => widget.update());
   widget.setTaskSummaryProvider(() => {
-    if (!nativeTaskStore) return { count: 0 };
-    const tasks = nativeTaskStore.list().filter(t => t.status === "pending" || t.status === "in_progress");
-    const active = tasks.find(t => t.status === "in_progress");
-    const next = tasks.find(t => t.status === "pending");
-    const focus = active
-      ? `active: ${active.subject.slice(0, 50)}`
-      : next
-        ? `next: ${next.subject.slice(0, 50)}`
+    // Once pi-tasks owns the channels, any native store created during the
+    // detection window is a shadow — never surface it in the status line.
+    if (tasksAvailable || !nativeTaskStore) return { count: 0 };
+
+    let count = 0;
+    let activeSubject: string | undefined;
+    let nextSubject: string | undefined;
+    for (const task of nativeTaskStore.list()) {
+      if (task.status === "in_progress") {
+        count++;
+        activeSubject ??= task.subject;
+      } else if (task.status === "pending") {
+        count++;
+        nextSubject ??= task.subject;
+      }
+    }
+
+    const focus = activeSubject
+      ? `active: ${activeSubject.slice(0, 50)}`
+      : nextSubject
+        ? `next: ${nextSubject.slice(0, 50)}`
         : undefined;
-    return { count: tasks.length, focusText: focus };
+    return { count, focusText: focus };
   });
 
   scheduler = new CronScheduler(store, onLoopFire);
@@ -80,9 +95,19 @@ export default function (pi: ExtensionAPI) {
 
   // ── pi-tasks integration ──
   let tasksAvailable = false;
+  let tasksDetectionSettled = false;
   let nativeTaskStore: TaskStore | undefined;
   let nativeTasksRegistered = false;
 
+  function getOrCreateNativeTaskStore(): TaskStore | undefined {
+    // pi-tasks owns the task channels; don't create a shadow store.
+    if (tasksAvailable) return undefined;
+    if (!nativeTaskStore) {
+      nativeTaskStore = new TaskStore(resolveTaskStorePath(getScopeOptions(), _sessionId));
+    }
+    return nativeTaskStore;
+  }
+
   const taskRuntime = createTaskRuntimeBridge({
     pi,
     isTasksAvailable: () => tasksAvailable,
@@ -97,6 +122,31 @@ export default function (pi: ExtensionAPI) {
       widget.update();
       await evaluateTaskBacklog(taskStore, taskStore.pendingCount());
     },
+    onDetectionStarted: () => {
+      tasksDetectionSettled = false;
+    },
+    onDetectionSettled: () => {
+      tasksDetectionSettled = true;
+    },
+    debug,
+  });
+
+  // The RPC server registers at init (not behind the 6s tool-fallback timer) so
+  // early cross-extension calls never race the timer; it stands down via
+  // isEnabled once an external pi-tasks is detected. checkTasksVersion ignores
+  // this server's own ping reply via its provider field. Mutating verbs stay
+  // silent until the detection probe settles, so a co-resident pi-tasks can
+  // never race the native server into creating divergent task state.
+  registerNativeTaskRpc({
+    pi,
+    getNativeTaskStore: getOrCreateNativeTaskStore,
+    isEnabled: () => !tasksAvailable,
+    isDetectionSettled: () => tasksDetectionSettled,
+    evaluateTaskBacklog: (taskStore, pendingCount) =>
+      evaluateTaskBacklog(taskStore, pendingCount),
+    updateWidget: () => {
+      widget.update();
+    },
     debug,
   });
 
@@ -161,6 +211,9 @@ export default function (pi: ExtensionAPI) {
     deleteLoop: (id) => {
       store.delete(id);
     },
+    recordDeletionTombstone: (id, tombstone) => {
+      store.recordDeletionTombstone(id, tombstone);
+    },
     addTrigger: (entry) => {
       triggerSystem.add(entry);
     },
@@ -173,6 +226,12 @@ export default function (pi: ExtensionAPI) {
     hasPendingTasks: () => hasPendingTasks(),
     bootstrapTaskLoop: (entry) => maybeBootstrapTaskLoop(entry),
     triggerHasEventSource,
+    emitLoopAutodeleted: (payload) => {
+      pi.events.emit("loops:autodeleted", payload);
+    },
+    emitTaskBacklogEmpty: (payload) => {
+      pi.events.emit("tasks:backlog_empty", payload);
+    },
     debug,
   });
 
@@ -193,6 +252,17 @@ export default function (pi: ExtensionAPI) {
     }
     store.fire(entry.id);
 
+    const firedAt = Date.now();
+    const firedEntry = entry.trigger.type === "dynamic"
+      ? store.updateDynamic(entry.id, {
+          dynamic: {
+            awaitingUpdate: true,
+            nextWakeAt: undefined,
+            lastUpdatedAt: firedAt,
+          },
+        }) ?? entry
+      : entry;
+
     if (entry.autoTask) {
       autoCreateTask(entry).then((taskId) => {
         if (taskId) debug(`loop #${entry.id} → task #${taskId}`);
@@ -200,13 +270,14 @@ export default function (pi: ExtensionAPI) {
     }
 
     pi.events.emit("loop:fire", {
-      loopId: entry.id,
-      prompt: entry.prompt,
-      trigger: entry.trigger,
-      timestamp: Date.now(),
-      readOnly: entry.readOnly,
-      recurring: entry.recurring,
-      autoTask: entry.autoTask,
+      loopId: firedEntry.id,
+      prompt: firedEntry.prompt,
+      trigger: firedEntry.trigger,
+      timestamp: firedAt,
+      readOnly: firedEntry.readOnly,
+      recurring: firedEntry.recurring,
+      autoTask: firedEntry.autoTask,
+      dynamic: firedEntry.dynamic,
     });
   }
 
@@ -301,9 +372,12 @@ export default function (pi: ExtensionAPI) {
 
   // ── Native task tools (only when pi-tasks is absent) ──
 
+  // Only tool/command registration stays deferred: the tool names collide with
+  // pi-tasks and cannot be unregistered. The RPC server is already live (above).
   const nativeTaskFallbackTimer = setTimeout(() => {
     if (tasksAvailable || nativeTasksRegistered) return;
-    const taskStore = new TaskStore(resolveTaskStorePath(getScopeOptions(), _sessionId));
+    const taskStore = getOrCreateNativeTaskStore();
+    if (!taskStore) return;
 
     try {
       registerTasksCommand({
@@ -331,7 +405,6 @@ export default function (pi: ExtensionAPI) {
       throw error;
     }
 
-    nativeTaskStore = taskStore;
     nativeTasksRegistered = true;
     debug("native task tools registered (pi-tasks not detected)");
   }, 6000);

package/src/loop-format.ts

@@ -0,0 +1,22 @@
+import type { Trigger } from "./types.js";
+
+export type TriggerFormatStyle = "command" | "create" | "list" | "notification";
+
+export function formatTrigger(trigger: Trigger | string, style: TriggerFormatStyle = "list"): string {
+  if (typeof trigger === "string") return trigger;
+
+  if (trigger.type === "cron") {
+    return style === "create" || style === "notification"
+      ? `schedule: ${trigger.schedule}`
+      : `cron: ${trigger.schedule}`;
+  }
+
+  if (trigger.type === "event") return `event: ${trigger.source}`;
+
+  if (trigger.type === "dynamic") return "dynamic";
+
+  if (style === "command") return `hybrid: ${trigger.cron}`;
+  if (style === "create") return `hybrid: cron ${trigger.cron} + event ${trigger.event.source}`;
+  if (style === "notification") return "hybrid";
+  return `hybrid: ${trigger.cron} + ${trigger.event.source}`;
+}

package/src/loop-parse.ts

@@ -23,8 +23,10 @@ const COMMON_INTERVALS: Record<number, string> = {
 };
 
 function roundToNearestCommon(seconds: number): { cron: string; description: string } {
+  // COMMON_INTERVALS is a non-empty const table, so keys[0] and
+  // COMMON_INTERVALS[best] below are true invariants, not runtime fallbacks.
   const keys = Object.keys(COMMON_INTERVALS).map(Number).sort((a, b) => a - b);
-  let best = keys[0];
+  let best = keys[0] as number;
   for (const k of keys) {
     if (Math.abs(k - seconds) < Math.abs(best - seconds)) best = k;
   }
@@ -43,7 +45,7 @@ function roundToNearestCommon(seconds: number): { cron: string; description: str
     }
   }
 
-  return { cron: COMMON_INTERVALS[best], description };
+  return { cron: COMMON_INTERVALS[best] as string, description };
 }
 
 function isFullCron(expr: string): boolean {
@@ -51,17 +53,60 @@ function isFullCron(expr: string): boolean {
   return parts.length === 5;
 }
 
+function parseCronNumber(input: string, min: number, max: number): number | undefined {
+  if (!/^\d+$/.test(input)) return undefined;
+  const value = Number.parseInt(input, 10);
+  return value >= min && value <= max ? value : undefined;
+}
+
+function isValidCronField(field: string, min: number, max: number): boolean {
+  return field.split(",").every((part) => {
+    const [base, step, extra] = part.split("/");
+    if (extra !== undefined || base === undefined) return false;
+    if (step !== undefined && (parseCronNumber(step, 1, max - min + 1) === undefined)) return false;
+    if (base === "*") return true;
+
+    const range = base.split("-");
+    if (range.length === 1) return step === undefined && parseCronNumber(base, min, max) !== undefined;
+    if (range.length !== 2) return false;
+
+    const start = parseCronNumber(range[0] ?? "", min, max);
+    const end = parseCronNumber(range[1] ?? "", min, max);
+    return start !== undefined && end !== undefined && start <= end;
+  });
+}
+
+export function isValidCronExpression(expr: string): boolean {
+  const fields = expr.trim().split(/\s+/);
+  if (fields.length !== 5) return false;
+
+  const ranges = [
+    [0, 59],
+    [0, 23],
+    [1, 31],
+    [1, 12],
+    [0, 6],
+  ] as const;
+  return fields.every((field, index) => {
+    const range = ranges[index];
+    return range !== undefined && isValidCronField(field, range[0], range[1]);
+  });
+}
+
 export function parseInterval(input: string): { cron: string; description: string } {
   const trimmed = input.trim();
 
   if (isFullCron(trimmed)) {
+    if (!isValidCronExpression(trimmed)) {
+      throw new Error(`Invalid cron expression: ${trimmed}`);
+    }
     return { cron: trimmed, description: `cron: ${trimmed}` };
   }
 
   const match = trimmed.match(/^(\d+)\s*(s|m|h|d)$/i);
   if (match) {
-    const value = parseInt(match[1], 10);
-    const unit = match[2].toLowerCase();
+    const value = parseInt(match[1] ?? "", 10);
+    const unit = (match[2] ?? "").toLowerCase();
     const totalSec = value * (UNIT_TO_CRON[unit] ?? 60);
 
     if (totalSec < 60) {
@@ -78,9 +123,18 @@ export function parseInterval(input: string): { cron: string; description: strin
 
 export function cronToNextFire(cronExpr: string, fromDate: Date = new Date()): Date {
   const parts = cronExpr.trim().split(/\s+/);
-  if (parts.length !== 5) throw new Error(`Invalid cron expression: ${cronExpr}`);
+  if (!isValidCronExpression(cronExpr)) throw new Error(`Invalid cron expression: ${cronExpr}`);
 
   const [minF, hourF, dayF, monthF, dowF] = parts;
+  if (
+    minF === undefined ||
+    hourF === undefined ||
+    dayF === undefined ||
+    monthF === undefined ||
+    dowF === undefined
+  ) {
+    throw new Error(`Invalid cron expression: ${cronExpr}`);
+  }
   const now = new Date(fromDate);
   now.setSeconds(0, 0);
 
@@ -107,7 +161,7 @@ function cronFieldMatches(field: string, value: number): boolean {
     if (part === "*") return true;
 
     if (part.includes("/")) {
-      const [range, stepStr] = part.split("/");
+      const [range = "", stepStr = ""] = part.split("/");
       const step = parseInt(stepStr, 10);
       let rangeMin: number;
       let rangeMax: number;
@@ -116,7 +170,7 @@ function cronFieldMatches(field: string, value: number): boolean {
         rangeMin = 0;
         rangeMax = 59;
       } else if (range.includes("-")) {
-        const [minS, maxS] = range.split("-");
+        const [minS = "", maxS = ""] = range.split("-");
         rangeMin = parseInt(minS, 10);
         rangeMax = parseInt(maxS, 10);
       } else {
@@ -132,7 +186,7 @@ function cronFieldMatches(field: string, value: number): boolean {
     }
 
     if (part.includes("-")) {
-      const [minS, maxS] = part.split("-");
+      const [minS = "", maxS = ""] = part.split("-");
       const min = parseInt(minS, 10);
       const max = parseInt(maxS, 10);
       if (value >= min && value <= max) return true;