@memoraone/mcp 0.1.5 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memoraone/mcp",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -12,18 +12,19 @@
   "publishConfig": {
     "access": "public"
   },
+  "scripts": {
+    "build": "tsup",
+    "prepublishOnly": "pnpm run build",
+    "dev": "tsx src/index.ts",
+    "lint": "eslint ."
+  },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.1",
     "dotenv": "^16.4.5",
-    "node-fetch": "2.7.0",
     "zod": "^4.0.0"
   },
   "devDependencies": {
+    "tsup": "^8.5.1",
     "typescript": "^5.9.2"
-  },
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "dev": "tsx src/index.ts",
-    "lint": "eslint ."
   }
-}
+}

package/dist/cli.js

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-/* eslint-env node */
-/* global console, process */
-// CLI entrypoint for npx @memoraone/mcp
-import './index.js';

package/dist/client/memoraClient.js

@@ -1,58 +0,0 @@
-async function requestJson(url, method, headers, body) {
-    const { default: fetch } = await import('node-fetch');
-    const res = await fetch(url, {
-        method,
-        headers,
-        body: body === undefined ? undefined : JSON.stringify(body ?? {}),
-    });
-    const text = await res.text();
-    return {
-        status: res.status,
-        statusText: res.statusText,
-        ok: res.ok,
-        text,
-    };
-}
-export class MemoraOneHttpError extends Error {
-    constructor(status, statusText, body) {
-        super(`MemoraOne request failed: ${status} ${statusText}`);
-        this.name = 'MemoraOneHttpError';
-        this.status = status;
-        this.body = body;
-    }
-}
-export class MemoraClient {
-    constructor(cfg) {
-        this.baseUrl = cfg.apiUrl;
-        this.apiKey = cfg.apiKey;
-    }
-    buildHeaders(options) {
-        const headers = {
-            'content-type': 'application/json',
-            'x-api-key': this.apiKey,
-            ...(options?.headers ?? {}),
-        };
-        if (options?.projectId) {
-            headers['x-memora-project-id'] = options.projectId;
-        }
-        return headers;
-    }
-    async post(path, body, options) {
-        const url = `${this.baseUrl}${path.startsWith('/') ? path : `/${path}`}`;
-        process.stderr.write(`[memoraone-mcp] http url=${url} apiKeyPrefix=${String(this.apiKey).slice(0, 8)} apiKeyLen=${String(this.apiKey).length}\n`);
-        const res = await requestJson(url, 'POST', this.buildHeaders(options), body);
-        if (!res.ok) {
-            throw new MemoraOneHttpError(res.status, res.statusText, res.text);
-        }
-        return res.text ? JSON.parse(res.text) : null;
-    }
-    async get(path, options) {
-        const url = `${this.baseUrl}${path.startsWith('/') ? path : `/${path}`}`;
-        const res = await requestJson(url, 'GET', this.buildHeaders(options));
-        if (!res.ok) {
-            throw new MemoraOneHttpError(res.status, res.statusText, res.text);
-        }
-        return res.text ? JSON.parse(res.text) : null;
-    }
-}
-export default MemoraClient;

package/dist/config.js

