wave-agent-sdk 1.0.0 → 1.0.1

package/src/services/autoMemoryService.ts

@@ -2,14 +2,32 @@ import * as path from "node:path";
 import * as fs from "node:fs/promises";
 import { Container } from "../utils/container.js";
 import { MessageManager } from "../managers/messageManager.js";
-import { ForkedAgentManager } from "../managers/forkedAgentManager.js";
+import { AIManager } from "../managers/aiManager.js";
 import { MemoryService } from "./memory.js";
 import { ConfigurationService } from "./configurationService.js";
 import { logger } from "../utils/globalLogger.js";
 import { isPathInside } from "../utils/pathSafety.js";
 import { buildAutoMemoryExtractionPrompt } from "../prompts/autoMemoryExtraction.js";
+import {
+  READ_ONLY_COMMANDS,
+  splitBashCommand,
+  hasWriteRedirections,
+  hasCommandSubstitution,
+  hasProcessSubstitution,
+  hasSedInPlace,
+  isDangerousFind,
+} from "../utils/bashParser.js";
 import type { Message } from "../types/index.js";
 
+/**
+ * Message fed back to the extraction fork when the model requests a tool
+ * outside the allowed set (Bash rm, MCP tools, Agent, out-of-dir writes...).
+ */
+const DENIED_TOOL_MESSAGE =
+  "This tool call was denied during auto-memory extraction. Available tools: " +
+  "Read, Grep, Glob, read-only Bash commands, and Write/Edit inside the " +
+  "memory directory only.";
+
 /**
  * Service responsible for managing the auto-memory background agent lifecycle.
  * Extracts and updates persistent project-level memory from conversation history.
@@ -17,6 +35,8 @@ import type { Message } from "../types/index.js";
 export class AutoMemoryService {
   private lastMemoryMessageId: string | null = null;
   private turnsSinceLastExtraction: number = 0;
+  private extractionInProgress: boolean = false;
+  private pendingExtraction: Promise<void> | null = null;
 
   constructor(private container: Container) {}
 
@@ -24,8 +44,8 @@ export class AutoMemoryService {
     return this.container.get<MessageManager>("MessageManager")!;
   }
 
-  private get forkedAgentManager(): ForkedAgentManager {
-    return this.container.get<ForkedAgentManager>("ForkedAgentManager")!;
+  private get aiManager(): AIManager {
+    return this.container.get<AIManager>("AIManager")!;
   }
 
   private get memoryService(): MemoryService {
@@ -71,7 +91,14 @@ export class AutoMemoryService {
       (m) =>
         m.role === "assistant" &&
         m.blocks.some((b) => {
-          if (b.type === "tool" && (b.name === "Write" || b.name === "Edit")) {
+          if (
+            b.type === "tool" &&
+            (b.name === "Write" || b.name === "Edit") &&
+            // Only a successful manual write counts as a manual update. A
+            // denied/failed write didn't touch memory, so the extraction fork
+            // must still run or the information is lost.
+            b.success !== false
+          ) {
             try {
               const params = b.parameters ? JSON.parse(b.parameters) : null;
               const filePath = params?.file_path || params?.path;
@@ -98,22 +125,61 @@ export class AutoMemoryService {
       return;
     }
 
-    // 3. Trigger background extraction using a forked subagent
-    try {
-      await this.runExtraction(workdir, messages);
-      this.lastMemoryMessageId = messages[messages.length - 1].id || null;
-      this.turnsSinceLastExtraction = 0;
-    } catch (error) {
-      logger.error("Auto-memory extraction failed to trigger:", error);
+    // 3. Concurrency guard: if an extraction is already in flight, skip this
+    // turn. turnsSinceLastExtraction is intentionally NOT reset so the next
+    // eligible turn retriggers the extraction.
+    if (this.extractionInProgress) {
+      logger.debug(
+        "Skipping auto-memory extraction: another extraction is still in progress.",
+      );
+      return;
     }
+
+    // 4. Trigger the perfect-fork extraction fire-and-forget. The message
+    // snapshot and new-message count are computed now; lastMemoryMessageId
+    // advances at trigger time so the next extraction starts from a later
+    // window even while this one runs.
+    const lastExtractedIndex = this.lastMemoryMessageId
+      ? messages.findIndex((m) => m.id === this.lastMemoryMessageId)
+      : -1;
+    const newMessageCount =
+      lastExtractedIndex === -1
+        ? messages.length
+        : messages.length - 1 - lastExtractedIndex;
+
+    this.turnsSinceLastExtraction = 0;
+    this.lastMemoryMessageId = messages[messages.length - 1].id || null;
+    this.extractionInProgress = true;
+    const extraction = this.runExtraction(workdir, messages, newMessageCount)
+      .catch((error) => {
+        logger.error("Auto-memory extraction failed:", error);
+      })
+      .finally(() => {
+        this.extractionInProgress = false;
+        this.pendingExtraction = null;
+      });
+    this.pendingExtraction = extraction;
+  }
+
+  /**
+   * Wait for an in-flight extraction to settle. Called from Agent.dispose so
+   * the process doesn't exit while the extraction fork is mid-flight.
+   */
+  async drain(): Promise<void> {
+    await this.pendingExtraction;
   }
 
   /**
-   * Initialize and execute the background extraction subagent.
+   * Initialize and execute the extraction in a perfect fork: same system
+   * prompt, tools, model, and message prefix as the main conversation, so the
+   * prompt cache is reused. A tool gate confines the fork to read-only
+   * inspection and memory-directory writes. Runs in-process; callers treat it
+   * as fire-and-forget.
    */
   private async runExtraction(
     workdir: string,
     messages: Message[],
+    newMessageCount: number,
   ): Promise<void> {
     const memoryDir = this.memoryService.getAutoMemoryDirectory(workdir);
 
@@ -132,43 +198,83 @@ export class AutoMemoryService {
       // Ignore if directory doesn't exist yet
     }
 
-    // Calculate how many new messages to analyze
-    let newMessageCount = messages.length;
-    if (this.lastMemoryMessageId) {
-      const lastIndex = messages.findIndex(
-        (m) => m.id === this.lastMemoryMessageId,
-      );
-      if (lastIndex !== -1) {
-        newMessageCount = messages.length - 1 - lastIndex;
-      }
-    }
-
     const prompt = buildAutoMemoryExtractionPrompt(
       newMessageCount,
       existingMemoriesManifest,
     );
 
-    // Execute the forked agent in background (fire-and-forget, decoupled from BackgroundTaskManager)
-    await this.forkedAgentManager.forkAndExecute(
-      "general-purpose",
+    await this.aiManager.runAutoMemoryFork(
       messages,
+      `${prompt}\n\nThe memory directory for this project is: ${memoryDir}`,
       {
-        description: "Auto-memory extraction background agent",
-        allowedTools: [
-          "Read",
-          "Glob",
-          "Grep",
-          `Write(${memoryDir}/**/*)`,
-          `Edit(${memoryDir}/**/*)`,
-          `Bash(rm ${memoryDir}/**/*)`,
-        ],
-        model: "fastModel", // Use fast model for background tasks to reduce latency and cost
-        permissionModeOverride: "dontAsk", // Auto-deny out-of-scope writes without prompting user
         maxTurns: 5, // Limit turns to prevent verification rabbit-holes
+        canUseTool: (name, args) =>
+          this.isAllowedForkTool(name, args, memoryDir, workdir),
+        deniedToolMessage: DENIED_TOOL_MESSAGE,
       },
-      `${prompt}\n\nThe memory directory for this project is: ${memoryDir}`,
     );
 
-    logger.debug("Auto-memory extraction started in background.");
+    logger.debug("Auto-memory extraction completed.");
+  }
+
+  /**
+   * Tool gate for the extraction fork: Read/Grep/Glob are always allowed;
+   * Write/Edit only when the target path is inside the memory directory; Bash
+   * only for read-only commands (aligned with the permission manager's
+   * read-only bash classification). Everything else — Bash rm, MCP tools,
+   * Agent, out-of-dir writes — is denied.
+   */
+  private isAllowedForkTool(
+    name: string,
+    args: Record<string, unknown>,
+    memoryDir: string,
+    workdir: string,
+  ): boolean {
+    if (name === "Read" || name === "Grep" || name === "Glob") {
+      return true;
+    }
+
+    if (name === "Write" || name === "Edit") {
+      const filePath = args.file_path ?? args.path;
+      if (typeof filePath !== "string" || !filePath) return false;
+      const absolutePath = path.isAbsolute(filePath)
+        ? filePath
+        : path.resolve(workdir, filePath);
+      return isPathInside(absolutePath, memoryDir);
+    }
+
+    if (name === "Bash") {
+      const command = typeof args.command === "string" ? args.command : "";
+      return this.isReadOnlyBashCommand(command);
+    }
+
+    return false;
+  }
+
+  /**
+   * A bash command is read-only when every part is a READ_ONLY_COMMANDS entry
+   * without write redirections, command/process substitution, sed -i, or
+   * dangerous find flags. Mirrors PermissionManager.isAutoAllowedPart.
+   */
+  private isReadOnlyBashCommand(command: string): boolean {
+    if (!command.trim()) return false;
+    if (hasWriteRedirections(command)) return false;
+    if (hasCommandSubstitution(command)) return false;
+    if (hasProcessSubstitution(command)) return false;
+    if (hasSedInPlace(command)) return false;
+
+    const parts = splitBashCommand(command);
+    if (parts.length === 0) return false;
+
+    return parts.every((part) => {
+      const trimmed = part.trim();
+      if (!trimmed) return true;
+      const commandMatch = trimmed.match(/^(\w+)(\s+.*)?$/);
+      if (!commandMatch) return false;
+      const cmd = commandMatch[1];
+      if (!READ_ONLY_COMMANDS.includes(cmd)) return false;
+      if (cmd === "find" && isDangerousFind(part)) return false;
+      return true;
+    });
   }
 }

