@akira-tl/forgerelay 0.9.0 → 0.9.2

package/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable ForgeRelay changes are documented here.
 
 ## [Unreleased]
 
+## [0.9.2] - 2026-09-04
+
+### Added
+
+- Added persistent Workspace-owned `workspace.checkpoint` create/list/inspect/delete operations backed by immutable Git-visible working-tree snapshots. Checkpoints preserve stable Workspace identity across restart, close/reopen, managed-worktree backing recreation, and ordinary idle GC; ignored files stay excluded, Relay execution remains owned by the Execution ForgeRelay, Composite use remains explicit-member scoped, and no Core MCP tool was added.
+
+## [0.9.1] - 2026-09-04
+
+### Added
+
+- Added the low-frequency `workspace.recovery` Capability for ForgeRelay-managed worktrees. `status` reports the existing recovery model; `repair` can recreate missing active execution backing only from the surviving ForgeRelay managed branch; and Workspace-scoped `cleanup` removes only proven stale worktree registration or an already-integrated closed-Workspace managed branch. Workspace identity and Task state are preserved, active/unique/ambiguous Git state is never force-deleted, Relay executes recovery on the owning Execution ForgeRelay, and Composite use remains explicit-member scoped.
+
 ## [0.9.0] - 2026-09-04
 
 ### Added

package/capabilities/workspace/managed-worktrees/GUIDE.md

@@ -45,4 +45,26 @@ Managed worktree finalize：
 
 source checkout 可能被用户或其他 Agent 修改。关闭前不要假设 target branch 仍停留在创建 worktree 时的状态；让 ForgeRelay 的 close 检查决定是否可以安全集成。遇到 diverged target、dirty source、忙碌 workspace 或 cleanup warning 时，保留现有 worktree 状态并向用户说明真实失败点，不要自行强制 reset、merge 或删除 worktree。
 
-如果需要继续工作，复用原 `workspaceId` 或已知 worktree path；不要因为一次关闭失败就创建新的隔离副本。
+如果 active managed-worktree Workspace 的物理 backing 丢失，先用 `open_workspace action="inspect"` 或 `workspace.recovery` 的 `status` 查看恢复分类。只有 Capability 返回 `recoverable` 时，才考虑 `workspace.recovery { operation: "repair" }`。
+
+`workspace.recovery` 的 repair 规则：
+
+- 只恢复当前 persistent `workspaceId`，不会创建新的 Workspace identity；
+- 必须从持久化记录中的原 `forgerelay/*` managed branch 恢复，绝不从 target branch 重新创建替代工作；
+- managed branch、target branch、source repository identity、worktree ownership 任一无法证明时返回 `manual-intervention`，不猜测；
+- 若同一 managed branch 已出现另一个 worktree candidate，拒绝自动恢复；
+- recovery backing 创建后必须重新验证 branch、HEAD、Git registration 和工作树健康状态，验证失败时仅回滚 ForgeRelay 本次创建的临时 backing；
+- repair 不 merge、不 rebase、不 reset、不删除 managed branch，也不移动 target branch。
+
+`workspace.recovery { operation: "cleanup" }` 只清理当前 persistent Workspace 能证明归属的 Git administrative residue：
+
+- backing 已不存在且 stale registration 仍精确对应持久化 managed branch 时，可只移除该 registration；不执行 repository-wide `git worktree prune`；
+- active Workspace 的 managed branch 始终保留，即使 stale registration 已被清掉，避免 cleanup 把仍需恢复的 Workspace 变成不可恢复状态；
+- closed Workspace 的残留 `forgerelay/*` branch 只有在没有任何 worktree registration 或其他 persistent Workspace identity 持有它、source checkout 仍位于持久化 target branch、且 Git 证明该 branch 已完整并入 target 时才允许删除；
+- unique/unmerged commits、branch ownership mismatch、active backing、缺失 target、source/target identity 不可证明等情况返回 `manual-intervention`，不强制删除；
+- cleanup 返回 `cleaned`、`nothing-to-clean` 或 `manual-intervention` 分类；对 active Workspace 成功清理 registration 后同时返回更新后的 recovery projection；
+- cleanup 不 reopen、close、delete Workspace，也不改变 persistent Workspace lifecycle state。
+
+Relay Workspace 的 recovery 在 Execution ForgeRelay 上执行；Composite Workspace 必须显式指定实际拥有该 worktree 的 member。不要在 Gateway 或 Composite identity 上自行解释/修改成员 Git 状态。
+
+如果需要继续工作，复用原 `workspaceId`；不要因为 backing 丢失、一次关闭失败或一次恢复失败就创建新的隔离副本来绕过原状态。

