@kody-ade/kody-engine 0.3.40 → 0.3.41

package/dist/bin/kody.js

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.3.40",
+  version: "0.3.41",
   description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",
@@ -612,6 +612,68 @@ import * as path20 from "path";
 // src/dispatch.ts
 import * as fs6 from "fs";
 
+// src/cron-match.ts
+var FIELD_BOUNDS = [
+  [0, 59],
+  // minute
+  [0, 23],
+  // hour
+  [1, 31],
+  // day-of-month
+  [1, 12],
+  // month
+  [0, 6]
+  // day-of-week
+];
+function parseCron(spec) {
+  const fields = spec.trim().split(/\s+/);
+  if (fields.length !== 5) {
+    throw new Error(`Invalid cron expression: "${spec}" \u2014 expected 5 space-separated fields`);
+  }
+  const sets = fields.map((f, i) => parseField(f, FIELD_BOUNDS[i][0], FIELD_BOUNDS[i][1]));
+  return { minute: sets[0], hour: sets[1], dom: sets[2], month: sets[3], dow: sets[4] };
+}
+function parseField(field, min, max) {
+  const out = /* @__PURE__ */ new Set();
+  for (const part of field.split(",")) {
+    const [base, stepStr] = part.split("/");
+    const step = stepStr ? parseInt(stepStr, 10) : 1;
+    if (!Number.isFinite(step) || step < 1) {
+      throw new Error(`Invalid step in cron field "${field}"`);
+    }
+    let lo;
+    let hi;
+    if (base === "*") {
+      lo = min;
+      hi = max;
+    } else if (base.includes("-")) {
+      const [aStr, bStr] = base.split("-");
+      lo = parseInt(aStr, 10);
+      hi = parseInt(bStr, 10);
+    } else {
+      lo = parseInt(base, 10);
+      hi = lo;
+    }
+    if (!Number.isFinite(lo) || !Number.isFinite(hi) || lo < min || hi > max || lo > hi) {
+      throw new Error(`Invalid cron field "${field}" \u2014 out of range [${min},${max}] or reversed`);
+    }
+    for (let i = lo; i <= hi; i += step) out.add(i);
+  }
+  return out;
+}
+function cronMatchesAt(expr, date) {
+  return expr.minute.has(date.getUTCMinutes()) && expr.hour.has(date.getUTCHours()) && expr.dom.has(date.getUTCDate()) && expr.month.has(date.getUTCMonth() + 1) && expr.dow.has(date.getUTCDay());
+}
+function cronMatchesInWindow(spec, end, windowSec) {
+  const expr = parseCron(spec);
+  const endMs = Math.floor(end.getTime() / 6e4) * 6e4;
+  const minuteSteps = Math.max(1, Math.ceil(windowSec / 60));
+  for (let i = 0; i < minuteSteps; i++) {
+    if (cronMatchesAt(expr, new Date(endMs - i * 6e4))) return true;
+  }
+  return false;
+}
+
 // src/registry.ts
 import * as fs5 from "fs";
 import * as path5 from "path";
@@ -725,11 +787,9 @@ function autoDispatch(opts) {
     if (!Number.isNaN(n) && n > 0) {
       return { executable: "run", cliArgs: { issue: n }, target: n };
     }
-    return { executable: "mission-scheduler", cliArgs: {}, target: 0 };
-  }
-  if (eventName === "schedule") {
-    return { executable: "mission-scheduler", cliArgs: {}, target: 0 };
+    return null;
   }
+  if (eventName === "schedule") return null;
   if (eventName === "pull_request") return null;
   if (eventName !== "issue_comment") return null;
   const rawBody = String(event.comment?.body ?? "");
@@ -771,6 +831,39 @@ function autoDispatch(opts) {
   }
   return { executable, cliArgs: args, target: targetNum };
 }
