@openturtle/cli 0.3.0

package/dist/installers/agents.js

@@ -0,0 +1,301 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { hookCommand } from '../commands/hook.js';
+import { readJsonFile, writeJsonFile } from '../core/json.js';
+import { appendCodexHookBlocks, claudeMcpPath, claudeSettingsPath, codexConfigPath, cursorMcpPath, kiroMcpPath, mergeCodexMcpServer, mergeJsonMcpServer, qoderMcpPath, removeCodexManagedConfig, removeJsonMcpServer, } from '../core/mcp-config.js';
+import { ensureFileDir } from '../core/paths.js';
+import { removeCursorHookEntries, removeDirIfExists, removeFileIfExists, removeManagedHookEntries, writeJsonOrRemoveEmpty, } from './uninstall.js';
+export function installClaude(options) {
+    mergeJsonMcpServer(claudeMcpPath(options.scope, options.workspace, options.homeDir));
+    writeSkill(path.join(rootForScope(options, '.claude'), 'skills', 'openturtle-cli', 'SKILL.md'), 'Claude');
+    if (options.withAgentHooks) {
+        mergeJsonMcpServerInSettings(claudeSettingsPath(options.scope, options.workspace, options.homeDir));
+        const settingsPath = claudeSettingsPath(options.scope, options.workspace, options.homeDir);
+        const settings = readJsonFile(settingsPath, {});
+        const hooks = settings.hooks || {};
+        settings.hooks = {
+            ...hooks,
+            UserPromptSubmit: mergeManagedHookArray(hooks.UserPromptSubmit, managedHook('claude', 'UserPromptSubmit')),
+            PreToolUse: mergeManagedHookArray(hooks.PreToolUse, managedHook('claude', 'PreToolUse', '*')),
+            PostToolUse: mergeManagedHookArray(hooks.PostToolUse, managedHook('claude', 'PostToolUse', '*')),
+            Stop: mergeManagedHookArray(hooks.Stop, managedHook('claude', 'Stop')),
+        };
+        writeJsonFile(settingsPath, settings);
+    }
+}
+export function installCodex(options) {
+    const configPath = codexConfigPath(options.scope, options.workspace, options.homeDir);
+    mergeCodexMcpServer(configPath);
+    writeSkill(path.join(rootForScope(options, '.codex'), 'skills', 'openturtle-cli', 'SKILL.md'), 'Codex');
+    appendAgentsSnippet(options.workspace);
+    if (options.withAgentHooks) {
+        appendCodexHookBlocks(configPath, [
+            codexHookBlock('PreToolUse', 'codex', 'PreToolUse'),
+            codexHookBlock('PostToolUse', 'codex', 'PostToolUse'),
+            codexHookBlock('Stop', 'codex', 'Stop'),
+        ].join('\n\n'));
+    }
+}
+export function installCursor(options) {
+    mergeJsonMcpServer(cursorMcpPath(options.workspace));
+    writeTextFile(path.join(options.workspace, '.cursor', 'rules', 'openturtle-cli.mdc'), [
+        '---',
+        'description: Use OpenTurtle CLI MCP tools for goals, todos, reusable knowledge, source files, worklogs, and report drafts.',
+        'alwaysApply: true',
+        '---',
+        '',
+        'Prefer the `ot-cli` MCP server when reading or updating OpenTurtle goals, todos, worklogs, reports, or reusable workspace knowledge.',
+        'Use knowledge source-file tools only when you need the original files behind a knowledge object.',
+        'Todo quality: when creating or proposing todos, include source context, scope/environment, concrete steps, measurable acceptance criteria, and evidence. If any of those are unclear, use AskUserQuestion when available or ask the user one concise question before creating the todo.',
+        '',
+    ].join('\n'));
+    if (options.withAgentHooks) {
+        const hooksPath = path.join(options.homeDir || os.homedir(), '.cursor', 'hooks.json');
+        const hooks = readJsonFile(hooksPath, {});
+        hooks.preToolUse = mergeManagedHookArray(hooks.preToolUse, cursorHook('cursor', 'pre_tool_use'));
+        hooks.postToolUse = mergeManagedHookArray(hooks.postToolUse, cursorHook('cursor', 'post_tool_use'));
+        writeJsonFile(hooksPath, hooks);
+    }
+}
+export function installQoder(options) {
+    mergeJsonMcpServer(qoderMcpPath(options.scope, options.workspace, options.homeDir));
+    writeSkill(path.join(rootForScope(options, '.qoder'), 'skills', 'openturtle-cli', 'SKILL.md'), 'Qoder');
+    if (options.withAgentHooks) {
+        const settingsPath = options.scope === 'user'
+            ? path.join(options.homeDir || os.homedir(), '.qoder', 'settings.json')
+            : path.join(options.workspace, '.qoder', 'settings.local.json');
+        const settings = readJsonFile(settingsPath, {});
+        const hooks = settings.hooks || {};
+        settings.hooks = {
+            ...hooks,
+            UserPromptSubmit: mergeManagedHookArray(hooks.UserPromptSubmit, managedHook('qoder', 'UserPromptSubmit')),
+            PreToolUse: mergeManagedHookArray(hooks.PreToolUse, managedHook('qoder', 'PreToolUse', '*')),
+            PostToolUse: mergeManagedHookArray(hooks.PostToolUse, managedHook('qoder', 'PostToolUse', '*')),
+            PostToolUseFailure: mergeManagedHookArray(hooks.PostToolUseFailure, managedHook('qoder', 'PostToolUseFailure', '*')),
+            Stop: mergeManagedHookArray(hooks.Stop, managedHook('qoder', 'Stop')),
+        };
+        writeJsonFile(settingsPath, settings);
+    }
+}
+export function installKiro(options) {
+    mergeJsonMcpServer(kiroMcpPath(options.scope, options.workspace, options.homeDir));
+    writeTextFile(path.join(rootForScope(options, '.kiro'), 'steering', 'openturtle-cli.md'), [
+        '# OpenTurtle CLI',
+        '',
+        'Use the `ot-cli` MCP server for OpenTurtle goals, todos, reusable knowledge, source files, worklogs, and daily report drafts.',
+        'Todo quality: when creating or proposing todos, include source context, scope/environment, concrete steps, measurable acceptance criteria, and evidence. If any of those are unclear, use AskUserQuestion when available or ask the user one concise question before creating the todo.',
+        'Hooks installed by OpenTurtle are audit-only and must not block the user workflow.',
+        '',
+    ].join('\n'));
+    if (options.withAgentHooks) {
+        const agentPath = path.join(rootForScope(options, '.kiro'), 'agents', 'openturtle-cli.json');
+        const agent = readJsonFile(agentPath, {});
+        const hooks = agent.hooks || {};
+        agent.name = 'openturtle-cli';
+        agent.description = 'OpenTurtle local audit and MCP integration';
+        agent.hooks = {
+            ...hooks,
+            agentSpawn: managedKiroHookList('agentSpawn'),
+            userPromptSubmit: managedKiroHookList('userPromptSubmit'),
+            preToolUse: managedKiroHookList('preToolUse', '*'),
+            postToolUse: managedKiroHookList('postToolUse', '*'),
+            stop: managedKiroHookList('stop'),
+        };
+        writeJsonFile(agentPath, agent);
+        writeKiroIdeHook(path.join(rootForScope(options, '.kiro'), 'hooks', 'openturtle-cli-audit.kiro.hook'));
+    }
+}
+export function uninstallClaude(options) {
+    const root = rootForScope(options, '.claude');
+    removeJsonMcpServer(claudeMcpPath(options.scope, options.workspace, options.homeDir), 'ot-cli', root);
+    const settingsPath = claudeSettingsPath(options.scope, options.workspace, options.homeDir);
+    if (fs.existsSync(settingsPath)) {
+        const settings = readJsonFile(settingsPath, {});
+        if (settings.mcpServers && typeof settings.mcpServers === 'object') {
+            delete settings.mcpServers['ot-cli'];
+        }
+        writeJsonOrRemoveEmpty(settingsPath, removeManagedHookEntries(settings), root);
+    }
+    removeDirIfExists(path.join(root, 'skills', 'openturtle-cli'), root);
+}
+export function uninstallCodex(options) {
+    const root = rootForScope(options, '.codex');
+    removeCodexManagedConfig(codexConfigPath(options.scope, options.workspace, options.homeDir), root);
+    removeDirIfExists(path.join(root, 'skills', 'openturtle-cli'), root);
+    removeAgentsSnippet(options.workspace);
+}
+export function uninstallCursor(options) {
+    removeJsonMcpServer(cursorMcpPath(options.workspace), 'ot-cli', options.workspace);
+    const root = path.join(options.workspace, '.cursor');
+    removeFileIfExists(path.join(root, 'rules', 'openturtle-cli.mdc'), root);
+    const hooksPath = path.join(options.homeDir || os.homedir(), '.cursor', 'hooks.json');
+    if (fs.existsSync(hooksPath)) {
+        const hooks = readJsonFile(hooksPath, {});
+        writeJsonOrRemoveEmpty(hooksPath, removeCursorHookEntries(hooks), path.dirname(hooksPath));
+    }
+}
+export function uninstallQoder(options) {
+    const root = rootForScope(options, '.qoder');
+    removeJsonMcpServer(qoderMcpPath(options.scope, options.workspace, options.homeDir), 'ot-cli', options.scope === 'user'
+        ? path.dirname(qoderMcpPath(options.scope, options.workspace, options.homeDir))
+        : options.workspace);
+    removeDirIfExists(path.join(root, 'skills', 'openturtle-cli'), root);
+    const settingsPath = options.scope === 'user'
+        ? path.join(options.homeDir || os.homedir(), '.qoder', 'settings.json')
+        : path.join(options.workspace, '.qoder', 'settings.local.json');
+    if (fs.existsSync(settingsPath)) {
+        const settings = readJsonFile(settingsPath, {});
+        writeJsonOrRemoveEmpty(settingsPath, removeManagedHookEntries(settings), root);
+    }
+}
+export function uninstallKiro(options) {
+    const root = rootForScope(options, '.kiro');
+    removeJsonMcpServer(kiroMcpPath(options.scope, options.workspace, options.homeDir), 'ot-cli', root);
+    removeFileIfExists(path.join(root, 'steering', 'openturtle-cli.md'), root);
+    removeFileIfExists(path.join(root, 'agents', 'openturtle-cli.json'), root);
+    removeFileIfExists(path.join(root, 'hooks', 'openturtle-cli-audit.kiro.hook'), root);
+}
+function rootForScope(options, dirName) {
+    return options.scope === 'user'
+        ? path.join(options.homeDir || os.homedir(), dirName)
+        : path.join(options.workspace, dirName);
+}
+function mergeJsonMcpServerInSettings(settingsPath) {
+    const settings = readJsonFile(settingsPath, {});
+    const servers = settings.mcpServers && typeof settings.mcpServers === 'object'
+        ? settings.mcpServers
+        : {};
+    servers['ot-cli'] = { command: 'ot', args: ['mcp', 'serve'], enabled: true };
+    writeJsonFile(settingsPath, { ...settings, mcpServers: servers });
+}
+function managedHook(target, event, matcher) {
+    return withoutUndefined({
+        id: 'OPENTURTLE-CLI',
+        name: 'OPENTURTLE-CLI audit',
+        matcher,
+        command: hookCommand(target, event),
+        timeout_ms: 2000,
+        continue_on_error: true,
+    });
+}
+function managedKiroHookList(event, matcher) {
+    return [
+        withoutUndefined({
+            id: 'OPENTURTLE-CLI',
+            name: 'OPENTURTLE-CLI audit',
+            matcher,
+            command: hookCommand('kiro', event),
+            timeout_ms: 2000,
+            cache_ttl_seconds: 0,
+            continue_on_error: true,
+        }),
+    ];
+}
+function cursorHook(target, event) {
+    return {
+        id: 'OPENTURTLE-CLI',
+        command: hookCommand(target, event),
+        timeout_ms: 2000,
+        continue_on_error: true,
+    };
+}
+function mergeManagedHookArray(existing, entry) {
+    const values = Array.isArray(existing) ? existing.filter((item) => item?.id !== 'OPENTURTLE-CLI') : [];
+    return [...values, entry];
+}
+function codexHookBlock(hook, target, event) {
+    return [
+        `[[hooks.${hook}]]`,
+        `command = "ot"`,
+        `args = ["hook", "ingest", "--target", "${target}", "--event", "${event}", "--stdin-json"]`,
+        `timeout_ms = 2000`,
+    ].join('\n');
+}
+function writeSkill(filePath, agentName) {
+    writeTextFile(filePath, [
+        '---',
+        'name: openturtle-cli',
+        'description: Use OpenTurtle projects, team roster, project context, knowledge, meetings, goals, todos, and worklogs from an agent or terminal without requiring the Desktop client.',
+        '---',
+        '',
+        '# OpenTurtle CLI',
+        '',
+        `Use the \`ot-cli\` MCP server in ${agentName} when its tool covers the task. Use the direct \`ot\` command for projects, roster, project context, meetings, or any newer operation that is not exposed by MCP.`,
+        'If authentication is missing, ask the user to run `ot auth login --web`; never request or expose their browser token.',
+        'Run `ot --json doctor` before a remote workflow when authentication or server reachability is uncertain.',
+        'Read commands emit JSON. Before a write, run the same command with `--dry-run` and inspect `request.path` and `request.body`.',
+        'Treat knowledge as reusable memory objects. Treat source files as original materials referenced by knowledge, not as a second knowledge system.',
+        '',
+        '## Meeting workflow',
+        '',
+        '1. Resolve the project with `ot projects resolve`, then inspect `ot roster list` and `ot context get`.',
+        '2. Upload audio with `ot meetings upload` or inspect an existing meeting with `ot meetings show`, `transcript`, and `minutes`.',
+        '3. Publish complete minutes with `ot meetings publish <meeting-id>`. Meeting minutes belong in Knowledge, not WorkLog.',
+        '4. Review drafts using `ot meetings updates list <meeting-id>` and edit them when needed.',
+        '5. Confirm only reviewed updates with `ot meetings updates confirm ... --knowledge <knowledge-id>`. Never confirm without the saved meeting knowledge id.',
+        '6. Use the materialized Todo or WorkLog ids returned by confirmation as the project update evidence.',
+        '',
+        '## Todo quality',
+        '',
+        'When creating or proposing OpenTurtle todos through any available OpenTurtle MCP tool, include source context, scope/environment, concrete action steps, measurable acceptance criteria, and required evidence.',
+        'Source context means the goal, meeting, plan artifact, commit, PR, file, worklog, or user request that caused the todo.',
+        'If the source context, environment, owner, due date, measurable acceptance criteria, or evidence is unclear, ask the user first. Use AskUserQuestion when the host supports it; otherwise ask one concise question before creating the todo.',
+        'Avoid vague acceptance such as "no obvious delay", "works normally", or "verify it". Prefer concrete thresholds, environments, and evidence.',
+        'Use `--body-file <json>` or `--body-file -` for structured writes so shell quoting does not corrupt payloads.',
+        'Do not write to `.openturtle/`; CLI state lives in `.openturtle-cli/` and `~/.openturtle/cli/`.',
+        '',
+    ].join('\n'));
+}
+function appendAgentsSnippet(workspace) {
+    const filePath = path.join(workspace, 'AGENTS.md');
+    const existing = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf-8') : '';
+    const marker = '<!-- OPENTURTLE-CLI -->';
+    if (existing.includes(marker))
+        return;
+    const snippet = [
+        marker,
+        '',
+        'When OpenTurtle goals, todos, reusable knowledge, source files, worklogs, or report drafts are needed, prefer the `ot-cli` MCP server.',
+        'Knowledge means reusable memory objects; source files are original materials behind knowledge.',
+        'Todo quality: when creating or proposing todos, include source context, scope/environment, concrete steps, measurable acceptance criteria, and evidence. If any of those are unclear, use AskUserQuestion when available or ask the user one concise question before creating the todo.',
+        '',
+        '<!-- /OPENTURTLE-CLI -->',
+    ].join('\n');
+    writeTextFile(filePath, `${existing.trimEnd()}${existing.trim() ? '\n\n' : ''}${snippet}\n`);
+}
+function removeAgentsSnippet(workspace) {
+    const filePath = path.join(workspace, 'AGENTS.md');
+    if (!fs.existsSync(filePath))
+        return;
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const cleaned = content.replace(/<!-- OPENTURTLE-CLI -->[\s\S]*?<!-- \/OPENTURTLE-CLI -->\n?/m, '').trimEnd();
+    if (cleaned) {
+        fs.writeFileSync(filePath, `${cleaned}\n`, 'utf-8');
+    }
+    else {
+        fs.rmSync(filePath, { force: true });
+    }
+}
+function writeKiroIdeHook(filePath) {
+    writeTextFile(filePath, [
+        '{',
+        '  "name": "OpenTurtle CLI audit",',
+        '  "description": "Record Kiro hook events into .openturtle-cli/state.db",',
+        '  "event": "postToolUse",',
+        '  "action": {',
+        '    "type": "command",',
+        `    "command": "${hookCommand('kiro', 'postToolUse').replaceAll('"', '\\"')}",`,
+        '    "timeout_ms": 2000',
+        '  }',
+        '}',
+        '',
+    ].join('\n'));
+}
+function writeTextFile(filePath, content) {
+    ensureFileDir(filePath);
+    fs.writeFileSync(filePath, content, 'utf-8');
+}
+function withoutUndefined(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+}

