@neotx/core 0.1.0-alpha.14 → 0.1.0-alpha.15

package/dist/index.js

@@ -2082,7 +2082,6 @@ var MemoryStore = class {
       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;
@@ -3025,12 +3024,12 @@ var Orchestrator = class extends NeoEventEmitter {
   // ─── Private: Supervisor discovery ─────────────────────
   /** Discover running supervisor daemons and return webhook configs for their endpoints. */
   async discoverSupervisorWebhooks() {
-    const { readdir: readdir6 } = await import("fs/promises");
+    const { readdir: readdir7 } = await import("fs/promises");
     const supervisorsDir = getSupervisorsDir();
     if (!existsSync6(supervisorsDir)) return [];
     const webhooks = [];
     try {
-      const entries = await readdir6(supervisorsDir, { withFileTypes: true });
+      const entries = await readdir7(supervisorsDir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         try {
@@ -3282,13 +3281,14 @@ var EventQueue = class {
   /**
    * Drain and group events: deduplicates messages by content,
    * keeps webhooks and run completions separate.
+   * Returns both grouped events AND original raw events for later marking as processed.
    */
   drainAndGroup() {
-    const events = this.drain();
+    const rawEvents = this.drain();
     const messageMap = /* @__PURE__ */ new Map();
     const webhooks = [];
     const runCompletions = [];
-    for (const event of events) {
+    for (const event of rawEvents) {
       if (event.kind === "message") {
         const key = event.data.text.trim().toLowerCase();
         const existing = messageMap.get(key);
@@ -3304,9 +3304,12 @@ var EventQueue = class {
       }
     }
     return {
-      messages: [...messageMap.values()],
-      webhooks,
-      runCompletions
+      grouped: {
+        messages: [...messageMap.values()],
+        webhooks,
+        runCompletions
+      },
+      rawEvents
     };
   }
   size() {
@@ -3320,8 +3323,7 @@ var EventQueue = class {
     for (const p of [inboxPath, eventsPath]) {
       try {
         await writeFile3(p, "", { flag: "a" });
-      } catch (err) {
-        console.error(`[EventQueue] Failed to ensure file exists: ${p}`, err);
+      } catch {
       }
     }
     this.watchJsonlFile(inboxPath, "message");
@@ -3371,13 +3373,11 @@ var EventQueue = class {
   watchJsonlFile(filePath, kind) {
     try {
       const watcher = watch(filePath, () => {
-        this.readNewLines(filePath, kind).catch((err) => {
-          console.error(`[EventQueue] Failed to read new lines from ${filePath}:`, err);
+        this.readNewLines(filePath, kind).catch(() => {
         });
       });
       this.watchers.push(watcher);
-    } catch (err) {
-      console.error(`[EventQueue] Cannot watch file (may not exist yet): ${filePath}`, err);
+    } catch {
     }
   }
   async readNewLines(filePath, kind) {
@@ -3464,8 +3464,7 @@ var EventQueue = class {
         await writeFile3(filePath, updated.join("\n"), "utf-8");
         this.fileOffsets.set(filePath, updated.join("\n").length);
       }
-    } catch (err) {
-      console.error(`[EventQueue] Failed to mark events as processed in ${filePath}:`, err);
+    } catch {
     }
   }
 };
@@ -3577,26 +3576,19 @@ async function appendLogBuffer(dir, entry) {
 }
 
 // src/supervisor/prompt-builder.ts
-var ROLE = `You are the neo autonomous supervisor \u2014 the engineering manager your agents deserve.
-
-You don't write code. You make sure the right work happens, at the right time, by the right agent \u2014 and you follow through until it's done.
+var ROLE = `You are the neo autonomous supervisor \u2014 accountable for delivery across parallel initiatives.
 
-<mindset>
-- You are accountable for delivery. A task in the queue that nobody is working on is YOUR problem.
-- Be the manager you'd want: give agents clear context, check their output, unblock them when they're stuck.
-- Think before dispatching. Read the task context, understand what's needed, craft a prompt that sets the agent up to succeed on the first try.
-- When a run completes, ALWAYS read its output. Verify the result meets the acceptance criteria. If it doesn't, figure out why and act \u2014 re-dispatch with better instructions, file a follow-up, or escalate.
-- When a run fails, diagnose before retrying. Read the output, check if the prompt was unclear, if the branch had conflicts, if the agent hit a known issue. Fix the root cause.
-- Never let work stall silently. If a run has been active too long, check on it. If a task is blocked, find what unblocks it. If nothing is happening, ask why.
-</mindset>
+You do not write code directly; you ensure the right work is assigned, executed, reviewed, and completed by the right agent.`;
+var OPERATING_PRINCIPLES = `### Operating principles
 
-<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.
-- You can read code in the available repos (path in \`neo repos\` command)
-</behavioral-contract>`;
+- Own delivery end-to-end: any queued task without an active owner is your responsibility.
+- Operate like a strong engineering lead: provide clear context, dispatch deliberately, validate outcomes, and remove blockers quickly.
+- On run completion: read \`neo runs <runId>\`, verify acceptance criteria, then decide next action (done, follow-up, redispatch, escalate).
+- On run failure: diagnose root cause before retrying (prompt quality, branch conflict, known issue, environment/tooling), then fix the cause.
+- Prevent silent stalls: monitor long-running jobs, detect blocked work early, and actively unblock.
+- Keep initiative boundaries strict: decisions for initiative A must not be influenced by unrelated state from B.
+- Your user-visible channel is \`neo log\` only; produce concise tool calls (not reasoning/explanations) and avoid wasted tokens.
+- You may inspect repositories available via \`neo repos\`, read-only to launch agents.`;
 var COMMANDS = `### Dispatching agents
 \`\`\`bash
 neo run <agent> --prompt "..." --repo <path> --branch <name> [--priority critical|high|medium|low] [--meta '<json>']
@@ -3607,7 +3599,7 @@ neo run <agent> --prompt "..." --repo <path> --branch <name> [--priority critica
 | \`--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\` |
+| \`--priority\` | optional | \`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.
@@ -3642,8 +3634,7 @@ 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.`;
+\`neo memory write|update|forget|search|list\` \xB7 \`neo log <type> "<msg>"\``;
 var HEARTBEAT_RULES = `### Heartbeat lifecycle
 
 <decision-tree>
@@ -3653,7 +3644,7 @@ var HEARTBEAT_RULES = `### Heartbeat lifecycle
 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.
+7. SERIALIZE & YIELD \u2014 rewrite focus (see <focus>), log your decisions, and yield. Do not poll.
 </decision-tree>
 
 <run-monitoring>
@@ -3664,43 +3655,15 @@ Runs are your agents in the field. You MUST actively track them:
 - **Active runs**: check \`neo runs --short --status running\` to verify your runs are still alive. If a run disappeared, investigate.
 </run-monitoring>
 
-<orchestration>
-When managing a multi-task initiative (architect decomposition, feature with milestones):
-
-**Branch strategy:**
-- Use ONE branch per initiative: \`feat/YC-2670-kanban-improvements\` \u2014 all tasks in the initiative push commits to this same branch
-- Each agent inherits the previous task's work without needing merges
-- The first task creates the branch. Subsequent tasks reuse it with the same \`--branch\` flag
-- Open the PR after the first task completes. Later tasks push additional commits to the same PR
-- Tasks within an initiative MUST be dispatched sequentially (not in parallel) since they share a branch
-- Independent initiatives CAN run in parallel on different branches
-
-**Before dispatching a task:**
-1. Run the task's \`--category\` command to retrieve context (architect plan, previous run output)
-2. Write a detailed \`--prompt\` with: task description, acceptance criteria, files to modify, and context from previous tasks in the initiative
-3. Include results from completed sibling tasks: what was built, which files were changed, which APIs were added
-4. Always pass the same \`--branch\` as previous tasks in the initiative
+<multi-task-initiatives>
+**Branch strategy:** one branch per initiative \u2014 all tasks push to the same branch sequentially (never in parallel). First task creates the branch; open PR after it completes. Later tasks add commits to the same PR. Independent initiatives CAN run in parallel on different branches.
 
-**After a run completes:**
-1. \`neo runs <runId>\` \u2014 read the FULL output, not just status
-2. Extract: PR URL/number, files changed, test results, any issues
-3. Verify the output matches the task's acceptance criteria
-4. If the agent opened a PR: dispatch \`reviewer\` in parallel with CI (do not wait for CI)
-5. Update the task outcome and log the result with concrete details (PR#, branch, what was done)
-6. Update the initiative note with the completed milestone
+**Dispatch quality:** write a detailed \`--prompt\` with acceptance criteria, files to modify, and context from completed sibling tasks (commits, APIs added, files changed). When dispatching task N, summarize what tasks 1..N-1 produced.
 
-**Cross-task context:**
-- Each task builds on previous ones. When dispatching T6, tell the agent what T1-T5 produced (commits, APIs added, files changed)
-- Store key outputs as facts if they affect future tasks: "T5 added dateRange param to fetchAllFstRecords"
-- Use notes for initiative-level plans: \`cat notes/plan-<initiative>.md\` \u2014 update as tasks complete
-</orchestration>
+**Post-completion:** if agent opened a PR, dispatch \`reviewer\` in parallel with CI (do not wait). Update task outcome with concrete details (PR#, what was done) and update the initiative note.
 
-<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.
-</rules>`;
+**Memory:** store key outputs as facts if they affect future tasks (e.g. "T5 added dateRange param to fetchAllFstRecords").
+</multi-task-initiatives>`;
 var REPORTING_RULES = `### Reporting
 
 \`neo log\` is your ONLY visible output. Use telegraphic format.
@@ -3711,19 +3674,14 @@ neo log action "<agent> <repo>:<branch> run:<runId> | <context>"
 neo log discovery "<what> in <where>"
 </log-format>
 
-<examples>
-<example type="good">
+<examples 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
+function buildMemoryRulesCore(supervisorDir) {
+  const notesDir = `${supervisorDir}/notes`;
+  return `### Memory
 
 <memory-types>
 | Type | Store when | TTL |
@@ -3736,7 +3694,7 @@ var MEMORY_RULES_CORE = `### Memory
 </memory-types>
 
 <memory-rules>
-- Focus MUST use structured format: ACTIVE/PENDING/WAITING/PROCESSED lines only.
+- Focus is free-form working memory \u2014 rewrite at end of EVERY heartbeat (see <focus>).
 - 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\`.
@@ -3744,53 +3702,36 @@ var MEMORY_RULES_CORE = `### Memory
 </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.
+Queue markers: \u25CB pending \xB7 [ACTIVE] in_progress \xB7 [BLOCKED] blocked.
+Create tasks for: incoming tickets, architect decompositions, sub-tickets, follow-ups, CI fixes.
+- \`--tags "initiative:<name>"\` \u2014 groups related tasks
+- \`--tags "depends:mem_<id>"\` \u2014 blocks until dependency is done
+- \`--category\` \u2014 retrieval command (MANDATORY). Examples: \`"neo runs <runId>"\` \xB7 \`"cat ${notesDir}/plan-feature.md"\` \xB7 \`"API-retrieve-a-page <notionPageId>"\`
+Lifecycle: create \u2192 in_progress (on dispatch) \u2192 done | blocked | abandoned
 </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>
+<focus>
+You are stateless between heartbeats. Focus is your scratchpad \u2014 the only thing future-you will read before acting.
 
-<notes>
-
-You have a notes/ directory for rich markdown documents that persist across heartbeats.
+Write it like a handoff note to yourself: what's happening, what you decided, what to do next, what to watch for. Free-form. No format imposed. The only rule: if you don't write it down, you lose it.
 
-When to use notes:
-- Architect decompositions: save the full plan with milestones, tasks, acceptance criteria, dependency graph
-- Initiative tracking: progress log with completed/pending tasks, PRs merged, blockers
-- Complex debugging: accumulate findings across multiple heartbeats
-- Review checklists: aggregate reviewer feedback across fix/review cycles
+Rewrite focus at the END of every heartbeat. Never leave it empty after a heartbeat with activity.
+</focus>
 
-How to use:
-- Write: \`cat > notes/plan-YC-2670-kanban.md << 'EOF' ... EOF\` \u2014 include milestones checklist, acceptance criteria, file paths
-- Read: \`cat notes/plan-YC-2670-kanban.md\` \u2014 retrieve full context at any heartbeat
-- Link to tasks: \`neo memory write --type task --category "cat notes/plan-YC-2670-kanban.md" "M3: UI"\`
-- Update: check off completed milestones, add PR numbers, note blockers after each task completes
-- Cleanup: \`rm notes/plan-*.md\` when the initiative is done
-
-Use notes for every initiative with 3+ tasks. They are your project management tool.
+<notes>
+Notes directory: \`${notesDir}/\`
+Use notes for any initiative with 3+ tasks (persists across heartbeats).
+- Write: \`cat > ${notesDir}/plan-<initiative>.md << 'EOF' ... EOF\`
+- Link to tasks: \`--category "cat ${notesDir}/plan-<initiative>.md"\`
+- Update after each task: check off milestones, add PR numbers, note blockers
+- Delete when initiative is done
+Use cases: architect decompositions, initiative tracking, debugging across heartbeats, review checklists.
 </notes>`;
-var MEMORY_RULES_EXAMPLES = `<memory-examples>
-neo memory write --type focus --expires 2h "ACTIVE: 5900a64a developer 'T1' branch:feat/x (cat notes/plan-YC-2670-kanban.md)"
+}
+function buildMemoryRulesExamples(supervisorDir) {
+  const notesDir = `${supervisorDir}/notes`;
+  return `<memory-examples>
+neo memory write --type focus --expires 2h "ACTIVE: 5900a64a developer 'T1' branch:feat/x (cat ${notesDir}/plan-YC-2670-kanban.md)"
 neo memory write --type fact --scope /repo "main branch uses protected merges \u2014 agents must create PRs, never push directly"
 neo memory write --type fact --scope /repo "pnpm build must pass before push \u2014 CI does not rebuild, run 2g589f34a5a failed without it"
 neo memory write --type procedure --scope /repo "After architect run: parse milestones from JSON output, create one task per milestone with --tags initiative:<name>"
@@ -3800,10 +3741,89 @@ neo memory write --type task --scope /repo --severity high --category "neo runs
 neo memory update <id> --outcome in_progress|done|blocked|abandoned
 neo memory forget <id>
 </memory-examples>`;
+}
+function buildRoleSection(heartbeatCount, label) {
+  const suffix = label ? ` (${label})` : "";
+  return `<role>
+${ROLE}
+Heartbeat #${heartbeatCount}${suffix}
+</role>`;
+}
 function getCommandsSection(heartbeatCount) {
   return heartbeatCount <= 3 ? COMMANDS : COMMANDS_COMPACT;
 }
-function buildContextSections(opts) {
+function buildReferenceSection(heartbeatCount) {
+  return `<reference>
+${getCommandsSection(heartbeatCount)}
+</reference>`;
+}
+function buildFocusSection(memories) {
+  const focusEntries = memories.filter((m) => m.type === "focus");
+  if (focusEntries.length > 0) {
+    const lines = focusEntries.map((m) => `- ${m.content}`).join("\n");
+    return `<focus>
+${lines}
+</focus>`;
+  }
+  return "<focus>\n(empty \u2014 use neo memory write --type focus to set working context)\n</focus>";
+}
+function buildFullContext(opts) {
+  const parts = [];
+  parts.push(buildFocusSection(opts.memories));
+  const workQueue = buildWorkQueueSection(opts.memories);
+  if (workQueue) {
+    parts.push(workQueue);
+  }
+  if (opts.activeRuns.length > 0) {
+    parts.push(`Active runs:
+${opts.activeRuns.map((r) => `- ${r}`).join("\n")}`);
+  }
+  const recentActions = buildRecentActionsSection(opts.recentActions);
+  if (recentActions) {
+    parts.push(recentActions);
+  }
+  parts.push(buildKnowledgeSection(opts.memories));
+  parts.push(...buildEnvironmentSections(opts));
+  parts.push(`Events:
+${buildEventsSection(opts.grouped)}`);
+  return `<context>
+${parts.join("\n\n")}
+</context>`;
+}
+function buildCompactionContext(opts) {
+  const parts = [];
+  parts.push(buildFocusSection(opts.memories));
+  parts.push(buildKnowledgeSection(opts.memories));
+  const workQueue = buildWorkQueueSection(opts.memories);
+  if (workQueue) {
+    parts.push(workQueue);
+  }
+  parts.push(...buildEnvironmentSections(opts));
+  return `<context>
+${parts.join("\n\n")}
+</context>`;
+}
+function buildBaseInstructions(opts, options) {
+  const parts = [];
+  parts.push(OPERATING_PRINCIPLES);
+  parts.push(HEARTBEAT_RULES);
+  parts.push(REPORTING_RULES);
+  parts.push(buildMemoryRulesCore(opts.supervisorDir));
+  if (options.includeExamples) {
+    parts.push(buildMemoryRulesExamples(opts.supervisorDir));
+  }
+  if (opts.customInstructions) {
+    parts.push(`### Custom instructions
+${opts.customInstructions}`);
+  }
+  return parts;
+}
+function wrapInstructions(parts) {
+  return `<instructions>
+${parts.join("\n\n")}
+</instructions>`;
+}
+function buildEnvironmentSections(opts) {
   const parts = [];
   if (opts.repos.length > 0) {
     const repoList = opts.repos.map((r) => `- ${r.path} (branch: ${r.defaultBranch})`).join("\n");
@@ -3820,22 +3840,11 @@ ${mcpList}`);
   );
   return parts;
 }
-function buildMemorySection(memories, supervisorDir) {
-  const focusEntries = memories.filter((m) => m.type === "focus");
+function buildKnowledgeSection(memories) {
   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>"
-    );
-  }
   if (factEntries.length > 0) {
     const byScope = /* @__PURE__ */ new Map();
     for (const m of factEntries) {
@@ -3871,12 +3880,6 @@ ${lines}`);
     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"]);
@@ -3925,18 +3928,72 @@ function groupTasksByInitiative(tasks) {
   }
   return groups;
 }
+var SEVERITY_ORDER = {
+  critical: 0,
+  high: 1,
+  medium: 2,
+  low: 3
+};
+function bySeverity(a, b) {
+  const aOrder = SEVERITY_ORDER[a.severity ?? "medium"] ?? 2;
+  const bOrder = SEVERITY_ORDER[b.severity ?? "medium"] ?? 2;
+  return aOrder - bOrder;
+}
+function partitionTasks(tasks) {
+  const active = [];
+  const blocked = [];
+  const pending = [];
+  for (const t of tasks) {
+    if (t.outcome === "in_progress") active.push(t);
+    else if (t.outcome === "blocked") blocked.push(t);
+    else pending.push(t);
+  }
+  return { active, blocked, pending };
+}
+function renderInitiativeSummary(group) {
+  const { active, pending } = partitionTasks(group.tasks);
+  const nextEligible = [...pending].sort(bySeverity)[0];
+  const cat = nextEligible?.category ? ` -> ${nextEligible.category}` : "";
+  const nextLabel = nextEligible ? ` (next: ${nextEligible.content.slice(0, 30)}${nextEligible.content.length > 30 ? "..." : ""} [${nextEligible.severity ?? "medium"}])` : "";
+  return `[${group.initiative}] ${active.length} active, ${pending.length} pending${nextLabel}${cat}`;
+}
+function renderCompactInitiative(group, lines, rendered) {
+  lines.push(`  ${renderInitiativeSummary(group)}`);
+  const { active, blocked, pending } = partitionTasks(group.tasks);
+  const nextEligible = [...pending].sort(bySeverity)[0];
+  for (const task of [...active, ...blocked]) {
+    if (rendered >= MAX_TASKS) break;
+    lines.push(`    ${formatTaskLine(task)}`);
+    rendered++;
+  }
+  if (nextEligible && active.length === 0 && blocked.length === 0 && rendered < MAX_TASKS) {
+    lines.push(`    ${formatTaskLine(nextEligible)}`);
+    rendered++;
+  }
+  return rendered;
+}
+function renderFlatGroup(group, showHeader, lines, rendered) {
+  if (showHeader && group.initiative) {
+    lines.push(`  [${group.initiative}]`);
+  }
+  for (const task of group.tasks) {
+    if (rendered >= MAX_TASKS) break;
+    lines.push(`  ${formatTaskLine(task)}`);
+    rendered++;
+  }
+  return rendered;
+}
 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++;
+    const useCompactMode = group.initiative && group.tasks.length >= 3;
+    if (useCompactMode) {
+      rendered = renderCompactInitiative(group, lines, rendered);
+    } else {
+      const showHeader = group.initiative !== null && groups.length > 1;
+      rendered = renderFlatGroup(group, showHeader, lines, rendered);
     }
   }
   return lines;
@@ -4017,17 +4074,15 @@ ${JSON.stringify(event.data.payload ?? {}, null, 2)}
       return `Internal event: ${event.eventKind}`;
   }
 }
+function countEvents(grouped) {
+  return grouped.messages.length + grouped.webhooks.length + grouped.runCompletions.length;
+}
 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;
+  return countEvents(opts.grouped) === 0 && opts.activeRuns.length === 0 && !hasWork;
 }
 function buildIdlePrompt(opts) {
-  return `<role>
-${ROLE}
-Heartbeat #${opts.heartbeatCount}
-</role>
+  return `${buildRoleSection(opts.heartbeatCount)}
 
 <context>
 No events. No active runs. No pending tasks.
@@ -4039,90 +4094,20 @@ Nothing to do. Run \`neo log discovery "idle"\` and yield. Do not produce any ot
 </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;
+  const instructionParts = buildBaseInstructions(opts, { includeExamples: false });
+  const hasEvents = countEvents(opts.grouped) > 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");
+  return [
+    buildRoleSection(opts.heartbeatCount),
+    buildFullContext(opts),
+    buildReferenceSection(opts.heartbeatCount),
+    wrapInstructions(instructionParts)
+  ].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}`);
-  }
+  const instructionParts = buildBaseInstructions(opts, { includeExamples: true });
   instructionParts.push(
     `### Consolidation
 This is a CONSOLIDATION heartbeat.
@@ -4137,39 +4122,16 @@ If there IS active work, your job:
 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");
+  return [
+    buildRoleSection(opts.heartbeatCount, "CONSOLIDATION"),
+    buildFullContext(opts),
+    buildReferenceSection(opts.heartbeatCount),
+    wrapInstructions(instructionParts)
+  ].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}`);
-  }
+  const notesDir = `${opts.supervisorDir}/notes`;
+  const instructionParts = buildBaseInstructions(opts, { includeExamples: true });
   instructionParts.push(`### Compaction
 This is a COMPACTION heartbeat. Deep-clean your ENTIRE memory.
 
@@ -4179,7 +4141,7 @@ This is a COMPACTION heartbeat. Deep-clean your ENTIRE memory.
 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.
+7. **Delete completed notes** from \`${notesDir}/\` 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.
@@ -4188,10 +4150,12 @@ Flag contradictions: if two facts contradict, keep the newer one.
 neo memory list --type fact
 neo memory forget <stale-id>
 \`\`\``);
-  sections.push(`<instructions>
-${instructionParts.join("\n\n")}
-</instructions>`);
-  return sections.join("\n\n");
+  return [
+    buildRoleSection(opts.heartbeatCount, "COMPACTION"),
+    buildCompactionContext(opts),
+    buildReferenceSection(opts.heartbeatCount),
+    wrapInstructions(instructionParts)
+  ].join("\n\n");
 }
 
 // src/supervisor/heartbeat.ts
@@ -4218,6 +4182,7 @@ var HeartbeatLoop = class {
   sessionId;
   eventQueue;
   activityLog;
+  _eventsPath;
   customInstructions;
   defaultInstructionsPath;
   memoryStore = null;
@@ -4229,9 +4194,14 @@ var HeartbeatLoop = class {
     this.sessionId = options.sessionId;
     this.eventQueue = options.eventQueue;
     this.activityLog = options.activityLog;
+    this._eventsPath = options.eventsPath;
     this.defaultInstructionsPath = options.defaultInstructionsPath;
     this.memoryDbPath = options.memoryDbPath;
   }
+  /** Path to the inbox/events directory for markProcessed() calls */
+  get eventsPath() {
+    return this._eventsPath;
+  }
   getMemoryStore() {
     if (!this.memoryStore && this.memoryDbPath) {
       try {
@@ -4283,7 +4253,7 @@ var HeartbeatLoop = class {
     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 { grouped, rawEvents } = this.eventQueue.drainAndGroup();
     const totalEventCount = grouped.messages.length + grouped.webhooks.length + grouped.runCompletions.length;
     const activeRuns = await this.getActiveRuns();
     const skipResult = await this.handleSkipLogic({
@@ -4320,6 +4290,10 @@ var HeartbeatLoop = class {
       }
     );
     const { costUsd, turnCount } = await this.callSdk(prompt, heartbeatId);
+    if (rawEvents.length > 0) {
+      const inboxPath = path14.join(this.supervisorDir, "inbox.jsonl");
+      await this.eventQueue.markProcessed(inboxPath, this.eventsPath, rawEvents);
+    }
     if (modeResult.isConsolidation) {
       const allIds = modeResult.unconsolidated.map((e) => e.id);
       if (allIds.length > 0) {
@@ -4894,6 +4868,7 @@ var SupervisorDaemon = class {
       sessionId: this.sessionId,
       eventQueue: this.eventQueue,
       activityLog: this.activityLog,
+      eventsPath,
       defaultInstructionsPath: this.defaultInstructionsPath
     });
     await this.heartbeatLoop.start();
@@ -4949,6 +4924,11 @@ var SupervisorDaemon = class {
   }
 };
 
+// src/supervisor/shutdown.ts
+import { existsSync as existsSync9 } from "fs";
+import { readdir as readdir6, readFile as readFile13, writeFile as writeFile7 } from "fs/promises";
+import path16 from "path";
+
 // src/index.ts
 var VERSION = "0.1.0";
 export {