@lore-co/cli 0.1.10 → 0.1.12

package/dist/cli.js

@@ -5,7 +5,7 @@ import { randomUUID } from "node:crypto";
 import { delimiter, dirname, resolve } from "node:path";
 import { homedir, platform } from "node:os";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { WorkspaceIdentityResponseSchema, } from "@lore-co/core";
+import { NATIVE_CODING_AGENT_NAMES, WorkspaceIdentityResponseSchema, isNativeCodingAgent, } from "@lore-co/core";
 import { runHook, } from "./runtime.js";
 import { connectGithub, runGithubCommand } from "./github.js";
 import { runDevinCommand } from "./devin.js";
@@ -18,8 +18,17 @@ const LORE_OWNER_ARGUMENT = "--owner lore";
 export const LORE_OPENCODE_PLUGIN = "@lore-co/opencode";
 export const DEFAULT_HOSTED_API_URL = "https://api.uselore.co";
 export const DEFAULT_HOSTED_DASHBOARD_URL = "https://uselore.co";
-const CONFIGURED_AGENT_NAMES = ["claude", "codex", "opencode"];
+const CONFIGURED_AGENT_NAMES = NATIVE_CODING_AGENT_NAMES;
 const HOOK_EVENTS = ["UserPromptSubmit", "Stop", "SessionEnd"];
+const CURSOR_HOOK_EVENTS = [
+    "beforeSubmitPrompt",
+    "afterAgentResponse",
+    "sessionEnd",
+];
+const POLYTOKEN_HOOK_EVENTS = [
+    "pre_user_prompt",
+    "post_model_turn",
+];
 const ROOT_HELP = `lore
 Connect local coding agents to Lore shared engineering memory.
 
@@ -66,7 +75,7 @@ Options:
   --url <url>           Lore API base URL (default: https://api.uselore.co)
   --dashboard-url <url> Lore dashboard URL (default: https://uselore.co for hosted Lore)
   --token <token>       Workspace bearer token (or LORE_WORKSPACE_TOKEN/LORE_TOKEN)
-  --agent <name>        claude, codex, or opencode; repeat to override auto-detection
+  --agent <name>        claude, codex, cursor, opencode, polytoken, or t3code; repeat to override auto-detection
   --timeout-ms <ms>     Hook request timeout, 250-10000 (default: 2500)
   --json                Print machine-readable output
   --help                Show this command's help
@@ -74,6 +83,7 @@ Options:
 Examples:
   lore connect --token "$LORE_WORKSPACE_TOKEN" --agent claude
   lore connect --url http://localhost:3004 --token dev-token --agent codex
+  lore connect --token "$LORE_WORKSPACE_TOKEN" --agent cursor
 `;
 const STATUS_HELP = `lore status
 Show whether Lore is configured and each native integration is installed.
@@ -112,9 +122,14 @@ function isObject(value) {
 function cloneObject(value) {
     return structuredClone(value);
 }
-export function getLorePaths(home) {
-    const resolvedHome = resolve(home ?? process.env.HOME ?? homedir());
+export function getLorePaths(home, environment = process.env) {
+    const resolvedHome = resolve(home ?? environment.HOME ?? homedir());
     const loreDirectory = resolve(resolvedHome, ".lore");
+    const xdgConfigHome = environment.XDG_CONFIG_HOME?.trim() === undefined ||
+        environment.XDG_CONFIG_HOME.trim() === ""
+        ? resolve(resolvedHome, ".config")
+        : resolve(environment.XDG_CONFIG_HOME);
+    const t3Home = resolve(environment.T3CODE_HOME?.trim() || resolve(resolvedHome, ".t3"));
     return {
         home: resolvedHome,
         loreDirectory,
@@ -126,23 +141,30 @@ export function getLorePaths(home) {
         queue: resolve(loreDirectory, "queue"),
         codexHooks: resolve(resolvedHome, ".codex", "hooks.json"),
         claudeSettings: resolve(resolvedHome, ".claude", "settings.json"),
+        cursorHooks: resolve(resolvedHome, ".cursor", "hooks.json"),
+        cursorUserData: platform() === "darwin"
+            ? resolve(resolvedHome, "Library", "Application Support", "Cursor")
+            : resolve(resolvedHome, ".config", "Cursor"),
         openCodeConfig: resolve(resolvedHome, ".config", "opencode", "opencode.json"),
+        polytokenHooks: resolve(xdgConfigHome, "polytoken", "hooks.json"),
+        t3Settings: resolve(t3Home, "userdata", "settings.json"),
     };
 }
 function shellQuote(value) {
     return `'${value.replaceAll("'", "'\"'\"'")}'`;
 }
 function isConfiguredAgent(value) {
-    return (value === "claude" || value === "codex" || value === "opencode");
+    return typeof value === "string" && isNativeCodingAgent(value);
 }
