@kody-ade/kody-engine 0.2.6 → 0.2.8

package/dist/bin/kody2.js

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.2.6",
+  version: "0.2.8",
   description: "kody2 \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",
@@ -151,8 +151,8 @@ function getAnthropicApiKeyOrDummy() {
 }
 
 // src/executor.ts
-import * as fs12 from "fs";
-import * as path10 from "path";
+import * as fs13 from "fs";
+import * as path11 from "path";
 
 // src/agent.ts
 import * as fs2 from "fs";
@@ -463,9 +463,15 @@ function loadProfile(profilePath) {
     throw new ProfileError(profilePath, "profile must be a JSON object");
   }
   const r = raw;
+  const kind = r.kind === "scheduled" ? "scheduled" : "oneshot";
+  if (kind === "scheduled" && typeof r.schedule !== "string") {
+    throw new ProfileError(profilePath, `kind: "scheduled" requires a "schedule" cron string`);
+  }
   const profile = {
     name: requireString(profilePath, r, "name"),
     describe: typeof r.describe === "string" ? r.describe : "",
+    kind,
+    schedule: typeof r.schedule === "string" ? r.schedule : void 0,
     inputs: parseInputs(profilePath, r.inputs),
     claudeCode: parseClaudeCode(profilePath, r.claudeCode),
     cliTools: parseCliTools(profilePath, r.cliTools),
@@ -1664,12 +1670,75 @@ function tryPostPr2(prNumber, body, cwd) {
 
 // src/scripts/initFlow.ts
 import { execFileSync as execFileSync9 } from "child_process";
+import * as fs10 from "fs";
+import * as path9 from "path";
+
+// src/registry.ts
 import * as fs9 from "fs";
 import * as path8 from "path";
+function getExecutablesRoot() {
+  const here = path8.dirname(new URL(import.meta.url).pathname);
+  const candidates = [
+    path8.join(here, "executables"),
+    // dev: src/
+    path8.join(here, "..", "executables"),
+    // built: dist/bin → dist/executables
+    path8.join(here, "..", "src", "executables")
+    // fallback
+  ];
+  for (const c of candidates) {
+    if (fs9.existsSync(c) && fs9.statSync(c).isDirectory()) return c;
+  }
+  return candidates[0];
+}
+function listExecutables(root = getExecutablesRoot()) {
+  if (!fs9.existsSync(root)) return [];
+  const entries = fs9.readdirSync(root, { withFileTypes: true });
+  const out = [];
+  for (const ent of entries) {
+    if (!ent.isDirectory()) continue;
+    const profilePath = path8.join(root, ent.name, "profile.json");
+    if (fs9.existsSync(profilePath) && fs9.statSync(profilePath).isFile()) {
+      out.push({ name: ent.name, profilePath });
+    }
+  }
+  return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+function hasExecutable(name, root = getExecutablesRoot()) {
+  if (!isSafeName(name)) return false;
+  const profilePath = path8.join(root, name, "profile.json");
+  return fs9.existsSync(profilePath) && fs9.statSync(profilePath).isFile();
+}
+function isSafeName(name) {
+  return /^[a-z][a-z0-9-]*$/.test(name) && !name.includes("..");
+}
+function parseGenericFlags(argv) {
+  const args = {};
+  const positional = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg.startsWith("--")) {
+      positional.push(arg);
+      continue;
+    }
+    const key = arg.slice(2);
+    const next = argv[i + 1];
+    if (next !== void 0 && !next.startsWith("--")) {
+      args[key] = next;
+      i++;
+    } else {
+      args[key] = true;
+    }
+  }
+  if (positional.length > 0) args._ = positional;
+  return args;
+}
+
+// src/scripts/initFlow.ts
 function detectPackageManager(cwd) {
-  if (fs9.existsSync(path8.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs9.existsSync(path8.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs9.existsSync(path8.join(cwd, "bun.lockb"))) return "bun";
+  if (fs10.existsSync(path9.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs10.existsSync(path9.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs10.existsSync(path9.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function qualityCommandsFor(pm) {
@@ -1790,26 +1859,74 @@ function performInit(cwd, force) {
   const pm = detectPackageManager(cwd);
   const ownerRepo = detectOwnerRepo(cwd);
   const defaultBranch = defaultBranchFromGit(cwd);
-  const configPath = path8.join(cwd, "kody.config.json");
-  if (fs9.existsSync(configPath) && !force) {
+  const configPath = path9.join(cwd, "kody.config.json");
+  if (fs10.existsSync(configPath) && !force) {
     skipped.push("kody.config.json");
   } else {
     const cfg = makeConfig(pm, ownerRepo, defaultBranch);
-    fs9.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
+    fs10.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
 `);
     wrote.push("kody.config.json");
   }
-  const workflowDir = path8.join(cwd, ".github", "workflows");
-  const workflowPath = path8.join(workflowDir, "kody2.yml");
-  if (fs9.existsSync(workflowPath) && !force) {
+  const workflowDir = path9.join(cwd, ".github", "workflows");
+  const workflowPath = path9.join(workflowDir, "kody2.yml");
+  if (fs10.existsSync(workflowPath) && !force) {
     skipped.push(".github/workflows/kody2.yml");
   } else {
-    fs9.mkdirSync(workflowDir, { recursive: true });
-    fs9.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
+    fs10.mkdirSync(workflowDir, { recursive: true });
+    fs10.writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
     wrote.push(".github/workflows/kody2.yml");
   }
+  for (const exe of listExecutables()) {
+    let profile;
+    try {
+      profile = loadProfile(exe.profilePath);
+    } catch {
+      continue;
+    }
+    if (profile.kind !== "scheduled" || !profile.schedule) continue;
+    const target = path9.join(workflowDir, `kody2-${exe.name}.yml`);
+    if (fs10.existsSync(target) && !force) {
+      skipped.push(`.github/workflows/kody2-${exe.name}.yml`);
+      continue;
+    }
+    fs10.writeFileSync(target, renderScheduledWorkflow(exe.name, profile.schedule));
+    wrote.push(`.github/workflows/kody2-${exe.name}.yml`);
+  }
   return { wrote, skipped };
 }
+function renderScheduledWorkflow(name, cron) {
+  return `# Scheduled kody2 executable: ${name}
+# Generated by \`kody2 init\`. Regenerate with \`kody2 init --force\`.
+# Edit the cron below or the executable's profile.json#schedule.
+
+name: kody2 ${name}
+
+on:
+  schedule:
+    - cron: "${cron}"
+  workflow_dispatch:
+
+jobs:
+  run:
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    permissions:
+      issues: write
+      pull-requests: read
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          token: \${{ secrets.KODY_TOKEN || github.token }}
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+      - env:
+          GH_TOKEN: \${{ secrets.KODY_TOKEN || github.token }}
+        run: npx -y -p @kody-ade/kody-engine@latest kody2 ${name}
+`;
+}
 var initFlow = async (ctx) => {
   const force = ctx.args.force === true;
   const cwd = ctx.cwd;
@@ -1845,10 +1962,201 @@ var loadCoverageRules = async (ctx) => {
   ctx.data.coverageRules = ctx.config.testRequirements ?? [];
 };
 
+// src/state.ts
+import { execFileSync as execFileSync10 } from "child_process";
+var STATE_BEGIN = "<!-- kody2:state:v1:begin -->";
+var STATE_END = "<!-- kody2:state:v1:end -->";
+var HISTORY_MAX_ENTRIES = 20;
+var API_TIMEOUT_MS2 = 3e4;
+function emptyState() {
+  return {
+    schemaVersion: 1,
+    core: {
+      phase: "idle",
+      status: "pending",
+      currentExecutable: null,
+      lastOutcome: null,
+      attempts: {}
+    },
+    executables: {},
+    history: []
+  };
+}
+function ghToken3() {
+  return process.env.GH_PAT?.trim() || process.env.GH_TOKEN;
+}
+function gh3(args, input, cwd) {
+  const token = ghToken3();
+  const env = token ? { ...process.env, GH_TOKEN: token } : { ...process.env };
+  return execFileSync10("gh", args, {
+    encoding: "utf-8",
+    timeout: API_TIMEOUT_MS2,
+    cwd,
+    env,
+    input,
+    stdio: input ? ["pipe", "pipe", "pipe"] : ["ignore", "pipe", "pipe"]
+  }).trim();
+}
+function findStateComment(target, number, cwd) {
+  const apiPath = target === "issue" ? `repos/{owner}/{repo}/issues/${number}/comments` : `repos/{owner}/{repo}/issues/${number}/comments`;
+  try {
+    const raw = gh3(["api", "--paginate", apiPath], void 0, cwd);
+    const list = JSON.parse(raw);
+    for (const c of list) {
+      if (c.body?.includes(STATE_BEGIN)) {
+        return { id: String(c.id), body: c.body };
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function parseStateComment(body) {
+  const beginIdx = body.indexOf(STATE_BEGIN);
+  const endIdx = body.indexOf(STATE_END, beginIdx + 1);
+  if (beginIdx < 0 || endIdx < 0) return emptyState();
+  const between = body.slice(beginIdx + STATE_BEGIN.length, endIdx);
+  const fenceMatch = between.match(/```json\s*([\s\S]*?)\s*```/);
+  if (!fenceMatch) return emptyState();
+  try {
+    const parsed = JSON.parse(fenceMatch[1]);
+    if (parsed?.schemaVersion !== 1) return emptyState();
+    return {
+      schemaVersion: 1,
+      core: { ...emptyState().core, ...parsed.core },
+      executables: parsed.executables ?? {},
+      history: Array.isArray(parsed.history) ? parsed.history : []
+    };
+  } catch {
+    return emptyState();
+  }
+}
+function reduce(state, executable, action) {
+  if (!action) return state;
+  const newAttempts = { ...state.core.attempts, [executable]: (state.core.attempts[executable] ?? 0) + 1 };
+  const newExecutables = {
+    ...state.executables,
+    [executable]: { ...state.executables[executable] ?? { lastAction: null }, lastAction: action }
+  };
+  const newHistory = [
+    ...state.history,
+    { timestamp: action.timestamp, executable, action: action.type, note: noteFromAction(action) }
+  ].slice(-HISTORY_MAX_ENTRIES);
+  return {
+    schemaVersion: 1,
+    core: {
+      ...state.core,
+      attempts: newAttempts,
+      lastOutcome: action,
+      currentExecutable: executable,
+      status: statusFromAction(action),
+      phase: phaseFromAction(executable, action)
+    },
+    executables: newExecutables,
+    history: newHistory
+  };
+}
+function statusFromAction(action) {
+  if (/FAILED$|ERROR$|MISSING$|REJECTED$/i.test(action.type)) return "failed";
+  if (/COMPLETED$|SHIPPED$|MERGED$|SUCCESS$/i.test(action.type)) return "succeeded";
+  return "running";
+}
+function phaseFromAction(executable, action) {
+  if (/FAILED$|ERROR$|REJECTED$/i.test(action.type)) return "failed";
+  if (executable === "build") return statusFromAction(action) === "succeeded" ? "implementing" : "implementing";
+  if (executable === "review") return "reviewing";
+  if (executable === "release") return "shipped";
+  return "idle";
+}
+function noteFromAction(action) {
+  const p = action.payload;
+  if (typeof p?.prUrl === "string") return p.prUrl;
+  if (typeof p?.reason === "string") return p.reason.slice(0, 120);
+  if (typeof p?.commitMessage === "string") return p.commitMessage.slice(0, 120);
+  return void 0;
+}
+function renderStateComment(state) {
+  const lines = [];
+  lines.push(STATE_BEGIN);
+  lines.push("");
+  lines.push("```json");
+  lines.push(JSON.stringify(
+    { schemaVersion: state.schemaVersion, core: state.core, executables: state.executables, history: state.history },
+    null,
+    2
+  ));
+  lines.push("```");
+  lines.push("");
+  lines.push(STATE_END);
+  lines.push("");
+  lines.push("## kody2 task state");
+  lines.push("");
+  lines.push(`- **Phase:** \`${state.core.phase}\`  **Status:** \`${state.core.status}\``);
+  if (state.core.currentExecutable) {
+    lines.push(`- **Last executable:** \`${state.core.currentExecutable}\``);
+  }
+  if (state.core.lastOutcome) {
+    lines.push(`- **Last action:** \`${state.core.lastOutcome.type}\``);
+  }
+  const attempts = Object.entries(state.core.attempts).map(([k, v]) => `${k}:${v}`).join(", ");
+  if (attempts) lines.push(`- **Attempts:** ${attempts}`);
+  if (state.core.prUrl) lines.push(`- **PR:** ${state.core.prUrl}`);
+  if (state.core.runUrl) lines.push(`- **Run:** ${state.core.runUrl}`);
+  lines.push("");
+  if (state.history.length > 0) {
+    lines.push("### Recent history");
+    lines.push("");
+    const recent = state.history.slice(-10).reverse();
+    for (const h of recent) {
+      const note = h.note ? ` \u2014 ${h.note}` : "";
+      lines.push(`- \`${h.timestamp}\` **${h.executable}** \u2192 \`${h.action}\`${note}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function readTaskState(target, number, cwd) {
+  const existing = findStateComment(target, number, cwd);
+  return existing ? parseStateComment(existing.body) : emptyState();
+}
+function writeTaskState(target, number, state, cwd) {
+  const body = renderStateComment(state);
+  const existing = findStateComment(target, number, cwd);
+  try {
+    if (existing) {
+      gh3(
+        ["api", `repos/{owner}/{repo}/issues/comments/${existing.id}`, "-X", "PATCH", "-F", "body=@-"],
+        body,
+        cwd
+      );
+    } else {
+      const sub = target === "issue" ? "issue" : "pr";
+      gh3([sub, "comment", String(number), "--body-file", "-"], body, cwd);
+    }
+  } catch (err) {
+    process.stderr.write(
+      `[kody2 state] failed to write state on ${target} #${number}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+}
+
+// src/scripts/loadTaskState.ts
+var loadTaskState = async (ctx) => {
+  const target = ctx.data.commentTargetType;
+  const number = ctx.data.commentTargetNumber;
+  if (!target || !number) {
+    ctx.data.taskState = emptyState();
+    return;
+  }
+  ctx.data.taskState = readTaskState(target, number, ctx.cwd);
+};
+
 // src/scripts/parseAgentResult.ts
-var parseAgentResult2 = async (ctx, _profile, agentResult) => {
+var parseAgentResult2 = async (ctx, profile, agentResult) => {
   if (!agentResult) {
     ctx.data.agentDone = false;
+    ctx.data.action = makeAction("AGENT_NOT_RUN", { reason: "no agent result" });
     return;
   }
   const parsed = parseAgentResult(agentResult.finalText);
@@ -1858,7 +2166,21 @@ var parseAgentResult2 = async (ctx, _profile, agentResult) => {
   ctx.data.agentFailureReason = parsed.failureReason;
   ctx.data.agentOutcome = agentResult.outcome;
   ctx.data.agentError = agentResult.error;
+  const modeSeg = (ctx.args.mode ?? profile.name).replace(/-/g, "_").toUpperCase();
+  if (parsed.done) {
+    ctx.data.action = makeAction(`${modeSeg}_COMPLETED`, {
+      commitMessage: parsed.commitMessage,
+      prSummary: parsed.prSummary
+    });
+  } else {
+    ctx.data.action = makeAction(`${modeSeg}_FAILED`, {
+      reason: parsed.failureReason || agentResult.error || "unknown failure"
+    });
+  }
 };
+function makeAction(type, payload) {
+  return { type, payload, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+}
 
 // src/scripts/postIssueComment.ts
 var postIssueComment2 = async (ctx) => {
@@ -1962,9 +2284,9 @@ REVIEW_POSTED=https://github.com/${ctx.config.github.owner}/${ctx.config.github.
 };
 
 // src/scripts/releaseFlow.ts
-import { execFileSync as execFileSync10, spawnSync } from "child_process";
-import * as fs10 from "fs";
-import * as path9 from "path";
+import { execFileSync as execFileSync11, spawnSync } from "child_process";
+import * as fs11 from "fs";
+import * as path10 from "path";
 function bumpVersion(current, bump) {
   const m = current.match(/^(\d+)\.(\d+)\.(\d+)(.*)$/);
   if (!m) throw new Error(`cannot parse version '${current}' (expected x.y.z[-suffix])`);
@@ -1980,19 +2302,19 @@ function bumpVersion(current, bump) {
   return `${major}.${minor}.${patch}`;
 }
 function updateVersionInFile(file, newVersion, cwd) {
-  const abs = path9.join(cwd, file);
-  if (!fs10.existsSync(abs)) return false;
-  const content = fs10.readFileSync(abs, "utf-8");
+  const abs = path10.join(cwd, file);
+  if (!fs11.existsSync(abs)) return false;
+  const content = fs11.readFileSync(abs, "utf-8");
   const updated = content.replace(/"version"\s*:\s*"[^"]+"/, `"version": "${newVersion}"`);
   if (updated === content) return false;
-  fs10.writeFileSync(abs, updated);
+  fs11.writeFileSync(abs, updated);
   return true;
 }
 function generateChangelog(cwd, newVersion, lastTag) {
   const range = lastTag ? `${lastTag}..HEAD` : "HEAD";
   let log = "";
   try {
-    log = execFileSync10("git", ["log", range, "--pretty=format:%s||%h", "--no-merges"], {
+    log = execFileSync11("git", ["log", range, "--pretty=format:%s||%h", "--no-merges"], {
       cwd,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
@@ -2033,23 +2355,23 @@ function generateChangelog(cwd, newVersion, lastTag) {
   return parts.join("\n");
 }
 function prependChangelog(cwd, entry) {
-  const p = path9.join(cwd, "CHANGELOG.md");
+  const p = path10.join(cwd, "CHANGELOG.md");
   const header = "# Changelog\n\nAll notable changes to this project will be documented in this file.\n\n";
-  if (fs10.existsSync(p)) {
-    const prior = fs10.readFileSync(p, "utf-8");
+  if (fs11.existsSync(p)) {
+    const prior = fs11.readFileSync(p, "utf-8");
     if (/^#\s*Changelog\b/m.test(prior)) {
       const idx = prior.indexOf("\n", prior.indexOf("# Changelog"));
-      fs10.writeFileSync(p, `${prior.slice(0, idx + 1)}
+      fs11.writeFileSync(p, `${prior.slice(0, idx + 1)}
 ${entry}${prior.slice(idx + 1)}`);
     } else {
-      fs10.writeFileSync(p, `${header}${entry}${prior}`);
+      fs11.writeFileSync(p, `${header}${entry}${prior}`);
     }
   } else {
-    fs10.writeFileSync(p, `${header}${entry}`);
+    fs11.writeFileSync(p, `${header}${entry}`);
   }
 }
 function git3(args, cwd, timeout = 6e4) {
-  return execFileSync10("git", args, {
+  return execFileSync11("git", args, {
     encoding: "utf-8",
     timeout,
     cwd,
@@ -2096,13 +2418,13 @@ var releaseFlow = async (ctx) => {
 };
 async function runPrepare(args) {
   const { cwd, bump, dryRun, versionFiles, ctx } = args;
-  const pkgPath = path9.join(cwd, "package.json");
-  if (!fs10.existsSync(pkgPath)) {
+  const pkgPath = path10.join(cwd, "package.json");
+  if (!fs11.existsSync(pkgPath)) {
     ctx.output.exitCode = 99;
     ctx.output.reason = "release prepare: package.json not found";
     return;
   }
-  const pkg = JSON.parse(fs10.readFileSync(pkgPath, "utf-8"));
+  const pkg = JSON.parse(fs11.readFileSync(pkgPath, "utf-8"));
   if (typeof pkg.version !== "string") {
     ctx.output.exitCode = 99;
     ctx.output.reason = "release prepare: package.json has no version";
@@ -2173,8 +2495,8 @@ Merge this and then run \`kody2 release --mode finalize\`.`;
 }
 async function runFinalize(args) {
   const { cwd, dryRun, timeoutMs, releaseCfg, ctx } = args;
-  const pkgPath = path9.join(cwd, "package.json");
-  const pkg = JSON.parse(fs10.readFileSync(pkgPath, "utf-8"));
+  const pkgPath = path10.join(cwd, "package.json");
+  const pkg = JSON.parse(fs11.readFileSync(pkgPath, "utf-8"));
   if (typeof pkg.version !== "string") {
     ctx.output.exitCode = 99;
     ctx.output.reason = "release finalize: package.json has no version";
@@ -2264,7 +2586,7 @@ ${truncate2(r.stderr, 2e3)}
 }
 
 // src/scripts/resolveFlow.ts
-import { execFileSync as execFileSync11 } from "child_process";
+import { execFileSync as execFileSync12 } from "child_process";
 var CONFLICT_DIFF_MAX_BYTES = 4e4;
 var resolveFlow = async (ctx) => {
   const prNumber = ctx.args.pr;
@@ -2316,7 +2638,7 @@ var resolveFlow = async (ctx) => {
 };
 function getConflictedFiles(cwd) {
   try {
-    const out = execFileSync11("git", ["diff", "--name-only", "--diff-filter=U"], {
+    const out = execFileSync12("git", ["diff", "--name-only", "--diff-filter=U"], {
       encoding: "utf-8",
       cwd,
       env: { ...process.env, HUSKY: "0" }
@@ -2331,7 +2653,7 @@ function getConflictMarkersPreview(files, cwd, maxBytes = CONFLICT_DIFF_MAX_BYTE
   let total = 0;
   for (const f of files) {
     try {
-      const content = execFileSync11("cat", [f], { encoding: "utf-8", cwd }).toString();
+      const content = execFileSync12("cat", [f], { encoding: "utf-8", cwd }).toString();
       const snippet = `### ${f}
 
 \`\`\`
@@ -2411,6 +2733,35 @@ function tryPost(issueNumber, body, cwd) {
   }
 }
 
+// src/scripts/saveTaskState.ts
+var saveTaskState = async (ctx, profile) => {
+  const target = ctx.data.commentTargetType;
+  const number = ctx.data.commentTargetNumber;
+  const state = ctx.data.taskState;
+  if (!target || !number || !state) return;
+  const executable = profile.name;
+  const action = ctx.data.action ?? synthesizeAction(ctx);
+  if (ctx.output.prUrl && !state.core.prUrl) state.core.prUrl = ctx.output.prUrl;
+  if (typeof ctx.data.runUrl === "string") state.core.runUrl = ctx.data.runUrl;
+  const next = reduce(state, executable, action);
+  if (ctx.output.prUrl) next.core.prUrl = ctx.output.prUrl;
+  if (typeof ctx.data.runUrl === "string") next.core.runUrl = ctx.data.runUrl;
+  writeTaskState(target, number, next, ctx.cwd);
+  ctx.data.taskStateRendered = renderStateComment(next);
+};
+function synthesizeAction(ctx) {
+  const ok = ctx.output.exitCode === 0;
+  return {
+    type: ok ? "RUN_COMPLETED" : "RUN_FAILED",
+    payload: {
+      exitCode: ctx.output.exitCode,
+      reason: ctx.output.reason,
+      prUrl: ctx.output.prUrl
+    },
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
 // src/verify.ts
 import { spawn as spawn2 } from "child_process";
 var TAIL_CHARS = 4e3;
@@ -2495,8 +2846,87 @@ var verify = async (ctx) => {
   }
 };
 
+// src/scripts/watchStalePrsFlow.ts
+function readWatchConfig(ctx) {
+  const cfg = ctx.config.watch;
+  if (!cfg || typeof cfg !== "object") return {};
+  const r = cfg;
+  return {
+    staleDays: typeof r.staleDays === "number" && r.staleDays > 0 ? Math.floor(r.staleDays) : void 0,
+    reportIssueNumber: typeof r.reportIssueNumber === "number" && r.reportIssueNumber > 0 ? Math.floor(r.reportIssueNumber) : void 0
+  };
+}
+function findStalePrs(cwd, staleDays, now = /* @__PURE__ */ new Date()) {
+  let raw = "";
+  try {
+    raw = gh(
+      [
+        "pr",
+        "list",
+        "--state",
+        "open",
+        "--limit",
+        "100",
+        "--json",
+        "number,title,url,updatedAt"
+      ],
+      { cwd }
+    );
+  } catch {
+    return [];
+  }
+  let list;
+  try {
+    list = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(list)) return [];
+  const cutoffMs = now.getTime() - staleDays * 24 * 60 * 60 * 1e3;
+  const stale = [];
+  for (const pr of list) {
+    const ts = Date.parse(pr.updatedAt);
+    if (!Number.isFinite(ts) || ts > cutoffMs) continue;
+    const daysStale = Math.floor((now.getTime() - ts) / (24 * 60 * 60 * 1e3));
+    stale.push({ number: pr.number, title: pr.title, url: pr.url, updatedAt: pr.updatedAt, daysStale });
+  }
+  return stale.sort((a, b) => b.daysStale - a.daysStale);
+}
+function formatStaleReport(stale, staleDays) {
+  if (stale.length === 0) {
+    return `\u{1F7E2} **kody2 watch-stale-prs** \u2014 no open PRs untouched for more than ${staleDays} days. \u2728`;
+  }
+  const lines = [
+    `\u{1F7E1} **kody2 watch-stale-prs** \u2014 ${stale.length} PR(s) untouched for > ${staleDays} days:`,
+    ""
+  ];
+  for (const pr of stale.slice(0, 50)) {
+    lines.push(`- [#${pr.number}](${pr.url}) \u2014 *${truncate2(pr.title, 80)}* (${pr.daysStale} days stale)`);
+  }
+  if (stale.length > 50) lines.push(`- \u2026 and ${stale.length - 50} more`);
+  return lines.join("\n");
+}
+var watchStalePrsFlow = async (ctx) => {
+  ctx.skipAgent = true;
+  const { staleDays = 7, reportIssueNumber } = readWatchConfig(ctx);
+  const stale = findStalePrs(ctx.cwd, staleDays);
+  const report = formatStaleReport(stale, staleDays);
+  process.stdout.write(`${report}
+`);
+  if (reportIssueNumber) {
+    try {
+      postIssueComment(reportIssueNumber, report, ctx.cwd);
+    } catch (err) {
+      process.stderr.write(`[kody2 watch] failed to post to issue #${reportIssueNumber}: ${err instanceof Error ? err.message : String(err)}
+`);
+    }
+  }
+  ctx.output.exitCode = 0;
+  ctx.data.staleCount = stale.length;
+};
+
 // src/scripts/writeRunSummary.ts
-import * as fs11 from "fs";
+import * as fs12 from "fs";
 var writeRunSummary = async (ctx) => {
   const summaryPath = process.env.GITHUB_STEP_SUMMARY;
   if (!summaryPath) return;
@@ -2518,7 +2948,7 @@ var writeRunSummary = async (ctx) => {
   if (reason) lines.push(`- **Reason:** ${reason}`);
   lines.push("");
   try {
-    fs11.appendFileSync(summaryPath, `${lines.join("\n")}
+    fs12.appendFileSync(summaryPath, `${lines.join("\n")}
 `);
   } catch {
   }
@@ -2533,6 +2963,8 @@ var preflightScripts = {
   reviewFlow,
   initFlow,
   releaseFlow,
+  watchStalePrsFlow,
+  loadTaskState,
   loadConventions,
   loadCoverageRules,
   composePrompt
@@ -2545,7 +2977,8 @@ var postflightScripts = {
   ensurePr: ensurePr2,
   postIssueComment: postIssueComment2,
   postReviewResult,
-  writeRunSummary
+  writeRunSummary,
+  saveTaskState
 };
 var allScriptNames = /* @__PURE__ */ new Set([
   ...Object.keys(preflightScripts),
@@ -2553,7 +2986,7 @@ var allScriptNames = /* @__PURE__ */ new Set([
 ]);
 
 // src/tools.ts
-import { execFileSync as execFileSync12 } from "child_process";
+import { execFileSync as execFileSync13 } from "child_process";
 function verifyCliTools(tools, cwd) {
   const out = [];
   for (const t of tools) out.push(verifyOne(t, cwd));
@@ -2586,7 +3019,7 @@ function verifyOne(tool, cwd) {
 }
 function runShell2(cmd, cwd, timeoutMs = 3e4) {
   try {
-    execFileSync12("sh", ["-c", cmd], { cwd, stdio: "pipe", timeout: timeoutMs });
+    execFileSync13("sh", ["-c", cmd], { cwd, stdio: "pipe", timeout: timeoutMs });
     return true;
   } catch {
     return false;
@@ -2637,7 +3070,7 @@ async function runExecutable(profileName, input) {
     data: {},
     output: { exitCode: 0 }
   };
-  const ndjsonDir = path10.join(input.cwd, ".kody2");
+  const ndjsonDir = path11.join(input.cwd, ".kody2");
   const invokeAgent = async (prompt) => runAgent({
     prompt,
     model,
@@ -2696,17 +3129,17 @@ async function runExecutable(profileName, input) {
   }
 }
 function resolveProfilePath(profileName) {
-  const here = path10.dirname(new URL(import.meta.url).pathname);
+  const here = path11.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path10.join(here, "executables", profileName, "profile.json"),
+    path11.join(here, "executables", profileName, "profile.json"),
     // same-dir sibling (dev)
-    path10.join(here, "..", "executables", profileName, "profile.json"),
+    path11.join(here, "..", "executables", profileName, "profile.json"),
     // up one (prod: dist/bin → dist/executables)
-    path10.join(here, "..", "src", "executables", profileName, "profile.json")
+    path11.join(here, "..", "src", "executables", profileName, "profile.json")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs12.existsSync(c)) return c;
+    if (fs13.existsSync(c)) return c;
   }
   return candidates[0];
 }
@@ -2784,12 +3217,12 @@ function finish(out) {
 }
 
 // src/kody2-cli.ts
-import { execFileSync as execFileSync13 } from "child_process";
-import * as fs14 from "fs";
-import * as path11 from "path";
+import { execFileSync as execFileSync14 } from "child_process";
+import * as fs15 from "fs";
+import * as path12 from "path";
 
 // src/dispatch.ts
-import * as fs13 from "fs";
+import * as fs14 from "fs";
 function autoDispatch(explicit) {
   if (explicit?.mode && explicit.target) {
     return {
@@ -2799,10 +3232,10 @@ function autoDispatch(explicit) {
   }
   const eventName = process.env.GITHUB_EVENT_NAME;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventName || !eventPath || !fs13.existsSync(eventPath)) return null;
+  if (!eventName || !eventPath || !fs14.existsSync(eventPath)) return null;
   let event = {};
   try {
-    event = JSON.parse(fs13.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs14.readFileSync(eventPath, "utf-8"));
   } catch {
     return null;
   }
@@ -2922,14 +3355,14 @@ function resolveAuthToken(env = process.env) {
   return token;
 }
 function detectPackageManager2(cwd) {
-  if (fs14.existsSync(path11.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs14.existsSync(path11.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs14.existsSync(path11.join(cwd, "bun.lockb"))) return "bun";
+  if (fs15.existsSync(path12.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs15.existsSync(path12.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs15.existsSync(path12.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function shellOut(cmd, args, cwd, stream = true) {
   try {
-    execFileSync13(cmd, args, {
+    execFileSync14(cmd, args, {
       cwd,
       stdio: stream ? "inherit" : "pipe",
       env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1", CI: process.env.CI ?? "1" }
@@ -2942,7 +3375,7 @@ function shellOut(cmd, args, cwd, stream = true) {
 }
 function isOnPath(bin) {
   try {
-    execFileSync13("which", [bin], { stdio: "pipe" });
+    execFileSync14("which", [bin], { stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -2976,7 +3409,7 @@ function installLitellmIfNeeded(cwd) {
   } catch {
   }
   try {
-    execFileSync13("python3", ["-c", "import litellm"], { stdio: "pipe" });
+    execFileSync14("python3", ["-c", "import litellm"], { stdio: "pipe" });
     process.stdout.write("\u2192 kody2: litellm already installed\n");
     return 0;
   } catch {
@@ -2986,26 +3419,26 @@ function installLitellmIfNeeded(cwd) {
 }
 function configureGitIdentity(cwd) {
   try {
-    const name = execFileSync13("git", ["config", "user.name"], { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
+    const name = execFileSync14("git", ["config", "user.name"], { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
     if (name) return;
   } catch {
   }
   try {
-    execFileSync13("git", ["config", "user.name", "kody2-bot"], { cwd, stdio: "pipe" });
+    execFileSync14("git", ["config", "user.name", "kody2-bot"], { cwd, stdio: "pipe" });
   } catch {
   }
   try {
-    execFileSync13("git", ["config", "user.email", "kody2-bot@users.noreply.github.com"], { cwd, stdio: "pipe" });
+    execFileSync14("git", ["config", "user.email", "kody2-bot@users.noreply.github.com"], { cwd, stdio: "pipe" });
   } catch {
   }
 }
 function postFailureTail(issueNumber, cwd, reason) {
   if (!issueNumber) return;
-  const logPath = path11.join(cwd, ".kody2", "last-run.jsonl");
+  const logPath = path12.join(cwd, ".kody2", "last-run.jsonl");
   let tail = "";
   try {
-    if (fs14.existsSync(logPath)) {
-      const content = fs14.readFileSync(logPath, "utf-8");
+    if (fs15.existsSync(logPath)) {
+      const content = fs15.readFileSync(logPath, "utf-8");
       tail = content.slice(-3e3);
     }
   } catch {
@@ -3042,7 +3475,7 @@ async function runCi(argv) {
 ${CI_HELP}`);
     return 64;
   }
-  const cwd = args.cwd ? path11.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path12.resolve(args.cwd) : process.cwd();
   const dispatch = autoFallback ?? {
     mode: "run",
     target: args.issueNumber,
@@ -3117,67 +3550,6 @@ ${CI_HELP}`);
   }
 }
 
-// src/registry.ts
-import * as fs15 from "fs";
-import * as path12 from "path";
-function getExecutablesRoot() {
-  const here = path12.dirname(new URL(import.meta.url).pathname);
-  const candidates = [
-    path12.join(here, "executables"),
-    // dev: src/
-    path12.join(here, "..", "executables"),
-    // built: dist/bin → dist/executables
-    path12.join(here, "..", "src", "executables")
-    // fallback
-  ];
-  for (const c of candidates) {
-    if (fs15.existsSync(c) && fs15.statSync(c).isDirectory()) return c;
-  }
-  return candidates[0];
-}
-function listExecutables(root = getExecutablesRoot()) {
-  if (!fs15.existsSync(root)) return [];
-  const entries = fs15.readdirSync(root, { withFileTypes: true });
-  const out = [];
-  for (const ent of entries) {
-    if (!ent.isDirectory()) continue;
-    const profilePath = path12.join(root, ent.name, "profile.json");
-    if (fs15.existsSync(profilePath) && fs15.statSync(profilePath).isFile()) {
-      out.push({ name: ent.name, profilePath });
-    }
-  }
-  return out.sort((a, b) => a.name.localeCompare(b.name));
-}
-function hasExecutable(name, root = getExecutablesRoot()) {
-  if (!isSafeName(name)) return false;
-  const profilePath = path12.join(root, name, "profile.json");
-  return fs15.existsSync(profilePath) && fs15.statSync(profilePath).isFile();
-}
-function isSafeName(name) {
-  return /^[a-z][a-z0-9-]*$/.test(name) && !name.includes("..");
-}
-function parseGenericFlags(argv) {
-  const args = {};
-  const positional = [];
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i];
-    if (!arg.startsWith("--")) {
-      positional.push(arg);
-      continue;
-    }
-    const key = arg.slice(2);
-    const next = argv[i + 1];
-    if (next !== void 0 && !next.startsWith("--")) {
-      args[key] = next;
-      i++;
-    } else {
-      args[key] = true;
-    }
-  }
-  if (positional.length > 0) args._ = positional;
-  return args;
-}
-
 // src/entry.ts
 var HELP_TEXT = `kody2 \u2014 single-session autonomous engineer
 

package/dist/executables/build/profile.json

@@ -67,6 +67,7 @@
       { "script": "fixFlow",     "runWhen": { "args.mode": "fix" } },
       { "script": "fixCiFlow",   "runWhen": { "args.mode": "fix-ci" } },
       { "script": "resolveFlow", "runWhen": { "args.mode": "resolve" } },
+      { "script": "loadTaskState" },
       { "script": "loadConventions" },
       { "script": "loadCoverageRules" },
       { "script": "composePrompt" }
@@ -78,7 +79,21 @@
       { "script": "commitAndPush" },
       { "script": "ensurePr" },
       { "script": "postIssueComment" },
-      { "script": "writeRunSummary" }
+      { "script": "writeRunSummary" },
+      { "script": "saveTaskState" }
+    ]
+  },
+  "output": {
+    "actionTypes": [
+      "RUN_COMPLETED",
+      "RUN_FAILED",
+      "FIX_COMPLETED",
+      "FIX_FAILED",
+      "FIX_CI_COMPLETED",
+      "FIX_CI_FAILED",
+      "RESOLVE_COMPLETED",
+      "RESOLVE_FAILED",
+      "AGENT_NOT_RUN"
     ]
   }
 }

package/dist/executables/types.ts

@@ -17,6 +17,14 @@ import type { Kody2Config } from "../config.js"
 export interface Profile {
   name: string
   describe: string
+  /**
+   * Execution model. `oneshot` (default): single invocation on demand.
+   * `scheduled`: fires periodically via an external cron (typically GHA
+   * `schedule:`). Scheduled profiles must declare a `schedule` cron string.
+   */
+  kind: "oneshot" | "scheduled"
+  /** Cron expression for scheduled profiles (e.g. "0 8 * * MON"). */
+  schedule?: string
   inputs: InputSpec[]
   claudeCode: ClaudeCodeSpec
   cliTools: CliToolSpec[]

package/dist/executables/watch-stale-prs/profile.json

@@ -0,0 +1,32 @@
+{
+  "name": "watch-stale-prs",
+  "describe": "Scheduled: list open PRs untouched for N days and report. No agent invocation.",
+
+  "kind": "scheduled",
+  "schedule": "0 8 * * MON",
+
+  "inputs": [],
+
+  "claudeCode": {
+    "model": "inherit",
+    "permissionMode": "default",
+    "maxTurns": null,
+    "systemPromptAppend": null,
+    "tools": [],
+    "hooks": { "PreToolUse": [], "PostToolUse": [], "Stop": [] },
+    "skills": [],
+    "commands": [],
+    "subagents": [],
+    "plugins": [],
+    "mcpServers": []
+  },
+
+  "cliTools": [],
+
+  "scripts": {
+    "preflight": [
+      { "script": "watchStalePrsFlow" }
+    ],
+    "postflight": []
+  }
+}

package/package.json

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