dsh-tower 1.1.2 → 1.2.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 1.2.0 — 2026-10-18
+
+- **`tower_merge` 对“提交已落地但调用报错”的恢复**：合并命令失败/超时后检查 `HEAD`，若已是
+  `[baseTip, branchTip]` 双父合并提交则视为成功并记录；失败时清理 `MERGE_HEAD` 与陈旧锁文件，
+  只回滚与本 mission 相关的路径，避免 index/工作树残留。
+- **区分失败类型**：真实内容冲突返回 `merge-conflict`（保留 blocked 语义）；hook/进程失败返回
+  `merge-hook-failed`，附带 `timeout: true`（超时）与 `cleanup` 字段，mission 保持 `completed`
+  以便重试。
+- **合并超时可配置**：`tower_merge` 新增 `timeoutMs` 参数（默认 15 分钟），并把合并输出缓冲提升到
+  64 MB，慢速 `pre-merge-commit` 钩子不再被 15 秒默认超时误杀。
+- **自动对账已落地合并**：`tower_merge` 检测 branch/reviewed commit 已包含在 base 中时，找到对应
+  merge commit（或落地 tip）并直接记录为 merged（`reconciled: true`），无需手工改 Git 历史。
+- **`tower_rebase`**：branch 已包含于 base 时返回 `alreadyMerged`/`skipped` 且不再把分支
+  fast-forward 到 base tip，保留已审查的 tip 供 `tower_merge` 记录。
+- **状态机**：允许 `blocked → completed`；`missionSummary` 暴露 `mergedCommit`/`mergedAt`。
+- 测试：22 项（新增 reconcile、rebase skip、hook 失败、hook 超时四个协议用例）。
+- 修复 GitHub issues #1 / #2。
+
 ## 1.1.2 — 2026-10-18
 
 - README 文件更名：默认 `README.md` 改为中文版，英文版移到 `README.en.md`；两边的语言切换链接、

package/README.en.md

@@ -149,6 +149,8 @@ The offline suite needs no DSH process and creates throwaway Git repositories in
 - **`tower_control` is missing.** The config `allowAgentControl` is `false`; set it to `true` and restart.
 - **Merge is blocked.** Run `tower_preflight` and read the blocker codes above; `stale-base` means run `tower_rebase` first.
 - **A mission branch is stale after base moved.** `tower_rebase` rebases inside the worktree; a clean conflict-free rebase waives re-review for the previous verdict.
+- **A merge commit exists but `tower_merge` reported a failure.** Re-run `tower_merge`: it detects the landed merge commit (or a branch already contained in the base) and records it as reconciled instead of merging twice.
+- **The repository runs a slow `pre-merge-commit` hook.** The merge timeout defaults to 15 minutes and can be raised per call with `tower_merge({ ..., timeoutMs: 900000 })`; hook output is buffered up to 64 MB. A hook failure returns `merge-hook-failed` (with `timeout: true` when it timed out) and leaves the repository clean for a retry.
 
 ## Contributing
 

package/README.md

@@ -149,6 +149,8 @@ npm test        # node --test tests/*.test.mjs
 - **没有 `tower_control`。** 配置 `allowAgentControl` 为 `false`；改为 `true` 并重启。
 - **合并被阻止。** 运行 `tower_preflight` 查看 blocker code；`stale-base` 表示先执行 `tower_rebase`。
 - **基线前进后分支过期。** `tower_rebase` 在 worktree 内完成 rebase；干净且无冲突的 rebase 可免去上一轮审查的重审。
+- **合并提交已经存在，但 `tower_merge` 报了失败。** 重新执行 `tower_merge` 即可：它会检测已落地的合并提交（或分支已包含在 base 中）并记录为 reconciled，不会重复合并。
+- **仓库的 `pre-merge-commit` 钩子很慢。** 合并超时默认 15 分钟，可按次通过 `tower_merge({ ..., timeoutMs: 900000 })` 调大；钩子输出缓冲上限 64 MB。钩子失败返回 `merge-hook-failed`（超时带 `timeout: true`），并保持仓库干净以便重试。
 
 ## 贡献
 

package/lib/git.js

@@ -6,10 +6,13 @@ const GIT_TIMEOUT_MS = 15000
 const MAX_BUFFER = 16 * 1024 * 1024
 
 export class GitError extends Error {
-  constructor(args, detail, code) {
+  constructor(args, detail, code, meta = {}) {
     super(`git ${args.join(' ')} failed: ${detail}`)
     this.name = 'GitError'
     this.code = code
+    this.timedOut = meta.timedOut === true
+    this.bufferOverflow = meta.bufferOverflow === true
+    this.stdout = meta.stdout ?? ''
   }
 }
 
@@ -27,11 +30,14 @@ export function git(cwd, args, options = {}) {
       },
       (error, stdout, stderr) => {
         if (error) {
+          const timedOut = error.killed === true || error.signal === 'SIGTERM' || error.code === 'ETIMEDOUT'
+          const bufferOverflow = error.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER'
           reject(
             new GitError(
               args,
               String(stderr || error.message || '').trim(),
               typeof error.code === 'number' ? error.code : undefined,
+              { timedOut, bufferOverflow, stdout: String(stdout ?? '').slice(0, 64 * 1024) },
             ),
           )
           return

package/lib/tools.js

@@ -732,12 +732,17 @@ export function registerTowerTools(ctx) {
   define(ctx, {
     name: 'tower_merge',
     description:
-      'Merge a mission branch into the recorded base branch with --no-ff, after the hard gate passes. Verifies the two merge parents and records the mission as merged. A failed gate returns stable blocker codes instead of merging; a Git conflict aborts the merge and marks the mission blocked.',
+      'Merge a mission branch into the recorded base branch with --no-ff, after the hard gate passes. Verifies the two merge parents and records the mission as merged. If the merge commit already landed (manual merge, crashed or slow pre-merge hook), it detects the merge commit and records it as reconciled instead of merging again. A failed gate returns stable blocker codes without merging; a hook failure aborts cleanly and returns "merge-hook-failed" while a real content conflict returns "merge-conflict".',
     parameters: {
       type: 'object',
       properties: {
         repoRoot: { type: 'string', description: 'Absolute path inside the target Git repository.' },
         missionId: { type: 'string', description: 'Mission id, e.g. M1.' },
+        timeoutMs: {
+          type: 'integer',
+          minimum: 1000,
+          description: 'Optional timeout for the merge command in milliseconds, including pre-merge hooks (default 15 minutes).',
+        },
       },
       required: ['repoRoot', 'missionId'],
       additionalProperties: false,
@@ -746,14 +751,14 @@ export function registerTowerTools(ctx) {
     async execute(args) {
       const tower = await Tower.open(args.repoRoot)
       const { activity } = await observeActivity(ctx, tower)
-      return tower.merge({ missionId: args.missionId, activity })
+      return tower.merge({ missionId: args.missionId, activity, timeoutMs: args.timeoutMs })
     },
   })
 
   define(ctx, {
     name: 'tower_rebase',
     description:
-      'Rebase a mission branch onto the current base tip inside its own worktree. Refuses while its worker is running or the worktree is dirty. A clean conflict-free rebase waives re-review for the old review; a conflict is aborted and the mission is marked blocked.',
+      'Rebase a mission branch onto the current base tip inside its own worktree. Refuses while its worker is running or the worktree is dirty. A clean conflict-free rebase waives re-review for the old review; a conflict is aborted and the mission is marked blocked. If the branch is already contained in the base, it returns alreadyMerged and leaves the branch untouched so tower_merge can record the landed merge.',
     parameters: {
       type: 'object',
       properties: {

package/lib/tower.js

@@ -1,5 +1,6 @@
 // Tower domain: repo-scoped mission state machine, validation, and gates.
 import path from 'node:path'
+import fsp from 'node:fs/promises'
 import {
   git,
   resolveRepo,
@@ -14,6 +15,7 @@ import {
   countCommits,
   isClean,
   isAncestor,
+  tryGit,
 } from './git.js'
 import {
   pathsFor,
@@ -41,7 +43,7 @@ const TERMINAL = new Set(['merged', 'abandoned'])
 const TRANSITIONS = {
   planned: ['active', 'abandoned'],
   active: ['completed', 'blocked', 'paused', 'abandoned'],
-  blocked: ['active', 'paused', 'abandoned'],
+  blocked: ['active', 'paused', 'completed', 'abandoned'],
   paused: ['active', 'abandoned'],
   completed: ['active', 'abandoned'],
   merged: [],
@@ -63,6 +65,46 @@ export const FINDING_SEVERITIES = ['low', 'medium', 'high', 'critical']
 export const MERGE_VERDICTS = ['merge', 'fix-then-merge', 'hold']
 const MAX_REVIEW_ROUNDS = 5
 const REVIEW_STATUS_RE = /^(clean|p1-\d+items|p2-\d+items)$/
+const DEFAULT_MERGE_TIMEOUT_MS = 15 * 60 * 1000
+const MERGE_MAX_BUFFER = 64 * 1024 * 1024
+
+function mergeTimeoutMs(value) {
+  if (value === undefined || value === null) return DEFAULT_MERGE_TIMEOUT_MS
+  const ms = Number(value)
+  if (!Number.isInteger(ms) || ms < 1000) fail('timeoutMs must be an integer of at least 1000 milliseconds')
+  return ms
+}
+
+async function commitParents(cwd, sha) {
+  const line = await tryGit(cwd, ['rev-list', '--parents', '-n', '1', sha])
+  return line ? line.trim().split(/\s+/).slice(1) : []
+}
+
+/**
+ * Find a reachable merge commit whose second parent is one of the known tips.
+ * `--no-ff` merges put the integrated branch on the second parent, so this is
+ * the concrete evidence that a mission's work already landed in the base.
+ */
+async function findLandedMerge(cwd, baseTip, tips) {
+  const revs = (await tryGit(cwd, ['rev-list', '--merges', '-n', '100', baseTip])) ?? ''
+  for (const sha of revs.split('\n').filter(Boolean)) {
+    const parents = await commitParents(cwd, sha)
+    if (parents.length >= 2 && tips.has(parents[1])) return { commit: sha, parents }
+  }
+  return null
+}
+
+function describeGitFailure(error) {
+  const prefix = error?.timedOut ? 'timed out: ' : error?.bufferOverflow ? 'output buffer overflow: ' : ''
+  return `${prefix}${String(error?.message ?? error)}`
+}
+
+/** A killed git process can leave lock files behind; only used after a failed merge. */
+async function removeStaleGitLocks(commonDir) {
+  for (const name of ['index.lock', 'HEAD.lock', 'MERGE_HEAD.lock', 'ORIG_HEAD.lock']) {
+    await fsp.unlink(path.join(commonDir, name)).catch(() => {})
+  }
+}
 
 function globToRegExp(pattern) {
   let out = '^'
@@ -361,6 +403,8 @@ export function missionSummary(mission) {
     blockers: mission.blockers ?? [],
     tasks: taskCounts(mission.tasks ?? []),
     scopeGeneration: mission.scopeGeneration ?? 1,
+    mergedCommit: mission.mergedCommit ?? null,
+    mergedAt: mission.mergedAt ?? null,
     updatedAt: mission.updatedAt,
   }
 }
@@ -1286,35 +1330,197 @@ export class Tower {
     }
   }
 
+  /**
+   * Record a merge that already landed in Git without being recorded here:
+   * a crashed/timed-out merge, a manual merge, or a rebase that fast-forwarded
+   * the branch to the base tip. The evidence is concrete: a clean merge review
+   * exists and either the branch tip or the reviewed commit is already an
+   * ancestor of the base.
+   */
+  async reconcileLandedMerge(state, mission) {
+    if (!['completed', 'blocked'].includes(mission.status)) return null
+    if (!mission.worktree) return null
+    const branch = mission.worktree.branch
+    const reviews = (state.reviews ?? []).filter((review) => review.branch === branch)
+    if (reviews.length === 0) return null
+    const latest = reviews.reduce((a, b) => (a.round >= b.round ? a : b))
+    if (latest.status !== 'clean' || latest.mergeVerdict !== 'merge') return null
+    let baseTip
+    let branchTip
+    try {
+      baseTip = await revParse(this.root, state.base)
+      branchTip = await revParse(mission.worktree.path, 'HEAD')
+    } catch {
+      return null
+    }
+    const reviewedTip = latest.reviewedCommit
+    const branchLanded = await isAncestor(this.root, branchTip, baseTip)
+    const reviewedLanded = reviewedTip ? await isAncestor(this.root, reviewedTip, baseTip) : false
+    if (!branchLanded && !reviewedLanded) return null
+    const tips = new Set([branchTip, reviewedTip].filter(Boolean))
+    const found = await findLandedMerge(this.root, baseTip, tips)
+    const mergedCommit = found ? found.commit : reviewedLanded ? reviewedTip : branchTip
+    const now = Date.now()
+    mission.status = 'merged'
+    mission.mergedAt = now
+    mission.mergedCommit = mergedCommit
+    mission.blockers = []
+    mission.notes.push(
+      found
+        ? `reconciled already-landed merge ${mergedCommit.slice(0, 7)} with parents [${found.parents.map((parent) => parent.slice(0, 7)).join(', ')}]`
+        : `reconciled already-landed merge: ${mergedCommit.slice(0, 7)} is contained in ${state.base} (no merge commit found)`,
+    )
+    mission.updatedAt = now
+    state.revision += 1
+    state.updatedAt = now
+    validateState(state, this.paths.state)
+    await writeJsonAtomic(this.paths.state, state)
+    await appendJsonl(this.paths.activity, {
+      at: now,
+      type: 'merge',
+      missionId: mission.id,
+      text: `reconciled already-landed ${mergedCommit.slice(0, 7)} on ${state.base}`,
+    })
+    return {
+      ok: true,
+      reconciled: true,
+      alreadyLanded: true,
+      mergedCommit,
+      baseTip,
+      branchTip,
+      parents: found ? found.parents : null,
+      review: {
+        round: latest.round,
+        status: latest.status,
+        mergeVerdict: latest.mergeVerdict,
+        reviewer: latest.reviewer,
+        reviewedCommit: reviewedTip,
+      },
+    }
+  }
+
   async merge(input) {
     return withLock(this.paths, async () => {
-      const gate = await this.evaluateGate(input)
-      if (!gate.ok) return { ok: false, blockers: gate.blockers, missionId: input.missionId }
       const state = await this.load()
       const mission = state.missions.find((entry) => entry.id === input.missionId)
+      if (!mission) {
+        return { ok: false, blockers: [{ code: 'mission-missing', detail: `unknown mission "${input.missionId}"` }] }
+      }
+      const baseTip = await revParse(this.root, state.base)
+      if (mission.status === 'merged') {
+        return { ok: true, alreadyMerged: true, mergedCommit: mission.mergedCommit ?? null, baseTip }
+      }
+      const reconciled = await this.reconcileLandedMerge(state, mission)
+      if (reconciled) return reconciled
+      const gate = await this.evaluateGate(input)
+      if (!gate.ok) return { ok: false, blockers: gate.blockers, missionId: input.missionId }
+
       const worktree = mission.worktree
-      const baseTipBefore = await revParse(this.root, state.base)
+      const baseTipBefore = await revParse(this.root, 'HEAD')
       const branchTip = await revParse(worktree.path, 'HEAD')
-
+      const timeoutMs = mergeTimeoutMs(input.timeoutMs)
+      let failure = null
       try {
-        await git(this.root, ['merge', '--no-ff', worktree.branch, '-m', `tower: merge ${mission.id} — ${mission.title}`])
+        await git(
+          this.root,
+          ['merge', '--no-ff', worktree.branch, '-m', `tower: merge ${mission.id} — ${mission.title}`],
+          { timeoutMs, maxBuffer: MERGE_MAX_BUFFER },
+        )
       } catch (error) {
-        await git(this.root, ['merge', '--abort']).catch(() => {})
+        failure = error
+      }
+
+      const newTip = await revParse(this.root, 'HEAD')
+      const parents = await commitParents(this.root, newTip)
+      const expectedShape = parents.length === 2 && parents[0] === baseTipBefore && parents[1] === branchTip
+      const warnings = []
+
+      if (failure && expectedShape) {
+        warnings.push(
+          `merge command reported a failure (${describeGitFailure(failure)}) but merge commit ${newTip.slice(0, 7)} exists; treated as merged`,
+        )
+        const dirty = (await git(this.root, ['status', '--porcelain']))
+          .split('\n')
+          .filter(Boolean)
+          .map((line) => line.slice(3).trim())
+        if (dirty.length > 0) {
+          const changed = new Set(gate.changedFiles ?? [])
+          if (dirty.every((file) => changed.has(file))) {
+            await git(this.root, ['reset', '--hard', 'HEAD'])
+            warnings.push('restored index/worktree to the merge commit (only merge-related paths were dirty)')
+          } else {
+            warnings.push('working tree still has unrelated changes; left untouched — inspect it before the next Git operation')
+          }
+        }
+      } else if (failure) {
+        const unmerged = (await tryGit(this.root, ['ls-files', '-u'])) ?? ''
+        const conflict = unmerged.trim().length > 0
+        let cleanup = 'none'
+        const mergeHeadPath = path.join(this.commonDir, 'MERGE_HEAD')
+        if (await exists(mergeHeadPath)) {
+          try {
+            await git(this.root, ['merge', '--abort'])
+            cleanup = 'aborted'
+          } catch {
+            await removeStaleGitLocks(this.commonDir)
+            try {
+              await git(this.root, ['merge', '--abort'])
+              cleanup = 'aborted-after-lock-cleanup'
+            } catch {
+              await git(this.root, ['reset', '--hard', baseTipBefore]).catch(() => {})
+              cleanup = 'reset'
+            }
+          }
+        } else if (newTip !== baseTipBefore) {
+          await removeStaleGitLocks(this.commonDir)
+          await git(this.root, ['reset', '--hard', baseTipBefore]).catch(() => {})
+          cleanup = 'reset'
+        }
+        // A killed git process can leave the index staged even without
+        // MERGE_HEAD. Restore only when every dirty path belongs to this merge.
+        const dirtyAfter = (await git(this.root, ['status', '--porcelain']))
+          .split('\n')
+          .filter(Boolean)
+          .map((line) => line.slice(3).trim())
+        if (dirtyAfter.length > 0) {
+          const changed = new Set(gate.changedFiles ?? [])
+          if (dirtyAfter.every((file) => changed.has(file))) {
+            await removeStaleGitLocks(this.commonDir)
+            await git(this.root, ['reset', '--hard', baseTipBefore]).catch(() => {})
+            cleanup = cleanup === 'none' ? 'reset' : `${cleanup}+reset`
+          } else {
+            warnings.push(`cleanup left unrelated changes untouched: ${dirtyAfter.slice(0, 5).join(', ')}`)
+          }
+        }
+        const detail = describeGitFailure(failure).slice(0, 2000)
         const now = Date.now()
-        mission.status = 'blocked'
-        mission.blockers.push(`merge conflict: ${String(error?.message ?? error).slice(0, 240)}`)
+        if (conflict) {
+          mission.status = 'blocked'
+          mission.blockers.push(`merge conflict: ${detail.slice(0, 240)}`)
+        } else {
+          mission.notes.push(`merge command failed before creating a commit (${detail.slice(0, 240)}); mission left ${mission.status} for retry`)
+        }
         mission.updatedAt = now
         state.revision += 1
         state.updatedAt = now
         await writeJsonAtomic(this.paths.state, state)
-        await appendJsonl(this.paths.activity, { at: now, type: 'merge', missionId: mission.id, text: 'conflict' })
-        return { ok: false, blockers: [{ code: 'merge-conflict', detail: String(error?.message ?? error) }] }
+        await appendJsonl(this.paths.activity, { at: now, type: 'merge', missionId: mission.id, text: `${conflict ? 'conflict' : 'failed-before-commit'} (${cleanup})` })
+        return {
+          ok: false,
+          missionId: mission.id,
+          blockers: [
+            {
+              code: conflict ? 'merge-conflict' : 'merge-hook-failed',
+              detail,
+              ...(failure.timedOut === true ? { timeout: true } : {}),
+              cleanup,
+            },
+          ],
+          ...(warnings.length > 0 ? { warnings } : {}),
+        }
       }
 
-      const newTip = await revParse(this.root, 'HEAD')
-      const parentLine = await git(this.root, ['rev-list', '--parents', '-n', '1', 'HEAD'])
-      const parents = parentLine.trim().split(/\s+/).slice(1)
-      if (parents.length !== 2 || parents[0] !== baseTipBefore || parents[1] !== branchTip) {
+      if (!expectedShape) {
         return {
           ok: false,
           blockers: [
@@ -1342,7 +1548,14 @@ export class Tower {
         missionId: mission.id,
         text: `${branchTip.slice(0, 7)} -> ${newTip.slice(0, 7)} on ${state.base}`,
       })
-      return { ok: true, mergedCommit: newTip, baseTip: baseTipBefore, branchTip, parents }
+      return {
+        ok: true,
+        mergedCommit: newTip,
+        baseTip: baseTipBefore,
+        branchTip,
+        parents,
+        ...(warnings.length > 0 ? { warnings, recoveredFromFailure: true } : {}),
+      }
     })
   }
 
@@ -1364,6 +1577,20 @@ export class Tower {
       }
       const oldTip = await revParse(mission.worktree.path, 'HEAD')
       const baseTip = await revParse(this.root, state.base)
+      if (await isAncestor(this.root, oldTip, baseTip)) {
+        // The branch is already contained in the base (manual merge, crashed
+        // merge, earlier fast-forward). Rewriting the branch tip to the base
+        // would destroy the reviewed tip and the ability to record the merge.
+        return {
+          ok: true,
+          alreadyMerged: true,
+          skipped: true,
+          oldTip,
+          newTip: oldTip,
+          baseTip,
+          note: `${oldTip.slice(0, 7)} is already contained in ${state.base} ${baseTip.slice(0, 7)}; branch left untouched — call tower_merge to record the landed merge`,
+        }
+      }
       if (await isAncestor(this.root, baseTip, oldTip)) {
         return { ok: true, alreadyUpToDate: true, oldTip, newTip: oldTip, baseTip }
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-tower",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "type": "module",
   "description": "DSH-native Tower: mission planning, worktree isolation, review-gated merges, and a human-owned Tower mode.",
   "license": "MIT",