@openturtle/cli 0.3.2 → 0.3.4

package/dist/commands/local-knowledge.js

@@ -0,0 +1,129 @@
+import { readJsonBody } from '../core/input.js';
+import { createLocalKnowledgeEntry, getLocalKnowledgeAsset, importLocalKnowledgePaths, listLocalKnowledgeAssets, removeLocalKnowledgeAsset, updateLocalKnowledgeEntry, } from '../local-knowledge/library.js';
+import { readLocalKnowledgeIndexedContent, searchLocalKnowledgeIndex, } from '../local-knowledge/index.js';
+import { localKnowledgeStoreRoot } from '../local-knowledge/root.js';
+export function createLocalKnowledgeCommands(root = localKnowledgeStoreRoot()) {
+    return {
+        root,
+        list: () => listLocalKnowledgeAssets(root),
+        async search(query, limit = 20, matchMode = 'any') {
+            const assets = await listLocalKnowledgeAssets(root);
+            const hits = await searchLocalKnowledgeIndex(assets, query, Math.max(1, Math.min(limit, 100)), root, matchMode);
+            const byId = new Map(assets.map((asset) => [asset.id, asset]));
+            const items = hits.flatMap((hit) => {
+                const asset = byId.get(hit.assetId);
+                return asset ? [{ ...asset, matches: hit.matches }] : [];
+            });
+            return { root, items, count: items.length };
+        },
+        async read(assetId, truncate = 200_000) {
+            const asset = getLocalKnowledgeAsset(assetId, root);
+            if (!asset)
+                throw new Error('Local knowledge asset was not found');
+            const indexed = await readLocalKnowledgeIndexedContent(asset, Math.max(1, Math.min(truncate, 1_000_000)), root);
+            return {
+                ...asset,
+                text: indexed.content,
+                content_available: indexed.contentAvailable,
+                truncated: indexed.truncated,
+                index_status: indexed.indexStatus,
+            };
+        },
+        importPaths(paths, dryRun = false) {
+            if (dryRun)
+                return Promise.resolve(localDryRun(root, 'import', { paths }));
+            return importLocalKnowledgePaths(paths, root);
+        },
+        create(input, dryRun = false) {
+            if (dryRun)
+                return Promise.resolve(localDryRun(root, 'create', { input }));
+            return createLocalKnowledgeEntry(input, root);
+        },
+        update(assetId, input, dryRun = false) {
+            if (dryRun)
+                return Promise.resolve(localDryRun(root, 'update', { asset_id: assetId, input }));
+            return updateLocalKnowledgeEntry(assetId, input, root);
+        },
+        remove(assetId, dryRun = false) {
+            if (dryRun)
+                return Promise.resolve(localDryRun(root, 'remove', { asset_id: assetId }));
+            return removeLocalKnowledgeAsset(assetId, root);
+        },
+    };
+}
+export async function searchKnowledgeEverywhere(query, options, fetchCloud, root = localKnowledgeStoreRoot()) {
+    if (options.cloudOnly && options.localOnly)
+        throw new Error('Use --cloud-only or --local-only, not both');
+    const local = createLocalKnowledgeCommands(root);
+    const [cloudResult, localResult] = await Promise.all([
+        options.localOnly ? Promise.resolve(null) : fetchCloud(),
+        options.cloudOnly
+            ? Promise.resolve(null)
+            : local.search(query, Number(options.limit) || 20, normalizeMatchMode(options.match)),
+    ]);
+    return {
+        query,
+        cloud: cloudResult,
+        local: localResult,
+    };
+}
+export function registerLocalKnowledgeCommands(knowledge, callbacks) {
+    const commands = createLocalKnowledgeCommands();
+    const local = knowledge.command('local').description('Local indexed knowledge available without Desktop');
+    const action = (fn) => (...args) => {
+        Promise.resolve(fn(...args)).catch(callbacks.fatal);
+    };
+    local.command('list').action(action(async () => callbacks.print(await commands.list())));
+    local
+        .command('search <query>')
+        .option('--limit <number>', 'maximum results', Number, 20)
+        .option('--match <mode>', 'any|all|exact', 'any')
+        .action(action(async (query, options) => callbacks.print(await commands.search(query, options.limit, normalizeMatchMode(options.match)))));
+    local
+        .command('read <assetId>')
+        .option('--truncate <characters>', 'maximum extracted characters', Number, 200_000)
+        .action(action(async (assetId, options) => callbacks.print(await commands.read(assetId, options.truncate))));
+    local
+        .command('import <paths...>')
+        .option('--dry-run')
+        .action(action(async (paths, options) => callbacks.print(await commands.importPaths(paths, Boolean(options.dryRun)))));
+    local
+        .command('create')
+        .requiredOption('--body-file <path>', 'JSON body file, or - for stdin')
+        .option('--dry-run')
+        .action(action(async (options) => callbacks.print(await commands.create(asEntryInput(await readJsonBody(options.bodyFile)), Boolean(options.dryRun)))));
+    local
+        .command('update <assetId>')
+        .requiredOption('--body-file <path>', 'JSON body file, or - for stdin')
+        .option('--dry-run')
+        .action(action(async (assetId, options) => callbacks.print(await commands.update(assetId, asEntryInput(await readJsonBody(options.bodyFile)), Boolean(options.dryRun)))));
+    local
+        .command('remove <assetId>')
+        .option('--dry-run')
+        .action(action(async (assetId, options) => callbacks.print(await commands.remove(assetId, Boolean(options.dryRun)))));
+}
+function normalizeMatchMode(value) {
+    return value === 'all' || value === 'exact' ? value : 'any';
+}
+function asEntryInput(value) {
+    const kind = value.kind;
+    if (kind !== 'note' && kind !== 'decision' && kind !== 'fact' && kind !== 'meeting') {
+        throw new Error('Local knowledge kind must be note, decision, fact, or meeting');
+    }
+    return {
+        title: String(value.title || ''),
+        body: String(value.body || ''),
+        kind,
+        projectId: value.projectId == null ? undefined : String(value.projectId),
+        status: String(value.status || 'draft'),
+        attachments: Array.isArray(value.attachments)
+            ? value.attachments.map((item) => {
+                const attachment = item;
+                return { name: String(attachment.name || ''), path: String(attachment.path || '') };
+            })
+            : undefined,
+    };
+}
+function localDryRun(root, operation, input) {
+    return { dry_run: true, local_knowledge: { root, operation, ...input } };
+}

