@openturtle/cli 0.3.2 → 0.3.3

package/dist/index.js

@@ -2,21 +2,19 @@
 import fs from 'node:fs';
 import { Command } from 'commander';
 import { registerCollaborationCommands } from './commands/collaboration.js';
-import { ingestRawHook, recordGitPostCommit } from './commands/hook.js';
 import { doctor, draftDailyReport, createResourceCommands } from './commands/resources.js';
 import { ApiClient, ApiError } from './core/api-client.js';
 import { scheduleAutomaticUpdate, updateCli } from './core/auto-update.js';
 import { clearAuth, readAuth, redactToken, writeAuth } from './core/auth.js';
 import { DEFAULT_SERVER_URL } from './core/defaults.js';
+import { forgetInstallation, readInstallations, recordInstallation, replaceInstallations, } from './core/installations.js';
 import { findWorkspaceRoot } from './core/paths.js';
 import { initProjectStore } from './core/store.js';
 import { cliVersion } from './core/version.js';
 import { loginWithWeb } from './core/web-auth.js';
 import { installClaude, installCodex, installCursor, installKiro, installQoder, uninstallClaude, uninstallCodex, uninstallCursor, uninstallKiro, uninstallQoder, } from './installers/agents.js';
-import { installGitHook, uninstallGitHook } from './installers/git.js';
+import { uninstallLegacyGitHook } from './installers/legacy-git-cleanup.js';
 import { uninstallAllLocalState } from './installers/uninstall.js';
-import { serveMcp } from './mcp/server.js';
-import { candidateHistoryPaths, importHistory } from './watchers/importers.js';
 const program = new Command();
 program
     .name('ot')
@@ -125,17 +123,17 @@ program
     .command('install')
     .option('--target <target>')
     .option('--scope <scope>', 'project|user', 'project')
-    .option('--with-agent-hooks')
     .action(action((options) => {
     requireOption(options.target, '--target');
     const workspace = findWorkspaceRoot();
     for (const target of expandTargets(options.target)) {
-        installTarget(target, workspace, options.scope, Boolean(options.withAgentHooks));
+        installTarget(target, workspace, options.scope);
     }
     print({
         installed: options.target,
-        mcp_server_name: 'ot-cli',
-        with_agent_hooks: Boolean(options.withAgentHooks),
+        scope: options.scope,
+        integration: 'cli-skill',
+        legacy_mcp_and_hooks_removed: true,
     });
 }));
 program
@@ -151,52 +149,6 @@ program
     const local_state = options.target === 'all' ? uninstallAllLocalState(workspace) : { removedProjectDir: false };
     print({ uninstalled: options.target, scope: options.scope, local_state });
 }));
-const hook = program.command('hook');
-hook
-    .command('ingest')
-    .option('--target <target>')
-    .option('--event <event>')
-    .option('--stdin-json')
-    .action(action(async (options) => {
-    requireOption(options.target, '--target');
-    requireOption(options.event, '--event');
-    const stdin = options.stdinJson ? await readStdin() : '{}';
-    const result = ingestRawHook({
-        target: options.target,
-        event: options.event,
-        stdin,
-        workspace: findWorkspaceRoot(),
-    });
-    if (!result.ok)
-        process.exitCode = 0;
-}));
-hook.command('git-post-commit').action(action(() => {
-    recordGitPostCommit(findWorkspaceRoot());
-}));
-hook.command('doctor').action(action(() => print(doctor(findWorkspaceRoot()))));
-program
-    .command('import-history')
-    .option('--target <target>')
-    .action(action((options) => {
-    requireOption(options.target, '--target');
-    const workspace = findWorkspaceRoot();
-    if (options.target === 'all') {
-        print(['claude', 'codex', 'cursor', 'qoder', 'kiro'].map((target) => importHistory(target, workspace)));
-        return;
-    }
-    print(importHistory(options.target, workspace));
-}));
-program
-    .command('watch')
-    .option('--target <target>')
-    .action(action((options) => {
-    requireOption(options.target, '--target');
-    print({
-        target: options.target,
-        watcher_paths: candidateHistoryPaths(options.target),
-        note: 'v1 watch uses import-history polling semantics; native hooks are preferred where supported.',
-    });
-}));
 const resources = createResourceCommands();
 const goals = program.command('goals');
 goals
@@ -339,16 +291,8 @@ program
     throw new Error('Usage: ot report draft [--today] [--output <path>]');
 }));
 program
