@@ -1,9 +1,10 @@
 import { LayerNode } from "@opencode-ai/core/effect/layer-node"
-import { and, eq, sql } from "drizzle-orm"
+import { and, eq, inArray, sql } from "drizzle-orm"
 import { Database } from "@opencode-ai/core/database/database"
 import { ProjectDirectoryTable, ProjectTable } from "@opencode-ai/core/project/sql"
 import { ProjectDirectories } from "@opencode-ai/core/project/directories"
-import { SessionTable } from "@opencode-ai/core/session/sql"
+import { MessageTable, PartTable, SessionTable, TodoTable } from "@opencode-ai/core/session/sql"
+import { EventTable } from "@opencode-ai/core/event/sql"
 import { WorkspaceTable } from "@opencode-ai/core/control-plane/workspace.sql"
 import { Flag } from "@opencode-ai/core/flag/flag"
 import { GlobalBus } from "@/bus/global"
@@ -63,6 +64,8 @@ export const UpdateInput = Schema.Struct({
   name: Schema.optional(Schema.String),
   icon: Schema.optional(Project.Icon),
   commands: Schema.optional(Project.Commands),
+  /** new absolute location for an existing worktree; relocates stored history */
+  worktree: Schema.optional(Schema.String),
 })
 export type UpdateInput = Types.DeepMutable<Schema.Schema.Type<typeof UpdateInput>>
 
