@magclaw/cli-core 0.1.39 → 0.1.40

package/src/cli.js

@@ -7,56 +7,11 @@ import { chmod, copyFile, cp, lstat, mkdir, open, readFile, readdir, readlink, r
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { parseCli } from './cli-core/args.js';
+import { runExternalTeamSharingCommand } from './cli-core/team-sharing-delegate.js';
 import { renderListProfiles, shouldUseColor } from './list-renderer.js';
-import {
-  buildTeamMemorySyncPackageFromTranscript,
-  installTeamMemoryHookConfig,
-  parseTeamMemoryTranscript,
-} from './team-memory-hooks.js';
-import {
-  checkTeamSharingUpgrade,
-  convertTeamSharingProjectToMemoryConfig,
-  disableTeamSharingSkill,
-  initTeamSharingProject,
-  installTeamSharingHooks,
-  installTeamSharingSkill,
-  listTeamSharingProjects,
-  loginTeamSharingProfile,
-  logoutTeamSharingProfile,
-  readTeamSharingProfileConfig,
-  readTeamSharingProjectConfig,
-  removeTeamSharingHooks,
-  removeTeamSharingSkill,
-  setTeamSharingProjectEnabled,
-  setupTeamSharing,
-  statusTeamSharingProject,
-  statusTeamSharingHooks,
-  statusTeamSharingSkill,
-  teamSharingPaths,
-  unsetTeamSharingProject,
-  whoamiTeamSharingProfile,
-} from './team-sharing.js';
-
-export {
-  checkTeamSharingUpgrade,
-  disableTeamSharingSkill,
-  initTeamSharingProject,
-  installTeamSharingHooks,
-  installTeamSharingSkill,
-  listTeamSharingProjects,
-  loginTeamSharingProfile,
-  logoutTeamSharingProfile,
-  removeTeamSharingHooks,
-  removeTeamSharingSkill,
-  setTeamSharingProjectEnabled,
-  setupTeamSharing,
-  statusTeamSharingProject,
-  statusTeamSharingHooks,
-  statusTeamSharingSkill,
-  teamSharingPaths,
-  unsetTeamSharingProject,
-  whoamiTeamSharingProfile,
-} from './team-sharing.js';
+
+export { parseCli } from './cli-core/args.js';
 
 export const DEFAULT_PROFILE = 'default';
 export const DEFAULT_SERVER_URL = 'http://127.0.0.1:6543';
@@ -682,51 +637,6 @@ async function acquireDaemonLock(profile = DEFAULT_PROFILE, config = {}, env = p
   throw new Error(`MagClaw daemon profile "${paths.profile}" is already starting.`);
 }
 
-function parseFlagKey(item) {
-  return item
-    .replace(/^--/, '')
-    .replace(/-([a-z])/g, (_match, char) => char.toUpperCase());
-}
-
-export function parseCli(argv = process.argv) {
-  const args = argv.slice(2);
-  const command = args[0] && !args[0].startsWith('-') ? args.shift() : 'connect';
-  const flags = {};
-  const positionals = [];
-  for (let index = 0; index < args.length; index += 1) {
-    const item = args[index];
-    if (item === '-h') {
-      flags.help = true;
-      continue;
-    }
-    if (item === '-V') {
-      flags.version = true;
-      continue;
-    }
-    if (!item.startsWith('--')) {
-      positionals.push(item);
-      continue;
-    }
-    const equalsIndex = item.indexOf('=');
-    if (equalsIndex > 2) {
-      flags[parseFlagKey(item.slice(0, equalsIndex))] = item.slice(equalsIndex + 1);
-      continue;
-    }
-    const key = parseFlagKey(item);
-    const next = args[index + 1];
-    if (!next || next.startsWith('--')) {
-      flags[key] = true;
-    } else {
-      flags[key] = next;
-      index += 1;
-    }
-  }
-  flags._ = positionals;
-  flags.profileExplicit = Boolean(flags.profile);
-  flags.profile = safeProfileName(flags.profile || process.env.MAGCLAW_DAEMON_PROFILE || DEFAULT_PROFILE);
-  return { command, flags };
-}
-
 function renderHelp() {
   return [
     `MagClaw daemon CLI ${DAEMON_VERSION}`,
@@ -743,10 +653,9 @@ function renderHelp() {
     '  list         List local daemon profiles and connected Computers',
     '  logs         Print recent daemon logs for one profile',
     '  install-cli  Install or repair durable magclaw command shims',
-    '  memory       Configure and use MagClaw team-memory sync',
-    '  team-sharing Configure MagClaw Team Sharing setup, login, hooks, and skill',
-    '  skills       Install or manage MagClaw feature skills',
-    '  hooks        Install or manage MagClaw feature hooks',
+    '  team-sharing Delegate to the standalone @magclaw/team-sharing CLI',
+    '  skills       Delegate Team Sharing skill management to @magclaw/team-sharing',
+    '  hooks        Delegate Team Sharing hook management to @magclaw/team-sharing',
     '  upgrade      Upgrade the background daemon package',
     '  doctor       Show runtime and environment diagnostics',
     '  uninstall    Stop and remove the background daemon service',
@@ -936,85 +845,6 @@ async function writeJsonFile(file, value) {
   await writeFile(file, `${JSON.stringify(value, null, 2)}\n`);
 }
 
-export function teamMemoryPaths({ profile = DEFAULT_PROFILE, cwd = process.cwd(), env = process.env } = {}) {
-  const home = homeDirForEnv(env) || os.homedir();
-  const memoryHome = path.resolve(env.MAGCLAW_MEMORY_HOME || path.join(home, '.magclaw', 'memory'));
-  const cleanProfile = safeProfileName(profile || env.MAGCLAW_MEMORY_PROFILE || DEFAULT_PROFILE);
-  const projectDir = path.resolve(cwd || process.cwd());
-  return {
-    profile: cleanProfile,
-    memoryHome,
-    profilesDir: path.join(memoryHome, 'profiles'),
-    profileConfig: path.join(memoryHome, 'profiles', cleanProfile, 'config.json'),
-    projectConfig: path.join(projectDir, '.magclaw', 'team-memory.json'),
-    projectCursor: path.join(projectDir, '.magclaw', 'team-memory-cursor.json'),
-  };
-}
-
-function normalizeMemoryServerUrl(value = '') {
-  return String(value || DEFAULT_SERVER_URL).replace(/\/+$/, '');
-}
-
-export async function loginTeamMemoryProfile(flags = {}, env = process.env) {
-  const paths = teamMemoryPaths({ profile: flags.profile || env.MAGCLAW_MEMORY_PROFILE || DEFAULT_PROFILE, env });
-  const existing = await readJsonFile(paths.profileConfig, {});
-  const token = String(flags.token || flags.apiKey || flags.memoryToken || env.MAGCLAW_MEMORY_TOKEN || existing.token || '').trim();
-  const serverUrl = normalizeMemoryServerUrl(flags.serverUrl || existing.serverUrl || env.MAGCLAW_PUBLIC_URL || DEFAULT_SERVER_URL);
-  const profile = {
-    version: 1,
-    profile: paths.profile,
-    serverUrl,
-    workspaceId: String(flags.workspaceId || flags.workspace || existing.workspaceId || env.MAGCLAW_WORKSPACE_ID || 'local').trim(),
-    token,
-    tokenScope: ['team_memory:sync', 'team_memory:search', 'team_memory:context', 'team_memory:feedback'],
-    updatedAt: now(),
-    createdAt: existing.createdAt || now(),
-  };
-  await writeJsonFile(paths.profileConfig, profile);
-  return {
-    ok: true,
-    profile: paths.profile,
-    serverUrl,
-    workspaceId: profile.workspaceId,
-    hasToken: Boolean(token),
-    profileConfig: paths.profileConfig,
-  };
-}
-
-export async function initTeamMemoryProject(flags = {}, env = process.env) {
-  const cwd = path.resolve(flags.cwd || process.cwd());
-  const paths = teamMemoryPaths({ profile: flags.profile || env.MAGCLAW_MEMORY_PROFILE || DEFAULT_PROFILE, cwd, env });
-  const channel = String(flags.channel || flags.channelId || flags.channelPath || flags._?.[1] || '').trim();
-  if (!channel) throw new Error('Usage: magclaw memory init --channel <channelPathOrId>');
-  const existing = await readJsonFile(paths.projectConfig, {});
-  const projectKey = String(flags.projectKey || existing.projectKey || path.basename(cwd)).trim();
-  const config = {
-    version: 1,
-    enabled: flags.enabled === undefined ? true : !['0', 'false', 'no'].includes(String(flags.enabled).toLowerCase()),
-    profile: paths.profile,
-    serverUrl: normalizeMemoryServerUrl(flags.serverUrl || existing.serverUrl || env.MAGCLAW_PUBLIC_URL || DEFAULT_SERVER_URL),
-    workspaceId: String(flags.workspaceId || flags.workspace || existing.workspaceId || env.MAGCLAW_WORKSPACE_ID || 'local').trim(),
-    channelId: String(flags.channelId || (!/^(https?|feishu|lark|mc):/i.test(channel) ? channel : existing.channelId || '')).trim(),
-    channelPath: String(flags.channelPath || (/^(https?|feishu|lark|mc):/i.test(channel) ? channel : existing.channelPath || '')).trim(),
-    routingMode: 'fixed_single_channel',
-    projectKey,
-    enabledRuntimes: ['codex', 'claude_code'],
-    updatedAt: now(),
-    createdAt: existing.createdAt || now(),
-  };
-  await writeJsonFile(paths.projectConfig, config);
-  return {
-    ok: true,
-    projectConfig: paths.projectConfig,
-    profile: paths.profile,
-    serverUrl: config.serverUrl,
-    workspaceId: config.workspaceId,
-    channelId: config.channelId,
-    channelPath: config.channelPath,
-    projectKey,
-  };
-}
-
 async function readProfile(profile, env = process.env) {
   const paths = profilePaths(profile, env);
   const config = await readJsonFile(paths.config, {});
@@ -6699,469 +6529,6 @@ async function postSetupJson(serverUrl, pathname, body = {}) {
   return data;
 }
 
-async function teamMemoryRequestJson({ serverUrl, token = '', method = 'GET', pathname = '/api/team-memory/doctor', body = null } = {}) {
-  const response = await fetch(`${normalizeMemoryServerUrl(serverUrl)}${pathname}`, {
-    method,
-    headers: {
-      ...(body ? { 'content-type': 'application/json' } : {}),
-      ...(token ? { authorization: `Bearer ${token}` } : {}),
-    },
-    ...(body ? { body: JSON.stringify(body) } : {}),
-  });
-  const data = await response.json().catch(() => ({}));
-  if (!response.ok) {
-    throw new Error(data.error || data.message || `${response.status} ${response.statusText}`);
-  }
-  return data;
-}
-
-async function readTeamMemoryProjectConfig(flags = {}, env = process.env) {
-  const paths = teamMemoryPaths({ profile: flags.profile || env.MAGCLAW_MEMORY_PROFILE || DEFAULT_PROFILE, cwd: flags.cwd || process.cwd(), env });
-  const teamSharing = await readTeamSharingProjectConfig({ profile: flags.profile || env.MAGCLAW_TEAM_SHARING_PROFILE || env.MAGCLAW_MEMORY_PROFILE || DEFAULT_PROFILE, cwd: flags.cwd || process.cwd(), env });
-  if (teamSharing.config) {
-    return {
-      paths: {
-        ...paths,
-        teamSharingProjectConfig: teamSharing.paths.projectConfig,
-      },
-      config: convertTeamSharingProjectToMemoryConfig(teamSharing.config),
-    };
-  }
-  return {
-    paths,
-    config: await readJsonFile(paths.projectConfig, null),
-  };
-}
-
-async function readTeamMemoryProfile(profile, env = process.env) {
-  const paths = teamMemoryPaths({ profile, env });
-  const sharing = await readTeamSharingProfileConfig(profile, env);
-  if (sharing.config?.token || sharing.config?.server_url) {
-    return {
-      paths: {
-        ...paths,
-        teamSharingProfileConfig: sharing.paths.profileConfig,
-      },
-      config: {
-        version: sharing.config.version || 1,
-        profile: sharing.config.profile || profile,
-        serverUrl: sharing.config.server_url || sharing.config.serverUrl,
-        workspaceId: sharing.config.workspace_id || sharing.config.workspaceId,
-        token: sharing.config.token,
-      },
-    };
-  }
-  return {
-    paths,
-    config: await readJsonFile(paths.profileConfig, {}),
-  };
-}
-
-async function resolveTeamMemoryClient(flags = {}, env = process.env) {
-  const project = await readTeamMemoryProjectConfig(flags, env);
-  if (!project.config) throw new Error('Run `magclaw memory init --channel <channel>` in this project first.');
-  const profile = await readTeamMemoryProfile(flags.profile || project.config.profile || DEFAULT_PROFILE, env);
-  return {
-    project,
-    profile,
-    serverUrl: flags.serverUrl || project.config.serverUrl || profile.config.serverUrl || DEFAULT_SERVER_URL,
-    token: String(profile.config.token || env.MAGCLAW_MEMORY_TOKEN || '').trim(),
-  };
-}
-
-async function doctorTeamMemory(flags = {}, env = process.env) {
-  const project = await readTeamMemoryProjectConfig(flags, env);
-  const profileName = flags.profile || project.config?.profile || env.MAGCLAW_MEMORY_PROFILE || DEFAULT_PROFILE;
-  const profile = await readTeamMemoryProfile(profileName, env);
-  const serverUrl = normalizeMemoryServerUrl(flags.serverUrl || project.config?.serverUrl || profile.config.serverUrl || DEFAULT_SERVER_URL);
-  const token = String(profile.config.token || env.MAGCLAW_MEMORY_TOKEN || '').trim();
-  const local = {
-    projectConfig: { exists: Boolean(project.config), path: project.paths.projectConfig },
-    profileConfig: { exists: Boolean(profile.config?.profile), path: profile.paths.profileConfig },
-    hasToken: Boolean(token),
-    channelConfigured: Boolean(project.config?.channelId || project.config?.channelPath),
-  };
-  if (flags.offline) {
-    return { ok: Object.values(local).every((item) => typeof item === 'boolean' ? item : item.exists !== false), local, remote: null };
-  }
-  try {
-    const remote = await teamMemoryRequestJson({ serverUrl, token, pathname: '/api/team-memory/doctor' });
-    return {
-      ok: Boolean(local.projectConfig.exists && local.profileConfig.exists && local.channelConfigured && remote.ok),
-      serverUrl,
-      local,
-      remote,
-    };
-  } catch (error) {
-    return {
-      ok: false,
-      serverUrl,
-      local,
-      remote: { ok: false, error: error?.message || String(error) },
-    };
-  }
-}
-
-function cursorLastOrdinal(cursor = {}, runtime = 'codex', sessionId = '') {
-  return Number(cursor?.sessions?.[runtime]?.[sessionId]?.lastOrdinal || 0);
-}
-
-async function writeTeamMemoryCursor(file, runtime, cursor) {
-  const existing = await readJsonFile(file, {});
-  const sessions = existing.sessions && typeof existing.sessions === 'object' ? existing.sessions : {};
-  sessions[runtime] = sessions[runtime] && typeof sessions[runtime] === 'object' ? sessions[runtime] : {};
-  sessions[runtime][cursor.sessionId] = {
-    ...(sessions[runtime][cursor.sessionId] || {}),
-    ...cursor,
-  };
-  await writeJsonFile(file, {
-    version: 1,
-    sessions,
-    updatedAt: now(),
-  });
-}
-
-export async function syncTeamMemoryTranscript(flags = {}, env = process.env) {
-  const transcriptPath = String(flags.transcript || flags.file || flags._?.[1] || '').trim();
-  if (!transcriptPath) {
-    if (flags.hookEvent) return { ok: true, empty: true, reason: 'missing_transcript_path' };
-    throw new Error('Usage: magclaw memory sync --transcript <path>');
-  }
-  const project = await readTeamMemoryProjectConfig(flags, env);
-  if (!project.config) throw new Error('Run `magclaw memory init --channel <channel>` in this project first.');
-  const runtime = String(flags.runtime || 'codex').trim().toLowerCase() === 'claude' || String(flags.runtime || '').trim().toLowerCase() === 'claude-code'
-    ? 'claude_code'
-    : String(flags.runtime || 'codex').trim().toLowerCase();
-  if (project.config.enabled === false) {
-    if (flags.hookEvent) return { ok: true, empty: true, reason: 'project_disabled' };
-    throw new Error('Team Sharing is disabled for this project.');
-  }
-  const runtimeConfig = project.config.runtimes?.[runtime];
-  if (flags.hookEvent && runtimeConfig && runtimeConfig.hooksEnabled === false) {
-    return { ok: true, empty: true, reason: 'runtime_hooks_disabled' };
-  }
-  const profile = await readTeamMemoryProfile(flags.profile || project.config.profile || DEFAULT_PROFILE, env);
-  const token = String(profile.config.token || env.MAGCLAW_MEMORY_TOKEN || '').trim();
-  const content = await readFile(path.resolve(transcriptPath), 'utf8');
-  const parsed = parseTeamMemoryTranscript(content, {
-    runtime,
-    sessionId: flags.sessionId || '',
-    title: flags.title || '',
-    projectDir: flags.cwd || process.cwd(),
-  });
-  const cursor = await readJsonFile(project.paths.projectCursor, {});
-  const lastOrdinal = Number(flags.full ? 0 : cursorLastOrdinal(cursor, parsed.runtime, parsed.sessionId));
-  const syncPackage = buildTeamMemorySyncPackageFromTranscript(content, {
-    runtime: parsed.runtime,
-    sessionId: parsed.sessionId,
-    title: flags.title || parsed.title || path.basename(transcriptPath),
-    projectKey: project.config.projectKey,
-    workspaceId: project.config.workspaceId,
-    channelId: project.config.channelId,
-    channelPath: project.config.channelPath,
-    projectDir: flags.cwd || process.cwd(),
-    lastOrdinal,
-    minCreatedAt: project.config.enabledSince || '',
-  });
-  if (syncPackage.empty || !syncPackage.body) return { ok: true, empty: true, cursor: syncPackage.cursor };
-  const result = await teamMemoryRequestJson({
-    serverUrl: flags.serverUrl || project.config.serverUrl || profile.config.serverUrl || DEFAULT_SERVER_URL,
-    token,
-    method: 'POST',
-    pathname: '/api/team-memory/sync',
-    body: syncPackage.body,
-  });
-  if (result?.ok !== false) {
-    await writeTeamMemoryCursor(project.paths.projectCursor, parsed.runtime, syncPackage.cursor);
-  }
-  return {
-    ...result,
-    cursor: syncPackage.cursor,
-  };
-}
-
-export async function installTeamMemoryHooks(flags = {}, env = process.env) {
-  const home = homeDirForEnv(env) || os.homedir();
-  const cwd = path.resolve(flags.cwd || process.cwd());
-  const runtime = String(flags.runtime || 'all').trim().toLowerCase();
-  const output = { ok: true };
-  if (runtime === 'all' || runtime === 'codex') {
-    output.codex = await installTeamMemoryHookConfig({
-      runtime: 'codex',
-      configPath: flags.codexConfig || path.join(home, '.codex', 'hooks.json'),
-      projectDir: cwd,
-    });
-  }
-  if (runtime === 'all' || runtime === 'claude' || runtime === 'claude_code' || runtime === 'claude-code') {
-    output.claude = await installTeamMemoryHookConfig({
-      runtime: 'claude_code',
-      configPath: flags.claudeConfig || path.join(home, '.claude', 'settings.json'),
-      projectDir: cwd,
-    });
-  }
-  output.ok = Boolean((!output.codex || output.codex.ok) && (!output.claude || output.claude.ok));
-  return output;
-}
-
-export async function searchTeamMemory(flags = {}, env = process.env) {
-  const query = String(flags.query || flags._?.slice(1).join(' ') || '').trim();
-  if (!query) throw new Error('Usage: magclaw memory search --query <text>');
-  const { project, serverUrl, token } = await resolveTeamMemoryClient(flags, env);
-  return teamMemoryRequestJson({
-    serverUrl,
-    token,
-    method: 'POST',
-    pathname: '/api/team-memory/search',
-    body: {
-      query,
-      channelId: flags.channelId || project.config.channelId || '',
-      projectKey: flags.projectKey || project.config.projectKey || '',
-      dateRange: flags.dateRange || null,
-      candidateK: flags.candidateK || undefined,
-      limit: flags.limit || 5,
-    },
-  });
-}
-
-export async function readTeamMemoryContext(flags = {}, env = process.env) {
-  const sessionId = String(flags.sessionId || flags.session || flags._?.[1] || '').trim();
-  if (!sessionId) throw new Error('Usage: magclaw memory context --session-id <sessionId>');
-  const { serverUrl, token } = await resolveTeamMemoryClient(flags, env);
-  const params = new URLSearchParams();
-  if (flags.anchorEventId || flags.anchor) params.set('anchorEventId', String(flags.anchorEventId || flags.anchor));
-  if (flags.direction) params.set('direction', String(flags.direction));
-  if (flags.limit) params.set('limit', String(flags.limit));
-  const suffix = params.toString() ? `?${params.toString()}` : '';
-  return teamMemoryRequestJson({
-    serverUrl,
-    token,
-    pathname: `/api/team-memory/context/${encodeURIComponent(sessionId)}${suffix}`,
-  });
-}
-
-function teamMemorySkillMarkdown() {
-  return [
-    '---',
-    'name: magclaw-team-memory',
-    'description: Search and read MagClaw team memory shared from Codex and Claude Code sessions.',
-    '---',
-    '',
-    '# MagClaw Team Memory',
-    '',
-    'Use this skill when the user asks what the team discussed, wants to align with another session, or needs original AI conversation context.',
-    '',
-    '## Workflow',
-    '',
-    '1. Run `magclaw memory search --query "<question>" --limit 5` from the project directory.',
-    '2. Answer from the returned L0/L1 evidence when the user only needs a rough understanding.',
-    '3. For deep follow-up, run `magclaw memory context --session-id <sessionId> --anchor-event-id <eventId> --direction around --limit 20`.',
-    '4. Cite session titles, source refs, and context URLs from the command output.',
-    '',
-    '## Rules',
-    '',
-    '- Do not upload local secrets or raw tool output.',
-    '- Prefer concise synthesis first, then pull original context only when needed.',
-    '- If search returns low confidence or too few results, ask a narrower question or date range.',
-    '',
-  ].join('\n');
-}
-
-async function writeTeamMemorySkill(rootDir) {
-  const skillDir = path.join(rootDir, 'skills', 'magclaw-team-memory');
-  await mkdir(skillDir, { recursive: true });
-  const skillPath = path.join(skillDir, 'SKILL.md');
-  await writeFile(skillPath, teamMemorySkillMarkdown());
-  return skillPath;
-}
-
-export async function installTeamMemorySkill(flags = {}, env = process.env) {
-  const home = homeDirForEnv(env) || os.homedir();
-  const target = String(flags.target || 'codex').trim().toLowerCase();
-  const output = { ok: true, installed: [] };
-  if (target === 'codex' || target === 'all') {
-    const codexHome = path.resolve(env.CODEX_HOME || path.join(home, '.codex'));
-    output.installed.push({ target: 'codex', path: await writeTeamMemorySkill(codexHome) });
-  }
-  if (target === 'claude' || target === 'claude_code' || target === 'claude-code' || target === 'all') {
-    const claudeHome = path.resolve(env.CLAUDE_HOME || path.join(home, '.claude'));
-    output.installed.push({ target: 'claude_code', path: await writeTeamMemorySkill(claudeHome) });
-  }
-  output.ok = output.installed.length > 0;
-  return output;
-}
-
-async function runTeamMemoryCommand(flags = {}, env = process.env) {
-  const subcommand = String(flags._?.[0] || 'help').trim();
-  if (subcommand === 'help' || flags.help) {
-    process.stdout.write([
-      'Usage: magclaw memory <command> [options]',
-      '',
-      'Commands:',
-      '  login   Save a scoped team-memory token in the user profile',
-      '  init    Write .magclaw/team-memory.json for the current project',
-      '  doctor  Check local and server-side team-memory configuration',
-      '  install-hooks  Install Codex/Claude hook commands for this project',
-      '  install-skill  Install the MagClaw team-memory skill locally',
-      '  search  Query shared team memory through /api/team-memory/search',
-      '  context Read original context around a session anchor',
-      '  sync    Upload one transcript file through /api/team-memory/sync',
-      '',
-    ].join('\n'));
-    return;
-  }
-  switch (subcommand) {
-    case 'login':
-      printJson(await loginTeamMemoryProfile(flags, env));
-      break;
-    case 'init':
-      printJson(await initTeamMemoryProject(flags, env));
-      break;
-    case 'doctor':
-      printJson(await doctorTeamMemory(flags, env));
-      break;
-    case 'install-hooks':
-    case 'install':
-      printJson(await installTeamMemoryHooks(flags, env));
-      break;
-    case 'install-skill':
-    case 'skill':
-      printJson(await installTeamMemorySkill(flags, env));
-      break;
-    case 'search':
-      printJson(await searchTeamMemory(flags, env));
-      break;
-    case 'context':
-      printJson(await readTeamMemoryContext(flags, env));
-      break;
-    case 'sync':
-      printJson(await syncTeamMemoryTranscript(flags, env));
-      break;
-    default:
-      throw new Error(`Unknown memory command: ${subcommand}`);
-  }
-}
-
-async function runTeamSharingCommand(flags = {}, env = process.env) {
-  const subcommand = String(flags._?.[0] || 'help').trim();
-  if (subcommand === 'help' || flags.help) {
-    process.stdout.write([
-      'Usage: magclaw team-sharing <command> [options]',
-      '',
-      'Commands:',
-      '  setup    Configure login, project channel, hooks, and skill',
-      '  login    Browser/device login for scoped team-memory sync token',
-      '  logout   Revoke and remove the cached Team Sharing token',
-      '  relogin  Force a fresh browser/device login',
-      '  whoami   Show the current Team Sharing identity',
-      '  projects List configured project paths',
-      '  init     Write .magclaw/team-sharing.yaml for this project',
-      '  unset    Remove this project Team Sharing config',
-      '  enable   Enable this project sync',
-      '  disable  Disable this project sync',
-      '  status   Show project/login/hook/skill status',
-      '  doctor   Check local config, server auth, hooks, skill, and upgrade state',
-      '  upgrade  Check npm latest version for team-sharing',
-      '  search   Query shared team memory',
-      '  context  Read original context around an anchor',
-      '  sync     Upload one transcript file',
-      '',
-    ].join('\n'));
-    return;
-  }
-  switch (subcommand) {
-    case 'setup':
-    case 'install':
-      printJson({
-        ...(await setupTeamSharing(flags, env)),
-        cli: flags.noInstallCli ? { ok: true, skipped: true } : await installCliShim(flags, env),
-      });
-      break;
-    case 'login':
-      printJson(await loginTeamSharingProfile(flags, env));
-      break;
-    case 'relogin':
-      await logoutTeamSharingProfile(flags, env);
-      printJson(await loginTeamSharingProfile(flags, env));
-      break;
-    case 'logout':
-      printJson(await logoutTeamSharingProfile(flags, env));
-      break;
-    case 'whoami':
-      printJson(await whoamiTeamSharingProfile(flags, env));
-      break;
-    case 'projects':
-      printJson(await listTeamSharingProjects(flags, env));
-      break;
-    case 'init':
-      printJson(await initTeamSharingProject(flags, env));
-      break;
-    case 'unset':
-      printJson(await unsetTeamSharingProject(flags, env));
-      break;
-    case 'enable':
-      printJson(await setTeamSharingProjectEnabled(flags, env, true));
-      break;
-    case 'disable':
-      printJson(await setTeamSharingProjectEnabled(flags, env, false));
-      break;
-    case 'status':
-      printJson({
-        ok: true,
-        project: await statusTeamSharingProject(flags, env),
-        hooks: await statusTeamSharingHooks({ ...flags, target: flags.target || 'all' }, env),
-        skill: await statusTeamSharingSkill({ ...flags, target: flags.target || 'all' }, env),
-      });
-      break;
-    case 'doctor':
-      printJson({
-        ok: true,
-        project: await statusTeamSharingProject(flags, env),
-        hooks: await statusTeamSharingHooks({ ...flags, target: flags.target || 'all' }, env),
-        skill: await statusTeamSharingSkill({ ...flags, target: flags.target || 'all' }, env),
-        upgrade: await checkTeamSharingUpgrade({ force: Boolean(flags.force) }, env).catch((error) => ({ ok: false, error: error.message })),
-      });
-      break;
-    case 'upgrade':
-      printJson(await checkTeamSharingUpgrade({ force: true }, env));
-      break;
-    case 'search':
-      printJson(await searchTeamMemory(flags, env));
-      break;
-    case 'context':
-      printJson(await readTeamMemoryContext(flags, env));
-      break;
-    case 'sync':
-      printJson(await syncTeamMemoryTranscript({ ...flags, integration: flags.integration || 'team-sharing' }, env));
-      break;
-    default:
-      throw new Error(`Unknown team-sharing command: ${subcommand}`);
-  }
-}
-
-async function runFeatureInstallCommand(kind, flags = {}, env = process.env) {
-  const subcommand = String(flags._?.[0] || 'help').trim();
-  const feature = String(flags.feature || flags.name || flags._?.[1] || 'team-sharing').trim();
-  if (feature !== 'team-sharing' && feature !== 'team-memory') {
-    throw new Error(`${kind} currently supports --feature team-sharing.`);
-  }
-  if (subcommand === 'help' || flags.help) {
-    process.stdout.write(`Usage: magclaw ${kind} <install|remove|enable|disable|status> --feature team-sharing\n`);
-    return;
-  }
-  if (kind === 'skills') {
-    if (subcommand === 'install' || subcommand === 'enable') printJson(await installTeamSharingSkill(flags, env));
-    else if (subcommand === 'remove') printJson(await removeTeamSharingSkill(flags, env));
-    else if (subcommand === 'disable') printJson(await disableTeamSharingSkill(flags, env));
-    else if (subcommand === 'status') printJson(await statusTeamSharingSkill(flags, env));
-    else throw new Error(`Unknown skills command: ${subcommand}`);
-    return;
-  }
-  if (subcommand === 'install' || subcommand === 'enable') printJson(await installTeamSharingHooks(flags, env));
-  else if (subcommand === 'remove' || subcommand === 'disable') printJson(await removeTeamSharingHooks(flags, env));
-  else if (subcommand === 'status') printJson(await statusTeamSharingHooks(flags, env));
-  else throw new Error(`Unknown hooks command: ${subcommand}`);
-}
-
 function hasComputerTarget(flags = {}) {
   return Boolean(flags.profileExplicit || flags.server || flags.serverSlug || flags.slug || flags._?.[1]);
 }
@@ -7752,17 +7119,14 @@ export async function main(argv = process.argv, env = process.env) {
     case 'computer':
       await runComputerCommand(flags, env);
       break;
-    case 'memory':
-      await runTeamMemoryCommand(flags, env);
-      break;
     case 'team-sharing':
-      await runTeamSharingCommand(flags, env);
+      await runExternalTeamSharingCommand(argv.slice(3), env);
       break;
     case 'skills':
-      await runFeatureInstallCommand('skills', flags, env);
+      await runExternalTeamSharingCommand(argv.slice(2), env);
       break;
     case 'hooks':
-      await runFeatureInstallCommand('hooks', flags, env);
+      await runExternalTeamSharingCommand(argv.slice(2), env);
       break;
     case 'start': {
       printJson(await startSavedBackground(flags, env));