saeeol 1.1.0 → 1.1.1

package/src/acp/agent-utils.ts

@@ -0,0 +1,206 @@
+import { parse as parseDataUrl } from "@saeeol/boxes/dataurl"
+import { RequestError, type Role, type ToolKind, type Usage, type PlanEntry } from "@agentclientprotocol/sdk"
+import * as Log from "@saeeol/core/util/log"
+import { pathToFileURL } from "url"
+import { Hash } from "@saeeol/core/util/hash"
+import { Provider } from "@/provider/provider"
+import { ModelID, ProviderID } from "../provider/schema"
+import { MessageV2 } from "@/session/message-v2"
+import { Result, Schema } from "effect"
+import { Todo } from "@/session/todo"
+import { applyPatch } from "diff"
+import type { AssistantMessage, SaeeolClient } from "@saeeol/sdk/v2"
+import { InstallationVersion } from "@saeeol/core/installation/version"
+import { fetchDefaultModel } from "@saeeol/gateway"
+import type { ToolCallContent } from "@agentclientprotocol/sdk"
+import type { ACPConfig } from "./types"
+import type { ACPSessionManager } from "./session"
+import type { SessionConfigOption, ModeOption, ModelOption } from "./agent-types"
+
+export { type ModeOption, type ModelOption } from "./agent-types"
+
+const decodeTodos = Schema.decodeUnknownResult(Schema.fromJsonString(Schema.Array(Todo.Info)))
+const DEFAULT_VARIANT_VALUE = "default"
+export const log = Log.create({ service: "acp-agent" })
+
+export async function getContextLimit(sdk: SaeeolClient, providerID: ProviderID, modelID: ModelID, directory: string) {
+  const providers = await sdk.config
+    .providers({ directory })
+    .then((x) => x.data?.providers ?? [])
+    .catch((error) => { log.error("failed to get providers for context limit", { error }); return [] })
+  const provider = providers.find((p) => p.id === providerID)
+  return provider?.models[modelID]?.limit.context ?? null
+}
+
+export async function sendUsageUpdate(
+  connection: { sessionUpdate: (p: any) => Promise<any> },
+  sdk: SaeeolClient,
+  sessionID: string,
+  directory: string,
+) {
+  const messages = await sdk.session
+    .messages({ sessionID, directory }, { throwOnError: true })
+    .then((x) => x.data)
+    .catch((error) => { log.error("failed to fetch messages for usage update", { error }); return undefined })
+  if (!messages) return
+  const assistantMessages = messages.filter(
+    (m): m is { info: AssistantMessage; parts: any[] } => m.info.role === "assistant",
+  )
+  const lastAssistant = assistantMessages[assistantMessages.length - 1]
+  if (!lastAssistant) return
+  const msg = lastAssistant.info
+  if (!msg.providerID || !msg.modelID) return
+  const size = await getContextLimit(sdk, ProviderID.make(msg.providerID), ModelID.make(msg.modelID), directory)
+  if (!size) return
+  const used = msg.tokens.input + (msg.tokens.cache?.read ?? 0)
+  const totalCost = assistantMessages.reduce((sum, m) => sum + m.info.cost, 0)
+  await connection
+    .sessionUpdate({ sessionId: sessionID, update: { sessionUpdate: "usage_update", used, size, cost: { amount: totalCost, currency: "USD" } } })
+    .catch((error) => { log.error("failed to send usage update", { error }) })
+}
+
+export function toToolKind(toolName: string): ToolKind {
+  const tool = toolName.toLocaleLowerCase()
+  switch (tool) {
+    case "bash": return "execute"
+    case "webfetch": return "fetch"
+    case "edit": case "patch": case "write": return "edit"
+    case "grep": case "glob": case "context7_resolve_library_id": case "context7_get_library_docs": return "search"
+    case "read": return "read"
+    default: return "other"
+  }
+}
+
+export function toLocations(toolName: string, input: Record<string, any>): { path: string }[] {
+  const tool = toolName.toLocaleLowerCase()
+  switch (tool) {
+    case "read": case "edit": case "write": return input["filePath"] ? [{ path: input["filePath"] }] : []
+    case "glob": case "grep": return input["path"] ? [{ path: input["path"] }] : []
+    default: return []
+  }
+}
+
+export function getNewContent(fileOriginal: string, unifiedDiff: string): string | undefined {
+  const result = applyPatch(fileOriginal, unifiedDiff)
+  if (result === false) { log.error("Failed to apply unified diff (context mismatch)"); return undefined }
+  return result
+}
+
+export function parseUri(uri: string): { type: "file"; url: string; filename: string; mime: string } | { type: "text"; text: string } {
+  try {
+    if (uri.startsWith("file://")) {
+      const path = uri.slice(7)
+      const name = path.split("/").pop() || path
+      return { type: "file", url: uri, filename: name, mime: "text/plain" }
+    }
+    if (uri.startsWith("zed://")) {
+      const url = new URL(uri)
+      const path = url.searchParams.get("path")
+      if (path) { const name = path.split("/").pop() || path; return { type: "file", url: pathToFileURL(path).href, filename: name, mime: "text/plain" } }
+    }
+    return { type: "text", text: uri }
+  } catch { return { type: "text", text: uri } }
+}
+
+export function sortProvidersByName<T extends { name: string }>(providers: T[]): T[] {
+  return [...providers].sort((a, b) => { const na = a.name.toLowerCase(); const nb = b.name.toLowerCase(); return na < nb ? -1 : na > nb ? 1 : 0 })
+}
+
+export function modelVariantsFromProviders(
+  providers: Array<{ id: string; models: Record<string, { variants?: Record<string, any> }> }>,
+  model: { providerID: ProviderID; modelID: ModelID },
+): string[] {
+  const provider = providers.find((entry) => entry.id === model.providerID)
+  if (!provider) return []
+  const modelInfo = provider.models[model.modelID]
+  if (!modelInfo?.variants) return []
+  return Object.keys(modelInfo.variants)
+}
+
+export function buildAvailableModels(
+  providers: Array<{ id: string; name: string; models: Record<string, any> }>,
+  options: { includeVariants?: boolean } = {},
+): ModelOption[] {
+  const includeVariants = options.includeVariants ?? false
+  return providers.flatMap((provider) => {
+    const unsorted: Array<{ id: string; name: string; variants?: Record<string, any> }> = Object.values(provider.models)
+    const models = Provider.sort(unsorted)
+    return models.flatMap((model: any) => {
+      const base: ModelOption = { modelId: `${provider.id}/${model.id}`, name: `${provider.name}/${model.name}` }
+      if (!includeVariants || !model.variants) return [base]
+      const variants = Object.keys(model.variants).filter((v) => v !== DEFAULT_VARIANT_VALUE)
+      return [base, ...variants.map((variant) => ({ modelId: `${provider.id}/${model.id}/${variant}`, name: `${provider.name}/${model.name} (${variant})` }))]
+    })
+  })
+}
+
+export function formatModelIdWithVariant(
+  model: { providerID: ProviderID; modelID: ModelID },
+  variant: string | undefined,
+  availableVariants: string[],
+  includeVariant: boolean,
+) {
+  const base = `${model.providerID}/${model.modelID}`
+  if (!includeVariant || !variant || !availableVariants.includes(variant)) return base
+  return `${base}/${variant}`
+}
+
+export function buildVariantMeta(input: { model: { providerID: ProviderID; modelID: ModelID }; variant?: string; availableVariants: string[] }) {
+  return { saeeol: { modelId: `${input.model.providerID}/${input.model.modelID}`, variant: input.variant ?? null, availableVariants: input.availableVariants } }
+}
+
+export function parseModelSelection(
+  modelId: string,
+  providers: Array<{ id: string; models: Record<string, { variants?: Record<string, any> }> }>,
+): { model: { providerID: ProviderID; modelID: ModelID }; variant?: string } {
+  const parsed = Provider.parseModel(modelId)
+  const provider = providers.find((p) => p.id === parsed.providerID)
+  if (!provider) return { model: parsed, variant: undefined }
+  if (provider.models[parsed.modelID]) return { model: parsed, variant: undefined }
+  const segments = parsed.modelID.split("/")
+  if (segments.length > 1) {
+    const candidateVariant = segments[segments.length - 1]
+    const baseModelId = segments.slice(0, -1).join("/")
+    const baseModelInfo = provider.models[baseModelId]
+    if (baseModelInfo?.variants && candidateVariant in baseModelInfo.variants)
+      return { model: { providerID: parsed.providerID, modelID: ModelID.make(baseModelId) }, variant: candidateVariant }
+  }
+  return { model: parsed, variant: undefined }
+}
+
+export function buildConfigOptions(input: {
+  currentModelId: string; availableModels: ModelOption[]; modes?: { availableModes: ModeOption[]; currentModeId: string } | undefined
+}): SessionConfigOption[] {
+  const options: SessionConfigOption[] = [{ id: "model", name: "Model", category: "model", type: "select", currentValue: input.currentModelId, options: input.availableModels.map((m) => ({ value: m.modelId, name: m.name })) }]
+  if (input.modes) options.push({ id: "mode", name: "Session Mode", category: "mode", type: "select", currentValue: input.modes.currentModeId, options: input.modes.availableModes.map((m) => ({ value: m.id, name: m.name, ...(m.description ? { description: m.description } : {}) })) })
+  return options
+}
+
+export async function defaultModel(config: ACPConfig, cwd?: string): Promise<{ providerID: ProviderID; modelID: ModelID }> {
+  const sdk = config.sdk
+  const configured = config.defaultModel
+  if (configured) return configured
+  const directory = cwd ?? process.cwd()
+  const specified = await sdk.config.get({ directory }, { throwOnError: true }).then((resp) => { const cfg = resp.data; if (!cfg || !cfg.model) return undefined; return Provider.parseModel(cfg.model) }).catch((error) => { log.error("failed to load user config for default model", { error }); return undefined })
+  const providers = await sdk.config.providers({ directory }, { throwOnError: true }).then((x) => x.data?.providers ?? []).catch((error) => { log.error("failed to list providers for default model", { error }); return [] })
+  if (specified && providers.length) { const provider = providers.find((p) => p.id === specified.providerID); if (provider && provider.models[specified.modelID]) return specified }
+  if (specified && !providers.length) return specified
+  const saeeolProvider = providers.find((p) => p.id === "saeeol")
+  if (saeeolProvider) { const [best] = Provider.sort(Object.values(saeeolProvider.models)); if (best) return { providerID: ProviderID.make(best.providerID), modelID: ModelID.make(best.id) } }
+  const models = providers.flatMap((p) => Object.values(p.models))
+  const [best] = Provider.sort(models)
+  if (best) return { providerID: ProviderID.make(best.providerID), modelID: ModelID.make(best.id) }
+  if (specified) return specified
+  if (providers.some((p) => p.id === "saeeol")) { const freeModel = await fetchDefaultModel(); return { providerID: ProviderID.saeeol, modelID: ModelID.make(freeModel) } }
+  throw new Error("no model available: no providers are configured and no default model is set")
+}
+
+export function buildUsage(msg: AssistantMessage): Usage {
+  return {
+    totalTokens: msg.tokens.input + msg.tokens.output + msg.tokens.reasoning + (msg.tokens.cache?.read ?? 0) + (msg.tokens.cache?.write ?? 0),
+    inputTokens: msg.tokens.input, outputTokens: msg.tokens.output,
+    thoughtTokens: msg.tokens.reasoning || undefined, cachedReadTokens: msg.tokens.cache?.read || undefined, cachedWriteTokens: msg.tokens.cache?.write || undefined,
+  }
+}
+
+export { decodeTodos, DEFAULT_VARIANT_VALUE }

