@kody-ade/kody-engine 0.3.41 → 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.41",
+  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) {