@zhijiewang/openharness 2.0.0 → 2.3.0

package/dist/tools/ScheduleWakeupTool/index.d.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import type { Tool } from "../../Tool.js";
+declare const inputSchema: z.ZodObject<{
+    delaySeconds: z.ZodNumber;
+    reason: z.ZodString;
+    prompt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    prompt: string;
+    reason: string;
+    delaySeconds: number;
+}, {
+    prompt: string;
+    reason: string;
+    delaySeconds: number;
+}>;
+/**
+ * Pending wakeup state — consumed by the REPL loop to schedule the next iteration.
+ */
+export type PendingWakeup = {
+    delaySeconds: number;
+    reason: string;
+    prompt: string;
+    scheduledAt: number;
+};
+/** Called by the REPL to check if a wakeup was scheduled */
+export declare function consumeWakeup(): PendingWakeup | null;
+/** Cancel any pending wakeup */
+export declare function cancelWakeup(): void;
+/** Check if there's a pending wakeup without consuming it */
+export declare function hasPendingWakeup(): boolean;
+/**
+ * Suggest an optimal delay based on what you're waiting for.
+ * Returns a delay in seconds that respects cache TTL boundaries.
+ *
+ * @param estimatedWaitSeconds - How long you think the thing will take
+ * @param isIdle - True if there's nothing specific to check, just periodic polling
+ * @returns Recommended delay in seconds
+ */
+export declare function suggestDelay(estimatedWaitSeconds: number, isIdle?: boolean): number;
+export declare const ScheduleWakeupTool: Tool<typeof inputSchema>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/ScheduleWakeupTool/index.js