-    .command('mcp [subcommand]')
-    .description('MCP server commands')
-    .allowUnknownOption()
-    .action(action(async (subcommand) => {
-    if (subcommand === 'serve') {
-        await serveMcp();
-        return;
-    }
-    throw new Error('Usage: ot mcp serve');
-}));
+    .command('_refresh-installs', { hidden: true })
+    .action(action(() => print({ refreshed: refreshRecordedInstallations() })));
 scheduleAutomaticUpdate(cliVersion());
 if (!runSpecialNestedCommand(process.argv)) {
     try {
@@ -384,24 +328,26 @@ function fatal(err) {
     }
     process.exit(1);
 }
-function installTarget(target, workspace, scope, withAgentHooks) {
+function installTarget(target, workspace, scope) {
     if (target === 'git')
-        installGitHook(workspace);
+        throw new Error('Git Hook installation has been removed; use uninstall --target git for cleanup');
+    const options = { workspace, scope };
     if (target === 'claude')
-        installClaude({ workspace, scope, withAgentHooks });
+        installClaude(options);
     if (target === 'codex')
-        installCodex({ workspace, scope, withAgentHooks });
+        installCodex(options);
     if (target === 'cursor')
-        installCursor({ workspace, scope, withAgentHooks });
+        installCursor(options);
     if (target === 'qoder')
-        installQoder({ workspace, scope, withAgentHooks });
+        installQoder(options);
     if (target === 'kiro')
-        installKiro({ workspace, scope, withAgentHooks });
+        installKiro(options);
+    recordInstallation({ target, scope, workspace });
 }
 function uninstallTarget(target, workspace, scope) {
-    const options = { workspace, scope, withAgentHooks: true };
+    const options = { workspace, scope };
     if (target === 'git')
-        uninstallGitHook(workspace);
+        uninstallLegacyGitHook(workspace);
     if (target === 'claude')
         uninstallClaude(options);
     if (target === 'codex')
@@ -412,6 +358,8 @@ function uninstallTarget(target, workspace, scope) {
         uninstallQoder(options);
     if (target === 'kiro')
         uninstallKiro(options);
+    if (target !== 'git')
+        forgetInstallation({ target, scope, workspace });
 }
 function requireOption(value, name) {
     if (value == null || value === '') {
@@ -420,7 +368,7 @@ function requireOption(value, name) {
 }
 function expandTargets(target) {
     if (target === 'all')
-        return ['git', 'claude', 'codex', 'cursor', 'qoder', 'kiro'];
+        return ['claude', 'codex', 'cursor', 'qoder', 'kiro'];
     return [target];
 }
 function print(value, asJson = true) {
@@ -430,12 +378,6 @@ function print(value, asJson = true) {
     }
     process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
 }
-async function readStdin() {
-    const chunks = [];
-    for await (const chunk of process.stdin)
-        chunks.push(Buffer.from(chunk));
-    return Buffer.concat(chunks).toString('utf-8');
-}
 function updateGitignore(workspace) {
     const gitignorePath = `${workspace}/.gitignore`;
     const existing = fs.existsSync(gitignorePath) ? fs.readFileSync(gitignorePath, 'utf-8') : '';
@@ -445,10 +387,6 @@ function updateGitignore(workspace) {
 }
 function runSpecialNestedCommand(argv) {
     const [, , first, second, ...rest] = argv;
-    if (first === 'mcp' && second === 'serve') {
-        void serveMcp().catch(fatal);
-        return true;
-    }
     if (first === 'report' && second === 'draft') {
         const options = parseSimpleOptions(rest);
         print({ path: draftDailyReport(findWorkspaceRoot(), options) });
@@ -457,6 +395,17 @@ function runSpecialNestedCommand(argv) {
     }
     return false;
 }
+function refreshRecordedInstallations() {
+    const kept = [];
+    for (const installation of readInstallations()) {
+        if (!fs.existsSync(installation.workspace))
+            continue;
+        installTarget(installation.target, installation.workspace, installation.scope);
+        kept.push(installation);
+    }
+    replaceInstallations(kept);
+    return kept.length;
+}
 function parseSimpleOptions(args) {
     const options = {};
     for (let index = 0; index < args.length; index += 1) {

package/dist/installers/agents.js

@@ -1,158 +1,116 @@
 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 { readJsonFile } from '../core/json.js';
+import { claudeLegacyServerPath, claudeSettingsPath, codexConfigPath, cursorLegacyServerPath, kiroLegacyServerPath, qoderLegacyServerPath, removeLegacyCodexConfig, removeLegacyJsonServer, } from '../core/legacy-agent-cleanup.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);
-    }
+    cleanupClaudeLegacy(options);
+    writeSkill(path.join(rootForScope(options, '.claude'), 'skills', 'openturtle-cli', 'SKILL.md'));
 }
 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'));
-    }
+    cleanupCodexLegacy(options);
+    writeSkill(path.join(rootForScope(options, '.codex'), 'skills', 'openturtle-cli', 'SKILL.md'));
+    if (options.scope === 'project')
+        appendAgentsSnippet(options.workspace);
 }
 export function installCursor(options) {
-    mergeJsonMcpServer(cursorMcpPath(options.workspace));
+    cleanupCursorLegacy(options);
     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.',
+        'description: Use the OpenTurtle CLI directly for projects, goals, todos, knowledge, meetings, and worklogs.',
         '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.',
+        'Run OpenTurtle operations with the direct `ot ... --json` CLI. Do not use an OpenTurtle MCP server or install OpenTurtle hooks.',
+        'Start with `command -v ot` and `ot --json doctor`; if authentication is missing, ask the user to run `ot auth login --web`.',
+        'Before a write, run the same command with `--dry-run` and inspect the request path and body.',
+        'Todo quality: include source context, scope/environment, concrete steps, measurable acceptance criteria, and evidence. Ask one concise question when required information is unclear.',
         '',
     ].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);
-    }
+    cleanupQoderLegacy(options);
+    writeSkill(path.join(rootForScope(options, '.qoder'), 'skills', 'openturtle-cli', 'SKILL.md'));
 }
 export function installKiro(options) {
-    mergeJsonMcpServer(kiroMcpPath(options.scope, options.workspace, options.homeDir));
+    cleanupKiroLegacy(options);
     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.',
+        'Run OpenTurtle operations with the direct `ot ... --json` CLI. Do not use an OpenTurtle MCP server or install OpenTurtle hooks.',
+        'Start with `command -v ot` and `ot --json doctor`; if authentication is missing, ask the user to run `ot auth login --web`.',
+        'Before a write, run the same command with `--dry-run` and inspect the request path and body.',
+        'Todo quality: include source context, scope/environment, concrete steps, measurable acceptance criteria, and evidence. Ask one concise question when required information is unclear.',
         '',
     ].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) {
+    cleanupClaudeLegacy(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) {
+    cleanupCodexLegacy(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);
+    if (options.scope === 'project')
+        removeAgentsSnippet(options.workspace);
 }
 export function uninstallCursor(options) {
-    removeJsonMcpServer(cursorMcpPath(options.workspace), 'ot-cli', options.workspace);
+    cleanupCursorLegacy(options);
     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) {
+    cleanupQoderLegacy(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);
+}
+export function uninstallKiro(options) {
+    cleanupKiroLegacy(options);
+    const root = rootForScope(options, '.kiro');
+    removeFileIfExists(path.join(root, 'steering', 'openturtle-cli.md'), root);
+}
+function cleanupClaudeLegacy(options) {
+    const root = rootForScope(options, '.claude');
+    removeLegacyJsonServer(claudeLegacyServerPath(options.scope, options.workspace, options.homeDir), root);
+    const settingsPath = claudeSettingsPath(options.scope, options.workspace, options.homeDir);
+    if (!fs.existsSync(settingsPath))
+        return;
+    const settings = readJsonFile(settingsPath, {});
+    if (settings.mcpServers && typeof settings.mcpServers === 'object')
+        delete settings.mcpServers['ot-cli'];
+    writeJsonOrRemoveEmpty(settingsPath, removeManagedHookEntries(settings), root);
+}
+function cleanupCodexLegacy(options) {
+    const root = rootForScope(options, '.codex');
+    removeLegacyCodexConfig(codexConfigPath(options.scope, options.workspace, options.homeDir), root);
+}
+function cleanupCursorLegacy(options) {
+    removeLegacyJsonServer(cursorLegacyServerPath(options.workspace), options.workspace);
+    const hooksPath = path.join(options.homeDir || os.homedir(), '.cursor', 'hooks.json');
+    if (!fs.existsSync(hooksPath))
+        return;
+    const hooks = readJsonFile(hooksPath, {});
+    writeJsonOrRemoveEmpty(hooksPath, removeCursorHookEntries(hooks), path.dirname(hooksPath));
+}
+function cleanupQoderLegacy(options) {
+    const root = rootForScope(options, '.qoder');
+    const mcpPath = qoderLegacyServerPath(options.scope, options.workspace, options.homeDir);
+    removeLegacyJsonServer(mcpPath, options.scope === 'user' ? path.dirname(mcpPath) : options.workspace);
     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);
-    }
+    if (!fs.existsSync(settingsPath))
+        return;
+    const settings = readJsonFile(settingsPath, {});
+    writeJsonOrRemoveEmpty(settingsPath, removeManagedHookEntries(settings), root);
 }