@@ -1,68 +0,0 @@
-//packages/mcp/src/config.ts
-import * as process from 'node:process';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { z } from 'zod/v4';
-import { resolveApiUrl } from './configUtils.js';
-const dotenvPath = path.resolve(process.cwd(), '.env');
-if (fs.existsSync(dotenvPath)) {
-    try {
-        const { config: loadDotEnv } = await import('dotenv');
-        loadDotEnv({ path: dotenvPath });
-    }
-    catch (err) {
-        process.stderr.write('[memoraone-mcp] Failed to load .env: ' + String(err) + '\n');
-    }
-}
-const EnvSchema = z.object({
-    MEMORAONE_API_URL: z.string().url().optional(),
-    MEMORAONE_API_KEY: z.string().min(1),
-    MEMORAONE_DEV_MODE: z.string().min(1).optional(),
-    MEMORAONE_AGENT_NAME: z.string().min(1).optional(),
-    MEMORAONE_AGENT_TYPE: z.string().min(1).optional(),
-    MEMORAONE_SOURCE: z.string().min(1).optional(),
-    MEMORAONE_WORKLOG: z.string().min(1).optional(),
-    MEMORAONE_HEARTBEAT: z.string().min(1).optional(),
-    MEMORAONE_HEARTBEAT_INTERVAL_MS: z.string().min(1).optional(),
-});
-const requiredEnvVars = ['MEMORAONE_API_KEY'];
-const missingEnvVars = requiredEnvVars.filter((key) => {
-    const value = process.env[key];
-    return value === undefined || value.trim() === '';
-});
-if (missingEnvVars.length > 0) {
-    for (const key of missingEnvVars) {
-        process.stderr.write(`Missing ${key}\n`);
-    }
-    process.exit(1);
-}
-const parsed = EnvSchema.safeParse(process.env);
-const resolvedApiUrl = resolveApiUrl(process.env);
-if (!parsed.success) {
-    const formatted = parsed.error.format();
-    process.stderr.write('[memoraone-mcp] Invalid environment variables ' + JSON.stringify(formatted) + '\n');
-    throw new Error('Config validation failed');
-}
-const parseBooleanFlag = (value, defaultValue) => {
-    if (value === undefined) {
-        return defaultValue;
-    }
-    const normalized = value.trim().toLowerCase();
-    if (['1', 'true', 'yes', 'on'].includes(normalized)) {
-        return true;
-    }
-    if (['0', 'false', 'no', 'off'].includes(normalized)) {
-        return false;
-    }
-    return defaultValue;
-};
-export const config = {
-    apiUrl: resolvedApiUrl.replace(/\/+$/, ''),
-    apiKey: parsed.data.MEMORAONE_API_KEY,
-    agentName: parsed.data.MEMORAONE_AGENT_NAME ?? 'cursor',
-    agentType: parsed.data.MEMORAONE_AGENT_TYPE ?? 'agent',
-    source: parsed.data.MEMORAONE_SOURCE ?? 'cursor',
-    worklogEnabled: parseBooleanFlag(parsed.data.MEMORAONE_WORKLOG, true),
-    heartbeatEnabled: parseBooleanFlag(parsed.data.MEMORAONE_HEARTBEAT, true),
-    heartbeatIntervalMs: Number.parseInt(parsed.data.MEMORAONE_HEARTBEAT_INTERVAL_MS ?? '30000', 10),
-};

package/dist/configUtils.js

@@ -1,13 +0,0 @@
-//packages/mcp/src/configUtils.ts
-export const DEFAULT_API_URL = 'https://api.memoraone.com';
-export const DEV_API_URL = 'http://localhost:3001';
-export function resolveApiUrl(env) {
-    const explicitUrl = env.MEMORAONE_API_URL?.trim();
-    if (explicitUrl) {
-        return explicitUrl;
-    }
-    if (env.MEMORAONE_DEV_MODE === '1') {
-        return DEV_API_URL;
-    }
-    return DEFAULT_API_URL;
-}

package/dist/index.js