@@ -0,0 +1,115 @@
+import { z } from "zod";
+/** Prompt cache TTL in seconds (Anthropic's ephemeral cache) */
+const CACHE_TTL = 300;
+/** Maximum warm-cache delay — stay under TTL with margin */
+const CACHE_WARM_MAX = 270;
+const inputSchema = z.object({
+    delaySeconds: z.number().describe("Seconds from now to wake up. Clamped to [60, 3600]."),
+    reason: z.string().describe("One short sentence explaining the chosen delay. Shown to the user."),
+    prompt: z
+        .string()
+        .describe("The /loop prompt to fire on wake-up. Pass the same prompt each turn to continue the loop. Omit to end the loop."),
+});
+let pendingWakeup = null;
+/** Called by the REPL to check if a wakeup was scheduled */
+export function consumeWakeup() {
+    const w = pendingWakeup;
+    pendingWakeup = null;
+    return w;
+}
+/** Cancel any pending wakeup */
+export function cancelWakeup() {
+    pendingWakeup = null;
+}
+/** Check if there's a pending wakeup without consuming it */
+export function hasPendingWakeup() {
+    return pendingWakeup !== null;
+}
+/**
+ * Suggest an optimal delay based on what you're waiting for.
+ * Returns a delay in seconds that respects cache TTL boundaries.
+ *
+ * @param estimatedWaitSeconds - How long you think the thing will take
+ * @param isIdle - True if there's nothing specific to check, just periodic polling
+ * @returns Recommended delay in seconds
+ */
+export function suggestDelay(estimatedWaitSeconds, isIdle = false) {
+    if (isIdle) {
+        // Idle polling: 20-30 min range. One cache miss, long amortization.
+        return 1200;
+    }
+    if (estimatedWaitSeconds <= CACHE_WARM_MAX) {
+        // Short wait: stay in cache window. Round up to at least 60s.
+        return Math.max(60, Math.min(CACHE_WARM_MAX, Math.round(estimatedWaitSeconds)));
+    }
+    if (estimatedWaitSeconds <= CACHE_TTL) {
+        // Awkward zone: would barely miss cache. Drop to warm max.
+        return CACHE_WARM_MAX;
+    }
+    if (estimatedWaitSeconds <= 600) {
+        // 5-10 min: commit to the cache miss, wait the full estimated time.
+        return Math.round(estimatedWaitSeconds);
+    }
+    // Longer waits: cap at estimated time, but don't exceed 3600.
+    return Math.min(3600, Math.round(estimatedWaitSeconds));
+}
+/**
+ * Classify a delay into a cache-awareness category.
+ */
+function classifyDelay(delay) {
+    if (delay <= CACHE_WARM_MAX) {
+        return { zone: "warm", note: "prompt cache stays warm" };
+    }
+    if (delay > CACHE_WARM_MAX && delay <= CACHE_TTL + 30) {
+        return {
+            zone: "boundary",
+            note: `~5min cache TTL boundary — consider ${CACHE_WARM_MAX}s (warm) or 1200s+ (amortized cold)`,
+        };
+    }
+    const missCount = Math.floor(delay / CACHE_TTL);
+    return { zone: "cold", note: `cache miss expected (${missCount > 1 ? `${missCount} windows` : "once"})` };
+}
+export const ScheduleWakeupTool = {
+    name: "ScheduleWakeup",
+    description: "Schedule when to resume work in /loop dynamic mode. The model self-paces iterations of a recurring task.",
+    inputSchema,
+    riskLevel: "low",
+    isReadOnly() {
+        return true;
+    },
+    isConcurrencySafe() {
+        return true;
+    },
+    async call(input, _context) {
+        // Clamp delay to [60, 3600]
+        const delay = Math.max(60, Math.min(3600, Math.round(input.delaySeconds)));
+        pendingWakeup = {
+            delaySeconds: delay,
+            reason: input.reason,
+            prompt: input.prompt,
+            scheduledAt: Date.now(),
+        };
+        const { zone, note } = classifyDelay(delay);
+        const icon = zone === "warm" ? "cache:warm" : zone === "boundary" ? "cache:boundary" : "cache:cold";
+        return {
+            output: `Wakeup scheduled in ${delay}s [${icon}] (${note})\nReason: ${input.reason}`,
+            isError: false,
+        };
+    },
+    prompt() {
+        return `ScheduleWakeup: Schedule when to resume work in /loop dynamic mode.
+
+The prompt cache has a ${CACHE_TTL}s (5-minute) TTL. Choose delays with cache in mind:
+- 60-${CACHE_WARM_MAX}s: cache stays warm. For active work — checking builds, polling state changes.
+- AVOID ~${CACHE_TTL}s: you pay the cache miss without amortizing it. Drop to ${CACHE_WARM_MAX}s or commit to 1200s+.
+- 1200-1800s (20-30min): ideal for idle ticks. One cache miss buys a long wait.
+
+Think about what you're waiting for, not round numbers. If a build takes ~8 min, sleep ${CACHE_WARM_MAX}s twice rather than 60s eight times.
+
+Parameters:
+- delaySeconds: 60-3600. Clamped by runtime.
+- reason: Short sentence shown to user (e.g., "checking build output").
+- prompt: The /loop prompt to repeat. Pass the same prompt each turn to continue. Omit the ScheduleWakeup call to end the loop.`;
+    },
+};
+//# sourceMappingURL=index.js.map

package/dist/tools/SendMessageTool/index.js

@@ -1,29 +1,47 @@
 import { z } from "zod";
 import { getMessageBus } from "../../services/agent-messaging.js";
 const inputSchema = z.object({
-    to: z.string().describe("Target agent ID, or '*' for broadcast"),
+    to: z
+        .string()
+        .describe("Target agent ID or name, or '*' for broadcast. Use a background agent's ID to send it a message."),
     content: z.string().describe("Message content"),
     type: z.enum(["request", "response", "status", "error"]).optional(),
 });
 export const SendMessageTool = {
     name: "SendMessage",
-    description: "Send a message to another agent. Use for coordination in multi-agent workflows.",
+    description: "Send a message to another agent. Use for coordination in multi-agent workflows. Can target background agents by ID.",
     inputSchema,
     riskLevel: "low",
-    isReadOnly() { return true; },
-    isConcurrencySafe() { return true; },
+    isReadOnly() {
+        return true;
+    },
+    isConcurrencySafe() {
+        return true;
+    },
     async call(input) {
         const bus = getMessageBus();
+        // Check if target is a background agent
+        const bgAgent = bus.getBackgroundAgent(input.to);
+        if (bgAgent) {
+            bus.sendToBackgroundAgent(input.to, input.content);
+            const statusInfo = bgAgent.status === "completed"
+                ? `Agent completed. Result: ${bgAgent.result?.slice(0, 500) ?? "(no result)"}${(bgAgent.result?.length ?? 0) > 500 ? "..." : ""}`
+                : bgAgent.status === "error"
+                    ? `Agent errored: ${bgAgent.result ?? "unknown error"}`
+                    : `Agent still running (started ${Math.round((Date.now() - bgAgent.startedAt) / 1000)}s ago)`;
+            return { output: `Message queued for background agent ${input.to}.\nStatus: ${statusInfo}`, isError: false };
+        }
+        // Standard agent messaging
         bus.send({
-            from: 'lead',
+            from: "lead",
             to: input.to,
-            type: input.type ?? 'request',
+            type: input.type ?? "request",
             content: input.content,
         });
         return { output: `Message sent to ${input.to}`, isError: false };
     },
     prompt() {
-        return "SendMessage: Send messages to other agents for coordination. Use to: '*' for broadcast.";
+        return "SendMessage: Send messages to other agents for coordination. Use to: '*' for broadcast, or use a background agent's ID to query its status and send follow-up messages.";
     },
 };
 //# sourceMappingURL=index.js.map

