feat(core): V2 session API 补齐 + TUI 迁移

- V2 core 新增 remove/update/children/fork(atMessageID)/todo 方法
- Protocol 新增 6 个 V2 endpoint (remove/update/fork/children/messages/todo)
- Server 实现新增 endpoint handler
- SDK 重新生成
- TUI 迁移: delete/update/abort/fork/compact/shell/create/get/revert/todo/list
- sync.tsx session.get 通过 toV1Session adapter 迁移到 V2
- MCP 工具 V2 ToolRegistry 接入
- 缓存策略统一到 cache-policy.ts
- Dream 记忆 LLM 接入
- Session Fork V2 核心实现
- TUI cursor/replay SSE 订阅

Author: edy

packages/core/src/location-services.ts

@@ -33,6 +33,9 @@ import { Snapshot } from "./snapshot"
 import { SubagentRunner } from "./subagent/runner"
 import { SystemContextBuiltIns } from "./system-context/builtins"
 import { SystemContextRegistry } from "./system-context/registry"
+import { McpRegistration } from "./mcp/registration"
+import { McpToolSource } from "./mcp/tool-source"
+import { MemoryContext } from "./memory/context"
 import { BuiltInTools } from "./tool/builtins"
 import { ReadToolFileSystem } from "./tool/read-filesystem"
 import { ToolRegistry } from "./tool/registry"
