feat(core): implement v2 session wait and skill activation

Wait: port upstream 5e90a68 — SessionRunCoordinator.awaitIdle joins
in-process drains until idle; SessionV2.wait narrows to NotFoundError.

Skill: port upstream 23adaaa — durable SessionEvent.Skill.Activated,
SessionMessage.Skill projection through message-updater/projector/
to-llm-message/compaction, SessionV2.skill with SkillNotFoundError and
fork-resume, POST /api/session/:sessionID/skill endpoint, SDK v2 regen.
TUI UX, report skill, daemon, and plugin parts deferred; deviations
registered in MERGE.md.

Author: See U

MERGE.md

@@ -165,6 +165,8 @@ fork 与上游改了同一处（常见于 TUI 视觉/UX、core 加固逻辑）
 | `packages/schema/src/session-event.ts` + `packages/core/src/session/runner/llm.ts` (v2 drain 失败 live 事件 `session.next.failed`) | 中 | 保留：新增 live-only `SessionEvent.Failed`（不入 durable manifest/不投影），`SessionRunner.run` 失败（非纯中断 cause）时发布，覆盖 step 开始前的失败（如 `ModelUnavailableError`）——此前 drain 失败仅 `execution/local.ts` logError，客户端不可见；step 内失败仍由 durable `Step.Failed` 结算（会双发，与 v1 `session.error` + assistant error 双通道一致）；测试 `packages/core/test/session-runner.test.ts`（publishes a live failed event when a drain fails）；连带更新 manifest 计数测试（schema 侧原本在 HEAD 即过期失败，修正为真实计数 89/59/35）+ SDK v2 重新生成（上游 runner 若补 durable 状态事件则取上游版本并移除本事件） |
 | `packages/tui/src/context/sdk.tsx` + `packages/sdk/js/src/v2/gen` (移除残留 `/sync/*` SDK 面) | 低 | 保留：fork 早前裁剪了 server `/sync/*` 路由，但 SDK gen 与 TUI `sdk.sync.start()`（实验 flag 下静默 404）未同步；本次 SDK 重新生成后一并删除 TUI 调用点（上游 sync 面回归时随上游恢复） |
 | `packages/core/src/{session.ts,session/compaction.ts,session/history.ts,session/runner/*}` (v2 手动 compact 实现) | 中 | 保留：实现 `SessionV2.compact`（原 stub 恒 `OperationUnavailableError`），spec `specs/v2/session.md:105` 已列为 sanctioned improvement。`SessionCompaction.make` 抽出共享 `summarize` 核心（`reason: "auto"\|"manual"`），新增 `compactManually`（输出预算取 `model.route.defaults.limits?.output`，可选 `instructions` 折入 `buildPrompt`）；`SessionHistory.load` 改由新导出 `entries()`（读 epoch `baseline_seq` 只读，不触发 SystemContext 初始化）派生；`SessionRunner` 接口新增 `compact`，`SessionV2.compact` 经 `locations.get(session.location)` 路由，失败/无可压缩内容统一映射 `OperationUnavailableError`（HTTP 503 文案不变）。已知限制：手动 compact 不经 `SessionRunCoordinator` 串行化，与进行中 drain 并发时下一 turn 才生效；测试 `packages/core/test/session-runner.test.ts`（manually compacts on demand / returns false when nothing to compact）（上游实现 v2 手动 compact 后取上游版本） |
+| `packages/core/src/{session.ts,session/run-coordinator.ts,session/execution.ts,session/execution/local.ts}` (v2 `SessionV2.wait` 实现) | 低 | 保留：实现 `SessionV2.wait`（原 stub 恒 `OperationUnavailableError`）。逐字对齐上游 in-flight 提交 `5e90a68d6a`（wip(core): v2 subagent foundations）：`SessionRunCoordinator.awaitIdle`（await entry `done` + `Effect.exit` 吞掉失败/中断、循环复查 successor 直到 idle，空闲即 no-op、不发起 drain），`SessionExecution.awaitIdle` 透传，`SessionV2.wait` 委托并收窄为 `NotFoundError`，server handler 移除死的 503 映射，literals 移除 `"wait"`（对齐 `bd8d858bf7` 前态）。语义限制：仅覆盖本进程持有的执行；测试为 fork 补充（上游 wip 无测试）：`packages/core/test/session-run-coordinator.test.ts`（awaitIdle 4 例）+ `packages/opencode/test/server/httpapi-session.test.ts`（wait 改期望 204）（上游该分支合入后按上游版本对齐） |
+| `packages/{schema,core,protocol,server}/src/**` + `packages/sdk/js/src/v2/gen` (v2 `SessionV2.skill` 实现) | 中 | 保留：实现 `SessionV2.skill`（原 stub 恒 `OperationUnavailableError`）。逐字移植上游 in-flight 提交 `23adaaaeab`（feat(core): add native skill activation）：durable `SessionEvent.Skill.Activated` + `SessionMessage.Skill` + projector/message-updater/to-llm-message/compaction 全链路，`SessionV2.skill` 经 `locations.get(session.location)` 解析 `SkillV2.list()`、未命中报 `Session.SkillNotFoundError`、`resume !== false` 时 fork `execution.resume`，协议新增 `POST /api/session/:sessionID/skill`（404 `SkillNotFoundError`）+ server handler + SDK v2 重新生成。未移植部分：TUI skill UX（依赖上游更新的 useLocation 管线）、report skill、cli daemon、plugin skill.ts、packages/client gen。测试为 fork 补充：`packages/core/test/session-create.test.ts`（activates a known skill as a durable skill message）+ httpapi-exercise/httpapi-session 覆盖；manifest 计数随 durable 事件 +1（60/90/90/36）（上游该分支合入后按上游版本对齐） |
 
 ### TUI 偏离（四批 23 轮审计打磨，全域）
 

packages/core/src/session.ts

@@ -1,7 +1,7 @@
 export * as SessionV2 from "./session"
 export * from "./session/schema"
 
-import { DateTime, Effect, Layer, Schema, Context, Stream } from "effect"
+import { DateTime, Effect, Layer, Schema, Context, Stream, Scope } from "effect"
 import { ListAnchor } from "@opencode-ai/schema/session"
 import { and, asc, desc, eq, gt, like, lt, or, type SQL } from "drizzle-orm"
 import { ProjectV2 } from "./project"
@@ -37,6 +37,7 @@ import { SessionRevert } from "./session/revert"
 import { Revert } from "@opencode-ai/schema/revert"
 import { FSUtil } from "./fs-util"
 import { SessionDurable } from "@opencode-ai/schema/durable-event-manifest"
+import { SkillV2 } from "./skill"
 
 export const RevertState = Revert.State
 export type RevertState = Revert.State
@@ -95,7 +96,7 @@ export class NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("Ses
 export class OperationUnavailableError extends Schema.TaggedErrorClass<OperationUnavailableError>()(
   "Session.OperationUnavailableError",
   {
-    operation: Schema.Literals(["move", "shell", "skill", "switchAgent", "compact", "wait"]),
+    operation: Schema.Literals(["move", "shell", "skill", "switchAgent", "compact"]),
   },
 ) {}
 
@@ -105,10 +106,13 @@ export class PromptConflictError extends Schema.TaggedErrorClass<PromptConflictE
   sessionID: SessionSchema.ID,
   messageID: SessionMessage.ID,
 }) {}
+export class SkillNotFoundError extends Schema.TaggedErrorClass<SkillNotFoundError>()("Session.SkillNotFoundError", {
+  skill: Schema.String,
+}) {}
 export const MessageNotFoundError = SessionRevert.MessageNotFoundError
 export type MessageNotFoundError = SessionRevert.MessageNotFoundError
 
-export type Error = NotFoundError | MessageDecodeError | OperationUnavailableError | PromptConflictError
+export type Error = NotFoundError | MessageDecodeError | OperationUnavailableError | PromptConflictError | SkillNotFoundError
 
 export interface Interface {
   readonly list: (input?: ListInput) => Effect.Effect<SessionSchema.Info[]>
@@ -158,13 +162,13 @@ export interface Interface {
     resume?: boolean
   }) => Effect.Effect<void, OperationUnavailableError>
   readonly skill: (input: {
-    id?: EventV2.ID
+    id?: SessionMessage.ID
     sessionID: SessionSchema.ID
     skill: string
     resume?: boolean
-  }) => Effect.Effect<void, OperationUnavailableError>
+  }) => Effect.Effect<void, NotFoundError | SkillNotFoundError>
   readonly compact: (input: CompactInput) => Effect.Effect<void, NotFoundError | OperationUnavailableError>
-  readonly wait: (id: SessionSchema.ID) => Effect.Effect<void, NotFoundError | OperationUnavailableError>
+  readonly wait: (id: SessionSchema.ID) => Effect.Effect<void, NotFoundError>
   readonly active: Effect.Effect<ReadonlySet<SessionSchema.ID>>
   readonly resume: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError | SessionRunner.RunError>
   readonly interrupt: (sessionID: SessionSchema.ID) => Effect.Effect<void>
@@ -191,6 +195,7 @@ const layer = Layer.effect(
     const execution = yield* SessionExecution.Service
     const store = yield* SessionStore.Service
     const locations = yield* LocationServiceMap.Service
+    const scope = yield* Scope.Scope
     const decodeMessage = Schema.decodeUnknownEffect(SessionMessage.Message)
     const isDurableSessionEvent = Schema.is(SessionEvent.Durable)
     const decode = (row: typeof SessionMessageTable.$inferSelect) =>
@@ -387,8 +392,22 @@ const layer = Layer.effect(
       shell: Effect.fn("V2Session.shell")(function* () {
         return yield* new OperationUnavailableError({ operation: "shell" })
       }),
-      skill: Effect.fn("V2Session.skill")(function* () {
-        return yield* new OperationUnavailableError({ operation: "skill" })
+      skill: Effect.fn("V2Session.skill")(function* (input) {
+        const session = yield* result.get(input.sessionID)
+        const skills = yield* SkillV2.Service.pipe(Effect.provide(locations.get(session.location)))
+        const skill = (yield* skills.list()).find((item) => item.name === input.skill)
+        if (!skill) return yield* new SkillNotFoundError({ skill: input.skill })
+        yield* events.publish(SessionEvent.Skill.Activated, {
+          sessionID: input.sessionID,
+          messageID: input.id ?? SessionMessage.ID.create(),
+          timestamp: yield* DateTime.now,
+          name: skill.name,
+          text: skill.content,
+        })
+        if (input.resume !== false)
+          yield* execution
+            .resume(input.sessionID)
+            .pipe(Effect.ignore, Effect.forkIn(scope, { startImmediately: true }), Effect.asVoid)
       }),
       switchAgent: Effect.fn("V2Session.switchAgent")(function* (input) {
         yield* result.get(input.sessionID)
@@ -427,7 +446,7 @@ const layer = Layer.effect(
       }),
       wait: Effect.fn("V2Session.wait")(function* (sessionID) {
         yield* result.get(sessionID)
-        return yield* new OperationUnavailableError({ operation: "wait" })
+        yield* execution.awaitIdle(sessionID)
       }),
       active: execution.active,
       resume: Effect.fn("V2Session.resume")(function* (sessionID) {

packages/core/src/session/compaction.ts

@@ -123,6 +123,7 @@ const serialize = (message: SessionMessage.Message) => {
   }
   if (message.type === "system") return `[System update]: ${message.text}`
   if (message.type === "synthetic") return `[Synthetic context]: ${message.text}`
+  if (message.type === "skill") return `[Skill activated: ${message.name}]\n${message.text}`
   if (message.type === "shell") return `[Shell]: ${message.command}\n${truncate(message.output)}`
   return ""
 }

packages/core/src/session/execution.ts

@@ -15,6 +15,8 @@ export interface Interface {
   readonly wake: (sessionID: SessionSchema.ID) => Effect.Effect<void>
   /** Interrupt active work owned by this process. Idle interruption is a no-op. */
   readonly interrupt: (sessionID: SessionSchema.ID) => Effect.Effect<void>
+  /** Resolves once this process owns no active execution for the Session. Returns immediately when idle and never starts work. */
+  readonly awaitIdle: (sessionID: SessionSchema.ID) => Effect.Effect<void>
 }
 
 /** Routes execution from a Session ID to the runner owned by that Session's Location. */
@@ -30,5 +32,6 @@ export const noopLayer = Layer.succeed(
     resume: () => Effect.void,
     wake: () => Effect.void,
     interrupt: () => Effect.void,
+    awaitIdle: () => Effect.void,
   }),
 )

packages/core/src/session/execution/local.ts

@@ -33,6 +33,7 @@ const layer = Layer.effect(
       interrupt: coordinator.interrupt,
       resume: coordinator.run,
       wake: coordinator.wake,
+      awaitIdle: coordinator.awaitIdle,
     })
   }),
 )

packages/core/src/session/message-updater.ts

@@ -157,6 +157,17 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
           }),
         )
       },