package/dist/tools/SessionSearchTool/index.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import type { Tool } from "../../Tool.js";
+declare const inputSchema: z.ZodObject<{
+    query: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+    limit?: number | undefined;
+}, {
+    query: string;
+    limit?: number | undefined;
+}>;
+export declare const SessionSearchTool: Tool<typeof inputSchema>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/SessionSearchTool/index.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { getSessionDb, searchSessions } from "../../harness/session-db.js";
+const inputSchema = z.object({
+    query: z.string().describe("Search query — keywords or phrases to find in past sessions"),
+    limit: z.number().optional().describe("Max results to return (default: 5)"),
+});
+export const SessionSearchTool = {
+    name: "SessionSearch",
+    description: "Search past sessions for relevant context. Use when the current task seems related to previous work.",
+    inputSchema,
+    riskLevel: "low",
+    isReadOnly() {
+        return true;
+    },
+    isConcurrencySafe() {
+        return true;
+    },
+    async call(input, _context) {
+        try {
+            const db = getSessionDb();
+            const results = searchSessions(db, input.query, input.limit ?? 5);
+            if (results.length === 0) {
+                return { output: `No matching sessions found for "${input.query}".`, isError: false };
+            }
+            const lines = results.map((r, i) => `${i + 1}. [${r.sessionId}] ${r.model} (${r.messageCount} msgs, $${r.cost.toFixed(3)})\n   ${r.snippet}`);
+            return { output: `Found ${results.length} matching session(s):\n\n${lines.join("\n\n")}`, isError: false };
+        }
+        catch (err) {
+            return { output: `Session search failed: ${err instanceof Error ? err.message : String(err)}`, isError: true };
+        }
+    },
+    prompt() {
+        return "SessionSearch: Search past sessions for relevant context using full-text search. Use when the current task may relate to previous work. Returns snippets from matching sessions ranked by relevance.";
+    },
+};
+//# sourceMappingURL=index.js.map

package/dist/tools/SkillTool/index.d.ts

@@ -3,11 +3,14 @@ import type { Tool } from "../../Tool.js";
 declare const inputSchema: z.ZodObject<{
     skill: z.ZodString;
     args: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     skill: string;
+    path?: string | undefined;
     args?: string | undefined;
 }, {
     skill: string;
+    path?: string | undefined;
     args?: string | undefined;
 }>;
 export declare const SkillTool: Tool<typeof inputSchema>;

package/dist/tools/SkillTool/index.js

@@ -1,44 +1,74 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
 import { z } from "zod";