@@ -61,12 +64,15 @@ export const locationServices = LayerNode.group([
   SkillV2.node,
   SystemContextRegistry.node,
   SystemContextBuiltIns.node,
+  MemoryContext.node,
   LocationMutation.node,
   FileMutation.node,
   PermissionV2.node,
   ToolOutputStore.node,
   ToolRegistry.node,
   ToolRegistry.toolsNode,
+  McpToolSource.node,
+  McpRegistration.node,
   Image.node,
   SkillGuidance.node,
   ReferenceGuidance.node,

packages/core/src/mcp/registration.ts

@@ -0,0 +1,97 @@
+export * as McpRegistration from "./registration"
+
+import { ToolFailure } from "@opencode-ai/llm"
+import { Effect, Layer, Schema } from "effect"
+import { makeLocationNode } from "../effect/app-node"
+import { ToolRegistry } from "../tool/registry"
+import { Tool } from "../tool/tool"
+import { Tools } from "../tool/tools"
+import { McpToolSource } from "./tool-source"
+
+const sanitize = (value: string) => value.replace(/[^a-zA-Z0-9_-]/g, "_")
+const toolName = (serverName: string, name: string) => sanitize(serverName) + "_" + sanitize(name)
+
+const Output = Schema.Struct({
+  content: Schema.Array(Schema.Unknown),
+  isError: Schema.optional(Schema.Boolean),
+  structuredContent: Schema.optional(Schema.Unknown),
+})
+
+function toModelOutput(output: Schema.Schema.Type<typeof Output>): ReadonlyArray<Tool.Content> {
+  const parts: Tool.Content[] = []
+  for (const item of output.content) {
+    if (typeof item !== "object" || item === null) continue
+    const part = item as Record<string, unknown>
+    if (part.type === "text" && typeof part.text === "string") {
+      parts.push({ type: "text", text: part.text })
+    } else if (part.type === "image" && typeof part.data === "string" && typeof part.mimeType === "string") {
+      parts.push({ type: "file", data: part.data, mime: part.mimeType })
+    } else if (part.type === "resource" && typeof part.resource === "object" && part.resource !== null) {
+      const resource = part.resource as Record<string, unknown>
+      if (typeof resource.text === "string") parts.push({ type: "text", text: resource.text })
+      if (typeof resource.blob === "string" && typeof resource.mimeType === "string") {
+        parts.push({ type: "file", data: resource.blob, mime: resource.mimeType })
+      }
+    }
+  }
+  if (parts.length === 0 && output.structuredContent !== undefined) {
+    parts.push({ type: "text", text: JSON.stringify(output.structuredContent) })
+  }
+  return parts
+}
+
+const layer = Layer.effectDiscard(
+  Effect.gen(function* () {
+    const source = yield* McpToolSource.Service
+    const tools = yield* Tools.Service
+    const entries = yield* source.tools
+
+    if (entries.length === 0) return
+
+    const record: Record<string, Tool.AnyTool> = {}
+    for (const entry of entries) {
+      const name = toolName(entry.serverName, entry.def.name)
+      record[name] = Tool.make({
+        description: entry.def.description ?? `MCP tool ${entry.def.name} from ${entry.serverName}`,
+        input: Schema.Record(Schema.String, Schema.Unknown),
+        inputJsonSchema: {
+          ...entry.def.inputSchema,
+          type: "object",
+          properties: (entry.def.inputSchema.properties ?? {}) as Record<string, unknown>,
+          additionalProperties: false,
+        },
+        output: Output,
+        execute: (input) =>
+          source.execute(entry.serverName, entry.def.name, input, { timeout: entry.timeout }).pipe(
+            Effect.mapError(
+              (error) => new ToolFailure({ message: error.message }),
+            ),
+            Effect.flatMap((result) => {
+              if (result.isError) {
+                const text = result.content
+                  .filter((item): item is { type: "text"; text: string } => item.type === "text")
+                  .map((item) => item.text)
+                  .filter((text) => text.trim())
+                  .join("\n\n")
+                return Effect.fail(new ToolFailure({ message: text || "MCP tool returned an error" }))
+              }
+              return Effect.succeed({
+                content: result.content as Array<unknown>,
+                isError: result.isError,
+                structuredContent: result.structuredContent,
+              })
+            }),
+          ),
+        toModelOutput: ({ output }) => toModelOutput(output),
+      })
+    }
+
+    yield* tools.register(record).pipe(Effect.orDie)
+  }),
+)
+
+export const node = makeLocationNode({
+  name: "mcp-registration",
+  layer,
+  deps: [ToolRegistry.node, McpToolSource.node],
+})

packages/core/src/mcp/tool-source.ts

@@ -0,0 +1,74 @@
+export * as McpToolSource from "./tool-source"
+
+import { Context, Effect, Layer } from "effect"
+import { makeGlobalNode } from "../effect/app-node"
+
+/** JSON Schema definition for an MCP tool's input. */
+export interface ToolDef {
+  readonly name: string
+  readonly description?: string
+  readonly inputSchema: Record<string, unknown>
+}
+
+/** A discovered MCP tool with its owning server. */
+export interface ToolEntry {
+  readonly serverName: string
+  readonly def: ToolDef
+  readonly timeout?: number
+}
+
+export type ContentPart =
+  | { readonly type: "text"; readonly text: string }
+  | { readonly type: "image"; readonly data: string; readonly mimeType: string }
+  | {
+      readonly type: "resource"
+      readonly resource: {
+        readonly uri: string
+        readonly text?: string
+        readonly blob?: string
+        readonly mimeType?: string
+      }
+    }
+
+export interface ToolResult {
+  readonly content: ReadonlyArray<ContentPart>
+  readonly isError?: boolean
+  readonly structuredContent?: unknown
+}
+
+export interface Interface {
+  /** All currently connected MCP tools across servers. */
+  readonly tools: Effect.Effect<ReadonlyArray<ToolEntry>>
+  /** Execute a tool on a specific server. */
+  readonly execute: (
+    serverName: string,
+    toolName: string,
+    args: Record<string, unknown>,
+    options?: { readonly signal?: AbortSignal; readonly timeout?: number },
+  ) => Effect.Effect<ToolResult, Error>
+}
+
+/**
+ * Abstract MCP tool source consumed by the V2 registration layer.
+ * The actual MCP client implementation lives in the server package;
+ * core only depends on this interface.
+ */
+export class Service extends Context.Service<Service, Interface>()("@opencode/v2/McpToolSource") {}
+
+/** Default no-op source: no MCP tools available. */
+export const noop: Interface = {
+  tools: Effect.succeed([]),
+  execute: (_serverName, toolName) =>
+    Effect.fail(new Error(`MCP tool source not available (called ${toolName})`)),
+}
+
+/**
+ * Process-scoped node with a no-op default. The server package replaces this
+ * via `buildLocationServiceMap(replacements)` with a real implementation
+ * backed by the MCP client.
+ */
+export const node = makeGlobalNode({
+  service: Service,
+  layer: Layer.succeed(Service, noop),
+  deps: [],
+})

packages/core/src/memory/dream.ts

@@ -21,9 +21,10 @@ export const shouldConsolidate = async (): Promise<boolean> => {
 }
 
 const buildPrompt = (existing: ReadonlyArray<Memory>, summaries: ReadonlyArray<string>): string => {
-  const existingText = existing.length === 0
-    ? "(no existing memories)"
-    : existing.map((m) => `- [${m.category}] ${m.title}: ${m.content}`).join("\n")
+  const existingText =
+    existing.length === 0
+      ? "(no existing memories)"
+      : existing.map((m) => `- [${m.category}] ${m.title}: ${m.content}`).join("\n")
 
   const summariesText = summaries.join("\n---\n")
 
@@ -47,37 +48,80 @@ Respond with a JSON array of memory objects:
 If no new memories should be extracted, respond with: []`
 }
 
-export const consolidate = async (sessionSummaries: ReadonlyArray<string>): Promise<void> => {
+/** Extract JSON array from LLM response that may contain markdown fences. */
+const extractJson = (text: string): string => {
+  const fenced = text.match(/```(?:json)?\s*\n?([\s\S]*?)```/)
+  if (fenced) return fenced[1].trim()
+  const bracket = text.indexOf("[")
+  const lastBracket = text.lastIndexOf("]")
+  if (bracket >= 0 && lastBracket > bracket) return text.slice(bracket, lastBracket + 1)
+  return text.trim()
+}
+
+/**
+ * Consolidate session summaries into long-term memories.
+ * @param sessionSummaries - Compaction summaries from recent sessions.
+ * @param generate - LLM text generation function injected by the caller.
+ *   Receives the consolidation prompt, returns the raw LLM response text.
+ */
+export const consolidate = async (
+  sessionSummaries: ReadonlyArray<string>,
+  generate: (prompt: string) => Promise<string>,
+): Promise<void> => {
   if (sessionSummaries.length === 0) return
 
   const existing = await loadMemories()
-  const _prompt = buildPrompt(existing, sessionSummaries)
+  const prompt = buildPrompt(existing, sessionSummaries)
 
   try {
-    const response = await Bun.stdin.text() // placeholder - in real usage, call LLM
-    const parsed = JSON.parse(response) as ReadonlyArray<{
+    const response = await generate(prompt)
+    const parsed = JSON.parse(extractJson(response)) as ReadonlyArray<{
       category: Memory["category"]
       title: string
       content: string
       keywords: ReadonlyArray<string>
     }>
 
+    if (!Array.isArray(parsed) || parsed.length === 0) {
+      await writeLastDream(Date.now())
+      return
+    }
+
     const now = new Date().toISOString()
-    const newMemories: ReadonlyArray<Memory> = parsed.map((item) => ({
-      id: crypto.randomUUID(),
-      category: item.category,
-      title: item.title,
-      content: item.content,
-      keywords: item.keywords,
-      created_at: now,
-      updated_at: now,
-    }))
-
-    const merged = [...existing, ...newMemories].slice(-200)
-    await saveMemories(merged)
+    const newMemories: ReadonlyArray<Memory> = parsed
+      .filter(
+        (item): item is { category: Memory["category"]; title: string; content: string; keywords: string[] } =>
+          typeof item.title === "string" &&
+          typeof item.content === "string" &&
+          ["user", "feedback", "project", "reference"].includes(item.category),
+      )
+      .map((item) => ({
+        id: crypto.randomUUID(),
+        category: item.category,
+        title: item.title,
+        content: item.content,
+        keywords: Array.isArray(item.keywords) ? item.keywords : [],
+        created_at: now,
+        updated_at: now,
+      }))
+
+    // Merge: update existing memories by title match, append new ones
+    const byTitle = new Map(existing.map((m) => [m.title.toLowerCase(), m]))
+    const merged = [...existing]
+    for (const mem of newMemories) {
+      const existingMatch = byTitle.get(mem.title.toLowerCase())
+      if (existingMatch) {
+        const index = merged.indexOf(existingMatch)
+        if (index >= 0) merged[index] = { ...mem, id: existingMatch.id, created_at: existingMatch.created_at }
+      } else {
+        merged.push(mem)
+      }
+    }
+
+    await saveMemories(merged.slice(-200))
     await writeLastDream(Date.now())
   } catch {
-    // Silently fail - don't crash on consolidation errors
+    // Silently fail — consolidation is best-effort background work
   }
 }