+function dispatchScheduledWatches(opts) {
+  const now = opts?.now ?? /* @__PURE__ */ new Date();
+  const envWindow = Number(process.env.KODY_SCHEDULE_WINDOW_SEC);
+  const windowSec = opts?.windowSec ?? (Number.isFinite(envWindow) && envWindow > 0 ? envWindow : 300);
+  const out = [];
+  for (const exe of listExecutables()) {
+    let raw;
+    try {
+      raw = fs6.readFileSync(exe.profilePath, "utf-8");
+    } catch {
+      continue;
+    }
+    let profile;
+    try {
+      profile = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    if (profile.role !== "watch") continue;
+    if (profile.kind !== "scheduled") continue;
+    const schedule = profile.schedule;
+    if (typeof schedule !== "string" || schedule.trim().length === 0) continue;
+    if (!opts?.force) {
+      try {
+        if (!cronMatchesInWindow(schedule, now, windowSec)) continue;
+      } catch {
+        continue;
+      }
+    }
+    out.push({ executable: exe.name, cliArgs: {}, target: 0 });
+  }
+  return out;
+}
 function extractAfterTag(body) {
   const idx = body.indexOf("@kody");
   if (idx === -1) return body;
@@ -1674,31 +1767,34 @@ var buildSyntheticPlugin = async (ctx, profile) => {
   const runId = `${profile.name}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   const root = path9.join(os2.tmpdir(), `kody-synth-${runId}`);
   fs10.mkdirSync(path9.join(root, ".claude-plugin"), { recursive: true });
+  const resolvePart = (bucket, entry) => {
+    const local = path9.join(profile.dir, bucket, entry);
+    if (fs10.existsSync(local)) return local;
+    const central = path9.join(catalog, bucket, entry);
+    if (fs10.existsSync(central)) return central;
+    throw new Error(
+      `buildSyntheticPlugin: ${bucket} entry '${entry}' not found in executable dir (${profile.dir}/${bucket}/) or catalog (${catalog}/${bucket}/)`
+    );
+  };
   if (cc.skills.length > 0) {
     const dst = path9.join(root, "skills");
     fs10.mkdirSync(dst, { recursive: true });
     for (const name of cc.skills) {
-      const src = path9.join(catalog, "skills", name);
-      if (!fs10.existsSync(src)) throw new Error(`buildSyntheticPlugin: skill not found in catalog: ${name}`);
-      copyDir(src, path9.join(dst, name));
+      copyDir(resolvePart("skills", name), path9.join(dst, name));
     }
   }
   if (cc.commands.length > 0) {
     const dst = path9.join(root, "commands");
     fs10.mkdirSync(dst, { recursive: true });
     for (const name of cc.commands) {
-      const src = path9.join(catalog, "commands", `${name}.md`);
-      if (!fs10.existsSync(src)) throw new Error(`buildSyntheticPlugin: command not found in catalog: ${name}`);
-      fs10.copyFileSync(src, path9.join(dst, `${name}.md`));
+      fs10.copyFileSync(resolvePart("commands", `${name}.md`), path9.join(dst, `${name}.md`));
     }
   }
   if (cc.subagents.length > 0) {
     const dst = path9.join(root, "agents");
     fs10.mkdirSync(dst, { recursive: true });
     for (const name of cc.subagents) {
-      const src = path9.join(catalog, "agents", `${name}.md`);
-      if (!fs10.existsSync(src)) throw new Error(`buildSyntheticPlugin: subagent not found in catalog: ${name}`);
-      fs10.copyFileSync(src, path9.join(dst, `${name}.md`));
+      fs10.copyFileSync(resolvePart("agents", `${name}.md`), path9.join(dst, `${name}.md`));
     }
   }
   if (cc.hooks.length > 0) {
@@ -1706,8 +1802,7 @@ var buildSyntheticPlugin = async (ctx, profile) => {
     fs10.mkdirSync(dst, { recursive: true });
     const merged = { hooks: {} };
     for (const name of cc.hooks) {
-      const src = path9.join(catalog, "hooks", `${name}.json`);
-      if (!fs10.existsSync(src)) throw new Error(`buildSyntheticPlugin: hook not found in catalog: ${name}`);
+      const src = resolvePart("hooks", `${name}.json`);
       const parsed = JSON.parse(fs10.readFileSync(src, "utf-8"));
       for (const [event, entries] of Object.entries(parsed.hooks ?? {})) {
         if (!Array.isArray(entries)) continue;
@@ -6333,6 +6428,22 @@ async function runCi(argv) {
   } catch {
   }
   const autoFallback = !args.issueNumber ? autoDispatch({ config: earlyConfig }) : null;
+  const eventName = process.env.GITHUB_EVENT_NAME;
+  const dispatchEventPath = process.env.GITHUB_EVENT_PATH;
+  let manualWorkflowDispatch = false;
+  if (!args.issueNumber && !autoFallback && eventName === "workflow_dispatch" && dispatchEventPath && fs23.existsSync(dispatchEventPath)) {
+    try {
+      const evt = JSON.parse(fs23.readFileSync(dispatchEventPath, "utf-8"));
+      const issueInput = parseInt(String(evt?.inputs?.issue_number ?? ""), 10);
+      const sessionInput = String(evt?.inputs?.sessionId ?? "");
+      manualWorkflowDispatch = !sessionInput && !(Number.isFinite(issueInput) && issueInput > 0);
+    } catch {
+      manualWorkflowDispatch = false;
+    }
+  }
+  if (!args.issueNumber && !autoFallback && (eventName === "schedule" || manualWorkflowDispatch)) {
+    return runScheduledFanOut(cwd, args, { force: manualWorkflowDispatch });
+  }
   if (!args.issueNumber && !autoFallback && process.env.GITHUB_EVENT_NAME) {
     process.stdout.write(`\u2192 kody: no action for event ${process.env.GITHUB_EVENT_NAME} \u2014 exiting cleanly
 `);
@@ -6418,6 +6529,79 @@ ${CI_HELP}`);
     return 99;
   }
 }
