@serviceme/devtools-core 0.4.1 → 0.4.3

package/dist/index.mjs

@@ -4744,7 +4744,7 @@ var PidManager = class {
   }
 };
 
-// src/scheduled-tasks/daemon/SchedulerDaemon.ts
+// src/scheduled-tasks/daemon/SchedulerDaemonV2.ts
 import * as fs18 from "fs";
 import * as os5 from "os";
 import * as path19 from "path";
@@ -5746,235 +5746,9 @@ var TaskLogManager = class {
   }
 };
 
-// src/scheduled-tasks/daemon/SchedulerDaemon.ts
+// src/scheduled-tasks/daemon/SchedulerDaemonV2.ts
 var TICK_INTERVAL = 1e3;
 var MIN_SCHEDULE_INTERVAL = 1e3;
-var SchedulerDaemon = class {
-  constructor(workspacePath, options = {}) {
-    this.tickTimer = null;
-    this.watcher = null;
-    this.running = false;
-    this.startTime = 0;
-    // Track last execution time and running state per task
-    this.lastRun = /* @__PURE__ */ new Map();
-    this.taskRunning = /* @__PURE__ */ new Set();
-    this.workspacePath = workspacePath;
-    const configDir = path19.join(workspacePath, ".serviceme");
-    this.configManager = new TaskConfigManager({
-      configPath: path19.join(configDir, "scheduled-tasks.json")
-    });
-    this.logManager = new TaskLogManager({
-      logPath: path19.join(configDir, "scheduled-tasks-log.json")
-    });
-    this.pidManager = new PidManager(workspacePath);
-    this.logger = new DaemonLogger(workspacePath);
-    this.getExecutor = options.getExecutor ?? getExecutor;
-  }
-  start() {
-    if (this.running) return;
-    this.running = true;
-    this.startTime = Date.now();
-    this.pidManager.writePid(process.pid);
-    const configPath = this.configManager.getConfigPath();
-    const logPath = this.logger.getLogPath();
-    this.logger.log("info", "=".repeat(60));
-    this.logger.log(
-      "info",
-      `Scheduler daemon started
-  PID:       ${process.pid}
-  Node:      ${process.version}
-  OS:        ${os5.type()} ${os5.release()} (${process.arch})
-  Platform:  ${process.platform}
-  Hostname:  ${os5.hostname()}
-  User:      ${os5.userInfo().username}
-  Workspace: ${this.workspacePath}
-  Config:    ${configPath}
-  LogPath:   ${logPath}
-  ExecPath:  ${process.execPath}`
-    );
-    this.tickTimer = setInterval(() => this.tick(), TICK_INTERVAL);
-    this.setupConfigWatch();
-    process.on("SIGTERM", () => this.stop());
-    process.on("SIGINT", () => this.stop());
-  }
-  stop() {
-    if (!this.running) return;
-    this.running = false;
-    if (this.tickTimer) {
-      clearInterval(this.tickTimer);
-      this.tickTimer = null;
-    }
-    if (this.watcher) {
-      this.watcher.close();
-      this.watcher = null;
-    }
-    this.pidManager.removePid();
-    this.logger.log("info", "Scheduler daemon stopped");
-    process.exit(0);
-  }
-  setupConfigWatch() {
-    const configPath = this.configManager.getConfigPath();
-    const dir = configPath.substring(0, configPath.lastIndexOf("/"));
-    try {
-      if (fs18.existsSync(dir)) {
-        this.watcher = fs18.watch(dir, (_eventType, filename) => {
-          if (filename === "scheduled-tasks.json") {
-            this.logger.log("info", "Config file changed, reconciling...");
-          }
-        });
-      }
-    } catch {
-      this.logger.log("warn", "Could not watch config directory");
-    }
-  }
-  tick() {
-    const config = this.configManager.readConfig();
-    const now = Date.now();
-    for (const task of config.tasks) {
-      if (!task.enabled) continue;
-      if (this.taskRunning.has(task.id)) continue;
-      let lastExec = this.lastRun.get(task.id);
-      if (lastExec === void 0) {
-        this.lastRun.set(task.id, now);
-        lastExec = now;
-      }
-      if (this.shouldRun(task, lastExec, now)) {
-        this.executeTask(task, now);
-      }
-    }
-  }
-  shouldRun(task, lastExec, now) {
-    if (task.scheduleType === "interval") {
-      const intervalMs = parseIntervalMs(task.schedule);
-      if (intervalMs < MIN_SCHEDULE_INTERVAL) return false;
-      return now - lastExec >= intervalMs;
-    }
-    if (task.scheduleType === "cron") {
-      if (now - lastExec < 6e4) return false;
-      return matchesCron(task.schedule, new Date(now));
-    }
-    return false;
-  }
-  async executeTask(task, now) {
-    this.taskRunning.add(task.id);
-    this.lastRun.set(task.id, now);
-    const startedAt = new Date(now).toISOString();
-    const startMs = Date.now();
-    this.logger.log(
-      "info",
-      `Executing task: ${task.name} (${task.id})
-  type:     ${task.taskType}
-  schedule: ${task.schedule} (${task.scheduleType})
-  enabled:  ${task.enabled}`
-    );
-    try {
-      const executionPayload = resolveTaskExecutionPayload(
-        task.taskType,
-        task.payload,
-        this.workspacePath
-      );
-      validateTaskPayload(task.taskType, executionPayload);
-      const executor = this.getExecutor(task.taskType);
-      const result = await executor.execute(executionPayload);
-      const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const durationMs = Date.now() - startMs;
-      this.logManager.appendLog({
-        taskId: task.id,
-        taskName: task.name,
-        startedAt,
-        finishedAt,
-        status: result.status === "running" ? "failure" : result.status,
-        output: result.output,
-        error: result.error
-      });
-      const outputBytes = result.output ? Buffer.byteLength(result.output) : 0;
-      this.logger.log(
-        "info",
-        `Task completed: ${task.name} (${task.id})
-  status:   ${result.status}
-  duration: ${durationMs}ms
-  outputBytes: ${outputBytes}`
-      );
-    } catch (err) {
-      const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const durationMs = Date.now() - startMs;
-      const message = err instanceof Error ? err.message : String(err);
-      this.logManager.appendLog({
-        taskId: task.id,
-        taskName: task.name,
-        startedAt,
-        finishedAt,
-        status: "failure",
-        error: message
-      });
-      this.logger.log(
-        "error",
-        `Task failed: ${task.name} (${task.id})
-  duration: ${durationMs}ms
-  error:    ${message}`
-      );
-    } finally {
-      this.taskRunning.delete(task.id);
-    }
-  }
-  getStatus() {
-    const config = this.configManager.readConfig();
-    return {
-      running: this.running,
-      pid: process.pid,
-      uptimeSeconds: this.running ? Math.floor((Date.now() - this.startTime) / 1e3) : null,
-      tasksRegistered: config.tasks.length,
-      tasksEnabled: config.tasks.filter((t) => t.enabled).length,
-      workspacePath: this.workspacePath,
-      pidFile: this.pidManager.getPidPath()
-    };
-  }
-};
-function parseIntervalMs(schedule) {
-  const match = /^every\s+(\d+)\s*(s|sec|m|min|h|hr|d|day)s?$/i.exec(schedule);
-  if (!match) return 0;
-  const [, numStr, unit] = match;
-  const num = Number.parseInt(numStr ?? "0", 10);
-  switch (unit?.toLowerCase()) {
-    case "s":
-    case "sec":
-      return num * 1e3;
-    case "m":
-    case "min":
-      return num * 60 * 1e3;
-    case "h":
-    case "hr":
-      return num * 60 * 60 * 1e3;
-    case "d":
-    case "day":
-      return num * 24 * 60 * 60 * 1e3;
-    default:
-      return 0;
-  }
-}
-function matchesCron(expression, date) {
-  const parts = expression.trim().split(/\s+/);
-  if (parts.length < 5) return false;
-  const [minPart, hourPart, dayPart, monthPart, weekdayPart] = parts;
-  if (!minPart || !hourPart || !dayPart || !monthPart || !weekdayPart) return false;
-  return matchCronField(minPart, date.getMinutes()) && matchCronField(hourPart, date.getHours()) && matchCronField(dayPart, date.getDate()) && matchCronField(monthPart, date.getMonth() + 1) && matchCronField(weekdayPart, date.getDay());
-}
-function matchCronField(field, value) {
-  if (field === "*") return true;
-  if (field.startsWith("*/")) {
-    const step = Number.parseInt(field.slice(2), 10);
-    return step > 0 && value % step === 0;
-  }
-  const values = field.split(",");
-  return values.some((v) => Number.parseInt(v, 10) === value);
-}
-
-// src/scheduled-tasks/daemon/SchedulerDaemonV2.ts
-import * as fs19 from "fs";
-import * as os6 from "os";
-import * as path20 from "path";
-var TICK_INTERVAL2 = 1e3;
-var MIN_SCHEDULE_INTERVAL2 = 1e3;
 var SCHEDULER_LOG_FILENAME2 = "scheduler.log";
 var SchedulerDaemonV2 = class {
   constructor(options = {}) {
@@ -5991,8 +5765,8 @@ var SchedulerDaemonV2 = class {
     this.configManager = options.configManager ?? new TaskConfigManager();
     this.logManager = options.logManager ?? new TaskLogManager();
     this.pidManager = options.pidManager ?? new PidManager("", { pidPath: getSchedulerPidPath() });
-    this.logger = options.logger ?? new DaemonLogger(os6.homedir(), {
-      logPath: path20.join(path20.dirname(this.pidManager.getPidPath()), SCHEDULER_LOG_FILENAME2)
+    this.logger = options.logger ?? new DaemonLogger(os5.homedir(), {
+      logPath: path19.join(path19.dirname(this.pidManager.getPidPath()), SCHEDULER_LOG_FILENAME2)
     });
     this.getExecutor = options.getExecutor ?? getExecutor;
     this.tryAcquireLock = options.tryAcquireLock ?? (() => true);
@@ -6022,12 +5796,12 @@ var SchedulerDaemonV2 = class {
       `SchedulerDaemonV2 started
   PID:       ${process.pid}
   Node:      ${process.version}
-  OS:        ${os6.type()} ${os6.release()} (${process.arch})
+  OS:        ${os5.type()} ${os5.release()} (${process.arch})
   Config:    ${this.configManager.getConfigPath()}
   LogPath:   ${this.logger.getLogPath()}
   PidPath:   ${this.pidManager.getPidPath()}`
     );
-    this.tickTimer = setInterval(() => this.tick(), TICK_INTERVAL2);
+    this.tickTimer = setInterval(() => this.tick(), TICK_INTERVAL);
     process.on("SIGTERM", this.sigtermHandler);
     process.on("SIGINT", this.sigintHandler);
   }
@@ -6050,7 +5824,7 @@ var SchedulerDaemonV2 = class {
     const now = Date.now();
     for (const task of config.tasks) {
       if (!task.enabled) continue;
-      if (!fs19.existsSync(task.workspace.path)) {
+      if (!fs18.existsSync(task.workspace.path)) {
         this.disableTaskForMissingWorkspace(task, config);
         continue;
       }
@@ -6090,13 +5864,13 @@ var SchedulerDaemonV2 = class {
   }
   shouldRun(task, lastExec, now) {
     if (task.scheduleType === "interval") {
-      const intervalMs = parseIntervalMs2(task.schedule);
-      if (intervalMs < MIN_SCHEDULE_INTERVAL2) return false;
+      const intervalMs = parseIntervalMs(task.schedule);
+      if (intervalMs < MIN_SCHEDULE_INTERVAL) return false;
       return now - lastExec >= intervalMs;
     }
     if (task.scheduleType === "cron") {
       if (now - lastExec < 6e4) return false;
-      return matchesCron2(task.schedule, new Date(now));
+      return matchesCron(task.schedule, new Date(now));
     }
     return false;
   }
@@ -6167,7 +5941,7 @@ var SchedulerDaemonV2 = class {
     };
   }
 };
-function parseIntervalMs2(schedule) {
+function parseIntervalMs(schedule) {
   const match = /^every\s+(\d+)\s*(s|sec|m|min|h|hr|d|day)s?$/i.exec(schedule);
   if (!match) return 0;
   const [, numStr, unit] = match;
@@ -6189,14 +5963,14 @@ function parseIntervalMs2(schedule) {
       return 0;
   }
 }
-function matchesCron2(expression, date) {
+function matchesCron(expression, date) {
   const parts = expression.trim().split(/\s+/);
   if (parts.length < 5) return false;
   const [minPart, hourPart, dayPart, monthPart, weekdayPart] = parts;
   if (!minPart || !hourPart || !dayPart || !monthPart || !weekdayPart) return false;
-  return matchCronField2(minPart, date.getMinutes()) && matchCronField2(hourPart, date.getHours()) && matchCronField2(dayPart, date.getDate()) && matchCronField2(monthPart, date.getMonth() + 1) && matchCronField2(weekdayPart, date.getDay());
+  return matchCronField(minPart, date.getMinutes()) && matchCronField(hourPart, date.getHours()) && matchCronField(dayPart, date.getDate()) && matchCronField(monthPart, date.getMonth() + 1) && matchCronField(weekdayPart, date.getDay());
 }
-function matchCronField2(field, value) {
+function matchCronField(field, value) {
   if (field === "*") return true;
   if (field.startsWith("*/")) {
     const step = Number.parseInt(field.slice(2), 10);
@@ -6207,21 +5981,21 @@ function matchCronField2(field, value) {
 }
 
 // src/scheduled-tasks/migration/MigrateToGlobal.ts
-import * as fs20 from "fs";
-import * as path21 from "path";
+import * as fs19 from "fs";
+import * as path20 from "path";
 import { isScheduledTasksConfigV1 as isScheduledTasksConfigV12, migrateV1ToV2 as migrateV1ToV22 } from "@serviceme/devtools-protocol";
 var WORKSPACE_DIR = ".serviceme";
 var V1_FILENAME = "scheduled-tasks.json";
 function defaultProbe(workspacePath) {
   return {
     path: workspacePath,
-    name: path21.basename(workspacePath) || workspacePath
+    name: path20.basename(workspacePath) || workspacePath
   };
 }
 function readV1Config(v1Path) {
   let raw;
   try {
-    raw = fs20.readFileSync(v1Path, "utf-8");
+    raw = fs19.readFileSync(v1Path, "utf-8");
   } catch (err) {
     return {
       ok: false,
@@ -6244,27 +6018,27 @@ function readV1Config(v1Path) {
 }
 function safeDelete(filePath) {
   try {
-    fs20.unlinkSync(filePath);
+    fs19.unlinkSync(filePath);
   } catch {
   }
 }
 function ensureDir(filePath) {
-  const dir = path21.dirname(filePath);
-  if (!fs20.existsSync(dir)) {
-    fs20.mkdirSync(dir, { recursive: true });
+  const dir = path20.dirname(filePath);
+  if (!fs19.existsSync(dir)) {
+    fs19.mkdirSync(dir, { recursive: true });
   }
 }
 function readJsonFile(filePath) {
-  if (!fs20.existsSync(filePath)) return null;
+  if (!fs19.existsSync(filePath)) return null;
   try {
-    return JSON.parse(fs20.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs19.readFileSync(filePath, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeJsonFile(filePath, data) {
   ensureDir(filePath);
-  fs20.writeFileSync(filePath, JSON.stringify(data, null, "	"), "utf-8");
+  fs19.writeFileSync(filePath, JSON.stringify(data, null, "	"), "utf-8");
 }
 function disambiguateName(task, existingNames, workspaceName) {
   if (!existingNames.has(task.name)) {
@@ -6294,8 +6068,8 @@ async function migrateToGlobal(options) {
   const conflicts = [];
   const issues = [];
   for (const workspacePath of options.workspacePaths) {
-    const v1Path = path21.join(workspacePath, WORKSPACE_DIR, V1_FILENAME);
-    if (!fs20.existsSync(v1Path)) continue;
+    const v1Path = path20.join(workspacePath, WORKSPACE_DIR, V1_FILENAME);
+    if (!fs19.existsSync(v1Path)) continue;
     const v1 = readV1Config(v1Path);
     if (!v1.ok) {
       failures.push({
@@ -6337,8 +6111,8 @@ async function migrateToGlobal(options) {
   if (migrated > 0) {
     ensureDir(globalConfigPath);
     const tmp = `${globalConfigPath}.tmp`;
-    fs20.writeFileSync(tmp, JSON.stringify(baseConfig, null, "	"), "utf-8");
-    fs20.renameSync(tmp, globalConfigPath);
+    fs19.writeFileSync(tmp, JSON.stringify(baseConfig, null, "	"), "utf-8");
+    fs19.renameSync(tmp, globalConfigPath);
   }
   if (failures.length > priorFailures.length) {
     writeJsonFile(migrationFailuresPath, failures);
@@ -6355,8 +6129,8 @@ async function migrateToGlobal(options) {
 
 // src/scheduled-tasks/workspace-probe/WorkspaceProbe.ts
 import { spawn as spawn5 } from "child_process";
-import * as fs21 from "fs";
-import * as path22 from "path";
+import * as fs20 from "fs";
+import * as path21 from "path";
 var DEFAULT_TIMEOUT_MS5 = 2e3;
 var GitTimeoutError = class extends Error {
   constructor() {
@@ -6419,8 +6193,8 @@ var WorkspaceProbe = class {
     }
   }
   async probe(workspacePath) {
-    const name = path22.basename(workspacePath) || workspacePath;
-    if (!workspacePath || !fs21.existsSync(workspacePath)) {
+    const name = path21.basename(workspacePath) || workspacePath;
+    if (!workspacePath || !fs20.existsSync(workspacePath)) {
       return {
         workspace: { path: workspacePath, name },
         error: "path-not-found"
@@ -6572,8 +6346,8 @@ var SkillReconciler = class {
 };
 
 // src/skills/SkillStore.ts
-import * as fs22 from "fs/promises";
-import * as path23 from "path";
+import * as fs21 from "fs/promises";
+import * as path22 from "path";
 var USER_SKILL_MARKER_FILE = ".serviceme-skill.json";
 var LEGACY_USER_SKILL_MARKER_FILE = ".ms-devtools-skill.json";
 var WORKSPACE_SKILLS_ROOT_RELATIVE = ".github/skills";
@@ -6589,7 +6363,7 @@ var SkillStore = class {
   constructor(options) {
     this.workspacePath = options.workspacePath;
     this.userSkillsRoot = options.userSkillsRoot;
-    this.fileSystem = options.fileSystem ?? fs22;
+    this.fileSystem = options.fileSystem ?? fs21;
   }
   normalizeRemoteSkillId(remoteId) {
     if (remoteId.startsWith("official/")) {
@@ -6608,10 +6382,10 @@ var SkillStore = class {
     return WORKSPACE_SKILLS_MARKER_RELATIVE;
   }
   getUserSkillPath(skillId) {
-    return path23.join(this.userSkillsRoot, skillId);
+    return path22.join(this.userSkillsRoot, skillId);
   }
   async listWorkspaceSkillIds() {
-    const skillsRootPath = path23.join(this.workspacePath, WORKSPACE_SKILLS_ROOT_RELATIVE);
+    const skillsRootPath = path22.join(this.workspacePath, WORKSPACE_SKILLS_ROOT_RELATIVE);
     try {
       const entries = await this.fileSystem.readdir(skillsRootPath, {
         withFileTypes: true
@@ -6635,7 +6409,7 @@ var SkillStore = class {
     const targetDir = this.getUserSkillPath(skillId);
     await this.fileSystem.mkdir(targetDir, { recursive: true });
     await this.fileSystem.writeFile(
-      path23.join(targetDir, USER_SKILL_MARKER_FILE),
+      path22.join(targetDir, USER_SKILL_MARKER_FILE),
       JSON.stringify({ skillId, installedBy: "serviceme" }, null, 2),
       "utf-8"
     );
@@ -6644,7 +6418,7 @@ var SkillStore = class {
     await this.migrateLegacyUserSkillMarker(skillId);
     try {
       const marker = await this.fileSystem.readFile(
-        path23.join(this.getUserSkillPath(skillId), USER_SKILL_MARKER_FILE),
+        path22.join(this.getUserSkillPath(skillId), USER_SKILL_MARKER_FILE),
         "utf-8"
       );
       const parsed = JSON.parse(marker);
@@ -6661,8 +6435,8 @@ var SkillStore = class {
    */
   async migrateLegacyUserSkillMarker(skillId) {
     const targetDir = this.getUserSkillPath(skillId);
-    const newPath = path23.join(targetDir, USER_SKILL_MARKER_FILE);
-    const legacyPath = path23.join(targetDir, LEGACY_USER_SKILL_MARKER_FILE);
+    const newPath = path22.join(targetDir, USER_SKILL_MARKER_FILE);
+    const legacyPath = path22.join(targetDir, LEGACY_USER_SKILL_MARKER_FILE);
     try {
       await this.fileSystem.readFile(newPath, "utf-8");
       return;
@@ -6675,12 +6449,12 @@ var SkillStore = class {
     }
   }
   async writeSkillFiles(skillId, scope, files) {
-    const root = scope === "workspace" ? path23.join(this.workspacePath, WORKSPACE_SKILLS_ROOT_RELATIVE) : this.userSkillsRoot;
-    const targetDir = path23.join(root, skillId);
+    const root = scope === "workspace" ? path22.join(this.workspacePath, WORKSPACE_SKILLS_ROOT_RELATIVE) : this.userSkillsRoot;
+    const targetDir = path22.join(root, skillId);
     await this.fileSystem.mkdir(targetDir, { recursive: true });
     for (const file of files) {
-      const filePath = path23.join(targetDir, file.path);
-      await this.fileSystem.mkdir(path23.dirname(filePath), { recursive: true });
+      const filePath = path22.join(targetDir, file.path);
+      await this.fileSystem.mkdir(path22.dirname(filePath), { recursive: true });
       await this.fileSystem.writeFile(filePath, file.content, "utf-8");
       if (file.executable) {
         try {
@@ -6693,8 +6467,8 @@ var SkillStore = class {
 };
 
 // src/submit/index.ts
-import * as fs23 from "fs/promises";
-import * as path24 from "path";
+import * as fs22 from "fs/promises";
+import * as path23 from "path";
 
 // src/submit/types.ts
 var SubmitError = class extends Error {
@@ -6744,14 +6518,14 @@ var SubmitClient = class {
       throw new SubmitError(v.reason ?? "unknown", v.detail ?? "validation denied");
     }
     const localRepoPath = getRepoDir(repoId);
-    const targetDir = path24.join(localRepoPath, "skills", skillName);
-    await fs23.mkdir(targetDir, { recursive: true });
+    const targetDir = path23.join(localRepoPath, "skills", skillName);
+    await fs22.mkdir(targetDir, { recursive: true });
     for (const f of files) {
-      const full = path24.join(targetDir, f.path);
-      await fs23.mkdir(path24.dirname(full), { recursive: true });
+      const full = path23.join(targetDir, f.path);
+      await fs22.mkdir(path23.dirname(full), { recursive: true });
       const tmp = `${full}.${process.pid}.${Date.now()}.tmp`;
-      await fs23.writeFile(tmp, f.content, "utf8");
-      await fs23.rename(tmp, full);
+      await fs22.writeFile(tmp, f.content, "utf8");
+      await fs22.rename(tmp, full);
     }
     const commitMessage = `feat(skills): add ${skillName}`;
     const { commitSha } = await this.git.commit(localRepoPath, commitMessage);
@@ -6820,7 +6594,7 @@ function touchLastUsedAt(tools, id, when = /* @__PURE__ */ new Date()) {
 
 // src/toolbox/ToolboxStore.ts
 import * as fsp2 from "fs/promises";
-import * as path25 from "path";
+import * as path24 from "path";
 import { setTimeout as delay2 } from "timers/promises";
 
 // src/toolbox/types.ts
@@ -6856,11 +6630,11 @@ var DEFAULT_LOCK_TIMEOUT_MS2 = 5e3;
 var DEFAULT_LOCK_RETRY_MS2 = 25;
 var LOCK_STALE_GRACE_MS2 = 200;
 var TMP_SUFFIX2 = ".tmp";
-var WORKSPACE_TOOLBOX_RELATIVE_PATH = path25.join(".github", ".serviceme-toolbox.json");
+var WORKSPACE_TOOLBOX_RELATIVE_PATH = path24.join(".github", ".serviceme-toolbox.json");
 var LEGACY_WORKSPACE_TOOLBOX_FILENAME = ".ms-devtools-toolbox.json";
 async function migrateLegacyWorkspaceToolboxFile(filePath) {
   if (!filePath) return;
-  const legacyPath = path25.join(path25.dirname(filePath), LEGACY_WORKSPACE_TOOLBOX_FILENAME);
+  const legacyPath = path24.join(path24.dirname(filePath), LEGACY_WORKSPACE_TOOLBOX_FILENAME);
   if (legacyPath === filePath) return;
   try {
     await fsp2.access(filePath);
@@ -6909,15 +6683,15 @@ var FsToolboxFileBackend = class {
     }
   }
   async purgeExcessBackups(filePath) {
-    const dir = path25.dirname(filePath);
-    const base = path25.basename(filePath);
+    const dir = path24.dirname(filePath);
+    const base = path24.basename(filePath);
     let entries;
     try {
       entries = await fsp2.readdir(dir);
     } catch {
       return;
     }
-    const backups = entries.filter((n) => n.startsWith(base) && n.endsWith(".bak")).map((n) => ({ name: n, filePath: path25.join(dir, n) })).sort((a, b) => {
+    const backups = entries.filter((n) => n.startsWith(base) && n.endsWith(".bak")).map((n) => ({ name: n, filePath: path24.join(dir, n) })).sort((a, b) => {
       return a.name.localeCompare(b.name);
     });
     const excess = backups.length - this.maxBackupCount;
@@ -6927,7 +6701,7 @@ var FsToolboxFileBackend = class {
     );
   }
   async write(filePath, payload) {
-    await fsp2.mkdir(path25.dirname(filePath), { recursive: true });
+    await fsp2.mkdir(path24.dirname(filePath), { recursive: true });
     const tmpPath = `${filePath}${TMP_SUFFIX2}`;
     const bytes = Buffer.from(JSON.stringify(payload, null, "	"), "utf8");
     await fsp2.rm(tmpPath, { force: true });
@@ -6971,7 +6745,7 @@ var ToolboxFileLock = class {
   constructor(filePath, timeoutMs, retryMs) {
     this.acquired = false;
     this.dirPath = `${filePath}.lock`;
-    this.pidFilePath = path25.join(this.dirPath, "pid");
+    this.pidFilePath = path24.join(this.dirPath, "pid");
     this.timeoutMs = timeoutMs;
     this.retryMs = retryMs;
   }
@@ -7021,7 +6795,7 @@ var ToolboxFileLock = class {
 };
 function defaultWorkspacePath() {
   if (process.env.SERVICEME_NO_WORKSPACE_TOOLBOX === "1") return null;
-  return path25.join(process.cwd(), WORKSPACE_TOOLBOX_RELATIVE_PATH);
+  return path24.join(process.cwd(), WORKSPACE_TOOLBOX_RELATIVE_PATH);
 }
 var ToolboxStore = class {
   constructor(opts = {}) {
@@ -7333,7 +7107,6 @@ export {
   SERVICEME_DIR_NAME,
   SERVICEME_HOME_ENV,
   SKILL_DRAFTS_SUBDIR,
-  SchedulerDaemon,
   SchedulerDaemonV2,
   ShellExecutor,
   SkillCatalogClient,
@@ -7407,7 +7180,6 @@ export {
   isGitHubLocalEmail,
   isStreamingTaskExecutor,
   isUserRepo,
-  matchesCron,
   mergeWithDefaults,
   migrateLegacyServerProxyEnabled,
   migrateToGlobal,
@@ -7415,7 +7187,6 @@ export {
   narrowRepoConfig,
   noopLogger,
   parseAgentToolPermissions,
-  parseIntervalMs,
   randomInstallationId,
   readServerProxyGlobal,
   reindexOrder,