@neotx/core 0.1.0-alpha.1 → 0.1.0-alpha.10

package/dist/index.js

@@ -74,51 +74,37 @@ import path2 from "path";
 // src/agents/resolver.ts
 function resolveAgent(config, builtIns) {
   const extendsName = config.extends ?? (builtIns.has(config.name) && config.extends === void 0 ? config.name : void 0);
-  const isExtending = extendsName !== void 0;
-  if (isExtending) {
-    const base = builtIns.get(extendsName);
-    if (!base) {
-      throw new Error(
-        `Agent "${config.name}" extends "${extendsName}", but no built-in agent with that name exists.`
-      );
-    }
-    let tools2;
-    if (config.tools) {
-      if (config.tools.includes("$inherited")) {
-        const baseTols = base.tools ?? [];
-        const newTools = config.tools.filter((t) => t !== "$inherited");
-        tools2 = [...baseTols, ...newTools];
-      } else {
-        tools2 = config.tools;
-      }
-    } else {
-      tools2 = base.tools ?? [];
-    }
-    let prompt2;
-    if (config.prompt) {
-      prompt2 = config.prompt;
-    } else {
-      prompt2 = base.prompt ?? "";
-    }
-    if (config.promptAppend) {
-      prompt2 = `${prompt2}
-
-${config.promptAppend}`;
-    }
-    const definition2 = {
-      description: config.description ?? base.description ?? "",
-      prompt: prompt2,
-      tools: tools2,
-      model: config.model ?? base.model ?? "sonnet"
-    };
-    return {
-      name: config.name,
-      definition: definition2,
-      sandbox: config.sandbox ?? base.sandbox ?? "readonly",
-      ...config.maxTurns !== void 0 ? { maxTurns: config.maxTurns } : base.maxTurns !== void 0 ? { maxTurns: base.maxTurns } : {},
-      source: config.name === extendsName && !config.extends ? "built-in" : "extended"
-    };
+  if (extendsName !== void 0) {
+    return resolveExtendedAgent(config, extendsName, builtIns);
+  }
+  return resolveCustomAgent(config);
+}
+function resolveExtendedAgent(config, extendsName, builtIns) {
+  const base = builtIns.get(extendsName);
+  if (!base) {
+    throw new Error(
+      `Agent "${config.name}" extends "${extendsName}", but no built-in agent with that name exists.`
+    );
   }
+  const tools = mergeTools(config.tools, base.tools);
+  const prompt = mergePrompt(config.prompt, config.promptAppend, base.prompt);
+  const mcpServers = mergeMcpServerNames(base.mcpServers, config.mcpServers);
+  const definition = {
+    description: config.description ?? base.description ?? "",
+    prompt,
+    tools,
+    model: config.model ?? base.model ?? "sonnet",
+    ...mcpServers.length > 0 ? { mcpServers } : {}
+  };
+  return {
+    name: config.name,
+    definition,
+    sandbox: config.sandbox ?? base.sandbox ?? "readonly",
+    ...config.maxTurns !== void 0 ? { maxTurns: config.maxTurns } : base.maxTurns !== void 0 ? { maxTurns: base.maxTurns } : {},
+    source: config.name === extendsName && !config.extends ? "built-in" : "extended"
+  };
+}
+function resolveCustomAgent(config) {
   if (!config.description) {
     throw new Error(
       `Agent "${config.name}" has no "extends" and no "description". Add a 'description' field to the agent YAML.`
@@ -155,7 +141,8 @@ ${config.promptAppend}`;
     description: config.description,
     prompt,
     tools,
-    model: config.model
+    model: config.model,
+    ...config.mcpServers?.length ? { mcpServers: config.mcpServers } : {}
   };
   return {
     name: config.name,
@@ -165,6 +152,27 @@ ${config.promptAppend}`;
     source: "custom"
   };
 }
+function mergeTools(configTools, baseTools) {
+  if (!configTools) return baseTools ?? [];
+  if (configTools.includes("$inherited")) {
+    const newTools = configTools.filter((t) => t !== "$inherited");
+    return [...baseTools ?? [], ...newTools];
+  }
+  return configTools;
+}
+function mergePrompt(configPrompt, promptAppend, basePrompt) {
+  let prompt = configPrompt ?? basePrompt ?? "";
+  if (promptAppend) {
+    prompt = `${prompt}
+
+${promptAppend}`;
+  }
+  return prompt;
+}
+function mergeMcpServerNames(base, override) {
+  if (!base?.length && !override?.length) return [];
+  return [.../* @__PURE__ */ new Set([...base ?? [], ...override ?? []])];
+}
 
 // src/agents/registry.ts
 var AgentRegistry = class {
@@ -438,9 +446,6 @@ function getSupervisorDir(name) {
 function getSupervisorStatePath(name) {
   return path3.join(getSupervisorDir(name), "state.json");
 }
-function getSupervisorMemoryPath(name) {
-  return path3.join(getSupervisorDir(name), "memory.md");
-}
 function getSupervisorActivityPath(name) {
   return path3.join(getSupervisorDir(name), "activity.jsonl");
 }
@@ -470,22 +475,22 @@ var mcpServerConfigSchema = z2.discriminatedUnion("type", [
   httpMcpServerSchema,
   stdioMcpServerSchema
 ]);
+var gitStrategySchema = z2.enum(["pr", "branch"]).default("branch");
 var repoConfigSchema = z2.object({
   path: z2.string(),
   name: z2.string().optional(),
   defaultBranch: z2.string().default("main"),
   branchPrefix: z2.string().default("feat"),
   pushRemote: z2.string().default("origin"),
-  autoCreatePr: z2.boolean().default(false),
-  prBaseBranch: z2.string().optional()
+  gitStrategy: gitStrategySchema
 });
 var globalConfigSchema = z2.object({
   repos: z2.array(repoConfigSchema).default([]),
   concurrency: z2.object({
     maxSessions: z2.number().default(5),
-    maxPerRepo: z2.number().default(2),
+    maxPerRepo: z2.number().default(4),
     queueMax: z2.number().default(50)
-  }).default({ maxSessions: 5, maxPerRepo: 2, queueMax: 50 }),
+  }).default({ maxSessions: 5, maxPerRepo: 4, queueMax: 50 }),
   budget: z2.object({
     dailyCapUsd: z2.number().default(500),
     alertThresholdPct: z2.number().default(80)
@@ -496,8 +501,9 @@ var globalConfigSchema = z2.object({
   }).default({ maxRetries: 3, backoffBaseMs: 3e4 }),
   sessions: z2.object({
     initTimeoutMs: z2.number().default(12e4),
-    maxDurationMs: z2.number().default(36e5)
-  }).default({ initTimeoutMs: 12e4, maxDurationMs: 36e5 }),
+    maxDurationMs: z2.number().default(36e5),
+    dir: z2.string().default("/tmp/neo-sessions")
+  }).default({ initTimeoutMs: 12e4, maxDurationMs: 36e5, dir: "/tmp/neo-sessions" }),
   webhooks: z2.array(
     z2.object({
       url: z2.string().url(),
@@ -509,22 +515,30 @@ var globalConfigSchema = z2.object({
   supervisor: z2.object({
     port: z2.number().default(7777),
     secret: z2.string().optional(),
-    idleIntervalMs: z2.number().default(6e4),
-    idleSkipMax: z2.number().default(20),
     heartbeatTimeoutMs: z2.number().default(3e5),
     maxConsecutiveFailures: z2.number().default(3),
     maxEventsPerSec: z2.number().default(10),
     dailyCapUsd: z2.number().default(50),
+    /** How often consolidation runs (ms) */
+    consolidationIntervalMs: z2.number().default(3e5),
+    /** How often compaction runs (ms) */
+    compactionIntervalMs: z2.number().default(36e5),
+    /** Safety timeout for waitForWork (ms) */
+    eventTimeoutMs: z2.number().default(3e5),
     instructions: z2.string().optional()
   }).default({
     port: 7777,
-    idleIntervalMs: 6e4,
-    idleSkipMax: 20,
     heartbeatTimeoutMs: 3e5,
     maxConsecutiveFailures: 3,
     maxEventsPerSec: 10,
-    dailyCapUsd: 50
+    dailyCapUsd: 50,
+    consolidationIntervalMs: 3e5,
+    compactionIntervalMs: 36e5,
+    eventTimeoutMs: 3e5
   }),
+  memory: z2.object({
+    embeddings: z2.boolean().default(true)
+  }).default({ embeddings: true }),
   mcpServers: z2.record(z2.string(), mcpServerConfigSchema).optional(),
   claudeCodePath: z2.string().optional(),
   idempotency: z2.object({
@@ -538,7 +552,7 @@ var DEFAULT_GLOBAL_CONFIG = {
   repos: [],
   concurrency: {
     maxSessions: 5,
-    maxPerRepo: 2,
+    maxPerRepo: 4,
     queueMax: 50
   },
   budget: {
@@ -620,18 +634,40 @@ async function listReposFromGlobalConfig() {
 }
 
 // src/cost/journal.ts
-import { appendFile, mkdir as mkdir2, readFile as readFile3 } from "fs/promises";
+import { appendFile, readFile as readFile3 } from "fs/promises";
+
+// src/shared/date.ts
 import path5 from "path";
+function toDateKey(date) {
+  return date.toISOString().slice(0, 10);
+}
+function fileForDate(date, prefix, dir) {
+  const yyyy = date.getUTCFullYear();
+  const mm = String(date.getUTCMonth() + 1).padStart(2, "0");
+  return path5.join(dir, `${prefix}-${yyyy}-${mm}.jsonl`);
+}
+
+// src/shared/fs.ts
+import { mkdir as mkdir2 } from "fs/promises";
+async function ensureDir(dirPath, cache) {
+  if (cache?.has(dirPath)) {
+    return;
+  }
+  await mkdir2(dirPath, { recursive: true });
+  cache?.add(dirPath);
+}
+
+// src/cost/journal.ts
 var CostJournal = class {
   dir;
-  dirCreated = false;
+  dirCache = /* @__PURE__ */ new Set();
   dayCache = null;
   constructor(options) {
     this.dir = options.dir;
   }
   async append(entry) {
-    await this.ensureDir();
-    const file = this.fileForDate(new Date(entry.timestamp));
+    await ensureDir(this.dir, this.dirCache);
+    const file = fileForDate(new Date(entry.timestamp), "cost", this.dir);
     await appendFile(file, `${JSON.stringify(entry)}
 `, "utf-8");
     this.dayCache = null;
@@ -642,7 +678,7 @@ var CostJournal = class {
     if (this.dayCache?.key === dayKey) {
       return this.dayCache.total;
     }
-    const file = this.fileForDate(d);
+    const file = fileForDate(d, "cost", this.dir);
     let total = 0;
     try {
       const content = await readFile3(file, "utf-8");
@@ -659,20 +695,7 @@ var CostJournal = class {
     this.dayCache = { key: dayKey, total };
     return total;
   }
-  fileForDate(date) {
-    const yyyy = date.getUTCFullYear();
-    const mm = String(date.getUTCMonth() + 1).padStart(2, "0");
-    return path5.join(this.dir, `cost-${yyyy}-${mm}.jsonl`);
-  }
-  async ensureDir() {
-    if (this.dirCreated) return;
-    await mkdir2(this.dir, { recursive: true });
-    this.dirCreated = true;
-  }
 };
-function toDateKey(date) {
-  return date.toISOString().slice(0, 10);
-}
 
 // src/events/emitter.ts
 import { EventEmitter } from "events";
@@ -713,36 +736,29 @@ var NeoEventEmitter = class {
 };
 
 // src/events/journal.ts
-import { appendFile as appendFile2, mkdir as mkdir3 } from "fs/promises";
-import path6 from "path";
+import { appendFile as appendFile2 } from "fs/promises";
 var EventJournal = class {
   dir;
-  dirCreated = false;
+  dirCache = /* @__PURE__ */ new Set();
   constructor(options) {
     this.dir = options.dir;
   }
   async append(event) {
-    await this.ensureDir();
-    const file = this.fileForDate(new Date(event.timestamp));
+    await ensureDir(this.dir, this.dirCache);
+    const file = fileForDate(new Date(event.timestamp), "events", this.dir);
     await appendFile2(file, `${JSON.stringify(event)}
 `, "utf-8");
   }
-  fileForDate(date) {
-    const yyyy = date.getUTCFullYear();
-    const mm = String(date.getUTCMonth() + 1).padStart(2, "0");
-    return path6.join(this.dir, `events-${yyyy}-${mm}.jsonl`);
-  }
-  async ensureDir() {
-    if (this.dirCreated) return;
-    await mkdir3(this.dir, { recursive: true });
-    this.dirCreated = true;
-  }
 };
 
 // src/events/webhook.ts
-import { createHmac } from "crypto";
+import { createHmac, randomUUID } from "crypto";
+var RETRY_EVENT_TYPES = /* @__PURE__ */ new Set(["session:complete", "session:fail", "budget:alert"]);
+var RETRY_MAX_ATTEMPTS = 3;
+var RETRY_BASE_DELAY_MS = 500;
 var WebhookDispatcher = class {
   webhooks;
+  pending = /* @__PURE__ */ new Set();
   constructor(webhooks) {
     this.webhooks = webhooks;
   }
@@ -751,8 +767,10 @@ var WebhookDispatcher = class {
     for (const webhook of this.webhooks) {
       if (!matchesFilter(event.type, webhook.events)) continue;
       const payload = {
+        id: randomUUID(),
         version: 1,
-        event: toSerializable(event),
+        event: event.type,
+        payload: toSerializable(event),
         source: "neo",
         deliveredAt: (/* @__PURE__ */ new Date()).toISOString()
       };
@@ -763,16 +781,45 @@ var WebhookDispatcher = class {
       if (webhook.secret) {
         headers["X-Neo-Signature"] = sign(body, webhook.secret);
       }
-      fetch(webhook.url, {
+      if (RETRY_EVENT_TYPES.has(event.type)) {
+        const p = sendWithRetry(webhook.url, headers, body, webhook.timeoutMs).catch(() => {
+        }).finally(() => this.pending.delete(p));
+        this.pending.add(p);
+      } else {
+        fetch(webhook.url, {
+          method: "POST",
+          headers,
+          body,
+          signal: AbortSignal.timeout(webhook.timeoutMs)
+        }).catch(() => {
+        });
+      }
+    }
+  }
+  /** Wait for all pending terminal webhook deliveries to complete. */
+  async flush() {
+    if (this.pending.size === 0) return;
+    await Promise.allSettled([...this.pending]);
+  }
+};
+async function sendWithRetry(url, headers, body, timeoutMs) {
+  for (let attempt = 1; attempt <= RETRY_MAX_ATTEMPTS; attempt++) {
+    try {
+      const res = await fetch(url, {
         method: "POST",
         headers,
         body,
-        signal: AbortSignal.timeout(webhook.timeoutMs)
-      }).catch(() => {
+        signal: AbortSignal.timeout(timeoutMs)
       });
+      if (res.ok) return;
+    } catch {
+    }
+    if (attempt < RETRY_MAX_ATTEMPTS) {
+      const delay = RETRY_BASE_DELAY_MS * 2 ** (attempt - 1);
+      await new Promise((resolve4) => setTimeout(resolve4, delay));
     }
   }
-};
+}
 function matchesFilter(eventType, filters) {
   if (!filters || filters.length === 0) return true;
   return filters.some((f) => {
@@ -793,74 +840,145 @@ function toSerializable(event) {
   return obj;
 }
 
-// src/isolation/git.ts
+// src/isolation/clone.ts
 import { execFile } from "child_process";
-import { resolve } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { mkdir as mkdir3, readdir as readdir2, rm } from "fs/promises";
+import { dirname, resolve } from "path";
 import { promisify } from "util";
-
-// src/isolation/git-mutex.ts
-var locks = /* @__PURE__ */ new Map();
-async function withGitLock(repoPath, fn) {
-  const previous = locks.get(repoPath) ?? Promise.resolve();
-  let releaseLock;
-  const current = new Promise((resolve4) => {
-    releaseLock = resolve4;
+var execFileAsync = promisify(execFile);
+var GIT_TIMEOUT = 6e4;
+async function createSessionClone(options) {
+  const repoPath = resolve(options.repoPath);
+  const sessionDir = resolve(options.sessionDir);
+  await mkdir3(dirname(sessionDir), { recursive: true });
+  const remoteUrl = await execFileAsync("git", ["config", "--get", "remote.origin.url"], {
+    cwd: repoPath,
+    timeout: GIT_TIMEOUT
+  }).then(({ stdout }) => stdout.trim()).catch(() => "");
+  const cloneSource = remoteUrl || repoPath;
+  await execFileAsync("git", ["clone", "--branch", options.baseBranch, cloneSource, sessionDir], {
+    timeout: GIT_TIMEOUT
   });
-  locks.set(repoPath, current);
-  await previous;
-  try {
-    return await fn();
-  } finally {
-    releaseLock?.();
-    if (locks.get(repoPath) === current) {
-      locks.delete(repoPath);
+  if (options.branch !== options.baseBranch) {
+    const branchExists = await execFileAsync(
+      "git",
+      ["ls-remote", "--heads", "origin", options.branch],
+      { cwd: sessionDir, timeout: GIT_TIMEOUT }
+    ).then(({ stdout }) => stdout.trim().length > 0).catch(() => false);
+    if (branchExists) {
+      await execFileAsync("git", ["fetch", "origin", options.branch], {
+        cwd: sessionDir,
+        timeout: GIT_TIMEOUT
+      });
+      await execFileAsync("git", ["checkout", "-b", options.branch, `origin/${options.branch}`], {
+        cwd: sessionDir,
+        timeout: GIT_TIMEOUT
+      });
+    } else {
+      await execFileAsync("git", ["checkout", "-b", options.branch], {
+        cwd: sessionDir,
+        timeout: GIT_TIMEOUT
+      });
+    }
+  }
+  return { path: sessionDir, branch: options.branch, repoPath };
+}
+async function removeSessionClone(sessionPath) {
+  const absPath = resolve(sessionPath);
+  if (!existsSync2(absPath)) {
+    return;
+  }
+  await rm(absPath, { recursive: true, force: true });
+}
+async function listSessionClones(sessionsBaseDir) {
+  const absBase = resolve(sessionsBaseDir);
+  if (!existsSync2(absBase)) {
+    return [];
+  }
+  const entries = await readdir2(absBase, { withFileTypes: true });
+  const clones = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const clonePath = resolve(absBase, entry.name);
+    try {
+      const { stdout: branchOut } = await execFileAsync(
+        "git",
+        ["rev-parse", "--abbrev-ref", "HEAD"],
+        {
+          cwd: clonePath,
+          timeout: GIT_TIMEOUT
+        }
+      );
+      let repoPath = clonePath;
+      try {
+        const { stdout: originUrl } = await execFileAsync(
+          "git",
+          ["config", "--get", "remote.origin.url"],
+          { cwd: clonePath, timeout: GIT_TIMEOUT }
+        );
+        const url = originUrl.trim();
+        if (url) repoPath = resolve(clonePath, url);
+      } catch {
+      }
+      clones.push({
+        path: clonePath,
+        branch: branchOut.trim(),
+        repoPath
+      });
+    } catch {
     }
   }
+  return clones;
 }
 
 // src/isolation/git.ts
-var execFileAsync = promisify(execFile);
-var GIT_TIMEOUT = 6e4;
+import { execFile as execFile2 } from "child_process";
+import { resolve as resolve2 } from "path";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile2);
+var GIT_TIMEOUT2 = 6e4;
 async function git(repoPath, args) {
-  const { stdout } = await execFileAsync("git", args, {
-    cwd: resolve(repoPath),
-    timeout: GIT_TIMEOUT
+  const { stdout } = await execFileAsync2("git", args, {
+    cwd: resolve2(repoPath),
+    timeout: GIT_TIMEOUT2
   });
   return stdout.trim();
 }
 async function createBranch(repoPath, branch, baseBranch) {
-  await withGitLock(repoPath, () => git(repoPath, ["branch", branch, baseBranch]));
+  await git(repoPath, ["branch", branch, baseBranch]);
 }
 async function pushBranch(repoPath, branch, remote) {
-  await withGitLock(repoPath, () => git(repoPath, ["push", remote, branch]));
+  await git(repoPath, ["push", remote, branch]);
 }
 async function fetchRemote(repoPath, remote) {
-  await withGitLock(repoPath, () => git(repoPath, ["fetch", remote]));
+  await git(repoPath, ["fetch", remote]);
 }
 async function deleteBranch(repoPath, branch) {
-  await withGitLock(repoPath, () => git(repoPath, ["branch", "-D", branch]));
+  await git(repoPath, ["branch", "-D", branch]);
 }
 async function getCurrentBranch(repoPath) {
-  return withGitLock(repoPath, () => git(repoPath, ["rev-parse", "--abbrev-ref", "HEAD"]));
+  return git(repoPath, ["rev-parse", "--abbrev-ref", "HEAD"]);
 }
-function getBranchName(config, runId) {
+function getBranchName(config, runId, branch) {
+  if (branch) return branch;
   const prefix = config.branchPrefix ?? "feat";
   const sanitized = runId.toLowerCase().replace(/[^a-z0-9-]/g, "-");
   return `${prefix}/run-${sanitized}`;
 }
-async function pushWorktreeBranch(worktreePath, branch, remote) {
-  await withGitLock(worktreePath, () => git(worktreePath, ["push", "-u", remote, branch]));
+async function pushSessionBranch(sessionPath, branch, remote) {
+  await git(sessionPath, ["push", "-u", remote, branch]);
 }
 
 // src/isolation/sandbox.ts
-import { resolve as resolve2 } from "path";
+import { resolve as resolve3 } from "path";
 var WRITE_TOOLS = /* @__PURE__ */ new Set(["Write", "Edit", "NotebookEdit"]);
-function buildSandboxConfig(agent, worktreePath) {
+function buildSandboxConfig(agent, sessionPath) {
   const isWritable = agent.sandbox === "writable";
-  const absWorktree = worktreePath ? resolve2(worktreePath) : void 0;
+  const absSession = sessionPath ? resolve3(sessionPath) : void 0;
   const allowedTools = isWritable ? agent.definition.tools : agent.definition.tools.filter((t) => !WRITE_TOOLS.has(t));
-  const readablePaths = absWorktree ? [absWorktree] : [];
-  const writablePaths = isWritable && absWorktree ? [absWorktree] : [];
+  const readablePaths = absSession ? [absSession] : [];
+  const writablePaths = isWritable && absSession ? [absSession] : [];
   return {
     allowedTools,
     readablePaths,
@@ -869,112 +987,9 @@ function buildSandboxConfig(agent, worktreePath) {
   };
 }
 
-// src/isolation/worktree.ts
-import { execFile as execFile2 } from "child_process";
-import { existsSync as existsSync2 } from "fs";
-import { readdir as readdir2, rm } from "fs/promises";
-import { resolve as resolve3 } from "path";
-import { promisify as promisify2 } from "util";
-var execFileAsync2 = promisify2(execFile2);
-var GIT_TIMEOUT2 = 6e4;
-async function createWorktree(options) {
-  const repoPath = resolve3(options.repoPath);
-  const worktreeDir = resolve3(options.worktreeDir);
-  await withGitLock(repoPath, async () => {
-    await execFileAsync2(
-      "git",
-      ["worktree", "add", "-b", options.branch, worktreeDir, options.baseBranch],
-      { cwd: repoPath, timeout: GIT_TIMEOUT2 }
-    );
-  });
-  await execFileAsync2("git", ["config", "core.hooksPath", "/dev/null"], {
-    cwd: worktreeDir,
-    timeout: GIT_TIMEOUT2
-  });
-  return { path: worktreeDir, branch: options.branch, repoPath };
-}
-async function removeWorktree(worktreePath) {
-  const absPath = resolve3(worktreePath);
-  if (!existsSync2(absPath)) {
-    return;
-  }
-  const repoPath = await findRepoForWorktree(absPath);
-  if (repoPath) {
-    await withGitLock(repoPath, async () => {
-      try {
-        await execFileAsync2("git", ["worktree", "remove", absPath, "--force"], {
-          cwd: repoPath,
-          timeout: GIT_TIMEOUT2
-        });
-      } catch {
-        await rm(absPath, { recursive: true, force: true });
-        await execFileAsync2("git", ["worktree", "prune"], {
-          cwd: repoPath,
-          timeout: GIT_TIMEOUT2
-        }).catch(() => {
-        });
-      }
-      await execFileAsync2("git", ["update-index", "--refresh"], {
-        cwd: repoPath,
-        timeout: GIT_TIMEOUT2
-      }).catch(() => {
-      });
-    });
-  } else {
-    await rm(absPath, { recursive: true, force: true });
-  }
-}
-async function listWorktrees(repoPath) {
-  const absRepoPath = resolve3(repoPath);
-  const { stdout } = await execFileAsync2("git", ["worktree", "list", "--porcelain"], {
-    cwd: absRepoPath,
-    timeout: GIT_TIMEOUT2
-  });
-  const worktrees = [];
-  let current;
-  for (const line of stdout.split("\n")) {
-    if (line.startsWith("worktree ")) {
-      if (current) {
-        worktrees.push({ ...current, repoPath: absRepoPath });
-      }
-      current = { path: line.slice(9), branch: "" };
-    } else if (line.startsWith("branch ") && current) {
-      current.branch = line.slice(7).replace("refs/heads/", "");
-    }
-  }
-  if (current) {
-    worktrees.push({ ...current, repoPath: absRepoPath });
-  }
-  return worktrees;
-}
-async function cleanupOrphanedWorktrees(worktreeBaseDir) {
-  const absBase = resolve3(worktreeBaseDir);
-  if (!existsSync2(absBase)) {
-    return;
-  }
-  const entries = await readdir2(absBase, { withFileTypes: true });
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    const worktreePath = resolve3(absBase, entry.name);
-    await removeWorktree(worktreePath);
-  }
-}
-async function findRepoForWorktree(worktreePath) {
-  try {
-    const { stdout } = await execFileAsync2("git", ["rev-parse", "--git-common-dir"], {
-      cwd: worktreePath,
-      timeout: GIT_TIMEOUT2
-    });
-    const gitCommonDir = resolve3(worktreePath, stdout.trim());
-    return resolve3(gitCommonDir, "..");
-  } catch {
-    return void 0;
-  }
-}
-
 // src/middleware/audit-log.ts
 import { appendFile as appendFile3, mkdir as mkdir4 } from "fs/promises";
-import path7 from "path";
+import path6 from "path";
 var DEFAULT_FLUSH_INTERVAL_MS = 500;
 var DEFAULT_FLUSH_SIZE = 20;
 function auditLog(options) {
@@ -988,7 +1003,7 @@ function auditLog(options) {
   let dirCreated = false;
   const buffers = /* @__PURE__ */ new Map();
   let flushTimer;
-  async function ensureDir() {
+  async function ensureDir2() {
     if (!dirCreated) {
       await mkdir4(dir, { recursive: true });
       dirCreated = true;
@@ -996,10 +1011,10 @@ function auditLog(options) {
   }
   async function flushAll() {
     if (buffers.size === 0) return;
-    await ensureDir();
+    await ensureDir2();
     const writes = [];
     for (const [sessionId, lines] of buffers) {
-      const filePath = path7.join(dir, `${sessionId}.jsonl`);
+      const filePath = path6.join(dir, `${sessionId}.jsonl`);
       writes.push(appendFile3(filePath, lines.join(""), "utf-8"));
     }
     buffers.clear();
@@ -1008,8 +1023,8 @@ function auditLog(options) {
   async function flushSession(sessionId) {
     const lines = buffers.get(sessionId);
     if (!lines || lines.length === 0) return;
-    await ensureDir();
-    const filePath = path7.join(dir, `${sessionId}.jsonl`);
+    await ensureDir2();
+    const filePath = path6.join(dir, `${sessionId}.jsonl`);
     await appendFile3(filePath, lines.join(""), "utf-8");
     buffers.delete(sessionId);
   }
@@ -1174,10 +1189,116 @@ function loopDetection(options) {
 }
 
 // src/orchestrator.ts
-import { randomUUID } from "crypto";
-import { existsSync as existsSync4 } from "fs";
-import { mkdir as mkdir5, readdir as readdir4, readFile as readFile5, writeFile as writeFile2 } from "fs/promises";
-import path9 from "path";
+import { randomUUID as randomUUID3 } from "crypto";
+import { existsSync as existsSync6 } from "fs";
+import { mkdir as mkdir6, readFile as readFile7 } from "fs/promises";
+import path11 from "path";
+
+// src/orchestrator/run-store.ts
+import { existsSync as existsSync3 } from "fs";
+import { mkdir as mkdir5, readdir as readdir3, readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
+import path7 from "path";
+
+// src/shared/process.ts
+function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "EPERM") {
+      return true;
+    }
+    return false;
+  }
+}
+
+// src/orchestrator/run-store.ts
+var ORPHAN_GRACE_PERIOD_MS = 3e4;
+var RunStore = class {
+  runsDir;
+  createdDirs = /* @__PURE__ */ new Set();
+  constructor(options = {}) {
+    this.runsDir = options.runsDir ?? getRunsDir();
+  }
+  /**
+   * Persist a run to disk. Creates the repo subdirectory if needed.
+   * Fails silently — run persistence is non-critical.
+   */
+  async persistRun(run) {
+    try {
+      const slug = toRepoSlug({ path: run.repo });
+      const repoDir = getRepoRunsDir(slug);
+      if (!this.createdDirs.has(repoDir)) {
+        await mkdir5(repoDir, { recursive: true });
+        this.createdDirs.add(repoDir);
+      }
+      const filePath = path7.join(repoDir, `${run.runId}.json`);
+      await writeFile2(filePath, JSON.stringify(run, null, 2), "utf-8");
+    } catch {
+    }
+  }
+  /**
+   * Find all runs that were left in "running" state but whose process died.
+   * Returns them so the caller can emit failure events and update status.
+   */
+  async recoverOrphanedRuns() {
+    if (!existsSync3(this.runsDir)) return [];
+    const orphaned = [];
+    try {
+      const jsonFiles = await this.collectRunFiles();
+      for (const filePath of jsonFiles) {
+        const run = await this.recoverRunIfOrphaned(filePath);
+        if (run) orphaned.push(run);
+      }
+    } catch {
+    }
+    return orphaned;
+  }
+  /**
+   * Collect all .json run files from the runs directory tree.
+   * Searches both top-level and repo subdirectories.
+   */
+  async collectRunFiles() {
+    const entries = await readdir3(this.runsDir, { withFileTypes: true });
+    const jsonFiles = [];
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const subDir = path7.join(this.runsDir, entry.name);
+        const subFiles = await readdir3(subDir);
+        for (const f of subFiles) {
+          if (f.endsWith(".json")) jsonFiles.push(path7.join(subDir, f));
+        }
+      } else if (entry.name.endsWith(".json")) {
+        jsonFiles.push(path7.join(this.runsDir, entry.name));
+      }
+    }
+    return jsonFiles;
+  }
+  /**
+   * Check if a run file represents an orphaned run.
+   * If so, update its status to "failed" and return it.
+   */
+  async recoverRunIfOrphaned(filePath) {
+    const content = await readFile4(filePath, "utf-8");
+    const run = JSON.parse(content);
+    if (run.status !== "running") return null;
+    if (run.pid && run.pid === process.pid) return null;
+    if (run.pid && isProcessAlive(run.pid)) return null;
+    const ageMs = Date.now() - new Date(run.createdAt).getTime();
+    if (ageMs < ORPHAN_GRACE_PERIOD_MS) return null;
+    run.status = "failed";
+    run.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await writeFile2(filePath, JSON.stringify(run, null, 2), "utf-8");
+    return run;
+  }
+};
+
+// src/runner/session-executor.ts
+import { readFile as readFile5 } from "fs/promises";
+import path8 from "path";
 
 // src/runner/output-parser.ts
 function extractJson(raw) {
@@ -1195,37 +1316,61 @@ function extractJson(raw) {
   }
   return void 0;
 }
+var PR_URL_REGEX = /^PR_URL:\s*(https?:\/\/\S+)/m;
+function extractPrUrl(raw) {
+  const match = raw.match(PR_URL_REGEX);
+  if (!match?.[1]) return void 0;
+  const prUrl = match[1];
+  const numberMatch = prUrl.match(/\/pull\/(\d+)/);
+  if (numberMatch?.[1]) {
+    return { prUrl, prNumber: Number.parseInt(numberMatch[1], 10) };
+  }
+  return { prUrl };
+}
 function parseOutput(raw, schema) {
+  const prInfo = extractPrUrl(raw);
+  const base = { rawOutput: raw };
+  if (prInfo) {
+    base.prUrl = prInfo.prUrl;
+    if (prInfo.prNumber !== void 0) {
+      base.prNumber = prInfo.prNumber;
+    }
+  }
   if (!schema) {
-    return { rawOutput: raw };
+    return base;
   }
   const extracted = extractJson(raw);
   if (extracted === void 0) {
-    return {
-      rawOutput: raw,
-      parseError: "Failed to extract JSON from output"
-    };
+    base.parseError = "Failed to extract JSON from output";
+    return base;
   }
   const result = schema.safeParse(extracted);
   if (!result.success) {
-    return {
-      rawOutput: raw,
-      parseError: `Schema validation failed: ${result.error.message}`
-    };
+    base.parseError = `Schema validation failed: ${result.error.message}`;
+    return base;
   }
-  return {
-    rawOutput: raw,
-    output: result.data
-  };
+  base.output = result.data;
+  return base;
 }
 
-// src/runner/session.ts
+// src/sdk-types.ts
 function isInitMessage(msg) {
   return msg.type === "system" && msg.subtype === "init";
 }
 function isResultMessage(msg) {
   return msg.type === "result";
 }
+function isAssistantMessage(msg) {
+  return msg.type === "assistant" && !msg.subtype;
+}
+function isToolUseMessage(msg) {
+  return msg.type === "assistant" && msg.subtype === "tool_use";
+}
+function isToolResultMessage(msg) {
+  return msg.type === "assistant" && msg.subtype === "tool_result";
+}
+
+// src/runner/session.ts
 function checkAborted(signal) {
   if (signal.aborted) {
     const reason = signal.reason;
@@ -1237,8 +1382,36 @@ function toSessionError(error, isTimeout, sessionId) {
   const message = error instanceof Error ? error.message : String(error);
   return new SessionError(message, isTimeout ? "timeout" : "unknown", sessionId);
 }
+function buildQueryOptions(options) {
+  const { sessionPath, sandboxConfig } = options;
+  const queryOptions = {
+    // Always pass cwd: session clone for writable agents, repo root for readonly.
+    // Without this, readonly agents default to process.cwd() and may write to main tree.
+    cwd: sessionPath ?? options.repoPath,
+    // maxTurns: agent.maxTurns,
+    allowedTools: sandboxConfig.allowedTools,
+    // Workers run detached without a TTY — bypass interactive permission prompts.
+    // Required pair: permissionMode alone is not enough, SDK also needs the flag.
+    permissionMode: "bypassPermissions",
+    allowDangerouslySkipPermissions: true,
+    // Load project-level CLAUDE.md so agents inherit project rules and conventions.
+    settingSources: ["user", "project", "local"],
+    // Don't persist agent sessions — they are ephemeral clones.
+    persistSession: false
+  };
+  if (options.resumeSessionId) {
+    queryOptions.resume = options.resumeSessionId;
+  }
+  if (options.mcpServers && Object.keys(options.mcpServers).length > 0) {
+    queryOptions.mcpServers = options.mcpServers;
+  }
+  if (options.env && Object.keys(options.env).length > 0) {
+    queryOptions.env = { ...process.env, ...options.env };
+  }
+  return queryOptions;
+}
 async function runSession(options) {
-  const { agent, prompt, worktreePath, sandboxConfig, initTimeoutMs, maxDurationMs, onEvent } = options;
+  const { prompt, initTimeoutMs, maxDurationMs, onEvent } = options;
   const startTime = Date.now();
   let sessionId = "";
   const abortController = new AbortController();
@@ -1250,30 +1423,11 @@ async function runSession(options) {
   }, maxDurationMs);
   try {
     const sdk = await import("@anthropic-ai/claude-agent-sdk");
-    const queryOptions = {
-      // Always pass cwd: worktree for writable agents, repo root for readonly.
-      // Without this, readonly agents default to process.cwd() and may write to main tree.
-      cwd: worktreePath ?? options.repoPath,
-      maxTurns: agent.maxTurns,
-      allowedTools: sandboxConfig.allowedTools
-    };
-    if (options.resumeSessionId) {
-      queryOptions.resume = options.resumeSessionId;
-    }
-    if (options.mcpServers?.length) {
-      queryOptions.mcpServers = options.mcpServers;
-    }
+    const queryOptions = buildQueryOptions(options);
     let output = "";
     let costUsd = 0;
     let turnCount = 0;
-    const fullPrompt = agent.definition.prompt ? `${agent.definition.prompt}
-
----
-
-## Task
-
-${prompt}` : prompt;
-    const stream = sdk.query({ prompt: fullPrompt, options: queryOptions });
+    const stream = sdk.query({ prompt, options: queryOptions });
     for await (const message of stream) {
       checkAborted(abortController.signal);
       const msg = message;
@@ -1387,44 +1541,725 @@ async function runWithRecovery(options) {
   throw new Error("Recovery failed: unreachable");
 }
 
-// src/workflows/registry.ts
-import { existsSync as existsSync3 } from "fs";
-import { readdir as readdir3 } from "fs/promises";
-import path8 from "path";
+// src/runner/session-executor.ts
+var INSTRUCTIONS_PATH = ".neo/INSTRUCTIONS.md";
+async function loadRepoInstructions(repoPath) {
+  const filePath = path8.join(repoPath, INSTRUCTIONS_PATH);
+  try {
+    return await readFile5(filePath, "utf-8");
+  } catch {
+    return void 0;
+  }
+}
+function buildGitStrategyInstructions(strategy, agent, branch, baseBranch, remote, metadata) {
+  const prNumber = metadata?.prNumber;
+  if (agent.sandbox !== "writable") {
+    if (prNumber) {
+      return `## Pull Request
 
-// src/workflows/loader.ts
-import { readFile as readFile4 } from "fs/promises";
-import { parse } from "yaml";
-import { z as z3 } from "zod";
-var workflowStepDefSchema = z3.object({
-  type: z3.literal("step").optional().default("step"),
-  agent: z3.string(),
-  dependsOn: z3.array(z3.string()).optional(),
-  prompt: z3.string().optional(),
-  sandbox: z3.enum(["writable", "readonly"]).optional(),
-  maxTurns: z3.number().int().positive().optional(),
-  mcpServers: z3.array(z3.string()).optional(),
-  recovery: z3.object({
-    maxRetries: z3.number().int().nonnegative().optional(),
-    nonRetryable: z3.array(z3.string()).optional()
-  }).optional(),
-  condition: z3.string().optional()
-});
-var workflowGateDefSchema = z3.object({
-  type: z3.literal("gate"),
-  dependsOn: z3.array(z3.string()).optional(),
-  description: z3.string(),
-  timeout: z3.string().optional(),
-  autoApprove: z3.boolean().optional()
-});
-var workflowHeaderSchema = z3.object({
-  name: z3.string().min(1),
-  description: z3.string().optional(),
-  steps: z3.record(z3.string(), z3.unknown())
-});
-function parseStepEntry(stepName, stepValue) {
-  const obj = stepValue;
-  const schema = obj.type === "gate" ? workflowGateDefSchema : workflowStepDefSchema;
+PR #${String(prNumber)} is open for this task. After your review, leave your findings as a comment: \`gh pr comment ${String(prNumber)} --body "..."\`.`;
+    }
+    return null;
+  }
+  if (strategy === "pr") {
+    if (prNumber) {
+      return `## Git workflow
+
+You are on branch \`${branch}\`.
+An open PR exists: #${String(prNumber)}.
+After committing, push your changes to the branch. The PR will be updated automatically.
+Leave a review comment on the PR summarizing what you did: \`gh pr comment ${String(prNumber)} --body "..."\`.`;
+    }
+    return `## Git workflow
+
+You are on branch \`${branch}\` (base: \`${baseBranch}\`).
+After committing:
+1. Push: \`git push -u ${remote} ${branch}\`
+2. Create a PR against \`${baseBranch}\` \u2014 choose a title and description that reflect the work you completed. End the PR body with: \`\u{1F916} Generated with [neo](https://neotx.dev)\`
+3. Output the PR URL on a dedicated line: \`PR_URL: <url>\``;
+  }
+  return `## Git workflow
+
+You are on branch \`${branch}\` (base: \`${baseBranch}\`).
+Commit your changes. The branch will be pushed automatically.`;
+}
+function buildReportingInstructions(_runId) {
+  return `## Reporting & Memory
+
+### Progress reporting (real-time, visible in TUI)
+Chain \`neo log\` with the command that triggered it \u2014 never standalone:
+\`\`\`bash
+pnpm test && neo log milestone "all tests passing" || neo log blocker "tests failing"
+git push origin HEAD && neo log action "pushed to branch"
+neo log decision "chose JWT over sessions \u2014 simpler for MVP"
+\`\`\`
+
+### Memory (persistent, injected into future agent prompts)
+Write discoveries so the next agent on this repo starts smarter.
+
+**Be selective** \u2014 only write a memory if it would change HOW you or future agents approach work:
+\`\`\`bash
+# GOOD: affects workflow decisions
+neo memory write --type fact --scope $NEO_REPOSITORY "CI requires pnpm build before push \u2014 no auto-rebuild in pipeline"
+neo memory write --type fact --scope $NEO_REPOSITORY "Biome enforces complexity max 20 \u2014 extract helpers for large functions"
+neo memory write --type procedure --scope $NEO_REPOSITORY "Integration tests require DATABASE_URL env var \u2014 set before running"
+
+# BAD: trivial or derivable \u2014 do NOT write these
+# "packages/core has 71 files" \u2014 derivable from ls
+# "Uses React 19" \u2014 visible in package.json
+# "apps/web has no test framework" \u2014 derivable from ls/cat
+\`\`\`
+
+**The test**: if \`cat package.json\`, \`ls\`, or reading the README can answer it, do NOT memorize it. Only memorize truths that affect decisions or non-obvious workflows learned from failure.
+
+Write at key moments: after resolving a non-obvious issue, after discovering a build/CI quirk, before finishing.`;
+}
+function buildFullPrompt(agentPrompt, repoInstructions, gitInstructions, taskPrompt, memoryContext, cwdInstructions, reportingInstructions) {
+  const sections = [];
+  if (agentPrompt) sections.push(agentPrompt);
+  if (cwdInstructions) sections.push(cwdInstructions);
+  if (memoryContext) sections.push(memoryContext);
+  if (repoInstructions) sections.push(`## Repository instructions
+
+${repoInstructions}`);
+  if (gitInstructions) sections.push(gitInstructions);
+  if (reportingInstructions) sections.push(reportingInstructions);
+  sections.push(`## Task
+
+${taskPrompt}`);
+  return sections.join("\n\n---\n\n");
+}
+function buildMiddlewareContext(runId, workflow, step, agent, repo, getContextValue) {
+  const store = /* @__PURE__ */ new Map();
+  return {
+    runId,
+    workflow,
+    step,
+    agent,
+    repo,
+    get: ((key) => {
+      const value = getContextValue(key);
+      if (value !== void 0) return value;
+      return store.get(key);
+    }),
+    set: ((key, value) => {
+      store.set(key, value);
+    })
+  };
+}
+var SessionExecutor = class {
+  constructor(config, getContextValue) {
+    this.config = config;
+    this.getContextValue = getContextValue;
+  }
+  /**
+   * Execute an agent session with the given input and dependencies.
+   * Handles prompt building, SDK invocation via recovery wrapper, and output parsing.
+   */
+  async execute(input, deps) {
+    const {
+      runId,
+      agent,
+      stepDef,
+      repoConfig,
+      repoPath,
+      prompt: taskPrompt,
+      branch,
+      gitStrategy,
+      sessionPath,
+      metadata,
+      startedAt
+    } = input;
+    const { middleware, mcpServers, memoryContext, onAttempt } = deps;
+    if (agent.sandbox === "writable" && !branch) {
+      throw new Error(
+        "Validation error: --branch is required for writable agents. Provide an explicit branch name (e.g. --branch feat/PROJ-42-description)."
+      );
+    }
+    const branchName = agent.sandbox === "writable" ? branch : "";
+    const sandboxConfig = buildSandboxConfig(agent, sessionPath);
+    const chain = buildMiddlewareChain(middleware);
+    const middlewareContext = buildMiddlewareContext(
+      runId,
+      stepDef.prompt ? "workflow" : "direct",
+      "execute",
+      agent.name,
+      repoPath,
+      this.getContextValue
+    );
+    const hooks = buildSDKHooks(chain, middlewareContext, middleware);
+    const repoInstructions = await loadRepoInstructions(repoPath);
+    const gitInstructions = buildGitStrategyInstructions(
+      gitStrategy,
+      agent,
+      branchName,
+      repoConfig.defaultBranch,
+      repoConfig.pushRemote ?? "origin",
+      metadata
+    );
+    const cwdInstructions = sessionPath ? `## Working directory
+
+You are working in an isolated clone at: \`${sessionPath}\`
+ALWAYS run commands from this directory. NEVER cd to or operate on any other repository.` : void 0;
+    const reportingInstructions = buildReportingInstructions(runId);
+    const fullPrompt = buildFullPrompt(
+      agent.definition.prompt,
+      repoInstructions,
+      gitInstructions,
+      stepDef.prompt ?? taskPrompt,
+      memoryContext,
+      cwdInstructions,
+      reportingInstructions
+    );
+    const recoveryOpts = stepDef.recovery;
+    const agentEnv = {
+      NEO_RUN_ID: runId,
+      NEO_AGENT_NAME: agent.name,
+      NEO_REPOSITORY: repoPath
+    };
+    const sessionResult = await runWithRecovery({
+      agent,
+      prompt: fullPrompt,
+      repoPath,
+      sandboxConfig,
+      hooks,
+      env: agentEnv,
+      initTimeoutMs: this.config.initTimeoutMs,
+      maxDurationMs: this.config.maxDurationMs,
+      maxRetries: recoveryOpts?.maxRetries ?? this.config.maxRetries,
+      backoffBaseMs: this.config.backoffBaseMs,
+      ...sessionPath ? { sessionPath } : {},
+      ...mcpServers ? { mcpServers } : {},
+      ...recoveryOpts?.nonRetryable ? { nonRetryable: recoveryOpts.nonRetryable } : {},
+      ...onAttempt ? { onAttempt } : {}
+    });
+    const parsed = parseOutput(sessionResult.output);
+    const result = {
+      status: "success",
+      sessionId: sessionResult.sessionId,
+      output: parsed.output ?? parsed.rawOutput,
+      rawOutput: sessionResult.output,
+      costUsd: sessionResult.costUsd,
+      durationMs: sessionResult.durationMs,
+      agent: agent.name,
+      startedAt,
+      completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      attempt: 1,
+      parsed
+    };
+    if (parsed.prUrl) {
+      result.prUrl = parsed.prUrl;
+    }
+    if (parsed.prNumber !== void 0) {
+      result.prNumber = parsed.prNumber;
+    }
+    return result;
+  }
+};
+
+// src/supervisor/memory/embedder.ts
+var extractorPromise = null;
+function getExtractor() {
+  if (!extractorPromise) {
+    extractorPromise = (async () => {
+      const { pipeline } = await import("@huggingface/transformers");
+      return pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2", {
+        dtype: "fp32"
+      });
+    })();
+  }
+  return extractorPromise;
+}
+var LocalEmbedder = class {
+  dimensions = 384;
+  async embed(texts) {
+    const extractor = await getExtractor();
+    const output = await extractor(texts, { pooling: "mean", normalize: true });
+    return output.tolist();
+  }
+};
+
+// src/supervisor/memory/entry.ts
+import { z as z3 } from "zod";
+var memoryTypeSchema = z3.enum([
+  "fact",
+  "procedure",
+  "episode",
+  "focus",
+  "feedback",
+  "task"
+]);
+var memoryEntrySchema = z3.object({
+  id: z3.string(),
+  type: memoryTypeSchema,
+  scope: z3.string(),
+  // "global" | repo path
+  content: z3.string(),
+  source: z3.string(),
+  // "developer" | "reviewer" | "supervisor" | "user"
+  tags: z3.array(z3.string()).default([]),
+  // Lifecycle
+  createdAt: z3.string(),
+  lastAccessedAt: z3.string(),
+  accessCount: z3.number().default(0),
+  // Optional per-type fields
+  expiresAt: z3.string().optional(),
+  // focus TTL
+  outcome: z3.string().optional(),
+  // episode: success/failure/blocked
+  runId: z3.string().optional(),
+  category: z3.string().optional(),
+  // feedback: reviewer issue category
+  severity: z3.string().optional(),
+  supersedes: z3.string().optional()
+  // contradiction resolution
+});
+var memoryWriteInputSchema = z3.object({
+  type: memoryTypeSchema,
+  scope: z3.string().default("global"),
+  content: z3.string(),
+  source: z3.string().default("user"),
+  tags: z3.array(z3.string()).default([]),
+  expiresAt: z3.string().optional(),
+  outcome: z3.string().optional(),
+  runId: z3.string().optional(),
+  category: z3.string().optional(),
+  severity: z3.string().optional(),
+  supersedes: z3.string().optional()
+});
+
+// src/supervisor/memory/format.ts
+var TYPE_LABELS = {
+  fact: "Fact",
+  procedure: "How-to",
+  episode: "Past run",
+  focus: "Current focus",
+  feedback: "Recurring issue"
+};
+var TYPE_ICONS = {
+  fact: "\xB7",
+  procedure: "\u2192",
+  episode: "\u25C7",
+  focus: "\u2605",
+  feedback: "\u26A0"
+};
+function formatMemoriesForPrompt(memories) {
+  if (memories.length === 0) return "";
+  const grouped = /* @__PURE__ */ new Map();
+  for (const m of memories) {
+    const group = grouped.get(m.type) ?? [];
+    group.push(m);
+    grouped.set(m.type, group);
+  }
+  const sections = [];
+  for (const [type, entries] of grouped) {
+    const label = TYPE_LABELS[type] ?? type;
+    const icon = TYPE_ICONS[type] ?? "\xB7";
+    const lines = entries.map((e) => {
+      const confidence = e.accessCount >= 3 ? "" : " (unconfirmed)";
+      return `${icon} ${e.content}${confidence}`;
+    });
+    sections.push(`### ${label}s
+${lines.join("\n")}`);
+  }
+  return `## Known context for this repository
+
+${sections.join("\n\n")}`;
+}
+
+// src/supervisor/memory/store.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { existsSync as existsSync4, mkdirSync } from "fs";
+import { createRequire } from "module";
+import path9 from "path";
+var esmRequire = createRequire(import.meta.url);
+var MemoryStore = class {
+  db;
+  embedder;
+  hasVec;
+  constructor(dbPath, embedder) {
+    const dir = path9.dirname(dbPath);
+    if (!existsSync4(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    const Database = esmRequire("better-sqlite3");
+    this.db = new Database(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+    this.embedder = embedder ?? null;
+    this.hasVec = false;
+    this.initSchema();
+  }
+  // ─── Schema initialization ───────────────────────────
+  initSchema() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS memories (
+        id TEXT PRIMARY KEY,
+        type TEXT NOT NULL CHECK(type IN ('fact','procedure','episode','focus','feedback','task')),
+        scope TEXT NOT NULL,
+        content TEXT NOT NULL,
+        source TEXT NOT NULL,
+        tags TEXT DEFAULT '[]',
+        created_at TEXT NOT NULL,
+        last_accessed_at TEXT NOT NULL,
+        access_count INTEGER DEFAULT 0,
+        expires_at TEXT,
+        outcome TEXT,
+        run_id TEXT,
+        category TEXT,
+        severity TEXT,
+        supersedes TEXT
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_mem_type_scope ON memories(type, scope);
+      CREATE INDEX IF NOT EXISTS idx_mem_created ON memories(created_at);
+    `);
+    this.migrateCheckConstraint();
+    this.db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+        content,
+        content='memories',
+        content_rowid='rowid',
+        tokenize='porter'
+      );
+    `);
+    this.db.exec(`
+      CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
+        INSERT INTO memories_fts(rowid, content) VALUES (new.rowid, new.content);
+      END;
+      CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
+        INSERT INTO memories_fts(memories_fts, rowid, content) VALUES('delete', old.rowid, old.content);
+      END;
+      CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
+        INSERT INTO memories_fts(memories_fts, rowid, content) VALUES('delete', old.rowid, old.content);
+        INSERT INTO memories_fts(rowid, content) VALUES (new.rowid, new.content);
+      END;
+    `);
+    if (this.embedder) {
+      try {
+        const sqliteVec = esmRequire("sqlite-vec");
+        sqliteVec.load(this.db);
+        this.db.exec(`
+          CREATE VIRTUAL TABLE IF NOT EXISTS memories_vec USING vec0(
+            memory_id TEXT,
+            embedding float[${this.embedder.dimensions}]
+          );
+        `);
+        this.hasVec = true;
+      } catch {
+        this.hasVec = false;
+      }
+    }
+  }
+  /**
+   * Migrate existing tables whose CHECK constraint predates the 'task' type.
+   * SQLite doesn't allow ALTER CHECK, so we recreate the table if needed.
+   */
+  migrateCheckConstraint() {
+    const tableInfo = this.db.prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name='memories'").get();
+    if (!tableInfo || tableInfo.sql.includes("'task'")) return;
+    this.db.exec(`
+      ALTER TABLE memories RENAME TO memories_old;
+
+      CREATE TABLE memories (
+        id TEXT PRIMARY KEY,
+        type TEXT NOT NULL CHECK(type IN ('fact','procedure','episode','focus','feedback','task')),
+        scope TEXT NOT NULL,
+        content TEXT NOT NULL,
+        source TEXT NOT NULL,
+        tags TEXT DEFAULT '[]',
+        created_at TEXT NOT NULL,
+        last_accessed_at TEXT NOT NULL,
+        access_count INTEGER DEFAULT 0,
+        expires_at TEXT,
+        outcome TEXT,
+        run_id TEXT,
+        category TEXT,
+        severity TEXT,
+        supersedes TEXT
+      );
+
+      INSERT INTO memories SELECT * FROM memories_old;
+      DROP TABLE memories_old;
+    `);
+  }
+  // ─── Write ───────────────────────────────────────────
+  async write(input) {
+    const id = `mem_${randomUUID2().slice(0, 12)}`;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.prepare(
+      `INSERT INTO memories (id, type, scope, content, source, tags, created_at, last_accessed_at, access_count, expires_at, outcome, run_id, category, severity, supersedes)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      id,
+      input.type,
+      input.scope ?? "global",
+      input.content,
+      input.source ?? "user",
+      JSON.stringify(input.tags ?? []),
+      now,
+      now,
+      input.expiresAt ?? null,
+      input.outcome ?? null,
+      input.runId ?? null,
+      input.category ?? null,
+      input.severity ?? null,
+      input.supersedes ?? null
+    );
+    if (this.embedder && this.hasVec) {
+      try {
+        const [vector] = await this.embedder.embed([input.content]);
+        const rowid = this.db.prepare("SELECT rowid FROM memories WHERE id = ?").get(id);
+        if (rowid && vector) {
+          this.db.prepare("INSERT INTO memories_vec (rowid, memory_id, embedding) VALUES (?, ?, ?)").run(rowid.rowid, id, new Float32Array(vector));
+        }
+      } catch {
+      }
+    }
+    return id;
+  }
+  // ─── Update ──────────────────────────────────────────
+  update(id, content) {
+    this.db.prepare("UPDATE memories SET content = ? WHERE id = ?").run(content, id);
+    if (this.hasVec) {
+      const row = this.db.prepare("SELECT rowid FROM memories WHERE id = ?").get(id);
+      if (row) {
+        this.db.prepare("DELETE FROM memories_vec WHERE rowid = ?").run(row.rowid);
+      }
+    }
+  }
+  // ─── Update fields ───────────────────────────────────
+  updateFields(id, fields) {
+    const sets = [];
+    const params = [];
+    if (fields.content !== void 0) {
+      sets.push("content = ?");
+      params.push(fields.content);
+    }
+    if (fields.outcome !== void 0) {
+      sets.push("outcome = ?");
+      params.push(fields.outcome);
+    }
+    if (fields.runId !== void 0) {
+      sets.push("run_id = ?");
+      params.push(fields.runId);
+    }
+    if (sets.length === 0) return;
+    params.push(id);
+    this.db.prepare(`UPDATE memories SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+  }
+  // ─── Forget ──────────────────────────────────────────
+  forget(id) {
+    const row = this.db.prepare("SELECT rowid FROM memories WHERE id = ?").get(id);
+    if (row && this.hasVec) {
+      this.db.prepare("DELETE FROM memories_vec WHERE rowid = ?").run(row.rowid);
+    }
+    this.db.prepare("DELETE FROM memories WHERE id = ?").run(id);
+  }
+  // ─── Query (synchronous — structured filters) ───────
+  query(opts = {}) {
+    const conditions = [];
+    const params = [];
+    if (opts.scope) {
+      conditions.push("(scope = ? OR scope = 'global')");
+      params.push(opts.scope);
+    }
+    if (opts.types && opts.types.length > 0) {
+      const placeholders = opts.types.map(() => "?").join(",");
+      conditions.push(`type IN (${placeholders})`);
+      params.push(...opts.types);
+    }
+    if (opts.since) {
+      conditions.push("created_at > ?");
+      params.push(opts.since);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    let orderBy;
+    switch (opts.sortBy) {
+      case "accessCount":
+        orderBy = "ORDER BY access_count DESC";
+        break;
+      case "createdAt":
+        orderBy = "ORDER BY created_at DESC";
+        break;
+      case "relevance":
+      default:
+        orderBy = "ORDER BY (access_count * MAX(0, 1.0 - (julianday('now') - julianday(last_accessed_at)) / 60.0)) DESC";
+        break;
+    }
+    const limit = opts.limit ? `LIMIT ${opts.limit}` : "LIMIT 50";
+    const rows = this.db.prepare(`SELECT * FROM memories ${where} ${orderBy} ${limit}`).all(...params);
+    return rows.map(rowToEntry);
+  }
+  // ─── Search (async — semantic or FTS) ────────────────
+  async search(text, opts = {}) {
+    if (this.embedder && this.hasVec) {
+      try {
+        const [queryVec] = await this.embedder.embed([text]);
+        const limit2 = opts.limit ?? 20;
+        const candidates = this.db.prepare(
+          `SELECT m.*, v.distance
+           FROM memories_vec v
+           JOIN memories m ON m.rowid = v.rowid
+           WHERE v.embedding MATCH ?
+           ORDER BY v.distance
+           LIMIT ?`
+        ).all(new Float32Array(queryVec), limit2 * 3);
+        const filtered = candidates.filter((row) => {
+          if (opts.scope && row.scope !== opts.scope && row.scope !== "global") return false;
+          if (opts.types && opts.types.length > 0 && !opts.types.includes(row.type))
+            return false;
+          return true;
+        });
+        return filtered.slice(0, limit2).map((row) => rowToEntry(row));
+      } catch {
+      }
+    }
+    const limit = opts.limit ?? 20;
+    const ftsQuery = text.split(/\s+/).filter(Boolean).map((w) => `"${w}"`).join(" OR ");
+    if (!ftsQuery) return this.query(opts);
+    try {
+      const rows = this.db.prepare(
+        `SELECT m.*, rank
+         FROM memories_fts fts
+         JOIN memories m ON m.rowid = fts.rowid
+         WHERE memories_fts MATCH ?
+         ORDER BY rank
+         LIMIT ?`
+      ).all(ftsQuery, limit);
+      const filtered = rows.filter((row) => {
+        if (opts.scope && row.scope !== opts.scope && row.scope !== "global") return false;
+        if (opts.types && opts.types.length > 0 && !opts.types.includes(row.type))
+          return false;
+        return true;
+      });
+      return filtered.map(rowToEntry);
+    } catch {
+      return this.query(opts);
+    }
+  }
+  // ─── Lifecycle ───────────────────────────────────────
+  markAccessed(ids) {
+    if (ids.length === 0) return;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const stmt = this.db.prepare(
+      "UPDATE memories SET access_count = access_count + 1, last_accessed_at = ? WHERE id = ?"
+    );
+    const transaction = this.db.transaction(() => {
+      for (const id of ids) {
+        stmt.run(now, id);
+      }
+    });
+    transaction();
+  }
+  decay(maxAgeDays = 30, minAccessCount = 3) {
+    const staleResult = this.db.prepare(
+      `DELETE FROM memories
+       WHERE access_count < ?
+         AND julianday('now') - julianday(last_accessed_at) > ?
+         AND type NOT IN ('focus', 'task')`
+    ).run(minAccessCount, maxAgeDays);
+    const taskResult = this.db.prepare(
+      `DELETE FROM memories
+       WHERE type = 'task'
+         AND outcome = 'done'
+         AND julianday('now') - julianday(last_accessed_at) > 7`
+    ).run();
+    return staleResult.changes + taskResult.changes;
+  }
+  expireEphemeral() {
+    const result = this.db.prepare(
+      `DELETE FROM memories
+       WHERE type = 'focus'
+         AND expires_at IS NOT NULL
+         AND expires_at < ?`
+    ).run((/* @__PURE__ */ new Date()).toISOString());
+    return result.changes;
+  }
+  // ─── Stats ───────────────────────────────────────────
+  stats() {
+    const total = this.db.prepare("SELECT COUNT(*) as count FROM memories").get().count;
+    const byTypeRows = this.db.prepare("SELECT type, COUNT(*) as count FROM memories GROUP BY type").all();
+    const byType = {};
+    for (const row of byTypeRows) {
+      byType[row.type] = row.count;
+    }
+    const byScopeRows = this.db.prepare("SELECT scope, COUNT(*) as count FROM memories GROUP BY scope").all();
+    const byScope = {};
+    for (const row of byScopeRows) {
+      byScope[row.scope] = row.count;
+    }
+    return { total, byType, byScope };
+  }
+  // ─── Cleanup ─────────────────────────────────────────
+  close() {
+    this.db.close();
+  }
+};
+function rowToEntry(row) {
+  let tags = [];
+  try {
+    tags = JSON.parse(row.tags);
+  } catch {
+    tags = [];
+  }
+  return {
+    id: row.id,
+    type: row.type,
+    scope: row.scope,
+    content: row.content,
+    source: row.source,
+    tags,
+    createdAt: row.created_at,
+    lastAccessedAt: row.last_accessed_at,
+    accessCount: row.access_count,
+    expiresAt: row.expires_at ?? void 0,
+    outcome: row.outcome ?? void 0,
+    runId: row.run_id ?? void 0,
+    category: row.category ?? void 0,
+    severity: row.severity ?? void 0,
+    supersedes: row.supersedes ?? void 0
+  };
+}
+
+// src/workflows/registry.ts
+import { existsSync as existsSync5 } from "fs";
+import { readdir as readdir4 } from "fs/promises";
+import path10 from "path";
+
+// src/workflows/loader.ts
+import { readFile as readFile6 } from "fs/promises";
+import { parse } from "yaml";
+import { z as z4 } from "zod";
+var workflowStepDefSchema = z4.object({
+  type: z4.literal("step").optional().default("step"),
+  agent: z4.string(),
+  dependsOn: z4.array(z4.string()).optional(),
+  prompt: z4.string().optional(),
+  sandbox: z4.enum(["writable", "readonly"]).optional(),
+  maxTurns: z4.number().int().positive().optional(),
+  mcpServers: z4.array(z4.string()).optional(),
+  recovery: z4.object({
+    maxRetries: z4.number().int().nonnegative().optional(),
+    nonRetryable: z4.array(z4.string()).optional()
+  }).optional(),
+  condition: z4.string().optional()
+});
+var workflowGateDefSchema = z4.object({
+  type: z4.literal("gate"),
+  dependsOn: z4.array(z4.string()).optional(),
+  description: z4.string(),
+  timeout: z4.string().optional(),
+  autoApprove: z4.boolean().optional()
+});
+var workflowHeaderSchema = z4.object({
+  name: z4.string().min(1),
+  description: z4.string().optional(),
+  steps: z4.record(z4.string(), z4.unknown())
+});
+function parseStepEntry(stepName, stepValue) {
+  const obj = stepValue;
+  const schema = obj.type === "gate" ? workflowGateDefSchema : workflowStepDefSchema;
   const result = schema.safeParse(stepValue);
   if (result.success) {
     return { step: result.data, errors: [] };
@@ -1460,7 +2295,7 @@ ${errors.join("\n")}`);
   return steps;
 }
 async function loadWorkflow(filePath) {
-  const content = await readFile4(filePath, "utf-8");
+  const content = await readFile6(filePath, "utf-8");
   const raw = parse(content);
   const headerResult = workflowHeaderSchema.safeParse(raw);
   if (!headerResult.success) {
@@ -1498,11 +2333,11 @@ var WorkflowRegistry = class {
     return this.workflows.has(name);
   }
   async loadFromDir(dir) {
-    if (!existsSync3(dir)) return;
-    const files = await readdir3(dir);
+    if (!existsSync5(dir)) return;
+    const files = await readdir4(dir);
     for (const file of files) {
       if (!file.endsWith(".yml") && !file.endsWith(".yaml")) continue;
-      const filePath = path8.join(dir, file);
+      const filePath = path10.join(dir, file);
       const workflow = await loadWorkflow(filePath);
       this.workflows.set(workflow.name, workflow);
     }
@@ -1513,7 +2348,6 @@ var WorkflowRegistry = class {
 var MAX_PROMPT_SIZE = 100 * 1024;
 var MAX_METADATA_DEPTH = 5;
 var SHUTDOWN_TIMEOUT_MS = 5 * 60 * 1e3;
-var WORKTREES_DIR = ".neo/worktrees";
 var textEncoder = new TextEncoder();
 var Orchestrator = class extends NeoEventEmitter {
   config;
@@ -1525,17 +2359,19 @@ var Orchestrator = class extends NeoEventEmitter {
   idempotencyCache = /* @__PURE__ */ new Map();
   abortControllers = /* @__PURE__ */ new Map();
   repoIndex = /* @__PURE__ */ new Map();
-  createdRunDirs = /* @__PURE__ */ new Set();
+  runStore = new RunStore();
   journalDir;
   builtInWorkflowDir;
   customWorkflowDir;
   costJournal = null;
   eventJournal = null;
   webhookDispatcher = null;
+  memoryStore = null;
   _paused = false;
   _costToday = 0;
   _startedAt = 0;
   _drainResolve = null;
+  skipOrphanRecovery;
   constructor(config, options = {}) {
     super();
     this.config = config;
@@ -1543,8 +2379,9 @@ var Orchestrator = class extends NeoEventEmitter {
     this.journalDir = options.journalDir ?? getJournalsDir();
     this.builtInWorkflowDir = options.builtInWorkflowDir;
     this.customWorkflowDir = options.customWorkflowDir;
+    this.skipOrphanRecovery = options.skipOrphanRecovery ?? false;
     for (const repo of config.repos) {
-      const resolvedPath = path9.resolve(repo.path);
+      const resolvedPath = path11.resolve(repo.path);
       const normalizedRepo = { ...repo, path: resolvedPath };
       this.repoIndex.set(resolvedPath, normalizedRepo);
     }
@@ -1642,8 +2479,15 @@ var Orchestrator = class extends NeoEventEmitter {
     this._startedAt = Date.now();
     this.costJournal = new CostJournal({ dir: this.journalDir });
     this.eventJournal = new EventJournal({ dir: this.journalDir });
-    if (this.config.webhooks.length > 0) {
-      this.webhookDispatcher = new WebhookDispatcher(this.config.webhooks);
+    const supervisorWebhooks = await this.discoverSupervisorWebhooks();
+    const allWebhooks = [...this.config.webhooks, ...supervisorWebhooks];
+    if (allWebhooks.length > 0) {
+      this.webhookDispatcher = new WebhookDispatcher(allWebhooks);
+    }
+    if (supervisorWebhooks.length > 0) {
+      console.log(
+        `[neo] Discovered ${supervisorWebhooks.length} supervisor webhook(s): ${supervisorWebhooks.map((w) => w.url).join(", ")}`
+      );
     }
     this._costToday = await this.costJournal.getDayTotal();
     if (this.builtInWorkflowDir) {
@@ -1653,12 +2497,10 @@ var Orchestrator = class extends NeoEventEmitter {
         this.registerWorkflow(workflow);
       }
     }
-    await this.recoverOrphanedRuns();
-    for (const repo of this.config.repos) {
-      const worktreeBase = path9.join(repo.path, WORKTREES_DIR);
-      await cleanupOrphanedWorktrees(worktreeBase).catch(() => {
-      });
+    if (!this.skipOrphanRecovery) {
+      await this.recoverOrphanedRuns();
     }
+    await mkdir6(this.config.sessions.dir, { recursive: true });
   }
   async shutdown() {
     this._paused = true;
@@ -1682,6 +2524,9 @@ var Orchestrator = class extends NeoEventEmitter {
       type: "orchestrator:shutdown",
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
+    if (this.webhookDispatcher) {
+      await this.webhookDispatcher.flush();
+    }
   }
   // ─── Emit override (journal events) ───────────────────
   emit(event) {
@@ -1721,8 +2566,8 @@ var Orchestrator = class extends NeoEventEmitter {
     return idempotencyKey;
   }
   buildDispatchContext(input) {
-    const runId = input.runId ?? randomUUID();
-    const sessionId = randomUUID();
+    const runId = input.runId ?? randomUUID3();
+    const sessionId = randomUUID3();
     const workflow = this.workflows.get(input.workflow);
     if (!workflow) {
       const available = [...this.workflows.keys()].join(", ") || "none";
@@ -1758,28 +2603,39 @@ var Orchestrator = class extends NeoEventEmitter {
   }
   async executeStep(ctx) {
     const { input, runId, sessionId, startedAt, agent, repoConfig, activeSession } = ctx;
-    let worktreePath;
+    let sessionPath;
+    await this.persistRun({
+      version: 1,
+      runId,
+      workflow: input.workflow,
+      repo: input.repo,
+      prompt: input.prompt,
+      pid: process.pid,
+      status: "running",
+      steps: {},
+      createdAt: activeSession.startedAt,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      metadata: input.metadata
+    });
     try {
-      if (agent.sandbox === "writable") {
-        const branchName = getBranchName(repoConfig, runId);
-        const worktreeDir = path9.join(input.repo, WORKTREES_DIR, runId);
-        const info = await createWorktree({
-          repoPath: input.repo,
-          branch: branchName,
-          baseBranch: repoConfig.defaultBranch,
-          worktreeDir
-        });
-        worktreePath = info.path;
-        activeSession.worktreePath = worktreePath;
-      }
-      const stepResult = await this.runAgentSession(ctx, worktreePath);
+      const branchName = input.branch || repoConfig.defaultBranch;
+      const sessionDir = path11.join(this.config.sessions.dir, runId);
+      const info = await createSessionClone({
+        repoPath: input.repo,
+        branch: branchName,
+        baseBranch: repoConfig.defaultBranch,
+        sessionDir
+      });
+      sessionPath = info.path;
+      activeSession.sessionPath = sessionPath;
+      const stepResult = await this.runAgentSession(ctx, sessionPath);
       this.emitCostEvents(sessionId, stepResult.costUsd, ctx);
       this.emitSessionComplete(ctx, stepResult);
       return stepResult;
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
       this.emitSessionFail(ctx, errorMsg);
-      return {
+      const failResult = {
         status: "failure",
         sessionId,
         costUsd: 0,
@@ -1790,9 +2646,22 @@ var Orchestrator = class extends NeoEventEmitter {
         error: errorMsg,
         attempt: 1
       };
+      try {
+        const store = this.getMemoryStore();
+        await store.write({
+          type: "episode",
+          scope: input.repo,
+          content: `Run ${runId.slice(0, 8)} (${agent.name}): failed${failResult.error ? ` \u2014 ${failResult.error.slice(0, 150)}` : ""}`,
+          source: agent.name,
+          outcome: "failure",
+          runId
+        });
+      } catch {
+      }
+      return failResult;
     } finally {
-      if (worktreePath) {
-        await this.finalizeWorktree(worktreePath, ctx);
+      if (sessionPath) {
+        await this.finalizeSession(sessionPath, ctx);
       }
       this.semaphore.release(sessionId);
       this._activeSessions.delete(sessionId);
@@ -1804,35 +2673,26 @@ var Orchestrator = class extends NeoEventEmitter {
     }
   }
   /**
-   * Push the branch, then remove the worktree.
+   * Push the branch (writable only), then remove the session clone.
    * Runs in `finally` so it executes on both success and failure.
    */
-  async finalizeWorktree(worktreePath, ctx) {
-    const { runId, repoConfig } = ctx;
-    const branch = getBranchName(repoConfig, runId);
-    const remote = repoConfig.pushRemote ?? "origin";
-    try {
-      await pushWorktreeBranch(worktreePath, branch, remote).catch(() => {
-      });
-    } catch {
+  async finalizeSession(sessionPath, ctx) {
+    if (ctx.agent.sandbox === "writable") {
+      const branch = ctx.input.branch;
+      const remote = ctx.repoConfig.pushRemote ?? "origin";
+      try {
+        await pushSessionBranch(sessionPath, branch, remote).catch(() => {
+        });
+      } catch {
+      }
     }
     try {
-      await removeWorktree(worktreePath);
+      await removeSessionClone(sessionPath);
     } catch {
     }
   }
-  async runAgentSession(ctx, worktreePath) {
-    const { input, runId, sessionId, stepName, stepDef, agent, activeSession } = ctx;
-    const sandboxConfig = buildSandboxConfig(agent, worktreePath);
-    const chain = buildMiddlewareChain(this.userMiddleware);
-    const middlewareContext = this.buildMiddlewareContext(
-      runId,
-      input.workflow,
-      stepName,
-      agent.name,
-      input.repo
-    );
-    const hooks = buildSDKHooks(chain, middlewareContext, this.userMiddleware);
+  async runAgentSession(ctx, sessionPath) {
+    const { input, runId, sessionId, stepName, stepDef, agent, repoConfig, activeSession } = ctx;
     this.emit({
       type: "session:start",
       sessionId,
@@ -1844,69 +2704,101 @@ var Orchestrator = class extends NeoEventEmitter {
       metadata: input.metadata,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
+    const executor = new SessionExecutor(
+      {
+        initTimeoutMs: this.config.sessions.initTimeoutMs,
+        maxDurationMs: this.config.sessions.maxDurationMs,
+        maxRetries: this.config.recovery.maxRetries,
+        backoffBaseMs: this.config.recovery.backoffBaseMs
+      },
+      (key) => {
+        if (key === "costToday") return this._costToday;
+        if (key === "budgetCapUsd") return this.config.budget.dailyCapUsd;
+        return void 0;
+      }
+    );
+    const strategy = input.gitStrategy ?? repoConfig.gitStrategy ?? "branch";
+    const mcpServers = this.resolveMcpServers(stepDef, agent);
+    const memoryContext = this.loadMemoryContext(input.repo);
     const recoveryOpts = stepDef.recovery;
-    const sessionResult = await runWithRecovery({
-      agent,
-      prompt: stepDef.prompt ?? input.prompt,
-      repoPath: input.repo,
-      sandboxConfig,
-      hooks,
-      initTimeoutMs: this.config.sessions.initTimeoutMs,
-      maxDurationMs: this.config.sessions.maxDurationMs,
-      maxRetries: recoveryOpts?.maxRetries ?? this.config.recovery.maxRetries,
-      backoffBaseMs: this.config.recovery.backoffBaseMs,
-      ...worktreePath ? { worktreePath } : {},
-      ...recoveryOpts?.nonRetryable ? { nonRetryable: recoveryOpts.nonRetryable } : {},
-      onAttempt: (attempt, strategy) => {
-        if (attempt > 1) {
-          this.emit({
-            type: "session:fail",
-            sessionId,
-            runId,
-            error: `Retrying with strategy: ${strategy}`,
-            attempt: attempt - 1,
-            maxRetries: recoveryOpts?.maxRetries ?? this.config.recovery.maxRetries,
-            willRetry: true,
-            metadata: input.metadata,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          });
+    const result = await executor.execute(
+      {
+        runId,
+        sessionId,
+        agent,
+        stepDef,
+        repoConfig,
+        repoPath: input.repo,
+        prompt: input.prompt,
+        branch: input.branch,
+        gitStrategy: strategy,
+        sessionPath,
+        metadata: input.metadata,
+        startedAt: activeSession.startedAt
+      },
+      {
+        middleware: this.userMiddleware,
+        mcpServers,
+        memoryContext,
+        onAttempt: (attempt, strategy2) => {
+          if (attempt > 1) {
+            this.emit({
+              type: "session:fail",
+              sessionId,
+              runId,
+              error: `Retrying with strategy: ${strategy2}`,
+              attempt: attempt - 1,
+              maxRetries: recoveryOpts?.maxRetries ?? this.config.recovery.maxRetries,
+              willRetry: true,
+              metadata: input.metadata,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
         }
       }
-    });
-    const parsed = parseOutput(sessionResult.output);
-    return {
-      status: "success",
-      sessionId: sessionResult.sessionId,
-      output: parsed.output ?? parsed.rawOutput,
-      rawOutput: sessionResult.output,
-      costUsd: sessionResult.costUsd,
-      durationMs: sessionResult.durationMs,
-      agent: agent.name,
-      startedAt: activeSession.startedAt,
-      completedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      attempt: 1
-    };
+    );
+    try {
+      const store = this.getMemoryStore();
+      const isSuccess = result.status === "success";
+      await store.write({
+        type: "episode",
+        scope: input.repo,
+        content: `Run ${runId.slice(0, 8)} (${agent.name}): ${isSuccess ? "completed" : "failed"}${result.error ? ` \u2014 ${result.error.slice(0, 150)}` : ""}`,
+        source: agent.name,
+        outcome: isSuccess ? "success" : "failure",
+        runId
+      });
+    } catch {
+    }
+    return result;
   }
   async finalizeDispatch(ctx, stepResult, idempotencyKey) {
-    const { input, runId, stepName, repoConfig, activeSession } = ctx;
+    const { input, runId, stepName, activeSession } = ctx;
     const taskResult = {
       runId,
       workflow: input.workflow,
       repo: input.repo,
       status: stepResult.status === "success" ? "success" : "failure",
       steps: { [stepName]: stepResult },
-      branch: stepResult.status === "success" && activeSession.worktreePath ? getBranchName(repoConfig, runId) : void 0,
+      branch: stepResult.status === "success" && activeSession.sessionPath ? input.branch : void 0,
       costUsd: stepResult.costUsd,
       durationMs: Date.now() - ctx.startedAt,
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       metadata: input.metadata
     };
+    if (stepResult.prUrl) {
+      taskResult.prUrl = stepResult.prUrl;
+    }
+    if (stepResult.prNumber !== void 0) {
+      taskResult.prNumber = stepResult.prNumber;
+    }
     await this.persistRun({
       version: 1,
       runId,
       workflow: input.workflow,
       repo: input.repo,
       prompt: input.prompt,
+      pid: process.pid,
       branch: taskResult.branch,
       status: taskResult.status === "success" ? "completed" : "failed",
       steps: taskResult.steps,
@@ -1923,6 +2815,30 @@ var Orchestrator = class extends NeoEventEmitter {
     }
     return taskResult;
   }
+  // ─── Private: Memory injection ──────────────────────────
+  getMemoryStore() {
+    if (!this.memoryStore) {
+      const supervisorDir = path11.join(getSupervisorsDir(), "supervisor");
+      this.memoryStore = new MemoryStore(path11.join(supervisorDir, "memory.sqlite"));
+    }
+    return this.memoryStore;
+  }
+  loadMemoryContext(repoPath) {
+    try {
+      const store = this.getMemoryStore();
+      const memories = store.query({
+        scope: repoPath,
+        types: ["fact", "procedure", "feedback"],
+        limit: 25,
+        sortBy: "relevance"
+      });
+      if (memories.length === 0) return void 0;
+      store.markAccessed(memories.map((m) => m.id));
+      return formatMemoriesForPrompt(memories);
+    } catch {
+      return void 0;
+    }
+  }
   // ─── Private: Event helpers ────────────────────────────
   emitCostEvents(sessionId, sessionCost, ctx) {
     this._costToday += sessionCost;
@@ -1997,7 +2913,7 @@ var Orchestrator = class extends NeoEventEmitter {
         `Validation error: prompt exceeds maximum size of ${String(MAX_PROMPT_SIZE)} bytes`
       );
     }
-    if (!existsSync4(input.repo)) {
+    if (!existsSync6(input.repo)) {
       throw new Error(`Validation error: repo path does not exist: ${input.repo}`);
     }
     if (!this.workflows.has(input.workflow)) {
@@ -2070,32 +2986,14 @@ var Orchestrator = class extends NeoEventEmitter {
     return agent;
   }
   resolveRepo(repoPath) {
-    const repo = this.repoIndex.get(path9.resolve(repoPath));
+    const repo = this.repoIndex.get(path11.resolve(repoPath));
     if (repo) return repo;
     return {
       path: repoPath,
       defaultBranch: "main",
       branchPrefix: "feat",
       pushRemote: "origin",
-      autoCreatePr: false
-    };
-  }
-  buildMiddlewareContext(runId, workflow, step, agent, repo) {
-    const store = /* @__PURE__ */ new Map();
-    return {
-      runId,
-      workflow,
-      step,
-      agent,
-      repo,
-      get: ((key) => {
-        if (key === "costToday") return this._costToday;
-        if (key === "budgetCapUsd") return this.config.budget.dailyCapUsd;
-        return store.get(key);
-      }),
-      set: ((key, value) => {
-        store.set(key, value);
-      })
+      gitStrategy: "branch"
     };
   }
   computeBudgetRemainingPct() {
@@ -2103,48 +3001,76 @@ var Orchestrator = class extends NeoEventEmitter {
     if (cap <= 0) return 0;
     return Math.max(0, (cap - this._costToday) / cap * 100);
   }
-  // ─── Private: Run persistence ──────────────────────────
-  async persistRun(run) {
-    try {
-      const slug = toRepoSlug({ path: run.repo });
-      const runsDir = getRepoRunsDir(slug);
-      if (!this.createdRunDirs.has(runsDir)) {
-        await mkdir5(runsDir, { recursive: true });
-        this.createdRunDirs.add(runsDir);
+  // ─── Private: MCP server resolution ────────────────────
+  resolveMcpServers(stepDef, agent) {
+    const configServers = this.config.mcpServers;
+    if (!configServers) return void 0;
+    const names = /* @__PURE__ */ new Set();
+    if (stepDef.mcpServers) {
+      for (const name of stepDef.mcpServers) names.add(name);
+    }
+    if (agent.definition.mcpServers) {
+      for (const name of agent.definition.mcpServers) names.add(name);
+    }
+    if (names.size === 0) return void 0;
+    const resolved = {};
+    for (const name of names) {
+      const serverConfig = configServers[name];
+      if (serverConfig) {
+        resolved[name] = serverConfig;
       }
-      const filePath = path9.join(runsDir, `${run.runId}.json`);
-      await writeFile2(filePath, JSON.stringify(run, null, 2), "utf-8");
-    } catch {
     }
-  }
-  async recoverOrphanedRuns() {
-    const runsDir = getRunsDir();
-    if (!existsSync4(runsDir)) return;
+    return Object.keys(resolved).length > 0 ? resolved : void 0;
+  }
+  // ─── Private: Supervisor discovery ─────────────────────
+  /** Discover running supervisor daemons and return webhook configs for their endpoints. */
+  async discoverSupervisorWebhooks() {
+    const { readdir: readdir6 } = await import("fs/promises");
+    const supervisorsDir = getSupervisorsDir();
+    if (!existsSync6(supervisorsDir)) return [];
+    const webhooks = [];
     try {
-      const entries = await readdir4(runsDir, { withFileTypes: true });
-      const jsonFiles = [];
+      const entries = await readdir6(supervisorsDir, { withFileTypes: true });
       for (const entry of entries) {
-        if (entry.isDirectory()) {
-          const subDir = path9.join(runsDir, entry.name);
-          const subFiles = await readdir4(subDir);
-          for (const f of subFiles) {
-            if (f.endsWith(".json")) jsonFiles.push(path9.join(subDir, f));
-          }
-        } else if (entry.name.endsWith(".json")) {
-          jsonFiles.push(path9.join(runsDir, entry.name));
-        }
-      }
-      for (const filePath of jsonFiles) {
-        const content = await readFile5(filePath, "utf-8");
-        const run = JSON.parse(content);
-        if (run.status === "running") {
-          run.status = "failed";
-          run.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-          await writeFile2(filePath, JSON.stringify(run, null, 2), "utf-8");
+        if (!entry.isDirectory()) continue;
+        try {
+          const statePath = path11.join(supervisorsDir, entry.name, "state.json");
+          const raw = await readFile7(statePath, "utf-8");
+          const state = JSON.parse(raw);
+          if (state.status !== "running" || !state.port) continue;
+          if (state.pid && !isProcessAlive(state.pid)) continue;
+          webhooks.push({
+            url: `http://localhost:${String(state.port)}/webhook`,
+            events: ["session:complete", "session:fail", "budget:alert"],
+            secret: this.config.supervisor.secret,
+            timeoutMs: 5e3
+          });
+        } catch {
         }
       }
     } catch {
     }
+    return webhooks;
+  }
+  // ─── Private: Run persistence ──────────────────────────
+  async persistRun(run) {
+    await this.runStore.persistRun(run);
+  }
+  async recoverOrphanedRuns() {
+    const orphanedRuns = await this.runStore.recoverOrphanedRuns();
+    for (const run of orphanedRuns) {
+      this.emit({
+        type: "session:fail",
+        sessionId: run.runId,
+        runId: run.runId,
+        error: "Orphaned run: process died without completing",
+        attempt: 1,
+        maxRetries: this.config.recovery.maxRetries,
+        willRetry: false,
+        metadata: run.metadata,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
   }
 };
 function isPlainObject(value) {
@@ -2161,40 +3087,45 @@ function objectDepth(obj, current = 0) {
 }
 
 // src/supervisor/schemas.ts
-import { z as z4 } from "zod";
-var supervisorDaemonStateSchema = z4.object({
-  pid: z4.number(),
-  tmuxSession: z4.string(),
-  sessionId: z4.string(),
-  port: z4.number(),
-  cwd: z4.string(),
-  startedAt: z4.string(),
-  lastHeartbeat: z4.string().optional(),
-  heartbeatCount: z4.number().default(0),
-  totalCostUsd: z4.number().default(0),
-  todayCostUsd: z4.number().default(0),
-  costResetDate: z4.string().optional(),
-  idleSkipCount: z4.number().default(0),
-  status: z4.enum(["running", "draining", "stopped"]).default("running")
+import { z as z5 } from "zod";
+var wakeReasonSchema = z5.enum(["events", "timer", "active_runs", "forced"]);
+var supervisorDaemonStateSchema = z5.object({
+  pid: z5.number(),
+  sessionId: z5.string(),
+  port: z5.number(),
+  cwd: z5.string(),
+  startedAt: z5.string(),
+  lastHeartbeat: z5.string().optional(),
+  heartbeatCount: z5.number().default(0),
+  totalCostUsd: z5.number().default(0),
+  todayCostUsd: z5.number().default(0),
+  costResetDate: z5.string().optional(),
+  idleSkipCount: z5.number().default(0),
+  activeWorkSkipCount: z5.number().default(0),
+  status: z5.enum(["running", "draining", "stopped"]).default("running"),
+  lastConsolidationHeartbeat: z5.number().default(0),
+  lastCompactionHeartbeat: z5.number().default(0),
+  lastConsolidationTimestamp: z5.string().optional(),
+  wakeReason: wakeReasonSchema.optional()
 });
-var webhookIncomingEventSchema = z4.object({
-  id: z4.string().optional(),
-  source: z4.string().optional(),
-  event: z4.string().optional(),
-  payload: z4.record(z4.string(), z4.unknown()).optional(),
-  receivedAt: z4.string(),
-  processedAt: z4.string().optional()
+var webhookIncomingEventSchema = z5.object({
+  id: z5.string().optional(),
+  source: z5.string().optional(),
+  event: z5.string().optional(),
+  payload: z5.record(z5.string(), z5.unknown()).optional(),
+  receivedAt: z5.string(),
+  processedAt: z5.string().optional()
 });
-var inboxMessageSchema = z4.object({
-  id: z4.string(),
-  from: z4.enum(["tui", "api", "external"]),
-  text: z4.string(),
-  timestamp: z4.string(),
-  processedAt: z4.string().optional()
+var inboxMessageSchema = z5.object({
+  id: z5.string(),
+  from: z5.enum(["tui", "api", "external", "agent"]),
+  text: z5.string(),
+  timestamp: z5.string(),
+  processedAt: z5.string().optional()
 });
-var activityEntrySchema = z4.object({
-  id: z4.string(),
-  type: z4.enum([
+var activityEntrySchema = z5.object({
+  id: z5.string(),
+  type: z5.enum([
     "heartbeat",
     "decision",
     "action",
@@ -2206,15 +3137,27 @@ var activityEntrySchema = z4.object({
     "dispatch",
     "tool_use"
   ]),
-  summary: z4.string(),
-  detail: z4.unknown().optional(),
-  timestamp: z4.string()
+  summary: z5.string(),
+  detail: z5.unknown().optional(),
+  timestamp: z5.string()
+});
+var logBufferEntrySchema = z5.object({
+  id: z5.string(),
+  type: z5.enum(["progress", "action", "decision", "blocker", "milestone", "discovery"]),
+  message: z5.string(),
+  agent: z5.string().optional(),
+  runId: z5.string().optional(),
+  repo: z5.string().optional(),
+  target: z5.enum(["memory", "knowledge", "digest"]),
+  timestamp: z5.string(),
+  consolidatedAt: z5.string().optional()
 });
+var internalEventKindSchema = z5.enum(["consolidation_timer", "active_run_check"]);
 
 // src/supervisor/activity-log.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { appendFile as appendFile4, readFile as readFile6, rename, stat } from "fs/promises";
-import path10 from "path";
+import { randomUUID as randomUUID4 } from "crypto";
+import { appendFile as appendFile4, readFile as readFile8, rename, stat } from "fs/promises";
+import path12 from "path";
 var ACTIVITY_FILE = "activity.jsonl";
 var MAX_SIZE_BYTES = 10 * 1024 * 1024;
 var ActivityLog = class {
@@ -2222,7 +3165,7 @@ var ActivityLog = class {
   dir;
   constructor(dir) {
     this.dir = dir;
-    this.filePath = path10.join(dir, ACTIVITY_FILE);
+    this.filePath = path12.join(dir, ACTIVITY_FILE);
   }
   /**
    * Append a structured entry to the activity log.
@@ -2239,7 +3182,7 @@ var ActivityLog = class {
    */
   async log(type, summary, detail) {
     await this.append({
-      id: randomUUID2(),
+      id: randomUUID4(),
       type,
       summary,
       detail,
@@ -2252,7 +3195,7 @@ var ActivityLog = class {
   async tail(n) {
     let content;
     try {
-      content = await readFile6(this.filePath, "utf-8");
+      content = await readFile8(this.filePath, "utf-8");
     } catch {
       return [];
     }
@@ -2272,7 +3215,7 @@ var ActivityLog = class {
       const stats = await stat(this.filePath);
       if (stats.size > MAX_SIZE_BYTES) {
         const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-        const rotatedPath = path10.join(this.dir, `activity-${timestamp}.jsonl`);
+        const rotatedPath = path12.join(this.dir, `activity-${timestamp}.jsonl`);
         await rename(this.filePath, rotatedPath);
       }
     } catch {
@@ -2281,15 +3224,15 @@ var ActivityLog = class {
 };
 
 // src/supervisor/daemon.ts
-import { randomUUID as randomUUID4 } from "crypto";
-import { existsSync as existsSync5 } from "fs";
-import { mkdir as mkdir6, readFile as readFile10, rm as rm2, writeFile as writeFile6 } from "fs/promises";
+import { randomUUID as randomUUID6 } from "crypto";
+import { existsSync as existsSync8 } from "fs";
+import { mkdir as mkdir7, readFile as readFile12, rm as rm2, writeFile as writeFile6 } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import path13 from "path";
+import path15 from "path";
 
 // src/supervisor/event-queue.ts
 import { watch } from "fs";
-import { readFile as readFile7, writeFile as writeFile3 } from "fs/promises";
+import { readFile as readFile9, writeFile as writeFile3 } from "fs/promises";
 var EventQueue = class {
   queue = [];
   seenIds = /* @__PURE__ */ new Set();
@@ -2373,7 +3316,14 @@ var EventQueue = class {
    * Start watching inbox.jsonl and events.jsonl for new entries.
    * New lines are parsed and pushed into the queue.
    */
-  startWatching(inboxPath, eventsPath) {
+  async startWatching(inboxPath, eventsPath) {
+    for (const p of [inboxPath, eventsPath]) {
+      try {
+        await writeFile3(p, "", { flag: "a" });
+      } catch (err) {
+        console.error(`[EventQueue] Failed to ensure file exists: ${p}`, err);
+      }
+    }
     this.watchJsonlFile(inboxPath, "message");
     this.watchJsonlFile(eventsPath, "webhook");
   }
@@ -2421,18 +3371,20 @@ var EventQueue = class {
   watchJsonlFile(filePath, kind) {
     try {
       const watcher = watch(filePath, () => {
-        this.readNewLines(filePath, kind).catch(() => {
+        this.readNewLines(filePath, kind).catch((err) => {
+          console.error(`[EventQueue] Failed to read new lines from ${filePath}:`, err);
         });
       });
       this.watchers.push(watcher);
-    } catch {
+    } catch (err) {
+      console.error(`[EventQueue] Cannot watch file (may not exist yet): ${filePath}`, err);
     }
   }
   async readNewLines(filePath, kind) {
     let content;
     try {
-      content = await readFile7(filePath, "utf-8");
-    } catch {
+      content = await readFile9(filePath, "utf-8");
+    } catch (_err) {
       return;
     }
     const offset = this.fileOffsets.get(filePath) ?? 0;
@@ -2449,15 +3401,15 @@ var EventQueue = class {
         } else {
           this.push({ kind: "message", data: parsed });
         }
-      } catch {
+      } catch (_err) {
       }
     }
   }
   async replayFile(filePath, kind) {
     let content;
     try {
-      content = await readFile7(filePath, "utf-8");
-    } catch {
+      content = await readFile9(filePath, "utf-8");
+    } catch (_err) {
       return;
     }
     this.fileOffsets.set(filePath, content.length);
@@ -2473,7 +3425,7 @@ var EventQueue = class {
           this.push({ kind: "message", data: parsed });
         }
         unprocessed.push(line);
-      } catch {
+      } catch (_err) {
       }
     }
   }
@@ -2492,7 +3444,7 @@ var EventQueue = class {
   }
   async markInFile(filePath, matchTimestamp, processedAt) {
     try {
-      const content = await readFile7(filePath, "utf-8");
+      const content = await readFile9(filePath, "utf-8");
       const lines = content.split("\n");
       let changed = false;
       const updated = lines.map((line) => {
@@ -2504,7 +3456,7 @@ var EventQueue = class {
             changed = true;
             return JSON.stringify(parsed);
           }
-        } catch {
+        } catch (_err) {
         }
         return line;
       });
@@ -2512,269 +3464,689 @@ var EventQueue = class {
         await writeFile3(filePath, updated.join("\n"), "utf-8");
         this.fileOffsets.set(filePath, updated.join("\n").length);
       }
-    } catch {
+    } catch (err) {
+      console.error(`[EventQueue] Failed to mark events as processed in ${filePath}:`, err);
     }
   }
 };
 
 // src/supervisor/heartbeat.ts
-import { randomUUID as randomUUID3 } from "crypto";
-import { readFile as readFile9, writeFile as writeFile5 } from "fs/promises";
+import { randomUUID as randomUUID5 } from "crypto";
+import { existsSync as existsSync7 } from "fs";
+import { readdir as readdir5, readFile as readFile11, writeFile as writeFile5 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import path12 from "path";
-import { fileURLToPath } from "url";
+import path14 from "path";
 
-// src/supervisor/memory.ts
-import { appendFile as appendFile5, readFile as readFile8, rename as rename2, writeFile as writeFile4 } from "fs/promises";
-import path11 from "path";
-var MEMORY_FILE = "memory.json";
-var KNOWLEDGE_FILE = "knowledge.json";
-var ARCHIVE_FILE = "memory-archive.jsonl";
-var LEGACY_FILE = "memory.md";
-var MAX_SIZE_KB = 6;
-var MAX_DECISIONS = 10;
-function parseStructuredMemory(raw) {
-  if (!raw.trim()) {
-    return emptyMemory();
-  }
-  try {
-    const parsed = JSON.parse(raw);
-    return {
-      activeWork: parsed.activeWork ?? [],
-      blockers: parsed.blockers ?? [],
-      repoNotes: parsed.repoNotes ?? {},
-      recentDecisions: parsed.recentDecisions ?? [],
-      trackerSync: parsed.trackerSync ?? {},
-      notes: parsed.notes ?? ""
-    };
-  } catch {
-    return { ...emptyMemory(), notes: raw };
-  }
+// src/supervisor/log-buffer.ts
+import { appendFile as appendFile5, readFile as readFile10, stat as stat2, writeFile as writeFile4 } from "fs/promises";
+import path13 from "path";
+var LOG_BUFFER_FILE = "log-buffer.jsonl";
+var MAX_FILE_BYTES = 1024 * 1024;
+var COMPACTION_AGE_MS = 24 * 60 * 60 * 1e3;
+function bufferPath(dir) {
+  return path13.join(dir, LOG_BUFFER_FILE);
 }
-function emptyMemory() {
-  return {
-    activeWork: [],
-    blockers: [],
-    repoNotes: {},
-    recentDecisions: [],
-    trackerSync: {},
-    notes: ""
-  };
+function parseLines(content) {
+  const entries = [];
+  const lines = content.trim().split("\n").filter(Boolean);
+  for (const line of lines) {
+    try {
+      entries.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return entries;
 }
-async function loadKnowledge(dir) {
+async function readLogBuffer(dir) {
   try {
-    return await readFile8(path11.join(dir, KNOWLEDGE_FILE), "utf-8");
+    const content = await readFile10(bufferPath(dir), "utf-8");
+    return parseLines(content);
   } catch {
-    return "";
+    return [];
   }
 }
-async function saveKnowledge(dir, content) {
-  await writeFile4(path11.join(dir, KNOWLEDGE_FILE), content, "utf-8");
+async function readUnconsolidated(dir) {
+  const entries = await readLogBuffer(dir);
+  return entries.filter((e) => !e.consolidatedAt);
 }
-async function loadMemory(dir) {
+async function markConsolidated(dir, ids) {
+  const filePath = bufferPath(dir);
+  let content;
   try {
-    return await readFile8(path11.join(dir, MEMORY_FILE), "utf-8");
+    content = await readFile10(filePath, "utf-8");
   } catch {
+    return;
   }
-  try {
-    const legacy = await readFile8(path11.join(dir, LEGACY_FILE), "utf-8");
-    if (legacy.trim()) {
-      await writeFile4(path11.join(dir, MEMORY_FILE), legacy, "utf-8");
-      await rename2(path11.join(dir, LEGACY_FILE), path11.join(dir, `${LEGACY_FILE}.bak`));
-      return legacy;
+  const idSet = new Set(ids);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const lines = content.trim().split("\n").filter(Boolean);
+  const updated = [];
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      if (idSet.has(entry.id) && !entry.consolidatedAt) {
+        entry.consolidatedAt = now;
+      }
+      updated.push(JSON.stringify(entry));
+    } catch {
+      updated.push(line);
     }
-  } catch {
   }
-  return "";
-}
-async function saveMemory(dir, content) {
-  const compacted = await compactMemory(dir, content);
-  await writeFile4(path11.join(dir, MEMORY_FILE), compacted, "utf-8");
+  await writeFile4(filePath, `${updated.join("\n")}
+`, "utf-8");
 }
-function extractMemoryFromResponse(response) {
-  const match = /<memory>([\s\S]*?)<\/memory>/i.exec(response);
-  if (!match?.[1]) return null;
-  const content = match[1].trim();
-  if (content.startsWith("{")) {
+async function compactLogBuffer(dir) {
+  const filePath = bufferPath(dir);
+  let content;
+  try {
+    content = await readFile10(filePath, "utf-8");
+  } catch {
+    return;
+  }
+  const now = Date.now();
+  const lines = content.trim().split("\n").filter(Boolean);
+  const kept = [];
+  for (const line of lines) {
     try {
-      JSON.parse(content);
-      return content;
+      const entry = JSON.parse(line);
+      if (entry.consolidatedAt) {
+        const consolidatedTime = new Date(entry.consolidatedAt).getTime();
+        if (now - consolidatedTime > COMPACTION_AGE_MS) {
+          continue;
+        }
+      }
+      kept.push(JSON.stringify(entry));
     } catch {
     }
   }
-  return content;
-}
-function extractKnowledgeFromResponse(response) {
-  const match = /<knowledge>([\s\S]*?)<\/knowledge>/i.exec(response);
-  if (!match?.[1]) return null;
-  return match[1].trim();
-}
-function checkMemorySize(content) {
-  const sizeKB = Buffer.byteLength(content, "utf-8") / 1024;
-  return { ok: sizeKB <= MAX_SIZE_KB, sizeKB: Math.round(sizeKB * 10) / 10 };
+  let result = `${kept.join("\n")}
+`;
+  while (Buffer.byteLength(result, "utf-8") > MAX_FILE_BYTES && kept.length > 0) {
+    kept.shift();
+    result = `${kept.join("\n")}
+`;
+  }
+  await writeFile4(filePath, result, "utf-8");
 }
-async function compactMemory(dir, content) {
-  if (!content.startsWith("{")) return content;
-  let parsed;
+async function appendLogBuffer(dir, entry) {
   try {
-    parsed = parseStructuredMemory(content);
-  } catch {
-    return content;
-  }
-  let changed = false;
-  if (parsed.recentDecisions.length > MAX_DECISIONS) {
-    const toArchive = parsed.recentDecisions.slice(0, -MAX_DECISIONS);
-    parsed.recentDecisions = parsed.recentDecisions.slice(-MAX_DECISIONS);
-    changed = true;
-    const archivePath = path11.join(dir, ARCHIVE_FILE);
-    const entry = {
-      type: "decisions_archived",
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      decisions: toArchive
-    };
-    await appendFile5(archivePath, `${JSON.stringify(entry)}
+    await appendFile5(bufferPath(dir), `${JSON.stringify(entry)}
 `, "utf-8");
+  } catch {
   }
-  const result = changed ? JSON.stringify(parsed, null, 2) : content;
-  const sizeKB = Buffer.byteLength(result, "utf-8") / 1024;
-  if (sizeKB > MAX_SIZE_KB && parsed.notes.length > 200) {
-    const archivePath = path11.join(dir, ARCHIVE_FILE);
-    const entry = {
-      type: "notes_archived",
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      notes: parsed.notes
-    };
-    await appendFile5(archivePath, `${JSON.stringify(entry)}
-`, "utf-8");
-    parsed.notes = "(archived \u2014 see memory-archive.jsonl)";
-    return JSON.stringify(parsed, null, 2);
-  }
-  return result;
 }
 
 // src/supervisor/prompt-builder.ts
-function buildHeartbeatPrompt(opts) {
-  const sections = [];
-  sections.push(`You are the neo autonomous supervisor (heartbeat #${opts.heartbeatCount}).
-You orchestrate developer agents across repositories. You make decisions autonomously.
-
-Your job:
-1. Process any incoming events (webhooks, user messages, run completions)
-2. Decide what actions to take (dispatch agents, check status, respond to users)
-3. Update your memory with relevant context for future heartbeats
-4. If nothing to do, simply acknowledge and wait
-
-Available commands (via bash):
-  neo run <agent> --prompt "..." [--repo <path>]   dispatch an agent
-  neo runs --short [--all]                         check recent runs
-  neo cost --short [--all]                         check budget
-  neo agents                                       list available agents
-
-IMPORTANT: Always include a <memory>...</memory> block at the end of your response with your updated memory.
-
-## Reporting
-Use the \`mcp__neo__report_progress\` tool to log your decisions, actions and blockers.
-Always report what you're doing and why \u2014 these logs are your audit trail.
-Types: "decision" (what you chose), "action" (what you did), "blocker" (what's stuck), "progress" (status update).`);
-  if (opts.customInstructions) {
-    sections.push(`## Custom instructions
-${opts.customInstructions}`);
-  }
+var ROLE = `You are the neo autonomous supervisor \u2014 a stateless dispatch controller.
+
+You receive state (events, memory, work queue) and produce actions (tool calls).
+
+<behavioral-contract>
+- Your ONLY visible output is \`neo log\` commands. The TUI shows these and nothing else.
+- Your text output is NEVER shown to anyone \u2014 every token of text is wasted cost.
+- Produce tool calls, not explanations. Do not narrate your reasoning.
+- You NEVER modify code \u2014 that is the agents' job.
+</behavioral-contract>`;
+var COMMANDS = `### Dispatching agents
+\`\`\`bash
+neo run <agent> --prompt "..." --repo <path> --branch <name> [--priority critical|high|medium|low] [--meta '<json>']
+\`\`\`
+
+| Flag | Required | Description |
+|------|----------|-------------|
+| \`--prompt\` | always | Task description for the agent |
+| \`--repo\` | always | Target repository path |
+| \`--branch\` | always | Branch name for the isolated clone |
+| \`--priority\` | no | \`critical\`, \`high\`, \`medium\`, \`low\` |
+| \`--meta\` | **always** | JSON with \`"label"\` for identification + \`"ticketId"\`, \`"stage"\`, etc. |
+
+All agents require \`--branch\`. Each agent session runs in an isolated clone on that branch.
+Always include \`--meta '{"label":"T1-auth-middleware","ticketId":"YC-42","stage":"develop"}'\` so you can identify runs later.
+
+### Monitoring & reading agent output
+\`\`\`bash
+neo runs --short                    # check recent runs
+neo runs --short --status running   # check active runs are alive
+neo runs <runId>                    # full run details + agent output (MUST READ on completion)
+neo cost --short [--all]            # check budget
+\`\`\`
+
+\`neo runs <runId>\` returns the agent's full output. **ALWAYS read it when a run completes** \u2014 it contains structured JSON (PR URLs, issues, plans, milestones) that you need to decide next steps.
+
+### Memory
+\`\`\`bash
+neo memory write --type fact --scope /path "Stable fact about repo"
+neo memory write --type focus --expires 2h "Current working context"
+neo memory write --type procedure --scope /path "How to do X"
+neo memory write --type task --scope /path --severity high --category "neo runs <id>" "Task description"
+neo memory update <id> --outcome in_progress|done|blocked|abandoned
+neo memory forget <id>
+neo memory search "keyword"
+neo memory list --type fact
+\`\`\`
+
+### Reporting
+\`\`\`bash
+neo log <type> "<message>"   # visible in TUI only
+\`\`\``;
+var COMMANDS_COMPACT = `### Commands (reference)
+\`neo run <agent> --prompt "..." --repo <path> --branch <name> --meta '{"label":"T1-auth",...}'\`
+\`neo runs [--short | <runId>]\` \xB7 \`neo runs --short --status running\` \xB7 \`neo cost --short\`
+\`neo memory write|update|forget|search|list\` \xB7 \`neo log <type> "<msg>"\`
+ALWAYS read run output on completion: \`neo runs <runId>\` \u2014 it contains the agent's structured result.`;
+var HEARTBEAT_RULES = `### Heartbeat lifecycle
+
+<decision-tree>
+1. DEDUP FIRST \u2014 check focus for PROCESSED entries. Skip any runId already processed.
+2. MONITOR RUNS \u2014 \`neo runs --short\` to check active run status. If a run completed since last HB, read its output with \`neo runs <runId>\` BEFORE doing anything else.
+3. PENDING TASKS? \u2014 dispatch the next eligible task from work queue. Do not re-plan.
+4. EVENTS? \u2014 process run completions, messages, webhooks. Parse agent JSON output.
+5. FOLLOW-UPS? \u2014 check CI (\`gh pr checks\`), deferred dispatches.
+6. DISPATCH \u2014 route work to agents. Mark tasks \`in_progress\`, add ACTIVE to focus.
+7. YIELD \u2014 log your decisions and yield. Do not poll. Completions arrive at future heartbeats.
+</decision-tree>
+
+<run-monitoring>
+Runs are your agents in the field. You MUST track them:
+- **On dispatch**: always include a label in \`--meta\` for identification: \`--meta '{"label":"T6-csv-export","ticketId":"YC-42",...}'\`
+- **On completion**: ALWAYS run \`neo runs <runId>\` to read the agent's full output. The output contains structured JSON (PR URLs, issues, plans) \u2014 you need it to decide next steps.
+- **On failure**: read the output to understand why. Check if the task should be retried, blocked, or abandoned.
+- **Active runs**: check \`neo runs --short --status running\` to verify your runs are still alive. If a run disappeared, investigate.
+</run-monitoring>
+
+<rules>
+- Work queue IS your plan. Never re-plan existing tasks.
+- Maximize parallelism: dispatch independent tasks in the same heartbeat.
+- After dispatch: update focus, yield immediately. Do NOT wait for results.
+- Deferred work (CI pending): MUST check at next heartbeat.
+- Before dispatching a task, run the \`--category\` command from the task to retrieve context.
+</rules>`;
+var REPORTING_RULES = `### Reporting
+
+\`neo log\` is your ONLY visible output. Use telegraphic format.
+
+<log-format>
+neo log decision "<ticket> \u2192 <action> | <1-line reason>"
+neo log action "<agent> <repo>:<branch> run:<runId> | <context>"
+neo log discovery "<what> in <where>"
+</log-format>
+
+<examples>
+<example type="good">
+neo log decision "YC-42 \u2192 developer | clear spec, complexity 3"
+neo log action "developer standards:feat/YC-42-auth run:5900a64a | task T1"
+neo log discovery "CI requires node 20 in api-service"
+</example>
+<example type="bad">
+neo log plan "Good! Now let me check the status and update things accordingly."
+neo log decision "Heartbeat #309: Idle cycle - no action required. All 4 repositories stable."
+neo log action "I've dispatched a developer agent to work on the authentication feature."
+</example>
+</examples>`;
+var MEMORY_RULES_CORE = `### Memory
+
+<memory-types>
+| Type | Store when | TTL |
+|------|-----------|-----|
+| \`fact\` | Stable truth affecting dispatch decisions | Permanent (decays) |
+| \`procedure\` | Same failure 3+ times | Permanent |
+| \`focus\` | After every dispatch/deferral | --expires required |
+| \`task\` | Any planned work (tickets, decompositions, follow-ups) | Until done/abandoned |
+| \`feedback\` | Same review complaint 3+ times | Permanent |
+</memory-types>
+
+<memory-rules>
+- Focus MUST use structured format: ACTIVE/PENDING/WAITING/PROCESSED lines only.
+- NEVER store: file counts, line numbers, completed work details, data available via \`neo runs <id>\`.
+- After PR merge: forget related facts unless they are reusable architectural truths.
+- Pattern escalation: same failure 3+ times \u2192 write a \`procedure\`.
+- Every memory that references external context MUST include a retrieval command (in \`--category\` for tasks, in content for facts/procedures). You are stateless \u2014 if you can't retrieve it later, don't store it.
+</memory-rules>
+
+<task-workflow>
+Tasks are your work queue. The work queue section above shows them with markers (\`\u25CB\` pending, \`[ACTIVE]\` in_progress, \`[BLOCKED]\` blocked).
+
+Create a task for any planned work: incoming tickets, architect decompositions, refiner sub-tickets, follow-up actions, CI fixes.
+- \`--severity critical|high|medium|low\` \u2014 dispatch highest severity first
+- \`--tags "initiative:<name>"\` \u2014 groups related tasks (shown as [initiative] headers in queue)
+- \`--tags "depends:mem_<id>"\` \u2014 task cannot start until dependency is done
+- \`--category\` \u2014 **MANDATORY** \u2014 the command to retrieve context for this task (shown as \`\u2192 <command>\` in queue)
+
+**Context retrieval rule**: every task and relevant memory MUST include a way for you to access its source context at a future heartbeat. You are stateless \u2014 without this, you lose the context.
+- Agent output: \`--category "neo runs <runId>"\`
+- Note/plan: \`--category "cat notes/plan-feature.md"\`
+- Notion ticket: \`--category "API-retrieve-a-page <notionPageId>"\`
+- Architect decomposition: \`--category "neo runs <architectRunId>"\` (contains milestones + tasks)
+
+Lifecycle: create \u2192 \`neo memory update <id> --outcome in_progress\` (on dispatch) \u2192 \`done\` (on success) / \`blocked\` (on failure, will retry) / \`abandoned\` (terminal, won't retry)
+
+Dispatch rule: pick the highest-severity task with no unmet dependencies. Dispatch independent tasks in parallel. Before dispatching, run the \`--category\` command to retrieve task context.
+</task-workflow>
+
+<focus-format>
+ACTIVE: <runId> <agent> "<task>" branch:<name>
+PENDING: <taskId> "<description>" depends:<taskId>
+WAITING: <what> since:HB<N>
+PROCESSED: <runId> \u2192 <outcome> PR#<N>
+</focus-format>
+
+**Notes** (\`notes/\`, via Bash): use for detailed multi-page plans that span multiple heartbeats. After creating a plan, write a focus summary with \`--category "cat notes/<file>"\`. Delete notes when done.`;
+var MEMORY_RULES_EXAMPLES = `<memory-commands>
+neo memory write --type focus --expires 2h "ACTIVE: 5900a64a developer 'T1' branch:feat/x"
+neo memory write --type fact --scope /repo "CI requires pnpm build \u2014 discovered in run abc123"
+neo memory write --type procedure --scope /repo "Check gh pr view before re-dispatch"
+neo memory write --type task --scope /repo --severity high --category "neo runs abc123" --tags "initiative:auth-v2,depends:mem_xyz" "T1: Auth middleware"
+neo memory update <id> --outcome in_progress|done|blocked|abandoned
+neo memory forget <id>
+</memory-commands>`;
+function getCommandsSection(heartbeatCount) {
+  return heartbeatCount <= 3 ? COMMANDS : COMMANDS_COMPACT;
+}
+function buildContextSections(opts) {
+  const parts = [];
   if (opts.repos.length > 0) {
     const repoList = opts.repos.map((r) => `- ${r.path} (branch: ${r.defaultBranch})`).join("\n");
-    sections.push(`## Registered repositories
+    parts.push(`Repositories:
 ${repoList}`);
-  } else {
-    sections.push("## Registered repositories\n(none \u2014 run 'neo init' in a repo to register it)");
   }
   if (opts.mcpServerNames.length > 0) {
     const mcpList = opts.mcpServerNames.map((n) => `- ${n}`).join("\n");
-    sections.push(
-      `## Available integrations (MCP)
-${mcpList}
-
-You can use these tools directly to query external systems.`
-    );
+    parts.push(`Integrations (MCP):
+${mcpList}`);
   }
-  sections.push(
-    `## Budget status
-- Today: $${opts.budgetStatus.todayUsd.toFixed(2)} / $${opts.budgetStatus.capUsd.toFixed(2)} (${opts.budgetStatus.remainingPct.toFixed(0)}% remaining)`
+  parts.push(
+    `Budget: $${opts.budgetStatus.todayUsd.toFixed(2)} / $${opts.budgetStatus.capUsd.toFixed(2)} (${opts.budgetStatus.remainingPct.toFixed(0)}% remaining)`
   );
-  if (opts.activeRuns.length > 0) {
-    sections.push(`## Active runs
-${opts.activeRuns.map((r) => `- ${r}`).join("\n")}`);
+  return parts;
+}
+function buildMemorySection(memories, supervisorDir) {
+  const focusEntries = memories.filter((m) => m.type === "focus");
+  const factEntries = memories.filter((m) => m.type === "fact");
+  const procedureEntries = memories.filter((m) => m.type === "procedure");
+  const feedbackEntries = memories.filter((m) => m.type === "feedback");
+  const parts = [];
+  if (focusEntries.length > 0) {
+    const lines = focusEntries.map((m) => `- ${m.content}`).join("\n");
+    parts.push(`<focus>
+${lines}
+</focus>`);
+  } else {
+    parts.push(
+      "<focus>\n(empty \u2014 use neo memory write --type focus to set working context)\n</focus>"
+    );
   }
-  const { messages, webhooks, runCompletions } = opts.grouped;
-  const totalEvents = messages.length + webhooks.length + runCompletions.length;
-  if (totalEvents > 0) {
-    const parts = [];
-    for (const msg of messages) {
-      const countSuffix = msg.count > 1 ? ` (\xD7${msg.count})` : "";
-      parts.push(`**Message from ${msg.from}${countSuffix}**: ${msg.text}`);
+  if (factEntries.length > 0) {
+    const byScope = /* @__PURE__ */ new Map();
+    for (const m of factEntries) {
+      const scope = m.scope === "global" ? "global" : m.scope.split("/").pop() ?? m.scope;
+      const group = byScope.get(scope) ?? [];
+      group.push(m);
+      byScope.set(scope, group);
     }
-    for (const evt of webhooks) {
-      parts.push(formatEvent(evt));
+    const scopeSections = [];
+    for (const [scope, entries] of byScope) {
+      const oldestAccess = Math.min(
+        ...entries.map((m) => Date.now() - new Date(m.lastAccessedAt).getTime())
+      );
+      const daysAgo = Math.floor(oldestAccess / 864e5);
+      const staleHint = daysAgo >= 5 ? ` (last accessed ${daysAgo}d ago)` : "";
+      const lines = entries.map((m) => {
+        const confidence = m.accessCount >= 3 ? "" : " (unconfirmed)";
+        return `  - ${m.content}${confidence}`;
+      }).join("\n");
+      scopeSections.push(`  [${scope}]${staleHint} (${entries.length})
+${lines}`);
     }
-    for (const evt of runCompletions) {
-      parts.push(formatEvent(evt));
+    parts.push(`Known facts:
+${scopeSections.join("\n")}`);
+  }
+  if (procedureEntries.length > 0) {
+    const lines = procedureEntries.map((m) => `- ${m.content}`).join("\n");
+    parts.push(`Procedures:
+${lines}`);
+  }
+  if (feedbackEntries.length > 0) {
+    const lines = feedbackEntries.map((m) => `- [${m.category ?? "general"}] ${m.content}`).join("\n");
+    parts.push(`Recurring review issues:
+${lines}`);
+  }
+  parts.push(`For detailed plans and checklists, use notes:
+\`\`\`bash
+cat > ${supervisorDir}/notes/plan-feature.md << 'EOF'
+<your detailed plan here>
+EOF
+\`\`\``);
+  return parts.join("\n\n");
+}
+var DONE_OUTCOMES = /* @__PURE__ */ new Set(["done", "abandoned"]);
+var MAX_TASKS = 15;
+function buildWorkQueueSection(memories) {
+  const tasks = memories.filter((m) => m.type === "task" && !DONE_OUTCOMES.has(m.outcome ?? ""));
+  const doneCount = countDoneTasks(memories);
+  if (tasks.length === 0) {
+    if (doneCount > 0) {
+      return `Work queue (0 remaining, ${doneCount} done) \u2014 all tasks complete. Pick up new work or wait for events.`;
     }
-    sections.push(`## Pending events (${totalEvents})
-${parts.join("\n\n")}`);
-  } else {
-    sections.push(
-      "## Pending events\nNo new events. This is an idle heartbeat \u2014 check on active runs if any, or wait."
-    );
+    return "";
   }
-  if (opts.knowledge) {
-    sections.push(`## Reference knowledge (read-only)
-${opts.knowledge}
-
-To update knowledge, output a \`<knowledge>...</knowledge>\` block. Only update when reference data changes (API IDs, workspace config, etc.).`);
+  const groups = groupTasksByInitiative(tasks);
+  const lines = renderTaskGroups(groups);
+  if (tasks.length > MAX_TASKS) {
+    lines.push(`  ... and ${tasks.length - MAX_TASKS} more pending`);
   }
-  sections.push(buildMemorySection(opts.memory, opts.memorySizeKB));
-  return sections.join("\n\n---\n\n");
+  const header = `Work queue (${tasks.length} remaining, ${doneCount} done) \u2014 dispatch the next eligible task:`;
+  return `${header}
+${lines.join("\n")}`;
 }
-function buildMemorySection(memory, memorySizeKB) {
-  const schema = `{
-  "activeWork": ["description of current task 1", ...],
-  "blockers": ["what is stuck and why", ...],
-  "repoNotes": { "/path/to/repo": "relevant context about this repo" },
-  "recentDecisions": [{ "date": "YYYY-MM-DD", "decision": "what you decided", "outcome": "result" }],
-  "trackerSync": { "ticket-id": "last known status" },
-  "notes": "free-form context that doesn't fit elsewhere"
-}`;
-  if (!memory) {
-    return `## Your current memory
-(empty \u2014 this is your first heartbeat, initialize your memory)
-
-Your memory MUST be a JSON object inside \`<memory>...</memory>\` tags:
-\`\`\`
-${schema}
-\`\`\`
-Keep under 8KB. Prune old decisions (keep last 10).`;
+function countDoneTasks(memories) {
+  return memories.filter((m) => m.type === "task" && DONE_OUTCOMES.has(m.outcome ?? "")).length;
+}
+function groupTasksByInitiative(tasks) {
+  const initiativeMap = /* @__PURE__ */ new Map();
+  const noInitiative = [];
+  for (const task of tasks) {
+    const tag = task.tags.find((t) => t.startsWith("initiative:"));
+    if (tag) {
+      const key = tag.slice("initiative:".length);
+      const group = initiativeMap.get(key) ?? [];
+      group.push(task);
+      initiativeMap.set(key, group);
+    } else {
+      noInitiative.push(task);
+    }
   }
-  const sizeWarning = memorySizeKB > 8 ? "\n\n**Memory is over 8KB \u2014 condense it. Remove old decisions, summarize notes.**" : "";
-  return `## Your current memory (${memorySizeKB}KB)${sizeWarning}
-${memory}
-
-Remember: update your memory as a JSON object inside \`<memory>...</memory>\` tags.
-Schema: ${schema}`;
+  const groups = [];
+  for (const [initiative, taskList] of initiativeMap) {
+    groups.push({ initiative, tasks: taskList });
+  }
+  if (noInitiative.length > 0) {
+    groups.push({ initiative: null, tasks: noInitiative });
+  }
+  return groups;
+}
+function renderTaskGroups(groups) {
+  const lines = [];
+  let rendered = 0;
+  for (const group of groups) {
+    if (rendered >= MAX_TASKS) break;
+    if (group.initiative && groups.length > 1) {
+      lines.push(`  [${group.initiative}]`);
+    }
+    for (const task of group.tasks) {
+      if (rendered >= MAX_TASKS) break;
+      lines.push(`  ${formatTaskLine(task)}`);
+      rendered++;
+    }
+  }
+  return lines;
+}
+function formatTaskLine(task) {
+  const marker = formatTaskMarker(task.outcome);
+  const severity = task.severity ? `[${task.severity}] ` : "";
+  const scope = task.scope !== "global" ? ` (${getBasename(task.scope)})` : "";
+  const run = task.runId ? ` [run ${task.runId.slice(0, 8)}]` : "";
+  const cat = task.category ? ` \u2192 ${task.category}` : "";
+  return `${marker} ${severity}${task.content}${scope}${run}${cat}`;
+}
+function formatTaskMarker(outcome) {
+  switch (outcome) {
+    case "in_progress":
+      return "[ACTIVE]";
+    case "blocked":
+      return "[BLOCKED]";
+    default:
+      return "\u25CB";
+  }
+}
+function getBasename(scopePath) {
+  const parts = scopePath.split("/");
+  return parts[parts.length - 1] || scopePath;
+}
+var SIGNIFICANT_TYPES = /* @__PURE__ */ new Set(["decision", "action", "dispatch", "error"]);
+function buildRecentActionsSection(entries) {
+  const significant = entries.filter((e) => SIGNIFICANT_TYPES.has(e.type));
+  if (significant.length === 0) return "";
+  const lines = significant.map((e) => {
+    const ago = formatTimeAgo(Date.now() - new Date(e.timestamp).getTime());
+    return `- [${e.type}] ${e.summary} (${ago})`;
+  });
+  return `Recent actions (your last heartbeats):
+${lines.join("\n")}`;
+}
+function formatTimeAgo(ms) {
+  if (ms < 6e4) return "just now";
+  const minutes = Math.floor(ms / 6e4);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h${minutes % 60}m ago`;
+  return `${Math.floor(hours / 24)}d ago`;
+}
+function buildEventsSection(grouped) {
+  const { messages, webhooks, runCompletions } = grouped;
+  const totalEvents = messages.length + webhooks.length + runCompletions.length;
+  if (totalEvents === 0) {
+    return "No new events.";
+  }
+  const parts = [];
+  for (const msg of messages) {
+    const countSuffix = msg.count > 1 ? ` (x${msg.count})` : "";
+    parts.push(`Message from ${msg.from}${countSuffix}: ${msg.text}`);
+  }
+  for (const evt of webhooks) {
+    parts.push(formatEvent(evt));
+  }
+  for (const evt of runCompletions) {
+    parts.push(formatEvent(evt));
+  }
+  return `${totalEvents} pending event(s):
+${parts.join("\n\n")}`;
 }
 function formatEvent(event) {
   switch (event.kind) {
     case "webhook":
-      return `**Webhook** [${event.data.source ?? "unknown"}] ${event.data.event ?? ""}
+      return `Webhook [${event.data.source ?? "unknown"}] ${event.data.event ?? ""}
 \`\`\`json
 ${JSON.stringify(event.data.payload ?? {}, null, 2)}
 \`\`\``;
     case "message":
-      return `**Message from ${event.data.from}**: ${event.data.text}`;
+      return `Message from ${event.data.from}: ${event.data.text}`;
     case "run_complete":
-      return `**Run completed**: ${event.runId} (check with \`neo runs\`)`;
+      return `Run completed: ${event.runId} (check with \`neo runs\`)`;
+    case "internal":
+      return `Internal event: ${event.eventKind}`;
   }
 }
+function isIdleHeartbeat(opts) {
+  const { messages, webhooks, runCompletions } = opts.grouped;
+  const totalEvents = messages.length + webhooks.length + runCompletions.length;
+  const hasWork = buildWorkQueueSection(opts.memories) !== "";
+  return totalEvents === 0 && opts.activeRuns.length === 0 && !hasWork;
+}
+function buildIdlePrompt(opts) {
+  return `<role>
+${ROLE}
+Heartbeat #${opts.heartbeatCount}
+</role>
+
+<context>
+No events. No active runs. No pending tasks.
+Budget: $${opts.budgetStatus.todayUsd.toFixed(2)} / $${opts.budgetStatus.capUsd.toFixed(2)} (${opts.budgetStatus.remainingPct.toFixed(0)}% remaining)
+</context>
+
+<directive>
+Nothing to do. Run \`neo log discovery "idle"\` and yield. Do not produce any other output.
+</directive>`;
+}
+function buildStandardPrompt(opts) {
+  const sections = [];
+  sections.push(`<role>
+${ROLE}
+Heartbeat #${opts.heartbeatCount}
+</role>`);
+  const contextParts = [];
+  const workQueue = buildWorkQueueSection(opts.memories);
+  if (workQueue) {
+    contextParts.push(workQueue);
+  }
+  if (opts.activeRuns.length > 0) {
+    contextParts.push(`Active runs:
+${opts.activeRuns.map((r) => `- ${r}`).join("\n")}`);
+  }
+  contextParts.push(...buildContextSections(opts));
+  contextParts.push(buildMemorySection(opts.memories, opts.supervisorDir));
+  const recentActions = buildRecentActionsSection(opts.recentActions);
+  if (recentActions) {
+    contextParts.push(recentActions);
+  }
+  contextParts.push(`Events:
+${buildEventsSection(opts.grouped)}`);
+  sections.push(`<context>
+${contextParts.join("\n\n")}
+</context>`);
+  sections.push(`<reference>
+${getCommandsSection(opts.heartbeatCount)}
+</reference>`);
+  const instructionParts = [];
+  instructionParts.push(HEARTBEAT_RULES);
+  instructionParts.push(REPORTING_RULES);
+  instructionParts.push(MEMORY_RULES_CORE);
+  if (opts.customInstructions) {
+    instructionParts.push(`### Custom instructions
+${opts.customInstructions}`);
+  }
+  const { messages, webhooks, runCompletions } = opts.grouped;
+  const hasEvents = messages.length + webhooks.length + runCompletions.length > 0;
+  instructionParts.push(
+    hasEvents ? "Process events, dispatch eligible work, yield. Each heartbeat costs ~$0.10 \u2014 be efficient." : "No events. If pending work exists, dispatch it. Otherwise yield immediately."
+  );
+  sections.push(`<instructions>
+${instructionParts.join("\n\n")}
+</instructions>`);
+  return sections.join("\n\n");
+}
+function buildConsolidationPrompt(opts) {
+  const sections = [];
+  sections.push(`<role>
+${ROLE}
+Heartbeat #${opts.heartbeatCount} (CONSOLIDATION)
+</role>`);
+  const contextParts = [];
+  const workQueueConsolidation = buildWorkQueueSection(opts.memories);
+  if (workQueueConsolidation) {
+    contextParts.push(workQueueConsolidation);
+  }
+  if (opts.activeRuns.length > 0) {
+    contextParts.push(`Active runs:
+${opts.activeRuns.map((r) => `- ${r}`).join("\n")}`);
+  }
+  contextParts.push(...buildContextSections(opts));
+  contextParts.push(buildMemorySection(opts.memories, opts.supervisorDir));
+  const recentActions = buildRecentActionsSection(opts.recentActions);
+  if (recentActions) {
+    contextParts.push(recentActions);
+  }
+  contextParts.push(`Events:
+${buildEventsSection(opts.grouped)}`);
+  sections.push(`<context>
+${contextParts.join("\n\n")}
+</context>`);
+  sections.push(`<reference>
+${getCommandsSection(opts.heartbeatCount)}
+</reference>`);
+  const instructionParts = [];
+  instructionParts.push(HEARTBEAT_RULES);
+  instructionParts.push(REPORTING_RULES);
+  instructionParts.push(MEMORY_RULES_CORE);
+  instructionParts.push(MEMORY_RULES_EXAMPLES);
+  if (opts.customInstructions) {
+    instructionParts.push(`### Custom instructions
+${opts.customInstructions}`);
+  }
+  instructionParts.push(
+    `### Consolidation
+This is a CONSOLIDATION heartbeat.
+
+**Idle guard**: if there are NO active runs AND no new events since last consolidation, log "idle, no changes" and yield immediately. Do NOT re-validate facts you already reviewed.
+
+If there IS active work, your job:
+
+1. **Review memory** \u2014 check facts and procedures for accuracy. Remove outdated entries. Resolve contradictions (keep newer). Remove facts about completed work (merged PRs, finished initiatives).
+2. **Update focus** \u2014 rewrite focus using the MANDATORY structured format (ACTIVE/PENDING/WAITING/PROCESSED). Remove resolved items. Add new context.
+3. **Pattern escalation** \u2014 if agents hit the same issue 3+ times (check recent actions), write a \`procedure\` to prevent recurrence.
+4. **Prune completed work** \u2014 if a PR is merged or an initiative is done, forget related facts that are no longer actionable. Keep only reusable architectural truths.
+5. **Prune done tasks** \u2014 forget tasks with outcome \`done\` or \`abandoned\` older than 7 days.`
+  );
+  sections.push(`<instructions>
+${instructionParts.join("\n\n")}
+</instructions>`);
+  return sections.join("\n\n");
+}
+function buildCompactionPrompt(opts) {
+  const sections = [];
+  sections.push(`<role>
+${ROLE}
+Heartbeat #${opts.heartbeatCount} (COMPACTION)
+</role>`);
+  const contextParts = [];
+  contextParts.push(...buildContextSections(opts));
+  contextParts.push(buildMemorySection(opts.memories, opts.supervisorDir));
+  const workQueueCompaction = buildWorkQueueSection(opts.memories);
+  if (workQueueCompaction) {
+    contextParts.push(workQueueCompaction);
+  }
+  sections.push(`<context>
+${contextParts.join("\n\n")}
+</context>`);
+  sections.push(`<reference>
+${getCommandsSection(opts.heartbeatCount)}
+</reference>`);
+  const instructionParts = [];
+  instructionParts.push(HEARTBEAT_RULES);
+  instructionParts.push(REPORTING_RULES);
+  instructionParts.push(MEMORY_RULES_CORE);
+  instructionParts.push(MEMORY_RULES_EXAMPLES);
+  if (opts.customInstructions) {
+    instructionParts.push(`### Custom instructions
+${opts.customInstructions}`);
+  }
+  instructionParts.push(`### Compaction
+This is a COMPACTION heartbeat. Deep-clean your ENTIRE memory.
+
+1. **Remove stale facts** \u2014 facts >7 days old with no recent reinforcement. Check the "(last accessed Xd ago)" hints in the facts section.
+2. **Remove completed-work facts** \u2014 if all PRs for a repo initiative are merged/closed, forget related facts. Keep only reusable architectural truths (build system, CI config, tooling).
+3. **Remove trivial facts** \u2014 file counts, line numbers, structural details that \`ls\` or \`cat package.json\` can answer. These waste context.
+4. **Merge duplicates** \u2014 combine similar facts within the same scope into one.
+5. **Clean up focus** \u2014 forget resolved items, rewrite remaining in structured format.
+6. **Prune done tasks** \u2014 forget tasks with outcome \`done\` or \`abandoned\` older than 7 days.
+7. **Delete completed notes** from notes/ directory.
+8. **Stay under 15 facts per scope** \u2014 prioritize facts that affect dispatch decisions.
+
+Flag contradictions: if two facts contradict, keep the newer one.
+
+\`\`\`bash
+neo memory list --type fact
+neo memory forget <stale-id>
+\`\`\``);
+  sections.push(`<instructions>
+${instructionParts.join("\n\n")}
+</instructions>`);
+  return sections.join("\n\n");
+}
 
 // src/supervisor/heartbeat.ts
+var DEFAULT_IDLE_SKIP_MAX = 20;
+var DEFAULT_ACTIVE_WORK_SKIP_MAX = 3;
+var DEFAULT_CONSOLIDATION_INTERVAL = 5;
+function shouldConsolidate(heartbeatCount, lastConsolidationHeartbeat, consolidationInterval, hasPendingEntries) {
+  const since = heartbeatCount - lastConsolidationHeartbeat;
+  if (since >= consolidationInterval) return true;
+  if (hasPendingEntries && since >= 2) return true;
+  return false;
+}
+function shouldCompact(heartbeatCount, lastCompactionHeartbeat, compactionInterval = 50) {
+  const since = heartbeatCount - lastCompactionHeartbeat;
+  return since >= compactionInterval;
+}
 var HeartbeatLoop = class {
   stopping = false;
   consecutiveFailures = 0;
@@ -2786,6 +4158,9 @@ var HeartbeatLoop = class {
   eventQueue;
   activityLog;
   customInstructions;
+  defaultInstructionsPath;
+  memoryStore = null;
+  memoryDbPath;
   constructor(options) {
     this.config = options.config;
     this.supervisorDir = options.supervisorDir;
@@ -2793,6 +4168,17 @@ var HeartbeatLoop = class {
     this.sessionId = options.sessionId;
     this.eventQueue = options.eventQueue;
     this.activityLog = options.activityLog;
+    this.defaultInstructionsPath = options.defaultInstructionsPath;
+    this.memoryDbPath = options.memoryDbPath;
+  }
+  getMemoryStore() {
+    if (!this.memoryStore && this.memoryDbPath) {
+      try {
+        this.memoryStore = new MemoryStore(this.memoryDbPath);
+      } catch {
+      }
+    }
+    return this.memoryStore;
   }
   async start() {
     this.customInstructions = await this.loadInstructions();
@@ -2807,7 +4193,7 @@ var HeartbeatLoop = class {
         await this.activityLog.log("error", `Heartbeat failed: ${msg}`, { error: msg });
         if (this.consecutiveFailures >= this.config.supervisor.maxConsecutiveFailures) {
           const backoffMs = Math.min(
-            this.config.supervisor.idleIntervalMs * 2 ** (this.consecutiveFailures - this.config.supervisor.maxConsecutiveFailures),
+            this.config.supervisor.eventTimeoutMs * 2 ** (this.consecutiveFailures - this.config.supervisor.maxConsecutiveFailures),
             15 * 60 * 1e3
             // max 15 minutes
           );
@@ -2820,7 +4206,7 @@ var HeartbeatLoop = class {
         }
       }
       if (this.stopping) break;
-      await this.eventQueue.waitForEvent(this.config.supervisor.idleIntervalMs);
+      await this.eventQueue.waitForEvent(this.config.supervisor.eventTimeoutMs);
     }
     await this.activityLog.log("heartbeat", "Supervisor heartbeat loop stopped");
   }
@@ -2831,57 +4217,234 @@ var HeartbeatLoop = class {
   }
   async runHeartbeat() {
     const startTime = Date.now();
-    const heartbeatId = randomUUID3();
+    const heartbeatId = randomUUID5();
     const state = await this.readState();
     const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const budgetCheck = await this.checkBudgetExceeded(state, today);
+    if (budgetCheck.exceeded) return;
+    const grouped = this.eventQueue.drainAndGroup();
+    const totalEventCount = grouped.messages.length + grouped.webhooks.length + grouped.runCompletions.length;
+    const activeRuns = await this.getActiveRuns();
+    const skipResult = await this.handleSkipLogic({
+      state,
+      totalEventCount,
+      activeRuns
+    });
+    if (skipResult.shouldSkip) return;
+    if (skipResult.resetCounters) {
+      await this.updateState({ idleSkipCount: 0, activeWorkSkipCount: 0 });
+    }
+    const modeResult = await this.determineHeartbeatMode(state);
+    const { prompt, modeLabel } = await this.buildHeartbeatModePrompt({
+      grouped,
+      todayCost: budgetCheck.todayCost,
+      heartbeatCount: modeResult.heartbeatCount,
+      unconsolidated: modeResult.unconsolidated,
+      isCompaction: modeResult.isCompaction,
+      isConsolidation: modeResult.isConsolidation,
+      activeRuns,
+      lastHeartbeat: state?.lastHeartbeat,
+      lastConsolidationTimestamp: modeResult.lastConsolidationTs
+    });
+    await this.activityLog.log(
+      "heartbeat",
+      `Heartbeat #${modeResult.heartbeatCount} starting (${modeLabel})`,
+      {
+        heartbeatId,
+        eventCount: totalEventCount,
+        messages: grouped.messages.length,
+        webhooks: grouped.webhooks.length,
+        runCompletions: grouped.runCompletions.length,
+        isConsolidation: modeResult.isConsolidation
+      }
+    );
+    const { costUsd, turnCount } = await this.callSdk(prompt, heartbeatId);
+    if (modeResult.isConsolidation) {
+      const allIds = modeResult.unconsolidated.map((e) => e.id);
+      if (allIds.length > 0) {
+        await markConsolidated(this.supervisorDir, allIds);
+      }
+      await compactLogBuffer(this.supervisorDir);
+    }
+    const durationMs = Date.now() - startTime;
+    const { stateUpdate } = this.buildStateUpdate({
+      state,
+      today,
+      todayCost: budgetCheck.todayCost,
+      costUsd,
+      heartbeatCount: modeResult.heartbeatCount,
+      isConsolidation: modeResult.isConsolidation,
+      isCompaction: modeResult.isCompaction
+    });
+    await this.updateState(stateUpdate);
+    await this.activityLog.log(
+      "heartbeat",
+      `Heartbeat #${modeResult.heartbeatCount + 1} complete (${modeLabel})`,
+      {
+        heartbeatId,
+        costUsd,
+        durationMs,
+        turnCount,
+        isConsolidation: modeResult.isConsolidation
+      }
+    );
+  }
+  /**
+   * Check if supervisor daily budget is exceeded.
+   */
+  async checkBudgetExceeded(state, today) {
     const todayCost = state?.costResetDate === today ? state.todayCostUsd ?? 0 : 0;
     if (todayCost >= this.config.supervisor.dailyCapUsd) {
       await this.activityLog.log(
         "error",
         `Supervisor daily budget exceeded ($${todayCost.toFixed(2)} / $${this.config.supervisor.dailyCapUsd}). Skipping heartbeat.`
       );
-      await this.sleep(this.config.supervisor.idleIntervalMs);
-      return;
+      await this.sleep(this.config.supervisor.eventTimeoutMs);
+      return { todayCost, exceeded: true };
     }
-    const grouped = this.eventQueue.drainAndGroup();
-    const totalEventCount = grouped.messages.length + grouped.webhooks.length + grouped.runCompletions.length;
+    return { todayCost, exceeded: false };
+  }
+  /**
+   * Handle skip logic for idle and active-work scenarios.
+   */
+  async handleSkipLogic(opts) {
+    const { state, totalEventCount, activeRuns } = opts;
     const idleSkipCount = state?.idleSkipCount ?? 0;
-    if (totalEventCount === 0 && idleSkipCount < this.config.supervisor.idleSkipMax) {
-      await this.updateState({ idleSkipCount: idleSkipCount + 1 });
-      await this.activityLog.log("heartbeat", `Idle skip #${idleSkipCount + 1} \u2014 no events`);
-      return;
+    const activeWorkSkipCount = state?.activeWorkSkipCount ?? 0;
+    const hasActiveWork = activeRuns.length > 0;
+    if (totalEventCount === 0) {
+      if (hasActiveWork) {
+        if (activeWorkSkipCount < DEFAULT_ACTIVE_WORK_SKIP_MAX) {
+          await this.updateState({
+            activeWorkSkipCount: activeWorkSkipCount + 1,
+            idleSkipCount: 0
+          });
+          await this.activityLog.log(
+            "heartbeat",
+            `Active-work skip #${activeWorkSkipCount + 1}/${DEFAULT_ACTIVE_WORK_SKIP_MAX} \u2014 ${activeRuns.length} runs active, no events`
+          );
+          return { shouldSkip: true, resetCounters: false };
+        }
+      } else {
+        if (idleSkipCount < DEFAULT_IDLE_SKIP_MAX) {
+          await this.updateState({
+            idleSkipCount: idleSkipCount + 1,
+            activeWorkSkipCount: 0
+          });
+          await this.activityLog.log("heartbeat", `Idle skip #${idleSkipCount + 1} \u2014 no events`);
+          return { shouldSkip: true, resetCounters: false };
+        }
+      }
     }
-    if (idleSkipCount > 0) {
-      await this.updateState({ idleSkipCount: 0 });
+    const needsReset = idleSkipCount > 0 || activeWorkSkipCount > 0;
+    return { shouldSkip: false, resetCounters: needsReset };
+  }
+  /**
+   * Determine heartbeat mode: compaction > consolidation > standard.
+   */
+  async determineHeartbeatMode(state) {
+    const heartbeatCount = state?.heartbeatCount ?? 0;
+    const lastConsolidation = state?.lastConsolidationHeartbeat ?? 0;
+    const lastCompaction = state?.lastCompactionHeartbeat ?? 0;
+    const lastConsolidationTs = state?.lastConsolidationTimestamp;
+    const unconsolidated = await readUnconsolidated(this.supervisorDir);
+    const hasNewEntriesSinceLastConsolidation = lastConsolidationTs ? unconsolidated.some((e) => e.timestamp > lastConsolidationTs) : unconsolidated.length > 0;
+    const hasPendingEntries = unconsolidated.length > 0;
+    const isCompaction = shouldCompact(heartbeatCount, lastCompaction);
+    const wouldConsolidate = shouldConsolidate(
+      heartbeatCount,
+      lastConsolidation,
+      DEFAULT_CONSOLIDATION_INTERVAL,
+      hasPendingEntries
+    );
+    const isConsolidation = isCompaction || wouldConsolidate && hasNewEntriesSinceLastConsolidation;
+    return {
+      isConsolidation,
+      isCompaction,
+      unconsolidated,
+      heartbeatCount,
+      lastConsolidation,
+      lastConsolidationTs
+    };
+  }
+  /**
+   * Build the state update object after heartbeat completion.
+   */
+  buildStateUpdate(opts) {
+    const stateUpdate = {
+      sessionId: this.sessionId,
+      lastHeartbeat: (/* @__PURE__ */ new Date()).toISOString(),
+      heartbeatCount: opts.heartbeatCount + 1,
+      totalCostUsd: (opts.state?.totalCostUsd ?? 0) + opts.costUsd,
+      todayCostUsd: opts.todayCost + opts.costUsd,
+      costResetDate: opts.today
+    };
+    if (opts.isConsolidation) {
+      stateUpdate.lastConsolidationHeartbeat = opts.heartbeatCount + 1;
+      stateUpdate.lastConsolidationTimestamp = (/* @__PURE__ */ new Date()).toISOString();
     }
-    const memory = await loadMemory(this.supervisorDir);
-    const knowledge = await loadKnowledge(this.supervisorDir);
-    const memoryCheck = checkMemorySize(memory);
+    if (opts.isCompaction) {
+      stateUpdate.lastCompactionHeartbeat = opts.heartbeatCount + 1;
+    }
+    return { stateUpdate };
+  }
+  /**
+   * Build the prompt for the current heartbeat mode.
+   */
+  async buildHeartbeatModePrompt(opts) {
     const mcpServerNames = this.config.mcpServers ? Object.keys(this.config.mcpServers) : [];
-    const prompt = buildHeartbeatPrompt({
+    const store = this.getMemoryStore();
+    const memories = store ? store.query({ limit: 40, sortBy: "relevance" }) : [];
+    const recentActions = await this.activityLog.tail(20);
+    const sharedOpts = {
       repos: this.config.repos,
-      memory,
-      knowledge,
-      memorySizeKB: memoryCheck.sizeKB,
-      grouped,
+      grouped: opts.grouped,
       budgetStatus: {
-        todayUsd: todayCost,
+        todayUsd: opts.todayCost,
         capUsd: this.config.supervisor.dailyCapUsd,
-        remainingPct: (this.config.supervisor.dailyCapUsd - todayCost) / this.config.supervisor.dailyCapUsd * 100
+        remainingPct: (this.config.supervisor.dailyCapUsd - opts.todayCost) / this.config.supervisor.dailyCapUsd * 100
       },
-      activeRuns: [],
-      // TODO: read from persisted runs
-      heartbeatCount: state?.heartbeatCount ?? 0,
+      activeRuns: opts.activeRuns,
+      heartbeatCount: opts.heartbeatCount,
       mcpServerNames,
-      customInstructions: this.customInstructions
-    });
-    await this.activityLog.log("heartbeat", `Heartbeat #${state?.heartbeatCount ?? 0} starting`, {
-      heartbeatId,
-      eventCount: totalEventCount,
-      messages: grouped.messages.length,
-      webhooks: grouped.webhooks.length,
-      runCompletions: grouped.runCompletions.length
-    });
+      customInstructions: this.customInstructions,
+      supervisorDir: this.supervisorDir,
+      memories,
+      recentActions
+    };
+    if (opts.isCompaction) {
+      return {
+        prompt: buildCompactionPrompt({
+          ...sharedOpts,
+          lastConsolidationTimestamp: opts.lastConsolidationTimestamp
+        }),
+        modeLabel: "compaction"
+      };
+    }
+    if (opts.isConsolidation) {
+      return {
+        prompt: buildConsolidationPrompt({
+          ...sharedOpts,
+          lastConsolidationTimestamp: opts.lastConsolidationTimestamp
+        }),
+        modeLabel: "consolidation"
+      };
+    }
+    if (isIdleHeartbeat(sharedOpts)) {
+      return {
+        prompt: buildIdlePrompt(sharedOpts),
+        modeLabel: "idle"
+      };
+    }
+    return {
+      prompt: buildStandardPrompt(sharedOpts),
+      modeLabel: "standard"
+    };
+  }
+  /**
+   * Call the Claude SDK and stream results.
+   */
+  async callSdk(prompt, heartbeatId) {
     const abortController = new AbortController();
     this.activeAbort = abortController;
     const timeout = setTimeout(() => {
@@ -2892,41 +4455,27 @@ var HeartbeatLoop = class {
     let turnCount = 0;
     try {
       const sdk = await import("@anthropic-ai/claude-agent-sdk");
-      const allowedTools = ["Bash", "Read", "mcp__neo__*"];
+      const allowedTools = ["Bash", "Read"];
       if (this.config.mcpServers) {
         for (const name of Object.keys(this.config.mcpServers)) {
           allowedTools.push(`mcp__${name}__*`);
         }
       }
-      const mcpInternalPath = path12.join(
-        path12.dirname(fileURLToPath(import.meta.url)),
-        "mcp-internal.js"
-      );
-      const mcpServers = {
-        neo: {
-          type: "stdio",
-          command: "node",
-          args: [mcpInternalPath],
-          env: { NEO_ACTIVITY_PATH: this.activityLog.filePath }
-        },
-        ...this.config.mcpServers ?? {}
-      };
       const queryOptions = {
         cwd: homedir2(),
-        maxTurns: 50,
         allowedTools,
         permissionMode: "bypassPermissions",
         allowDangerouslySkipPermissions: true,
-        mcpServers
+        mcpServers: this.config.mcpServers ?? {}
       };
       const stream = sdk.query({ prompt, options: queryOptions });
       for await (const message of stream) {
         if (abortController.signal.aborted) break;
         const msg = message;
-        if (msg.type === "system" && msg.subtype === "init") {
+        if (isInitMessage(msg)) {
           this.sessionId = msg.session_id;
         }
-        if (msg.type === "result") {
+        if (isResultMessage(msg)) {
           output = msg.result ?? "";
           costUsd = msg.total_cost_usd ?? 0;
           turnCount = msg.num_turns ?? 0;
@@ -2937,39 +4486,11 @@ var HeartbeatLoop = class {
       clearTimeout(timeout);
       this.activeAbort = null;
     }
-    const newMemory = extractMemoryFromResponse(output);
-    if (newMemory) {
-      await saveMemory(this.supervisorDir, newMemory);
-    }
-    const newKnowledge = extractKnowledgeFromResponse(output);
-    if (newKnowledge) {
-      await saveKnowledge(this.supervisorDir, newKnowledge);
-    }
-    const durationMs = Date.now() - startTime;
-    await this.updateState({
-      sessionId: this.sessionId,
-      lastHeartbeat: (/* @__PURE__ */ new Date()).toISOString(),
-      heartbeatCount: (state?.heartbeatCount ?? 0) + 1,
-      totalCostUsd: (state?.totalCostUsd ?? 0) + costUsd,
-      todayCostUsd: todayCost + costUsd,
-      costResetDate: today
-    });
-    await this.activityLog.log(
-      "heartbeat",
-      `Heartbeat #${(state?.heartbeatCount ?? 0) + 1} complete`,
-      {
-        heartbeatId,
-        costUsd,
-        durationMs,
-        turnCount,
-        memoryUpdated: !!newMemory,
-        responseSummary: output
-      }
-    );
+    return { output, costUsd, turnCount };
   }
   async readState() {
     try {
-      const raw = await readFile9(this.statePath, "utf-8");
+      const raw = await readFile11(this.statePath, "utf-8");
       return JSON.parse(raw);
     } catch {
       return null;
@@ -2977,29 +4498,63 @@ var HeartbeatLoop = class {
   }
   async updateState(updates) {
     try {
-      const raw = await readFile9(this.statePath, "utf-8");
+      const raw = await readFile11(this.statePath, "utf-8");
       const state = JSON.parse(raw);
       Object.assign(state, updates);
       await writeFile5(this.statePath, JSON.stringify(state, null, 2), "utf-8");
     } catch {
     }
   }
+  /** Read persisted run files and return summaries of active (running/paused) runs. */
+  async getActiveRuns() {
+    const runsDir = getRunsDir();
+    if (!existsSync7(runsDir)) return [];
+    try {
+      const entries = await readdir5(runsDir, { withFileTypes: true });
+      const active = [];
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const subDir = path14.join(runsDir, entry.name);
+        const files = await readdir5(subDir);
+        for (const f of files) {
+          if (!f.endsWith(".json")) continue;
+          try {
+            const raw = await readFile11(path14.join(subDir, f), "utf-8");
+            const run = JSON.parse(raw);
+            if (run.status === "running" || run.status === "paused") {
+              active.push(
+                `${run.runId} [${run.status}] ${run.workflow} on ${path14.basename(run.repo)}`
+              );
+            }
+          } catch {
+          }
+        }
+      }
+      return active;
+    } catch {
+      return [];
+    }
+  }
   /**
    * Load custom instructions from SUPERVISOR.md.
    * Resolution order:
    * 1. Explicit path via `supervisor.instructions` in config
-   * 2. Default: ~/.neo/SUPERVISOR.md
+   * 2. User default: ~/.neo/SUPERVISOR.md
+   * 3. Bundled default from @neotx/agents (if path provided)
    */
   async loadInstructions() {
     const candidates = [];
     if (this.config.supervisor.instructions) {
-      candidates.push(path12.resolve(this.config.supervisor.instructions));
+      candidates.push(path14.resolve(this.config.supervisor.instructions));
+    }
+    candidates.push(path14.join(getDataDir(), "SUPERVISOR.md"));
+    if (this.defaultInstructionsPath) {
+      candidates.push(this.defaultInstructionsPath);
     }
-    candidates.push(path12.join(getDataDir(), "SUPERVISOR.md"));
     for (const filePath of candidates) {
       try {
-        const content = await readFile9(filePath, "utf-8");
-        await this.activityLog.log("event", `Loaded custom instructions from ${filePath}`);
+        const content = await readFile11(filePath, "utf-8");
+        await this.activityLog.log("event", `Loaded instructions from ${filePath}`);
         return content;
       } catch {
       }
@@ -3008,17 +4563,17 @@ var HeartbeatLoop = class {
   }
   /** Route a single SDK stream message to the appropriate log handler. */
   async logStreamMessage(msg, heartbeatId) {
-    if (msg.type !== "assistant") return;
-    if (!msg.subtype) {
+    if (isAssistantMessage(msg)) {
       await this.logContentBlocks(msg, heartbeatId);
-    } else if (msg.subtype === "tool_use") {
+    } else if (isToolUseMessage(msg)) {
       await this.logToolUse(msg, heartbeatId);
-    } else if (msg.subtype === "tool_result") {
+    } else if (isToolResultMessage(msg)) {
       await this.logToolResult(msg, heartbeatId);
     }
   }
   /** Log thinking and plan blocks from assistant content — no truncation. */
   async logContentBlocks(msg, heartbeatId) {
+    if (!isAssistantMessage(msg)) return;
     const content = msg.message?.content;
     if (!content) return;
     for (const block of content) {
@@ -3033,7 +4588,8 @@ var HeartbeatLoop = class {
   }
   /** Log tool use events — distinguish MCP tools from built-in tools. */
   async logToolUse(msg, heartbeatId) {
-    const toolName = String(msg.tool ?? "unknown");
+    if (!isToolUseMessage(msg)) return;
+    const toolName = msg.tool;
     const isMcp = toolName.startsWith("mcp__");
     await this.activityLog.log(
       isMcp ? "tool_use" : "action",
@@ -3043,7 +4599,8 @@ var HeartbeatLoop = class {
   }
   /** Detect agent dispatches from bash tool results. */
   async logToolResult(msg, heartbeatId) {
-    const result = String(msg.result ?? "");
+    if (!isToolResultMessage(msg)) return;
+    const result = msg.result ?? "";
     const runMatch = /Run\s+(\S+)\s+dispatched/i.exec(result);
     if (runMatch) {
       await this.activityLog.log("dispatch", `Agent dispatched: ${runMatch[1]}`, {
@@ -3058,7 +4615,7 @@ var HeartbeatLoop = class {
 };
 
 // src/supervisor/webhook-server.ts
-import { timingSafeEqual } from "crypto";
+import { createHmac as createHmac2, timingSafeEqual } from "crypto";
 import { appendFile as appendFile6 } from "fs/promises";
 import { createServer } from "http";
 var MAX_BODY_SIZE = 1024 * 1024;
@@ -3111,24 +4668,25 @@ var WebhookServer = class {
     this.sendJson(res, 404, { error: "Not found" });
   }
   async handleWebhook(req, res) {
+    const body = await this.readBody(req);
+    if (body === null) {
+      this.sendJson(res, 413, { error: "Payload too large (max 1MB)" });
+      return;
+    }
     if (this.secret) {
-      const provided = req.headers["x-neo-secret"];
-      if (!provided) {
-        this.sendJson(res, 401, { error: "Missing X-Neo-Secret header" });
+      const signature = req.headers["x-neo-signature"];
+      if (!signature) {
+        this.sendJson(res, 401, { error: "Missing X-Neo-Signature header" });
         return;
       }
-      const expected = Buffer.from(this.secret, "utf-8");
-      const actual = Buffer.from(provided, "utf-8");
-      if (expected.length !== actual.length || !timingSafeEqual(expected, actual)) {
-        this.sendJson(res, 403, { error: "Invalid secret" });
+      const expected = createHmac2("sha256", this.secret).update(body).digest("hex");
+      const expectedBuf = Buffer.from(expected, "utf-8");
+      const actualBuf = Buffer.from(signature, "utf-8");
+      if (expectedBuf.length !== actualBuf.length || !timingSafeEqual(expectedBuf, actualBuf)) {
+        this.sendJson(res, 403, { error: "Invalid signature" });
         return;
       }
     }
-    const body = await this.readBody(req);
-    if (body === null) {
-      this.sendJson(res, 413, { error: "Payload too large (max 1MB)" });
-      return;
-    }
     let parsed;
     try {
       parsed = JSON.parse(body);
@@ -3178,6 +4736,7 @@ var SupervisorDaemon = class {
   name;
   config;
   dir;
+  defaultInstructionsPath;
   webhookServer = null;
   eventQueue = null;
   heartbeatLoop = null;
@@ -3187,13 +4746,14 @@ var SupervisorDaemon = class {
     this.name = options.name;
     this.config = options.config;
     this.dir = getSupervisorDir(options.name);
+    this.defaultInstructionsPath = options.defaultInstructionsPath;
   }
   async start() {
-    await mkdir6(this.dir, { recursive: true });
-    const lockPath = path13.join(this.dir, "daemon.lock");
-    if (existsSync5(lockPath)) {
+    await mkdir7(this.dir, { recursive: true });
+    const lockPath = path15.join(this.dir, "daemon.lock");
+    if (existsSync8(lockPath)) {
       const lockPid = await this.readLockPid(lockPath);
-      if (lockPid && this.isProcessAlive(lockPid)) {
+      if (lockPid && isProcessAlive(lockPid)) {
         throw new Error(
           `Supervisor "${this.name}" already running (PID ${lockPid}). Use --kill first.`
         );
@@ -3202,35 +4762,44 @@ var SupervisorDaemon = class {
     }
     const tempLock = `${lockPath}.${process.pid}`;
     await writeFile6(tempLock, String(process.pid), "utf-8");
-    const { rename: rename3 } = await import("fs/promises");
-    await rename3(tempLock, lockPath);
+    const { rename: rename2 } = await import("fs/promises");
+    await rename2(tempLock, lockPath);
     const existingState = await this.readState();
     if (existingState?.sessionId && existingState.status !== "stopped") {
       this.sessionId = existingState.sessionId;
     } else {
-      this.sessionId = randomUUID4();
+      this.sessionId = randomUUID6();
     }
     this.activityLog = new ActivityLog(this.dir);
     this.eventQueue = new EventQueue({
       maxEventsPerSec: this.config.supervisor.maxEventsPerSec
     });
-    const inboxPath = path13.join(this.dir, "inbox.jsonl");
-    const eventsPath = path13.join(this.dir, "events.jsonl");
+    const inboxPath = path15.join(this.dir, "inbox.jsonl");
+    const eventsPath = path15.join(this.dir, "events.jsonl");
     await this.eventQueue.replayUnprocessed(inboxPath, eventsPath);
-    this.eventQueue.startWatching(inboxPath, eventsPath);
+    await this.eventQueue.startWatching(inboxPath, eventsPath);
     this.webhookServer = new WebhookServer({
       port: this.config.supervisor.port,
       secret: this.config.supervisor.secret,
       eventsPath,
       onEvent: (event) => {
         this.eventQueue?.push({ kind: "webhook", data: event });
+        if ((event.event === "session:complete" || event.event === "session:fail") && event.payload) {
+          const runId = typeof event.payload.runId === "string" ? event.payload.runId : void 0;
+          if (runId) {
+            this.eventQueue?.push({
+              kind: "run_complete",
+              runId,
+              timestamp: event.receivedAt
+            });
+          }
+        }
       },
       getHealth: () => this.getHealthInfo()
     });
     await this.webhookServer.start();
     await this.writeState({
       pid: process.pid,
-      tmuxSession: `neo-${this.name}`,
       sessionId: this.sessionId,
       port: this.config.supervisor.port,
       cwd: homedir3(),
@@ -3241,7 +4810,11 @@ var SupervisorDaemon = class {
       todayCostUsd: existingState?.todayCostUsd ?? 0,
       costResetDate: existingState?.costResetDate,
       idleSkipCount: existingState?.idleSkipCount ?? 0,
-      status: "running"
+      activeWorkSkipCount: existingState?.activeWorkSkipCount ?? 0,
+      status: "running",
+      lastConsolidationHeartbeat: existingState?.lastConsolidationHeartbeat ?? 0,
+      lastCompactionHeartbeat: existingState?.lastCompactionHeartbeat ?? 0,
+      lastConsolidationTimestamp: existingState?.lastConsolidationTimestamp
     });
     const shutdown = () => {
       this.stop().catch(console.error);
@@ -3252,14 +4825,15 @@ var SupervisorDaemon = class {
       "event",
       `Supervisor "${this.name}" started on port ${this.config.supervisor.port}`
     );
-    const statePath = path13.join(this.dir, "state.json");
+    const statePath = path15.join(this.dir, "state.json");
     this.heartbeatLoop = new HeartbeatLoop({
       config: this.config,
       supervisorDir: this.dir,
       statePath,
       sessionId: this.sessionId,
       eventQueue: this.eventQueue,
-      activityLog: this.activityLog
+      activityLog: this.activityLog,
+      defaultInstructionsPath: this.defaultInstructionsPath
     });
     await this.heartbeatLoop.start();
   }
@@ -3274,7 +4848,7 @@ var SupervisorDaemon = class {
       state.status = "stopped";
       await this.writeState(state);
     }
-    const lockPath = path13.join(this.dir, "daemon.lock");
+    const lockPath = path15.join(this.dir, "daemon.lock");
     await rm2(lockPath, { force: true });
     if (this.activityLog) {
       await this.activityLog.log("event", `Supervisor "${this.name}" stopped`);
@@ -3291,35 +4865,27 @@ var SupervisorDaemon = class {
     };
   }
   async readState() {
-    const statePath = path13.join(this.dir, "state.json");
+    const statePath = path15.join(this.dir, "state.json");
     try {
-      const raw = await readFile10(statePath, "utf-8");
+      const raw = await readFile12(statePath, "utf-8");
       return JSON.parse(raw);
     } catch {
       return null;
     }
   }
   async writeState(state) {
-    const statePath = path13.join(this.dir, "state.json");
+    const statePath = path15.join(this.dir, "state.json");
     await writeFile6(statePath, JSON.stringify(state, null, 2), "utf-8");
   }
   async readLockPid(lockPath) {
     try {
-      const raw = await readFile10(lockPath, "utf-8");
+      const raw = await readFile12(lockPath, "utf-8");
       const pid = Number.parseInt(raw.trim(), 10);
       return Number.isNaN(pid) ? null : pid;
     } catch {
       return null;
     }
   }
-  isProcessAlive(pid) {
-    try {
-      process.kill(pid, 0);
-      return true;
-    } catch {
-      return false;
-    }
-  }
 };
 
 // src/index.ts
@@ -3331,10 +4897,13 @@ export {
   EventJournal,
   EventQueue,
   HeartbeatLoop,
+  LocalEmbedder,
+  MemoryStore,
   NeoEventEmitter,
   Orchestrator,
   Semaphore,
   SessionError,
+  SessionExecutor,
   SupervisorDaemon,
   VERSION,
   WebhookDispatcher,
@@ -3347,18 +4916,18 @@ export {
   agentSandboxSchema,
   agentToolEntrySchema,
   agentToolSchema,
+  appendLogBuffer,
   auditLog,
   budgetGuard,
-  buildHeartbeatPrompt,
+  buildFullPrompt,
+  buildGitStrategyInstructions,
   buildMiddlewareChain,
+  buildReportingInstructions,
   buildSDKHooks,
   buildSandboxConfig,
-  checkMemorySize,
-  cleanupOrphanedWorktrees,
   createBranch,
-  createWorktree,
+  createSessionClone,
   deleteBranch,
-  extractMemoryFromResponse,
   fetchRemote,
   getBranchName,
   getCurrentBranch,
@@ -3373,17 +4942,17 @@ export {
   getSupervisorEventsPath,
   getSupervisorInboxPath,
   getSupervisorLockPath,
-  getSupervisorMemoryPath,
   getSupervisorStatePath,
   getSupervisorsDir,
   globalConfigSchema,
   inboxMessageSchema,
+  isProcessAlive,
   listReposFromGlobalConfig,
-  listWorktrees,
+  listSessionClones,
   loadAgentFile,
   loadConfig,
   loadGlobalConfig,
-  loadMemory,
+  loadRepoInstructions,
   loadWorkflow,
   loopDetection,
   matchesFilter,
@@ -3391,18 +4960,17 @@ export {
   neoConfigSchema,
   parseOutput,
   pushBranch,
+  pushSessionBranch,
   removeRepoFromGlobalConfig,
-  removeWorktree,
+  removeSessionClone,
   repoConfigSchema,
   resolveAgent,
   runSession,
   runWithRecovery,
-  saveMemory,
   supervisorDaemonStateSchema,
   supervisorDaemonStateSchema as supervisorStateSchema,
   toRepoSlug,
   webhookIncomingEventSchema,
-  withGitLock,
   workflowGateDefSchema,
   workflowStepDefSchema
 };