+async function runScheduledFanOut(cwd, args, opts) {
+  const matches = dispatchScheduledWatches({ force: opts.force });
+  if (matches.length === 0) {
+    process.stdout.write(
+      `\u2192 kody: scheduled wake \u2014 no watches matched ${opts.force ? "(force mode, no watches discovered)" : "(window)"}, exiting cleanly
+`
+    );
+    return 0;
+  }
+  const names = matches.map((m) => m.executable).join(", ");
+  process.stdout.write(`\u2192 kody: scheduled wake \u2014 firing ${matches.length} watch(es): ${names}
+`);
+  try {
+    const n = unpackAllSecrets();
+    if (n > 0) process.stdout.write(`\u2192 kody: unpacked ${n} secret(s) from ALL_SECRETS
+`);
+    resolveAuthToken();
+    const pm = args.packageManager ?? detectPackageManager2(cwd);
+    process.stdout.write(`\u2192 kody: package manager = ${pm}
+`);
+    if (!args.skipInstall) {
+      const code = installDeps(pm, cwd);
+      if (code !== 0) {
+        process.stderr.write(`[kody] dep install failed (${pm}, exit ${code})
+`);
+        return 99;
+      }
+    }
+    if (!args.skipLitellm) {
+      const code = installLitellmIfNeeded(cwd);
+      if (code !== 0) {
+        process.stderr.write(`[kody] litellm install failed (exit ${code})
+`);
+        return 99;
+      }
+    }
+    configureGitIdentity(cwd);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[kody] preflight crashed: ${msg}
+`);
+    return 99;
+  }
+  const config = loadConfig(cwd);
+  let worstExit = 0;
+  for (const match of matches) {
+    process.stdout.write(`
+\u2192 kody: running watch \`${match.executable}\`
+`);
+    try {
+      const result = await runExecutable(match.executable, {
+        cliArgs: match.cliArgs,
+        cwd,
+        config,
+        verbose: args.verbose,
+        quiet: args.quiet
+      });
+      if (result.exitCode !== 0) {
+        process.stderr.write(
+          `[kody] watch \`${match.executable}\` exited ${result.exitCode}: ${result.reason ?? "(no reason)"}
+`
+        );
+        if (result.exitCode > worstExit) worstExit = result.exitCode;
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[kody] watch \`${match.executable}\` crashed: ${msg}
+`);
+      worstExit = Math.max(worstExit, 99);
+    }
+  }
+  return worstExit;
+}
 
 // src/chat-cli.ts
 var DEFAULT_MODEL = "claude/claude-haiku-4-5-20251001";

package/dist/executables/probe-skill/profile.json