package/capabilities/workspace/workspace-checkpoints/GUIDE.md

@@ -0,0 +1,75 @@
+# Workspace Checkpoints
+
+`workspace.checkpoint` provides low-frequency, persistent checkpoints owned by the current filesystem Workspace. Checkpoints are immutable Git-backed snapshots intended for deliberate recovery/history workflows.
+
+## v0.9.2 surface
+
+Supported operations are deliberately limited to:
+
+- `create` — create a named immutable checkpoint of the current Git-visible working tree.
+- `list` — return bounded checkpoint metadata, newest identity preserved in creation order.
+- `inspect` — return bounded metadata for one checkpoint.
+- `delete` — explicitly delete one checkpoint and its ForgeRelay-owned Git ref.
+
+Restore is **not** part of v0.9.2. Do not emulate restore with checkout/reset or other destructive Git commands unless the user separately and explicitly asks for such Git work outside this Capability.
+
+## Create
+
+Use:
+
+```json
+{
+  "operation": "create",
+  "name": "before parser refactor"
+}
+```
+
+A checkpoint snapshots the current Git-visible working-tree content using a private temporary Git index. Creation does not move branch `HEAD`, write project history, modify files, or mutate the real staging index.
+
+The snapshot includes tracked files and non-ignored untracked files that Git would normally admit. Git-ignored files are excluded. Consequently Workspace checkpoints are **not a backup mechanism for secrets, ignored configuration, credentials, build caches, or other ignored files**.
+
+Checkpoint metadata includes a stable checkpoint id, user-provided name, creation timestamp, immutable snapshot commit id, base `HEAD`, and bounded file/addition/removal counts. It does not return patches or full file contents by default.
+
+## List and inspect
+
+Use `list` for discovery:
+
+```json
+{
+  "operation": "list",
+  "offset": 0,
+  "limit": 50
+}
+```
+
+Use `inspect` only after selecting an id:
+
+```json
+{
+  "operation": "inspect",
+  "checkpointId": "cp_0123456789"
+}
+```
+
+`list` and `inspect` expose bounded metadata only. Checkpoints do not move when `review.changes` advances its independent last-shown baseline.
+
+## Delete
+
+Deletion is explicit:
+
+```json
+{
+  "operation": "delete",
+  "checkpointId": "cp_0123456789"
+}
+```
+
+ForgeRelay verifies that the Workspace-owned Git ref still points at the checkpoint's recorded immutable commit before deleting it. A mismatched or missing ref is treated as inconsistent state rather than silently deleting something else.
+
+Ordinary Workspace close, process restart, idle Workspace cache GC, and managed-worktree backing replacement preserve checkpoints. Permanent `close_workspace { action: "delete" }` removes checkpoints owned by that Workspace identity.
+
+## Relay and Composite Workspaces
+
+Checkpoint ownership belongs to the Execution Workspace. Through Workspace Relay, checkpoint operations execute on the remote Execution ForgeRelay and persist there.
+
+A Composite Workspace does not own filesystem checkpoints itself. Pass an explicit `member` so the operation targets that member's persistent Workspace identity.

package/dist/mcp/server/core/capabilities/workspace-checkpoint.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+export const workspaceCheckpointInputSchema = z.discriminatedUnion("operation", [
+    z.object({
+        operation: z.literal("create"),
+        name: z.string().trim().min(1).max(120),
+    }).strict(),
+    z.object({
+        operation: z.literal("list"),
+        offset: z.number().int().min(0).optional(),
+        limit: z.number().int().min(1).max(100).optional(),
+    }).strict(),
+    z.object({
+        operation: z.literal("inspect"),
+        checkpointId: z.string().regex(/^cp_[a-f0-9]{10}$/),
+    }).strict(),
+    z.object({
+        operation: z.literal("delete"),
+        checkpointId: z.string().regex(/^cp_[a-f0-9]{10}$/),
+    }).strict(),
+]);