package/src/acp/agent.ts

@@ -0,0 +1,89 @@
+import {
+  type AgentSideConnection,
+  type AuthenticateRequest,
+  type InitializeRequest,
+  type InitializeResponse,
+  type ListSessionsRequest,
+  type ListSessionsResponse,
+  type LoadSessionRequest,
+  type NewSessionRequest,
+  type ForkSessionRequest,
+  type ForkSessionResponse,
+  type ResumeSessionRequest,
+  type ResumeSessionResponse,
+  type CancelNotification,
+  type SetSessionModelRequest,
+  type SetSessionModeRequest,
+  type SetSessionModeResponse,
+  type SetSessionConfigOptionRequest,
+  type SetSessionConfigOptionResponse,
+  type PromptRequest,
+  type PermissionOption,
+} from "@agentclientprotocol/sdk"
+import { ACPSessionManager } from "./session"
+import type { ACPConfig } from "./types"
+import type { AgentDeps } from "./agent-types"
+import { initialize, newSession, loadSession, listSessions, forkSession, resumeSession } from "./agent-session"
+import { startEventSubscription } from "./agent-events"
+import { prompt, cancel, setSessionModel, setSessionMode, setSessionConfigOption } from "./agent-prompt"
+
+export type { ModeOption, ModelOption } from "./agent-types"
+
+async function init({ sdk: _sdk }: { sdk: any }) {
+  return { create: (connection: AgentSideConnection, fullConfig: ACPConfig) => new Agent(connection, fullConfig) }
+}
+
+class Agent {
+  private connection: AgentSideConnection
+  private config: ACPConfig
+  private sdk: any
+  private sessionManager: ACPSessionManager
+  private eventAbort = new AbortController()
+  private eventStarted = false
+  private bashSnapshots = new Map<string, string>()
+  private toolStarts = new Set<string>()
+  private permissionQueues = new Map<string, Promise<void>>()
+  private permissionOptions: PermissionOption[] = [
+    { optionId: "once", kind: "allow_once", name: "Allow once" },
+    { optionId: "always", kind: "allow_always", name: "Always allow" },
+    { optionId: "reject", kind: "reject_once", name: "Reject" },
+  ]
+
+  constructor(connection: AgentSideConnection, config: ACPConfig) {
+    this.connection = connection
+    this.config = config
+    this.sdk = config.sdk
+    this.sessionManager = new ACPSessionManager(this.sdk)
+    startEventSubscription(this.deps, this.eventAbort, { value: false })
+    this.eventStarted = true
+  }
+
+  private get deps(): AgentDeps {
+    return {
+      connection: this.connection,
+      config: this.config,
+      sdk: this.sdk,
+      sessionManager: this.sessionManager,
+      permissionOptions: this.permissionOptions,
+      bashSnapshots: this.bashSnapshots,
+      toolStarts: this.toolStarts,
+      permissionQueues: this.permissionQueues,
+    }
+  }
+
+  async initialize(params: InitializeRequest) { return initialize(params) }
+  async authenticate(_params: AuthenticateRequest) { throw new Error("Authentication not implemented") }
+  async newSession(params: NewSessionRequest) { return newSession(this.deps, params) }
+  async loadSession(params: LoadSessionRequest) { return loadSession(this.deps, params) }
+  async listSessions(params: ListSessionsRequest): Promise<ListSessionsResponse> { return listSessions(this.deps, params) }
+  async unstable_forkSession(params: ForkSessionRequest): Promise<ForkSessionResponse> { return forkSession(this.deps, params) }
+  async unstable_resumeSession(params: ResumeSessionRequest): Promise<ResumeSessionResponse> { return resumeSession(this.deps, params) }
+  async unstable_setSessionModel(params: SetSessionModelRequest) { return setSessionModel(this.deps, params) }
+  async setSessionMode(params: SetSessionModeRequest): Promise<SetSessionModeResponse | void> { return setSessionMode(this.deps, params) }
+  async setSessionConfigOption(params: SetSessionConfigOptionRequest): Promise<SetSessionConfigOptionResponse> { return setSessionConfigOption(this.deps, params) }
+  async prompt(params: PromptRequest) { return prompt(this.deps, params) }
+  async cancel(params: CancelNotification) { return cancel(this.deps, params) }
+}
+
+export { init, Agent }
+export * as ACP from "./agent"

package/src/acp/session.ts

@@ -0,0 +1,116 @@
+import { RequestError, type McpServer } from "@agentclientprotocol/sdk"
+import type { ACPSessionState } from "./types"
+import * as Log from "@saeeol/core/util/log"
+import type { SaeeolClient } from "@saeeol/sdk/v2"
+
+const log = Log.create({ service: "acp-session-manager" })
+
+export class ACPSessionManager {
+  private sessions = new Map<string, ACPSessionState>()
+  private sdk: SaeeolClient
+
+  constructor(sdk: SaeeolClient) {
+    this.sdk = sdk
+  }
+
+  tryGet(sessionId: string): ACPSessionState | undefined {
+    return this.sessions.get(sessionId)
+  }
+
+  async create(cwd: string, mcpServers: McpServer[], model?: ACPSessionState["model"]): Promise<ACPSessionState> {
+    const session = await this.sdk.session
+      .create(
+        {
+          directory: cwd,
+        },
+        { throwOnError: true },
+      )
+      .then((x) => x.data!)
+
+    const sessionId = session.id
+    const resolvedModel = model
+
+    const state: ACPSessionState = {
+      id: sessionId,
+      cwd,
+      mcpServers,
+      createdAt: new Date(),
+      model: resolvedModel,
+    }
+    log.info("creating_session", { state })
+
+    this.sessions.set(sessionId, state)
+    return state
+  }
+
+  async load(
+    sessionId: string,
+    cwd: string,
+    mcpServers: McpServer[],
+    model?: ACPSessionState["model"],
+  ): Promise<ACPSessionState> {
+    const session = await this.sdk.session
+      .get(
+        {
+          sessionID: sessionId,
+          directory: cwd,
+        },
+        { throwOnError: true },
+      )
+      .then((x) => x.data!)
+
+    const resolvedModel = model
+
+    const state: ACPSessionState = {
+      id: sessionId,
+      cwd,
+      mcpServers,
+      createdAt: new Date(session.time.created),
+      model: resolvedModel,
+    }
+    log.info("loading_session", { state })
+
+    this.sessions.set(sessionId, state)
+    return state
+  }
+
+  get(sessionId: string): ACPSessionState {
+    const session = this.sessions.get(sessionId)
+    if (!session) {
+      log.error("session not found", { sessionId })
+      throw RequestError.invalidParams(JSON.stringify({ error: `Session not found: ${sessionId}` }))
+    }
+    return session
+  }
+
+  getModel(sessionId: string) {
+    const session = this.get(sessionId)
+    return session.model
+  }
+
+  setModel(sessionId: string, model: ACPSessionState["model"]) {
+    const session = this.get(sessionId)
+    session.model = model
+    this.sessions.set(sessionId, session)
+    return session
+  }
+
+  getVariant(sessionId: string) {
+    const session = this.get(sessionId)
+    return session.variant
+  }
+
+  setVariant(sessionId: string, variant?: string) {
+    const session = this.get(sessionId)
+    session.variant = variant
+    this.sessions.set(sessionId, session)
+    return session
+  }
+
+  setMode(sessionId: string, modeId: string) {
+    const session = this.get(sessionId)
+    session.modeId = modeId
+    this.sessions.set(sessionId, session)
+    return session
+  }
+}

package/src/acp/types.ts

@@ -0,0 +1,24 @@
+import type { McpServer } from "@agentclientprotocol/sdk"
+import type { SaeeolClient } from "@saeeol/sdk/v2"
+import type { ProviderID, ModelID } from "../provider/schema"
+
+export interface ACPSessionState {
+  id: string
+  cwd: string
+  mcpServers: McpServer[]
+  createdAt: Date
+  model?: {
+    providerID: ProviderID
+    modelID: ModelID
+  }
+  variant?: string
+  modeId?: string
+}
+
+export interface ACPConfig {
+  sdk: SaeeolClient
+  defaultModel?: {
+    providerID: ProviderID
+    modelID: ModelID
+  }
+}

package/src/addons/addon-analytics.ts

@@ -0,0 +1,14 @@
+import type { Addon } from "./types"
+
+// ── analytics: 사용량 통계 + 모델 테스트 + PR ────────────────────────
+export const analytics: Addon = {
+  id: "analytics",
+  category: "analytics",
+  minTier: "master",
+  required: false,
+  commands: [
+    () => import("../cli/cmd/stats").then((m) => ({ StatsCommand: m.StatsCommand })),
+    () => import("../cli/cmd/pr").then((m) => ({ PrCommand: m.PrCommand })),
+    () => import("../saeeol/cli/cmd/roll-call").then((m) => ({ RollCallCommand: m.RollCallCommand })),
+  ],
+}

package/src/addons/addon-core.ts

@@ -0,0 +1,15 @@
+import type { Addon } from "./types"
+
+// ── core: TUI 채팅 + 프롬프트 실행 ──────────────────────────────────
+export const core: Addon = {
+  id: "core",
+  category: "core",
+  minTier: "light",
+  required: true,
+  commands: [
+    () => import("../cli/cmd/tui/thread").then((m) => ({ TuiThreadCommand: m.TuiThreadCommand })),
+    () => import("../cli/cmd/run").then((m) => ({ RunCommand: m.RunCommand })),
+    () => import("../cli/cmd/generate").then((m) => ({ GenerateCommand: m.GenerateCommand })),
+    () => import("../cli/cmd/session").then((m) => ({ SessionCommand: m.SessionCommand })),
+  ],
+}

package/src/addons/addon-data.ts

@@ -0,0 +1,14 @@
+import type { Addon } from "./types"
+
+// ── data: 세션 내보내기/가져오기 + DB ───────────────────────────────
+export const data: Addon = {
+  id: "data",
+  category: "data",
+  minTier: "code",
+  required: true,
+  commands: [
+    () => import("../cli/cmd/export").then((m) => ({ ExportCommand: m.ExportCommand })),
+    () => import("../cli/cmd/import").then((m) => ({ ImportCommand: m.ImportCommand })),
+    () => import("../cli/cmd/db").then((m) => ({ DbCommand: m.DbCommand })),
+  ],
+}

package/src/addons/addon-dev.ts

@@ -0,0 +1,13 @@
+import type { Addon } from "./types"
+
+// ── dev: 에이전트 관리 + 디버깅 ─────────────────────────────────────
+export const dev: Addon = {
+  id: "dev",
+  category: "dev",
+  minTier: "code",
+  required: false,
+  commands: [
+    () => import("../cli/cmd/agent").then((m) => ({ AgentCommand: m.AgentCommand })),
+    () => import("../cli/cmd/debug").then((m) => ({ DebugCommand: m.DebugCommand })),
+  ],
+}

package/src/addons/addon-lifecycle.ts

@@ -0,0 +1,13 @@
+import type { Addon } from "./types"
+
+// ── lifecycle: 설치/업그레이드/제거 ──────────────────────────────────
+export const lifecycle: Addon = {
+  id: "lifecycle",
+  category: "lifecycle",
+  minTier: "light",
+  required: true,
+  commands: [
+    () => import("../cli/cmd/upgrade").then((m) => ({ UpgradeCommand: m.UpgradeCommand })),
+    () => import("../cli/cmd/uninstall").then((m) => ({ UninstallCommand: m.UninstallCommand })),
+  ],
+}

package/src/addons/addon-llm.ts

@@ -0,0 +1,15 @@
+import type { Addon } from "./types"
+
+// ── llm: LLM provider 설정 + 모델 관리 ──────────────────────────────
+export const llm: Addon = {
+  id: "llm",
+  category: "llm",
+  minTier: "light",
+  required: true,
+  commands: [
+    () => import("../cli/cmd/init").then((m) => ({ InitCommand: m.InitCommand })),
+    () => import("../cli/cmd/providers").then((m) => ({ ProvidersCommand: m.ProvidersCommand })),
+    () => import("../cli/cmd/models").then((m) => ({ ModelsCommand: m.ModelsCommand })),
+    () => import("../cli/cmd/config").then((m) => ({ ConfigCLICommand: m.ConfigCommand })),
+  ],
+}

package/src/addons/addon-remote.ts

@@ -0,0 +1,12 @@
+import type { Addon } from "./types"
+
+// ── remote: 실시간 세션 릴레이 ──────────────────────────────────────
+export const remote: Addon = {
+  id: "remote",
+  category: "remote",
+  minTier: "master",
+  required: false,
+  commands: [
+    () => import("../cli/cmd/remote").then((m) => ({ RemoteCommand: m.RemoteCommand })),
+  ],
+}

