@neotx/core 0.1.0-alpha.19 → 0.1.0-alpha.20

package/dist/index.d.ts

@@ -149,6 +149,9 @@ declare const globalConfigSchema: z.ZodObject<{
         compactionIntervalMs: z.ZodDefault<z.ZodNumber>;
         eventTimeoutMs: z.ZodDefault<z.ZodNumber>;
         instructions: z.ZodOptional<z.ZodString>;
+        idleSkipMax: z.ZodDefault<z.ZodNumber>;
+        activeWorkSkipMax: z.ZodDefault<z.ZodNumber>;
+        autoDecide: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>>;
     memory: z.ZodDefault<z.ZodObject<{
         embeddings: z.ZodDefault<z.ZodBoolean>;
@@ -220,6 +223,9 @@ declare const neoConfigSchema: z.ZodObject<{
         compactionIntervalMs: z.ZodDefault<z.ZodNumber>;
         eventTimeoutMs: z.ZodDefault<z.ZodNumber>;
         instructions: z.ZodOptional<z.ZodString>;
+        idleSkipMax: z.ZodDefault<z.ZodNumber>;
+        activeWorkSkipMax: z.ZodDefault<z.ZodNumber>;
+        autoDecide: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>>;
     memory: z.ZodDefault<z.ZodObject<{
         embeddings: z.ZodDefault<z.ZodBoolean>;
@@ -1635,6 +1641,7 @@ declare class HeartbeatLoop {
     private checkBudgetExceeded;
     /**
      * Handle skip logic for idle and active-work scenarios.
+     * Uses IdleDetector to make skip decisions based on context.
      */
     private handleSkipLogic;
     /**

package/dist/index.js

@@ -518,7 +518,13 @@ var supervisorConfigSchema = z2.object({
   compactionIntervalMs: z2.number().default(36e5),
   /** Safety timeout for waitForWork (ms) */
   eventTimeoutMs: z2.number().default(3e5),
-  instructions: z2.string().optional()
+  instructions: z2.string().optional(),
+  /** Max consecutive idle loop iterations before supervisor pauses polling */
+  idleSkipMax: z2.number().default(20),
+  /** Max consecutive active-work loop iterations before supervisor yields */
+  activeWorkSkipMax: z2.number().default(3),
+  /** When true, supervisor answers pending decisions autonomously instead of waiting for human input */
+  autoDecide: z2.boolean().default(false)
 }).default({
   port: 7777,
   heartbeatTimeoutMs: 3e5,
@@ -527,7 +533,10 @@ var supervisorConfigSchema = z2.object({
   dailyCapUsd: 50,
   consolidationIntervalMs: 3e5,
   compactionIntervalMs: 36e5,
-  eventTimeoutMs: 3e5
+  eventTimeoutMs: 3e5,
+  idleSkipMax: 20,
+  activeWorkSkipMax: 3,
+  autoDecide: false
 });
 var globalConfigSchema = z2.object({
   repos: z2.array(repoConfigSchema).default([]),
@@ -598,7 +607,10 @@ var defaultConfig = {
     dailyCapUsd: 50,
     consolidationIntervalMs: 3e5,
     compactionIntervalMs: 36e5,
-    eventTimeoutMs: 3e5
+    eventTimeoutMs: 3e5,
+    idleSkipMax: 20,
+    activeWorkSkipMax: 3,
+    autoDecide: false
   },
   memory: { embeddings: true }
 };
@@ -3811,6 +3823,57 @@ import { readdir as readdir4, readFile as readFile11, writeFile as writeFile6 }
 import { homedir as homedir4 } from "os";
 import path14 from "path";
 
+// src/supervisor/idle-detector.ts
+import { z as z6 } from "zod";
+var idleDetectorConfigSchema = z6.object({
+  idleSkipMax: z6.number(),
+  activeWorkSkipMax: z6.number()
+});
+var idleContextSchema = z6.object({
+  eventCount: z6.number(),
+  activeRuns: z6.number(),
+  hasPendingConsolidation: z6.boolean(),
+  hasExpiredDecisions: z6.boolean(),
+  timeSinceLastHeartbeatMs: z6.number(),
+  idleSkipCount: z6.number(),
+  activeWorkSkipCount: z6.number()
+});
+var skipResultSchema = z6.object({
+  shouldSkip: z6.boolean(),
+  reason: z6.string()
+});
+var IdleDetector = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Evaluate whether the current heartbeat should be skipped.
+   * @returns SkipResult with shouldSkip flag and reason
+   */
+  shouldSkip(context) {
+    if (context.eventCount > 0) {
+      return { shouldSkip: false, reason: "events pending" };
+    }
+    if (context.hasPendingConsolidation) {
+      return { shouldSkip: false, reason: "pending consolidation" };
+    }
+    if (context.hasExpiredDecisions) {
+      return { shouldSkip: false, reason: "expired decisions" };
+    }
+    if (context.activeRuns > 0) {
+      if (context.activeWorkSkipCount >= this.config.activeWorkSkipMax) {
+        return { shouldSkip: false, reason: "active work skip threshold exceeded" };
+      }
+      return { shouldSkip: true, reason: "active runs, within threshold" };
+    }
+    if (context.idleSkipCount >= this.config.idleSkipMax) {
+      return { shouldSkip: false, reason: "idle skip threshold exceeded" };
+    }
+    return { shouldSkip: true, reason: "idle, within threshold" };
+  }
+};
+
 // src/supervisor/log-buffer.ts
 import { appendFile as appendFile6, readFile as readFile10, stat as stat2, writeFile as writeFile5 } from "fs/promises";
 import path13 from "path";
@@ -4140,7 +4203,7 @@ ${lines}
   }
   return "<focus>\n(empty \u2014 use neo memory write --type focus to set working context)\n</focus>";
 }
-function buildPendingDecisionsSection(decisions) {
+function buildPendingDecisionsSection(decisions, autoDecide = false) {
   if (!decisions || decisions.length === 0) {
     return "";
   }
@@ -4159,13 +4222,22 @@ function buildPendingDecisionsSection(decisions) {
       lines.push(`    Context: ${d.context}`);
     }
   }
-  return `Pending decisions (${decisions.length}):
-${lines.join("\n")}
+  const instruction = autoDecide ? `You are in **autoDecide** mode \u2014 answer each pending decision yourself based on available context, project knowledge, and best engineering judgment.
+
+\`\`\`bash
+neo decision answer <decision_id> <answer>
+\`\`\`
+
+For each decision: analyze the options, consider the project context and risk, then answer decisively. Prefer safe, incremental choices when uncertain. Log your reasoning before answering.
 
-To answer a decision, emit a \`decision:answer\` event:
+**Merge authority:** In autoDecide mode you MAY merge branches when the PR is ready (CI green, reviews approved). Use \`gh pr merge\` with the appropriate merge strategy.` : `To answer a decision, emit a \`decision:answer\` event:
 \`\`\`bash
 neo event emit decision:answer --data '{"id":"<decision_id>","answer":"<option_key>"}'
 \`\`\``;
+  return `Pending decisions (${decisions.length}):
+${lines.join("\n")}
+
+${instruction}`;
 }
 function buildAnsweredDecisionsSection(decisions) {
   if (!decisions || decisions.length === 0) {
@@ -4193,7 +4265,7 @@ ${opts.activeRuns.map((r) => `- ${r}`).join("\n")}`);
   if (recentActions) {
     parts.push(recentActions);
   }
-  const pendingDecisions = buildPendingDecisionsSection(opts.pendingDecisions);
+  const pendingDecisions = buildPendingDecisionsSection(opts.pendingDecisions, opts.autoDecide);
   if (pendingDecisions) {
     parts.push(pendingDecisions);
   }
@@ -4519,7 +4591,28 @@ Nothing to do. Run \`neo log discovery "idle"\` and yield. Do not produce any ot
   }
   const repoList = opts.repos.map((r) => `- ${r.path} (branch: ${r.defaultBranch})`).join("\n");
   if (hasPendingDecisions) {
-    const pendingSection = buildPendingDecisionsSection(opts.pendingDecisions);
+    const pendingSection = buildPendingDecisionsSection(opts.pendingDecisions, opts.autoDecide);
+    if (opts.autoDecide) {
+      return `${buildRoleSection(opts.heartbeatCount)}
+
+<context>
+No events. No active runs. No pending tasks.
+${budgetLine}
+
+${pendingSection}
+
+Repositories:
+${repoList}
+</context>
+
+<reference>
+${getCommandsSection(opts.heartbeatCount)}
+</reference>
+
+<directive>
+Idle \u2014 but there are pending decisions to resolve. You are in **autoDecide** mode: answer each pending decision now using your best engineering judgment, then yield. You MAY merge branches when PRs are ready (CI green, reviews approved).
+</directive>`;
+    }
     return `${buildRoleSection(opts.heartbeatCount)}
 
 <context>
@@ -4638,50 +4731,50 @@ neo memory forget <stale-id>
 }
 
 // src/supervisor/webhookEvents.ts
-import { z as z6 } from "zod";
-var supervisorStartedEventSchema = z6.object({
-  type: z6.literal("supervisor_started"),
-  supervisorId: z6.string(),
-  startedAt: z6.string().datetime()
+import { z as z7 } from "zod";
+var supervisorStartedEventSchema = z7.object({
+  type: z7.literal("supervisor_started"),
+  supervisorId: z7.string(),
+  startedAt: z7.string().datetime()
 });
-var heartbeatEventSchema = z6.object({
-  type: z6.literal("heartbeat"),
-  supervisorId: z6.string(),
-  heartbeatNumber: z6.number().int().min(0),
-  timestamp: z6.string().datetime(),
-  runsActive: z6.number().int().min(0),
-  budget: z6.object({
-    todayUsd: z6.number().min(0),
-    limitUsd: z6.number().min(0)
+var heartbeatEventSchema = z7.object({
+  type: z7.literal("heartbeat"),
+  supervisorId: z7.string(),
+  heartbeatNumber: z7.number().int().min(0),
+  timestamp: z7.string().datetime(),
+  runsActive: z7.number().int().min(0),
+  budget: z7.object({
+    todayUsd: z7.number().min(0),
+    limitUsd: z7.number().min(0)
   })
 });
-var runDispatchedEventSchema = z6.object({
-  type: z6.literal("run_dispatched"),
-  supervisorId: z6.string(),
-  runId: z6.string(),
-  agent: z6.string(),
-  repo: z6.string(),
-  branch: z6.string(),
-  prompt: z6.string().max(500)
+var runDispatchedEventSchema = z7.object({
+  type: z7.literal("run_dispatched"),
+  supervisorId: z7.string(),
+  runId: z7.string(),
+  agent: z7.string(),
+  repo: z7.string(),
+  branch: z7.string(),
+  prompt: z7.string().max(500)
   // truncated
 });
-var runCompletedEventSchema = z6.object({
-  type: z6.literal("run_completed"),
-  supervisorId: z6.string(),
-  runId: z6.string(),
-  status: z6.enum(["completed", "failed", "cancelled"]),
-  output: z6.string().max(1e3).optional(),
+var runCompletedEventSchema = z7.object({
+  type: z7.literal("run_completed"),
+  supervisorId: z7.string(),
+  runId: z7.string(),
+  status: z7.enum(["completed", "failed", "cancelled"]),
+  output: z7.string().max(1e3).optional(),
   // truncated
-  costUsd: z6.number().min(0),
-  durationMs: z6.number().int().min(0)
+  costUsd: z7.number().min(0),
+  durationMs: z7.number().int().min(0)
 });
-var supervisorStoppedEventSchema = z6.object({
-  type: z6.literal("supervisor_stopped"),
-  supervisorId: z6.string(),
-  stoppedAt: z6.string().datetime(),
-  reason: z6.enum(["shutdown", "budget_exceeded", "error", "manual"])
+var supervisorStoppedEventSchema = z7.object({
+  type: z7.literal("supervisor_stopped"),
+  supervisorId: z7.string(),
+  stoppedAt: z7.string().datetime(),
+  reason: z7.enum(["shutdown", "budget_exceeded", "error", "manual"])
 });
-var supervisorWebhookEventSchema = z6.discriminatedUnion("type", [
+var supervisorWebhookEventSchema = z7.discriminatedUnion("type", [
   supervisorStartedEventSchema,
   heartbeatEventSchema,
   runDispatchedEventSchema,
@@ -4690,8 +4783,6 @@ var supervisorWebhookEventSchema = z6.discriminatedUnion("type", [
 ]);
 
 // 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;
@@ -4856,13 +4947,18 @@ var HeartbeatLoop = class {
     const activeRuns = await this.getActiveRuns();
     const decisionStore = this.getDecisionStore();
     await this.processDecisionAnswers(rawEvents, decisionStore);
-    await decisionStore.expire();
-    const _pendingDecisions = await decisionStore.pending();
-    void _pendingDecisions;
+    const expiredDecisions = await decisionStore.expire();
+    const hasExpiredDecisions = expiredDecisions.length > 0;
+    const pendingDecisions = this.config.supervisor.autoDecide ? await decisionStore.pending() : [];
+    const answeredDecisions = this.config.supervisor.autoDecide ? await decisionStore.answered(state?.lastHeartbeat) : [];
+    const unconsolidatedEntries = await readUnconsolidated(this.supervisorDir);
+    const hasPendingConsolidation = unconsolidatedEntries.length > 0;
     const skipResult = await this.handleSkipLogic({
       state,
       totalEventCount,
-      activeRuns
+      activeRuns,
+      hasPendingConsolidation,
+      hasExpiredDecisions
     });
     if (skipResult.shouldSkip) return;
     if (skipResult.resetCounters) {
@@ -4877,6 +4973,8 @@ var HeartbeatLoop = class {
       isCompaction: modeResult.isCompaction,
       isConsolidation: modeResult.isConsolidation,
       activeRuns,
+      pendingDecisions,
+      answeredDecisions,
       lastHeartbeat: state?.lastHeartbeat,
       lastConsolidationTimestamp: modeResult.lastConsolidationTs
     });
@@ -4972,35 +5070,50 @@ var HeartbeatLoop = class {
   }
   /**
    * Handle skip logic for idle and active-work scenarios.
+   * Uses IdleDetector to make skip decisions based on context.
    */
   async handleSkipLogic(opts) {
-    const { state, totalEventCount, activeRuns } = opts;
+    const { state, totalEventCount, activeRuns, hasPendingConsolidation, hasExpiredDecisions } = opts;
     const idleSkipCount = state?.idleSkipCount ?? 0;
     const activeWorkSkipCount = state?.activeWorkSkipCount ?? 0;
     const hasActiveWork = activeRuns.length > 0;
-    if (totalEventCount === 0) {
+    const lastHeartbeatMs = state?.lastHeartbeat ? new Date(state.lastHeartbeat).getTime() : Date.now();
+    const timeSinceLastHeartbeatMs = Date.now() - lastHeartbeatMs;
+    const context = {
+      eventCount: totalEventCount,
+      activeRuns: activeRuns.length,
+      hasPendingConsolidation,
+      hasExpiredDecisions,
+      timeSinceLastHeartbeatMs,
+      idleSkipCount,
+      activeWorkSkipCount
+    };
+    const detector = new IdleDetector({
+      idleSkipMax: this.config.supervisor.idleSkipMax,
+      activeWorkSkipMax: this.config.supervisor.activeWorkSkipMax
+    });
+    const result = detector.shouldSkip(context);
+    if (result.shouldSkip) {
       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 };
-        }
+        await this.updateState({
+          activeWorkSkipCount: activeWorkSkipCount + 1,
+          idleSkipCount: 0
+        });
+        await this.activityLog.log(
+          "heartbeat",
+          `Active-work skip #${activeWorkSkipCount + 1}/${this.config.supervisor.activeWorkSkipMax} \u2014 ${result.reason}`
+        );
       } 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 };
-        }
+        await this.updateState({
+          idleSkipCount: idleSkipCount + 1,
+          activeWorkSkipCount: 0
+        });
+        await this.activityLog.log(
+          "heartbeat",
+          `Idle skip #${idleSkipCount + 1}/${this.config.supervisor.idleSkipMax} \u2014 ${result.reason}`
+        );
       }
+      return { shouldSkip: true, resetCounters: false };
     }
     const needsReset = idleSkipCount > 0 || activeWorkSkipCount > 0;
     return { shouldSkip: false, resetCounters: needsReset };
@@ -5075,7 +5188,10 @@ var HeartbeatLoop = class {
       customInstructions: this.customInstructions,
       supervisorDir: this.supervisorDir,
       memories,
-      recentActions
+      recentActions,
+      pendingDecisions: opts.pendingDecisions,
+      answeredDecisions: opts.answeredDecisions,
+      autoDecide: this.config.supervisor.autoDecide
     };
     if (opts.isCompaction) {
       return {
@@ -5899,16 +6015,16 @@ import path17 from "path";
 import { existsSync as existsSync10 } from "fs";
 import { mkdir as mkdir8, readFile as readFile15, writeFile as writeFile9 } from "fs/promises";
 import path18 from "path";
-import { z as z7 } from "zod";
-var webhookEntrySchema = z7.object({
-  url: z7.string().url(),
-  events: z7.array(z7.string()).optional(),
-  secret: z7.string().optional(),
-  timeoutMs: z7.number().default(5e3),
-  createdAt: z7.string().default(() => (/* @__PURE__ */ new Date()).toISOString())
+import { z as z8 } from "zod";
+var webhookEntrySchema = z8.object({
+  url: z8.string().url(),
+  events: z8.array(z8.string()).optional(),
+  secret: z8.string().optional(),
+  timeoutMs: z8.number().default(5e3),
+  createdAt: z8.string().default(() => (/* @__PURE__ */ new Date()).toISOString())
 });
-var webhooksConfigSchema = z7.object({
-  webhooks: z7.array(webhookEntrySchema).default([])
+var webhooksConfigSchema = z8.object({
+  webhooks: z8.array(webhookEntrySchema).default([])
 });
 function getWebhooksConfigPath() {
   return path18.join(getDataDir(), "webhooks.json");