@@ -93,6 +96,10 @@ export interface Interface {
   readonly list: () => Effect.Effect<Info[]>
   readonly get: (id: ProjectV2.ID) => Effect.Effect<Info | undefined>
   readonly update: (input: UpdateInput) => Effect.Effect<Info, NotFoundError>
+  readonly remove: (input: {
+    projectID: ProjectV2.ID
+    mode: "cascade" | "detach"
+  }) => Effect.Effect<void, NotFoundError>
   readonly initGit: (input: { directory: string; project: Info }) => Effect.Effect<Info>
   readonly setInitialized: (id: ProjectV2.ID) => Effect.Effect<void>
   readonly sandboxes: (id: ProjectV2.ID) => Effect.Effect<string[]>
@@ -375,9 +382,35 @@ const layer = Layer.effect(
     })
 
     const update = Effect.fn("Project.update")(function* (input: UpdateInput) {
+      const current = yield* db
+        .select()
+        .from(ProjectTable)
+        .where(eq(ProjectTable.id, input.projectID))
+        .get()
+        .pipe(Effect.orDie)
+      if (!current) return yield* new NotFoundError({ projectID: input.projectID })
+
+      let worktree = current.worktree
+      if (input.worktree && input.worktree !== current.worktree) {
+        const next = AbsolutePath.make(input.worktree)
+        if (!(yield* fs.exists(next).pipe(Effect.orDie))) {
+          return yield* new NotFoundError({ projectID: input.projectID })
+        }
+        // history follows the folder: migrate every stored reference (#23248, #34737)
+        yield* Relocation.relocateProjectData({ from: current.worktree, to: next }).pipe(
+          Effect.catchAllCause((cause) =>
+            Effect.logError("project history relocation failed", { cause, projectID: input.projectID }).pipe(
+              Effect.asVoid,
+            ),
+          ),
+        )
+        worktree = next
+      }
+
       const result = yield* db
         .update(ProjectTable)
         .set({
+          worktree,
           name: input.name,
           icon_url: input.icon?.url,
           icon_url_override: input.icon?.override,
@@ -406,6 +439,45 @@ const layer = Layer.effect(
       return project
     })
 
+    const remove = Effect.fn("Project.remove")(function* (input: {
+      projectID: ProjectV2.ID
+      mode: "cascade" | "detach"
+    }) {
+      if (input.projectID === ProjectV2.ID.make("global")) {
+        return yield* new NotFoundError({ projectID: input.projectID })
+      }
+      const row = yield* db
+        .select()
+        .from(ProjectTable)
+        .where(eq(ProjectTable.id, input.projectID))
+        .get()
+        .pipe(Effect.orDie)
+      if (!row) return yield* new NotFoundError({ projectID: input.projectID })
+
+      const sessionRows = yield* db
+        .select({ id: SessionTable.id })
+        .from(SessionTable)
+        .where(eq(SessionTable.project_id, input.projectID))
+        .all()
+        .pipe(Effect.orDie)
+      const ids = sessionRows.map((r) => r.id)
+
+      yield* db.transaction((tx) =>
+        Effect.gen(function* () {
+          // messages/parts/todos cascade from session rows; events do not
+          for (let i = 0; i < ids.length; i += 400) {
+            const chunk = ids.slice(i, i + 400)
+            yield* tx.delete(EventTable).where(inArray(EventTable.aggregate_id, chunk)).run().pipe(Effect.orDie)
+          }
+          if (input.mode === "cascade") {
+            yield* tx.delete(SessionTable).where(eq(SessionTable.project_id, input.projectID)).run().pipe(Effect.orDie)
+          }
+          yield* tx.delete(ProjectDirectoryTable).where(eq(ProjectDirectoryTable.project_id, input.projectID)).run().pipe(Effect.orDie)
+          yield* tx.delete(ProjectTable).where(eq(ProjectTable.id, input.projectID)).run().pipe(Effect.orDie)
+        }),
+      )
+    })
+
     const setInitialized = Effect.fn("Project.setInitialized")(function* (id: ProjectV2.ID) {
       yield* db
         .update(ProjectTable)
@@ -486,6 +558,7 @@ const layer = Layer.effect(
       list,
       get,
       update,
+      remove,
       initGit,
       setInitialized,
       sandboxes,
 
@@ -11,6 +11,7 @@ import { described } from "./metadata"
 const root = "/project"
 const UpdatePayload = Schema.Struct({
   name: Schema.optional(Schema.String),
+  worktree: Schema.optional(Schema.String),
   icon: Schema.optional(Project.Info.fields.icon),
   commands: Schema.optional(Project.Info.fields.commands),
 })
@@ -62,6 +63,19 @@ export const ProjectApi = HttpApi.make("project")
             description: "Update project properties such as name, icon, and commands.",
           }),
         ),
+        HttpApiEndpoint.del("remove", `${root}/:projectID`, {
+          params: { projectID: ProjectV2.ID },
+          query: WorkspaceRoutingQuery,
+          payload: Schema.Struct({ mode: Schema.optional(Schema.Literals(["cascade", "detach"])) }),
+          success: described(Schema.Void, "Deletion result"),
+          error: [HttpApiError.BadRequest, ProjectNotFoundError],
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "project.remove",
+            summary: "Delete a project",
+            description: "Remove a registered project. mode=cascade also deletes every session and its history.",
+          }),
+        ),
         HttpApiEndpoint.get("directories", `${root}/:projectID/directories`, {
           params: { projectID: ProjectV2.ID },
           query: WorkspaceRoutingQuery,
 
@@ -53,11 +53,26 @@ export const projectHandlers = HttpApiBuilder.group(InstanceHttpApi, "project",
       project.directories({ projectID: ctx.params.projectID }),
     )
 
+    const remove = Effect.fn("ProjectHttpApi.remove")(function* (ctx: {
+      params: { projectID: ProjectV2.ID }
+      payload: { mode?: "cascade" | "detach" }
+    }) {
+      return yield* svc
+        .remove({ projectID: ctx.params.projectID, mode: ctx.payload.mode ?? "cascade" })
+        .pipe(
+          Effect.catchTag("Project.NotFoundError", (error) =>
+            Effect.fail(new ProjectNotFoundError({ projectID: error.projectID })),
+          ),
+          Effect.asVoid,
+        )
+    })
+
     return handlers
       .handle("list", list)
       .handle("current", current)
       .handle("initGit", initGit)
       .handle("update", update)
       .handle("directories", directories)
+      .handle("remove", remove)
   }),
 )