package/dist/commands/resources.js

@@ -103,16 +103,13 @@ export function doctor(workspace, target) {
             project_dir: store.dir,
             project_dir_exists: projectDirExists,
             global_dir: path.join(process.env.HOME || '', '.openturtle', 'cli'),
-            mcp_server_name: 'ot-cli',
+            integration: 'cli-skill',
         },
         auth: {
             server: auth.server || null,
             token_configured: Boolean(auth.token),
         },
-        coexistence: {
-            avoids_project_dot_openturtle: true,
-            desktop_mcp_names_reserved: ['openturtle-knowledge', 'openturtle-automations', 'openturtle-todo'],
-        },
+        coexistence: { avoids_project_dot_openturtle: true },
         target: target || 'all',
     };
 }

package/dist/core/auth.js

@@ -7,13 +7,15 @@ export function authPath(homeDir = os.homedir()) {
     return path.join(cliGlobalDir(homeDir), 'auth.json');
 }
 export function readAuth(homeDir = os.homedir()) {
-    const envToken = process.env.OPENTURTLE_TOKEN;
-    const envServer = process.env.OPENTURTLE_SERVER_URL || process.env.SERVER_URL;
+    const envToken = process.env.OPENTURTLE_API_TOKEN || process.env.OPENTURTLE_TOKEN;
+    const envServer = process.env.OPENTURTLE_API_BASE_URL || process.env.OPENTURTLE_SERVER_URL || process.env.SERVER_URL;
+    const envTeamId = process.env.OPENTURTLE_TEAM_ID;
     const config = readJsonFile(authPath(homeDir), {});
     return {
         ...config,
         ...(envServer ? { server: envServer } : {}),
         ...(envToken ? { token: envToken } : {}),
+        ...(envTeamId ? { teamId: envTeamId } : {}),
     };
 }
 export function writeAuth(config, homeDir = os.homedir()) {

package/dist/core/auto-update.js

@@ -40,6 +40,15 @@ export function npmUpdateArgs() {
     ];
 }
 export async function updateCli(currentVersion, options = {}, dependencies = {}) {
+    if ((dependencies.env || process.env).OPENTURTLE_CLI_DISTRIBUTION === 'desktop') {
+        return {
+            current: currentVersion,
+            latest: null,
+            available: false,
+            updated: false,
+            reason: 'desktop_managed',
+        };
+    }
     const latest = await fetchLatestVersion(dependencies.fetchImpl);
     if (!latest) {
         return { current: currentVersion, latest: null, available: false, updated: false, reason: 'not_published' };
@@ -64,13 +73,16 @@ export async function updateCli(currentVersion, options = {}, dependencies = {})
         };
     }
     await (dependencies.runNpmInstall || runNpmInstall)(npmUpdateArgs());