+      "session.next.skill.activated": (event) => {
+        return adapter.appendMessage(
+          SessionMessage.Skill.make({
+            id: event.data.messageID,
+            type: "skill",
+            name: event.data.name,
+            text: event.data.text,
+            time: { created: event.data.timestamp },
+          }),
+        )
+      },
       "session.next.shell.started": (event) => {
         return adapter.appendMessage(
           SessionMessage.Shell.make({

packages/core/src/session/projector.ts

@@ -376,6 +376,15 @@ const layer = Layer.effectDiscard(
     )
     yield* events.project(SessionEvent.ContextUpdated, (event) => run(db, event))
     yield* events.project(SessionEvent.Synthetic, (event) => run(db, event))
+    yield* events.project(SessionEvent.Skill.Activated, (event) =>
+      insertMessage(db, event, {
+        id: event.data.messageID,
+        type: "skill",
+        name: event.data.name,
+        text: event.data.text,
+        time: { created: event.data.timestamp },
+      }),
+    )
     yield* events.project(SessionEvent.Shell.Started, (event) => run(db, event))
     yield* events.project(SessionEvent.Shell.Ended, (event) => run(db, event))
     yield* events.project(SessionEvent.Step.Started, (event) => run(db, event))

packages/core/src/session/run-coordinator.ts

@@ -12,6 +12,8 @@ export interface Coordinator<Key, E> {
   readonly wake: (key: Key) => Effect.Effect<void>
   /** Stops active execution and waits for its cleanup. */
   readonly interrupt: (key: Key) => Effect.Effect<void>
+  /** Resolves once no execution is active for the key. Returns immediately when already idle and never starts work. */
+  readonly awaitIdle: (key: Key) => Effect.Effect<void>
 }
 
 type Entry<E> = {
@@ -100,5 +102,15 @@ export const make = <Key, E>(options: {
         return Fiber.interrupt(entry.owner)
       })
 
-    return { active: Effect.sync(() => new Set(active.keys())), run, wake, interrupt }
+    // Each successful drain reuses its entry.done across coalesced wakes, so one await
+    // already spans steered and queued continuation. Re-check after it settles to cover a
+    // fresh wake (or a failure/stopping successor) that installs a new entry.
+    const awaitIdle = (key: Key): Effect.Effect<void> =>
+      Effect.suspend(() => {
+        const entry = active.get(key)
+        if (entry === undefined) return Effect.void
+        return Deferred.await(entry.done).pipe(Effect.exit, Effect.andThen(awaitIdle(key)))
+      })
+
+    return { active: Effect.sync(() => new Set(active.keys())), run, wake, interrupt, awaitIdle }
   })

packages/core/src/session/runner/to-llm-message.ts

@@ -131,6 +131,8 @@ function toLLMMessage(message: SessionMessage.Message, model: Model): Message[]
       ]
     case "synthetic":
       return [Message.make({ id: message.id, role: "user", content: message.text, metadata: message.metadata })]
+    case "skill":
+      return [Message.make({ id: message.id, role: "user", content: message.text, metadata: message.metadata })]
     case "system":
       return [Message.system(message.text)]
     case "shell":

packages/core/test/session-create.test.ts

@@ -23,6 +23,8 @@ import { SessionInput } from "@opencode-ai/core/session/input"
 import { SessionEvent } from "@opencode-ai/core/session/event"
 import { SessionTable } from "@opencode-ai/core/session/sql"
 import { SessionStore } from "@opencode-ai/core/session/store"
+import { SkillV2 } from "@opencode-ai/core/skill"
+import { LocationServiceMap } from "@opencode-ai/core/location-service-map"
 import { WorkspaceV2 } from "@opencode-ai/core/workspace"
 import { testEffect } from "./lib/effect"
 import { tmpdir } from "./fixture/tmpdir"
@@ -37,7 +39,14 @@ const projects = Layer.succeed(
 )
 const it = testEffect(
   AppNodeBuilder.build(
-    LayerNode.group([Database.node, EventV2.node, SessionProjector.node, SessionStore.node, SessionV2.node]),
+    LayerNode.group([
+      Database.node,
+      EventV2.node,
+      LocationServiceMap.node,
+      SessionProjector.node,
+      SessionStore.node,
+      SessionV2.node,
+    ]),
     [
       [ProjectV2.node, projects],
       [SessionExecution.node, SessionExecution.noopLayer],
@@ -318,7 +327,40 @@ describe("SessionV2.create", () => {
         )
 
       expect(yield* unavailable(session.shell({ sessionID: created.id, command: "pwd" }))).toBe("shell")
-      expect(yield* unavailable(session.skill({ sessionID: created.id, skill: "review" }))).toBe("skill")
+    }),
+  )
+
+  it.effect("activates a known skill as a durable skill message", () =>
+    Effect.gen(function* () {
+      const session = yield* SessionV2.Service
+      const tmp = yield* Effect.acquireRelease(
+        Effect.promise(() => tmpdir()),
+        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+      )
+      const created = yield* session.create({
+        location: Location.Ref.make({ directory: AbsolutePath.make(tmp.path) }),
+      })
+      const skills = yield* SkillV2.Service.pipe(Effect.provide(LocationServiceMap.Service.get(created.location)))
+      yield* skills.transform((editor) =>
+        editor.source({
+          type: "embedded",
+          skill: SkillV2.Info.make({
+            name: "review",
+            location: AbsolutePath.make(path.join(tmp.path, "review/SKILL.md")),
+            content: "Review the changes carefully.",
+          }),
+        }),
+      )
+
+      yield* session.skill({ sessionID: created.id, skill: "review" })
+
+      expect(yield* session.messages({ sessionID: created.id, order: "asc" })).toMatchObject([
+        { type: "skill", name: "review", text: "Review the changes carefully." },
+      ])
+      expect(yield* session.skill({ sessionID: created.id, skill: "missing" }).pipe(Effect.flip)).toMatchObject({
+        _tag: "Session.SkillNotFoundError",
+        skill: "missing",
+      })
     }),
   )