zenox 1.2.3 → 1.4.0

package/README.md

@@ -17,6 +17,17 @@
 
 Zenox supercharges [OpenCode](https://opencode.ai) with specialized AI agents that handle different aspects of development. Instead of one agent doing everything, you get a team of experts — each optimized for their domain.
 
+## Features
+
+- **4 Specialized Agents** — Explorer, Librarian, Oracle, UI Planner
+- **Background Tasks** — Fire multiple agents in parallel
+- **Thinking Mode Variants** — Configure thinking levels (high, xhigh, max) per agent
+- **Keyword Triggers** — `ultrawork`, `deep research`, `explore codebase`
+- **Session History** — Query past sessions to learn from previous work
+- **Code Intelligence** — Search symbols via LSP
+- **Todo Continuation** — Auto-reminds when tasks are incomplete
+- **Auto-Updates** — Toast notification when new version available
+
 ## Why Zenox?
 
 Most AI coding assistants use a single model for everything. Zenox takes a different approach:
@@ -114,6 +125,46 @@ Zenox shows toast notifications for background task events:
 - 🎉 **All Complete** — Shows summary of all finished tasks
 - ❌ **Task Failed** — Shows error message
 
+## Session History
+
+Query past sessions to learn from previous work:
+
+| Tool | What it does |
+|------|--------------|
+| `session_list` | List recent sessions to find relevant past work |
+| `session_search` | Search messages across sessions for how something was done |
+
+```
+You: "How did we implement auth last time?"
+→ session_search({ query: "authentication" })
+→ Finds excerpts from past sessions where auth was discussed
+```
+
+## Code Intelligence
+
+Search for symbols via LSP (Language Server Protocol):
+
+| Tool | What it does |
+|------|--------------|
+| `find_symbols` | Search for functions, classes, variables by name |
+| `lsp_status` | Check which language servers are running |
+
+```
+You: "Find where handleLogin is defined"
+→ find_symbols({ query: "handleLogin" })
+→ Returns: Function in src/auth/handlers.ts, line 42
+```
+
+## Todo Continuation
+
+Zenox automatically reminds you to continue working when:
+
+- You have incomplete tasks in your todo list
+- The session goes idle
+- There's been enough time since the last reminder (10 second cooldown)
+
+This keeps you on track without manual intervention. The agent will be prompted to continue until all todos are complete or blocked.
+
 ## Configuration
 
 ### Custom Models
@@ -135,6 +186,34 @@ Config saves to `~/.config/opencode/zenox.json`:
 }
 ```
 
+### Thinking Mode Variants
+
+Configure thinking/reasoning levels for models that support extended thinking (like Claude, GPT with reasoning, etc.):
+
+```json
+{
+  "agents": {
+    "oracle": { 
+      "model": "anthropic/claude-opus-4-5",
+      "variant": "high"
+    },
+    "ui-planner": { 
+      "model": "openai/gpt-5.2-codex",
+      "variant": "xhigh"
+    }
+  }
+}
+```
+
+Available variants (model-dependent):
+- `low` — Minimal thinking
+- `medium` — Balanced thinking
+- `high` — Extended thinking
+- `xhigh` — Extra high thinking
+- `max` — Maximum reasoning depth
+
+Variants are applied safely — if an agent doesn't exist or the model doesn't support the variant, it gracefully falls back.
+
 ### Disable Agents or MCPs
 
 ```json

package/dist/agents/types.d.ts

@@ -3,5 +3,6 @@ export type AgentFactory = (model?: string) => AgentConfig;
 export type BuiltinAgentName = "explorer" | "librarian" | "oracle" | "ui-planner";
 export type AgentOverrideConfig = Partial<AgentConfig> & {
     prompt_append?: string;
+    variant?: string;
 };
 export type AgentOverrides = Partial<Record<BuiltinAgentName, AgentOverrideConfig>>;

package/dist/background/manager.d.ts