-    return { current: currentVersion, latest, available: true, updated: true };
+    await (dependencies.refreshInstalledSkills || refreshInstalledSkills)();
+    return { current: currentVersion, latest, available: true, updated: true, skills_refreshed: true };
 }
 export function scheduleAutomaticUpdate(currentVersion, dependencies = {}) {
     try {
         const env = dependencies.env || process.env;
         const argv = dependencies.argv || process.argv;
-        if (env.OPENTURTLE_DISABLE_AUTO_UPDATE === '1' || env.OPENTURTLE_AUTO_UPDATE_WORKER === '1')
+        if (env.OPENTURTLE_CLI_DISTRIBUTION === 'desktop' ||
+            env.OPENTURTLE_DISABLE_AUTO_UPDATE === '1' ||
+            env.OPENTURTLE_AUTO_UPDATE_WORKER === '1')
             return false;
         if (argv[2] === 'update' || !isManagedNpmInstall(dependencies.packageRoot))
             return false;
@@ -166,6 +178,22 @@ function runNpmInstall(args) {
         });
     });
 }
+function refreshInstalledSkills() {
+    const entryPath = fileURLToPath(new URL('../index.js', import.meta.url));
+    return new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, [entryPath, '_refresh-installs'], {
+            env: { ...process.env, OPENTURTLE_AUTO_UPDATE_WORKER: '1' },
+            stdio: 'ignore',
+        });
+        child.once('error', reject);
+        child.once('exit', (code, signal) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`Skill refresh failed (${signal || `exit ${code ?? 'unknown'}`})`));
+        });
+    });
+}
 function spawnUpdateWorker(workerPath, env) {
     const child = spawn(process.execPath, [workerPath], {
         detached: true,

package/dist/core/installations.js

@@ -0,0 +1,41 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { cliGlobalDir, ensureFileDir } from './paths.js';
+export function installationsPath(homeDir) {
+    return path.join(cliGlobalDir(homeDir), 'installations.json');
+}
+export function readInstallations(filePath = installationsPath()) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        return Array.isArray(parsed.installations) ? parsed.installations : [];
+    }
+    catch {
+        return [];
+    }
+}
+export function recordInstallation(installation, filePath = installationsPath()) {
+    const normalized = normalizeInstallation(installation);
+    const installations = readInstallations(filePath).filter((item) => installationKey(item) !== installationKey(normalized));
+    writeInstallations([...installations, normalized], filePath);
+}
+export function forgetInstallation(installation, filePath = installationsPath()) {
+    const key = installationKey(normalizeInstallation(installation));
+    writeInstallations(readInstallations(filePath).filter((item) => installationKey(item) !== key), filePath);
+}
+export function replaceInstallations(installations, filePath = installationsPath()) {
+    writeInstallations(installations.map(normalizeInstallation), filePath);
+}
+function normalizeInstallation(installation) {
+    return { ...installation, workspace: path.resolve(installation.workspace) };
+}
+function installationKey(installation) {
+    return `${installation.target}\0${installation.scope}\0${path.resolve(installation.workspace)}`;
+}
+function writeInstallations(installations, filePath) {
+    if (installations.length === 0) {
+        fs.rmSync(filePath, { force: true });
+        return;
+    }
+    ensureFileDir(filePath);
+    fs.writeFileSync(filePath, `${JSON.stringify({ installations }, null, 2)}\n`, { mode: 0o600 });
+}

package/dist/core/{mcp-config.js → legacy-agent-cleanup.js}

@@ -2,27 +2,15 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { readJsonFile, writeJsonFile } from './json.js';
-import { ensureFileDir } from './paths.js';
-export const MCP_SERVER_NAME = 'ot-cli';
-export function otMcpConfig() {
-    return { command: 'ot', args: ['mcp', 'serve'], enabled: true };
-}
-export function mergeJsonMcpServer(filePath, name = MCP_SERVER_NAME) {
-    const parsed = readJsonFile(filePath, {});
-    const servers = parsed.mcpServers && typeof parsed.mcpServers === 'object'
-        ? parsed.mcpServers
-        : {};
-    servers[name] = otMcpConfig();
-    writeJsonFile(filePath, { ...parsed, mcpServers: servers });
-}
-export function removeJsonMcpServer(filePath, name = MCP_SERVER_NAME, pruneStopDir) {
+const LEGACY_SERVER_NAME = 'ot-cli';
+export function removeLegacyJsonServer(filePath, pruneStopDir) {
     if (!fs.existsSync(filePath))
         return;
     const parsed = readJsonFile(filePath, {});
     const servers = parsed.mcpServers && typeof parsed.mcpServers === 'object'
         ? { ...parsed.mcpServers }
         : {};
-    delete servers[name];
+    delete servers[LEGACY_SERVER_NAME];
     const next = { ...parsed, mcpServers: servers };
     if (Object.keys(servers).length === 0)
         delete next.mcpServers;
@@ -33,7 +21,7 @@ export function removeJsonMcpServer(filePath, name = MCP_SERVER_NAME, pruneStopD
     }
     writeJsonFile(filePath, next);
 }
-export function claudeMcpPath(scope, workspace, homeDir = os.homedir()) {
+export function claudeLegacyServerPath(scope, workspace, homeDir = os.homedir()) {
     return scope === 'user'
         ? path.join(homeDir, '.claude', 'mcp_servers.json')
         : path.join(workspace, '.claude', 'mcp_servers.json');
@@ -46,42 +34,23 @@ export function claudeSettingsPath(scope, workspace, homeDir = os.homedir()) {
 export function codexConfigPath(scope, workspace, homeDir = os.homedir()) {
     return scope === 'user' ? path.join(homeDir, '.codex', 'config.toml') : path.join(workspace, '.codex', 'config.toml');
 }
-export function cursorMcpPath(workspace) {
+export function cursorLegacyServerPath(workspace) {
     return path.join(workspace, '.mcp.json');
 }
-export function qoderMcpPath(scope, workspace, homeDir = os.homedir()) {
+export function qoderLegacyServerPath(scope, workspace, homeDir = os.homedir()) {
     return scope === 'user' ? path.join(homeDir, '.qoder.json') : path.join(workspace, '.mcp.json');
 }
-export function kiroMcpPath(scope, workspace, homeDir = os.homedir()) {
+export function kiroLegacyServerPath(scope, workspace, homeDir = os.homedir()) {
     return scope === 'user'
         ? path.join(homeDir, '.kiro', 'settings', 'mcp.json')
         : path.join(workspace, '.kiro', 'settings', 'mcp.json');
 }
-export function mergeCodexMcpServer(filePath) {
-    ensureFileDir(filePath);
-    const existing = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf-8') : '';
-    const withoutServer = stripTomlTable(existing, `mcp_servers.${MCP_SERVER_NAME}`);
-    const block = [
-        `[mcp_servers.${MCP_SERVER_NAME}]`,
-        `command = "ot"`,
-        `args = ["mcp", "serve"]`,
-        `enabled = true`,
-    ].join('\n');
-    fs.writeFileSync(filePath, `${[withoutServer.trimEnd(), block].filter(Boolean).join('\n\n')}\n`, 'utf-8');
-}
-export function appendCodexHookBlocks(filePath, hookBlocks) {
-    ensureFileDir(filePath);
-    const existing = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf-8') : '';
-    const cleaned = removeManagedTomlBlock(existing, 'hooks');
-    const block = [`# >>> OPENTURTLE-CLI:hooks`, hookBlocks.trimEnd(), `# <<< OPENTURTLE-CLI:hooks`].join('\n');
-    fs.writeFileSync(filePath, `${[cleaned.trimEnd(), block].filter(Boolean).join('\n\n')}\n`, 'utf-8');
-}
-export function removeCodexManagedConfig(filePath, pruneStopDir) {
+export function removeLegacyCodexConfig(filePath, pruneStopDir) {
     if (!fs.existsSync(filePath))
         return;
     const existing = fs.readFileSync(filePath, 'utf-8');
     const withoutHooks = removeManagedTomlBlock(existing, 'hooks');
-    const withoutServer = stripTomlTable(withoutHooks, `mcp_servers.${MCP_SERVER_NAME}`);
+    const withoutServer = stripTomlTable(withoutHooks, `mcp_servers.${LEGACY_SERVER_NAME}`);
     const next = withoutServer.trim();
     if (!next) {
         fs.rmSync(filePath, { force: true });
@@ -99,9 +68,8 @@ function stripTomlTable(content, tableName) {
     let skipping = false;
     const tablePattern = new RegExp(`^\\s*\\[${escapeRegExp(tableName)}\\]\\s*$`);
     for (const line of lines) {
-        if (/^\s*\[/.test(line)) {
+        if (/^\s*\[/.test(line))
             skipping = tablePattern.test(line);
-        }
         if (!skipping)
             kept.push(line);
     }

package/dist/core/store.js

@@ -5,14 +5,13 @@ import { projectWorklogDir } from './paths.js';
 export function initProjectStore(workspacePath) {
     const workspace = path.resolve(workspacePath);
     const dir = projectWorklogDir(workspace);
-    fs.mkdirSync(path.join(dir, 'hooks'), { recursive: true });
     fs.mkdirSync(path.join(dir, 'drafts'), { recursive: true });
     fs.mkdirSync(path.join(dir, 'cache'), { recursive: true });
     const configPath = path.join(dir, 'config.json');
     if (!fs.existsSync(configPath)) {
         fs.writeFileSync(configPath, `${JSON.stringify({
             version: 1,
-            mcpServerName: 'ot-cli',
+            integration: 'cli-skill',
             createdAt: new Date().toISOString(),
         }, null, 2)}\n`, 'utf-8');
     }
@@ -37,17 +36,6 @@ function migrate(db) {
       dedupe_key TEXT NOT NULL UNIQUE
     );
 
-    CREATE TABLE IF NOT EXISTS hook_runs (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      target TEXT NOT NULL,
-      event_type TEXT NOT NULL,
-      exit_code INTEGER NOT NULL,
-      duration_ms INTEGER NOT NULL,
-      raw_input_json TEXT,
-      error TEXT,
-      occurred_at TEXT NOT NULL
-    );
-
     CREATE TABLE IF NOT EXISTS commits (
       hash TEXT PRIMARY KEY,
       message TEXT,
@@ -81,13 +69,6 @@ export function upsertEvent(store, event) {
         .run(event.type, event.source, event.sourceId || null, event.workspacePath || null, event.summary || null, event.rawJson == null ? null : JSON.stringify(event.rawJson), occurredAt, event.dedupeKey);
     return { inserted: result.changes > 0 };
 }
-export function recordHookRun(store, run) {
-    store.db
-        .prepare(`INSERT INTO hook_runs
-        (target, event_type, exit_code, duration_ms, raw_input_json, error, occurred_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?)`)
-        .run(run.target, run.eventType, run.exitCode, run.durationMs, run.rawInputJson || null, run.error || null, run.occurredAt || new Date().toISOString());
-}
 export function listEvents(store, limit = 100) {
     return store.db
         .prepare('SELECT * FROM events ORDER BY occurred_at ASC, id ASC LIMIT ?')

package/dist/index.js

@@ -2,21 +2,20 @@
 import fs from 'node:fs';
 import { Command } from 'commander';
 import { registerCollaborationCommands } from './commands/collaboration.js';
-import { ingestRawHook, recordGitPostCommit } from './commands/hook.js';
+import { registerLocalKnowledgeCommands, searchKnowledgeEverywhere } from './commands/local-knowledge.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 +124,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 +150,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
@@ -281,8 +234,11 @@ knowledge
     .option('--person <name-or-id>')
     .option('--scope <scope>', 'team|managed|participating|assigned', 'team')
     .option('--limit <number>', 'maximum results', Number)
+    .option('--match <mode>', 'local match mode: any|all|exact', 'any')
+    .option('--cloud-only')
+    .option('--local-only')
     .option('--json')
-    .action(action(async (keyword, options) => print(await resources.searchKnowledge(keyword, options), options.json)));
+    .action(action(async (keyword, options) => print(await searchKnowledgeEverywhere(keyword, options, () => resources.searchKnowledge(keyword, options)), options.json)));
 knowledge
     .command('sources')
     .option('--path <path>')
@@ -293,6 +249,7 @@ knowledge
     .command('source <path>')
     .option('--json')
     .action(action(async (filePath, options) => print(await resources.readKnowledgeSource(filePath), options.json)));
+registerLocalKnowledgeCommands(knowledge, { print, fatal });
 const worklogs = program.command('worklogs');
 worklogs
     .command('list')
@@ -339,16 +296,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 +333,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 +363,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 +373,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 +383,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 +392,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 +400,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) {