package/src/services/configurationService.ts

@@ -619,16 +619,31 @@ export class ConfigurationService {
       baseConfig.fastModelOptions = fastModelSource.options;
     }
 
+    // Resolve fast-model disable-thinking params from models[fastModel].disableThinkingOptions
+    const fastModelDisableThinking =
+      fastModelSource && fastModelSource.disableThinkingOptions
+        ? fastModelSource.disableThinkingOptions
+        : undefined;
+    if (fastModelDisableThinking) {
+      baseConfig.disableThinkingOptions = fastModelDisableThinking;
+    }
+
     // Merge model-specific settings from configuration
     const modelSpecificConfig =
       resolvedAgentModel &&
       this.currentConfiguration?.models?.[resolvedAgentModel];
 
     if (modelSpecificConfig) {
-      return {
+      const resolved: ModelConfig = {
         ...baseConfig,
         ...modelSpecificConfig,
       };
+      // Re-apply after the spread so the agent model's own
+      // disableThinkingOptions cannot clobber the fast-model value.
+      if (fastModelDisableThinking) {
+        resolved.disableThinkingOptions = fastModelDisableThinking;
+      }
+      return resolved;
     }
 
     return baseConfig;

package/src/services/session.ts

@@ -612,6 +612,74 @@ export async function cleanupEmptyProjectDirectories(): Promise<void> {
   }
 }
 
