@kody-ade/kody-engine 0.3.42 → 0.3.43

package/dist/bin/kody.js

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.3.42",
+  version: "0.3.43",
   description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",
@@ -50,9 +50,9 @@ var package_default = {
 };
 
 // src/chat-cli.ts
-import { execFileSync as execFileSync23 } from "child_process";
-import * as fs24 from "fs";
-import * as path21 from "path";
+import { execFileSync as execFileSync24 } from "child_process";
+import * as fs26 from "fs";
+import * as path23 from "path";
 
 // src/chat/events.ts
 import * as fs from "fs";
@@ -154,7 +154,7 @@ function loadConfig(projectDir = process.cwd()) {
     throw new Error(`kody.config.json is invalid JSON: ${msg}`);
   }
   const quality = raw.quality ?? {};
-  const git3 = raw.git ?? {};
+  const git4 = raw.git ?? {};
   const github = raw.github ?? {};
   const agent = raw.agent ?? {};
   if (!agent.model || typeof agent.model !== "string") {
@@ -171,7 +171,7 @@ function loadConfig(projectDir = process.cwd()) {
       testUnit: typeof quality.testUnit === "string" ? quality.testUnit : ""
     },
     git: {
-      defaultBranch: typeof git3.defaultBranch === "string" ? git3.defaultBranch : "main"
+      defaultBranch: typeof git4.defaultBranch === "string" ? git4.defaultBranch : "main"
     },
     github: {
       owner: String(github.owner),
@@ -605,9 +605,9 @@ async function emit(sink, type, sessionId, suffix, payload) {
 }
 
 // src/kody-cli.ts
-import { execFileSync as execFileSync22 } from "child_process";
-import * as fs23 from "fs";
-import * as path20 from "path";
+import { execFileSync as execFileSync23 } from "child_process";
+import * as fs25 from "fs";
+import * as path22 from "path";
 
 // src/dispatch.ts
 import * as fs6 from "fs";
@@ -948,8 +948,8 @@ function coerceBare(spec, value) {
 
 // src/executor.ts
 import { spawnSync } from "child_process";
-import * as fs22 from "fs";
-import * as path19 from "path";
+import * as fs24 from "fs";
+import * as path21 from "path";
 
 // src/litellm.ts
 import { execFileSync, spawn } from "child_process";
@@ -3161,6 +3161,101 @@ function ensurePr(opts) {
   return { url, number, draft: opts.draft, action: "created" };
 }
 
+// src/scripts/ensureMemorizePr.ts
+var TITLE_MAX2 = 72;
+var ensureMemorizePr = async (ctx) => {
+  if (ctx.skipAgent && ctx.output.exitCode !== void 0 && ctx.output.exitCode !== 0) {
+    return;
+  }
+  const commitResult = ctx.data.commitResult;
+  const hasCommits = Boolean(ctx.data.hasCommitsAhead);
+  if (!commitResult?.committed && !hasCommits) {
+    process.stdout.write("[kody memorize] no vault changes \u2014 skipping PR\n");
+    ctx.output.exitCode = 0;
+    ctx.output.reason = "no vault changes";
+    return;
+  }
+  const branch = ctx.data.branch;
+  if (!branch) {
+    ctx.output.exitCode = 4;
+    ctx.output.reason = "memorize: no branch on ctx.data.branch";
+    return;
+  }
+  const datestamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const titleBase = `kody memorize: vault update ${datestamp}`;
+  const title = titleBase.length <= TITLE_MAX2 ? titleBase : `${titleBase.slice(0, TITLE_MAX2 - 1)}\u2026`;
+  const body = buildBody(ctx, branch, datestamp);
+  const existing = findExistingPr(branch, ctx.cwd);
+  if (existing) {
+    try {
+      gh2(["pr", "edit", String(existing.number), "--body-file", "-"], { input: body, cwd: ctx.cwd });
+      ctx.output.prUrl = existing.url;
+      ctx.data.prResult = { url: existing.url, number: existing.number, action: "updated" };
+      process.stdout.write(`[kody memorize] updated PR ${existing.url}
+`);
+    } catch (err) {
+      ctx.output.exitCode = 4;
+      ctx.output.reason = `gh pr edit #${existing.number} failed: ${err instanceof Error ? err.message : String(err)}`;
+    }
+    return;
+  }
+  try {
+    const output = gh2(
+      [
+        "pr",
+        "create",
+        "--head",
+        branch,
+        "--base",
+        ctx.config.git.defaultBranch,
+        "--title",
+        title,
+        "--body-file",
+        "-"
+      ],
+      { input: body, cwd: ctx.cwd }
+    );
+    const url = output.trim();
+    const match = url.match(/\/pull\/(\d+)$/);
+    const number = match ? parseInt(match[1], 10) : 0;
+    ctx.output.prUrl = url;
+    ctx.data.prResult = { url, number, action: "created" };
+    process.stdout.write(`[kody memorize] opened PR ${url}
+`);
+  } catch (err) {
+    ctx.output.exitCode = 4;
+    ctx.output.reason = `PR creation failed: ${err instanceof Error ? err.message : String(err)}`;
+  }
+};
+function buildBody(ctx, branch, datestamp) {
+  const lines = [];
+  lines.push("## Summary");
+  lines.push("");
+  const summary = ctx.data.prSummary?.trim();
+  if (summary) {
+    lines.push(summary);
+  } else {
+    lines.push(`Vault knowledge base update for ${datestamp}.`);
+  }
+  lines.push("");
+  const changedFiles = ctx.data.changedFiles ?? [];
+  if (changedFiles.length > 0) {
+    lines.push("## Changes");
+    lines.push("");
+    for (const f of changedFiles.slice(0, 50)) lines.push(`- \`${f}\``);
+    if (changedFiles.length > 50) lines.push(`- \u2026 and ${changedFiles.length - 50} more`);
+    lines.push("");
+  }
+  const recentCount = ctx.data.recentPrCount;
+  if (typeof recentCount === "number") {
+    lines.push(`Synthesized from ${recentCount} merged PR(s) since ${ctx.data.vaultSinceIso ?? "(unknown)"}.`);
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push(`_Opened by kody memorize on branch \`${branch}\`._`);
+  return lines.join("\n");
+}
+
 // src/scripts/ensurePr.ts
 var ensurePr2 = async (ctx) => {
   if (ctx.skipAgent && ctx.output.exitCode !== void 0) {
@@ -4367,8 +4462,333 @@ var loadTaskState = async (ctx) => {
   ctx.data.taskState = readTaskState(target, number, ctx.cwd);
 };
 
-// src/scripts/mergeReleasePr.ts
+// src/scripts/loadVaultContext.ts
+import * as fs21 from "fs";
+import * as path19 from "path";
+var VAULT_DIR_RELATIVE = ".kody/vault";
+var MAX_PAGES = 8;
+var PER_PAGE_MAX_BYTES = 4e3;
+var TOTAL_MAX_BYTES2 = 24e3;
+var TRUNCATED_SUFFIX2 = "\n\n\u2026 (truncated)";
+var loadVaultContext = async (ctx) => {
+  const vaultAbs = path19.join(ctx.cwd, VAULT_DIR_RELATIVE);
+  if (!fs21.existsSync(vaultAbs)) {
+    ctx.data.vaultContext = "";
+    return;
+  }
+  let pages = [];
+  try {
+    pages = collectPages(vaultAbs);
+  } catch {
+    ctx.data.vaultContext = "";
+    return;
+  }
+  if (pages.length === 0) {
+    ctx.data.vaultContext = "";
+    return;
+  }
+  const queryTerms = extractQueryTerms(ctx);
+  const ranked = queryTerms.length > 0 ? scorePages(pages, queryTerms) : sortByRecency(pages);
+  const top = ranked.slice(0, MAX_PAGES);
+  ctx.data.vaultContext = formatBlock(top);
+};
+function collectPages(vaultAbs) {
+  const out = [];
+  walkMd(vaultAbs, (file) => {
+    let stat;
+    try {
+      stat = fs21.statSync(file);
+    } catch {
+      return;
+    }
+    let raw;
+    try {
+      raw = fs21.readFileSync(file, "utf-8");
+    } catch {
+      return;
+    }
+    const fm = raw.match(/^---\s*\n([\s\S]*?)\n---/);
+    const title = fm?.[1]?.match(/^title:\s*(.+)$/m)?.[1]?.trim() ?? path19.basename(file, ".md");
+    const updated = fm?.[1]?.match(/^updated:\s*([0-9T:.+\-Z]+)/m)?.[1]?.trim() ?? "";
+    out.push({
+      relPath: path19.relative(vaultAbs, file),
+      title,
+      updated,
+      content: raw.length > PER_PAGE_MAX_BYTES ? raw.slice(0, PER_PAGE_MAX_BYTES) + TRUNCATED_SUFFIX2 : raw,
+      mtime: stat.mtimeMs
+    });
+  });
+  return out;
+}
+function extractQueryTerms(ctx) {
+  const terms = [];
+  const issue = ctx.data.issue;
+  const pr = ctx.data.pr;
+  if (issue?.title) terms.push(...tokenize(issue.title));
+  if (pr?.title) terms.push(...tokenize(pr.title));
+  return Array.from(new Set(terms)).slice(0, 20);
+}
+function tokenize(s) {
+  return s.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((t) => t.length >= 3);
+}
+function scorePages(pages, terms) {
+  return pages.map((p) => {
+    const haystack = `${p.title} ${p.content}`.toLowerCase();
+    let score = 0;
+    for (const t of terms) {
+      if (haystack.includes(t)) score++;
+    }
+    return { p, score };
+  }).sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    return b.p.mtime - a.p.mtime;
+  }).map((x) => x.p);
+}
+function sortByRecency(pages) {
+  return [...pages].sort((a, b) => {
+    if (a.updated && b.updated && a.updated !== b.updated) {
+      return b.updated.localeCompare(a.updated);
+    }
+    return b.mtime - a.mtime;
+  });
+}
+function formatBlock(pages) {
+  if (pages.length === 0) return "";
+  const lines = ["# Project memory (`.kody/vault/`)", "", "Pages from prior memorize ticks. Treat as advisory context \u2014 confirm against the codebase before acting.", ""];
+  let total = 0;
+  for (const p of pages) {
+    const block = [`## ${p.title} \u2014 \`${p.relPath}\``, "", p.content].join("\n");
+    if (total + block.length > TOTAL_MAX_BYTES2) {
+      lines.push("_\u2026 (further pages truncated to fit budget)_");
+      break;
+    }
+    lines.push(block);
+    lines.push("");
+    total += block.length;
+  }
+  return lines.join("\n");
+}
+function walkMd(root, visit) {
+  let stack = [root];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    let names;
+    try {
+      names = fs21.readdirSync(dir);
+    } catch {
+      continue;
+    }
+    for (const name of names) {
+      if (name.startsWith(".")) continue;
+      const full = path19.join(dir, name);
+      let stat;
+      try {
+        stat = fs21.statSync(full);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory()) {
+        stack.push(full);
+        continue;
+      }
+      if (stat.isFile() && full.endsWith(".md")) visit(full);
+    }
+  }
+}
+
+// src/scripts/memorizeFlow.ts
 import { execFileSync as execFileSync14 } from "child_process";
+import * as fs22 from "fs";
+import * as path20 from "path";
+var VAULT_DIR_RELATIVE2 = ".kody/vault";
+var DEFAULT_LOOKBACK_HOURS = 36;
+var MAX_RECENT_PRS = 25;
+var MAX_VAULT_INDEX_ENTRIES = 200;
+var PR_BODY_TRUNC = 2e3;
+var memorizeFlow = async (ctx) => {
+  const vaultAbs = path20.join(ctx.cwd, VAULT_DIR_RELATIVE2);
+  ensureBranch(ctx, vaultAbs);
+  if (ctx.skipAgent) return;
+  const sinceIso = computeSinceIso(vaultAbs);
+  ctx.data.vaultSinceIso = sinceIso;
+  ctx.data.vaultUpdatedIso = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  ctx.data.vaultDir = VAULT_DIR_RELATIVE2;
+  const recent = fetchRecentPrs(ctx.cwd, sinceIso);
+  ctx.data.recentPrs = formatRecentPrs(recent);
+  ctx.data.recentPrCount = recent.length;
+  if (!fs22.existsSync(vaultAbs)) {
+    fs22.mkdirSync(vaultAbs, { recursive: true });
+  }
+  ctx.data.vaultIndex = formatVaultIndex(vaultAbs);
+  if (recent.length === 0) {
+    process.stdout.write(`[kody memorize] no merged PRs since ${sinceIso}; agent may emit no changes
+`);
+  } else {
+    process.stdout.write(`[kody memorize] ${recent.length} merged PR(s) since ${sinceIso} \u2192 branch ${ctx.data.branch}
+`);
+  }
+};
+function ensureBranch(ctx, vaultAbs) {
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10).replace(/-/g, "");
+  const branch = `kody/memorize-${stamp}`;
+  const defaultBranch = ctx.config.git.defaultBranch;
+  try {
+    git3(["fetch", "origin", defaultBranch], ctx.cwd);
+  } catch {
+  }
+  try {
+    git3(["rev-parse", "--verify", `origin/${branch}`], ctx.cwd);
+    git3(["checkout", "-B", branch, `origin/${branch}`], ctx.cwd);
+  } catch {
+    try {
+      git3(["checkout", "-B", branch, `origin/${defaultBranch}`], ctx.cwd);
+    } catch {
+      git3(["checkout", "-B", branch], ctx.cwd);
+    }
+  }
+  ctx.data.branch = branch;
+  if (!fs22.existsSync(vaultAbs)) {
+    fs22.mkdirSync(vaultAbs, { recursive: true });
+  }
+}
+function computeSinceIso(vaultAbs) {
+  const fallback = new Date(Date.now() - DEFAULT_LOOKBACK_HOURS * 60 * 60 * 1e3).toISOString();
+  if (!fs22.existsSync(vaultAbs)) return fallback;
+  let latest = "";
+  walkMd2(vaultAbs, (file) => {
+    let raw;
+    try {
+      raw = fs22.readFileSync(file, "utf-8");
+    } catch {
+      return;
+    }
+    const m = raw.match(/^---\s*\n([\s\S]*?)\n---/);
+    if (!m) return;
+    const updated = m[1]?.match(/^updated:\s*([0-9T:.+\-Z]+)/m);
+    if (!updated) return;
+    const ts = new Date(updated[1].trim()).toISOString();
+    if (ts > latest) latest = ts;
+  });
+  return latest || fallback;
+}
+function fetchRecentPrs(cwd, sinceIso) {
+  let raw;
+  try {
+    raw = gh2(
+      [
+        "pr",
+        "list",
+        "--state",
+        "merged",
+        "--limit",
+        String(MAX_RECENT_PRS * 2),
+        "--json",
+        "number,title,url,mergedAt,body"
+      ],
+      { cwd }
+    );
+  } catch {
+    return [];
+  }
+  let arr;
+  try {
+    arr = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(arr)) return [];
+  const since = Date.parse(sinceIso);
+  const filtered = [];
+  for (const p of arr) {
+    if (typeof p.number !== "number") continue;
+    const merged = p.mergedAt ? Date.parse(p.mergedAt) : NaN;
+    if (!Number.isFinite(merged) || merged <= since) continue;
+    filtered.push({
+      number: p.number,
+      title: p.title ?? "(no title)",
+      url: p.url ?? "",
+      mergedAt: p.mergedAt ?? "",
+      body: (p.body ?? "").slice(0, PR_BODY_TRUNC)
+    });
+    if (filtered.length >= MAX_RECENT_PRS) break;
+  }
+  return filtered;
+}
+function formatRecentPrs(prs) {
+  if (prs.length === 0) return "_(no merged PRs since the last memorize tick)_";
+  const lines = [];
+  for (const p of prs) {
+    lines.push(`### PR #${p.number} \u2014 ${p.title}`);
+    if (p.url) lines.push(p.url);
+    lines.push(`Merged: ${p.mergedAt}`);
+    lines.push("");
+    if (p.body.trim()) {
+      lines.push(p.body.trim());
+    } else {
+      lines.push("_(no PR body)_");
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function formatVaultIndex(vaultAbs) {
+  const entries = [];
+  walkMd2(vaultAbs, (file) => {
+    if (entries.length >= MAX_VAULT_INDEX_ENTRIES) return;
+    const rel = path20.relative(vaultAbs, file);
+    let title = rel;
+    try {
+      const raw = fs22.readFileSync(file, "utf-8");
+      const m = raw.match(/^---\s*\n([\s\S]*?)\n---/);
+      const titleMatch = m?.[1]?.match(/^title:\s*(.+)$/m);
+      if (titleMatch) title = `${titleMatch[1].trim()} (${rel})`;
+    } catch {
+    }
+    entries.push(`- ${title}`);
+  });
+  if (entries.length === 0) return "_(vault is empty)_";
+  return entries.join("\n");
+}
+function walkMd2(root, visit) {
+  if (!fs22.existsSync(root)) return;
+  let stack = [root];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    let names;
+    try {
+      names = fs22.readdirSync(dir);
+    } catch {
+      continue;
+    }
+    for (const name of names) {
+      if (name.startsWith(".")) continue;
+      const full = path20.join(dir, name);
+      let stat;
+      try {
+        stat = fs22.statSync(full);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory()) {
+        stack.push(full);
+        continue;
+      }
+      if (stat.isFile() && full.endsWith(".md")) visit(full);
+    }
+  }
+}
+function git3(args, cwd) {
+  return execFileSync14("git", args, {
+    encoding: "utf-8",
+    timeout: 3e4,
+    cwd,
+    env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
+    stdio: ["pipe", "pipe", "pipe"]
+  }).trim();
+}
+
+// src/scripts/mergeReleasePr.ts
+import { execFileSync as execFileSync15 } from "child_process";
 var API_TIMEOUT_MS6 = 6e4;
 var mergeReleasePr = async (ctx) => {
   const state = ctx.data.taskState;
@@ -4385,7 +4805,7 @@ var mergeReleasePr = async (ctx) => {
     return;
   }
   try {
-    execFileSync14("gh", ["pr", "merge", String(prNumber), "--merge"], {
+    execFileSync15("gh", ["pr", "merge", String(prNumber), "--merge"], {
       timeout: API_TIMEOUT_MS6,
       cwd: ctx.cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -4650,7 +5070,7 @@ var persistFlowState = async (ctx) => {
 };
 
 // src/scripts/postClassification.ts
-import { execFileSync as execFileSync15 } from "child_process";
+import { execFileSync as execFileSync16 } from "child_process";
 var API_TIMEOUT_MS7 = 3e4;
 var VALID_CLASSES2 = /* @__PURE__ */ new Set(["feature", "bug", "spec", "chore"]);
 var postClassification = async (ctx) => {
@@ -4680,7 +5100,7 @@ var postClassification = async (ctx) => {
   }
   tryAuditComment(issueNumber, `\u{1F50E} kody classified as \`${classification}\`${reason ? ` \u2014 ${reason}` : ""}`, ctx.cwd);
   try {
-    execFileSync15("gh", ["issue", "comment", String(issueNumber), "--body", `@kody ${classification}`], {
+    execFileSync16("gh", ["issue", "comment", String(issueNumber), "--body", `@kody ${classification}`], {
       cwd: ctx.cwd,
       timeout: API_TIMEOUT_MS7,
       stdio: ["ignore", "pipe", "pipe"]
@@ -4714,7 +5134,7 @@ function parseClassification(prSummary) {
 }
 function tryAuditComment(issueNumber, body, cwd) {
   try {
-    execFileSync15("gh", ["issue", "comment", String(issueNumber), "--body", body], {
+    execFileSync16("gh", ["issue", "comment", String(issueNumber), "--body", body], {
       cwd,
       timeout: API_TIMEOUT_MS7,
       stdio: ["ignore", "pipe", "pipe"]
@@ -5010,7 +5430,7 @@ var resolveArtifacts = async (ctx, profile) => {
 };
 
 // src/scripts/resolveFlow.ts
-import { execFileSync as execFileSync16 } from "child_process";
+import { execFileSync as execFileSync17 } from "child_process";
 var CONFLICT_DIFF_MAX_BYTES = 4e4;
 var resolveFlow = async (ctx) => {
   const prNumber = ctx.args.pr;
@@ -5080,7 +5500,7 @@ function buildPreferBlock(prefer, baseBranch) {
 }
 function getConflictedFiles(cwd) {
   try {
-    const out = execFileSync16("git", ["diff", "--name-only", "--diff-filter=U"], {
+    const out = execFileSync17("git", ["diff", "--name-only", "--diff-filter=U"], {
       encoding: "utf-8",
       cwd,
       env: { ...process.env, HUSKY: "0" }
@@ -5095,7 +5515,7 @@ function getConflictMarkersPreview(files, cwd, maxBytes = CONFLICT_DIFF_MAX_BYTE
   let total = 0;
   for (const f of files) {
     try {
-      const content = execFileSync16("cat", [f], { encoding: "utf-8", cwd }).toString();
+      const content = execFileSync17("cat", [f], { encoding: "utf-8", cwd }).toString();
       const snippet = `### ${f}
 
 \`\`\`
@@ -5269,11 +5689,11 @@ var skipAgent = async (ctx) => {
 };
 
 // src/scripts/stageMergeConflicts.ts
-import { execFileSync as execFileSync17 } from "child_process";
+import { execFileSync as execFileSync18 } from "child_process";
 var stageMergeConflicts = async (ctx) => {
   if (ctx.data.agentDone === false) return;
   try {
-    execFileSync17("git", ["add", "-A"], {
+    execFileSync18("git", ["add", "-A"], {
       cwd: ctx.cwd,
       env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
       stdio: "pipe"
@@ -5283,7 +5703,7 @@ var stageMergeConflicts = async (ctx) => {
 };
 
 // src/scripts/startFlow.ts
-import { execFileSync as execFileSync18 } from "child_process";
+import { execFileSync as execFileSync19 } from "child_process";
 var API_TIMEOUT_MS8 = 3e4;
 var startFlow = async (ctx, profile, _agentResult, args) => {
   const entry = args?.entry;
@@ -5317,7 +5737,7 @@ function postKodyComment(target, issueNumber, state, next, cwd) {
   const sub = target === "pr" && state?.core.prUrl ? "pr" : "issue";
   const body = `@kody ${next}`;
   try {
-    execFileSync18("gh", [sub, "comment", String(targetNumber), "--body", body], {
+    execFileSync19("gh", [sub, "comment", String(targetNumber), "--body", body], {
       timeout: API_TIMEOUT_MS8,
       cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -5331,7 +5751,7 @@ function postKodyComment(target, issueNumber, state, next, cwd) {
 }
 
 // src/scripts/syncFlow.ts
-import { execFileSync as execFileSync19 } from "child_process";
+import { execFileSync as execFileSync20 } from "child_process";
 var syncFlow = async (ctx, _profile, args) => {
   const announceOnSuccess = Boolean(args?.announceOnSuccess);
   const prNumber = ctx.args.pr;
@@ -5403,7 +5823,7 @@ function bail2(ctx, prNumber, reason) {
 }
 function revParseHead(cwd) {
   try {
-    return execFileSync19("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).toString().trim();
+    return execFileSync20("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).toString().trim();
   } catch {
     return "";
   }
@@ -5411,9 +5831,9 @@ function revParseHead(cwd) {
 function pushBranch(branch, cwd) {
   const env = { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" };
   try {
-    execFileSync19("git", ["push", "-u", "origin", branch], { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
+    execFileSync20("git", ["push", "-u", "origin", branch], { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
   } catch {
-    execFileSync19("git", ["push", "--force-with-lease", "-u", "origin", branch], {
+    execFileSync20("git", ["push", "--force-with-lease", "-u", "origin", branch], {
       cwd,
       env,
       stdio: ["ignore", "pipe", "pipe"]
@@ -5524,7 +5944,7 @@ var verify = async (ctx) => {
 };
 
 // src/scripts/waitForCi.ts
-import { execFileSync as execFileSync20 } from "child_process";
+import { execFileSync as execFileSync21 } from "child_process";
 var API_TIMEOUT_MS9 = 3e4;
 var waitForCi = async (ctx, _profile, _agentResult, args) => {
   const timeoutMinutes = numArg(args, "timeoutMinutes", 30);
@@ -5602,7 +6022,7 @@ var waitForCi = async (ctx, _profile, _agentResult, args) => {
 };
 function fetchChecks(prNumber, cwd) {
   try {
-    const raw = execFileSync20("gh", ["pr", "checks", String(prNumber), "--json", "bucket,state,name,workflow,link"], {
+    const raw = execFileSync21("gh", ["pr", "checks", String(prNumber), "--json", "bucket,state,name,workflow,link"], {
       encoding: "utf-8",
       timeout: API_TIMEOUT_MS9,
       cwd,
@@ -5777,7 +6197,7 @@ var writeMissionStateFile = async (ctx, _profile, _agentResult) => {
 };
 
 // src/scripts/writeRunSummary.ts
-import * as fs21 from "fs";
+import * as fs23 from "fs";
 var writeRunSummary = async (ctx, profile) => {
   const summaryPath = process.env.GITHUB_STEP_SUMMARY;
   if (!summaryPath) return;
@@ -5799,7 +6219,7 @@ var writeRunSummary = async (ctx, profile) => {
   if (reason) lines.push(`- **Reason:** ${reason}`);
   lines.push("");
   try {
-    fs21.appendFileSync(summaryPath, `${lines.join("\n")}
+    fs23.appendFileSync(summaryPath, `${lines.join("\n")}
 `);
   } catch {
   }
@@ -5815,7 +6235,9 @@ var preflightScripts = {
   syncFlow,
   initFlow,
   watchStalePrsFlow,
+  memorizeFlow,
   loadTaskState,
+  loadVaultContext,
   loadIssueContext,
   loadIssueStateComment,
   loadMissionFromFile,
@@ -5850,6 +6272,7 @@ var postflightScripts = {
   stageMergeConflicts,
   commitAndPush: commitAndPush2,
   ensurePr: ensurePr2,
+  ensureMemorizePr,
   postIssueComment: postIssueComment2,
   postPlanComment,
   postResearchComment,
@@ -5875,7 +6298,7 @@ var allScriptNames = /* @__PURE__ */ new Set([
 ]);
 
 // src/tools.ts
-import { execFileSync as execFileSync21 } from "child_process";
+import { execFileSync as execFileSync22 } from "child_process";
 function verifyCliTools(tools, cwd) {
   const out = [];
   for (const t of tools) out.push(verifyOne(t, cwd));
@@ -5908,7 +6331,7 @@ function verifyOne(tool, cwd) {
 }
 function runShell(cmd, cwd, timeoutMs = 3e4) {
   try {
-    execFileSync21("sh", ["-c", cmd], { cwd, stdio: "pipe", timeout: timeoutMs });
+    execFileSync22("sh", ["-c", cmd], { cwd, stdio: "pipe", timeout: timeoutMs });
     return true;
   } catch {
     return false;
@@ -5976,9 +6399,9 @@ async function runExecutable(profileName, input) {
     data: {},
     output: { exitCode: 0 }
   };
-  const ndjsonDir = path19.join(input.cwd, ".kody");
+  const ndjsonDir = path21.join(input.cwd, ".kody");
   const invokeAgent = async (prompt) => {
-    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path19.isAbsolute(p) ? p : path19.resolve(profile.dir, p)).filter((p) => p.length > 0);
+    const externalPlugins = (profile.claudeCode.plugins ?? []).map((p) => path21.isAbsolute(p) ? p : path21.resolve(profile.dir, p)).filter((p) => p.length > 0);
     const syntheticPath = ctx.data.syntheticPluginPath;
     const pluginPaths = [...externalPlugins, ...syntheticPath ? [syntheticPath] : []];
     return runAgent({
@@ -6056,17 +6479,17 @@ async function runExecutable(profileName, input) {
 function resolveProfilePath(profileName) {
   const found = resolveExecutable(profileName);
   if (found) return found;
-  const here = path19.dirname(new URL(import.meta.url).pathname);
+  const here = path21.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path19.join(here, "executables", profileName, "profile.json"),
+    path21.join(here, "executables", profileName, "profile.json"),
     // same-dir sibling (dev)
-    path19.join(here, "..", "executables", profileName, "profile.json"),
+    path21.join(here, "..", "executables", profileName, "profile.json"),
     // up one (prod: dist/bin → dist/executables)
-    path19.join(here, "..", "src", "executables", profileName, "profile.json")
+    path21.join(here, "..", "src", "executables", profileName, "profile.json")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs22.existsSync(c)) return c;
+    if (fs24.existsSync(c)) return c;
   }
   return candidates[0];
 }
@@ -6159,8 +6582,8 @@ function finish(out) {
 var SHELL_TIMEOUT_MS = 3e5;
 function runShellEntry(entry, ctx, profile) {
   const shellName = entry.shell;
-  const shellPath = path19.join(profile.dir, shellName);
-  if (!fs22.existsSync(shellPath)) {
+  const shellPath = path21.join(profile.dir, shellName);
+  if (!fs24.existsSync(shellPath)) {
     ctx.skipAgent = true;
     ctx.output.exitCode = 99;
     ctx.output.reason = `shell script not found: ${shellName} (looked in ${profile.dir})`;
@@ -6310,14 +6733,14 @@ function resolveAuthToken(env = process.env) {
   return token;
 }
 function detectPackageManager2(cwd) {
-  if (fs23.existsSync(path20.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs23.existsSync(path20.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs23.existsSync(path20.join(cwd, "bun.lockb"))) return "bun";
+  if (fs25.existsSync(path22.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs25.existsSync(path22.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs25.existsSync(path22.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function shellOut(cmd, args, cwd, stream = true) {
   try {
-    execFileSync22(cmd, args, {
+    execFileSync23(cmd, args, {
       cwd,
       stdio: stream ? "inherit" : "pipe",
       env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1", CI: process.env.CI ?? "1" }
@@ -6330,7 +6753,7 @@ function shellOut(cmd, args, cwd, stream = true) {
 }
 function isOnPath(bin) {
   try {
-    execFileSync22("which", [bin], { stdio: "pipe" });
+    execFileSync23("which", [bin], { stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -6364,7 +6787,7 @@ function installLitellmIfNeeded(cwd) {
   } catch {
   }
   try {
-    execFileSync22("python3", ["-c", "import litellm"], { stdio: "pipe" });
+    execFileSync23("python3", ["-c", "import litellm"], { stdio: "pipe" });
     process.stdout.write("\u2192 kody: litellm already installed\n");
     return 0;
   } catch {
@@ -6374,16 +6797,16 @@ function installLitellmIfNeeded(cwd) {
 }
 function configureGitIdentity(cwd) {
   try {
-    const name = execFileSync22("git", ["config", "user.name"], { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
+    const name = execFileSync23("git", ["config", "user.name"], { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
     if (name) return;
   } catch {
   }
   try {
-    execFileSync22("git", ["config", "user.name", "github-actions[bot]"], { cwd, stdio: "pipe" });
+    execFileSync23("git", ["config", "user.name", "github-actions[bot]"], { cwd, stdio: "pipe" });
   } catch {
   }
   try {
-    execFileSync22("git", ["config", "user.email", "41898282+github-actions[bot]@users.noreply.github.com"], {
+    execFileSync23("git", ["config", "user.email", "41898282+github-actions[bot]@users.noreply.github.com"], {
       cwd,
       stdio: "pipe"
     });
@@ -6392,11 +6815,11 @@ function configureGitIdentity(cwd) {
 }
 function postFailureTail(issueNumber, cwd, reason) {
   if (!issueNumber) return;
-  const logPath = path20.join(cwd, ".kody", "last-run.jsonl");
+  const logPath = path22.join(cwd, ".kody", "last-run.jsonl");
   let tail = "";
   try {
-    if (fs23.existsSync(logPath)) {
-      const content = fs23.readFileSync(logPath, "utf-8");
+    if (fs25.existsSync(logPath)) {
+      const content = fs25.readFileSync(logPath, "utf-8");
       tail = content.slice(-3e3);
     }
   } catch {
@@ -6421,7 +6844,7 @@ async function runCi(argv) {
     return 0;
   }
   const args = parseCiArgs(argv);
-  const cwd = args.cwd ? path20.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path22.resolve(args.cwd) : process.cwd();
   let earlyConfig;
   try {
     earlyConfig = loadConfig(cwd);
@@ -6431,9 +6854,9 @@ async function runCi(argv) {
   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)) {
+  if (!args.issueNumber && !autoFallback && eventName === "workflow_dispatch" && dispatchEventPath && fs25.existsSync(dispatchEventPath)) {
     try {
-      const evt = JSON.parse(fs23.readFileSync(dispatchEventPath, "utf-8"));
+      const evt = JSON.parse(fs25.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);
@@ -6648,15 +7071,15 @@ function parseChatArgs(argv, env = process.env) {
   return result;
 }
 function commitChatFiles(cwd, sessionId, verbose) {
-  const sessionFile = path21.relative(cwd, sessionFilePath(cwd, sessionId));
-  const eventsFile = path21.relative(cwd, eventsFilePath(cwd, sessionId));
-  const paths = [sessionFile, eventsFile].filter((p) => fs24.existsSync(path21.join(cwd, p)));
+  const sessionFile = path23.relative(cwd, sessionFilePath(cwd, sessionId));
+  const eventsFile = path23.relative(cwd, eventsFilePath(cwd, sessionId));
+  const paths = [sessionFile, eventsFile].filter((p) => fs26.existsSync(path23.join(cwd, p)));
   if (paths.length === 0) return;
   const opts = { cwd, stdio: verbose ? "inherit" : "pipe" };
   try {
-    execFileSync23("git", ["add", ...paths], opts);
-    execFileSync23("git", ["commit", "--quiet", "-m", `chat: reply for ${sessionId}`], opts);
-    execFileSync23("git", ["push", "--quiet", "origin", "HEAD"], opts);
+    execFileSync24("git", ["add", ...paths], opts);
+    execFileSync24("git", ["commit", "--quiet", "-m", `chat: reply for ${sessionId}`], opts);
+    execFileSync24("git", ["push", "--quiet", "origin", "HEAD"], opts);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     process.stderr.write(`[kody:chat] commit/push skipped: ${msg}
@@ -6688,7 +7111,7 @@ async function runChat(argv) {
 ${CHAT_HELP}`);
     return 64;
   }
-  const cwd = args.cwd ? path21.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path23.resolve(args.cwd) : process.cwd();
   const sessionId = args.sessionId;
   const unpackedSecrets = unpackAllSecrets();
   if (unpackedSecrets > 0) {

package/dist/executables/fix/profile.json

@@ -73,6 +73,7 @@
       { "script": "loadTaskState" },
       { "script": "loadConventions" },
       { "script": "loadPriorArt" },
+      { "script": "loadVaultContext" },
       { "script": "loadCoverageRules" },
       { "script": "composePrompt" }
     ],

package/dist/executables/fix/prompt.md

@@ -21,6 +21,8 @@ You are Kody, an autonomous engineer. Apply the feedback below to the existing P
 
 If a prior-art block is present above, scan it before editing — those are earlier attempts (possibly by you, possibly by a human) at the same fix. Note what was rejected and why; do not repeat a discarded approach.
 
+{{vaultContext}}
+
 # Required steps
 1. **Extract** every actionable item from the feedback. A structured review uses headings like `### Concerns`, `### Suggestions`, and `### Bugs`; each bullet under those headings is a distinct item. `### Strengths`, `### Summary`, and `### Bottom line` are NOT items — skip them. If the feedback has no headings (plain inline feedback), treat the whole feedback as one item.
 2. **Number each item** internally (Item 1, Item 2, …). You will account for every one of them in your final message below.

package/dist/executables/memorize/profile.json

@@ -0,0 +1,48 @@
+{
+  "name": "memorize",
+  "role": "watch",
+  "describe": "Scheduled: synthesize recently merged PRs into the project's .kody/vault/ markdown wiki and open a PR with the changes.",
+  "kind": "scheduled",
+  "schedule": "0 3 * * *",
+  "inputs": [],
+  "claudeCode": {
+    "model": "inherit",
+    "permissionMode": "acceptEdits",
+    "maxTurns": null,
+    "maxThinkingTokens": null,
+    "systemPromptAppend": null,
+    "tools": ["Read", "Write", "Edit", "Bash", "Grep", "Glob"],
+    "hooks": ["block-git"],
+    "skills": [],
+    "commands": [],
+    "subagents": [],
+    "plugins": [],
+    "mcpServers": []
+  },
+  "cliTools": [
+    {
+      "name": "gh",
+      "install": {
+        "required": true,
+        "checkCommand": "command -v gh"
+      },
+      "verify": "gh auth status",
+      "usage": "Use `gh` only for read-only inspection (`gh pr view`, `gh pr list`, `gh api`) when you need extra context on a referenced PR. Never use it to commit, push, or open PRs — the wrapper does that.",
+      "allowedUses": ["pr", "api", "issue"]
+    }
+  ],
+  "inputArtifacts": [],
+  "outputArtifacts": [],
+  "scripts": {
+    "preflight": [
+      { "script": "memorizeFlow" },
+      { "script": "composePrompt" }
+    ],
+    "postflight": [
+      { "script": "parseAgentResult" },
+      { "script": "abortUnfinishedGitOps" },
+      { "script": "commitAndPush" },
+      { "script": "ensureMemorizePr" }
+    ]
+  }
+}

package/dist/executables/memorize/prompt.md

@@ -0,0 +1,59 @@
+You are **kody memorize**, the project's long-term memory keeper. You synthesize recently merged work into a markdown knowledge base at `.kody/vault/` so future kody runs can recall decisions, conventions, and component knowledge.
+
+## What you have
+
+### Recent merged PRs (since {{vaultSinceIso}})
+
+{{recentPrs}}
+
+### Existing vault index
+
+Vault root: `.kody/vault/`
+
+{{vaultIndex}}
+
+## What to do
+
+1. **Read each recent PR's title, body, and (if useful) diff via `gh pr view <n>` / `gh pr diff <n>`.**
+2. **Map each PR to the concept pages it affects** — files like `architecture/<area>.md`, `conventions/<topic>.md`, `decisions/<slug>.md`, `components/<name>.md`, or whatever organization the existing vault uses. If the vault is empty, start with a small set of pages reflecting what you actually learned.
+3. **Update or create those pages.** Each page is a concept (e.g. "executor", "release flow"), NOT a per-PR log. A PR contributes one or more updates — small additions, edits to keep current, links back to the PR URL.
+4. **Cross-link** related pages with relative markdown links so the vault forms a connected graph.
+5. **Be terse.** Each page is reference material, not a story. One short paragraph per fact, bullet lists where useful, links instead of recapping.
+6. **Don't duplicate the codebase.** Capture *what was decided* and *why*, not *how* the code looks — the code is authoritative for that.
+7. **Don't invent.** If a PR's intent isn't clear, skip it rather than guessing.
+
+## Page conventions
+
+- Filename: `kebab-case.md`.
+- Frontmatter (YAML) on every page:
+  ```yaml
+  ---
+  title: <Human Title>
+  type: architecture | convention | decision | component | runbook
+  updated: {{vaultUpdatedIso}}
+  sources:
+    - <PR URL or file path>
+  ---
+  ```
+- Body: one short intro paragraph, then sections.
+- Cross-references via relative links: `[executor](../architecture/executor.md)`.
+
+## Rules
+
+- Edit files only under `.kody/vault/`. Do not touch any other path.
+- Do not commit or push. The wrapper does it.
+- Do not run `git` or `gh` for anything except read-only inspection of referenced PRs.
+- If there is nothing meaningful to add (PRs are trivial chores, all already captured, etc.), say so and emit `DONE` with `COMMIT_MSG: chore(vault): no updates`. The wrapper will detect no changes and skip the PR.
+
+## Output contract (MANDATORY)
+
+End your response with these lines, exactly:
+
+```
+DONE
+COMMIT_MSG: chore(vault): <one-line summary>
+PR_SUMMARY:
+<2–6 line summary of what changed in the vault and why>
+```
+
+If you decide to abort with no changes, emit `DONE` with the no-updates `COMMIT_MSG` and a brief `PR_SUMMARY` saying so.

package/dist/executables/resolve/profile.json

@@ -63,6 +63,9 @@
       {
         "script": "loadConventions"
       },
+      {
+        "script": "loadVaultContext"
+      },
       {
         "script": "loadCoverageRules"
       },

package/dist/executables/resolve/prompt.md

@@ -9,7 +9,7 @@ You are Kody, an autonomous engineer. A `git merge origin/{{baseBranch}}` into P
 
 {{conflictedFiles}}
 
-{{preferBlock}}{{conventionsBlock}}{{toolsUsage}}# Working-tree conflict markers (truncated)
+{{preferBlock}}{{conventionsBlock}}{{vaultContext}}{{toolsUsage}}# Working-tree conflict markers (truncated)
 
 {{conflictMarkersPreview}}
 

package/dist/executables/run/profile.json

@@ -46,6 +46,7 @@
       { "script": "loadTaskState" },
       { "script": "resolveArtifacts" },
       { "script": "loadPriorArt" },
+      { "script": "loadVaultContext" },
       { "script": "loadConventions" },
       { "script": "loadCoverageRules" },
       { "script": "composePrompt" }

package/dist/executables/run/prompt.md

@@ -17,6 +17,8 @@ If the plan above is non-empty, TREAT IT AS AUTHORITATIVE — follow its file li
 
 If a prior-art block is present above, READ THE DIFFS — those are failed or superseded attempts at this same issue. Identify what went wrong (review comments, the fact they were closed without merging, or behavioural gaps in the diff itself) and pick a different approach. Repeating a prior failed attempt is a hard failure even if your tests pass locally.
 
+{{vaultContext}}
+
 # Required steps (all in this one session — no handoff)
 1. **Research** — read the issue carefully, then meet the research floor below before any Edit/Write. Use Grep/Glob/Read to investigate.
 

package/package.json

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

package/templates/kody.yml

@@ -47,6 +47,10 @@ on:
     types: [created]
   pull_request:
     types: [closed]
+  schedule:
+    # Wakes every 5 minutes; kody fans out to whichever scheduled executables
+    # (mission-scheduler, memorize, watch-stale-prs, …) match this minute.
+    - cron: "*/5 * * * *"
 
 jobs:
   run: