fix(api): require session selection

Co-authored-by: Kit Langton <kit.langton@gmail.com>

packages/cli/src/run/run.ts

@@ -94,11 +94,9 @@ async function execute(input: RunCommandInput, prepared: Prepared, endpoint: End
     prepare: async (next) => {
       const selected =
         next.model ??
-        (options.variant
-          ? await client.model
-              .default({ location: { directory: next.location.directory, workspace: next.location.workspaceID } })
-              .then((result) => result.data)
-          : undefined)
+        (await client.model
+          .default({ location: { directory: next.location.directory, workspace: next.location.workspaceID } })
+          .then((result) => result.data))
       const model = selected
         ? {
             providerID: selected.providerID,
@@ -108,7 +106,12 @@ async function execute(input: RunCommandInput, prepared: Prepared, endpoint: End
         : undefined
       if ((options.variant ?? explicit?.variant) && !model)
         throw new RunTargetError("Cannot select a variant before selecting a model", next.session?.id)
-      return { model, agent: next.agent }
+      const agent =
+        next.agent ??
+        (await client.agent
+          .list({ location: { directory: next.location.directory, workspace: next.location.workspaceID } })
+          .then((result) => result.data.find((item) => item.mode !== "subagent" && !item.hidden)?.id))
+      return { model, agent }
     },
   }).catch((error) => {
     if (!(error instanceof RunTargetError)) throw error

packages/cli/src/session-target.ts

@@ -56,13 +56,16 @@ export async function resolveSessionTarget(input: {
     agent: input.agent ?? selected?.agent,
     signal: input.signal,
   })
+  if (!selected && (!prepared.agent || !prepared.model)) {
+    throw new SessionTargetMutationError(new Error("Creating a session requires an agent and model"))
+  }
   const session =
     selected ??
     (await input.client.session
       .create(
         {
-          agent: prepared.agent,
-          model: prepared.model,
+          agent: prepared.agent!,
+          model: prepared.model!,
           location: { directory: location.directory, workspaceID: location.workspaceID },
         },
         ...requestOptions(input.signal),

packages/cli/test/session-target.test.ts

@@ -61,7 +61,11 @@ describe("session target resolver", () => {
     spyOn(client.location, "get").mockResolvedValue(location("/server", "work_1"))
     const create = spyOn(client.session, "create").mockImplementation(async (input) => {
       order.push("create")
-      expect(input).toMatchObject({ agent: "prepared", location: { directory: "/server", workspaceID: "work_1" } })
+      expect(input).toMatchObject({
+        agent: "prepared",
+        model: { providerID: "openai", id: "gpt-5" },
+        location: { directory: "/server", workspaceID: "work_1" },
+      })
       return session("ses_fresh", "/server", "work_1")
     })
 
@@ -71,20 +75,22 @@ describe("session target resolver", () => {
       prepare: async (input) => {
         order.push("prepare")
         expect(input.location.workspaceID).toBe("work_1")
-        return { model: input.model, agent: "prepared" }
+        return { model: { providerID: "openai", id: "gpt-5" }, agent: "prepared" }
       },
     })
     expect(create).toHaveBeenCalledTimes(1)
     expect(order).toEqual(["prepare", "create"])
   })
 
-  test("uses the agent resolved by the server for a fresh Session", async () => {
+  test("requires an explicit agent and model for a fresh Session", async () => {
     const client = OpenCode.make({ baseUrl: "https://opencode.test" })
     spyOn(client.location, "get").mockResolvedValue(location("/project"))
-    spyOn(client.session, "create").mockResolvedValue({ ...session("ses_fresh", "/project"), agent: "review" })
+    const create = spyOn(client.session, "create")
 
-    const target = await resolveSessionTarget({ client, prepare })
-    expect(target.agent).toBe("review")
+    await expect(resolveSessionTarget({ client, prepare })).rejects.toThrow(
+      "Creating a session requires an agent and model",
+    )
+    expect(create).not.toHaveBeenCalled()
   })
 
   test("does not retry an ambiguous Session creation", async () => {

packages/client/src/effect/api/api.ts

@@ -120,12 +120,12 @@ export type SessionListOperation<E = never> = (input?: Endpoint5_0Input) => Effe
 export type Endpoint5_1Input = {
   readonly id?: Session.ID | undefined
   readonly title?: string | undefined
-  readonly agent?: Agent.ID | undefined
-  readonly model?: Model.Ref | undefined
+  readonly agent: Agent.ID
+  readonly model: Model.Ref
   readonly location?: Location.Ref | undefined
 }
 export type Endpoint5_1Output = Session.Info
-export type SessionCreateOperation<E = never> = (input?: Endpoint5_1Input) => Effect.Effect<Endpoint5_1Output, E>
+export type SessionCreateOperation<E = never> = (input: Endpoint5_1Input) => Effect.Effect<Endpoint5_1Output, E>
 
 export type Endpoint5_2Input = {
   readonly info: Session.Info

packages/client/src/effect/generated/client.ts

@@ -305,15 +305,15 @@ const Endpoint5_0 = (raw: RawClient["server.session"]) => (input?: Endpoint5_0In
     }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint5_1 = (raw: RawClient["server.session"]) => (input?: Endpoint5_1Input) =>
+const Endpoint5_1 = (raw: RawClient["server.session"]) => (input: Endpoint5_1Input) =>
   preserveEffect<Endpoint5_1Output>()(
     raw["session.create"]({
       payload: {
-        id: input?.["id"],
-        title: input?.["title"],
-        agent: input?.["agent"],
-        model: input?.["model"],
-        location: input?.["location"],
+        id: input["id"],
+        title: input["title"],
+        agent: input["agent"],
+        model: input["model"],
+        location: input["location"],
       },
     }).pipe(
       Effect.mapError(mapClientError),

packages/client/src/promise/generated/client.ts

@@ -464,17 +464,17 @@ export function make(options: ClientOptions) {
           },
           requestOptions,
         ),
-      create: (input?: SessionCreateInput, requestOptions?: RequestOptions) =>
+      create: (input: SessionCreateInput, requestOptions?: RequestOptions) =>
         request<{ readonly data: SessionCreateOutput }>(
           {
             method: "POST",
             path: `/api/session`,
             body: {
-              id: input?.["id"],
-              title: input?.["title"],
-              agent: input?.["agent"],
-              model: input?.["model"],
-              location: input?.["location"],
+              id: input["id"],
+              title: input["title"],
+              agent: input["agent"],
+              model: input["model"],
+              location: input["location"],
             },
             successStatus: 200,
             declaredStatuses: [401, 400],

packages/client/src/promise/generated/types.ts

@@ -2436,36 +2436,36 @@ export type SessionCreateInput = {
   readonly id?: {
     readonly id?: string | null
     readonly title?: string | null
-    readonly agent?: string | null
-    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
+    readonly agent: string
+    readonly model: { readonly id: string; readonly providerID: string; readonly variant?: string }
     readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
   }["id"]
   readonly title?: {
     readonly id?: string | null
     readonly title?: string | null
-    readonly agent?: string | null
-    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
+    readonly agent: string
+    readonly model: { readonly id: string; readonly providerID: string; readonly variant?: string }
     readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
   }["title"]
-  readonly agent?: {
+  readonly agent: {
     readonly id?: string | null
     readonly title?: string | null
-    readonly agent?: string | null
-    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
+    readonly agent: string
+    readonly model: { readonly id: string; readonly providerID: string; readonly variant?: string }
     readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
   }["agent"]
-  readonly model?: {
+  readonly model: {
     readonly id?: string | null
     readonly title?: string | null
-    readonly agent?: string | null
-    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
+    readonly agent: string
+    readonly model: { readonly id: string; readonly providerID: string; readonly variant?: string }
     readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
   }["model"]
   readonly location?: {
     readonly id?: string | null
     readonly title?: string | null
-    readonly agent?: string | null
-    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
+    readonly agent: string
+    readonly model: { readonly id: string; readonly providerID: string; readonly variant?: string }
     readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
   }["location"]
 }

packages/client/test/effect.test.ts

@@ -181,6 +181,8 @@ test("session methods retain decoded Effect inputs and outputs", async () => {
     const page = yield* client.session.list({ limit: 10 })
     const active = yield* client.session.active()
     const created = yield* client.session.create({
+      agent: Agent.ID.make("build"),
+      model: Model.Ref.make({ id: "claude", providerID: "anthropic" }),
       location: Location.Ref.make({ directory: AbsolutePath.make("/tmp/project") }),
     })
     yield* client.session.switchAgent({ sessionID: Session.ID.make("ses_test"), agent: Agent.ID.make("build") })

packages/client/test/promise.test.ts

@@ -454,7 +454,11 @@ test("session methods use the public HTTP contract", async () => {
 
   const page = await client.session.list({ limit: 10, order: "desc", parentID: null })
   const active = await client.session.active()
-  const created = await client.session.create({ location: { directory: "/tmp/project" } })
+  const created = await client.session.create({
+    agent: "build",
+    model: { id: "claude", providerID: "anthropic" },
+    location: { directory: "/tmp/project" },
+  })
   await client.session.switchAgent({ sessionID: "ses_test", agent: "build" })
   await client.session.switchModel({
     sessionID: "ses_test",
@@ -528,7 +532,7 @@ test("middleware errors remain declared client errors", async () => {
   })
 
   try {
-    await client.session.create({})
+    await client.session.create({ agent: "build", model: { id: "claude", providerID: "anthropic" } })
     throw new Error("Expected request to fail")
   } catch (error) {
     expect(isUnauthorizedError(error)).toBe(true)

packages/core/src/config/plugin/agent.ts

@@ -161,11 +161,14 @@ function isPathAction(action: string): action is PathAction {
 }
 
 function expandHome(resource: string, home: string) {
-  if (resource.startsWith("~/")) return home + resource.slice(1)
   if (resource === "~") return home
   if (resource === "$HOME") return home
-  if (resource.startsWith("$HOME/")) return home + resource.slice(5)
-  if (resource.startsWith("$HOME\\")) return home + resource.slice(5)
+  const relative = resource.startsWith("~/")
+    ? resource.slice(2)
+    : resource.startsWith("$HOME/") || resource.startsWith("$HOME\\")
+      ? resource.slice(6)
+      : undefined
+  if (relative !== undefined) return (path.posix.isAbsolute(home) ? path.posix : path.win32).join(home, relative)
   return resource
 }
 

packages/core/src/plugin/host.ts

@@ -340,12 +340,12 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: import("../p
       hook: (name, callback) => hooks.register("session", name, callback),
       create: (input) =>
         runtime.session.create({
-          id: input?.id,
-          title: input?.title,
-          agent: input?.agent,
-          model: input?.model,
+          id: input.id,
+          title: input.title,
+          agent: input.agent,
+          model: input.model,
           location:
-            input?.location ?? Location.Ref.make({ directory: location.directory, workspaceID: location.workspaceID }),
+            input.location ?? Location.Ref.make({ directory: location.directory, workspaceID: location.workspaceID }),
         }),
       get: (input) => runtime.session.get(input.sessionID),
       prompt: runtime.session.prompt,

packages/core/src/plugin/promise.ts

@@ -269,25 +269,21 @@ export function fromPromise(plugin: Plugin) {
               register(host.session.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))))),
             create: (input) =>
               run(
-                host.session.create(
-                  input === undefined
-                    ? undefined
-                    : {
-                        id: input.id == null ? undefined : Session.ID.make(input.id),
-                        agent: input.agent == null ? undefined : Agent.ID.make(input.agent),
-                        model: input.model == null ? undefined : model(input.model),
-                        location:
-                          input.location == null
-                            ? undefined
-                            : Location.Ref.make({
-                                directory: AbsolutePath.make(input.location.directory),
-                                workspaceID:
-                                  input.location.workspaceID === undefined
-                                    ? undefined
-                                    : Workspace.ID.make(input.location.workspaceID),
-                              }),
-                      },
-                ),
+                host.session.create({
+                  id: input.id == null ? undefined : Session.ID.make(input.id),
+                  agent: Agent.ID.make(input.agent),
+                  model: model(input.model),
+                  location:
+                    input.location == null
+                      ? undefined
+                      : Location.Ref.make({
+                          directory: AbsolutePath.make(input.location.directory),
+                          workspaceID:
+                            input.location.workspaceID === undefined
+                              ? undefined
+                              : Workspace.ID.make(input.location.workspaceID),
+                        }),
+                }),
               ),
             get: (input) => run(host.session.get({ sessionID: Session.ID.make(input.sessionID) })),
             prompt: (input) =>

packages/core/src/skill.ts

@@ -2,7 +2,7 @@ export * as Skill from "./skill"
 
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import path from "path"
-import { Context, Effect, Layer, Schema, Scope, Stream, Types } from "effect"
+import { Context, Effect, Layer, Schema, Stream, Types } from "effect"
 import { FileSystem } from "@opencode-ai/schema/filesystem"
 import { Skill } from "@opencode-ai/schema/skill"
 import { Agent } from "./agent"
@@ -13,7 +13,6 @@ import { Permission } from "./permission"
 import { AbsolutePath } from "./schema"
 import { SkillDiscovery } from "./skill/discovery"
 import { State } from "./state"
-import { Watcher } from "./filesystem/watcher"
 
 export const DirectorySource = Skill.DirectorySource
 export type DirectorySource = Skill.DirectorySource
@@ -82,51 +81,6 @@ const layer = Layer.effect(
     const discovery = yield* SkillDiscovery.Service
     const fs = yield* FSUtil.Service
     const bus = yield* Bus.Service
-    const watcher = yield* Watcher.Service
-    const scope = yield* Scope.Scope
-    const cache = new Map<string, { skills: Info[]; paths: readonly string[] }>()
-    const watched = new Set<string>()
-
-    const invalidate = Effect.fn("Skill.invalidateFromWatcher")(function* (file: string) {
-      const invalidated = Array.from(cache.entries()).filter(([, loaded]) =>
-        loaded.paths.some((item) => FSUtil.overlaps(item, file)),
-      )
-      if (invalidated.length === 0) return
-      for (const [key] of invalidated) cache.delete(key)
-      yield* Effect.logInfo("skill cache invalidated", {
-        file,
-        sources: invalidated.map(([key]) => key),
-        skills: invalidated.flatMap(([, loaded]) => loaded.skills.map((skill) => skill.id)),
-      })
-      yield* bus.publish(Skill.Event.Updated, {}).pipe(Effect.asVoid)
-    })
-
-    const watch = Effect.fn("Skill.watch")(function* (directory: string) {
-      const target = path.resolve(directory)
-      if (watched.has(target)) return
-      watched.add(target)
-      const updates = yield* watcher.subscribe({ path: target, type: "directory" })
-      yield* updates.pipe(
-        Stream.runForEach((update) => invalidate(update.path)),
-        Effect.forkIn(scope, { startImmediately: true }),
-      )
-    })
-
-    const watchDirectory = Effect.fn("Skill.watchDirectory")(function* (directory: string) {
-      const target = path.resolve(directory)
-      const resolved = yield* fs.realPath(directory).pipe(Effect.catch(() => Effect.succeed(undefined)))
-      if (resolved) {
-        yield* watch(resolved)
-        if (resolved !== target) {
-          yield* watch(path.dirname(target))
-        }
-        return resolved === target ? [target] : [target, resolved]
-      }
-      if (yield* fs.isDir(path.dirname(target))) {
-        yield* watch(path.dirname(target))
-      }
-      return [target]
-    })
 
     const state = State.create<Data, Draft>({
       name: "skill",
@@ -138,8 +92,7 @@ const layer = Layer.effect(
         },
         list: () => draft.sources as Source[],
       }),
-      finalize: () =>
-        Effect.sync(() => cache.clear()).pipe(Effect.andThen(bus.publish(Skill.Event.Updated, {})), Effect.asVoid),
+      finalize: () => bus.publish(Skill.Event.Updated, {}).pipe(Effect.asVoid),
     })
 
     const load = Effect.fn("Skill.load")(function* (source: Source) {
@@ -151,22 +104,14 @@ const layer = Layer.effect(
           directories: [],
           skills: [source.skill.id],
         })
-        return { skills: [source.skill], paths: [] }
+        return { skills: [source.skill], directories: [] }
       }
       const directories = source.type === "directory" ? [source.path] : yield* discovery.pull(source.url)
-      const roots = (yield* Effect.forEach(directories, watchDirectory)).flat()
-      const paths = [...roots]
       for (const directory of directories) {
         const files = yield* fs
           .scan("{*.md,**/SKILL.md}", { cwd: directory, absolute: true, include: "file", symlink: true, dot: true })
           .pipe(Effect.catch(() => Effect.succeed([] as string[])))
         for (const filepath of files.toSorted()) {
-          const resolved = yield* fs.realPath(filepath).pipe(Effect.catch(() => Effect.succeed(filepath)))
-          if (!roots.some((root) => FSUtil.contains(root, resolved))) {
-            const external = path.dirname(resolved)
-            paths.push(external)
-            yield* watch(external)
-          }
           const content = yield* fs.readFileStringSafe(filepath).pipe(Effect.catch(() => Effect.succeed(undefined)))
           if (!content) continue
           const markdown = ConfigMarkdown.parseOption(content)
@@ -194,7 +139,22 @@ const layer = Layer.effect(
         directories,
         skills: skills.map((skill) => skill.id),
       })
-      return { skills, paths }
+      return { skills, directories }
+    })
+
+    const cache = new Map<string, { skills: Info[]; directories: readonly string[] }>()
+    const invalidate = Effect.fn("Skill.invalidateFromWatcher")(function* (file: string) {
+      const invalidated = Array.from(cache.entries()).filter(([, loaded]) =>
+        loaded.directories.some((directory) => FSUtil.contains(directory, file)),
+      )
+      if (invalidated.length === 0) return
+      for (const [key] of invalidated) cache.delete(key)
+      yield* Effect.logInfo("skill cache invalidated", {
+        file,
+        sources: invalidated.map(([key]) => key),
+        skills: invalidated.flatMap(([, loaded]) => loaded.skills.map((skill) => skill.id)),
+      })
+      yield* bus.publish(Skill.Event.Updated, {}).pipe(Effect.asVoid)
     })
 
     yield* bus.subscribe(FileSystem.Event.Changed).pipe(
@@ -227,5 +187,5 @@ const layer = Layer.effect(
 export const node = makeLocationNode({
   service: Service,
   layer,
-  deps: [SkillDiscovery.node, FSUtil.node, Bus.node, Watcher.node],
+  deps: [SkillDiscovery.node, FSUtil.node, Bus.node],
 })

packages/core/test/config/agent.test.ts

@@ -51,6 +51,11 @@ describe("ConfigAgentPlugin.Plugin", () => {
   it.effect("matches Windows paths against home-relative permissions", () =>
     Effect.gen(function* () {
       const permissions = yield* loadHomePermissions("C:\\Users\\test")
+      expect(permissions).toContainEqual({
+        action: "external_directory",
+        resource: "C:\\Users\\test\\p\\**",
+        effect: "allow",
+      })
       expect(
         Permission.evaluate("external_directory", "C:\\Users\\test\\p\\opencode\\src\\*", permissions).effect,
       ).toBe("allow")

packages/core/test/skill.test.ts

@@ -6,11 +6,11 @@ import { Agent } from "@opencode-ai/core/agent"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { Bus } from "@opencode-ai/core/bus"
+import { FSUtil } from "@opencode-ai/util/fs-util"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Skill } from "@opencode-ai/core/skill"
 import { SkillDiscovery } from "@opencode-ai/core/skill/discovery"
 import { FileSystem } from "@opencode-ai/schema/filesystem"
-import { Watcher } from "@opencode-ai/core/filesystem/watcher"
 import { tmpdir } from "./fixture/tmpdir"
 import { testEffect } from "./lib/effect"
 
@@ -25,15 +25,8 @@ const discovery = Layer.succeed(
     },
   }),
 )
-const watcherLayer = Watcher.testLayer
 const it = testEffect(
-  Layer.mergeAll(
-    AppNodeBuilder.build(LayerNode.group([Skill.node, Agent.node, Bus.node]), [
-      [SkillDiscovery.node, discovery],
-      [Watcher.node, watcherLayer],
-    ]),
-    watcherLayer,
-  ),
+  AppNodeBuilder.build(LayerNode.group([Skill.node, Agent.node, Bus.node]), [[SkillDiscovery.node, discovery]]),
 )
 
 function write(directory: string, name: string, description: string) {
@@ -60,24 +53,6 @@ function waitForSkillUpdate() {
   })
 }
 
-function expectSubscription(check: (input: Watcher.WatchInput) => boolean) {
-  return Effect.gen(function* () {
-    const watcher = yield* Watcher.Test
-    expect((yield* watcher.subscriptions()).some(check)).toBe(true)
-  })
-}
-
-function emitAndWait(update: Watcher.Update) {
-  return Effect.gen(function* () {
-    const watcher = yield* Watcher.Test
-    yield* Effect.acquireUseRelease(
-      waitForSkillUpdate(),
-      ({ deferred }) => watcher.emit(update).pipe(Effect.andThen(Deferred.await(deferred)), Effect.timeout("1 second")),
-      ({ fiber }) => Fiber.interrupt(fiber),
-    )
-  })
-}
-
 describe("Skill", () => {
   it.live("publishes updates when skill sources change", () =>
     Effect.gen(function* () {
@@ -223,7 +198,7 @@ metadata:
     ),
   )
 
-  it.live("clears cached skills when sources reload", () =>
+  it.live("invalidates cached skills and publishes updates for watcher changes", () =>
     Effect.acquireRelease(
       Effect.promise(() => tmpdir()),
       (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
@@ -235,155 +210,26 @@ metadata:
             await write(tmp.path, "deploy", "Initial deploy")
           })
 
+          const bus = yield* Bus.Service
           const skill = yield* Skill.Service
           yield* skill.transform((editor) => editor.source({ type: "directory", path: AbsolutePath.make(tmp.path) }))
-          expect((yield* skill.list()).find((item) => item.id === "deploy")?.description).toBe("Initial deploy")
 
+          expect((yield* skill.list()).find((item) => item.name === "deploy")?.description).toBe("Initial deploy")
+
+          const file = path.join(tmp.path, "deploy", "SKILL.md")
           yield* Effect.promise(() => write(tmp.path, "deploy", "Updated deploy"))
-          yield* skill.reload()
+          expect((yield* skill.list()).find((item) => item.name === "deploy")?.description).toBe("Initial deploy")
 
-          expect((yield* skill.list()).find((item) => item.id === "deploy")?.description).toBe("Updated deploy")
-        }),
-      ),
-    ),
-  )
-
-  it.live("reloads project sources created after their missing parent", () =>
-    Effect.acquireRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ).pipe(
-      Effect.flatMap((tmp) =>
-        Effect.gen(function* () {
-          const source = path.join(tmp.path, "generated", "skills")
-          const file = path.join(source, "deploy", "SKILL.md")
-          const skill = yield* Skill.Service
-          const bus = yield* Bus.Service
-          yield* skill.transform((editor) => editor.source({ type: "directory", path: AbsolutePath.make(source) }))
-          expect(yield* skill.list()).toEqual([])
-
-          yield* Effect.promise(async () => {
-            await fs.mkdir(path.dirname(file), { recursive: true })
-            await write(source, "deploy", "Deploy production")
-          })
           yield* Effect.acquireUseRelease(
             waitForSkillUpdate(),
             ({ deferred }) =>
               bus
-                .publish(FileSystem.Event.Changed, { file, event: "add" })
+                .publish(FileSystem.Event.Changed, { file, event: "change" })
                 .pipe(Effect.andThen(Deferred.await(deferred)), Effect.timeout("1 second")),
             ({ fiber }) => Fiber.interrupt(fiber),
           )
 
-          expect((yield* skill.list()).map((item) => item.id)).toEqual([Skill.ID.make("deploy")])
-        }),
-      ),
-    ),
-  )
-
-  it.live("watches directory sources for added and changed skills", () =>
-    Effect.acquireRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ).pipe(
-      Effect.flatMap((tmp) =>
-        Effect.gen(function* () {
-          yield* Effect.promise(async () => {
-            await fs.mkdir(path.join(tmp.path, "deploy"), { recursive: true })
-            await write(tmp.path, "deploy", "Initial deploy")
-          })
-
-          const skill = yield* Skill.Service
-          yield* skill.transform((editor) => editor.source({ type: "directory", path: AbsolutePath.make(tmp.path) }))
-          expect((yield* skill.list()).map((item) => item.id)).toEqual([Skill.ID.make("deploy")])
-          yield* expectSubscription((input) => input.type === "directory" && input.path === tmp.path)
-
-          const deploy = path.join(tmp.path, "deploy", "SKILL.md")
-          yield* Effect.promise(() => write(tmp.path, "deploy", "Updated deploy"))
-          yield* emitAndWait({ type: "update", path: deploy })
-          expect((yield* skill.list()).find((item) => item.id === "deploy")?.description).toBe("Updated deploy")
-
-          yield* Effect.promise(async () => {
-            await fs.mkdir(path.join(tmp.path, "review"), { recursive: true })
-            await write(tmp.path, "review", "Review changes")
-          })
-          const review = path.join(tmp.path, "review", "SKILL.md")
-          yield* emitAndWait({ type: "create", path: review })
-          expect((yield* skill.list()).map((item) => item.id)).toEqual([
-            Skill.ID.make("deploy"),
-            Skill.ID.make("review"),
-          ])
-
-          yield* Effect.promise(() => fs.rm(path.join(tmp.path, "review"), { recursive: true }))
-          yield* emitAndWait({ type: "delete", path: review })
-          expect((yield* skill.list()).map((item) => item.id)).toEqual([Skill.ID.make("deploy")])
-        }),
-      ),
-    ),
-  )
-
-  it.live("watches canonical directories behind symlinked skills", () =>
-    Effect.acquireRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ).pipe(
-      Effect.flatMap((tmp) =>
-        Effect.gen(function* () {
-          const source = path.join(tmp.path, "source")
-          const target = path.join(tmp.path, "target", "bro")
-          const file = path.join(target, "SKILL.md")
-          yield* Effect.promise(async () => {
-            await fs.mkdir(source, { recursive: true })
-            await fs.mkdir(target, { recursive: true })
-            await fs.writeFile(file, "---\nname: bro\ndescription: Initial\n---\n# bro")
-            await fs.symlink(target, path.join(source, "bro"))
-          })
-
-          const skill = yield* Skill.Service
-          yield* skill.transform((editor) => editor.source({ type: "directory", path: AbsolutePath.make(source) }))
-          expect((yield* skill.list()).find((item) => item.id === "bro")?.description).toBe("Initial")
-          yield* expectSubscription((input) => input.type === "directory" && input.path === target)
-
-          yield* Effect.promise(() => fs.writeFile(file, "---\nname: bro\ndescription: Updated\n---\n# bro"))
-          yield* emitAndWait({ type: "update", path: file })
-          expect((yield* skill.list()).find((item) => item.id === "bro")?.description).toBe("Updated")
-        }),
-      ),
-    ),
-  )
-
-  it.live("invalidates symlinked sources when their target changes", () =>
-    Effect.acquireRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ).pipe(
-      Effect.flatMap((tmp) =>
-        Effect.gen(function* () {
-          const source = path.join(tmp.path, "source")
-          const first = path.join(tmp.path, "first")
-          const second = path.join(tmp.path, "second")
-          yield* Effect.promise(async () => {
-            await fs.mkdir(path.join(first, "bro"), { recursive: true })
-            await fs.mkdir(path.join(second, "bro"), { recursive: true })
-            await write(first, "bro", "First")
-            await write(second, "bro", "Second")
-            await fs.symlink(first, source)
-          })
-
-          const skill = yield* Skill.Service
-          yield* skill.transform((editor) => editor.source({ type: "directory", path: AbsolutePath.make(source) }))
-          expect((yield* skill.list()).find((item) => item.id === "bro")?.description).toBe("First")
-          yield* expectSubscription((input) => input.type === "directory" && input.path === first)
-          yield* expectSubscription((input) => input.type === "directory" && input.path === tmp.path)
-
-          yield* Effect.promise(async () => {
-            await fs.unlink(source)
-            await fs.symlink(second, source)
-          })
-          yield* emitAndWait({ type: "update", path: source })
-
-          expect((yield* skill.list()).find((item) => item.id === "bro")?.description).toBe("Second")
-          yield* expectSubscription((input) => input.type === "directory" && input.path === second)
+          expect((yield* skill.list()).find((item) => item.name === "deploy")?.description).toBe("Updated deploy")
         }),
       ),
     ),

packages/protocol/src/groups/session.ts

@@ -151,8 +151,8 @@ export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S>(sessionLo
         payload: Schema.Struct({
           id: Session.ID.pipe(Schema.optional),
           title: Schema.String.pipe(Schema.optional),
-          agent: Agent.ID.pipe(Schema.optional),
-          model: Model.Ref.pipe(Schema.optional),
+          agent: Agent.ID,
+          model: Model.Ref,
           location: Location.Ref.pipe(Schema.optional),
         }),
         success: Schema.Struct({ data: Session.Info }),
@@ -160,7 +160,7 @@ export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S>(sessionLo
         OpenApi.annotations({
           identifier: "v2.session.create",
           summary: "Create session",
-          description: "Create a session at the requested location.",
+          description: "Create a session with an explicit agent and model at the requested location.",
         }),
       ),
     )

packages/tui/src/app.tsx

@@ -512,7 +512,7 @@ function App(props: { pair?: DialogPairCredentials }) {
   const terminalTitleEnabled = () => config.data.terminal?.title ?? true
   const copyOnSelectEnabled = () => config.data.terminal?.copy_on_select ?? process.platform !== "win32"
   const pasteSummaryEnabled = () => config.data.prompt?.paste !== "full"
-  const tabsVertical = () => (config.data.tabs?.vertical ?? false) && sessionTabsFitVertically(dimensions().width)
+  const tabsVertical = () => config.data.tabs.layout === "vertical" && sessionTabsFitVertically(dimensions().width)
   const tabsVisible = () =>
     sessionTabs.enabled() && (sessionTabs.tabs().length > 0 || sessionTabs.newTab()) && route.data.type !== "plugin"
 

packages/tui/src/component/dialog-config.tsx

@@ -101,12 +101,11 @@ export const settings: Setting[] = [
     labels: ["current directory", "global"],
   },
   {
-    title: "Vertical",
+    title: "Layout",
     category: "Tabs",
-    path: ["tabs", "vertical"],
-    default: false,
-    values: [false, true],
-    labels: ["off", "on"],
+    path: ["tabs", "layout"],
+    default: "horizontal",
+    values: ["horizontal", "vertical"],
     keywords: ["sidebar", "orientation", "left"],
   },
   {

packages/tui/src/config/index.tsx

@@ -132,8 +132,8 @@ export const Info = Schema.Struct({
       scope: Schema.optional(Schema.Literals(["global", "cwd"])).annotate({
         description: "Share tabs globally or keep a separate set for each working directory",
       }),
-      vertical: Schema.optional(Schema.Boolean).annotate({
-        description: "Show tabs in a left sidebar instead of a horizontal strip",
+      layout: Schema.optional(Schema.Literals(["horizontal", "vertical"])).annotate({
+        description: "Show tabs in a horizontal strip or vertical sidebar",
       }),
     }),
   ).annotate({ description: "Tab strip settings" }),
@@ -194,7 +194,7 @@ export type Resolved = Omit<Info, "attention" | "keybinds" | "leader" | "mouse"
   tabs: {
     enabled: boolean
     scope: "global" | "cwd"
-    vertical?: boolean
+    layout: "horizontal" | "vertical"
   }
 }
 
@@ -230,6 +230,7 @@ export function resolve(input: Info, options: { terminalSuspend: boolean }): Res
       ...input.tabs,
       enabled: input.tabs?.enabled ?? true,
       scope: input.tabs?.scope ?? "cwd",
+      layout: input.tabs?.layout ?? "horizontal",
     },
   }
 }

packages/tui/src/routes/session/index.tsx

@@ -204,7 +204,7 @@ export function Session() {
   const availableWidth = createMemo(
     () =>
       dimensions().width -
-      (config.tabs?.enabled && config.tabs.vertical && sessionTabsFitVertically(dimensions().width)
+      (config.tabs?.enabled && config.tabs.layout === "vertical" && sessionTabsFitVertically(dimensions().width)
         ? SESSION_SIDEBAR_WIDTH
         : 0),
   )

packages/tui/test/config-v2.test.tsx

@@ -18,7 +18,10 @@ test("validates mini replay settings", () => {
 test("validates the session tabs setting", () => {
   const decode = Schema.decodeUnknownSync(Info)
 
-  expect(decode({ tabs: { enabled: true, vertical: true } })).toEqual({ tabs: { enabled: true, vertical: true } })
+  expect(decode({ tabs: { enabled: true, layout: "vertical" } })).toEqual({
+    tabs: { enabled: true, layout: "vertical" },
+  })
+  expect(() => decode({ tabs: { layout: true } })).toThrow()
   expect(() => decode({ tabs: { enabled: "on" } })).toThrow()
 })
 
@@ -39,12 +42,13 @@ test("resolves nested config and keybind defaults", () => {
   expect(config.scroll).toEqual({ speed: 2, acceleration: true })
   expect(config.diffs).toEqual({ view: "split" })
   expect(config.debug).toEqual({ devtools: true })
-  expect(config.tabs).toEqual({ enabled: true, scope: "cwd" })
+  expect(config.tabs).toEqual({ enabled: true, scope: "cwd", layout: "horizontal" })
 })
 
 test("shows resolved tab defaults in settings", () => {
   expect(settings.find((setting) => setting.path.join(".") === "tabs.enabled")?.default).toBe(true)
   expect(settings.find((setting) => setting.path.join(".") === "tabs.scope")?.default).toBe("cwd")
+  expect(settings.find((setting) => setting.path.join(".") === "tabs.layout")?.default).toBe("horizontal")
 })
 
 test("provides config and its host interface", async () => {