@@ -1,265 +0,0 @@
-#!/usr/bin/env node
-/* eslint-env node */
-/* global console, process */
-// packages/mcp/src/index.ts
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { config } from './config.js';
-import MemoraClient from './client/memoraClient.js';
-import { postEventShape } from './tools/postEvent.js';
-import { askWithMemoryShape } from './tools/askWithMemory.js';
-import { logIntentShape } from './tools/logIntent.js';
-import { logChangeSummaryShape } from './tools/logChangeSummary.js';
-import { logToolResultShape } from './tools/logToolResult.js';
-import { logCommandShape } from './tools/logCommand.js';
-import { listProjectsShape } from './tools/listProjects.js';
-import { setProjectShape } from './tools/setProject.js';
-import { handlePostEvent } from './tools/handlers/postEvent.js';
-import { handleAskWithMemory } from './tools/handlers/askWithMemory.js';
-import { handleLogIntent } from './tools/handlers/logIntent.js';
-import { handleLogChangeSummary } from './tools/handlers/logChangeSummary.js';
-import { handleLogToolResult } from './tools/handlers/logToolResult.js';
-import { handleLogCommand } from './tools/handlers/logCommand.js';
-import { handleListProjects } from './tools/handlers/listProjects.js';
-import { handleSetProject } from './tools/handlers/setProject.js';
-import { getCurrentProjectId } from './runContext.js';
-async function sendHeartbeat(client) {
-    try {
-        await client.post('/admin/api-keys/heartbeat', {});
-    }
-    catch (err) {
-        console.error('[memoraone-mcp] heartbeat error (silent)', err);
-    }
-}
-function redactSensitiveFields(obj) {
-    if (obj === null || obj === undefined) {
-        return obj;
-    }
-    if (typeof obj !== 'object') {
-        return obj;
-    }
-    if (Array.isArray(obj)) {
-        return obj.map(redactSensitiveFields);
-    }
-    const redacted = {};
-    const sensitiveKeys = /^(headers?|api[_-]?key|token|cookie|authorization|auth|password|secret|credential|bearer)$/i;
-    for (const [key, value] of Object.entries(obj)) {
-        if (sensitiveKeys.test(key)) {
-            redacted[key] = '[REDACTED]';
-        }
-        else if (typeof value === 'object') {
-            redacted[key] = redactSensitiveFields(value);
-        }
-        else {
-            redacted[key] = value;
-        }
-    }
-    return redacted;
-}
-function sanitizeArgsSummary(args) {
-    try {
-        const redacted = redactSensitiveFields(args);
-        const summary = JSON.stringify(redacted);
-        return summary.length > 200 ? summary.slice(0, 200) + '...' : summary;
-    }
-    catch {
-        return '[unable to serialize args]';
-    }
-}
-async function postWorklogEvent(client, message) {
-    try {
-        const projectId = getCurrentProjectId();
-        if (!projectId) {
-            return;
-        }
-        const body = {
-            kind: 'note',
-            concept: 'concept:worklog',
-            actor: { type: config.agentType, name: config.agentName },
-            message,
-            metadata: {
-                source: config.source,
-                purpose: 'worklog',
-            },
-        };
-        await client.post('/timeline/events', body, { projectId });
-    }
-    catch (err) {
-        console.error('[memoraone-mcp] worklog error (silent)', err);
-    }
-}
-function registerToolWithWorklog(server, client, toolName, description, schema, handler) {
-    if (!config.worklogEnabled) {
-        server.tool(toolName, description, schema, handler);
-        return;
-    }
-    server.tool(toolName, description, schema, async (args) => {
-        const argsSummary = sanitizeArgsSummary(args);
-        const start = Date.now();
-        await postWorklogEvent(client, `tool_start: ${toolName} ${argsSummary}`);
-        try {
-            const result = await handler(args);
-            const durationMs = Date.now() - start;
-            await postWorklogEvent(client, `tool_end: ${toolName} ok (${durationMs}ms)`);
-            return result;
-        }
-        catch (err) {
-            const durationMs = Date.now() - start;
-            const errorSummary = err?.message || String(err);
-            const shortError = errorSummary.length > 100 ? errorSummary.slice(0, 100) + '...' : errorSummary;
-            await postWorklogEvent(client, `tool_end: ${toolName} error (${durationMs}ms): ${shortError}`);
-            throw err;
-        }
-    });
-}
-async function main() {
-    const client = new MemoraClient(config);
-    // Log agent identity (no secrets)
-    console.error(`[memoraone-mcp] Agent identity: name="${config.agentName}", type="${config.agentType}", source="${config.source}"`);
-    const server = new McpServer({
-        name: 'memoraone-vscode-mcp',
-        version: '1.0.0',
-    });
-    // Track tool names for diagnostic logging
-    const registeredToolNames = [];
-    // ---- memora_post_event ----
-    registeredToolNames.push('memora_post_event');
-    registerToolWithWorklog(server, client, 'memora_post_event', 'Forward an event to MemoraOne timeline', postEventShape, async (args) => {
-        const result = await handlePostEvent(client, args);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(result),
-                },
-            ],
-        };
-    });
-    // ---- memora_list_projects ----
-    registeredToolNames.push('memora_list_projects');
-    server.tool('memora_list_projects', 'List projects available to the current API key', listProjectsShape, async () => {
-        const result = await handleListProjects(client);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(result),
-                },
-            ],
-        };
-    });
-    // ---- memora_set_project ----
-    registeredToolNames.push('memora_set_project');
-    server.tool('memora_set_project', 'Set the current project id for subsequent tool calls', setProjectShape, async (args) => {
-        const result = await handleSetProject(args);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(result),
-                },
-            ],
-        };
-    });
-    // ---- memora_ask_with_memory ----
-    registeredToolNames.push('memora_ask_with_memory');
-    registerToolWithWorklog(server, client, 'memora_ask_with_memory', 'Ask MemoraOne with project memory context', askWithMemoryShape, async (args) => {
-        const result = await handleAskWithMemory(client, args);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(result),
-                },
-            ],
-        };
-    });
-    // ---- memora_log_intent ----
-    registeredToolNames.push('memora_log_intent');
-    registerToolWithWorklog(server, client, 'memora_log_intent', 'Log a natural-language TASK or DECISION intent to the MemoraOne timeline', logIntentShape, async (args) => {
-        const result = await handleLogIntent(client, args);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(result),
-                },
-            ],
-        };
-    });
-    // ---- memora_log_change_summary ----
-    registeredToolNames.push('memora_log_change_summary');
-    registerToolWithWorklog(server, client, 'memora_log_change_summary', 'Log a concise code change summary to the MemoraOne timeline', logChangeSummaryShape, async (args) => {
-        const result = await handleLogChangeSummary(client, args);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(result),
-                },
-            ],
-        };
-    });
-    // ---- memora_log_tool_result ----
-    registeredToolNames.push('memora_log_tool_result');
-    registerToolWithWorklog(server, client, 'memora_log_tool_result', 'Log a tool execution result to the MemoraOne timeline', logToolResultShape, async (args) => {
-        const result = await handleLogToolResult(client, args);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(result),
-                },
-            ],
-        };
-    });
-    // ---- memora_log_command ----
-    registeredToolNames.push('memora_log_command');
-    registerToolWithWorklog(server, client, 'memora_log_command', 'Log a command execution to the MemoraOne timeline', logCommandShape, async (args) => {
-        const result = await handleLogCommand(client, args);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(result),
-                },
-            ],
-        };
-    });
-    console.error('[memoraone-vscode-mcp] Starting MCP server with', registeredToolNames.length, 'tools');
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    let heartbeatInterval = null;
-    if (config.heartbeatEnabled) {
-        if (globalThis.__memoraHeartbeatInterval) {
-            clearInterval(globalThis.__memoraHeartbeatInterval);
-        }
-        await sendHeartbeat(client);
-        const intervalMs = Number.isFinite(config.heartbeatIntervalMs)
-            ? Math.max(1000, config.heartbeatIntervalMs)
-            : 30000;
-        heartbeatInterval = setInterval(() => {
-            sendHeartbeat(client).catch(() => {
-                // Errors already logged in sendHeartbeat
-            });
-        }, intervalMs);
-        globalThis.__memoraHeartbeatInterval = heartbeatInterval;
-    }
-    const shutdown = (signal) => {
-        if (heartbeatInterval) {
-            clearInterval(heartbeatInterval);
-        }
-        if (globalThis.__memoraHeartbeatInterval) {
-            clearInterval(globalThis.__memoraHeartbeatInterval);
-        }
-        console.error(`[memoraone-vscode-mcp] Received ${signal}, shutting down`);
-        process.exit(0);
-    };
-    process.on('SIGINT', () => shutdown('SIGINT'));
-    process.on('SIGTERM', () => shutdown('SIGTERM'));
-    console.error('[memoraone-vscode-mcp] MCP server ready');
-}
-main().catch((err) => {
-    console.error('[memoraone-vscode-mcp] fatal error', err);
-    process.exit(1);
-});