-import { findSkill, discoverSkills } from "../../harness/plugins.js";
+import { discoverSkills, findSkill } from "../../harness/plugins.js";
 const inputSchema = z.object({
     skill: z.string(),
     args: z.string().optional(),
+    path: z.string().optional().describe("Path to a supporting file within the skill directory (Level 2)"),
 });
 export const SkillTool = {
     name: "Skill",
     description: "Execute a skill by loading its definition from project or global skills.",
     inputSchema,
     riskLevel: "low",
-    isReadOnly() { return true; },
-    isConcurrencySafe() { return false; },
-    async call(input, context) {
+    isReadOnly() {
+        return true;
+    },
+    isConcurrencySafe() {
+        return false;
+    },
+    async call(input, _context) {
         // Path traversal protection
         if (input.skill.includes("..") || input.skill.includes("/") || input.skill.includes("\\")) {
             return { output: "Error: Invalid skill name.", isError: true };
         }
+        // Early path traversal check for Level 2
+        if (input.path && input.path.includes("..")) {
+            return { output: "Error: Path traversal not allowed.", isError: true };
+        }
         // List skills if "list" or "ls"
         if (input.skill === "list" || input.skill === "ls") {
             const skills = discoverSkills();
             if (skills.length === 0)
                 return { output: "No skills found. Create .oh/skills/*.md to add skills.", isError: false };
-            const lines = skills.map(s => `${s.name.padEnd(20)} [${s.source}] ${s.description.slice(0, 50)}`);
-            return { output: lines.join('\n'), isError: false };
+            const lines = skills.map((s) => `${s.name.padEnd(20)} [${s.source}] ${s.description.slice(0, 50)}`);
+            return { output: lines.join("\n"), isError: false };
         }
         // Find skill across all sources
         const skill = findSkill(input.skill);
         if (!skill) {
-            const available = discoverSkills().map(s => s.name).join(', ');
+            const available = discoverSkills()
+                .map((s) => s.name)
+                .join(", ");
             return {
-                output: `Error: Skill "${input.skill}" not found.${available ? ` Available: ${available}` : ' Create .oh/skills/*.md to add skills.'}`,
+                output: `Error: Skill "${input.skill}" not found.${available ? ` Available: ${available}` : " Create .oh/skills/*.md to add skills."}`,
                 isError: true,
             };
         }
+        // Level 2: supporting file access
+        if (input.path) {
+            const skillDir = resolve(skill.filePath.replace(/\.md$/, ""));
+            const filePath = resolve(skillDir, input.path);
+            // Block path traversal via absolute paths, .., or any escape from skillDir
+            if (!filePath.startsWith(skillDir)) {
+                return { output: "Error: Path traversal not allowed.", isError: true };
+            }
+            try {
+                const content = readFileSync(filePath, "utf-8");
+                return { output: content, isError: false };
+            }
+            catch {
+                return { output: `File not found: ${input.path} (looked in ${skillDir}/)`, isError: true };
+            }
+        }
         return { output: skill.content, isError: false };
     },
     prompt() {
         return `Execute a skill by loading its definition. Skills are searched in .oh/skills/ (project) and ~/.oh/skills/ (global). Parameters:
 - skill (string, required): The skill name (or "list" to see available skills).
-- args (string, optional): Arguments to pass to the skill.`;
+- args (string, optional): Arguments to pass to the skill.
+- path (string, optional): Path to a supporting file within the skill's directory (for reference docs, scripts, templates).`;
     },
 };
 //# sourceMappingURL=index.js.map

package/dist/tools/TaskCreateTool/index.d.ts

@@ -8,13 +8,13 @@ declare const inputSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     description: string;
     subject: string;
-    activeForm?: string | undefined;
     metadata?: Record<string, unknown> | undefined;
+    activeForm?: string | undefined;
 }, {
     description: string;
     subject: string;
-    activeForm?: string | undefined;
     metadata?: Record<string, unknown> | undefined;
+    activeForm?: string | undefined;
 }>;
 export declare const TaskCreateTool: Tool<typeof inputSchema>;
 export {};

package/dist/tools/TaskCreateTool/index.js

