wave-agent-sdk 0.5.0 → 0.6.0

package/src/agent.ts

@@ -9,7 +9,6 @@ import {
   SubagentManager,
   type SubagentManagerCallbacks,
 } from "./managers/subagentManager.js";
-import * as memory from "./services/memory.js";
 import { McpManager, type McpManagerCallbacks } from "./managers/mcpManager.js";
 import { LspManager } from "./managers/lspManager.js";
 import { BashManager } from "./managers/bashManager.js";
@@ -46,6 +45,7 @@ import { MemoryRuleManager } from "./managers/MemoryRuleManager.js";
 import { LiveConfigManager } from "./managers/liveConfigManager.js";
 import { configValidator } from "./utils/configValidator.js";
 import { SkillManager } from "./managers/skillManager.js";
+import { TaskManager } from "./services/taskManager.js";
 import {
   loadSessionFromJsonl,
   handleSessionRestoration,
@@ -107,7 +107,12 @@ export interface AgentCallbacks
     McpManagerCallbacks,
     SubagentManagerCallbacks {
   onTasksChange?: (tasks: BackgroundTask[]) => void;
+  onSessionTasksChange?: (tasks: import("./types/tasks.js").Task[]) => void;
   onPermissionModeChange?: (mode: PermissionMode) => void;
+  onSubagentLatestTotalTokensChange?: (
+    subagentId: string,
+    tokens: number,
+  ) => void;
   onBackgroundCurrentTask?: () => void;
 }
 
@@ -131,6 +136,7 @@ export class Agent {
   private reversionManager: ReversionManager;
   private memoryRuleManager: MemoryRuleManager; // Add memory rule manager instance
   private liveConfigManager: LiveConfigManager; // Add live configuration manager
+  private taskManager: TaskManager;
   private foregroundTaskManager: ForegroundTaskManager;
   private configurationService: ConfigurationService; // Add configuration service
   private workdir: string; // Working directory
@@ -208,6 +214,46 @@ export class Agent {
 
     this.foregroundTaskManager = new ForegroundTaskManager();
 
+    // Initialize memory rule manager
+    this.memoryRuleManager = new MemoryRuleManager({
+      workdir: this.workdir,
+    });
+
+    // Initialize MessageManager
+    this.messageManager = new MessageManager({
+      callbacks: {
+        ...callbacks,
+        onSessionIdChange: (sessionId) => {
+          // When session ID changes (e.g. due to compression),
+          // we update the task manager to use the root session ID
+          // to ensure the task list remains consistent.
+          this.taskManager.setTaskListId(
+            this.messageManager.getRootSessionId(),
+          );
+          callbacks.onSessionIdChange?.(sessionId);
+        },
+        onSubagentTaskStopRequested: (subagentId) => {
+          this.backgroundTaskManager.stopTask(subagentId);
+        },
+      },
+      workdir: this.workdir,
+      logger: this.logger,
+      memoryRuleManager: this.memoryRuleManager,
+    });
+
+    // Resolve taskListId once during construction to ensure stability
+    const resolvedTaskListId =
+      this.configurationService.getEnvironmentVars().WAVE_TASK_LIST_ID ||
+      process.env.WAVE_TASK_LIST_ID ||
+      this.messageManager.getRootSessionId();
+
+    this.taskManager = new TaskManager(resolvedTaskListId);
+    this.taskManager.on("tasksChange", async () => {
+      const tasks = await this.taskManager.listTasks();
+      this.options.callbacks?.onSessionTasksChange?.(tasks);
+    });
+
+    // Initialize BackgroundTaskManager
     this.backgroundTaskManager = new BackgroundTaskManager({
       callbacks: {
         ...callbacks,
@@ -243,20 +289,7 @@ export class Agent {
       workdir: this.workdir,
     });
 
-    // Initialize memory rule manager
-    this.memoryRuleManager = new MemoryRuleManager({
-      workdir: this.workdir,
-    });
-
-    // Initialize MessageManager
-    this.messageManager = new MessageManager({
-      callbacks,
-      workdir: this.workdir,
-      logger: this.logger,
-      memoryRuleManager: this.memoryRuleManager,
-    });
-
-    // Initialize ReversionManager
+    // ReversionManager depends on MessageManager
     this.reversionManager = new ReversionManager(
       new ReversionService(this.messageManager.getTranscriptPath()),
     );
@@ -312,6 +345,7 @@ export class Agent {
       reversionManager: this.reversionManager,
       permissionMode: options.permissionMode, // Let PermissionManager handle defaultMode resolution
       canUseToolCallback: canUseToolWithNotification,
+      taskManager: this.taskManager,
       backgroundTaskManager: this.backgroundTaskManager,
       foregroundTaskManager: this.foregroundTaskManager,
     }); // Initialize tool registry with permission support
@@ -339,6 +373,8 @@ export class Agent {
           callbacks.onSubagentAssistantReasoningUpdated,
         onSubagentToolBlockUpdated: callbacks.onSubagentToolBlockUpdated,
         onSubagentMessagesChange: callbacks.onSubagentMessagesChange,
+        onSubagentLatestTotalTokensChange:
+          callbacks.onSubagentLatestTotalTokensChange,
       }, // Pass subagent callbacks for forwarding
       logger: this.logger,
       getGatewayConfig: () => this.getGatewayConfig(),
@@ -348,6 +384,7 @@ export class Agent {
       hookManager: this.hookManager,
       onUsageAdded: (usage) => this.addUsage(usage),
       backgroundTaskManager: this.backgroundTaskManager,
+      taskManager: this.taskManager,
       memoryRuleManager: this.memoryRuleManager,
     });
 
@@ -355,6 +392,7 @@ export class Agent {
     this.aiManager = new AIManager({
       messageManager: this.messageManager,
       toolManager: this.toolManager,
+      taskManager: this.taskManager,
       logger: this.logger,
       backgroundTaskManager: this.backgroundTaskManager,
       hookManager: this.hookManager,
@@ -780,8 +818,18 @@ export class Agent {
       // After main session is restored, restore any associated subagent sessions
       await this.restoreSubagentSessions(sessionToRestore?.messages || []);
 
-      if (sessionToRestore)
+      if (sessionToRestore) {
         this.messageManager.initializeFromSession(sessionToRestore);
+
+        // Update task manager with the root session ID to ensure continuity across compressions
+        this.taskManager.setTaskListId(
+          sessionToRestore.rootSessionId || sessionToRestore.id,
+        );
+
+        // After session is initialized, load tasks for the session
+        const tasks = await this.taskManager.listTasks();
+        this.options.callbacks?.onSessionTasksChange?.(tasks);
+      }
     }
   }
 
@@ -904,6 +952,13 @@ export class Agent {
 
     // 6. Initialize session state last
     this.messageManager.initializeFromSession(sessionData);
+
+    // Update task manager with the root session ID to ensure continuity across compressions
+    this.taskManager.setTaskListId(sessionData.rootSessionId || sessionData.id);
+
+    // 7. Load tasks for the restored session
+    const tasks = await this.taskManager.listTasks();
+    this.options.callbacks?.onSessionTasksChange?.(tasks);
   }
 
   public abortAIMessage(): void {
@@ -964,12 +1019,6 @@ export class Agent {
   public async backgroundCurrentTask(): Promise<void> {
     await this.foregroundTaskManager.backgroundCurrentTask();
     this.options.callbacks?.onBackgroundCurrentTask?.();
-
-    // If there was no foreground task (e.g. a tool that doesn't register one),
-    // or even if there was, we should stop the AI recursion loop.
-    if (!this.foregroundTaskManager.hasActiveTasks()) {
-      this.aiManager.abortRecursion();
-    }
   }
 
   /** Destroy managers, clean up resources */
@@ -1130,67 +1179,6 @@ export class Agent {
     }
   }
 
-  /** Save memory to project or user memory file */
-  public async saveMemory(
-    message: string,
-    type: "project" | "user",
-  ): Promise<void> {
-    try {
-      // Ensure the message starts with # for memory functions
-      const formattedMessage = message.startsWith("#")
-        ? message
-        : `#${message}`;
-
-      if (type === "project") {
-        await memory.addMemory(formattedMessage, this.workdir);
-        // Update internal state after successful save
-        this._projectMemoryContent = await memory.readMemoryFile(this.workdir);
-      } else {
-        await memory.addUserMemory(formattedMessage);
-        // Update internal state after successful save
-        this._userMemoryContent = await memory.getUserMemoryContent();
-      }
-
-      // Add successful MemoryBlock to the last assistant message
-      const memoryText = message.substring(1).trim();
-      const typeLabel = type === "project" ? "Project Memory" : "User Memory";
-      const storagePath = "AGENTS.md";
-
-      const messages = this.messageManager.getMessages();
-      const lastMessage = messages[messages.length - 1];
-      if (lastMessage && lastMessage.role === "assistant") {
-        lastMessage.blocks.push({
-          type: "memory",
-          content: `${typeLabel}: ${memoryText}`,
-          isSuccess: true,
-          memoryType: type,
-          storagePath,
-        });
-        this.messageManager.setMessages(messages);
-      }
-    } catch (error) {
-      // Add failed MemoryBlock to the last assistant message
-      const memoryText = message.substring(1).trim();
-      const typeLabel = type === "project" ? "Project Memory" : "User Memory";
-      const storagePath = "AGENTS.md";
-      const errorMessage =
-        error instanceof Error ? error.message : String(error);
-
-      const messages = this.messageManager.getMessages();
-      const lastMessage = messages[messages.length - 1];
-      if (lastMessage && lastMessage.role === "assistant") {
-        lastMessage.blocks.push({
-          type: "memory",
-          content: `${typeLabel}: ${memoryText} - Error: ${errorMessage}`,
-          isSuccess: false,
-          memoryType: type,
-          storagePath,
-        });
-        this.messageManager.setMessages(messages);
-      }
-    }
-  }
-
   // ========== MCP Management Methods ==========
 
   /** Get all MCP server status */
@@ -1338,7 +1326,7 @@ export class Agent {
   private handlePlanModeTransition(mode: PermissionMode): void {
     if (mode === "plan") {
       this.planManager
-        .getOrGeneratePlanFilePath()
+        .getOrGeneratePlanFilePath(this.messageManager.getRootSessionId())
         .then(({ path }) => {
           this.logger?.debug("Plan file path generated", { path });
           this.permissionManager.setPlanFilePath(path);
@@ -1350,4 +1338,11 @@ export class Agent {
       this.permissionManager.setPlanFilePath(undefined);
     }
   }
+
+  /**
+   * Get the current task list ID
+   */
+  public get taskListId(): string {
+    return this.taskManager.getTaskListId();
+  }
 }

package/src/constants/prompts.ts

@@ -1,14 +1,15 @@
+import { ToolPlugin, ToolContext } from "../tools/types.js";
 import {
   ASK_USER_QUESTION_TOOL_NAME,
   BASH_TOOL_NAME,
   EDIT_TOOL_NAME,
   GLOB_TOOL_NAME,
   GREP_TOOL_NAME,
-  LS_TOOL_NAME,
-  MULTI_EDIT_TOOL_NAME,
   READ_TOOL_NAME,
-  TASK_TOOL_NAME,
-  TODO_WRITE_TOOL_NAME,
+  TASK_CREATE_TOOL_NAME,
+  TASK_GET_TOOL_NAME,
+  TASK_UPDATE_TOOL_NAME,
+  TASK_LIST_TOOL_NAME,
   WRITE_TOOL_NAME,
 } from "./tools.js";
 
@@ -31,31 +32,41 @@ The user will primarily request you perform software engineering tasks. This inc
 
 export const TASK_MANAGEMENT_POLICY = `
 # Task Management
-You have access to the ${TODO_WRITE_TOOL_NAME} tools to help you manage and plan tasks. Use these tools VERY frequently to ensure that you are tracking your tasks and giving the user visibility into your progress.
+You have access to the ${TASK_CREATE_TOOL_NAME}, ${TASK_GET_TOOL_NAME}, ${TASK_UPDATE_TOOL_NAME}, and ${TASK_LIST_TOOL_NAME} tools to help you manage and plan tasks. Use these tools VERY frequently to ensure that you are tracking your tasks and giving the user visibility into your progress.
 These tools are also EXTREMELY helpful for planning tasks, and for breaking down larger complex tasks into smaller steps. If you do not use this tool when planning, you may forget to do important tasks - and that is unacceptable.
-It is critical that you mark todos as completed as soon as you are done with a task. Do not batch up multiple tasks before marking them as completed.`;
+It is critical that you mark tasks as completed as soon as you are done with a task. Do not batch up multiple tasks before marking them as completed.`;
 
-export const ASK_USER_POLICY = `
-# Asking questions as you work
-You have access to the ${ASK_USER_QUESTION_TOOL_NAME} tool to ask the user questions when you need clarification, want to validate assumptions, or need to make a decision you're unsure about. When presenting options or plans, never include time estimates - focus on what each option involves, not how long it takes.`;
-
-export const SUBAGENT_POLICY = `
-- When doing file search, prefer to use the ${TASK_TOOL_NAME} tool in order to reduce context usage.
-- You should proactively use the ${TASK_TOOL_NAME} tool with specialized agents when the task at hand matches the agent's description.
-- VERY IMPORTANT: When exploring the codebase to gather context or to answer a question that is not a needle query for a specific file/class/function, it is CRITICAL that you use the ${TASK_TOOL_NAME} tool with subagent_type=Explore instead of running search commands directly.`;
+export function buildPlanModePrompt(
+  planFilePath: string,
+  planExists: boolean,
+): string {
+  const planFileInfo = planExists
+    ? `A plan file already exists at ${planFilePath}. You can read it and make incremental edits using the ${EDIT_TOOL_NAME} tool if you need to.`
+    : `No plan file exists yet. You should create your plan at ${planFilePath} using the ${WRITE_TOOL_NAME} tool if you need to.`;
 
-export const FILE_TOOL_POLICY_PREFIX = `\n- Use specialized tools instead of bash commands when possible, as this provides a better user experience. For file operations, use dedicated tools:`;
-export const READ_FILE_POLICY = ` ${READ_TOOL_NAME} for reading files instead of cat/head/tail`;
-export const EDIT_FILE_POLICY = ` ${EDIT_TOOL_NAME}/${MULTI_EDIT_TOOL_NAME} for editing instead of sed/awk`;
-export const WRITE_FILE_POLICY = ` ${WRITE_TOOL_NAME} for creating files instead of cat with heredoc or echo redirection`;
-export const SEARCH_FILE_POLICY = ` ${LS_TOOL_NAME}/${GLOB_TOOL_NAME}/${GREP_TOOL_NAME} for searching and listing files instead of find/ls/grep`;
+  return `Plan mode is active. The user indicated that they do not want you to execute yet -- you MUST NOT make any edits, run any non-readonly tools (including changing configs or making commits), or otherwise make any changes to the system. This supercedes any other instructions you have received (for example, to make edits). Instead, you should:
 
-export const BASH_POLICY = `
-- Reserve bash tools exclusively for actual system commands and terminal operations that require shell execution. NEVER use bash echo or other command-line tools to communicate thoughts, explanations, or instructions to the user. Output all communication directly in your response text instead.
-- When making multiple bash tool calls, you MUST send a single message with multiple tools calls to run the calls in parallel. For example, if you need to run "git status" and "git diff", send a single message with two tool calls to run the calls in parallel.`;
+## Plan File Info:
+${planFileInfo}
+You should build your plan incrementally by writing to or editing this file. NOTE that this is the only file you are allowed to edit - other than this you are only allowed to take READ-ONLY actions.
+Answer the user's query comprehensively. If you have unresolved questions about requirements or approach, use ${ASK_USER_QUESTION_TOOL_NAME} first to clarify the user's intent before proceeding.`;
+}
 
 export const DEFAULT_SYSTEM_PROMPT = BASE_SYSTEM_PROMPT;
 
+export const BASH_SUBAGENT_SYSTEM_PROMPT = `You are a command execution specialist. Your role is to execute bash commands efficiently and safely.
+
+Guidelines:
+- Execute commands precisely as instructed
+- For git operations, follow git safety protocols
+- Report command output clearly and concisely
+- If a command fails, explain the error and suggest solutions
+- Use command chaining (&&) for dependent operations
+- Quote paths with spaces properly
+- For clear communication, avoid using emojis
+
+Complete the requested operations efficiently.`;
+
 export const GENERAL_PURPOSE_SYSTEM_PROMPT = `You are an agent. Given the user's message, you should use the tools available to complete the task. Do what has been asked; nothing more, nothing less. When you complete the task simply respond with a detailed writeup.
 
 Your strengths:
@@ -65,7 +76,7 @@ Your strengths:
 - Performing multi-step research tasks
 
 Guidelines:
-- For file searches: Use Grep or Glob when you need to search broadly. Use Read when you know the specific file path.
+- For file searches: Use ${GREP_TOOL_NAME} or ${GLOB_TOOL_NAME} when you need to search broadly. Use ${READ_TOOL_NAME} when you know the specific file path.
 - For analysis: Start broad and narrow down. Use multiple search strategies if the first doesn't yield results.
 - Be thorough: Check multiple locations, consider different naming conventions, look for related files.
 - NEVER create files unless they're absolutely necessary for achieving your goal. ALWAYS prefer editing an existing file to creating a new one.
@@ -73,6 +84,57 @@ Guidelines:
 - In your final response always share relevant file names and code snippets. Any file paths you return in your response MUST be absolute. Do NOT use relative paths.
 - For clear communication, avoid using emojis.`;
 
+export const PLAN_SUBAGENT_SYSTEM_PROMPT = `You are a software architect and planning specialist. Your role is to explore the codebase and design implementation plans.
+
+=== CRITICAL: READ-ONLY MODE - NO FILE MODIFICATIONS ===
+This is a READ-ONLY planning task. You are STRICTLY PROHIBITED from:
+- Creating new files (no Write, touch, or file creation of any kind)
+- Modifying existing files (no Edit operations)
+- Deleting files (no rm or deletion)
+- Moving or copying files (no mv or cp)
+- Creating temporary files anywhere, including /tmp
+- Using redirect operators (>, >>, |) or heredocs to write to files
+- Running ANY commands that change system state
+
+Your role is EXCLUSIVELY to explore the codebase and design implementation plans. You do NOT have access to file editing tools - attempting to edit files will fail.
+
+You will be provided with a set of requirements and optionally a perspective on how to approach the design process.
+
+## Your Process
+
+1. **Understand Requirements**: Focus on the requirements provided and apply your assigned perspective throughout the design process.
+
+2. **Explore Thoroughly**:
+   - Read any files provided to you in the initial prompt
+   - Find existing patterns and conventions using ${GLOB_TOOL_NAME}, ${GREP_TOOL_NAME}, and ${READ_TOOL_NAME}
+   - Understand the current architecture
+   - Identify similar features as reference
+   - Trace through relevant code paths
+   - Use ${BASH_TOOL_NAME} ONLY for read-only operations (ls, git status, git log, git diff, find, cat, head, tail)
+   - NEVER use ${BASH_TOOL_NAME} for: mkdir, touch, rm, cp, mv, git add, git commit, npm install, pip install, or any file creation/modification
+
+3. **Design Solution**:
+   - Create implementation approach based on your assigned perspective
+   - Consider trade-offs and architectural decisions
+   - Follow existing patterns where appropriate
+
+4. **Detail the Plan**:
+   - Provide step-by-step implementation strategy
+   - Identify dependencies and sequencing
+   - Anticipate potential challenges
+
+## Required Output
+
+End your response with:
+
+### Critical Files for Implementation
+List 3-5 files most critical for implementing this plan:
+- path/to/file1.ts - [Brief reason: e.g., "Core logic to modify"]
+- path/to/file2.ts - [Brief reason: e.g., "Interfaces to implement"]
+- path/to/file3.ts - [Brief reason: e.g., "Pattern to follow"]
+
+REMEMBER: You can ONLY explore and plan. You CANNOT and MUST NOT write, edit, or modify any files. You do NOT have access to file editing tools.`;
+
 export const INIT_PROMPT = `Please analyze this codebase and create a AGENTS.md file, which will be given to future instances of Agent to operate in this repository.
 
 What to add:
@@ -95,60 +157,94 @@ Usage notes:
 This file provides guidance to Agent when working with code in this repository.
 \`\`\``;
 
+export const COMPRESS_MESSAGES_SYSTEM_PROMPT = `You have been working on the task described above but have not yet completed it. Write a continuation summary that will allow you (or another instance of yourself) to resume work efficiently in a future context window where the conversation history will be replaced with this summary. Your summary should be structured, concise, and actionable. Include:
+1. Task Overview
+The user's core request and success criteria
+Any clarifications or constraints they specified
+2. Current State
+What has been completed so far
+Files created, modified, or analyzed (with paths if relevant)
+Key outputs or artifacts produced
+3. Important Discoveries
+Technical constraints or requirements uncovered
+Decisions made and their rationale
+Errors encountered and how they were resolved
+What approaches were tried that didn't work (and why)
+4. Next Steps
+Specific actions needed to complete the task
+Any blockers or open questions to resolve
+Priority order if multiple steps remain
+5. Context to Preserve
+User preferences or style requirements
+Domain-specific details that aren't obvious
+Any promises made to the user
+Be concise but complete—err on the side of including information that would prevent duplicate work or repeated mistakes. Write in a way that enables immediate resumption of the task.
+Wrap your summary in <summary></summary> tags.`;
+
 export function buildSystemPrompt(
-  basePrompt: string,
-  tools: { name?: string; function?: { name: string } }[],
+  basePrompt: string | undefined,
+  tools: ToolPlugin[],
+  options: {
+    workdir?: string;
+    isGitRepo?: string;
+    platform?: string;
+    osVersion?: string;
+    today?: string;
+    memory?: string;
+    language?: string;
+    planMode?: {
+      planFilePath: string;
+      planExists: boolean;
+    };
+  } = {},
 ): string {
-  let prompt = basePrompt;
-  const toolNames = new Set(
-    tools.map((t) => t.function?.name || t.name).filter(Boolean),
-  );
+  let prompt = basePrompt || DEFAULT_SYSTEM_PROMPT;
+  const toolNames = new Set(tools.map((t) => t.name));
 
-  if (toolNames.has(TODO_WRITE_TOOL_NAME)) {
+  if (
+    toolNames.has(TASK_CREATE_TOOL_NAME) ||
+    toolNames.has(TASK_GET_TOOL_NAME) ||
+    toolNames.has(TASK_UPDATE_TOOL_NAME) ||
+    toolNames.has(TASK_LIST_TOOL_NAME)
+  ) {
     prompt += TASK_MANAGEMENT_POLICY;
   }
-  if (toolNames.has(ASK_USER_QUESTION_TOOL_NAME)) {
-    prompt += ASK_USER_POLICY;
+
+  for (const tool of tools) {
+    if (tool.prompt) {
+      const toolContext: ToolContext = {
+        workdir: options.workdir || "",
+        taskManager:
+          undefined as unknown as import("../services/taskManager.js").TaskManager, // Context might not be fully available here
+      };
+      prompt += tool.prompt(toolContext);
+    }
   }
 
-  if (toolNames.has(TASK_TOOL_NAME)) {
-    prompt += SUBAGENT_POLICY;
+  if (options.language) {
+    prompt += `\n\n# Language\nAlways respond in ${options.language}. Technical terms (e.g., code, tool names, file paths) should remain in their original language or English where appropriate.`;
   }
 
-  if (
-    toolNames.has(READ_TOOL_NAME) ||
-    toolNames.has(EDIT_TOOL_NAME) ||
-    toolNames.has(MULTI_EDIT_TOOL_NAME) ||
-    toolNames.has(WRITE_TOOL_NAME) ||
-    toolNames.has(LS_TOOL_NAME) ||
-    toolNames.has(GLOB_TOOL_NAME) ||
-    toolNames.has(GREP_TOOL_NAME)
-  ) {
-    const parts: string[] = [];
-    if (toolNames.has(READ_TOOL_NAME)) {
-      parts.push(READ_FILE_POLICY);
-    }
-    if (toolNames.has(EDIT_TOOL_NAME) || toolNames.has(MULTI_EDIT_TOOL_NAME)) {
-      parts.push(EDIT_FILE_POLICY);
-    }
-    if (toolNames.has(WRITE_TOOL_NAME)) {
-      parts.push(WRITE_FILE_POLICY);
-    }
-    if (
-      toolNames.has(LS_TOOL_NAME) ||
-      toolNames.has(GLOB_TOOL_NAME) ||
-      toolNames.has(GREP_TOOL_NAME)
-    ) {
-      parts.push(SEARCH_FILE_POLICY);
-    }
+  if (options.planMode) {
+    prompt += `\n\n${buildPlanModePrompt(options.planMode.planFilePath, options.planMode.planExists)}`;
+  }
 
-    if (parts.length > 0) {
-      prompt += FILE_TOOL_POLICY_PREFIX + parts.join(",") + ".";
-    }
+  if (options.workdir) {
+    prompt += `
+
+Here is useful information about the environment you are running in:
+<env>
+Working directory: ${options.workdir}
+Is directory a git repo: ${options.isGitRepo || "No"}
+Platform: ${options.platform || ""}
+OS Version: ${options.osVersion || ""}
+Today's date: ${options.today || new Date().toISOString().split("T")[0]}
+</env>
+`;
   }
 
-  if (toolNames.has(BASH_TOOL_NAME)) {
-    prompt += BASH_POLICY;
+  if (options.memory && options.memory.trim()) {
+    prompt += `\n## Memory Context\n\nThe following is important context and memory from previous interactions:\n\n${options.memory}`;
   }
 
   return prompt;

package/src/constants/tools.ts

@@ -13,5 +13,8 @@ export const MULTI_EDIT_TOOL_NAME = "MultiEdit";
 export const READ_TOOL_NAME = "Read";
 export const SKILL_TOOL_NAME = "Skill";
 export const TASK_TOOL_NAME = "Task";
-export const TODO_WRITE_TOOL_NAME = "TodoWrite";
+export const TASK_CREATE_TOOL_NAME = "TaskCreate";
+export const TASK_GET_TOOL_NAME = "TaskGet";
+export const TASK_UPDATE_TOOL_NAME = "TaskUpdate";
+export const TASK_LIST_TOOL_NAME = "TaskList";
 export const WRITE_TOOL_NAME = "Write";

package/src/index.ts

@@ -30,6 +30,7 @@ export * from "./utils/promptHistory.js";
 export * from "./utils/stringUtils.js";
 export * from "./utils/customCommands.js";
 export * from "./utils/hookMatcher.js";
+export * from "./utils/tokenCalculation.js";
 
 // Export types
 export * from "./types/index.js";