package/dist/runContext.js

@@ -1,25 +0,0 @@
-// packages/mcp/src/runContext.ts
-import * as crypto from 'crypto';
-let currentRunId = null;
-let currentProjectId = null;
-export function getCurrentRunId() {
-    return currentRunId;
-}
-export function setCurrentRunId(id) {
-    currentRunId = id;
-}
-export function getCurrentProjectId() {
-    return currentProjectId;
-}
-export function setCurrentProjectId(id) {
-    currentProjectId = id;
-}
-export function resolveRunId(passed) {
-    if (passed) {
-        return passed;
-    }
-    return currentRunId;
-}
-export function generateRunId() {
-    return crypto.randomBytes(16).toString('hex');
-}

package/dist/tools/askWithMemory.js

@@ -1,12 +0,0 @@
-//memoraone/adapters/vscode-mcp/src/tools/askWithMemory.ts
-import { z } from 'zod/v4';
-export const askWithMemoryShape = {
-    question: z.string().min(1),
-    code_context: z
-        .object({
-        file_path: z.string().optional(),
-        selected_text: z.string().optional(),
-        language: z.string().optional(),
-    })
-        .optional(),
-};

package/dist/tools/handlers/askWithMemory.js

@@ -1,43 +0,0 @@
-//memoraone/adapters/vscode-mcp/src/tools/handlers/askWithMemory.ts
-import { z } from 'zod/v4';
-import { getCurrentProjectId } from '../../runContext.js';
-const askWithMemoryInputSchema = z.object({
-    question: z.string().min(1),
-    code_context: z
-        .object({
-        file_path: z.string().optional(),
-        selected_text: z.string().optional(),
-        language: z.string().optional(),
-    })
-        .optional(),
-});
-function isAskWithMemoryResponse(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        typeof value.answer === 'string' &&
-        value.answer !== '');
-}
-export async function handleAskWithMemory(client, args) {
-    const parsed = askWithMemoryInputSchema.parse(args ?? {});
-    const projectId = getCurrentProjectId();
-    if (!projectId) {
-        throw new Error('No project selected. Use memora_list_projects and memora_set_project to select a project.');
-    }
-    const payload = {
-        question: parsed.question,
-    };
-    if (parsed.code_context) {
-        payload.code_context = parsed.code_context;
-    }
-    const res = await client.post('/agent/ask-with-memory', payload, { projectId });
-    if (!isAskWithMemoryResponse(res)) {
-        const err = new Error('Unexpected response from MemoraOne');
-        err.status = 502;
-        err.body = res;
-        throw err;
-    }
-    return {
-        answer: res.answer,
-        used: res.used ?? {},
-    };
-}

