@wrongstack/core 0.8.0 → 0.8.4

package/dist/index.js

@@ -3965,11 +3965,11 @@ function validateAgainstSchema(value, schema) {
   walk2(value, schema, "", errors);
   return { ok: errors.length === 0, errors };
 }
-function walk2(value, schema, path26, errors) {
+function walk2(value, schema, path27, errors) {
   if (schema.enum !== void 0) {
     if (!schema.enum.some((e) => deepEqual(e, value))) {
       errors.push({
-        path: path26 || "<root>",
+        path: path27 || "<root>",
         message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
       });
       return;
@@ -3978,7 +3978,7 @@ function walk2(value, schema, path26, errors) {
   if (typeof schema.type === "string") {
     if (!checkType(value, schema.type)) {
       errors.push({
-        path: path26 || "<root>",
+        path: path27 || "<root>",
         message: `expected ${schema.type}, got ${describeType(value)}`
       });
       return;
@@ -3988,19 +3988,19 @@ function walk2(value, schema, path26, errors) {
     const obj = value;
     for (const req of schema.required ?? []) {
       if (!(req in obj)) {
-        errors.push({ path: joinPath(path26, req), message: "required property missing" });
+        errors.push({ path: joinPath(path27, req), message: "required property missing" });
       }
     }
     if (schema.properties) {
       for (const [key, subSchema] of Object.entries(schema.properties)) {
         if (key in obj) {
-          walk2(obj[key], subSchema, joinPath(path26, key), errors);
+          walk2(obj[key], subSchema, joinPath(path27, key), errors);
         }
       }
     }
   }
   if (schema.type === "array" && Array.isArray(value) && schema.items) {
-    value.forEach((item, i) => walk2(item, schema.items, `${path26}[${i}]`, errors));
+    value.forEach((item, i) => walk2(item, schema.items, `${path27}[${i}]`, errors));
   }
 }
 function checkType(value, type) {
@@ -6182,10 +6182,36 @@ var DefaultPermissionPolicy = class {
     return void 0;
   }
 };
-var AutoApprovePermissionPolicy = class {
+var AutoApprovePermissionPolicy = class _AutoApprovePermissionPolicy {
+  /**
+   * Tools that are too dangerous to auto-approve even in a delegated
+   * subagent context. Subagents run non-interactively under a director
+   * and cannot answer prompts, but inherited authorization does not
+   * imply blanket permission for destructive or privilege-escalating
+   * operations. These tools remain at their declared `permission`
+   * level so the leader must explicitly allow them per-spawn.
+   */
+  static DENY = /* @__PURE__ */ new Set([
+    "bash",
+    // arbitrary shell — use exec for constrained shell
+    "write",
+    // arbitrary file write
+    "scaffold",
+    // arbitrary file generation outside project root
+    "patch",
+    // arbitrary diff application
+    "install",
+    // installs from arbitrary package sources
+    "exec"
+    // restricted shell but with arbitrary command args
+  ]);
   async evaluate(tool) {
-    if (tool.permission === "deny") {
-      return { permission: "deny", source: "default", reason: "tool default deny" };
+    if (tool.permission === "deny" || _AutoApprovePermissionPolicy.DENY.has(tool.name)) {
+      return {
+        permission: "deny",
+        source: "subagent_guard",
+        reason: _AutoApprovePermissionPolicy.DENY.has(tool.name) ? `tool ${tool.name} is not auto-approved for subagents \u2014 ask the leader to allow it explicitly` : "tool default deny"
+      };
     }
     return { permission: "auto", source: "yolo" };
   }
@@ -7262,6 +7288,7 @@ Summarize the following message range:`;
 };
 
 // src/execution/auto-compaction-middleware.ts
+var LEVEL_RANK2 = { warn: 0, soft: 1, hard: 2 };
 var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
   name = "AutoCompaction";
   compactor;
@@ -7276,12 +7303,28 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
   failureMode;
   policyProvider;
   /**
-   * Overhead factor applied to the rough message-token estimate to produce a
-   * figure comparable to the real API request size (system prompt + tool defs).
-   * Without this factor, raw message tokens undercount real load by 15-50% in
-   * short conversations, causing premature compaction triggers.
+   * Calibration factor applied to the estimator output. The estimator is now
+   * expected to already include messages + system prompt + tool definitions
+   * (see `estimateRequestTokens.total`), so no overhead boost is needed. Kept
+   * as a constant so a future calibration against real provider tokenization
+   * (BPE vs the chars/3.5 rough estimator) can dial this without touching the
+   * threshold-check math.
+   *
+   * Historical note: was 1.3 when the estimator only counted messages — that
+   * double-counted system+tools once the estimator was upgraded, firing
+   * compaction ~30% earlier than intended (e.g. real 56% load showed as 73%).
    */
-  static OVERHEAD_FACTOR = 1.3;
+  static OVERHEAD_FACTOR = 1;
+  /**
+   * Once a compaction attempt reduces nothing (preserveK protects everything,
+   * no oversized tool_results remain to elide), retrying on every iteration
+   * just spams `compaction.fired` events without making progress. We remember
+   * the no-op and skip until either the pressure level escalates or context
+   * has grown by at least this many tokens since the failed attempt.
+   */
+  static NOOP_RETRY_DELTA_TOKENS = 2e3;
+  /** Tracks the most recent no-op attempt so we can avoid re-firing per turn. */
+  lastNoopAttempt = null;
   /**
    * @param compactor        Compactor to use for compaction.
    * @param maxContext       Provider's max context window in tokens.
@@ -7323,19 +7366,44 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
         hard: this.hardThreshold
       };
       const aggressiveOn = policy?.aggressiveOn ?? this.aggressiveOn;
-      if (load >= thresholds.hard) {
-        await this.compact(ctx, true, { level: "hard", tokens, load });
-      } else if (load >= thresholds.soft) {
-        await this.compact(ctx, aggressiveOn !== "hard", { level: "soft", tokens, load });
-      } else if (load >= thresholds.warn) {
-        await this.compact(ctx, aggressiveOn === "warn", { level: "warn", tokens, load });
+      const level = load >= thresholds.hard ? "hard" : load >= thresholds.soft ? "soft" : load >= thresholds.warn ? "warn" : null;
+      if (!level) {
+        this.lastNoopAttempt = null;
+        return next(ctx);
+      }
+      if (this.shouldSkipNoopRetry(level, tokens)) {
+        return next(ctx);
       }
+      const aggressive = level === "hard" ? true : level === "soft" ? aggressiveOn !== "hard" : aggressiveOn === "warn";
+      await this.compact(ctx, aggressive, { level, tokens, load });
       return next(ctx);
     };
   }
+  /**
+   * Returns true when the previous compaction at the same or higher pressure
+   * level reduced nothing and context has not grown materially since. Prevents
+   * a stuck preserveK window from spamming compaction events every iteration.
+   */
+  shouldSkipNoopRetry(level, tokens) {
+    const stuck = this.lastNoopAttempt;
+    if (!stuck) return false;
+    if (LEVEL_RANK2[level] > LEVEL_RANK2[stuck.level]) return false;
+    const delta = tokens - stuck.tokens;
+    return delta < _AutoCompactionMiddleware.NOOP_RETRY_DELTA_TOKENS;
+  }
+  recordAttempt(level, tokens, report) {
+    const reduced = report.before > report.after;
+    const repaired = !!report.repaired;
+    if (reduced || repaired) {
+      this.lastNoopAttempt = null;
+    } else {
+      this.lastNoopAttempt = { level, tokens };
+    }
+  }
   async compact(ctx, aggressive, pressure) {
     try {
       const report = await this.compactor.compact(ctx, { aggressive });
+      this.recordAttempt(pressure.level, pressure.tokens, report);
       this.events?.emit("compaction.fired", {
         level: pressure.level,
         tokens: pressure.tokens,
@@ -8193,8 +8261,8 @@ ${recentJournal}` : "No prior iterations.",
       await saveGoal(this.goalPath, abandoned);
     }
     try {
-      const { unlink: unlink10 } = await import('fs/promises');
-      await unlink10(this.goalPath);
+      const { unlink: unlink11 } = await import('fs/promises');
+      await unlink11(this.goalPath);
     } catch {
     }
     this.opts.onEternalStop?.();
@@ -15446,10 +15514,10 @@ var AISpecBuilder = class {
   async saveSession() {
     if (!this.sessionPath) return;
     try {
-      const fsp16 = await import('fs/promises');
-      const path26 = await import('path');
+      const fsp17 = await import('fs/promises');
+      const path27 = await import('path');
       const { atomicWrite: atomicWrite2 } = await Promise.resolve().then(() => (init_atomic_write(), atomic_write_exports));
-      await fsp16.mkdir(path26.dirname(this.sessionPath), { recursive: true });
+      await fsp17.mkdir(path27.dirname(this.sessionPath), { recursive: true });
       await atomicWrite2(this.sessionPath, JSON.stringify(this.session, null, 2));
     } catch {
     }
@@ -15458,8 +15526,8 @@ var AISpecBuilder = class {
   async loadSession() {
     if (!this.sessionPath) return false;
     try {
-      const fsp16 = await import('fs/promises');
-      const raw = await fsp16.readFile(this.sessionPath, "utf8");
+      const fsp17 = await import('fs/promises');
+      const raw = await fsp17.readFile(this.sessionPath, "utf8");
       const loaded = JSON.parse(raw);
       if (loaded?.id && loaded?.phase && loaded?.title) {
         this.session = loaded;
@@ -15473,8 +15541,8 @@ var AISpecBuilder = class {
   async deleteSession() {
     if (!this.sessionPath) return;
     try {
-      const fsp16 = await import('fs/promises');
-      await fsp16.unlink(this.sessionPath);
+      const fsp17 = await import('fs/promises');
+      await fsp17.unlink(this.sessionPath);
     } catch {
     }
   }
@@ -16159,15 +16227,15 @@ function computeCriticalPath(graph, topoOrder, blockedByMap) {
       maxId = id;
     }
   }
-  const path26 = [];
+  const path27 = [];
   let current = maxId;
   const visited = /* @__PURE__ */ new Set();
   while (current && !visited.has(current)) {
     visited.add(current);
-    path26.unshift(current);
+    path27.unshift(current);
     current = prev.get(current) ?? null;
   }
-  return path26;
+  return path27;
 }
 function computeParallelGroups(graph, blockedByMap) {
   const groups = [];
@@ -17147,7 +17215,7 @@ async function startMetricsServer(opts) {
   const tls = opts.tls;
   const useHttps = !!(tls?.cert && tls?.key);
   const host = opts.host ?? "127.0.0.1";
-  const path26 = opts.path ?? "/metrics";
+  const path27 = opts.path ?? "/metrics";
   const healthPath = opts.healthPath ?? "/healthz";
   const healthRegistry = opts.healthRegistry;
   const listener = (req, res) => {
@@ -17157,7 +17225,7 @@ async function startMetricsServer(opts) {
       return;
     }
     const url = req.url.split("?")[0];
-    if (url === path26) {
+    if (url === path27) {
       let body;
       try {
         body = renderPrometheus(opts.sink.snapshot());
@@ -17221,7 +17289,7 @@ async function startMetricsServer(opts) {
   const protocol = useHttps ? "https" : "http";
   return {
     port: boundPort,
-    url: `${protocol}://${host}:${boundPort}${path26}`,
+    url: `${protocol}://${host}:${boundPort}${path27}`,
     close: () => new Promise((resolve6, reject) => {
       server.close((err) => err ? reject(err) : resolve6());
     })
@@ -19341,8 +19409,8 @@ var ReportGenerator = class {
     try {
       await stat(this.options.outputDir);
     } catch {
-      const { mkdir: mkdir11 } = await import('fs/promises');
-      await mkdir11(this.options.outputDir, { recursive: true });
+      const { mkdir: mkdir12 } = await import('fs/promises');
+      await mkdir12(this.options.outputDir, { recursive: true });
     }
   }
   generateMarkdown(result) {
@@ -20264,16 +20332,16 @@ Use \`/security report <number>\` to view a specific report.` };
     }
     const index = Number.parseInt(reportId, 10) - 1;
     if (!Number.isNaN(index) && reports[index]) {
-      const { readFile: readFile30 } = await import('fs/promises');
-      const content = await readFile30(join(reportsDir, reports[index]), "utf-8");
+      const { readFile: readFile31 } = await import('fs/promises');
+      const content = await readFile31(join(reportsDir, reports[index]), "utf-8");
       return { message: `# Security Report
 
 ${content}` };
     }
     const match = reports.find((r) => r.includes(reportId));
     if (match) {
-      const { readFile: readFile30 } = await import('fs/promises');
-      const content = await readFile30(join(reportsDir, match), "utf-8");
+      const { readFile: readFile31 } = await import('fs/promises');
+      const content = await readFile31(join(reportsDir, match), "utf-8");
       return { message: `# Security Report
 
 ${content}` };
@@ -23199,6 +23267,863 @@ function wrapApiForCapabilityCheck(plugin, api, log, enforce = false) {
   });
 }
 
-export { AGENTS_BY_PHASE, AGENT_CATALOG, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, Agent, AgentError, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, CONTEXT_WINDOW_MODES, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorStateCheckpoint, DoneConditionChecker, ERROR_CODES, EternalAutonomyEngine, EventBus, ExtensionRegistry, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, FsError, GitignoreUpdater, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, LAYER_1_IDENTITY, LLMSelector, MAX_JOURNAL_ENTRIES, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, ReportGenerator, RunController, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, ScopedEventBus, SddParallelRun, SddTaskDecomposer, SecurityScanner, SecurityScannerOrchestrator, SelectiveCompactor, SessionAnalyzer, SessionError, SkillGenerator, SkillInstaller, SkillManifestStore, SlashCommandRegistry, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, TechStackDetector, ToolError, ToolExecutor, ToolRegistry, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, appendJournal, applyRosterBudget, asBlocks, asText, atomicWrite, attachAutoExtend, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildBtwBlock, buildChildEnv, buildGoalPreamble, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildRecoveryStrategies, classifyFamily, clearPlan, color, compileGlob, compileUserRegex, composeDirectorPrompt, composeSubagentPrompt, computeTaskProgress, consumeBtwNotes, context7Server, contextManagerTool, createAutoExecutor, createContextManagerTool, createDefaultPipelines, createDelegateTool, createMcpControlTool, createMessage, createSecuritySlashCommand, createToolOutputSerializer, decryptConfigSecrets, defaultGitignoreUpdater, defaultOrchestrator, defaultReportGenerator, defaultSecurityScanner, defaultSkillGenerator, defaultTechStackDetector, deriveTodosFromPlanItem, detectNewlineStyle, dispatchAgent, downloadGitHubTarball, emptyGoal, emptyPlan, encryptConfigSecrets, ensureDir, estimateRequestTokens, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, extractRunEnv, filesystemServer, findCriticalPath, formatContextWindowModeList, formatGoal, formatPlan, formatPlanTemplates, formatTodosList, getAgentDefinition, getContextWindowMode, getPlanTemplate, getTemplate, githubServer, goalFilePath, googleMapsServer, isAgentError, isConfigError, isContextWindowModeId, isFsError, isImageBlock, isPluginError, isSessionError, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isWrongStackError, listContextWindowModes, listPlanTemplates, listTemplates, loadDirectorState, loadGoal, loadPlan, loadPlugins, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeAutonomyPromptContributor, makeContinueToNextIterationTool, makeDirectorSessionFactory, makeLLMClassifier, matchAny, matchGlob, migratePlaintextSecrets, miniMaxVisionServer, normalizeToLf, parseContinueDirective, parseSkillRef, pendingBtwCount, projectHash, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, resolveContextWindowPolicy, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, safeParse, safeStringify, sanitizeJsonString, saveGoal, savePlan, saveTodosCheckpoint, scoreAgents, securitySlashCommand, sentinelServer, setBtwNote, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, stripAnsi, summarizeUsage, templateToMarkdown, toStyle, toWrongStackError, topologicalSort, unifiedDiff, unloadPlugins, validateAgainstSchema, wireMetricsToEvents, wrapAsState, zaiVisionServer };
+// src/autophase/phase-graph-builder.ts
+var PhaseGraphBuilder = class _PhaseGraphBuilder {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  async build() {
+    const graphId = crypto.randomUUID();
+    const phases = /* @__PURE__ */ new Map();
+    const phaseIds = [];
+    for (let i = 0; i < this.opts.phases.length; i++) {
+      const tmpl = this.opts.phases[i];
+      const phaseId = crypto.randomUUID();
+      phaseIds.push(phaseId);
+      const store = new DefaultTaskStore();
+      const tracker = new TaskTracker({ store });
+      const taskGraph = await tracker.createGraph(phaseId, `${tmpl.name} Tasks`);
+      if (tmpl.taskTemplates && tmpl.taskTemplates.length > 0) {
+        for (const tt of tmpl.taskTemplates) {
+          tracker.addNode({
+            title: tt.title,
+            description: tt.description,
+            type: tt.type,
+            priority: tt.priority,
+            status: "pending",
+            estimateHours: tt.estimateHours,
+            tags: tt.tags ?? []
+          });
+        }
+      }
+      const phase = {
+        id: phaseId,
+        name: tmpl.name,
+        description: tmpl.description,
+        status: "pending",
+        taskGraph,
+        dependsOn: i > 0 ? [phaseIds[i - 1]] : [],
+        nextPhases: i < this.opts.phases.length - 1 ? [phaseIds[i + 1]] : [],
+        parallelizable: tmpl.parallelizable,
+        priority: tmpl.priority,
+        estimateHours: tmpl.estimateHours,
+        assignedAgents: [],
+        createdAt: Date.now(),
+        updatedAt: Date.now()
+      };
+      phases.set(phaseId, phase);
+    }
+    const phaseArray = Array.from(phases.values());
+    for (let i = 0; i < phaseArray.length; i++) {
+      const phase = phaseArray[i];
+      phase.nextPhases = i < phaseArray.length - 1 ? [phaseArray[i + 1].id] : [];
+      phase.dependsOn = i > 0 ? [phaseArray[i - 1].id] : [];
+    }
+    const graph = {
+      id: graphId,
+      title: this.opts.title,
+      description: this.opts.description ?? "",
+      phases,
+      rootPhaseIds: phaseIds.length > 0 ? [phaseIds[0]] : [],
+      activePhaseIds: [],
+      completedPhaseIds: [],
+      failedPhaseIds: [],
+      autonomous: this.opts.autonomous ?? true,
+      stopOnComplete: true,
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    };
+    return graph;
+  }
+  /**
+   * Var olan bir TaskGraph'tan fazlar oluştur.
+   * Task'ları priority/type göre gruplayarak fazlara ayırır.
+   */
+  static fromTaskGraph(taskGraph, options) {
+    const tasksPerPhase = options.tasksPerPhase ?? 5;
+    const nodes = Array.from(taskGraph.nodes.values());
+    const sorted = [...nodes].sort((a, b) => {
+      const prioOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+      return (prioOrder[a.priority] ?? 4) - (prioOrder[b.priority] ?? 4);
+    });
+    const groups = [];
+    for (let i = 0; i < sorted.length; i += tasksPerPhase) {
+      groups.push(sorted.slice(i, i + tasksPerPhase));
+    }
+    const phaseTemplates = groups.map((group, idx) => {
+      const hasCritical = group.some((t2) => t2.priority === "critical");
+      const totalHours = group.reduce((sum, t2) => sum + (t2.estimateHours ?? 2), 0);
+      return {
+        name: `Phase ${idx + 1}: ${group[0]?.title.slice(0, 30) ?? "Tasks"}`,
+        description: group.map((t2) => t2.title).join(", "),
+        priority: hasCritical ? "critical" : "high",
+        estimateHours: totalHours,
+        parallelizable: false,
+        taskTemplates: group.map((t2) => ({
+          title: t2.title,
+          description: t2.description,
+          type: t2.type,
+          priority: t2.priority,
+          estimateHours: t2.estimateHours ?? 2,
+          tags: t2.tags ?? []
+        }))
+      };
+    });
+    const builder = new _PhaseGraphBuilder({
+      ...options,
+      phases: phaseTemplates
+    });
+    return builder.build();
+  }
+};
+
+// src/autophase/phase-orchestrator.ts
+var PhaseOrchestrator = class {
+  graph;
+  ctx;
+  opts;
+  events;
+  stopped = false;
+  paused = false;
+  runningPhases = /* @__PURE__ */ new Set();
+  tickInterval = null;
+  constructor(opts) {
+    this.graph = opts.graph;
+    this.ctx = opts.ctx;
+    this.events = opts.events ?? this.createNoopEventBus();
+    this.opts = {
+      maxConcurrentPhases: opts.maxConcurrentPhases ?? 1,
+      maxConcurrentTasks: opts.maxConcurrentTasks ?? 2,
+      maxRetries: opts.maxRetries ?? 2,
+      autonomous: opts.autonomous ?? true,
+      phaseDelayMs: opts.phaseDelayMs ?? 0,
+      stopOnFailure: opts.stopOnFailure ?? true,
+      events: this.events
+    };
+  }
+  // ─── Lifecycle ────────────────────────────────────────────────────────────
+  /**
+   * Tüm faz akışını başlat.
+   * Autonomous mode'da: kök faz(lar)ı başlatır, bitince sonrakini otomatik başlatır.
+   */
+  async start() {
+    this.stopped = false;
+    this.paused = false;
+    this.graph.startedAt = Date.now();
+    this.graph.updatedAt = Date.now();
+    let readyPhases = this.getReadyPhases();
+    while (readyPhases.length > 0 && !this.stopped) {
+      const batch = readyPhases.slice(0, this.opts.maxConcurrentPhases);
+      await Promise.all(batch.map((p) => this.startPhase(p)));
+      readyPhases = this.getReadyPhases().filter(
+        (p) => !this.runningPhases.has(p.id) && p.status !== "completed" && p.status !== "failed"
+      );
+    }
+    if (this.opts.autonomous) {
+      this.tickInterval = setInterval(() => this.tick(), 1e3);
+    }
+  }
+  /** Duraklat — aktif fazlar çalışmaya devam eder ama yeni faz başlamaz */
+  pause() {
+    this.paused = true;
+  }
+  /** Devam et — yeni fazlar başlayabilir */
+  resume() {
+    this.paused = false;
+    void this.tick();
+  }
+  /** Tamamen durdur — aktif fazlar da durdurulur */
+  stop() {
+    this.stopped = true;
+    if (this.tickInterval) {
+      clearInterval(this.tickInterval);
+      this.tickInterval = null;
+    }
+    for (const phaseId of this.runningPhases) {
+      const phase = this.graph.phases.get(phaseId);
+      if (phase) {
+        this.updatePhaseStatus(phase, "paused");
+      }
+    }
+  }
+  // ─── Tick Loop (Autonomous) ───────────────────────────────────────────────
+  async tick() {
+    if (this.stopped || this.paused) return;
+    const active = this.getActivePhases();
+    const ready = this.getReadyPhases();
+    this.emit("autonomous.tick", {
+      activePhases: active.map((p) => p.id),
+      queuedPhases: ready.map((p) => p.id)
+    });
+    this.ctx.onTick?.({ activePhases: active, readyPhases: ready });
+    const availableSlots = this.opts.maxConcurrentPhases - active.length;
+    if (availableSlots > 0 && ready.length > 0) {
+      for (const phase of ready.slice(0, availableSlots)) {
+        await this.startPhase(phase);
+      }
+    }
+    if (this.isComplete()) {
+      this.onGraphComplete();
+      return;
+    }
+    if (this.opts.stopOnFailure && this.graph.failedPhaseIds.length > 0) {
+      const failedPhase = this.graph.phases.get(this.graph.failedPhaseIds[0]);
+      if (failedPhase) {
+        this.onGraphFailed(failedPhase);
+      }
+      return;
+    }
+  }
+  // ─── Phase Execution ──────────────────────────────────────────────────────
+  async startPhase(phase) {
+    if (phase.status !== "pending" && phase.status !== "ready") return;
+    this.updatePhaseStatus(phase, "running");
+    phase.startedAt = Date.now();
+    this.runningPhases.add(phase.id);
+    this.graph.activePhaseIds.push(phase.id);
+    this.emit("phase.started", { phaseId: phase.id, name: phase.name });
+    try {
+      await this.executePhaseTasks(phase);
+      const failedTasks = this.getFailedTaskCount(phase);
+      const completedTasks = this.getCompletedTaskCount(phase);
+      this.emit("phase.allTasksDone", {
+        phaseId: phase.id,
+        completed: completedTasks,
+        failed: failedTasks
+      });
+      if (failedTasks > 0 && this.opts.stopOnFailure) {
+        this.updatePhaseStatus(phase, "failed");
+        phase.completedAt = Date.now();
+        phase.actualDurationMs = Date.now() - (phase.startedAt ?? Date.now());
+        this.runningPhases.delete(phase.id);
+        this.emit("phase.failed", {
+          phaseId: phase.id,
+          name: phase.name,
+          error: `${failedTasks} task(s) failed`
+        });
+        this.ctx.onPhaseFail?.(phase, new Error(`${failedTasks} task(s) failed`));
+      } else {
+        this.updatePhaseStatus(phase, "completed");
+        phase.completedAt = Date.now();
+        phase.actualDurationMs = Date.now() - (phase.startedAt ?? Date.now());
+        this.runningPhases.delete(phase.id);
+        this.graph.completedPhaseIds.push(phase.id);
+        this.emit("phase.completed", {
+          phaseId: phase.id,
+          name: phase.name,
+          durationMs: phase.actualDurationMs
+        });
+        this.ctx.onPhaseComplete?.(phase);
+      }
+    } catch (error) {
+      this.updatePhaseStatus(phase, "failed");
+      phase.completedAt = Date.now();
+      phase.actualDurationMs = Date.now() - (phase.startedAt ?? Date.now());
+      this.runningPhases.delete(phase.id);
+      this.graph.failedPhaseIds.push(phase.id);
+      this.emit("phase.failed", {
+        phaseId: phase.id,
+        name: phase.name,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      this.ctx.onPhaseFail?.(phase, error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  async executePhaseTasks(phase) {
+    phase.taskGraph;
+    const pendingTasks = this.getExecutableTasks(phase);
+    while (pendingTasks.length > 0 && !this.stopped) {
+      const batch = pendingTasks.splice(0, this.opts.maxConcurrentTasks);
+      const results = await Promise.allSettled(
+        batch.map((task) => this.executeSingleTask(task, phase))
+      );
+      for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        const task = batch[i];
+        if (!result || !task) continue;
+        if (result.status === "fulfilled") {
+          this.markTaskCompleted(phase, task);
+        } else {
+          this.markTaskFailed(phase, task, result.reason);
+        }
+      }
+      const newReady = this.getExecutableTasks(phase);
+      pendingTasks.length = 0;
+      pendingTasks.push(...newReady);
+    }
+  }
+  async executeSingleTask(task, phase) {
+    const tracker = this.getTrackerForPhase(phase);
+    tracker.updateNodeStatus(task.id, "in_progress");
+    return this.ctx.executeTask(task, phase.id);
+  }
+  markTaskCompleted(phase, task) {
+    const tracker = this.getTrackerForPhase(phase);
+    tracker.updateNodeStatus(task.id, "completed");
+    this.emit("phase.taskCompleted", {
+      phaseId: phase.id,
+      taskId: task.id,
+      taskTitle: task.title
+    });
+  }
+  markTaskFailed(phase, task, error) {
+    const tracker = this.getTrackerForPhase(phase);
+    tracker.updateNodeStatus(task.id, "failed", error instanceof Error ? error.message : String(error));
+    this.emit("phase.taskFailed", {
+      phaseId: phase.id,
+      taskId: task.id,
+      taskTitle: task.title,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+  // ─── Helpers ──────────────────────────────────────────────────────────────
+  getReadyPhases() {
+    const ready = [];
+    for (const phase of this.graph.phases.values()) {
+      if (phase.status !== "pending") continue;
+      const depsDone = phase.dependsOn.every((depId) => {
+        const dep = this.graph.phases.get(depId);
+        return dep?.status === "completed" || dep?.status === "skipped";
+      });
+      if (depsDone) {
+        ready.push(phase);
+      }
+    }
+    const prioOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+    ready.sort((a, b) => (prioOrder[a.priority] ?? 4) - (prioOrder[b.priority] ?? 4));
+    return ready;
+  }
+  getActivePhases() {
+    return Array.from(this.graph.phases.values()).filter((p) => p.status === "running");
+  }
+  getExecutableTasks(phase) {
+    const tracker = this.getTrackerForPhase(phase);
+    return tracker.getAllNodes({ status: ["pending", "blocked"] }).filter((n) => n.status === "pending" && tracker.canStart(n.id)).sort((a, b) => {
+      const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+      return (priorityOrder[a.priority] ?? 4) - (priorityOrder[b.priority] ?? 4);
+    });
+  }
+  getTrackerForPhase(phase) {
+    const store = new DefaultTaskStore();
+    const tracker = new TaskTracker({ store });
+    tracker.graph = phase.taskGraph;
+    return tracker;
+  }
+  getFailedTaskCount(phase) {
+    const tracker = this.getTrackerForPhase(phase);
+    return tracker.getAllNodes({ status: ["failed"] }).length;
+  }
+  getCompletedTaskCount(phase) {
+    const tracker = this.getTrackerForPhase(phase);
+    return tracker.getAllNodes({ status: ["completed"] }).length;
+  }
+  updatePhaseStatus(phase, status) {
+    const from = phase.status;
+    phase.status = status;
+    phase.updatedAt = Date.now();
+    this.graph.updatedAt = Date.now();
+    this.emit("phase.statusChange", { phaseId: phase.id, from, to: status });
+  }
+  isComplete() {
+    const allPhases = Array.from(this.graph.phases.values());
+    return allPhases.every(
+      (p) => p.status === "completed" || p.status === "skipped" || p.status === "failed"
+    );
+  }
+  onGraphComplete() {
+    this.graph.completedAt = Date.now();
+    const durationMs = this.graph.completedAt - (this.graph.startedAt ?? this.graph.completedAt);
+    this.emit("graph.completed", { graphId: this.graph.id, durationMs });
+    this.stop();
+  }
+  onGraphFailed(failedPhase) {
+    this.emit("graph.failed", {
+      graphId: this.graph.id,
+      failedPhaseId: failedPhase.id,
+      error: `Phase "${failedPhase.name}" failed`
+    });
+    this.stop();
+  }
+  // ─── Progress ─────────────────────────────────────────────────────────────
+  getProgress() {
+    const phases = Array.from(this.graph.phases.values());
+    let pending = 0, ready = 0, running = 0, paused = 0, completed = 0, failed = 0, skipped = 0;
+    let totalTasks = 0, completedTasks = 0, failedTasks = 0, estimatedHours = 0, actualHours = 0;
+    for (const p of phases) {
+      switch (p.status) {
+        case "pending":
+          pending++;
+          break;
+        case "ready":
+          ready++;
+          break;
+        case "running":
+          running++;
+          break;
+        case "paused":
+          paused++;
+          break;
+        case "completed":
+          completed++;
+          break;
+        case "failed":
+          failed++;
+          break;
+        case "skipped":
+          skipped++;
+          break;
+      }
+      estimatedHours += p.estimateHours;
+      if (p.actualDurationMs) actualHours += p.actualDurationMs / 36e5;
+      const tracker = this.getTrackerForPhase(p);
+      const progress = tracker.getProgress();
+      totalTasks += progress.total;
+      completedTasks += progress.completed;
+      failedTasks += progress.failed;
+    }
+    const totalPhases = phases.length;
+    const done = completed + skipped;
+    return {
+      totalPhases,
+      pending,
+      ready,
+      running,
+      paused,
+      completed,
+      failed,
+      skipped,
+      percentComplete: totalPhases > 0 ? Math.round(done / totalPhases * 100) : 0,
+      totalTasks,
+      completedTasks,
+      failedTasks,
+      estimatedHours,
+      actualHours
+    };
+  }
+  getGraph() {
+    return this.graph;
+  }
+  isRunning() {
+    return !this.stopped && this.runningPhases.size > 0;
+  }
+  isPaused() {
+    return this.paused;
+  }
+  // ─── Agent Assignment ─────────────────────────────────────────────────────
+  assignAgent(phaseId, agentId) {
+    const phase = this.graph.phases.get(phaseId);
+    if (!phase) return;
+    if (!phase.assignedAgents.includes(agentId)) {
+      phase.assignedAgents.push(agentId);
+      this.emit("agent.assigned", { phaseId, agentId });
+    }
+  }
+  releaseAgent(phaseId, agentId) {
+    const phase = this.graph.phases.get(phaseId);
+    if (!phase) return;
+    phase.assignedAgents = phase.assignedAgents.filter((id) => id !== agentId);
+    this.emit("agent.released", { phaseId, agentId });
+  }
+  // ─── Events ───────────────────────────────────────────────────────────────
+  emit(event, payload) {
+    this.events.emit(event, payload);
+  }
+  createNoopEventBus() {
+    return {
+      emit: () => {
+      },
+      on: () => {
+      },
+      off: () => {
+      },
+      once: () => {
+      },
+      listeners: /* @__PURE__ */ new Map(),
+      wildcards: /* @__PURE__ */ new Set(),
+      setLogger: () => {
+      },
+      onAny: () => {
+      },
+      offAny: () => {
+      },
+      emitAsync: async () => [],
+      waitFor: async () => {
+      }
+    };
+  }
+};
+
+// src/autophase/auto-phase-runner.ts
+var AutoPhaseRunner = class {
+  graph = null;
+  orchestrator = null;
+  opts;
+  progressInterval = null;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  async start() {
+    const builder = new PhaseGraphBuilder({
+      title: this.opts.title,
+      description: this.opts.description,
+      phases: this.opts.phases,
+      autonomous: this.opts.autonomous,
+      stopOnFailure: this.opts.stopOnFailure
+    });
+    this.graph = await builder.build();
+    const ctx = {
+      executeTask: this.opts.executeTask,
+      onPhaseComplete: (phase) => {
+        this.opts.onPhaseComplete?.(phase);
+      },
+      onPhaseFail: (phase, error) => {
+        this.opts.onPhaseFail?.(phase, error);
+      },
+      onTick: (tickCtx) => {
+        this.opts.onTick?.(tickCtx);
+      }
+    };
+    this.orchestrator = new PhaseOrchestrator({
+      graph: this.graph,
+      ctx,
+      maxConcurrentPhases: this.opts.maxConcurrentPhases,
+      maxConcurrentTasks: this.opts.maxConcurrentTasks,
+      maxRetries: this.opts.maxRetries,
+      autonomous: this.opts.autonomous,
+      phaseDelayMs: this.opts.phaseDelayMs,
+      stopOnFailure: this.opts.stopOnFailure,
+      events: this.opts.events
+    });
+    if (this.opts.onProgress) {
+      this.progressInterval = setInterval(() => {
+        const progress = this.orchestrator.getProgress();
+        this.opts.onProgress(progress);
+      }, 2e3);
+    }
+    const events = this.opts.events;
+    if (events) {
+      events.on(
+        "graph.completed",
+        (payload) => {
+          const p = payload;
+          if (this.graph && p.graphId === this.graph.id) {
+            this.opts.onComplete?.(this.graph);
+            this.cleanup();
+          }
+        }
+      );
+      events.on(
+        "graph.failed",
+        (payload) => {
+          const p = payload;
+          if (this.graph && p.graphId === this.graph.id) {
+            const failedPhase = this.graph.phases.get(p.failedPhaseId);
+            if (failedPhase) {
+              this.opts.onFail?.(this.graph, failedPhase, new Error(p.error));
+            }
+            this.cleanup();
+          }
+        }
+      );
+    }
+    await this.orchestrator.start();
+    return this.graph;
+  }
+  pause() {
+    this.orchestrator?.pause();
+  }
+  resume() {
+    this.orchestrator?.resume();
+  }
+  stop() {
+    this.orchestrator?.stop();
+    this.cleanup();
+  }
+  getProgress() {
+    return this.orchestrator?.getProgress() ?? null;
+  }
+  getGraph() {
+    return this.graph;
+  }
+  isRunning() {
+    return this.orchestrator?.isRunning() ?? false;
+  }
+  isPaused() {
+    return this.orchestrator?.isPaused() ?? false;
+  }
+  assignAgent(phaseId, agentId) {
+    this.orchestrator?.assignAgent(phaseId, agentId);
+  }
+  releaseAgent(phaseId, agentId) {
+    this.orchestrator?.releaseAgent(phaseId, agentId);
+  }
+  cleanup() {
+    if (this.progressInterval) {
+      clearInterval(this.progressInterval);
+      this.progressInterval = null;
+    }
+  }
+};
+async function createAutoPhaseFromTaskGraph(taskGraph, options) {
+  const graph = await PhaseGraphBuilder.fromTaskGraph(taskGraph, {
+    title: options.title ?? taskGraph.title,
+    tasksPerPhase: options.tasksPerPhase
+  });
+  const phases = Array.from(graph.phases.values()).map((p) => ({
+    name: p.name,
+    description: p.description,
+    priority: p.priority,
+    estimateHours: p.estimateHours,
+    parallelizable: p.parallelizable
+  }));
+  return new AutoPhaseRunner({
+    ...options,
+    title: options.title ?? taskGraph.title,
+    phases
+  });
+}
+var PhaseStore = class {
+  baseDir;
+  constructor(opts) {
+    this.baseDir = opts.baseDir;
+  }
+  async save(graph) {
+    const filePath = this.getFilePath(graph.id);
+    await fsp2.mkdir(path6.dirname(filePath), { recursive: true });
+    const serialized = this.serializeGraph(graph);
+    await fsp2.writeFile(filePath, JSON.stringify(serialized, null, 2), "utf8");
+  }
+  async load(graphId) {
+    const filePath = this.getFilePath(graphId);
+    try {
+      const raw = await fsp2.readFile(filePath, "utf8");
+      const serialized = JSON.parse(raw);
+      return this.deserializeGraph(serialized);
+    } catch {
+      return null;
+    }
+  }
+  async delete(graphId) {
+    const filePath = this.getFilePath(graphId);
+    try {
+      await fsp2.unlink(filePath);
+    } catch {
+    }
+  }
+  async list() {
+    try {
+      const entries = await fsp2.readdir(this.baseDir, { withFileTypes: true });
+      const graphs = [];
+      for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+        try {
+          const raw = await fsp2.readFile(path6.join(this.baseDir, entry.name), "utf8");
+          const serialized = JSON.parse(raw);
+          const done = serialized.completedPhaseIds.length;
+          const total = serialized.phases.length;
+          graphs.push({
+            id: serialized.id,
+            title: serialized.title,
+            updatedAt: serialized.updatedAt,
+            status: done === total ? "completed" : done > 0 ? "in_progress" : "pending"
+          });
+        } catch {
+        }
+      }
+      return graphs.sort((a, b) => b.updatedAt - a.updatedAt);
+    } catch {
+      return [];
+    }
+  }
+  getFilePath(graphId) {
+    return path6.join(this.baseDir, `${graphId}.json`);
+  }
+  serializeGraph(graph) {
+    return {
+      id: graph.id,
+      title: graph.title,
+      description: graph.description,
+      phases: Array.from(graph.phases.values()).map((p) => this.serializePhase(p)),
+      rootPhaseIds: graph.rootPhaseIds,
+      activePhaseIds: graph.activePhaseIds,
+      completedPhaseIds: graph.completedPhaseIds,
+      failedPhaseIds: graph.failedPhaseIds,
+      autonomous: graph.autonomous,
+      stopOnComplete: graph.stopOnComplete,
+      createdAt: graph.createdAt,
+      updatedAt: graph.updatedAt,
+      startedAt: graph.startedAt,
+      completedAt: graph.completedAt
+    };
+  }
+  serializePhase(phase) {
+    return {
+      id: phase.id,
+      name: phase.name,
+      description: phase.description,
+      status: phase.status,
+      taskGraph: this.serializeTaskGraph(phase.taskGraph),
+      dependsOn: phase.dependsOn,
+      nextPhases: phase.nextPhases,
+      parallelizable: phase.parallelizable,
+      priority: phase.priority,
+      estimateHours: phase.estimateHours,
+      actualDurationMs: phase.actualDurationMs,
+      startedAt: phase.startedAt,
+      completedAt: phase.completedAt,
+      assignedAgents: phase.assignedAgents,
+      metadata: phase.metadata,
+      createdAt: phase.createdAt,
+      updatedAt: phase.updatedAt
+    };
+  }
+  serializeTaskGraph(graph) {
+    return {
+      id: graph.id,
+      specId: graph.specId,
+      title: graph.title,
+      nodes: Array.from(graph.nodes.values()).map((n) => this.serializeTaskNode(n)),
+      edges: graph.edges,
+      rootNodes: graph.rootNodes,
+      createdAt: graph.createdAt,
+      updatedAt: graph.updatedAt
+    };
+  }
+  serializeTaskNode(node) {
+    return { ...node };
+  }
+  deserializeGraph(serialized) {
+    const phases = /* @__PURE__ */ new Map();
+    for (const sp of serialized.phases) {
+      phases.set(sp.id, this.deserializePhase(sp));
+    }
+    return {
+      id: serialized.id,
+      title: serialized.title,
+      description: serialized.description,
+      phases,
+      rootPhaseIds: serialized.rootPhaseIds,
+      activePhaseIds: serialized.activePhaseIds,
+      completedPhaseIds: serialized.completedPhaseIds,
+      failedPhaseIds: serialized.failedPhaseIds,
+      autonomous: serialized.autonomous,
+      stopOnComplete: serialized.stopOnComplete,
+      createdAt: serialized.createdAt,
+      updatedAt: serialized.updatedAt,
+      startedAt: serialized.startedAt,
+      completedAt: serialized.completedAt
+    };
+  }
+  deserializePhase(serialized) {
+    return {
+      id: serialized.id,
+      name: serialized.name,
+      description: serialized.description,
+      status: serialized.status,
+      taskGraph: this.deserializeTaskGraph(serialized.taskGraph),
+      dependsOn: serialized.dependsOn,
+      nextPhases: serialized.nextPhases,
+      parallelizable: serialized.parallelizable,
+      priority: serialized.priority,
+      estimateHours: serialized.estimateHours,
+      actualDurationMs: serialized.actualDurationMs,
+      startedAt: serialized.startedAt,
+      completedAt: serialized.completedAt,
+      assignedAgents: serialized.assignedAgents,
+      metadata: serialized.metadata,
+      createdAt: serialized.createdAt,
+      updatedAt: serialized.updatedAt
+    };
+  }
+  deserializeTaskGraph(serialized) {
+    const nodes = /* @__PURE__ */ new Map();
+    for (const sn of serialized.nodes) {
+      nodes.set(sn.id, sn);
+    }
+    return {
+      id: serialized.id,
+      specId: serialized.specId,
+      title: serialized.title,
+      nodes,
+      edges: serialized.edges,
+      rootNodes: serialized.rootNodes,
+      createdAt: serialized.createdAt,
+      updatedAt: serialized.updatedAt
+    };
+  }
+};
+
+// src/autophase/checkpoint.ts
+var CheckpointManager = class {
+  store;
+  maxCheckpoints;
+  checkpoints = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.store = opts.store;
+    this.maxCheckpoints = opts.maxCheckpoints ?? 10;
+  }
+  async saveCheckpoint(graph, label) {
+    await this.store.save(graph);
+    const activePhase = Array.from(graph.phases.values()).find(
+      (p) => p.status === "running" || p.status === "paused"
+    );
+    const checkpoint = {
+      id: crypto.randomUUID(),
+      graphId: graph.id,
+      phaseId: activePhase?.id ?? graph.rootPhaseIds[0] ?? "",
+      phaseStatus: activePhase?.status ?? "pending",
+      taskStatuses: activePhase ? Array.from(activePhase.taskGraph.nodes.values()).map((t2) => ({
+        taskId: t2.id,
+        status: t2.status,
+        title: t2.title
+      })) : [],
+      timestamp: Date.now(),
+      label
+    };
+    this.checkpoints.set(checkpoint.id, checkpoint);
+    this.pruneCheckpoints();
+    return checkpoint;
+  }
+  async restoreCheckpoint(checkpointId) {
+    const checkpoint = this.checkpoints.get(checkpointId);
+    if (!checkpoint) return null;
+    const graph = await this.store.load(checkpoint.graphId);
+    if (!graph) return null;
+    const phase = graph.phases.get(checkpoint.phaseId);
+    if (phase) {
+      phase.status = checkpoint.phaseStatus;
+      phase.updatedAt = Date.now();
+      for (const ts of checkpoint.taskStatuses) {
+        const task = phase.taskGraph.nodes.get(ts.taskId);
+        if (task) {
+          task.status = ts.status;
+          task.updatedAt = Date.now();
+        }
+      }
+    }
+    graph.updatedAt = Date.now();
+    return graph;
+  }
+  listCheckpoints(graphId) {
+    const all = Array.from(this.checkpoints.values());
+    const filtered = graphId ? all.filter((c) => c.graphId === graphId) : all;
+    return filtered.sort((a, b) => b.timestamp - a.timestamp);
+  }
+  deleteCheckpoint(checkpointId) {
+    return this.checkpoints.delete(checkpointId);
+  }
+  pruneCheckpoints() {
+    const all = Array.from(this.checkpoints.values()).sort(
+      (a, b) => a.timestamp - b.timestamp
+    );
+    while (all.length > this.maxCheckpoints) {
+      const oldest = all.shift();
+      if (oldest) this.checkpoints.delete(oldest.id);
+    }
+  }
+};
+
+export { AGENTS_BY_PHASE, AGENT_CATALOG, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, Agent, AgentError, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutoPhaseRunner, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, CONTEXT_WINDOW_MODES, CheckpointManager, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorStateCheckpoint, DoneConditionChecker, ERROR_CODES, EternalAutonomyEngine, EventBus, ExtensionRegistry, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, FsError, GitignoreUpdater, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, LAYER_1_IDENTITY, LLMSelector, MAX_JOURNAL_ENTRIES, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, PhaseGraphBuilder, PhaseOrchestrator, PhaseStore, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, ReportGenerator, RunController, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, ScopedEventBus, SddParallelRun, SddTaskDecomposer, SecurityScanner, SecurityScannerOrchestrator, SelectiveCompactor, SessionAnalyzer, SessionError, SkillGenerator, SkillInstaller, SkillManifestStore, SlashCommandRegistry, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, TechStackDetector, ToolError, ToolExecutor, ToolRegistry, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, appendJournal, applyRosterBudget, asBlocks, asText, atomicWrite, attachAutoExtend, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildBtwBlock, buildChildEnv, buildGoalPreamble, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildRecoveryStrategies, classifyFamily, clearPlan, color, compileGlob, compileUserRegex, composeDirectorPrompt, composeSubagentPrompt, computeTaskProgress, consumeBtwNotes, context7Server, contextManagerTool, createAutoExecutor, createAutoPhaseFromTaskGraph, createContextManagerTool, createDefaultPipelines, createDelegateTool, createMcpControlTool, createMessage, createSecuritySlashCommand, createToolOutputSerializer, decryptConfigSecrets, defaultGitignoreUpdater, defaultOrchestrator, defaultReportGenerator, defaultSecurityScanner, defaultSkillGenerator, defaultTechStackDetector, deriveTodosFromPlanItem, detectNewlineStyle, dispatchAgent, downloadGitHubTarball, emptyGoal, emptyPlan, encryptConfigSecrets, ensureDir, estimateRequestTokens, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, extractRunEnv, filesystemServer, findCriticalPath, formatContextWindowModeList, formatGoal, formatPlan, formatPlanTemplates, formatTodosList, getAgentDefinition, getContextWindowMode, getPlanTemplate, getTemplate, githubServer, goalFilePath, googleMapsServer, isAgentError, isConfigError, isContextWindowModeId, isFsError, isImageBlock, isPluginError, isSessionError, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isWrongStackError, listContextWindowModes, listPlanTemplates, listTemplates, loadDirectorState, loadGoal, loadPlan, loadPlugins, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeAutonomyPromptContributor, makeContinueToNextIterationTool, makeDirectorSessionFactory, makeLLMClassifier, matchAny, matchGlob, migratePlaintextSecrets, miniMaxVisionServer, normalizeToLf, parseContinueDirective, parseSkillRef, pendingBtwCount, projectHash, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, resolveContextWindowPolicy, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, safeParse, safeStringify, sanitizeJsonString, saveGoal, savePlan, saveTodosCheckpoint, scoreAgents, securitySlashCommand, sentinelServer, setBtwNote, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, stripAnsi, summarizeUsage, templateToMarkdown, toStyle, toWrongStackError, topologicalSort, unifiedDiff, unloadPlugins, validateAgainstSchema, wireMetricsToEvents, wrapAsState, zaiVisionServer };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map