Merge origin/dev into feature/composio-tools-library

Integrate 58 commits from dev including:
- Composio gateway proxy (routes through Rowboat API when signed in)
- Gmail/Calendar sync triggers on OAuth callback
- Account, Connected Accounts, Note Tagging settings tabs
- Rowboat model gateway support
- app-navigation and save-to-memory builtin tools
- Voice mode, billing, inline tasks, agent notes

Resolved conflicts by keeping both sides:
- types.ts: z.string().optional() (resilient + optional)
- client.ts: updated listToolkitToolsDetailed to use new auth pattern
- builtin-tools.ts: kept composio dynamic tool registration imports
- instructions.ts: kept both new tools and composio tools prompt
- composio-handler.ts: merged all imports from both sides
- ipc.ts: kept tools library + useComposioForGoogle handlers
- settings-dialog.tsx: kept all new tabs (account, connected-accounts,
  note-tagging) alongside tools library tab

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

apps/x/packages/core/src/account/account.ts

@@ -0,0 +1,8 @@
+import container from '../di/container.js';
+import { IOAuthRepo } from '../auth/repo.js';
+
+export async function isSignedIn(): Promise<boolean> {
+    const oauthRepo = container.resolve<IOAuthRepo>('oauthRepo');
+    const { tokens } = await oauthRepo.read('rowboat');
+    return !!tokens;
+}

apps/x/packages/core/src/agents/runtime.ts

@@ -2,7 +2,6 @@ import { jsonSchema, ModelMessage } from "ai";
 import fs from "fs";
 import path from "path";
 import { WorkDir } from "../config/config.js";
-import { getNoteCreationStrictness } from "../config/note_creation_config.js";
 import { Agent, ToolAttachment } from "@x/shared/dist/agent.js";
 import { AssistantContentPart, AssistantMessage, Message, MessageList, ProviderOptions, ToolCallPart, ToolMessage } from "@x/shared/dist/message.js";
 import { LanguageModel, stepCountIs, streamText, tool, Tool, ToolSet } from "ai";
@@ -17,6 +16,8 @@ import { isBlocked, extractCommandNames } from "../application/lib/command-execu
 import container from "../di/container.js";
 import { IModelConfigRepo } from "../models/repo.js";
 import { createProvider } from "../models/models.js";
+import { isSignedIn } from "../account/account.js";
+import { getGatewayProvider } from "../models/gateway.js";
 import { IAgentsRepo } from "./repo.js";
 import { IMonotonicallyIncreasingIdGenerator } from "../application/lib/id-gen.js";
 import { IBus } from "../application/lib/bus.js";
@@ -26,9 +27,65 @@ import { IRunsLock } from "../runs/lock.js";
 import { IAbortRegistry } from "../runs/abort-registry.js";
 import { PrefixLogger } from "@x/shared";
 import { parse } from "yaml";
-import { raw as noteCreationMediumRaw } from "../knowledge/note_creation_medium.js";
-import { raw as noteCreationLowRaw } from "../knowledge/note_creation_low.js";
-import { raw as noteCreationHighRaw } from "../knowledge/note_creation_high.js";
+import { getRaw as getNoteCreationRaw } from "../knowledge/note_creation.js";
+import { getRaw as getLabelingAgentRaw } from "../knowledge/labeling_agent.js";
+import { getRaw as getNoteTaggingAgentRaw } from "../knowledge/note_tagging_agent.js";
+import { getRaw as getInlineTaskAgentRaw } from "../knowledge/inline_task_agent.js";
+import { getRaw as getAgentNotesAgentRaw } from "../knowledge/agent_notes_agent.js";
+
+const AGENT_NOTES_DIR = path.join(WorkDir, 'knowledge', 'Agent Notes');
+
+function loadAgentNotesContext(): string | null {
+    const sections: string[] = [];
+
+    const userFile = path.join(AGENT_NOTES_DIR, 'user.md');
+    const prefsFile = path.join(AGENT_NOTES_DIR, 'preferences.md');
+
+    try {
+        if (fs.existsSync(userFile)) {
+            const content = fs.readFileSync(userFile, 'utf-8').trim();
+            if (content) {
+                sections.push(`## About the User\nThese are notes you took about the user in previous chats.\n\n${content}`);
+            }
+        }
+    } catch { /* ignore */ }
+
+    try {
+        if (fs.existsSync(prefsFile)) {
+            const content = fs.readFileSync(prefsFile, 'utf-8').trim();
+            if (content) {
+                sections.push(`## User Preferences\nThese are notes you took on their general preferences.\n\n${content}`);
+            }
+        }
+    } catch { /* ignore */ }
+
+    // List other Agent Notes files for on-demand access
+    const otherFiles: string[] = [];
+    const skipFiles = new Set(['user.md', 'preferences.md', 'inbox.md']);
+    try {
+        if (fs.existsSync(AGENT_NOTES_DIR)) {
+            function listMdFiles(dir: string, prefix: string) {
+                for (const entry of fs.readdirSync(dir)) {
+                    const fullPath = path.join(dir, entry);
+                    const stat = fs.statSync(fullPath);
+                    if (stat.isDirectory()) {
+                        listMdFiles(fullPath, `${prefix}${entry}/`);
+                    } else if (entry.endsWith('.md') && !skipFiles.has(`${prefix}${entry}`)) {
+                        otherFiles.push(`${prefix}${entry}`);
+                    }
+                }
+            }
+            listMdFiles(AGENT_NOTES_DIR, '');
+        }
+    } catch { /* ignore */ }
+
+    if (otherFiles.length > 0) {
+        sections.push(`## More Specific Preferences\nFor more specific preferences, you can read these files using workspace-readFile. Only read them when relevant to the current task.\n\n${otherFiles.map(f => `- knowledge/Agent Notes/${f}`).join('\n')}`);
+    }
+
+    if (sections.length === 0) return null;
+    return `# Agent Memory\n\n${sections.join('\n\n')}`;
+}
 
 export interface IAgentRuntime {
     trigger(runId: string): Promise<void>;
@@ -320,24 +377,12 @@ export async function loadAgent(id: string): Promise<z.infer<typeof Agent>> {
             tools[name] = { type: "builtin", name };
         }
         // Rebuild instructions to include current Composio tools section
-        const instructions = buildCopilotInstructions();
+        const instructions = await buildCopilotInstructions();
         return { ...CopilotAgent, tools, instructions };
     }
 
     if (id === 'note_creation') {
-        const strictness = getNoteCreationStrictness();
-        let raw = '';
-        switch (strictness) {
-            case 'medium':
-                raw = noteCreationMediumRaw;
-                break;
-            case 'low':
-                raw = noteCreationLowRaw;
-                break;
-            case 'high':
-                raw = noteCreationHighRaw;
-                break;
-        }
+        const raw = getNoteCreationRaw();
         let agent: z.infer<typeof Agent> = {
             name: id,
             instructions: raw,
@@ -362,6 +407,106 @@ export async function loadAgent(id: string): Promise<z.infer<typeof Agent>> {
         return agent;
     }
 
+    if (id === 'labeling_agent') {
+        const labelingAgentRaw = getLabelingAgentRaw();
+        let agent: z.infer<typeof Agent> = {
+            name: id,
+            instructions: labelingAgentRaw,
+        };
+
+        if (labelingAgentRaw.startsWith("---")) {
+            const end = labelingAgentRaw.indexOf("\n---", 3);
+            if (end !== -1) {
+                const fm = labelingAgentRaw.slice(3, end).trim();
+                const content = labelingAgentRaw.slice(end + 4).trim();
+                const yaml = parse(fm);
+                const parsed = Agent.omit({ name: true, instructions: true }).parse(yaml);
+                agent = {
+                    ...agent,
+                    ...parsed,
+                    instructions: content,
+                };
+            }
+        }
+
+        return agent;
+    }
+
+    if (id === 'note_tagging_agent') {
+        const noteTaggingAgentRaw = getNoteTaggingAgentRaw();
+        let agent: z.infer<typeof Agent> = {
+            name: id,
+            instructions: noteTaggingAgentRaw,
+        };
+
+        if (noteTaggingAgentRaw.startsWith("---")) {
+            const end = noteTaggingAgentRaw.indexOf("\n---", 3);
+            if (end !== -1) {
+                const fm = noteTaggingAgentRaw.slice(3, end).trim();
+                const content = noteTaggingAgentRaw.slice(end + 4).trim();
+                const yaml = parse(fm);
+                const parsed = Agent.omit({ name: true, instructions: true }).parse(yaml);
+                agent = {
+                    ...agent,
+                    ...parsed,
+                    instructions: content,
+                };
+            }
+        }
+
+        return agent;
+    }
+
+    if (id === 'inline_task_agent') {
+        const inlineTaskAgentRaw = getInlineTaskAgentRaw();
+        let agent: z.infer<typeof Agent> = {
+            name: id,
+            instructions: inlineTaskAgentRaw,
+        };
+
+        if (inlineTaskAgentRaw.startsWith("---")) {
+            const end = inlineTaskAgentRaw.indexOf("\n---", 3);
+            if (end !== -1) {
+                const fm = inlineTaskAgentRaw.slice(3, end).trim();
+                const content = inlineTaskAgentRaw.slice(end + 4).trim();
+                const yaml = parse(fm);
+                const parsed = Agent.omit({ name: true, instructions: true }).parse(yaml);
+                agent = {
+                    ...agent,
+                    ...parsed,
+                    instructions: content,
+                };
+            }
+        }
+
+        return agent;
+    }
+
+    if (id === 'agent_notes_agent') {
+        const agentNotesAgentRaw = getAgentNotesAgentRaw();
+        let agent: z.infer<typeof Agent> = {
+            name: id,
+            instructions: agentNotesAgentRaw,
+        };
+
+        if (agentNotesAgentRaw.startsWith("---")) {
+            const end = agentNotesAgentRaw.indexOf("\n---", 3);
+            if (end !== -1) {
+                const fm = agentNotesAgentRaw.slice(3, end).trim();
+                const content = agentNotesAgentRaw.slice(end + 4).trim();
+                const yaml = parse(fm);
+                const parsed = Agent.omit({ name: true, instructions: true }).parse(yaml);
+                agent = {
+                    ...agent,
+                    ...parsed,
+                    instructions: content,
+                };
+            }
+        }
+
+        return agent;
+    }
+
     const repo = container.resolve<IAgentsRepo>('agentsRepo');
     return await repo.fetch(id);
 }
@@ -714,11 +859,21 @@ export async function* streamAgent({
     const tools = await buildTools(agent);
 
     // set up provider + model
-    const provider = createProvider(modelConfig.provider);
-    const knowledgeGraphAgents = ["note_creation", "email-draft", "meeting-prep"];
-    const modelId = (knowledgeGraphAgents.includes(state.agentName!) && modelConfig.knowledgeGraphModel)
-        ? modelConfig.knowledgeGraphModel
-        : modelConfig.model;
+    const signedIn = await isSignedIn();
+    const provider = signedIn
+        ? await getGatewayProvider()
+        : createProvider(modelConfig.provider);
+    const knowledgeGraphAgents = ["note_creation", "email-draft", "meeting-prep", "labeling_agent", "note_tagging_agent", "agent_notes_agent"];
+    const isKgAgent = knowledgeGraphAgents.includes(state.agentName!);
+    const isInlineTaskAgent = state.agentName === "inline_task_agent";
+    const defaultModel = signedIn ? "gpt-5.4" : modelConfig.model;
+    const defaultKgModel = signedIn ? "gpt-5.4-mini" : defaultModel;
+    const defaultInlineTaskModel = signedIn ? "gpt-5.4-mini" : defaultModel;
+    const modelId = isInlineTaskAgent
+        ? defaultInlineTaskModel
+        : (isKgAgent && modelConfig.knowledgeGraphModel)
+            ? modelConfig.knowledgeGraphModel
+            : isKgAgent ? defaultKgModel : defaultModel;
     const model = provider.languageModel(modelId);
     logger.log(`using model: ${modelId}`);
 
@@ -836,11 +991,23 @@ export async function* streamAgent({
         }
 
         // get any queued user messages
+        let voiceInput = false;
+        let voiceOutput: 'summary' | 'full' | null = null;
+        let searchEnabled = false;
         while (true) {
             const msg = await messageQueue.dequeue(runId);
             if (!msg) {
                 break;
             }
+            if (msg.voiceInput) {
+                voiceInput = true;
+            }
+            if (msg.searchEnabled) {
+                searchEnabled = true;
+            }
+            if (msg.voiceOutput) {
+                voiceOutput = msg.voiceOutput;
+            }
             loopLogger.log('dequeued user message', msg.messageId);
             yield* processEvent({
                 runId,
@@ -880,7 +1047,29 @@ export async function* streamAgent({
             minute: '2-digit',
             timeZoneName: 'short'
         });
-        const instructionsWithDateTime = `Current date and time: ${currentDateTime}\n\n${agent.instructions}`;
+        let instructionsWithDateTime = `Current date and time: ${currentDateTime}\n\n${agent.instructions}`;
+        // Inject Agent Notes context for copilot
+        if (state.agentName === 'copilot' || state.agentName === 'rowboatx') {
+            const agentNotesContext = loadAgentNotesContext();
+            if (agentNotesContext) {
+                instructionsWithDateTime += `\n\n${agentNotesContext}`;
+            }
+        }
+        if (voiceInput) {
+            loopLogger.log('voice input enabled, injecting voice input prompt');
+            instructionsWithDateTime += `\n\n# Voice Input\nThe user's message was transcribed from speech. Be aware that:\n- There may be transcription errors. Silently correct obvious ones (e.g. homophones, misheard words). If an error is genuinely ambiguous, briefly mention your interpretation (e.g. "I'm assuming you meant X").\n- Spoken messages are often long-winded. The user may ramble, repeat themselves, or correct something they said earlier in the same message. Focus on their final intent, not every word verbatim.`;
+        }
+        if (voiceOutput === 'summary') {
+            loopLogger.log('voice output enabled (summary mode), injecting voice output prompt');
+            instructionsWithDateTime += `\n\n# Voice Output (MANDATORY)\nThe user has voice output enabled. You MUST start your response with <voice></voice> tags that provide a spoken summary and guide to your written response. This is NOT optional — every response MUST begin with <voice> tags.\n\nRules:\n1. ALWAYS start your response with one or more <voice> tags. Never skip them.\n2. Place ALL <voice> tags at the BEGINNING of your response, before any detailed content. Do NOT intersperse <voice> tags throughout the response.\n3. Wrap EACH spoken sentence in its own separate <voice> tag so it can be spoken incrementally. Do NOT wrap everything in a single <voice> block.\n4. Use voice as a TL;DR and navigation aid — do NOT read the entire response aloud.\n\nExample — if the user asks "what happened in my meeting with Sarah yesterday?":\n<voice>Your meeting with Sarah covered three main things: the Q2 roadmap timeline, hiring for the backend role, and the client demo next week.</voice>\n<voice>I've pulled out the key details and action items below — the demo prep notes are at the end.</voice>\n\n## Meeting with Sarah — March 11\n(Then the full detailed written response follows without any more <voice> tags.)\n\nAny text outside <voice> tags is shown visually but not spoken.`;
+        } else if (voiceOutput === 'full') {
+            loopLogger.log('voice output enabled (full mode), injecting voice output prompt');
+            instructionsWithDateTime += `\n\n# Voice Output — Full Read-Aloud (MANDATORY)\nThe user wants your ENTIRE response spoken aloud. You MUST wrap your full response in <voice></voice> tags. This is NOT optional.\n\nRules:\n1. Wrap EACH sentence in its own separate <voice> tag so it can be spoken incrementally.\n2. Write your response in a natural, conversational style suitable for listening — no markdown headings, bullet points, or formatting symbols. Use plain spoken language.\n3. Structure the content as if you are speaking to the user directly. Use transitions like "first", "also", "one more thing" instead of visual formatting.\n4. Every sentence MUST be inside a <voice> tag. Do not leave any content outside <voice> tags.\n\nExample:\n<voice>Your meeting with Sarah covered three main things.</voice>\n<voice>First, you discussed the Q2 roadmap timeline and agreed to push the launch to April.</voice>\n<voice>Second, you talked about hiring for the backend role — Sarah will send over two candidates by Friday.</voice>\n<voice>And lastly, the client demo is next week on Thursday at 2pm, and you're handling the intro slides.</voice>`;
+        }
+        if (searchEnabled) {
+            loopLogger.log('search enabled, injecting search prompt');
+            instructionsWithDateTime += `\n\n# Search\nThe user has requested a search. Load the search skill and use web search or research search as needed to answer their query.`;
+        }
         let streamError: string | null = null;
         for await (const event of streamLlm(
             model,

apps/x/packages/core/src/application/assistant/instructions.ts

@@ -1,5 +1,4 @@
-import { skillCatalog } from "./skills/index.js";
-import { WorkDir as BASE_DIR } from "../../config/config.js";
+import { skillCatalog } from "./skills/index.js"; // eslint-disable-line @typescript-eslint/no-unused-vars -- used in template literal
 import { getRuntimeContext, getRuntimeContextPrompt } from "./runtime-context.js";
 import { composioEnabledToolsRepo } from "../../composio/enabled-tools-repo.js";
 import { composioAccountsRepo } from "../../composio/repo.js";
@@ -11,8 +10,8 @@ const runtimeContextPrompt = getRuntimeContextPrompt(getRuntimeContext());
  * Generate dynamic instructions section for Composio tools.
  * Returns empty string if no tools are enabled.
  */
-function getComposioToolsPrompt(): string {
-    if (!isComposioConfigured()) return '';
+async function getComposioToolsPrompt(): Promise<string> {
+    if (!(await isComposioConfigured())) return '';
 
     const enabledTools = composioEnabledToolsRepo.getAll();
     const toolEntries = Object.values(enabledTools);
@@ -80,7 +79,33 @@ Rowboat is an agentic assistant for everyday work - emails, meetings, projects,
 
 **Document Collaboration:** When users ask you to work on a document, collaborate on writing, create a new document, edit/refine existing notes, or say things like "let's work on [X]", "help me write [X]", "create a doc for [X]", or "let's draft [X]", you MUST load the \`doc-collab\` skill first. This is required for any document creation or editing task. The skill provides structured guidance for creating, editing, and refining documents in the knowledge base.
 
-**Slack:** When users ask about Slack messages, want to send messages to teammates, check channel conversations, or find someone on Slack, load the \`slack\` skill. You can send messages, view channel history, search conversations, and find users. Always check if Slack is connected first with \`slack-checkConnection\`, and always show message drafts to the user before sending.
+**App Control:** When users ask you to open notes, show the bases or graph view, filter or search notes, or manage saved views, load the \`app-navigation\` skill first. It provides structured guidance for navigating the app UI and controlling the knowledge base view.
+
+**Slack:** When users ask about Slack messages, want to send messages to teammates, check channel conversations, or find someone on Slack, load the \`slack\` skill. You can send messages, view channel history, search conversations, and find users. Always show message drafts to the user before sending.
+
+## Learning About the User (save-to-memory)
+
+Use the \`save-to-memory\` tool to note things worth remembering about the user. This builds a persistent profile that helps you serve them better over time. Call it proactively — don't ask permission.
+
+**When to save:**
+- User states a preference: "I prefer bullet points"
+- User corrects your style: "too formal, keep it casual"
+- You learn about their relationships: "Monica is my co-founder"
+- You notice workflow patterns: "no meetings before 11am"
+- User gives explicit instructions: "never use em-dashes"
+- User has preferences for specific tasks: "pitch decks should be minimal, max 12 slides"
+
+**Capture context, not blanket rules:**
+- BAD: "User prefers casual tone" — this loses important context
+- GOOD: "User prefers casual tone with internal team (Ramnique, Monica) but formal/polished with investors (Brad, Dalton)"
+- BAD: "User likes short emails" — too vague
+- GOOD: "User sends very terse 1-2 line emails to co-founder Ramnique, but writes structured 2-3 paragraph emails to investors with proper greetings"
+- Always note WHO or WHAT CONTEXT a preference applies to. Most preferences are situational, not universal.
+
+**When NOT to save:**
+- Ephemeral task details ("draft an email about X")
+- Things already in the knowledge graph
+- Information you can derive from reading their notes
 
 ## Memory That Compounds
 Unlike other AI assistants that start cold every session, you have access to a live knowledge graph that updates itself from Gmail, calendar, and meeting notes (Google Meet, Granola, Fireflies). This isn't just summaries - it's structured extraction of decisions, commitments, open questions, and context, routed to long-lived notes for each person, project, and topic.
@@ -231,6 +256,8 @@ ${runtimeContextPrompt}
 - \`loadSkill\` - Skill loading
 - \`slack-checkConnection\`, \`slack-listAvailableTools\`, \`slack-executeAction\` - Slack integration (requires Slack to be connected via Composio). Use \`slack-listAvailableTools\` first to discover available tool slugs, then \`slack-executeAction\` to execute them.
 - \`web-search\` and \`research-search\` - Web and research search tools (available when configured). **You MUST load the \`web-search\` skill before using either of these tools.** It tells you which tool to pick and how many searches to do.
+- \`app-navigation\` - Control the app UI: open notes, switch views, filter/search the knowledge base, manage saved views. **Load the \`app-navigation\` skill before using this tool.**
+- \`save-to-memory\` - Save observations about the user to the agent memory system. Use this proactively during conversations.
 - **Composio tools** (\`composio-*\`) — External service integrations enabled by the user in Settings > Tools Library. These connect to third-party apps like Gmail, GitHub, Linear, Notion, etc. See the "Composio Integration Tools" section below for available tools.
 
 **Prefer these tools whenever possible** — they work instantly with zero friction. For file operations inside \`~/.rowboat/\`, always use these instead of \`executeCommand\`.
@@ -276,8 +303,8 @@ Never output raw file paths in plain text when they could be wrapped in a filepa
  * Build full copilot instructions with dynamic Composio tools section.
  * Called each time the agent is loaded to reflect currently enabled tools.
  */
-export function buildCopilotInstructions(): string {
-    const composioPrompt = getComposioToolsPrompt();
+export async function buildCopilotInstructions(): Promise<string> {
+    const composioPrompt = await getComposioToolsPrompt();
     if (!composioPrompt) return CopilotInstructions;
     return CopilotInstructions + '\n' + composioPrompt;
 }

apps/x/packages/core/src/application/assistant/skills/app-navigation/skill.ts

@@ -0,0 +1,82 @@
+export const skill = String.raw`
+# App Navigation Skill
+
+You have access to the **app-navigation** tool which lets you control the Rowboat UI directly — opening notes, switching views, filtering the knowledge base, and creating saved views.
+
+## Actions
+
+### open-note
+Open a specific knowledge file in the editor pane.
+
+**When to use:** When the user asks to see, open, or view a specific note (e.g., "open John's note", "show me the Acme project page").
+
+**Parameters:**
+- ` + "`path`" + `: Full workspace-relative path (e.g., ` + "`knowledge/People/John Smith.md`" + `)
+
+**Tips:**
+- Use ` + "`workspace-grep`" + ` first to find the exact path if you're unsure of the filename.
+- Always pass the full ` + "`knowledge/...`" + ` path, not just the filename.
+
+### open-view
+Switch the UI to the graph or bases view.
+
+**When to use:** When the user asks to see the knowledge graph, view all notes, or open the bases/table view.
+
+**Parameters:**
+- ` + "`view`" + `: ` + "`\"graph\"`" + ` or ` + "`\"bases\"`" + `
+
+### update-base-view
+Change filters, columns, sort order, or search in the bases (table) view.
+
+**When to use:** When the user asks to find, filter, sort, or search notes. Examples: "show me all active customers", "filter by topic=hiring", "sort by name", "search for pricing".
+
+**Parameters:**
+- ` + "`filters`" + `: Object with ` + "`set`" + `, ` + "`add`" + `, ` + "`remove`" + `, or ` + "`clear`" + ` — each takes an array of ` + "`{ category, value }`" + ` pairs.
+  - ` + "`set`" + `: Replace ALL current filters with these.
+  - ` + "`add`" + `: Append filters without removing existing ones.
+  - ` + "`remove`" + `: Remove specific filters.
+  - ` + "`clear: true`" + `: Remove all filters.
+- ` + "`columns`" + `: Object with ` + "`set`" + `, ` + "`add`" + `, or ` + "`remove`" + ` — each takes an array of column names (frontmatter keys).
+- ` + "`sort`" + `: ` + "`{ field, dir }`" + ` where dir is ` + "`\"asc\"`" + ` or ` + "`\"desc\"`" + `.
+- ` + "`search`" + `: Free-text search string.
+
+**Tips:**
+- If unsure what categories/values are available, call ` + "`get-base-state`" + ` first.
+- For "show me X", prefer ` + "`filters.set`" + ` to start fresh rather than ` + "`filters.add`" + `.
+- Categories come from frontmatter keys (e.g., relationship, status, topic, type).
+- **CRITICAL: Do NOT pass ` + "`columns`" + ` unless the user explicitly asks to show/hide specific columns.** Omit the ` + "`columns`" + ` parameter entirely when only filtering, sorting, or searching. Passing ` + "`columns`" + ` will override the user's current column layout and can make the view appear empty.
+
+### get-base-state
+Retrieve information about what's in the knowledge base — available filter categories, values, and note count.
+
+**When to use:** When you need to know what properties exist before filtering, or when the user asks "what can I filter by?", "how many notes are there?", etc.
+
+**Parameters:**
+- ` + "`base_name`" + ` (optional): Name of a saved base to inspect.
+
+### create-base
+Save the current view configuration as a named base.
+
+**When to use:** When the user asks to save a filtered view, create a saved search, or says "save this as [name]".
+
+**Parameters:**
+- ` + "`name`" + `: Human-readable name for the base.
+
+## Workflow Example
+
+1. User: "Show me all people who are customers"
+2. First, check what properties are available:
+   ` + "`app-navigation({ action: \"get-base-state\" })`" + `
+3. Apply filters based on the available properties:
+   ` + "`app-navigation({ action: \"update-base-view\", filters: { set: [{ category: \"relationship\", value: \"customer\" }] } })`" + `
+4. If the user wants to save it:
+   ` + "`app-navigation({ action: \"create-base\", name: \"Customers\" })`" + `
+
+## Important Notes
+- The ` + "`update-base-view`" + ` action will automatically navigate to the bases view if the user isn't already there.
+- ` + "`open-note`" + ` validates that the file exists before navigating.
+- Filter categories and values come from frontmatter in knowledge files.
+- **Never send ` + "`columns`" + ` or ` + "`sort`" + ` with ` + "`update-base-view`" + ` unless the user specifically asks to change them.** Only pass the parameters you intend to change — omitted parameters are left untouched.
+`;
+
+export default skill;

apps/x/packages/core/src/application/assistant/skills/doc-collab/skill.ts

@@ -173,6 +173,56 @@ Documents are stored in \`~/.rowboat/knowledge/\` with subfolders:
 - \`Topics/\` - Subject matter notes
 - Root level for general documents
 
+## Rich Blocks
+
+Notes support rich block types beyond standard Markdown. Blocks are fenced code blocks with a language identifier and a JSON body. Use these when the user asks for visual content like charts, tables, images, or embeds.
+
+### Image Block
+Displays an image with optional alt text and caption.
+\`\`\`image
+{"src": "https://example.com/photo.png", "alt": "Description", "caption": "Optional caption"}
+\`\`\`
+- \`src\` (required): URL or relative path to the image
+- \`alt\` (optional): Alt text
+- \`caption\` (optional): Caption displayed below the image
+
+### Embed Block
+Embeds external content (YouTube videos, Figma designs, or generic links).
+\`\`\`embed
+{"provider": "youtube", "url": "https://www.youtube.com/watch?v=VIDEO_ID", "caption": "Video title"}
+\`\`\`
+- \`provider\` (required): \`"youtube"\`, \`"figma"\`, or \`"generic"\`
+- \`url\` (required): Full URL to the content
+- \`caption\` (optional): Caption displayed below the embed
+- YouTube and Figma render as iframes; generic shows a link card
+
+### Chart Block
+Renders a chart from inline data.
+\`\`\`chart
+{"chart": "bar", "title": "Q1 Revenue", "data": [{"month": "Jan", "revenue": 50000}, {"month": "Feb", "revenue": 62000}], "x": "month", "y": "revenue"}
+\`\`\`
+- \`chart\` (required): \`"line"\`, \`"bar"\`, or \`"pie"\`
+- \`title\` (optional): Chart title
+- \`data\` (optional): Array of objects with the data points
+- \`source\` (optional): Relative path to a JSON file containing the data array (alternative to inline data)
+- \`x\` (required): Key name for the x-axis / label field
+- \`y\` (required): Key name for the y-axis / value field
+
+### Table Block
+Renders a styled table from structured data.
+\`\`\`table
+{"title": "Team", "columns": ["name", "role"], "data": [{"name": "Alice", "role": "Eng"}, {"name": "Bob", "role": "Design"}]}
+\`\`\`
+- \`columns\` (required): Array of column names (determines display order)
+- \`data\` (required): Array of row objects
+- \`title\` (optional): Table title
+
+### Block Guidelines
+- The JSON must be valid and on a single line (no pretty-printing)
+- Insert blocks using \`workspace-editFile\` just like any other content
+- When the user asks for a chart, table, or embed — use blocks rather than plain Markdown tables or image links
+- When editing a note that already contains blocks, preserve them unless the user asks to change them
+
 ## Best Practices
 
 **Writing style:**

apps/x/packages/core/src/application/assistant/skills/index.ts

@@ -11,6 +11,7 @@ import slackSkill from "./slack/skill.js";
 import backgroundAgentsSkill from "./background-agents/skill.js";
 import createPresentationsSkill from "./create-presentations/skill.js";
 import webSearchSkill from "./web-search/skill.js";
+import appNavigationSkill from "./app-navigation/skill.js";
 
 const CURRENT_DIR = path.dirname(fileURLToPath(import.meta.url));
 const CATALOG_PREFIX = "src/application/assistant/skills";
@@ -95,6 +96,12 @@ const definitions: SkillDefinition[] = [
     summary: "Following the confirmation process before removing workflows or agents and their dependencies.",
     content: deletionGuardrailsSkill,
   },
+  {
+    id: "app-navigation",
+    title: "App Navigation",
+    summary: "Navigate the app UI - open notes, switch views, filter/search the knowledge base, and manage saved views.",
+    content: appNavigationSkill,
+  },
 ];
 
 const skillEntries = definitions.map((definition) => ({

apps/x/packages/core/src/application/assistant/skills/slack/skill.ts

@@ -1,121 +1,124 @@
-import { slackToolCatalogMarkdown } from "./tool-catalog.js";
-
 const skill = String.raw`
-# Slack Integration Skill
+# Slack Integration Skill (agent-slack CLI)
 
-You can interact with Slack to help users communicate with their team. This includes sending messages, viewing channel history, finding users, and searching conversations.
+You interact with Slack by running **agent-slack** commands through \`executeCommand\`.
 
-## Prerequisites
+---
+
+## 1. Check Connection
+
+Before any Slack operation, read \`~/.rowboat/config/slack.json\`. If \`enabled\` is \`false\` or the \`workspaces\` array is empty, simply tell the user: "Slack is not enabled. You can enable it in the Connectors settings." Do not attempt any agent-slack commands.
+
+If enabled, use the workspace URLs from the config for all commands.
+
+---
+
+## 2. Core Commands
+
+### Messages
+
+| Action | Command |
+|--------|---------|
+| List recent messages | \`agent-slack message list "#channel-name" --limit 25\` |
+| List thread replies | \`agent-slack message list "#channel" --thread-ts 1234567890.123456\` |
+| Get a single message | \`agent-slack message get "https://team.slack.com/archives/C.../p..."\` |
+| Send a message | \`agent-slack message send "#channel-name" "Hello team!"\` |
+| Reply in thread | \`agent-slack message send "#channel-name" "Reply text" --thread-ts 1234567890.123456\` |
+| Edit a message | \`agent-slack message edit "#channel-name" --ts 1234567890.123456 "Updated text"\` |
+| Delete a message | \`agent-slack message delete "#channel-name" --ts 1234567890.123456\` |
+
+**Targets** can be:
+- A full Slack URL: \`https://team.slack.com/archives/C01234567/p1234567890123456\`
+- A channel name: \`"#general"\` or \`"general"\`
+- A channel ID: \`C01234567\`
+
+### Reactions
 
-Before using Slack tools, ALWAYS check if Slack is connected:
 \`\`\`
-slack-checkConnection({})
+agent-slack message react add "<target>" <emoji> --ts <ts>
+agent-slack message react remove "<target>" <emoji> --ts <ts>
 \`\`\`
 
-If not connected, inform the user they need to connect Slack from the settings/onboarding.
+### Search
 
-## Available Tools
-
-### Check Connection
 \`\`\`
-slack-checkConnection({})
-\`\`\`
-Returns whether Slack is connected and ready to use.
-
-### List Users
-\`\`\`
-slack-listUsers({ limit: 100 })
-\`\`\`
-Lists users in the workspace. Use this to resolve a name to a user ID.
-
-### List DM Conversations
-\`\`\`
-slack-getDirectMessages({ limit: 50 })
-\`\`\`
-Lists DM channels (type "im"). Each entry includes the DM channel ID and the user ID.
-
-### List Channels
-\`\`\`
-slack-listChannels({ types: "public_channel,private_channel", limit: 100 })
-\`\`\`
-Lists channels the user has access to.
-
-### Get Conversation History
-\`\`\`
-slack-getChannelHistory({ channel: "C01234567", limit: 20 })
-\`\`\`
-Fetches recent messages for a channel or DM.
-
-### Search Messages
-\`\`\`
-slack-searchMessages({ query: "in:@username", count: 20 })
-\`\`\`
-Searches Slack messages using Slack search syntax.
-
-### Send a Message
-\`\`\`
-slack-sendMessage({ channel: "C01234567", text: "Hello team!" })
-\`\`\`
-Sends a message to a channel or DM. Always show the draft first.
-
-### Execute a Slack Action
-\`\`\`
-slack-executeAction({
-  toolSlug: "EXACT_TOOL_SLUG_FROM_DISCOVERY",
-  input: { /* tool-specific parameters */ }
-})
-\`\`\`
-Executes any Slack tool using its exact slug discovered from \`slack-listAvailableTools\`.
-
-### Discover Available Tools (Fallback)
-\`\`\`
-slack-listAvailableTools({ search: "conversation" })
-\`\`\`
-Lists available Slack tools from Composio. Use this only if a builtin Slack tool fails and you need a specific slug.
-
-## Composio Slack Tool Catalog (Pinned)
-Use the exact tool slugs below with \`slack-executeAction\` when needed. Prefer these over \`slack-listAvailableTools\` to avoid redundant discovery.
-
-${slackToolCatalogMarkdown}
-
-## Workflow
-
-### Step 1: Check Connection
-\`\`\`
-slack-checkConnection({})
+agent-slack search messages "query text" --limit 20
+agent-slack search messages "query" --channel "#channel-name" --user "@username"
+agent-slack search messages "query" --after 2025-01-01 --before 2025-02-01
+agent-slack search files "query" --limit 10
 \`\`\`
 
-### Step 2: Choose the Builtin Tool
-Use the builtin Slack tools above for common tasks. Only fall back to \`slack-listAvailableTools\` + \`slack-executeAction\` if something is missing.
+### Channels
 
-## Common Tasks
+\`\`\`
+agent-slack channel new --name "project-x" --workspace https://team.slack.com
+agent-slack channel new --name "secret-project" --private
+agent-slack channel invite --channel "#project-x" --users "@alice,@bob"
+\`\`\`
 
-### Find the Most Recent DM with Someone
-1. Search messages first: \`slack-searchMessages({ query: "in:@Name", count: 1 })\`
-2. If you need exact DM history:
-   - \`slack-listUsers({})\` to find the user ID
-   - \`slack-getDirectMessages({})\` to find the DM channel for that user
-   - \`slack-getChannelHistory({ channel: "D...", limit: 20 })\`
+### Users
 
-### Send a Message
-1. Draft the message and show it to the user
-2. ONLY after user approval, send using \`slack-sendMessage\`
+\`\`\`
+agent-slack user list --limit 200
+agent-slack user get "@username"
+agent-slack user get U01234567
+\`\`\`
 
-### Search Messages
-1. Use \`slack-searchMessages({ query: "...", count: 20 })\`
+### Canvases
+
+\`\`\`
+agent-slack canvas get "https://team.slack.com/docs/F01234567"
+agent-slack canvas get F01234567 --workspace https://team.slack.com
+\`\`\`
+
+---
+
+## 3. Multi-Workspace
+
+**Important:** The user has chosen which workspaces to use. Before your first Slack operation, read \`~/.rowboat/config/slack.json\` to see the selected workspaces. Only interact with workspaces listed in that config — ignore any other authenticated workspaces.
+
+If the selected workspace list contains multiple entries, use \`--workspace <url>\` to disambiguate:
+
+\`\`\`
+agent-slack message list "#general" --workspace https://team.slack.com
+\`\`\`
+
+If only one workspace is selected, always use \`--workspace\` with its URL to avoid ambiguity with other authenticated workspaces.
+
+---
+
+## 4. Token Budget Control
+
+Use \`--limit\` to control how many messages/results are returned. Use \`--max-body-chars\` or \`--max-content-chars\` to truncate long message bodies:
+
+\`\`\`
+agent-slack message list "#channel" --limit 10
+agent-slack search messages "query" --limit 5 --max-content-chars 2000
+\`\`\`
+
+---
+
+## 5. Discovering More Commands
+
+For any command you're unsure about:
+
+\`\`\`
+agent-slack --help
+agent-slack message --help
+agent-slack search --help
+agent-slack channel --help
+\`\`\`
+
+---
 
 ## Best Practices
 
-- **Always show drafts before sending** - Never send Slack messages without user confirmation
-- **Summarize, don't dump** - When showing channel history, summarize the key points
-- **Cross-reference with knowledge base** - Check if mentioned people have notes in the knowledge base
-
-## Error Handling
-
-If a Slack operation fails:
-1. Try \`slack-listAvailableTools\` to verify the tool slug is correct
-2. Check if Slack is still connected with \`slack-checkConnection\`
-3. Inform the user of the specific error
+- **Always show drafts before sending** — Never send Slack messages without user confirmation
+- **Summarize, don't dump** — When showing channel history, summarize the key points rather than pasting everything
+- **Prefer Slack URLs** — When referring to messages, use Slack URLs over raw channel names when available
+- **Use --limit** — Always set reasonable limits to keep output concise and token-efficient
+- **Resolve user IDs** — Messages contain raw user IDs like \`U078AHJP341\`. Resolve them to real names before presenting to the user. Batch all lookups into a single \`executeCommand\` call using \`;\` separators, e.g. \`agent-slack user get U078AHJP341 --workspace ... ; agent-slack user get U090UEZCEQ0 --workspace ...\`
+- **Cross-reference with knowledge base** — Check if mentioned people have notes in the knowledge base
 `;
 
 export default skill;

apps/x/packages/core/src/application/assistant/skills/slack/tool-catalog.ts

@@ -1,117 +0,0 @@
-export type SlackToolDefinition = {
-    name: string;
-    slug: string;
-    description: string;
-};
-
-export const slackToolCatalog: SlackToolDefinition[] = [
-    { name: "Add Emoji Alias", slug: "SLACK_ADD_AN_EMOJI_ALIAS_IN_SLACK", description: "Adds an alias for an existing custom emoji." },
-    { name: "Add Remote File", slug: "SLACK_ADD_A_REMOTE_FILE_FROM_A_SERVICE", description: "Adds a reference to an external file (e.g., GDrive, Dropbox) to Slack." },
-    { name: "Add Star to Item", slug: "SLACK_ADD_A_STAR_TO_AN_ITEM", description: "Stars a channel, file, comment, or message." },
-    { name: "Add Call Participants", slug: "SLACK_ADD_CALL_PARTICIPANTS", description: "Registers new participants added to a Slack call." },
-    { name: "Add Emoji", slug: "SLACK_ADD_EMOJI", description: "Adds a custom emoji to a workspace via a unique name and URL." },
-    { name: "Add Reaction", slug: "SLACK_ADD_REACTION_TO_AN_ITEM", description: "Adds a specified emoji reaction to a message." },
-    { name: "Archive Channel", slug: "SLACK_ARCHIVE_A_PUBLIC_OR_PRIVATE_CHANNEL", description: "Archives a public or private channel." },
-    { name: "Archive Conversation", slug: "SLACK_ARCHIVE_A_SLACK_CONVERSATION", description: "Archives a conversation by its ID." },
-    { name: "Close DM/MPDM", slug: "SLACK_CLOSE_DM_OR_MULTI_PERSON_DM", description: "Closes a DM or MPDM sidebar view for the user." },
-    { name: "Create Reminder", slug: "SLACK_CREATE_A_REMINDER", description: "Creates a reminder with text and time (natural language supported)." },
-    { name: "Create User Group", slug: "SLACK_CREATE_A_SLACK_USER_GROUP", description: "Creates a new user group (subteam)." },
-    { name: "Create Channel", slug: "SLACK_CREATE_CHANNEL", description: "Initiates a public or private channel conversation." },
-    { name: "Create Channel Conversation", slug: "SLACK_CREATE_CHANNEL_BASED_CONVERSATION", description: "Creates a new channel with specific org-wide or team settings." },
-    { name: "Customize URL Unfurl", slug: "SLACK_CUSTOMIZE_URL_UNFURL", description: "Defines custom content for URL previews in a specific message." },
-    { name: "Delete File Comment", slug: "SLACK_DELETE_A_COMMENT_ON_A_FILE", description: "Deletes a specific comment from a file." },
-    { name: "Delete File", slug: "SLACK_DELETE_A_FILE_BY_ID", description: "Permanently deletes a file by its ID." },
-    { name: "Delete Channel", slug: "SLACK_DELETE_A_PUBLIC_OR_PRIVATE_CHANNEL", description: "Irreversibly deletes a channel and its history (Enterprise only)." },
-    { name: "Delete Scheduled Message", slug: "SLACK_DELETE_A_SCHEDULED_MESSAGE_IN_A_CHAT", description: "Deletes a pending scheduled message." },
-    { name: "Delete Reminder", slug: "SLACK_DELETE_A_SLACK_REMINDER", description: "Deletes an existing reminder." },
-    { name: "Delete Message", slug: "SLACK_DELETES_A_MESSAGE_FROM_A_CHAT", description: "Deletes a message by channel ID and timestamp." },
-    { name: "Delete Profile Photo", slug: "SLACK_DELETE_USER_PROFILE_PHOTO", description: "Reverts the user's profile photo to the default avatar." },
-    { name: "Disable User Group", slug: "SLACK_DISABLE_AN_EXISTING_SLACK_USER_GROUP", description: "Disables (archives) a user group." },
-    { name: "Enable User Group", slug: "SLACK_ENABLE_A_SPECIFIED_USER_GROUP", description: "Reactivates a disabled user group." },
-    { name: "Share File Publicly", slug: "SLACK_ENABLE_PUBLIC_SHARING_OF_A_FILE", description: "Generates a public URL for a file." },
-    { name: "End Call", slug: "SLACK_END_A_CALL_WITH_DURATION_AND_ID", description: "Ends an ongoing call." },
-    { name: "End Snooze", slug: "SLACK_END_SNOOZE", description: "Ends the current user's snooze mode immediately." },
-    { name: "End DND Session", slug: "SLACK_END_USER_DO_NOT_DISTURB_SESSION", description: "Ends the current DND session." },
-    { name: "Fetch Bot Info", slug: "SLACK_FETCH_BOT_USER_INFORMATION", description: "Fetches metadata for a specific bot user." },
-    { name: "Fetch History", slug: "SLACK_FETCH_CONVERSATION_HISTORY", description: "Fetches chronological messages and events from a channel." },
-    { name: "Fetch Item Reactions", slug: "SLACK_FETCH_ITEM_REACTIONS", description: "Fetches all reactions for a message, file, or comment." },
-    { name: "Retrieve Replies", slug: "SLACK_FETCH_MESSAGE_THREAD_FROM_A_CONVERSATION", description: "Retrieves replies to a specific parent message." },
-    { name: "Fetch Team Info", slug: "SLACK_FETCH_TEAM_INFO", description: "Fetches comprehensive metadata about the team." },
-    { name: "Fetch Workspace Settings", slug: "SLACK_FETCH_WORKSPACE_SETTINGS_INFORMATION", description: "Retrieves detailed settings for a specific workspace." },
-    { name: "Find Channels", slug: "SLACK_FIND_CHANNELS", description: "Searches channels by name, topic, or purpose." },
-    { name: "Find User by Email", slug: "SLACK_FIND_USER_BY_EMAIL_ADDRESS", description: "Finds a user object using their email address." },
-    { name: "Find Users", slug: "SLACK_FIND_USERS", description: "Searches users by name, email, or display name." },
-    { name: "Get Conversation Preferences", slug: "SLACK_GET_CHANNEL_CONVERSATION_PREFERENCES", description: "Retrieves posting/threading preferences for a channel." },
-    { name: "Get Reminder Info", slug: "SLACK_GET_REMINDER_INFORMATION", description: "Retrieves detailed information for a specific reminder." },
-    { name: "Get Remote File", slug: "SLACK_GET_REMOTE_FILE", description: "Retrieves info about a previously added remote file." },
-    { name: "Get Team DND Status", slug: "SLACK_GET_TEAM_DND_STATUS", description: "Retrieves the DND status for specific users." },
-    { name: "Get User Presence", slug: "SLACK_GET_USER_PRESENCE_INFO", description: "Retrieves real-time presence (active/away)." },
-    { name: "Invite to Channel", slug: "SLACK_INVITE_USERS_TO_A_SLACK_CHANNEL", description: "Invites users to a channel by their user IDs." },
-    { name: "Invite to Workspace", slug: "SLACK_INVITE_USER_TO_WORKSPACE", description: "Invites a user to a workspace and channels via email." },
-    { name: "Join Conversation", slug: "SLACK_JOIN_AN_EXISTING_CONVERSATION", description: "Joins a conversation by channel ID." },
-    { name: "Leave Conversation", slug: "SLACK_LEAVE_A_CONVERSATION", description: "Leaves a conversation." },
-    { name: "List All Channels", slug: "SLACK_LIST_ALL_CHANNELS", description: "Lists all conversations with various filters." },
-    { name: "List All Users", slug: "SLACK_LIST_ALL_USERS", description: "Retrieves a paginated list of all users in the workspace." },
-    { name: "List User Group Members", slug: "SLACK_LIST_ALL_USERS_IN_A_USER_GROUP", description: "Lists all user IDs within a group." },
-    { name: "List Conversations", slug: "SLACK_LIST_CONVERSATIONS", description: "Retrieves conversations accessible to a specific user." },
-    { name: "List Files", slug: "SLACK_LIST_FILES_WITH_FILTERS_IN_SLACK", description: "Lists files and metadata with filtering options." },
-    { name: "List Reminders", slug: "SLACK_LIST_REMINDERS", description: "Lists all reminders for the authenticated user." },
-    { name: "List Remote Files", slug: "SLACK_LIST_REMOTE_FILES", description: "Retrieves info about a team's remote files." },
-    { name: "List Scheduled Messages", slug: "SLACK_LIST_SCHEDULED_MESSAGES", description: "Lists pending scheduled messages." },
-    { name: "List Pinned Items", slug: "SLACK_LISTS_PINNED_ITEMS_IN_A_CHANNEL", description: "Retrieves all messages/files pinned to a channel." },
-    { name: "List Starred Items", slug: "SLACK_LIST_STARRED_ITEMS", description: "Lists items starred by the user." },
-    { name: "List Custom Emojis", slug: "SLACK_LIST_TEAM_CUSTOM_EMOJIS", description: "Lists all workspace custom emojis and their URLs." },
-    { name: "List User Groups", slug: "SLACK_LIST_USER_GROUPS_FOR_TEAM_WITH_OPTIONS", description: "Lists user-created and default user groups." },
-    { name: "List User Reactions", slug: "SLACK_LIST_USER_REACTIONS", description: "Lists all reactions added by a specific user." },
-    { name: "List Admin Users", slug: "SLACK_LIST_WORKSPACE_USERS", description: "Retrieves a paginated list of workspace administrators." },
-    { name: "Set User Presence", slug: "SLACK_MANUALLY_SET_USER_PRESENCE", description: "Manually overrides automated presence status." },
-    { name: "Mark Reminder Complete", slug: "SLACK_MARK_REMINDER_AS_COMPLETE", description: "Marks a reminder as complete (deprecated by Slack in March 2023)." },
-    { name: "Open DM", slug: "SLACK_OPEN_DM", description: "Opens/resumes a DM or MPDM." },
-    { name: "Pin Item", slug: "SLACK_PINS_AN_ITEM_TO_A_CHANNEL", description: "Pins a message to a channel." },
-    { name: "Remove Remote File", slug: "SLACK_REMOVE_A_REMOTE_FILE", description: "Removes a reference to an external file." },
-    { name: "Remove Star", slug: "SLACK_REMOVE_A_STAR_FROM_AN_ITEM", description: "Unstars an item." },
-    { name: "Remove from Channel", slug: "SLACK_REMOVE_A_USER_FROM_A_CONVERSATION", description: "Removes a specified user from a conversation." },
-    { name: "Remove Call Participants", slug: "SLACK_REMOVE_CALL_PARTICIPANTS", description: "Registers the removal of participants from a call." },
-    { name: "Remove Reaction", slug: "SLACK_REMOVE_REACTION_FROM_ITEM", description: "Removes an emoji reaction from an item." },
-    { name: "Rename Conversation", slug: "SLACK_RENAME_A_CONVERSATION", description: "Renames a channel ID/Conversation." },
-    { name: "Rename Emoji", slug: "SLACK_RENAME_AN_EMOJI", description: "Renames a custom emoji." },
-    { name: "Rename Channel", slug: "SLACK_RENAME_A_SLACK_CHANNEL", description: "Renames a public or private channel." },
-    { name: "Retrieve Identity", slug: "SLACK_RETRIEVE_A_USER_S_IDENTITY_DETAILS", description: "Retrieves basic user/team identity details." },
-    { name: "Retrieve Call Info", slug: "SLACK_RETRIEVE_CALL_INFORMATION", description: "Retrieves a snapshot of a call's status." },
-    { name: "Retrieve Conversation Info", slug: "SLACK_RETRIEVE_CONVERSATION_INFORMATION", description: "Retrieves metadata for a specific conversation." },
-    { name: "Get Conversation Members", slug: "SLACK_RETRIEVE_CONVERSATION_MEMBERS_LIST", description: "Lists active user IDs in a conversation." },
-    { name: "Retrieve User DND", slug: "SLACK_RETRIEVE_CURRENT_USER_DND_STATUS", description: "Retrieves DND status for a user." },
-    { name: "Retrieve File Details", slug: "SLACK_RETRIEVE_DETAILED_INFORMATION_ABOUT_A_FILE", description: "Retrieves metadata and comments for a file." },
-    { name: "Retrieve User Details", slug: "SLACK_RETRIEVE_DETAILED_USER_INFORMATION", description: "Retrieves comprehensive info for a specific user ID." },
-    { name: "Get Message Permalink", slug: "SLACK_RETRIEVE_MESSAGE_PERMALINK_URL", description: "Gets the permalink URL for a specific message." },
-    { name: "Retrieve Team Profile", slug: "SLACK_RETRIEVE_TEAM_PROFILE_DETAILS", description: "Retrieves the profile field structure for a team." },
-    { name: "Retrieve User Profile", slug: "SLACK_RETRIEVE_USER_PROFILE_INFORMATION", description: "Retrieves specific profile info for a user." },
-    { name: "Revoke Public File", slug: "SLACK_REVOKE_PUBLIC_SHARING_ACCESS_FOR_A_FILE", description: "Revokes a file's public sharing URL." },
-    { name: "Schedule Message", slug: "SLACK_SCHEDULE_MESSAGE", description: "Schedules a message for a future time (up to 120 days)." },
-    { name: "Search Messages", slug: "SLACK_SEARCH_MESSAGES", description: "Workspace-wide message search with advanced filters." },
-    { name: "Send Ephemeral", slug: "SLACK_SEND_EPHEMERAL_MESSAGE", description: "Sends a message visible only to a specific user." },
-    { name: "Send Message", slug: "SLACK_SEND_MESSAGE", description: "Posts a message to a channel, DM, or group." },
-    { name: "Set Conversation Purpose", slug: "SLACK_SET_A_CONVERSATION_S_PURPOSE", description: "Updates the purpose description of a channel." },
-    { name: "Set DND Duration", slug: "SLACK_SET_DND_DURATION", description: "Turns on DND or changes its current duration." },
-    { name: "Set Profile Photo", slug: "SLACK_SET_PROFILE_PHOTO", description: "Sets the user's profile image with cropping." },
-    { name: "Set Read Cursor", slug: "SLACK_SET_READ_CURSOR_IN_A_CONVERSATION", description: "Marks a specific timestamp as read." },
-    { name: "Set User Profile", slug: "SLACK_SET_SLACK_USER_PROFILE_INFORMATION", description: "Updates individual or multiple user profile fields." },
-    { name: "Set Conversation Topic", slug: "SLACK_SET_THE_TOPIC_OF_A_CONVERSATION", description: "Updates the topic of a conversation." },
-    { name: "Share Me Message", slug: "SLACK_SHARE_A_ME_MESSAGE_IN_A_CHANNEL", description: "Sends a third-person user action message (/me)." },
-    { name: "Share Remote File", slug: "SLACK_SHARE_REMOTE_FILE_IN_CHANNELS", description: "Shares a registered remote file into channels." },
-    { name: "Start Call", slug: "SLACK_START_CALL", description: "Registers a new call for third-party integration." },
-    { name: "Start RTM Session", slug: "SLACK_START_REAL_TIME_MESSAGING_SESSION", description: "Initiates a real-time messaging WebSocket session." },
-    { name: "Unarchive Channel", slug: "SLACK_UNARCHIVE_A_PUBLIC_OR_PRIVATE_CHANNEL", description: "Unarchives a specific channel." },
-    { name: "Unarchive Conversation", slug: "SLACK_UNARCHIVE_CHANNEL", description: "Reverses archival for a conversation." },
-    { name: "Unpin Item", slug: "SLACK_UNPIN_ITEM_FROM_CHANNEL", description: "Unpins a message from a channel." },
-    { name: "Update User Group", slug: "SLACK_UPDATE_AN_EXISTING_SLACK_USER_GROUP", description: "Updates name, handle, or channels for a user group." },
-    { name: "Update Remote File", slug: "SLACK_UPDATES_AN_EXISTING_REMOTE_FILE", description: "Updates metadata for a remote file reference." },
-    { name: "Update Message", slug: "SLACK_UPDATES_A_SLACK_MESSAGE", description: "Modifies the content of an existing message." },
-    { name: "Update Call Info", slug: "SLACK_UPDATE_SLACK_CALL_INFORMATION", description: "Updates call title or join URLs." },
-    { name: "Update Group Members", slug: "SLACK_UPDATE_USER_GROUP_MEMBERS", description: "Replaces the member list of a user group." },
-    { name: "Upload File", slug: "SLACK_UPLOAD_OR_CREATE_A_FILE_IN_SLACK", description: "Uploads content or binary files to Slack." },
-];
-
-export const slackToolCatalogMarkdown = slackToolCatalog
-    .map((tool) => `- ${tool.name} (${tool.slug}) - ${tool.description}`)
-    .join("\n");

apps/x/packages/core/src/application/lib/builtin-tools.ts

@@ -14,12 +14,15 @@ import { IAgentsRepo } from "../../agents/repo.js";
 import { WorkDir } from "../../config/config.js";
 import { composioAccountsRepo } from "../../composio/repo.js";
 import { composioEnabledToolsRepo } from "../../composio/enabled-tools-repo.js";
-import { executeAction as executeComposioAction, isConfigured as isComposioConfigured, listToolkitTools } from "../../composio/client.js";
-import { slackToolCatalog } from "../assistant/skills/slack/tool-catalog.js";
+import { executeAction as executeComposioAction, isConfigured as isComposioConfigured } from "../../composio/client.js";
 import type { ToolContext } from "./exec-tool.js";
 import { generateText, jsonSchema } from "ai";
 import { createProvider } from "../../models/models.js";
 import { IModelConfigRepo } from "../../models/repo.js";
+import { isSignedIn } from "../../account/account.js";
+import { getGatewayProvider } from "../../models/gateway.js";
+import { getAccessToken } from "../../auth/tokens.js";
+import { API_URL } from "../../config/env.js";
 // Parser libraries are loaded dynamically inside parseFile.execute()
 // to avoid pulling pdfjs-dist's DOM polyfills into the main bundle.
 // Import paths are computed so esbuild cannot statically resolve them.
@@ -37,232 +40,6 @@ const BuiltinToolsSchema = z.record(z.string(), z.object({
     isAvailable: z.custom<() => Promise<boolean>>().optional(),
 }));
 
-type SlackToolHint = {
-    search?: string;
-    patterns: string[];
-    fallbackSlugs?: string[];
-    preferSlugIncludes?: string[];
-    excludePatterns?: string[];
-    minScore?: number;
-};
-
-const slackToolHints: Record<string, SlackToolHint> = {
-    sendMessage: {
-        search: "message",
-        patterns: ["send", "message", "channel"],
-        fallbackSlugs: [
-            "SLACK_SEND_MESSAGE",
-            "SLACK_SENDS_A_MESSAGE_TO_A_SLACK_CHANNEL",
-            "SLACK_SEND_A_MESSAGE",
-        ],
-    },
-    listConversations: {
-        search: "conversation",
-        patterns: ["list", "conversation", "channel"],
-        fallbackSlugs: [
-            "SLACK_LIST_CONVERSATIONS",
-            "SLACK_LIST_ALL_CHANNELS",
-            "SLACK_LIST_ALL_SLACK_TEAM_CHANNELS_WITH_VARIOUS_FILTERS",
-            "SLACK_LIST_CHANNELS",
-            "SLACK_LIST_CHANNEL",
-        ],
-        preferSlugIncludes: ["list", "conversation"],
-        minScore: 2,
-    },
-    getConversationHistory: {
-        search: "history",
-        patterns: ["history", "conversation", "message"],
-        fallbackSlugs: [
-            "SLACK_FETCH_CONVERSATION_HISTORY",
-            "SLACK_FETCHES_CONVERSATION_HISTORY",
-            "SLACK_GET_CONVERSATION_HISTORY",
-            "SLACK_GET_CHANNEL_HISTORY",
-        ],
-        preferSlugIncludes: ["history"],
-        minScore: 2,
-    },
-    listUsers: {
-        search: "user",
-        patterns: ["list", "user"],
-        fallbackSlugs: [
-            "SLACK_LIST_ALL_USERS",
-            "SLACK_LIST_ALL_SLACK_TEAM_USERS_WITH_PAGINATION",
-            "SLACK_LIST_USERS",
-            "SLACK_GET_USERS",
-            "SLACK_USERS_LIST",
-        ],
-        preferSlugIncludes: ["list", "user"],
-        excludePatterns: ["find", "by name", "by email", "by_email", "by_name", "lookup", "profile", "info"],
-        minScore: 2,
-    },
-    getUserInfo: {
-        search: "user",
-        patterns: ["user", "info", "profile"],
-        fallbackSlugs: [
-            "SLACK_GET_USER_INFO",
-            "SLACK_GET_USER",
-            "SLACK_USER_INFO",
-        ],
-        preferSlugIncludes: ["user", "info"],
-        minScore: 1,
-    },
-    searchMessages: {
-        search: "search",
-        patterns: ["search", "message"],
-        fallbackSlugs: [
-            "SLACK_SEARCH_FOR_MESSAGES_WITH_QUERY",
-            "SLACK_SEARCH_MESSAGES",
-            "SLACK_SEARCH_MESSAGE",
-        ],
-        preferSlugIncludes: ["search"],
-        minScore: 1,
-    },
-};
-
-const slackToolSlugCache = new Map<string, string>();
-
-const slackToolSlugOverrides: Partial<Record<keyof typeof slackToolHints, string>> = {
-    sendMessage: "SLACK_SEND_MESSAGE",
-    listConversations: "SLACK_LIST_CONVERSATIONS",
-    getConversationHistory: "SLACK_FETCH_CONVERSATION_HISTORY",
-    listUsers: "SLACK_LIST_ALL_USERS",
-    getUserInfo: "SLACK_RETRIEVE_DETAILED_USER_INFORMATION",
-    searchMessages: "SLACK_SEARCH_MESSAGES",
-};
-
-const compactObject = (input: Record<string, unknown>) =>
-    Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined));
-
-type SlackToolResult = { success: boolean; data?: unknown; error?: string };
-
-/** Helper to execute a Slack tool with consistent account validation and error handling */
-async function executeSlackTool(
-    hintKey: keyof typeof slackToolHints,
-    params: Record<string, unknown>
-): Promise<SlackToolResult> {
-    const account = composioAccountsRepo.getAccount('slack');
-    if (!account || account.status !== 'ACTIVE') {
-        return { success: false, error: 'Slack is not connected' };
-    }
-    try {
-        const toolSlug = await resolveSlackToolSlug(hintKey);
-        return await executeComposioAction(toolSlug, account.id, compactObject(params));
-    } catch (error) {
-        return {
-            success: false,
-            error: error instanceof Error ? error.message : 'Unknown error',
-        };
-    }
-}
-
-const normalizeSlackTool = (tool: { slug: string; name?: string; description?: string }) =>
-    `${tool.slug} ${tool.name || ""} ${tool.description || ""}`.toLowerCase();
-
-const scoreSlackTool = (tool: { slug: string; name?: string; description?: string }, patterns: string[]) => {
-    const slug = tool.slug.toLowerCase();
-    const name = (tool.name || "").toLowerCase();
-    const description = (tool.description || "").toLowerCase();
-
-    let score = 0;
-    for (const pattern of patterns) {
-        const needle = pattern.toLowerCase();
-        if (slug.includes(needle)) score += 3;
-        if (name.includes(needle)) score += 2;
-        if (description.includes(needle)) score += 1;
-    }
-    return score;
-};
-
-const pickSlackTool = (
-    tools: Array<{ slug: string; name?: string; description?: string }>,
-    hint: SlackToolHint,
-) => {
-    let candidates = tools;
-
-    if (hint.excludePatterns && hint.excludePatterns.length > 0) {
-        candidates = candidates.filter((tool) => {
-            const haystack = normalizeSlackTool(tool);
-            return !hint.excludePatterns!.some((pattern) => haystack.includes(pattern.toLowerCase()));
-        });
-    }
-
-    if (hint.preferSlugIncludes && hint.preferSlugIncludes.length > 0) {
-        const preferred = candidates.filter((tool) =>
-            hint.preferSlugIncludes!.every((pattern) => tool.slug.toLowerCase().includes(pattern.toLowerCase()))
-        );
-        if (preferred.length > 0) {
-            candidates = preferred;
-        }
-    }
-
-    let best: { slug: string; name?: string; description?: string } | null = null;
-    let bestScore = 0;
-
-    for (const tool of candidates) {
-        const score = scoreSlackTool(tool, hint.patterns);
-        if (score > bestScore) {
-            bestScore = score;
-            best = tool;
-        }
-    }
-
-    if (!best || (hint.minScore !== undefined && bestScore < hint.minScore)) {
-        return null;
-    }
-
-    return best;
-};
-
-const resolveSlackToolSlug = async (hintKey: keyof typeof slackToolHints) => {
-    const cached = slackToolSlugCache.get(hintKey);
-    if (cached) return cached;
-
-    const hint = slackToolHints[hintKey];
-
-    const override = slackToolSlugOverrides[hintKey];
-    if (override && slackToolCatalog.some((tool) => tool.slug === override)) {
-        slackToolSlugCache.set(hintKey, override);
-        return override;
-    }
-    const resolveFromTools = (tools: Array<{ slug: string; name?: string; description?: string }>) => {
-        if (hint.fallbackSlugs && hint.fallbackSlugs.length > 0) {
-            const fallbackSet = new Set(hint.fallbackSlugs.map((slug) => slug.toLowerCase()));
-            const fallback = tools.find((tool) => fallbackSet.has(tool.slug.toLowerCase()));
-            if (fallback) return fallback.slug;
-        }
-
-        const best = pickSlackTool(tools, hint);
-        return best?.slug || null;
-    };
-
-    const initialTools = slackToolCatalog;
-
-    if (!initialTools.length) {
-        throw new Error("No Slack tools returned from Composio");
-    }
-
-    const initialSlug = resolveFromTools(initialTools);
-    if (initialSlug) {
-        slackToolSlugCache.set(hintKey, initialSlug);
-        return initialSlug;
-    }
-
-    const allSlug = resolveFromTools(slackToolCatalog);
-
-    if (!allSlug) {
-        const fallback = await listToolkitTools("slack", hint.search || null);
-        const fallbackSlug = resolveFromTools(fallback.items || []);
-        if (!fallbackSlug) {
-            throw new Error(`Unable to resolve Slack tool for ${hintKey}. Try slack-listAvailableTools.`);
-        }
-        slackToolSlugCache.set(hintKey, fallbackSlug);
-        return fallbackSlug;
-    }
-
-    slackToolSlugCache.set(hintKey, allSlug);
-    return allSlug;
-};
-
 const LLMPARSE_MIME_TYPES: Record<string, string> = {
     '.pdf': 'application/pdf',
     '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
@@ -862,7 +639,9 @@ export const BuiltinTools: z.infer<typeof BuiltinToolsSchema> = {
                 // Resolve model config from DI container
                 const modelConfigRepo = container.resolve<IModelConfigRepo>('modelConfigRepo');
                 const modelConfig = await modelConfigRepo.getConfig();
-                const provider = createProvider(modelConfig.provider);
+                const provider = await isSignedIn()
+                    ? await getGatewayProvider()
+                    : createProvider(modelConfig.provider);
                 const model = provider.languageModel(modelConfig.model);
 
                 const userPrompt = prompt || 'Convert this file to well-structured markdown.';
@@ -1111,160 +890,141 @@ export const BuiltinTools: z.infer<typeof BuiltinToolsSchema> = {
     },
 
     // ============================================================================
-    // Slack Tools (via Composio)
+    // App Navigation
     // ============================================================================
 
-    'slack-checkConnection': {
-        description: 'Check if Slack is connected and ready to use. Use this before other Slack operations.',
-        inputSchema: z.object({}),
-        execute: async () => {
-            if (!isComposioConfigured()) {
-                return {
-                    connected: false,
-                    error: 'Composio is not configured. Please set up your Composio API key first.',
-                };
+    'app-navigation': {
+        description: 'Control the app UI - navigate to notes, switch views, filter/search the knowledge base, and manage saved views.',
+        inputSchema: z.object({
+            action: z.enum(["open-note", "open-view", "update-base-view", "get-base-state", "create-base"]).describe("The navigation action to perform"),
+            // open-note
+            path: z.string().optional().describe("Knowledge file path for open-note, e.g. knowledge/People/John.md"),
+            // open-view
+            view: z.enum(["bases", "graph"]).optional().describe("Which view to open (for open-view action)"),
+            // update-base-view
+            filters: z.object({
+                set: z.array(z.object({ category: z.string(), value: z.string() })).optional().describe("Replace all filters with these"),
+                add: z.array(z.object({ category: z.string(), value: z.string() })).optional().describe("Add these filters"),
+                remove: z.array(z.object({ category: z.string(), value: z.string() })).optional().describe("Remove these filters"),
+                clear: z.boolean().optional().describe("Clear all filters"),
+            }).optional().describe("Filter modifications (for update-base-view)"),
+            columns: z.object({
+                set: z.array(z.string()).optional().describe("Replace visible columns with these"),
+                add: z.array(z.string()).optional().describe("Add these columns"),
+                remove: z.array(z.string()).optional().describe("Remove these columns"),
+            }).optional().describe("Column modifications (for update-base-view)"),
+            sort: z.object({
+                field: z.string(),
+                dir: z.enum(["asc", "desc"]),
+            }).optional().describe("Sort configuration (for update-base-view)"),
+            search: z.string().optional().describe("Search query to filter notes (for update-base-view)"),
+            // get-base-state
+            base_name: z.string().optional().describe("Name of a saved base to inspect (for get-base-state). Omit for the current/default view."),
+            // create-base
+            name: z.string().optional().describe("Name for the saved base view (for create-base)"),
+        }),
+        execute: async (input: {
+            action: string;
+            [key: string]: unknown;
+        }) => {
+            switch (input.action) {
+                case 'open-note': {
+                    const filePath = input.path as string;
+                    try {
+                        const result = await workspace.exists(filePath);
+                        if (!result.exists) {
+                            return { success: false, error: `File not found: ${filePath}` };
+                        }
+                        return { success: true, action: 'open-note', path: filePath };
+                    } catch {
+                        return { success: false, error: `Could not access file: ${filePath}` };
+                    }
+                }
+
+                case 'open-view': {
+                    const view = input.view as string;
+                    return { success: true, action: 'open-view', view };
+                }
+
+                case 'update-base-view': {
+                    const updates: Record<string, unknown> = {};
+                    if (input.filters) updates.filters = input.filters;
+                    if (input.columns) updates.columns = input.columns;
+                    if (input.sort) updates.sort = input.sort;
+                    if (input.search !== undefined) updates.search = input.search;
+                    return { success: true, action: 'update-base-view', updates };
+                }
+
+                case 'get-base-state': {
+                    // Scan knowledge/ files and extract frontmatter properties
+                    try {
+                        const { parseFrontmatter } = await import("@x/shared/dist/frontmatter.js");
+                        const entries = await workspace.readdir("knowledge", { recursive: true, allowedExtensions: [".md"] });
+                        const files = entries.filter(e => e.kind === 'file');
+                        const properties = new Map<string, Set<string>>();
+                        let noteCount = 0;
+
+                        for (const file of files) {
+                            try {
+                                const { data } = await workspace.readFile(file.path);
+                                const { fields } = parseFrontmatter(data);
+                                noteCount++;
+                                for (const [key, value] of Object.entries(fields)) {
+                                    if (!value) continue;
+                                    let set = properties.get(key);
+                                    if (!set) { set = new Set(); properties.set(key, set); }
+                                    const values = Array.isArray(value) ? value : [value];
+                                    for (const v of values) {
+                                        const trimmed = v.trim();
+                                        if (trimmed) set.add(trimmed);
+                                    }
+                                }
+                            } catch {
+                                // skip unreadable files
+                            }
+                        }
+
+                        const availableProperties: Record<string, string[]> = {};
+                        for (const [key, values] of properties) {
+                            availableProperties[key] = [...values].sort();
+                        }
+
+                        return {
+                            success: true,
+                            action: 'get-base-state',
+                            noteCount,
+                            availableProperties,
+                        };
+                    } catch (error) {
+                        return {
+                            success: false,
+                            error: error instanceof Error ? error.message : 'Failed to read knowledge base',
+                        };
+                    }
+                }
+
+                case 'create-base': {
+                    const name = input.name as string;
+                    const safeName = name.replace(/[^a-zA-Z0-9_\- ]/g, '').trim();
+                    if (!safeName) {
+                        return { success: false, error: 'Invalid base name' };
+                    }
+                    const basePath = `bases/${safeName}.base`;
+                    try {
+                        const config = { name: safeName, filters: [], columns: [] };
+                        await workspace.writeFile(basePath, JSON.stringify(config, null, 2), { mkdirp: true });
+                        return { success: true, action: 'create-base', name: safeName, path: basePath };
+                    } catch (error) {
+                        return {
+                            success: false,
+                            error: error instanceof Error ? error.message : 'Failed to create base',
+                        };
+                    }
+                }
+
+                default:
+                    return { success: false, error: `Unknown action: ${input.action}` };
             }
-            const account = composioAccountsRepo.getAccount('slack');
-            if (!account || account.status !== 'ACTIVE') {
-                return {
-                    connected: false,
-                    error: 'Slack is not connected. Please connect Slack from the settings.',
-                };
-            }
-            return {
-                connected: true,
-                accountId: account.id,
-            };
-        },
-    },
-
-    'slack-listAvailableTools': {
-        description: 'List available Slack tools from Composio. Use this to discover the correct tool slugs before executing actions. Call this first if other Slack tools return errors.',
-        inputSchema: z.object({
-            search: z.string().optional().describe('Optional search query to filter tools (e.g., "message", "channel", "user")'),
-        }),
-        execute: async ({ search }: { search?: string }) => {
-            if (!isComposioConfigured()) {
-                return { success: false, error: 'Composio is not configured' };
-            }
-
-            try {
-                const result = await listToolkitTools('slack', search || null);
-                return {
-                    success: true,
-                    tools: result.items,
-                    count: result.items.length,
-                };
-            } catch (error) {
-                return {
-                    success: false,
-                    error: error instanceof Error ? error.message : 'Unknown error',
-                };
-            }
-        },
-    },
-
-    'slack-executeAction': {
-        description: 'Execute a Slack action by its Composio tool slug. Use slack-listAvailableTools first to discover correct slugs. Pass the exact slug and the required input parameters.',
-        inputSchema: z.object({
-            toolSlug: z.string().describe('The exact Composio tool slug (e.g., "SLACKBOT_SEND_A_MESSAGE_TO_A_SLACK_CHANNEL")'),
-            input: z.record(z.string(), z.unknown()).describe('Input parameters for the tool (check the tool description for required fields)'),
-        }),
-        execute: async ({ toolSlug, input }: { toolSlug: string; input: Record<string, unknown> }) => {
-            const account = composioAccountsRepo.getAccount('slack');
-            if (!account || account.status !== 'ACTIVE') {
-                return { success: false, error: 'Slack is not connected' };
-            }
-
-            try {
-                const result = await executeComposioAction(toolSlug, account.id, input);
-                return result;
-            } catch (error) {
-                return {
-                    success: false,
-                    error: error instanceof Error ? error.message : 'Unknown error',
-                };
-            }
-        },
-    },
-
-    'slack-sendMessage': {
-        description: 'Send a message to a Slack channel or user. Requires channel ID (starts with C for channels, D for DMs) or user ID.',
-        inputSchema: z.object({
-            channel: z.string().describe('Channel ID (e.g., C01234567) or user ID (e.g., U01234567) to send the message to'),
-            text: z.string().describe('The message text to send'),
-        }),
-        execute: async ({ channel, text }: { channel: string; text: string }) => {
-            return executeSlackTool("sendMessage", { channel, text });
-        },
-    },
-
-    'slack-listChannels': {
-        description: 'List Slack channels the user has access to. Returns channel IDs and names.',
-        inputSchema: z.object({
-            types: z.string().optional().describe('Comma-separated channel types: public_channel, private_channel, mpim, im (default: public_channel,private_channel)'),
-            limit: z.number().optional().describe('Maximum number of channels to return (default: 100)'),
-        }),
-        execute: async ({ types, limit }: { types?: string; limit?: number }) => {
-            return executeSlackTool("listConversations", {
-                types: types || "public_channel,private_channel",
-                limit: limit ?? 100,
-            });
-        },
-    },
-
-    'slack-getChannelHistory': {
-        description: 'Get recent messages from a Slack channel. Returns message history with timestamps and user IDs.',
-        inputSchema: z.object({
-            channel: z.string().describe('Channel ID to get history from (e.g., C01234567)'),
-            limit: z.number().optional().describe('Maximum number of messages to return (default: 20, max: 100)'),
-        }),
-        execute: async ({ channel, limit }: { channel: string; limit?: number }) => {
-            return executeSlackTool("getConversationHistory", {
-                channel,
-                limit: limit !== undefined ? Math.min(limit, 100) : 20,
-            });
-        },
-    },
-
-    'slack-listUsers': {
-        description: 'List users in the Slack workspace. Returns user IDs, names, and profile info.',
-        inputSchema: z.object({
-            limit: z.number().optional().describe('Maximum number of users to return (default: 100)'),
-        }),
-        execute: async ({ limit }: { limit?: number }) => {
-            return executeSlackTool("listUsers", { limit: limit ?? 100 });
-        },
-    },
-
-    'slack-getUserInfo': {
-        description: 'Get detailed information about a specific Slack user by their user ID.',
-        inputSchema: z.object({
-            user: z.string().describe('User ID to get info for (e.g., U01234567)'),
-        }),
-        execute: async ({ user }: { user: string }) => {
-            return executeSlackTool("getUserInfo", { user });
-        },
-    },
-
-    'slack-searchMessages': {
-        description: 'Search for messages in Slack. Find messages containing specific text across channels.',
-        inputSchema: z.object({
-            query: z.string().describe('Search query text'),
-            count: z.number().optional().describe('Maximum number of results (default: 20)'),
-        }),
-        execute: async ({ query, count }: { query: string; count?: number }) => {
-            return executeSlackTool("searchMessages", { query, count: count ?? 20 });
-        },
-    },
-
-    'slack-getDirectMessages': {
-        description: 'List direct message (DM) channels. Returns IDs of DM conversations with other users.',
-        inputSchema: z.object({
-            limit: z.number().optional().describe('Maximum number of DM channels to return (default: 50)'),
-        }),
-        execute: async ({ limit }: { limit?: number }) => {
-            return executeSlackTool("listConversations", { types: "im", limit: limit ?? 50 });
         },
     },
 
@@ -1280,9 +1040,9 @@ export const BuiltinTools: z.infer<typeof BuiltinToolsSchema> = {
             freshness: z.string().optional().describe('Filter by freshness: pd (past day), pw (past week), pm (past month), py (past year)'),
         }),
         isAvailable: async () => {
+            if (await isSignedIn()) return true;
             try {
-                const homedir = process.env.HOME || process.env.USERPROFILE || '';
-                const braveConfigPath = path.join(homedir, '.rowboat', 'config', 'brave-search.json');
+                const braveConfigPath = path.join(WorkDir, 'config', 'brave-search.json');
                 const raw = await fs.readFile(braveConfigPath, 'utf8');
                 const config = JSON.parse(raw);
                 return !!config.apiKey;
@@ -1292,30 +1052,6 @@ export const BuiltinTools: z.infer<typeof BuiltinToolsSchema> = {
         },
         execute: async ({ query, count, freshness }: { query: string; count?: number; freshness?: string }) => {
             try {
-                // Read API key from config
-                const homedir = process.env.HOME || process.env.USERPROFILE || '';
-                const braveConfigPath = path.join(homedir, '.rowboat', 'config', 'brave-search.json');
-
-                let apiKey: string;
-                try {
-                    const raw = await fs.readFile(braveConfigPath, 'utf8');
-                    const config = JSON.parse(raw);
-                    apiKey = config.apiKey;
-                } catch {
-                    return {
-                        success: false,
-                        error: 'Brave Search API key not configured. Create ~/.rowboat/config/brave-search.json with { "apiKey": "<your-key>" }',
-                    };
-                }
-
-                if (!apiKey) {
-                    return {
-                        success: false,
-                        error: 'Brave Search API key is empty. Set "apiKey" in ~/.rowboat/config/brave-search.json',
-                    };
-                }
-
-                // Build query params
                 const resultCount = Math.min(Math.max(count || 5, 1), 20);
                 const params = new URLSearchParams({
                     q: query,
@@ -1325,13 +1061,47 @@ export const BuiltinTools: z.infer<typeof BuiltinToolsSchema> = {
                     params.set('freshness', freshness);
                 }
 
-                const url = `https://api.search.brave.com/res/v1/web/search?${params.toString()}`;
-                const response = await fetch(url, {
-                    headers: {
-                        'X-Subscription-Token': apiKey,
-                        'Accept': 'application/json',
-                    },
-                });
+                let response: Response;
+
+                if (await isSignedIn()) {
+                    // Use proxy
+                    const accessToken = await getAccessToken();
+                    response = await fetch(`${API_URL}/v1/search/brave?${params.toString()}`, {
+                        headers: {
+                            'Authorization': `Bearer ${accessToken}`,
+                            'Accept': 'application/json',
+                        },
+                    });
+                } else {
+                    // Read API key from config
+                    const braveConfigPath = path.join(WorkDir, 'config', 'brave-search.json');
+
+                    let apiKey: string;
+                    try {
+                        const raw = await fs.readFile(braveConfigPath, 'utf8');
+                        const config = JSON.parse(raw);
+                        apiKey = config.apiKey;
+                    } catch {
+                        return {
+                            success: false,
+                            error: 'Brave Search API key not configured. Create ~/.rowboat/config/brave-search.json with { "apiKey": "<your-key>" }',
+                        };
+                    }
+
+                    if (!apiKey) {
+                        return {
+                            success: false,
+                            error: 'Brave Search API key is empty. Set "apiKey" in ~/.rowboat/config/brave-search.json',
+                        };
+                    }
+
+                    response = await fetch(`https://api.search.brave.com/res/v1/web/search?${params.toString()}`, {
+                        headers: {
+                            'X-Subscription-Token': apiKey,
+                            'Accept': 'application/json',
+                        },
+                    });
+                }
 
                 if (!response.ok) {
                     const body = await response.text();
@@ -1378,9 +1148,9 @@ export const BuiltinTools: z.infer<typeof BuiltinToolsSchema> = {
             category: z.enum(['company', 'research paper', 'news', 'tweet', 'personal site', 'financial report', 'people']).optional().describe('Filter results by category'),
         }),
         isAvailable: async () => {
+            if (await isSignedIn()) return true;
             try {
-                const homedir = process.env.HOME || process.env.USERPROFILE || '';
-                const exaConfigPath = path.join(homedir, '.rowboat', 'config', 'exa-search.json');
+                const exaConfigPath = path.join(WorkDir, 'config', 'exa-search.json');
                 const raw = await fs.readFile(exaConfigPath, 'utf8');
                 const config = JSON.parse(raw);
                 return !!config.apiKey;
@@ -1390,31 +1160,9 @@ export const BuiltinTools: z.infer<typeof BuiltinToolsSchema> = {
         },
         execute: async ({ query, numResults, category }: { query: string; numResults?: number; category?: string }) => {
             try {
-                const homedir = process.env.HOME || process.env.USERPROFILE || '';
-                const exaConfigPath = path.join(homedir, '.rowboat', 'config', 'exa-search.json');
-
-                let apiKey: string;
-                try {
-                    const raw = await fs.readFile(exaConfigPath, 'utf8');
-                    const config = JSON.parse(raw);
-                    apiKey = config.apiKey;
-                } catch {
-                    return {
-                        success: false,
-                        error: 'Exa Search API key not configured. Create ~/.rowboat/config/exa-search.json with { "apiKey": "<your-key>" }',
-                    };
-                }
-
-                if (!apiKey) {
-                    return {
-                        success: false,
-                        error: 'Exa Search API key is empty. Set "apiKey" in ~/.rowboat/config/exa-search.json',
-                    };
-                }
-
                 const resultCount = Math.min(Math.max(numResults || 5, 1), 20);
 
-                const body: Record<string, unknown> = {
+                const reqBody: Record<string, unknown> = {
                     query,
                     numResults: resultCount,
                     type: 'auto',
@@ -1424,17 +1172,54 @@ export const BuiltinTools: z.infer<typeof BuiltinToolsSchema> = {
                     },
                 };
                 if (category) {
-                    body.category = category;
+                    reqBody.category = category;
                 }
 
-                const response = await fetch('https://api.exa.ai/search', {
-                    method: 'POST',
-                    headers: {
-                        'x-api-key': apiKey,
-                        'Content-Type': 'application/json',
-                    },
-                    body: JSON.stringify(body),
-                });
+                let response: Response;
+
+                if (await isSignedIn()) {
+                    // Use proxy
+                    const accessToken = await getAccessToken();
+                    response = await fetch(`${API_URL}/v1/search/exa`, {
+                        method: 'POST',
+                        headers: {
+                            'Authorization': `Bearer ${accessToken}`,
+                            'Content-Type': 'application/json',
+                        },
+                        body: JSON.stringify(reqBody),
+                    });
+                } else {
+                    // Read API key from config
+                    const exaConfigPath = path.join(WorkDir, 'config', 'exa-search.json');
+
+                    let apiKey: string;
+                    try {
+                        const raw = await fs.readFile(exaConfigPath, 'utf8');
+                        const config = JSON.parse(raw);
+                        apiKey = config.apiKey;
+                    } catch {
+                        return {
+                            success: false,
+                            error: 'Exa Search API key not configured. Create ~/.rowboat/config/exa-search.json with { "apiKey": "<your-key>" }',
+                        };
+                    }
+
+                    if (!apiKey) {
+                        return {
+                            success: false,
+                            error: 'Exa Search API key is empty. Set "apiKey" in ~/.rowboat/config/exa-search.json',
+                        };
+                    }
+
+                    response = await fetch('https://api.exa.ai/search', {
+                        method: 'POST',
+                        headers: {
+                            'x-api-key': apiKey,
+                            'Content-Type': 'application/json',
+                        },
+                        body: JSON.stringify(reqBody),
+                    });
+                }
 
                 if (!response.ok) {
                     const text = await response.text();
@@ -1478,6 +1263,27 @@ export const BuiltinTools: z.infer<typeof BuiltinToolsSchema> = {
             }
         },
     },
+    'save-to-memory': {
+        description: "Save a note about the user to the agent memory inbox. Use this when you observe something worth remembering — their preferences, communication patterns, relationship context, scheduling habits, or explicit instructions about how they want things done.",
+        inputSchema: z.object({
+            note: z.string().describe("The observation or preference to remember. Be specific and concise."),
+        }),
+        execute: async ({ note }: { note: string }) => {
+            const inboxPath = path.join(WorkDir, 'knowledge', 'Agent Notes', 'inbox.md');
+            const dir = path.dirname(inboxPath);
+            await fs.mkdir(dir, { recursive: true });
+
+            const timestamp = new Date().toISOString();
+            const entry = `\n- [${timestamp}] ${note}\n`;
+
+            await fs.appendFile(inboxPath, entry, 'utf-8');
+
+            return {
+                success: true,
+                message: `Saved to memory: ${note}`,
+            };
+        },
+    },
 };
 
 // ============================================================================
@@ -1527,10 +1333,15 @@ function registerComposioTools(): void {
                         error: `Toolkit "${toolkitSlug}" is not connected. Please connect it in Settings > Tools Library.`,
                     };
                 }
-                return executeComposioAction(slug, account.id, input);
+                return executeComposioAction(slug, {
+                    connected_account_id: account.id,
+                    user_id: 'rowboat-user',
+                    version: 'latest',
+                    arguments: input,
+                });
             },
             isAvailable: async () => {
-                return isComposioConfigured() && composioAccountsRepo.isConnected(toolkitSlug);
+                return (await isComposioConfigured()) && composioAccountsRepo.isConnected(toolkitSlug);
             },
         };
     }

apps/x/packages/core/src/application/lib/command-executor.ts

@@ -4,6 +4,7 @@ import { getSecurityAllowList } from '../../config/security.js';
 import { getExecutionShell } from '../assistant/runtime-context.js';
 
 const execPromise = promisify(exec);
+
 const COMMAND_SPLIT_REGEX = /(?:\|\||&&|;|\||\n|`|\$\(|\(|\))/;
 const ENV_ASSIGNMENT_REGEX = /^[A-Za-z_][A-Za-z0-9_]*=.*/;
 const WRAPPER_COMMANDS = new Set(['sudo', 'env', 'time', 'command']);

apps/x/packages/core/src/application/lib/message-queue.ts

@@ -3,14 +3,18 @@ import { UserMessageContent } from "@x/shared/dist/message.js";
 import z from "zod";
 
 export type UserMessageContentType = z.infer<typeof UserMessageContent>;
+export type VoiceOutputMode = 'summary' | 'full';
 
 type EnqueuedMessage = {
     messageId: string;
     message: UserMessageContentType;
+    voiceInput?: boolean;
+    voiceOutput?: VoiceOutputMode;
+    searchEnabled?: boolean;
 };
 
 export interface IMessageQueue {
-    enqueue(runId: string, message: UserMessageContentType): Promise<string>;
+    enqueue(runId: string, message: UserMessageContentType, voiceInput?: boolean, voiceOutput?: VoiceOutputMode, searchEnabled?: boolean): Promise<string>;
     dequeue(runId: string): Promise<EnqueuedMessage | null>;
 }
 
@@ -26,7 +30,7 @@ export class InMemoryMessageQueue implements IMessageQueue {
         this.idGenerator = idGenerator;
     }
 
-    async enqueue(runId: string, message: UserMessageContentType): Promise<string> {
+    async enqueue(runId: string, message: UserMessageContentType, voiceInput?: boolean, voiceOutput?: VoiceOutputMode, searchEnabled?: boolean): Promise<string> {
         if (!this.store[runId]) {
             this.store[runId] = [];
         }
@@ -34,6 +38,9 @@ export class InMemoryMessageQueue implements IMessageQueue {
         this.store[runId].push({
             messageId: id,
             message,
+            voiceInput,
+            voiceOutput,
+            searchEnabled,
         });
         return id;
     }
@@ -44,4 +51,4 @@ export class InMemoryMessageQueue implements IMessageQueue {
         }
         return this.store[runId].shift() ?? null;
     }
-}
+}

apps/x/packages/core/src/auth/oauth-client.ts

@@ -46,13 +46,15 @@ export async function discoverConfiguration(
     console.log(`[OAuth] Using cached configuration for ${issuerUrl}`);
     return cached;
   }
-
   console.log(`[OAuth] Discovering authorization server metadata for ${issuerUrl}...`);
   const config = await client.discovery(
     new URL(issuerUrl),
     clientId,
     undefined, // no client_secret (PKCE flow)
-    client.None() // PKCE doesn't require client authentication
+    client.None(), // PKCE doesn't require client authentication
+    {
+      execute: [client.allowInsecureRequests],
+    }
   );
 
   configCache.set(cacheKey, config);
@@ -110,7 +112,10 @@ export async function registerClient(
       client_name: clientName,
       scope: scopes.join(' '),
     },
-    client.None()
+    client.None(),
+    {
+      execute: [client.allowInsecureRequests],
+    },
   );
 
   const metadata = config.clientMetadata();

apps/x/packages/core/src/auth/providers.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { getRowboatConfig } from '../config/rowboat.js';
 
 /**
  * Discovery configuration - how to get OAuth endpoints
@@ -51,6 +52,20 @@ export type ProviderConfigEntry = ProviderConfig[string];
  * All configured OAuth providers
  */
 const providerConfigs: ProviderConfig = {
+  rowboat: {
+    discovery: {
+      mode: 'issuer',
+      issuer: "TBD",
+    },
+    client: {
+      mode: 'dcr',
+    },
+    scopes: [
+      "openid",
+      "email",
+      "profile",
+    ],
+  },
   google: {
     discovery: {
       mode: 'issuer',
@@ -83,21 +98,21 @@ const providerConfigs: ProviderConfig = {
 /**
  * Get provider configuration by name
  */
-export function getProviderConfig(providerName: string): ProviderConfigEntry {
+export async function getProviderConfig(providerName: string): Promise<ProviderConfigEntry> {
   const config = providerConfigs[providerName];
   if (!config) {
     throw new Error(`Unknown OAuth provider: ${providerName}`);
   }
+  if (providerName === 'rowboat') {
+    const rowboatConfig = await getRowboatConfig();
+    config.discovery = {
+      mode: 'issuer',
+      issuer: `${rowboatConfig.supabaseUrl}/auth/v1/.well-known/oauth-authorization-server`,
+    }
+  }
   return config;
 }
 
-/**
- * Get all provider configurations
- */
-export function getAllProviderConfigs(): ProviderConfig {
-  return providerConfigs;
-}
-
 /**
  * Get list of all configured OAuth providers
  */

apps/x/packages/core/src/auth/tokens.ts

@@ -0,0 +1,46 @@
+import container from '../di/container.js';
+import { IOAuthRepo } from './repo.js';
+import { IClientRegistrationRepo } from './client-repo.js';
+import { getProviderConfig } from './providers.js';
+import * as oauthClient from './oauth-client.js';
+
+export async function getAccessToken(): Promise<string> {
+    const oauthRepo = container.resolve<IOAuthRepo>('oauthRepo');
+    const { tokens } = await oauthRepo.read('rowboat');
+    if (!tokens) {
+        throw new Error('Not signed into Rowboat');
+    }
+
+    if (!oauthClient.isTokenExpired(tokens)) {
+        return tokens.access_token;
+    }
+
+    if (!tokens.refresh_token) {
+        throw new Error('Rowboat token expired and no refresh token available. Please sign in again.');
+    }
+
+    const providerConfig = await getProviderConfig('rowboat');
+    if (providerConfig.discovery.mode !== 'issuer') {
+        throw new Error('Rowboat provider requires issuer discovery mode');
+    }
+
+    const clientRepo = container.resolve<IClientRegistrationRepo>('clientRegistrationRepo');
+    const registration = await clientRepo.getClientRegistration('rowboat');
+    if (!registration) {
+        throw new Error('Rowboat client not registered. Please sign in again.');
+    }
+
+    const config = await oauthClient.discoverConfiguration(
+        providerConfig.discovery.issuer,
+        registration.client_id,
+    );
+
+    const refreshed = await oauthClient.refreshTokens(
+        config,
+        tokens.refresh_token,
+        tokens.scopes,
+    );
+    await oauthRepo.upsert('rowboat', { tokens: refreshed });
+
+    return refreshed.access_token;
+}

apps/x/packages/core/src/billing/billing.ts

@@ -0,0 +1,43 @@
+import { getAccessToken } from '../auth/tokens.js';
+import { API_URL } from '../config/env.js';
+
+export interface BillingInfo {
+  userEmail: string | null;
+  userId: string | null;
+  subscriptionPlan: string | null;
+  subscriptionStatus: string | null;
+  sanctionedCredits: number;
+  availableCredits: number;
+}
+
+export async function getBillingInfo(): Promise<BillingInfo> {
+  const accessToken = await getAccessToken();
+  const response = await fetch(`${API_URL}/v1/me`, {
+    headers: { Authorization: `Bearer ${accessToken}` },
+  });
+  if (!response.ok) {
+    throw new Error(`Billing API failed: ${response.status}`);
+  }
+  const body = await response.json() as {
+    user: {
+      id: string;
+      email: string;
+    };
+    billing: {
+      plan: string | null;
+      status: string | null;
+      usage: {
+        sanctionedCredits: number;
+        availableCredits: number;
+      };
+    };
+  };
+  return {
+    userEmail: body.user.email ?? null,
+    userId: body.user.id ?? null,
+    subscriptionPlan: body.billing.plan,
+    subscriptionStatus: body.billing.status,
+    sanctionedCredits: body.billing.usage.sanctionedCredits,
+    availableCredits: body.billing.usage.availableCredits,
+  };
+}

apps/x/packages/core/src/composio/client.ts

@@ -1,7 +1,6 @@
 import { z } from "zod";
 import fs from "fs";
 import path from "path";
-import { Composio } from "@composio/core";
 import { WorkDir } from "../config/config.js";
 import {
     ZAuthConfig,
@@ -12,33 +11,36 @@ import {
     ZCreateConnectedAccountResponse,
     ZDeleteOperationResponse,
     ZErrorResponse,
+    ZExecuteActionRequest,
     ZExecuteActionResponse,
     ZListResponse,
+    ZTool,
     ZToolkit,
 } from "./types.js";
+import { isSignedIn } from "../account/account.js";
+import { getAccessToken } from "../auth/tokens.js";
+import { API_URL } from "../config/env.js";
 
-const BASE_URL = 'https://backend.composio.dev/api/v3';
+const COMPOSIO_BASE_URL = 'https://backend.composio.dev/api/v3';
 const CONFIG_FILE = path.join(WorkDir, 'config', 'composio.json');
 
-// Composio SDK client (lazily initialized)
-let composioClient: Composio | null = null;
-
-function getComposioClient(): Composio {
-    if (composioClient) {
-        return composioClient;
+async function getBaseUrl(): Promise<string> {
+    if (await isSignedIn()) {
+        return `${API_URL}/v1/composio`;
     }
+    return COMPOSIO_BASE_URL;
+}
 
+async function getAuthHeaders(): Promise<Record<string, string>> {
+    if (await isSignedIn()) {
+        const token = await getAccessToken();
+        return { 'Authorization': `Bearer ${token}` };
+    }
     const apiKey = getApiKey();
     if (!apiKey) {
         throw new Error('Composio API key not configured');
     }
-
-    composioClient = new Composio({ apiKey });
-    return composioClient;
-}
-
-function resetComposioClient(): void {
-    composioClient = null;
+    return { 'x-api-key': apiKey };
 }
 
 /**
@@ -46,6 +48,8 @@ function resetComposioClient(): void {
  */
 const ZComposioConfig = z.object({
     apiKey: z.string().optional(),
+    use_composio_for_google: z.boolean().optional(),
+    use_composio_for_google_calendar: z.boolean().optional(),
 });
 
 type ComposioConfig = z.infer<typeof ZComposioConfig>;
@@ -91,38 +95,58 @@ export function setApiKey(apiKey: string): void {
     const config = loadConfig();
     config.apiKey = apiKey;
     saveConfig(config);
-    resetComposioClient();
 }
 
 /**
  * Check if Composio is configured
  */
-export function isConfigured(): boolean {
+export async function isConfigured(): Promise<boolean> {
+    if (await isSignedIn()) return true;
     return !!getApiKey();
 }
 
+/**
+ * Check if Composio should be used for Google services (Gmail, etc.)
+ */
+export async function useComposioForGoogle(): Promise<boolean> {
+    if (await isSignedIn()) return true;
+    const config = loadConfig();
+    return config.use_composio_for_google === true;
+}
+
+/**
+ * Check if Composio should be used for Google Calendar
+ */
+export async function useComposioForGoogleCalendar(): Promise<boolean> {
+    if (await isSignedIn()) return true;
+    const config = loadConfig();
+    return config.use_composio_for_google_calendar === true;
+}
+
 /**
  * Make an API call to Composio
  */
 export async function composioApiCall<T extends z.ZodTypeAny>(
     schema: T,
-    url: string,
+    path: string,
+    params: Record<string, string> = {},
     options: RequestInit = {},
 ): Promise<z.infer<T>> {
-    const apiKey = getApiKey();
-    if (!apiKey) {
-        throw new Error('Composio API key not configured');
-    }
+    const authHeaders = await getAuthHeaders();
+    const baseURL = await getBaseUrl();
+    const url = new URL(`${baseURL}${path}`);
 
     console.log(`[Composio] ${options.method || 'GET'} ${url}`);
     const startTime = Date.now();
 
     try {
+        Object.entries(params).forEach(([key, value]) => url.searchParams.set(key, value));
+
         const response = await fetch(url, {
             ...options,
             headers: {
                 ...options.headers,
-                "x-api-key": apiKey,
+                ...authHeaders,
                 ...(options.method === 'POST' ? { "Content-Type": "application/json" } : {}),
             },
         });
@@ -158,7 +182,7 @@ export async function composioApiCall<T extends z.ZodTypeAny>(
             throw new Error(`Failed to parse response: ${message}`);
         }
 
-        if (typeof data === 'object' && data !== null && 'error' in data) {
+        if (typeof data === 'object' && data !== null && 'error' in data && data.error !== null && typeof data.error === 'object') {
             const parsedError = ZErrorResponse.parse(data);
             throw new Error(`Composio error (${parsedError.error.error_code}): ${parsedError.error.message}`);
         }
@@ -174,47 +198,20 @@ export async function composioApiCall<T extends z.ZodTypeAny>(
  * List available toolkits
  */
 export async function listToolkits(cursor: string | null = null): Promise<z.infer<ReturnType<typeof ZListResponse<typeof ZToolkit>>>> {
-    const url = new URL(`${BASE_URL}/toolkits`);
-    url.searchParams.set("sort_by", "usage");
+    const params: Record<string, string> = {
+        sort_by: "usage",
+    };
     if (cursor) {
-        url.searchParams.set("cursor", cursor);
+        params.cursor = cursor;
     }
-    return composioApiCall(ZListResponse(ZToolkit), url.toString());
+    return composioApiCall(ZListResponse(ZToolkit), "/toolkits", params);
 }
 
 /**
  * Get a specific toolkit
  */
 export async function getToolkit(toolkitSlug: string): Promise<z.infer<typeof ZToolkit>> {
-    const apiKey = getApiKey();
-    if (!apiKey) {
-        throw new Error('Composio API key not configured');
-    }
-
-    const url = `${BASE_URL}/toolkits/${toolkitSlug}`;
-    console.log(`[Composio] GET ${url}`);
-
-    const response = await fetch(url, {
-        headers: { "x-api-key": apiKey },
-    });
-
-    if (!response.ok) {
-        throw new Error(`Failed to fetch toolkit: ${response.status} ${response.statusText}`);
-    }
-
-    const data = await response.json();
-
-    const no_auth = data.composio_managed_auth_schemes?.includes('NO_AUTH') ||
-                    data.auth_config_details?.some((config: { mode: string }) => config.mode === 'NO_AUTH') ||
-                    false;
-
-    return ZToolkit.parse({
-        ...data,
-        no_auth,
-        meta: data.meta || { description: '', logo: '', tools_count: 0, triggers_count: 0 },
-        auth_schemes: data.auth_schemes || [],
-        composio_managed_auth_schemes: data.composio_managed_auth_schemes || [],
-    });
+    return composioApiCall(ZToolkit, `/toolkits/${toolkitSlug}`);
 }
 
 /**
@@ -225,15 +222,16 @@ export async function listAuthConfigs(
     cursor: string | null = null,
     managedOnly: boolean = false
 ): Promise<z.infer<ReturnType<typeof ZListResponse<typeof ZAuthConfig>>>> {
-    const url = new URL(`${BASE_URL}/auth_configs`);
-    url.searchParams.set("toolkit_slug", toolkitSlug);
+    const params: Record<string, string> = {
+        toolkit_slug: toolkitSlug,
+    };
     if (cursor) {
-        url.searchParams.set("cursor", cursor);
+        params.cursor = cursor;
     }
     if (managedOnly) {
-        url.searchParams.set("is_composio_managed", "true");
+        params.is_composio_managed = "true";
     }
-    return composioApiCall(ZListResponse(ZAuthConfig), url.toString());
+    return composioApiCall(ZListResponse(ZAuthConfig), "/auth_configs", params);
 }
 
 /**
@@ -242,8 +240,7 @@ export async function listAuthConfigs(
 export async function createAuthConfig(
     request: z.infer<typeof ZCreateAuthConfigRequest>
 ): Promise<z.infer<typeof ZCreateAuthConfigResponse>> {
-    const url = new URL(`${BASE_URL}/auth_configs`);
-    return composioApiCall(ZCreateAuthConfigResponse, url.toString(), {
+    return composioApiCall(ZCreateAuthConfigResponse, "/auth_configs", {}, {
         method: 'POST',
         body: JSON.stringify(request),
     });
@@ -253,8 +250,7 @@ export async function createAuthConfig(
  * Delete an auth config
  */
 export async function deleteAuthConfig(authConfigId: string): Promise<z.infer<typeof ZDeleteOperationResponse>> {
-    const url = new URL(`${BASE_URL}/auth_configs/${authConfigId}`);
-    return composioApiCall(ZDeleteOperationResponse, url.toString(), {
+    return composioApiCall(ZDeleteOperationResponse, `/auth_configs/${authConfigId}`, {}, {
         method: 'DELETE',
     });
 }
@@ -265,8 +261,7 @@ export async function deleteAuthConfig(authConfigId: string): Promise<z.infer<ty
 export async function createConnectedAccount(
     request: z.infer<typeof ZCreateConnectedAccountRequest>
 ): Promise<z.infer<typeof ZCreateConnectedAccountResponse>> {
-    const url = new URL(`${BASE_URL}/connected_accounts`);
-    return composioApiCall(ZCreateConnectedAccountResponse, url.toString(), {
+    return composioApiCall(ZCreateConnectedAccountResponse, "/connected_accounts", {}, {
         method: 'POST',
         body: JSON.stringify(request),
     });
@@ -276,16 +271,14 @@ export async function createConnectedAccount(
  * Get a connected account
  */
 export async function getConnectedAccount(connectedAccountId: string): Promise<z.infer<typeof ZConnectedAccount>> {
-    const url = new URL(`${BASE_URL}/connected_accounts/${connectedAccountId}`);
-    return composioApiCall(ZConnectedAccount, url.toString());
+    return composioApiCall(ZConnectedAccount, `/connected_accounts/${connectedAccountId}`);
 }
 
 /**
  * Delete a connected account
  */
 export async function deleteConnectedAccount(connectedAccountId: string): Promise<z.infer<typeof ZDeleteOperationResponse>> {
-    const url = new URL(`${BASE_URL}/connected_accounts/${connectedAccountId}`);
-    return composioApiCall(ZDeleteOperationResponse, url.toString(), {
+    return composioApiCall(ZDeleteOperationResponse, `/connected_accounts/${connectedAccountId}`, {}, {
         method: 'DELETE',
     });
 }
@@ -296,38 +289,15 @@ export async function deleteConnectedAccount(connectedAccountId: string): Promis
 export async function listToolkitTools(
     toolkitSlug: string,
     searchQuery: string | null = null,
-): Promise<{ items: Array<{ slug: string; name: string; description: string }> }> {
-    const apiKey = getApiKey();
-    if (!apiKey) {
-        throw new Error('Composio API key not configured');
-    }
-
-    const url = new URL(`${BASE_URL}/tools`);
-    url.searchParams.set('toolkit_slug', toolkitSlug);
-    url.searchParams.set('limit', '200');
-    if (searchQuery) {
-        url.searchParams.set('search', searchQuery);
-    }
-
-    console.log(`[Composio] Listing tools for toolkit: ${toolkitSlug}`);
-
-    const response = await fetch(url.toString(), {
-        headers: { "x-api-key": apiKey },
-    });
-
-    if (!response.ok) {
-        throw new Error(`Failed to list tools: ${response.status} ${response.statusText}`);
-    }
-
-    const data = await response.json() as { items?: Array<Record<string, unknown>> };
-
-    return {
-        items: (data.items || []).map((item) => ({
-            slug: String(item.slug ?? ''),
-            name: String(item.name ?? ''),
-            description: String(item.description ?? ''),
-        })),
+): Promise<z.infer<ReturnType<typeof ZListResponse<typeof ZTool>>>> {
+    const params: Record<string, string> = {
+        toolkit_slug: toolkitSlug,
+        limit: '200',
     };
+    if (searchQuery) {
+        params.search = searchQuery;
+    }
+    return composioApiCall(ZListResponse(ZTool), "/tools", params);
 }
 
 /**
@@ -337,12 +307,10 @@ export async function listToolkitToolsDetailed(
     toolkitSlug: string,
     searchQuery: string | null = null,
 ): Promise<{ items: Array<{ slug: string; name: string; description: string; toolkitSlug: string; inputParameters: { type: 'object'; properties: Record<string, unknown>; required?: string[] } }> }> {
-    const apiKey = getApiKey();
-    if (!apiKey) {
-        throw new Error('Composio API key not configured');
-    }
+    const authHeaders = await getAuthHeaders();
+    const baseURL = await getBaseUrl();
 
-    const url = new URL(`${BASE_URL}/tools`);
+    const url = new URL(`${baseURL}/tools`);
     url.searchParams.set('toolkit_slug', toolkitSlug);
     url.searchParams.set('limit', '200');
     if (searchQuery) {
@@ -352,7 +320,7 @@ export async function listToolkitToolsDetailed(
     console.log(`[Composio] Listing tools (detailed) for toolkit: ${toolkitSlug}`);
 
     const response = await fetch(url.toString(), {
-        headers: { "x-api-key": apiKey },
+        headers: authHeaders,
     });
 
     if (!response.ok) {
@@ -380,29 +348,14 @@ export async function listToolkitToolsDetailed(
 }
 
 /**
- * Execute a tool action using Composio SDK
+ * Execute a tool action
  */
 export async function executeAction(
     actionSlug: string,
-    connectedAccountId: string,
-    input: Record<string, unknown>
+    request: z.infer<typeof ZExecuteActionRequest>
 ): Promise<z.infer<typeof ZExecuteActionResponse>> {
-    console.log(`[Composio] Executing action: ${actionSlug} (account: ${connectedAccountId})`);
-
-    try {
-        const client = getComposioClient();
-        const result = await client.tools.execute(actionSlug, {
-            userId: 'rowboat-user',
-            arguments: input,
-            connectedAccountId,
-            dangerouslySkipVersionCheck: true,
-        });
-
-        console.log(`[Composio] Action completed successfully`);
-        return { success: true, data: result.data };
-    } catch (error) {
-        console.error(`[Composio] Action execution failed:`, JSON.stringify(error, Object.getOwnPropertyNames(error ?? {}), 2));
-        const message = error instanceof Error ? error.message : (typeof error === 'object' ? JSON.stringify(error) : 'Unknown error');
-        return { success: false, data: null, error: message };
-    }
+    return composioApiCall(ZExecuteActionResponse, `/tools/execute/${actionSlug}`, {}, {
+        method: 'POST',
+        body: JSON.stringify(request),
+    });
 }

apps/x/packages/core/src/composio/types.ts

@@ -45,11 +45,11 @@ export const ZToolkit = z.object({
     slug: z.string(),
     name: z.string(),
     meta: ZToolkitMeta,
-    no_auth: z.boolean(),
+    no_auth: z.boolean().optional(),
     // Use z.string() instead of ZAuthScheme to be resilient against
     // new auth types added by the Composio API over time.
-    auth_schemes: z.array(z.string()),
-    composio_managed_auth_schemes: z.array(z.string()),
+    auth_schemes: z.array(z.string()).optional(),
+    composio_managed_auth_schemes: z.array(z.string()).optional(),
 });
 
 /**
@@ -70,7 +70,7 @@ export const ZTool = z.object({
         required: z.array(z.string()).optional(),
         additionalProperties: z.boolean().optional(),
     }),
-    no_auth: z.boolean(),
+    no_auth: z.boolean().optional(),
 });
 
 /**
@@ -202,18 +202,19 @@ export const ZListResponse = <T extends z.ZodTypeAny>(schema: T) => z.object({
  * Execute action request
  */
 export const ZExecuteActionRequest = z.object({
-    action: z.string(),
     connected_account_id: z.string(),
-    input: z.record(z.string(), z.unknown()),
+    user_id: z.string(),
+    version: z.string(),
+    arguments: z.any().optional(),
 });
 
 /**
  * Execute action response
  */
 export const ZExecuteActionResponse = z.object({
-    success: z.boolean(),
     data: z.unknown(),
-    error: z.string().optional(),
+    successful: z.boolean(),
+    error: z.string().nullable(),
 });
 
 /**

apps/x/packages/core/src/config/config.ts

@@ -23,7 +23,7 @@ function ensureDefaultConfigs() {
     const noteCreationConfig = path.join(WorkDir, "config", "note_creation.json");
     if (!fs.existsSync(noteCreationConfig)) {
         fs.writeFileSync(noteCreationConfig, JSON.stringify({
-            strictness: "high",
+            strictness: "medium",
             configured: false
         }, null, 2));
     }

apps/x/packages/core/src/config/env.ts

@@ -0,0 +1,2 @@
+export const API_URL =
+  process.env.API_URL || 'https://api.x.rowboatlabs.com';

apps/x/packages/core/src/config/note_creation_config.ts

@@ -11,7 +11,7 @@ interface NoteCreationConfig {
 }
 
 const CONFIG_FILE = path.join(WorkDir, 'config', 'note_creation.json');
-const DEFAULT_STRICTNESS: NoteCreationStrictness = 'high';
+const DEFAULT_STRICTNESS: NoteCreationStrictness = 'medium';
 
 /**
  * Read the full config file.

apps/x/packages/core/src/config/rowboat.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { RowboatApiConfig } from "@x/shared/dist/rowboat-account.js";
+import { API_URL } from "./env.js";
+
+let cached: z.infer<typeof RowboatApiConfig> | null = null;
+
+export async function getRowboatConfig(): Promise<z.infer<typeof RowboatApiConfig>> {
+  if (cached) {
+    return cached;
+  }
+  const response = await fetch(`${API_URL}/v1/config`);
+  const data = RowboatApiConfig.parse(await response.json());
+  cached = data;
+  return data;
+}

apps/x/packages/core/src/config/user_config.ts

@@ -0,0 +1,44 @@
+import fs from 'fs';
+import path from 'path';
+import { z } from 'zod';
+import { WorkDir } from './config.js';
+
+const USER_CONFIG_PATH = path.join(WorkDir, 'config', 'user.json');
+
+export const UserConfig = z.object({
+    name: z.string().optional(),
+    email: z.string().email(),
+    domain: z.string().optional(),
+});
+
+export type UserConfig = z.infer<typeof UserConfig>;
+
+export function loadUserConfig(): UserConfig | null {
+    try {
+        if (fs.existsSync(USER_CONFIG_PATH)) {
+            const content = fs.readFileSync(USER_CONFIG_PATH, 'utf-8');
+            const parsed = JSON.parse(content);
+            return UserConfig.parse(parsed);
+        }
+    } catch (error) {
+        console.error('[UserConfig] Error loading user config:', error);
+    }
+    return null;
+}
+
+export function saveUserConfig(config: UserConfig): void {
+    const dir = path.dirname(USER_CONFIG_PATH);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    const validated = UserConfig.parse(config);
+    fs.writeFileSync(USER_CONFIG_PATH, JSON.stringify(validated, null, 2));
+}
+
+export function updateUserEmail(email: string): void {
+    const existing = loadUserConfig();
+    const config = existing
+        ? { ...existing, email }
+        : { email };
+    saveUserConfig(config);
+}

apps/x/packages/core/src/di/container.ts

@@ -14,6 +14,7 @@ import { FSGranolaConfigRepo, IGranolaConfigRepo } from "../knowledge/granola/re
 import { IAbortRegistry, InMemoryAbortRegistry } from "../runs/abort-registry.js";
 import { FSAgentScheduleRepo, IAgentScheduleRepo } from "../agent-schedule/repo.js";
 import { FSAgentScheduleStateRepo, IAgentScheduleStateRepo } from "../agent-schedule/state-repo.js";
+import { FSSlackConfigRepo, ISlackConfigRepo } from "../slack/repo.js";
 
 const container = createContainer({
     injectionMode: InjectionMode.PROXY,
@@ -37,6 +38,7 @@ container.register({
     granolaConfigRepo: asClass<IGranolaConfigRepo>(FSGranolaConfigRepo).singleton(),
     agentScheduleRepo: asClass<IAgentScheduleRepo>(FSAgentScheduleRepo).singleton(),
     agentScheduleStateRepo: asClass<IAgentScheduleStateRepo>(FSAgentScheduleStateRepo).singleton(),
+    slackConfigRepo: asClass<ISlackConfigRepo>(FSSlackConfigRepo).singleton(),
 });
 
 export default container;

apps/x/packages/core/src/index.ts

@@ -9,3 +9,6 @@ export { initConfigs } from './config/initConfigs.js';
 
 // Knowledge version history
 export * as versionHistory from './knowledge/version_history.js';
+
+// Voice mode (config + TTS)
+export * as voice from './voice/voice.js';

apps/x/packages/core/src/knowledge/agent_notes.ts

@@ -0,0 +1,384 @@
+import fs from 'fs';
+import path from 'path';
+import { google } from 'googleapis';
+import { WorkDir } from '../config/config.js';
+import { createRun, createMessage } from '../runs/runs.js';
+import { bus } from '../runs/bus.js';
+import { serviceLogger } from '../services/service_logger.js';
+import { loadUserConfig, updateUserEmail } from '../config/user_config.js';
+import { GoogleClientFactory } from './google-client-factory.js';
+import { useComposioForGoogle, executeAction } from '../composio/client.js';
+import { composioAccountsRepo } from '../composio/repo.js';
+import {
+    loadAgentNotesState,
+    saveAgentNotesState,
+    markEmailProcessed,
+    markRunProcessed,
+    type AgentNotesState,
+} from './agent_notes_state.js';
+
+const SYNC_INTERVAL_MS = 10 * 1000; // 10 seconds (for testing)
+const EMAIL_BATCH_SIZE = 5;
+const RUNS_BATCH_SIZE = 5;
+const GMAIL_SYNC_DIR = path.join(WorkDir, 'gmail_sync');
+const RUNS_DIR = path.join(WorkDir, 'runs');
+const AGENT_NOTES_DIR = path.join(WorkDir, 'knowledge', 'Agent Notes');
+const INBOX_FILE = path.join(AGENT_NOTES_DIR, 'inbox.md');
+const AGENT_ID = 'agent_notes_agent';
+
+// --- File helpers ---
+
+function ensureAgentNotesDir(): void {
+    if (!fs.existsSync(AGENT_NOTES_DIR)) {
+        fs.mkdirSync(AGENT_NOTES_DIR, { recursive: true });
+    }
+}
+
+// --- Email scanning ---
+
+function findUserSentEmails(
+    state: AgentNotesState,
+    userEmail: string,
+    limit: number,
+): string[] {
+    if (!fs.existsSync(GMAIL_SYNC_DIR)) {
+        return [];
+    }
+
+    const results: { path: string; mtime: number }[] = [];
+    const userEmailLower = userEmail.toLowerCase();
+
+    function traverse(dir: string) {
+        const entries = fs.readdirSync(dir);
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry);
+            const stat = fs.statSync(fullPath);
+
+            if (stat.isDirectory()) {
+                if (entry !== 'attachments') {
+                    traverse(fullPath);
+                }
+            } else if (stat.isFile() && entry.endsWith('.md')) {
+                if (state.processedEmails[fullPath]) {
+                    continue;
+                }
+
+                try {
+                    const content = fs.readFileSync(fullPath, 'utf-8');
+                    const fromLines = content.match(/^### From:.*$/gm);
+                    if (fromLines?.some(line => line.toLowerCase().includes(userEmailLower))) {
+                        results.push({ path: fullPath, mtime: stat.mtimeMs });
+                    }
+                } catch {
+                    continue;
+                }
+            }
+        }
+    }
+
+    traverse(GMAIL_SYNC_DIR);
+
+    results.sort((a, b) => b.mtime - a.mtime);
+    return results.slice(0, limit).map(r => r.path);
+}
+
+function extractUserPartsFromEmail(content: string, userEmail: string): string | null {
+    const userEmailLower = userEmail.toLowerCase();
+    const sections = content.split(/^---$/m);
+    const userSections: string[] = [];
+
+    for (const section of sections) {
+        const fromMatch = section.match(/^### From:.*$/m);
+        if (fromMatch && fromMatch[0].toLowerCase().includes(userEmailLower)) {
+            userSections.push(section.trim());
+        }
+    }
+
+    return userSections.length > 0 ? userSections.join('\n\n---\n\n') : null;
+}
+
+// --- Inbox reading ---
+
+function readInbox(): string[] {
+    if (!fs.existsSync(INBOX_FILE)) {
+        return [];
+    }
+    const content = fs.readFileSync(INBOX_FILE, 'utf-8').trim();
+    if (!content) {
+        return [];
+    }
+    return content.split('\n').filter(l => l.trim());
+}
+
+function clearInbox(): void {
+    if (fs.existsSync(INBOX_FILE)) {
+        fs.writeFileSync(INBOX_FILE, '');
+    }
+}
+
+// --- Copilot run scanning ---
+
+function findNewCopilotRuns(state: AgentNotesState): string[] {
+    if (!fs.existsSync(RUNS_DIR)) {
+        return [];
+    }
+
+    const results: string[] = [];
+    const files = fs.readdirSync(RUNS_DIR).filter(f => f.endsWith('.jsonl'));
+
+    for (const file of files) {
+        if (state.processedRuns[file]) {
+            continue;
+        }
+
+        try {
+            const fullPath = path.join(RUNS_DIR, file);
+            const fd = fs.openSync(fullPath, 'r');
+            const buf = Buffer.alloc(512);
+            const bytesRead = fs.readSync(fd, buf, 0, 512, 0);
+            fs.closeSync(fd);
+
+            const firstLine = buf.subarray(0, bytesRead).toString('utf-8').split('\n')[0];
+            const event = JSON.parse(firstLine);
+            if (event.agentName === 'copilot') {
+                results.push(file);
+            }
+        } catch {
+            continue;
+        }
+    }
+
+    results.sort();
+    return results;
+}
+
+function extractConversationMessages(runFilePath: string): { role: string; text: string }[] {
+    const messages: { role: string; text: string }[] = [];
+    try {
+        const content = fs.readFileSync(runFilePath, 'utf-8');
+        const lines = content.split('\n').filter(l => l.trim());
+
+        for (const line of lines) {
+            try {
+                const event = JSON.parse(line);
+                if (event.type !== 'message') continue;
+
+                const msg = event.message;
+                if (!msg || (msg.role !== 'user' && msg.role !== 'assistant')) continue;
+
+                let text = '';
+                if (typeof msg.content === 'string') {
+                    text = msg.content.trim();
+                } else if (Array.isArray(msg.content)) {
+                    text = msg.content
+                        .filter((p: { type: string }) => p.type === 'text')
+                        .map((p: { text: string }) => p.text)
+                        .join('\n')
+                        .trim();
+                }
+
+                if (text) {
+                    messages.push({ role: msg.role, text });
+                }
+            } catch {
+                continue;
+            }
+        }
+    } catch {
+        // ignore
+    }
+    return messages;
+}
+
+// --- Wait for agent run completion ---
+
+async function waitForRunCompletion(runId: string): Promise<void> {
+    return new Promise(async (resolve) => {
+        const unsubscribe = await bus.subscribe('*', async (event) => {
+            if (event.type === 'run-processing-end' && event.runId === runId) {
+                unsubscribe();
+                resolve();
+            }
+        });
+    });
+}
+
+// --- User email resolution ---
+
+async function ensureUserEmail(): Promise<string | null> {
+    const existing = loadUserConfig();
+    if (existing?.email) {
+        return existing.email;
+    }
+
+    // Try Composio (used when signed in or composio configured)
+    try {
+        if (await useComposioForGoogle()) {
+            const account = composioAccountsRepo.getAccount('gmail');
+            if (account && account.status === 'ACTIVE') {
+                const result = await executeAction('GMAIL_GET_PROFILE', {
+                    connected_account_id: account.id,
+                    user_id: 'rowboat-user',
+                    version: 'latest',
+                    arguments: { user_id: 'me' },
+                });
+                const email = (result.data as Record<string, unknown>)?.emailAddress as string | undefined;
+                if (email) {
+                    updateUserEmail(email);
+                    console.log(`[AgentNotes] Auto-populated user email via Composio: ${email}`);
+                    return email;
+                }
+            }
+        }
+    } catch (error) {
+        console.log('[AgentNotes] Could not fetch email via Composio:', error instanceof Error ? error.message : error);
+    }
+
+    // Try direct Google OAuth
+    try {
+        const auth = await GoogleClientFactory.getClient();
+        if (auth) {
+            const gmail = google.gmail({ version: 'v1', auth });
+            const profile = await gmail.users.getProfile({ userId: 'me' });
+            if (profile.data.emailAddress) {
+                updateUserEmail(profile.data.emailAddress);
+                console.log(`[AgentNotes] Auto-populated user email: ${profile.data.emailAddress}`);
+                return profile.data.emailAddress;
+            }
+        }
+    } catch (error) {
+        console.log('[AgentNotes] Could not fetch Gmail profile for user email:', error instanceof Error ? error.message : error);
+    }
+
+    return null;
+}
+
+// --- Main processing ---
+
+async function processAgentNotes(): Promise<void> {
+    ensureAgentNotesDir();
+    const state = loadAgentNotesState();
+    const userEmail = await ensureUserEmail();
+
+    // Collect all source material
+    const messageParts: string[] = [];
+
+    // 1. Emails (only if we have user email)
+    const emailPaths = userEmail
+        ? findUserSentEmails(state, userEmail, EMAIL_BATCH_SIZE)
+        : [];
+    if (emailPaths.length > 0) {
+        messageParts.push(`## Emails sent by the user\n`);
+        for (const p of emailPaths) {
+            const content = fs.readFileSync(p, 'utf-8');
+            const userParts = extractUserPartsFromEmail(content, userEmail!);
+            if (userParts) {
+                messageParts.push(`---\n${userParts}\n---\n`);
+            }
+        }
+    }
+
+    // 2. Inbox entries
+    const inboxEntries = readInbox();
+    if (inboxEntries.length > 0) {
+        messageParts.push(`## Notes from the assistant (save-to-memory inbox)\n`);
+        messageParts.push(inboxEntries.join('\n'));
+    }
+
+    // 3. Copilot conversations
+    const newRuns = findNewCopilotRuns(state);
+    const runsToProcess = newRuns.slice(-RUNS_BATCH_SIZE);
+    if (runsToProcess.length > 0) {
+        let conversationText = '';
+        for (const runFile of runsToProcess) {
+            const messages = extractConversationMessages(path.join(RUNS_DIR, runFile));
+            if (messages.length === 0) continue;
+            conversationText += `\n--- Conversation ---\n`;
+            for (const msg of messages) {
+                conversationText += `${msg.role}: ${msg.text}\n\n`;
+            }
+        }
+        if (conversationText.trim()) {
+            messageParts.push(`## Recent copilot conversations\n${conversationText}`);
+        }
+    }
+
+    // Nothing to process
+    if (messageParts.length === 0) {
+        return;
+    }
+
+    const serviceRun = await serviceLogger.startRun({
+        service: 'agent_notes',
+        message: 'Processing agent notes',
+        trigger: 'timer',
+    });
+
+    try {
+        const timestamp = new Date().toISOString();
+        const message = `Current timestamp: ${timestamp}\n\nProcess the following source material and update the Agent Notes folder accordingly.\n\n${messageParts.join('\n\n')}`;
+
+        const agentRun = await createRun({ agentId: AGENT_ID });
+        await createMessage(agentRun.id, message);
+        await waitForRunCompletion(agentRun.id);
+
+        // Mark everything as processed
+        for (const p of emailPaths) {
+            markEmailProcessed(p, state);
+        }
+        for (const r of newRuns) {
+            markRunProcessed(r, state);
+        }
+        if (inboxEntries.length > 0) {
+            clearInbox();
+        }
+
+        state.lastRunTime = new Date().toISOString();
+        saveAgentNotesState(state);
+
+        await serviceLogger.log({
+            type: 'run_complete',
+            service: serviceRun.service,
+            runId: serviceRun.runId,
+            level: 'info',
+            message: 'Agent notes processing complete',
+            durationMs: Date.now() - serviceRun.startedAt,
+            outcome: 'ok',
+            summary: {
+                emails: emailPaths.length,
+                inboxEntries: inboxEntries.length,
+                copilotRuns: runsToProcess.length,
+            },
+        });
+    } catch (error) {
+        console.error('[AgentNotes] Error processing:', error);
+        await serviceLogger.log({
+            type: 'error',
+            service: serviceRun.service,
+            runId: serviceRun.runId,
+            level: 'error',
+            message: 'Error processing agent notes',
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+
+// --- Entry point ---
+
+export async function init() {
+    console.log('[AgentNotes] Starting Agent Notes Service...');
+    console.log(`[AgentNotes] Will process every ${SYNC_INTERVAL_MS / 1000} seconds`);
+
+    // Initial run
+    await processAgentNotes();
+
+    // Periodic polling
+    while (true) {
+        await new Promise(resolve => setTimeout(resolve, SYNC_INTERVAL_MS));
+        try {
+            await processAgentNotes();
+        } catch (error) {
+            console.error('[AgentNotes] Error in main loop:', error);
+        }
+    }
+}

apps/x/packages/core/src/knowledge/agent_notes_agent.ts

@@ -0,0 +1,90 @@
+export function getRaw(): string {
+  return `---
+tools:
+  workspace-writeFile:
+    type: builtin
+    name: workspace-writeFile
+  workspace-readFile:
+    type: builtin
+    name: workspace-readFile
+  workspace-edit:
+    type: builtin
+    name: workspace-edit
+  workspace-readdir:
+    type: builtin
+    name: workspace-readdir
+  workspace-mkdir:
+    type: builtin
+    name: workspace-mkdir
+---
+# Agent Notes
+
+You are the Agent Notes agent. You maintain a set of notes about the user in the \`knowledge/Agent Notes/\` folder. Your job is to process new source material and update the notes accordingly.
+
+## Folder Structure
+
+The Agent Notes folder contains markdown files that capture what you've learned about the user:
+
+- **user.md** — Facts about who the user IS: their identity, role, company, team, projects, relationships, life context. NOT how they write or what they prefer. Each fact is a timestamped bullet point.
+- **preferences.md** — General preferences and explicit rules (e.g., "don't use em-dashes", "no meetings before 11am"). These are injected into the assistant's system prompt on every chat.
+- **style/email.md** — Email writing style patterns, bucketed by recipient context, with examples from actual emails.
+- Other files as needed — If you notice preferences specific to a topic (e.g., presentations, meeting prep), create a dedicated file for them (e.g., \`presentations.md\`, \`meeting-prep.md\`).
+
+## How to Process Source Material
+
+You will receive a message containing some combination of:
+1. **Emails sent by the user** — Analyze their writing style and update \`style/email.md\`. Do NOT put style observations in \`user.md\`.
+2. **Inbox entries** — Notes the assistant saved during conversations via save-to-memory. Route each to the appropriate file. General preferences go to \`preferences.md\`. Topic-specific preferences get their own file.
+3. **Copilot conversations** — User and assistant messages from recent chats. Extract lasting facts about the user and append timestamped entries to \`user.md\`.
+
+## What Goes Where — Be Strict
+
+### user.md — ONLY identity and context facts
+Good examples:
+- Co-founded Rowboat Labs with Ramnique
+- Team of 4 people
+- Previously worked at Twitter
+- Planning to fundraise after Product Hunt launch
+- Based in Bangalore, travels to SF periodically
+
+Bad examples (do NOT put these in user.md):
+- "Uses concise, friendly scheduling replies" → this is style, goes in style/email.md
+- "Frequently replies with short confirmations" → this is style, goes in style/email.md
+- "Uses the abbreviation PFA" → this is style, goes in style/email.md
+- "Requested a children's story about a scientist grandmother" → this is an ephemeral task, skip entirely
+- "Prefers 30-minute meeting slots" → this is a preference, goes in preferences.md
+
+### style/email.md — Writing patterns from emails
+Organize by recipient context. Include concrete examples quoted from actual emails.
+- Close team (very terse, no greeting/sign-off)
+- External/investors (casual but structured)
+- Formal/cold (concise, complete sentences)
+
+### preferences.md — Explicit rules and preferences
+Things the user has stated they want or don't want.
+
+### Other files — Topic-specific persistent preferences ONLY
+Create a new file ONLY for recurring preference themes where the user has expressed multiple lasting preferences about a specific skill or task type. Examples: \`presentations.md\` (if the user has stated preferences about slide design, deck structure, etc.), \`meeting-prep.md\` (if they have preferences about how meetings are prepared).
+
+Do NOT create files for:
+- One-off facts or transient situations (e.g., "looking for housing in SF" — that's a user.md fact, not a preference file)
+- Topics with only a single observation
+- Things that are better captured in user.md or preferences.md
+
+## Rules
+
+- Always read a file before updating it so you know what's already there.
+- For \`user.md\`: Format is \`- [ISO_TIMESTAMP] The fact\`. The timestamp indicates when the fact was last confirmed.
+  - **Add** new facts with the current timestamp.
+  - **Refresh** existing facts: if you would add a fact that's already there, update its timestamp to the current one so it stays fresh.
+  - **Remove** facts that are likely outdated. Use your judgment: time-bound facts (e.g., "planning to launch next week", "has a meeting with X on Friday") go stale quickly. Stable facts (e.g., "co-founded Rowboat with Ramnique", "previously worked at Twitter") persist. If a fact's timestamp is old and it describes something transient, remove it.
+- For \`preferences.md\` and other preference files: you may reorganize and deduplicate, but preserve all existing preferences that are still relevant.
+- **Deduplicate strictly.** Before adding anything, check if the same fact is already captured — even if worded differently. Do NOT add a near-duplicate.
+- **Skip ephemeral tasks.** If the user asked the assistant to do a one-off thing (draft an email, write a story, search for something), that is NOT a fact about the user. Skip it entirely.
+- Be concise — bullet points, not paragraphs.
+- Capture context, not blanket rules. BAD: "User prefers casual tone". GOOD: "User prefers casual tone with internal team but formal with investors."
+- **If there's nothing new to add to a file, do NOT touch it.** Do not create placeholder content, do not write "no preferences recorded", do not add explanatory notes about what the file is for. Leave it empty or leave it as-is.
+- **Do NOT create files unless you have actual content for them.** An empty or boilerplate file is worse than no file.
+- Create the \`style/\` directory if it doesn't exist yet and you have style content to write.
+`;
+}

apps/x/packages/core/src/knowledge/agent_notes_state.ts

@@ -0,0 +1,62 @@
+import fs from 'fs';
+import path from 'path';
+import { WorkDir } from '../config/config.js';
+
+const STATE_FILE = path.join(WorkDir, 'agent_notes_state.json');
+
+export interface AgentNotesState {
+    processedEmails: Record<string, { processedAt: string }>;
+    processedRuns: Record<string, { processedAt: string }>;
+    lastRunTime: string;
+}
+
+export function loadAgentNotesState(): AgentNotesState {
+    if (fs.existsSync(STATE_FILE)) {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8'));
+            // Handle migration from older state without processedRuns
+            if (!parsed.processedRuns) {
+                parsed.processedRuns = {};
+            }
+            return parsed;
+        } catch (error) {
+            console.error('Error loading agent notes state:', error);
+        }
+    }
+
+    return {
+        processedEmails: {},
+        processedRuns: {},
+        lastRunTime: new Date(0).toISOString(),
+    };
+}
+
+export function saveAgentNotesState(state: AgentNotesState): void {
+    try {
+        fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+    } catch (error) {
+        console.error('Error saving agent notes state:', error);
+        throw error;
+    }
+}
+
+export function markEmailProcessed(filePath: string, state: AgentNotesState): void {
+    state.processedEmails[filePath] = {
+        processedAt: new Date().toISOString(),
+    };
+}
+
+export function markRunProcessed(runFile: string, state: AgentNotesState): void {
+    state.processedRuns[runFile] = {
+        processedAt: new Date().toISOString(),
+    };
+}
+
+export function resetAgentNotesState(): void {
+    const emptyState: AgentNotesState = {
+        processedEmails: {},
+        processedRuns: {},
+        lastRunTime: new Date().toISOString(),
+    };
+    saveAgentNotesState(emptyState);
+}

apps/x/packages/core/src/knowledge/build_graph.ts

@@ -1,7 +1,6 @@
 import fs from 'fs';
 import path from 'path';
 import { WorkDir } from '../config/config.js';
-import { autoConfigureStrictnessIfNeeded } from '../config/strictness_analyzer.js';
 import { createRun, createMessage } from '../runs/runs.js';
 import { bus } from '../runs/bus.js';
 import { serviceLogger, type ServiceRunContext } from '../services/service_logger.js';
@@ -26,11 +25,11 @@ const NOTES_OUTPUT_DIR = path.join(WorkDir, 'knowledge');
 const NOTE_CREATION_AGENT = 'note_creation';
 
 // Configuration for the graph builder service
-const SYNC_INTERVAL_MS = 30 * 1000; // Check every 30 seconds
+const SYNC_INTERVAL_MS = 15 * 1000; // 15 seconds
 const SOURCE_FOLDERS = [
     'gmail_sync',
-    'fireflies_transcripts',
-    'granola_notes',
+    path.join('knowledge', 'Meetings', 'fireflies'),
+    path.join('knowledge', 'Meetings', 'granola'),
 ];
 
 // Voice memos are now created directly in knowledge/Voice Memos/<date>/
@@ -193,7 +192,9 @@ async function createNotesFromBatch(
     // Add each file's content
     message += `# Source Files to Process\n\n`;
     files.forEach((file, idx) => {
-        message += `## Source File ${idx + 1}: ${path.basename(file.path)}\n\n`;
+        // Pass workspace-relative path so the agent can link back to meeting notes
+        const relativePath = path.relative(WorkDir, file.path);
+        message += `## Source File ${idx + 1}: ${relativePath}\n\n`;
         message += file.content;
         message += `\n\n---\n\n`;
     });
@@ -363,7 +364,19 @@ export async function buildGraph(sourceDir: string): Promise<void> {
     console.log(`[buildGraph] State loaded. Previously processed: ${previouslyProcessedCount} files`);
 
     // Get files that need processing (new or changed)
-    const filesToProcess = getFilesToProcess(sourceDir, state);
+    let filesToProcess = getFilesToProcess(sourceDir, state);
+
+    // For gmail_sync, only process emails that have been labeled (have YAML frontmatter)
+    if (sourceDir.endsWith('gmail_sync')) {
+        filesToProcess = filesToProcess.filter(filePath => {
+            try {
+                const content = fs.readFileSync(filePath, 'utf-8');
+                return content.startsWith('---');
+            } catch {
+                return false;
+            }
+        });
+    }
 
     if (filesToProcess.length === 0) {
         console.log(`[buildGraph] No new or changed files to process in ${path.basename(sourceDir)}`);
@@ -525,8 +538,6 @@ async function processVoiceMemosForKnowledge(): Promise<boolean> {
 async function processAllSources(): Promise<void> {
     console.log('[GraphBuilder] Checking for new content in all sources...');
 
-    // Auto-configure strictness on first run if not already done
-    autoConfigureStrictnessIfNeeded();
 
     let anyFilesProcessed = false;
 
@@ -555,7 +566,19 @@ async function processAllSources(): Promise<void> {
         }
 
         try {
-            const filesToProcess = getFilesToProcess(sourceDir, state);
+            let filesToProcess = getFilesToProcess(sourceDir, state);
+
+            // For gmail_sync, only process emails that have been labeled (have YAML frontmatter)
+            if (folder === 'gmail_sync') {
+                filesToProcess = filesToProcess.filter(filePath => {
+                    try {
+                        const content = fs.readFileSync(filePath, 'utf-8');
+                        return content.startsWith('---');
+                    } catch {
+                        return false;
+                    }
+                });
+            }
 
             if (filesToProcess.length > 0) {
                 console.log(`[GraphBuilder] Found ${filesToProcess.length} new/changed files in ${folder}`);

apps/x/packages/core/src/knowledge/fireflies-client-factory.ts

@@ -135,7 +135,7 @@ export class FirefliesClientFactory {
         }
 
         console.log(`[Fireflies] Initializing OAuth configuration...`);
-        const providerConfig = getProviderConfig(this.PROVIDER_NAME);
+        const providerConfig = await getProviderConfig(this.PROVIDER_NAME);
 
         if (providerConfig.discovery.mode === 'issuer') {
             if (providerConfig.client.mode === 'static') {

apps/x/packages/core/src/knowledge/google-client-factory.ts

@@ -155,7 +155,7 @@ export class GoogleClientFactory {
         }
 
         console.log(`[OAuth] Initializing Google OAuth configuration...`);
-        const providerConfig = getProviderConfig(this.PROVIDER_NAME);
+        const providerConfig = await getProviderConfig(this.PROVIDER_NAME);
 
         if (providerConfig.discovery.mode === 'issuer') {
             if (providerConfig.client.mode === 'static') {

apps/x/packages/core/src/knowledge/granola/sync.ts

@@ -17,13 +17,14 @@ import {
 const GRANOLA_CLIENT_VERSION = '6.462.1';
 const GRANOLA_API_BASE = 'https://api.granola.ai';
 const GRANOLA_CONFIG_PATH = path.join(homedir(), 'Library', 'Application Support', 'Granola', 'supabase.json');
-const SYNC_DIR = path.join(WorkDir, 'granola_notes');
-const STATE_FILE = path.join(SYNC_DIR, 'sync_state.json');
+const SYNC_DIR = path.join(WorkDir, 'knowledge', 'Meetings', 'granola');
+const STATE_FILE = path.join(WorkDir, 'granola_sync_state.json');
 const SYNC_INTERVAL_MS = 5 * 60 * 1000; // Check every 5 minutes
 const API_DELAY_MS = 1000; // 1 second delay between API calls
 const RATE_LIMIT_RETRY_DELAY_MS = 60 * 1000; // Wait 1 minute on rate limit
 const MAX_RETRIES = 3; // Maximum retries for rate-limited requests
 const MAX_BATCH_SIZE = 10; // Process max 10 documents per folder per sync
+const LOOKBACK_DAYS = 30; // Only sync documents from the last 30 days
 
 // --- Wake Signal for Immediate Sync Trigger ---
 let wakeResolve: (() => void) | null = null;
@@ -370,6 +371,10 @@ async function syncNotes(): Promise<void> {
         let hasMore = true;
         const changedTitles: string[] = [];
 
+        // Calculate lookback cutoff date
+        const lookbackCutoff = new Date();
+        lookbackCutoff.setDate(lookbackCutoff.getDate() - LOOKBACK_DAYS);
+
         // Fetch documents with pagination
         while (hasMore) {
             // Delay before API call (except first)
@@ -390,7 +395,16 @@ async function syncNotes(): Promise<void> {
             }
 
             // Process each document
+            let foundOldDoc = false;
             for (const doc of docsResponse.docs) {
+                // Skip documents outside the lookback period
+                const docDate = new Date(doc.created_at);
+                if (docDate < lookbackCutoff) {
+                    console.log(`[Granola] Document "${doc.title}" is older than ${LOOKBACK_DAYS} days, stopping pagination`);
+                    foundOldDoc = true;
+                    break;
+                }
+
                 const docUpdatedAt = doc.updated_at || doc.created_at;
                 const lastSyncedAt = state.syncedDocs[doc.id];
 
@@ -407,8 +421,15 @@ async function syncNotes(): Promise<void> {
 
                 // Convert to markdown and save
                 const markdown = documentToMarkdown(doc);
-                const filename = `${doc.id}_${cleanFilename(docTitle)}.md`;
-                const filePath = path.join(SYNC_DIR, filename);
+                const dateDir = path.join(
+                    SYNC_DIR,
+                    String(docDate.getFullYear()),
+                    String(docDate.getMonth() + 1).padStart(2, '0'),
+                    String(docDate.getDate()).padStart(2, '0')
+                );
+                ensureDir(dateDir);
+                const filename = `${cleanFilename(docTitle)}.md`;
+                const filePath = path.join(dateDir, filename);
 
                 fs.writeFileSync(filePath, markdown);
 
@@ -424,6 +445,12 @@ async function syncNotes(): Promise<void> {
                 state.syncedDocs[doc.id] = docUpdatedAt;
             }
 
+            // Stop if we hit a document outside the lookback period
+            if (foundOldDoc) {
+                hasMore = false;
+                break;
+            }
+
             // Move to next page
             offset += docsResponse.docs.length;
 

apps/x/packages/core/src/knowledge/inline_task_agent.ts

@@ -0,0 +1,92 @@
+import { BuiltinTools } from '../application/lib/builtin-tools.js';
+
+export function getRaw(): string {
+  const toolEntries = Object.keys(BuiltinTools)
+    .map(name => `  ${name}:\n    type: builtin\n    name: ${name}`)
+    .join('\n');
+
+  const now = new Date();
+  const defaultEnd = new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000);
+  const localNow = now.toLocaleString('en-US', { dateStyle: 'full', timeStyle: 'long' });
+  const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  const nowISO = now.toISOString();
+  const defaultEndISO = defaultEnd.toISOString();
+
+  return `---
+model: gpt-5.2
+tools:
+${toolEntries}
+---
+# Task
+
+You are an inline task execution agent. You receive a @rowboat instruction from within a knowledge note and either execute it immediately or set it up as a recurring task.
+
+# Two Modes
+
+## 1. One-Time Tasks (no scheduling intent)
+For instructions that should be executed immediately (e.g., "summarize this note", "look up the weather"):
+- Execute the instruction using your full workspace tool set
+- Return the result as markdown content
+- Do NOT include any schedule or instruction markers
+
+## 2. Recurring/Scheduled Tasks (has scheduling intent)
+For instructions that imply a recurring or future-scheduled task (e.g., "every morning at 8am check emails", "remind me tomorrow at 3pm"):
+- Do NOT execute the task — only set up the schedule
+- You MUST include BOTH markers described below
+- Do NOT include any other content besides the markers
+
+# Markers for Scheduled Tasks
+
+When the instruction has scheduling intent, your response MUST contain these markers and nothing else:
+
+## Schedule Marker (required)
+<!--rowboat-schedule:{"type":"...","label":"..."}-->
+
+Schedule types:
+1. "cron" — recurring: \`<!--rowboat-schedule:{"type":"cron","expression":"<5-field cron>","startDate":"<ISO>","endDate":"<ISO>","label":"<label>"}-->\`
+   "startDate" defaults to now (${nowISO}). "endDate" defaults to 7 days from now (${defaultEndISO}).
+   Example: "every morning at 8am" → \`<!--rowboat-schedule:{"type":"cron","expression":"0 8 * * *","startDate":"${nowISO}","endDate":"${defaultEndISO}","label":"runs daily at 8 AM until ${defaultEnd.toLocaleDateString('en-US', { month: 'short', day: 'numeric' })}"}-->\`
+
+2. "window" — recurring with time window: \`<!--rowboat-schedule:{"type":"window","cron":"<cron>","startTime":"HH:MM","endTime":"HH:MM","startDate":"<ISO>","endDate":"<ISO>","label":"<label>"}-->\`
+
+3. "once" — future one-time: \`<!--rowboat-schedule:{"type":"once","runAt":"<ISO 8601>","label":"<label>"}-->\`
+
+The "label" must be a short plain-English description starting with "runs" (e.g., "runs daily at 8 AM until Mar 24").
+
+## Instruction Marker (required for scheduled tasks)
+<!--rowboat-instruction:the refined instruction text-->
+
+This is the instruction that will be executed on each scheduled run. You may refine/clarify the original instruction to make it more specific and actionable for the background agent that will execute it. For example:
+- User says "check my emails every morning" → \`<!--rowboat-instruction:Check for new emails and summarize any important ones.-->\`
+- User says "news about claude daily" → \`<!--rowboat-instruction:Search for the latest news about Anthropic's Claude AI and list the top stories with sources.-->\`
+
+If the instruction is already clear and actionable, you can keep it as-is.
+
+# Context
+
+Current local time: ${localNow}
+Timezone: ${tz}
+Current UTC time: ${nowISO}
+
+# Output Rules
+
+- For one-time tasks: write output as note content — it must read naturally as part of the document. NEVER include meta-commentary. Keep concise and well-formatted in markdown.
+- For scheduled tasks: output ONLY the two markers (schedule + instruction), nothing else.
+- Do not modify the original note file — the system handles all insertions.
+
+# Target Regions
+
+For recurring/scheduled tasks, the note will contain a **target region** delimited by HTML comment tags:
+
+\`\`\`
+<!--task-target:TARGETID-->
+...existing content...
+<!--/task-target:TARGETID-->
+\`\`\`
+
+When you see a target region associated with your task (during a scheduled run), your response MUST be the replacement content for that region. You should:
+- Write content that replaces whatever is currently between the tags
+- Use the existing content as context (e.g., to update rather than regenerate from scratch if appropriate)
+- Do NOT include the target tags themselves in your response
+`;
+}

apps/x/packages/core/src/knowledge/inline_tasks.ts

@@ -0,0 +1,741 @@
+import fs from 'fs';
+import path from 'path';
+import { CronExpressionParser } from 'cron-parser';
+import { generateText } from 'ai';
+import { WorkDir } from '../config/config.js';
+import { createRun, createMessage, fetchRun } from '../runs/runs.js';
+import { bus } from '../runs/bus.js';
+import container from '../di/container.js';
+import type { IModelConfigRepo } from '../models/repo.js';
+import { createProvider } from '../models/models.js';
+import { inlineTask } from '@x/shared';
+
+const SYNC_INTERVAL_MS = 15 * 1000; // 15 seconds
+const INLINE_TASK_AGENT = 'inline_task_agent';
+const KNOWLEDGE_DIR = path.join(WorkDir, 'knowledge');
+
+
+// ---------------------------------------------------------------------------
+// Minimal frontmatter helpers (duplicated from renderer to avoid cross-package
+// dependency — can be moved to shared later).
+// ---------------------------------------------------------------------------
+
+function splitFrontmatter(content: string): { raw: string | null; body: string } {
+    if (!content.startsWith('---')) {
+        return { raw: null, body: content };
+    }
+    const endIndex = content.indexOf('\n---', 3);
+    if (endIndex === -1) {
+        return { raw: null, body: content };
+    }
+    const closingEnd = endIndex + 4;
+    const raw = content.slice(0, closingEnd);
+    let body = content.slice(closingEnd);
+    if (body.startsWith('\n')) {
+        body = body.slice(1);
+    }
+    return { raw, body };
+}
+
+function joinFrontmatter(raw: string | null, body: string): string {
+    if (!raw) return body;
+    return raw + '\n' + body;
+}
+
+function extractAllFrontmatterValues(raw: string | null): Record<string, string | string[]> {
+    const result: Record<string, string | string[]> = {};
+    if (!raw) return result;
+
+    const lines = raw.split('\n');
+    let currentKey: string | null = null;
+
+    for (const line of lines) {
+        if (line === '---' || line.trim() === '') {
+            currentKey = null;
+            continue;
+        }
+        const topMatch = line.match(/^(\w[\w\s]*\w|\w+):\s*(.*)$/);
+        if (topMatch) {
+            const key = topMatch[1];
+            const value = topMatch[2].trim();
+            if (value) {
+                result[key] = value;
+                currentKey = null;
+            } else {
+                currentKey = key;
+                result[key] = [];
+            }
+            continue;
+        }
+        if (currentKey) {
+            const itemMatch = line.match(/^\s+-\s+(.+)$/);
+            if (itemMatch) {
+                const arr = result[currentKey];
+                if (Array.isArray(arr)) {
+                    arr.push(itemMatch[1].trim());
+                }
+            }
+        }
+    }
+    return result;
+}
+
+function buildFrontmatter(fields: Record<string, string | string[]>): string | null {
+    const lines: string[] = [];
+    for (const [key, value] of Object.entries(fields)) {
+        if (Array.isArray(value)) {
+            if (value.length === 0) continue;
+            lines.push(`${key}:`);
+            for (const item of value) {
+                if (item.trim()) lines.push(`  - ${item.trim()}`);
+            }
+        } else {
+            const trimmed = (value ?? '').trim();
+            if (!trimmed) continue;
+            lines.push(`${key}: ${trimmed}`);
+        }
+    }
+    if (lines.length === 0) return null;
+    return `---\n${lines.join('\n')}\n---`;
+}
+
+// ---------------------------------------------------------------------------
+// Schedule types
+// ---------------------------------------------------------------------------
+
+type InlineTaskSchedule =
+    | { type: 'cron'; expression: string; startDate: string; endDate: string; label: string }
+    | { type: 'window'; cron: string; startTime: string; endTime: string; startDate: string; endDate: string; label: string }
+    | { type: 'once'; runAt: string; label: string };
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function scanDirectoryRecursive(dir: string): string[] {
+    if (!fs.existsSync(dir)) return [];
+    const files: string[] = [];
+    const entries = fs.readdirSync(dir);
+    for (const entry of entries) {
+        if (entry.startsWith('.')) continue;
+        const fullPath = path.join(dir, entry);
+        const stat = fs.statSync(fullPath);
+        if (stat.isDirectory()) {
+            files.push(...scanDirectoryRecursive(fullPath));
+        } else if (stat.isFile() && entry.endsWith('.md')) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+
+/**
+ * Wait for a run to complete by listening for run-processing-end event
+ */
+async function waitForRunCompletion(runId: string): Promise<void> {
+    return new Promise(async (resolve) => {
+        const unsubscribe = await bus.subscribe('*', async (event) => {
+            if (event.type === 'run-processing-end' && event.runId === runId) {
+                unsubscribe();
+                resolve();
+            }
+        });
+    });
+}
+
+/**
+ * Extract the assistant's final text response from a run's log.
+ */
+async function extractAgentResponse(runId: string): Promise<string | null> {
+    const run = await fetchRun(runId);
+    // Walk backwards through the log to find the last assistant message
+    for (let i = run.log.length - 1; i >= 0; i--) {
+        const event = run.log[i];
+        if (event.type === 'message' && event.message.role === 'assistant') {
+            const content = event.message.content;
+            if (typeof content === 'string') {
+                return content;
+            }
+            // Content may be an array of parts — concatenate text parts
+            if (Array.isArray(content)) {
+                const text = content
+                    .filter((p) => p.type === 'text')
+                    .map((p) => (p as { type: 'text'; text: string }).text)
+                    .join('');
+                return text || null;
+            }
+        }
+    }
+    return null;
+}
+
+interface InlineTask {
+    instruction: string;
+    schedule: InlineTaskSchedule | null;
+    /** Line index of the opening ```task fence in the body */
+    startLine: number;
+    /** Line index of the closing ``` fence */
+    endLine: number;
+    /** Target region ID for recurring tasks */
+    targetId: string | null;
+}
+
+/**
+ * Parse the tell-rowboat block content (JSON format).
+ * Returns { instruction, schedule } or null if not valid JSON.
+ * Also supports legacy @rowboat format.
+ */
+function parseBlockContent(contentLines: string[]): { instruction: string; schedule: InlineTaskSchedule | null; lastRunAt: string | null; targetId: string | null } | null {
+    const raw = contentLines.join('\n').trim();
+    try {
+        const data = JSON.parse(raw);
+        const parsed = inlineTask.InlineTaskBlockSchema.safeParse(data);
+        if (parsed.success) {
+            return {
+                instruction: parsed.data.instruction,
+                schedule: parsed.data.schedule ? { ...parsed.data.schedule, label: parsed.data['schedule-label'] ?? '' } as InlineTaskSchedule : null,
+                lastRunAt: parsed.data.lastRunAt ?? null,
+                targetId: parsed.data.targetId ?? null,
+            };
+        }
+        // Fallback for blocks that have instruction but don't fully match schema
+        if (data && typeof data === 'object' && data.instruction) {
+            return {
+                instruction: data.instruction,
+                schedule: data.schedule ?? null,
+                lastRunAt: data.lastRunAt ?? null,
+                targetId: data.targetId ?? null,
+            };
+        }
+    } catch {
+        // Legacy format: @rowboat lines + optional schedule: JSON line
+    }
+
+    // Legacy fallback: parse @rowboat instruction and schedule: line
+    let schedule: InlineTaskSchedule | null = null;
+    const instructionLines: string[] = [];
+    for (const cl of contentLines) {
+        const schedMatch = cl.trim().match(/^schedule:\s*(.+)$/);
+        if (schedMatch) {
+            try {
+                const obj = JSON.parse(schedMatch[1]);
+                if (obj && typeof obj === 'object' && obj.type) {
+                    schedule = obj as InlineTaskSchedule;
+                }
+            } catch { /* not JSON schedule, skip */ }
+        } else if (!/^schedule-config:\s/.test(cl.trim())) {
+            instructionLines.push(cl);
+        }
+    }
+    const firstRowboatLine = instructionLines.find(l => l.trim().startsWith('@rowboat'));
+    const rawInstruction = firstRowboatLine?.trim() ?? instructionLines.join('\n').trim();
+    const instruction = rawInstruction.replace(/^@rowboat:?\s*/, '');
+    if (!instruction) return null;
+    return { instruction, schedule, lastRunAt: null, targetId: null };
+}
+
+/**
+ * Determine if a scheduled task is due to run.
+ */
+function isScheduledTaskDue(schedule: InlineTaskSchedule, lastRunAt: string | null): boolean {
+    const now = new Date();
+
+    // Check startDate/endDate bounds for cron and window
+    if (schedule.type === 'cron' || schedule.type === 'window') {
+        if (schedule.startDate && now < new Date(schedule.startDate)) return false;
+        if (schedule.endDate && now > new Date(schedule.endDate)) return false;
+    }
+
+    switch (schedule.type) {
+        case 'cron': {
+            if (!lastRunAt) return true; // Never run → due
+            try {
+                const lastRun = new Date(lastRunAt);
+                const interval = CronExpressionParser.parse(schedule.expression, {
+                    currentDate: lastRun,
+                });
+                const nextRun = interval.next().toDate();
+                return now >= nextRun;
+            } catch {
+                return false;
+            }
+        }
+        case 'window': {
+            if (!lastRunAt) return true;
+            try {
+                const lastRun = new Date(lastRunAt);
+                const interval = CronExpressionParser.parse(schedule.cron, {
+                    currentDate: lastRun,
+                });
+                const nextDate = interval.next().toDate();
+
+                // Check if we're within the time window
+                const [startHour, startMin] = schedule.startTime.split(':').map(Number);
+                const [endHour, endMin] = schedule.endTime.split(':').map(Number);
+                const startMinutes = startHour * 60 + startMin;
+                const endMinutes = endHour * 60 + endMin;
+                const nowMinutes = now.getHours() * 60 + now.getMinutes();
+
+                // The cron date must have passed and we need to be in the time window
+                return now >= nextDate && nowMinutes >= startMinutes && nowMinutes <= endMinutes;
+            } catch {
+                return false;
+            }
+        }
+        case 'once': {
+            if (lastRunAt) return false; // Already ran
+            const runAt = new Date(schedule.runAt);
+            return now >= runAt;
+        }
+    }
+}
+
+
+/**
+ * Find ```tell-rowboat code blocks in a note body and return tasks that are pending execution.
+ */
+function findPendingTasks(body: string): InlineTask[] {
+    const tasks: InlineTask[] = [];
+    const lines = body.split('\n');
+    let i = 0;
+    while (i < lines.length) {
+        const trimmed = lines[i].trim();
+        if (trimmed.startsWith('```task') || trimmed.startsWith('```tell-rowboat')) {
+            const startLine = i;
+            i++;
+            const contentLines: string[] = [];
+            while (i < lines.length && lines[i].trim() !== '```') {
+                contentLines.push(lines[i]);
+                i++;
+            }
+            const endLine = i; // line with closing ```
+
+            const parsed = parseBlockContent(contentLines);
+            if (parsed) {
+                const { instruction, schedule, lastRunAt, targetId } = parsed;
+
+                if (schedule) {
+                    if (isScheduledTaskDue(schedule, lastRunAt)) {
+                        tasks.push({ instruction, schedule, startLine, endLine, targetId });
+                    }
+                } else {
+                    // One-time task: skip if already ran
+                    if (!lastRunAt) {
+                        tasks.push({ instruction, schedule: null, startLine, endLine, targetId });
+                    }
+                }
+            }
+        }
+        i++;
+    }
+    return tasks;
+}
+
+/**
+ * Insert the agent result below the tell-rowboat code block in the body.
+ * Returns the updated body string.
+ */
+function insertResultBelow(body: string, endLine: number, result: string): string {
+    const lines = body.split('\n');
+    // Insert a blank line + result after the closing ``` fence
+    lines.splice(endLine + 1, 0, '', result);
+    return lines.join('\n');
+}
+
+
+/**
+ * Replace content inside a target region identified by targetId.
+ * If the target region exists, replaces its content.
+ * If it doesn't exist, creates the target region below the task block,
+ * wrapping any existing content between the block and the next block/heading.
+ */
+function replaceTargetRegion(body: string, targetId: string, result: string, endLine: number): string {
+    const openTag = `<!--task-target:${targetId}-->`;
+    const closeTag = `<!--/task-target:${targetId}-->`;
+    const openIdx = body.indexOf(openTag);
+    const closeIdx = body.indexOf(closeTag);
+
+    if (openIdx !== -1 && closeIdx !== -1 && closeIdx > openIdx) {
+        // Target region exists — replace content between the tags
+        const before = body.slice(0, openIdx + openTag.length);
+        const after = body.slice(closeIdx);
+        return before + '\n' + result + '\n' + after;
+    }
+
+    // Target region doesn't exist yet — create it below the task block's closing fence
+    const lines = body.split('\n');
+    const taggedResult = `${openTag}\n${result}\n${closeTag}`;
+    lines.splice(endLine + 1, 0, '', taggedResult);
+    return lines.join('\n');
+}
+
+/**
+ * Determine if a note has any "live" tell-rowboat tasks.
+ * A task is live if:
+ *   - It's a one-time task that hasn't been completed yet
+ *   - It's a scheduled task whose endDate hasn't passed (or has no endDate)
+ *   - It's a scheduled task before its startDate (will run in the future)
+ */
+function hasLiveTasks(body: string): boolean {
+    const now = new Date();
+    const lines = body.split('\n');
+    let i = 0;
+    while (i < lines.length) {
+        const trimmed = lines[i].trim();
+        if (trimmed.startsWith('```task') || trimmed.startsWith('```tell-rowboat')) {
+            i++;
+            const contentLines: string[] = [];
+            while (i < lines.length && lines[i].trim() !== '```') {
+                contentLines.push(lines[i]);
+                i++;
+            }
+
+            const parsed = parseBlockContent(contentLines);
+            if (!parsed) { i++; continue; }
+
+            const { schedule, lastRunAt } = parsed;
+
+            if (schedule) {
+                if (schedule.type === 'cron' || schedule.type === 'window') {
+                    const endDate = schedule.endDate;
+                    if (!endDate || now <= new Date(endDate)) {
+                        return true;
+                    }
+                } else if (schedule.type === 'once') {
+                    if (!lastRunAt) {
+                        return true;
+                    }
+                }
+            } else {
+                // One-time task without schedule: live if never ran
+                if (!lastRunAt) {
+                    return true;
+                }
+            }
+        }
+        i++;
+    }
+    return false;
+}
+
+// ---------------------------------------------------------------------------
+// Block data helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Update the JSON content inside a task code block to include lastRunAt.
+ * Replaces the content lines between the opening and closing fences.
+ */
+function updateBlockData(body: string, startLine: number, endLine: number, lastRunAt: string): string {
+    const lines = body.split('\n');
+    // Content is between startLine+1 and endLine-1
+    const contentLines = lines.slice(startLine + 1, endLine);
+    const raw = contentLines.join('\n').trim();
+
+    try {
+        const data = JSON.parse(raw);
+        data.lastRunAt = lastRunAt;
+        const updatedJson = JSON.stringify(data);
+        // Replace content lines with the updated JSON (single line)
+        lines.splice(startLine + 1, endLine - startLine - 1, updatedJson);
+    } catch {
+        // Not valid JSON — skip update
+    }
+
+    return lines.join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// Main processing
+// ---------------------------------------------------------------------------
+
+async function processInlineTasks(): Promise<void> {
+    console.log('[InlineTasks] Checking live notes...');
+
+    if (!fs.existsSync(KNOWLEDGE_DIR)) {
+        console.log('[InlineTasks] Knowledge directory not found');
+        return;
+    }
+
+    const allFiles = scanDirectoryRecursive(KNOWLEDGE_DIR);
+    let totalProcessed = 0;
+
+    for (const filePath of allFiles) {
+        let content: string;
+        try {
+            content = fs.readFileSync(filePath, 'utf-8');
+        } catch {
+            continue;
+        }
+
+        const { raw, body } = splitFrontmatter(content);
+        const fields = extractAllFrontmatterValues(raw);
+
+        // Only process files marked as live
+        if (fields['live_note'] !== 'true') continue;
+
+        const tasks = findPendingTasks(body);
+
+        if (tasks.length === 0) {
+            // No pending tasks — check if still live, update if not
+            const live = hasLiveTasks(body);
+            if (!live) {
+                fields['live_note'] = 'false';
+                // Remove rowboat_tasks if present (legacy cleanup)
+                delete fields['rowboat_tasks'];
+                const newRaw = buildFrontmatter(fields);
+                const newContent = joinFrontmatter(newRaw, body);
+                try {
+                    fs.writeFileSync(filePath, newContent, 'utf-8');
+                    const rel = path.relative(WorkDir, filePath);
+                    console.log(`[InlineTasks] Marked ${rel} as no longer live`);
+                } catch { /* ignore */ }
+            }
+            continue;
+        }
+
+        const relativePath = path.relative(WorkDir, filePath);
+        console.log(`[InlineTasks] Found ${tasks.length} pending task(s) in ${relativePath}`);
+
+        // Process tasks one at a time, bottom-up so line indices stay valid
+        // (inserting content shifts lines below, so process from bottom to top)
+        const sortedTasks = [...tasks].sort((a, b) => b.endLine - a.endLine);
+
+        let currentBody = body;
+
+        for (const task of sortedTasks) {
+            console.log(`[InlineTasks] Running task: "${task.instruction.slice(0, 80)}..."`);
+
+            try {
+                const run = await createRun({ agentId: INLINE_TASK_AGENT });
+
+                const message = [
+                    `Execute the following instruction from the note "${relativePath}":`,
+                    '',
+                    `**Instruction:** ${task.instruction}`,
+                    '',
+                    '**Full note content for context:**',
+                    '```markdown',
+                    content,
+                    '```',
+                ].join('\n');
+
+                await createMessage(run.id, message);
+                await waitForRunCompletion(run.id);
+
+                const result = await extractAgentResponse(run.id);
+                if (result) {
+                    if (task.targetId) {
+                        // Recurring task with target region — replace content inside the region
+                        currentBody = replaceTargetRegion(currentBody, task.targetId, result, task.endLine);
+                    } else {
+                        // No target region — insert below the block
+                        currentBody = insertResultBelow(currentBody, task.endLine, result);
+                    }
+                    // Update the block JSON with lastRunAt
+                    const timestamp = new Date().toISOString();
+                    currentBody = updateBlockData(currentBody, task.startLine, task.endLine, timestamp);
+                    totalProcessed++;
+                    console.log(`[InlineTasks] Task completed`);
+                } else {
+                    console.warn(`[InlineTasks] No response from agent for task`);
+                }
+            } catch (error) {
+                console.error(`[InlineTasks] Error processing task:`, error);
+            }
+        }
+
+        // Update frontmatter — only manage live_note, remove legacy rowboat_tasks
+        const live = hasLiveTasks(currentBody);
+        fields['live_note'] = live ? 'true' : 'false';
+        delete fields['rowboat_tasks'];
+        const newRaw = buildFrontmatter(fields);
+        const newContent = joinFrontmatter(newRaw, currentBody);
+
+        try {
+            fs.writeFileSync(filePath, newContent, 'utf-8');
+            console.log(`[InlineTasks] Updated ${relativePath}`);
+        } catch (error) {
+            console.error(`[InlineTasks] Error writing ${relativePath}:`, error);
+        }
+    }
+
+    if (totalProcessed > 0) {
+        console.log(`[InlineTasks] Done. Processed ${totalProcessed} task(s).`);
+    } else {
+        console.log('[InlineTasks] No pending tasks found');
+    }
+}
+
+/**
+ * Process a @rowboat instruction via the inline task agent.
+ * The agent can execute one-off tasks and/or detect scheduling intent.
+ * Returns schedule info (if any), a schedule label, and optional response text.
+ */
+type ScheduleWithoutLabel =
+    | { type: 'cron'; expression: string; startDate: string; endDate: string }
+    | { type: 'window'; cron: string; startTime: string; endTime: string; startDate: string; endDate: string }
+    | { type: 'once'; runAt: string };
+
+export async function processRowboatInstruction(
+    instruction: string,
+    noteContent: string,
+    notePath: string,
+): Promise<{
+    instruction: string;
+    schedule: ScheduleWithoutLabel | null;
+    scheduleLabel: string | null;
+    response: string | null;
+}> {
+    const run = await createRun({ agentId: INLINE_TASK_AGENT });
+
+    const message = [
+        `Process the following @rowboat instruction from the note "${notePath}":`,
+        '',
+        `**Instruction:** ${instruction}`,
+        '',
+        '**Full note content for context:**',
+        '```markdown',
+        noteContent,
+        '```',
+    ].join('\n');
+
+    await createMessage(run.id, message);
+    await waitForRunCompletion(run.id);
+
+    const rawResponse = await extractAgentResponse(run.id);
+    if (!rawResponse) {
+        return { instruction, schedule: null, scheduleLabel: null, response: null };
+    }
+
+    // Parse out the schedule marker if present (allow multiline JSON)
+    const scheduleMarkerRegex = /<!--rowboat-schedule:([\s\S]*?)-->/;
+    const scheduleMatch = rawResponse.match(scheduleMarkerRegex);
+
+    // Parse out the instruction marker if present
+    const instructionMarkerRegex = /<!--rowboat-instruction:([\s\S]*?)-->/;
+    const instructionMatch = rawResponse.match(instructionMarkerRegex);
+
+    let schedule: ScheduleWithoutLabel | null = null;
+    let scheduleLabel: string | null = null;
+    let refinedInstruction = instruction;
+
+    if (instructionMatch) {
+        refinedInstruction = instructionMatch[1].trim();
+    }
+
+    if (scheduleMatch) {
+        try {
+            const parsed = JSON.parse(scheduleMatch[1]);
+            if (parsed && typeof parsed === 'object' && parsed.type) {
+                scheduleLabel = parsed.label || null;
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const { label: _, ...rest } = parsed;
+                schedule = rest as ScheduleWithoutLabel;
+            }
+        } catch {
+            // Invalid JSON in marker — ignore
+        }
+
+        // Scheduled task — no response content (agent only returns markers)
+        return { instruction: refinedInstruction, schedule, scheduleLabel, response: null };
+    }
+
+    // One-time task — the full response is the content
+    const response = rawResponse.trim() || null;
+    return { instruction: refinedInstruction, schedule: null, scheduleLabel: null, response };
+}
+
+/**
+ * Classify whether an instruction contains a scheduling intent using the user's configured LLM.
+ * Returns a schedule object or null for one-time tasks.
+ */
+export async function classifySchedule(instruction: string): Promise<InlineTaskSchedule | null> {
+    const repo = container.resolve<IModelConfigRepo>('modelConfigRepo');
+    const config = await repo.getConfig();
+    const provider = createProvider(config.provider);
+    const model = provider.languageModel(config.model);
+
+    const now = new Date();
+    const defaultEnd = new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000);
+    const localNow = now.toLocaleString('en-US', { dateStyle: 'full', timeStyle: 'long' });
+    const localEnd = defaultEnd.toLocaleString('en-US', { dateStyle: 'full', timeStyle: 'long' });
+    const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    const nowISO = now.toISOString();
+    const defaultEndISO = defaultEnd.toISOString();
+
+    const systemPrompt = `You classify whether a user instruction contains a scheduling intent.
+
+If the instruction implies a recurring or future-scheduled task, return a JSON object with the schedule.
+If the instruction is a one-time immediate task, return null.
+
+Every schedule object MUST include a "label" field: a short, plain-English description starting with "runs" that includes the end date (e.g. "runs every 2 minutes until Mar 12", "runs daily at 8 AM until Mar 12").
+
+Schedule types:
+1. "cron" — recurring schedule. Return: {"type":"cron","expression":"<cron>","startDate":"<ISO>","endDate":"<ISO>","label":"<human readable>"}
+   Use standard 5-field cron (minute hour day-of-month month day-of-week).
+   "startDate" defaults to now (${nowISO}). "endDate" defaults to 7 days from now (${defaultEndISO}).
+   Override these if the user specifies a duration (e.g. "for the next 3 days" → endDate = now + 3 days) or a start (e.g. "starting next Monday").
+   Example: "every morning at 8am" → {"type":"cron","expression":"0 8 * * *","startDate":"${nowISO}","endDate":"${defaultEndISO}","label":"runs daily at 8 AM until Mar 12"}
+
+2. "window" — recurring with a time window. Return: {"type":"window","cron":"<cron>","startTime":"HH:MM","endTime":"HH:MM","startDate":"<ISO>","endDate":"<ISO>","label":"<human readable>"}
+   Use when the user specifies a range like "between 8am and 10am". Same startDate/endDate defaults and override rules as cron.
+
+3. "once" — run once at a specific future time. Return: {"type":"once","runAt":"<ISO 8601 datetime>","label":"<human readable>"}
+   Use when the user says "tomorrow at 3pm", "next Friday", etc. No startDate/endDate for once.
+
+Current local time: ${localNow}
+Timezone: ${tz}
+Current UTC time: ${nowISO}
+Default end time (local): ${localEnd}
+
+Respond with ONLY valid JSON: either a schedule object or null. No other text.`;
+
+    try {
+        const result = await generateText({
+            model,
+            system: systemPrompt,
+            prompt: instruction,
+        });
+
+        let text = result.text.trim();
+        console.log('[classifySchedule] LLM response:', text);
+        // Strip markdown code fences if the LLM wraps the JSON
+        text = text.replace(/^```(?:json)?\s*\n?/, '').replace(/\n?```\s*$/, '').trim();
+        if (text === 'null' || text === '') {
+            return null;
+        }
+
+        const parsed = JSON.parse(text);
+        if (!parsed || typeof parsed !== 'object' || !parsed.type) {
+            return null;
+        }
+
+        return parsed as InlineTaskSchedule;
+    } catch (error) {
+        console.error('[classifySchedule] Error:', error);
+        return null;
+    }
+}
+
+/**
+ * Main entry point — runs as independent polling service
+ */
+export async function init() {
+    console.log('[InlineTasks] Starting Inline Task Service...');
+    console.log(`[InlineTasks] Will check for task blocks every ${SYNC_INTERVAL_MS / 1000} seconds`);
+
+    // Initial run
+    await processInlineTasks();
+
+    // Periodic polling
+    while (true) {
+        await new Promise(resolve => setTimeout(resolve, SYNC_INTERVAL_MS));
+
+        try {
+            await processInlineTasks();
+        } catch (error) {
+            console.error('[InlineTasks] Error in main loop:', error);
+        }
+    }
+}

apps/x/packages/core/src/knowledge/label_emails.ts

@@ -0,0 +1,269 @@
+import fs from 'fs';
+import path from 'path';
+import { WorkDir } from '../config/config.js';
+import { createRun, createMessage } from '../runs/runs.js';
+import { bus } from '../runs/bus.js';
+import { serviceLogger } from '../services/service_logger.js';
+import { limitEventItems } from './limit_event_items.js';
+import {
+    loadLabelingState,
+    saveLabelingState,
+    markFileAsLabeled,
+    type LabelingState,
+} from './labeling_state.js';
+
+const SYNC_INTERVAL_MS = 15 * 1000; // 15 seconds
+const BATCH_SIZE = 15;
+const LABELING_AGENT = 'labeling_agent';
+const GMAIL_SYNC_DIR = path.join(WorkDir, 'gmail_sync');
+const MAX_CONTENT_LENGTH = 8000;
+
+/**
+ * Find email files that haven't been labeled yet
+ */
+function getUnlabeledEmails(state: LabelingState): string[] {
+    if (!fs.existsSync(GMAIL_SYNC_DIR)) {
+        return [];
+    }
+
+    const unlabeled: string[] = [];
+
+    function traverse(dir: string) {
+        const entries = fs.readdirSync(dir);
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry);
+            const stat = fs.statSync(fullPath);
+
+            if (stat.isDirectory()) {
+                traverse(fullPath);
+            } else if (stat.isFile() && entry.endsWith('.md')) {
+                // Skip if already tracked in state
+                if (state.processedFiles[fullPath]) {
+                    continue;
+                }
+
+                // Skip if file already has frontmatter
+                try {
+                    const content = fs.readFileSync(fullPath, 'utf-8');
+                    if (content.startsWith('---')) {
+                        continue;
+                    }
+                } catch {
+                    continue;
+                }
+
+                unlabeled.push(fullPath);
+            }
+        }
+    }
+
+    traverse(GMAIL_SYNC_DIR);
+    return unlabeled;
+}
+
+/**
+ * Wait for a run to complete by listening for run-processing-end event
+ */
+async function waitForRunCompletion(runId: string): Promise<void> {
+    return new Promise(async (resolve) => {
+        const unsubscribe = await bus.subscribe('*', async (event) => {
+            if (event.type === 'run-processing-end' && event.runId === runId) {
+                unsubscribe();
+                resolve();
+            }
+        });
+    });
+}
+
+/**
+ * Label a batch of email files using the labeling agent
+ */
+async function labelEmailBatch(
+    files: { path: string; content: string }[]
+): Promise<{ runId: string; filesEdited: Set<string> }> {
+    const run = await createRun({
+        agentId: LABELING_AGENT,
+    });
+
+    let message = `Label the following ${files.length} email files by prepending YAML frontmatter.\n\n`;
+    message += `**Important:** Use workspace-relative paths with workspace-edit (e.g. "gmail_sync/email.md", NOT absolute paths).\n\n`;
+
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        const relativePath = path.relative(WorkDir, file.path);
+        const truncated = file.content.length > MAX_CONTENT_LENGTH
+            ? file.content.slice(0, MAX_CONTENT_LENGTH) + '\n\n[... content truncated, use workspace-readFile for full content ...]'
+            : file.content;
+
+        message += `## File ${i + 1}: ${relativePath}\n\n`;
+        message += truncated;
+        message += `\n\n---\n\n`;
+    }
+
+    const filesEdited = new Set<string>();
+
+    const unsubscribe = await bus.subscribe(run.id, async (event) => {
+        if (event.type !== 'tool-invocation') {
+            return;
+        }
+        if (event.toolName !== 'workspace-edit') {
+            return;
+        }
+        try {
+            const parsed = JSON.parse(event.input) as { path?: string };
+            if (typeof parsed.path === 'string') {
+                filesEdited.add(parsed.path);
+            }
+        } catch {
+            // ignore parse errors
+        }
+    });
+
+    await createMessage(run.id, message);
+    await waitForRunCompletion(run.id);
+    unsubscribe();
+
+    return { runId: run.id, filesEdited };
+}
+
+/**
+ * Process all unlabeled emails in batches
+ */
+async function processUnlabeledEmails(): Promise<void> {
+    console.log('[EmailLabeling] Checking for unlabeled emails...');
+
+    const state = loadLabelingState();
+    const unlabeled = getUnlabeledEmails(state);
+
+    if (unlabeled.length === 0) {
+        console.log('[EmailLabeling] No unlabeled emails found');
+        return;
+    }
+
+    console.log(`[EmailLabeling] Found ${unlabeled.length} unlabeled emails`);
+
+    const run = await serviceLogger.startRun({
+        service: 'email_labeling',
+        message: `Labeling ${unlabeled.length} email${unlabeled.length === 1 ? '' : 's'}`,
+        trigger: 'timer',
+    });
+
+    const relativeFiles = unlabeled.map(f => path.relative(WorkDir, f));
+    const limitedFiles = limitEventItems(relativeFiles);
+    await serviceLogger.log({
+        type: 'changes_identified',
+        service: run.service,
+        runId: run.runId,
+        level: 'info',
+        message: `Found ${unlabeled.length} unlabeled email${unlabeled.length === 1 ? '' : 's'}`,
+        counts: { emails: unlabeled.length },
+        items: limitedFiles.items,
+        truncated: limitedFiles.truncated,
+    });
+
+    const totalBatches = Math.ceil(unlabeled.length / BATCH_SIZE);
+    let totalEdited = 0;
+    let hadError = false;
+
+    for (let i = 0; i < unlabeled.length; i += BATCH_SIZE) {
+        const batchPaths = unlabeled.slice(i, i + BATCH_SIZE);
+        const batchNumber = Math.floor(i / BATCH_SIZE) + 1;
+
+        try {
+            // Read file contents for the batch
+            const files: { path: string; content: string }[] = [];
+            for (const filePath of batchPaths) {
+                try {
+                    const content = fs.readFileSync(filePath, 'utf-8');
+                    files.push({ path: filePath, content });
+                } catch (error) {
+                    console.error(`[EmailLabeling] Error reading ${filePath}:`, error);
+                }
+            }
+
+            if (files.length === 0) {
+                continue;
+            }
+
+            console.log(`[EmailLabeling] Processing batch ${batchNumber}/${totalBatches} (${files.length} files)`);
+            await serviceLogger.log({
+                type: 'progress',
+                service: run.service,
+                runId: run.runId,
+                level: 'info',
+                message: `Processing batch ${batchNumber}/${totalBatches} (${files.length} files)`,
+                step: 'batch',
+                current: batchNumber,
+                total: totalBatches,
+                details: { filesInBatch: files.length },
+            });
+
+            const result = await labelEmailBatch(files);
+            totalEdited += result.filesEdited.size;
+
+            // Only mark files that were actually edited by the agent
+            for (const file of files) {
+                const relativePath = path.relative(WorkDir, file.path);
+                if (result.filesEdited.has(relativePath)) {
+                    markFileAsLabeled(file.path, state);
+                }
+            }
+
+            saveLabelingState(state);
+            console.log(`[EmailLabeling] Batch ${batchNumber}/${totalBatches} complete, ${result.filesEdited.size} files edited`);
+        } catch (error) {
+            hadError = true;
+            console.error(`[EmailLabeling] Error processing batch ${batchNumber}:`, error);
+            await serviceLogger.log({
+                type: 'error',
+                service: run.service,
+                runId: run.runId,
+                level: 'error',
+                message: `Error processing batch ${batchNumber}`,
+                error: error instanceof Error ? error.message : String(error),
+                context: { batchNumber },
+            });
+        }
+    }
+
+    state.lastRunTime = new Date().toISOString();
+    saveLabelingState(state);
+
+    await serviceLogger.log({
+        type: 'run_complete',
+        service: run.service,
+        runId: run.runId,
+        level: hadError ? 'error' : 'info',
+        message: `Email labeling complete: ${totalEdited} files labeled`,
+        durationMs: Date.now() - run.startedAt,
+        outcome: hadError ? 'error' : 'ok',
+        summary: {
+            totalEmails: unlabeled.length,
+            filesLabeled: totalEdited,
+        },
+    });
+
+    console.log(`[EmailLabeling] Done. ${totalEdited} emails labeled.`);
+}
+
+/**
+ * Main entry point - runs as independent polling service
+ */
+export async function init() {
+    console.log('[EmailLabeling] Starting Email Labeling Service...');
+    console.log(`[EmailLabeling] Will check for unlabeled emails every ${SYNC_INTERVAL_MS / 1000} seconds`);
+
+    // Initial run
+    await processUnlabeledEmails();
+
+    // Periodic polling
+    while (true) {
+        await new Promise(resolve => setTimeout(resolve, SYNC_INTERVAL_MS));
+
+        try {
+            await processUnlabeledEmails();
+        } catch (error) {
+            console.error('[EmailLabeling] Error in main loop:', error);
+        }
+    }
+}

apps/x/packages/core/src/knowledge/labeling_agent.ts

@@ -0,0 +1,59 @@
+import { renderTagSystemForEmails } from './tag_system.js';
+
+export function getRaw(): string {
+  return `---
+model: gpt-5.2
+tools:
+  workspace-readFile:
+    type: builtin
+    name: workspace-readFile
+  workspace-edit:
+    type: builtin
+    name: workspace-edit
+  workspace-readdir:
+    type: builtin
+    name: workspace-readdir
+---
+# Task
+
+You are an email labeling agent. Given a batch of email files, you will classify each email and prepend YAML frontmatter with structured labels.
+
+${renderTagSystemForEmails()}
+
+# Instructions
+
+1. For each email file provided in the message, read its content carefully.
+2. Classify the email using the taxonomy above. Be accurate and conservative — only apply labels that clearly fit.
+3. Use \`workspace-edit\` to prepend YAML frontmatter to the file. The oldString should be the first line of the file (the \`# Subject\` heading), and the newString should be the frontmatter followed by that same first line.
+4. Always include \`processed: true\` and \`labeled_at\` with the current ISO timestamp.
+5. If the email already has frontmatter (starts with \`---\`), skip it.
+
+# Frontmatter Format
+
+\`\`\`yaml
+---
+labels:
+  relationship:
+    - Investor
+  topics:
+    - Fundraising
+    - Finance
+  type: Intro
+  filter:
+    - Promotion
+  action: FYI
+processed: true
+labeled_at: "2026-02-28T12:00:00Z"
+---
+\`\`\`
+
+# Rules
+
+- Every label category must be present in the frontmatter, even if empty (use \`[]\` for empty arrays).
+- \`type\` and \`action\` are single values (strings), not arrays.
+- \`relationship\`, \`topics\`, and \`filter\` are arrays.
+- Use the exact label values from the taxonomy — do not invent new ones.
+- The \`labeled_at\` timestamp should be the current time in ISO 8601 format.
+- Process all files in the batch. Do not skip any unless they already have frontmatter.
+`;
+}

apps/x/packages/core/src/knowledge/labeling_state.ts

@@ -0,0 +1,48 @@
+import fs from 'fs';
+import path from 'path';
+import { WorkDir } from '../config/config.js';
+
+const STATE_FILE = path.join(WorkDir, 'labeling_state.json');
+
+export interface LabelingState {
+    processedFiles: Record<string, { labeledAt: string }>;
+    lastRunTime: string;
+}
+
+export function loadLabelingState(): LabelingState {
+    if (fs.existsSync(STATE_FILE)) {
+        try {
+            return JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8'));
+        } catch (error) {
+            console.error('Error loading labeling state:', error);
+        }
+    }
+
+    return {
+        processedFiles: {},
+        lastRunTime: new Date(0).toISOString(),
+    };
+}
+
+export function saveLabelingState(state: LabelingState): void {
+    try {
+        fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+    } catch (error) {
+        console.error('Error saving labeling state:', error);
+        throw error;
+    }
+}
+
+export function markFileAsLabeled(filePath: string, state: LabelingState): void {
+    state.processedFiles[filePath] = {
+        labeledAt: new Date().toISOString(),
+    };
+}
+
+export function resetLabelingState(): void {
+    const emptyState: LabelingState = {
+        processedFiles: {},
+        lastRunTime: new Date().toISOString(),
+    };
+    saveLabelingState(emptyState);
+}

apps/x/packages/core/src/knowledge/note_creation.ts

@@ -1,4 +1,8 @@
-export const raw = `---
+import { renderNoteTypesBlock } from './note_system.js';
+import { renderNoteEffectRules } from './tag_system.js';
+
+export function getRaw(): string {
+  return `---
 model: gpt-5.2
 tools:
   workspace-writeFile:
@@ -23,6 +27,15 @@ tools:
     type: builtin
     name: workspace-glob
 ---
+# Context
+
+**Current date and time:** ${new Date().toISOString()}
+
+Sources (emails, meetings, voice memos) are processed in roughly chronological order. This means:
+- Earlier sources may reference events that have since occurred — later sources will provide updates.
+- If a source mentions a future meeting or deadline, it may already be in the past by now. Use the current date above to reason about what is past vs. upcoming.
+- Don't treat old commitments as still "open" if later sources or the current date suggest they've likely been resolved.
+
 # Task
 
 You are a memory agent. Given a single source file (email, meeting transcript, or voice memo), you will:
@@ -130,25 +143,15 @@ Either:
 
 ---
 
-# The Core Rule: Medium Strictness
+# The Core Rule: Label-Based Filtering
 
-**MEDIUM STRICTNESS MODE**
+**Emails now have YAML frontmatter with labels.** Use these labels to decide whether to process or skip.
 
-**Meetings create notes because:**
-- You chose to spend time with these people
-- If you met them, they matter enough to track
-- Meeting transcripts have rich context
+**Meetings and voice memos always create notes** — no label check needed.
 
-**Emails can create notes if:**
-- The email contains personalized content (not mass mail)
-- The sender seems relevant to your work (business context, not consumer services)
-- The email is part of a meaningful exchange (not one-off transactional)
+**For emails, read the YAML frontmatter labels and apply these rules:**
 
-**Skip creating notes for:**
-- Mass emails and newsletters
-- Automated/transactional emails
-- Consumer service providers (utilities, subscriptions, etc.)
-- Cold sales outreach with no prior relationship indication
+${renderNoteEffectRules()}
 
 ---
 
@@ -163,6 +166,7 @@ workspace-readFile({ path: "{source_file}" })
 - Has \`Attendees:\` field
 - Has \`Meeting:\` title
 - Transcript format with speaker labels
+- Source file path is under \`knowledge/Meetings/\` (e.g. \`knowledge/Meetings/granola/...\` or \`knowledge/Meetings/fireflies/...\`)
 
 **Email indicators:**
 - Has \`From:\` and \`To:\` fields
@@ -170,8 +174,8 @@ workspace-readFile({ path: "{source_file}" })
 - Email signature
 
 **Voice memo indicators:**
-- Has \`**Type:** voice memo\` field
-- Has \`**Path:**\` field with path like \`Voice Memos/YYYY-MM-DD/...\`
+- Has YAML frontmatter with \`type: voice memo\`
+- Has frontmatter \`path:\` field like \`Voice Memos/YYYY-MM-DD/...\`
 - Has \`## Transcript\` section
 
 **Set processing mode:**
@@ -217,168 +221,40 @@ Emails containing calendar invites (\`.ics\` attachments or inline calendar data
 
 ---
 
-# Step 1: Source Filtering
+# Step 1: Source Filtering (Label-Based)
 
-## Skip These Sources (Both Meetings and Emails)
+## For Meetings and Voice Memos
+Always process — no filtering needed.
 
-### Mass Emails and Newsletters
+## For Emails — Read YAML Frontmatter
 
-**Indicators:**
-- Sent to a list (To: contains multiple addresses, or undisclosed-recipients)
-- Unsubscribe link in body or footer
-- From a no-reply or marketing address (noreply@, newsletter@, marketing@, hello@)
-- Generic greeting ("Hi there", "Dear subscriber", "Hello!")
-- Promotional language ("Don't miss out", "Limited time", "% off")
-- Mailing list headers (List-Unsubscribe, Mailing-List)
-- Sent via marketing platforms (via sendgrid, via mailchimp, etc.)
+Emails have YAML frontmatter with labels prepended by the labeling agent:
 
-**Action:** SKIP with reason "Newsletter/mass email"
+\`\`\`yaml
+---
+labels:
+  relationship:
+    - Investor
+  topics:
+    - Fundraising
+  type: Intro
+  filter: []
+  action: FYI
+processed: true
+labeled_at: "2026-02-28T12:00:00Z"
+---
+\`\`\`
 
-### Product Updates & Changelogs
+## Decision Rules
 
-**Indicators:**
-- Subject contains: "changelog", "what's new", "product update", "release notes", "v1.x", "new features"
-- Content describes feature releases, bug fixes, or product changes
-- Sent to all users/customers (not personalized to you specifically)
-- From tools/SaaS you use: Cal.com, Notion, Slack, Linear, Figma, etc.
-- No action required from you — purely informational
-- Written in announcement style, not conversational
-
-**Examples to SKIP:**
-- "Cal.com Changelog v6.1" — product update
-- "What's new in Notion - January 2026" — feature announcement
-- "Introducing new Slack features" — product marketing
-- "Linear Release Notes" — changelog
-
-**Action:** SKIP with reason "Product update/changelog"
-
-### Cold Outreach / Sales Emails
-
-**THE RULE: If someone emails you offering services and you never responded, SKIP.**
-
-It doesn't matter how personalized, detailed, or relevant the pitch seems. If:
-1. They initiated contact (you didn't reach out first)
-2. They're offering services/products
-3. You never replied or engaged
-
-Then it's cold outreach and should be SKIPPED. Do NOT create notes for cold outreach senders or their organizations.
-
-**EXCEPTION:** If they reference a prior real-world interaction, CREATE a note:
-- "Great meeting you at [conference/event]"
-- "Following up on our conversation at..."
-- "It was nice chatting at [place]"
-- "[Mutual contact] suggested I reach out after we met"
-
-This indicates a real relationship that started offline, not cold outreach.
-
-**Indicators:**
-- Unsolicited contact from someone you've never interacted with
-- Offering services you didn't request (HR, payroll, compliance, bookkeeping, recruiting, dev shops, marketing, etc.)
-- Sales-y language: "wanted to reach out", "thought this might help", "quick question about your..."
-- Mentions your company growth/funding/hiring/tech stack as a hook
-- Attaches "free guides", "case studies", "resources", or "frameworks"
-- Asks for a call/meeting without any prior relationship
-- From domains you've never contacted or met with before
-- No existing note for this person or organization
-- **No reply from the user in the email thread**
-
-**Examples to SKIP:**
-- "Saw you raised funding, wanted to reach out about our services"
-- "Quick question about your bookkeeping/compliance/hiring"
-- "Shared this guide that might help with [your problem]"
-- "Noticed you're scaling, we help startups with..."
-- "Would love 15 minutes to show you how we can help"
-- Detailed pitch about HR/payroll/India expansion services (still cold outreach!)
-- Follow-up emails to previous cold outreach that got no response
-
-**Key distinction:**
-- **You reaching out to a vendor** → worth tracking (you initiated)
-- **You replied to their outreach** → worth tracking (you engaged)
-- **Vendor cold emailing you with no response** → SKIP (no relationship exists)
-
-**IMPORTANT: CC'd people on cold outreach**
-When an email is identified as cold outreach, skip notes for ALL parties involved:
-- The sender (the person doing the outreach)
-- Anyone CC'd on the email (colleagues of the sender, other contacts they're trying to connect)
-- The organization they represent
-
-If someone only appears in your memory as "CC'd on outreach emails from [Sender]", they don't warrant a note — they're just incidentally included in cold outreach, not a real relationship.
-
-**Action:** SKIP with reason "Cold outreach/sales email - no engagement from user"
-
-### Automated/Transactional
-
-**Indicators:**
-- From automated systems (notifications@, alerts@, no-reply@)
-- Password resets, login alerts, shipping notifications
-- Calendar invites without substance
-- Receipts and invoices (unless from key vendor/customer)
-- GitHub/Jira/Slack notifications
-
-**Action:** SKIP with reason "Automated/transactional"
-
-### Low-Signal
-
-**Indicators:**
-- Very short with no substance ("Thanks!", "Sounds good", "Got it")
-- Only contains forwarded message with no commentary
-- Auto-replies ("I'm out of office")
-
-**Action:** SKIP with reason "Low signal"
-
-### Consumer Services (Medium strictness specific)
-
-**Indicators:**
-- From consumer service companies (utilities, streaming, retail)
-- Account management emails
-- Subscription confirmations
-- Delivery notifications
-
-**Action:** SKIP with reason "Consumer service"
-
-### Infrastructure & SaaS Providers
-
-**Skip emails from these types of services:**
-- Domain registrars: GoDaddy, Namecheap, Google Domains, Cloudflare
-- Hosting providers: AWS, Google Cloud, Azure, DigitalOcean, Heroku, Vercel, Netlify
-- Email providers: Google Workspace, Microsoft 365, Zoho
-- Payment processors: Stripe, PayPal, Square, Razorpay
-- Developer tools: GitHub, GitLab, Bitbucket, npm, Docker Hub
-- Analytics: Google Analytics, Mixpanel, Amplitude, Segment
-- Auth providers: Auth0, Okta, Firebase Auth
-- Support platforms: Zendesk, Intercom, Freshdesk
-- HR/Payroll: Gusto, Rippling, Deel, Remote
-
-**Indicators:**
-- Automated system notifications (renewal reminders, usage alerts, security notices)
-- No personalized content from a human
-- From domains like @godaddy.com, @aws.amazon.com, @stripe.com, etc.
-- Templates about account status, billing, or technical alerts
-
-**Action:** SKIP with reason "Infrastructure/SaaS provider notification"
-
-## Email-Specific Processing (Medium Strictness)
-
-For emails, evaluate if the content is personalized and business-relevant:
-
-**Create note if:**
-- The email is personally addressed and substantive
-- The sender appears to be from a business/organization relevant to your work
-- The content discusses work, projects, opportunities, or professional topics
-- It's a warm intro from anyone (not just existing contacts)
-- It's a thoughtful cold outreach that's specific to your work
-
-**Do not create note if:**
-- Clearly mass/templated email
-- Consumer service interaction
-- Generic sales pitch with no personalization
+${renderNoteEffectRules()}
 
 ## Filter Decision Output
 
 If skipping:
 \`\`\`
 SKIP
-Reason: {reason}
+Reason: Labels indicate skip-only categories: {list the labels}
 \`\`\`
 
 If processing, continue to Step 2.
@@ -552,16 +428,16 @@ Resolution Map:
 - "the integration" → "Acme Integration" (same project)
 \`\`\`
 
-## 4b: Apply Source Type Rules (Medium Strictness)
+## 4b: Apply Source Type Rules
 
-**If source_type == "meeting":**
+**If source_type == "meeting" or "voice_memo":**
 - Resolved entities → Update existing notes
 - New entities that pass filters → Create new notes
 
-**If source_type == "email" (MEDIUM STRICTNESS):**
+**If source_type == "email":**
+- The email already passed label-based filtering in Step 1
 - Resolved entities → Update existing notes
-- New entities → Create notes IF the email is personalized and business-relevant
-- New entities from cold sales pitches without personalization → Skip
+- New entities → Create notes (the labels already confirmed this email is worth processing)
 
 ## 4c: Disambiguation Rules
 
@@ -628,39 +504,23 @@ For entities not resolved to existing notes, determine if they warrant new notes
 
 ## People
 
-### Who Gets a Note (Medium Strictness)
+### Who Gets a Note
 
 **CREATE a note for people who are:**
 - External (not @user.domain)
 - Attendees in meetings
-- Email correspondents sending personalized, business-relevant content
+- Email correspondents (emails that reach this step already passed label-based filtering)
 - Decision makers or contacts at customers, prospects, or partners
 - Investors or potential investors
 - Candidates you are interviewing
 - Advisors or mentors
 - Key collaborators
 - Introducers who connect you to valuable contacts
-- Anyone reaching out with a specific, relevant opportunity
 
 **DO NOT create notes for:**
-- Transactional service providers (bank employees, support reps)
-- One-time administrative contacts
 - Large group meeting attendees you didn't interact with
 - Internal colleagues (@user.domain)
 - Assistants handling only logistics
-- Generic role-based contacts
-- Consumer service representatives
-- Generic cold sales outreach with no personalization
-
-### The Relevance Test (Medium Strictness)
-
-Ask: Is this person relevant to my professional work or goals?
-
-- Sarah Chen, VP Engineering evaluating your product → **Yes, create note**
-- James from HSBC who set up your account → **No, skip**
-- Investor reaching out about your company → **Yes, create note**
-- Cold recruiter with a generic pitch → **No, skip**
-- Someone reaching out about a specific opportunity → **Yes, create note**
 
 ### Role Inference
 
@@ -830,6 +690,16 @@ One line summarizing this source's relevance to the entity:
 **{YYYY-MM-DD}** ({meeting|email|voice memo}): {Summary with [[links]]}
 \`\`\`
 
+**For meetings:** Include a link to the source meeting note. Derive the wiki-link path from the source file path (strip the \`.md\` extension):
+\`\`\`
+**2025-01-15** (meeting): Discussed [[Projects/Acme Integration]] timeline with [[People/David Kim]]. See [[Meetings/granola/abc123_Weekly Sync]]
+\`\`\`
+
+**For emails:** Include a Gmail web link to the thread. Extract the thread ID from the \`**Thread ID:**\` field in the email source file, then construct the URL as \`https://mail.google.com/mail/#inbox/{threadId}\`:
+\`\`\`
+**2025-01-15** (email): [[People/Sarah Chen]] sent pricing proposal for [[Projects/Acme Integration]]. [View thread](https://mail.google.com/mail/#inbox/18d5a3b2c1e4f567)
+\`\`\`
+
 **For voice memos:** Include a link to the voice memo file using the Path field:
 \`\`\`
 **2025-01-15** (voice memo): Discussed [[Projects/Acme Integration]] timeline. See [[Voice Memos/2025-01-15/voice-memo-2025-01-15T10-30-00-000Z]]
@@ -837,11 +707,13 @@ One line summarizing this source's relevance to the entity:
 
 **Important:** Use canonical names with absolute paths from resolution map in all summaries:
 \`\`\`
-# Correct (uses absolute paths):
-**2025-01-15** (meeting): [[People/Sarah Chen]] confirmed timeline with [[People/David Kim]]. Blocked on [[Topics/Security Compliance]].
+# Correct (uses absolute paths and source links):
+**2025-01-15** (meeting): [[People/Sarah Chen]] confirmed timeline with [[People/David Kim]]. Blocked on [[Topics/Security Compliance]]. See [[Meetings/fireflies/abc_Team Sync]]
+**2025-01-15** (email): [[People/Sarah Chen]] shared the contract draft. [View thread](https://mail.google.com/mail/#inbox/18d5a3b2c1e4f567)
 
-# Incorrect (uses variants or relative links):
+# Incorrect (uses variants or relative links, missing source links):
 **2025-01-15** (meeting): Sarah confirmed timeline with David. Blocked on SOC 2.
+**2025-01-15** (email): Sarah shared the contract draft.
 \`\`\`
 
 ---
@@ -1025,153 +897,28 @@ After writing, verify links go both ways.
 
 ---
 
-# Note Templates
-
-## People
-\`\`\`markdown
-# {Full Name}
-
-## Info
-**Role:** {role, or inferred role with qualifier, or leave blank if truly unknown}
-**Organization:** [[Organizations/{organization}]] or leave blank
-**Email:** {email or leave blank}
-**Aliases:** {comma-separated: first name, nicknames, email}
-**First met:** {YYYY-MM-DD}
-**Last seen:** {YYYY-MM-DD}
-
-## Summary
-{2-3 sentences: Who they are, why you know them, what you're working on together.}
-
-## Connected to
-- [[Organizations/{Organization}]] — works at
-- [[People/{Person}]] — {colleague, introduced by, reports to}
-- [[Projects/{Project}]] — {role}
-
-## Activity
-- **{YYYY-MM-DD}** ({meeting|email|voice memo}): {Summary with [[Folder/Name]] links}
-
-## Key facts
-{Substantive facts only. Leave empty if none.}
-
-## Open items
-{Commitments and next steps only. Leave empty if none.}
-\`\`\`
-
-## Organizations
-\`\`\`markdown
-# {Organization Name}
-
-## Info
-**Type:** {company|team|institution|other}
-**Industry:** {industry or leave blank}
-**Relationship:** {customer|prospect|partner|competitor|vendor|other}
-**Domain:** {primary email domain}
-**Aliases:** {comma-separated: short names, abbreviations}
-**First met:** {YYYY-MM-DD}
-**Last seen:** {YYYY-MM-DD}
-
-## Summary
-{2-3 sentences: What this org is, what your relationship is.}
-
-## People
-- [[People/{Person}]] — {role}
-
-## Contacts
-{For transactional contacts who don't get their own notes}
-
-## Projects
-- [[Projects/{Project}]] — {relationship}
-
-## Activity
-- **{YYYY-MM-DD}** ({meeting|email|voice memo}): {Summary with [[Folder/Name]] links}
-
-## Key facts
-{Substantive facts only. Leave empty if none.}
-
-## Open items
-{Commitments and next steps only. Leave empty if none.}
-\`\`\`
-
-## Projects
-\`\`\`markdown
-# {Project Name}
-
-## Info
-**Type:** {deal|product|initiative|hiring|other}
-**Status:** {active|planning|on hold|completed|cancelled}
-**Started:** {YYYY-MM-DD or leave blank}
-**Last activity:** {YYYY-MM-DD}
-
-## Summary
-{2-3 sentences: What this project is, goal, current state.}
-
-## People
-- [[People/{Person}]] — {role}
-
-## Organizations
-- [[Organizations/{Org}]] — {customer|partner|etc.}
-
-## Related
-- [[Topics/{Topic}]] — {relationship}
-- [[Projects/{Project}]] — {relationship}
-
-## Timeline
-**{YYYY-MM-DD}** ({meeting|email})
-{What happened.}
-
-## Decisions
-- **{YYYY-MM-DD}**: {Decision}. {Rationale}.
-
-## Open items
-{Commitments and next steps only. Leave empty if none.}
-
-## Key facts
-{Substantive facts only. Leave empty if none.}
-\`\`\`
-
-## Topics
-\`\`\`markdown
-# {Topic Name}
-
-## About
-{1-2 sentences: What this topic covers.}
-
-**Keywords:** {comma-separated}
-**Aliases:** {other ways this topic is referenced}
-**First mentioned:** {YYYY-MM-DD}
-**Last mentioned:** {YYYY-MM-DD}
-
-## Related
-- [[People/{Person}]] — {relationship}
-- [[Organizations/{Org}]] — {relationship}
-- [[Projects/{Project}]] — {relationship}
-
-## Log
-**{YYYY-MM-DD}** ({meeting|email}: {title})
-{Summary with [[Folder/Name]] links}
-
-## Decisions
-- **{YYYY-MM-DD}**: {Decision}
-
-## Open items
-{Commitments and next steps only. Leave empty if none.}
-
-## Key facts
-{Substantive facts only. Leave empty if none.}
-\`\`\`
+${renderNoteTypesBlock()}
 
 ---
 
-# Summary: Medium Strictness Rules
+# Summary: Label-Based Rules
 
 | Source Type | Creates Notes? | Updates Notes? | Detects State Changes? |
 |-------------|---------------|----------------|------------------------|
 | Meeting | Yes | Yes | Yes |
 | Voice memo | Yes | Yes | Yes |
-| Email (personalized, business-relevant) | Yes | Yes | Yes |
-| Email (mass/automated/consumer) | No (SKIP) | No | No |
-| Email (cold outreach with personalization) | Yes | Yes | Yes |
-| Email (generic cold outreach) | No | No | No |
+| Email (has create label) | Yes | Yes | Yes |
+| Email (only skip labels) | No (SKIP) | No | No |
+
+**Meeting activity format:** Always include a link to the source meeting note:
+\`\`\`
+**2025-01-15** (meeting): Discussed project timeline with [[People/Sarah Chen]]. See [[Meetings/granola/abc123_Weekly Sync]]
+\`\`\`
+
+**Email activity format:** Always include a Gmail web link using the Thread ID from the source:
+\`\`\`
+**2025-01-15** (email): [[People/Sarah Chen]] sent pricing proposal. [View thread](https://mail.google.com/mail/#inbox/18d5a3b2c1e4f567)
+\`\`\`
 
 **Voice memo activity format:** Always include a link to the source voice memo:
 \`\`\`
@@ -1198,7 +945,7 @@ Before completing, verify:
 
 **Source Type:**
 - [ ] Correctly identified as meeting or email
-- [ ] Applied correct medium strictness rules
+- [ ] Applied label-based filtering rules correctly
 
 **Resolution:**
 - [ ] Extracted all name variants from source
@@ -1233,4 +980,5 @@ Before completing, verify:
 - [ ] Dates are YYYY-MM-DD
 - [ ] Bidirectional links are consistent
 - [ ] New notes in correct folders
-`;
+`;
+}

apps/x/packages/core/src/knowledge/note_creation_low.ts

@@ -1,874 +0,0 @@
-export const raw = `---
-model: gpt-5.2
-tools:
-  workspace-writeFile:
-    type: builtin
-    name: workspace-writeFile
-  workspace-readFile:
-    type: builtin
-    name: workspace-readFile
-  workspace-edit:
-    type: builtin
-    name: workspace-edit
-  workspace-readdir:
-    type: builtin
-    name: workspace-readdir
-  workspace-mkdir:
-    type: builtin
-    name: workspace-mkdir
-  workspace-grep:
-    type: builtin
-    name: workspace-grep
-  workspace-glob:
-    type: builtin
-    name: workspace-glob
----
-# Task
-
-You are a memory agent. Given a single source file (email, meeting transcript, or voice memo), you will:
-
-1. **Determine source type (meeting or email)**
-2. **Evaluate if the source is worth processing**
-3. **Search for all existing related notes**
-4. **Resolve entities to canonical names**
-5. Identify new entities worth tracking
-6. Extract structured information (decisions, commitments, key facts)
-7. **Detect state changes (status updates, resolved items, role changes)**
-8. Create new notes or update existing notes
-9. **Apply state changes to existing notes**
-
-The core rule: **Capture broadly. Meetings, voice memos, and emails create notes for most external contacts.**
-
-You have full read access to the existing knowledge directory. Use this extensively to:
-- Find existing notes for people, organizations, projects mentioned
-- Resolve ambiguous names (find existing note for "David")
-- Understand existing relationships before updating
-- Avoid creating duplicate notes
-- Maintain consistency with existing content
-- **Detect when new information changes the state of existing notes**
-
-# Inputs
-
-1. **source_file**: Path to a single file to process (email or meeting transcript)
-2. **knowledge_folder**: Path to Obsidian vault (read/write access)
-3. **user**: Information about the owner of this memory
-   - name: e.g., "Arj"
-   - email: e.g., "arj@rowboat.com"
-   - domain: e.g., "rowboat.com"
-4. **knowledge_index**: A pre-built index of all existing notes (provided in the message)
-
-# Knowledge Base Index
-
-**IMPORTANT:** You will receive a pre-built index of all existing notes at the start of each request. This index contains:
-- All people notes with their names, emails, aliases, and organizations
-- All organization notes with their names, domains, and aliases
-- All project notes with their names and statuses
-- All topic notes with their names and keywords
-
-**USE THE INDEX for entity resolution instead of grep/search commands.** This is much faster.
-
-When you need to:
-- Check if a person exists → Look up by name/email/alias in the index
-- Find an organization → Look up by name/domain in the index
-- Resolve "David" to a full name → Check index for people with that name/alias + organization context
-
-**Only use \`cat\` to read full note content** when you need details not in the index (e.g., existing activity logs, open items).
-
-# Tools Available
-
-You have access to these tools:
-
-**For reading files:**
-\`\`\`
-workspace-readFile({ path: "knowledge/People/Sarah Chen.md" })
-\`\`\`
-
-**For creating NEW files:**
-\`\`\`
-workspace-writeFile({ path: "knowledge/People/Sarah Chen.md", data: "# Sarah Chen\\n\\n..." })
-\`\`\`
-
-**For editing EXISTING files (preferred for updates):**
-\`\`\`
-workspace-edit({
-  path: "knowledge/People/Sarah Chen.md",
-  oldString: "## Activity\\n",
-  newString: "## Activity\\n- **2026-02-03** (meeting): New activity entry\\n"
-})
-\`\`\`
-
-**For listing directories:**
-\`\`\`
-workspace-readdir({ path: "knowledge/People" })
-\`\`\`
-
-**For creating directories:**
-\`\`\`
-workspace-mkdir({ path: "knowledge/Projects", recursive: true })
-\`\`\`
-
-**For searching files:**
-\`\`\`
-workspace-grep({ pattern: "Acme Corp", searchPath: "knowledge", fileGlob: "*.md" })
-\`\`\`
-
-**For finding files by pattern:**
-\`\`\`
-workspace-glob({ pattern: "**/*.md", cwd: "knowledge/People" })
-\`\`\`
-
-**IMPORTANT:**
-- Use \`workspace-edit\` for updating existing notes (adding activity, updating fields)
-- Use \`workspace-writeFile\` only for creating new notes
-- Prefer the knowledge_index for entity resolution (it's faster than grep)
-
-# Output
-
-Either:
-- **SKIP** with reason, if source should be ignored
-- Updated or new markdown files in notes_folder
-
----
-
-# The Core Rule: Low Strictness - Capture Broadly
-
-**LOW STRICTNESS MODE**
-
-This mode prioritizes comprehensive capture over selectivity. The goal is to never miss a potentially important contact.
-
-**Meetings create notes for:**
-- All external attendees (anyone not @user.domain)
-
-**Emails create notes for:**
-- Any personalized email from an identifiable sender
-- Anyone who reaches out directly
-- Any external contact who communicates with you
-
-**Only skip:**
-- Obvious automated/system emails (no human sender)
-- Mass newsletters with unsubscribe links
-- Truly anonymous or unidentifiable senders
-
-**Philosophy:** It's better to have a note you don't need than to miss tracking someone important.
-
----
-
-# Step 0: Determine Source Type
-
-Read the source file and determine if it's a meeting or email.
-\`\`\`
-workspace-readFile({ path: "{source_file}" })
-\`\`\`
-
-**Meeting indicators:**
-- Has \`Attendees:\` field
-- Has \`Meeting:\` title
-- Transcript format with speaker labels
-
-**Email indicators:**
-- Has \`From:\` and \`To:\` fields
-- Has \`Subject:\` field
-- Email signature
-
-**Voice memo indicators:**
-- Has \`**Type:** voice memo\` field
-- Has \`**Path:**\` field with path like \`Voice Memos/YYYY-MM-DD/...\`
-- Has \`## Transcript\` section
-
-**Set processing mode:**
-- \`source_type = "meeting"\` → Create notes for all external attendees
-- \`source_type = "email"\` → Create notes for sender if identifiable human
-- \`source_type = "voice_memo"\` → Create notes for all mentioned entities (treat like meetings)
-
----
-
-## Calendar Invite Emails
-
-Emails containing calendar invites (\`.ics\` attachments) are **high signal** - a scheduled meeting means this person matters.
-
-**How to identify:**
-- Subject contains "Invitation:", "Accepted:", "Declined:", or "Updated:"
-- Has \`.ics\` attachment reference
-
-**Rules:**
-1. **CREATE a note for the primary contact** - the person you're meeting with
-2. **Skip automated notifications** - from calendar-no-reply@google.com with no human sender
-3. **Skip "Accepted/Declined" responses** - just RSVP confirmations
-
-Once a note exists, subsequent emails will enrich it. When the meeting happens, the transcript adds more detail.
-
----
-
-# Step 1: Source Filtering (Minimal)
-
-## Skip Only These Sources
-
-### Mass Newsletters
-
-**Indicators (must have MULTIPLE of these):**
-- Unsubscribe link in body or footer
-- From a marketing address (noreply@, newsletter@, marketing@)
-- Sent to multiple recipients or undisclosed-recipients
-- Sent via marketing platforms (via sendgrid, via mailchimp, etc.)
-
-**Action:** SKIP with reason "Mass newsletter"
-
-### Purely Automated (No Human Sender)
-
-**Indicators:**
-- From automated systems with no human behind them (alerts@, notifications@)
-- Password resets, login alerts
-- System notifications (GitHub automated, CI/CD alerts)
-- Receipt confirmations with no human contact info
-
-**Action:** SKIP with reason "Automated system message"
-
-### Truly Low-Signal
-
-**Indicators (must be clearly content-free):**
-- Body is ONLY "Thanks!", "Got it", "OK" with nothing else
-- Auto-replies ("I'm out of office") with no human context
-
-**Action:** SKIP with reason "No substantive content"
-
-## Process Everything Else
-
-**Important:** When in doubt, PROCESS. In low strictness mode, we err on the side of capturing more.
-
-If skipping:
-\`\`\`
-SKIP
-Reason: {reason}
-\`\`\`
-
-If processing, continue to Step 2.
-
----
-
-# Step 2: Read and Parse Source File
-\`\`\`
-workspace-readFile({ path: "{source_file}" })
-\`\`\`
-
-Extract metadata:
-
-**For meetings:**
-- **Date:** From header or filename
-- **Title:** Meeting name
-- **Attendees:** List of participants
-- **Duration:** If available
-
-**For emails:**
-- **Date:** From \`Date:\` header
-- **Subject:** From \`Subject:\` header
-- **From:** Sender email/name
-- **To/Cc:** Recipients
-
-## 2a: Exclude Self
-
-Never create or update notes for:
-- The user (matches user.name, user.email, or @user.domain)
-- Anyone @{user.domain} (colleagues at user's company)
-
-Filter these out from attendees/participants before proceeding.
-
-## 2b: Extract All Name Variants
-
-From the source, collect every way entities are referenced:
-
-**People variants:**
-- Full names: "Sarah Chen"
-- First names only: "Sarah"
-- Last names only: "Chen"
-- Initials: "S. Chen"
-- Email addresses: "sarah@acme.com"
-- Roles/titles: "their CTO", "the VP of Engineering"
-
-**Organization variants:**
-- Full names: "Acme Corporation"
-- Short names: "Acme"
-- Abbreviations: "AC"
-- Email domains: "@acme.com"
-
-**Project variants:**
-- Explicit names: "Project Atlas"
-- Descriptive references: "the integration", "the pilot", "the deal"
-
-Create a list of all variants found.
-
----
-
-# Step 3: Look Up Existing Notes in Index
-
-**Use the provided knowledge_index to find existing notes. Do NOT use grep commands.**
-
-## 3a: Look Up People
-
-For each person variant (name, email, alias), check the index:
-
-\`\`\`
-From index, find matches for:
-- "Sarah Chen" → Check People table for matching name
-- "Sarah" → Check People table for matching name or alias
-- "sarah@acme.com" → Check People table for matching email
-- "@acme.com" → Check People table for matching organization or check Organizations for domain
-\`\`\`
-
-## 3b: Look Up Organizations
-
-\`\`\`
-From index, find matches for:
-- "Acme Corp" → Check Organizations table for matching name
-- "Acme" → Check Organizations table for matching name or alias
-- "acme.com" → Check Organizations table for matching domain
-\`\`\`
-
-## 3c: Look Up Projects and Topics
-
-\`\`\`
-From index, find matches for:
-- "the pilot" → Check Projects table for related names
-- "SOC 2" → Check Topics table for matching keywords
-\`\`\`
-
-## 3d: Read Full Notes When Needed
-
-Only read the full note content when you need details not in the index (e.g., activity logs, open items):
-\`\`\`
-workspace-readFile({ path: "{knowledge_folder}/People/Sarah Chen.md" })
-\`\`\`
-
-**Why read these notes:**
-- Find canonical names (David → David Kim)
-- Check Aliases fields for known variants
-- Understand existing relationships
-- See organization context for disambiguation
-- Check what's already captured (avoid duplicates)
-- Review open items (some might be resolved)
-- **Check current status fields (might need updating)**
-- **Check current roles (might have changed)**
-
-## 3e: Matching Criteria
-
-Use these criteria to determine if a variant matches an existing note:
-
-**People matching:**
-
-| Source has | Note has | Match if |
-|------------|----------|----------|
-| First name "Sarah" | Full name "Sarah Chen" | Same organization context |
-| Email "sarah@acme.com" | Email field | Exact match |
-| Email domain "@acme.com" | Organization "Acme Corp" | Domain matches org |
-| Role "VP Engineering" | Role field | Same org + same role |
-| First name + company context | Full name + Organization | Company matches |
-| Any variant | Aliases field | Listed in aliases |
-
-**Organization matching:**
-
-| Source has | Note has | Match if |
-|------------|----------|----------|
-| "Acme" | "Acme Corp" | Substring match |
-| "Acme Corporation" | "Acme Corp" | Same root name |
-| "@acme.com" | Domain field | Domain matches |
-| Any variant | Aliases field | Listed in aliases |
-
-**Project matching:**
-
-| Source has | Note has | Match if |
-|------------|----------|----------|
-| "the pilot" | "Acme Pilot" | Same org context in source |
-| "integration project" | "Acme Integration" | Same org + similar type |
-| "Series A" | "Series A Fundraise" | Unique identifier match |
-
----
-
-# Step 4: Resolve Entities to Canonical Names
-
-Using the search results from Step 3, resolve each variant to a canonical name.
-
-## 4a: Build Resolution Map
-
-Create a mapping from every source reference to its canonical form.
-
-## 4b: Apply Source Type Rules (Low Strictness)
-
-**If source_type == "meeting":**
-- Resolved entities → Update existing notes
-- New entities → Create new notes for ALL external attendees
-
-**If source_type == "email" (LOW STRICTNESS):**
-- Resolved entities → Update existing notes
-- New entities → Create notes for the sender and any mentioned contacts
-
-## 4c: Disambiguation Rules
-
-When multiple candidates match a variant, disambiguate by:
-1. Email match (definitive)
-2. Organization context (strong signal)
-3. Role match
-4. Recency (tiebreaker)
-
-## 4d: Resolution Map Output
-
-Final resolution map before proceeding:
-\`\`\`
-RESOLVED (use canonical name with absolute path):
-- "Sarah", "Sarah Chen", "sarah@acme.com" → [[People/Sarah Chen]]
-
-NEW ENTITIES (create notes):
-- "Jennifer" (CTO, Acme Corp) → Create [[People/Jennifer]]
-
-AMBIGUOUS (create with disambiguation note):
-- "Mike" (no context) → Create [[People/Mike]] with note about ambiguity
-\`\`\`
-
----
-
-# Step 5: Identify New Entities (Low Strictness - Capture Broadly)
-
-For entities not resolved to existing notes, create notes for most of them.
-
-## People
-
-### Who Gets a Note (Low Strictness)
-
-**CREATE a note for:**
-- ALL external meeting attendees (not @user.domain)
-- ALL email senders with identifiable names/emails
-- Anyone CC'd on emails who seems relevant
-- Anyone mentioned by name in conversations
-- Cold outreach senders (even if unsolicited)
-- Sales reps, recruiters, service providers
-- Anyone who might be useful to remember later
-
-**DO NOT create notes for:**
-- Internal colleagues (@user.domain)
-- Truly anonymous/unidentifiable senders
-- System-generated sender names with no human behind them
-
-### The Low Strictness Test
-
-Ask: Could this person ever be useful to remember?
-
-- Sarah Chen, VP Engineering → **Yes, create note**
-- James from HSBC → **Yes, create note** (might need banking help again)
-- Random recruiter → **Yes, create note** (might want to contact later)
-- Cold sales person → **Yes, create note** (might be relevant someday)
-- Support rep → **Yes, create note** (might need them again)
-
-### Role Inference
-
-If role is not explicitly stated, infer from context. Write "Unknown" only if truly impossible to infer anything.
-
-### Relationship Type Guide (Low Strictness)
-
-| Relationship Type | Create People Notes? | Create Org Note? |
-|-------------------|----------------------|------------------|
-| Customer | Yes — all contacts | Yes |
-| Prospect | Yes — all contacts | Yes |
-| Investor | Yes | Yes |
-| Partner | Yes — all contacts | Yes |
-| Vendor | Yes — all contacts | Yes |
-| Bank/Financial | Yes | Yes |
-| Candidate | Yes | No |
-| Recruiter | Yes | Optional |
-| Service provider | Yes | Optional |
-| Cold outreach | Yes | Optional |
-| Support interaction | Yes | Optional |
-
-## Organizations
-
-**CREATE a note if:**
-- Anyone from that org is mentioned or contacted you
-- The org is mentioned in any context
-
-**Only skip:**
-- Organizations you genuinely can't identify
-
-## Projects
-
-**CREATE a note if:**
-- Discussed in meeting or email
-- Any indication of ongoing work or collaboration
-
-## Topics
-
-**CREATE a note if:**
-- Mentioned more than once
-- Seems like a recurring theme
-
----
-
-# Step 6: Extract Content
-
-For each entity that has or will have a note, extract relevant content.
-
-## Decisions
-
-Extract what was decided, when, by whom, and why.
-
-## Commitments
-
-Extract who committed to what, and any deadlines.
-
-## Key Facts
-
-Key facts should be **substantive information** — not commentary about missing data.
-
-**Extract if:**
-- Specific numbers, dates, or metrics
-- Preferences or working style
-- Background information
-- Authority or decision process
-- Concerns or constraints
-- What they're working on or interested in
-
-**Never include:**
-- Meta-commentary about missing data
-- Obvious facts already in Info section
-- Placeholder text
-
-**If there are no substantive key facts, leave the section empty.**
-
-## Open Items
-
-**Include:**
-- Commitments made
-- Requests received
-- Next steps discussed
-- Follow-ups agreed
-
-**Never include:**
-- Data gaps or research tasks
-- Wishes or hypotheticals
-
-## Summary
-
-The summary should answer: **"Who is this person and why do I know them?"**
-
-Write 2-3 sentences covering their role/function, context of the relationship, and what you're discussing.
-
-## Activity Summary
-
-One line summarizing this source's relevance to the entity:
-\`\`\`
-**{YYYY-MM-DD}** ({meeting|email|voice memo}): {Summary with [[links]]}
-\`\`\`
-
-**For voice memos:** Include a link to the voice memo file using the Path field:
-\`\`\`
-**2025-01-15** (voice memo): Discussed [[Projects/Acme Integration]] timeline. See [[Voice Memos/2025-01-15/voice-memo-2025-01-15T10-30-00-000Z]]
-\`\`\`
-
----
-
-# Step 7: Detect State Changes
-
-Review the extracted content for signals that existing note fields should be updated.
-
-## 7a: Project Status Changes
-
-Look for signals like "approved", "on hold", "cancelled", "completed", etc.
-
-## 7b: Open Item Resolution
-
-Look for signals that tracked items are now complete.
-
-## 7c: Role/Title Changes
-
-Look for new titles in signatures or explicit announcements.
-
-## 7d: Organization/Relationship Changes
-
-Look for company changes, partnership announcements, etc.
-
-## 7e: Build State Change List
-
-Compile all detected state changes before writing.
-
----
-
-# Step 8: Check for Duplicates and Conflicts
-
-Before writing:
-- Check if already processed this source
-- Skip duplicate key facts
-- Handle conflicting information by noting both versions
-
----
-
-# Step 9: Write Updates
-
-## 9a: Create and Update Notes
-
-**IMPORTANT: Write sequentially, one file at a time.**
-- Generate content for exactly one note.
-- Issue exactly one write/edit command.
-- Wait for the tool to return before generating the next note.
-- Do NOT batch multiple write commands in a single response.
-
-**For NEW entities (use workspace-writeFile):**
-\`\`\`
-workspace-writeFile({
-  path: "{knowledge_folder}/People/Jennifer.md",
-  data: "# Jennifer\\n\\n## Summary\\n..."
-})
-\`\`\`
-
-**For EXISTING entities (use workspace-edit):**
-- Read current content first with workspace-readFile
-- Use workspace-edit to add activity entry at TOP (reverse chronological)
-- Update fields using targeted edits
-\`\`\`
-workspace-edit({
-  path: "{knowledge_folder}/People/Sarah Chen.md",
-  oldString: "## Activity\\n",
-  newString: "## Activity\\n- **2026-02-03** (meeting): Met to discuss project timeline\\n"
-})
-\`\`\`
-
-## 9b: Apply State Changes
-
-Update all fields identified in Step 7.
-
-## 9c: Update Aliases
-
-Add newly discovered name variants to Aliases field.
-
-## 9d: Writing Rules
-
-- **Always use absolute paths** with format \`[[Folder/Name]]\` for all links
-- Use YYYY-MM-DD format for dates
-- Be concise: one line per activity entry
-- Escape quotes properly in shell commands
-- Write only one file per response (no multi-file write batches)
-
----
-
-# Step 10: Ensure Bidirectional Links
-
-After writing, verify links go both ways.
-
-## Absolute Link Format
-
-**IMPORTANT:** Always use absolute links:
-\`\`\`markdown
-[[People/Sarah Chen]]
-[[Organizations/Acme Corp]]
-[[Projects/Acme Integration]]
-[[Topics/Security Compliance]]
-\`\`\`
-
-## Bidirectional Link Rules
-
-| If you add... | Then also add... |
-|---------------|------------------|
-| Person → Organization | Organization → Person |
-| Person → Project | Project → Person |
-| Project → Organization | Organization → Project |
-| Project → Topic | Topic → Project |
-| Person → Person | Person → Person (reverse) |
-
----
-
-# Note Templates
-
-## People
-\`\`\`markdown
-# {Full Name}
-
-## Info
-**Role:** {role, inferred role, or Unknown}
-**Organization:** [[Organizations/{organization}]] or leave blank
-**Email:** {email or leave blank}
-**Aliases:** {comma-separated: first name, nicknames, email}
-**First met:** {YYYY-MM-DD}
-**Last seen:** {YYYY-MM-DD}
-
-## Summary
-{2-3 sentences: Who they are, why you know them.}
-
-## Connected to
-- [[Organizations/{Organization}]] — works at
-- [[People/{Person}]] — {relationship}
-- [[Projects/{Project}]] — {role}
-
-## Activity
-- **{YYYY-MM-DD}** ({meeting|email|voice memo}): {Summary with [[Folder/Name]] links}
-
-## Key facts
-{Substantive facts only. Leave empty if none.}
-
-## Open items
-{Commitments and next steps only. Leave empty if none.}
-\`\`\`
-
-## Organizations
-\`\`\`markdown
-# {Organization Name}
-
-## Info
-**Type:** {company|team|institution|other}
-**Industry:** {industry or leave blank}
-**Relationship:** {customer|prospect|partner|competitor|vendor|other}
-**Domain:** {primary email domain}
-**Aliases:** {short names, abbreviations}
-**First met:** {YYYY-MM-DD}
-**Last seen:** {YYYY-MM-DD}
-
-## Summary
-{2-3 sentences: What this org is, what your relationship is.}
-
-## People
-- [[People/{Person}]] — {role}
-
-## Contacts
-{For contacts who have their own notes}
-
-## Projects
-- [[Projects/{Project}]] — {relationship}
-
-## Activity
-- **{YYYY-MM-DD}** ({meeting|email|voice memo}): {Summary}
-
-## Key facts
-{Substantive facts only. Leave empty if none.}
-
-## Open items
-{Commitments and next steps only. Leave empty if none.}
-\`\`\`
-
-## Projects
-\`\`\`markdown
-# {Project Name}
-
-## Info
-**Type:** {deal|product|initiative|hiring|other}
-**Status:** {active|planning|on hold|completed|cancelled}
-**Started:** {YYYY-MM-DD or leave blank}
-**Last activity:** {YYYY-MM-DD}
-
-## Summary
-{2-3 sentences: What this project is, goal, current state.}
-
-## People
-- [[People/{Person}]] — {role}
-
-## Organizations
-- [[Organizations/{Org}]] — {relationship}
-
-## Related
-- [[Topics/{Topic}]] — {relationship}
-
-## Timeline
-**{YYYY-MM-DD}** ({meeting|email|voice memo})
-{What happened.}
-
-## Decisions
-- **{YYYY-MM-DD}**: {Decision}
-
-## Open items
-{Commitments and next steps only.}
-
-## Key facts
-{Substantive facts only.}
-\`\`\`
-
-## Topics
-\`\`\`markdown
-# {Topic Name}
-
-## About
-{1-2 sentences: What this topic covers.}
-
-**Keywords:** {comma-separated}
-**Aliases:** {other references}
-**First mentioned:** {YYYY-MM-DD}
-**Last mentioned:** {YYYY-MM-DD}
-
-## Related
-- [[People/{Person}]] — {relationship}
-- [[Organizations/{Org}]] — {relationship}
-- [[Projects/{Project}]] — {relationship}
-
-## Log
-**{YYYY-MM-DD}** ({meeting|email}: {title})
-{Summary}
-
-## Decisions
-- **{YYYY-MM-DD}**: {Decision}
-
-## Open items
-{Commitments and next steps only.}
-
-## Key facts
-{Substantive facts only.}
-\`\`\`
-
----
-
-# Summary: Low Strictness Rules
-
-| Source Type | Creates Notes? | Updates Notes? | Detects State Changes? |
-|-------------|---------------|----------------|------------------------|
-| Meeting | Yes — ALL external attendees | Yes | Yes |
-| Voice memo | Yes — all mentioned entities | Yes | Yes |
-| Email (any human sender) | Yes | Yes | Yes |
-| Email (automated/newsletter) | No (SKIP) | No | No |
-
-**Voice memo activity format:** Always include a link to the source voice memo:
-\`\`\`
-**2025-01-15** (voice memo): Discussed project timeline with [[People/Sarah Chen]]. See [[Voice Memos/2025-01-15/voice-memo-...]]
-\`\`\`
-
-**Philosophy:** Capture broadly, filter later if needed.
-
----
-
-# Error Handling
-
-1. **Missing data:** Leave blank or write "Unknown"
-2. **Ambiguous names:** Create note with disambiguation note
-3. **Conflicting info:** Note both versions
-4. **grep returns nothing:** Create new notes
-5. **State change unclear:** Log in activity but don't change the field
-6. **Note file malformed:** Log warning, attempt partial update
-7. **Shell command fails:** Log error, continue
-
----
-
-# Quality Checklist
-
-Before completing, verify:
-
-**Source Type:**
-- [ ] Correctly identified as meeting or email
-- [ ] Applied low strictness rules (capture broadly)
-
-**Resolution:**
-- [ ] Extracted all name variants
-- [ ] Searched existing notes
-- [ ] Built resolution map
-- [ ] Used absolute paths \`[[Folder/Name]]\`
-
-**Filtering:**
-- [ ] Excluded only self and @user.domain
-- [ ] Created notes for all external contacts
-- [ ] Only skipped obvious automated/newsletters
-
-**Content Quality:**
-- [ ] Summaries describe relationship
-- [ ] Roles inferred where possible
-- [ ] Key facts are substantive
-- [ ] Open items are commitments/next steps
-
-**State Changes:**
-- [ ] Detected and applied state changes
-- [ ] Logged changes in activity
-
-**Structure:**
-- [ ] All links use \`[[Folder/Name]]\` format
-- [ ] Activity entries reverse chronological
-- [ ] Dates are YYYY-MM-DD
-- [ ] Bidirectional links consistent
-`;

apps/x/packages/core/src/knowledge/note_system.ts

@@ -0,0 +1,209 @@
+import path from "path";
+import fs from "fs";
+import { WorkDir } from "../config/config.js";
+
+export interface NoteTypeDefinition {
+  type: string;
+  folder: string;
+  template: string;
+  extractionGuide: string;
+}
+
+// ── Default definitions (used to seed ~/.rowboat/config/notes.json) ──────────
+
+const DEFAULT_NOTE_TYPE_DEFINITIONS: NoteTypeDefinition[] = [
+  {
+    type: "People",
+    folder: "People",
+    template: `# {Full Name}
+
+## Info
+**Role:** {role, or inferred role with qualifier, or leave blank if truly unknown}
+**Organization:** [[Organizations/{organization}]] or leave blank
+**Email:** {email or leave blank}
+**Aliases:** {comma-separated: first name, nicknames, email}
+**First met:** {YYYY-MM-DD}
+**Last seen:** {YYYY-MM-DD}
+
+## Summary
+{2-3 sentences: Who they are, why you know them, what you're working on together.}
+
+## Connected to
+- [[Organizations/{Organization}]] — works at
+- [[People/{Person}]] — {colleague, introduced by, reports to}
+- [[Projects/{Project}]] — {role}
+
+## Activity
+- **{YYYY-MM-DD}** ({meeting|email|voice memo}): {Summary with [[Folder/Name]] links}
+
+## Key facts
+{Substantive facts only. Leave empty if none.}
+
+## Open items
+{Commitments and next steps only. Leave empty if none.}`,
+    extractionGuide:
+      "Look for: name, role, organization, email, aliases, relationship context",
+  },
+  {
+    type: "Organizations",
+    folder: "Organizations",
+    template: `# {Organization Name}
+
+## Info
+**Type:** {company|team|institution|other}
+**Industry:** {industry or leave blank}
+**Relationship:** {customer|prospect|partner|competitor|vendor|other}
+**Domain:** {primary email domain}
+**Aliases:** {comma-separated: short names, abbreviations}
+**First met:** {YYYY-MM-DD}
+**Last seen:** {YYYY-MM-DD}
+
+## Summary
+{2-3 sentences: What this org is, what your relationship is.}
+
+## People
+- [[People/{Person}]] — {role}
+
+## Contacts
+{For transactional contacts who don't get their own notes}
+
+## Projects
+- [[Projects/{Project}]] — {relationship}
+
+## Activity
+- **{YYYY-MM-DD}** ({meeting|email|voice memo}): {Summary with [[Folder/Name]] links}
+
+## Key facts
+{Substantive facts only. Leave empty if none.}
+
+## Open items
+{Commitments and next steps only. Leave empty if none.}`,
+    extractionGuide:
+      "Look for: organization name, type, industry, relationship, domain, key people, projects",
+  },
+  {
+    type: "Projects",
+    folder: "Projects",
+    template: `# {Project Name}
+
+## Info
+**Type:** {deal|product|initiative|hiring|other}
+**Status:** {active|planning|on hold|completed|cancelled}
+**Started:** {YYYY-MM-DD or leave blank}
+**Last activity:** {YYYY-MM-DD}
+
+## Summary
+{2-3 sentences: What this project is, goal, current state.}
+
+## People
+- [[People/{Person}]] — {role}
+
+## Organizations
+- [[Organizations/{Org}]] — {customer|partner|etc.}
+
+## Related
+- [[Topics/{Topic}]] — {relationship}
+- [[Projects/{Project}]] — {relationship}
+
+## Timeline
+**{YYYY-MM-DD}** ({meeting|email})
+{What happened.}
+
+## Decisions
+- **{YYYY-MM-DD}**: {Decision}. {Rationale}.
+
+## Open items
+{Commitments and next steps only. Leave empty if none.}
+
+## Key facts
+{Substantive facts only. Leave empty if none.}`,
+    extractionGuide:
+      "Look for: project name, type, status, people involved, organizations, timeline, decisions",
+  },
+  {
+    type: "Topics",
+    folder: "Topics",
+    template: `# {Topic Name}
+
+## About
+{1-2 sentences: What this topic covers.}
+
+**Keywords:** {comma-separated}
+**Aliases:** {other ways this topic is referenced}
+**First mentioned:** {YYYY-MM-DD}
+**Last mentioned:** {YYYY-MM-DD}
+
+## Related
+- [[People/{Person}]] — {relationship}
+- [[Organizations/{Org}]] — {relationship}
+- [[Projects/{Project}]] — {relationship}
+
+## Log
+**{YYYY-MM-DD}** ({meeting|email}: {title})
+{Summary with [[Folder/Name]] links}
+
+## Decisions
+- **{YYYY-MM-DD}**: {Decision}
+
+## Open items
+{Commitments and next steps only. Leave empty if none.}
+
+## Key facts
+{Substantive facts only. Leave empty if none.}`,
+    extractionGuide:
+      "Look for: topic name, keywords, related people/orgs/projects, decisions, key facts",
+  },
+  {
+    type: "Meetings",
+    folder: "Meetings",
+    template: "",
+    extractionGuide:
+      "Look for: meeting title, date, attendees, source (granola or fireflies), duration, topics discussed",
+  },
+];
+
+// ── Disk-backed config with mtime caching ──────────────────────────────────
+
+export const NOTES_CONFIG_PATH = path.join(WorkDir, "config", "notes.json");
+
+let cachedNoteTypeDefinitions: NoteTypeDefinition[] | null = null;
+let cachedMtimeMs: number | null = null;
+
+function ensureNotesConfigSync(): void {
+  if (!fs.existsSync(NOTES_CONFIG_PATH)) {
+    fs.writeFileSync(
+      NOTES_CONFIG_PATH,
+      JSON.stringify(DEFAULT_NOTE_TYPE_DEFINITIONS, null, 2) + "\n",
+      "utf8",
+    );
+  }
+}
+
+export function getNoteTypeDefinitions(): NoteTypeDefinition[] {
+  ensureNotesConfigSync();
+  try {
+    const stats = fs.statSync(NOTES_CONFIG_PATH);
+    if (cachedNoteTypeDefinitions && cachedMtimeMs === stats.mtimeMs) {
+      return cachedNoteTypeDefinitions;
+    }
+    const content = fs.readFileSync(NOTES_CONFIG_PATH, "utf8");
+    cachedNoteTypeDefinitions = JSON.parse(content);
+    cachedMtimeMs = stats.mtimeMs;
+    return cachedNoteTypeDefinitions!;
+  } catch {
+    cachedNoteTypeDefinitions = null;
+    cachedMtimeMs = null;
+    return DEFAULT_NOTE_TYPE_DEFINITIONS;
+  }
+}
+
+// ── Render helper ────────────────────────────────────────────────────────
+
+export function renderNoteTypesBlock(): string {
+  const defs = getNoteTypeDefinitions();
+  const sections = defs.map(
+    (d) =>
+      `## ${d.type}\n\`\`\`markdown\n${d.template}\n\`\`\``,
+  );
+  return `# Note Templates\n\n${sections.join("\n\n")}`;
+}

apps/x/packages/core/src/knowledge/note_tagging_agent.ts

@@ -0,0 +1,142 @@
+import { renderTagSystemForNotes } from './tag_system.js';
+
+export function getRaw(): string {
+  return `---
+model: gpt-5.2
+tools:
+  workspace-readFile:
+    type: builtin
+    name: workspace-readFile
+  workspace-edit:
+    type: builtin
+    name: workspace-edit
+  workspace-readdir:
+    type: builtin
+    name: workspace-readdir
+---
+# Task
+
+You are a note tagging agent. Given a batch of knowledge notes (People, Organizations, Projects, Topics, Meetings), you will classify each note and prepend YAML frontmatter with categorized tags and Info/metadata attributes.
+
+# Instructions
+
+1. For each note file provided in the message, read its content carefully.
+2. Determine the note type from its folder path (People/, Organizations/, Projects/, Topics/, Meetings/).
+3. Classify the note using the Rowboat Tag System (Note Tags section) appended below.
+4. Extract attributes from the note's \`## Info\` section (or \`## About\` for Topics). For Meetings, extract metadata from the note content and file path (see Meeting extraction rules below).
+5. Use \`workspace-edit\` to prepend YAML frontmatter to the file. The oldString should be the first line of the file (the \`# Title\` heading), and the newString should be the frontmatter followed by that same first line.
+6. If the note already has frontmatter (starts with \`---\`), skip it.
+
+# Frontmatter Format
+
+Tags are organized by **category** (not a flat list). Each tag category is a top-level YAML key. Use a plain string for single values, or a YAML list for multiple values.
+
+Info attributes from the \`## Info\` section are also included as top-level keys.
+
+\`\`\`yaml
+---
+relationship: customer
+relationship_sub: primary
+topic:
+  - sales
+  - fundraising
+source: email
+status: active
+action: action-required
+role: VP Engineering
+organization: Acme Corp
+email: sarah@acme.com
+first_met: "2024-06-15"
+last_seen: "2025-01-20"
+---
+\`\`\`
+
+## Tag category keys
+
+Use these exact keys for each tag category:
+
+| Category | Key | Single or multi | Example |
+|----------|-----|-----------------|---------|
+| Relationship | \`relationship\` | single | \`relationship: customer\` |
+| Relationship sub | \`relationship_sub\` | single or multi | \`relationship_sub: primary\` |
+| Topic | \`topic\` | single or multi | \`topic: sales\` or list |
+| Email type | \`email_type\` | single or multi | \`email_type: followup\` |
+| Action | \`action\` | single or multi | \`action: action-required\` |
+| Status | \`status\` | single | \`status: active\` |
+| Source | \`source\` | single or multi | \`source: email\` or list |
+
+**Rules:**
+- Use a plain string when there's only one value: \`topic: sales\`
+- Use a YAML list when there are multiple values:
+  \`\`\`yaml
+  topic:
+    - sales
+    - fundraising
+  \`\`\`
+- **Omit a category entirely** if no tags apply for it. Do not include empty keys.
+- Only use tag values from the Rowboat Tag System — do not invent new tags.
+
+# Info Attribute Extraction Rules
+
+Extract all \`**Key:** value\` fields from the \`## Info\` (or \`## About\`) section into YAML frontmatter keys:
+
+1. **Convert keys to snake_case**: e.g. \`**First met:**\` → \`first_met\`, \`**Last activity:**\` → \`last_activity\`, \`**Last seen:**\` → \`last_seen\`.
+2. **Strip wiki-link syntax**: \`[[Organizations/Acme Corp]]\` → \`Acme Corp\`. Extract just the display name (last path segment).
+3. **Skip blank/placeholder values**: If a field says "leave blank", is empty, or contains only template placeholders like \`{role}\`, omit it from the frontmatter.
+4. **Quote dates**: Wrap date values in quotes, e.g. \`first_met: "2024-06-15"\`.
+5. **Aliases as list**: If the value is comma-separated (like Aliases), store as a YAML list:
+   \`\`\`yaml
+   aliases:
+     - Sarah
+     - sarah@acme.com
+   \`\`\`
+
+**Per note type, extract these fields:**
+
+- **People**: role, organization, email, aliases, first_met, last_seen
+- **Organizations**: type, industry, relationship, domain, aliases, first_met, last_seen
+- **Projects**: type, status, started, last_activity
+- **Topics** (from \`## About\`): keywords, aliases, first_mentioned, last_mentioned
+- **Meetings**: Extract from the note content and file path:
+  - \`date\`: meeting date (from the file path \`Meetings/{source}/YYYY/MM/DD/\` or from \`created_at\`/\`Date:\` in content)
+  - \`source\`: \`granola\` or \`fireflies\` (from the file path)
+  - \`attendees\`: list of attendee names (from \`Attendees:\` field or participant list)
+  - \`title\`: meeting title
+  - \`topic\`: relevant topic tags based on meeting content
+
+Note: For Organizations, the Info \`**Relationship:**\` field is separate from the \`relationship\` tag category. Include both — the Info field as \`info_relationship\` and the tag as \`relationship\`.
+
+# Tag Selection Rules
+
+1. **Always include at least one relationship or topic tag** — every note must be classifiable.
+2. **Always include a source tag** — \`email\` or \`meeting\` based on what the note's Activity section shows.
+3. **Default status is \`active\`** for all new tags.
+4. **For People notes**, include:
+   - One primary relationship tag (e.g. \`customer\`, \`investor\`, \`prospect\`)
+   - Relationship sub-tags if applicable (e.g. \`primary\`, \`champion\`, \`former\`)
+   - Topic tags based on what you're working on together
+   - Source tags based on the Activity section
+   - Action tags if there are open items
+5. **For Organization notes**, include:
+   - One primary relationship tag
+   - Topic tags based on the relationship context
+   - Source tags
+6. **For Project notes**, include:
+   - Topic tags based on project type
+   - Source tags
+   - Action tags if there are open items
+7. **For Topic notes**, include:
+   - The relevant topic tag
+   - Source tags
+8. **For Meeting notes**, include:
+   - \`source: meeting\`
+   - Topic tags based on what was discussed
+   - The \`date\`, \`attendees\`, and \`title\` fields extracted from content
+9. **Only use tags from the Rowboat Tag System** — do not invent new tags.
+9. Process all files in the batch. Do not skip any unless they already have frontmatter.
+
+---
+
+${renderTagSystemForNotes()}
+`;
+}

apps/x/packages/core/src/knowledge/note_tagging_state.ts

@@ -0,0 +1,48 @@
+import fs from 'fs';
+import path from 'path';
+import { WorkDir } from '../config/config.js';
+
+const STATE_FILE = path.join(WorkDir, 'note_tagging_state.json');
+
+export interface NoteTaggingState {
+    processedFiles: Record<string, { taggedAt: string }>;
+    lastRunTime: string;
+}
+
+export function loadNoteTaggingState(): NoteTaggingState {
+    if (fs.existsSync(STATE_FILE)) {
+        try {
+            return JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8'));
+        } catch (error) {
+            console.error('Error loading note tagging state:', error);
+        }
+    }
+
+    return {
+        processedFiles: {},
+        lastRunTime: new Date(0).toISOString(),
+    };
+}
+
+export function saveNoteTaggingState(state: NoteTaggingState): void {
+    try {
+        fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+    } catch (error) {
+        console.error('Error saving note tagging state:', error);
+        throw error;
+    }
+}
+
+export function markNoteAsTagged(filePath: string, state: NoteTaggingState): void {
+    state.processedFiles[filePath] = {
+        taggedAt: new Date().toISOString(),
+    };
+}
+
+export function resetNoteTaggingState(): void {
+    const emptyState: NoteTaggingState = {
+        processedFiles: {},
+        lastRunTime: new Date().toISOString(),
+    };
+    saveNoteTaggingState(emptyState);
+}

apps/x/packages/core/src/knowledge/summarize_meeting.ts

@@ -0,0 +1,168 @@
+import fs from 'fs';
+import path from 'path';
+import { generateText } from 'ai';
+import container from '../di/container.js';
+import type { IModelConfigRepo } from '../models/repo.js';
+import { createProvider } from '../models/models.js';
+import { isSignedIn } from '../account/account.js';
+import { getGatewayProvider } from '../models/gateway.js';
+import { WorkDir } from '../config/config.js';
+
+const CALENDAR_SYNC_DIR = path.join(WorkDir, 'calendar_sync');
+
+const SYSTEM_PROMPT = `You are a meeting notes assistant. Given a raw meeting transcript and a list of calendar events from around the same time, create concise, well-organized meeting notes.
+
+## Calendar matching
+You will be given the transcript (with a timestamp of when recording started) and recent calendar events with their titles, times, and attendees. If a calendar event clearly matches this meeting (overlapping time + content aligns), then:
+- Do NOT output a title or heading — the title is already set by the caller.
+- Replace generic speaker labels ("Speaker 0", "Speaker 1", "System audio") with actual attendee names, but ONLY if you have HIGH CONFIDENCE about which speaker is which based on the discussion content. If unsure, use "They" instead of "Speaker 0" etc.
+- "You" in the transcript is the local user — if the calendar event has an organizer or you can identify who "You" is from context, use their name.
+
+If no calendar event matches with high confidence, or if no calendar events are provided, use "They" for all non-"You" speakers.
+
+## Format rules
+- Do NOT output a title or top-level heading (# or ##). Start directly with section content.
+- Use ### for section headers that group related discussion topics
+- Section headers should be in sentence case (e.g. "### Onboarding flow status"), NOT Title Case
+- Use bullet points with sub-bullets for details
+- Include a "### Action items" section at the end if any were discussed
+- Focus on decisions, key discussions, and takeaways — not verbatim quotes
+- Attribute statements to speakers when relevant
+- Keep it concise — the notes should be much shorter than the transcript
+- Output markdown only, no preamble or explanation`;
+
+/**
+ * Load recent calendar events from the calendar_sync directory.
+ * Returns a formatted string of events for the LLM prompt.
+ */
+function loadRecentCalendarEvents(meetingTime: string): string {
+    try {
+        if (!fs.existsSync(CALENDAR_SYNC_DIR)) return '';
+
+        const files = fs.readdirSync(CALENDAR_SYNC_DIR).filter(f => f.endsWith('.json') && f !== 'sync_state.json' && f !== 'composio_state.json');
+        if (files.length === 0) return '';
+
+        const meetingDate = new Date(meetingTime);
+        // Only consider events within ±3 hours of the meeting
+        const windowMs = 3 * 60 * 60 * 1000;
+
+        const relevantEvents: string[] = [];
+
+        for (const file of files) {
+            try {
+                const content = fs.readFileSync(path.join(CALENDAR_SYNC_DIR, file), 'utf-8');
+                const event = JSON.parse(content);
+
+                const startTime = event.start?.dateTime || event.start?.date;
+                if (!startTime) continue;
+
+                const eventStart = new Date(startTime);
+                if (Math.abs(eventStart.getTime() - meetingDate.getTime()) > windowMs) continue;
+
+                const attendees = (event.attendees || [])
+                    .map((a: { displayName?: string; email?: string }) => a.displayName || a.email)
+                    .filter(Boolean)
+                    .join(', ');
+
+                const endTime = event.end?.dateTime || event.end?.date || '';
+                const organizer = event.organizer?.displayName || event.organizer?.email || '';
+
+                relevantEvents.push(
+                    `- Title: ${event.summary || 'Untitled'}\n` +
+                    `  Start: ${startTime}\n` +
+                    `  End: ${endTime}\n` +
+                    `  Organizer: ${organizer}\n` +
+                    `  Attendees: ${attendees || 'none listed'}`
+                );
+            } catch {
+                // Skip malformed files
+            }
+        }
+
+        if (relevantEvents.length === 0) return '';
+        return `\n\n## Calendar events around this time\n\n${relevantEvents.join('\n\n')}`;
+    } catch {
+        return '';
+    }
+}
+
+/**
+ * Load a specific calendar event from the calendar_sync directory using
+ * the calendar_event JSON stored in the meeting note frontmatter.
+ * If a `source` field is present, loads the full event file for richer
+ * details (attendees, organizer, etc.).
+ */
+function loadCalendarEventContext(calendarEventJson: string): string {
+    try {
+        const meta = JSON.parse(calendarEventJson) as {
+            summary?: string;
+            start?: string;
+            end?: string;
+            location?: string;
+            htmlLink?: string;
+            conferenceLink?: string;
+            source?: string;
+        };
+
+        // Try to load the full event from source file for attendee info
+        let attendees = '';
+        let organizer = '';
+        if (meta.source) {
+            try {
+                const fullPath = path.join(WorkDir, meta.source);
+                if (fs.existsSync(fullPath)) {
+                    const event = JSON.parse(fs.readFileSync(fullPath, 'utf-8'));
+                    attendees = (event.attendees || [])
+                        .map((a: { displayName?: string; email?: string }) => a.displayName || a.email)
+                        .filter(Boolean)
+                        .join(', ');
+                    organizer = event.organizer?.displayName || event.organizer?.email || '';
+                }
+            } catch {
+                // Fall through — use metadata only
+            }
+        }
+
+        const eventStr =
+            `- Title: ${meta.summary || 'Untitled'}\n` +
+            `  Start: ${meta.start || ''}\n` +
+            `  End: ${meta.end || ''}\n` +
+            `  Organizer: ${organizer || 'unknown'}\n` +
+            `  Attendees: ${attendees || 'none listed'}`;
+
+        return `\n\n## Calendar event for this meeting\n\n${eventStr}`;
+    } catch {
+        return '';
+    }
+}
+
+export async function summarizeMeeting(transcript: string, meetingStartTime?: string, calendarEventJson?: string): Promise<string> {
+    const repo = container.resolve<IModelConfigRepo>('modelConfigRepo');
+    const config = await repo.getConfig();
+    const signedIn = await isSignedIn();
+    const provider = signedIn
+        ? await getGatewayProvider()
+        : createProvider(config.provider);
+    const modelId = config.meetingNotesModel
+        || (signedIn ? "gpt-5.4" : config.model);
+    const model = provider.languageModel(modelId);
+
+    // If a specific calendar event was linked, use it directly.
+    // Otherwise fall back to scanning events within ±3 hours.
+    let calendarContext: string;
+    if (calendarEventJson) {
+        calendarContext = loadCalendarEventContext(calendarEventJson);
+    } else {
+        calendarContext = meetingStartTime ? loadRecentCalendarEvents(meetingStartTime) : '';
+    }
+
+    const prompt = `Meeting recording started at: ${meetingStartTime || 'unknown'}\n\n${transcript}${calendarContext}`;
+
+    const result = await generateText({
+        model,
+        system: SYSTEM_PROMPT,
+        prompt,
+    });
+
+    return result.text.trim();
+}

apps/x/packages/core/src/knowledge/sync_calendar.ts

@@ -5,13 +5,16 @@ import { OAuth2Client } from 'google-auth-library';
 import { NodeHtmlMarkdown } from 'node-html-markdown'
 import { WorkDir } from '../config/config.js';
 import { GoogleClientFactory } from './google-client-factory.js';
-import { serviceLogger } from '../services/service_logger.js';
+import { serviceLogger, type ServiceRunContext } from '../services/service_logger.js';
 import { limitEventItems } from './limit_event_items.js';
+import { executeAction, useComposioForGoogleCalendar } from '../composio/client.js';
+import { composioAccountsRepo } from '../composio/repo.js';
 
 // Configuration
 const SYNC_DIR = path.join(WorkDir, 'calendar_sync');
 const SYNC_INTERVAL_MS = 5 * 60 * 1000; // Check every 5 minutes
 const LOOKBACK_DAYS = 14;
+const COMPOSIO_LOOKBACK_DAYS = 14;
 const REQUIRED_SCOPES = [
     'https://www.googleapis.com/auth/calendar.events.readonly',
     'https://www.googleapis.com/auth/drive.readonly'
@@ -56,7 +59,7 @@ function cleanUpOldFiles(currentEventIds: Set<string>, syncDir: string): string[
     const files = fs.readdirSync(syncDir);
     const deleted: string[] = [];
     for (const filename of files) {
-        if (filename === 'sync_state.json') continue;
+        if (filename === 'sync_state.json' || filename === 'composio_state.json') continue;
 
         // We expect files like:
         // {eventId}.json
@@ -133,10 +136,10 @@ async function processAttachments(drive: drive.Drive, event: cal.Schema$Event, s
             const filename = `${eventId}_doc_${safeTitle}.md`;
             const filePath = path.join(syncDir, filename);
 
-            // Simple cache check: if file exists, skip. 
+            // Simple cache check: if file exists, skip.
             // Ideally we check modifiedTime, but that requires an extra API call per file.
             // Given the loop interval, we can just check existence to save quota.
-            // If user updates notes, they might want them re-synced. 
+            // If user updates notes, they might want them re-synced.
             // For now, let's just check existence. To be smarter, we'd need a state file or check API.
             if (fs.existsSync(filePath)) continue;
 
@@ -343,20 +346,248 @@ async function performSync(syncDir: string, lookbackDays: number) {
     }
 }
 
+// --- Composio-based Sync ---
+
+interface ComposioCalendarState {
+    last_sync: string; // ISO string
+}
+
+function loadComposioState(stateFile: string): ComposioCalendarState | null {
+    if (fs.existsSync(stateFile)) {
+        try {
+            const data = JSON.parse(fs.readFileSync(stateFile, 'utf-8'));
+            if (data.last_sync) {
+                return { last_sync: data.last_sync };
+            }
+        } catch (e) {
+            console.error('[Calendar] Failed to load composio state:', e);
+        }
+    }
+    return null;
+}
+
+function saveComposioState(stateFile: string, lastSync: string): void {
+    fs.writeFileSync(stateFile, JSON.stringify({ last_sync: lastSync }, null, 2));
+}
+
+/**
+ * Save a Composio calendar event as JSON (same format used by Google OAuth path).
+ * The event data from Composio is already structured similarly to Google Calendar API.
+ */
+function saveComposioEvent(eventData: Record<string, unknown>, syncDir: string): { changed: boolean; isNew: boolean; title: string } {
+    const eventId = eventData.id as string | undefined;
+    if (!eventId) return { changed: false, isNew: false, title: 'Unknown' };
+
+    const filePath = path.join(syncDir, `${eventId}.json`);
+    const content = JSON.stringify(eventData, null, 2);
+    const exists = fs.existsSync(filePath);
+
+    try {
+        if (exists) {
+            const existing = fs.readFileSync(filePath, 'utf-8');
+            if (existing === content) {
+                return { changed: false, isNew: false, title: (eventData.summary as string) || eventId };
+            }
+        }
+
+        fs.writeFileSync(filePath, content);
+        return { changed: true, isNew: !exists, title: (eventData.summary as string) || eventId };
+    } catch (e) {
+        console.error(`[Calendar] Error saving event ${eventId}:`, e);
+        return { changed: false, isNew: false, title: (eventData.summary as string) || eventId };
+    }
+}
+
+async function performSyncComposio() {
+    const STATE_FILE = path.join(SYNC_DIR, 'composio_state.json');
+
+    if (!fs.existsSync(SYNC_DIR)) fs.mkdirSync(SYNC_DIR, { recursive: true });
+
+    const account = composioAccountsRepo.getAccount('googlecalendar');
+    if (!account || account.status !== 'ACTIVE') {
+        console.log('[Calendar] Google Calendar not connected via Composio. Skipping sync.');
+        return;
+    }
+
+    const connectedAccountId = account.id;
+
+    // Calculate time window: lookback + 14 days forward
+    const now = new Date();
+    const lookbackMs = COMPOSIO_LOOKBACK_DAYS * 24 * 60 * 60 * 1000;
+    const twoWeeksForwardMs = 14 * 24 * 60 * 60 * 1000;
+
+    const timeMin = new Date(now.getTime() - lookbackMs).toISOString();
+    const timeMax = new Date(now.getTime() + twoWeeksForwardMs).toISOString();
+
+    console.log(`[Calendar] Syncing via Composio from ${timeMin} to ${timeMax} (lookback: ${COMPOSIO_LOOKBACK_DAYS} days)...`);
+
+    let run: ServiceRunContext | null = null;
+    const ensureRun = async (): Promise<ServiceRunContext> => {
+        if (!run) {
+            run = await serviceLogger.startRun({
+                service: 'calendar',
+                message: 'Syncing calendar (Composio)',
+                trigger: 'timer',
+            });
+        }
+        return run;
+    };
+
+    try {
+        const result = await executeAction(
+            'GOOGLECALENDAR_FIND_EVENT',
+            {
+                connected_account_id: connectedAccountId,
+                user_id: 'rowboat-user',
+                version: 'latest',
+                arguments: {
+                    calendar_id: 'primary',
+                    time_min: timeMin,
+                    time_max: timeMax,
+                    single_events: true,
+                    order_by: 'startTime',
+                },
+            }
+        );
+
+        if (!result.successful || !result.data) {
+            console.error('[Calendar] Failed to list events via Composio:', result.error);
+            return;
+        }
+
+        const data = result.data as Record<string, unknown>;
+        // Composio may return events in different structures
+        let events: Array<Record<string, unknown>> = [];
+
+        if (Array.isArray(data.items)) {
+            events = data.items as Array<Record<string, unknown>>;
+        } else if (Array.isArray(data.events)) {
+            events = data.events as Array<Record<string, unknown>>;
+        } else if (Array.isArray(data)) {
+            events = data as unknown as Array<Record<string, unknown>>;
+        }
+
+        const currentEventIds = new Set<string>();
+        let newCount = 0;
+        let updatedCount = 0;
+        const changedTitles: string[] = [];
+
+        if (events.length === 0) {
+            console.log('[Calendar] No events found in this window.');
+        } else {
+            console.log(`[Calendar] Found ${events.length} events.`);
+            for (const event of events) {
+                const eventId = event.id as string | undefined;
+                if (eventId) {
+                    const saveResult = saveComposioEvent(event, SYNC_DIR);
+                    currentEventIds.add(eventId);
+
+                    if (saveResult.changed) {
+                        await ensureRun();
+                        changedTitles.push(saveResult.title);
+                        if (saveResult.isNew) {
+                            newCount++;
+                        } else {
+                            updatedCount++;
+                        }
+                    }
+                }
+            }
+        }
+
+        // Clean up events no longer in the window
+        const deletedFiles = cleanUpOldFiles(currentEventIds, SYNC_DIR);
+        let deletedCount = 0;
+        if (deletedFiles.length > 0) {
+            await ensureRun();
+            deletedCount = deletedFiles.length;
+        }
+
+        // Log results if any changes were detected (run was started by ensureRun)
+        if (run) {
+            const r = run as ServiceRunContext;
+            const totalChanges = newCount + updatedCount + deletedCount;
+            const limitedTitles = limitEventItems(changedTitles);
+            await serviceLogger.log({
+                type: 'changes_identified',
+                service: r.service,
+                runId: r.runId,
+                level: 'info',
+                message: `Calendar updates: ${totalChanges} change${totalChanges === 1 ? '' : 's'}`,
+                counts: {
+                    newEvents: newCount,
+                    updatedEvents: updatedCount,
+                    deletedFiles: deletedCount,
+                },
+                items: limitedTitles.items,
+                truncated: limitedTitles.truncated,
+            });
+            await serviceLogger.log({
+                type: 'run_complete',
+                service: r.service,
+                runId: r.runId,
+                level: 'info',
+                message: `Calendar sync complete: ${totalChanges} change${totalChanges === 1 ? '' : 's'}`,
+                durationMs: Date.now() - r.startedAt,
+                outcome: 'ok',
+                summary: {
+                    newEvents: newCount,
+                    updatedEvents: updatedCount,
+                    deletedFiles: deletedCount,
+                },
+            });
+        }
+
+        // Save state
+        saveComposioState(STATE_FILE, new Date().toISOString());
+        console.log(`[Calendar] Composio sync completed. ${newCount} new, ${updatedCount} updated, ${deletedCount} deleted.`);
+    } catch (error) {
+        console.error('[Calendar] Error during Composio sync:', error);
+        const errRun = await ensureRun();
+        await serviceLogger.log({
+            type: 'error',
+            service: errRun.service,
+            runId: errRun.runId,
+            level: 'error',
+            message: 'Calendar sync error',
+            error: error instanceof Error ? error.message : String(error),
+        });
+        await serviceLogger.log({
+            type: 'run_complete',
+            service: errRun.service,
+            runId: errRun.runId,
+            level: 'error',
+            message: 'Calendar sync failed',
+            durationMs: Date.now() - errRun.startedAt,
+            outcome: 'error',
+        });
+    }
+}
+
 export async function init() {
     console.log("Starting Google Calendar & Notes Sync (TS)...");
     console.log(`Will sync every ${SYNC_INTERVAL_MS / 1000} seconds.`);
 
     while (true) {
         try {
-            // Check if credentials are available with required scopes
-            const hasCredentials = await GoogleClientFactory.hasValidCredentials(REQUIRED_SCOPES);
-
-            if (!hasCredentials) {
-                console.log("Google OAuth credentials not available or missing required Calendar/Drive scopes. Sleeping...");
+            const composioMode = await useComposioForGoogleCalendar();
+            if (composioMode) {
+                const isConnected = composioAccountsRepo.isConnected('googlecalendar');
+                if (!isConnected) {
+                    console.log('[Calendar] Google Calendar not connected via Composio. Sleeping...');
+                } else {
+                    await performSyncComposio();
+                }
             } else {
-                // Perform one sync
-                await performSync(SYNC_DIR, LOOKBACK_DAYS);
+                // Check if credentials are available with required scopes
+                const hasCredentials = await GoogleClientFactory.hasValidCredentials(REQUIRED_SCOPES);
+
+                if (!hasCredentials) {
+                    console.log("Google OAuth credentials not available or missing required Calendar/Drive scopes. Sleeping...");
+                } else {
+                    // Perform one sync
+                    await performSync(SYNC_DIR, LOOKBACK_DAYS);
+                }
             }
         } catch (error) {
             console.error("Error in main loop:", error);

apps/x/packages/core/src/knowledge/sync_fireflies.ts

@@ -6,9 +6,9 @@ import { serviceLogger, type ServiceRunContext } from '../services/service_logge
 import { limitEventItems } from './limit_event_items.js';
 
 // Configuration
-const SYNC_DIR = path.join(WorkDir, 'fireflies_transcripts');
+const SYNC_DIR = path.join(WorkDir, 'knowledge', 'Meetings', 'fireflies');
 const SYNC_INTERVAL_MS = 30 * 60 * 1000; // Check every 30 minutes (reduced from 1 minute)
-const STATE_FILE = path.join(SYNC_DIR, 'sync_state.json');
+const STATE_FILE = path.join(WorkDir, 'fireflies_sync_state.json');
 const LOOKBACK_DAYS = 30; // Last 1 month
 const API_DELAY_MS = 2000; // 2 second delay between API calls
 const RATE_LIMIT_RETRY_DELAY_MS = 60 * 1000; // Wait 1 minute on rate limit
@@ -569,8 +569,16 @@ async function syncMeetings() {
                 
                 // Convert to markdown and save
                 const markdown = meetingToMarkdown(meetingData);
-                const filename = `${meetingId}_${cleanFilename(meetingData.title || 'untitled')}.md`;
-                const filePath = path.join(SYNC_DIR, filename);
+                const meetingDate = new Date(meetingData.dateString || meetingData.date || Date.now());
+                const dateDir = path.join(
+                    SYNC_DIR,
+                    String(meetingDate.getFullYear()),
+                    String(meetingDate.getMonth() + 1).padStart(2, '0'),
+                    String(meetingDate.getDate()).padStart(2, '0')
+                );
+                fs.mkdirSync(dateDir, { recursive: true });
+                const filename = `${cleanFilename(meetingData.title || 'untitled')}.md`;
+                const filePath = path.join(dateDir, filename);
                 
                 fs.writeFileSync(filePath, markdown);
                 console.log(`[Fireflies] Saved: ${filename}`);

apps/x/packages/core/src/knowledge/sync_gmail.ts

@@ -7,6 +7,8 @@ import { WorkDir } from '../config/config.js';
 import { GoogleClientFactory } from './google-client-factory.js';
 import { serviceLogger, type ServiceRunContext } from '../services/service_logger.js';
 import { limitEventItems } from './limit_event_items.js';
+import { executeAction, useComposioForGoogle } from '../composio/client.js';
+import { composioAccountsRepo } from '../composio/repo.js';
 
 // Configuration
 const SYNC_DIR = path.join(WorkDir, 'gmail_sync');
@@ -440,20 +442,370 @@ async function performSync() {
     }
 }
 
+// --- Composio-based Sync ---
+
+const COMPOSIO_LOOKBACK_DAYS = 30;
+
+interface ComposioSyncState {
+    last_sync: string; // ISO string
+}
+
+function loadComposioState(stateFile: string): ComposioSyncState | null {
+    if (fs.existsSync(stateFile)) {
+        try {
+            const data = JSON.parse(fs.readFileSync(stateFile, 'utf-8'));
+            if (data.last_sync) {
+                return { last_sync: data.last_sync };
+            }
+        } catch (e) {
+            console.error('[Gmail] Failed to load composio state:', e);
+        }
+    }
+    return null;
+}
+
+function saveComposioState(stateFile: string, lastSync: string): void {
+    fs.writeFileSync(stateFile, JSON.stringify({ last_sync: lastSync }, null, 2));
+}
+
+function tryParseDate(dateStr: string): Date | null {
+    const d = new Date(dateStr);
+    return isNaN(d.getTime()) ? null : d;
+}
+
+interface ParsedMessage {
+    from: string;
+    date: string;
+    subject: string;
+    body: string;
+}
+
+function parseMessageData(messageData: Record<string, unknown>): ParsedMessage {
+    const headers = messageData.payload && typeof messageData.payload === 'object'
+        ? (messageData.payload as Record<string, unknown>).headers as Array<{ name: string; value: string }> | undefined
+        : undefined;
+
+    const from = headers?.find(h => h.name === 'From')?.value || String(messageData.from || messageData.sender || 'Unknown');
+    const date = headers?.find(h => h.name === 'Date')?.value || String(messageData.date || messageData.internalDate || 'Unknown');
+    const subject = headers?.find(h => h.name === 'Subject')?.value || String(messageData.subject || '(No Subject)');
+
+    let body = '';
+
+    if (messageData.payload && typeof messageData.payload === 'object') {
+        body = extractBodyFromPayload(messageData.payload as Record<string, unknown>);
+    }
+
+    if (!body) {
+        if (typeof messageData.body === 'string') {
+            body = messageData.body;
+        } else if (typeof messageData.snippet === 'string') {
+            body = messageData.snippet;
+        } else if (typeof messageData.text === 'string') {
+            body = messageData.text;
+        }
+    }
+
+    if (body && (body.includes('<html') || body.includes('<div') || body.includes('<p'))) {
+        body = nhm.translate(body);
+    }
+
+    if (body) {
+        body = body.split('\n').filter((line: string) => !line.trim().startsWith('>')).join('\n');
+    }
+
+    return { from, date, subject, body };
+}
+
+function extractBodyFromPayload(payload: Record<string, unknown>): string {
+    const parts = payload.parts as Array<Record<string, unknown>> | undefined;
+
+    if (parts) {
+        for (const part of parts) {
+            const mimeType = part.mimeType as string | undefined;
+            const bodyData = part.body && typeof part.body === 'object'
+                ? (part.body as Record<string, unknown>).data as string | undefined
+                : undefined;
+
+            if ((mimeType === 'text/plain' || mimeType === 'text/html') && bodyData) {
+                const decoded = Buffer.from(bodyData, 'base64').toString('utf-8');
+                if (mimeType === 'text/html') {
+                    return nhm.translate(decoded);
+                }
+                return decoded;
+            }
+
+            if (part.parts) {
+                const result = extractBodyFromPayload(part as Record<string, unknown>);
+                if (result) return result;
+            }
+        }
+    }
+
+    const bodyData = payload.body && typeof payload.body === 'object'
+        ? (payload.body as Record<string, unknown>).data as string | undefined
+        : undefined;
+
+    if (bodyData) {
+        const decoded = Buffer.from(bodyData, 'base64').toString('utf-8');
+        const mimeType = payload.mimeType as string | undefined;
+        if (mimeType === 'text/html') {
+            return nhm.translate(decoded);
+        }
+        return decoded;
+    }
+
+    return '';
+}
+
+async function processThreadComposio(connectedAccountId: string, threadId: string, syncDir: string): Promise<string | null> {
+    let threadResult;
+    try {
+        threadResult = await executeAction(
+            'GMAIL_FETCH_MESSAGE_BY_THREAD_ID',
+            {
+                connected_account_id: connectedAccountId,
+                user_id: 'rowboat-user',
+                version: 'latest',
+                arguments: { thread_id: threadId, user_id: 'me' },
+            }
+        );
+    } catch (error) {
+        console.warn(`[Gmail] Skipping thread ${threadId} (fetch failed):`, error instanceof Error ? error.message : error);
+        return null;
+    }
+
+    if (!threadResult.successful || !threadResult.data) {
+        console.error(`[Gmail] Failed to fetch thread ${threadId}:`, threadResult.error);
+        return null;
+    }
+
+    const data = threadResult.data as Record<string, unknown>;
+    const messages = data.messages as Array<Record<string, unknown>> | undefined;
+
+    let newestDate: Date | null = null;
+
+    if (!messages || messages.length === 0) {
+        const parsed = parseMessageData(data);
+        const mdContent = `# ${parsed.subject}\n\n` +
+            `**Thread ID:** ${threadId}\n` +
+            `**Message Count:** 1\n\n---\n\n` +
+            `### From: ${parsed.from}\n` +
+            `**Date:** ${parsed.date}\n\n` +
+            `${parsed.body}\n\n---\n\n`;
+
+        fs.writeFileSync(path.join(syncDir, `${cleanFilename(threadId)}.md`), mdContent);
+        console.log(`[Gmail] Synced Thread: ${parsed.subject} (${threadId})`);
+        newestDate = tryParseDate(parsed.date);
+    } else {
+        const firstParsed = parseMessageData(messages[0]);
+        let mdContent = `# ${firstParsed.subject}\n\n`;
+        mdContent += `**Thread ID:** ${threadId}\n`;
+        mdContent += `**Message Count:** ${messages.length}\n\n---\n\n`;
+
+        for (const msg of messages) {
+            const parsed = parseMessageData(msg);
+            mdContent += `### From: ${parsed.from}\n`;
+            mdContent += `**Date:** ${parsed.date}\n\n`;
+            mdContent += `${parsed.body}\n\n`;
+            mdContent += `---\n\n`;
+
+            const msgDate = tryParseDate(parsed.date);
+            if (msgDate && (!newestDate || msgDate > newestDate)) {
+                newestDate = msgDate;
+            }
+        }
+
+        fs.writeFileSync(path.join(syncDir, `${cleanFilename(threadId)}.md`), mdContent);
+        console.log(`[Gmail] Synced Thread: ${firstParsed.subject} (${threadId})`);
+    }
+
+    if (!newestDate) return null;
+    return new Date(newestDate.getTime() + 1000).toISOString();
+}
+
+async function performSyncComposio() {
+    const ATTACHMENTS_DIR = path.join(SYNC_DIR, 'attachments');
+    const STATE_FILE = path.join(SYNC_DIR, 'sync_state.json');
+
+    if (!fs.existsSync(SYNC_DIR)) fs.mkdirSync(SYNC_DIR, { recursive: true });
+    if (!fs.existsSync(ATTACHMENTS_DIR)) fs.mkdirSync(ATTACHMENTS_DIR, { recursive: true });
+
+    const account = composioAccountsRepo.getAccount('gmail');
+    if (!account || account.status !== 'ACTIVE') {
+        console.log('[Gmail] Gmail not connected via Composio. Skipping sync.');
+        return;
+    }
+
+    const connectedAccountId = account.id;
+
+    const state = loadComposioState(STATE_FILE);
+    let afterEpochSeconds: number;
+
+    if (state) {
+        afterEpochSeconds = Math.floor(new Date(state.last_sync).getTime() / 1000);
+        console.log(`[Gmail] Syncing messages since ${state.last_sync}...`);
+    } else {
+        const pastDate = new Date();
+        pastDate.setDate(pastDate.getDate() - COMPOSIO_LOOKBACK_DAYS);
+        afterEpochSeconds = Math.floor(pastDate.getTime() / 1000);
+        console.log(`[Gmail] First sync - fetching last ${COMPOSIO_LOOKBACK_DAYS} days...`);
+    }
+
+    let run: ServiceRunContext | null = null;
+    const ensureRun = async () => {
+        if (!run) {
+            run = await serviceLogger.startRun({
+                service: 'gmail',
+                message: 'Syncing Gmail (Composio)',
+                trigger: 'timer',
+            });
+        }
+    };
+
+    try {
+        const allThreadIds: string[] = [];
+        let pageToken: string | undefined;
+
+        do {
+            const params: Record<string, unknown> = {
+                query: `after:${afterEpochSeconds}`,
+                max_results: 20,
+                user_id: 'me',
+            };
+            if (pageToken) {
+                params.page_token = pageToken;
+            }
+
+            const result = await executeAction(
+                'GMAIL_LIST_THREADS',
+                {
+                    connected_account_id: connectedAccountId,
+                    user_id: 'rowboat-user',
+                    version: 'latest',
+                    arguments: params,
+                }
+            );
+
+            if (!result.successful || !result.data) {
+                console.error('[Gmail] Failed to list threads:', result.error);
+                return;
+            }
+
+            const data = result.data as Record<string, unknown>;
+            const threads = data.threads as Array<Record<string, unknown>> | undefined;
+
+            if (threads && threads.length > 0) {
+                for (const thread of threads) {
+                    const threadId = thread.id as string | undefined;
+                    if (threadId) {
+                        allThreadIds.push(threadId);
+                    }
+                }
+            }
+
+            pageToken = data.nextPageToken as string | undefined;
+        } while (pageToken);
+
+        if (allThreadIds.length === 0) {
+            console.log('[Gmail] No new threads.');
+            return;
+        }
+
+        console.log(`[Gmail] Found ${allThreadIds.length} threads to sync.`);
+
+        await ensureRun();
+        const limitedThreads = limitEventItems(allThreadIds);
+        await serviceLogger.log({
+            type: 'changes_identified',
+            service: run!.service,
+            runId: run!.runId,
+            level: 'info',
+            message: `Found ${allThreadIds.length} thread${allThreadIds.length === 1 ? '' : 's'} to sync`,
+            counts: { threads: allThreadIds.length },
+            items: limitedThreads.items,
+            truncated: limitedThreads.truncated,
+        });
+
+        // Process oldest first so high-water mark advances chronologically
+        allThreadIds.reverse();
+
+        let highWaterMark: string | null = state?.last_sync ?? null;
+        let processedCount = 0;
+        for (const threadId of allThreadIds) {
+            try {
+                const newestInThread = await processThreadComposio(connectedAccountId, threadId, SYNC_DIR);
+                processedCount++;
+
+                if (newestInThread) {
+                    if (!highWaterMark || new Date(newestInThread) > new Date(highWaterMark)) {
+                        highWaterMark = newestInThread;
+                    }
+                    saveComposioState(STATE_FILE, highWaterMark);
+                }
+            } catch (error) {
+                console.error(`[Gmail] Error processing thread ${threadId}, skipping:`, error);
+            }
+        }
+
+        await serviceLogger.log({
+            type: 'run_complete',
+            service: run!.service,
+            runId: run!.runId,
+            level: 'info',
+            message: `Gmail sync complete: ${processedCount}/${allThreadIds.length} thread${allThreadIds.length === 1 ? '' : 's'}`,
+            durationMs: Date.now() - run!.startedAt,
+            outcome: 'ok',
+            summary: { threads: processedCount },
+        });
+
+        console.log(`[Gmail] Sync completed. Processed ${processedCount}/${allThreadIds.length} threads.`);
+    } catch (error) {
+        console.error('[Gmail] Error during sync:', error);
+        await ensureRun();
+        await serviceLogger.log({
+            type: 'error',
+            service: run!.service,
+            runId: run!.runId,
+            level: 'error',
+            message: 'Gmail sync error',
+            error: error instanceof Error ? error.message : String(error),
+        });
+        await serviceLogger.log({
+            type: 'run_complete',
+            service: run!.service,
+            runId: run!.runId,
+            level: 'error',
+            message: 'Gmail sync failed',
+            durationMs: Date.now() - run!.startedAt,
+            outcome: 'error',
+        });
+    }
+}
+
 export async function init() {
     console.log("Starting Gmail Sync (TS)...");
     console.log(`Will sync every ${SYNC_INTERVAL_MS / 1000} seconds.`);
 
     while (true) {
         try {
-            // Check if credentials are available with required scopes
-            const hasCredentials = await GoogleClientFactory.hasValidCredentials(REQUIRED_SCOPE);
-            
-            if (!hasCredentials) {
-                console.log("Google OAuth credentials not available or missing required Gmail scope. Sleeping...");
+            const composioMode = await useComposioForGoogle();
+            if (composioMode) {
+                const isConnected = composioAccountsRepo.isConnected('gmail');
+                if (!isConnected) {
+                    console.log('[Gmail] Gmail not connected via Composio. Sleeping...');
+                } else {
+                    await performSyncComposio();
+                }
             } else {
-                // Perform one sync
-                await performSync();
+                // Check if credentials are available with required scopes
+                const hasCredentials = await GoogleClientFactory.hasValidCredentials(REQUIRED_SCOPE);
+
+                if (!hasCredentials) {
+                    console.log("Google OAuth credentials not available or missing required Gmail scope. Sleeping...");
+                } else {
+                    // Perform one sync
+                    await performSync();
+                }
             }
         } catch (error) {
             console.error("Error in main loop:", error);

apps/x/packages/core/src/knowledge/tag_notes.ts

@@ -0,0 +1,282 @@
+import fs from 'fs';
+import path from 'path';
+import { WorkDir } from '../config/config.js';
+import { createRun, createMessage } from '../runs/runs.js';
+import { bus } from '../runs/bus.js';
+import { serviceLogger } from '../services/service_logger.js';
+import { limitEventItems } from './limit_event_items.js';
+import {
+    loadNoteTaggingState,
+    saveNoteTaggingState,
+    markNoteAsTagged,
+    type NoteTaggingState,
+} from './note_tagging_state.js';
+import { getNoteTypeDefinitions } from './note_system.js';
+
+const SYNC_INTERVAL_MS = 15 * 1000; // 15 seconds
+const BATCH_SIZE = 15;
+const NOTE_TAGGING_AGENT = 'note_tagging_agent';
+const KNOWLEDGE_DIR = path.join(WorkDir, 'knowledge');
+const MAX_CONTENT_LENGTH = 8000;
+
+/**
+ * Find knowledge notes that haven't been tagged yet
+ */
+function getUntaggedNotes(state: NoteTaggingState): string[] {
+    if (!fs.existsSync(KNOWLEDGE_DIR)) {
+        return [];
+    }
+
+    const untagged: string[] = [];
+    const noteFolders = getNoteTypeDefinitions().map(d => d.folder);
+
+    function scanDir(dir: string) {
+        const entries = fs.readdirSync(dir);
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry);
+            const stat = fs.statSync(fullPath);
+
+            if (stat.isDirectory()) {
+                scanDir(fullPath);
+                continue;
+            }
+
+            if (!stat.isFile() || !entry.endsWith('.md')) {
+                continue;
+            }
+
+            // Skip if already tracked in state
+            if (state.processedFiles[fullPath]) {
+                continue;
+            }
+
+            // Skip if file already has frontmatter
+            try {
+                const content = fs.readFileSync(fullPath, 'utf-8');
+                if (content.startsWith('---')) {
+                    continue;
+                }
+            } catch {
+                continue;
+            }
+
+            untagged.push(fullPath);
+        }
+    }
+
+    for (const folder of noteFolders) {
+        const folderPath = path.join(KNOWLEDGE_DIR, folder);
+        if (!fs.existsSync(folderPath)) {
+            continue;
+        }
+        scanDir(folderPath);
+    }
+
+    return untagged;
+}
+
+/**
+ * Wait for a run to complete by listening for run-processing-end event
+ */
+async function waitForRunCompletion(runId: string): Promise<void> {
+    return new Promise(async (resolve) => {
+        const unsubscribe = await bus.subscribe('*', async (event) => {
+            if (event.type === 'run-processing-end' && event.runId === runId) {
+                unsubscribe();
+                resolve();
+            }
+        });
+    });
+}
+
+/**
+ * Tag a batch of note files using the tagging agent
+ */
+async function tagNoteBatch(
+    files: { path: string; content: string }[]
+): Promise<{ runId: string; filesEdited: Set<string> }> {
+    const run = await createRun({
+        agentId: NOTE_TAGGING_AGENT,
+    });
+
+    let message = `Tag the following ${files.length} knowledge notes by prepending YAML frontmatter with appropriate tags.\n\n`;
+    message += `**Important:** Use workspace-relative paths with workspace-edit (e.g. "knowledge/People/Sarah Chen.md", NOT absolute paths).\n\n`;
+
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        const relativePath = path.relative(WorkDir, file.path);
+        const truncated = file.content.length > MAX_CONTENT_LENGTH
+            ? file.content.slice(0, MAX_CONTENT_LENGTH) + '\n\n[... content truncated, use workspace-readFile for full content ...]'
+            : file.content;
+
+        message += `## File ${i + 1}: ${relativePath}\n\n`;
+        message += truncated;
+        message += `\n\n---\n\n`;
+    }
+
+    const filesEdited = new Set<string>();
+
+    const unsubscribe = await bus.subscribe(run.id, async (event) => {
+        if (event.type !== 'tool-invocation') {
+            return;
+        }
+        if (event.toolName !== 'workspace-edit') {
+            return;
+        }
+        try {
+            const parsed = JSON.parse(event.input) as { path?: string };
+            if (typeof parsed.path === 'string') {
+                filesEdited.add(parsed.path);
+            }
+        } catch {
+            // ignore parse errors
+        }
+    });
+
+    await createMessage(run.id, message);
+    await waitForRunCompletion(run.id);
+    unsubscribe();
+
+    return { runId: run.id, filesEdited };
+}
+
+/**
+ * Process all untagged notes in batches
+ */
+async function processUntaggedNotes(): Promise<void> {
+    console.log('[NoteTagging] Checking for untagged notes...');
+
+    const state = loadNoteTaggingState();
+    const untagged = getUntaggedNotes(state);
+
+    if (untagged.length === 0) {
+        console.log('[NoteTagging] No untagged notes found');
+        return;
+    }
+
+    console.log(`[NoteTagging] Found ${untagged.length} untagged notes`);
+
+    const run = await serviceLogger.startRun({
+        service: 'note_tagging',
+        message: `Tagging ${untagged.length} note${untagged.length === 1 ? '' : 's'}`,
+        trigger: 'timer',
+    });
+
+    const relativeFiles = untagged.map(f => path.relative(WorkDir, f));
+    const limitedFiles = limitEventItems(relativeFiles);
+    await serviceLogger.log({
+        type: 'changes_identified',
+        service: run.service,
+        runId: run.runId,
+        level: 'info',
+        message: `Found ${untagged.length} untagged note${untagged.length === 1 ? '' : 's'}`,
+        counts: { notes: untagged.length },
+        items: limitedFiles.items,
+        truncated: limitedFiles.truncated,
+    });
+
+    const totalBatches = Math.ceil(untagged.length / BATCH_SIZE);
+    let totalEdited = 0;
+    let hadError = false;
+
+    for (let i = 0; i < untagged.length; i += BATCH_SIZE) {
+        const batchPaths = untagged.slice(i, i + BATCH_SIZE);
+        const batchNumber = Math.floor(i / BATCH_SIZE) + 1;
+
+        try {
+            const files: { path: string; content: string }[] = [];
+            for (const filePath of batchPaths) {
+                try {
+                    const content = fs.readFileSync(filePath, 'utf-8');
+                    files.push({ path: filePath, content });
+                } catch (error) {
+                    console.error(`[NoteTagging] Error reading ${filePath}:`, error);
+                }
+            }
+
+            if (files.length === 0) {
+                continue;
+            }
+
+            console.log(`[NoteTagging] Processing batch ${batchNumber}/${totalBatches} (${files.length} files)`);
+            await serviceLogger.log({
+                type: 'progress',
+                service: run.service,
+                runId: run.runId,
+                level: 'info',
+                message: `Processing batch ${batchNumber}/${totalBatches} (${files.length} files)`,
+                step: 'batch',
+                current: batchNumber,
+                total: totalBatches,
+                details: { filesInBatch: files.length },
+            });
+
+            const result = await tagNoteBatch(files);
+            totalEdited += result.filesEdited.size;
+
+            // Only mark files that were actually edited by the agent
+            for (const file of files) {
+                const relativePath = path.relative(WorkDir, file.path);
+                if (result.filesEdited.has(relativePath)) {
+                    markNoteAsTagged(file.path, state);
+                }
+            }
+
+            saveNoteTaggingState(state);
+            console.log(`[NoteTagging] Batch ${batchNumber}/${totalBatches} complete, ${result.filesEdited.size} files tagged`);
+        } catch (error) {
+            hadError = true;
+            console.error(`[NoteTagging] Error processing batch ${batchNumber}:`, error);
+            await serviceLogger.log({
+                type: 'error',
+                service: run.service,
+                runId: run.runId,
+                level: 'error',
+                message: `Error processing batch ${batchNumber}`,
+                error: error instanceof Error ? error.message : String(error),
+                context: { batchNumber },
+            });
+        }
+    }
+
+    state.lastRunTime = new Date().toISOString();
+    saveNoteTaggingState(state);
+
+    await serviceLogger.log({
+        type: 'run_complete',
+        service: run.service,
+        runId: run.runId,
+        level: hadError ? 'error' : 'info',
+        message: `Note tagging complete: ${totalEdited} notes tagged`,
+        durationMs: Date.now() - run.startedAt,
+        outcome: hadError ? 'error' : 'ok',
+        summary: {
+            totalNotes: untagged.length,
+            notesTagged: totalEdited,
+        },
+    });
+
+    console.log(`[NoteTagging] Done. ${totalEdited} notes tagged.`);
+}
+
+/**
+ * Main entry point - runs as independent polling service
+ */
+export async function init() {
+    console.log('[NoteTagging] Starting Note Tagging Service...');
+    console.log(`[NoteTagging] Will check for untagged notes every ${SYNC_INTERVAL_MS / 1000} seconds`);
+
+    // Initial run
+    await processUntaggedNotes();
+
+    // Periodic polling
+    while (true) {
+        await new Promise(resolve => setTimeout(resolve, SYNC_INTERVAL_MS));
+
+        try {
+            await processUntaggedNotes();
+        } catch (error) {
+            console.error('[NoteTagging] Error in main loop:', error);
+        }
+    }
+}

apps/x/packages/core/src/knowledge/tag_system.ts

@@ -0,0 +1,230 @@
+import path from "path";
+import fs from "fs";
+import { WorkDir } from "../config/config.js";
+
+export type TagApplicability = 'email' | 'notes' | 'both';
+
+export type TagType =
+  | 'relationship'
+  | 'relationship-sub'
+  | 'topic'
+  | 'email-type'
+  | 'filter'
+  | 'action'
+  | 'status'
+  | 'source';
+
+export type NoteEffect = 'create' | 'skip' | 'none';
+
+export interface TagDefinition {
+  tag: string;
+  type: TagType;
+  applicability: TagApplicability;
+  description: string;
+  example?: string;
+  /** Whether an email with this tag should create notes ('create'), be skipped ('skip'), or has no effect on note creation ('none'). */
+  noteEffect?: NoteEffect;
+}
+
+// ── Default definitions (used to seed ~/.rowboat/config/tags.json) ──────────
+
+const DEFAULT_TAG_DEFINITIONS: TagDefinition[] = [
+  // ── Relationship (both) ──────────────────────────────────────────────
+  { tag: 'investor', type: 'relationship', applicability: 'both', noteEffect: 'create', description: 'Investors, VCs, or angels', example: 'Following up on our meeting — we\'d like to move forward with the Series A term sheet.' },
+  { tag: 'customer', type: 'relationship', applicability: 'both', noteEffect: 'create', description: 'Paying customers', example: 'We\'re seeing great results with Rowboat. Can we discuss expanding to more teams?' },
+  { tag: 'prospect', type: 'relationship', applicability: 'both', noteEffect: 'create', description: 'Potential customers', example: 'Thanks for the demo yesterday. We\'re interested in starting a pilot.' },
+  { tag: 'partner', type: 'relationship', applicability: 'both', noteEffect: 'create', description: 'Business partners', example: 'Let\'s discuss how we can promote the integration to both our user bases.' },
+  { tag: 'vendor', type: 'relationship', applicability: 'both', noteEffect: 'create', description: 'Service providers you work with', example: 'Here are the updated employment agreements you requested.' },
+  { tag: 'product', type: 'relationship', applicability: 'both', noteEffect: 'skip', description: 'Products or services you use (automated)', example: 'Your AWS bill for January 2025 is now available.' },
+  { tag: 'candidate', type: 'relationship', applicability: 'both', noteEffect: 'create', description: 'Job applicants', example: 'Thanks for reaching out. I\'d love to learn more about the engineering role.' },
+  { tag: 'team', type: 'relationship', applicability: 'both', noteEffect: 'create', description: 'Internal team members', example: 'Here\'s the updated roadmap for Q2. Let\'s discuss in our sync.' },
+  { tag: 'advisor', type: 'relationship', applicability: 'both', noteEffect: 'create', description: 'Advisors, mentors, or board members', example: 'I\'ve reviewed the deck. Here are my thoughts on the GTM strategy.' },
+  { tag: 'personal', type: 'relationship', applicability: 'both', noteEffect: 'create', description: 'Family or friends', example: 'Are you coming to Thanksgiving this year? Let me know your travel dates.' },
+  { tag: 'press', type: 'relationship', applicability: 'both', noteEffect: 'create', description: 'Journalists or media', example: 'I\'m writing a piece on AI agents. Would you be available for an interview?' },
+  { tag: 'community', type: 'relationship', applicability: 'both', noteEffect: 'create', description: 'Users, peers, or open source contributors', example: 'Love what you\'re building with Rowboat. Here\'s a bug I found...' },
+  { tag: 'government', type: 'relationship', applicability: 'both', noteEffect: 'create', description: 'Government agencies', example: 'Your Delaware franchise tax is due by March 1, 2025.' },
+
+  // ── Relationship Sub-Tags (notes only) ───────────────────────────────
+  { tag: 'primary', type: 'relationship-sub', applicability: 'notes', noteEffect: 'none', description: 'Main contact or decision maker', example: 'Sarah Chen — VP Engineering, your main point of contact at Acme.' },
+  { tag: 'secondary', type: 'relationship-sub', applicability: 'notes', noteEffect: 'none', description: 'Supporting contact, involved but not the lead', example: 'David Kim — Engineer CC\'d on customer emails.' },
+  { tag: 'executive-assistant', type: 'relationship-sub', applicability: 'notes', noteEffect: 'none', description: 'EA or admin handling scheduling and logistics', example: 'Lisa — Sarah\'s EA who schedules all her meetings.' },
+  { tag: 'cc', type: 'relationship-sub', applicability: 'notes', noteEffect: 'none', description: 'Person who\'s CC\'d but not actively engaged', example: 'Manager looped in for visibility on deal.' },
+  { tag: 'referred-by', type: 'relationship-sub', applicability: 'notes', noteEffect: 'none', description: 'Person who made an introduction or referral', example: 'David Park — Investor who intro\'d you to Sarah.' },
+  { tag: 'former', type: 'relationship-sub', applicability: 'notes', noteEffect: 'none', description: 'Previously held this relationship, no longer active', example: 'John — Former customer who churned last year.' },
+  { tag: 'champion', type: 'relationship-sub', applicability: 'notes', noteEffect: 'none', description: 'Internal advocate pushing for you', example: 'Engineer who loves your product and is selling internally.' },
+  { tag: 'blocker', type: 'relationship-sub', applicability: 'notes', noteEffect: 'none', description: 'Person opposing or blocking progress', example: 'CFO resistant to spending on new tools.' },
+
+  // ── Topic (both) ─────────────────────────────────────────────────────
+  { tag: 'sales', type: 'topic', applicability: 'both', noteEffect: 'create', description: 'Sales conversations, deals, and revenue', example: 'Here\'s the pricing proposal we discussed. Let me know if you have questions.' },
+  { tag: 'support', type: 'topic', applicability: 'both', noteEffect: 'create', description: 'Help requests, issues, and customer support', example: 'We\'re seeing an error when trying to export. Can you help?' },
+  { tag: 'legal', type: 'topic', applicability: 'both', noteEffect: 'create', description: 'Contracts, terms, compliance, and legal matters', example: 'Legal has reviewed the MSA. Attached are our requested changes.' },
+  { tag: 'finance', type: 'topic', applicability: 'both', noteEffect: 'create', description: 'Money, invoices, payments, banking, and taxes', example: 'Your invoice #1234 for $5,000 is attached. Payment due in 30 days.' },
+  { tag: 'hiring', type: 'topic', applicability: 'both', noteEffect: 'create', description: 'Recruiting, interviews, and employment', example: 'We\'d like to move forward with a final round interview. Are you available Thursday?' },
+  { tag: 'fundraising', type: 'topic', applicability: 'both', noteEffect: 'create', description: 'Raising money and investor relations', example: 'Thanks for sending the deck. We\'d like to schedule a partner meeting.' },
+  { tag: 'travel', type: 'topic', applicability: 'both', noteEffect: 'skip', description: 'Flights, hotels, trips, and travel logistics', example: 'Your flight to Tokyo on March 15 is confirmed. Confirmation #ABC123.' },
+  { tag: 'event', type: 'topic', applicability: 'both', noteEffect: 'create', description: 'Conferences, meetups, and gatherings', example: 'You\'re invited to speak at TechCrunch Disrupt. Can you confirm your availability?' },
+  { tag: 'shopping', type: 'topic', applicability: 'both', noteEffect: 'skip', description: 'Purchases, orders, and returns', example: 'Your order #12345 has shipped. Track it here.' },
+  { tag: 'health', type: 'topic', applicability: 'both', noteEffect: 'skip', description: 'Medical, wellness, and health-related matters', example: 'Your appointment with Dr. Smith is confirmed for Monday at 2pm.' },
+  { tag: 'learning', type: 'topic', applicability: 'both', noteEffect: 'skip', description: 'Courses, education, and skill-building', example: 'Welcome to the Advanced Python course. Here\'s your access link.' },
+  { tag: 'research', type: 'topic', applicability: 'both', noteEffect: 'create', description: 'Research requests and information gathering', example: 'Here\'s the market analysis you requested on the AI agent space.' },
+
+  // ── Email Type ───────────────────────────────────────────────────────
+  { tag: 'intro', type: 'email-type', applicability: 'both', noteEffect: 'create', description: 'Warm introduction from someone you know', example: 'I\'d like to introduce you to Sarah Chen, VP Engineering at Acme.' },
+  { tag: 'followup', type: 'email-type', applicability: 'both', noteEffect: 'create', description: 'Following up on a previous conversation', example: 'Following up on our call last week. Have you had a chance to review the proposal?' },
+  { tag: 'scheduling', type: 'email-type', applicability: 'email', noteEffect: 'skip', description: 'Meeting and calendar scheduling', example: 'Are you available for a call next Tuesday at 2pm?' },
+  { tag: 'cold-outreach', type: 'email-type', applicability: 'email', noteEffect: 'skip', description: 'Unsolicited contact from someone you don\'t know', example: 'Hi, I noticed your company is growing fast. I\'d love to show you how we can help with...' },
+  { tag: 'newsletter', type: 'email-type', applicability: 'email', noteEffect: 'skip', description: 'Newsletters, marketing emails, and subscriptions', example: 'This week in AI: The latest developments in agent frameworks...' },
+  { tag: 'notification', type: 'email-type', applicability: 'email', noteEffect: 'skip', description: 'Automated alerts, receipts, and system notifications', example: 'Your password was changed successfully. If this wasn\'t you, contact support.' },
+
+  // ── Filter (email only) ──────────────────────────────────────────────
+  { tag: 'spam', type: 'filter', applicability: 'email', noteEffect: 'skip', description: 'Junk and unwanted email', example: 'Congratulations! You\'ve won $1,000,000...' },
+  { tag: 'promotion', type: 'filter', applicability: 'email', noteEffect: 'skip', description: 'Marketing offers and sales pitches', example: '50% off all items this weekend only!' },
+  { tag: 'social', type: 'filter', applicability: 'email', noteEffect: 'skip', description: 'Social media notifications', example: 'John Smith commented on your post.' },
+  { tag: 'forums', type: 'filter', applicability: 'email', noteEffect: 'skip', description: 'Mailing lists and group discussions', example: 'Re: [dev-list] Question about API design' },
+
+  // ── Action ───────────────────────────────────────────────────────────
+  { tag: 'action-required', type: 'action', applicability: 'both', noteEffect: 'create', description: 'Needs a response or action from you', example: 'Can you send me the pricing by Friday?' },
+  { tag: 'fyi', type: 'action', applicability: 'email', noteEffect: 'skip', description: 'Informational only, no action needed', example: 'Just wanted to let you know the deal closed. Thanks for your help!' },
+  { tag: 'urgent', type: 'action', applicability: 'both', noteEffect: 'create', description: 'Time-sensitive, needs immediate attention', example: 'We need your signature on the contract by EOD today or we lose the deal.' },
+  { tag: 'waiting', type: 'action', applicability: 'both', noteEffect: 'create', description: 'Waiting on a response from them' },
+
+  // ── Status (email) ───────────────────────────────────────────────────
+  { tag: 'unread', type: 'status', applicability: 'email', noteEffect: 'none', description: 'Not yet processed' },
+  { tag: 'to-reply', type: 'status', applicability: 'email', noteEffect: 'none', description: 'Need to respond' },
+  { tag: 'done', type: 'status', applicability: 'email', noteEffect: 'none', description: 'Handled, can be archived' },
+
+  // ── Source (notes only) ──────────────────────────────────────────────
+  { tag: 'email', type: 'source', applicability: 'notes', noteEffect: 'none', description: 'Created or updated from email' },
+  { tag: 'meeting', type: 'source', applicability: 'notes', noteEffect: 'none', description: 'Created or updated from meeting transcript' },
+  { tag: 'browser', type: 'source', applicability: 'notes', noteEffect: 'none', description: 'Content captured from web browsing' },
+  { tag: 'web-search', type: 'source', applicability: 'notes', noteEffect: 'none', description: 'Information from web search' },
+  { tag: 'manual', type: 'source', applicability: 'notes', noteEffect: 'none', description: 'Manually entered by user' },
+  { tag: 'import', type: 'source', applicability: 'notes', noteEffect: 'none', description: 'Imported from another system' },
+
+  // ── Status (notes) ──────────────────────────────────────────────────
+  { tag: 'active', type: 'status', applicability: 'notes', noteEffect: 'none', description: 'Currently relevant, recent activity' },
+  { tag: 'archived', type: 'status', applicability: 'notes', noteEffect: 'none', description: 'No longer active, kept for reference' },
+  { tag: 'stale', type: 'status', applicability: 'notes', noteEffect: 'none', description: 'No activity in 60+ days, needs attention or archive' },
+];
+
+// ── Disk-backed config with mtime caching ──────────────────────────────────
+
+export const TAGS_CONFIG_PATH = path.join(WorkDir, "config", "tags.json");
+
+let cachedTagDefinitions: TagDefinition[] | null = null;
+let cachedMtimeMs: number | null = null;
+
+function ensureTagsConfigSync(): void {
+  if (!fs.existsSync(TAGS_CONFIG_PATH)) {
+    fs.writeFileSync(
+      TAGS_CONFIG_PATH,
+      JSON.stringify(DEFAULT_TAG_DEFINITIONS, null, 2) + "\n",
+      "utf8",
+    );
+  }
+}
+
+export function getTagDefinitions(): TagDefinition[] {
+  ensureTagsConfigSync();
+  try {
+    const stats = fs.statSync(TAGS_CONFIG_PATH);
+    if (cachedTagDefinitions && cachedMtimeMs === stats.mtimeMs) {
+      return cachedTagDefinitions;
+    }
+    const content = fs.readFileSync(TAGS_CONFIG_PATH, "utf8");
+    cachedTagDefinitions = JSON.parse(content);
+    cachedMtimeMs = stats.mtimeMs;
+    return cachedTagDefinitions!;
+  } catch {
+    cachedTagDefinitions = null;
+    cachedMtimeMs = null;
+    return DEFAULT_TAG_DEFINITIONS;
+  }
+}
+
+// ── Render helpers ───────────────────────────────────────────────────────
+
+const TYPE_ORDER: TagType[] = [
+  'relationship', 'relationship-sub', 'topic', 'email-type',
+  'filter', 'action', 'status', 'source',
+];
+
+const TYPE_LABELS: Record<TagType, string> = {
+  'relationship': 'Relationship',
+  'relationship-sub': 'Relationship Sub-Tags',
+  'topic': 'Topic',
+  'email-type': 'Email Type',
+  'filter': 'Filter',
+  'action': 'Action',
+  'status': 'Status',
+  'source': 'Source',
+};
+
+function renderTagGroups(tags: TagDefinition[]): string {
+  const groups = new Map<TagType, TagDefinition[]>();
+  for (const tag of tags) {
+    const list = groups.get(tag.type) ?? [];
+    list.push(tag);
+    groups.set(tag.type, list);
+  }
+
+  const sections: string[] = [];
+  for (const type of TYPE_ORDER) {
+    const group = groups.get(type);
+    if (!group || group.length === 0) continue;
+
+    const label = TYPE_LABELS[type];
+    const rows = group.map(t => {
+      const example = t.example ?? '';
+      return `| ${t.tag} | ${t.description} | ${example} |`;
+    });
+
+    sections.push(
+      `## ${label}\n\n` +
+      `| Tag | Description | Example |\n` +
+      `|-----|-------------|---------|\n` +
+      rows.join('\n'),
+    );
+  }
+
+  return `# Tag System Reference\n\n${sections.join('\n\n')}`;
+}
+
+export function renderNoteEffectRules(): string {
+  const tags = getTagDefinitions();
+  const skipByType = new Map<string, string[]>();
+  const createByType = new Map<string, string[]>();
+
+  for (const t of tags) {
+    const effect = t.noteEffect ?? 'none';
+    if (effect === 'none') continue;
+    const label = TYPE_LABELS[t.type] ?? t.type;
+    const map = effect === 'skip' ? skipByType : createByType;
+    const list = map.get(label) ?? [];
+    list.push(t.tag.split('-').map(w => w[0].toUpperCase() + w.slice(1)).join(' '));
+    map.set(label, list);
+  }
+
+  const formatList = (map: Map<string, string[]>) =>
+    Array.from(map.entries()).map(([type, tags]) => `- **${type}:** ${tags.join(', ')}`).join('\n');
+
+  return [
+    `**SKIP if the email has ANY of these labels (skip labels override everything):**`,
+    formatList(skipByType),
+    ``,
+    `**CREATE/UPDATE notes if the email has ANY of these labels (and no skip labels present):**`,
+    formatList(createByType),
+    ``,
+    `**Logic:** If even one label falls in the "skip" list, skip the email — skip labels are hard filters that override create labels.`,
+  ].join('\n');
+}
+
+export function renderTagSystemForNotes(): string {
+  const tags = getTagDefinitions().filter(t => t.applicability !== 'email');
+  return renderTagGroups(tags);
+}
+
+export function renderTagSystemForEmails(): string {
+  const tags = getTagDefinitions().filter(t => t.applicability !== 'notes');
+  return renderTagGroups(tags);
+}

apps/x/packages/core/src/mcp/repo.ts

@@ -5,10 +5,6 @@ import path from "path";
 import z from "zod";
 
 const DEFAULT_MCP_SERVERS = {
-    exa: {
-        type: "http" as const,
-        url: "https://mcp.exa.ai/mcp",
-    },
 };
 
 export interface IMcpConfigRepo {

apps/x/packages/core/src/models/gateway.ts

@@ -0,0 +1,41 @@
+import { ProviderV2 } from '@ai-sdk/provider';
+import { createOpenRouter } from '@openrouter/ai-sdk-provider';
+import { getAccessToken } from '../auth/tokens.js';
+import { API_URL } from '../config/env.js';
+
+export async function getGatewayProvider(): Promise<ProviderV2> {
+    const accessToken = await getAccessToken();
+    return createOpenRouter({
+        baseURL: `${API_URL}/v1/llm`,
+        apiKey: accessToken,
+    });
+}
+
+type ProviderSummary = {
+    id: string;
+    name: string;
+    models: Array<{
+        id: string;
+        name?: string;
+        release_date?: string;
+    }>;
+};
+
+export async function listGatewayModels(): Promise<{ providers: ProviderSummary[] }> {
+    const accessToken = await getAccessToken();
+    const response = await fetch(`${API_URL}/v1/llm/models`, {
+        headers: { Authorization: `Bearer ${accessToken}` },
+    });
+    if (!response.ok) {
+        throw new Error(`Gateway /v1/models failed: ${response.status}`);
+    }
+    const body = await response.json() as { data: Array<{ id: string }> };
+    const models = body.data.map((m) => ({ id: m.id }));
+    return {
+        providers: [{
+            id: 'rowboat',
+            name: 'Rowboat',
+            models,
+        }],
+    };
+}

apps/x/packages/core/src/models/models.ts

@@ -8,6 +8,8 @@ import { createOpenRouter } from '@openrouter/ai-sdk-provider';
 import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
 import { LlmModelConfig, LlmProvider } from "@x/shared/dist/models.js";
 import z from "zod";
+import { isSignedIn } from "../account/account.js";
+import { getGatewayProvider } from "./gateway.js";
 
 export const Provider = LlmProvider;
 export const ModelConfig = LlmModelConfig;
@@ -62,7 +64,7 @@ export function createProvider(config: z.infer<typeof Provider>): ProviderV2 {
                 apiKey,
                 baseURL,
                 headers,
-            });
+            }) as unknown as ProviderV2;
         default:
             throw new Error(`Unsupported provider flavor: ${config.flavor}`);
     }
@@ -78,7 +80,9 @@ export async function testModelConnection(
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), effectiveTimeout);
     try {
-        const provider = createProvider(providerConfig);
+        const provider = await isSignedIn()
+            ? await getGatewayProvider()
+            : createProvider(providerConfig);
         const languageModel = provider.languageModel(model);
         await generateText({
             model: languageModel,

apps/x/packages/core/src/models/repo.ts

@@ -51,6 +51,7 @@ export class FSModelConfigRepo implements IModelConfigRepo {
             model: config.model,
             models: config.models,
             knowledgeGraphModel: config.knowledgeGraphModel,
+            meetingNotesModel: config.meetingNotesModel,
         };
 
         const toWrite = { ...config, providers: existingProviders };

apps/x/packages/core/src/runs/runs.ts

@@ -1,6 +1,6 @@
 import z from "zod";
 import container from "../di/container.js";
-import { IMessageQueue, UserMessageContentType } from "../application/lib/message-queue.js";
+import { IMessageQueue, UserMessageContentType, VoiceOutputMode } from "../application/lib/message-queue.js";
 import { AskHumanResponseEvent, ToolPermissionRequestEvent, ToolPermissionResponseEvent, CreateRunOptions, Run, ListRunsResponse, ToolPermissionAuthorizePayload, AskHumanResponsePayload } from "@x/shared/dist/runs.js";
 import { IRunsRepo } from "./repo.js";
 import { IAgentRuntime } from "../agents/runtime.js";
@@ -19,9 +19,9 @@ export async function createRun(opts: z.infer<typeof CreateRunOptions>): Promise
     return run;
 }
 
-export async function createMessage(runId: string, message: UserMessageContentType): Promise<string> {
+export async function createMessage(runId: string, message: UserMessageContentType, voiceInput?: boolean, voiceOutput?: VoiceOutputMode, searchEnabled?: boolean): Promise<string> {
     const queue = container.resolve<IMessageQueue>('messageQueue');
-    const id = await queue.enqueue(runId, message);
+    const id = await queue.enqueue(runId, message, voiceInput, voiceOutput, searchEnabled);
     const runtime = container.resolve<IAgentRuntime>('agentRuntime');
     runtime.trigger(runId);
     return id;

apps/x/packages/core/src/slack/repo.ts

@@ -0,0 +1,41 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { WorkDir } from '../config/config.js';
+import { SlackConfig } from './types.js';
+
+export interface ISlackConfigRepo {
+    getConfig(): Promise<SlackConfig>;
+    setConfig(config: SlackConfig): Promise<void>;
+}
+
+export class FSSlackConfigRepo implements ISlackConfigRepo {
+    private readonly configPath = path.join(WorkDir, 'config', 'slack.json');
+    private readonly defaultConfig: SlackConfig = { enabled: false, workspaces: [] };
+
+    constructor() {
+        this.ensureConfigFile();
+    }
+
+    private async ensureConfigFile(): Promise<void> {
+        try {
+            await fs.access(this.configPath);
+        } catch {
+            await fs.writeFile(this.configPath, JSON.stringify(this.defaultConfig, null, 2));
+        }
+    }
+
+    async getConfig(): Promise<SlackConfig> {
+        try {
+            const content = await fs.readFile(this.configPath, 'utf8');
+            const parsed = JSON.parse(content);
+            return SlackConfig.parse(parsed);
+        } catch {
+            return this.defaultConfig;
+        }
+    }
+
+    async setConfig(config: SlackConfig): Promise<void> {
+        const validated = SlackConfig.parse(config);
+        await fs.writeFile(this.configPath, JSON.stringify(validated, null, 2));
+    }
+}

apps/x/packages/core/src/slack/types.ts

@@ -0,0 +1,13 @@
+import z from "zod";
+
+export const SlackWorkspace = z.object({
+    url: z.string(),
+    name: z.string(),
+});
+export type SlackWorkspace = z.infer<typeof SlackWorkspace>;
+
+export const SlackConfig = z.object({
+    enabled: z.boolean(),
+    workspaces: z.array(SlackWorkspace).default([]),
+});
+export type SlackConfig = z.infer<typeof SlackConfig>;

apps/x/packages/core/src/voice/voice.ts

@@ -0,0 +1,88 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { isSignedIn } from '../account/account.js';
+import { getAccessToken } from '../auth/tokens.js';
+import { API_URL } from '../config/env.js';
+
+const homedir = process.env.HOME || process.env.USERPROFILE || '';
+
+export interface VoiceConfig {
+    deepgram: { apiKey: string } | null;
+    elevenlabs: { apiKey: string; voiceId?: string } | null;
+}
+
+async function readJsonConfig(filename: string): Promise<Record<string, unknown> | null> {
+    try {
+        const configPath = path.join(homedir, '.rowboat', 'config', filename);
+        const raw = await fs.readFile(configPath, 'utf8');
+        return JSON.parse(raw);
+    } catch {
+        return null;
+    }
+}
+
+export async function getVoiceConfig(): Promise<VoiceConfig> {
+    const dgConfig = await readJsonConfig('deepgram.json');
+    const elConfig = await readJsonConfig('elevenlabs.json');
+
+    return {
+        deepgram: dgConfig?.apiKey ? { apiKey: dgConfig.apiKey as string } : null,
+        elevenlabs: elConfig?.apiKey
+            ? { apiKey: elConfig.apiKey as string, voiceId: elConfig.voiceId as string | undefined }
+            : null,
+    };
+}
+
+export async function synthesizeSpeech(text: string): Promise<{ audioBase64: string; mimeType: string }> {
+    const config = await getVoiceConfig();
+    const signedIn = await isSignedIn();
+
+    let url: string;
+    let headers: Record<string, string>;
+
+    if (signedIn) {
+        const voiceId = config.elevenlabs?.voiceId || 'UgBBYS2sOqTuMpoF3BR0';
+        const accessToken = await getAccessToken();
+        url = `${API_URL}/v1/voice/text-to-speech/${voiceId}`;
+        headers = {
+            'Authorization': `Bearer ${accessToken}`,
+            'Content-Type': 'application/json',
+        };
+        console.log('[voice] synthesizing speech via Rowboat proxy, text length:', text.length, 'voiceId:', voiceId);
+    } else {
+        if (!config.elevenlabs) {
+            throw new Error('ElevenLabs not configured. Create ~/.rowboat/config/elevenlabs.json with { "apiKey": "<your-key>" }');
+        }
+        const voiceId = config.elevenlabs.voiceId || 'UgBBYS2sOqTuMpoF3BR0';
+        url = `https://api.elevenlabs.io/v1/text-to-speech/${voiceId}`;
+        headers = {
+            'xi-api-key': config.elevenlabs.apiKey,
+            'Content-Type': 'application/json',
+        };
+        console.log('[voice] synthesizing speech via ElevenLabs, text length:', text.length, 'voiceId:', voiceId);
+    }
+
+    const response = await fetch(url, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({
+            text,
+            model_id: 'eleven_flash_v2_5',
+            voice_settings: {
+                stability: 0.5,
+                similarity_boost: 0.75,
+            },
+        }),
+    });
+
+    if (!response.ok) {
+        const errText = await response.text().catch(() => 'Unknown error');
+        console.error('[voice] TTS API error:', response.status, errText);
+        throw new Error(`TTS API error ${response.status}: ${errText}`);
+    }
+
+    const arrayBuffer = await response.arrayBuffer();
+    const audioBase64 = Buffer.from(arrayBuffer).toString('base64');
+    console.log('[voice] synthesized audio, base64 length:', audioBase64.length);
+    return { audioBase64, mimeType: 'audio/mpeg' };
+}