@serviceme/devtools-cli 0.1.3 → 0.1.5

package/dist/cli.js

@@ -4,8 +4,9 @@
 var child_process = require('child_process');
 var fs2 = require('fs/promises');
 var path = require('path');
-var fs6 = require('fs');
+var fs8 = require('fs');
 var crypto = require('crypto');
+var os = require('os');
 var readline = require('readline');
 
 function _interopNamespace(e) {
@@ -28,7 +29,8 @@ function _interopNamespace(e) {
 
 var fs2__namespace = /*#__PURE__*/_interopNamespace(fs2);
 var path__namespace = /*#__PURE__*/_interopNamespace(path);
-var fs6__namespace = /*#__PURE__*/_interopNamespace(fs6);
+var fs8__namespace = /*#__PURE__*/_interopNamespace(fs8);
+var os__namespace = /*#__PURE__*/_interopNamespace(os);
 var readline__namespace = /*#__PURE__*/_interopNamespace(readline);
 
 var __create = Object.create;
@@ -157,6 +159,7 @@ var init_env = __esm({
       "pnpm",
       "nvm",
       "nrm",
+      "rtk",
       "dotnet",
       "nuget"
     ];
@@ -360,7 +363,8 @@ async function runCommand(command, options2 = {}) {
       cwd: options2.cwd,
       env: options2.env,
       shell: options2.shell,
-      stdio: "pipe"
+      stdio: "pipe",
+      windowsHide: true
     });
     let stdout = "";
     let stderr = "";
@@ -582,13 +586,19 @@ var init_copilot2 = __esm({
 });
 
 // ../../packages/serviceme-core/src/env/environmentInspector.ts
-var TOOL_CHECK_TIMEOUT_MS, ERROR_CODE_NOT_FOUND, EnvironmentInspector;
+var DEFAULT_TOOL_CHECK_TIMEOUT_MS, TOOL_CHECK_TIMEOUT_MS, ERROR_CODE_NOT_FOUND, ERROR_CODE_TIMEOUT, EnvironmentInspector;
 var init_environmentInspector = __esm({
   "../../packages/serviceme-core/src/env/environmentInspector.ts"() {
     init_src();
     init_runCommand();
-    TOOL_CHECK_TIMEOUT_MS = 5e3;
+    DEFAULT_TOOL_CHECK_TIMEOUT_MS = 5e3;
+    TOOL_CHECK_TIMEOUT_MS = {
+      nuget: 12e3,
+      nvm: 8e3,
+      dotnet: 8e3
+    };
     ERROR_CODE_NOT_FOUND = 127;
+    ERROR_CODE_TIMEOUT = "ETIMEDOUT";
     EnvironmentInspector = class {
       async checkEnvironment() {
         const results = await Promise.all(
@@ -625,19 +635,18 @@ var init_environmentInspector = __esm({
           const isWindows = process.platform === "win32";
           const result = await runCommand(isWindows ? "where" : "which", {
             args: [toolName],
-            timeoutMs: TOOL_CHECK_TIMEOUT_MS
+            timeoutMs: this.getToolTimeout(toolName)
           });
-          return result.stdout.trim().split("\n")[0];
+          return result.stdout.split(/\r?\n/).map((line2) => line2.trim()).find((line2) => line2.length > 0);
         } catch {
           return void 0;
         }
       }
       async getToolVersion(toolName) {
-        const command = this.getVersionCommand(toolName);
-        const isWindows = process.platform === "win32";
-        const result = await runCommand(isWindows ? "cmd.exe" : "/bin/bash", {
-          args: isWindows ? ["/c", command] : ["-lc", command],
-          timeoutMs: TOOL_CHECK_TIMEOUT_MS
+        const invocation = this.getVersionInvocation(toolName);
+        const result = await runCommand(invocation.command, {
+          args: invocation.args,
+          timeoutMs: this.getToolTimeout(toolName)
         });
         return this.parseVersion(toolName, result.stdout || result.stderr);
       }
@@ -646,7 +655,7 @@ var init_environmentInspector = __esm({
           try {
             const result = await runCommand("cmd.exe", {
               args: ["/c", "nvm version"],
-              timeoutMs: TOOL_CHECK_TIMEOUT_MS
+              timeoutMs: this.getToolTimeout("nvm")
             });
             return {
               installed: true,
@@ -666,7 +675,7 @@ var init_environmentInspector = __esm({
               "-lc",
               'export NVM_DIR="$HOME/.nvm"; [ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"; nvm --version'
             ],
-            timeoutMs: TOOL_CHECK_TIMEOUT_MS
+            timeoutMs: this.getToolTimeout("nvm")
           });
           return {
             installed: true,
@@ -691,7 +700,7 @@ var init_environmentInspector = __esm({
         try {
           const result = await runCommand("dotnet", {
             args: ["nuget", "list", "source"],
-            timeoutMs: TOOL_CHECK_TIMEOUT_MS
+            timeoutMs: this.getToolTimeout("nuget")
           });
           const privateSourceUrl = "http://192.168.20.209:10010/nuget";
           if (result.stdout.includes(privateSourceUrl)) {
@@ -709,17 +718,28 @@ var init_environmentInspector = __esm({
           return this.handleToolCheckError(error);
         }
       }
-      getVersionCommand(toolName) {
+      getVersionInvocation(toolName) {
+        const isWindows = process.platform === "win32";
+        if (isWindows && ["npm", "pnpm", "nrm"].includes(toolName)) {
+          return {
+            command: "cmd.exe",
+            args: ["/d", "/s", "/c", `${toolName} --version`]
+          };
+        }
         const commands = {
-          git: "git --version",
-          node: "node --version",
-          npm: "npm --version",
-          pnpm: "pnpm --version",
-          nvm: "nvm --version",
-          nrm: "nrm --version",
-          dotnet: "dotnet --version"
+          git: { command: "git", args: ["--version"] },
+          node: { command: "node", args: ["--version"] },
+          npm: { command: "npm", args: ["--version"] },
+          pnpm: { command: "pnpm", args: ["--version"] },
+          nvm: { command: "nvm", args: ["--version"] },
+          nrm: { command: "nrm", args: ["--version"] },
+          rtk: { command: "rtk", args: ["--version"] },
+          dotnet: { command: "dotnet", args: ["--version"] }
         };
-        return commands[toolName] || `${toolName} --version`;
+        return commands[toolName] || { command: toolName, args: ["--version"] };
+      }
+      getToolTimeout(toolName) {
+        return TOOL_CHECK_TIMEOUT_MS[toolName] ?? DEFAULT_TOOL_CHECK_TIMEOUT_MS;
       }
       parseVersion(toolName, output) {
         const cleaned = output.trim();
@@ -746,10 +766,11 @@ var init_environmentInspector = __esm({
         const execError = error;
         const message = execError.message || String(error);
         const code = execError.code;
-        const isNotFound = message.includes("command not found") || message.includes("not recognized") || code === ERROR_CODE_NOT_FOUND;
+        const isNotFound = message.includes("command not found") || message.includes("not recognized") || message.includes("ENOENT") || code === "ENOENT" || code === ERROR_CODE_NOT_FOUND;
+        const isTimeout = code === ERROR_CODE_TIMEOUT || message.toLowerCase().includes("timed out");
         return {
           installed: false,
-          error: isNotFound ? "Not installed" : message
+          error: isNotFound ? "Not installed" : isTimeout ? "Check timed out" : message
         };
       }
     };
@@ -1126,9 +1147,9 @@ var require_esprima = __commonJS({
                 });
               };
               CommentHandler2.prototype.visitComment = function(node, metadata) {
-                var type = node.type[0] === "L" ? "Line" : "Block";
+                var type2 = node.type[0] === "L" ? "Line" : "Block";
                 var comment = {
-                  type,
+                  type: type2,
                   value: node.value
                 };
                 if (node.range) {
@@ -1141,7 +1162,7 @@ var require_esprima = __commonJS({
                 if (this.attach) {
                   var entry = {
                     comment: {
-                      type,
+                      type: type2,
                       value: node.value,
                       range: [metadata.start.offset, metadata.end.offset]
                     },
@@ -1150,7 +1171,7 @@ var require_esprima = __commonJS({
                   if (node.loc) {
                     entry.comment.loc = node.loc;
                   }
-                  node.type = type;
+                  node.type = type2;
                   this.leading.push(entry);
                   this.trailing.push(entry);
                 }
@@ -5965,28 +5986,28 @@ var require_esprima = __commonJS({
                 };
               };
               Scanner2.prototype.scanIdentifier = function() {
-                var type;
+                var type2;
                 var start = this.index;
                 var id = this.source.charCodeAt(start) === 92 ? this.getComplexIdentifier() : this.getIdentifier();
                 if (id.length === 1) {
-                  type = 3;
+                  type2 = 3;
                 } else if (this.isKeyword(id)) {
-                  type = 4;
+                  type2 = 4;
                 } else if (id === "null") {
-                  type = 5;
+                  type2 = 5;
                 } else if (id === "true" || id === "false") {
-                  type = 1;
+                  type2 = 1;
                 } else {
-                  type = 3;
+                  type2 = 3;
                 }
-                if (type !== 3 && start + id.length !== this.index) {
+                if (type2 !== 3 && start + id.length !== this.index) {
                   var restore = this.index;
                   this.index = start;
                   this.tolerateUnexpectedToken(messages_1.Messages.InvalidEscapedReservedWord);
                   this.index = restore;
                 }
                 return {
-                  type,
+                  type: type2,
                   value: id,
                   lineNumber: this.lineNumber,
                   lineStart: this.lineStart,
@@ -8437,13 +8458,13 @@ var require_parse = __commonJS({
       last = current;
       current = new_token;
     };
-    var type = () => {
+    var type2 = () => {
       if (!current) {
         unexpected_end();
       }
       return current.type === "Punctuator" ? current.value : current.type;
     };
-    var is = (t) => type() === t;
+    var is = (t) => type2() === t;
     var expect = (a) => {
       if (!is(a)) {
         unexpected();
@@ -8598,7 +8619,7 @@ var require_parse = __commonJS({
       return array;
     };
     function walk() {
-      let tt = type();
+      let tt = type2();
       if (tt === CURLY_BRACKET_OPEN) {
         next();
         return {
@@ -8614,7 +8635,7 @@ var require_parse = __commonJS({
       let negative = EMPTY;
       if (tt === MINUS) {
         next();
-        tt = type();
+        tt = type2();
         negative = MINUS;
       }
       let v;
@@ -8740,11 +8761,11 @@ var require_stringify = __commonJS({
       let is_line_comment = false;
       const str = comments.reduce((prev, {
         inline,
-        type,
+        type: type2,
         value
       }) => {
         const delimiter = inline ? SPACE : LF + deeper_gap;
-        is_line_comment = type === "LineComment";
+        is_line_comment = type2 === "LineComment";
         return prev + delimiter + comment_stringify(value, is_line_comment);
       }, EMPTY);
       return display_block || is_line_comment ? str + LF + deeper_gap : str;
@@ -8984,9 +9005,9 @@ function read() {
   }
   return c2;
 }
-function newToken(type, value) {
+function newToken(type2, value) {
   return {
-    type,
+    type: type2,
     value,
     line,
     column
@@ -10192,7 +10213,7 @@ var require_pend = __commonJS({
 // ../../node_modules/.pnpm/yauzl@3.2.0/node_modules/yauzl/fd-slicer.js
 var require_fd_slicer = __commonJS({
   "../../node_modules/.pnpm/yauzl@3.2.0/node_modules/yauzl/fd-slicer.js"(exports$1) {
-    var fs11 = __require("fs");
+    var fs13 = __require("fs");
     var util2 = __require("util");
     var stream = __require("stream");
     var Readable = stream.Readable;
@@ -10217,7 +10238,7 @@ var require_fd_slicer = __commonJS({
     FdSlicer.prototype.read = function(buffer2, offset, length, position, callback) {
       var self = this;
       self.pend.go(function(cb) {
-        fs11.read(self.fd, buffer2, offset, length, position, function(err, bytesRead, buffer3) {
+        fs13.read(self.fd, buffer2, offset, length, position, function(err, bytesRead, buffer3) {
           cb();
           callback(err, bytesRead, buffer3);
         });
@@ -10226,7 +10247,7 @@ var require_fd_slicer = __commonJS({
     FdSlicer.prototype.write = function(buffer2, offset, length, position, callback) {
       var self = this;
       self.pend.go(function(cb) {
-        fs11.write(self.fd, buffer2, offset, length, position, function(err, written, buffer3) {
+        fs13.write(self.fd, buffer2, offset, length, position, function(err, written, buffer3) {
           cb();
           callback(err, written, buffer3);
         });
@@ -10247,7 +10268,7 @@ var require_fd_slicer = __commonJS({
       if (self.refCount > 0) return;
       if (self.refCount < 0) throw new Error("invalid unref");
       if (self.autoClose) {
-        fs11.close(self.fd, onCloseDone);
+        fs13.close(self.fd, onCloseDone);
       }
       function onCloseDone(err) {
         if (err) {
@@ -10284,7 +10305,7 @@ var require_fd_slicer = __commonJS({
       self.context.pend.go(function(cb) {
         if (self.destroyed) return cb();
         var buffer2 = Buffer.allocUnsafe(toRead);
-        fs11.read(self.context.fd, buffer2, 0, toRead, self.pos, function(err, bytesRead) {
+        fs13.read(self.context.fd, buffer2, 0, toRead, self.pos, function(err, bytesRead) {
           if (err) {
             self.destroy(err);
           } else if (bytesRead === 0) {
@@ -10331,7 +10352,7 @@ var require_fd_slicer = __commonJS({
       }
       self.context.pend.go(function(cb) {
         if (self.destroyed) return cb();
-        fs11.write(self.context.fd, buffer2, 0, buffer2.length, self.pos, function(err2, bytes) {
+        fs13.write(self.context.fd, buffer2, 0, buffer2.length, self.pos, function(err2, bytes) {
           if (err2) {
             self.destroy();
             cb();
@@ -10769,7 +10790,7 @@ var require_buffer_crc32 = __commonJS({
 // ../../node_modules/.pnpm/yauzl@3.2.0/node_modules/yauzl/index.js
 var require_yauzl = __commonJS({
   "../../node_modules/.pnpm/yauzl@3.2.0/node_modules/yauzl/index.js"(exports$1) {
-    var fs11 = __require("fs");
+    var fs13 = __require("fs");
     var zlib = __require("zlib");
     var fd_slicer = require_fd_slicer();
     var crc32 = require_buffer_crc32();
@@ -10790,7 +10811,7 @@ var require_yauzl = __commonJS({
     exports$1.Entry = Entry;
     exports$1.LocalFileHeader = LocalFileHeader;
     exports$1.RandomAccessReader = RandomAccessReader;
-    function open2(path8, options2, callback) {
+    function open2(path9, options2, callback) {
       if (typeof options2 === "function") {
         callback = options2;
         options2 = null;
@@ -10802,10 +10823,10 @@ var require_yauzl = __commonJS({
       if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
       if (options2.strictFileNames == null) options2.strictFileNames = false;
       if (callback == null) callback = defaultCallback;
-      fs11.open(path8, "r", function(err, fd) {
+      fs13.open(path9, "r", function(err, fd) {
         if (err) return callback(err);
         fromFd(fd, options2, function(err2, zipfile) {
-          if (err2) fs11.close(fd, defaultCallback);
+          if (err2) fs13.close(fd, defaultCallback);
           callback(err2, zipfile);
         });
       });
@@ -10822,7 +10843,7 @@ var require_yauzl = __commonJS({
       if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
       if (options2.strictFileNames == null) options2.strictFileNames = false;
       if (callback == null) callback = defaultCallback;
-      fs11.fstat(fd, function(err, stats) {
+      fs13.fstat(fd, function(err, stats) {
         if (err) return callback(err);
         var reader = fd_slicer.createFromFd(fd, { autoClose: true });
         fromRandomAccessReader(reader, stats.size, options2, callback);
@@ -11534,7 +11555,7 @@ var init_fileUtils = __esm({
                         return reject(
                           new Error("Failed to open zip entry stream.")
                         );
-                      const writeStream = fs6.createWriteStream(outputPath);
+                      const writeStream = fs8.createWriteStream(outputPath);
                       readStream.on("error", reject);
                       writeStream.on("error", reject);
                       writeStream.on("close", () => {
@@ -11608,7 +11629,7 @@ var init_fileUtils = __esm({
         const destFile = path.join(destDir, file);
         if (!overwrite) {
           try {
-            await fs2.access(destFile, fs6.constants.F_OK);
+            await fs2.access(destFile, fs8.constants.F_OK);
             await fs2.rm(sourceFile, { recursive: true, force: true });
             continue;
           } catch {
@@ -11819,8 +11840,8 @@ var init_DaemonLogger = __esm({
       constructor(workspacePath) {
         this.logPath = path__namespace.join(workspacePath, CONFIG_DIR, LOG_FILE);
         const dir = path__namespace.dirname(this.logPath);
-        if (!fs6__namespace.existsSync(dir)) {
-          fs6__namespace.mkdirSync(dir, { recursive: true });
+        if (!fs8__namespace.existsSync(dir)) {
+          fs8__namespace.mkdirSync(dir, { recursive: true });
         }
       }
       getLogPath() {
@@ -11831,16 +11852,16 @@ var init_DaemonLogger = __esm({
         const line2 = `[${ts}] [${level.toUpperCase()}] ${message}
 `;
         this.rotateIfNeeded();
-        fs6__namespace.appendFileSync(this.logPath, line2, "utf-8");
+        fs8__namespace.appendFileSync(this.logPath, line2, "utf-8");
       }
       rotateIfNeeded() {
         try {
-          const stats = fs6__namespace.statSync(this.logPath);
+          const stats = fs8__namespace.statSync(this.logPath);
           if (stats.size > MAX_LOG_SIZE) {
-            const content = fs6__namespace.readFileSync(this.logPath, "utf-8");
+            const content = fs8__namespace.readFileSync(this.logPath, "utf-8");
             const halfIdx = content.indexOf("\n", Math.floor(content.length / 2));
             if (halfIdx > 0) {
-              fs6__namespace.writeFileSync(this.logPath, content.slice(halfIdx + 1), "utf-8");
+              fs8__namespace.writeFileSync(this.logPath, content.slice(halfIdx + 1), "utf-8");
             }
           }
         } catch {
@@ -11863,20 +11884,20 @@ var init_PidManager = __esm({
       }
       writePid(pid) {
         const dir = path__namespace.dirname(this.pidPath);
-        if (!fs6__namespace.existsSync(dir)) {
-          fs6__namespace.mkdirSync(dir, { recursive: true });
+        if (!fs8__namespace.existsSync(dir)) {
+          fs8__namespace.mkdirSync(dir, { recursive: true });
         }
-        fs6__namespace.writeFileSync(this.pidPath, String(pid), "utf-8");
+        fs8__namespace.writeFileSync(this.pidPath, String(pid), "utf-8");
       }
       readPid() {
-        if (!fs6__namespace.existsSync(this.pidPath)) return null;
-        const raw = fs6__namespace.readFileSync(this.pidPath, "utf-8").trim();
+        if (!fs8__namespace.existsSync(this.pidPath)) return null;
+        const raw = fs8__namespace.readFileSync(this.pidPath, "utf-8").trim();
         const pid = Number.parseInt(raw, 10);
         return Number.isNaN(pid) ? null : pid;
       }
       removePid() {
-        if (fs6__namespace.existsSync(this.pidPath)) {
-          fs6__namespace.unlinkSync(this.pidPath);
+        if (fs8__namespace.existsSync(this.pidPath)) {
+          fs8__namespace.unlinkSync(this.pidPath);
         }
       }
       isProcessRunning(pid) {
@@ -11897,12 +11918,76 @@ var init_PidManager = __esm({
     };
   }
 });
-var DEFAULT_TIMEOUT, MAX_OUTPUT_BYTES, GithubCopilotCliExecutor;
+
+// ../../packages/serviceme-core/src/scheduled-tasks/executors/timeout.ts
+function resolveConfiguredTimeoutMs(timeoutSeconds, defaultTimeoutMs) {
+  if (timeoutSeconds === 0) {
+    return void 0;
+  }
+  if (typeof timeoutSeconds !== "number" || !Number.isFinite(timeoutSeconds) || timeoutSeconds < 0) {
+    return defaultTimeoutMs;
+  }
+  return timeoutSeconds * 1e3;
+}
+var init_timeout = __esm({
+  "../../packages/serviceme-core/src/scheduled-tasks/executors/timeout.ts"() {
+  }
+});
+function redactArgs(args) {
+  const redacted = [];
+  let redactNext = false;
+  for (const arg of args) {
+    if (redactNext) {
+      redacted.push("<redacted>");
+      redactNext = false;
+      continue;
+    }
+    redacted.push(arg);
+    if (arg === "--prompt") {
+      redactNext = true;
+    }
+  }
+  return redacted;
+}
+function writeDiagnostic(message) {
+  const logPath = process.env.SERVICEME_SCHEDULER_LOG_PATH;
+  if (logPath) {
+    fs8__namespace.appendFileSync(logPath, message);
+    return;
+  }
+  process.stderr.write(message);
+}
+function resolveGithubCopilotCliExecution(payload) {
+  const args = ["copilot", "prompt", "--prompt", payload.prompt];
+  if (payload.autopilot) {
+    args.push("--autopilot");
+  }
+  if (payload.allowTools && payload.allowTools.length > 0) {
+    args.push("--allow-tools", payload.allowTools.join(","));
+  }
+  if (payload.model) {
+    args.push("--model", payload.model);
+  }
+  if (payload.agent) {
+    args.push("--agent", payload.agent);
+  }
+  args.push("--timeout", String(payload.timeout ?? 0));
+  return {
+    command: "serviceme",
+    args,
+    cwd: payload.workspace,
+    timeoutMs: resolveConfiguredTimeoutMs(payload.timeout, DEFAULT_TIMEOUT_MS2),
+    diagnosticArgs: redactArgs(args),
+    promptLen: payload.prompt.length
+  };
+}
+var MAX_OUTPUT_BYTES, DEFAULT_TIMEOUT_MS2, GithubCopilotCliExecutor;
 var init_GithubCopilotCliExecutor = __esm({
   "../../packages/serviceme-core/src/scheduled-tasks/executors/GithubCopilotCliExecutor.ts"() {
     init_doctor();
-    DEFAULT_TIMEOUT = 3e5;
+    init_timeout();
     MAX_OUTPUT_BYTES = 2 * 1024 * 1024;
+    DEFAULT_TIMEOUT_MS2 = 3e5;
     GithubCopilotCliExecutor = class {
       async execute(payload, abortSignal) {
         const authenticated = await isCopilotAuthenticated();
@@ -11925,7 +12010,7 @@ var init_GithubCopilotCliExecutor = __esm({
       }
       executeStreaming(payload, onOutput, abortSignal) {
         const p = payload;
-        const timeout = (p.timeout != null ? p.timeout * 1e3 : null) ?? DEFAULT_TIMEOUT;
+        const execution = resolveGithubCopilotCliExecution(p);
         let resolve;
         const resultPromise = new Promise((r) => {
           resolve = r;
@@ -11934,7 +12019,7 @@ var init_GithubCopilotCliExecutor = __esm({
         const settle = (result) => {
           if (settled) return;
           settled = true;
-          clearTimeout(timer);
+          if (timer) clearTimeout(timer);
           resolve?.(result);
         };
         if (abortSignal?.aborted) {
@@ -11947,36 +12032,32 @@ var init_GithubCopilotCliExecutor = __esm({
             }
           };
         }
-        const args = ["copilot", "prompt", "--prompt", p.prompt];
-        if (p.autopilot) {
-          args.push("--autopilot");
-        }
-        if (p.allowTools && p.allowTools.length > 0) {
-          args.push("--allow-tools", p.allowTools.join(","));
-        }
-        if (p.model) {
-          args.push("--model", p.model);
-        }
-        if (p.agent) {
-          args.push("--agent", p.agent);
-        }
-        if (p.timeout != null) {
-          args.push("--timeout", String(p.timeout));
-        }
-        const child = child_process.spawn("serviceme", args, {
-          cwd: p.workspace,
-          stdio: ["ignore", "pipe", "pipe"]
+        writeDiagnostic(
+          `[GithubCopilotCliExecutor] spawn: command=${execution.command}, args=${JSON.stringify(execution.diagnosticArgs)}, promptLen=${execution.promptLen}, cwd=${execution.cwd ?? "(default)"}, platform=${process.platform}, windowsHide=true, pid=${process.pid}
+`
+        );
+        const child = child_process.spawn(execution.command, execution.args, {
+          cwd: execution.cwd,
+          stdio: ["ignore", "pipe", "pipe"],
+          windowsHide: true
         });
-        const timer = setTimeout(() => {
+        if (child.pid) {
+          writeDiagnostic(
+            `[GithubCopilotCliExecutor] spawned child PID=${child.pid}
+`
+          );
+        }
+        const timeoutMs = execution.timeoutMs;
+        const timer = timeoutMs != null ? setTimeout(() => {
           child.kill("SIGTERM");
           setTimeout(() => {
             if (!child.killed) child.kill("SIGKILL");
           }, 5e3);
           settle({
             status: "timeout",
-            error: `Copilot CLI execution timed out after ${timeout / 1e3}s`
+            error: `Copilot CLI execution timed out after ${timeoutMs / 1e3}s`
           });
-        }, timeout);
+        }, timeoutMs) : void 0;
         let stdoutBuf = "";
         let stderrBuf = "";
         child.stdout.on("data", (chunk) => {
@@ -12022,20 +12103,23 @@ var init_GithubCopilotCliExecutor = __esm({
 });
 
 // ../../packages/serviceme-core/src/scheduled-tasks/executors/HttpRequestExecutor.ts
-var DEFAULT_TIMEOUT2, HttpRequestExecutor;
+var DEFAULT_TIMEOUT_MS3, HttpRequestExecutor;
 var init_HttpRequestExecutor = __esm({
   "../../packages/serviceme-core/src/scheduled-tasks/executors/HttpRequestExecutor.ts"() {
-    DEFAULT_TIMEOUT2 = 3e4;
+    init_timeout();
+    DEFAULT_TIMEOUT_MS3 = 3e4;
     HttpRequestExecutor = class {
       async execute(payload, abortSignal) {
         const p = payload;
-        const timeout = (p.timeout != null ? p.timeout * 1e3 : null) ?? DEFAULT_TIMEOUT2;
+        const timeoutMs = resolveConfiguredTimeoutMs(p.timeout, DEFAULT_TIMEOUT_MS3);
         const ac = new AbortController();
-        const timer = setTimeout(() => {
+        let timedOut = false;
+        const timer = timeoutMs != null ? setTimeout(() => {
+          timedOut = true;
           ac.abort();
-        }, timeout);
+        }, timeoutMs) : void 0;
         if (abortSignal?.aborted) {
-          clearTimeout(timer);
+          if (timer) clearTimeout(timer);
           return { status: "cancelled", error: "Execution aborted" };
         }
         let externalAbort = false;
@@ -12043,7 +12127,7 @@ var init_HttpRequestExecutor = __esm({
           "abort",
           () => {
             externalAbort = true;
-            clearTimeout(timer);
+            if (timer) clearTimeout(timer);
             ac.abort();
           },
           { once: true }
@@ -12055,7 +12139,7 @@ var init_HttpRequestExecutor = __esm({
             body: p.body,
             signal: ac.signal
           });
-          clearTimeout(timer);
+          if (timer) clearTimeout(timer);
           const body = await response.text();
           if (response.ok) {
             return {
@@ -12070,14 +12154,17 @@ ${body}`.trim()
 ${body}`.trim()
           };
         } catch (err) {
-          clearTimeout(timer);
+          if (timer) clearTimeout(timer);
           if (err instanceof Error && err.name === "AbortError") {
             if (externalAbort) {
               return { status: "cancelled", error: "Execution cancelled" };
             }
+            if (!timedOut || timeoutMs == null) {
+              return { status: "failure", error: err.message };
+            }
             return {
               status: "timeout",
-              error: `HTTP request timed out after ${timeout / 1e3}s`
+              error: `HTTP request timed out after ${timeoutMs / 1e3}s`
             };
           }
           const message = err instanceof Error ? err.message : String(err);
@@ -12087,11 +12174,84 @@ ${body}`.trim()
     };
   }
 });
-var DEFAULT_TIMEOUT3, MAX_OUTPUT_BYTES2, ShellExecutor;
+function resolveShellExecution(script, options2 = {}) {
+  const platform = options2.platform ?? process.platform;
+  const env = options2.env ?? process.env;
+  const fileExists = options2.fileExists ?? fs8__namespace.existsSync;
+  if (platform === "win32") {
+    const posixShell = usesPosixShellSyntax(script) ? findWindowsPosixShell(env, fileExists) : null;
+    if (posixShell) {
+      return {
+        command: posixShell,
+        args: ["-s"],
+        stdinScript: script,
+        outputEncoding: "utf8",
+        shellKind: "posix"
+      };
+    }
+    return {
+      command: env.ComSpec ?? env.COMSPEC ?? "cmd.exe",
+      args: ["/d", "/s", "/c", script],
+      outputEncoding: "utf8",
+      shellKind: "cmd"
+    };
+  }
+  return {
+    command: "sh",
+    args: ["-s"],
+    stdinScript: script,
+    outputEncoding: "utf8",
+    shellKind: "posix"
+  };
+}
+function usesPosixShellSyntax(script) {
+  return /\$\([^)]*\)|`[^`]*`/.test(script);
+}
+function findWindowsPosixShell(env, fileExists) {
+  const explicitShell = env.SERVICEME_POSIX_SHELL;
+  if (explicitShell && fileExists(explicitShell)) {
+    return explicitShell;
+  }
+  const knownGitBashPaths = [
+    "C:\\Program Files\\Git\\bin\\bash.exe",
+    "C:\\Program Files\\Git\\usr\\bin\\bash.exe",
+    "C:\\Program Files (x86)\\Git\\bin\\bash.exe",
+    "C:\\Program Files (x86)\\Git\\usr\\bin\\bash.exe"
+  ];
+  for (const candidate of knownGitBashPaths) {
+    if (fileExists(candidate)) return candidate;
+  }
+  const pathValue = env.Path ?? env.PATH ?? "";
+  for (const dir of pathValue.split(path__namespace.win32.delimiter)) {
+    if (!dir) continue;
+    for (const executable of POSIX_SHELL_CANDIDATES) {
+      const candidate = path__namespace.win32.join(dir, executable);
+      if (fileExists(candidate) && !isWindowsWslLauncher(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  return null;
+}
+function isWindowsWslLauncher(candidate) {
+  const normalized = path__namespace.win32.normalize(candidate).toLowerCase();
+  return normalized.endsWith("\\windows\\system32\\bash.exe") || normalized.endsWith("\\windows\\syswow64\\bash.exe");
+}
+function writeDiagnostic2(message) {
+  const logPath = process.env.SERVICEME_SCHEDULER_LOG_PATH;
+  if (logPath) {
+    fs8__namespace.appendFileSync(logPath, message);
+    return;
+  }
+  process.stderr.write(message);
+}
+var MAX_OUTPUT_BYTES2, DEFAULT_TIMEOUT_MS4, POSIX_SHELL_CANDIDATES, ShellExecutor;
 var init_ShellExecutor = __esm({
   "../../packages/serviceme-core/src/scheduled-tasks/executors/ShellExecutor.ts"() {
-    DEFAULT_TIMEOUT3 = 6e4;
+    init_timeout();
     MAX_OUTPUT_BYTES2 = 1024 * 1024;
+    DEFAULT_TIMEOUT_MS4 = 6e4;
+    POSIX_SHELL_CANDIDATES = ["bash.exe", "sh.exe"];
     ShellExecutor = class {
       async execute(payload, abortSignal) {
         let output = "";
@@ -12107,7 +12267,7 @@ var init_ShellExecutor = __esm({
       }
       executeStreaming(payload, onOutput, abortSignal) {
         const p = payload;
-        const timeout = (p.timeout != null ? p.timeout * 1e3 : null) ?? DEFAULT_TIMEOUT3;
+        const timeoutMs = resolveConfiguredTimeoutMs(p.timeout, DEFAULT_TIMEOUT_MS4);
         let resolve;
         const resultPromise = new Promise((r) => {
           resolve = r;
@@ -12116,7 +12276,7 @@ var init_ShellExecutor = __esm({
         const settle = (result) => {
           if (settled) return;
           settled = true;
-          clearTimeout(timer);
+          if (timer) clearTimeout(timer);
           resolve?.(result);
         };
         if (abortSignal?.aborted) {
@@ -12129,37 +12289,65 @@ var init_ShellExecutor = __esm({
             }
           };
         }
-        const child = child_process.spawn("sh", ["-c", p.script], {
+        const shellExecution = resolveShellExecution(p.script);
+        const spawnOpts = {
           cwd: p.cwd,
-          stdio: ["ignore", "pipe", "pipe"]
-        });
-        const timer = setTimeout(() => {
+          stdio: [shellExecution.stdinScript ? "pipe" : "ignore", "pipe", "pipe"],
+          windowsHide: true
+        };
+        writeDiagnostic2(
+          `[ShellExecutor] spawn:
+  platform=${process.platform}
+  shell=${shellExecution.shellKind}
+  command=${shellExecution.command}
+  args=${JSON.stringify(shellExecution.args.filter((a) => a !== p.script))}
+  stdin=${shellExecution.stdinScript ? "true" : "false"}
+  cwd=${p.cwd ?? "(default)"}
+  timeout=${timeoutMs != null ? `${timeoutMs}ms` : "unlimited"}
+  scriptLen=${p.script.length}
+  windowsHide=true
+  daemonPid=${process.pid}
+`
+        );
+        const child = child_process.spawn(shellExecution.command, shellExecution.args, spawnOpts);
+        if (shellExecution.stdinScript && child.stdin) {
+          child.stdin.end(shellExecution.stdinScript);
+        }
+        if (child.pid) {
+          writeDiagnostic2(`[ShellExecutor] spawned child PID=${child.pid}
+`);
+        }
+        const timer = timeoutMs != null ? setTimeout(() => {
           child.kill("SIGTERM");
           setTimeout(() => {
             if (!child.killed) child.kill("SIGKILL");
           }, 5e3);
           settle({
             status: "timeout",
-            error: `Shell execution timed out after ${timeout / 1e3}s`
+            error: `Shell execution timed out after ${timeoutMs / 1e3}s`
           });
-        }, timeout);
+        }, timeoutMs) : void 0;
         let stdoutBuf = "";
         let stderrBuf = "";
-        child.stdout.on("data", (chunk) => {
-          const data = chunk.toString();
+        child.stdout?.on("data", (chunk) => {
+          const data = chunk.toString(shellExecution.outputEncoding);
           stdoutBuf += data;
           if (stdoutBuf.length > MAX_OUTPUT_BYTES2)
             stdoutBuf = stdoutBuf.slice(-MAX_OUTPUT_BYTES2);
           onOutput("stdout", data);
         });
-        child.stderr.on("data", (chunk) => {
-          const data = chunk.toString();
+        child.stderr?.on("data", (chunk) => {
+          const data = chunk.toString(shellExecution.outputEncoding);
           stderrBuf += data;
           if (stderrBuf.length > MAX_OUTPUT_BYTES2)
             stderrBuf = stderrBuf.slice(-MAX_OUTPUT_BYTES2);
           onOutput("stderr", data);
         });
         child.on("close", (code) => {
+          writeDiagnostic2(
+            `[ShellExecutor] child PID=${child.pid} exited: code=${code}
+`
+          );
           if (code === 0) {
             settle({ status: "success", output: stdoutBuf || void 0 });
           } else {
@@ -12221,9 +12409,38 @@ var init_executors = __esm({
 function emptyConfig() {
   return { version: 1, tasks: [] };
 }
+function isRecord3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function requireNonEmptyString(payload, field, taskType) {
+  if (!isRecord3(payload) || typeof payload[field] !== "string" || !payload[field].trim()) {
+    throw createServicemeError(
+      "invalid_payload",
+      `${taskType} payload ${field} is required`
+    );
+  }
+}
+function validateTaskPayload(taskType, payload) {
+  switch (taskType) {
+    case "command":
+      requireNonEmptyString(payload, "command", taskType);
+      return;
+    case "shell":
+      requireNonEmptyString(payload, "script", taskType);
+      return;
+    case "http_request":
+      requireNonEmptyString(payload, "url", taskType);
+      requireNonEmptyString(payload, "method", taskType);
+      return;
+    case "github_copilot_cli":
+      requireNonEmptyString(payload, "prompt", taskType);
+      return;
+  }
+}
 var CONFIG_DIR3, CONFIG_FILE, TaskConfigManager;
 var init_TaskConfigManager = __esm({
   "../../packages/serviceme-core/src/scheduled-tasks/TaskConfigManager.ts"() {
+    init_src();
     CONFIG_DIR3 = ".serviceme";
     CONFIG_FILE = "scheduled-tasks.json";
     TaskConfigManager = class {
@@ -12234,21 +12451,21 @@ var init_TaskConfigManager = __esm({
         return this.configPath;
       }
       readConfig() {
-        if (!fs6__namespace.existsSync(this.configPath)) {
+        if (!fs8__namespace.existsSync(this.configPath)) {
           return emptyConfig();
         }
-        const raw = fs6__namespace.readFileSync(this.configPath, "utf-8");
+        const raw = fs8__namespace.readFileSync(this.configPath, "utf-8");
         const parsed = JSON.parse(raw);
         return parsed;
       }
       writeConfig(config) {
         const dir = path__namespace.dirname(this.configPath);
-        if (!fs6__namespace.existsSync(dir)) {
-          fs6__namespace.mkdirSync(dir, { recursive: true });
+        if (!fs8__namespace.existsSync(dir)) {
+          fs8__namespace.mkdirSync(dir, { recursive: true });
         }
         const tmp = `${this.configPath}.tmp`;
-        fs6__namespace.writeFileSync(tmp, JSON.stringify(config, null, "	"), "utf-8");
-        fs6__namespace.renameSync(tmp, this.configPath);
+        fs8__namespace.writeFileSync(tmp, JSON.stringify(config, null, "	"), "utf-8");
+        fs8__namespace.renameSync(tmp, this.configPath);
       }
       listTasks() {
         return this.readConfig().tasks;
@@ -12260,6 +12477,7 @@ var init_TaskConfigManager = __esm({
         return this.readConfig().tasks.find((t) => t.name === name);
       }
       createTask(input) {
+        validateTaskPayload(input.taskType, input.payload);
         const config = this.readConfig();
         const now = (/* @__PURE__ */ new Date()).toISOString();
         const task = {
@@ -12288,6 +12506,9 @@ var init_TaskConfigManager = __esm({
         if (!existing) {
           throw new Error(`Task '${id}' not found`);
         }
+        const nextTaskType = input.taskType ?? existing.taskType;
+        const nextPayload = input.payload ?? existing.payload;
+        validateTaskPayload(nextTaskType, nextPayload);
         const updated = {
           ...existing,
           ...input.name !== void 0 && { name: input.name },
@@ -12327,6 +12548,200 @@ var init_TaskConfigManager = __esm({
     };
   }
 });
+
+// ../../packages/serviceme-core/src/scheduled-tasks/TaskExecutionEngine.ts
+function hasNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function resolveTaskExecutionPayload(taskType, payload, workspacePath) {
+  if (!hasNonEmptyString(workspacePath)) {
+    return payload;
+  }
+  if (taskType === "shell") {
+    const shellPayload = payload;
+    if (hasNonEmptyString(shellPayload.cwd)) {
+      return shellPayload;
+    }
+    return { ...shellPayload, cwd: workspacePath };
+  }
+  if (taskType === "github_copilot_cli") {
+    const copilotPayload = payload;
+    if (hasNonEmptyString(copilotPayload.workspace)) {
+      return copilotPayload;
+    }
+    return { ...copilotPayload, workspace: workspacePath };
+  }
+  return payload;
+}
+var TaskExecutionEngine;
+var init_TaskExecutionEngine = __esm({
+  "../../packages/serviceme-core/src/scheduled-tasks/TaskExecutionEngine.ts"() {
+    init_types();
+    init_TaskConfigManager();
+    TaskExecutionEngine = class {
+      constructor(getExecutor2) {
+        this.getExecutor = getExecutor2;
+        this.running = /* @__PURE__ */ new Map();
+        this.taskExecutions = /* @__PURE__ */ new Map();
+        this.listener = null;
+      }
+      setListener(listener) {
+        this.listener = listener;
+      }
+      async execute(snapshot) {
+        const policy = snapshot.concurrencyPolicy ?? "reject";
+        if (policy === "reject") {
+          const existingIds = this.taskExecutions.get(snapshot.taskId);
+          if (existingIds && existingIds.size > 0) {
+            throw new Error(
+              `TASK_ALREADY_RUNNING: Task ${snapshot.taskId} is already running`
+            );
+          }
+        }
+        const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+        if (!this.taskExecutions.has(snapshot.taskId)) {
+          this.taskExecutions.set(snapshot.taskId, /* @__PURE__ */ new Set());
+        }
+        this.taskExecutions.get(snapshot.taskId)?.add(snapshot.executionId);
+        const ac = new AbortController();
+        const runningExec = {
+          executionId: snapshot.executionId,
+          taskId: snapshot.taskId,
+          startedAt,
+          cancel: () => ac.abort()
+        };
+        this.running.set(snapshot.executionId, runningExec);
+        this.listener?.onStarted({
+          executionId: snapshot.executionId,
+          taskId: snapshot.taskId,
+          startedAt
+        });
+        try {
+          const executionPayload = resolveTaskExecutionPayload(
+            snapshot.type,
+            snapshot.payload,
+            snapshot.workspacePath
+          );
+          validateTaskPayload(snapshot.type, executionPayload);
+          const executor = this.getExecutor(snapshot.type);
+          let result;
+          if (isStreamingTaskExecutor(executor)) {
+            const handle = executor.executeStreaming(
+              executionPayload,
+              (stream, data) => {
+                this.listener?.onOutput({
+                  executionId: snapshot.executionId,
+                  stream,
+                  data
+                });
+              },
+              ac.signal
+            );
+            runningExec.cancel = () => {
+              handle.cancel();
+              ac.abort();
+            };
+            result = await handle.result;
+          } else {
+            result = await executor.execute(executionPayload, ac.signal);
+          }
+          const log = {
+            id: snapshot.executionId,
+            taskId: snapshot.taskId,
+            taskName: snapshot.name,
+            startedAt,
+            finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            status: result.status === "running" ? "failure" : result.status,
+            output: result.output,
+            error: result.error
+          };
+          switch (log.status) {
+            case "success":
+              this.listener?.onCompleted({
+                executionId: snapshot.executionId,
+                log
+              });
+              break;
+            case "cancelled":
+              this.listener?.onCancelled({
+                executionId: snapshot.executionId,
+                log
+              });
+              break;
+            case "timeout":
+              this.listener?.onFailed({
+                executionId: snapshot.executionId,
+                status: "timeout",
+                reason: "timeout",
+                log
+              });
+              break;
+            default:
+              this.listener?.onFailed({
+                executionId: snapshot.executionId,
+                status: "failure",
+                reason: "error",
+                log
+              });
+              break;
+          }
+        } catch (err) {
+          const log = {
+            id: snapshot.executionId,
+            taskId: snapshot.taskId,
+            taskName: snapshot.name,
+            startedAt,
+            finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            status: ac.signal.aborted ? "cancelled" : "failure",
+            error: err instanceof Error ? err.message : String(err)
+          };
+          if (ac.signal.aborted) {
+            this.listener?.onCancelled({
+              executionId: snapshot.executionId,
+              log
+            });
+          } else {
+            this.listener?.onFailed({
+              executionId: snapshot.executionId,
+              status: "failure",
+              reason: "error",
+              log
+            });
+          }
+        } finally {
+          this.running.delete(snapshot.executionId);
+          const taskExecIds = this.taskExecutions.get(snapshot.taskId);
+          if (taskExecIds) {
+            taskExecIds.delete(snapshot.executionId);
+            if (taskExecIds.size === 0) {
+              this.taskExecutions.delete(snapshot.taskId);
+            }
+          }
+        }
+      }
+      cancel(executionId) {
+        const exec = this.running.get(executionId);
+        if (!exec) return false;
+        exec.cancel();
+        return true;
+      }
+      listRunning() {
+        return Array.from(this.running.values()).map((e) => ({
+          executionId: e.executionId,
+          taskId: e.taskId,
+          startedAt: e.startedAt
+        }));
+      }
+      dispose() {
+        for (const exec of this.running.values()) {
+          exec.cancel();
+        }
+        this.running.clear();
+        this.taskExecutions.clear();
+      }
+    };
+  }
+});
 function emptyLogFile() {
   return { logs: [] };
 }
@@ -12360,11 +12775,11 @@ var init_TaskLogManager = __esm({
         return this.logPath;
       }
       readLogFile() {
-        if (!fs6__namespace.existsSync(this.logPath)) {
+        if (!fs8__namespace.existsSync(this.logPath)) {
           return emptyLogFile();
         }
         try {
-          const raw = fs6__namespace.readFileSync(this.logPath, "utf-8");
+          const raw = fs8__namespace.readFileSync(this.logPath, "utf-8");
           const parsed = JSON.parse(raw);
           const file = validateAndRepairLogFile(parsed);
           if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.logs) || parsed.logs.length !== file.logs.length) {
@@ -12380,21 +12795,21 @@ var init_TaskLogManager = __esm({
       }
       backupCorruptedFile() {
         try {
-          if (fs6__namespace.existsSync(this.logPath)) {
+          if (fs8__namespace.existsSync(this.logPath)) {
             const backupPath = `${this.logPath}.corrupted.${Date.now()}`;
-            fs6__namespace.copyFileSync(this.logPath, backupPath);
+            fs8__namespace.copyFileSync(this.logPath, backupPath);
           }
         } catch {
         }
       }
       writeLogFile(file) {
         const dir = path__namespace.dirname(this.logPath);
-        if (!fs6__namespace.existsSync(dir)) {
-          fs6__namespace.mkdirSync(dir, { recursive: true });
+        if (!fs8__namespace.existsSync(dir)) {
+          fs8__namespace.mkdirSync(dir, { recursive: true });
         }
         const tmp = `${this.logPath}.tmp`;
-        fs6__namespace.writeFileSync(tmp, JSON.stringify(file, null, "	"), "utf-8");
-        fs6__namespace.renameSync(tmp, this.logPath);
+        fs8__namespace.writeFileSync(tmp, JSON.stringify(file, null, "	"), "utf-8");
+        fs8__namespace.renameSync(tmp, this.logPath);
       }
       appendLog(input) {
         const file = this.readLogFile();
@@ -12486,6 +12901,7 @@ var init_SchedulerDaemon = __esm({
   "../../packages/serviceme-core/src/scheduled-tasks/daemon/SchedulerDaemon.ts"() {
     init_executors();
     init_TaskConfigManager();
+    init_TaskExecutionEngine();
     init_TaskLogManager();
     init_DaemonLogger();
     init_PidManager();
@@ -12511,7 +12927,23 @@ var init_SchedulerDaemon = __esm({
         this.running = true;
         this.startTime = Date.now();
         this.pidManager.writePid(process.pid);
-        this.logger.log("info", `Scheduler daemon started (PID: ${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:        ${os__namespace.type()} ${os__namespace.release()} (${process.arch})
+  Platform:  ${process.platform}
+  Hostname:  ${os__namespace.hostname()}
+  User:      ${os__namespace.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());
@@ -12536,8 +12968,8 @@ var init_SchedulerDaemon = __esm({
         const configPath = this.configManager.getConfigPath();
         const dir = configPath.substring(0, configPath.lastIndexOf("/"));
         try {
-          if (fs6__namespace.existsSync(dir)) {
-            this.watcher = fs6__namespace.watch(dir, (_eventType, filename) => {
+          if (fs8__namespace.existsSync(dir)) {
+            this.watcher = fs8__namespace.watch(dir, (_eventType, filename) => {
               if (filename === "scheduled-tasks.json") {
                 this.logger.log("info", "Config file changed, reconciling...");
               }
@@ -12553,7 +12985,11 @@ var init_SchedulerDaemon = __esm({
         for (const task of config.tasks) {
           if (!task.enabled) continue;
           if (this.taskRunning.has(task.id)) continue;
-          const lastExec = this.lastRun.get(task.id) ?? 0;
+          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);
           }
@@ -12575,11 +13011,25 @@ var init_SchedulerDaemon = __esm({
         this.taskRunning.add(task.id);
         this.lastRun.set(task.id, now);
         const startedAt = new Date(now).toISOString();
-        this.logger.log("info", `Executing task: ${task.name} (${task.id})`);
+        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 = getExecutor(task.taskType);
-          const result = await executor.execute(task.payload);
+          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,
@@ -12589,9 +13039,17 @@ var init_SchedulerDaemon = __esm({
             output: result.output,
             error: result.error
           });
-          this.logger.log("info", `Task ${task.name} completed: ${result.status}`);
+          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,
@@ -12601,7 +13059,12 @@ var init_SchedulerDaemon = __esm({
             status: "failure",
             error: message
           });
-          this.logger.log("error", `Task ${task.name} failed: ${message}`);
+          this.logger.log(
+            "error",
+            `Task failed: ${task.name} (${task.id})
+  duration: ${durationMs}ms
+  error:    ${message}`
+          );
         } finally {
           this.taskRunning.delete(task.id);
         }
@@ -12631,170 +13094,6 @@ var init_daemon = __esm({
   }
 });
 
-// ../../packages/serviceme-core/src/scheduled-tasks/TaskExecutionEngine.ts
-var TaskExecutionEngine;
-var init_TaskExecutionEngine = __esm({
-  "../../packages/serviceme-core/src/scheduled-tasks/TaskExecutionEngine.ts"() {
-    init_types();
-    TaskExecutionEngine = class {
-      constructor(getExecutor2) {
-        this.getExecutor = getExecutor2;
-        this.running = /* @__PURE__ */ new Map();
-        this.taskExecutions = /* @__PURE__ */ new Map();
-        this.listener = null;
-      }
-      setListener(listener) {
-        this.listener = listener;
-      }
-      async execute(snapshot) {
-        const policy = snapshot.concurrencyPolicy ?? "reject";
-        if (policy === "reject") {
-          const existingIds = this.taskExecutions.get(snapshot.taskId);
-          if (existingIds && existingIds.size > 0) {
-            throw new Error(
-              `TASK_ALREADY_RUNNING: Task ${snapshot.taskId} is already running`
-            );
-          }
-        }
-        const executor = this.getExecutor(snapshot.type);
-        const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-        if (!this.taskExecutions.has(snapshot.taskId)) {
-          this.taskExecutions.set(snapshot.taskId, /* @__PURE__ */ new Set());
-        }
-        this.taskExecutions.get(snapshot.taskId)?.add(snapshot.executionId);
-        const ac = new AbortController();
-        const runningExec = {
-          executionId: snapshot.executionId,
-          taskId: snapshot.taskId,
-          startedAt,
-          cancel: () => ac.abort()
-        };
-        this.running.set(snapshot.executionId, runningExec);
-        this.listener?.onStarted({
-          executionId: snapshot.executionId,
-          taskId: snapshot.taskId,
-          startedAt
-        });
-        try {
-          let result;
-          if (isStreamingTaskExecutor(executor)) {
-            const handle = executor.executeStreaming(
-              snapshot.payload,
-              (stream, data) => {
-                this.listener?.onOutput({
-                  executionId: snapshot.executionId,
-                  stream,
-                  data
-                });
-              },
-              ac.signal
-            );
-            runningExec.cancel = () => {
-              handle.cancel();
-              ac.abort();
-            };
-            result = await handle.result;
-          } else {
-            result = await executor.execute(snapshot.payload, ac.signal);
-          }
-          const log = {
-            id: snapshot.executionId,
-            taskId: snapshot.taskId,
-            taskName: snapshot.name,
-            startedAt,
-            finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
-            status: result.status === "running" ? "failure" : result.status,
-            output: result.output,
-            error: result.error
-          };
-          switch (log.status) {
-            case "success":
-              this.listener?.onCompleted({
-                executionId: snapshot.executionId,
-                log
-              });
-              break;
-            case "cancelled":
-              this.listener?.onCancelled({
-                executionId: snapshot.executionId,
-                log
-              });
-              break;
-            case "timeout":
-              this.listener?.onFailed({
-                executionId: snapshot.executionId,
-                status: "timeout",
-                reason: "timeout",
-                log
-              });
-              break;
-            default:
-              this.listener?.onFailed({
-                executionId: snapshot.executionId,
-                status: "failure",
-                reason: "error",
-                log
-              });
-              break;
-          }
-        } catch (err) {
-          const log = {
-            id: snapshot.executionId,
-            taskId: snapshot.taskId,
-            taskName: snapshot.name,
-            startedAt,
-            finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
-            status: ac.signal.aborted ? "cancelled" : "failure",
-            error: err instanceof Error ? err.message : String(err)
-          };
-          if (ac.signal.aborted) {
-            this.listener?.onCancelled({
-              executionId: snapshot.executionId,
-              log
-            });
-          } else {
-            this.listener?.onFailed({
-              executionId: snapshot.executionId,
-              status: "failure",
-              reason: "error",
-              log
-            });
-          }
-        } finally {
-          this.running.delete(snapshot.executionId);
-          const taskExecIds = this.taskExecutions.get(snapshot.taskId);
-          if (taskExecIds) {
-            taskExecIds.delete(snapshot.executionId);
-            if (taskExecIds.size === 0) {
-              this.taskExecutions.delete(snapshot.taskId);
-            }
-          }
-        }
-      }
-      cancel(executionId) {
-        const exec = this.running.get(executionId);
-        if (!exec) return false;
-        exec.cancel();
-        return true;
-      }
-      listRunning() {
-        return Array.from(this.running.values()).map((e) => ({
-          executionId: e.executionId,
-          taskId: e.taskId,
-          startedAt: e.startedAt
-        }));
-      }
-      dispose() {
-        for (const exec of this.running.values()) {
-          exec.cancel();
-        }
-        this.running.clear();
-        this.taskExecutions.clear();
-      }
-    };
-  }
-});
-
 // ../../packages/serviceme-core/src/scheduled-tasks/index.ts
 var init_scheduled_tasks2 = __esm({
   "../../packages/serviceme-core/src/scheduled-tasks/index.ts"() {
@@ -12836,7 +13135,9 @@ __export(src_exports, {
   moveFiles: () => moveFiles,
   noopLogger: () => noopLogger,
   parseIntervalMs: () => parseIntervalMs,
-  unzipFile: () => unzipFile
+  resolveTaskExecutionPayload: () => resolveTaskExecutionPayload,
+  unzipFile: () => unzipFile,
+  validateTaskPayload: () => validateTaskPayload
 });
 var init_src2 = __esm({
   "../../packages/serviceme-core/src/index.ts"() {
@@ -12905,7 +13206,7 @@ init_src();
 
 // src/version.ts
 var SERVICEME_CLI_NAME = "serviceme";
-var SERVICEME_CLI_VERSION = "0.1.3";
+var SERVICEME_CLI_VERSION = "0.1.5";
 
 // src/bridge/ndjson.ts
 function writeBridgeMessage(message) {
@@ -13432,7 +13733,7 @@ function requireWorkspace(parsed) {
       "Missing required flag: --workspacePath"
     );
   }
-  if (!fs6__namespace.existsSync(wp)) {
+  if (!fs8__namespace.existsSync(wp)) {
     throw createServicemeError(
       "workspace_not_found",
       `Workspace path does not exist: ${wp}`
@@ -13765,8 +14066,14 @@ async function handleTrigger(parsed) {
     );
   }
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const executionPayload = resolveTaskExecutionPayload(
+    task.taskType,
+    task.payload,
+    wp
+  );
+  validateTaskPayload(task.taskType, executionPayload);
   const executor = getExecutor(task.taskType);
-  const result = await executor.execute(task.payload);
+  const result = await executor.execute(executionPayload);
   const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
   const logMgr = new TaskLogManager(wp);
   const log = logMgr.appendLog({
@@ -13995,7 +14302,7 @@ function requireWorkspace2(parsed) {
       "Missing required flag: --workspacePath"
     );
   }
-  if (!fs6__namespace.existsSync(wp)) {
+  if (!fs8__namespace.existsSync(wp)) {
     throw createServicemeError(
       "workspace_not_found",
       `Workspace path does not exist: ${wp}`
@@ -14024,20 +14331,43 @@ function handleStart(parsed) {
   }
   const logPath = path__namespace.join(wp, ".serviceme", "scheduler.log");
   const logDir = path__namespace.dirname(logPath);
-  if (!fs6__namespace.existsSync(logDir)) {
-    fs6__namespace.mkdirSync(logDir, { recursive: true });
-  }
-  const out = fs6__namespace.openSync(logPath, "a");
-  const err = fs6__namespace.openSync(logPath, "a");
-  const child = child_process.spawn(
-    process.execPath,
-    [cliPath, "scheduler", "__daemon", "--workspacePath", wp],
-    {
-      detached: true,
-      stdio: ["ignore", out, err],
-      env: { ...process.env }
-    }
+  if (!fs8__namespace.existsSync(logDir)) {
+    fs8__namespace.mkdirSync(logDir, { recursive: true });
+  }
+  const spawnCmd = process.execPath;
+  const spawnArgs = [
+    cliPath,
+    "scheduler",
+    "__daemon",
+    "--workspacePath",
+    wp,
+    "--logPath",
+    logPath
+  ];
+  if (process.platform === "win32") {
+    fs8__namespace.appendFileSync(
+      logPath,
+      `[scheduler:start] spawning daemon via hidden PowerShell Start-Process: cmd=${spawnCmd}, args=${JSON.stringify(spawnArgs)}, platform=${process.platform}, windowsHide=true
+`
+    );
+    const pid2 = startWindowsDaemon(spawnCmd, spawnArgs);
+    pidMgr.writePid(pid2);
+    writeSuccess({ pid: pid2, status: "started", workspacePath: wp });
+    return;
+  }
+  const out = fs8__namespace.openSync(logPath, "a");
+  const err = fs8__namespace.openSync(logPath, "a");
+  fs8__namespace.appendFileSync(
+    logPath,
+    `[scheduler:start] spawning daemon: cmd=${spawnCmd}, args=${JSON.stringify(spawnArgs)}, platform=${process.platform}, detached=true, windowsHide=true
+`
   );
+  const child = child_process.spawn(spawnCmd, spawnArgs, {
+    detached: true,
+    stdio: ["ignore", out, err],
+    env: { ...process.env },
+    windowsHide: true
+  });
   child.unref();
   const pid = child.pid;
   if (pid === void 0) {
@@ -14049,6 +14379,60 @@ function handleStart(parsed) {
   pidMgr.writePid(pid);
   writeSuccess({ pid, status: "started", workspacePath: wp });
 }
+function startWindowsDaemon(command, args) {
+  const argumentLine = args.map(quoteWindowsArgument).join(" ");
+  const script = [
+    "$ErrorActionPreference = 'Stop'",
+    `$process = Start-Process -FilePath ${quotePowerShellString(command)} -ArgumentList ${quotePowerShellString(argumentLine)} -WindowStyle Hidden -PassThru`,
+    "Write-Output $process.Id"
+  ].join("; ");
+  const encodedCommand = Buffer.from(script, "utf16le").toString("base64");
+  const result = child_process.spawnSync(
+    "powershell.exe",
+    [
+      "-NoProfile",
+      "-NonInteractive",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-WindowStyle",
+      "Hidden",
+      "-EncodedCommand",
+      encodedCommand
+    ],
+    {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    }
+  );
+  if (result.error) {
+    throw createServicemeError(
+      "internal_error",
+      `Failed to start scheduler daemon: ${result.error.message}`
+    );
+  }
+  if (result.status !== 0) {
+    const stderr = result.stderr.trim();
+    throw createServicemeError(
+      "internal_error",
+      `Failed to start scheduler daemon${stderr ? `: ${stderr}` : ""}`
+    );
+  }
+  const pid = Number.parseInt(result.stdout.trim(), 10);
+  if (!Number.isFinite(pid)) {
+    throw createServicemeError(
+      "internal_error",
+      `Failed to parse scheduler daemon PID: ${result.stdout.trim()}`
+    );
+  }
+  return pid;
+}
+function quotePowerShellString(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+function quoteWindowsArgument(value) {
+  return `"${value.replace(/(\\*)"/g, '$1$1\\"').replace(/\\+$/g, "$&$&")}"`;
+}
 function handleStop(parsed) {
   const wp = requireWorkspace2(parsed);
   if (!getBooleanFlag(parsed, "yes")) {
@@ -14084,7 +14468,7 @@ function handleStatus(parsed) {
   let uptimeSeconds = null;
   if (pid !== null) {
     try {
-      const stat2 = fs6__namespace.statSync(pidMgr.getPidPath());
+      const stat2 = fs8__namespace.statSync(pidMgr.getPidPath());
       uptimeSeconds = Math.floor((Date.now() - stat2.mtimeMs) / 1e3);
     } catch {
       uptimeSeconds = null;
@@ -14103,6 +14487,10 @@ function handleStatus(parsed) {
 }
 async function runDaemon(parsed) {
   const wp = requireWorkspace2(parsed);
+  const logPath = getStringFlag(parsed, "logPath");
+  if (logPath) {
+    process.env.SERVICEME_SCHEDULER_LOG_PATH = logPath;
+  }
   const pidMgr = new PidManager(wp);
   const existingPid = pidMgr.getRunningPid();
   if (existingPid !== null && existingPid !== process.pid) {