package/dist/mcp/server/core/capabilities.js

@@ -46,6 +46,12 @@ const CAPABILITY_GUIDE_DEFINITIONS = [
         description: "Persistent Task Lists owned by the current Workspace.",
         whenToRead: "Read before creating or maintaining Workspace Tasks.",
     },
+    {
+        name: "workspace-checkpoints",
+        directory: "workspace/workspace-checkpoints",
+        description: "Immutable persistent Git-backed checkpoints owned by the current Workspace.",
+        whenToRead: "Read before creating, listing, inspecting, or deleting Workspace checkpoints.",
+    },
     {
         name: "batch-execution",
         description: "One-call execution of multiple independent ForgeRelay core operations.",
@@ -95,6 +101,8 @@ export function buildCapabilityFingerprint(config, version, context = {}) {
         "capability-guides.read",
         "code.intelligence",
         "workspace.tasks",
+        "workspace.recovery",
+        "workspace.checkpoint",
     ];
     if (config.toolMode !== "codex") {
         capabilities.push("batch.execute");

package/dist/mcp/server/core/capability-registry.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { MAX_CODE_INTELLIGENCE_RESULT_LIMIT, } from "../../../lsp/code-intelligence-types.js";
 import { batchExecuteInputSchema, } from "../../operations/batch/types.js";
+import { workspaceCheckpointInputSchema, } from "./capabilities/workspace-checkpoint.js";
 export class CapabilityError extends Error {
     code;
     constructor(code, message) {
@@ -190,6 +191,11 @@ export function createCapabilityRegistry(dependencies) {
             taskId: z.string().min(1),
         }).strict(),
     ]);
+    const workspaceRecoveryInput = z.discriminatedUnion("operation", [
+        z.object({ operation: z.literal("status") }).strict(),
+        z.object({ operation: z.literal("repair") }).strict(),
+        z.object({ operation: z.literal("cleanup") }).strict(),
+    ]);
     const subagentSessionInput = z.discriminatedUnion("operation", [
         z.object({
             operation: z.literal("start"),
@@ -287,6 +293,30 @@ export function createCapabilityRegistry(dependencies) {
                     run: async (input, context, options) => dependencies.codeIntelligence.run(input, context, options),
                 }]
             : []),
+        ...(dependencies.workspaceRecovery
+            ? [{
+                    name: "workspace.recovery",
+                    description: "Inspect or safely repair the current managed-worktree Workspace when ForgeRelay can prove the surviving managed branch and execution backing ownership.",
+                    guideName: "managed-worktrees",
+                    readGuideBeforeFirstUse: true,
+                    batchPolicy: "unsupported",
+                    inputSchema: workspaceRecoveryInput,
+                    availability: (context) => managedWorktreeAvailability(context, dependencies.workspaceRecovery?.available ?? false, dependencies.workspaceRecovery?.unavailableReason),
+                    run: async (input, context, options) => dependencies.workspaceRecovery.run(input, context, options),
+                }]
+            : []),
+        ...(dependencies.workspaceCheckpoint
+            ? [{
+                    name: "workspace.checkpoint",
+                    description: "Create, list, inspect, or delete immutable Git-backed checkpoints owned by the current persistent Workspace.",
+                    guideName: "workspace-checkpoints",
+                    readGuideBeforeFirstUse: true,
+                    batchPolicy: "unsupported",
+                    inputSchema: workspaceCheckpointInputSchema,
+                    availability: (context) => filesystemWorkspaceAvailability(context, dependencies.workspaceCheckpoint?.available ?? false, dependencies.workspaceCheckpoint?.unavailableReason),
+                    run: async (input, context, options) => dependencies.workspaceCheckpoint.run(input, context, options),
+                }]
+            : []),
         ...(dependencies.workspaceTasks
             ? [{
                     name: "workspace.tasks",
@@ -360,6 +390,17 @@ function filesystemWorkspaceAvailability(context, available = true, reason) {
     }
     return { available, ...(reason ? { reason } : {}) };
 }
+function managedWorktreeAvailability(context, available = true, reason) {
+    if (context.workspaceKind !== "workspace" ||
+        context.workspaceMode !== "worktree" ||
+        context.workspaceManaged !== true) {
+        return {
+            available: false,
+            reason: "This capability is available only for a ForgeRelay-managed worktree Workspace.",
+        };
+    }
+    return { available, ...(reason ? { reason } : {}) };
+}
 function requireWorkspaceRoot(context) {
     if (context.workspaceKind !== "workspace" || !context.workspaceRoot) {
         throw new CapabilityError("capability_unavailable", "This capability requires a filesystem-backed Workspace.");

package/dist/mcp/server/core/capability-support.js

@@ -1,3 +1,4 @@
+import { loadCapabilityGuides } from "./capabilities.js";
 import { CapabilityError } from "./capability-registry.js";
 import { formatPathForPrompt } from "../../../workspaces/resources/skills.js";
 export function workspaceHookInvocation(workspace) {
@@ -13,6 +14,8 @@ export function capabilityContextFor(workspace) {
         workspaceId: workspace.id,
         workspaceKind: "workspace",
         workspaceRoot: workspace.root,
+        workspaceMode: workspace.mode,
+        workspaceManaged: workspace.worktree?.managed ?? false,
         guides: workspace.capabilityGuides.map((guide) => ({
             name: guide.name,
             description: guide.description,
@@ -21,6 +24,20 @@ export function capabilityContextFor(workspace) {
         })),
     };
 }
+export function managedWorktreeRecoveryCapabilityContext(session, config) {
+    return {
+        workspaceId: session.id,
+        workspaceKind: "workspace",
+        workspaceMode: session.mode,
+        workspaceManaged: session.managed,
+        guides: loadCapabilityGuides(config).map((guide) => ({
+            name: guide.name,
+            description: guide.description,
+            whenToRead: guide.whenToRead,
+            path: formatPathForPrompt(guide.filePath),
+        })),
+    };
+}
 export function compositeCapabilityContext(workspaceId, guides) {
     return {
         workspaceId,

package/dist/mcp/server/operations/runtime/operation-runtime.js

@@ -10,7 +10,7 @@ import { formatAgentsPath } from "../../../../workspaces.js";
 import { markReturnedOutput, processActivityOutcome, processToolResponse, } from "../../../process/runtime.js";
 import { capabilityActivityAuditRequest, capabilityActivityAuditResult } from "../../../../subagents/sessions/mcp/audit.js";
 import { activityRelationFor, activityRequestFor, runActivityTool, runActivityToolWithHooks, standardActivityOutcome, } from "../../core/activity-support.js";
-import { capabilityContextFor, workspaceHookInvocation } from "../../core/capability-support.js";
+import { capabilityContextFor, managedWorktreeRecoveryCapabilityContext, workspaceHookInvocation, } from "../../core/capability-support.js";
 import { assertWorkspaceInstructionsLoadedBeforeSideEffect, contentLineCount, contentText, countDiffStats, formatDiscoveredWorkspaceInstructions, logFailedToolResponse, logToolCall, newFilePatch, textBlock, textSummary, toolResultContent, toolResultIsError, toolResultText, workspaceLogContext, } from "../../core/tool-support.js";
 import { appendAutomaticMutationDiagnostics } from "./mutation-diagnostics.js";
 export function createOperationRuntime(options) {
@@ -429,6 +429,58 @@ export function createOperationRuntime(options) {
         },
         capabilityRun: async (input, context) => {
             const { workspaceId, name, arguments: capabilityArguments, file } = input;
+            if (name === "workspace.recovery") {
+                const session = workspaces.getWorkspaceSession(workspaceId);
+                if (session.status === "closed") {
+                    const startedAt = performance.now();
+                    try {
+                        const execution = await capabilityRegistry.run(name, capabilityArguments ?? {}, managedWorktreeRecoveryCapabilityContext(session, config), {
+                            nativeFile: file,
+                            signal: context.signal,
+                            requestMeta: context.requestMeta,
+                            sessionId: context.sessionId,
+                            batch: context.batch,
+                        });
+                        const result = {
+                            content: [textBlock(`Capability ${name} completed.\n${JSON.stringify(execution.value, null, 2)}`)],
+                            structuredContent: { name, action: "run", result: execution.value },
+                        };
+                        logToolCall(config, {
+                            tool: toolNames.capability,
+                            workspaceId: session.id,
+                            capability: name,
+                            action: "run",
+                            success: true,
+                            durationMs: Math.round(performance.now() - startedAt),
+                        });
+                        return result;
+                    }
+                    catch (error) {
+                        const capabilityError = error instanceof CapabilityError
+                            ? error
+                            : new CapabilityError("execution_failed", error instanceof Error ? error.message : String(error));
+                        const result = {
+                            content: [textBlock(`${capabilityError.code}: ${capabilityError.message}`)],
+                            structuredContent: {
+                                name,
+                                action: "run",
+                                error: { code: capabilityError.code, message: capabilityError.message },
+                            },
+                            isError: true,
+                        };
+                        logToolCall(config, {
+                            tool: toolNames.capability,
+                            workspaceId: session.id,
+                            capability: name,
+                            action: "run",
+                            success: false,
+                            durationMs: Math.round(performance.now() - startedAt),
+                            error: capabilityError.message,
+                        });
+                        return result;
+                    }
+                }
+            }
             const workspace = workspaces.getWorkspace(workspaceId);
             let changedPaths = [];
             return runActivityTool(activityLifecycle, workspace, hostScopeIdFor(context.requestMeta, context.sessionId), toolNames.capability, activityRequestFor(capabilityActivityAuditRequest(input), context), (activityContext) => runToolWithHooks(hooks, {
@@ -438,6 +490,7 @@ export function createOperationRuntime(options) {
                 payload: { name, action: "run" },
                 isFailure: toolResultIsError,
                 changedPaths: () => changedPaths,
+                afterCwd: () => workspaces.getWorkspaceSession(workspaceId).root,
                 operation: async () => {
                     const startedAt = performance.now();
                     try {

package/dist/mcp/server/workspace/runtime/workspace-tools.js

@@ -15,7 +15,7 @@ const WRITE_TOOL_ANNOTATIONS = {
     openWorldHint: false,
 };
 export function registerWorkspaceAuxiliaryTools(options) {
-    const { server, config, workspaces, remoteWorkspaces, compositeWorkspaces, compositeTaskGuides, capabilityRegistry, coreOperations, activityLifecycle, hooks, workspaceTasks, taskReminders, activityQueries, compositeActivity, workspacePanelStates, processSessions, reviewCheckpoints, codeIntelligence, resolveExecutionTarget, prepareExecutionContext, hostScopeIdFor, presentExecutionResult, presentSemanticWorkResult, } = options;
+    const { server, config, workspaces, remoteWorkspaces, compositeWorkspaces, compositeTaskGuides, capabilityRegistry, coreOperations, activityLifecycle, hooks, workspaceTasks, workspaceCheckpoints, taskReminders, activityQueries, compositeActivity, workspacePanelStates, processSessions, reviewCheckpoints, codeIntelligence, resolveExecutionTarget, prepareExecutionContext, hostScopeIdFor, presentExecutionResult, presentSemanticWorkResult, } = options;
     registerAppTool(server, "workspace_instruction", {
         title: "Read Workspace instruction",
         description: "App-only lazy data source for one instruction file already advertised by the Workspace presentation. Reading through this UI source does not activate nested instructions or create an Activity.",
@@ -399,6 +399,7 @@ export function registerWorkspaceAuxiliaryTools(options) {
                 },
                 payload: { workspaceId: session.id, action: "delete", mode: session.mode },
                 operation: async () => {
+                    await workspaceCheckpoints.deleteWorkspace(session.id);
                     workspaces.deleteWorkspace(session.id);
                     workspaceTasks.deleteWorkspace(session.id);
                     taskReminders.forget(session.id);
@@ -444,6 +445,7 @@ export function registerWorkspaceAuxiliaryTools(options) {
                 },
                 payload: { workspaceId: session.id, action: "delete", mode: session.mode },
                 operation: async () => {
+                    await workspaceCheckpoints.deleteWorkspace(session.id);
                     workspaces.deleteWorkspace(session.id);
                     workspaceTasks.deleteWorkspace(session.id);
                     taskReminders.forget(session.id);
@@ -509,6 +511,7 @@ export function registerWorkspaceAuxiliaryTools(options) {
                     }
                     await Promise.all(physicalWorkspaceIds.map((id) => reviewCheckpoints.releaseWorkspace(id)));
                     if (action === "delete") {
+                        await workspaceCheckpoints.deleteWorkspace(workspace.id);
                         workspaces.deleteWorkspace(workspace.id);
                         workspaceTasks.deleteWorkspace(workspace.id);
                         taskReminders.forget(workspace.id);

package/dist/server.js

@@ -26,6 +26,7 @@ import { shutdownHttpServer } from "./mcp/server/transport/server-shutdown.js";
 import { formatPathForPrompt } from "./workspaces/resources/skills.js";
 import { WorkspaceTaskReminderTracker } from "./workspaces/tasks/workspace-task-reminders.js";
 import { WorkspaceTaskStore } from "./workspaces/tasks/workspace-tasks.js";
+import { WorkspaceCheckpointStore } from "./workspaces/state/workspace-checkpoints.js";
 import { compactWorkspacePresentation } from "./workspaces/presentation/workspace-presentation.js";
 import { formatAgentsPath } from "./workspaces.js";
 import { summarizeSubagentProfile } from "./subagents/profiles.js";
@@ -49,6 +50,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
     const compositeWorkspaces = options.compositeWorkspaces
         ?? new CompositeWorkspaceRegistry(config.stateDir);
     const workspaceTasks = new WorkspaceTaskStore(config.stateDir);
+    const workspaceCheckpoints = new WorkspaceCheckpointStore(config.stateDir);
     const taskReminders = options.taskReminders
         ?? new WorkspaceTaskReminderTracker(config.taskReminderInterval, workspaceTasks);
     const compositeTaskGuides = loadCapabilityGuides(config).filter((guide) => guide.name === "workspace-tasks");
@@ -131,6 +133,34 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
     const capabilityRegistry = createCapabilityRegistry({
         inspectHooks: (workspaceRoot) => checkHookConfiguration(workspaceRoot, config.hooks),
         ...subagentMcp.registryDependencies,
+        workspaceRecovery: {
+            available: true,
+            run: async (input, context) => ({
+                value: await workspaces.runManagedWorktreeRecovery(context.workspaceId, input.operation),
+            }),
+        },
+        workspaceCheckpoint: {
+            available: true,
+            run: async (input, context) => {
+                const root = requireCapabilityWorkspaceRoot(context);
+                switch (input.operation) {
+                    case "create":
+                        return {
+                            value: {
+                                workspaceId: context.workspaceId,
+                                checkpoint: await workspaceCheckpoints.create(context.workspaceId, root, input.name),
+                                ignoredFilesIncluded: false,
+                            },
+                        };
+                    case "list":
+                        return { value: await workspaceCheckpoints.list(context.workspaceId, root, input) };
+                    case "inspect":
+                        return { value: await workspaceCheckpoints.inspect(context.workspaceId, root, input.checkpointId) };
+                    case "delete":
+                        return { value: await workspaceCheckpoints.delete(context.workspaceId, root, input.checkpointId) };
+                }
+            },
+        },
         workspaceTasks: {
             available: true,
             run: async (input, context) => {
@@ -445,7 +475,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
     });
     registerWorkspaceAuxiliaryTools({
         server, config, workspaces, remoteWorkspaces, compositeWorkspaces, compositeTaskGuides, capabilityRegistry,
-        coreOperations, activityLifecycle, hooks, workspaceTasks, taskReminders, activityQueries, compositeActivity,
+        coreOperations, activityLifecycle, hooks, workspaceTasks, workspaceCheckpoints, taskReminders, activityQueries, compositeActivity,
         workspacePanelStates, processSessions, reviewCheckpoints, codeIntelligence, resolveExecutionTarget,
         prepareExecutionContext, hostScopeIdFor, presentExecutionResult, presentSemanticWorkResult,
     });

package/dist/workspaces/git/git-worktrees.js

@@ -228,7 +228,7 @@ async function isAncestor(ancestor, descendant, cwd) {
         return false;
     }
 }
-function managedWorktreePath(input) {
+export function managedWorktreePath(input) {
     const repoName = sanitizePathSegment(basename(input.repoRoot)) || "repo";
     return join(input.worktreeRoot, `${repoName}-${input.worktreeId}`);
 }