-export function uninstallKiro(options) {
+function cleanupKiroLegacy(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);
+    removeLegacyJsonServer(kiroLegacyServerPath(options.scope, options.workspace, options.homeDir), root);
     removeFileIfExists(path.join(root, 'agents', 'openturtle-cli.json'), root);
     removeFileIfExists(path.join(root, 'hooks', 'openturtle-cli-audit.kiro.hook'), root);
 }
@@ -161,59 +119,11 @@ function rootForScope(options, dirName) {
         ? 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 writeSkill(filePath) {
+    writeTextFile(filePath, skillContent());
 }
-function codexHookBlock(hook, target, event) {
+export function skillContent() {
     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.',
@@ -221,10 +131,11 @@ function writeSkill(filePath, agentName) {
         '',
         '# 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.`,
+        'Use the direct `ot` command for every OpenTurtle operation. Do not use an OpenTurtle MCP server and do not install OpenTurtle hooks.',
+        'Start with `command -v ot`. Run `ot --json doctor` before a remote workflow when authentication or server reachability is uncertain.',
         '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`.',
+        'Run commands as `ot ... --json` so results are stable and machine-readable.',
+        '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',
@@ -238,31 +149,29 @@ function writeSkill(filePath, agentName) {
         '',
         '## 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.',
+        'When creating or proposing OpenTurtle todos, 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.',
+        'If the source context, environment, owner, due date, measurable acceptance criteria, or evidence is unclear, 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'));
+    ].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 withoutOld = existing.replace(/<!-- OPENTURTLE-CLI -->[\s\S]*?<!-- \/OPENTURTLE-CLI -->\n?/m, '').trimEnd();
     const snippet = [
-        marker,
+        '<!-- OPENTURTLE-CLI -->',
         '',
-        '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.',
+        'Use the direct `ot ... --json` CLI for OpenTurtle projects, goals, todos, knowledge, meetings, and worklogs. Do not use an OpenTurtle MCP server or install OpenTurtle hooks.',
+        'Run `ot --json doctor` when authentication or server reachability is uncertain, and use `--dry-run` before writes.',
+        'Todo quality: include source context, scope/environment, concrete steps, measurable acceptance criteria, and evidence. Ask one concise question when required information is unclear.',
         '',
         '<!-- /OPENTURTLE-CLI -->',
     ].join('\n');
-    writeTextFile(filePath, `${existing.trimEnd()}${existing.trim() ? '\n\n' : ''}${snippet}\n`);
+    writeTextFile(filePath, `${withoutOld}${withoutOld ? '\n\n' : ''}${snippet}\n`);
 }
 function removeAgentsSnippet(workspace) {
     const filePath = path.join(workspace, 'AGENTS.md');
@@ -270,32 +179,12 @@ function removeAgentsSnippet(workspace) {
         return;
     const content = fs.readFileSync(filePath, 'utf-8');
     const cleaned = content.replace(/<!-- OPENTURTLE-CLI -->[\s\S]*?<!-- \/OPENTURTLE-CLI -->\n?/m, '').trimEnd();
-    if (cleaned) {
+    if (cleaned)
         fs.writeFileSync(filePath, `${cleaned}\n`, 'utf-8');
-    }
-    else {
+    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/legacy-git-cleanup.js

@@ -0,0 +1,29 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { projectWorklogDir } from '../core/paths.js';
+const MARKER = 'OPENTURTLE-CLI';
+export function uninstallLegacyGitHook(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 });
+    try {
+        if (fs.existsSync(path.dirname(originalPath)) && fs.readdirSync(path.dirname(originalPath)).length === 0) {
+            fs.rmdirSync(path.dirname(originalPath));
+        }
+    }
+    catch {
+        // Legacy cleanup should not fail because an auxiliary directory is not empty.
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openturtle/cli",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "OpenTurtle collaboration, knowledge, meeting, and agent CLI",
   "keywords": [
     "openturtle",
@@ -32,7 +32,7 @@
     "registry": "https://registry.npmjs.org/"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "node --input-type=module -e \"import fs from 'node:fs'; fs.rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.json",
     "prepublishOnly": "pnpm run test && pnpm run build",
     "test": "tsx --test test/*.test.ts",
     "dev": "tsx src/index.ts"