-function isCommandHookAgent(agent) {
-    return agent === "claude" || agent === "codex";
+function isConnectAgent(value) {
+    return isConfiguredAgent(value) || value === "t3code";
 }
 function hookCommand(agent, paths) {
+    const loreHome = `LORE_HOME=${shellQuote(paths.home)}`;
     if (IS_STANDALONE_BINARY) {
-        return `env -u BUN_OPTIONS -u BUN_BE_BUN ${shellQuote(process.execPath)} hook --agent ${agent} ${LORE_OWNER_ARGUMENT}`;
+        return `env -u BUN_OPTIONS -u BUN_BE_BUN ${loreHome} ${shellQuote(process.execPath)} hook --agent ${agent} ${LORE_OWNER_ARGUMENT}`;
     }
-    return `${shellQuote(process.execPath)} ${shellQuote(paths.runtime)} --agent ${agent} ${LORE_OWNER_ARGUMENT}`;
+    return `env ${loreHome} ${shellQuote(process.execPath)} ${shellQuote(paths.runtime)} --agent ${agent} ${LORE_OWNER_ARGUMENT}`;
 }
 function isLoreHook(value) {
     if (!isObject(value) || value.type !== "command") {
@@ -242,6 +264,113 @@ export function countLoreHooks(input) {
     }
     return count;
 }
+function cursorEventHandler(event, paths) {
+    return {
+        type: "command",
+        command: hookCommand("cursor", paths),
+        timeout: event === "sessionEnd" ? 2 : event === "afterAgentResponse" ? 3 : 25,
+    };
+}
+function stripLoreFromCursorEvent(value) {
+    return Array.isArray(value) ? value.filter((hook) => !isLoreHook(hook)) : [];
+}
+export function mergeLoreCursorHooks(input, paths) {
+    const result = cloneObject(input);
+    if (result.version !== undefined && result.version !== 1) {
+        throw new Error('Cursor configuration field "version" must be 1');
+    }
+    if (result.hooks !== undefined && !isObject(result.hooks)) {
+        throw new Error('Cursor configuration field "hooks" must be a JSON object');
+    }
+    const hooks = isObject(result.hooks) ? { ...result.hooks } : {};
+    for (const event of CURSOR_HOOK_EVENTS) {
+        if (hooks[event] !== undefined && !Array.isArray(hooks[event])) {
+            throw new Error(`Cursor hook event "${event}" must be a JSON array`);
+        }
+        hooks[event] = [
+            ...stripLoreFromCursorEvent(hooks[event]),
+            cursorEventHandler(event, paths),
+        ];
+    }
+    result.version = 1;
+    result.hooks = hooks;
+    return result;
+}
+export function removeLoreCursorHooks(input) {
+    const result = cloneObject(input);
+    if (!isObject(result.hooks)) {
+        return result;
+    }
+    const hooks = { ...result.hooks };
+    for (const event of CURSOR_HOOK_EVENTS) {
+        if (!Array.isArray(hooks[event])) {
+            continue;
+        }
+        const remaining = stripLoreFromCursorEvent(hooks[event]);
+        if (remaining.length === 0) {
+            delete hooks[event];
+        }
+        else {
+            hooks[event] = remaining;
+        }
+    }
+    if (Object.keys(hooks).length === 0) {
+        delete result.hooks;
+    }
+    else {
+        result.hooks = hooks;
+    }
+    return result;
+}
+export function countLoreCursorHooks(input) {
+    if (!isObject(input.hooks)) {
+        return 0;
+    }
+    return CURSOR_HOOK_EVENTS.reduce((count, event) => {
+        const hooks = input.hooks;
+        if (!isObject(hooks) || !Array.isArray(hooks[event])) {
+            return count;
+        }
+        return count + hooks[event].filter(isLoreHook).length;
+    }, 0);
+}
+function polytokenEventHandler(event, paths) {
+    return {
+        name: `lore-${event.replaceAll("_", "-")}`,
+        event,
+        handler: { bash: hookCommand("polytoken", paths) },
+    };
+}
+function isLorePolytokenHook(value) {
+    if (!isObject(value) || !isObject(value.handler)) {
+        return false;
+    }
+    const command = value.handler.bash;
+    return (typeof command === "string" &&
+        (/(?:^|\s)--owner(?:=|\s+)lore(?:\s|$)/u.test(command) ||
+            command.includes("/.lore/bin/lore-hook.mjs")));
+}
+export function mergeLorePolytokenHooks(input, paths) {
+    if (!Array.isArray(input)) {
+        throw new Error("Polytoken hooks must contain a JSON array");
+    }
+    const retained = input.filter((hook) => !isLorePolytokenHook(hook));
+    return [
+        ...structuredClone(retained),
+        ...POLYTOKEN_HOOK_EVENTS.map((event) => polytokenEventHandler(event, paths)),
+    ];
+}
+export function removeLorePolytokenHooks(input) {
+    if (!Array.isArray(input)) {
+        throw new Error("Polytoken hooks must contain a JSON array");
+    }
+    return structuredClone(input.filter((hook) => !isLorePolytokenHook(hook)));
+}
+export function countLorePolytokenHooks(input) {
+    return Array.isArray(input)
+        ? input.filter((hook) => isLorePolytokenHook(hook)).length
+        : 0;
+}
 function isLoreOpenCodePlugin(value) {
     return (typeof value === "string" &&
         /^@lore-co\/(?:opencode|opencode-plugin)(?:@[^\s]+)?$/u.test(value));
@@ -284,9 +413,6 @@ async function readJsonDocument(path) {
             stat(path),
         ]);
         const parsed = JSON.parse(raw);
-        if (!isObject(parsed)) {
-            throw new Error(`Expected a JSON object in ${path}`);
-        }
         return {
             exists: true,
             value: parsed,
@@ -298,7 +424,7 @@ async function readJsonDocument(path) {
             ? error.code
             : undefined;
         if (code === "ENOENT") {
-            return { exists: false, value: {}, mode: 0o600 };
+            return { exists: false, value: undefined, mode: 0o600 };
         }
         if (error instanceof SyntaxError) {
             throw new Error(`Refusing to overwrite invalid JSON in ${path}`, {
@@ -347,6 +473,25 @@ function parseConnectorConfig(value) {
         return null;
     }
     const agents = value.agents.filter((agent) => isConfiguredAgent(agent));
+    const parsedAgentConfigPaths = {};
+    if (isObject(value.agentConfigPaths)) {
+        for (const agent of CONFIGURED_AGENT_NAMES) {
+            const paths = value.agentConfigPaths[agent];
+            if (!Array.isArray(paths)) {
+                continue;
+            }
+            const valid = paths.flatMap((path) => {
+                const normalized = typeof path === "string" ? path.trim() : "";
+                return normalized === "" ? [] : [resolve(normalized)];
+            });
+            if (valid.length > 0) {
+                parsedAgentConfigPaths[agent] = [...new Set(valid)];
+            }
+        }
+    }
+    const agentConfigPaths = Object.keys(parsedAgentConfigPaths).length === 0
+        ? undefined
+        : parsedAgentConfigPaths;
     const timeoutMs = typeof value.timeoutMs === "number" &&
         Number.isInteger(value.timeoutMs) &&
         value.timeoutMs >= 250 &&
@@ -362,6 +507,10 @@ function parseConnectorConfig(value) {
         ...(dashboardUrl === undefined ? {} : { dashboardUrl }),
         token: value.token,
         agents,
+        ...(agentConfigPaths === undefined ||
+            Object.keys(agentConfigPaths).length === 0
+            ? {}
+            : { agentConfigPaths }),
         connectedAt: value.connectedAt,
         timeoutMs,
     };
@@ -518,20 +667,266 @@ async function pathExists(path) {
         return false;
     }
 }
+async function cursorAvailable(paths) {
+    return ((await commandExists("cursor")) ||
+        (await pathExists(paths.cursorUserData)));
+}
+function objectConfiguration(input, agent) {
+    if (!isObject(input)) {
+        throw new Error(`${agent} configuration must contain a JSON object`);
+    }
+    return input;
+}
+const AGENT_TARGETS = {
+    claude: {
+        integration: "hooks",
+        expected: HOOK_EVENTS.length,
+        runtimeRequired: true,
+        emptyValue: () => ({}),
+        configPath: (paths) => paths.claudeSettings,
+        detect: async () => commandExists("claude"),
+        executable: async () => commandExists("claude"),
+        merge: (input, paths) => mergeLoreHooks(objectConfiguration(input, "claude"), "claude", paths),
+        remove: (input) => removeLoreHooks(objectConfiguration(input, "claude")),
+        count: (input) => countLoreHooks(objectConfiguration(input, "claude")),
+    },
+    codex: {
+        integration: "hooks",
+        expected: HOOK_EVENTS.length,
+        runtimeRequired: true,
+        emptyValue: () => ({}),
+        configPath: (paths) => paths.codexHooks,
+        detect: async () => commandExists("codex"),
+        executable: async () => commandExists("codex"),
+        merge: (input, paths) => mergeLoreHooks(objectConfiguration(input, "codex"), "codex", paths),
+        remove: (input) => removeLoreHooks(objectConfiguration(input, "codex")),
+        count: (input) => countLoreHooks(objectConfiguration(input, "codex")),
+    },
+    cursor: {
+        integration: "hooks",
+        expected: CURSOR_HOOK_EVENTS.length,
+        runtimeRequired: true,
+        emptyValue: () => ({}),
+        configPath: (paths) => paths.cursorHooks,
+        detect: async (paths) => (await cursorAvailable(paths)) || pathExists(paths.cursorHooks),
+        executable: cursorAvailable,
+        merge: (input, paths) => mergeLoreCursorHooks(objectConfiguration(input, "cursor"), paths),
+        remove: (input) => removeLoreCursorHooks(objectConfiguration(input, "cursor")),
+        count: (input) => countLoreCursorHooks(objectConfiguration(input, "cursor")),
+    },
+    opencode: {
+        integration: "plugin",
+        expected: 1,
+        runtimeRequired: false,
+        emptyValue: () => ({}),
+        configPath: (paths) => paths.openCodeConfig,
+        detect: async (paths) => (await commandExists("opencode")) || pathExists(paths.openCodeConfig),
+        executable: async () => commandExists("opencode"),
+        merge: (input) => mergeLoreOpenCodePlugin(objectConfiguration(input, "opencode")),
+        remove: (input) => removeLoreOpenCodePlugin(objectConfiguration(input, "opencode")),
+        count: (input) => countLoreOpenCodePlugins(objectConfiguration(input, "opencode")),
+    },
+    polytoken: {
+        integration: "hooks",
+        expected: POLYTOKEN_HOOK_EVENTS.length,
+        runtimeRequired: true,
+        emptyValue: () => [],
+        configPath: (paths) => paths.polytokenHooks,
+        detect: async (paths) => (await commandExists("polytoken")) || pathExists(paths.polytokenHooks),
+        executable: async () => commandExists("polytoken"),
+        merge: mergeLorePolytokenHooks,
+        remove: removeLorePolytokenHooks,
+        count: countLorePolytokenHooks,
+    },
+};
+function targetFor(agent) {
+    return AGENT_TARGETS[agent];
+}
 async function detectAgents(paths) {
-    const [codex, claude, openCodeExecutable, openCodeConfig] = await Promise.all([
-        commandExists("codex"),
-        commandExists("claude"),
-        commandExists("opencode"),
-        pathExists(paths.openCodeConfig),
+    const detected = await Promise.all(CONFIGURED_AGENT_NAMES.map(async (agent) => ({
+        agent,
+        detected: await targetFor(agent).detect(paths),
+    })));
+    return detected.flatMap(({ agent, detected: present }) => present ? [agent] : []);
+}
+function installationKey(installation) {
+    return `${installation.agent}\0${resolve(installation.configPath)}`;
+}
+function uniqueInstallations(installations) {
+    const byKey = new Map();
+    for (const installation of installations) {
+        const normalized = {
+            agent: installation.agent,
+            configPath: resolve(installation.configPath),
+        };
+        byKey.set(installationKey(normalized), normalized);
+    }
+    return [...byKey.values()].sort((left, right) => installationKey(left).localeCompare(installationKey(right)));
+}
+function defaultInstallation(agent, paths) {
+    return { agent, configPath: targetFor(agent).configPath(paths) };
+}
+function configuredInstallations(config, paths) {
+    return (config?.agents.flatMap((agent) => {
+        const configuredPaths = config.agentConfigPaths?.[agent];
+        return configuredPaths === undefined
+            ? [defaultInstallation(agent, paths)]
+            : configuredPaths.map((configPath) => ({ agent, configPath }));
+    }) ?? []);
+}
+function nestedObject(input, key) {
+    return isObject(input[key]) ? input[key] : {};
+}
+function firstString(...values) {
+    for (const value of values) {
+        if (typeof value === "string" && value.trim() !== "") {
+            return value.trim();
+        }
+    }
+    return undefined;
+}
+function t3ProviderAgent(key, input) {
+    const config = nestedObject(input, "config");
+    const signal = [
+        key,
+        firstString(input.driver),
+        firstString(input.provider),
+        firstString(input.type),
+        firstString(config.driver),
+        firstString(config.provider),
+        firstString(config.type),
+    ]
+        .filter((value) => value !== undefined)
+        .join(" ")
+        .toLocaleLowerCase();
+    if (signal.includes("opencode")) {
+        return "opencode";
+    }
+    if (signal.includes("cursor")) {
+        return "cursor";
+    }
+    if (signal.includes("claude")) {
+        return "claude";
+    }
+    if (signal.includes("codex")) {
+        return "codex";
+    }
+    return undefined;
+}
+function t3ProviderConfigPath(agent, input, paths) {
+    const config = nestedObject(input, "config");
+    const environment = nestedObject(input, "environment");
+    const configEnvironment = nestedObject(config, "environment");
+    const home = nestedObject(input, "home");
+    const configHome = nestedObject(config, "home");
+    const environmentValue = (key) => environment[key] ?? configEnvironment[key];
+    const homePath = firstString(input.homePath, config.homePath, home.path, configHome.path);
+    if (agent === "codex") {
+        const root = firstString(homePath, environmentValue("CODEX_HOME"));
+        return root === undefined
+            ? paths.codexHooks
+            : resolve(root, "hooks.json");
+    }
+    if (agent === "claude") {
+        const root = firstString(homePath, environmentValue("CLAUDE_CONFIG_DIR"));
+        return root === undefined
+            ? paths.claudeSettings
+            : resolve(root, "settings.json");
+    }
+    if (agent === "cursor") {
+        return paths.cursorHooks;
+    }
+    const serverUrl = firstString(input.serverUrl, config.serverUrl);
+    if (serverUrl !== undefined) {
+        return undefined;
+    }
+    const explicitConfig = firstString(input.configPath, config.configPath, environmentValue("OPENCODE_CONFIG"));
+    if (explicitConfig !== undefined) {
+        return resolve(explicitConfig);
+    }
+    const configDirectory = firstString(input.configDirectory, config.configDirectory, environmentValue("OPENCODE_CONFIG_DIR"));
+    if (configDirectory !== undefined) {
+        return resolve(configDirectory, "opencode.json");
+    }
+    const xdgConfigHome = firstString(environmentValue("XDG_CONFIG_HOME"));
+    return xdgConfigHome === undefined
+        ? paths.openCodeConfig
+        : resolve(xdgConfigHome, "opencode", "opencode.json");
+}
+function discoverT3CodeProviders(settings, paths) {
+    if (!isObject(settings)) {
+        throw new Error("T3 Code settings must contain a JSON object");
+    }
+    const records = [];
+    for (const field of ["providerInstances", "providers"]) {
+        const collection = settings[field];
+        if (!isObject(collection)) {
+            continue;
+        }
+        for (const [key, value] of Object.entries(collection)) {
+            if (isObject(value)) {
+                records.push([key, value]);
+            }
+        }
+    }
+    const warnings = [];
+    const installations = uniqueInstallations(records.flatMap(([key, value]) => {
+        if (value.enabled === false || value.disabled === true) {
+            return [];
+        }
+        const agent = t3ProviderAgent(key, value);
+        if (agent === undefined) {
+            return [];
+        }
+        const configPath = t3ProviderConfigPath(agent, value, paths);
+        if (agent === "opencode" && configPath === undefined) {
+            warnings.push(`T3 Code provider "${key}" uses an external OpenCode server; install and configure Lore on that server.`);
+        }
+        return configPath === undefined ? [] : [{ agent, configPath }];
+    }));
+    return { installations, warnings };
+}
+export function t3CodeProviderInstallations(settings, paths) {
+    return discoverT3CodeProviders(settings, paths).installations;
+}
+async function readT3CodeProviderInstallations(paths) {
+    try {
+        return discoverT3CodeProviders(JSON.parse(await readFile(paths.t3Settings, "utf8")), paths);
+    }
+    catch (error) {
+        const code = typeof error === "object" && error !== null && "code" in error
+            ? error.code
+            : undefined;
+        if (code === "ENOENT") {
+            return { installations: [], warnings: [] };
+        }
+        if (error instanceof SyntaxError) {
+            throw new Error(`Refusing to use invalid T3 Code settings in ${paths.t3Settings}`, { cause: error });
+        }
+        throw error;
+    }
+}
+async function expandConnectInstallations(requested, paths) {
+    const direct = requested.flatMap((agent) => agent === "t3code" ? [] : [defaultInstallation(agent, paths)]);
+    if (!requested.includes("t3code")) {
+        return { installations: direct, warnings: [] };
+    }
+    const configured = await readT3CodeProviderInstallations(paths);
+    const t3Providers = ["claude", "codex", "cursor", "opencode"];
+    const detected = await Promise.all(t3Providers.map(async (agent) => ({
+        agent,
+        available: await targetFor(agent).detect(paths),
+    })));
+    const routed = detected.flatMap(({ agent, available }) => available ? [defaultInstallation(agent, paths)] : []);
+    const installations = uniqueInstallations([
+        ...direct,
+        ...configured.installations,
+        ...routed,
     ]);
-    return [
-        ...(codex ? ["codex"] : []),
-        ...(claude ? ["claude"] : []),
-        ...(openCodeExecutable || openCodeConfig
-            ? ["opencode"]
-            : []),
-    ];
+    if (installations.length === 0) {
+        throw new Error(`T3 Code delegates to provider CLIs, but no supported local Claude, Codex, Cursor, or OpenCode provider was found in ${paths.t3Settings}. Install a provider, set T3CODE_HOME, or connect it explicitly.`);
+    }
+    return { installations, warnings: configured.warnings };
 }
 async function installRuntime(paths) {
     if (IS_STANDALONE_BINARY) {
@@ -553,28 +948,19 @@ async function installRuntime(paths) {
         atomicWrite(paths.runtimePackage, '{"type":"module"}\n', 0o600),
     ]);
 }
-function hookPath(agent, paths) {
-    return agent === "codex" ? paths.codexHooks : paths.claudeSettings;
-}
 function agentConfigPath(agent, paths) {
-    return agent === "opencode"
-        ? paths.openCodeConfig
-        : hookPath(agent, paths);
+    return targetFor(agent).configPath(paths);
 }
 function mergeAgentConfig(input, agent, paths) {
-    return agent === "opencode"
-        ? mergeLoreOpenCodePlugin(input)
-        : mergeLoreHooks(input, agent, paths);
+    const target = targetFor(agent);
+    return target.merge(input === undefined ? target.emptyValue() : input, paths);
 }
 function removeAgentConfig(input, agent) {
-    return agent === "opencode"
-        ? removeLoreOpenCodePlugin(input)
-        : removeLoreHooks(input);
+    return targetFor(agent).remove(input);
 }
 function countAgentIntegrations(input, agent) {
-    return agent === "opencode"
-        ? countLoreOpenCodePlugins(input)
-        : countLoreHooks(input);
+    const target = targetFor(agent);
+    return target.count(input === undefined ? target.emptyValue() : input);
 }
 function parseInteger(value, flag) {
     const parsed = Number(value);
@@ -627,11 +1013,11 @@ function parseConnectArguments(args) {
             }
             parsed.timeoutMs = timeoutMs;
         }
-        else if (isConfiguredAgent(value)) {
+        else if (isConnectAgent(value)) {
             parsed.agents.push(value);
         }
         else {
-            throw new Error("--agent must be claude, codex, or opencode");
+            throw new Error("--agent must be claude, codex, cursor, opencode, polytoken, or t3code");
         }
     }
     return parsed;
@@ -682,50 +1068,63 @@ async function connectCommand(args) {
     }
     const timeoutMs = parsed.timeoutMs ?? existing?.timeoutMs ?? 2_500;
     const identity = await authenticatedIdentity(apiUrl, token.trim(), timeoutMs);
-    const detected = parsed.agents.length === 0 ? await detectAgents(paths) : [];
+    const requestedExpansion = parsed.agents.length === 0
+        ? { installations: [], warnings: [] }
+        : await expandConnectInstallations(parsed.agents, paths);
+    const detectedAgents = parsed.agents.length === 0 ? await detectAgents(paths) : [];
+    const installations = uniqueInstallations([
+        ...configuredInstallations(existing, paths),
+        ...requestedExpansion.installations,
+        ...detectedAgents.map((agent) => defaultInstallation(agent, paths)),
+    ]);
     const agents = [
-        ...new Set([
-            ...(existing?.agents ?? []),
-            ...parsed.agents,
-            ...detected,
-        ]),
+        ...new Set(installations.map((installation) => installation.agent)),
     ].sort();
     if (agents.length === 0) {
-        throw new Error("No Claude, Codex, or OpenCode installation detected. Use --agent <name>.");
+        throw new Error("No Claude, Codex, Cursor, OpenCode, or Polytoken installation detected. Use --agent <name>; T3 Code users can use --agent t3code.");
     }
     const now = new Date();
     const documents = new Map();
     const mergedDocuments = new Map();
-    for (const agent of agents) {
-        const document = await readJsonDocument(agentConfigPath(agent, paths));
-        documents.set(agent, document);
-        mergedDocuments.set(agent, mergeAgentConfig(document.value, agent, paths));
+    for (const installation of installations) {
+        const key = installationKey(installation);
+        const document = await readJsonDocument(installation.configPath);
+        documents.set(key, document);
+        mergedDocuments.set(key, mergeAgentConfig(document.value, installation.agent, paths));
     }
-    if (agents.some(isCommandHookAgent)) {
+    if (installations.some((installation) => targetFor(installation.agent).runtimeRequired)) {
         await installRuntime(paths);
     }
     const changedHookFiles = [];
     const backups = [];
-    for (const agent of agents) {
-        const document = documents.get(agent);
-        const merged = mergedDocuments.get(agent);
+    for (const installation of installations) {
+        const key = installationKey(installation);
+        const document = documents.get(key);
+        const merged = mergedDocuments.get(key);
         if (document === undefined || merged === undefined) {
             continue;
         }
-        const result = await writeMergedJson(agentConfigPath(agent, paths), document, merged, now);
+        const result = await writeMergedJson(installation.configPath, document, merged, now);
         if (result.changed) {
-            changedHookFiles.push(agentConfigPath(agent, paths));
+            changedHookFiles.push(installation.configPath);
         }
         if (result.backup !== undefined) {
             backups.push(result.backup);
         }
     }
+    const agentConfigPaths = {};
+    for (const agent of agents) {
+        agentConfigPaths[agent] = installations
+            .filter((installation) => installation.agent === agent)
+            .map((installation) => installation.configPath);
+    }
     const config = {
         version: 1,
         apiUrl,
         ...(dashboardUrl === undefined ? {} : { dashboardUrl }),
         token: token.trim(),
         agents,
+        agentConfigPaths,
         connectedAt: existing?.connectedAt ?? now.toISOString(),
         timeoutMs,
     };
@@ -738,8 +1137,9 @@ async function connectCommand(args) {
         config: paths.config,
         changedHookFiles,
         backups,
+        warnings: requestedExpansion.warnings,
     };
-    writeResult(result, parsed.json, `connected: ${agents.join(", ")}\napi_url: ${config.apiUrl}\nconfig: ${paths.config}\n`);
+    writeResult(result, parsed.json, `connected: ${agents.join(", ")}\napi_url: ${config.apiUrl}\nconfig: ${paths.config}\n${requestedExpansion.warnings.map((warning) => `warning: ${warning}\n`).join("")}`);
 }
 async function queueCount(paths) {
     try {
@@ -750,23 +1150,33 @@ async function queueCount(paths) {
     }
 }
 async function getAgentStatus(agent, config, paths) {
-    const path = agentConfigPath(agent, paths);
+    const target = targetFor(agent);
+    const configuredPaths = config?.agentConfigPaths?.[agent];
+    const configPaths = config?.agents.includes(agent) === true && configuredPaths !== undefined
+        ? configuredPaths
+        : [agentConfigPath(agent, paths)];
     let installed = 0;
-    try {
-        installed = countAgentIntegrations((await readJsonDocument(path)).value, agent);
-    }
-    catch {
-        installed = 0;
+    let existing = 0;
+    for (const path of configPaths) {
+        try {
+            const document = await readJsonDocument(path);
+            installed += countAgentIntegrations(document.value, agent);
+            existing += document.exists ? 1 : 0;
+        }
+        catch {
+            // A malformed target config is reported as missing integration state.
+        }
     }
     return {
         agent,
         configured: config?.agents.includes(agent) ?? false,
-        executable: await commandExists(agent),
-        configExists: await pathExists(path),
-        configFile: path,
-        integration: agent === "opencode" ? "plugin" : "hooks",
+        executable: await target.executable(paths),
+        configExists: existing === configPaths.length,
+        configFile: configPaths[0] ?? agentConfigPath(agent, paths),
+        ...(configPaths.length > 1 ? { configFiles: configPaths } : {}),
+        integration: target.integration,
         installed,
-        expected: agent === "opencode" ? 1 : HOOK_EVENTS.length,
+        expected: target.expected * configPaths.length,
     };
 }
 async function statusData(paths) {
@@ -778,7 +1188,7 @@ async function statusData(paths) {
     catch {
         // Missing configuration is represented as disconnected.
     }
-    const runtimeRequired = config?.agents.some(isCommandHookAgent) ?? false;
+    const runtimeRequired = config?.agents.some((agent) => targetFor(agent).runtimeRequired) ?? false;
     const runtimeInstalledCheck = runtimeRequired
         ? Promise.all(IS_STANDALONE_BINARY
             ? [access(process.execPath, fsConstants.R_OK | fsConstants.X_OK)]
@@ -788,12 +1198,10 @@ async function statusData(paths) {
                 access(paths.runtimePackage, fsConstants.R_OK),
             ]).then(() => true, () => false)
         : Promise.resolve(false);
-    const [runtimeInstalled, queuedTurns, claude, codex, opencode] = await Promise.all([
+    const [runtimeInstalled, queuedTurns, agents] = await Promise.all([
         runtimeInstalledCheck,
         queueCount(paths),
-        getAgentStatus("claude", config, paths),
-        getAgentStatus("codex", config, paths),
-        getAgentStatus("opencode", config, paths),
+        Promise.all(CONFIGURED_AGENT_NAMES.map(async (agent) => getAgentStatus(agent, config, paths))),
     ]);
     return {
         connected: config !== null,
@@ -803,7 +1211,7 @@ async function statusData(paths) {
         runtimeRequired,
         runtimeInstalled,
         queuedTurns,
-        agents: [claude, codex, opencode],
+        agents,
     };
 }
 async function statusCommand(args) {
@@ -823,16 +1231,21 @@ async function disconnectCommand(args) {
         return;
     }
     const paths = getLorePaths();
+    const config = await readConnectorConfig(paths);
     const now = new Date();
     const changedHookFiles = [];
     const backups = [];
-    for (const agent of CONFIGURED_AGENT_NAMES) {
-        const path = agentConfigPath(agent, paths);
+    const installations = uniqueInstallations([
+        ...CONFIGURED_AGENT_NAMES.map((agent) => defaultInstallation(agent, paths)),
+        ...configuredInstallations(config, paths),
+    ]);
+    for (const installation of installations) {
+        const path = installation.configPath;
         const document = await readJsonDocument(path);
         if (!document.exists) {
             continue;
         }
-        const result = await writeMergedJson(path, document, removeAgentConfig(document.value, agent), now);
+        const result = await writeMergedJson(path, document, removeAgentConfig(document.value, installation.agent), now);
         if (result.changed) {
             changedHookFiles.push(path);
         }
@@ -952,7 +1365,7 @@ async function doctorCommand(args) {
         checks.push({
             name: `${agent.agent}-executable`,
             status: agent.executable ? "ok" : "warning",
-            detail: agent.executable ? "found on PATH" : "not found on PATH",
+            detail: agent.executable ? "detected" : "not detected",
         });
         checks.push({
             name: `${agent.agent}-${agent.integration}`,