package/dist/tools/handlers/listProjects.js

@@ -1,4 +0,0 @@
-export async function handleListProjects(client) {
-    const res = await client.get('/admin/projects');
-    return res ?? { items: [] };
-}

package/dist/tools/handlers/logChangeSummary.js

@@ -1,48 +0,0 @@
-//packages/mcp/src/tools/handlers/logChangeSummary.ts
-import { z } from 'zod/v4';
-import { getCurrentProjectId, resolveRunId } from '../../runContext.js';
-import { config } from '../../config.js';
-const logChangeSummaryInputSchema = z.object({
-    summary: z.string().min(1),
-    scope: z.string().min(1).optional(),
-    files: z.array(z.string().min(1)).optional(),
-    stats: z
-        .object({
-        files: z.number().int().nonnegative().optional(),
-        add: z.number().int().nonnegative().optional(),
-        del: z.number().int().nonnegative().optional(),
-    })
-        .optional(),
-    commit: z.string().min(1).optional(),
-    run_id: z.string().min(1).optional(),
-});
-export async function handleLogChangeSummary(client, args) {
-    const parsed = logChangeSummaryInputSchema.parse(args ?? {});
-    const projectId = getCurrentProjectId();
-    if (!projectId) {
-        throw new Error('No project selected. Use memora_list_projects and memora_set_project to select a project.');
-    }
-    const { summary, scope, files, stats, commit } = parsed;
-    const message = summary.startsWith('CHANGE:')
-        ? summary
-        : `CHANGE: ${scope ?? 'code'} — ${summary}`;
-    const run_id = resolveRunId(parsed.run_id);
-    const body = {
-        kind: 'note',
-        concept: 'concept:change_summary',
-        actor: { type: config.agentType, name: config.agentName },
-        message,
-        metadata: {
-            source: config.source,
-            purpose: 'change_summary',
-            tool: 'memora_log_change_summary',
-            ...(scope ? { scope } : {}),
-            ...(files ? { files } : {}),
-            ...(stats ? { stats } : {}),
-            ...(commit ? { commit } : {}),
-            ...(run_id ? { run_id } : {}),
-        },
-    };
-    await client.post('/timeline/events', body, { projectId });
-    return { ok: true };
-}