@@ -1,6 +1,6 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { z } from "zod";
-import * as fs from "fs/promises";
-import * as path from "path";
 const inputSchema = z.object({
     subject: z.string(),
     description: z.string(),

package/dist/tools/TaskGetTool/index.js

@@ -1,6 +1,6 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { z } from "zod";
-import * as fs from "fs/promises";
-import * as path from "path";
 const inputSchema = z.object({
     taskId: z.number(),
 });

package/dist/tools/TaskListTool/index.js

@@ -1,6 +1,6 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { z } from "zod";
-import * as fs from "fs/promises";
-import * as path from "path";
 const inputSchema = z.object({});
 export const TaskListTool = {
     name: "TaskList",
@@ -21,9 +21,7 @@ export const TaskListTool = {
             if (tasks.length === 0) {
                 return { output: "No tasks found.", isError: false };
             }
-            const output = tasks
-                .map((t) => `#${t.id} [${t.status}] ${t.subject}\n   ${t.description}`)
-                .join("\n\n");
+            const output = tasks.map((t) => `#${t.id} [${t.status}] ${t.subject}\n   ${t.description}`).join("\n\n");
             return { output, isError: false };
         }
         catch (err) {

package/dist/tools/TaskOutputTool/index.js

@@ -1,6 +1,6 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { z } from "zod";
-import * as fs from "fs/promises";
-import * as path from "path";
 const inputSchema = z.object({
     taskId: z.number(),
     output: z.string(),

package/dist/tools/TaskStopTool/index.js

@@ -1,6 +1,6 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { z } from "zod";
-import * as fs from "fs/promises";
-import * as path from "path";
 const inputSchema = z.object({
     taskId: z.number(),
     reason: z.string().optional(),
@@ -30,7 +30,7 @@ export const TaskStopTool = {
             }
             task.status = "cancelled";
             if (input.reason) {
-                task.output = (task.output ? task.output + "\n" : "") + `Cancelled: ${input.reason}`;
+                task.output = `${task.output ? `${task.output}\n` : ""}Cancelled: ${input.reason}`;
             }
             await fs.writeFile(filePath, JSON.stringify(tasks, null, 2), "utf-8");
             return { output: `Task #${task.id} cancelled.${input.reason ? ` Reason: ${input.reason}` : ""}`, isError: false };

package/dist/tools/TaskUpdateTool/index.d.ts

@@ -12,21 +12,21 @@ declare const inputSchema: z.ZodObject<{
     addBlockedBy: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
 }, "strip", z.ZodTypeAny, {
     taskId: number;
-    status?: "completed" | "pending" | "in_progress" | "cancelled" | "deleted" | undefined;
+    status?: "completed" | "pending" | "cancelled" | "in_progress" | "deleted" | undefined;
+    metadata?: Record<string, unknown> | undefined;
     description?: string | undefined;
     subject?: string | undefined;
     activeForm?: string | undefined;
-    metadata?: Record<string, unknown> | undefined;
     owner?: string | undefined;
     addBlocks?: number[] | undefined;
     addBlockedBy?: number[] | undefined;
 }, {
     taskId: number;
-    status?: "completed" | "pending" | "in_progress" | "cancelled" | "deleted" | undefined;
+    status?: "completed" | "pending" | "cancelled" | "in_progress" | "deleted" | undefined;
+    metadata?: Record<string, unknown> | undefined;
     description?: string | undefined;
     subject?: string | undefined;
     activeForm?: string | undefined;
-    metadata?: Record<string, unknown> | undefined;
     owner?: string | undefined;
     addBlocks?: number[] | undefined;
     addBlockedBy?: number[] | undefined;

package/dist/tools/TaskUpdateTool/index.js

@@ -1,6 +1,6 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { z } from "zod";
-import * as fs from "fs/promises";
-import * as path from "path";
 const inputSchema = z.object({
     taskId: z.number(),
     status: z.enum(["pending", "in_progress", "completed", "cancelled", "deleted"]).optional(),

package/dist/tools/ToolSearchTool/index.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
-import { DeferredMcpTool } from "../../mcp/DeferredMcpTool.js";
 import { DeferredTool } from "../../DeferredTool.js";
+import { DeferredMcpTool } from "../../mcp/DeferredMcpTool.js";
 const inputSchema = z.object({
     query: z.string().describe("Tool name or keyword to search for"),
     maxResults: z.number().optional().default(5).describe("Maximum results to return"),
@@ -10,16 +10,19 @@ export const ToolSearchTool = {
     description: "Search for available tools by name or keyword. Resolves deferred MCP tool schemas.",
     inputSchema,
     riskLevel: "low",
-    isReadOnly() { return true; },
-    isConcurrencySafe() { return true; },
+    isReadOnly() {
+        return true;
+    },
+    isConcurrencySafe() {
+        return true;
+    },
     async call(input, context) {
         const allTools = context.tools ?? [];
         const query = input.query.toLowerCase();
         const max = input.maxResults ?? 5;
         // Search by name or description
         const matches = allTools
-            .filter(t => t.name.toLowerCase().includes(query) ||
-            t.description.toLowerCase().includes(query))
+            .filter((t) => t.name.toLowerCase().includes(query) || t.description.toLowerCase().includes(query))
             .slice(0, max);
         if (matches.length === 0) {
             return { output: `No tools found matching "${input.query}".`, isError: false };
@@ -46,7 +49,7 @@ export const ToolSearchTool = {
                 results.push(`${tool.name}: ${tool.prompt().slice(0, 200)}`);
             }
         }
-        return { output: results.join('\n\n'), isError: false };
+        return { output: results.join("\n\n"), isError: false };
     },
     prompt() {
         return `Search for available tools by name or keyword. Use this to discover MCP tools and resolve their schemas before calling them. Parameters:

package/dist/tools/WebFetchTool/index.js

@@ -86,7 +86,7 @@ export const WebFetchTool = {
                 text = stripHtml(text);
             }
             if (text.length > MAX_OUTPUT) {
-                text = text.slice(0, MAX_OUTPUT) + "\n... [truncated]";
+                text = `${text.slice(0, MAX_OUTPUT)}\n... [truncated]`;
             }
             return { output: text, isError: false };
         }

package/dist/tools/WebSearchTool/index.js

@@ -39,9 +39,7 @@ export const WebSearchTool = {
                 const title = match[2].replace(/<[^>]*>/g, "").trim();
                 // DuckDuckGo wraps URLs in a redirect; extract the actual URL
                 const actualUrlMatch = rawUrl.match(/uddg=([^&]+)/);
-                const actualUrl = actualUrlMatch
-                    ? decodeURIComponent(actualUrlMatch[1])
-                    : rawUrl;
+                const actualUrl = actualUrlMatch ? decodeURIComponent(actualUrlMatch[1]) : rawUrl;
                 titles.push({ url: actualUrl, title });
             }
             const snippets = [];
@@ -58,9 +56,7 @@ export const WebSearchTool = {
             if (results.length === 0) {
                 return { output: "No results found.", isError: false };
             }
-            const output = results
-                .map((r, i) => `${i + 1}. ${r.title}\n   ${r.url}\n   ${r.snippet}`)
-                .join("\n\n");
+            const output = results.map((r, i) => `${i + 1}. ${r.title}\n   ${r.url}\n   ${r.snippet}`).join("\n\n");
             return { output, isError: false };
         }
         catch (err) {

package/dist/tools.js

@@ -6,44 +6,46 @@
  * activated via ToolSearch or first invocation.
  */
 import { DeferredTool } from "./DeferredTool.js";
+import { AgentTool } from "./tools/AgentTool/index.js";
+import { AskUserTool } from "./tools/AskUserTool/index.js";
 // Core tools — always fully loaded with complete prompts
 import { BashTool } from "./tools/BashTool/index.js";
+import { CronCreateTool, CronDeleteTool, CronListTool } from "./tools/CronTool/index.js";
+import { DiagnosticsTool } from "./tools/DiagnosticsTool/index.js";
+import { EnterPlanModeTool } from "./tools/EnterPlanModeTool/index.js";
+import { EnterWorktreeTool } from "./tools/EnterWorktreeTool/index.js";
+import { ExitPlanModeTool } from "./tools/ExitPlanModeTool/index.js";
+import { ExitWorktreeTool } from "./tools/ExitWorktreeTool/index.js";
+import { FileEditTool } from "./tools/FileEditTool/index.js";
 import { FileReadTool } from "./tools/FileReadTool/index.js";
 import { FileWriteTool } from "./tools/FileWriteTool/index.js";
-import { FileEditTool } from "./tools/FileEditTool/index.js";
 import { GlobTool } from "./tools/GlobTool/index.js";
 import { GrepTool } from "./tools/GrepTool/index.js";
+import { ImageReadTool } from "./tools/ImageReadTool/index.js";
+import { KillProcessTool } from "./tools/KillProcessTool/index.js";
 import { LSTool } from "./tools/LSTool/index.js";
-import { AskUserTool } from "./tools/AskUserTool/index.js";
-import { AgentTool } from "./tools/AgentTool/index.js";
-import { TaskCreateTool } from "./tools/TaskCreateTool/index.js";
-import { TaskUpdateTool } from "./tools/TaskUpdateTool/index.js";
-import { TaskListTool } from "./tools/TaskListTool/index.js";
-import { EnterPlanModeTool } from "./tools/EnterPlanModeTool/index.js";
-import { ExitPlanModeTool } from "./tools/ExitPlanModeTool/index.js";
-import { ToolSearchTool } from "./tools/ToolSearchTool/index.js";
 import { MemoryTool } from "./tools/MemoryTool/index.js";
-import { ImageReadTool } from "./tools/ImageReadTool/index.js";
-// Extended tools — deferred loading (minimal prompt until first use)
-import { WebFetchTool } from "./tools/WebFetchTool/index.js";
-import { WebSearchTool } from "./tools/WebSearchTool/index.js";
-import { TaskGetTool } from "./tools/TaskGetTool/index.js";
-import { TaskStopTool } from "./tools/TaskStopTool/index.js";
-import { TaskOutputTool } from "./tools/TaskOutputTool/index.js";
-import { SkillTool } from "./tools/SkillTool/index.js";
+import { MonitorTool } from "./tools/MonitorTool/index.js";
+import { MultiEditTool } from "./tools/MultiEditTool/index.js";
 import { NotebookEditTool } from "./tools/NotebookEditTool/index.js";
-import { DiagnosticsTool } from "./tools/DiagnosticsTool/index.js";
 import { ParallelAgentTool } from "./tools/ParallelAgentTool/index.js";
-import { SendMessageTool } from "./tools/SendMessageTool/index.js";
-import { CronCreateTool, CronDeleteTool, CronListTool } from "./tools/CronTool/index.js";
-import { EnterWorktreeTool } from "./tools/EnterWorktreeTool/index.js";
-import { ExitWorktreeTool } from "./tools/ExitWorktreeTool/index.js";
-import { KillProcessTool } from "./tools/KillProcessTool/index.js";
-import { RemoteTriggerTool } from "./tools/RemoteTriggerTool/index.js";
-import { MultiEditTool } from "./tools/MultiEditTool/index.js";
 import { PipelineTool } from "./tools/PipelineTool/index.js";
 import { PowerShellTool } from "./tools/PowerShellTool/index.js";
-import { MonitorTool } from "./tools/MonitorTool/index.js";
+import { RemoteTriggerTool } from "./tools/RemoteTriggerTool/index.js";
+import { ScheduleWakeupTool } from "./tools/ScheduleWakeupTool/index.js";
+import { SendMessageTool } from "./tools/SendMessageTool/index.js";
+// Extended tools — deferred loading (minimal prompt until first use)
+import { SessionSearchTool } from "./tools/SessionSearchTool/index.js";
+import { SkillTool } from "./tools/SkillTool/index.js";
+import { TaskCreateTool } from "./tools/TaskCreateTool/index.js";
+import { TaskGetTool } from "./tools/TaskGetTool/index.js";
+import { TaskListTool } from "./tools/TaskListTool/index.js";
+import { TaskOutputTool } from "./tools/TaskOutputTool/index.js";
+import { TaskStopTool } from "./tools/TaskStopTool/index.js";
+import { TaskUpdateTool } from "./tools/TaskUpdateTool/index.js";
+import { ToolSearchTool } from "./tools/ToolSearchTool/index.js";
+import { WebFetchTool } from "./tools/WebFetchTool/index.js";
+import { WebSearchTool } from "./tools/WebSearchTool/index.js";
 /**
  * Returns all registered tools.
  *
@@ -100,10 +102,9 @@ export function getAllTools() {
         MultiEditTool,
         PowerShellTool,
         MonitorTool,
+        ScheduleWakeupTool,
+        SessionSearchTool,
     ];
-    return [
-        ...core,
-        ...extended.map(t => new DeferredTool(t)),
-    ];
+    return [...core, ...extended.map((t) => new DeferredTool(t))];
 }
 //# sourceMappingURL=tools.js.map