@@ -15,7 +15,7 @@ export declare class BackgroundManager {
     private mainSessionID;
     private toastManager;
     setToastManager(manager: TaskToastManager): void;
-    setMainSession(sessionID: string): void;
+    setMainSession(sessionID: string | undefined): void;
     getMainSession(): string | undefined;
     private generateTaskId;
     launch(client: OpencodeClient, input: LaunchInput): Promise<BackgroundTask>;

package/dist/config/schema.d.ts

@@ -6,14 +6,17 @@ export declare const AgentNameSchema: z.ZodEnum<["explorer", "librarian", "oracl
 export type AgentName = z.infer<typeof AgentNameSchema>;
 /**
  * Configuration for overriding an agent's settings
- * Only model override is supported - keeps it simple
+ * Supports model and variant overrides for thinking modes
  */
 export declare const AgentOverrideConfigSchema: z.ZodObject<{
     model: z.ZodOptional<z.ZodString>;
+    variant: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     model?: string | undefined;
+    variant?: string | undefined;
 }, {
     model?: string | undefined;
+    variant?: string | undefined;
 }>;
 export type AgentOverrideConfig = z.infer<typeof AgentOverrideConfigSchema>;
 /**
@@ -22,57 +25,77 @@ export type AgentOverrideConfig = z.infer<typeof AgentOverrideConfigSchema>;
 export declare const AgentOverridesSchema: z.ZodObject<{
     explorer: z.ZodOptional<z.ZodObject<{
         model: z.ZodOptional<z.ZodString>;
+        variant: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         model?: string | undefined;
+        variant?: string | undefined;
     }, {
         model?: string | undefined;
+        variant?: string | undefined;
     }>>;
     librarian: z.ZodOptional<z.ZodObject<{
         model: z.ZodOptional<z.ZodString>;
+        variant: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         model?: string | undefined;
+        variant?: string | undefined;
     }, {
         model?: string | undefined;
+        variant?: string | undefined;
     }>>;
     oracle: z.ZodOptional<z.ZodObject<{
         model: z.ZodOptional<z.ZodString>;
+        variant: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         model?: string | undefined;
+        variant?: string | undefined;
     }, {
         model?: string | undefined;
+        variant?: string | undefined;
     }>>;
     "ui-planner": z.ZodOptional<z.ZodObject<{
         model: z.ZodOptional<z.ZodString>;
+        variant: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         model?: string | undefined;
+        variant?: string | undefined;
     }, {
         model?: string | undefined;
+        variant?: string | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
     explorer?: {
         model?: string | undefined;
+        variant?: string | undefined;
     } | undefined;
     librarian?: {
         model?: string | undefined;
+        variant?: string | undefined;
     } | undefined;
     oracle?: {
         model?: string | undefined;
+        variant?: string | undefined;
     } | undefined;
     "ui-planner"?: {
         model?: string | undefined;
+        variant?: string | undefined;
     } | undefined;
 }, {
     explorer?: {
         model?: string | undefined;
+        variant?: string | undefined;
     } | undefined;
     librarian?: {
         model?: string | undefined;
+        variant?: string | undefined;
     } | undefined;
     oracle?: {
         model?: string | undefined;
+        variant?: string | undefined;
     } | undefined;
     "ui-planner"?: {
         model?: string | undefined;
+        variant?: string | undefined;
     } | undefined;
 }>;
 export type AgentOverrides = z.infer<typeof AgentOverridesSchema>;
@@ -84,57 +107,77 @@ export declare const ZenoxConfigSchema: z.ZodObject<{
     agents: z.ZodOptional<z.ZodObject<{
         explorer: z.ZodOptional<z.ZodObject<{
             model: z.ZodOptional<z.ZodString>;
+            variant: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
             model?: string | undefined;
+            variant?: string | undefined;
         }, {
             model?: string | undefined;
+            variant?: string | undefined;
         }>>;
         librarian: z.ZodOptional<z.ZodObject<{
             model: z.ZodOptional<z.ZodString>;
+            variant: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
             model?: string | undefined;
+            variant?: string | undefined;
         }, {
             model?: string | undefined;
+            variant?: string | undefined;
         }>>;
         oracle: z.ZodOptional<z.ZodObject<{
             model: z.ZodOptional<z.ZodString>;
+            variant: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
             model?: string | undefined;
+            variant?: string | undefined;
         }, {
             model?: string | undefined;
+            variant?: string | undefined;
         }>>;
         "ui-planner": z.ZodOptional<z.ZodObject<{
             model: z.ZodOptional<z.ZodString>;
+            variant: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
             model?: string | undefined;
+            variant?: string | undefined;
         }, {
             model?: string | undefined;
+            variant?: string | undefined;
         }>>;
     }, "strip", z.ZodTypeAny, {
         explorer?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
         librarian?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
         oracle?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
         "ui-planner"?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
     }, {
         explorer?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
         librarian?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
         oracle?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
         "ui-planner"?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
     }>>;
     disabled_agents: z.ZodOptional<z.ZodArray<z.ZodEnum<["explorer", "librarian", "oracle", "ui-planner"]>, "many">>;
@@ -144,15 +187,19 @@ export declare const ZenoxConfigSchema: z.ZodObject<{
     agents?: {
         explorer?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
         librarian?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
         oracle?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
         "ui-planner"?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
     } | undefined;
     disabled_agents?: ("explorer" | "librarian" | "oracle" | "ui-planner")[] | undefined;
@@ -162,15 +209,19 @@ export declare const ZenoxConfigSchema: z.ZodObject<{
     agents?: {
         explorer?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
         librarian?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
         oracle?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
         "ui-planner"?: {
             model?: string | undefined;
+            variant?: string | undefined;
         } | undefined;
     } | undefined;
     disabled_agents?: ("explorer" | "librarian" | "oracle" | "ui-planner")[] | undefined;

package/dist/hooks/index.d.ts

@@ -1,3 +1,4 @@
 export { createAutoUpdateHook } from "./auto-update";
 export { createKeywordDetectorHook } from "./keyword-detector";
+export { createTodoEnforcerHook } from "./todo-enforcer";
 export type { KeywordType, KeywordConfig } from "./keyword-detector";

package/dist/hooks/todo-enforcer/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Todo Continuation Enforcer Hook
+ *
+ * Automatically reminds the agent to continue working when:
+ * - Session goes idle (session.idle event)
+ * - There are incomplete todos (pending or in_progress)
+ *
+ * Features:
+ * - Skips child sessions (background tasks)
+ * - Cooldown to prevent spam (10 seconds between reminders)
+ * - Shows toast notification when enforcing
+ *
+ * Inspired by oh-my-opencode's todo-continuation-enforcer
+ */
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { Event } from "@opencode-ai/sdk";
+interface SessionState {
+    lastEnforcedAt: number;
+    enforceCount: number;
+}
+export declare function createTodoEnforcerHook(ctx: PluginInput): {
+    event: ({ event }: {
+        event: Event;
+    }) => Promise<void>;
+};
+export type { SessionState };

package/dist/index.js

@@ -743,6 +743,85 @@ Include these keywords in your prompt to unlock special modes:
 | \`ultrawork\` or \`ulw\` | Maximum multi-agent coordination - aggressive parallel research |
 | \`deep research\` | Comprehensive exploration - fires 3-4 background agents |
 | \`explore codebase\` | Codebase mapping - multiple explorers in parallel |
+
+---
+
+## Session History Tools
+
+You have tools to learn from past work sessions:
+
+| Tool | Use For |
+|------|---------|
+| \`session_list\` | List recent sessions to find relevant past work |
+| \`session_search\` | Search messages across sessions for how something was done |
+
+### When to Use Session Tools
+
+- **Before implementing unfamiliar features** \u2014 search if done before
+- **When user says "like before" or "last time"** \u2014 find that session
+- **When debugging** \u2014 check if similar issues were solved previously
+- **For context on ongoing projects** \u2014 understand recent work history
+
+### Example Usage
+
+\`\`\`
+// Find how authentication was implemented before
+session_search({ query: "JWT authentication" })
+
+// List recent sessions to understand project context
+session_list({ limit: 5 })
+
+// Find past implementations of a feature
+session_search({ query: "rate limiting" })
+\`\`\`
+
+---
+
+## Code Intelligence Tools
+
+You have tools to understand code structure via LSP:
+
+| Tool | Use For |
+|------|---------|
+| \`find_symbols\` | Search for functions, classes, variables by name |
+| \`lsp_status\` | Check which language servers are running |
+
+### When to Use Code Intelligence
+
+- **Before editing code** \u2014 find the symbol's definition location
+- **When refactoring** \u2014 search for related symbols
+- **To understand project structure** \u2014 search for key symbols like "auth", "user", "api"
+- **To verify LSP availability** \u2014 check if code intelligence is working
+
+### Example Usage
+
+\`\`\`
+// Find all auth-related functions/classes
+find_symbols({ query: "auth" })
+
+// Find a specific function
+find_symbols({ query: "handleLogin" })
+
+// Check LSP server status
+lsp_status()
+\`\`\`
+
+---
+
+## Todo Continuation
+
+The system automatically reminds you if you go idle with incomplete tasks.
+
+**Best Practices:**
+- Keep your todo list updated with \`TodoWrite\`
+- Mark tasks complete immediately when finished
+- Use clear, actionable task descriptions
+- The system will prompt you to continue if tasks remain incomplete
+
+**Note:** You don't need to invoke the todo enforcer \u2014 it runs automatically when:
+- You have pending or in-progress todos
+- The session goes idle
+- There's been sufficient time since the last reminder
 `;
 
 // node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/external.js
@@ -4733,7 +4812,8 @@ var AgentNameSchema = exports_external.enum([
   "ui-planner"
 ]);
 var AgentOverrideConfigSchema = exports_external.object({
-  model: exports_external.string().optional()
+  model: exports_external.string().optional(),
+  variant: exports_external.string().optional()
 });
 var AgentOverridesSchema = exports_external.object({
   explorer: AgentOverrideConfigSchema.optional(),
@@ -4890,24 +4970,34 @@ class BackgroundManager {
         agent: task.agent
       }).catch(() => {});
     }
-    client.session.prompt({
-      path: { id: sessionID },
-      body: {
-        agent: input.agent,
-        tools: { task: false },
-        parts: [{ type: "text", text: input.prompt }]
-      }
-    }).catch((err) => {
-      const existingTask = this.tasks.get(task.id);
-      if (existingTask) {
-        existingTask.status = "failed";
-        existingTask.error = err.message ?? "Unknown error";
-        existingTask.completedAt = new Date;
-        if (this.toastManager) {
-          this.toastManager.showFailureToast(task.id, existingTask.error).catch(() => {});
+    const sendPrompt = async (retryWithoutAgent = false) => {
+      try {
+        await client.session.prompt({
+          path: { id: sessionID },
+          body: {
+            ...retryWithoutAgent ? {} : { agent: input.agent },
+            tools: { task: false },
+            parts: [{ type: "text", text: input.prompt }]
+          }
+        });
+      } catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        if (!retryWithoutAgent && (errorMsg.includes("agent.name") || errorMsg.includes("undefined is not an object"))) {
+          console.warn(`[zenox] Agent "${input.agent}" not found. Retrying with default agent.`);
+          return sendPrompt(true);
+        }
+        const existingTask = this.tasks.get(task.id);
+        if (existingTask) {
+          existingTask.status = "failed";
+          existingTask.error = errorMsg;
+          existingTask.completedAt = new Date;
+          if (this.toastManager) {
+            this.toastManager.showFailureToast(task.id, existingTask.error).catch(() => {});
+          }
         }
       }
-    });
+    };
+    sendPrompt().catch(() => {});
     return task;
   }
   getTask(taskId) {
@@ -17706,6 +17796,111 @@ ${primaryKeyword.context}`;
     }
   };
 }
+// src/hooks/todo-enforcer/index.ts
+var COOLDOWN_MS = 1e4;
+var TOAST_DURATION3 = 3000;
+var CONTINUATION_PROMPT = `[TODO CONTINUATION REMINDER]
+
+You have incomplete tasks in your todo list. Continue working on them.
+
+Rules:
+- Proceed without asking for permission
+- Mark each task complete when finished
+- Update todo status as you work
+- Do not stop until all tasks are done or blocked`;
+function createTodoEnforcerHook(ctx) {
+  const sessionStates = new Map;
+  const cleanupOldStates = () => {
+    const now = Date.now();
+    const maxAge = 30 * 60 * 1000;
+    for (const [sessionID, state] of sessionStates) {
+      if (now - state.lastEnforcedAt > maxAge) {
+        sessionStates.delete(sessionID);
+      }
+    }
+  };
+  return {
+    event: async ({ event }) => {
+      if (event.type !== "session.idle")
+        return;
+      const props = event.properties;
+      const sessionID = props?.sessionID;
+      if (!sessionID)
+        return;
+      let state = sessionStates.get(sessionID);
+      if (!state) {
+        state = { lastEnforcedAt: 0, enforceCount: 0 };
+        sessionStates.set(sessionID, state);
+      }
+      const now = Date.now();
+      if (now - state.lastEnforcedAt < COOLDOWN_MS) {
+        return;
+      }
+      try {
+        const sessionResult = await ctx.client.session.get({
+          path: { id: sessionID }
+        });
+        const session = sessionResult.data;
+        if (session?.parentID) {
+          return;
+        }
+      } catch {
+        return;
+      }
+      let todos = [];
+      try {
+        const todosResult = await ctx.client.session.todo({
+          path: { id: sessionID }
+        });
+        todos = todosResult.data ?? [];
+      } catch {
+        return;
+      }
+      if (todos.length === 0) {
+        return;
+      }
+      const incomplete = todos.filter((t) => t.status === "pending" || t.status === "in_progress");
+      if (incomplete.length === 0) {
+        return;
+      }
+      state.lastEnforcedAt = now;
+      state.enforceCount++;
+      const todoList = incomplete.map((t) => {
+        const priority = t.priority === "high" ? "!" : "";
+        return `- [${t.status}]${priority} ${t.content}`;
+      }).join(`
+`);
+      const completedCount = todos.length - incomplete.length;
+      const statusLine = `[Status: ${completedCount}/${todos.length} completed, ${incomplete.length} remaining]`;
+      const prompt = `${CONTINUATION_PROMPT}
+
+Current incomplete tasks:
+${todoList}
+
+${statusLine}`;
+      try {
+        await ctx.client.session.prompt({
+          path: { id: sessionID },
+          body: {
+            noReply: false,
+            parts: [{ type: "text", text: prompt }]
+          }
+        });
+        await ctx.client.tui.showToast({
+          body: {
+            title: "\uD83D\uDCCB Todo Reminder",
+            message: `${incomplete.length} task(s) remaining`,
+            variant: "info",
+            duration: TOAST_DURATION3
+          }
+        }).catch(() => {});
+      } catch {}
+      if (sessionStates.size > 50) {
+        cleanupOldStates();
+      }
+    }
+  };
+}
 // src/features/task-toast/manager.ts
 var LAUNCH_TOAST_DURATION = 3000;
 var COMPLETE_TOAST_DURATION = 4000;
@@ -17825,6 +18020,239 @@ Use background_output to retrieve.`,
     return this.tasks.get(taskId);
   }
 }
+// src/tools/session/tools.ts
+var MAX_SESSIONS_TO_SEARCH = 10;
+var DEFAULT_SEARCH_LIMIT = 20;
+var DEFAULT_LIST_LIMIT = 10;
+function createSessionTools(client) {
+  const sessionList = tool({
+    description: `List recent sessions to find relevant past work.
+Use when you need to see what was done before or find a specific session.
+Returns session IDs, titles, and creation dates.`,
+    args: {
+      limit: tool.schema.number().optional().describe("Max sessions to return (default: 10)")
+    },
+    async execute(args) {
+      try {
+        const result = await client.session.list();
+        const sessions = result.data ?? [];
+        const mainSessions = sessions.filter((s) => !s.parentID).slice(0, args.limit ?? DEFAULT_LIST_LIMIT);
+        if (mainSessions.length === 0) {
+          return "No sessions found.";
+        }
+        const formatted = mainSessions.map((s) => ({
+          id: s.id,
+          title: s.title ?? "(untitled)",
+          created: s.time?.created ? new Date(s.time.created).toISOString() : "unknown"
+        }));
+        return JSON.stringify(formatted, null, 2);
+      } catch (err) {
+        const errorMsg = err instanceof Error ? err.message : "Unknown error";
+        return `Failed to list sessions: ${errorMsg}`;
+      }
+    }
+  });
+  const sessionSearch = tool({
+    description: `Search messages across sessions to find how something was done before.
+Use when looking for past implementations, solutions, or context.
+Searches the last 10 sessions for matching content.`,
+    args: {
+      query: tool.schema.string().describe("Search query (case-insensitive)"),
+      limit: tool.schema.number().optional().describe("Max results to return (default: 20)")
+    },
+    async execute(args) {
+      try {
+        const sessionsResult = await client.session.list();
+        const sessions = sessionsResult.data ?? [];
+        const searchSessions = sessions.filter((s) => !s.parentID).slice(0, MAX_SESSIONS_TO_SEARCH);
+        if (searchSessions.length === 0) {
+          return "No sessions to search.";
+        }
+        const query = args.query.toLowerCase();
+        const maxResults = args.limit ?? DEFAULT_SEARCH_LIMIT;
+        const results = [];
+        for (const session of searchSessions) {
+          if (results.length >= maxResults)
+            break;
+          try {
+            const messagesResult = await client.session.messages({
+              path: { id: session.id },
+              query: { limit: 50 }
+            });
+            const messages = messagesResult.data ?? [];
+            for (const msg of messages) {
+              if (results.length >= maxResults)
+                break;
+              const textParts = msg.parts?.filter((p) => p.type === "text" && p.text) ?? [];
+              for (const part of textParts) {
+                if (results.length >= maxResults)
+                  break;
+                const text = part.text ?? "";
+                if (text.toLowerCase().includes(query)) {
+                  const lowerText = text.toLowerCase();
+                  const matchIndex = lowerText.indexOf(query);
+                  const start = Math.max(0, matchIndex - 50);
+                  const end = Math.min(text.length, matchIndex + query.length + 150);
+                  const excerpt = (start > 0 ? "..." : "") + text.substring(start, end).trim() + (end < text.length ? "..." : "");
+                  results.push({
+                    sessionId: session.id,
+                    sessionTitle: session.title ?? "(untitled)",
+                    role: msg.info?.role ?? "unknown",
+                    excerpt
+                  });
+                }
+              }
+            }
+          } catch {
+            continue;
+          }
+        }
+        if (results.length === 0) {
+          return `No matches found for "${args.query}" in the last ${MAX_SESSIONS_TO_SEARCH} sessions.`;
+        }
+        return JSON.stringify(results, null, 2);
+      } catch (err) {
+        const errorMsg = err instanceof Error ? err.message : "Unknown error";
+        return `Failed to search sessions: ${errorMsg}`;
+      }
+    }
+  });
+  return {
+    session_list: sessionList,
+    session_search: sessionSearch
+  };
+}
+// src/tools/code-intelligence/tools.ts
+var SYMBOL_KINDS = {
+  1: "File",
+  2: "Module",
+  3: "Namespace",
+  4: "Package",
+  5: "Class",
+  6: "Method",
+  7: "Property",
+  8: "Field",
+  9: "Constructor",
+  10: "Enum",
+  11: "Interface",
+  12: "Function",
+  13: "Variable",
+  14: "Constant",
+  15: "String",
+  16: "Number",
+  17: "Boolean",
+  18: "Array",
+  19: "Object",
+  20: "Key",
+  21: "Null",
+  22: "EnumMember",
+  23: "Struct",
+  24: "Event",
+  25: "Operator",
+  26: "TypeParameter"
+};
+function createCodeIntelligenceTools(client) {
+  const findSymbols = tool({
+    description: `Search for functions, classes, variables, and other symbols by name.
+Use to find where something is defined or to understand code structure.
+Returns symbol name, type (function/class/etc), file path, and location.`,
+    args: {
+      query: tool.schema.string().describe("Symbol name or pattern to search (e.g., 'handleAuth', 'User')")
+    },
+    async execute(args) {
+      try {
+        const result = await client.find.symbols({
+          query: { query: args.query }
+        });
+        const symbols = result.data ?? [];
+        if (symbols.length === 0) {
+          return `No symbols found matching "${args.query}"`;
+        }
+        const formatted = symbols.map((s) => {
+          const uri = s.location?.uri ?? "";
+          const path2 = uri.startsWith("file://") ? uri.slice(7) : uri;
+          return {
+            name: s.name,
+            kind: SYMBOL_KINDS[s.kind] ?? `Unknown(${s.kind})`,
+            path: path2,
+            location: s.location?.range ? `line ${s.location.range.start.line + 1}` : "unknown"
+          };
+        });
+        return JSON.stringify(formatted, null, 2);
+      } catch (err) {
+        const errorMsg = err instanceof Error ? err.message : "Unknown error";
+        return `Failed to search symbols: ${errorMsg}`;
+      }
+    }
+  });
+  const lspStatus = tool({
+    description: `Get the status of language servers (LSP).
+Use to check if code intelligence is available for the current project's languages.
+Shows which LSP servers are running and their status.`,
+    args: {},
+    async execute() {
+      try {
+        const result = await client.lsp.status();
+        const servers = result.data ?? [];
+        if (servers.length === 0) {
+          return "No LSP servers currently running.";
+        }
+        const formatted = servers.map((s) => ({
+          name: s.name ?? s.id,
+          status: s.status,
+          root: s.root
+        }));
+        return JSON.stringify(formatted, null, 2);
+      } catch (err) {
+        const errorMsg = err instanceof Error ? err.message : "Unknown error";
+        return `Failed to get LSP status: ${errorMsg}`;
+      }
+    }
+  });
+  return {
+    find_symbols: findSymbols,
+    lsp_status: lspStatus
+  };
+}
+// src/shared/agent-variant.ts
+function resolveAgentVariant(config2, agentName) {
+  if (!agentName)
+    return;
+  const agentOverrides = config2.agents;
+  return agentOverrides?.[agentName]?.variant;
+}
+function applyAgentVariant(config2, agentName, message) {
+  const variant = resolveAgentVariant(config2, agentName);
+  if (variant !== undefined && message.variant === undefined) {
+    message.variant = variant;
+  }
+}
+// src/shared/first-message-variant.ts
+function createFirstMessageVariantGate() {
+  const pending = new Set;
+  return {
+    markSessionCreated(info) {
+      if (info?.id && !info.parentID) {
+        pending.add(info.id);
+      }
+    },
+    shouldOverride(sessionID) {
+      if (!sessionID)
+        return false;
+      return pending.has(sessionID);
+    },
+    markApplied(sessionID) {
+      if (!sessionID)
+        return;
+      pending.delete(sessionID);
+    },
+    clear(sessionID) {
+      if (!sessionID)
+        return;
+      pending.delete(sessionID);
+    }
+  };
+}
 // src/index.ts
 var ZenoxPlugin = async (ctx) => {
   const pluginConfig = loadPluginConfig(ctx.directory);
@@ -17836,6 +18264,10 @@ var ZenoxPlugin = async (ctx) => {
   const backgroundTools = createBackgroundTools(backgroundManager, ctx.client);
   const autoUpdateHook = createAutoUpdateHook(ctx);
   const keywordDetectorHook = createKeywordDetectorHook(ctx);
+  const todoEnforcerHook = createTodoEnforcerHook(ctx);
+  const sessionTools = createSessionTools(ctx.client);
+  const codeIntelligenceTools = createCodeIntelligenceTools(ctx.client);
+  const firstMessageVariantGate = createFirstMessageVariantGate();
   const applyModelOverride = (agentName, baseAgent) => {
     const override = pluginConfig.agents?.[agentName];
     if (override?.model) {
@@ -17844,8 +18276,22 @@ var ZenoxPlugin = async (ctx) => {
     return baseAgent;
   };
   return {
-    tool: backgroundTools,
+    tool: {
+      ...backgroundTools,
+      ...sessionTools,
+      ...codeIntelligenceTools
+    },
     "chat.message": async (input, output) => {
+      const message = output.message;
+      if (firstMessageVariantGate.shouldOverride(input.sessionID)) {
+        const variant = resolveAgentVariant(pluginConfig, input.agent);
+        if (variant !== undefined) {
+          message.variant = variant;
+        }
+        firstMessageVariantGate.markApplied(input.sessionID);
+      } else {
+        applyAgentVariant(pluginConfig, input.agent, message);
+      }
       await keywordDetectorHook["chat.message"]?.(input, output);
     },
     event: async (input) => {
@@ -17854,10 +18300,19 @@ var ZenoxPlugin = async (ctx) => {
       if (event.type === "session.created") {
         const props = event.properties;
         const sessionInfo = props?.info;
+        firstMessageVariantGate.markSessionCreated(sessionInfo);
         if (sessionInfo?.id && !sessionInfo?.parentID) {
           backgroundManager.setMainSession(sessionInfo.id);
         }
       }
+      if (event.type === "session.deleted") {
+        const props = event.properties;
+        const sessionID = props?.info?.id;
+        firstMessageVariantGate.clear(sessionID);
+        if (sessionID && sessionID === backgroundManager.getMainSession()) {
+          backgroundManager.setMainSession(undefined);
+        }
+      }
       if (event.type === "session.idle") {
         const props = event.properties;
         const sessionID = props?.sessionID;
@@ -17867,16 +18322,28 @@ var ZenoxPlugin = async (ctx) => {
         if (notification) {
           const mainSessionID = backgroundManager.getMainSession();
           if (mainSessionID) {
-            await ctx.client.session.prompt({
-              path: { id: mainSessionID },
-              body: {
-                noReply: !notification.allComplete,
-                agent: notification.parentAgent,
-                parts: [{ type: "text", text: notification.message }]
+            const sendNotification = async (omitAgent = false) => {
+              try {
+                await ctx.client.session.prompt({
+                  path: { id: mainSessionID },
+                  body: {
+                    noReply: !notification.allComplete,
+                    ...omitAgent ? {} : { agent: notification.parentAgent },
+                    parts: [{ type: "text", text: notification.message }]
+                  }
+                });
+              } catch (err) {
+                const errorMsg = err instanceof Error ? err.message : String(err);
+                if (!omitAgent && (errorMsg.includes("agent.name") || errorMsg.includes("undefined"))) {
+                  return sendNotification(true);
+                }
               }
-            });
+            };
+            await sendNotification();
           }
+          return;
         }
+        await todoEnforcerHook.event(input);
       }
     },
     config: async (config2) => {

package/dist/orchestration/prompt.d.ts

@@ -2,4 +2,4 @@
  * Orchestration prompt to inject into Build and Plan agents.
  * This teaches the primary agents how to delegate to specialized subagents using the Task tool.
  */
-export declare const ORCHESTRATION_PROMPT = "\n\n---\n\n## Sub-Agent Delegation\n\nYou have specialized subagents. Use the **Task tool** to delegate work proactively.\n\n### Available Agents\n\n| Agent | Use For | subagent_type |\n|-------|---------|---------------|\n| **Explorer** | Codebase grep - fast pattern matching, \"Where is X?\" | `explorer` |\n| **Librarian** | External grep - docs, GitHub, OSS examples | `librarian` |\n| **Oracle** | Strategic advisor - architecture, debugging, decisions | `oracle` |\n| **UI Planner** | Designer-developer - visual design, CSS, animations | `ui-planner` |\n\n### Quick Rule: Background vs Synchronous\n\n| Agent | Default Execution | Why |\n|-------|-------------------|-----|\n| Explorer | `background_task` | It's codebase grep - fire and continue |\n| Librarian | `background_task` | It's external grep - fire and continue |\n| Oracle | `Task` (sync) | Need strategic answer before proceeding |\n| UI Planner | `Task` (sync) | Implements changes, needs write access |\n\n**Mental Model**: Explorer & Librarian = **grep commands**. You don't wait for grep, you fire it and continue thinking.\n\n### When to Delegate (Fire Immediately)\n\n| Trigger | subagent_type | Why |\n|---------|---------------|-----|\n| \"Where is X?\", \"Find Y\", locate code | `explorer` | Fast codebase search |\n| External library, \"how does X library work?\" | `librarian` | Searches docs, GitHub, OSS |\n| 2+ modules involved, cross-cutting concerns | `explorer` | Multi-file pattern discovery |\n| Architecture decision, \"should I use X or Y?\" | `oracle` | Deep reasoning advisor |\n| Visual/styling, CSS, animations, UI/UX | `ui-planner` | Designer-developer hybrid |\n| After 2+ failed fix attempts | `oracle` | Debugging escalation |\n\n### How to Delegate\n\nUse the Task tool with these parameters:\n\n```\nTask(\n  subagent_type: \"explorer\" | \"librarian\" | \"oracle\" | \"ui-planner\",\n  description: \"Short 3-5 word task description\",\n  prompt: \"Detailed instructions for the agent\"\n)\n```\n\n**Example delegations:**\n\n```\n// Find code in codebase\nTask(\n  subagent_type: \"explorer\",\n  description: \"Find auth middleware\",\n  prompt: \"Find all authentication middleware implementations in this codebase. Return file paths and explain the auth flow.\"\n)\n\n// Research external library\nTask(\n  subagent_type: \"librarian\",\n  description: \"React Query caching docs\",\n  prompt: \"How does React Query handle caching? Find official documentation and real-world examples with GitHub permalinks.\"\n)\n\n// Architecture decision\nTask(\n  subagent_type: \"oracle\",\n  description: \"Redux vs Zustand analysis\",\n  prompt: \"Analyze trade-offs between Redux and Zustand for this project. Consider bundle size, learning curve, and our existing patterns.\"\n)\n\n// UI/Visual work\nTask(\n  subagent_type: \"ui-planner\",\n  description: \"Redesign dashboard cards\",\n  prompt: \"Redesign the dashboard stat cards to be more visually appealing. Use modern aesthetics, subtle animations, and ensure responsive design.\"\n)\n```\n\n### Parallel Execution\n\nTo run multiple agents in parallel, call multiple Task tools in the **same response message**:\n\n```\n// CORRECT: Multiple Task calls in ONE message = parallel execution\nTask(subagent_type: \"explorer\", description: \"Find auth code\", prompt: \"...\")\nTask(subagent_type: \"librarian\", description: \"JWT best practices\", prompt: \"...\")\n// Both run simultaneously\n\n// WRONG: One Task per message = sequential (slow)\nMessage 1: Task(...) \u2192 wait for result\nMessage 2: Task(...) \u2192 wait for result\n```\n\n### Delegation Priority\n\n1. **Explorer FIRST** \u2014 Always locate code before modifying unfamiliar areas\n2. **Librarian** \u2014 When dealing with external libraries/APIs you don't fully understand\n3. **Oracle** \u2014 For complex decisions or after 2+ failed fix attempts\n4. **UI Planner** \u2014 For ANY visual/styling work (never edit CSS/UI yourself)\n\n### Critical Rules\n\n1. **Never touch frontend visual/styling code yourself** \u2014 Always delegate to `ui-planner`\n2. **Fire librarian proactively** when unfamiliar libraries are involved\n3. **Consult oracle BEFORE major architectural decisions**, not after\n4. **Verify delegated work** before marking task complete\n\n### When to Handle Directly (Don't Delegate)\n\n- Single file edits with known location\n- Questions answerable from code already in context\n- Trivial changes requiring no specialist knowledge\n- Tasks you can complete faster than explaining to an agent\n\n---\n\n## Background Tasks (Parallel Research)\n\nFor **independent research tasks** that benefit from parallelism, use background tasks instead of sequential Task calls.\n\n### When to Use Background Tasks\n\n| Scenario | Use Background Tasks |\n|----------|---------------------|\n| User wants \"comprehensive\" / \"thorough\" / \"deep\" exploration | YES - fire 3-4 agents in parallel |\n| Need BOTH codebase search AND external docs | YES - explore + librarian in parallel |\n| Exploring multiple modules/features simultaneously | YES - separate explore for each |\n| Result of Task A needed before Task B | NO - use sequential Task |\n| Single focused lookup | NO - just use Task directly |\n\n### How Background Tasks Work\n\n1. **Fire**: Launch multiple agents with `background_task` - they run in parallel\n2. **Continue**: Keep working while background agents search\n3. **Notify**: You'll be notified when ALL background tasks complete\n4. **Retrieve**: Use `background_output` to get each result\n\n### Usage\n\n```\n// Launch parallel research (all run simultaneously)\nbackground_task(agent=\"explorer\", description=\"Find auth code\", prompt=\"Search for authentication...\")\nbackground_task(agent=\"explorer\", description=\"Find db layer\", prompt=\"Search for database/ORM...\")\nbackground_task(agent=\"librarian\", description=\"Best practices\", prompt=\"Find framework best practices...\")\n\n// Continue working on other things while they run...\n\n// [NOTIFICATION: All background tasks complete!]\n\n// Retrieve results\nbackground_output(task_id=\"bg_abc123\")\nbackground_output(task_id=\"bg_def456\")\nbackground_output(task_id=\"bg_ghi789\")\n```\n\n### Background Tasks vs Task Tool\n\n| Aspect | Task Tool | Background Tasks |\n|--------|-----------|------------------|\n| Execution | Sequential (waits for result) | Parallel (fire-and-forget) |\n| Best for | Dependent tasks, immediate needs | Independent research, breadth |\n| Result | Inline, immediate | Retrieved later via background_output |\n\n### Key Insight\n\n- **Task** = Use when you need the result immediately before proceeding\n- **Background** = Use when researching multiple angles independently\n\n**Both tools coexist - choose based on whether tasks are dependent or independent.**\n\n### The Parallel Research Pattern\n\nFor complex tasks, fire research first, then continue working:\n\n```\n// 1. FIRE parallel research (don't wait!)\nbackground_task(agent=\"explorer\", description=\"Find existing patterns\", prompt=\"...\")\nbackground_task(agent=\"librarian\", description=\"Find best practices\", prompt=\"...\")\n\n// 2. CONTINUE productive work while they run:\n//    - Plan your implementation approach\n//    - Read files you already know about\n//    - Identify edge cases and questions\n\n// 3. When notified \u2192 RETRIEVE and synthesize\nbackground_output(task_id=\"bg_xxx\")\nbackground_output(task_id=\"bg_yyy\")\n```\n\n**Anti-pattern**: Firing background tasks then doing nothing. Always continue productive work!\n\n---\n\n## Keyword Triggers (Power User)\n\nInclude these keywords in your prompt to unlock special modes:\n\n| Keyword | Effect |\n|---------|--------|\n| `ultrawork` or `ulw` | Maximum multi-agent coordination - aggressive parallel research |\n| `deep research` | Comprehensive exploration - fires 3-4 background agents |\n| `explore codebase` | Codebase mapping - multiple explorers in parallel |\n";
+export declare const ORCHESTRATION_PROMPT = "\n\n---\n\n## Sub-Agent Delegation\n\nYou have specialized subagents. Use the **Task tool** to delegate work proactively.\n\n### Available Agents\n\n| Agent | Use For | subagent_type |\n|-------|---------|---------------|\n| **Explorer** | Codebase grep - fast pattern matching, \"Where is X?\" | `explorer` |\n| **Librarian** | External grep - docs, GitHub, OSS examples | `librarian` |\n| **Oracle** | Strategic advisor - architecture, debugging, decisions | `oracle` |\n| **UI Planner** | Designer-developer - visual design, CSS, animations | `ui-planner` |\n\n### Quick Rule: Background vs Synchronous\n\n| Agent | Default Execution | Why |\n|-------|-------------------|-----|\n| Explorer | `background_task` | It's codebase grep - fire and continue |\n| Librarian | `background_task` | It's external grep - fire and continue |\n| Oracle | `Task` (sync) | Need strategic answer before proceeding |\n| UI Planner | `Task` (sync) | Implements changes, needs write access |\n\n**Mental Model**: Explorer & Librarian = **grep commands**. You don't wait for grep, you fire it and continue thinking.\n\n### When to Delegate (Fire Immediately)\n\n| Trigger | subagent_type | Why |\n|---------|---------------|-----|\n| \"Where is X?\", \"Find Y\", locate code | `explorer` | Fast codebase search |\n| External library, \"how does X library work?\" | `librarian` | Searches docs, GitHub, OSS |\n| 2+ modules involved, cross-cutting concerns | `explorer` | Multi-file pattern discovery |\n| Architecture decision, \"should I use X or Y?\" | `oracle` | Deep reasoning advisor |\n| Visual/styling, CSS, animations, UI/UX | `ui-planner` | Designer-developer hybrid |\n| After 2+ failed fix attempts | `oracle` | Debugging escalation |\n\n### How to Delegate\n\nUse the Task tool with these parameters:\n\n```\nTask(\n  subagent_type: \"explorer\" | \"librarian\" | \"oracle\" | \"ui-planner\",\n  description: \"Short 3-5 word task description\",\n  prompt: \"Detailed instructions for the agent\"\n)\n```\n\n**Example delegations:**\n\n```\n// Find code in codebase\nTask(\n  subagent_type: \"explorer\",\n  description: \"Find auth middleware\",\n  prompt: \"Find all authentication middleware implementations in this codebase. Return file paths and explain the auth flow.\"\n)\n\n// Research external library\nTask(\n  subagent_type: \"librarian\",\n  description: \"React Query caching docs\",\n  prompt: \"How does React Query handle caching? Find official documentation and real-world examples with GitHub permalinks.\"\n)\n\n// Architecture decision\nTask(\n  subagent_type: \"oracle\",\n  description: \"Redux vs Zustand analysis\",\n  prompt: \"Analyze trade-offs between Redux and Zustand for this project. Consider bundle size, learning curve, and our existing patterns.\"\n)\n\n// UI/Visual work\nTask(\n  subagent_type: \"ui-planner\",\n  description: \"Redesign dashboard cards\",\n  prompt: \"Redesign the dashboard stat cards to be more visually appealing. Use modern aesthetics, subtle animations, and ensure responsive design.\"\n)\n```\n\n### Parallel Execution\n\nTo run multiple agents in parallel, call multiple Task tools in the **same response message**:\n\n```\n// CORRECT: Multiple Task calls in ONE message = parallel execution\nTask(subagent_type: \"explorer\", description: \"Find auth code\", prompt: \"...\")\nTask(subagent_type: \"librarian\", description: \"JWT best practices\", prompt: \"...\")\n// Both run simultaneously\n\n// WRONG: One Task per message = sequential (slow)\nMessage 1: Task(...) \u2192 wait for result\nMessage 2: Task(...) \u2192 wait for result\n```\n\n### Delegation Priority\n\n1. **Explorer FIRST** \u2014 Always locate code before modifying unfamiliar areas\n2. **Librarian** \u2014 When dealing with external libraries/APIs you don't fully understand\n3. **Oracle** \u2014 For complex decisions or after 2+ failed fix attempts\n4. **UI Planner** \u2014 For ANY visual/styling work (never edit CSS/UI yourself)\n\n### Critical Rules\n\n1. **Never touch frontend visual/styling code yourself** \u2014 Always delegate to `ui-planner`\n2. **Fire librarian proactively** when unfamiliar libraries are involved\n3. **Consult oracle BEFORE major architectural decisions**, not after\n4. **Verify delegated work** before marking task complete\n\n### When to Handle Directly (Don't Delegate)\n\n- Single file edits with known location\n- Questions answerable from code already in context\n- Trivial changes requiring no specialist knowledge\n- Tasks you can complete faster than explaining to an agent\n\n---\n\n## Background Tasks (Parallel Research)\n\nFor **independent research tasks** that benefit from parallelism, use background tasks instead of sequential Task calls.\n\n### When to Use Background Tasks\n\n| Scenario | Use Background Tasks |\n|----------|---------------------|\n| User wants \"comprehensive\" / \"thorough\" / \"deep\" exploration | YES - fire 3-4 agents in parallel |\n| Need BOTH codebase search AND external docs | YES - explore + librarian in parallel |\n| Exploring multiple modules/features simultaneously | YES - separate explore for each |\n| Result of Task A needed before Task B | NO - use sequential Task |\n| Single focused lookup | NO - just use Task directly |\n\n### How Background Tasks Work\n\n1. **Fire**: Launch multiple agents with `background_task` - they run in parallel\n2. **Continue**: Keep working while background agents search\n3. **Notify**: You'll be notified when ALL background tasks complete\n4. **Retrieve**: Use `background_output` to get each result\n\n### Usage\n\n```\n// Launch parallel research (all run simultaneously)\nbackground_task(agent=\"explorer\", description=\"Find auth code\", prompt=\"Search for authentication...\")\nbackground_task(agent=\"explorer\", description=\"Find db layer\", prompt=\"Search for database/ORM...\")\nbackground_task(agent=\"librarian\", description=\"Best practices\", prompt=\"Find framework best practices...\")\n\n// Continue working on other things while they run...\n\n// [NOTIFICATION: All background tasks complete!]\n\n// Retrieve results\nbackground_output(task_id=\"bg_abc123\")\nbackground_output(task_id=\"bg_def456\")\nbackground_output(task_id=\"bg_ghi789\")\n```\n\n### Background Tasks vs Task Tool\n\n| Aspect | Task Tool | Background Tasks |\n|--------|-----------|------------------|\n| Execution | Sequential (waits for result) | Parallel (fire-and-forget) |\n| Best for | Dependent tasks, immediate needs | Independent research, breadth |\n| Result | Inline, immediate | Retrieved later via background_output |\n\n### Key Insight\n\n- **Task** = Use when you need the result immediately before proceeding\n- **Background** = Use when researching multiple angles independently\n\n**Both tools coexist - choose based on whether tasks are dependent or independent.**\n\n### The Parallel Research Pattern\n\nFor complex tasks, fire research first, then continue working:\n\n```\n// 1. FIRE parallel research (don't wait!)\nbackground_task(agent=\"explorer\", description=\"Find existing patterns\", prompt=\"...\")\nbackground_task(agent=\"librarian\", description=\"Find best practices\", prompt=\"...\")\n\n// 2. CONTINUE productive work while they run:\n//    - Plan your implementation approach\n//    - Read files you already know about\n//    - Identify edge cases and questions\n\n// 3. When notified \u2192 RETRIEVE and synthesize\nbackground_output(task_id=\"bg_xxx\")\nbackground_output(task_id=\"bg_yyy\")\n```\n\n**Anti-pattern**: Firing background tasks then doing nothing. Always continue productive work!\n\n---\n\n## Keyword Triggers (Power User)\n\nInclude these keywords in your prompt to unlock special modes:\n\n| Keyword | Effect |\n|---------|--------|\n| `ultrawork` or `ulw` | Maximum multi-agent coordination - aggressive parallel research |\n| `deep research` | Comprehensive exploration - fires 3-4 background agents |\n| `explore codebase` | Codebase mapping - multiple explorers in parallel |\n\n---\n\n## Session History Tools\n\nYou have tools to learn from past work sessions:\n\n| Tool | Use For |\n|------|---------|\n| `session_list` | List recent sessions to find relevant past work |\n| `session_search` | Search messages across sessions for how something was done |\n\n### When to Use Session Tools\n\n- **Before implementing unfamiliar features** \u2014 search if done before\n- **When user says \"like before\" or \"last time\"** \u2014 find that session\n- **When debugging** \u2014 check if similar issues were solved previously\n- **For context on ongoing projects** \u2014 understand recent work history\n\n### Example Usage\n\n```\n// Find how authentication was implemented before\nsession_search({ query: \"JWT authentication\" })\n\n// List recent sessions to understand project context\nsession_list({ limit: 5 })\n\n// Find past implementations of a feature\nsession_search({ query: \"rate limiting\" })\n```\n\n---\n\n## Code Intelligence Tools\n\nYou have tools to understand code structure via LSP:\n\n| Tool | Use For |\n|------|---------|\n| `find_symbols` | Search for functions, classes, variables by name |\n| `lsp_status` | Check which language servers are running |\n\n### When to Use Code Intelligence\n\n- **Before editing code** \u2014 find the symbol's definition location\n- **When refactoring** \u2014 search for related symbols\n- **To understand project structure** \u2014 search for key symbols like \"auth\", \"user\", \"api\"\n- **To verify LSP availability** \u2014 check if code intelligence is working\n\n### Example Usage\n\n```\n// Find all auth-related functions/classes\nfind_symbols({ query: \"auth\" })\n\n// Find a specific function\nfind_symbols({ query: \"handleLogin\" })\n\n// Check LSP server status\nlsp_status()\n```\n\n---\n\n## Todo Continuation\n\nThe system automatically reminds you if you go idle with incomplete tasks.\n\n**Best Practices:**\n- Keep your todo list updated with `TodoWrite`\n- Mark tasks complete immediately when finished\n- Use clear, actionable task descriptions\n- The system will prompt you to continue if tasks remain incomplete\n\n**Note:** You don't need to invoke the todo enforcer \u2014 it runs automatically when:\n- You have pending or in-progress todos\n- The session goes idle\n- There's been sufficient time since the last reminder\n";

package/dist/shared/agent-variant.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Agent Variant Handling
+ *
+ * Safely resolves and applies agent variants for thinking modes.
+ * Defensive implementation to prevent "undefined is not an object" errors.
+ */
+import type { ZenoxConfig } from "../config";
+/**
+ * Safely resolve agent variant from config
+ * Returns undefined if agent doesn't exist or has no variant configured
+ */
+export declare function resolveAgentVariant(config: ZenoxConfig, agentName?: string): string | undefined;
+/**
+ * Apply agent variant to message if configured
+ * Safe for undefined agents - simply does nothing
+ */
+export declare function applyAgentVariant(config: ZenoxConfig, agentName: string | undefined, message: {
+    variant?: string;
+}): void;

package/dist/shared/first-message-variant.d.ts

@@ -0,0 +1,34 @@
+/**
+ * First Message Variant Gate
+ *
+ * Tracks new sessions to apply variants only on the first message.
+ * Prevents variants from being applied to forked/child sessions.
+ */
+type SessionInfo = {
+    id?: string;
+    parentID?: string;
+};
+/**
+ * Creates a gate that tracks which sessions need variant applied on first message
+ */
+export declare function createFirstMessageVariantGate(): {
+    /**
+     * Mark a newly created session as pending variant application
+     * Only marks non-child sessions (no parentID)
+     */
+    markSessionCreated(info?: SessionInfo): void;
+    /**
+     * Check if this session should have variant overridden
+     */
+    shouldOverride(sessionID?: string): boolean;
+    /**
+     * Mark variant as applied for this session
+     */
+    markApplied(sessionID?: string): void;
+    /**
+     * Clear session from tracking (on session delete)
+     */
+    clear(sessionID?: string): void;
+};
+export type FirstMessageVariantGate = ReturnType<typeof createFirstMessageVariantGate>;
+export {};

package/dist/shared/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Shared utilities for zenox plugin
+ */
+export { resolveAgentVariant, applyAgentVariant } from "./agent-variant";
+export { createFirstMessageVariantGate, type FirstMessageVariantGate, } from "./first-message-variant";

package/dist/tools/code-intelligence/index.d.ts

@@ -0,0 +1 @@
+export { createCodeIntelligenceTools, type CodeIntelligenceTools } from "./tools";

package/dist/tools/code-intelligence/tools.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Code Intelligence Tools
+ *
+ * Tools for understanding code structure via LSP:
+ * - find_symbols: Search workspace symbols by name
+ * - lsp_status: Check LSP server health
+ */
+import { type ToolDefinition } from "@opencode-ai/plugin";
+import type { OpencodeClient } from "@opencode-ai/sdk";
+export type CodeIntelligenceTools = {
+    [key: string]: ToolDefinition;
+};
+export declare function createCodeIntelligenceTools(client: OpencodeClient): CodeIntelligenceTools;

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

@@ -0,0 +1 @@
+export { createSessionTools, type SessionTools } from "./tools";

package/dist/tools/session/tools.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Session Tools
+ *
+ * Tools for querying past sessions and learning from previous work:
+ * - session_list: List recent sessions
+ * - session_search: Search messages across sessions
+ */
+import { type ToolDefinition } from "@opencode-ai/plugin";
+import type { OpencodeClient } from "@opencode-ai/sdk";
+export type SessionTools = {
+    [key: string]: ToolDefinition;
+};
+export declare function createSessionTools(client: OpencodeClient): SessionTools;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zenox",
-  "version": "1.2.3",
+  "version": "1.4.0",
   "description": "OpenCode plugin with specialized agents (explorer, librarian, oracle, ui-planner), background tasks for parallel execution, and smart orchestration",
   "author": "Ayush",
   "license": "MIT",
@@ -40,6 +40,12 @@
     "ultrawork",
     "keyword-triggers",
     "toast-notifications",
+    "session-history",
+    "code-intelligence",
+    "lsp",
+    "todo-enforcer",
+    "thinking-modes",
+    "variants",
     "ai",
     "llm",
     "cli"