+/**
+ * Clean up "ghost" session files that contain only meta messages
+ * (isMeta: true) — e.g. sessions where a SessionStart hook injected a
+ * system-reminder but no real user/assistant message was ever sent.
+ *
+ * Such sessions are no longer created thanks to lazy materialization in
+ * saveSession(); this one-time sweep removes files that predate that change
+ * so they stop showing up as "0 tokens / No content" entries in the resume
+ * list.
+ *
+ * @returns Promise that resolves to the number of files deleted
+ */
+export async function cleanupMetaOnlySessions(): Promise<number> {
+  // Do not perform cleanup operations in test environment
+  if (process.env.NODE_ENV === "test") {
+    return 0;
+  }
+
+  let deletedCount = 0;
+  try {
+    const projectDirs = await fs.readdir(SESSION_DIR);
+
+    for (const projectDirName of projectDirs) {
+      const projectPath = join(SESSION_DIR, projectDirName);
+      try {
+        const stat = await fs.stat(projectPath);
+        if (!stat.isDirectory()) {
+          continue;
+        }
+
+        const files = await fs.readdir(projectPath);
+        for (const file of files) {
+          if (!file.endsWith(".jsonl")) {
+            continue;
+          }
+
+          const filePath = join(projectPath, file);
+          try {
+            // Fast path: a file whose last message is not meta contains a
+            // real message, so it can never be meta-only.
+            const jsonlHandler = new JsonlHandler();
+            const lastMessage = await jsonlHandler.getLastMessage(filePath);
+            if (!lastMessage?.isMeta) {
+              continue;
+            }
+
+            const messages = await jsonlHandler.read(filePath);
+            if (messages.length > 0 && messages.every((m) => m.isMeta)) {
+              await fs.unlink(filePath);
+              deletedCount++;
+            }
+          } catch {
+            // Skip corrupted or unreadable files
+            continue;
+          }
+        }
+      } catch {
+        // Skip directories we can't access
+        continue;
+      }
+    }
+  } catch {
+    // Ignore errors if base directory doesn't exist or can't be accessed
+  }
+
+  return deletedCount;
+}
+
 /**
  * Check if a session exists in JSONL storage (new approach)
  *

package/src/types/agent.ts

@@ -119,10 +119,4 @@ export interface AgentCallbacks
   onCommandRunningChange?: (running: boolean) => void;
   onWorkdirChange?: (newCwd: string) => void;
   onQueuedMessagesChange?: (messages: QueuedMessage[]) => void;
-  onGoalStateChange?: (
-    active: boolean,
-    condition?: string,
-    elapsed?: string,
-  ) => void;
-  onGoalEvaluating?: (evaluating: boolean) => void;
 }

package/src/types/config.ts

@@ -33,4 +33,11 @@ export interface ModelConfig {
   options?: Record<string, unknown>;
   /** Fast model generation params (resolved from models[fastModel].options) */
   fastModelOptions?: Record<string, unknown>;