package/src/addons/addon-server.ts

@@ -0,0 +1,14 @@
+import type { Addon } from "./types"
+
+// ── server: headless 서버 + 원격 연결 + ACP ─────────────────────────
+export const server: Addon = {
+  id: "server",
+  category: "server",
+  minTier: "code",
+  required: true,
+  commands: [
+    () => import("../cli/cmd/serve").then((m) => ({ ServeCommand: m.ServeCommand })),
+    () => import("../cli/cmd/tui/attach").then((m) => ({ AttachCommand: m.AttachCommand })),
+    () => import("../cli/cmd/acp").then((m) => ({ AcpCommand: m.AcpCommand })),
+  ],
+}

package/src/addons/addon-tools.ts

@@ -0,0 +1,13 @@
+import type { Addon } from "./types"
+
+// ── tools: MCP + 플러그인 시스템 ────────────────────────────────────
+export const tools: Addon = {
+  id: "tools",
+  category: "tools",
+  minTier: "code",
+  required: true,
+  commands: [
+    () => import("../cli/cmd/mcp").then((m) => ({ McpCommand: m.McpCommand })),
+    () => import("../cli/cmd/plug").then((m) => ({ PluginCommand: m.PluginCommand })),
+  ],
+}

package/src/addons/addon-web.ts

@@ -0,0 +1,12 @@
+import type { Addon } from "./types"
+
+// ── web: 브라우저 채팅 UI ───────────────────────────────────────────
+export const web: Addon = {
+  id: "web",
+  category: "web",
+  minTier: "master",
+  required: true,
+  commands: [
+    () => import("../cli/cmd/web").then((m) => ({ WebCommand: m.WebCommand })),
+  ],
+}

package/src/addons/registry.ts

@@ -0,0 +1,65 @@
+import type { Addon, Tier } from "./types"
+import { core } from "./addon-core"
+import { llm } from "./addon-llm"
+import { lifecycle } from "./addon-lifecycle"
+import { server } from "./addon-server"
+import { tools } from "./addon-tools"
+import { data } from "./addon-data"
+import { dev } from "./addon-dev"
+import { web } from "./addon-web"
+import { remote } from "./addon-remote"
+import { analytics } from "./addon-analytics"
+
+// ╔══════════════════════════════════════════════════════════════════╗
+// ║  애드온 레지스트리                                               ║
+// ║                                                                   ║
+// ║  LIGHT  = core + llm + lifecycle              (3 addons, 10 cmd)  ║
+// ║  CODE   = LIGHT + server + tools + data + dev (8 addons, 20 cmd) ║
+// ║  MASTER = CODE + web + remote + analytics     (11 addons, 24 cmd)║
+// ╚══════════════════════════════════════════════════════════════════╝
+
+export const allAddons: Addon[] = [
+  // LIGHT
+  core,        // TUI 채팅, run, generate, session
+  llm,         // init, auth, models, config
+  lifecycle,   // upgrade, uninstall
+
+  // CODE
+  server,      // serve, attach, acp
+  tools,       // mcp, plugin
+  data,        // export, import, db
+  dev,         // agent, debug
+
+  // MASTER
+  web,         // web UI
+  remote,      // real-time relay
+  analytics,   // stats, pr, roll-call
+]
+
+const tierPriority: Record<Tier, number> = { light: 0, code: 1, master: 2 }
+
+export function addonsForTier(tier: Tier): Addon[] {
+  return allAddons.filter((a) => tierPriority[tier] >= tierPriority[a.minTier])
+}
+
+export async function commandsForTier(tier: Tier): Promise<any[]> {
+  const addons = addonsForTier(tier)
+  const commands: any[] = []
+  for (const addon of addons) {
+    for (const loader of addon.commands) {
+      const mod = await loader()
+      commands.push(...Object.values(mod))
+    }
+  }
+  return commands
+}
+
+export function manifest(tier: Tier) {
+  const addons = addonsForTier(tier)
+  return addons.map((a) => ({
+    id: a.id,
+    category: a.category,
+    commands: a.commands.length,
+    required: a.required,
+  }))
+}