@neotx/core 0.1.0-alpha.5 → 0.1.0-alpha.9

package/dist/index.d.ts

@@ -835,6 +835,8 @@ interface OrchestratorOptions {
     journalDir?: string | undefined;
     builtInWorkflowDir?: string | undefined;
     customWorkflowDir?: string | undefined;
+    /** Skip orphan recovery on start — workers should set this to true to avoid false orphan detection on concurrent launches. */
+    skipOrphanRecovery?: boolean | undefined;
 }
 declare class Orchestrator extends NeoEventEmitter {
     private readonly config;
@@ -858,6 +860,7 @@ declare class Orchestrator extends NeoEventEmitter {
     private _costToday;
     private _startedAt;
     private _drainResolve;
+    private readonly skipOrphanRecovery;
     constructor(config: NeoConfig, options?: OrchestratorOptions);
     registerWorkflow(definition: WorkflowDefinition): void;
     registerAgent(agent: ResolvedAgent): void;

package/dist/index.js

@@ -1207,7 +1207,10 @@ function isProcessAlive(pid) {
   try {
     process.kill(pid, 0);
     return true;
-  } catch {
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "EPERM") {
+      return true;
+    }
     return false;
   }
 }
@@ -1282,6 +1285,7 @@ var RunStore = class {
     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;
@@ -2367,6 +2371,7 @@ var Orchestrator = class extends NeoEventEmitter {
   _costToday = 0;
   _startedAt = 0;
   _drainResolve = null;
+  skipOrphanRecovery;
   constructor(config, options = {}) {
     super();
     this.config = config;
@@ -2374,6 +2379,7 @@ 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 = path11.resolve(repo.path);
       const normalizedRepo = { ...repo, path: resolvedPath };
@@ -2491,7 +2497,9 @@ var Orchestrator = class extends NeoEventEmitter {
         this.registerWorkflow(workflow);
       }
     }
-    await this.recoverOrphanedRuns();
+    if (!this.skipOrphanRecovery) {
+      await this.recoverOrphanedRuns();
+    }
     await mkdir6(this.config.sessions.dir, { recursive: true });
   }
   async shutdown() {
@@ -2602,6 +2610,7 @@ var Orchestrator = class extends NeoEventEmitter {
       workflow: input.workflow,
       repo: input.repo,
       prompt: input.prompt,
+      pid: process.pid,
       status: "running",
       steps: {},
       createdAt: activeSession.startedAt,
@@ -2789,6 +2798,7 @@ var Orchestrator = class extends NeoEventEmitter {
       workflow: input.workflow,
       repo: input.repo,
       prompt: input.prompt,
+      pid: process.pid,
       branch: taskResult.branch,
       status: taskResult.status === "success" ? "completed" : "failed",
       steps: taskResult.steps,
@@ -3567,7 +3577,16 @@ async function appendLogBuffer(dir, entry) {
 }
 
 // src/supervisor/prompt-builder.ts
-var ROLE = `You are the neo autonomous supervisor. You orchestrate developer agents across repositories. You make decisions autonomously, act on events, and yield quickly.`;
+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>']
@@ -3598,6 +3617,8 @@ neo agents                   # list available agents
 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
@@ -3607,107 +3628,109 @@ neo memory list --type fact
 \`\`\`bash
 neo log <type> "<message>"   # visible in TUI only
 \`\`\``;
+var COMMANDS_COMPACT = `### Commands (reference)
+\`neo run <agent> --prompt "..." --repo <path> --branch <name> [--meta '<json>']\`
+\`neo runs [--short | <runId>]\` \xB7 \`neo cost --short\` \xB7 \`neo agents\`
+\`neo memory write|update|forget|search|list\` \xB7 \`neo log <type> "<msg>"\`
+Always read output after architect/refiner: \`neo runs <runId>\`.`;
 var HEARTBEAT_RULES = `### Heartbeat lifecycle
-1. **Check work queue FIRST** \u2014 if you have pending tasks, work on the next one before looking for new work
-2. Process incoming events (messages, run completions)
-3. Follow up on pending work (CI checks, deferred dispatches) with \`neo runs\` or \`gh pr checks\`
-4. Make decisions and dispatch agents
-5. Update task status (\`neo memory update <id> --outcome in_progress|done|blocked\`) and log decisions
-6. Yield \u2014 each heartbeat should take seconds, not minutes
 
-**CRITICAL**: Your work queue IS your plan. Do not re-plan work that is already in the queue. When an planner agent produces tasks, create them with \`neo memory write --type task\`, then dispatch them one by one in subsequent heartbeats. Mark each task \`in_progress\` when dispatching, \`done\` when the run completes, \`blocked\` if stuck.
+<decision-tree>
+1. DEDUP FIRST \u2014 check focus for PROCESSED entries. Skip any runId already processed.
+2. PENDING TASKS? \u2014 dispatch the next eligible task from work queue. Do not re-plan.
+3. EVENTS? \u2014 process run completions, messages, webhooks. Parse agent JSON output.
+4. FOLLOW-UPS? \u2014 check CI (\`gh pr checks\`), deferred dispatches (\`neo runs\`).
+5. DISPATCH \u2014 route work to agents. Mark tasks \`in_progress\`, add ACTIVE to focus.
+6. YIELD \u2014 log your decisions and yield. Do not poll. Completions arrive at future heartbeats.
+</decision-tree>
 
-After dispatching with \`neo run\`, mark the task \`in_progress\`, note the runId in your focus, and yield. Do NOT poll in a loop.
-Completion events arrive at future heartbeats \u2014 react then.
-If you deferred work (e.g. "CI pending"), you MUST check it at the next heartbeat.`;
+<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>`;
 var REPORTING_RULES = `### Reporting
-\`neo log\` is your ONLY visible output \u2014 the TUI shows these and nothing else.
-- \`neo log decision "..."\` \u2014 why you chose this route
-- \`neo log action "..."\` \u2014 what you dispatched/did
-- \`neo log discovery "..."\` \u2014 ephemeral observations
-- 1-3 sentences per log. Pack maximum info: ticket, agent, branch, runId, cost, PR#. No markdown.
 
-Your text output is NEVER shown to users.`;
-var MEMORY_RULES = `### Memory \u2014 types and when to use each
+\`neo log\` is your ONLY visible output. Use telegraphic format.
 
-| Type | What | When | TTL |
-|------|------|------|-----|
-| \`fact\` | Stable truth that affects decisions | After discovering something that changes how you dispatch or review | Permanent (decays if unused) |
-| \`procedure\` | How-to recipe learned from failure | After the same issue occurs 3+ times | Permanent (decays if unused) |
-| \`focus\` | Structured working context | After every dispatch, deferral, or priority change | Expires (always set --expires) |
-| \`feedback\` | Recurring review pattern | After seeing the same reviewer complaint 3+ times | Permanent |
-| \`episode\` | Run outcome | Auto-created on run completion \u2014 do NOT write manually | Permanent |
-| \`task\` | Planned work item | After architect output or decomposition | Until done/abandoned |
+<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>
 
-#### What to store
-- Architectural truths that affect future dispatch decisions (CI config, build requirements, tooling)
-- Procedures learned from repeated failures (3+ occurrences of the same issue)
-- Active working context in structured focus format (see below)
+<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
 
-#### What NOT to store
-- File counts, line numbers, or structural details derivable from code (\`ls\` or \`cat package.json\` can answer it)
-- Completed work details \u2014 once a PR is merged, forget the related facts unless they are reusable
-- Agent output details already available via \`neo runs <id>\`
-- Facts about repos where no work is currently planned
+<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>
 
-#### Focus format (MANDATORY)
-Focus entries MUST use this structured format \u2014 no free-form paragraphs:
-\`\`\`
-ACTIVE: <runId> <agent> "<task>" branch:<name>
-PENDING: <taskId> "<description>" depends:<taskId>
-WAITING: <what> since:HB<N>
-PROCESSED: <runId> \u2192 <outcome> PR#<N>
-\`\`\`
+<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>
 
-\`\`\`bash
-# Focus: structured working context (always set --expires)
-neo memory write --type focus --expires 2h "ACTIVE: 5900a64a developer 'T1: schema+store' branch:feat/task-queue
-PENDING: T2 'CLI --outcome flag' depends:T1
-PENDING: T3+T4 'prompt injection' depends:T1"
+<task-workflow>
+Tasks are your work queue. The work queue section above shows them with markers (\`\u25CB\` pending, \`[ACTIVE]\` in_progress, \`[BLOCKED]\` blocked).
 
-# Facts: truths that change how you work (NOT trivia)
-neo memory write --type fact --scope /path/to/repo "CI requires pnpm build before push \u2014 no auto-rebuild in pipeline"
-neo memory write --type fact --scope /path/to/repo "Biome enforces complexity max 20 \u2014 extract helpers for large functions"
+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)
 
-# Procedures: recipes learned from failure (write after 3+ occurrences)
-neo memory write --type procedure --scope /path/to/repo "Before re-dispatching after orphan failure, check if PR already merged with gh pr view"
-neo memory write --type procedure --scope /path/to/repo "Integration tests require DATABASE_URL env var \u2014 agent must set it"
+**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)
 
-# Feedback: recurring reviewer complaints
-neo memory write --type feedback --scope /path/to/repo --category input_validation "Always validate user input at controller boundaries"
+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)
 
-# Tasks: work queue items from architect/refiner output
-neo memory write --type task --scope /path/to/repo --severity high --category "neo runs abc123" "T1: Implement auth middleware"
-neo memory write --type task --scope /path/to/repo --severity medium --tags "initiative:auth-v2,depends:mem_abc" --category "cat notes/plan-auth.md" "T2: Add JWT validation"
+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>
 
-# Update task status as you work
-neo memory update <id> --outcome in_progress
-neo memory update <id> --outcome done
-neo memory update <id> --outcome blocked
-neo memory update <id> --outcome abandoned
+<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>
 
-# Forget stale entries
+**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>
-
-# Search across all memories (semantic)
-neo memory search "database setup"
-\`\`\`
-
-#### Work queue workflow (Tasks)
-After architect/refiner output, create tasks with \`neo memory write --type task\`:
-- Include \`--category\` with the command to retrieve context (\`neo runs <id>\` or \`cat notes/<file>\`)
-- Use \`--tags depends:mem_<id>\` for task dependencies
-- Use \`--tags initiative:<name>\` to group tasks across repos
-- Update status with \`neo memory update <id> --outcome in_progress|done|blocked|abandoned\`
-- The queue is shown at every heartbeat \u2014 you will not lose track
-
-#### Pattern escalation
-When you encounter the same failure or issue 3+ times, ALWAYS write a \`procedure\` memory so you handle it automatically next time. Do not re-discover the same problem repeatedly.
-
-#### Event deduplication
-After processing a run completion, record the runId as PROCESSED in your focus. If the same runId appears in future events, skip it \u2014 do not re-analyze.
-
-**Notes** (\`notes/\`, via Bash): use for detailed multi-page plans, analysis, and checklists that span multiple heartbeats. After creating or reading a plan, write a focus summary: "Plan: <name> | Tasks: T1-T5 | Current: T1 | Next: T2 (depends T1) | Ref: cat notes/<file>". Delete notes when done.`;
+</memory-commands>`;
+function getCommandsSection(heartbeatCount) {
+  return heartbeatCount <= 3 ? COMMANDS : COMMANDS_COMPACT;
+}
 function buildContextSections(opts) {
   const parts = [];
   if (opts.repos.length > 0) {
@@ -3868,7 +3891,7 @@ function getBasename(scopePath) {
   const parts = scopePath.split("/");
   return parts[parts.length - 1] || scopePath;
 }
-var SIGNIFICANT_TYPES = /* @__PURE__ */ new Set(["decision", "action", "dispatch", "error", "plan"]);
+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 "";
@@ -3891,7 +3914,7 @@ function buildEventsSection(grouped) {
   const { messages, webhooks, runCompletions } = grouped;
   const totalEvents = messages.length + webhooks.length + runCompletions.length;
   if (totalEvents === 0) {
-    return "No new events. Idle heartbeat \u2014 check on active runs if any, or wait.";
+    return "No new events.";
   }
   const parts = [];
   for (const msg of messages) {
@@ -3922,15 +3945,33 @@ ${JSON.stringify(event.data.payload ?? {}, null, 2)}
       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>`);
-  sections.push(`<commands>
-${COMMANDS}
-</commands>`);
   const contextParts = [];
   const workQueue = buildWorkQueueSection(opts.memories);
   if (workQueue) {
@@ -3951,16 +3992,21 @@ ${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);
+  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(
-    "This is a standard heartbeat. Focus on processing events and dispatching work. If you have tasks in your work queue, dispatch the next eligible one."
+    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")}
@@ -3973,9 +4019,6 @@ function buildConsolidationPrompt(opts) {
 ${ROLE}
 Heartbeat #${opts.heartbeatCount} (CONSOLIDATION)
 </role>`);
-  sections.push(`<commands>
-${COMMANDS}
-</commands>`);
   const contextParts = [];
   const workQueueConsolidation = buildWorkQueueSection(opts.memories);
   if (workQueueConsolidation) {
@@ -3996,10 +4039,14 @@ ${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);
+  instructionParts.push(MEMORY_RULES_CORE);
+  instructionParts.push(MEMORY_RULES_EXAMPLES);
   if (opts.customInstructions) {
     instructionParts.push(`### Custom instructions
 ${opts.customInstructions}`);
@@ -4016,13 +4063,7 @@ If there IS active work, your job:
 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.
-
-\`\`\`bash
-neo memory write --type procedure --scope /repo "Before re-dispatching after orphan, check gh pr view first"
-neo memory write --type focus --expires 4h "ACTIVE: abc123 developer 'T3: prompt injection' branch:feat/task-queue
-PROCESSED: 5900a64a \u2192 PR#70 APPROVED"
-neo memory forget <stale-id>
-\`\`\``
+5. **Prune done tasks** \u2014 forget tasks with outcome \`done\` or \`abandoned\` older than 7 days.`
   );
   sections.push(`<instructions>
 ${instructionParts.join("\n\n")}
@@ -4035,9 +4076,6 @@ function buildCompactionPrompt(opts) {
 ${ROLE}
 Heartbeat #${opts.heartbeatCount} (COMPACTION)
 </role>`);
-  sections.push(`<commands>
-${COMMANDS}
-</commands>`);
   const contextParts = [];
   contextParts.push(...buildContextSections(opts));
   contextParts.push(buildMemorySection(opts.memories, opts.supervisorDir));
@@ -4048,10 +4086,14 @@ ${COMMANDS}
   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);
+  instructionParts.push(MEMORY_RULES_CORE);
+  instructionParts.push(MEMORY_RULES_EXAMPLES);
   if (opts.customInstructions) {
     instructionParts.push(`### Custom instructions
 ${opts.customInstructions}`);
@@ -4064,8 +4106,9 @@ This is a COMPACTION heartbeat. Deep-clean your ENTIRE memory.
 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. **Delete completed notes** from notes/ directory.
-7. **Stay under 15 facts per scope** \u2014 prioritize facts that affect dispatch decisions.
+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.
 
@@ -4376,6 +4419,12 @@ var HeartbeatLoop = class {
         modeLabel: "consolidation"
       };
     }
+    if (isIdleHeartbeat(sharedOpts)) {
+      return {
+        prompt: buildIdlePrompt(sharedOpts),
+        modeLabel: "idle"
+      };
+    }
     return {
       prompt: buildStandardPrompt(sharedOpts),
       modeLabel: "standard"
@@ -4403,7 +4452,6 @@ var HeartbeatLoop = class {
       }
       const queryOptions = {
         cwd: homedir2(),
-        maxTurns: 15,
         allowedTools,
         permissionMode: "bypassPermissions",
         allowDangerouslySkipPermissions: true,