chore(client): regenerate project API

test(project): update session project mock
feat(project): support project metadata updates
2026-07-24 11:46:17 +00:00 · 2026-07-23 12:06:18 +08:00 · 2026-07-23 12:06:02 +08:00 · 2026-07-23 12:05:51 +08:00 · 2026-07-23 12:05:43 +08:00 · 2026-07-23 12:05:41 +08:00
54 changed files with 1051 additions and 366 deletions
@@ -124,185 +124,190 @@ export type Endpoint5_8Input = {
 export type Endpoint5_8Output = EffectValue<ReturnType<RawClient["server.session"]["session.rename"]>>
 export type SessionRenameOperation<E = never> = (input: Endpoint5_8Input) => Effect.Effect<Endpoint5_8Output, E>

-type Endpoint5_9Request = Parameters<RawClient["server.session"]["session.move"]>[0]
-export type Endpoint5_9Input = {
-  readonly sessionID: Endpoint5_9Request["params"]["sessionID"]
-  readonly directory: Endpoint5_9Request["payload"]["directory"]
-  readonly workspaceID?: Endpoint5_9Request["payload"]["workspaceID"]
-}
-export type Endpoint5_9Output = EffectValue<ReturnType<RawClient["server.session"]["session.move"]>>
-export type SessionMoveOperation<E = never> = (input: Endpoint5_9Input) => Effect.Effect<Endpoint5_9Output, E>
+type Endpoint5_9Request = Parameters<RawClient["server.session"]["session.archive"]>[0]
+export type Endpoint5_9Input = { readonly sessionID: Endpoint5_9Request["params"]["sessionID"] }
+export type Endpoint5_9Output = EffectValue<ReturnType<RawClient["server.session"]["session.archive"]>>
+export type SessionArchiveOperation<E = never> = (input: Endpoint5_9Input) => Effect.Effect<Endpoint5_9Output, E>

-type Endpoint5_10Request = Parameters<RawClient["server.session"]["session.prompt"]>[0]
+type Endpoint5_10Request = Parameters<RawClient["server.session"]["session.move"]>[0]
 export type Endpoint5_10Input = {
  readonly sessionID: Endpoint5_10Request["params"]["sessionID"]
-  readonly id?: Endpoint5_10Request["payload"]["id"]
-  readonly text: Endpoint5_10Request["payload"]["text"]
-  readonly files?: Endpoint5_10Request["payload"]["files"]
-  readonly agents?: Endpoint5_10Request["payload"]["agents"]
-  readonly metadata?: Endpoint5_10Request["payload"]["metadata"]
-  readonly delivery?: Endpoint5_10Request["payload"]["delivery"]
-  readonly resume?: Endpoint5_10Request["payload"]["resume"]
+  readonly directory: Endpoint5_10Request["payload"]["directory"]
+  readonly workspaceID?: Endpoint5_10Request["payload"]["workspaceID"]
 }
-export type Endpoint5_10Output = EffectValue<ReturnType<RawClient["server.session"]["session.prompt"]>>["data"]
-export type SessionPromptOperation<E = never> = (input: Endpoint5_10Input) => Effect.Effect<Endpoint5_10Output, E>
+export type Endpoint5_10Output = EffectValue<ReturnType<RawClient["server.session"]["session.move"]>>
+export type SessionMoveOperation<E = never> = (input: Endpoint5_10Input) => Effect.Effect<Endpoint5_10Output, E>

-type Endpoint5_11Request = Parameters<RawClient["server.session"]["session.command"]>[0]
+type Endpoint5_11Request = Parameters<RawClient["server.session"]["session.prompt"]>[0]
 export type Endpoint5_11Input = {
  readonly sessionID: Endpoint5_11Request["params"]["sessionID"]
  readonly id?: Endpoint5_11Request["payload"]["id"]
-  readonly command: Endpoint5_11Request["payload"]["command"]
-  readonly arguments?: Endpoint5_11Request["payload"]["arguments"]
-  readonly agent?: Endpoint5_11Request["payload"]["agent"]
-  readonly model?: Endpoint5_11Request["payload"]["model"]
+  readonly text: Endpoint5_11Request["payload"]["text"]
  readonly files?: Endpoint5_11Request["payload"]["files"]
  readonly agents?: Endpoint5_11Request["payload"]["agents"]
+  readonly metadata?: Endpoint5_11Request["payload"]["metadata"]
  readonly delivery?: Endpoint5_11Request["payload"]["delivery"]
  readonly resume?: Endpoint5_11Request["payload"]["resume"]
 }
-export type Endpoint5_11Output = EffectValue<ReturnType<RawClient["server.session"]["session.command"]>>["data"]
-export type SessionCommandOperation<E = never> = (input: Endpoint5_11Input) => Effect.Effect<Endpoint5_11Output, E>
+export type Endpoint5_11Output = EffectValue<ReturnType<RawClient["server.session"]["session.prompt"]>>["data"]
+export type SessionPromptOperation<E = never> = (input: Endpoint5_11Input) => Effect.Effect<Endpoint5_11Output, E>

-type Endpoint5_12Request = Parameters<RawClient["server.session"]["session.skill"]>[0]
+type Endpoint5_12Request = Parameters<RawClient["server.session"]["session.command"]>[0]
 export type Endpoint5_12Input = {
  readonly sessionID: Endpoint5_12Request["params"]["sessionID"]
  readonly id?: Endpoint5_12Request["payload"]["id"]
-  readonly skill: Endpoint5_12Request["payload"]["skill"]
+  readonly command: Endpoint5_12Request["payload"]["command"]
+  readonly arguments?: Endpoint5_12Request["payload"]["arguments"]
+  readonly agent?: Endpoint5_12Request["payload"]["agent"]
+  readonly model?: Endpoint5_12Request["payload"]["model"]
+  readonly files?: Endpoint5_12Request["payload"]["files"]
+  readonly agents?: Endpoint5_12Request["payload"]["agents"]
+  readonly delivery?: Endpoint5_12Request["payload"]["delivery"]
  readonly resume?: Endpoint5_12Request["payload"]["resume"]
 }
-export type Endpoint5_12Output = EffectValue<ReturnType<RawClient["server.session"]["session.skill"]>>
-export type SessionSkillOperation<E = never> = (input: Endpoint5_12Input) => Effect.Effect<Endpoint5_12Output, E>
+export type Endpoint5_12Output = EffectValue<ReturnType<RawClient["server.session"]["session.command"]>>["data"]
+export type SessionCommandOperation<E = never> = (input: Endpoint5_12Input) => Effect.Effect<Endpoint5_12Output, E>

-type Endpoint5_13Request = Parameters<RawClient["server.session"]["session.synthetic"]>[0]
+type Endpoint5_13Request = Parameters<RawClient["server.session"]["session.skill"]>[0]
 export type Endpoint5_13Input = {
  readonly sessionID: Endpoint5_13Request["params"]["sessionID"]
  readonly id?: Endpoint5_13Request["payload"]["id"]
-  readonly text: Endpoint5_13Request["payload"]["text"]
-  readonly description?: Endpoint5_13Request["payload"]["description"]
-  readonly metadata?: Endpoint5_13Request["payload"]["metadata"]
-  readonly delivery?: Endpoint5_13Request["payload"]["delivery"]
+  readonly skill: Endpoint5_13Request["payload"]["skill"]
  readonly resume?: Endpoint5_13Request["payload"]["resume"]
 }
-export type Endpoint5_13Output = EffectValue<ReturnType<RawClient["server.session"]["session.synthetic"]>>["data"]
-export type SessionSyntheticOperation<E = never> = (input: Endpoint5_13Input) => Effect.Effect<Endpoint5_13Output, E>
+export type Endpoint5_13Output = EffectValue<ReturnType<RawClient["server.session"]["session.skill"]>>
+export type SessionSkillOperation<E = never> = (input: Endpoint5_13Input) => Effect.Effect<Endpoint5_13Output, E>

-type Endpoint5_14Request = Parameters<RawClient["server.session"]["session.shell"]>[0]
+type Endpoint5_14Request = Parameters<RawClient["server.session"]["session.synthetic"]>[0]
 export type Endpoint5_14Input = {
  readonly sessionID: Endpoint5_14Request["params"]["sessionID"]
  readonly id?: Endpoint5_14Request["payload"]["id"]
-  readonly command: Endpoint5_14Request["payload"]["command"]
+  readonly text: Endpoint5_14Request["payload"]["text"]
+  readonly description?: Endpoint5_14Request["payload"]["description"]
+  readonly metadata?: Endpoint5_14Request["payload"]["metadata"]
+  readonly delivery?: Endpoint5_14Request["payload"]["delivery"]
+  readonly resume?: Endpoint5_14Request["payload"]["resume"]
 }
-export type Endpoint5_14Output = EffectValue<ReturnType<RawClient["server.session"]["session.shell"]>>
-export type SessionShellOperation<E = never> = (input: Endpoint5_14Input) => Effect.Effect<Endpoint5_14Output, E>
+export type Endpoint5_14Output = EffectValue<ReturnType<RawClient["server.session"]["session.synthetic"]>>["data"]
+export type SessionSyntheticOperation<E = never> = (input: Endpoint5_14Input) => Effect.Effect<Endpoint5_14Output, E>

-type Endpoint5_15Request = Parameters<RawClient["server.session"]["session.compact"]>[0]
+type Endpoint5_15Request = Parameters<RawClient["server.session"]["session.shell"]>[0]
 export type Endpoint5_15Input = {
  readonly sessionID: Endpoint5_15Request["params"]["sessionID"]
  readonly id?: Endpoint5_15Request["payload"]["id"]
+  readonly command: Endpoint5_15Request["payload"]["command"]
 }
-export type Endpoint5_15Output = EffectValue<ReturnType<RawClient["server.session"]["session.compact"]>>["data"]
-export type SessionCompactOperation<E = never> = (input: Endpoint5_15Input) => Effect.Effect<Endpoint5_15Output, E>
+export type Endpoint5_15Output = EffectValue<ReturnType<RawClient["server.session"]["session.shell"]>>
+export type SessionShellOperation<E = never> = (input: Endpoint5_15Input) => Effect.Effect<Endpoint5_15Output, E>

-type Endpoint5_16Request = Parameters<RawClient["server.session"]["session.wait"]>[0]
-export type Endpoint5_16Input = { readonly sessionID: Endpoint5_16Request["params"]["sessionID"] }
-export type Endpoint5_16Output = EffectValue<ReturnType<RawClient["server.session"]["session.wait"]>>
-export type SessionWaitOperation<E = never> = (input: Endpoint5_16Input) => Effect.Effect<Endpoint5_16Output, E>
-
-type Endpoint5_17Request = Parameters<RawClient["server.session"]["session.revert.stage"]>[0]
-export type Endpoint5_17Input = {
-  readonly sessionID: Endpoint5_17Request["params"]["sessionID"]
-  readonly messageID: Endpoint5_17Request["payload"]["messageID"]
-  readonly files?: Endpoint5_17Request["payload"]["files"]
+type Endpoint5_16Request = Parameters<RawClient["server.session"]["session.compact"]>[0]
+export type Endpoint5_16Input = {
+  readonly sessionID: Endpoint5_16Request["params"]["sessionID"]
+  readonly id?: Endpoint5_16Request["payload"]["id"]
 }
-export type Endpoint5_17Output = EffectValue<ReturnType<RawClient["server.session"]["session.revert.stage"]>>["data"]
-export type SessionRevertStageOperation<E = never> = (input: Endpoint5_17Input) => Effect.Effect<Endpoint5_17Output, E>
+export type Endpoint5_16Output = EffectValue<ReturnType<RawClient["server.session"]["session.compact"]>>["data"]
+export type SessionCompactOperation<E = never> = (input: Endpoint5_16Input) => Effect.Effect<Endpoint5_16Output, E>

-type Endpoint5_18Request = Parameters<RawClient["server.session"]["session.revert.clear"]>[0]
-export type Endpoint5_18Input = { readonly sessionID: Endpoint5_18Request["params"]["sessionID"] }
-export type Endpoint5_18Output = EffectValue<ReturnType<RawClient["server.session"]["session.revert.clear"]>>
-export type SessionRevertClearOperation<E = never> = (input: Endpoint5_18Input) => Effect.Effect<Endpoint5_18Output, E>
+type Endpoint5_17Request = Parameters<RawClient["server.session"]["session.wait"]>[0]
+export type Endpoint5_17Input = { readonly sessionID: Endpoint5_17Request["params"]["sessionID"] }
+export type Endpoint5_17Output = EffectValue<ReturnType<RawClient["server.session"]["session.wait"]>>
+export type SessionWaitOperation<E = never> = (input: Endpoint5_17Input) => Effect.Effect<Endpoint5_17Output, E>

-type Endpoint5_19Request = Parameters<RawClient["server.session"]["session.revert.commit"]>[0]
+type Endpoint5_18Request = Parameters<RawClient["server.session"]["session.revert.stage"]>[0]
+export type Endpoint5_18Input = {
+  readonly sessionID: Endpoint5_18Request["params"]["sessionID"]
+  readonly messageID: Endpoint5_18Request["payload"]["messageID"]
+  readonly files?: Endpoint5_18Request["payload"]["files"]
+}
+export type Endpoint5_18Output = EffectValue<ReturnType<RawClient["server.session"]["session.revert.stage"]>>["data"]
+export type SessionRevertStageOperation<E = never> = (input: Endpoint5_18Input) => Effect.Effect<Endpoint5_18Output, E>
+
+type Endpoint5_19Request = Parameters<RawClient["server.session"]["session.revert.clear"]>[0]
 export type Endpoint5_19Input = { readonly sessionID: Endpoint5_19Request["params"]["sessionID"] }
-export type Endpoint5_19Output = EffectValue<ReturnType<RawClient["server.session"]["session.revert.commit"]>>
-export type SessionRevertCommitOperation<E = never> = (input: Endpoint5_19Input) => Effect.Effect<Endpoint5_19Output, E>
+export type Endpoint5_19Output = EffectValue<ReturnType<RawClient["server.session"]["session.revert.clear"]>>
+export type SessionRevertClearOperation<E = never> = (input: Endpoint5_19Input) => Effect.Effect<Endpoint5_19Output, E>

-type Endpoint5_20Request = Parameters<RawClient["server.session"]["session.context"]>[0]
+type Endpoint5_20Request = Parameters<RawClient["server.session"]["session.revert.commit"]>[0]
 export type Endpoint5_20Input = { readonly sessionID: Endpoint5_20Request["params"]["sessionID"] }
-export type Endpoint5_20Output = EffectValue<ReturnType<RawClient["server.session"]["session.context"]>>["data"]
-export type SessionContextOperation<E = never> = (input: Endpoint5_20Input) => Effect.Effect<Endpoint5_20Output, E>
+export type Endpoint5_20Output = EffectValue<ReturnType<RawClient["server.session"]["session.revert.commit"]>>
+export type SessionRevertCommitOperation<E = never> = (input: Endpoint5_20Input) => Effect.Effect<Endpoint5_20Output, E>

-type Endpoint5_21Request = Parameters<RawClient["server.session"]["session.pending.list"]>[0]
+type Endpoint5_21Request = Parameters<RawClient["server.session"]["session.context"]>[0]
 export type Endpoint5_21Input = { readonly sessionID: Endpoint5_21Request["params"]["sessionID"] }
-export type Endpoint5_21Output = EffectValue<ReturnType<RawClient["server.session"]["session.pending.list"]>>["data"]
-export type SessionPendingListOperation<E = never> = (input: Endpoint5_21Input) => Effect.Effect<Endpoint5_21Output, E>
+export type Endpoint5_21Output = EffectValue<ReturnType<RawClient["server.session"]["session.context"]>>["data"]
+export type SessionContextOperation<E = never> = (input: Endpoint5_21Input) => Effect.Effect<Endpoint5_21Output, E>

-type Endpoint5_22Request = Parameters<RawClient["server.session"]["session.instructions.entry.list"]>[0]
+type Endpoint5_22Request = Parameters<RawClient["server.session"]["session.pending.list"]>[0]
 export type Endpoint5_22Input = { readonly sessionID: Endpoint5_22Request["params"]["sessionID"] }
-export type Endpoint5_22Output = EffectValue<
+export type Endpoint5_22Output = EffectValue<ReturnType<RawClient["server.session"]["session.pending.list"]>>["data"]
+export type SessionPendingListOperation<E = never> = (input: Endpoint5_22Input) => Effect.Effect<Endpoint5_22Output, E>
+
+type Endpoint5_23Request = Parameters<RawClient["server.session"]["session.instructions.entry.list"]>[0]
+export type Endpoint5_23Input = { readonly sessionID: Endpoint5_23Request["params"]["sessionID"] }
+export type Endpoint5_23Output = EffectValue<
  ReturnType<RawClient["server.session"]["session.instructions.entry.list"]>
 >["data"]
 export type SessionInstructionsEntryListOperation<E = never> = (
-  input: Endpoint5_22Input,
-) => Effect.Effect<Endpoint5_22Output, E>
-
-type Endpoint5_23Request = Parameters<RawClient["server.session"]["session.instructions.entry.put"]>[0]
-export type Endpoint5_23Input = {
-  readonly sessionID: Endpoint5_23Request["params"]["sessionID"]
-  readonly key: Endpoint5_23Request["params"]["key"]
-  readonly value: Endpoint5_23Request["payload"]["value"]
-}
-export type Endpoint5_23Output = EffectValue<ReturnType<RawClient["server.session"]["session.instructions.entry.put"]>>
-export type SessionInstructionsEntryPutOperation<E = never> = (
  input: Endpoint5_23Input,
 ) => Effect.Effect<Endpoint5_23Output, E>

-type Endpoint5_24Request = Parameters<RawClient["server.session"]["session.instructions.entry.remove"]>[0]
+type Endpoint5_24Request = Parameters<RawClient["server.session"]["session.instructions.entry.put"]>[0]
 export type Endpoint5_24Input = {
  readonly sessionID: Endpoint5_24Request["params"]["sessionID"]
  readonly key: Endpoint5_24Request["params"]["key"]
+  readonly value: Endpoint5_24Request["payload"]["value"]
 }
-export type Endpoint5_24Output = EffectValue<
-  ReturnType<RawClient["server.session"]["session.instructions.entry.remove"]>
->
-export type SessionInstructionsEntryRemoveOperation<E = never> = (
+export type Endpoint5_24Output = EffectValue<ReturnType<RawClient["server.session"]["session.instructions.entry.put"]>>
+export type SessionInstructionsEntryPutOperation<E = never> = (
  input: Endpoint5_24Input,
 ) => Effect.Effect<Endpoint5_24Output, E>

-type Endpoint5_25Request = Parameters<RawClient["server.session"]["session.generate"]>[0]
+type Endpoint5_25Request = Parameters<RawClient["server.session"]["session.instructions.entry.remove"]>[0]
 export type Endpoint5_25Input = {
  readonly sessionID: Endpoint5_25Request["params"]["sessionID"]
-  readonly prompt: Endpoint5_25Request["payload"]["prompt"]
+  readonly key: Endpoint5_25Request["params"]["key"]
 }
-export type Endpoint5_25Output = EffectValue<ReturnType<RawClient["server.session"]["session.generate"]>>["data"]
-export type SessionGenerateOperation<E = never> = (input: Endpoint5_25Input) => Effect.Effect<Endpoint5_25Output, E>
+export type Endpoint5_25Output = EffectValue<
+  ReturnType<RawClient["server.session"]["session.instructions.entry.remove"]>
+>
+export type SessionInstructionsEntryRemoveOperation<E = never> = (
+  input: Endpoint5_25Input,
+) => Effect.Effect<Endpoint5_25Output, E>

-type Endpoint5_26Request = Parameters<RawClient["server.session"]["session.log"]>[0]
+type Endpoint5_26Request = Parameters<RawClient["server.session"]["session.generate"]>[0]
 export type Endpoint5_26Input = {
  readonly sessionID: Endpoint5_26Request["params"]["sessionID"]
-  readonly after?: Endpoint5_26Request["query"]["after"]
-  readonly follow?: Endpoint5_26Request["query"]["follow"]
+  readonly prompt: Endpoint5_26Request["payload"]["prompt"]
 }
-export type Endpoint5_26Output = StreamValue<EffectValue<ReturnType<RawClient["server.session"]["session.log"]>>>
-export type SessionLogOperation<E = never> = (input: Endpoint5_26Input) => Stream.Stream<Endpoint5_26Output, E>
+export type Endpoint5_26Output = EffectValue<ReturnType<RawClient["server.session"]["session.generate"]>>["data"]
+export type SessionGenerateOperation<E = never> = (input: Endpoint5_26Input) => Effect.Effect<Endpoint5_26Output, E>

-type Endpoint5_27Request = Parameters<RawClient["server.session"]["session.interrupt"]>[0]
-export type Endpoint5_27Input = { readonly sessionID: Endpoint5_27Request["params"]["sessionID"] }
-export type Endpoint5_27Output = EffectValue<ReturnType<RawClient["server.session"]["session.interrupt"]>>
-export type SessionInterruptOperation<E = never> = (input: Endpoint5_27Input) => Effect.Effect<Endpoint5_27Output, E>
+type Endpoint5_27Request = Parameters<RawClient["server.session"]["session.log"]>[0]
+export type Endpoint5_27Input = {
+  readonly sessionID: Endpoint5_27Request["params"]["sessionID"]
+  readonly after?: Endpoint5_27Request["query"]["after"]
+  readonly follow?: Endpoint5_27Request["query"]["follow"]
+}
+export type Endpoint5_27Output = StreamValue<EffectValue<ReturnType<RawClient["server.session"]["session.log"]>>>
+export type SessionLogOperation<E = never> = (input: Endpoint5_27Input) => Stream.Stream<Endpoint5_27Output, E>

-type Endpoint5_28Request = Parameters<RawClient["server.session"]["session.background"]>[0]
+type Endpoint5_28Request = Parameters<RawClient["server.session"]["session.interrupt"]>[0]
 export type Endpoint5_28Input = { readonly sessionID: Endpoint5_28Request["params"]["sessionID"] }
-export type Endpoint5_28Output = EffectValue<ReturnType<RawClient["server.session"]["session.background"]>>
-export type SessionBackgroundOperation<E = never> = (input: Endpoint5_28Input) => Effect.Effect<Endpoint5_28Output, E>
+export type Endpoint5_28Output = EffectValue<ReturnType<RawClient["server.session"]["session.interrupt"]>>
+export type SessionInterruptOperation<E = never> = (input: Endpoint5_28Input) => Effect.Effect<Endpoint5_28Output, E>

-type Endpoint5_29Request = Parameters<RawClient["server.session"]["session.message"]>[0]
-export type Endpoint5_29Input = {
-  readonly sessionID: Endpoint5_29Request["params"]["sessionID"]
-  readonly messageID: Endpoint5_29Request["params"]["messageID"]
+type Endpoint5_29Request = Parameters<RawClient["server.session"]["session.background"]>[0]
+export type Endpoint5_29Input = { readonly sessionID: Endpoint5_29Request["params"]["sessionID"] }
+export type Endpoint5_29Output = EffectValue<ReturnType<RawClient["server.session"]["session.background"]>>
+export type SessionBackgroundOperation<E = never> = (input: Endpoint5_29Input) => Effect.Effect<Endpoint5_29Output, E>
+
+type Endpoint5_30Request = Parameters<RawClient["server.session"]["session.message"]>[0]
+export type Endpoint5_30Input = {
+  readonly sessionID: Endpoint5_30Request["params"]["sessionID"]
+  readonly messageID: Endpoint5_30Request["params"]["messageID"]
 }
-export type Endpoint5_29Output = EffectValue<ReturnType<RawClient["server.session"]["session.message"]>>["data"]
-export type SessionMessageOperation<E = never> = (input: Endpoint5_29Input) => Effect.Effect<Endpoint5_29Output, E>
+export type Endpoint5_30Output = EffectValue<ReturnType<RawClient["server.session"]["session.message"]>>["data"]
+export type SessionMessageOperation<E = never> = (input: Endpoint5_30Input) => Effect.Effect<Endpoint5_30Output, E>

 export interface SessionApi<E = never> {
  readonly list: SessionListOperation<E>
@@ -314,6 +319,7 @@ export interface SessionApi<E = never> {
  readonly switchAgent: SessionSwitchAgentOperation<E>
  readonly switchModel: SessionSwitchModelOperation<E>
  readonly rename: SessionRenameOperation<E>
+  readonly archive: SessionArchiveOperation<E>
  readonly move: SessionMoveOperation<E>
  readonly prompt: SessionPromptOperation<E>
  readonly command: SessionCommandOperation<E>
@@ -614,21 +620,32 @@ export interface CredentialApi<E = never> {
 export type Endpoint13_0Output = EffectValue<ReturnType<RawClient["server.project"]["project.list"]>>
 export type ProjectListOperation<E = never> = () => Effect.Effect<Endpoint13_0Output, E>

-type Endpoint13_1Request = Parameters<RawClient["server.project"]["project.current"]>[0]
-export type Endpoint13_1Input = { readonly location?: Endpoint13_1Request["query"]["location"] }
-export type Endpoint13_1Output = EffectValue<ReturnType<RawClient["server.project"]["project.current"]>>
-export type ProjectCurrentOperation<E = never> = (input?: Endpoint13_1Input) => Effect.Effect<Endpoint13_1Output, E>
-
-type Endpoint13_2Request = Parameters<RawClient["server.project"]["project.directories"]>[0]
-export type Endpoint13_2Input = {
-  readonly projectID: Endpoint13_2Request["params"]["projectID"]
-  readonly location?: Endpoint13_2Request["query"]["location"]
+type Endpoint13_1Request = Parameters<RawClient["server.project"]["project.update"]>[0]
+export type Endpoint13_1Input = {
+  readonly projectID: Endpoint13_1Request["params"]["projectID"]
+  readonly name?: Endpoint13_1Request["payload"]["name"]
+  readonly icon?: Endpoint13_1Request["payload"]["icon"]
+  readonly commands?: Endpoint13_1Request["payload"]["commands"]
 }
-export type Endpoint13_2Output = EffectValue<ReturnType<RawClient["server.project"]["project.directories"]>>
-export type ProjectDirectoriesOperation<E = never> = (input: Endpoint13_2Input) => Effect.Effect<Endpoint13_2Output, E>
+export type Endpoint13_1Output = EffectValue<ReturnType<RawClient["server.project"]["project.update"]>>
+export type ProjectUpdateOperation<E = never> = (input: Endpoint13_1Input) => Effect.Effect<Endpoint13_1Output, E>
+
+type Endpoint13_2Request = Parameters<RawClient["server.project"]["project.current"]>[0]
+export type Endpoint13_2Input = { readonly location?: Endpoint13_2Request["query"]["location"] }
+export type Endpoint13_2Output = EffectValue<ReturnType<RawClient["server.project"]["project.current"]>>
+export type ProjectCurrentOperation<E = never> = (input?: Endpoint13_2Input) => Effect.Effect<Endpoint13_2Output, E>
+
+type Endpoint13_3Request = Parameters<RawClient["server.project"]["project.directories"]>[0]
+export type Endpoint13_3Input = {
+  readonly projectID: Endpoint13_3Request["params"]["projectID"]
+  readonly location?: Endpoint13_3Request["query"]["location"]
+}
+export type Endpoint13_3Output = EffectValue<ReturnType<RawClient["server.project"]["project.directories"]>>
+export type ProjectDirectoriesOperation<E = never> = (input: Endpoint13_3Input) => Effect.Effect<Endpoint13_3Output, E>

 export interface ProjectApi<E = never> {
  readonly list: ProjectListOperation<E>
+  readonly update: ProjectUpdateOperation<E>
  readonly current: ProjectCurrentOperation<E>
  readonly directories: ProjectDirectoriesOperation<E>
 }
@@ -820,55 +837,71 @@ export interface EventApi<E = never> {
  readonly subscribe: EventSubscribeOperation<E>
 }

-type Endpoint20_0Request = Parameters<RawClient["server.pty"]["pty.list"]>[0]
+type Endpoint20_0Request = Parameters<RawClient["server.pty"]["pty.shells"]>[0]
 export type Endpoint20_0Input = { readonly location?: Endpoint20_0Request["query"]["location"] }
-export type Endpoint20_0Output = EffectValue<ReturnType<RawClient["server.pty"]["pty.list"]>>
-export type PtyListOperation<E = never> = (input?: Endpoint20_0Input) => Effect.Effect<Endpoint20_0Output, E>
+export type Endpoint20_0Output = EffectValue<ReturnType<RawClient["server.pty"]["pty.shells"]>>
+export type PtyShellsOperation<E = never> = (input?: Endpoint20_0Input) => Effect.Effect<Endpoint20_0Output, E>

-type Endpoint20_1Request = Parameters<RawClient["server.pty"]["pty.create"]>[0]
-export type Endpoint20_1Input = {
-  readonly location?: Endpoint20_1Request["query"]["location"]
-  readonly command?: Endpoint20_1Request["payload"]["command"]
-  readonly args?: Endpoint20_1Request["payload"]["args"]
-  readonly cwd?: Endpoint20_1Request["payload"]["cwd"]
-  readonly title?: Endpoint20_1Request["payload"]["title"]
-  readonly env?: Endpoint20_1Request["payload"]["env"]
-}
-export type Endpoint20_1Output = EffectValue<ReturnType<RawClient["server.pty"]["pty.create"]>>
-export type PtyCreateOperation<E = never> = (input?: Endpoint20_1Input) => Effect.Effect<Endpoint20_1Output, E>
+type Endpoint20_1Request = Parameters<RawClient["server.pty"]["pty.list"]>[0]
+export type Endpoint20_1Input = { readonly location?: Endpoint20_1Request["query"]["location"] }
+export type Endpoint20_1Output = EffectValue<ReturnType<RawClient["server.pty"]["pty.list"]>>
+export type PtyListOperation<E = never> = (input?: Endpoint20_1Input) => Effect.Effect<Endpoint20_1Output, E>

-type Endpoint20_2Request = Parameters<RawClient["server.pty"]["pty.get"]>[0]
+type Endpoint20_2Request = Parameters<RawClient["server.pty"]["pty.create"]>[0]
 export type Endpoint20_2Input = {
-  readonly ptyID: Endpoint20_2Request["params"]["ptyID"]
  readonly location?: Endpoint20_2Request["query"]["location"]
+  readonly command?: Endpoint20_2Request["payload"]["command"]
+  readonly args?: Endpoint20_2Request["payload"]["args"]
+  readonly cwd?: Endpoint20_2Request["payload"]["cwd"]
+  readonly title?: Endpoint20_2Request["payload"]["title"]
+  readonly env?: Endpoint20_2Request["payload"]["env"]
 }
-export type Endpoint20_2Output = EffectValue<ReturnType<RawClient["server.pty"]["pty.get"]>>
-export type PtyGetOperation<E = never> = (input: Endpoint20_2Input) => Effect.Effect<Endpoint20_2Output, E>
+export type Endpoint20_2Output = EffectValue<ReturnType<RawClient["server.pty"]["pty.create"]>>
+export type PtyCreateOperation<E = never> = (input?: Endpoint20_2Input) => Effect.Effect<Endpoint20_2Output, E>

-type Endpoint20_3Request = Parameters<RawClient["server.pty"]["pty.update"]>[0]
+type Endpoint20_3Request = Parameters<RawClient["server.pty"]["pty.get"]>[0]
 export type Endpoint20_3Input = {
  readonly ptyID: Endpoint20_3Request["params"]["ptyID"]
  readonly location?: Endpoint20_3Request["query"]["location"]
-  readonly title?: Endpoint20_3Request["payload"]["title"]
-  readonly size?: Endpoint20_3Request["payload"]["size"]
 }
-export type Endpoint20_3Output = EffectValue<ReturnType<RawClient["server.pty"]["pty.update"]>>
-export type PtyUpdateOperation<E = never> = (input: Endpoint20_3Input) => Effect.Effect<Endpoint20_3Output, E>
+export type Endpoint20_3Output = EffectValue<ReturnType<RawClient["server.pty"]["pty.get"]>>
+export type PtyGetOperation<E = never> = (input: Endpoint20_3Input) => Effect.Effect<Endpoint20_3Output, E>

-type Endpoint20_4Request = Parameters<RawClient["server.pty"]["pty.remove"]>[0]
+type Endpoint20_4Request = Parameters<RawClient["server.pty"]["pty.update"]>[0]
 export type Endpoint20_4Input = {
  readonly ptyID: Endpoint20_4Request["params"]["ptyID"]
  readonly location?: Endpoint20_4Request["query"]["location"]
+  readonly title?: Endpoint20_4Request["payload"]["title"]
+  readonly size?: Endpoint20_4Request["payload"]["size"]
 }
-export type Endpoint20_4Output = EffectValue<ReturnType<RawClient["server.pty"]["pty.remove"]>>
-export type PtyRemoveOperation<E = never> = (input: Endpoint20_4Input) => Effect.Effect<Endpoint20_4Output, E>
+export type Endpoint20_4Output = EffectValue<ReturnType<RawClient["server.pty"]["pty.update"]>>
+export type PtyUpdateOperation<E = never> = (input: Endpoint20_4Input) => Effect.Effect<Endpoint20_4Output, E>
+
+type Endpoint20_5Request = Parameters<RawClient["server.pty"]["pty.remove"]>[0]
+export type Endpoint20_5Input = {
+  readonly ptyID: Endpoint20_5Request["params"]["ptyID"]
+  readonly location?: Endpoint20_5Request["query"]["location"]
+}
+export type Endpoint20_5Output = EffectValue<ReturnType<RawClient["server.pty"]["pty.remove"]>>
+export type PtyRemoveOperation<E = never> = (input: Endpoint20_5Input) => Effect.Effect<Endpoint20_5Output, E>
+
+type Endpoint20_6Request = Parameters<RawClient["server.pty"]["pty.connectToken"]>[0]
+export type Endpoint20_6Input = {
+  readonly ptyID: Endpoint20_6Request["params"]["ptyID"]
+  readonly location?: Endpoint20_6Request["query"]["location"]
+  readonly "x-opencode-ticket"?: Endpoint20_6Request["headers"]["x-opencode-ticket"]
+}
+export type Endpoint20_6Output = EffectValue<ReturnType<RawClient["server.pty"]["pty.connectToken"]>>
+export type PtyConnectTokenOperation<E = never> = (input: Endpoint20_6Input) => Effect.Effect<Endpoint20_6Output, E>

 export interface PtyApi<E = never> {
+  readonly shells: PtyShellsOperation<E>
  readonly list: PtyListOperation<E>
  readonly create: PtyCreateOperation<E>
  readonly get: PtyGetOperation<E>
  readonly update: PtyUpdateOperation<E>
  readonly remove: PtyRemoveOperation<E>
+  readonly connectToken: PtyConnectTokenOperation<E>
 }

 type Endpoint21_0Request = Parameters<RawClient["server.shell"]["shell.list"]>[0]
@@ -1011,32 +1044,47 @@ export interface ProjectCopyApi<E = never> {
  readonly refresh: ProjectCopyRefreshOperation<E>
 }

-type Endpoint25_0Request = Parameters<RawClient["server.vcs"]["vcs.status"]>[0]
+type Endpoint25_0Request = Parameters<RawClient["server.vcs"]["vcs.get"]>[0]
 export type Endpoint25_0Input = { readonly location?: Endpoint25_0Request["query"]["location"] }
-export type Endpoint25_0Output = EffectValue<ReturnType<RawClient["server.vcs"]["vcs.status"]>>
-export type VcsStatusOperation<E = never> = (input?: Endpoint25_0Input) => Effect.Effect<Endpoint25_0Output, E>
+export type Endpoint25_0Output = EffectValue<ReturnType<RawClient["server.vcs"]["vcs.get"]>>
+export type VcsGetOperation<E = never> = (input?: Endpoint25_0Input) => Effect.Effect<Endpoint25_0Output, E>

-type Endpoint25_1Request = Parameters<RawClient["server.vcs"]["vcs.diff"]>[0]
-export type Endpoint25_1Input = {
-  readonly location?: Endpoint25_1Request["query"]["location"]
-  readonly mode: Endpoint25_1Request["query"]["mode"]
-  readonly context?: Endpoint25_1Request["query"]["context"]
+type Endpoint25_1Request = Parameters<RawClient["server.vcs"]["vcs.status"]>[0]
+export type Endpoint25_1Input = { readonly location?: Endpoint25_1Request["query"]["location"] }
+export type Endpoint25_1Output = EffectValue<ReturnType<RawClient["server.vcs"]["vcs.status"]>>
+export type VcsStatusOperation<E = never> = (input?: Endpoint25_1Input) => Effect.Effect<Endpoint25_1Output, E>
+
+type Endpoint25_2Request = Parameters<RawClient["server.vcs"]["vcs.diff"]>[0]
+export type Endpoint25_2Input = {
+  readonly location?: Endpoint25_2Request["query"]["location"]
+  readonly mode: Endpoint25_2Request["query"]["mode"]
+  readonly context?: Endpoint25_2Request["query"]["context"]
 }
-export type Endpoint25_1Output = EffectValue<ReturnType<RawClient["server.vcs"]["vcs.diff"]>>
-export type VcsDiffOperation<E = never> = (input: Endpoint25_1Input) => Effect.Effect<Endpoint25_1Output, E>
+export type Endpoint25_2Output = EffectValue<ReturnType<RawClient["server.vcs"]["vcs.diff"]>>
+export type VcsDiffOperation<E = never> = (input: Endpoint25_2Input) => Effect.Effect<Endpoint25_2Output, E>

 export interface VcsApi<E = never> {
+  readonly get: VcsGetOperation<E>
  readonly status: VcsStatusOperation<E>
  readonly diff: VcsDiffOperation<E>
 }

-export type Endpoint26_0Output = EffectValue<ReturnType<RawClient["server.debug"]["debug.location"]>>
-export type DebugLocationListOperation<E = never> = () => Effect.Effect<Endpoint26_0Output, E>
+type Endpoint26_0Request = Parameters<RawClient["server.path"]["path.get"]>[0]
+export type Endpoint26_0Input = { readonly location?: Endpoint26_0Request["query"]["location"] }
+export type Endpoint26_0Output = EffectValue<ReturnType<RawClient["server.path"]["path.get"]>>
+export type PathGetOperation<E = never> = (input?: Endpoint26_0Input) => Effect.Effect<Endpoint26_0Output, E>

-type Endpoint26_1Request = Parameters<RawClient["server.debug"]["debug.location.evict"]>[0]
-export type Endpoint26_1Input = { readonly location?: Endpoint26_1Request["query"]["location"] }
-export type Endpoint26_1Output = EffectValue<ReturnType<RawClient["server.debug"]["debug.location.evict"]>>
-export type DebugLocationEvictOperation<E = never> = (input?: Endpoint26_1Input) => Effect.Effect<Endpoint26_1Output, E>
+export interface PathApi<E = never> {
+  readonly get: PathGetOperation<E>
+}
+
+export type Endpoint27_0Output = EffectValue<ReturnType<RawClient["server.debug"]["debug.location"]>>
+export type DebugLocationListOperation<E = never> = () => Effect.Effect<Endpoint27_0Output, E>
+
+type Endpoint27_1Request = Parameters<RawClient["server.debug"]["debug.location.evict"]>[0]
+export type Endpoint27_1Input = { readonly location?: Endpoint27_1Request["query"]["location"] }
+export type Endpoint27_1Output = EffectValue<ReturnType<RawClient["server.debug"]["debug.location.evict"]>>
+export type DebugLocationEvictOperation<E = never> = (input?: Endpoint27_1Input) => Effect.Effect<Endpoint27_1Output, E>

 export interface DebugApi<E = never> {
  readonly location: { readonly list: DebugLocationListOperation<E>; readonly evict: DebugLocationEvictOperation<E> }
@@ -1069,5 +1117,6 @@ export interface AppApi<E = never> {
  readonly reference: ReferenceApi<E>
  readonly projectCopy: ProjectCopyApi<E>
  readonly vcs: VcsApi<E>
+  readonly path: PathApi<E>
  readonly debug: DebugApi<E>
 }
@@ -151,30 +151,35 @@ const Endpoint5_8 = (raw: RawClient["server.session"]) => (input: Endpoint5_8Inp
    Effect.mapError(mapClientError),
  )

-type Endpoint5_9Request = Parameters<RawClient["server.session"]["session.move"]>[0]
-type Endpoint5_9Input = {
-  readonly sessionID: Endpoint5_9Request["params"]["sessionID"]
-  readonly directory: Endpoint5_9Request["payload"]["directory"]
-  readonly workspaceID?: Endpoint5_9Request["payload"]["workspaceID"]
-}
+type Endpoint5_9Request = Parameters<RawClient["server.session"]["session.archive"]>[0]
+type Endpoint5_9Input = { readonly sessionID: Endpoint5_9Request["params"]["sessionID"] }
 const Endpoint5_9 = (raw: RawClient["server.session"]) => (input: Endpoint5_9Input) =>
+  raw["session.archive"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint5_10Request = Parameters<RawClient["server.session"]["session.move"]>[0]
+type Endpoint5_10Input = {
+  readonly sessionID: Endpoint5_10Request["params"]["sessionID"]
+  readonly directory: Endpoint5_10Request["payload"]["directory"]
+  readonly workspaceID?: Endpoint5_10Request["payload"]["workspaceID"]
+}
+const Endpoint5_10 = (raw: RawClient["server.session"]) => (input: Endpoint5_10Input) =>
  raw["session.move"]({
    params: { sessionID: input["sessionID"] },
    payload: { directory: input["directory"], workspaceID: input["workspaceID"] },
  }).pipe(Effect.mapError(mapClientError))

-type Endpoint5_10Request = Parameters<RawClient["server.session"]["session.prompt"]>[0]
-type Endpoint5_10Input = {
-  readonly sessionID: Endpoint5_10Request["params"]["sessionID"]
-  readonly id?: Endpoint5_10Request["payload"]["id"]
-  readonly text: Endpoint5_10Request["payload"]["text"]
-  readonly files?: Endpoint5_10Request["payload"]["files"]
-  readonly agents?: Endpoint5_10Request["payload"]["agents"]
-  readonly metadata?: Endpoint5_10Request["payload"]["metadata"]
-  readonly delivery?: Endpoint5_10Request["payload"]["delivery"]
-  readonly resume?: Endpoint5_10Request["payload"]["resume"]
+type Endpoint5_11Request = Parameters<RawClient["server.session"]["session.prompt"]>[0]
+type Endpoint5_11Input = {
+  readonly sessionID: Endpoint5_11Request["params"]["sessionID"]
+  readonly id?: Endpoint5_11Request["payload"]["id"]
+  readonly text: Endpoint5_11Request["payload"]["text"]
+  readonly files?: Endpoint5_11Request["payload"]["files"]
+  readonly agents?: Endpoint5_11Request["payload"]["agents"]
+  readonly metadata?: Endpoint5_11Request["payload"]["metadata"]
+  readonly delivery?: Endpoint5_11Request["payload"]["delivery"]
+  readonly resume?: Endpoint5_11Request["payload"]["resume"]
 }
-const Endpoint5_10 = (raw: RawClient["server.session"]) => (input: Endpoint5_10Input) =>
+const Endpoint5_11 = (raw: RawClient["server.session"]) => (input: Endpoint5_11Input) =>
  raw["session.prompt"]({
    params: { sessionID: input["sessionID"] },
    payload: {
@@ -191,20 +196,20 @@ const Endpoint5_10 = (raw: RawClient["server.session"]) => (input: Endpoint5_10I
    Effect.map((value) => value.data),
  )

-type Endpoint5_11Request = Parameters<RawClient["server.session"]["session.command"]>[0]
-type Endpoint5_11Input = {
-  readonly sessionID: Endpoint5_11Request["params"]["sessionID"]
-  readonly id?: Endpoint5_11Request["payload"]["id"]
-  readonly command: Endpoint5_11Request["payload"]["command"]
-  readonly arguments?: Endpoint5_11Request["payload"]["arguments"]
-  readonly agent?: Endpoint5_11Request["payload"]["agent"]
-  readonly model?: Endpoint5_11Request["payload"]["model"]
-  readonly files?: Endpoint5_11Request["payload"]["files"]
-  readonly agents?: Endpoint5_11Request["payload"]["agents"]
-  readonly delivery?: Endpoint5_11Request["payload"]["delivery"]
-  readonly resume?: Endpoint5_11Request["payload"]["resume"]
+type Endpoint5_12Request = Parameters<RawClient["server.session"]["session.command"]>[0]
+type Endpoint5_12Input = {
+  readonly sessionID: Endpoint5_12Request["params"]["sessionID"]
+  readonly id?: Endpoint5_12Request["payload"]["id"]
+  readonly command: Endpoint5_12Request["payload"]["command"]
+  readonly arguments?: Endpoint5_12Request["payload"]["arguments"]
+  readonly agent?: Endpoint5_12Request["payload"]["agent"]
+  readonly model?: Endpoint5_12Request["payload"]["model"]
+  readonly files?: Endpoint5_12Request["payload"]["files"]
+  readonly agents?: Endpoint5_12Request["payload"]["agents"]
+  readonly delivery?: Endpoint5_12Request["payload"]["delivery"]
+  readonly resume?: Endpoint5_12Request["payload"]["resume"]
 }
-const Endpoint5_11 = (raw: RawClient["server.session"]) => (input: Endpoint5_11Input) =>
+const Endpoint5_12 = (raw: RawClient["server.session"]) => (input: Endpoint5_12Input) =>
  raw["session.command"]({
    params: { sessionID: input["sessionID"] },
    payload: {
@@ -223,30 +228,30 @@ const Endpoint5_11 = (raw: RawClient["server.session"]) => (input: Endpoint5_11I
    Effect.map((value) => value.data),
  )

-type Endpoint5_12Request = Parameters<RawClient["server.session"]["session.skill"]>[0]
-type Endpoint5_12Input = {
-  readonly sessionID: Endpoint5_12Request["params"]["sessionID"]
-  readonly id?: Endpoint5_12Request["payload"]["id"]
-  readonly skill: Endpoint5_12Request["payload"]["skill"]
-  readonly resume?: Endpoint5_12Request["payload"]["resume"]
+type Endpoint5_13Request = Parameters<RawClient["server.session"]["session.skill"]>[0]
+type Endpoint5_13Input = {
+  readonly sessionID: Endpoint5_13Request["params"]["sessionID"]
+  readonly id?: Endpoint5_13Request["payload"]["id"]
+  readonly skill: Endpoint5_13Request["payload"]["skill"]
+  readonly resume?: Endpoint5_13Request["payload"]["resume"]
 }
-const Endpoint5_12 = (raw: RawClient["server.session"]) => (input: Endpoint5_12Input) =>
+const Endpoint5_13 = (raw: RawClient["server.session"]) => (input: Endpoint5_13Input) =>
  raw["session.skill"]({
    params: { sessionID: input["sessionID"] },
    payload: { id: input["id"], skill: input["skill"], resume: input["resume"] },
  }).pipe(Effect.mapError(mapClientError))

-type Endpoint5_13Request = Parameters<RawClient["server.session"]["session.synthetic"]>[0]
-type Endpoint5_13Input = {
-  readonly sessionID: Endpoint5_13Request["params"]["sessionID"]
-  readonly id?: Endpoint5_13Request["payload"]["id"]
-  readonly text: Endpoint5_13Request["payload"]["text"]
-  readonly description?: Endpoint5_13Request["payload"]["description"]
-  readonly metadata?: Endpoint5_13Request["payload"]["metadata"]
-  readonly delivery?: Endpoint5_13Request["payload"]["delivery"]
-  readonly resume?: Endpoint5_13Request["payload"]["resume"]
+type Endpoint5_14Request = Parameters<RawClient["server.session"]["session.synthetic"]>[0]
+type Endpoint5_14Input = {
+  readonly sessionID: Endpoint5_14Request["params"]["sessionID"]
+  readonly id?: Endpoint5_14Request["payload"]["id"]
+  readonly text: Endpoint5_14Request["payload"]["text"]
+  readonly description?: Endpoint5_14Request["payload"]["description"]
+  readonly metadata?: Endpoint5_14Request["payload"]["metadata"]
+  readonly delivery?: Endpoint5_14Request["payload"]["delivery"]
+  readonly resume?: Endpoint5_14Request["payload"]["resume"]
 }
-const Endpoint5_13 = (raw: RawClient["server.session"]) => (input: Endpoint5_13Input) =>
+const Endpoint5_14 = (raw: RawClient["server.session"]) => (input: Endpoint5_14Input) =>
  raw["session.synthetic"]({
    params: { sessionID: input["sessionID"] },
    payload: {
@@ -262,41 +267,41 @@ const Endpoint5_13 = (raw: RawClient["server.session"]) => (input: Endpoint5_13I
    Effect.map((value) => value.data),
  )

-type Endpoint5_14Request = Parameters<RawClient["server.session"]["session.shell"]>[0]
-type Endpoint5_14Input = {
-  readonly sessionID: Endpoint5_14Request["params"]["sessionID"]
-  readonly id?: Endpoint5_14Request["payload"]["id"]
-  readonly command: Endpoint5_14Request["payload"]["command"]
+type Endpoint5_15Request = Parameters<RawClient["server.session"]["session.shell"]>[0]
+type Endpoint5_15Input = {
+  readonly sessionID: Endpoint5_15Request["params"]["sessionID"]
+  readonly id?: Endpoint5_15Request["payload"]["id"]
+  readonly command: Endpoint5_15Request["payload"]["command"]
 }
-const Endpoint5_14 = (raw: RawClient["server.session"]) => (input: Endpoint5_14Input) =>
+const Endpoint5_15 = (raw: RawClient["server.session"]) => (input: Endpoint5_15Input) =>
  raw["session.shell"]({
    params: { sessionID: input["sessionID"] },
    payload: { id: input["id"], command: input["command"] },
  }).pipe(Effect.mapError(mapClientError))

-type Endpoint5_15Request = Parameters<RawClient["server.session"]["session.compact"]>[0]
-type Endpoint5_15Input = {
-  readonly sessionID: Endpoint5_15Request["params"]["sessionID"]
-  readonly id?: Endpoint5_15Request["payload"]["id"]
+type Endpoint5_16Request = Parameters<RawClient["server.session"]["session.compact"]>[0]
+type Endpoint5_16Input = {
+  readonly sessionID: Endpoint5_16Request["params"]["sessionID"]
+  readonly id?: Endpoint5_16Request["payload"]["id"]
 }
-const Endpoint5_15 = (raw: RawClient["server.session"]) => (input: Endpoint5_15Input) =>
+const Endpoint5_16 = (raw: RawClient["server.session"]) => (input: Endpoint5_16Input) =>
  raw["session.compact"]({ params: { sessionID: input["sessionID"] }, payload: { id: input["id"] } }).pipe(
    Effect.mapError(mapClientError),
    Effect.map((value) => value.data),
  )

-type Endpoint5_16Request = Parameters<RawClient["server.session"]["session.wait"]>[0]
-type Endpoint5_16Input = { readonly sessionID: Endpoint5_16Request["params"]["sessionID"] }
-const Endpoint5_16 = (raw: RawClient["server.session"]) => (input: Endpoint5_16Input) =>
+type Endpoint5_17Request = Parameters<RawClient["server.session"]["session.wait"]>[0]
+type Endpoint5_17Input = { readonly sessionID: Endpoint5_17Request["params"]["sessionID"] }
+const Endpoint5_17 = (raw: RawClient["server.session"]) => (input: Endpoint5_17Input) =>
  raw["session.wait"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))

-type Endpoint5_17Request = Parameters<RawClient["server.session"]["session.revert.stage"]>[0]
-type Endpoint5_17Input = {
-  readonly sessionID: Endpoint5_17Request["params"]["sessionID"]
-  readonly messageID: Endpoint5_17Request["payload"]["messageID"]
-  readonly files?: Endpoint5_17Request["payload"]["files"]
+type Endpoint5_18Request = Parameters<RawClient["server.session"]["session.revert.stage"]>[0]
+type Endpoint5_18Input = {
+  readonly sessionID: Endpoint5_18Request["params"]["sessionID"]
+  readonly messageID: Endpoint5_18Request["payload"]["messageID"]
+  readonly files?: Endpoint5_18Request["payload"]["files"]
 }
-const Endpoint5_17 = (raw: RawClient["server.session"]) => (input: Endpoint5_17Input) =>
+const Endpoint5_18 = (raw: RawClient["server.session"]) => (input: Endpoint5_18Input) =>
  raw["session.revert.stage"]({
    params: { sessionID: input["sessionID"] },
    payload: { messageID: input["messageID"], files: input["files"] },
@@ -305,80 +310,80 @@ const Endpoint5_17 = (raw: RawClient["server.session"]) => (input: Endpoint5_17I
    Effect.map((value) => value.data),
  )

-type Endpoint5_18Request = Parameters<RawClient["server.session"]["session.revert.clear"]>[0]
-type Endpoint5_18Input = { readonly sessionID: Endpoint5_18Request["params"]["sessionID"] }
-const Endpoint5_18 = (raw: RawClient["server.session"]) => (input: Endpoint5_18Input) =>
-  raw["session.revert.clear"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
-
-type Endpoint5_19Request = Parameters<RawClient["server.session"]["session.revert.commit"]>[0]
+type Endpoint5_19Request = Parameters<RawClient["server.session"]["session.revert.clear"]>[0]
 type Endpoint5_19Input = { readonly sessionID: Endpoint5_19Request["params"]["sessionID"] }
 const Endpoint5_19 = (raw: RawClient["server.session"]) => (input: Endpoint5_19Input) =>
-  raw["session.revert.commit"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
+  raw["session.revert.clear"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))

-type Endpoint5_20Request = Parameters<RawClient["server.session"]["session.context"]>[0]
+type Endpoint5_20Request = Parameters<RawClient["server.session"]["session.revert.commit"]>[0]
 type Endpoint5_20Input = { readonly sessionID: Endpoint5_20Request["params"]["sessionID"] }
 const Endpoint5_20 = (raw: RawClient["server.session"]) => (input: Endpoint5_20Input) =>
+  raw["session.revert.commit"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint5_21Request = Parameters<RawClient["server.session"]["session.context"]>[0]
+type Endpoint5_21Input = { readonly sessionID: Endpoint5_21Request["params"]["sessionID"] }
+const Endpoint5_21 = (raw: RawClient["server.session"]) => (input: Endpoint5_21Input) =>
  raw["session.context"]({ params: { sessionID: input["sessionID"] } }).pipe(
    Effect.mapError(mapClientError),
    Effect.map((value) => value.data),
  )

-type Endpoint5_21Request = Parameters<RawClient["server.session"]["session.pending.list"]>[0]
-type Endpoint5_21Input = { readonly sessionID: Endpoint5_21Request["params"]["sessionID"] }
-const Endpoint5_21 = (raw: RawClient["server.session"]) => (input: Endpoint5_21Input) =>
+type Endpoint5_22Request = Parameters<RawClient["server.session"]["session.pending.list"]>[0]
+type Endpoint5_22Input = { readonly sessionID: Endpoint5_22Request["params"]["sessionID"] }
+const Endpoint5_22 = (raw: RawClient["server.session"]) => (input: Endpoint5_22Input) =>
  raw["session.pending.list"]({ params: { sessionID: input["sessionID"] } }).pipe(
    Effect.mapError(mapClientError),
    Effect.map((value) => value.data),
  )

-type Endpoint5_22Request = Parameters<RawClient["server.session"]["session.instructions.entry.list"]>[0]
-type Endpoint5_22Input = { readonly sessionID: Endpoint5_22Request["params"]["sessionID"] }
-const Endpoint5_22 = (raw: RawClient["server.session"]) => (input: Endpoint5_22Input) =>
+type Endpoint5_23Request = Parameters<RawClient["server.session"]["session.instructions.entry.list"]>[0]
+type Endpoint5_23Input = { readonly sessionID: Endpoint5_23Request["params"]["sessionID"] }
+const Endpoint5_23 = (raw: RawClient["server.session"]) => (input: Endpoint5_23Input) =>
  raw["session.instructions.entry.list"]({ params: { sessionID: input["sessionID"] } }).pipe(
    Effect.mapError(mapClientError),
    Effect.map((value) => value.data),
  )

-type Endpoint5_23Request = Parameters<RawClient["server.session"]["session.instructions.entry.put"]>[0]
-type Endpoint5_23Input = {
-  readonly sessionID: Endpoint5_23Request["params"]["sessionID"]
-  readonly key: Endpoint5_23Request["params"]["key"]
-  readonly value: Endpoint5_23Request["payload"]["value"]
+type Endpoint5_24Request = Parameters<RawClient["server.session"]["session.instructions.entry.put"]>[0]
+type Endpoint5_24Input = {
+  readonly sessionID: Endpoint5_24Request["params"]["sessionID"]
+  readonly key: Endpoint5_24Request["params"]["key"]
+  readonly value: Endpoint5_24Request["payload"]["value"]
 }
-const Endpoint5_23 = (raw: RawClient["server.session"]) => (input: Endpoint5_23Input) =>
+const Endpoint5_24 = (raw: RawClient["server.session"]) => (input: Endpoint5_24Input) =>
  raw["session.instructions.entry.put"]({
    params: { sessionID: input["sessionID"], key: input["key"] },
    payload: { value: input["value"] },
  }).pipe(Effect.mapError(mapClientError))

-type Endpoint5_24Request = Parameters<RawClient["server.session"]["session.instructions.entry.remove"]>[0]
-type Endpoint5_24Input = {
-  readonly sessionID: Endpoint5_24Request["params"]["sessionID"]
-  readonly key: Endpoint5_24Request["params"]["key"]
+type Endpoint5_25Request = Parameters<RawClient["server.session"]["session.instructions.entry.remove"]>[0]
+type Endpoint5_25Input = {
+  readonly sessionID: Endpoint5_25Request["params"]["sessionID"]
+  readonly key: Endpoint5_25Request["params"]["key"]
 }
-const Endpoint5_24 = (raw: RawClient["server.session"]) => (input: Endpoint5_24Input) =>
+const Endpoint5_25 = (raw: RawClient["server.session"]) => (input: Endpoint5_25Input) =>
  raw["session.instructions.entry.remove"]({ params: { sessionID: input["sessionID"], key: input["key"] } }).pipe(
    Effect.mapError(mapClientError),
  )

-type Endpoint5_25Request = Parameters<RawClient["server.session"]["session.generate"]>[0]
-type Endpoint5_25Input = {
-  readonly sessionID: Endpoint5_25Request["params"]["sessionID"]
-  readonly prompt: Endpoint5_25Request["payload"]["prompt"]
+type Endpoint5_26Request = Parameters<RawClient["server.session"]["session.generate"]>[0]
+type Endpoint5_26Input = {
+  readonly sessionID: Endpoint5_26Request["params"]["sessionID"]
+  readonly prompt: Endpoint5_26Request["payload"]["prompt"]
 }
-const Endpoint5_25 = (raw: RawClient["server.session"]) => (input: Endpoint5_25Input) =>
+const Endpoint5_26 = (raw: RawClient["server.session"]) => (input: Endpoint5_26Input) =>
  raw["session.generate"]({ params: { sessionID: input["sessionID"] }, payload: { prompt: input["prompt"] } }).pipe(
    Effect.mapError(mapClientError),
    Effect.map((value) => value.data),
  )

-type Endpoint5_26Request = Parameters<RawClient["server.session"]["session.log"]>[0]
-type Endpoint5_26Input = {
-  readonly sessionID: Endpoint5_26Request["params"]["sessionID"]
-  readonly after?: Endpoint5_26Request["query"]["after"]
-  readonly follow?: Endpoint5_26Request["query"]["follow"]
+type Endpoint5_27Request = Parameters<RawClient["server.session"]["session.log"]>[0]
+type Endpoint5_27Input = {
+  readonly sessionID: Endpoint5_27Request["params"]["sessionID"]
+  readonly after?: Endpoint5_27Request["query"]["after"]
+  readonly follow?: Endpoint5_27Request["query"]["follow"]
 }
-const Endpoint5_26 = (raw: RawClient["server.session"]) => (input: Endpoint5_26Input) =>
+const Endpoint5_27 = (raw: RawClient["server.session"]) => (input: Endpoint5_27Input) =>
  Stream.unwrap(
    raw["session.log"]({
      params: { sessionID: input["sessionID"] },
@@ -389,22 +394,22 @@ const Endpoint5_26 = (raw: RawClient["server.session"]) => (input: Endpoint5_26I
    ),
  )

-type Endpoint5_27Request = Parameters<RawClient["server.session"]["session.interrupt"]>[0]
-type Endpoint5_27Input = { readonly sessionID: Endpoint5_27Request["params"]["sessionID"] }
-const Endpoint5_27 = (raw: RawClient["server.session"]) => (input: Endpoint5_27Input) =>
-  raw["session.interrupt"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
-
-type Endpoint5_28Request = Parameters<RawClient["server.session"]["session.background"]>[0]
+type Endpoint5_28Request = Parameters<RawClient["server.session"]["session.interrupt"]>[0]
 type Endpoint5_28Input = { readonly sessionID: Endpoint5_28Request["params"]["sessionID"] }
 const Endpoint5_28 = (raw: RawClient["server.session"]) => (input: Endpoint5_28Input) =>
+  raw["session.interrupt"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint5_29Request = Parameters<RawClient["server.session"]["session.background"]>[0]
+type Endpoint5_29Input = { readonly sessionID: Endpoint5_29Request["params"]["sessionID"] }
+const Endpoint5_29 = (raw: RawClient["server.session"]) => (input: Endpoint5_29Input) =>
  raw["session.background"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))

-type Endpoint5_29Request = Parameters<RawClient["server.session"]["session.message"]>[0]
-type Endpoint5_29Input = {
-  readonly sessionID: Endpoint5_29Request["params"]["sessionID"]
-  readonly messageID: Endpoint5_29Request["params"]["messageID"]
+type Endpoint5_30Request = Parameters<RawClient["server.session"]["session.message"]>[0]
+type Endpoint5_30Input = {
+  readonly sessionID: Endpoint5_30Request["params"]["sessionID"]
+  readonly messageID: Endpoint5_30Request["params"]["messageID"]
 }
-const Endpoint5_29 = (raw: RawClient["server.session"]) => (input: Endpoint5_29Input) =>
+const Endpoint5_30 = (raw: RawClient["server.session"]) => (input: Endpoint5_30Input) =>
  raw["session.message"]({ params: { sessionID: input["sessionID"], messageID: input["messageID"] } }).pipe(
    Effect.mapError(mapClientError),
    Effect.map((value) => value.data),
@@ -420,23 +425,24 @@ const adaptGroup5 = (raw: RawClient["server.session"]) => ({
  switchAgent: Endpoint5_6(raw),
  switchModel: Endpoint5_7(raw),
  rename: Endpoint5_8(raw),
-  move: Endpoint5_9(raw),
-  prompt: Endpoint5_10(raw),
-  command: Endpoint5_11(raw),
-  skill: Endpoint5_12(raw),
-  synthetic: Endpoint5_13(raw),
-  shell: Endpoint5_14(raw),
-  compact: Endpoint5_15(raw),
-  wait: Endpoint5_16(raw),
-  revert: { stage: Endpoint5_17(raw), clear: Endpoint5_18(raw), commit: Endpoint5_19(raw) },
-  context: Endpoint5_20(raw),
-  pending: { list: Endpoint5_21(raw) },
-  instructions: { entry: { list: Endpoint5_22(raw), put: Endpoint5_23(raw), remove: Endpoint5_24(raw) } },
-  generate: Endpoint5_25(raw),
-  log: Endpoint5_26(raw),
-  interrupt: Endpoint5_27(raw),
-  background: Endpoint5_28(raw),
-  message: Endpoint5_29(raw),
+  archive: Endpoint5_9(raw),
+  move: Endpoint5_10(raw),
+  prompt: Endpoint5_11(raw),
+  command: Endpoint5_12(raw),
+  skill: Endpoint5_13(raw),
+  synthetic: Endpoint5_14(raw),
+  shell: Endpoint5_15(raw),
+  compact: Endpoint5_16(raw),
+  wait: Endpoint5_17(raw),
+  revert: { stage: Endpoint5_18(raw), clear: Endpoint5_19(raw), commit: Endpoint5_20(raw) },
+  context: Endpoint5_21(raw),
+  pending: { list: Endpoint5_22(raw) },
+  instructions: { entry: { list: Endpoint5_23(raw), put: Endpoint5_24(raw), remove: Endpoint5_25(raw) } },
+  generate: Endpoint5_26(raw),
+  log: Endpoint5_27(raw),
+  interrupt: Endpoint5_28(raw),
+  background: Endpoint5_29(raw),
+  message: Endpoint5_30(raw),
 })

 type Endpoint6_0Request = Parameters<RawClient["server.message"]["session.messages"]>[0]
@@ -736,17 +742,30 @@ const adaptGroup12 = (raw: RawClient["server.credential"]) => ({ update: Endpoin
 const Endpoint13_0 = (raw: RawClient["server.project"]) => () =>
  raw["project.list"]({}).pipe(Effect.mapError(mapClientError))

-type Endpoint13_1Request = Parameters<RawClient["server.project"]["project.current"]>[0]
-type Endpoint13_1Input = { readonly location?: Endpoint13_1Request["query"]["location"] }
-const Endpoint13_1 = (raw: RawClient["server.project"]) => (input?: Endpoint13_1Input) =>
+type Endpoint13_1Request = Parameters<RawClient["server.project"]["project.update"]>[0]
+type Endpoint13_1Input = {
+  readonly projectID: Endpoint13_1Request["params"]["projectID"]
+  readonly name?: Endpoint13_1Request["payload"]["name"]
+  readonly icon?: Endpoint13_1Request["payload"]["icon"]
+  readonly commands?: Endpoint13_1Request["payload"]["commands"]
+}
+const Endpoint13_1 = (raw: RawClient["server.project"]) => (input: Endpoint13_1Input) =>
+  raw["project.update"]({
+    params: { projectID: input["projectID"] },
+    payload: { name: input["name"], icon: input["icon"], commands: input["commands"] },
+  }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint13_2Request = Parameters<RawClient["server.project"]["project.current"]>[0]
+type Endpoint13_2Input = { readonly location?: Endpoint13_2Request["query"]["location"] }
+const Endpoint13_2 = (raw: RawClient["server.project"]) => (input?: Endpoint13_2Input) =>
  raw["project.current"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))

-type Endpoint13_2Request = Parameters<RawClient["server.project"]["project.directories"]>[0]
-type Endpoint13_2Input = {
-  readonly projectID: Endpoint13_2Request["params"]["projectID"]
-  readonly location?: Endpoint13_2Request["query"]["location"]
+type Endpoint13_3Request = Parameters<RawClient["server.project"]["project.directories"]>[0]
+type Endpoint13_3Input = {
+  readonly projectID: Endpoint13_3Request["params"]["projectID"]
+  readonly location?: Endpoint13_3Request["query"]["location"]
 }
-const Endpoint13_2 = (raw: RawClient["server.project"]) => (input: Endpoint13_2Input) =>
+const Endpoint13_3 = (raw: RawClient["server.project"]) => (input: Endpoint13_3Input) =>
  raw["project.directories"]({
    params: { projectID: input["projectID"] },
    query: { location: input["location"] },
@@ -754,8 +773,9 @@ const Endpoint13_2 = (raw: RawClient["server.project"]) => (input: Endpoint13_2I

 const adaptGroup13 = (raw: RawClient["server.project"]) => ({
  list: Endpoint13_0(raw),
-  current: Endpoint13_1(raw),
-  directories: Endpoint13_2(raw),
+  update: Endpoint13_1(raw),
+  current: Endpoint13_2(raw),
+  directories: Endpoint13_3(raw),
 })

 type Endpoint14_0Request = Parameters<RawClient["server.form"]["form.request.list"]>[0]
@@ -977,21 +997,26 @@ const Endpoint19_0 = (raw: RawClient["server.event"]) => () =>

 const adaptGroup19 = (raw: RawClient["server.event"]) => ({ subscribe: Endpoint19_0(raw) })

-type Endpoint20_0Request = Parameters<RawClient["server.pty"]["pty.list"]>[0]
+type Endpoint20_0Request = Parameters<RawClient["server.pty"]["pty.shells"]>[0]
 type Endpoint20_0Input = { readonly location?: Endpoint20_0Request["query"]["location"] }
 const Endpoint20_0 = (raw: RawClient["server.pty"]) => (input?: Endpoint20_0Input) =>
+  raw["pty.shells"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint20_1Request = Parameters<RawClient["server.pty"]["pty.list"]>[0]
+type Endpoint20_1Input = { readonly location?: Endpoint20_1Request["query"]["location"] }
+const Endpoint20_1 = (raw: RawClient["server.pty"]) => (input?: Endpoint20_1Input) =>
  raw["pty.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))

-type Endpoint20_1Request = Parameters<RawClient["server.pty"]["pty.create"]>[0]
-type Endpoint20_1Input = {
-  readonly location?: Endpoint20_1Request["query"]["location"]
-  readonly command?: Endpoint20_1Request["payload"]["command"]
-  readonly args?: Endpoint20_1Request["payload"]["args"]
-  readonly cwd?: Endpoint20_1Request["payload"]["cwd"]
-  readonly title?: Endpoint20_1Request["payload"]["title"]
-  readonly env?: Endpoint20_1Request["payload"]["env"]
+type Endpoint20_2Request = Parameters<RawClient["server.pty"]["pty.create"]>[0]
+type Endpoint20_2Input = {
+  readonly location?: Endpoint20_2Request["query"]["location"]
+  readonly command?: Endpoint20_2Request["payload"]["command"]
+  readonly args?: Endpoint20_2Request["payload"]["args"]
+  readonly cwd?: Endpoint20_2Request["payload"]["cwd"]
+  readonly title?: Endpoint20_2Request["payload"]["title"]
+  readonly env?: Endpoint20_2Request["payload"]["env"]
 }
-const Endpoint20_1 = (raw: RawClient["server.pty"]) => (input?: Endpoint20_1Input) =>
+const Endpoint20_2 = (raw: RawClient["server.pty"]) => (input?: Endpoint20_2Input) =>
  raw["pty.create"]({
    query: { location: input?.["location"] },
    payload: {
@@ -1003,46 +1028,61 @@ const Endpoint20_1 = (raw: RawClient["server.pty"]) => (input?: Endpoint20_1Inpu
    },
  }).pipe(Effect.mapError(mapClientError))

-type Endpoint20_2Request = Parameters<RawClient["server.pty"]["pty.get"]>[0]
-type Endpoint20_2Input = {
-  readonly ptyID: Endpoint20_2Request["params"]["ptyID"]
-  readonly location?: Endpoint20_2Request["query"]["location"]
+type Endpoint20_3Request = Parameters<RawClient["server.pty"]["pty.get"]>[0]
+type Endpoint20_3Input = {
+  readonly ptyID: Endpoint20_3Request["params"]["ptyID"]
+  readonly location?: Endpoint20_3Request["query"]["location"]
 }
-const Endpoint20_2 = (raw: RawClient["server.pty"]) => (input: Endpoint20_2Input) =>
+const Endpoint20_3 = (raw: RawClient["server.pty"]) => (input: Endpoint20_3Input) =>
  raw["pty.get"]({ params: { ptyID: input["ptyID"] }, query: { location: input["location"] } }).pipe(
    Effect.mapError(mapClientError),
  )

-type Endpoint20_3Request = Parameters<RawClient["server.pty"]["pty.update"]>[0]
-type Endpoint20_3Input = {
-  readonly ptyID: Endpoint20_3Request["params"]["ptyID"]
-  readonly location?: Endpoint20_3Request["query"]["location"]
-  readonly title?: Endpoint20_3Request["payload"]["title"]
-  readonly size?: Endpoint20_3Request["payload"]["size"]
+type Endpoint20_4Request = Parameters<RawClient["server.pty"]["pty.update"]>[0]
+type Endpoint20_4Input = {
+  readonly ptyID: Endpoint20_4Request["params"]["ptyID"]
+  readonly location?: Endpoint20_4Request["query"]["location"]
+  readonly title?: Endpoint20_4Request["payload"]["title"]
+  readonly size?: Endpoint20_4Request["payload"]["size"]
 }
-const Endpoint20_3 = (raw: RawClient["server.pty"]) => (input: Endpoint20_3Input) =>
+const Endpoint20_4 = (raw: RawClient["server.pty"]) => (input: Endpoint20_4Input) =>
  raw["pty.update"]({
    params: { ptyID: input["ptyID"] },
    query: { location: input["location"] },
    payload: { title: input["title"], size: input["size"] },
  }).pipe(Effect.mapError(mapClientError))

-type Endpoint20_4Request = Parameters<RawClient["server.pty"]["pty.remove"]>[0]
-type Endpoint20_4Input = {
-  readonly ptyID: Endpoint20_4Request["params"]["ptyID"]
-  readonly location?: Endpoint20_4Request["query"]["location"]
+type Endpoint20_5Request = Parameters<RawClient["server.pty"]["pty.remove"]>[0]
+type Endpoint20_5Input = {
+  readonly ptyID: Endpoint20_5Request["params"]["ptyID"]
+  readonly location?: Endpoint20_5Request["query"]["location"]
 }
-const Endpoint20_4 = (raw: RawClient["server.pty"]) => (input: Endpoint20_4Input) =>
+const Endpoint20_5 = (raw: RawClient["server.pty"]) => (input: Endpoint20_5Input) =>
  raw["pty.remove"]({ params: { ptyID: input["ptyID"] }, query: { location: input["location"] } }).pipe(
    Effect.mapError(mapClientError),
  )

+type Endpoint20_6Request = Parameters<RawClient["server.pty"]["pty.connectToken"]>[0]
+type Endpoint20_6Input = {
+  readonly ptyID: Endpoint20_6Request["params"]["ptyID"]
+  readonly location?: Endpoint20_6Request["query"]["location"]
+  readonly "x-opencode-ticket"?: Endpoint20_6Request["headers"]["x-opencode-ticket"]
+}
+const Endpoint20_6 = (raw: RawClient["server.pty"]) => (input: Endpoint20_6Input) =>
+  raw["pty.connectToken"]({
+    params: { ptyID: input["ptyID"] },
+    query: { location: input["location"] },
+    headers: { "x-opencode-ticket": input["x-opencode-ticket"] },
+  }).pipe(Effect.mapError(mapClientError))
+
 const adaptGroup20 = (raw: RawClient["server.pty"]) => ({
-  list: Endpoint20_0(raw),
-  create: Endpoint20_1(raw),
-  get: Endpoint20_2(raw),
-  update: Endpoint20_3(raw),
-  remove: Endpoint20_4(raw),
+  shells: Endpoint20_0(raw),
+  list: Endpoint20_1(raw),
+  create: Endpoint20_2(raw),
+  get: Endpoint20_3(raw),
+  update: Endpoint20_4(raw),
+  remove: Endpoint20_5(raw),
+  connectToken: Endpoint20_6(raw),
 })

 type Endpoint21_0Request = Parameters<RawClient["server.shell"]["shell.list"]>[0]
@@ -1214,34 +1254,50 @@ const adaptGroup24 = (raw: RawClient["server.projectCopy"]) => ({
  refresh: Endpoint24_2(raw),
 })

-type Endpoint25_0Request = Parameters<RawClient["server.vcs"]["vcs.status"]>[0]
+type Endpoint25_0Request = Parameters<RawClient["server.vcs"]["vcs.get"]>[0]
 type Endpoint25_0Input = { readonly location?: Endpoint25_0Request["query"]["location"] }
 const Endpoint25_0 = (raw: RawClient["server.vcs"]) => (input?: Endpoint25_0Input) =>
+  raw["vcs.get"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint25_1Request = Parameters<RawClient["server.vcs"]["vcs.status"]>[0]
+type Endpoint25_1Input = { readonly location?: Endpoint25_1Request["query"]["location"] }
+const Endpoint25_1 = (raw: RawClient["server.vcs"]) => (input?: Endpoint25_1Input) =>
  raw["vcs.status"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))

-type Endpoint25_1Request = Parameters<RawClient["server.vcs"]["vcs.diff"]>[0]
-type Endpoint25_1Input = {
-  readonly location?: Endpoint25_1Request["query"]["location"]
-  readonly mode: Endpoint25_1Request["query"]["mode"]
-  readonly context?: Endpoint25_1Request["query"]["context"]
+type Endpoint25_2Request = Parameters<RawClient["server.vcs"]["vcs.diff"]>[0]
+type Endpoint25_2Input = {
+  readonly location?: Endpoint25_2Request["query"]["location"]
+  readonly mode: Endpoint25_2Request["query"]["mode"]
+  readonly context?: Endpoint25_2Request["query"]["context"]
 }
-const Endpoint25_1 = (raw: RawClient["server.vcs"]) => (input: Endpoint25_1Input) =>
+const Endpoint25_2 = (raw: RawClient["server.vcs"]) => (input: Endpoint25_2Input) =>
  raw["vcs.diff"]({ query: { location: input["location"], mode: input["mode"], context: input["context"] } }).pipe(
    Effect.mapError(mapClientError),
  )

-const adaptGroup25 = (raw: RawClient["server.vcs"]) => ({ status: Endpoint25_0(raw), diff: Endpoint25_1(raw) })
+const adaptGroup25 = (raw: RawClient["server.vcs"]) => ({
+  get: Endpoint25_0(raw),
+  status: Endpoint25_1(raw),
+  diff: Endpoint25_2(raw),
+})

-const Endpoint26_0 = (raw: RawClient["server.debug"]) => () =>
+type Endpoint26_0Request = Parameters<RawClient["server.path"]["path.get"]>[0]
+type Endpoint26_0Input = { readonly location?: Endpoint26_0Request["query"]["location"] }
+const Endpoint26_0 = (raw: RawClient["server.path"]) => (input?: Endpoint26_0Input) =>
+  raw["path.get"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
+
+const adaptGroup26 = (raw: RawClient["server.path"]) => ({ get: Endpoint26_0(raw) })
+
+const Endpoint27_0 = (raw: RawClient["server.debug"]) => () =>
  raw["debug.location"]({}).pipe(Effect.mapError(mapClientError))

-type Endpoint26_1Request = Parameters<RawClient["server.debug"]["debug.location.evict"]>[0]
-type Endpoint26_1Input = { readonly location?: Endpoint26_1Request["query"]["location"] }
-const Endpoint26_1 = (raw: RawClient["server.debug"]) => (input?: Endpoint26_1Input) =>
+type Endpoint27_1Request = Parameters<RawClient["server.debug"]["debug.location.evict"]>[0]
+type Endpoint27_1Input = { readonly location?: Endpoint27_1Request["query"]["location"] }
+const Endpoint27_1 = (raw: RawClient["server.debug"]) => (input?: Endpoint27_1Input) =>
  raw["debug.location.evict"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))

-const adaptGroup26 = (raw: RawClient["server.debug"]) => ({
-  location: { list: Endpoint26_0(raw), evict: Endpoint26_1(raw) },
+const adaptGroup27 = (raw: RawClient["server.debug"]) => ({
+  location: { list: Endpoint27_0(raw), evict: Endpoint27_1(raw) },
 })

 const adaptClient = (raw: RawClient) => ({
@@ -1271,7 +1327,8 @@ const adaptClient = (raw: RawClient) => ({
  reference: adaptGroup23(raw["server.reference"]),
  projectCopy: adaptGroup24(raw["server.projectCopy"]),
  vcs: adaptGroup25(raw["server.vcs"]),
-  debug: adaptGroup26(raw["server.debug"]),
+  path: adaptGroup26(raw["server.path"]),
+  debug: adaptGroup27(raw["server.debug"]),
 })

 export const make = (options?: { readonly baseUrl?: URL | string }) =>
@@ -3,13 +3,22 @@ type Client = ReturnType<typeof import("./generated/client.js").make>
 export type AgentApi = Client["agent"]
 export type CommandApi = Client["command"]
 export type EventApi = Client["event"]
+export type FileApi = Client["file"]
 export type IntegrationApi = Client["integration"]
+export type MessageApi = Client["message"]
+export type McpApi = Client["mcp"]
 export type ModelApi = Client["model"]
 export type PluginApi = Client["plugin"]
+export type PermissionApi = Client["permission"]
+export type PathApi = Client["path"]
+export type ProjectApi = Client["project"]
 export type ProviderApi = Client["provider"]
+export type QuestionApi = Client["question"]
 export type ReferenceApi = Client["reference"]
 export type SessionApi = Client["session"]
 export type SkillApi = Client["skill"]
+export type PtyApi = Client["pty"]
+export type VcsApi = Client["vcs"]

 export interface CatalogApi {
  readonly provider: ProviderApi
@@ -26,6 +26,8 @@ import type {
  SessionSwitchModelOutput,
  SessionRenameInput,
  SessionRenameOutput,
+  SessionArchiveInput,
+  SessionArchiveOutput,
  SessionMoveInput,
  SessionMoveOutput,
  SessionPromptInput,
@@ -119,6 +121,8 @@ import type {
  CredentialRemoveInput,
  CredentialRemoveOutput,
  ProjectListOutput,
+  ProjectUpdateInput,
+  ProjectUpdateOutput,
  ProjectCurrentInput,
  ProjectCurrentOutput,
  ProjectDirectoriesInput,
@@ -162,6 +166,8 @@ import type {
  SkillListInput,
  SkillListOutput,
  EventSubscribeOutput,
+  PtyShellsInput,
+  PtyShellsOutput,
  PtyListInput,
  PtyListOutput,
  PtyCreateInput,
@@ -172,6 +178,8 @@ import type {
  PtyUpdateOutput,
  PtyRemoveInput,
  PtyRemoveOutput,
+  PtyConnectTokenInput,
+  PtyConnectTokenOutput,
  ShellListInput,
  ShellListOutput,
  ShellCreateInput,
@@ -200,10 +208,14 @@ import type {
  ProjectCopyRemoveOutput,
  ProjectCopyRefreshInput,
  ProjectCopyRefreshOutput,
+  VcsGetInput,
+  VcsGetOutput,
  VcsStatusInput,
  VcsStatusOutput,
  VcsDiffInput,
  VcsDiffOutput,
+  PathGetInput,
+  PathGetOutput,
  DebugLocationListOutput,
  DebugLocationEvictInput,
  DebugLocationEvictOutput,
@@ -535,6 +547,17 @@ export function make(options: ClientOptions) {
          },
          requestOptions,
        ),
+      archive: (input: SessionArchiveInput, requestOptions?: RequestOptions) =>
+        request<SessionArchiveOutput>(
+          {
+            method: "POST",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/archive`,
+            successStatus: 204,
+            declaredStatuses: [404, 400, 401],
+            empty: true,
+          },
+          requestOptions,
+        ),
      move: (input: SessionMoveInput, requestOptions?: RequestOptions) =>
        request<SessionMoveOutput>(
          {
@@ -1149,6 +1172,18 @@ export function make(options: ClientOptions) {
          { method: "GET", path: `/api/project`, successStatus: 200, declaredStatuses: [401, 400], empty: false },
          requestOptions,
        ),
+      update: (input: ProjectUpdateInput, requestOptions?: RequestOptions) =>
+        request<ProjectUpdateOutput>(
+          {
+            method: "PATCH",
+            path: `/api/project/${encodeURIComponent(input.projectID)}`,
+            body: { name: input["name"], icon: input["icon"], commands: input["commands"] },
+            successStatus: 200,
+            declaredStatuses: [404, 401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ),
      current: (input?: ProjectCurrentInput, requestOptions?: RequestOptions) =>
        request<ProjectCurrentOutput>(
          {
@@ -1428,6 +1463,18 @@ export function make(options: ClientOptions) {
        ),
    },
    pty: {
+      shells: (input?: PtyShellsInput, requestOptions?: RequestOptions) =>
+        request<PtyShellsOutput>(
+          {
+            method: "GET",
+            path: `/api/pty/shells`,
+            query: { location: input?.["location"] },
+            successStatus: 200,
+            declaredStatuses: [401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ),
      list: (input?: PtyListInput, requestOptions?: RequestOptions) =>
        request<PtyListOutput>(
          {
@@ -1496,6 +1543,19 @@ export function make(options: ClientOptions) {
          },
          requestOptions,
        ),
+      connectToken: (input: PtyConnectTokenInput, requestOptions?: RequestOptions) =>
+        request<PtyConnectTokenOutput>(
+          {
+            method: "POST",
+            path: `/api/pty/${encodeURIComponent(input.ptyID)}/connect-token`,
+            query: { location: input["location"] },
+            headers: { "x-opencode-ticket": input["x-opencode-ticket"] },
+            successStatus: 200,
+            declaredStatuses: [403, 404, 401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ),
    },
    shell: {
      list: (input?: ShellListInput, requestOptions?: RequestOptions) =>
@@ -1683,6 +1743,18 @@ export function make(options: ClientOptions) {
        ),
    },
    vcs: {
+      get: (input?: VcsGetInput, requestOptions?: RequestOptions) =>
+        request<VcsGetOutput>(
+          {
+            method: "GET",
+            path: `/api/vcs`,
+            query: { location: input?.["location"] },
+            successStatus: 200,
+            declaredStatuses: [401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ),
      status: (input?: VcsStatusInput, requestOptions?: RequestOptions) =>
        request<VcsStatusOutput>(
          {
@@ -1708,6 +1780,20 @@ export function make(options: ClientOptions) {
          requestOptions,
        ),
    },
+    path: {
+      get: (input?: PathGetInput, requestOptions?: RequestOptions) =>
+        request<PathGetOutput>(
+          {
+            method: "GET",
+            path: `/api/path`,
+            query: { location: input?.["location"] },
+            successStatus: 200,
+            declaredStatuses: [401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ),
+    },
    debug: {
      location: {
        list: (requestOptions?: RequestOptions) =>
@@ -501,6 +501,10 @@ export type QuestionTool = { messageID: string; callID: string }

 export type QuestionAnswer = Array<string>

+export type PtyShell = { path: string; name: string; acceptable: boolean }
+
+export type PtyTicketConnectToken = { ticket: string; expires_in: number }
+
 export type ShellInfo1 = {
  id: string
  status: "running" | "exited" | "timeout" | "killed"
@@ -526,6 +530,8 @@ export type ReferenceGitSource = {

 export type ProjectCopyCopy = { directory: string }

+export type VcsInfo = { branch?: string; defaultBranch?: string }
+
 export type VcsFileStatus = {
  file: string
  additions: number
@@ -533,6 +539,8 @@ export type VcsFileStatus = {
  status: "added" | "deleted" | "modified"
 }

+export type PathInfo = { home: string; state: string; config: string; worktree: string; directory: string }
+
 export type SessionMessageModelSelected = {
  id: string
  metadata?: { [x: string]: JsonValue }
@@ -549,6 +557,7 @@ export type CommandInfo = {
  agent?: string
  model?: ModelRef
  subtask?: boolean
+  source?: "command" | "mcp"
 }

 export type ProviderRequest = {
@@ -599,6 +608,16 @@ export type SessionRenamed = {
  data: { sessionID: string; title: string }
 }

+export type SessionArchived = {
+  id: string
+  created: number
+  metadata?: { [x: string]: any }
+  type: "session.archived"
+  durable: { aggregateID: string; seq: number; version: 1 }
+  location?: LocationRef
+  data: { sessionID: string }
+}
+
 export type SessionDeleted = {
  id: string
  created: number
@@ -2202,6 +2221,7 @@ export type SessionEventDurable =
  | SessionModelSelected
  | SessionMoved
  | SessionRenamed
+  | SessionArchived
  | SessionDeleted
  | SessionForked
  | SessionInputPromoted
@@ -2296,6 +2316,7 @@ export type V2Event =
  | SessionModelSelected
  | SessionMoved
  | SessionRenamed
+  | SessionArchived
  | SessionUsageUpdated
  | SessionDeleted
  | SessionForked
@@ -2495,6 +2516,14 @@ export type McpServerNotFoundError = {
 export const isMcpServerNotFoundError = (value: unknown): value is McpServerNotFoundError =>
  typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "McpServerNotFoundError"

+export type ProjectNotFoundError = {
+  readonly _tag: "ProjectNotFoundError"
+  readonly projectID: string
+  readonly message: string
+}
+export const isProjectNotFoundError = (value: unknown): value is ProjectNotFoundError =>
+  typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "ProjectNotFoundError"
+
 export type FormNotFoundError = { readonly _tag: "FormNotFoundError"; readonly id: string; readonly message: string }
 export const isFormNotFoundError = (value: unknown): value is FormNotFoundError =>
  typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "FormNotFoundError"
@@ -2527,6 +2556,10 @@ export type PtyNotFoundError = { readonly _tag: "PtyNotFoundError"; readonly pty
 export const isPtyNotFoundError = (value: unknown): value is PtyNotFoundError =>
  typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "PtyNotFoundError"

+export type ForbiddenError = { readonly _tag: "ForbiddenError"; readonly message: string }
+export const isForbiddenError = (value: unknown): value is ForbiddenError =>
+  typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "ForbiddenError"
+
 export type ShellNotFoundError = { readonly _tag: "ShellNotFoundError"; readonly id: string; readonly message: string }
 export const isShellNotFoundError = (value: unknown): value is ShellNotFoundError =>
  typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "ShellNotFoundError"
@@ -2757,6 +2790,10 @@ export type SessionRenameInput = {

 export type SessionRenameOutput = void

+export type SessionArchiveInput = { readonly sessionID: { readonly sessionID: string }["sessionID"] }
+
+export type SessionArchiveOutput = void
+
 export type SessionMoveInput = {
  readonly sessionID: { readonly sessionID: string }["sessionID"]
  readonly directory: { readonly directory: string; readonly workspaceID?: string }["directory"]
@@ -3584,6 +3621,27 @@ export type CredentialRemoveOutput = void

 export type ProjectListOutput = Array<Project>

+export type ProjectUpdateInput = {
+  readonly projectID: { readonly projectID: string }["projectID"]
+  readonly name?: {
+    readonly name?: string
+    readonly icon?: { readonly url?: string; readonly override?: string; readonly color?: string }
+    readonly commands?: { readonly start?: string }
+  }["name"]
+  readonly icon?: {
+    readonly name?: string
+    readonly icon?: { readonly url?: string; readonly override?: string; readonly color?: string }
+    readonly commands?: { readonly start?: string }
+  }["icon"]
+  readonly commands?: {
+    readonly name?: string
+    readonly icon?: { readonly url?: string; readonly override?: string; readonly color?: string }
+    readonly commands?: { readonly start?: string }
+  }["commands"]
+}
+
+export type ProjectUpdateOutput = Project
+
 export type ProjectCurrentInput = {
  readonly location?: {
    readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
@@ -4646,6 +4704,17 @@ export type SkillListOutput = {

 export type EventSubscribeOutput = V2Event

+export type PtyShellsInput = {
+  readonly location?: {
+    readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
+  }["location"]
+}
+
+export type PtyShellsOutput = {
+  location: { directory: string; workspaceID?: string; project: { id: string; directory: string } }
+  data: Array<PtyShell>
+}
+
 export type PtyListInput = {
  readonly location?: {
    readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
@@ -4741,6 +4810,19 @@ export type PtyRemoveInput = {

 export type PtyRemoveOutput = void

+export type PtyConnectTokenInput = {
+  readonly ptyID: { readonly ptyID: string }["ptyID"]
+  readonly location?: {
+    readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
+  }["location"]
+  readonly "x-opencode-ticket"?: { readonly "x-opencode-ticket"?: string | undefined }["x-opencode-ticket"]
+}
+
+export type PtyConnectTokenOutput = {
+  location: { directory: string; workspaceID?: string; project: { id: string; directory: string } }
+  data: PtyTicketConnectToken
+}
+
 export type ShellListInput = {
  readonly location?: {
    readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
@@ -4918,6 +5000,17 @@ export type ProjectCopyRefreshInput = {

 export type ProjectCopyRefreshOutput = void

+export type VcsGetInput = {
+  readonly location?: {
+    readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
+  }["location"]
+}
+
+export type VcsGetOutput = {
+  location: { directory: string; workspaceID?: string; project: { id: string; directory: string } }
+  data: VcsInfo
+}
+
 export type VcsStatusInput = {
  readonly location?: {
    readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
@@ -4952,6 +5045,14 @@ export type VcsDiffOutput = {
  data: Array<FileDiffInfo>
 }

+export type PathGetInput = {
+  readonly location?: {
+    readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
+  }["location"]
+}
+
+export type PathGetOutput = PathInfo
+
 export type DebugLocationListOutput = Array<LocationRef>

 export type DebugLocationEvictInput = {
@@ -4,13 +4,22 @@ export type {
  CatalogApi,
  CommandApi,
  EventApi,
+  FileApi,
  IntegrationApi,
+  MessageApi,
+  McpApi,
  ModelApi,
+  PermissionApi,
+  PathApi,
  PluginApi,
+  ProjectApi,
  ProviderApi,
+  QuestionApi,
  ReferenceApi,
  SessionApi,
  SkillApi,
+  PtyApi,
+  VcsApi,
 } from "./api.js"
 export type { EventSubscribeOutput as OpenCodeEvent } from "./generated/types"
 export type OpenCodeClient = ReturnType<typeof import("./generated/client").make>
@@ -31,6 +31,7 @@ test("exposes every standard HTTP API group", () => {
    "reference",
    "projectCopy",
    "vcs",
+    "path",
    "debug",
  ])
  expect(Object.keys(client.debug)).toEqual(["location"])
@@ -42,10 +43,37 @@ test("exposes every standard HTTP API group", () => {
  expect(Object.keys(client.integration.oauth)).toEqual(["connect", "status", "complete", "cancel"])
  expect(Object.keys(client.integration.command)).toEqual(["connect", "status", "cancel"])
  expect(Object.keys(client.file)).toEqual(["read", "list", "find"])
-  expect(Object.keys(client.vcs)).toEqual(["status", "diff"])
-  expect(Object.keys(client.pty)).toEqual(["list", "create", "get", "update", "remove"])
+  expect(Object.keys(client.vcs)).toEqual(["get", "status", "diff"])
+  expect(Object.keys(client.pty)).toEqual(["shells", "list", "create", "get", "update", "remove", "connectToken"])
  expect(Object.keys(client.shell)).toEqual(["list", "create", "get", "timeout", "output", "remove"])
-  expect(Object.keys(client.project)).toEqual(["list", "current", "directories"])
+  expect(Object.keys(client.project)).toEqual(["list", "update", "current", "directories"])
+})
+
+test("PTY connect token sends the required browser header", async () => {
+  let request: Request | undefined
+  const client = OpenCode.make({
+    baseUrl: "http://localhost:3000",
+    fetch: async (input, init) => {
+      request = input instanceof Request ? input : new Request(input, init)
+      return Response.json({
+        location: { directory: "/tmp/project", project: { id: "proj_test", directory: "/tmp/project" } },
+        data: { ticket: "ticket", expires_in: 60 },
+      })
+    },
+  })
+
+  const result = await client.pty.connectToken({
+    ptyID: "pty_test",
+    location: { directory: "/tmp/project" },
+    "x-opencode-ticket": "1",
+  })
+
+  expect(result.data.ticket).toBe("ticket")
+  expect(request?.method).toBe("POST")
+  expect(request?.headers.get("x-opencode-ticket")).toBe("1")
+  expect(request?.url).toBe(
+    "http://localhost:3000/api/pty/pty_test/connect-token?location%5Bdirectory%5D=%2Ftmp%2Fproject",
+  )
 })

 test("server.get uses the public HTTP contract", async () => {
@@ -85,6 +85,7 @@ export const layer = (options?: ShellSelect.Options) => Layer.effect(
          name: mcpCommandName(prompt.server, prompt.name),
          template: "",
          description: prompt.description,
+          source: "mcp",
        }),
      )
    })
@@ -98,7 +99,10 @@ export const layer = (options?: ShellSelect.Options) => Layer.effect(
        return (yield* mcpCommands()).find((command) => command.name === name)
      }),
      list: Effect.fn("CommandV2.list")(function* () {
-        const commands = Array.from(state.get().commands.values()) as Info[]
+        const commands = Array.from(state.get().commands.values()).map((command) => ({
+          ...command,
+          source: command.source ?? "command" as const,
+        }))
        const names = new Set(commands.map((command) => command.name))
        return [
          ...commands,
@@ -3,7 +3,7 @@ export * as Project from "./project"

 import { Context, Effect, Layer, Schema } from "effect"
 import { ChildProcess } from "effect/unstable/process"
-import { asc, desc } from "drizzle-orm"
+import { asc, desc, eq } from "drizzle-orm"
 import path from "path"
 import { AbsolutePath } from "./schema"
 import { Database } from "./database/database"
@@ -37,6 +37,13 @@ export type DirectoriesInput = typeof DirectoriesInput.Type
 export const Directories = ProjectSchema.Directories
 export type Directories = typeof Directories.Type

+export const UpdateInput = ProjectSchema.UpdateInput
+export type UpdateInput = typeof UpdateInput.Type
+
+export class NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("Project.NotFoundError", {
+  projectID: ID,
+}) {}
+
 export interface Resolved {
  readonly previous?: ID
  readonly id: ID
@@ -58,6 +65,7 @@ export const root = Effect.fn("Project.root")(function* (
 export interface Interface {
  readonly list: () => Effect.Effect<ReadonlyArray<Info>>
  readonly directories: (input: DirectoriesInput) => Effect.Effect<Directories>
+  readonly update: (projectID: ID, input: UpdateInput) => Effect.Effect<Info, NotFoundError>
  readonly resolve: (input: AbsolutePath) => Effect.Effect<Resolved>
  /**
   * Temporary bridge method for writing the resolved project ID to the repo-local cache.
@@ -121,6 +129,25 @@ const layer = Layer.effect(
      return yield* projectDirectories.list(input.projectID)
    })

+    const update = Effect.fn("Project.update")(function* (projectID: ID, input: UpdateInput) {
+      const row = yield* db
+        .update(ProjectTable)
+        .set({
+          name: input.name,
+          icon_url: input.icon?.url,
+          icon_url_override: input.icon?.override,
+          icon_color: input.icon?.color,
+          commands: input.commands,
+          time_updated: Date.now(),
+        })
+        .where(eq(ProjectTable.id, projectID))
+        .returning()
+        .get()
+        .pipe(Effect.orDie)
+      if (!row) return yield* new NotFoundError({ projectID })
+      return fromRow(row)
+    })
+
    const cached = Effect.fnUntraced(function* (dir: string) {
      return yield* fs.readFileString(path.join(dir, "opencode")).pipe(
        Effect.map((value) => value.trim()),
@@ -229,7 +256,7 @@ const layer = Layer.effect(
      yield* fs.writeFileString(path.join(input.store, "opencode"), input.id).pipe(Effect.ignore)
    })

-    return Service.of({ list, directories, resolve, commit })
+    return Service.of({ list, directories, update, resolve, commit })
  }),
 )

@@ -22,6 +22,9 @@ export type DirectoriesInput = typeof DirectoriesInput.Type
 export const Directories = Project.Directories
 export type Directories = typeof Directories.Type

+export const UpdateInput = Project.UpdateInput
+export type UpdateInput = typeof UpdateInput.Type
+
 export const Vcs = Schema.Union([
  Schema.Struct({
    type: Schema.Literal("git"),
@@ -78,6 +78,7 @@ export class ExitedError extends Schema.TaggedErrorClass<ExitedError>()("Pty.Exi
 }) {}

 export interface Interface {
+  readonly shells: () => Effect.Effect<ReadonlyArray<Pty.Shell>>
  readonly list: () => Effect.Effect<Info[]>
  readonly get: (id: PtyID) => Effect.Effect<Info, NotFoundError>
  readonly create: (input: CreateInput) => Effect.Effect<Info>
@@ -158,6 +159,10 @@ export const layer = (options?: ShellSelect.Options) => Layer.effect(
      return Array.from(sessions.values()).map((session) => session.info)
    })

+    const shells = Effect.fn("Pty.shells")(function* () {
+      return yield* Effect.promise(() => ShellSelect.list(options))
+    })
+
    const get = Effect.fn("Pty.get")(function* (id: PtyID) {
      return (yield* requireSession(id)).info
    })
@@ -309,7 +314,7 @@ export const layer = (options?: ShellSelect.Options) => Layer.effect(
      }
    })

-    return Service.of({ list, get, create, update, remove, write, attach })
+    return Service.of({ shells, list, get, create, update, remove, write, attach })
  }),
 )

@@ -226,6 +226,7 @@ export interface Interface {
    model: ModelV2.Ref
  }) => Effect.Effect<void, NotFoundError>
  readonly rename: (input: { sessionID: SessionSchema.ID; title: string }) => Effect.Effect<void, NotFoundError>
+  readonly archive: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError>
  readonly move: (input: {
    sessionID: SessionSchema.ID
    directory: AbsolutePath
@@ -705,6 +706,11 @@ const layer = Layer.effect(
          title: input.title,
        })
      }),
+      archive: Effect.fn("V2Session.archive")(function* (sessionID) {
+        const session = yield* result.get(sessionID)
+        if (session.time.archived) return
+        yield* events.publish(SessionEvent.Archived, { sessionID })
+      }),
      move: Effect.fn("V2Session.move")(function* (input) {
        const current = yield* result.get(input.sessionID)
        const value = input.directory.trim()
@@ -53,7 +53,7 @@ export function fromRow(row: typeof SessionTable.$inferSelect): SessionSchema.In
    time: {
      created: DateTime.makeUnsafe(row.time_created),
      updated: DateTime.makeUnsafe(row.time_updated),
-      archived: row.time_archived ? DateTime.makeUnsafe(row.time_archived) : undefined,
+      archived: row.time_archived !== null ? DateTime.makeUnsafe(row.time_archived) : undefined,
    },
  })
 }
@@ -171,6 +171,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
      },
      "session.moved": () => Effect.void,
      "session.renamed": () => Effect.void,
+      "session.archived": () => Effect.void,
      "session.deleted": () => Effect.void,
      "session.forked": () => Effect.void,
      "session.input.promoted": () => Effect.void,
@@ -609,6 +609,17 @@ const layer = Layer.effectDiscard(
        .run()
        .pipe(Effect.orDie),
    )
+    yield* events.project(SessionEvent.Archived, (event) =>
+      db
+        .update(SessionTable)
+        .set({
+          time_archived: DateTime.toEpochMillis(event.created),
+          time_updated: DateTime.toEpochMillis(event.created),
+        })
+        .where(eq(SessionTable.id, event.data.sessionID))
+        .run()
+        .pipe(Effect.orDie),
+    )
    yield* events.project(SessionEvent.UsageRecorded, (event) => applyUsage(db, event.data.sessionID, event.data))
    yield* events.project(SessionEvent.Forked, (event) => projectFork(db, event))
    yield* events.project(SessionEvent.InputPromoted, (event) =>
@@ -2,7 +2,7 @@ export * as Vcs from "./vcs"

 import { Context, Effect, Layer } from "effect"
 import { FileDiff } from "@opencode-ai/schema/file-diff"
-import { FileStatus, Mode } from "@opencode-ai/schema/vcs"
+import { FileStatus, Info, Mode } from "@opencode-ai/schema/vcs"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Location } from "./location"
@@ -10,13 +10,14 @@ import { AppProcess } from "@opencode-ai/util/process"
 import { VcsGit } from "./vcs/git"
 import { VcsHg } from "./vcs/hg"

-export { FileStatus, Mode }
+export { FileStatus, Info, Mode }

 export interface DiffOptions {
  readonly context?: number
 }

 export interface Interface {
+  readonly info: () => Effect.Effect<Info>
  readonly status: () => Effect.Effect<FileStatus[]>
  readonly diff: (mode: Mode, options?: DiffOptions) => Effect.Effect<FileDiff.Info[]>
 }
@@ -40,6 +41,10 @@ const layer = Layer.effect(
    const location = yield* Location.Service
    const impl = adapter(proc, fs, location)
    return Service.of({
+      info: Effect.fn("Vcs.info")(function* () {
+        if (!impl) return {}
+        return yield* impl.info()
+      }),
      status: Effect.fn("Vcs.status")(function* () {
        if (!impl) return []
        return yield* impl.status()
@@ -20,6 +20,12 @@ export function make(proc: AppProcess.Interface, input: { directory: string; wor
  const ctx: Ctx = { git: makeGit(proc), directory: input.directory, worktree: input.worktree }

  return {
+    info: Effect.fn("VcsGit.info")(function* () {
+      const [branch, root] = yield* Effect.all([ctx.git.branch(ctx.directory), ctx.git.defaultBranch(ctx.directory)], {
+        concurrency: 2,
+      })
+      return { branch, defaultBranch: root?.name }
+    }),
    status: Effect.fn("VcsGit.status")(function* () {
      const git = ctx.git
      const ref = (yield* git.hasHead(ctx.directory)) ? "HEAD" : undefined
@@ -73,6 +73,9 @@ export function make(
  })

  return {
+    info: Effect.fn("VcsHg.info")(function* () {
+      return { branch: yield* hg.branch(), defaultBranch: "default" }
+    }),
    status: Effect.fn("VcsHg.status")(function* () {
      const [items, batch] = yield* Effect.all(
        // Zero-context patches are enough to count changed lines.
@@ -59,6 +59,7 @@ describe("CommandV2", () => {
            providerID: ProviderV2.ID.make("anthropic"),
            variant: ModelV2.VariantID.make("high"),
          },
+          source: "command",
        }),
      ])
    }),
@@ -95,9 +95,10 @@ Review files`,
                variant: ModelV2.VariantID.make("high"),
              },
              subtask: true,
+              source: "command",
            }),
-            CommandV2.Info.make({ name: "empty", template: "" }),
-            CommandV2.Info.make({ name: "nested/docs", template: "Write docs" }),
+            CommandV2.Info.make({ name: "empty", template: "", source: "command" }),
+            CommandV2.Info.make({ name: "nested/docs", template: "Write docs", source: "command" }),
          ])

          yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, "commands", "review.md"), "Review again"))
@@ -79,6 +79,7 @@ describe("node build", () => {
        return Project.Service.of({
          list: () => Effect.succeed([]),
          directories: () => Effect.succeed([]),
+          update: () => Effect.die("unused"),
          resolve: (directory) => Effect.succeed({ id: Project.ID.global, directory }),
          commit: () => Effect.void,
        })
@@ -14,6 +14,7 @@ const projectLayer = Layer.succeed(
  Project.Service.of({
    list: () => Effect.succeed([]),
    directories: () => Effect.succeed([]),
+    update: () => Effect.die("unused"),
    resolve: () =>
      Effect.succeed({
        id: Project.ID.make("project"),
@@ -66,6 +66,31 @@ describe("ProjectV2.list", () => {
  )
 })

+describe("ProjectV2.update", () => {
+  it.effect("updates project metadata", () =>
+    Effect.gen(function* () {
+      const db = (yield* Database.Service).db
+      const project = yield* ProjectV2.Service
+      const id = ProjectV2.ID.make("updated")
+      yield* db
+        .insert(ProjectTable)
+        .values({ id, worktree: abs("/updated"), sandboxes: [], time_created: 1, time_updated: 1 })
+        .run()
+
+      const result = yield* project.update(id, {
+        name: "Updated",
+        icon: { color: "#ffffff" },
+        commands: { start: "bun dev" },
+      })
+
+      expect(result.name).toBe("Updated")
+      expect(result.icon).toEqual({ color: "#ffffff" })
+      expect(result.commands).toEqual({ start: "bun dev" })
+      expect(result.time.updated).toBeGreaterThan(1)
+    }),
+  )
+})
+
 function remoteID(remote: string) {
  return ProjectV2.ID.make(Hash.fast(`git-remote:${remote}`))
 }
@@ -90,6 +90,18 @@ const waitForOutput = (output: Queue.Queue<string>, text: string) =>
    }),
  )

+describe("Pty.shells", () => {
+  it.live("lists available shells", () =>
+    Effect.gen(function* () {
+      const pty = yield* Pty.Service
+      const shells = yield* pty.shells()
+
+      expect(shells.length).toBeGreaterThan(0)
+      expect(shells.every((shell) => shell.path && shell.name && typeof shell.acceptable === "boolean")).toBe(true)
+    }),
+  )
+})
+
 describe("pty", () => {
  it.live("returns typed not found errors for missing sessions", () =>
    Effect.gen(function* () {
@@ -36,6 +36,7 @@ const projects = Layer.succeed(
    list: () => Effect.succeed([]),
    resolve: (directory) => Effect.succeed({ id: ProjectV2.ID.global, directory }),
    directories: () => Effect.succeed([]),
+    update: () => Effect.die("unused"),
    commit: () => Effect.void,
  }),
 )
@@ -34,6 +34,7 @@ const projects = Layer.succeed(
    list: () => Effect.succeed([]),
    resolve: (directory) => Effect.succeed({ id: ProjectV2.ID.global, directory }),
    directories: () => Effect.succeed([]),
+    update: () => Effect.die("unused"),
    commit: () => Effect.void,
  }),
 )
@@ -660,4 +661,19 @@ describe("SessionV2.create", () => {
      ).toBe("Session.NotFoundError")
    }),
  )
+
+  it.effect("archives a Session through one durable event", () =>
+    Effect.gen(function* () {
+      const session = yield* SessionV2.Service
+      const created = yield* session.create({ location })
+
+      yield* session.archive(created.id)
+      yield* session.archive(created.id)
+
+      expect((yield* session.get(created.id)).time.archived).toBeDefined()
+      const events = Array.from(yield* logEvents(session, created.id).pipe(Stream.runCollect))
+      expect(events.map((event) => event.type)).toContain("session.archived")
+      expect(events.filter((event) => event.type === "session.archived")).toHaveLength(1)
+    }),
+  )
 })
@@ -57,6 +57,7 @@ const projects = Layer.succeed(
    list: () => Effect.succeed([]),
    resolve: (directory) => Effect.succeed({ id: ProjectV2.ID.global, directory }),
    directories: () => Effect.succeed([]),
+    update: () => Effect.die("unused"),
    commit: () => Effect.void,
  }),
 )
@@ -22,6 +22,7 @@ const projects = Layer.succeed(
    list: () => Effect.succeed([]),
    resolve: (directory) => Effect.succeed({ id: ProjectV2.ID.global, directory }),
    directories: () => Effect.succeed([]),
+    update: () => Effect.die("unused"),
    commit: () => Effect.void,
  }),
 )
@@ -19,6 +19,7 @@ const projects = Layer.succeed(
    list: () => Effect.succeed([]),
    resolve: (directory) => Effect.succeed({ id: ProjectV2.ID.global, directory }),
    directories: () => Effect.succeed([]),
+    update: () => Effect.die("unused"),
    commit: () => Effect.void,
  }),
 )
@@ -152,6 +152,7 @@ describeHg("Vcs mercurial", () => {
          await commitAll(directory, "initial")
        })
        const vcs = yield* Vcs.Service
+        expect(yield* vcs.info()).toEqual({ branch: "default", defaultBranch: "default" })
        expect(yield* vcs.diff("branch")).toEqual([])

        yield* Effect.promise(async () => {
@@ -53,6 +53,7 @@ describe("Vcs", () => {
    withTmp((directory) =>
      Effect.gen(function* () {
        const vcs = yield* Vcs.Service
+        expect(yield* vcs.info()).toEqual({})
        expect(yield* vcs.status()).toEqual([])
        expect(yield* vcs.diff("working")).toEqual([])
        expect(yield* vcs.diff("branch")).toEqual([])
@@ -155,6 +156,7 @@ describe("Vcs", () => {
          await commitAll(directory, "initial")
        })
        const vcs = yield* Vcs.Service
+        expect(yield* vcs.info()).toEqual({ branch: "main", defaultBranch: "main" })
        expect(yield* vcs.diff("branch")).toEqual([])

        yield* Effect.promise(async () => {
@@ -30,6 +30,7 @@ import { CredentialGroup } from "./groups/credential.js"
 import { ProjectGroup } from "./groups/project.js"
 import { ProjectCopyGroup } from "./groups/project-copy.js"
 import { VcsGroup } from "./groups/vcs.js"
+import { PathGroup } from "./groups/path.js"

 type LocationGroups<LocationId extends HttpApiMiddleware.AnyId> =
  | HttpApiGroup.AddMiddleware<typeof LocationGroup, LocationId>
@@ -50,6 +51,7 @@ type LocationGroups<LocationId extends HttpApiMiddleware.AnyId> =
  | HttpApiGroup.AddMiddleware<typeof ReferenceGroup, LocationId>
  | HttpApiGroup.AddMiddleware<typeof ProjectCopyGroup, LocationId>
  | HttpApiGroup.AddMiddleware<typeof VcsGroup, LocationId>
+  | HttpApiGroup.AddMiddleware<typeof PathGroup, LocationId>

 type SessionGroups<SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService> =
  | ReturnType<typeof makeSessionGroup<SessionLocationId, SessionLocationService>>
@@ -168,6 +170,7 @@ const makeApiFromGroup = <
    .add(ReferenceGroup.middleware(locationMiddleware))
    .add(ProjectCopyGroup.middleware(locationMiddleware))
    .add(VcsGroup.middleware(locationMiddleware))
+    .add(PathGroup.middleware(locationMiddleware))
    .add(DebugGroup)
    .annotateMerge(
      OpenApi.annotations({
@@ -60,7 +60,8 @@ export const groupNames = {
  "server.project": "project",
  "server.projectCopy": "projectCopy",
  "server.vcs": "vcs",
+  "server.path": "path",
 } as const

-export const promiseOmitEndpoints = new Set(["pty.connect", "pty.connectToken"])
-export const effectOmitEndpoints = new Set(["fs.read", "pty.connect", "pty.connectToken"])
+export const promiseOmitEndpoints = new Set(["pty.connect"])
+export const effectOmitEndpoints = new Set(["fs.read", "pty.connect"])
@@ -1,5 +1,6 @@
 import { Schema } from "effect"
 import { Skill } from "@opencode-ai/schema/skill"
+import { Project } from "@opencode-ai/schema/project"

 export class InvalidRequestError extends Schema.TaggedErrorClass<InvalidRequestError>()(
  "InvalidRequestError",
@@ -62,6 +63,15 @@ export class ProviderNotFoundError extends Schema.TaggedErrorClass<ProviderNotFo
  { httpApiStatus: 404 },
 ) {}

+export class ProjectNotFoundError extends Schema.TaggedErrorClass<ProjectNotFoundError>()(
+  "ProjectNotFoundError",
+  {
+    projectID: Project.ID,
+    message: Schema.String,
+  },
+  { httpApiStatus: 404 },
+) {}
+
 export class SessionNotFoundError extends Schema.TaggedErrorClass<SessionNotFoundError>()(
  "SessionNotFoundError",
  {
@@ -0,0 +1,20 @@
+import { Path } from "@opencode-ai/schema/path"
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
+import { LocationQuery, locationQueryOpenApi } from "./location.js"
+
+export const PathGroup = HttpApiGroup.make("server.path")
+  .add(
+    HttpApiEndpoint.get("path.get", "/api/path", {
+      query: LocationQuery,
+      success: Path.Info,
+    })
+      .annotateMerge(locationQueryOpenApi)
+      .annotateMerge(
+        OpenApi.annotations({
+          identifier: "v2.path.get",
+          summary: "Get paths",
+          description: "Get process and location paths.",
+        }),
+      ),
+  )
+  .annotateMerge(OpenApi.annotations({ title: "path", description: "Location and process paths." }))
@@ -2,6 +2,7 @@ import { Project } from "@opencode-ai/schema/project"
 import { Schema } from "effect"
 import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
 import { LocationQuery, locationQueryOpenApi } from "./location.js"
+import { ProjectNotFoundError } from "../errors.js"

 const root = "/api/project"

@@ -17,6 +18,20 @@ export const ProjectGroup = HttpApiGroup.make("server.project")
      }),
    ),
  )
+  .add(
+    HttpApiEndpoint.patch("project.update", `${root}/:projectID`, {
+      params: { projectID: Project.ID },
+      payload: Project.UpdateInput,
+      success: Project.Info,
+      error: ProjectNotFoundError,
+    }).annotateMerge(
+      OpenApi.annotations({
+        identifier: "v2.project.update",
+        summary: "Update project",
+        description: "Update project metadata.",
+      }),
+    ),
+  )
  .add(
    HttpApiEndpoint.get("project.current", `${root}/current`, {
      query: LocationQuery,
@@ -19,6 +19,20 @@ export function hasPtyConnectTicketURL(url: URL) {
 }

 export const PtyGroup = HttpApiGroup.make("server.pty")
+  .add(
+    HttpApiEndpoint.get("pty.shells", "/api/pty/shells", {
+      query: LocationQuery,
+      success: Location.response(Schema.Array(Pty.Shell)),
+    })
+      .annotateMerge(locationQueryOpenApi)
+      .annotateMerge(
+        OpenApi.annotations({
+          identifier: "v2.pty.shells",
+          summary: "List available shells",
+          description: "List shells available for interactive terminal sessions.",
+        }),
+      ),
+  )
  .add(
    HttpApiEndpoint.get("pty.list", "/api/pty", {
      query: LocationQuery,
@@ -101,13 +115,14 @@ export const PtyGroup = HttpApiGroup.make("server.pty")
    HttpApiEndpoint.post("pty.connectToken", "/api/pty/:ptyID/connect-token", {
      params: { ptyID: Pty.ID },
      query: LocationQuery,
+      headers: Schema.Struct({ [PTY_CONNECT_TOKEN_HEADER]: Schema.optional(Schema.String) }),
      success: Location.response(PtyTicket.ConnectToken),
      error: [ForbiddenError, PtyNotFoundError],
    })
      .annotateMerge(locationQueryOpenApi)
      .annotateMerge(
        OpenApi.annotations({
-          identifier: "v2.pty.connect.token",
+          identifier: "v2.pty.connectToken",
          summary: "Create PTY WebSocket token",
          description: "Create a short-lived single-use ticket for opening a PTY WebSocket connection.",
        }),
@@ -269,6 +269,21 @@ export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S>(sessionLo
          }),
        ),
    )
+    .add(
+      HttpApiEndpoint.post("session.archive", "/api/session/:sessionID/archive", {
+        params: { sessionID: Session.ID },
+        success: HttpApiSchema.NoContent,
+        error: SessionNotFoundError,
+      })
+        .middleware(sessionLocationMiddleware)
+        .annotateMerge(
+          OpenApi.annotations({
+            identifier: "v2.session.archive",
+            summary: "Archive session",
+            description: "Archive a session.",
+          }),
+        ),
+    )
    .add(
      HttpApiEndpoint.post("session.move", "/api/session/:sessionID/move", {
        params: { sessionID: Session.ID },
@@ -13,6 +13,20 @@ const DiffQuery = Schema.Struct({
 })

 export const VcsGroup = HttpApiGroup.make("server.vcs")
+  .add(
+    HttpApiEndpoint.get("vcs.get", "/api/vcs", {
+      query: LocationQuery,
+      success: Location.response(Vcs.Info),
+    })
+      .annotateMerge(locationQueryOpenApi)
+      .annotateMerge(
+        OpenApi.annotations({
+          identifier: "v2.vcs.get",
+          summary: "VCS information",
+          description: "Get the current and default branches for the requested location.",
+        }),
+      ),
+  )
  .add(
    HttpApiEndpoint.get("vcs.status", "/api/vcs/status", {
      query: LocationQuery,
@@ -16,6 +16,7 @@ export const Info = Schema.Struct({
  agent: Agent.ID.pipe(optional),
  model: Model.Ref.pipe(optional),
  subtask: Schema.Boolean.pipe(optional),
+  source: Schema.Literals(["command", "mcp"]).pipe(optional),
 }).annotate({ identifier: "Command.Info" })

 export const Event = {
@@ -14,6 +14,7 @@ export { Model } from "./model.js"
 export { Money } from "./money.js"
 export { Permission } from "./permission.js"
 export { PermissionSaved } from "./permission-saved.js"
+export { Path } from "./path.js"
 export { Project } from "./project.js"
 export { ProjectCopy } from "./project-copy.js"
 export { Provider } from "./provider.js"
@@ -0,0 +1,13 @@
+export * as Path from "./path.js"
+
+import { Schema } from "effect"
+import { AbsolutePath } from "./schema.js"
+
+export const Info = Schema.Struct({
+  home: AbsolutePath,
+  state: AbsolutePath,
+  config: AbsolutePath,
+  worktree: AbsolutePath,
+  directory: AbsolutePath,
+}).annotate({ identifier: "Path.Info" })
+export interface Info extends Schema.Schema.Type<typeof Info> {}
@@ -56,5 +56,12 @@ export const Info = Schema.Struct({
 }).annotate({ identifier: "Project" })
 export interface Info extends Schema.Schema.Type<typeof Info> {}

+export const UpdateInput = Schema.Struct({
+  name: optional(Schema.String),
+  icon: optional(Icon),
+  commands: optional(Commands),
+}).annotate({ identifier: "Project.UpdateInput" })
+export interface UpdateInput extends Schema.Schema.Type<typeof UpdateInput> {}
+
 const Updated = ephemeral({ type: "project.updated", schema: Info.fields })
 export const Event = { Updated, Definitions: inventory(Updated) }
@@ -56,3 +56,10 @@ export const UpdateInput = Schema.Struct({
  ),
 })
 export interface UpdateInput extends Schema.Schema.Type<typeof UpdateInput> {}
+
+export const Shell = Schema.Struct({
+  path: Schema.String,
+  name: Schema.String,
+  acceptable: Schema.Boolean,
+}).annotate({ identifier: "Pty.Shell" })
+export interface Shell extends Schema.Schema.Type<typeof Shell> {}
@@ -85,6 +85,13 @@ export const Renamed = Event.durable({
 })
 export type Renamed = typeof Renamed.Type

+export const Archived = Event.durable({
+  type: "session.archived",
+  ...options,
+  schema: Base,
+})
+export type Archived = typeof Archived.Type
+
 export const UsageRecorded = Event.durable({
  type: "session.usage.recorded",
  ...options,
@@ -539,6 +546,7 @@ export const Definitions = Event.inventory(
  ModelSelected,
  Moved,
  Renamed,
+  Archived,
  UsageUpdated,
  Deleted,
  Forked,
@@ -1,7 +1,7 @@
 export * as Vcs from "./vcs.js"

 import { Schema } from "effect"
-import { NonNegativeInt } from "./schema.js"
+import { NonNegativeInt, optional } from "./schema.js"

 export const Mode = Schema.Literals(["working", "branch"]).annotate({ identifier: "Vcs.Mode" })
 export type Mode = typeof Mode.Type
@@ -13,3 +13,9 @@ export const FileStatus = Schema.Struct({
  status: Schema.Literals(["added", "deleted", "modified"]),
 }).annotate({ identifier: "Vcs.FileStatus" })
 export interface FileStatus extends Schema.Schema.Type<typeof FileStatus> {}
+
+export const Info = Schema.Struct({
+  branch: optional(Schema.String),
+  defaultBranch: optional(Schema.String),
+}).annotate({ identifier: "Vcs.Info" })
+export interface Info extends Schema.Schema.Type<typeof Info> {}
@@ -104,6 +104,7 @@ describe("public event manifest", () => {
        "session.model.selected.1",
        "session.moved.1",
        "session.renamed.1",
+        "session.archived.1",
        "session.usage.recorded.1",
        "session.forked.2",
        "session.input.promoted.1",
@@ -26,6 +26,7 @@ import { CredentialHandler } from "./handlers/credential"
 import { ProjectHandler } from "./handlers/project"
 import { ProjectCopyHandler } from "./handlers/project-copy"
 import { VcsHandler } from "./handlers/vcs"
+import { PathHandler } from "./handlers/path"
 import { EventFeed } from "./event-feed"

 export const handlers = Layer.mergeAll(
@@ -56,4 +57,5 @@ export const handlers = Layer.mergeAll(
  ReferenceHandler,
  ProjectCopyHandler,
  VcsHandler,
+  PathHandler,
 )
@@ -0,0 +1,22 @@
+import { Location } from "@opencode-ai/core/location"
+import { AbsolutePath } from "@opencode-ai/core/schema"
+import { Global } from "@opencode-ai/util/global"
+import { Effect } from "effect"
+import { HttpApiBuilder } from "effect/unstable/httpapi"
+import { Api } from "../api"
+
+export const PathHandler = HttpApiBuilder.group(Api, "server.path", (handlers) =>
+  handlers.handle("path.get", () =>
+    Effect.gen(function* () {
+      const global = yield* Global.Service
+      const location = yield* Location.Service
+      return {
+        home: AbsolutePath.make(global.home),
+        state: AbsolutePath.make(global.state),
+        config: AbsolutePath.make(global.config),
+        worktree: location.project.directory,
+        directory: location.directory,
+      }
+    }),
+  ),
+)
@@ -3,10 +3,26 @@ import { Project } from "@opencode-ai/core/project"
 import { Effect } from "effect"
 import { HttpApiBuilder } from "effect/unstable/httpapi"
 import { Api } from "../api"
+import { ProjectNotFoundError } from "@opencode-ai/protocol/errors"

 export const ProjectHandler = HttpApiBuilder.group(Api, "server.project", (handlers) =>
  handlers
    .handle("project.list", () => Project.Service.use((project) => project.list()))
+    .handle("project.update", (ctx) =>
+      Effect.gen(function* () {
+        const project = yield* Project.Service
+        return yield* project.update(ctx.params.projectID, ctx.payload).pipe(
+          Effect.catchTag(
+            "Project.NotFoundError",
+            () =>
+              new ProjectNotFoundError({
+                projectID: ctx.params.projectID,
+                message: `Project not found: ${ctx.params.projectID}`,
+              }),
+          ),
+        )
+      }),
+    )
    .handle("project.current", () =>
      Location.Service.use((location) =>
        Effect.succeed({ id: location.project.id, directory: location.project.directory }),
@@ -29,6 +29,13 @@ export const PtyHandler = HttpApiBuilder.group(Api, "server.pty", (handlers) =>
    const environment = yield* PtyEnvironment.Service

    return handlers
+      .handle(
+        "pty.shells",
+        Effect.fn(function* () {
+          const pty = yield* Pty.Service
+          return yield* response(pty.shells())
+        }),
+      )
      .handle(
        "pty.list",
        Effect.fn(function* () {
@@ -201,6 +201,22 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
          return HttpApiSchema.NoContent.make()
        }),
      )
+      .handle(
+        "session.archive",
+        Effect.fn(function* (ctx) {
+          yield* session.archive(ctx.params.sessionID).pipe(
+            Effect.catchTag("Session.NotFoundError", (error) =>
+              Effect.fail(
+                new SessionNotFoundError({
+                  sessionID: error.sessionID,
+                  message: `Session not found: ${error.sessionID}`,
+                }),
+              ),
+            ),
+          )
+          return HttpApiSchema.NoContent.make()
+        }),
+      )
      .handle(
        "session.move",
        Effect.fn(function* (ctx) {
@@ -7,6 +7,14 @@ import { response } from "../location"
 export const VcsHandler = HttpApiBuilder.group(Api, "server.vcs", (handlers) =>
  Effect.gen(function* () {
    return handlers
+      .handle("vcs.get", () =>
+        response(
+          Effect.gen(function* () {
+            const vcs = yield* Vcs.Service
+            return yield* vcs.info()
+          }),
+        ),
+      )
      .handle("vcs.status", () =>
        response(
          Effect.gen(function* () {
@@ -60,6 +60,7 @@ const applicationServices = LayerNode.group([
  WellKnown.node,
  PtyEnvironment.node,
  LocationServiceMap.node,
+  Global.node,
  SessionRestart.node,
 ])

@@ -134,7 +135,9 @@ function makeRoutes<AuthError, AuthServices>(
    Layer.flatMap((context) => {
      const services = Layer.succeedContext(context)
      const requestServices = Layer.merge(
-        Layer.succeedContext(Context.pick(PermissionSaved.Service, Project.Service, WellKnown.Service)(context)),
+        Layer.succeedContext(
+          Context.pick(Global.Service, PermissionSaved.Service, Project.Service, WellKnown.Service)(context),
+        ),
        ServerInfo.layer(serviceURLs, options.app),
      )
      return HttpApiBuilder.layer(Api, { openapiPath: "/openapi.json" }).pipe(
Author	SHA1	Message	Date
Brendan Allan	62c47f467f	chore(client): regenerate project API	2026-07-23 12:06:18 +08:00
Brendan Allan	639a5fe5b1	test(project): update session project mock	2026-07-23 12:06:02 +08:00
Brendan Allan	9afd059fa1	feat(project): support project metadata updates	2026-07-23 12:05:51 +08:00
Brendan Allan	6bbf50b940	chore(client): regenerate session API	2026-07-23 12:05:43 +08:00
Brendan Allan	ba2dc65d6b	fix(session): keep archival project mock valid	2026-07-23 12:05:41 +08:00
Brendan Allan	08e616bcad	feat(session): add durable session archival	2026-07-23 12:05:31 +08:00
Brendan Allan	a6761d4fe0	chore(client): regenerate VCS API	2026-07-23 12:05:24 +08:00
Brendan Allan	305466e5ef	feat(vcs): expose repository branch metadata	2026-07-23 12:05:12 +08:00
Brendan Allan	704e9ff3fb	chore(client): regenerate PTY API	2026-07-23 12:05:05 +08:00
Brendan Allan	dbe7b937ef	feat(pty): expose shells and connect tokens	2026-07-23 12:04:43 +08:00
Brendan Allan	9de001d92f	chore(client): regenerate command API	2026-07-23 12:04:37 +08:00
Brendan Allan	3cd894d40a	feat(command): identify command sources	2026-07-23 12:04:35 +08:00
Brendan Allan	0e705e2a05	chore(client): regenerate path API	2026-07-23 12:04:25 +08:00
Brendan Allan	421d649019	fix(protocol): name path client group	2026-07-23 12:04:06 +08:00
Brendan Allan	a7855aa169	feat(server): expose location paths	2026-07-23 12:03:46 +08:00