package/dist/installers/git.js

@@ -0,0 +1,63 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { ensureDir, projectWorklogDir } from '../core/paths.js';
+const MARKER = 'OPENTURTLE-CLI';
+export function installGitHook(workspace) {
+    const gitHooksDir = path.join(workspace, '.git', 'hooks');
+    ensureDir(gitHooksDir);
+    ensureDir(path.join(projectWorklogDir(workspace), 'hooks'));
+    const hookPath = path.join(gitHooksDir, 'post-commit');
+    const originalPath = path.join(projectWorklogDir(workspace), 'hooks', 'git-post-commit.original');
+    if (fs.existsSync(hookPath)) {
+        const current = fs.readFileSync(hookPath, 'utf-8');
+        if (current.includes(MARKER))
+            return { installed: false, hookPath };
+        fs.renameSync(hookPath, originalPath);
+    }
+    const wrapper = `#!/bin/sh
+# >>> ${MARKER}:git-post-commit
+original_status=0
+if [ -x "${originalPath}" ]; then
+  "${originalPath}" "$@"
+  original_status="$?"
+fi
+
+if command -v ot >/dev/null 2>&1; then
+  (cd "${workspace}" && ot hook git-post-commit >/dev/null 2>&1) || true
+fi
+
+exit "$original_status"
+# <<< ${MARKER}:git-post-commit
+`;
+    fs.writeFileSync(hookPath, wrapper, 'utf-8');
+    fs.chmodSync(hookPath, 0o755);
+    return { installed: true, hookPath };
+}
+export function uninstallGitHook(workspace) {
+    const hookPath = path.join(workspace, '.git', 'hooks', 'post-commit');
+    const originalPath = path.join(projectWorklogDir(workspace), 'hooks', 'git-post-commit.original');
+    if (!fs.existsSync(hookPath))
+        return;
+    const current = fs.readFileSync(hookPath, 'utf-8');
+    if (!current.includes(MARKER))
+        return;
+    if (fs.existsSync(originalPath)) {
+        fs.copyFileSync(originalPath, hookPath);
+        fs.chmodSync(hookPath, 0o755);
+    }
+    else {
+        fs.unlinkSync(hookPath);
+    }
+    fs.rmSync(originalPath, { force: true });
+    removeEmptyDir(path.dirname(originalPath));
+}
+function removeEmptyDir(dirPath) {
+    try {
+        if (fs.existsSync(dirPath) && fs.readdirSync(dirPath).length === 0) {
+            fs.rmdirSync(dirPath);
+        }
+    }
+    catch {
+        // Uninstall should never fail because cleanup of an auxiliary directory failed.
+    }
+}