+  /**
+   * Fast-model-only disable-thinking params passed through verbatim
+   * (e.g. `{ thinking: { type: "disabled" } }`). Applied only in fast-model
+   * scenarios (webFetch content processing, `model: fastModel` subagents),
+   * never in the agent loop. `{}` clears the default.
+   */
+  disableThinkingOptions?: Record<string, unknown>;
 }

package/src/types/core.ts

@@ -25,7 +25,7 @@ export interface Usage {
   completion_tokens: number; // Tokens generated in completions
   total_tokens: number; // Sum of prompt + completion tokens
   model?: string; // Model used for the operation (e.g., "gpt-4", "gpt-3.5-turbo")
-  operation_type?: "agent" | "compact" | "goal_evaluation"; // Type of operation that generated usage
+  operation_type?: "agent" | "compact"; // Type of operation that generated usage
 
   // Cache-related tokens (Claude top-level + OpenAI prompt_tokens_details)
   cache_read_input_tokens?: number; // Tokens read from cache (Claude) or cached_tokens (OpenAI prompt_tokens_details)

package/src/utils/containerSetup.ts

@@ -16,7 +16,6 @@ import { SlashCommandManager } from "../managers/slashCommandManager.js";
 import { PluginManager } from "../managers/pluginManager.js";
 import { BangManager } from "../managers/bangManager.js";
 import { CronManager } from "../managers/cronManager.js";
-import { GoalManager } from "../managers/goalManager.js";
 import { WorkflowManager } from "../managers/workflowManager.js";
 import { MemoryRuleManager } from "../managers/MemoryRuleManager.js";
 import { ReversionManager } from "../managers/reversionManager.js";
@@ -25,6 +24,7 @@ import { ForkedAgentManager } from "../managers/forkedAgentManager.js";
 import { LiveConfigManager } from "../managers/liveConfigManager.js";
 import { ConfigurationService } from "../services/configurationService.js";
 import { ReversionService } from "../services/reversionService.js";
+import { cleanupMetaOnlySessions } from "../services/session.js";
 import { MemoryService } from "../services/memory.js";
 import { AutoMemoryService } from "../services/autoMemoryService.js";
 import { USER_MEMORY_FILE } from "./constants.js";
@@ -210,6 +210,17 @@ export function setupAgentContainer(
   reversionService.cleanupOldSessions(30).catch((error) => {
     logger.error("Failed to cleanup old file history:", error);
   });
+  // Remove pre-existing meta-only session files (SessionStart hook context
+  // with no real messages) that were persisted before lazy materialization.
+  cleanupMetaOnlySessions()
+    .then((count) => {
+      if (count > 0) {
+        logger.debug(`Removed ${count} meta-only session file(s)`);
+      }
+    })
+    .catch((error) => {
+      logger.error("Failed to cleanup meta-only session files:", error);
+    });
   const reversionManager = new ReversionManager(container);
   container.register("ReversionManager", reversionManager);
 
@@ -352,9 +363,6 @@ export function setupAgentContainer(
   container.register("CronManager", cronManager);
   cronManager.start();
 
-  const goalManager = new GoalManager(container);
-  container.register("GoalManager", goalManager);
-
   const workflowManager = new WorkflowManager(container);
   container.register("WorkflowManager", workflowManager);
 

package/dist/constants/goalPrompts.d.ts

@@ -1 +0,0 @@
-export declare const GOAL_EVALUATION_SYSTEM_PROMPT = "You are a goal evaluator. Given a goal condition and a conversation, determine whether the goal has been achieved.\n\nRules:\n- Judge ONLY based on what the conversation shows \u2014 tool outputs, test results, file contents, etc.\n- Do NOT assume work is done without evidence in the conversation.\n- Be strict and conservative: when uncertain, return met: false.\n- Be concise: your reason should be 1-2 sentences.\n\nRespond with JSON only, no other text:\n{\"met\": boolean, \"reason\": \"short explanation\"}";

package/dist/constants/goalPrompts.js

@@ -1,10 +0,0 @@
-export const GOAL_EVALUATION_SYSTEM_PROMPT = `You are a goal evaluator. Given a goal condition and a conversation, determine whether the goal has been achieved.
-
-Rules:
-- Judge ONLY based on what the conversation shows — tool outputs, test results, file contents, etc.
-- Do NOT assume work is done without evidence in the conversation.
-- Be strict and conservative: when uncertain, return met: false.
-- Be concise: your reason should be 1-2 sentences.
-
-Respond with JSON only, no other text:
-{"met": boolean, "reason": "short explanation"}`;

package/dist/managers/goalManager.d.ts

@@ -1,42 +0,0 @@
-import { Container } from "../utils/container.js";
-export interface GoalState {
-    condition: string;
-    startedAt: number;
-    turnCount: number;
-    tokenBaseline: number;
-    lastReason?: string;
-    consecutiveEvalFailures: number;
-}
-export declare class GoalManager {
-    private container;
-    private state;
-    private onGoalStateChange?;
-    private onGoalEvaluating?;
-    constructor(container: Container);
-    private get messageManager();
-    private get aiManager();
-    setOnGoalStateChange(callback: (active: boolean, condition?: string, elapsed?: string) => void): void;
-    setOnGoalEvaluating(callback: (evaluating: boolean) => void): void;
-    setGoal(condition: string): void;
-    clearGoal(): void;
-    getGoal(): GoalState | null;
-    isGoalActive(): boolean;
-    incrementTurnCount(): void;
-    getStatusString(): string;
-    /**
-     * Check circuit breakers. Returns a clear reason if goal should be force-cleared, null otherwise.
-     */
-    checkCircuitBreakers(): string | null;
-    /**
-     * Evaluate whether the goal has been met using the fast model.
-     */
-    evaluateGoal(abortSignal?: AbortSignal): Promise<{
-        isMet: boolean;
-        reason: string;
-    }>;
-    /**
-     * Parse the evaluation response from the fast model.
-     */
-    private parseEvaluationResponse;
-    private formatElapsed;
-}

package/dist/managers/goalManager.js

@@ -1,177 +0,0 @@
-import { evaluateGoal as aiEvaluateGoal } from "../services/aiService.js";
-import { convertMessagesForAPI } from "../utils/convertMessagesForAPI.js";
-import { logger } from "../utils/globalLogger.js";
-const MAX_GOAL_TURNS = 50;
-const MAX_GOAL_DURATION_MS = 30 * 60 * 1000; // 30 minutes
-const MAX_CONSECUTIVE_EVAL_FAILURES = 3;
-const MAX_CONDITION_LENGTH = 4000;
-export class GoalManager {
-    constructor(container) {
-        this.container = container;
-        this.state = null;
-    }
-    get messageManager() {
-        return this.container.get("MessageManager");
-    }
-    get aiManager() {
-        return this.container.get("AIManager");
-    }
-    setOnGoalStateChange(callback) {
-        this.onGoalStateChange = callback;
-    }
-    setOnGoalEvaluating(callback) {
-        this.onGoalEvaluating = callback;
-    }
-    setGoal(condition) {
-        if (condition.length > MAX_CONDITION_LENGTH) {
-            throw new Error(`Goal condition exceeds maximum length of ${MAX_CONDITION_LENGTH} characters`);
-        }
-        const totalTokens = this.messageManager.getLatestTotalTokens?.() ?? 0;
-        this.state = {
-            condition,
-            startedAt: Date.now(),
-            turnCount: 0,
-            tokenBaseline: totalTokens,
-            consecutiveEvalFailures: 0,
-        };
-        this.onGoalStateChange?.(true, condition, "0m");
-        logger?.info(`[Goal] Set goal: ${condition}`);
-    }
-    clearGoal() {
-        if (this.state) {
-            logger?.info(`[Goal] Cleared goal: ${this.state.condition}`);
-            this.state = null;
-            this.onGoalStateChange?.(false);
-        }
-    }
-    getGoal() {
-        return this.state;
-    }
-    isGoalActive() {
-        return this.state !== null;
-    }
-    incrementTurnCount() {
-        if (this.state) {
-            this.state.turnCount++;
-        }
-    }
-    getStatusString() {
-        if (!this.state)
-            return "No active goal";
-        const elapsed = this.formatElapsed(Date.now() - this.state.startedAt);
-        let status = `Goal: ${this.state.condition}\nElapsed: ${elapsed}\nTurns: ${this.state.turnCount}`;
-        if (this.state.lastReason) {
-            status += `\nLast evaluation: ${this.state.lastReason}`;
-        }
-        return status;
-    }
-    /**
-     * Check circuit breakers. Returns a clear reason if goal should be force-cleared, null otherwise.
-     */
-    checkCircuitBreakers() {
-        if (!this.state)
-            return null;
-        if (this.state.turnCount >= MAX_GOAL_TURNS) {
-            return `Goal cancelled: maximum turns (${MAX_GOAL_TURNS}) exceeded`;
-        }
-        if (Date.now() - this.state.startedAt >= MAX_GOAL_DURATION_MS) {
-            return `Goal cancelled: time limit (${MAX_GOAL_DURATION_MS / 60000} minutes) exceeded`;
-        }
-        if (this.state.consecutiveEvalFailures >= MAX_CONSECUTIVE_EVAL_FAILURES) {
-            return `Goal cancelled: ${MAX_CONSECUTIVE_EVAL_FAILURES} consecutive evaluation failures`;
-        }
-        return null;
-    }
-    /**
-     * Evaluate whether the goal has been met using the fast model.
-     */
-    async evaluateGoal(abortSignal) {
-        if (!this.state) {
-            return { isMet: false, reason: "No active goal" };
-        }
-        try {
-            const messages = this.messageManager.getMessages();
-            const apiMessages = convertMessagesForAPI(messages);
-            const gatewayConfig = this.aiManager.getGatewayConfig();
-            const modelConfig = this.aiManager.getModelConfig();
-            const fastModel = modelConfig.fastModel || modelConfig.model;
-            if (!fastModel) {
-                return {
-                    isMet: false,
-                    reason: "No model configured for goal evaluation",
-                };
-            }
-            this.onGoalEvaluating?.(true);
-            const result = await aiEvaluateGoal({
-                gatewayConfig,
-                modelConfig,
-                model: fastModel,
-                goalCondition: this.state.condition,
-                messages: apiMessages,
-                abortSignal,
-            });
-            // Track evaluation tokens separately
-            if (result.usage) {
-                const usage = {
-                    ...result.usage,
-                    operation_type: "goal_evaluation",
-                    model: fastModel,
-                };
-                this.messageManager.addUsage(usage);
-            }
-            // Reset failure counter on success
-            this.state.consecutiveEvalFailures = 0;
-            this.onGoalEvaluating?.(false);
-            // Parse the response
-            return this.parseEvaluationResponse(result.content);
-        }
-        catch (error) {
-            this.onGoalEvaluating?.(false);
-            this.state.consecutiveEvalFailures++;
-            logger?.warn(`[Goal] Evaluation failed (${this.state.consecutiveEvalFailures}/${MAX_CONSECUTIVE_EVAL_FAILURES}): ${error.message}`);
-            return {
-                isMet: false,
-                reason: `Evaluation failed: ${error.message}`,
-            };
-        }
-    }
-    /**
-     * Parse the evaluation response from the fast model.
-     */
-    parseEvaluationResponse(content) {
-        // Try direct JSON parse
-        try {
-            const parsed = JSON.parse(content);
-            if (typeof parsed.met === "boolean") {
-                return {
-                    isMet: parsed.met,
-                    reason: parsed.reason || "No reason provided",
-                };
-            }
-        }
-        catch {
-            // Fall through to regex
-        }
-        // Try regex extraction
-        const metMatch = content.match(/"met"\s*:\s*(true|false)/);
-        const reasonMatch = content.match(/"reason"\s*:\s*"([^"]*)"/);
-        if (metMatch) {
-            return {
-                isMet: metMatch[1] === "true",
-                reason: reasonMatch?.[1] || "No reason provided",
-            };
-        }
-        // Default: not met
-        return { isMet: false, reason: "Could not parse evaluation response" };
-    }
-    formatElapsed(ms) {
-        const minutes = Math.floor(ms / 60000);
-        if (minutes < 1)
-            return "<1m";
-        if (minutes < 60)
-            return `${minutes}m`;
-        const hours = Math.floor(minutes / 60);
-        const remainingMin = minutes % 60;
-        return `${hours}h${remainingMin}m`;
-    }
-}

package/src/constants/goalPrompts.ts

@@ -1,10 +0,0 @@
-export const GOAL_EVALUATION_SYSTEM_PROMPT = `You are a goal evaluator. Given a goal condition and a conversation, determine whether the goal has been achieved.
-
-Rules:
-- Judge ONLY based on what the conversation shows — tool outputs, test results, file contents, etc.
-- Do NOT assume work is done without evidence in the conversation.
-- Be strict and conservative: when uncertain, return met: false.
-- Be concise: your reason should be 1-2 sentences.
-
-Respond with JSON only, no other text:
-{"met": boolean, "reason": "short explanation"}`;