@@ -0,0 +1,35 @@
+{
+  "name": "probe-skill",
+  "role": "utility",
+  "describe": "Live-test executable. Loads the executable-local 'probe-skill-marker' skill (resolved from src/executables/probe-skill/skills/, NOT the central catalog) and asks the agent to emit the skill's token back as an issue comment. Validates the new local-skill resolution path in buildSyntheticPlugin end-to-end.",
+  "inputs": [
+    { "name": "issue", "flag": "--issue", "type": "int", "required": true, "describe": "GitHub issue number to verify against." }
+  ],
+  "claudeCode": {
+    "model": "inherit",
+    "permissionMode": "default",
+    "maxTurns": 12,
+    "systemPromptAppend": "You are running Kody's executable-local skill live verification. Emit the token exactly as the skill instructs.",
+    "tools": ["Read", "Grep", "Glob", "Bash"],
+    "hooks": [],
+    "skills": ["probe-skill-marker"],
+    "commands": [],
+    "subagents": [],
+    "plugins": [],
+    "mcpServers": []
+  },
+  "cliTools": [],
+  "scripts": {
+    "preflight": [
+      { "script": "loadIssueContext" },
+      { "script": "loadTaskState" },
+      { "script": "buildSyntheticPlugin" },
+      { "script": "composePrompt" }
+    ],
+    "postflight": [
+      { "script": "parseAgentResult" },
+      { "script": "writeRunSummary" },
+      { "script": "saveTaskState" }
+    ]
+  }
+}

package/dist/executables/probe-skill/prompt.md

@@ -0,0 +1,31 @@
+You are Kody's executable-local skill live verification agent. Your only job: prove that the skill named `probe-skill-marker` was loaded into your session from this executable's own directory (NOT the shared catalog), and report its token back to the issue.
+
+Issue #{{issue.number}}: {{issue.title}}
+
+---
+
+# What to do
+
+1. List your available skills. Confirm a skill named `probe-skill-marker` is loaded.
+2. Activate it (its activation phrase is "probe-skill-marker"). The skill instructs you to emit a single token of the form `PROBE_SKILL_OK_<version>`.
+3. Post a comment on issue #{{issue.number}} via `gh issue comment {{issue.number}} --body "..."`. The body must be a single line:
+   ```
+   probe-skill verification: <TOKEN>
+   ```
+   Replace `<TOKEN>` with whatever exact token the skill told you to emit. If the skill is NOT loaded, post `probe-skill verification: SKILL_NOT_LOADED` instead.
+
+# Output contract
+
+After posting the comment, your final message must be exactly:
+
+```
+DONE
+COMMIT_MSG: probe-skill: live verification for #{{issue.number}}
+PR_SUMMARY: probe-skill ran; see issue comment for the token.
+```
+
+# Rules
+
+- Read-only on the repo. Do NOT edit any file. Do NOT run git.
+- The only state-changing command you may run is `gh issue comment`.
+- Do not perform the issue's actual work.

package/dist/executables/probe-skill/skills/probe-skill-marker/SKILL.md

@@ -0,0 +1,18 @@
+---
+name: probe-skill-marker
+description: Internal Kody live-test skill, shipped from the probe-skill executable's own directory (not the shared src/plugins catalog). Activates when a prompt mentions "probe-skill-marker" and provides a versioned confirmation token.
+---
+
+# probe-skill-marker
+
+This skill exists only to verify that Kody's executable-local plugin-part resolution actually loads skills from `src/executables/<name>/skills/` into the agent's session.
+
+## When to activate
+
+When the user's prompt contains the phrase "probe-skill-marker" or explicitly asks whether the skill is loaded.
+
+## What to do
+
+Emit the literal token `PROBE_SKILL_OK_v1` exactly as written. Do not modify, paraphrase, or interpret it. The token version (`v1`) lets us prove that edits to this file are picked up on the next run — bumping it to `v2` here should result in the agent reporting `PROBE_SKILL_OK_v2` after a fresh publish + trigger.
+
+Do not use this skill for anything else. It is a no-op confirmation signal for infrastructure validation.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kody-ade/kody-engine",
-  "version": "0.3.40",
+  "version": "0.3.41",
   "description": "kody — autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   "license": "MIT",
   "type": "module",