package/dist/installers/uninstall.js

@@ -0,0 +1,107 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { projectWorklogDir } from '../core/paths.js';
+export function uninstallAllLocalState(workspace) {
+    const dir = projectWorklogDir(workspace);
+    if (!fs.existsSync(dir))
+        return { removedProjectDir: false };
+    fs.rmSync(dir, { recursive: true, force: true });
+    return { removedProjectDir: true };
+}
+export function removeFileIfExists(filePath, pruneStopDir) {
+    if (!fs.existsSync(filePath))
+        return false;
+    fs.rmSync(filePath, { force: true });
+    pruneEmptyParents(path.dirname(filePath), pruneStopDir);
+    return true;
+}
+export function removeDirIfExists(dirPath, pruneStopDir) {
+    if (!fs.existsSync(dirPath))
+        return false;
+    fs.rmSync(dirPath, { recursive: true, force: true });
+    pruneEmptyParents(path.dirname(dirPath), pruneStopDir);
+    return true;
+}
+export function pruneEmptyParents(startDir, stopDir) {
+    let current = startDir;
+    const stop = stopDir ? path.resolve(stopDir) : undefined;
+    for (let index = 0; index < 3; index += 1) {
+        try {
+            if (stop && path.resolve(current) === stop)
+                return;
+            if (!fs.existsSync(current))
+                return;
+            if (fs.readdirSync(current).length > 0)
+                return;
+            fs.rmdirSync(current);
+        }
+        catch {
+            return;
+        }
+        current = path.dirname(current);
+    }
+}
+export function removeManagedHookEntries(settings) {
+    if (!settings.hooks || typeof settings.hooks !== 'object')
+        return settings;
+    const nextHooks = {};
+    for (const [event, entries] of Object.entries(settings.hooks)) {
+        if (!Array.isArray(entries)) {
+            nextHooks[event] = entries;
+            continue;
+        }
+        const kept = entries.filter((entry) => !isOpenTurtleEntry(entry));
+        if (kept.length > 0)
+            nextHooks[event] = kept;
+    }
+    if (Object.keys(nextHooks).length > 0) {
+        settings.hooks = nextHooks;
+    }
+    else {
+        delete settings.hooks;
+    }
+    return settings;
+}
+export function removeCursorHookEntries(hooks) {
+    for (const [event, entries] of Object.entries(hooks)) {
+        if (!Array.isArray(entries))
+            continue;
+        hooks[event] = entries.filter((entry) => !isOpenTurtleEntry(entry));
+        if (hooks[event].length === 0)
+            delete hooks[event];
+    }
+    return hooks;
+}
+export function writeJsonOrRemoveEmpty(filePath, value, pruneStopDir) {
+    const next = removeEmptyObjects(value);
+    if (Object.keys(next).length === 0) {
+        removeFileIfExists(filePath, pruneStopDir);
+        return;
+    }
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(next, null, 2)}\n`, 'utf-8');
+}
+function isOpenTurtleEntry(entry) {
+    if (!entry || typeof entry !== 'object')
+        return false;
+    const value = entry;
+    return (value.id === 'OPENTURTLE-CLI' ||
+        value.name === 'OPENTURTLE-CLI audit' ||
+        (typeof value.command === 'string' && value.command.includes('ot hook ingest')));
+}
+function removeEmptyObjects(value) {
+    const next = {};
+    for (const [key, item] of Object.entries(value)) {
+        if (item && typeof item === 'object' && !Array.isArray(item)) {
+            const child = removeEmptyObjects(item);
+            if (Object.keys(child).length > 0)
+                next[key] = child;
+            continue;
+        }
+        if (Array.isArray(item) && item.length === 0)
+            continue;
+        if (item !== undefined)
+            next[key] = item;
+    }
+    return next;
+}

package/dist/mcp/server.js

@@ -0,0 +1,185 @@
+import readline from 'node:readline';
+import { createResourceCommands, draftDailyReport } from '../commands/resources.js';
+import { initProjectStore, listEvents, upsertEvent } from '../core/store.js';
+const TOOLS = [
+    tool('list_my_todos', 'List my OpenTurtle todos', {
+        type: 'object',
+        properties: {
+            project_id: { type: 'string' },
+            status: { type: 'string' },
+            mine: { type: 'boolean' },
+        },
+    }),
+    tool('list_goals', 'List OpenTurtle goals', {
+        type: 'object',
+        properties: {
+            project_id: { type: 'string' },
+            status: { type: 'string' },
+            mine: { type: 'boolean' },
+        },
+    }),
+    tool('list_workspace_knowledge', 'List reusable workspace knowledge objects', {
+        type: 'object',
+        properties: { project_id: { type: 'string' }, q: { type: 'string' } },
+    }),
+    tool('search_workspace_knowledge', 'Search reusable workspace knowledge objects', {
+        type: 'object',
+        properties: { keyword: { type: 'string' } },
+        required: ['keyword'],
+    }),
+    tool('list_knowledge_source_files', 'List source files behind workspace knowledge', {
+        type: 'object',
+        properties: { path: { type: 'string' }, q: { type: 'string' } },
+    }),
+    tool('read_knowledge_source_file', 'Read a source file behind workspace knowledge', {
+        type: 'object',
+        properties: { path: { type: 'string' } },
+        required: ['path'],
+    }),
+    tool('record_worklog', 'Record a work log entry', {
+        type: 'object',
+        properties: {
+            summary: { type: 'string' },
+            type: { type: 'string' },
+        },
+        required: ['summary'],
+    }),
+    tool('list_worklogs', 'List work logs', {
+        type: 'object',
+        properties: { today: { type: 'boolean' }, window: { type: 'string' } },
+    }),
+    tool('draft_daily_report', "Draft today's local daily report", {
+        type: 'object',
+        properties: { output: { type: 'string' } },
+    }),
+    tool('update_todo_progress', 'Update todo progress description with current progress, blockers, next step, and evidence such as logs, tests, screenshots, PRs, commits, or worklog references.', {
+        type: 'object',
+        properties: {
+            todo_id: { type: 'string' },
+            message: { type: 'string' },
+        },
+        required: ['todo_id', 'message'],
+    }),
+    tool('update_todo_status', 'Update todo status', {
+        type: 'object',
+        properties: {
+            todo_id: { type: 'string' },
+            status: { type: 'string' },
+        },
+        required: ['todo_id', 'status'],
+    }),
+];
+export async function handleMcpRequest(msg) {
+    const { id, method, params } = msg;
+    switch (method) {
+        case 'initialize':
+            return result(id, {
+                protocolVersion: '2024-11-05',
+                capabilities: { tools: {} },
+                serverInfo: { name: 'ot-cli', version: '0.2.0' },
+            });
+        case 'notifications/initialized':
+            return { jsonrpc: '2.0' };
+        case 'tools/list':
+            return result(id, { tools: TOOLS });
+        case 'tools/call': {
+            const name = String(params?.name || '');
+            const args = (params?.arguments || {});
+            try {
+                const output = await handleTool(name, args);
+                return result(id, { content: [{ type: 'text', text: JSON.stringify(output, null, 2) }] });
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return result(id, { content: [{ type: 'text', text: `Error: ${message}` }], isError: true });
+            }
+        }
+        case 'ping':
+            return result(id, {});
+        default:
+            return error(id, -32601, `Method not found: ${method}`);
+    }
+}
+export async function serveMcp() {
+    const rl = readline.createInterface({ input: process.stdin });
+    for await (const line of rl) {
+        if (!line.trim())
+            continue;
+        try {
+            const response = await handleMcpRequest(JSON.parse(line));
+            if (response.id !== undefined || response.result || response.error) {
+                process.stdout.write(`${JSON.stringify(response)}\n`);
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`[ot-cli-mcp] parse error: ${message}\n`);
+        }
+    }
+}
+async function handleTool(name, args) {
+    const commands = createResourceCommands();
+    try {
+        if (name === 'list_my_todos')
+            return await commands.listTodos({ ...args, mine: args.mine ?? true });
+        if (name === 'list_goals')
+            return await commands.listGoals(args);
+        if (name === 'list_workspace_knowledge')
+            return await commands.listKnowledge(args);
+        if (name === 'search_workspace_knowledge')
+            return await commands.searchKnowledge(String(args.keyword || ''));
+        if (name === 'list_knowledge_source_files')
+            return await commands.listKnowledgeSources(args);
+        if (name === 'read_knowledge_source_file')
+            return await commands.readKnowledgeSource(String(args.path || ''));
+        if (name === 'record_worklog')
+            return await commands.recordWorklog(String(args.summary || ''), String(args.type || 'note'));
+        if (name === 'list_worklogs')
+            return await commands.listWorklogs(args);
+        if (name === 'update_todo_progress') {
+            return await commands.updateTodoProgress(String(args.todo_id || ''), String(args.message || ''));
+        }
+        if (name === 'update_todo_status') {
+            return await commands.updateTodoStatus(String(args.todo_id || ''), String(args.status || ''));
+        }
+    }
+    catch (err) {
+        return localFallback(name, args, err);
+    }
+    if (name === 'draft_daily_report') {
+        return { source: 'local_cache', path: draftDailyReport(process.cwd(), { output: stringArg(args.output) }) };
+    }
+    throw new Error(`Unknown tool: ${name}`);
+}
+function localFallback(name, args, err) {
+    if (name === 'record_worklog') {
+        const store = initProjectStore(process.cwd());
+        upsertEvent(store, {
+            type: 'agent.session_imported',
+            source: 'codex',
+            workspacePath: process.cwd(),
+            summary: String(args.summary || ''),
+            rawJson: { tool: name, args },
+            dedupeKey: `local:record_worklog:${Date.now()}:${Math.random().toString(16).slice(2)}`,
+        });
+        return { source: 'local_cache', ok: true };
+    }
+    const store = initProjectStore(process.cwd());
+    return {
+        source: 'local_cache',
+        warning: err instanceof Error ? err.message : String(err),
+        events: listEvents(store, 50),
+    };
+}
+function tool(name, description, inputSchema) {
+    return { name, description, inputSchema };
+}
+function result(id, value) {
+    return { jsonrpc: '2.0', id: id ?? 0, result: value };
+}
+function error(id, code, message) {
+    return { jsonrpc: '2.0', id: id ?? 0, error: { code, message } };
+}
+function stringArg(value) {
+    return typeof value === 'string' && value ? value : undefined;
+}