@akira-tl/forgerelay 0.8.1 → 0.8.3

package/dist/workspace-store.js

@@ -90,6 +90,31 @@ export class SqliteWorkspaceStore {
             .where(eq(workspaceSessions.id, sessionId))
             .run();
     }
+    replaceWorktreeBacking(input) {
+        const sessionId = this.resolveSessionId(input.id);
+        if (!sessionId)
+            throw new Error(`Unknown workspace session: ${input.id}`);
+        this.pendingSessionTouches.delete(sessionId);
+        const row = this.database.db
+            .update(workspaceSessions)
+            .set({
+            root: input.root,
+            status: "active",
+            sourceRoot: input.sourceRoot,
+            baseRef: input.baseRef,
+            baseSha: input.baseSha,
+            branch: input.branch,
+            targetBranch: input.targetBranch,
+            managed: "true",
+            lastUsedAt: this.now().toISOString(),
+        })
+            .where(eq(workspaceSessions.id, sessionId))
+            .returning()
+            .get();
+        if (!row)
+            throw new Error(`Unknown workspace session: ${input.id}`);
+        return rowToWorkspaceSession(row);
+    }
     listSessions(input = {}) {
         const conditions = [
             input.status ? eq(workspaceSessions.status, input.status) : undefined,

package/dist/workspace-tasks.js

@@ -0,0 +1,351 @@
+import { createHash, randomBytes } from "node:crypto";
+import { mkdirSync, readFileSync, renameSync, rmSync, rmdirSync, writeFileSync, } from "node:fs";
+import { join } from "node:path";
+import * as z from "zod/v4";
+const TASK_STATE_VERSION = 1;
+const MAX_TASK_STATE_BYTES = 2 * 1024 * 1024;
+const MAX_TASK_LISTS = 100;
+const MAX_TASKS_PER_LIST = 500;
+const MAX_LIST_NAME_LENGTH = 120;
+const MAX_TASK_SUBJECT_LENGTH = 240;
+const MAX_TASK_CONTENT_LENGTH = 64 * 1024;
+const workspaceTaskSchema = z.object({
+    id: z.string().regex(/^tsk_[a-f0-9]{10}$/),
+    status: z.enum(["pending", "in_progress", "completed"]),
+    subject: z.string().min(1).max(MAX_TASK_SUBJECT_LENGTH),
+    content: z.string().max(MAX_TASK_CONTENT_LENGTH),
+}).strict();
+const workspaceTaskListSchema = z.object({
+    id: z.string().regex(/^tl_[a-f0-9]{10}$/),
+    name: z.string().min(1).max(MAX_LIST_NAME_LENGTH),
+    state: z.enum(["active", "archived"]),
+    revision: z.number().int().positive(),
+    tasks: z.array(workspaceTaskSchema).max(MAX_TASKS_PER_LIST),
+}).strict();
+const workspaceTaskStateSchema = z.object({
+    version: z.literal(TASK_STATE_VERSION),
+    revision: z.number().int().nonnegative(),
+    lists: z.array(workspaceTaskListSchema).max(MAX_TASK_LISTS),
+}).strict().superRefine((state, context) => {
+    const listIds = new Set();
+    const taskIds = new Set();
+    state.lists.forEach((list, listIndex) => {
+        if (listIds.has(list.id)) {
+            context.addIssue({
+                code: "custom",
+                path: ["lists", listIndex, "id"],
+                message: `Duplicate Task List id ${list.id}.`,
+            });
+        }
+        listIds.add(list.id);
+        list.tasks.forEach((task, taskIndex) => {
+            if (taskIds.has(task.id)) {
+                context.addIssue({
+                    code: "custom",
+                    path: ["lists", listIndex, "tasks", taskIndex, "id"],
+                    message: `Duplicate Task id ${task.id}.`,
+                });
+            }
+            taskIds.add(task.id);
+        });
+    });
+});
+export class WorkspaceTaskStore {
+    stateDir;
+    constructor(stateDir) {
+        this.stateDir = stateDir;
+    }
+    ensureWorkspace(workspaceId) {
+        const id = normalizeWorkspaceId(workspaceId);
+        const loaded = this.tryReadState(id);
+        if (loaded)
+            return snapshot(loaded.state, loaded.fingerprint);
+        return this.writeState(id, emptyState());
+    }
+    initializeWorkspace(workspaceId) {
+        const id = normalizeWorkspaceId(workspaceId);
+        const directory = this.workspaceStateDir(id);
+        mkdirSync(directory, { recursive: true, mode: 0o700 });
+        try {
+            writeFileSync(this.statePath(id), `${JSON.stringify(emptyState(), null, 2)}\n`, {
+                mode: 0o600,
+                flag: "wx",
+            });
+        }
+        catch (error) {
+            if (!isErrno(error, "EEXIST"))
+                throw error;
+        }
+    }
+    read(workspaceId) {
+        return this.ensureWorkspace(workspaceId);
+    }
+    createList(workspaceId, input) {
+        return this.mutate(workspaceId, (state) => {
+            if (state.lists.length >= MAX_TASK_LISTS) {
+                throw new Error(`Workspace Task List limit is ${MAX_TASK_LISTS}.`);
+            }
+            const list = {
+                id: `tl_${randomBytes(5).toString("hex")}`,
+                name: normalizeListName(input.name),
+                state: "active",
+                revision: 1,
+                tasks: [],
+            };
+            const position = normalizeInsertPosition(input.position, state.lists.length, "Task List");
+            state.lists.splice(position, 0, list);
+            return true;
+        });
+    }
+    updateList(workspaceId, listId, input) {
+        return this.mutate(workspaceId, (state) => {
+            const index = requireListIndex(state, listId);
+            const list = state.lists[index];
+            const nextName = input.name === undefined ? list.name : normalizeListName(input.name);
+            const nextState = input.state ?? list.state;
+            const nextPosition = input.position === undefined
+                ? index
+                : normalizeMovePosition(input.position, state.lists.length, "Task List");
+            const metadataChanged = nextName !== list.name || nextState !== list.state;
+            const positionChanged = nextPosition !== index;
+            if (!metadataChanged && !positionChanged)
+                return false;
+            list.name = nextName;
+            list.state = nextState;
+            list.revision += 1;
+            if (positionChanged)
+                moveArrayEntry(state.lists, index, nextPosition);
+            return true;
+        });
+    }
+    deleteList(workspaceId, listId) {
+        return this.mutate(workspaceId, (state) => {
+            state.lists.splice(requireListIndex(state, listId), 1);
+            return true;
+        });
+    }
+    createTask(workspaceId, listId, input) {
+        return this.mutate(workspaceId, (state) => {
+            const list = requireList(state, listId);
+            if (list.tasks.length >= MAX_TASKS_PER_LIST) {
+                throw new Error(`Task limit per Task List is ${MAX_TASKS_PER_LIST}.`);
+            }
+            const task = {
+                id: `tsk_${randomBytes(5).toString("hex")}`,
+                status: input.status ?? "pending",
+                subject: normalizeTaskSubject(input.subject),
+                content: normalizeTaskContent(input.content ?? ""),
+            };
+            const position = normalizeInsertPosition(input.position, list.tasks.length, "Task");
+            list.tasks.splice(position, 0, task);
+            list.revision += 1;
+            return true;
+        });
+    }
+    updateTask(workspaceId, listId, taskId, input) {
+        return this.mutate(workspaceId, (state) => {
+            const list = requireList(state, listId);
+            const index = requireTaskIndex(list, taskId);
+            const task = list.tasks[index];
+            const nextStatus = input.status ?? task.status;
+            const nextSubject = input.subject === undefined ? task.subject : normalizeTaskSubject(input.subject);
+            const nextContent = input.content === undefined ? task.content : normalizeTaskContent(input.content);
+            const nextPosition = input.position === undefined
+                ? index
+                : normalizeMovePosition(input.position, list.tasks.length, "Task");
+            const fieldsChanged = nextStatus !== task.status || nextSubject !== task.subject || nextContent !== task.content;
+            const positionChanged = nextPosition !== index;
+            if (!fieldsChanged && !positionChanged)
+                return false;
+            task.status = nextStatus;
+            task.subject = nextSubject;
+            task.content = nextContent;
+            if (positionChanged)
+                moveArrayEntry(list.tasks, index, nextPosition);
+            list.revision += 1;
+            return true;
+        });
+    }
+    deleteTask(workspaceId, listId, taskId) {
+        return this.mutate(workspaceId, (state) => {
+            const list = requireList(state, listId);
+            list.tasks.splice(requireTaskIndex(list, taskId), 1);
+            list.revision += 1;
+            return true;
+        });
+    }
+    deleteWorkspace(workspaceId) {
+        const id = normalizeWorkspaceId(workspaceId);
+        rmSync(this.statePath(id), { force: true });
+        try {
+            rmdirSync(this.workspaceStateDir(id));
+        }
+        catch (error) {
+            if (!isErrno(error, "ENOENT") && !isErrno(error, "ENOTEMPTY") && !isErrno(error, "EEXIST")) {
+                throw error;
+            }
+        }
+    }
+    mutate(workspaceId, mutateState) {
+        const id = normalizeWorkspaceId(workspaceId);
+        const loaded = this.tryReadState(id);
+        const state = loaded ? cloneState(loaded.state) : emptyState();
+        if (!mutateState(state)) {
+            return loaded
+                ? snapshot(loaded.state, loaded.fingerprint)
+                : this.writeState(id, state);
+        }
+        state.revision += 1;
+        return this.writeState(id, state);
+    }
+    tryReadState(workspaceId) {
+        const path = this.statePath(workspaceId);
+        let raw;
+        try {
+            raw = readFileSync(path);
+        }
+        catch (error) {
+            if (isErrno(error, "ENOENT"))
+                return undefined;
+            throw error;
+        }
+        if (raw.byteLength > MAX_TASK_STATE_BYTES) {
+            throw new Error(`Workspace Task state exceeds ${MAX_TASK_STATE_BYTES} bytes.`);
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw.toString("utf8"));
+        }
+        catch (error) {
+            throw new Error(`Workspace Task state is not valid JSON: ${errorMessage(error)}`);
+        }
+        const validated = workspaceTaskStateSchema.safeParse(parsed);
+        if (!validated.success) {
+            const details = validated.error.issues
+                .map((issue) => `${issue.path.length > 0 ? issue.path.join(".") : "state"}: ${issue.message}`)
+                .join("; ");
+            throw new Error(`Workspace Task state has an unsupported or invalid format: ${details}`);
+        }
+        return {
+            state: cloneState(validated.data),
+            fingerprint: fingerprint(raw),
+        };
+    }
+    writeState(workspaceId, state) {
+        const workspaceDir = this.workspaceStateDir(workspaceId);
+        mkdirSync(workspaceDir, { recursive: true, mode: 0o700 });
+        const validated = workspaceTaskStateSchema.parse(state);
+        const serialized = `${JSON.stringify(validated, null, 2)}\n`;
+        if (Buffer.byteLength(serialized, "utf8") > MAX_TASK_STATE_BYTES) {
+            throw new Error(`Workspace Task state exceeds ${MAX_TASK_STATE_BYTES} bytes.`);
+        }
+        const statePath = this.statePath(workspaceId);
+        const tempPath = `${statePath}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+        try {
+            writeFileSync(tempPath, serialized, { mode: 0o600 });
+            renameSync(tempPath, statePath);
+        }
+        finally {
+            rmSync(tempPath, { force: true });
+        }
+        return snapshot(validated, fingerprint(Buffer.from(serialized, "utf8")));
+    }
+    workspaceStateDir(workspaceId) {
+        return join(this.stateDir, "workspaces", workspaceId);
+    }
+    statePath(workspaceId) {
+        return join(this.workspaceStateDir(workspaceId), "tasks.json");
+    }
+}
+function emptyState() {
+    return { version: TASK_STATE_VERSION, revision: 0, lists: [] };
+}
+function snapshot(state, stateFingerprint) {
+    return {
+        ...cloneState(state),
+        fingerprint: stateFingerprint,
+    };
+}
+function cloneState(state) {
+    return {
+        version: state.version,
+        revision: state.revision,
+        lists: state.lists.map((list) => ({
+            ...list,
+            tasks: list.tasks.map((task) => ({ ...task })),
+        })),
+    };
+}
+function requireList(state, listId) {
+    return state.lists[requireListIndex(state, listId)];
+}
+function requireListIndex(state, listId) {
+    const index = state.lists.findIndex((list) => list.id === listId);
+    if (index < 0)
+        throw new Error(`Unknown Task List ${listId}.`);
+    return index;
+}
+function requireTaskIndex(list, taskId) {
+    const index = list.tasks.findIndex((task) => task.id === taskId);
+    if (index < 0)
+        throw new Error(`Task List ${list.id} has no Task ${taskId}.`);
+    return index;
+}
+function normalizeWorkspaceId(workspaceId) {
+    const value = workspaceId.trim();
+    if (!/^[a-z][a-z0-9_-]{1,127}$/.test(value)) {
+        throw new Error("Workspace ID is not valid for Workspace Task state.");
+    }
+    return value;
+}
+function normalizeListName(name) {
+    const value = name.trim();
+    if (!value)
+        throw new Error("Task List name must not be empty.");
+    if (value.length > MAX_LIST_NAME_LENGTH) {
+        throw new Error(`Task List name must be at most ${MAX_LIST_NAME_LENGTH} characters.`);
+    }
+    return value;
+}
+function normalizeTaskSubject(subject) {
+    const value = subject.trim();
+    if (!value)
+        throw new Error("Task subject must not be empty.");
+    if (value.length > MAX_TASK_SUBJECT_LENGTH) {
+        throw new Error(`Task subject must be at most ${MAX_TASK_SUBJECT_LENGTH} characters.`);
+    }
+    return value;
+}
+function normalizeTaskContent(content) {
+    if (content.length > MAX_TASK_CONTENT_LENGTH) {
+        throw new Error(`Task content must be at most ${MAX_TASK_CONTENT_LENGTH} characters.`);
+    }
+    return content;
+}
+function normalizeInsertPosition(position, length, label) {
+    if (position === undefined)
+        return length;
+    if (!Number.isInteger(position) || position < 0 || position > length) {
+        throw new Error(`${label} position must be an integer between 0 and ${length}.`);
+    }
+    return position;
+}
+function normalizeMovePosition(position, length, label) {
+    if (!Number.isInteger(position) || position < 0 || position >= length) {
+        throw new Error(`${label} position must be an integer between 0 and ${Math.max(0, length - 1)}.`);
+    }
+    return position;
+}
+function moveArrayEntry(values, from, to) {
+    const [value] = values.splice(from, 1);
+    values.splice(to, 0, value);
+}
+function fingerprint(content) {
+    return createHash("sha256").update(content).digest("hex");
+}
+function isErrno(error, code) {
+    return error instanceof Error && "code" in error && error.code === code;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/workspaces.js

@@ -5,7 +5,7 @@ import { tmpdir } from "node:os";
 import { basename, dirname, join, relative, resolve, sep } from "node:path";
 import { loadCapabilityGuides, markCapabilityGuideActivated, resolveCapabilityGuideReadPath, } from "./capabilities.js";
 import { HookRunner } from "./hooks.js";
-import { closeManagedWorktree, createManagedWorktree, resolveManagedWorktreeBase, } from "./git-worktrees.js";
+import { closeManagedWorktree, createManagedWorktree, discardFreshManagedWorktree, resolveManagedWorktreeBase, } from "./git-worktrees.js";
 import { AccessDeniedError, assertAllowedPath, isPathInsideRoot, resolveAllowedPath, } from "./roots.js";
 import { loadWorkspaceSkills, markSkillActivated, resolveSkillReadPath, } from "./skills.js";
 import { loadSubagentProfiles, } from "./subagents/profiles.js";
@@ -152,8 +152,11 @@ export class WorkspaceRegistry {
         };
     }
     async resumeWorkspace(workspaceId, conversationScopeId, bootstrapContext = "auto") {
-        const workspace = this.workspaceForOpen(workspaceId);
-        const context = await this.reusedWorkspaceContext(workspace);
+        const session = this.store?.getSession(workspaceId);
+        const context = session?.status === "closed" && session.mode === "worktree"
+            ? await this.reopenClosedManagedWorktreeContext(session)
+            : await this.reusedWorkspaceContext(await this.workspaceForOpen(workspaceId));
+        const workspace = context.workspace;
         if (!conversationScopeId || !this.store) {
             return {
                 ...context,
@@ -222,8 +225,8 @@ export class WorkspaceRegistry {
     }
     deleteWorkspace(workspaceId) {
         const session = this.getWorkspaceSession(workspaceId);
-        if (session.mode !== "checkout") {
-            throw new Error(`Workspace ${session.id} is not a checkout Workspace. Delete semantics for ${session.mode} Workspaces are handled by their own lifecycle.`);
+        if (session.mode === "worktree" && session.status === "active") {
+            throw new Error(`Workspace ${session.id} is an active managed-worktree Workspace. Finalize it safely before deleting its persistent identity.`);
         }
         this.deleteConversationBindingsForWorkspace(session.id);
         this.store?.deleteSession(session.id);
@@ -327,6 +330,7 @@ export class WorkspaceRegistry {
             },
         }));
         for (const aliasedWorkspaceId of aliasedWorkspaceIds) {
+            this.deleteConversationBindingsForWorkspace(aliasedWorkspaceId);
             this.store?.setSessionStatus(aliasedWorkspaceId, "closed");
             this.workspaces.delete(aliasedWorkspaceId);
         }
@@ -386,10 +390,8 @@ export class WorkspaceRegistry {
         if (boundContext)
             return boundContext;
         const context = await this.openOnce(targetKey, async () => {
-            const reusableWorkspace = await this.findReusableWorktreeBySource(sourceKey, resolvedBase.targetBranch);
-            if (!reusableWorkspace)
-                return this.openWorktreeWorkspace(path, input.baseRef);
-            return this.reusedWorkspaceContext(reusableWorkspace);
+            const reusableContext = await this.findReusableWorktreeContextBySource(sourceKey, resolvedBase.targetBranch);
+            return reusableContext ?? this.openWorktreeWorkspace(path, input.baseRef);
         });
         return this.withConversationContext(context, conversationScopeId, targetKey, bootstrapContext);
     }
@@ -576,16 +578,30 @@ export class WorkspaceRegistry {
         }
         return undefined;
     }
-    async findReusableWorktreeBySource(sourceKey, targetBranch) {
-        for (const session of this.activeSessions("worktree")) {
+    async findReusableWorktreeContextBySource(sourceKey, targetBranch) {
+        const sessions = this.store
+            ? this.store.listSessions({ mode: "worktree" })
+            : this.activeSessions("worktree");
+        const closedMatches = [];
+        for (const session of sessions) {
             if (!session.sourceRoot || session.targetBranch !== targetBranch)
                 continue;
             if (await canonicalPath(session.sourceRoot) !== sourceKey)
                 continue;
+            if (session.status === "closed") {
+                if (session.managed)
+                    closedMatches.push(session);
+                continue;
+            }
+            if (session.status !== "active")
+                continue;
             const root = await this.validSessionRoot(session);
             if (!root)
                 continue;
-            return this.workspaceFromSession(session, false);
+            return this.reusedWorkspaceContext(this.workspaceFromSession(session, false));
+        }
+        if (closedMatches.length === 1) {
+            return this.reopenClosedManagedWorktreeContext(closedMatches[0]);
         }
         return undefined;
     }
@@ -654,7 +670,7 @@ export class WorkspaceRegistry {
             includeBootstrapContext: true,
         };
     }
-    workspaceForOpen(workspaceId) {
+    async workspaceForOpen(workspaceId) {
         const session = this.store?.getSession(workspaceId);
         if (session?.status === "closed" && session.mode === "checkout") {
             this.store?.setSessionStatus(session.id, "active");
@@ -666,6 +682,72 @@ export class WorkspaceRegistry {
         }
         return this.getWorkspace(workspaceId);
     }
+    async reopenClosedManagedWorktreeContext(session) {
+        const operationKey = JSON.stringify(["worktree-reopen", session.id]);
+        return this.openOnce(operationKey, async () => {
+            const current = this.store?.getSession(session.id);
+            if (!current) {
+                throw new Error(`Unknown workspaceId: ${session.id}. Call open_workspace first.`);
+            }
+            if (current.status === "active") {
+                return this.reusedWorkspaceContext(this.getWorkspace(current.id));
+            }
+            if (current.status !== "closed" || current.mode !== "worktree") {
+                throw new Error(`Workspace ${current.id} is not a closed managed-worktree Workspace.`);
+            }
+            return this.reopenClosedManagedWorktreeContextUnlocked(current);
+        });
+    }
+    async reopenClosedManagedWorktreeContextUnlocked(session) {
+        if (!this.store) {
+            throw new Error(`Workspace ${session.id} cannot be reopened without persistent Workspace state.`);
+        }
+        if (!session.managed || !session.sourceRoot || !session.targetBranch) {
+            throw new Error(`Workspace ${session.id} does not have enough managed-worktree metadata to recreate its execution backing.`);
+        }
+        const worktree = await createManagedWorktree({
+            sourcePath: session.sourceRoot,
+            baseRef: session.targetBranch,
+            config: this.config,
+        });
+        const candidateSession = {
+            ...session,
+            root: worktree.path,
+            status: "active",
+            sourceRoot: worktree.sourceRoot,
+            baseRef: worktree.baseRef,
+            baseSha: worktree.baseSha,
+            branch: worktree.branch,
+            targetBranch: worktree.targetBranch,
+            managed: true,
+        };
+        const workspace = this.workspaceFromSession(candidateSession, false);
+        try {
+            const context = await this.reusedWorkspaceContext(workspace);
+            this.store.replaceWorktreeBacking({
+                id: session.id,
+                root: worktree.path,
+                sourceRoot: worktree.sourceRoot,
+                baseRef: worktree.baseRef,
+                baseSha: worktree.baseSha,
+                branch: worktree.branch,
+                targetBranch: worktree.targetBranch,
+            });
+            return context;
+        }
+        catch (error) {
+            this.workspaces.delete(session.id);
+            try {
+                await discardFreshManagedWorktree({ worktree, config: this.config });
+            }
+            catch (cleanupError) {
+                const original = error instanceof Error ? error.message : String(error);
+                const cleanup = cleanupError instanceof Error ? cleanupError.message : String(cleanupError);
+                throw new Error(`${original} Reopen rollback also failed: ${cleanup}`);
+            }
+            throw error;
+        }
+    }
     getWorkspaceSession(workspaceId) {
         const session = this.store?.getSession(workspaceId);
         if (session)

package/docs/chatgpt-coding-workflow.md

@@ -139,6 +139,19 @@ If histories diverge, close is refused and the worktree is preserved. Rebase and
 verify inside the worktree, then retry. The source checkout is not intentionally
 placed into a merge-conflict state.
 
+A successful managed close now preserves the Workspace identity as `closed` even
+though the physical worktree and managed branch are removed. Reopen that Workspace
+with `open_workspace(workspaceId="ws_...")`; ForgeRelay creates fresh worktree
+backing from the recorded source/target relationship and returns the same Workspace
+ID. If the source checkout or target branch can no longer provide valid backing, the
+open fails and the durable Workspace record remains closed.
+
+`close_workspace(action="delete")` is never an implicit discard for active isolated
+work. An active managed worktree still requires `commitMessage` and completes the
+same safe finalize/integrate/cleanup lifecycle before ForgeRelay deletes its identity.
+For an already-closed managed-worktree Workspace, delete removes only ForgeRelay-owned
+state and does not recreate the physical backing.
+
 Legacy `devspace/*` managed branches remain closable when they are already stored
 in workspace metadata; only new managed branches use `forgerelay/*`.
 
@@ -295,8 +308,10 @@ until `open_workspace` reactivates the same ID by path or by `workspaceId`.
 `close_workspace(action="delete")` is the explicit permanent checkout cleanup path:
 it removes ForgeRelay-owned Workspace state but never deletes or mutates project
 files. Managed-worktree close still requires `commitMessage` and runs the safe commit /
-fast-forward-only integration / cleanup lifecycle; managed-worktree, Composite, and
-relayed delete semantics are completed by their later lifecycle stages.
+fast-forward-only integration / cleanup lifecycle. Composite close preserves the same
+`cws_...` identity and member topology; Composite `action="delete"` dissolves only
+Composite-owned state without touching member Workspaces. Relayed delete remains a later
+lifecycle stage.
 
 Shell commands are allowed to modify ordinary project files when that is a
 natural part of the user's requested development task; ForgeRelay does not apply

package/docs/configuration.md

@@ -339,17 +339,32 @@ or externally removed managed-worktree root can therefore remain diagnostically
 ordinary same-target opens no longer accumulate duplicate inventory rows;
 `action="list"` remains the formal on-demand inventory path.
 
-For checkout-backed Workspaces, `close_workspace` now defaults to `action="close"`:
+For checkout-backed Workspaces, `close_workspace` defaults to `action="close"`:
 it marks the persistent Workspace closed, removes current conversation bindings, and
 keeps the same Workspace identity available for later `open_workspace` by path or ID.
 Closed Workspaces remain visible in inventory but ordinary execution tools reject them
 until reopened. `action="delete"` permanently removes ForgeRelay-owned checkout
 identity/state while never deleting or mutating the user's checkout directory.
-Managed-worktree close still requires `commitMessage` and runs the existing safe
-finalize lifecycle; managed-worktree delete semantics land in the next lifecycle
-stage. Composite close still dissolves in this stage, and Composite delete remains
-unavailable until its persistent lifecycle stage. Relayed delete is likewise deferred
-to Workspace Relay lifecycle parity.
+
+Managed-worktree close also preserves the Workspace identity. It still requires
+`commitMessage` and runs the existing BeforeWorktreeClose / commit / fast-forward-only
+integration / physical cleanup / AfterWorktreeClose lifecycle, then leaves the
+Workspace closed after its old worktree path and managed branch are removed. Reopening
+the closed Workspace by ID recreates fresh managed-worktree backing from its recorded
+source/target branch relationship while keeping the same `workspaceId`; an
+unambiguous repeated source/target open can reuse the same closed identity as well.
+If backing recreation fails, the record remains closed and unchanged.
+
+`action="delete"` on an active managed-worktree Workspace is not a discard operation:
+it requires `commitMessage`, completes the same safe finalize lifecycle, and only then
+removes the persistent ForgeRelay identity. Deleting an already-closed worktree
+Workspace removes only ForgeRelay-owned state and does not recreate backing.
+Composite close now marks only the Composite record closed while preserving its identity,
+name, members, and coordination metadata. Closed Composites remain inspectable and reject
+member routing or mutation until reopened with the same `cws_...` ID. Composite
+`action="delete"` permanently dissolves only Composite-owned state; it never closes,
+finalizes, deletes, or otherwise mutates member Workspaces. Relayed delete remains
+deferred to Workspace Relay lifecycle parity.
 
 Hot workspace/session activity timestamps are coalesced in memory and flushed to the
 SQLite state database in a transaction at most every five minutes; normal shutdown

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akira-tl/forgerelay",
-  "version": "0.8.1",
+  "version": "0.8.3",
   "description": "Local development control plane for MCP coding agents.",
   "type": "module",
   "homepage": "https://github.com/Akira-TL/forgerelay#readme",
@@ -47,7 +47,7 @@
     "release:publish": "node scripts/release/publish.mjs",
     "postinstall": "node scripts/fix-node-pty-permissions.mjs",
     "start": "node dist/cli.js serve",
-    "test": "node --test scripts/debug/runtime.test.mjs scripts/release-proof.test.mjs scripts/release/release-gate.test.mjs scripts/release/release-version.test.mjs && tsx src/oauth/router.test.ts && tsx src/remote-auth-cli.test.ts && tsx src/remote-ssh-auth-cli.test.ts && tsx src/remote-workspace-relay.test.ts && tsx src/remote-workspace-relay-process.test.ts && tsx src/config.test.ts && tsx src/lsp/language-server-config.test.ts && tsx src/lsp/normalization/hover.test.ts && tsx src/lsp/references.server.test.ts && tsx src/lsp/operations/document-symbols.server.test.ts && tsx src/lsp/operations/workspace-symbols.server.test.ts && tsx src/lsp/operations/diagnostics-push.server.test.ts && tsx src/lsp/operations/diagnostics-pull.server.test.ts && tsx src/lsp/operations/request-hardening.server.test.ts && tsx src/lsp/operations/recovery.server.test.ts && tsx src/lsp/operations/lifecycle.server.test.ts && tsx src/lsp/runtime/semantic-requests.test.ts && tsx src/logger.test.ts && tsx src/proxy-trust.test.ts && tsx src/mcp-app-template.test.ts && tsx src/hooks.test.ts && tsx src/capability-registry.test.ts && tsx src/mcp/server-instructions.test.ts && tsx src/request-meta.test.ts && tsx src/incoming-artifacts.test.ts && tsx src/artifact-download.test.ts && tsx src/ui/card-types.test.ts && tsx src/ui/workspace-lifecycle-app.test.ts && tsx src/ui/activity/model.test.ts && tsx src/ui/patch-display.test.ts && tsx src/ui/tool-display.test.ts && tsx src/apply-patch.test.ts && tsx src/process-platform.test.ts && tsx src/process-sessions.test.ts && tsx src/mcp-sessions.test.ts && tsx src/server-shutdown.test.ts && tsx src/subagents/providers/adapters/codex.test.ts && tsx src/subagents/providers/registry.test.ts && tsx src/subagents/providers/availability.test.ts && tsx src/subagents/profiles.test.ts && tsx src/subagents/cli-target.test.ts && tsx src/subagents/sessions/store.test.ts && tsx src/subagents/sessions/manager.test.ts && tsx src/subagents/sessions/mcp/capability.server.test.ts && tsx src/subagents/sessions/mcp/continuation.server.test.ts && tsx src/subagents/sessions/mcp/lifecycle.server.test.ts && tsx src/subagents/sessions/mcp/reconciliation.server.test.ts && tsx src/subagents/sessions/mcp/routing.server.test.ts && tsx src/roots.test.ts && tsx src/file-mutations.test.ts && tsx src/operations/edit-preflight.test.ts && tsx src/skills.test.ts && tsx src/db/migrations.test.ts && tsx src/workspace-store.test.ts && tsx src/activity/audit-store.test.ts && tsx src/activity/bash-output-store.test.ts && tsx src/activity/lifecycle.test.ts && tsx src/activity/query-service.test.ts && tsx src/operations/core-operation-executor.test.ts && tsx src/operations/bulk-mutation.test.ts && tsx src/operations/batch/scheduler.test.ts && tsx src/operations/batch/executor-policy.test.ts && tsx src/workspaces.test.ts && tsx src/workspace-conversation.test.ts && tsx src/review-checkpoints.test.ts && tsx src/lsp/code-intelligence.server.test.ts && npm run build:app && tsx src/server.test.ts && tsx src/oauth-store.test.ts && tsx src/cli.test.ts",
+    "test": "node --test scripts/debug/runtime.test.mjs scripts/release-proof.test.mjs scripts/release/release-gate.test.mjs scripts/release/release-version.test.mjs && tsx src/oauth/router.test.ts && tsx src/remote-auth-cli.test.ts && tsx src/remote-ssh-auth-cli.test.ts && tsx src/remote-workspace-relay.test.ts && tsx src/remote-workspace-relay-process.test.ts && tsx src/config.test.ts && tsx src/lsp/language-server-config.test.ts && tsx src/lsp/normalization/hover.test.ts && tsx src/lsp/references.server.test.ts && tsx src/lsp/operations/document-symbols.server.test.ts && tsx src/lsp/operations/workspace-symbols.server.test.ts && tsx src/lsp/operations/diagnostics-push.server.test.ts && tsx src/lsp/operations/diagnostics-pull.server.test.ts && tsx src/lsp/operations/request-hardening.server.test.ts && tsx src/lsp/operations/recovery.server.test.ts && tsx src/lsp/operations/lifecycle.server.test.ts && tsx src/lsp/runtime/semantic-requests.test.ts && tsx src/logger.test.ts && tsx src/proxy-trust.test.ts && tsx src/mcp-app-template.test.ts && tsx src/hooks.test.ts && tsx src/capability-registry.test.ts && tsx src/mcp/server-instructions.test.ts && tsx src/request-meta.test.ts && tsx src/incoming-artifacts.test.ts && tsx src/artifact-download.test.ts && tsx src/ui/card-types.test.ts && tsx src/ui/workspace-lifecycle-app.test.ts && tsx src/ui/activity/model.test.ts && tsx src/ui/patch-display.test.ts && tsx src/ui/tool-display.test.ts && tsx src/apply-patch.test.ts && tsx src/process-platform.test.ts && tsx src/process-sessions.test.ts && tsx src/mcp-sessions.test.ts && tsx src/server-shutdown.test.ts && tsx src/subagents/providers/adapters/codex.test.ts && tsx src/subagents/providers/registry.test.ts && tsx src/subagents/providers/availability.test.ts && tsx src/subagents/profiles.test.ts && tsx src/subagents/cli-target.test.ts && tsx src/subagents/sessions/store.test.ts && tsx src/subagents/sessions/manager.test.ts && tsx src/subagents/sessions/mcp/capability.server.test.ts && tsx src/subagents/sessions/mcp/continuation.server.test.ts && tsx src/subagents/sessions/mcp/lifecycle.server.test.ts && tsx src/subagents/sessions/mcp/reconciliation.server.test.ts && tsx src/subagents/sessions/mcp/routing.server.test.ts && tsx src/roots.test.ts && tsx src/file-mutations.test.ts && tsx src/operations/edit-preflight.test.ts && tsx src/skills.test.ts && tsx src/db/migrations.test.ts && tsx src/workspace-store.test.ts && tsx src/workspace-tasks.test.ts && tsx src/activity/audit-store.test.ts && tsx src/activity/bash-output-store.test.ts && tsx src/activity/lifecycle.test.ts && tsx src/activity/query-service.test.ts && tsx src/operations/core-operation-executor.test.ts && tsx src/operations/bulk-mutation.test.ts && tsx src/operations/batch/scheduler.test.ts && tsx src/operations/batch/executor-policy.test.ts && tsx src/workspaces.test.ts && tsx src/workspace-conversation.test.ts && tsx src/review-checkpoints.test.ts && tsx src/lsp/code-intelligence.server.test.ts && npm run build:app && tsx src/server.test.ts && tsx src/oauth-store.test.ts && tsx src/cli.test.ts",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "release:check": "node scripts/release-version.mjs check",
     "release:tag-check": "node scripts/release-version.mjs tag",