package/dist/tools/handlers/logCommand.js

@@ -1,44 +0,0 @@
-//packages/mcp/src/tools/handlers/logCommand.ts
-import { z } from 'zod/v4';
-import { getCurrentProjectId, resolveRunId } from '../../runContext.js';
-import { config } from '../../config.js';
-const logCommandInputSchema = z.object({
-    cmd: z.string().min(1),
-    summary: z.string().min(1),
-    cwd: z.string().min(1).optional(),
-    exit_code: z.number().int().optional(),
-    duration_ms: z.number().int().nonnegative().optional(),
-    run_id: z.string().min(1).optional(),
-    stats: z.record(z.string(), z.any()).optional(),
-});
-export async function handleLogCommand(client, args) {
-    const parsed = logCommandInputSchema.parse(args ?? {});
-    const projectId = getCurrentProjectId();
-    if (!projectId) {
-        throw new Error('No project selected. Use memora_list_projects and memora_set_project to select a project.');
-    }
-    const { cmd, summary, cwd, exit_code, duration_ms, stats } = parsed;
-    const message = summary.startsWith('COMMAND:')
-        ? summary
-        : `COMMAND: ${cmd} — ${summary}`;
-    const run_id = resolveRunId(parsed.run_id);
-    const body = {
-        kind: 'note',
-        concept: 'concept:command',
-        actor: { type: config.agentType, name: config.agentName },
-        message,
-        metadata: {
-            source: config.source,
-            purpose: 'command',
-            tool: 'memora_log_command',
-            cmd,
-            ...(cwd ? { cwd } : {}),
-            ...(exit_code !== undefined ? { exit_code } : {}),
-            ...(duration_ms !== undefined ? { duration_ms } : {}),
-            ...(run_id ? { run_id } : {}),
-            ...(stats ? { stats } : {}),
-        },
-    };
-    await client.post('/timeline/events', body, { projectId });
-    return { ok: true };
-}

package/dist/tools/handlers/logIntent.js

@@ -1,46 +0,0 @@
-//packages/mcp/src/tools/handlers/logIntent.ts
-import { z } from 'zod/v4';
-import { generateRunId, getCurrentProjectId, setCurrentRunId } from '../../runContext.js';
-import { config } from '../../config.js';
-const logIntentInputSchema = z.object({
-    intent: z.enum(['task', 'decision']),
-    message: z.string().min(1),
-    context: z.record(z.string(), z.any()).optional(),
-    intent_source: z.string().optional().default('cursor_chat'),
-    run_id: z.string().min(1).optional(),
-});
-export async function handleLogIntent(client, args) {
-    const parsed = logIntentInputSchema.parse(args ?? {});
-    const projectId = getCurrentProjectId();
-    if (!projectId) {
-        throw new Error('No project selected. Use memora_list_projects and memora_set_project to select a project.');
-    }
-    const intent = parsed.intent;
-    const message = parsed.message.trim();
-    if (!message) {
-        throw new Error('message cannot be empty after trimming');
-    }
-    const intent_source = parsed.intent_source ?? 'cursor_chat';
-    const context = parsed.context;
-    const purpose = intent; // 'task' | 'decision'
-    const concept = purpose === 'task' ? 'concept:task' : 'concept:decision';
-    // Determine run_id: use provided or generate new one
-    const run_id = parsed.run_id ?? generateRunId();
-    // Set current run_id when purpose is task or decision
-    setCurrentRunId(run_id);
-    const body = {
-        kind: 'note',
-        actor: { type: config.agentType, name: config.agentName },
-        concept, // MUST be TOP-LEVEL so it populates timeline_events.concept
-        message,
-        metadata: {
-            source: config.source,
-            purpose, // 'task' | 'decision'
-            intent_source: intent_source ?? 'cursor_chat',
-            run_id,
-            ...(context ? { context } : {}),
-        },
-    };
-    await client.post('/timeline/events', body, { projectId });
-    return { ok: true, run_id };
-}