dsh-git-worktree 0.7.4 → 0.8.0

package/lib/i18n/host-messages.d.ts

@@ -0,0 +1,1463 @@
+import type { Translator } from './core.js';
+/** Host-owned prose. Keys are stable; user data is passed only as interpolation values. */
+export declare const hostMessages: {
+    readonly sessionNotFound: {
+        readonly zh: "会话不存在: {p0}";
+        readonly en: "Session not found: {p0}";
+    };
+    readonly theSessionIsNotAssociatedWithAProject: {
+        readonly zh: "会话尚未关联项目";
+        readonly en: "The Session is not associated with a project.";
+    };
+    readonly projectNotFound: {
+        readonly zh: "项目不存在: {p0}";
+        readonly en: "Project not found: {p0}";
+    };
+    readonly projectRootDirectoryNotFound: {
+        readonly zh: "项目根目录不存在: {p0}";
+        readonly en: "Project root directory not found: {p0}";
+    };
+    readonly theSessionWorkspaceNoLongerMatchesItsBoundSession: {
+        readonly zh: "会话当前 Workspace 与已绑定 Session Target 不一致，已停止访问 checkout";
+        readonly en: "The Session Workspace no longer matches its bound Session Target; checkout access has stopped.";
+    };
+    readonly theSessionHasNotSelectedASessionTarget: {
+        readonly zh: "会话尚未选择 Session Target";
+        readonly en: "The Session has not selected a Session Target.";
+    };
+    readonly onlyTheOwnerIsolatedSessionCanPrepareAReview: {
+        readonly zh: "只有 owner Isolated 会话可以准备验收";
+        readonly en: "Only the owner Isolated Session can prepare a review.";
+    };
+    readonly theReviewSummaryCommitMessageOrValidationItemsAre: {
+        readonly zh: "验收摘要、提交信息或验证项目无效";
+        readonly en: "The review summary, commit message, or validation items are invalid.";
+    };
+    readonly theIsolatedCheckoutRecordDoesNotExist: {
+        readonly zh: "Isolated Checkout 记录不存在";
+        readonly en: "The Isolated Checkout record does not exist.";
+    };
+    readonly cannotPrepareAReviewInTheCurrentState: {
+        readonly zh: "当前 {p0}/{p1} 状态不能准备验收";
+        readonly en: "Cannot prepare a review in the current {p0}/{p1} state.";
+    };
+    readonly theIsolatedCheckoutIdentityCannotBeVerifiedRecoveryIs: {
+        readonly zh: "Isolated Checkout 身份无法确认，需要恢复";
+        readonly en: "The Isolated Checkout identity cannot be verified; recovery is required.";
+    };
+    readonly onlyTheOwnerIsolatedSessionCanSaveACheckpoint: {
+        readonly zh: "只有 owner Isolated 会话可以保存阶段";
+        readonly en: "Only the owner Isolated Session can save a checkpoint.";
+    };
+    readonly theCheckpointRequestOrCommitMessageIsInvalid: {
+        readonly zh: "Checkpoint 请求或 Commit Message 无效";
+        readonly en: "The Checkpoint request or commit message is invalid.";
+    };
+    readonly theCheckpointRequestIdIsAlreadyUsedByAnotherState: {
+        readonly zh: "Checkpoint requestId 已被其他状态使用，请刷新";
+        readonly en: "The Checkpoint requestId is already used by another state. Refresh and retry.";
+    };
+    readonly theSessionTargetHasChangedRefreshAndRetry: {
+        readonly zh: "Session Target 已变化，请刷新后重试";
+        readonly en: "The Session Target has changed. Refresh and retry.";
+    };
+    readonly cannotSaveACheckpointInTheCurrentState: {
+        readonly zh: "当前 {p0}/{p1} 状态不能保存阶段";
+        readonly en: "Cannot save a checkpoint in the current {p0}/{p1} state.";
+    };
+    readonly theCheckpointReviewOrGenerationHasChangedRefreshAnd: {
+        readonly zh: "Checkpoint Review 或 generation 已变化，请刷新后重试";
+        readonly en: "The Checkpoint Review or generation has changed. Refresh and retry.";
+    };
+    readonly anotherTaskIsOccupyingThisProjectSLocalAcceptance: {
+        readonly zh: "另一个任务正在占用该项目的 Local 验收槽位";
+        readonly en: "Another task is occupying this project's Local acceptance slot.";
+    };
+    readonly theCheckpointStateChangedBeforeTheHostCASRefresh: {
+        readonly zh: "Checkpoint 状态在 Host CAS 前发生变化，请刷新后重试";
+        readonly en: "The Checkpoint state changed before the Host CAS. Refresh and retry.";
+    };
+    readonly previewWasRolledBackButTheCheckoutRecordIs: {
+        readonly zh: "Preview 已撤回，但 Checkout 记录丢失";
+        readonly en: "Preview was rolled back, but the Checkout record is missing.";
+    };
+    readonly thereIsNoReviewCheckpointToSave: {
+        readonly zh: "当前没有可保存的验收阶段";
+        readonly en: "There is no review checkpoint to save.";
+    };
+    readonly theCheckpointJournalChangedBeforeRetainingTheInternalRef: {
+        readonly zh: "Checkpoint journal 在保留内部 ref 前发生变化";
+        readonly en: "The Checkpoint journal changed before retaining the internal ref.";
+    };
+    readonly checkpointWasCreatedButTheCheckoutRecordIsMissing: {
+        readonly zh: "Checkpoint 已创建，但 Checkout 记录丢失";
+        readonly en: "Checkpoint was created, but the Checkout record is missing.";
+    };
+    readonly onlyTheOwnerIsolatedSessionCanResumeEditing: {
+        readonly zh: "只有 owner Isolated 会话可以恢复编辑";
+        readonly en: "Only the owner Isolated Session can resume editing.";
+    };
+    readonly theCurrentWorktreeHasNoUnsyncedReviewToResume: {
+        readonly zh: "当前 Worktree 没有可恢复编辑的未同步验收稿";
+        readonly en: "The current Worktree has no unsynced review to resume editing.";
+    };
+    readonly thisReviewCardIsNoLongerTheCurrentReview: {
+        readonly zh: "该验收卡已不是当前 Review，请刷新后重试";
+        readonly en: "This review card is no longer the current Review. Refresh and retry.";
+    };
+    readonly theAcceptanceStateChangedBeforeResumingEditingRefreshAnd: {
+        readonly zh: "验收状态在恢复编辑前发生变化，请刷新后重试";
+        readonly en: "The acceptance state changed before resuming editing. Refresh and retry.";
+    };
+    readonly theConflictRecoveryIdentityChangedBeforeHostCASRun: {
+        readonly zh: "冲突恢复身份在 Host CAS 前已变化，请重新预检";
+        readonly en: "The conflict recovery identity changed before Host CAS. Run preflight again.";
+    };
+    readonly theAcceptanceStateChangedBeforeConflictRecoveryRefreshAnd: {
+        readonly zh: "验收状态在冲突恢复前发生变化，请刷新后重试";
+        readonly en: "The acceptance state changed before conflict recovery. Refresh and retry.";
+    };
+    readonly onlyTheOwnerIsolatedSessionCanRequestReviewRegeneration: {
+        readonly zh: "只有 owner Isolated 会话可以请求重新生成验收结果";
+        readonly en: "Only the owner Isolated Session can request review regeneration.";
+    };
+    readonly theReadOnlyReviewRegenerationIdentityChangedBeforeHost: {
+        readonly zh: "只读验收再生成身份在 Host 授权前已变化";
+        readonly en: "The read-only review regeneration identity changed before Host authorization.";
+    };
+    readonly theReadyReviewChangedBeforeReadOnlyAuthorization: {
+        readonly zh: "Ready Review 在只读授权前发生变化";
+        readonly en: "The Ready Review changed before read-only authorization.";
+    };
+    readonly theDetachedPreviewRecoveryProofHasChangedCheckAgain: {
+        readonly zh: "Detached Preview Recovery proof 已变化，请重新检查";
+        readonly en: "The Detached Preview Recovery proof has changed. Check again.";
+    };
+    readonly theDetachedPreviewChangedBeforeAnalysisAuthorization: {
+        readonly zh: "Detached Preview 在分析授权前发生变化";
+        readonly en: "The Detached Preview changed before analysis authorization.";
+    };
+    readonly recoveryHandoffRequiresANewPreallocatedSessionID: {
+        readonly zh: "Recovery handoff 必须使用新的预分配 Session ID";
+        readonly en: "Recovery handoff requires a new preallocated Session ID.";
+    };
+    readonly theRecoveryHandoffSessionIDIsAlreadyInUse: {
+        readonly zh: "Recovery handoff Session ID 已被占用";
+        readonly en: "The Recovery handoff Session ID is already in use.";
+    };
+    readonly thePreviousDetachedPreviewIdentityHasChanged: {
+        readonly zh: "旧 Detached Preview 身份已变化";
+        readonly en: "The previous Detached Preview identity has changed.";
+    };
+    readonly theOriginalSourceSessionIsUnavailableNoHandoffWorktree: {
+        readonly zh: "原始 source Session 不可用，未创建 handoff Worktree";
+        readonly en: "The original source Session is unavailable; no handoff Worktree was created.";
+    };
+    readonly theRecoveryHandoffWorktreeRecordIsMissingAfterCreation: {
+        readonly zh: "Recovery handoff Worktree 创建后记录缺失";
+        readonly en: "The Recovery handoff Worktree record is missing after creation.";
+    };
+    readonly aSessionThatInheritedItsSessionTargetCannotPerform: {
+        readonly zh: "继承 Session Target 的会话不能执行 Apply";
+        readonly en: "A Session that inherited its Session Target cannot perform Apply.";
+    };
+    readonly localCheckoutDoesNotSupportApply: {
+        readonly zh: "Local Checkout 不支持 Apply";
+        readonly en: "Local Checkout does not support Apply.";
+    };
+    readonly cannotApplyInTheCurrentState: {
+        readonly zh: "当前 {p0}/{p1} 状态不能 Apply";
+        readonly en: "Cannot Apply in the current {p0}/{p1} state.";
+    };
+    readonly anotherAcceptanceTaskInTheSameProjectIsOccupying: {
+        readonly zh: "同一项目已有验收任务正在占用 Local：{p0}";
+        readonly en: "Another acceptance task in the same project is occupying Local: {p0}";
+    };
+    readonly theIsolatedCheckoutStateHasChangedRecoveryIsRequired: {
+        readonly zh: "Isolated Checkout 状态已变化，需要恢复";
+        readonly en: "The Isolated Checkout state has changed; recovery is required.";
+    };
+    readonly worktreeChangedAfterBeingMarkedReadyForReviewPrepare: {
+        readonly zh: "Worktree 在标记可验收后又发生变化，请重新准备验收";
+        readonly en: "Worktree changed after being marked ready for review. Prepare the review again.";
+    };
+    readonly worktreeChangesWereWrittenToLocalPreviewThroughApplyWorktree: {
+        readonly zh: "Worktree 修改已通过 ApplyWorktree 写入 Local Preview";
+        readonly en: "Worktree changes were written to Local Preview through ApplyWorktree.";
+    };
+    readonly choreCommitWorktreeChanges: {
+        readonly zh: "chore: 提交 Worktree 修改";
+        readonly en: "chore: commit Worktree changes";
+    };
+    readonly onlyTheOwnerIsolatedSessionCanCheckPreviewRecovery: {
+        readonly zh: "只有 owner Isolated 会话可以检查 Preview 恢复";
+        readonly en: "Only the owner Isolated Session can check Preview recovery.";
+    };
+    readonly theSessionTargetHasChangedRefreshBeforeCheckingAgain: {
+        readonly zh: "Session Target 已变化，请刷新后重新检查";
+        readonly en: "The Session Target has changed. Refresh before checking again.";
+    };
+    readonly theCurrentStateIsNotTheSpecifiedDetachedPreview: {
+        readonly zh: "当前并非指定的 detached Preview 恢复状态";
+        readonly en: "The current state is not the specified detached Preview recovery state.";
+    };
+    readonly theWorktreeIdentityPathOrGitStateCannotCurrently: {
+        readonly zh: "Worktree 身份、路径或 Git 状态暂时无法确认";
+        readonly en: "The Worktree identity, path, or Git state cannot currently be verified.";
+    };
+    readonly previewRetainedArtifactsAreMissingOrDoNotMatch: {
+        readonly zh: "Preview retained artifacts 缺失或与 receipt 不一致";
+        readonly en: "Preview retained artifacts are missing or do not match the receipt.";
+    };
+    readonly thePreviewRecoveryStateChangedDuringTheCheck: {
+        readonly zh: "Preview 恢复状态在检查期间发生变化";
+        readonly en: "The Preview recovery state changed during the check.";
+    };
+    readonly previewRetainedArtifactsChangedDuringTheCheck: {
+        readonly zh: "Preview retained artifacts 在检查期间发生变化";
+        readonly en: "Preview retained artifacts changed during the check.";
+    };
+    readonly previewRecoveryCheckFailed: {
+        readonly zh: "Preview 恢复检查失败";
+        readonly en: "Preview recovery check failed.";
+    };
+    readonly onlyTheOwnerIsolatedSessionCanRunSyncPreflight: {
+        readonly zh: "只有 owner Isolated 会话可以执行同步预检";
+        readonly en: "Only the owner Isolated Session can run sync preflight.";
+    };
+    readonly theSessionTargetHasChangedRefreshBeforeRunningPreflight: {
+        readonly zh: "Session Target 已变化，请刷新后重新预检";
+        readonly en: "The Session Target has changed. Refresh before running preflight again.";
+    };
+    readonly theCurrentWorktreeIsNotReadyForReview: {
+        readonly zh: "当前 Worktree 尚未处于可验收状态";
+        readonly en: "The current Worktree is not ready for review.";
+    };
+    readonly theSessionTargetChangedDuringPreflightRefreshAndRetry: {
+        readonly zh: "Session Target 在预检期间发生变化，请刷新后重试";
+        readonly en: "The Session Target changed during preflight. Refresh and retry.";
+    };
+    readonly worktreeChangedAfterTheReviewWasPreparedRegenerateThe: {
+        readonly zh: "Worktree 在准备验收后发生变化，请重新生成验收结果";
+        readonly en: "Worktree changed after the review was prepared. Regenerate the review.";
+    };
+    readonly onlyTheOwnerIsolatedSessionCanSyncAReview: {
+        readonly zh: "只有 owner Isolated 会话可以同步验收";
+        readonly en: "Only the owner Isolated Session can sync a review.";
+    };
+    readonly theAcceptanceStateHasChangedRefreshAndRetry: {
+        readonly zh: "验收状态已变化，请刷新后重试";
+        readonly en: "The acceptance state has changed. Refresh and retry.";
+    };
+    readonly thereIsNoLocalPreviewToRelease: {
+        readonly zh: "当前没有可解除的 Local Preview";
+        readonly en: "There is no Local Preview to release.";
+    };
+    readonly thePreviewStateHasChangedRefreshAndRetry: {
+        readonly zh: "Preview 状态已变化，请刷新后重试";
+        readonly en: "The Preview state has changed. Refresh and retry.";
+    };
+    readonly onlyTheOwnerIsolatedSessionCanRollBackAcceptance: {
+        readonly zh: "只有 owner Isolated 会话可以撤回验收";
+        readonly en: "Only the owner Isolated Session can roll back acceptance.";
+    };
+    readonly thereIsNoLocalPreviewToRollBack: {
+        readonly zh: "当前没有可撤回的 Local Preview";
+        readonly en: "There is no Local Preview to roll back.";
+    };
+    readonly thePreviewRecoveryProofHasExpiredOrDoesNot: {
+        readonly zh: "Preview Recovery proof 已过期或不匹配，请重新检查";
+        readonly en: "The Preview Recovery proof has expired or does not match. Check again.";
+    };
+    readonly onlyTheOwnerIsolatedSessionCanFinalizeTheAcceptance: {
+        readonly zh: "只有 owner Isolated 会话可以完成验收提交";
+        readonly en: "Only the owner Isolated Session can finalize the acceptance commit.";
+    };
+    readonly thereIsNoLocalPreviewAwaitingAcceptance: {
+        readonly zh: "当前没有等待验收的 Local Preview";
+        readonly en: "There is no Local Preview awaiting acceptance.";
+    };
+    readonly theCommitWasCreatedButTheCheckoutRecordIs: {
+        readonly zh: "提交已创建，但 Checkout 记录丢失";
+        readonly en: "The commit was created, but the Checkout record is missing.";
+    };
+    readonly theCommitWasCreatedButSavingTheRetainedWorktree: {
+        readonly zh: "提交已创建，但保留 Worktree 状态写入失败";
+        readonly en: "The commit was created, but saving the retained Worktree state failed.";
+    };
+    readonly onlyTheOwnerIsolatedSessionCanRetryCleanup: {
+        readonly zh: "只有 owner Isolated 会话可以重试清理";
+        readonly en: "Only the owner Isolated Session can retry cleanup.";
+    };
+    readonly thereIsNoWorktreeCleanupToRetry: {
+        readonly zh: "当前没有待重试的 Worktree 清理";
+        readonly en: "There is no Worktree cleanup to retry.";
+    };
+    readonly aSessionThatInheritedItsSessionTargetCannotPerform162: {
+        readonly zh: "继承 Session Target 的会话不能执行 Finish";
+        readonly en: "A Session that inherited its Session Target cannot perform Finish.";
+    };
+    readonly localCheckoutDoesNotSupportFinish: {
+        readonly zh: "Local Checkout 不支持 Finish";
+        readonly en: "Local Checkout does not support Finish.";
+    };
+    readonly thisReviewCardIsNoLongerTheCurrentReview166: {
+        readonly zh: "该验收卡已不是当前 Review，请刷新并确认最新交付";
+        readonly en: "This review card is no longer the current Review. Refresh and confirm the latest delivery.";
+    };
+    readonly thisLegacyWorktreeWasWrittenToLocalThroughAn: {
+        readonly zh: "该历史 Worktree 已通过旧版 Apply 写入 Local；为避免遗漏或重复提交，已禁止自动 Finish，请先人工核对 Local 后再清理记录。";
+        readonly en: "This legacy Worktree was written to Local through an older Apply. Automatic Finish is disabled to avoid missing or duplicate commits. Check Local manually before cleaning up the record.";
+    };
+    readonly cannotFinishDirectlyInTheCurrentState: {
+        readonly zh: "当前 {p0}/{p1} 状态不能直接 Finish";
+        readonly en: "Cannot Finish directly in the current {p0}/{p1} state.";
+    };
+    readonly worktreeChangedAfterReviewPrepareTheReviewAgain: {
+        readonly zh: "Worktree 在验收后又发生变化，请重新准备验收";
+        readonly en: "Worktree changed after review. Prepare the review again.";
+    };
+    readonly skipLocalAcceptanceAndCommitDirectly: {
+        readonly zh: "跳过 Local 验收并直接提交";
+        readonly en: "Skip Local acceptance and commit directly.";
+    };
+    readonly theTaskCommitWasCreatedButTheCheckoutRecord: {
+        readonly zh: "任务提交已创建，但 Checkout 记录丢失，需要人工检查";
+        readonly en: "The task commit was created, but the Checkout record is missing. Manual inspection is required.";
+    };
+    readonly theTaskCommitWasCreatedButSavingTheRetained: {
+        readonly zh: "任务提交已创建，但保留 Worktree 状态写入失败";
+        readonly en: "The task commit was created, but saving the retained Worktree state failed.";
+    };
+    readonly aSessionThatInheritedItsSessionTargetCannotPerform178: {
+        readonly zh: "继承 Session Target 的会话不能执行 Discard";
+        readonly en: "A Session that inherited its Session Target cannot perform Discard.";
+    };
+    readonly localCheckoutDoesNotSupportDiscard: {
+        readonly zh: "Local Checkout 不支持 Discard";
+        readonly en: "Local Checkout does not support Discard.";
+    };
+    readonly localPreviewDriftedIntoDetachedRecoveryToPreserveRecovery: {
+        readonly zh: "Local Preview 已因漂移进入 detached 恢复态；为保留恢复证据，不能删除 Worktree。请先成功撤回 Preview。";
+        readonly en: "Local Preview drifted into detached recovery. To preserve recovery evidence, this Worktree cannot be deleted. Successfully roll back Preview first.";
+    };
+    readonly thisLegacyWorktreeWasWrittenToLocalThroughAn183: {
+        readonly zh: "该历史 Worktree 已通过旧版 Apply 写入 Local；不会自动 Discard，请先人工核对 Local 的未提交修改。";
+        readonly en: "This legacy Worktree was written to Local through an older Apply. Automatic Discard is disabled. Check Local's uncommitted changes manually first.";
+    };
+    readonly thisTaskIsPreviewingInLocalSafelyRollBack: {
+        readonly zh: "本任务正在 Local 预览；放弃任务前必须先安全撤回 Preview";
+        readonly en: "This task is previewing in Local. Safely roll back Preview before discarding the task.";
+    };
+    readonly cannotDiscardInTheCurrentState: {
+        readonly zh: "当前 {p0} 状态不能 Discard";
+        readonly en: "Cannot Discard in the current {p0} state.";
+    };
+    readonly confirmationWillPermanentlyDeleteCheckpointsNotYetDeliveredTo: {
+        readonly zh: "；确认后会永久删除 {p0} 个尚未交付到 Local 的阶段";
+        readonly en: "; confirmation will permanently delete {p0} checkpoints not yet delivered to Local";
+    };
+    readonly theIsolatedCheckoutHasUncommittedChangesUndeliveredCheckpointsOr: {
+        readonly zh: "Isolated Checkout 含未提交修改、未交付阶段或状态无法确认，需要明确确认{p0}";
+        readonly en: "The Isolated Checkout has uncommitted changes, undelivered checkpoints, or an unverified state. Explicit confirmation is required{p0}";
+    };
+    readonly failedToDeleteTheManagedCheckout: {
+        readonly zh: "删除 managed checkout 失败";
+        readonly en: "Failed to delete the managed checkout.";
+    };
+    readonly aSessionThatInheritedItsSessionTargetCannotPerform192: {
+        readonly zh: "继承 Session Target 的会话不能执行 Recover";
+        readonly en: "A Session that inherited its Session Target cannot perform Recover.";
+    };
+    readonly localCheckoutDoesNotSupportRecover: {
+        readonly zh: "Local Checkout 不支持 Recover";
+        readonly en: "Local Checkout does not support Recover.";
+    };
+    readonly cannotSafelyDetermineWhetherApplyModifiedLocalItWill: {
+        readonly zh: "Apply 是否已修改 Local 无法安全确认；不会自动重试或猜测成功";
+        readonly en: "Cannot safely determine whether Apply modified Local. It will not retry automatically or assume success.";
+    };
+    readonly theIsolatedCheckoutIsMissingOnlyAnExplicitDiscard: {
+        readonly zh: "Isolated Checkout 缺失，只能由 owner 明确 Discard 收口";
+        readonly en: "The Isolated Checkout is missing. Only an explicit Discard by its owner can close it.";
+    };
+    readonly theIsolatedCheckoutPathGitIdentityProjectHEADOr: {
+        readonly zh: "Isolated Checkout 的路径、Git 身份、项目、HEAD 或状态无法完整确认";
+        readonly en: "The Isolated Checkout path, Git identity, project, HEAD, or state cannot be fully verified.";
+    };
+    readonly deletedAgentSession: {
+        readonly zh: "已删除的 Agent 会话";
+        readonly en: "Deleted Agent Session";
+    };
+    readonly theCurrentIterationIsStillBeingEditedAndHas: {
+        readonly zh: "当前轮次仍在修改，尚未形成可清理的交付环境。";
+        readonly en: "The current iteration is still being edited and has no delivered environment to clean up.";
+    };
+    readonly theCurrentIterationIsAwaitingAcceptanceAndCannotBe: {
+        readonly zh: "当前轮次正在等待验收，不能清理。";
+        readonly en: "The current iteration is awaiting acceptance and cannot be cleaned up.";
+    };
+    readonly localPreviewHasNotBeenSafelyResolvedAndCannot: {
+        readonly zh: "Local Preview 尚未完成安全收口，不能清理。";
+        readonly en: "Local Preview has not been safely resolved and cannot be cleaned up.";
+    };
+    readonly worktreeHasBeenDeliveredAndReleasedFromManagementNo: {
+        readonly zh: "Worktree 已交付并解除管理，无需再次清理。";
+        readonly en: "Worktree has been delivered and released from management. No further cleanup is needed.";
+    };
+    readonly theLocalCheckoutIdentityCannotBeVerifiedThisIteration: {
+        readonly zh: "Local checkout identity 无法验证，不能证明本轮交付仍存在。";
+        readonly en: "The Local checkout identity cannot be verified; this iteration's delivery cannot be proven to exist.";
+    };
+    readonly thisIterationSDeliveryCommitIsNoLongerIn: {
+        readonly zh: "本轮交付 commit 已不在 Local 历史中，不能清理环境。";
+        readonly en: "This iteration's delivery commit is no longer in Local history. The environment cannot be cleaned up.";
+    };
+    readonly cannotVerifyWhetherThisIterationSDeliveryCommitIs: {
+        readonly zh: "无法验证本轮交付 commit 是否仍在 Local 历史中。";
+        readonly en: "Cannot verify whether this iteration's delivery commit is still in Local history.";
+    };
+    readonly theCleanupDirectoryIdentityCannotBeReverifiedTheEnvironment: {
+        readonly zh: "清理目录身份无法重新验证，已保留环境。";
+        readonly en: "The cleanup directory identity cannot be reverified. The environment was preserved.";
+    };
+    readonly theWorktreeCheckoutIdentityCannotBeVerifiedTheEnvironment: {
+        readonly zh: "Worktree checkout identity 无法验证，已保留环境。";
+        readonly en: "The Worktree checkout identity cannot be verified. The environment was preserved.";
+    };
+    readonly newChangesWereDetectedAfterCommitOrRetentionBulk: {
+        readonly zh: "提交或保留后检测到新增修改，不能批量清理。";
+        readonly en: "New changes were detected after commit or retention. Bulk cleanup is not allowed.";
+    };
+    readonly cannotProveTheCurrentWorktreeStateIsSafeThe: {
+        readonly zh: "无法证明 Worktree 当前状态安全，已保留环境。";
+        readonly en: "Cannot prove the current Worktree state is safe. The environment was preserved.";
+    };
+    readonly thePreviousCleanupDidNotFinishRevalidateAndRetry: {
+        readonly zh: "上次清理未完成，可重新校验后重试。";
+        readonly en: "The previous cleanup did not finish. Revalidate and retry.";
+    };
+    readonly retainedManuallyAtTheUserSRequest: {
+        readonly zh: "按用户选择手动保留。";
+        readonly en: "Retained manually at the user's request.";
+    };
+    readonly theRetentionPeriodHasNotExpired: {
+        readonly zh: "保留期限尚未到期。";
+        readonly en: "The retention period has not expired.";
+    };
+    readonly readOnlySafetyInspectionPassedCleanupIsAvailable: {
+        readonly zh: "已通过只读安全巡检，可以清理。";
+        readonly en: "Read-only safety inspection passed. Cleanup is available.";
+    };
+    readonly theWorktreeRevisionHasChangedCleanupWasNotPerformed: {
+        readonly zh: "Worktree revision 已变化，未执行清理。";
+        readonly en: "The Worktree revision has changed. Cleanup was not performed.";
+    };
+    readonly worktreeChangedBeforeCleanupCleanupWasNotPerformed: {
+        readonly zh: "Worktree 在清理前发生变化，未执行清理。";
+        readonly en: "Worktree changed before cleanup. Cleanup was not performed.";
+    };
+    readonly theWorktreeRecordDoesNotExist: {
+        readonly zh: "Worktree 记录不存在";
+        readonly en: "The Worktree record does not exist.";
+    };
+    readonly theCurrentSessionIsNotAllowedToManageThis: {
+        readonly zh: "当前 Session 无权管理该 Worktree";
+        readonly en: "The current Session is not allowed to manage this Worktree.";
+    };
+    readonly theOwnerSessionHasTakenOverThisWorktreeOnly: {
+        readonly zh: "Owner Session 已接管该 Worktree，只有 owner 可以管理";
+        readonly en: "The owner Session has taken over this Worktree. Only the owner can manage it.";
+    };
+    readonly theCurrentSessionAndWorktreeDoNotBelongTo: {
+        readonly zh: "当前 Session 与 Worktree 不属于同一原始项目";
+        readonly en: "The current Session and Worktree do not belong to the same original project.";
+    };
+    readonly theWorktreeStateHasChangedRefreshAndRetry: {
+        readonly zh: "Worktree 状态已变化，请刷新后重试";
+        readonly en: "The Worktree state has changed. Refresh and retry.";
+    };
+    readonly onlyRetainedFrozenWorktreesCanHaveTheirRetentionPeriod: {
+        readonly zh: "只有已保留的冻结 Worktree 可以调整保留期限";
+        readonly en: "Only retained, frozen Worktrees can have their retention period changed.";
+    };
+    readonly theCurrentWorktreeIsNotInACleanableState: {
+        readonly zh: "当前 Worktree 不处于可清理状态";
+        readonly en: "The current Worktree is not in a cleanable state.";
+    };
+    readonly theWorktreeDirectoryNoLongerExists: {
+        readonly zh: "Worktree 目录已不存在";
+        readonly en: "The Worktree directory no longer exists.";
+    };
+    readonly theWorktreeDirectoryIdentityCannotBeVerified: {
+        readonly zh: "Worktree 目录身份无法验证";
+        readonly en: "The Worktree directory identity cannot be verified.";
+    };
+    readonly onlyADeliveredIsolatedSessionCanBeginTheNext: {
+        readonly zh: "只有已交付的 Isolated Session 可以开始下一轮";
+        readonly en: "Only a delivered Isolated Session can begin the next iteration.";
+    };
+    readonly thePreviousIterationSWorktreeRecordDoesNotExist: {
+        readonly zh: "上一轮 Worktree 记录不存在";
+        readonly en: "The previous iteration's Worktree record does not exist.";
+    };
+    readonly onlyTheOwnerSessionCanBeginTheNextIteration: {
+        readonly zh: "只有 owner Session 可以开始下一轮";
+        readonly en: "Only the owner Session can begin the next iteration.";
+    };
+    readonly theWorktreeStateHasChangedRefreshBeforeBeginningThe: {
+        readonly zh: "Worktree 状态已变化，请刷新后再开始下一轮";
+        readonly en: "The Worktree state has changed. Refresh before beginning the next iteration.";
+    };
+    readonly onlyADeliveredStateWithSuccessfulCleanupCanBegin: {
+        readonly zh: "只有已成功清理的交付状态可以开始下一轮";
+        readonly en: "Only a delivered state with successful cleanup can begin the next iteration.";
+    };
+    readonly theCurrentSessionIsNotAssociatedWithAWorkspace: {
+        readonly zh: "当前 Session 尚未关联 Workspace";
+        readonly en: "The current Session is not associated with a Workspace.";
+    };
+    readonly theCurrentSessionSImmutableCwdDoesNotMatch: {
+        readonly zh: "当前 Session 的 immutable cwd 与上一轮 Worktree 不一致";
+        readonly en: "The current Session's immutable cwd does not match the previous iteration's Worktree.";
+    };
+    readonly thePreviousIterationSWorktreePathHasReappearedUnknown: {
+        readonly zh: "上一轮 Worktree 路径已重新出现，拒绝覆盖未知内容";
+        readonly en: "The previous iteration's Worktree path has reappeared. Unknown content will not be overwritten.";
+    };
+    readonly theOriginalLocalProjectIsUnavailableTheNextIteration: {
+        readonly zh: "原始 Local 项目已不可用，不能开始下一轮";
+        readonly en: "The original Local project is unavailable. The next iteration cannot begin.";
+    };
+    readonly theOriginalLocalProjectIdentityHasChanged: {
+        readonly zh: "原始 Local 项目身份已变化";
+        readonly en: "The original Local project identity has changed.";
+    };
+    readonly theOriginalLocalGitIdentityHasChanged: {
+        readonly zh: "原始 Local Git 身份已变化";
+        readonly en: "The original Local Git identity has changed.";
+    };
+    readonly theProjectRootIsNotInsideItsGitCheckout: {
+        readonly zh: "项目根目录不在其 Git checkout 内";
+        readonly en: "The project root is not inside its Git checkout.";
+    };
+    readonly thePreviousIterationSManagedProjectPathCannotBe: {
+        readonly zh: "上一轮 managed project 路径无法从 Local 身份重建";
+        readonly en: "The previous iteration's managed project path cannot be reconstructed from the Local identity.";
+    };
+    readonly theWorktreeContainerIsNotATrustedDirectory: {
+        readonly zh: "Worktree 容器不是可信目录";
+        readonly en: "The Worktree container is not a trusted directory.";
+    };
+    readonly theWorktreeContainerPathHasBeenRedirected: {
+        readonly zh: "Worktree 容器路径已被重定向";
+        readonly en: "The Worktree container path has been redirected.";
+    };
+    readonly theNextIterationSCheckoutGitIdentityDoesNot: {
+        readonly zh: "下一轮 checkout 的 Git 身份不匹配";
+        readonly en: "The next iteration's checkout Git identity does not match.";
+    };
+    readonly theStateChangedWhileCreatingTheNextIterationS: {
+        readonly zh: "下一轮 Worktree 创建期间状态已变化";
+        readonly en: "The state changed while creating the next iteration's Worktree.";
+    };
+    readonly creatingTheNextIterationSWorktreeFailedAndIts: {
+        readonly zh: "下一轮 Worktree 创建失败且残余目录包含未知内容，已保留现场";
+        readonly en: "Creating the next iteration's Worktree failed and its remaining directory contains unknown content. The environment was preserved.";
+    };
+    readonly theSessionIsAlreadyBoundToASessionTarget: {
+        readonly zh: "会话已经绑定 Session Target，不能切换";
+        readonly en: "The Session is already bound to a Session Target and cannot switch.";
+    };
+    readonly aNonGitProjectCannotCreateAnIsolatedCheckout: {
+        readonly zh: "非 Git 项目不能创建 Isolated Checkout";
+        readonly en: "A non-Git project cannot create an Isolated Checkout.";
+    };
+    readonly theFallbackWorktreeContainerIsNotATrustedDirectory: {
+        readonly zh: "Worktree 回退容器不是可信目录，未创建或修改任何 checkout";
+        readonly en: "The fallback Worktree container is not a trusted directory. No checkout was created or modified.";
+    };
+    readonly allWorktreeCheckoutIdentityPathsAlreadyExistUnknownDirectories: {
+        readonly zh: "Worktree Checkout identity 路径均已存在，拒绝覆盖未知目录";
+        readonly en: "All Worktree Checkout identity paths already exist. Unknown directories will not be overwritten.";
+    };
+    readonly theNewCheckoutSGitCommonDirectoryDoesNot: {
+        readonly zh: "新建 checkout 的 Git common dir 不匹配";
+        readonly en: "The new checkout's Git common directory does not match.";
+    };
+    readonly worktreeCreationFailedAndTheRemainingDirectoryContainsUnknown: {
+        readonly zh: "Worktree 创建失败且残余目录包含未知内容，已保留现场，请查看原因或改用新会话";
+        readonly en: "Worktree creation failed and the remaining directory contains unknown content. The environment was preserved. Check the cause or use a new Session.";
+    };
+    readonly worktreeCreationFailedTheRemainingDirectoryWasSafelyCleaned: {
+        readonly zh: "Worktree 创建失败，已安全清理残余目录，可直接重试";
+        readonly en: "Worktree creation failed. The remaining directory was safely cleaned up; you can retry.";
+    };
+    readonly anIsolatedTargetRequiresASeparatePreallocatedSessionID: {
+        readonly zh: "Isolated Target 必须使用独立的预分配 Session ID";
+        readonly en: "An Isolated Target requires a separate preallocated Session ID.";
+    };
+    readonly theTargetSessionIDIsAlreadyUsedByAnother: {
+        readonly zh: "目标 Session ID 已被其他 Workspace 使用";
+        readonly en: "The target Session ID is already used by another Workspace.";
+    };
+    readonly aNewIsolatedTargetCanOnlyBeCreatedFrom: {
+        readonly zh: "只能从 Local Session 创建新的 Isolated Target";
+        readonly en: "A new Isolated Target can only be created from a Local Session.";
+    };
+    readonly theIsolatedTargetRecordIsMissingAfterCreation: {
+        readonly zh: "Isolated Target 创建后记录缺失";
+        readonly en: "The Isolated Target record is missing after creation.";
+    };
+    readonly gitExitedWithCode: {
+        readonly zh: "git 命令退出码为 {p0}";
+        readonly en: "git exited with code {p0}";
+    };
+    readonly gitCommandTimedOut: {
+        readonly zh: "git 命令超时：{p0}";
+        readonly en: "git command timed out: {p0}";
+    };
+    readonly theLocalBranchHasChangedPreviewCannotBeRolled: {
+        readonly zh: "Local branch 已变化，不能自动撤回 Preview";
+        readonly en: "The Local branch has changed. Preview cannot be rolled back automatically.";
+    };
+    readonly localHEADIsNotASafeFastForwardFrom: {
+        readonly zh: "Local HEAD 不是 Preview 基线的安全快进，不能自动撤回";
+        readonly en: "Local HEAD is not a safe fast-forward from the Preview base. Automatic rollback is not allowed.";
+    };
+    readonly newLocalCommitsConflictWithPrePreviewLocalChanges: {
+        readonly zh: "Local 新提交与 Preview 前的本地修改冲突，无法安全撤回：{p0}";
+        readonly en: "New Local commits conflict with pre-Preview local changes. Safe rollback is not possible: {p0}";
+    };
+    readonly newLocalCommitsConflictWithThePreviewTaskChanges: {
+        readonly zh: "Local 新提交与 Preview 任务增量冲突，无法安全撤回：{p0}";
+        readonly en: "New Local commits conflict with the Preview task changes. Safe rollback is not possible: {p0}";
+    };
+    readonly newLocalCommitsAlreadyContainSomeOrAllPreview: {
+        readonly zh: "Local 新提交已经包含部分或全部 Preview 增量，不能通过撤回工作区改动来改写已提交历史";
+        readonly en: "New Local commits already contain some or all Preview changes. Rolling back workspace changes cannot rewrite committed history.";
+    };
+    readonly localHasAdditionalChangesInThePreviewAreaSafe: {
+        readonly zh: "Local 在 Preview 区域出现额外修改，无法安全撤回：{p0}";
+        readonly en: "Local has additional changes in the Preview area. Safe rollback is not possible: {p0}";
+    };
+    readonly localIsNotOnANormalBranchATask: {
+        readonly zh: "Local 当前不是普通分支，不能自动创建任务提交";
+        readonly en: "Local is not on a normal branch. A task commit cannot be created automatically.";
+    };
+    readonly theLocalBranchHasChangedThePreviewCommitCannot: {
+        readonly zh: "Local branch 已变化，不能完成 Preview 提交";
+        readonly en: "The Local branch has changed. The Preview commit cannot be finalized.";
+    };
+    readonly localHEADIsNotASafeFastForwardFrom281: {
+        readonly zh: "Local HEAD 不是 Preview 基线的安全快进，不能完成 Preview 提交";
+        readonly en: "Local HEAD is not a safe fast-forward from the Preview base. The Preview commit cannot be finalized.";
+    };
+    readonly localHasAdditionalChangesInThePreviewAreaA: {
+        readonly zh: "Local 在 Preview 区域出现额外修改，无法可靠提交：{p0}";
+        readonly en: "Local has additional changes in the Preview area. A reliable commit is not possible: {p0}";
+    };
+    readonly previewTaskChangesCannotBeReliablySeparatedFromThe: {
+        readonly zh: "Preview 任务增量无法与最新 Local HEAD 可靠拆分：{p0}";
+        readonly en: "Preview task changes cannot be reliably separated from the latest Local HEAD: {p0}";
+    };
+    readonly previewTaskChangesAreAlreadyInLocalHEADNo: {
+        readonly zh: "Preview 任务增量已经进入 Local HEAD；不会创建重复或空提交";
+        readonly en: "Preview task changes are already in Local HEAD. No duplicate or empty commit will be created.";
+    };
+    readonly thePreviewCommitCannotBeReliablySeparatedFromLocal: {
+        readonly zh: "Preview 提交与 Local staged 修改无法可靠分离：{p0}";
+        readonly en: "The Preview commit cannot be reliably separated from Local staged changes: {p0}";
+    };
+    readonly invalidCheckpointInput: {
+        readonly zh: "Checkpoint 输入无效";
+        readonly en: "Invalid Checkpoint input.";
+    };
+    readonly theCheckpointProjectDirectoryDoesNotBelongToThe: {
+        readonly zh: "Checkpoint 项目目录不属于当前 Worktree";
+        readonly en: "The Checkpoint project directory does not belong to the current Worktree.";
+    };
+    readonly checkpointCanOnlyWriteToADetachedManagedWorktree: {
+        readonly zh: "Checkpoint 只允许写入 detached managed Worktree";
+        readonly en: "Checkpoint can only write to a detached managed Worktree.";
+    };
+    readonly worktreeChangedAfterPreparingTheReviewTheCheckpointCannot: {
+        readonly zh: "Worktree 在准备验收后发生变化，不能保存阶段";
+        readonly en: "Worktree changed after preparing the review. The checkpoint cannot be saved.";
+    };
+    readonly worktreeContainsChangesOutsideTheProjectRootTheCheckpoint: {
+        readonly zh: "Worktree 包含项目根目录外的变更，不能保存阶段";
+        readonly en: "Worktree contains changes outside the project root. The checkpoint cannot be saved.";
+    };
+    readonly theCurrentCheckpointHasNoNewChangesToSave: {
+        readonly zh: "当前阶段没有可保存的新修改";
+        readonly en: "The current checkpoint has no new changes to save.";
+    };
+    readonly worktreeChangedBeforeSavingTheCheckpointPrepareTheReview: {
+        readonly zh: "Worktree 在保存阶段前发生变化，请重新准备验收";
+        readonly en: "Worktree changed before saving the checkpoint. Prepare the review again.";
+    };
+    readonly checkpointIndexWriteFailedAndHEADCouldNotBe: {
+        readonly zh: "Checkpoint index 写入失败且 HEAD 无法回滚：{p0}；{p1}";
+        readonly en: "Checkpoint index write failed and HEAD could not be rolled back: {p0}; {p1}";
+    };
+    readonly checkpointWriteFailedAndWasRolledBack: {
+        readonly zh: "Checkpoint 写入失败，已回滚：{p0}";
+        readonly en: "Checkpoint write failed and was rolled back: {p0}";
+    };
+    readonly checkpointWasWrittenButWorktreeDidNotReachA: {
+        readonly zh: "Checkpoint 已写入，但 Worktree 未收敛到 clean 状态";
+        readonly en: "Checkpoint was written, but Worktree did not reach a clean state.";
+    };
+    readonly cannotVerifyTheCheckpointAfterWritingTheEnvironmentMust: {
+        readonly zh: "Checkpoint 写后无法完成验证，需要保留现场确认：{p0}";
+        readonly en: "Cannot verify the Checkpoint after writing. The environment must be preserved for inspection: {p0}";
+    };
+    readonly anotherGitOperationIsUpdatingTheWorktreeIndexRetry: {
+        readonly zh: "Worktree index 正在被其他 Git 操作更新，请重试";
+        readonly en: "Another Git operation is updating the Worktree index. Retry later.";
+    };
+    readonly invalidCheckpointRecoveryOID: {
+        readonly zh: "Checkpoint 恢复 OID 无效";
+        readonly en: "Invalid Checkpoint recovery OID.";
+    };
+    readonly worktreeNoLongerHasADetachedHEAD: {
+        readonly zh: "Worktree 已不再是 detached HEAD";
+        readonly en: "Worktree no longer has a detached HEAD.";
+    };
+    readonly cannotProveTheRemainingIndexLockBelongsToThe: {
+        readonly zh: "遗留 index.lock 无法证明属于当前 Checkpoint，已保留现场";
+        readonly en: "Cannot prove the remaining index.lock belongs to the current Checkpoint. The environment was preserved.";
+    };
+    readonly worktreeHEADDoesNotMatchTheCheckpointBeingRecovered: {
+        readonly zh: "Worktree HEAD 与待恢复 Checkpoint 不一致";
+        readonly en: "Worktree HEAD does not match the Checkpoint being recovered.";
+    };
+    readonly worktreeHasNewChangesAfterCheckpointInterruptionTheIndex: {
+        readonly zh: "Worktree 在 Checkpoint 中断后出现新修改，不能自动恢复 index";
+        readonly en: "Worktree has new changes after Checkpoint interruption. The index cannot be recovered automatically.";
+    };
+    readonly theIndexHasNewStagedChangesAfterCheckpointInterruption: {
+        readonly zh: "Checkpoint 中断后 index 出现新 staged 修改，不能自动覆盖";
+        readonly en: "The index has new staged changes after Checkpoint interruption. Automatic overwrite is not allowed.";
+    };
+    readonly theRemainingIndexLockDoesNotMatchTheCheckpoint: {
+        readonly zh: "遗留 index.lock 与 Checkpoint 目标不一致，已保留现场";
+        readonly en: "The remaining index.lock does not match the Checkpoint target. The environment was preserved.";
+    };
+    readonly worktreeOrItsIndexChangedBeforeAcquiringTheCheckpoint: {
+        readonly zh: "Checkpoint 恢复加锁前 Worktree 或 index 已变化";
+        readonly en: "Worktree or its index changed before acquiring the Checkpoint recovery lock.";
+    };
+    readonly worktreeIsStillNotCleanAfterCheckpointIndexRecovery: {
+        readonly zh: "Checkpoint index 恢复后仍未收敛到 clean 状态";
+        readonly en: "Worktree is still not clean after Checkpoint index recovery.";
+    };
+    readonly invalidSessionBaseOIDFormat: {
+        readonly zh: "Session Base OID 格式无效";
+        readonly en: "Invalid Session Base OID format.";
+    };
+    readonly localAndIsolatedDoNotBelongToTheSame: {
+        readonly zh: "Local 与 Isolated 不属于同一 Git 仓库";
+        readonly en: "Local and Isolated do not belong to the same Git repository.";
+    };
+    readonly theLocalAndIsolatedProjectSubdirectoriesDoNotMatch: {
+        readonly zh: "Local 与 Isolated 的项目子目录不一致";
+        readonly en: "The Local and Isolated project subdirectories do not match.";
+    };
+    readonly isolatedContainsChangesOutsideTheProjectRootAReview: {
+        readonly zh: "Isolated 包含项目根目录外的变更，不能准备验收";
+        readonly en: "Isolated contains changes outside the project root. A review cannot be prepared.";
+    };
+    readonly isolatedContainsChangesOutsideTheProjectRootApplyWas: {
+        readonly zh: "Isolated 包含项目根目录外的变更，已拒绝 Apply";
+        readonly en: "Isolated contains changes outside the project root. Apply was rejected.";
+    };
+    readonly theApplyPlanIsMissingAlreadyUsedOrModified: {
+        readonly zh: "Apply plan 不存在、已使用或已被修改";
+        readonly en: "The Apply plan is missing, already used, or modified.";
+    };
+    readonly theApplyPlanSGitRepositoryIdentityHasChanged: {
+        readonly zh: "Apply plan 的 Git 仓库身份已变化";
+        readonly en: "The Apply plan's Git repository identity has changed.";
+    };
+    readonly localChangedAfterPlanningRecalculateThePlan: {
+        readonly zh: "Local 在 plan 后发生变化，请重新计算";
+        readonly en: "Local changed after planning. Recalculate the plan.";
+    };
+    readonly isolatedChangedAfterPlanningRecalculateThePlan: {
+        readonly zh: "Isolated 在 plan 后发生变化，请重新计算";
+        readonly en: "Isolated changed after planning. Recalculate the plan.";
+    };
+    readonly localChangedBeforeApplyWroteItsChangesRecalculateThe: {
+        readonly zh: "Local 在 Apply 写入前发生变化，请重新计算";
+        readonly en: "Local changed before Apply wrote its changes. Recalculate the plan.";
+    };
+    readonly thePreviewPlanIsMissingAlreadyUsedOrModified: {
+        readonly zh: "Preview plan 不存在、已使用或已被修改";
+        readonly en: "The Preview plan is missing, already used, or modified.";
+    };
+    readonly invalidPreviewIdentity: {
+        readonly zh: "Preview identity 无效";
+        readonly en: "Invalid Preview identity.";
+    };
+    readonly thePreviewPlanSGitRepositoryIdentityHasChanged: {
+        readonly zh: "Preview plan 的 Git 仓库身份已变化";
+        readonly en: "The Preview plan's Git repository identity has changed.";
+    };
+    readonly thePersistentPreviewSnapshotDoesNotMatchTheReviewed: {
+        readonly zh: "Preview 持久快照与审核 plan 不一致";
+        readonly en: "The persistent Preview snapshot does not match the reviewed plan.";
+    };
+    readonly localChangedBeforePreviewWroteItsChangesRecalculateThe: {
+        readonly zh: "Local 在 Preview 写入前发生变化，请重新计算";
+        readonly en: "Local changed before Preview wrote its changes. Recalculate the plan.";
+    };
+    readonly theLocalSnapshotAfterPreviewDoesNotMatchThe: {
+        readonly zh: "Preview 写入后的 Local snapshot 与准备结果不一致，需要恢复确认";
+        readonly en: "The Local snapshot after Preview does not match the prepared result. Recovery confirmation is required.";
+    };
+    readonly localChangedBeforePreviewRollbackRetry: {
+        readonly zh: "Local 在撤回 Preview 前发生变化，请重试";
+        readonly en: "Local changed before Preview rollback. Retry.";
+    };
+    readonly cannotVerifyAfterWritingPreviewRollbackTheEnvironmentMust: {
+        readonly zh: "Preview 撤回写后无法完成验证，需要保留现场确认：{p0}";
+        readonly en: "Cannot verify after writing Preview rollback. The environment must be preserved for inspection: {p0}";
+    };
+    readonly theLocalSnapshotAfterPreviewRollbackDoesNotMatch: {
+        readonly zh: "Preview 撤回后的 Local snapshot 与安全恢复结果不一致，需要保留现场确认";
+        readonly en: "The Local snapshot after Preview rollback does not match the safe recovery result. The environment must be preserved for inspection.";
+    };
+    readonly theCommitMessageMustNotBeEmpty: {
+        readonly zh: "提交信息不能为空";
+        readonly en: "The commit message must not be empty.";
+    };
+    readonly localChangedBeforeFinalizingPreviewRetry: {
+        readonly zh: "Local 在完成 Preview 前发生变化，请重试";
+        readonly en: "Local changed before finalizing Preview. Retry.";
+    };
+    readonly thePreviewTaskCommitTreeDoesNotMatchThe: {
+        readonly zh: "Preview 任务提交 tree 与恢复评估不一致";
+        readonly en: "The Preview task commit tree does not match the recovery assessment.";
+    };
+    readonly thePreviewFinalIndexTreeDoesNotMatchThe: {
+        readonly zh: "Preview 最终 index tree 与恢复评估不一致";
+        readonly en: "The Preview final index tree does not match the recovery assessment.";
+    };
+    readonly anotherGitOperationIsUpdatingTheLocalIndexRetry: {
+        readonly zh: "Local index 正在被其他 Git 操作更新，请重试";
+        readonly en: "Another Git operation is updating the Local index. Retry later.";
+    };
+    readonly localChangedBeforeThePreviewCommitWasWrittenRetry: {
+        readonly zh: "Local 在 Preview 提交写入前发生变化，请重试";
+        readonly en: "Local changed before the Preview commit was written. Retry.";
+    };
+    readonly previewCommitVerificationFailedAfterWriting: {
+        readonly zh: "Preview 提交写后验证失败";
+        readonly en: "Preview commit verification failed after writing.";
+    };
+    readonly indexLocalIndexChangedAfterPreviewWroteItsChanges: {
+        readonly zh: "index: Local index 在 Preview 写入后发生变化，拒绝覆盖并发 staged 状态";
+        readonly en: "index: Local index changed after Preview wrote its changes. Concurrent staged state will not be overwritten.";
+    };
+    readonly refVerifiableIndexCompensationEvidenceIsMissingPartialRollback: {
+        readonly zh: "ref: 缺少可验证的 index 补偿证据，拒绝部分回滚";
+        readonly en: "ref: Verifiable index compensation evidence is missing. Partial rollback was rejected.";
+    };
+    readonly thePreviewCommitWriteCouldNotBeVerifiedAnd: {
+        readonly zh: "Preview 提交写入未能验证，已完整回滚：{p0}";
+        readonly en: "The Preview commit write could not be verified and was fully rolled back: {p0}";
+    };
+    readonly cannotProveSuccessOrCompleteRollbackAfterWritingThe: {
+        readonly zh: "Preview 提交写入后无法证明成功或完整回滚，需要保留现场确认：{p0}{p1}";
+        readonly en: "Cannot prove success or complete rollback after writing the Preview commit. The environment must be preserved for inspection: {p0}{p1}";
+    };
+    readonly theFinishPlanIsMissingAlreadyUsedOrModified: {
+        readonly zh: "Finish plan 不存在、已使用或已被修改";
+        readonly en: "The Finish plan is missing, already used, or modified.";
+    };
+    readonly theFinishPlanSGitRepositoryIdentityHasChanged: {
+        readonly zh: "Finish plan 的 Git 仓库身份已变化";
+        readonly en: "The Finish plan's Git repository identity has changed.";
+    };
+    readonly finishRevalidationFoundConflictsInconsistentWithTheReviewedPlan: {
+        readonly zh: "Finish 复验得到与已审核 plan 不一致的冲突";
+        readonly en: "Finish revalidation found conflicts inconsistent with the reviewed plan.";
+    };
+    readonly theFileSetChangedDuringFinishRevalidation: {
+        readonly zh: "Finish 复验的文件集合已变化";
+        readonly en: "The file set changed during Finish revalidation.";
+    };
+    readonly localChangedBeforeFinishRecalculateThePlan: {
+        readonly zh: "Local 在 Finish 前发生变化，请重新计算";
+        readonly en: "Local changed before Finish. Recalculate the plan.";
+    };
+    readonly taskChangesCannotBeReliablySeparatedFromExistingLocal: {
+        readonly zh: "任务增量无法与 Local 原有修改可靠拆分：{p0}";
+        readonly en: "Task changes cannot be reliably separated from existing Local changes: {p0}";
+    };
+    readonly theTaskCommitCannotBeReliablySeparatedFromExisting: {
+        readonly zh: "任务提交与 Local 原有 staged 修改无法可靠分离：{p0}";
+        readonly en: "The task commit cannot be reliably separated from existing Local staged changes: {p0}";
+    };
+    readonly localChangedBeforeFinishWroteItsChangesRecalculateThe: {
+        readonly zh: "Local 在 Finish 写入前发生变化，请重新计算";
+        readonly en: "Local changed before Finish wrote its changes. Recalculate the plan.";
+    };
+    readonly finishWriteFailedAndCompleteRollbackCouldNotBe: {
+        readonly zh: "Finish 写入失败且无法证明完整回滚：{p0}；{p1}";
+        readonly en: "Finish write failed and complete rollback could not be proven: {p0}; {p1}";
+    };
+    readonly finishWriteFailedAndWasRolledBack: {
+        readonly zh: "Finish 写入失败，已回滚：{p0}";
+        readonly en: "Finish write failed and was rolled back: {p0}";
+    };
+    readonly gitOperationFailed: {
+        readonly zh: "Git 操作失败（{p0}）：{p1}";
+        readonly en: "Git operation failed ({p0}): {p1}";
+    };
+    readonly unknownGitError: {
+        readonly zh: "未知 Git 错误";
+        readonly en: "Unknown Git error";
+    };
+    readonly worktreeToolsCanOnlyBeCalledInADSH: {
+        readonly zh: "worktree 工具只能在 DSH Agent 会话中调用";
+        readonly en: "Worktree tools can only be called in a DSH Agent Session.";
+    };
+    readonly reserveAUniqueManagedGitWorktreeAndADistinct: {
+        readonly zh: "预留一个唯一的托管 Git Worktree 及独立 owner Session ID。此操作不会改变当前会话 cwd。工具返回后，停止在此 Local 会话中修改代码，让用户从 Worktree 卡片打开隔离会话。";
+        readonly en: "Reserve a unique managed Git worktree and a distinct owner Session ID. This does not change the current Session cwd. After the tool returns, stop modifying code in this Local Session and let the user open the isolated Session from the Worktree card.";
+    };
+    readonly createIsolatedSessionTarget: {
+        readonly zh: "创建隔离会话目标";
+        readonly en: "Create isolated Session Target";
+    };
+    readonly listManagedWorktreesVisibleToTheCurrentSessionResults: {
+        readonly zh: "列出当前会话可见的托管 Worktree。结果仅限原始项目内由此会话拥有或创建的 Worktree。";
+        readonly en: "List managed worktrees visible to the current Session. Results are scoped to the original project and to worktrees this Session owns or created.";
+    };
+    readonly listManagedWorktrees: {
+        readonly zh: "列出托管 Worktree";
+        readonly en: "List managed worktrees";
+    };
+    readonly whenTheCurrentIsolatedSessionIsReadyForReview: {
+        readonly zh: "当前 Isolated Session 处于尚未同步 Local 的 Ready for Review，且用户提出新的代码或文件修改时，必须先自动调用本工具使旧 Review 失效并恢复同一轮 Working，然后直接继续执行请求。纯讨论、问答或补充信息不要调用；不要要求用户点击恢复编辑，也不要先同步 Local。";
+        readonly en: "When the current Isolated Session is Ready for Review but not yet synced to Local, and the user requests new code or file changes, automatically call this tool first to invalidate the old Review and resume Working in the same iteration, then continue the request directly. Do not call it for discussion, questions, or additional information. Do not ask the user to click resume editing or sync Local first.";
+    };
+    readonly theCurrentWorktreeHasNoUnsyncedReviewToResume372: {
+        readonly zh: "当前 Worktree 没有可恢复的未同步 Review: {p0}";
+        readonly en: "The current Worktree has no unsynced Review to resume: {p0}";
+    };
+    readonly worktreeDidNotReturnToWorkingState: {
+        readonly zh: "Worktree 未恢复到 working 状态: {p0}";
+        readonly en: "Worktree did not return to working state: {p0}";
+    };
+    readonly resumeWorktreeRevision: {
+        readonly zh: "恢复 Worktree 编辑";
+        readonly en: "Resume Worktree revision";
+    };
+    readonly whenTheCurrentIsolatedSessionHasBeenDeliveredAnd: {
+        readonly zh: "当当前 Isolated Session 已交付并完成 cleanup，而用户在同一对话中提出新的代码或文件修改时，先调用本工具安全重建同一个 immutable cwd 并进入下一轮，然后继续执行用户请求。不要改用 worktree_create；retained 或 cleanup_pending 状态不能调用。";
+        readonly en: "When the current Isolated Session has been delivered and cleanup is complete, and the user requests new code or file changes in the same conversation, call this tool first to safely recreate the same immutable cwd and begin the next iteration, then continue the request. Do not use worktree_create instead. Do not call this tool in retained or cleanup_pending state.";
+    };
+    readonly theNextWorktreeIterationDidNotEnterWorkingState: {
+        readonly zh: "下一轮 Worktree 未进入 working 状态: {p0}";
+        readonly en: "The next Worktree iteration did not enter working state: {p0}";
+    };
+    readonly startNextWorktreeIteration: {
+        readonly zh: "开始下一轮 Worktree";
+        readonly en: "Start next Worktree iteration";
+    };
+    readonly onlyForWorktreeSessionsThatHaveAlreadySelectedAn: {
+        readonly zh: "仅用于已经选择 Isolated Checkout 的 Worktree Session，普通 Local Checkout 任务必须用正常助手回复结束且不得调用本工具。它是 Isolated Session 的最后一个模型动作：把完整交付报告、验证证据和建议 Commit Message 仅写入本工具参数，然后立即停止。不要在调用前后用普通回复重复完整报告；最多用一句话提示用户通过底部验收条处理。用户会显式决定是否提交或放弃，模型不得自动提交或清理。";
+        readonly en: "Only for Worktree Sessions that have already selected an Isolated Checkout. Ordinary Local Checkout tasks must end with a normal assistant reply and must not call this tool. This is the Isolated Session's final model action: put the complete delivery report, validation evidence, and suggested commit message only in this tool's arguments, then stop immediately. Do not repeat the complete report in normal replies before or after calling it; at most one sentence may direct the user to the bottom acceptance bar. The user explicitly decides whether to commit or discard. The model must not automatically commit or clean up.";
+    };
+    readonly oneLineSummaryOfTheChangeMax240Chars: {
+        readonly zh: "一句话描述改动（最多 240 个字符）。";
+        readonly en: "One-line summary of the change (max 240 chars).";
+    };
+    readonly optionalFullMarkdownDetailsMax12000Chars: {
+        readonly zh: "可选的完整 Markdown 详情（最多 12000 个字符）。";
+        readonly en: "Optional full Markdown details (max 12000 chars).";
+    };
+    readonly optionalOneLineValidationOutcome: {
+        readonly zh: "可选的一句话验证结果。";
+        readonly en: "Optional one-line validation outcome.";
+    };
+    readonly suggestedCommitMessageForTheHumanAcceptanceAction: {
+        readonly zh: "建议用于人工验收操作的提交信息。";
+        readonly en: "Suggested commit message for the human acceptance action.";
+    };
+    readonly worktreeDidNotEnterAReviewableState: {
+        readonly zh: "worktree 未进入可验收状态: {p0}";
+        readonly en: "Worktree did not enter a reviewable state: {p0}";
+    };
+    readonly readyForWorktreeReview: {
+        readonly zh: "提交 Worktree 验收";
+        readonly en: "Ready for Worktree review";
+    };
+    readonly checkoutPhase: {
+        readonly zh: "检出：{p0}（{p1}，阶段 {p2}）";
+        readonly en: "checkout: {p0} ({p1}, phase {p2})";
+    };
+    readonly worktreeCanOnlyBeUsedInADSHAgent: {
+        readonly zh: "`/worktree` 只能在 DSH Agent 会话中使用";
+        readonly en: "`/worktree` can only be used in a DSH Agent Session.";
+    };
+    readonly usageWorktreeStatusListContinueNextFinalizeReviewIdRevision: {
+        readonly zh: "用法：/worktree status | list | continue | next | finalize [<reviewId> <revision>] [cleanup|retain_24h|retain_3d|retain_manual] | finish <message> | discard | remove <checkoutId>";
+        readonly en: "Usage: /worktree status | list | continue | next | finalize [<reviewId> <revision>] [cleanup|retain_24h|retain_3d|retain_manual] | finish <message> | discard | remove <checkoutId>";
+    };
+    readonly finishedCommittedFileSAsCleanup: {
+        readonly zh: "已完成：{p0} 个文件已提交为 {p1}（清理：{p2}）。";
+        readonly en: "Finished: committed {p0} file(s) as {p1} (cleanup: {p2}).";
+    };
+    readonly inspectAndExplicitlyAcceptManagedWorktreeDelivery: {
+        readonly zh: "查看并明确确认托管 Worktree 交付";
+        readonly en: "inspect and explicitly accept managed worktree delivery";
+    };
+    readonly statusListContinueNextFinalizeRetentionFinishMessageDiscard: {
+        readonly zh: "status（状态）| list（列表）| continue（继续修改）| next（下一轮）| finalize [retention]（验收提交）| finish <message>（直接提交）| discard（丢弃）| remove <checkoutId>（移除）";
+        readonly en: "status | list | continue | next | finalize [retention] | finish <message> | discard | remove <checkoutId>";
+    };
+    readonly noManagedWorktreesVisibleToThisSession: {
+        readonly zh: "当前会话没有可见的托管 Worktree。";
+        readonly en: "No managed worktrees visible to this Session.";
+    };
+    readonly theCurrentWorktreeHasNoUnsyncedReadyForReview: {
+        readonly zh: "当前 Worktree 没有尚未同步的 Ready for Review 验收稿。";
+        readonly en: "The current Worktree has no unsynced Ready for Review draft.";
+    };
+    readonly resumedWorktreeIterationLocalWasNotModified: {
+        readonly zh: "已恢复 Worktree 第 {p0} 轮；未修改 Local。";
+        readonly en: "Resumed Worktree iteration {p0}; Local was not modified.";
+    };
+    readonly startedWorktreeIterationInTheCurrentSession: {
+        readonly zh: "已在当前会话开始 Worktree 第 {p0} 轮。";
+        readonly en: "Started Worktree iteration {p0} in the current Session.";
+    };
+    readonly theCurrentWorktreeIsNotReadyForReviewAnd: {
+        readonly zh: "当前 Worktree 尚未 Ready for Review，不能 finalize。";
+        readonly en: "The current Worktree is not Ready for Review and cannot be finalized.";
+    };
+    readonly thisReviewCardHasExpiredConfirmTheLatestReady: {
+        readonly zh: "该验收卡已过期；请确认会话中的最新 Ready for Review 卡片。";
+        readonly en: "This review card has expired. Confirm the latest Ready for Review card in the Session.";
+    };
+    readonly conflictNLocalHEADSyncAndResolveConflictsInWorktree: {
+        readonly zh: "Conflict: {p0}\nLocal HEAD: {p1} — 在 Worktree 内同步并解决后重新 Ready。";
+        readonly en: "Conflict: {p0}\\nLocal HEAD: {p1} — Sync and resolve conflicts in Worktree, then mark it Ready again.";
+    };
+    readonly finalizeDidNotReturnTheExpectedResult: {
+        readonly zh: "Finalize 未返回预期结果";
+        readonly en: "Finalize did not return the expected result.";
+    };
+    readonly finishDidNotReturnTheExpectedResult: {
+        readonly zh: "Finish 未返回预期结果";
+        readonly en: "Finish did not return the expected result.";
+    };
+    readonly worktreeDiscardedThisSessionTargetIsNoLongerAvailable: {
+        readonly zh: "Worktree 已丢弃。此会话目标不再可用。";
+        readonly en: "Worktree discarded. This Session target is no longer available.";
+    };
+    readonly discardDidNotReturnTheExpectedResult: {
+        readonly zh: "Discard 未返回预期结果";
+        readonly en: "Discard did not return the expected result.";
+    };
+    readonly noManagedWorktreeVisibleToThisSession: {
+        readonly zh: "当前会话没有可见的托管 Worktree {p0}。";
+        readonly en: "No managed worktree {p0} visible to this Session.";
+    };
+    readonly removedWorktree: {
+        readonly zh: "已移除 Worktree {p0}。";
+        readonly en: "Removed worktree {p0}.";
+    };
+    readonly unknownVerb: {
+        readonly zh: "未知操作 {p0}。\\n{p1}";
+        readonly en: "Unknown verb {p0}.\n{p1}";
+    };
+    readonly conflictRecoveryIsMissingAValidLocalHEADIdentity: {
+        readonly zh: "冲突恢复缺少有效的 Local HEAD 身份";
+        readonly en: "Conflict recovery is missing a valid Local HEAD identity.";
+    };
+    readonly conflictRecoveryContainsUnsafeOrOutOfBoundsFile: {
+        readonly zh: "冲突恢复包含不安全或越界的文件身份";
+        readonly en: "Conflict recovery contains unsafe or out-of-bounds file identities.";
+    };
+    readonly theCurrentSessionCheckoutModuleDoesNotSupportAcceptancePreflight: {
+        readonly zh: "当前 SessionCheckoutModule 不支持验收预检";
+        readonly en: "The current SessionCheckoutModule does not support acceptance preflight.";
+    };
+    readonly theCurrentSessionDoesNotExist: {
+        readonly zh: "当前 Session 不存在";
+        readonly en: "The current Session does not exist.";
+    };
+    readonly theCurrentSessionIsNotAssociatedWithAProject: {
+        readonly zh: "当前 Session 尚未关联项目";
+        readonly en: "The current Session is not associated with a project.";
+    };
+    readonly theCurrentSessionSProjectDoesNotExist: {
+        readonly zh: "当前 Session 项目不存在";
+        readonly en: "The current Session's project does not exist.";
+    };
+    readonly theCurrentSessionSProjectDirectoryDoesNotExist: {
+        readonly zh: "当前 Session 项目目录不存在";
+        readonly en: "The current Session's project directory does not exist.";
+    };
+    readonly theCurrentSessionSProjectIsNotAnAvailable: {
+        readonly zh: "当前 Session 项目不是可用的 Git Worktree";
+        readonly en: "The current Session's project is not an available Git Worktree.";
+    };
+    readonly theCurrentSessionWorkspaceCannotBeProvenToBelong: {
+        readonly zh: "当前 Session Workspace 无法证明属于该 Worktree 的原始项目";
+        readonly en: "The current Session Workspace cannot be proven to belong to this Worktree's original project.";
+    };
+    readonly theCurrentSessionCwdDoesNotMatchTheWorktree: {
+        readonly zh: "当前 Session cwd 与 Worktree 授权边界不一致";
+        readonly en: "The current Session cwd does not match the Worktree authorization boundary.";
+    };
+    readonly theCurrentSessionIsNotAllowedToAccessThis: {
+        readonly zh: "当前 Session 无权访问该 Worktree";
+        readonly en: "The current Session is not allowed to access this Worktree.";
+    };
+    readonly worktreeDoesNotMatchTheCurrentSessionSProject: {
+        readonly zh: "Worktree 与当前 Session 项目不一致";
+        readonly en: "Worktree does not match the current Session's project.";
+    };
+    readonly theAssociatedWorktreeSOwnerSessionIsUnavailable: {
+        readonly zh: "关联 Worktree 的 owner Session 不可用";
+        readonly en: "The associated Worktree's owner Session is unavailable.";
+    };
+    readonly theAcceptanceSlotHolderHasChangedCheckAgain: {
+        readonly zh: "验收槽位占用者已变化，请重新检查";
+        readonly en: "The acceptance slot holder has changed. Check again.";
+    };
+    readonly theWorktreeGitIdentityCannotBeVerified: {
+        readonly zh: "Worktree Git 身份无法验证";
+        readonly en: "The Worktree Git identity cannot be verified.";
+    };
+    readonly theCurrentSessionWorkspaceCannotBeProvenToBe: {
+        readonly zh: "当前 Session Workspace 无法证明关联 Worktree 项目";
+        readonly en: "The current Session Workspace cannot be proven to be associated with the Worktree project.";
+    };
+    readonly hostIdentityVerificationFailedForTheNewlyCreatedWorktree: {
+        readonly zh: "新建 Worktree 的 Host 身份校验失败";
+        readonly en: "Host identity verification failed for the newly created Worktree.";
+    };
+    readonly onlyTheOwnerIsolatedSessionCanReadTheReview: {
+        readonly zh: "只有 owner Isolated Session 可以读取验收 Diff";
+        readonly en: "Only the owner Isolated Session can read the review Diff.";
+    };
+    readonly theSessionTargetHasChangedRefresh: {
+        readonly zh: "Session Target 已变化，请刷新";
+        readonly en: "The Session Target has changed. Refresh.";
+    };
+    readonly theReviewIdentityHasChangedRefresh: {
+        readonly zh: "Review 身份已变化，请刷新";
+        readonly en: "The Review identity has changed. Refresh.";
+    };
+    readonly isolatedHEADChangedAfterReady: {
+        readonly zh: "Ready 后 Isolated HEAD 已变化";
+        readonly en: "Isolated HEAD changed after Ready.";
+    };
+    readonly isolatedContentChangedAfterReadyDiffBytesWereDiscarded: {
+        readonly zh: "Ready 后 Isolated 内容已变化，Diff bytes 已丢弃";
+        readonly en: "Isolated content changed after Ready. Diff bytes were discarded.";
+    };
+    readonly onlyTheOwnerIsolatedSessionCanRunSyncPreflight436: {
+        readonly zh: "只有 owner Isolated Session 可以执行同步预检";
+        readonly en: "Only the owner Isolated Session can run sync preflight.";
+    };
+    readonly onlyTheOwnerIsolatedSessionCanCheckPreviewRecovery440: {
+        readonly zh: "只有 owner Isolated Session 可以检查 Preview 恢复";
+        readonly en: "Only the owner Isolated Session can check Preview recovery.";
+    };
+    readonly theDetachedPreviewIdentityHasChangedRefresh: {
+        readonly zh: "Detached Preview 身份已变化，请刷新";
+        readonly en: "The Detached Preview identity has changed. Refresh.";
+    };
+    readonly theCurrentSessionCheckoutModuleDoesNotSupportPreviewRecoveryPreflight: {
+        readonly zh: "当前 SessionCheckoutModule 不支持 Preview Recovery 预检";
+        readonly en: "The current SessionCheckoutModule does not support Preview Recovery preflight.";
+    };
+    readonly thePreviewRecoveryAnalysisIdentityDoesNotMatch: {
+        readonly zh: "Preview Recovery 分析身份不匹配";
+        readonly en: "The Preview Recovery analysis identity does not match.";
+    };
+    readonly thePreviewRecoveryHandoffIdentityDoesNotMatch: {
+        readonly zh: "Preview Recovery handoff 身份不匹配";
+        readonly en: "The Preview Recovery handoff identity does not match.";
+    };
+    readonly hostIdentityVerificationFailedForTheRecoveryHandoffWorktree: {
+        readonly zh: "Recovery handoff Worktree 的 Host 身份校验失败";
+        readonly en: "Host identity verification failed for the Recovery handoff Worktree.";
+    };
+    readonly onlyTheOwnerIsolatedSessionCanSaveACheckpoint447: {
+        readonly zh: "只有 owner Isolated Session 可以保存阶段";
+        readonly en: "Only the owner Isolated Session can save a checkpoint.";
+    };
+    readonly theCheckpointCommitMessageOrRequestIdIsInvalid: {
+        readonly zh: "Checkpoint Commit Message 或 requestId 无效";
+        readonly en: "The Checkpoint commit message or requestId is invalid.";
+    };
+    readonly checkpointReturnedAnUnexpectedState: {
+        readonly zh: "Checkpoint 返回了非预期状态";
+        readonly en: "Checkpoint returned an unexpected state.";
+    };
+    readonly worktreeDidNotReturnToWorkingAfterCheckpoint: {
+        readonly zh: "Checkpoint 后 Worktree 状态未收敛到 Working";
+        readonly en: "Worktree did not return to Working after Checkpoint.";
+    };
+    readonly onlyTheOwnerIsolatedSessionCanPreviewChanges: {
+        readonly zh: "只有 owner Isolated Session 可以预览修改";
+        readonly en: "Only the owner Isolated Session can preview changes.";
+    };
+    readonly localPreviewPreflightFoundContentConflicts: {
+        readonly zh: "Local Preview 预检发现内容冲突";
+        readonly en: "Local Preview preflight found content conflicts.";
+    };
+    readonly previewReturnedAnUnexpectedState: {
+        readonly zh: "Preview 返回了非预期状态";
+        readonly en: "Preview returned an unexpected state.";
+    };
+    readonly onlyTheOwnerIsolatedSessionCanResumeEditing456: {
+        readonly zh: "只有 owner Isolated Session 可以继续修改";
+        readonly en: "Only the owner Isolated Session can resume editing.";
+    };
+    readonly invalidConflictRecoveryRequestIdentity: {
+        readonly zh: "冲突恢复请求身份无效";
+        readonly en: "Invalid conflict recovery request identity.";
+    };
+    readonly theWorktreeIdentityOrStateDoesNotMatchAfter: {
+        readonly zh: "恢复编辑后 Worktree 身份或状态不一致";
+        readonly en: "The Worktree identity or state does not match after resuming editing.";
+    };
+    readonly theHostCouldNotPersistTheExactConflictRecovery: {
+        readonly zh: "Host 未能持久化精确冲突恢复凭证";
+        readonly en: "The Host could not persist the exact conflict recovery receipt.";
+    };
+    readonly onlyTheOwnerIsolatedSessionCanRequestReviewRegeneration462: {
+        readonly zh: "只有 owner Isolated Session 可以请求重新生成验收结果";
+        readonly en: "Only the owner Isolated Session can request review regeneration.";
+    };
+    readonly onlyTheOwnerIsolatedSessionCanRollBackLocal: {
+        readonly zh: "只有 owner Isolated Session 可以撤回 Local Preview";
+        readonly en: "Only the owner Isolated Session can roll back Local Preview.";
+    };
+    readonly rollbackPreviewReturnedAnUnexpectedState: {
+        readonly zh: "Rollback Preview 返回了非预期状态";
+        readonly en: "Rollback Preview returned an unexpected state.";
+    };
+    readonly theOwnerSessionHasTakenOverThisWorktreeOnly467: {
+        readonly zh: "Owner Session 已接管该 Worktree，只有 owner 可以 Discard";
+        readonly en: "The owner Session has taken over this Worktree. Only the owner can Discard it.";
+    };
+    readonly discardReturnedAnUnexpectedState: {
+        readonly zh: "Discard 返回了非预期状态";
+        readonly en: "Discard returned an unexpected state.";
+    };
+    readonly onlyTheOwnerIsolatedSessionCanCommitAcceptance: {
+        readonly zh: "只有 owner Isolated Session 可以提交验收";
+        readonly en: "Only the owner Isolated Session can commit acceptance.";
+    };
+    readonly theCommitMessageMustContain1500Characters: {
+        readonly zh: "Commit Message 必须为 1–500 个字符";
+        readonly en: "The commit message must contain 1–500 characters.";
+    };
+    readonly applyingToLocalCausedConflicts: {
+        readonly zh: "Local 应用发生冲突";
+        readonly en: "Applying to Local caused conflicts.";
+    };
+    readonly finalizeReturnedAnUnexpectedState: {
+        readonly zh: "Finalize 返回了非预期状态";
+        readonly en: "Finalize returned an unexpected state.";
+    };
+    readonly onlyTheOwnerIsolatedSessionCanFinalizeLocalPreview: {
+        readonly zh: "只有 owner Isolated Session 可以完成 Local Preview 验收";
+        readonly en: "Only the owner Isolated Session can finalize Local Preview acceptance.";
+    };
+    readonly finalizePreviewReturnedAnUnexpectedState: {
+        readonly zh: "Finalize Preview 返回了非预期状态";
+        readonly en: "Finalize Preview returned an unexpected state.";
+    };
+    readonly theNextWorktreeIterationDidNotEnterWorkingState484: {
+        readonly zh: "下一轮 Worktree 未进入 working 状态";
+        readonly en: "The next Worktree iteration did not enter working state.";
+    };
+    readonly theNextIterationSWorktreeLineageOrCwdIdentity: {
+        readonly zh: "下一轮 Worktree 的 lineage 或 cwd 身份不一致";
+        readonly en: "The next iteration's Worktree lineage or cwd identity does not match.";
+    };
+    readonly gitFailed: {
+        readonly zh: "git {p0} 失败（{p1}）：{p2}";
+        readonly en: "git {p0} failed ({p1}): {p2}";
+    };
+    readonly reviewChangedFilesContainsAnUnsafeProjectRelativePath: {
+        readonly zh: "验收 changedFiles 包含不安全的项目相对路径。";
+        readonly en: "review changedFiles contains an unsafe project-relative path";
+    };
+    readonly reviewDiffPathInventoryExceedsTheSafeReadBudget: {
+        readonly zh: "验收 Diff 路径清单超出安全读取额度。";
+        readonly en: "review diff path inventory exceeds the safe read budget";
+    };
+    readonly gitDiffReturnedAnUnsafeProjectRelativePath: {
+        readonly zh: "git diff 返回了不安全的项目相对路径。";
+        readonly en: "git diff returned an unsafe project-relative path";
+    };
+    readonly reviewChangedFilesNoLongerMatchesTheIsolatedSnapshot: {
+        readonly zh: "验收 changedFiles 不再匹配隔离快照。";
+        readonly en: "review changedFiles no longer matches the isolated snapshot";
+    };
+    readonly worktreeConsoleOperationFailed: {
+        readonly zh: "Worktree Console 操作失败";
+        readonly en: "Worktree Console operation failed.";
+    };
+    readonly theWorktreeQuarantinePathIsInvalidOrAlreadyOccupied: {
+        readonly zh: "Worktree quarantine 路径无效或已被占用";
+        readonly en: "The Worktree quarantine path is invalid or already occupied.";
+    };
+    readonly theWorktreeDirectoryObjectWasReplacedRecursiveCleanupWas: {
+        readonly zh: "Worktree 目录对象已被替换，未执行递归清理";
+        readonly en: "The Worktree directory object was replaced. Recursive cleanup was not performed.";
+    };
+    readonly refusingToDeleteWorktreeResidueThatIsNotA: {
+        readonly zh: "拒绝删除非目录或符号链接形式的 Worktree 残余";
+        readonly en: "Refusing to delete Worktree residue that is not a directory or is a symbolic link.";
+    };
+    readonly gitTimedOutMsAndWasTerminated: {
+        readonly zh: "git {p0} 超时（{p1}ms），已终止";
+        readonly en: "git {p0} timed out ({p1}ms) and was terminated.";
+    };
+    readonly gitOperationFailedGit: {
+        readonly zh: "Git 操作失败: git {p0}{p1}";
+        readonly en: "Git operation failed: git {p0}{p1}";
+    };
+    readonly invalidInternalGitArtifactName: {
+        readonly zh: "内部 Git artifact 名称无效";
+        readonly en: "Invalid internal Git artifact name.";
+    };
+    readonly cannotReadTheInternalGitArtifact: {
+        readonly zh: "无法读取内部 Git artifact";
+        readonly en: "Cannot read the internal Git artifact.";
+    };
+    readonly cannotProveGitCommitAncestry: {
+        readonly zh: "无法证明 Git commit ancestry";
+        readonly en: "Cannot prove Git commit ancestry.";
+    };
+    readonly managedCheckoutsJsonIsCorruptCheckoutAccessHasStopped: {
+        readonly zh: "managed-checkouts.json 损坏，已停止访问 checkout";
+        readonly en: "managed-checkouts.json is corrupt. Checkout access has stopped.";
+    };
+    readonly commandDirty: {
+        readonly zh: "有未提交修改：{value}";
+        readonly en: "dirty: {value}";
+    };
+    readonly commandCurrent: {
+        readonly zh: "当前：{branch} @ {oid}";
+        readonly en: "current: {branch} @ {oid}";
+    };
+    readonly commandDelivery: {
+        readonly zh: "交付：{state}";
+        readonly en: "delivery: {state}";
+    };
+    readonly commandDetached: {
+        readonly zh: "分离 HEAD";
+        readonly en: "detached";
+    };
+    readonly commandNoOp: {
+        readonly zh: "无新增提交";
+        readonly en: "no-op";
+    };
+    readonly cleanupIdentityChanged: {
+        readonly zh: "Worktree 的 Git 身份或路径已变化，未执行清理。";
+        readonly en: "The Worktree Git identity or path has changed. Cleanup was not performed.";
+    };
+    readonly cleanupResidue: {
+        readonly zh: "Git Worktree 已解除注册，仅剩物理目录残余；可重试清理环境。";
+        readonly en: "Git Worktree has been unregistered; only directory residue remains. Environment cleanup can be retried.";
+    };
+    readonly cleanupIncompleteDelivery: {
+        readonly zh: "Worktree 交付状态不完整，未执行清理。";
+        readonly en: "The Worktree delivery state is incomplete. Cleanup was not performed.";
+    };
+    readonly cleanupIncompleteReceipt: {
+        readonly zh: "Worktree cleanup receipt 不完整";
+        readonly en: "The Worktree cleanup receipt is incomplete.";
+    };
+    readonly cleanupMissingBeforeQuarantine: {
+        readonly zh: "Worktree 记录在 quarantine 前丢失";
+        readonly en: "The Worktree record was lost before quarantine.";
+    };
+    readonly cleanupQuarantineIdentity: {
+        readonly zh: "Worktree quarantine 身份无法验证";
+        readonly en: "The Worktree quarantine identity cannot be verified.";
+    };
+    readonly cleanupNewChanges: {
+        readonly zh: "Worktree 在提交后出现了新修改，未执行清理。";
+        readonly en: "Worktree has new changes after the commit. Cleanup was not performed.";
+    };
+    readonly cleanupMissingBeforeRemoval: {
+        readonly zh: "Worktree 记录在清理前丢失，未执行清理。";
+        readonly en: "The Worktree record was lost before cleanup. Cleanup was not performed.";
+    };
+    readonly cleanupQuarantineBusy: {
+        readonly zh: "Worktree 已安全移入 quarantine，但目录仍被进程占用；dsh-git-worktree 会在同一清理授权内有限重试。";
+        readonly en: "Worktree was safely moved into quarantine, but a process still holds the directory. dsh-git-worktree will retry a limited number of times under the same cleanup authorization.";
+    };
+    readonly cleanupDirectoryBusy: {
+        readonly zh: "Worktree 目录仍被进程占用或 Windows 暂时拒绝删除；dsh-git-worktree 已完成有限重试，可稍后重试清理。";
+        readonly en: "A process still holds the Worktree directory or Windows temporarily denied deletion. dsh-git-worktree has completed its limited retries. Retry cleanup later.";
+    };
+    readonly commandConflict: {
+        readonly zh: "冲突：{files}";
+        readonly en: "Conflict: {files}";
+    };
+    readonly localCheckout: {
+        readonly zh: "本地检出";
+        readonly en: "Local Checkout";
+    };
+    readonly isolatedCheckout: {
+        readonly zh: "隔离检出";
+        readonly en: "Isolated Checkout";
+    };
+    readonly cleanupTimeout: {
+        readonly zh: "[session-checkout] {p0} 清理超时（{p1}ms），已跳过本次收敛";
+        readonly en: "[session-checkout] Cleanup of {p0} timed out ({p1}ms); skipped this reconciliation.";
+    };
+    readonly checkpointRefCleanupFailed: {
+        readonly zh: "[session-checkout] 清理未生效 Checkpoint ref 失败，已保守保留不可见引用";
+        readonly en: "[session-checkout] Failed to clean up the unapplied Checkpoint ref; conservatively retained the hidden ref.";
+    };
+    readonly tempDirectoryCleanupFailed: {
+        readonly zh: "[session-checkout-apply] 临时目录清理失败：";
+        readonly en: "[session-checkout-apply] Failed to clean up the temporary directory:";
+    };
+    readonly corruptPrimaryIndex: {
+        readonly zh: "[数据恢复] 主索引文件损坏: {p0}";
+        readonly en: "[Data recovery] Primary index file is corrupt: {p0}";
+    };
+    readonly recoveredFromTmp: {
+        readonly zh: "[数据恢复] 从 .tmp 文件恢复: {p0}";
+        readonly en: "[Data recovery] Recovered from .tmp file: {p0}";
+    };
+    readonly recoveredFromBak: {
+        readonly zh: "[数据恢复] 从 .bak 文件恢复: {p0}";
+        readonly en: "[Data recovery] Recovered from .bak file: {p0}";
+    };
+    readonly corruptBackupIndex: {
+        readonly zh: "[数据恢复] .bak 文件也损坏: {p0}";
+        readonly en: "[Data recovery] The .bak file is also corrupt: {p0}";
+    };
+    readonly previewRefsCleanupFailed: {
+        readonly zh: "[session-checkout] 清理 Preview refs 失败，已保守保留不可见引用";
+        readonly en: "[session-checkout] Failed to clean up Preview refs; conservatively retained the hidden refs.";
+    };
+    readonly internalRefsCleanupFailed: {
+        readonly zh: "[session-checkout] 清理内部 Session Checkout refs 失败，已保守保留不可见引用";
+        readonly en: "[session-checkout] Failed to clean up internal Session Checkout refs; conservatively retained the hidden refs.";
+    };
+};
+/** Registration metadata is shared between sessions, so expose both languages. */
+export declare function hostRegistrationMessage(key: keyof typeof hostMessages): string;
+export declare function hostPersistedCleanupMessage(message: string, translate: Translator<typeof hostMessages>): string;