weir-harness 1.2.2 → 2.0.0

package/src/todo-driver/index.js

@@ -68,9 +68,6 @@ function apply(ctx, config = {}) {
     }
   }
 
-  // Edit Lock (when enabled) owns session interruption: only its trusted
-  // resume re-arms editing work, never an ordinary user message or retry.
-  const editLockBlocks = (agent) => ctx.get?.('weirEditLock')?.blocksContinuation?.(agent) === true
   const compactionBlocks = (agent) => agent && ctx.get?.('weirCompactionCoordinator')?.blocksContinuation(agent) === true
   /** Delayed followup continuation for the provider-error path. */
   function scheduleRetry(session, delayMs) {
@@ -82,7 +79,6 @@ function apply(ctx, config = {}) {
       if (remaining.length === 0) return
       if (!stateOf(session.id).armed) return
       if (jobsRunningOf(agent.session)) return
-      if (editLockBlocks(agent)) return
       if (compactionBlocks(agent)) return
       injectOrWarn(ctx, `todo-driver: could not queue continuation for "${session.id}"`, () => {
         agent.followup(userTextMessage(renderContinuation(remaining), 'weir-todo-driver'))
@@ -95,7 +91,7 @@ function apply(ctx, config = {}) {
 
   // The sanctioned continuation boundary: steer and the turn runs on.
   function continueAtBoundary({ agent, signal }) {
-    if (compactionBlocks(agent) || editLockBlocks(agent)) return
+    if (compactionBlocks(agent)) return
     if (!opts.enabled) return
     const state = stateOf(agent.id)
     const remaining = remainingTodos(agent.session)
@@ -106,7 +102,6 @@ function apply(ctx, config = {}) {
       error: providerErrorPending.get(agent.id),
     })
     if (decision.kind !== 'continue') return
-    if (editLockBlocks(agent)) return
     injectOrWarn(ctx, `todo-driver: could not steer continuation for "${agent.id}"`, () => {
       agent.steer(userTextMessage(renderContinuation(remaining), 'weir-todo-driver'))
     })

package/src/worktree/cards.js

@@ -72,12 +72,6 @@ const COPY = {
     abandonLine: (/** @type {string} */ id, /** @type {string} */ title, /** @type {string} */ state) => `Abandon lane \`${id}\` — ${title} (state ${state}).`,
     unmergedLost: (/** @type {number} */ count, /** @type {string} */ branch) => `**${count} unmerged commit(s)** on \`${branch}\` will be lost if the branch is removed.`,
     noUnmerged: (/** @type {string} */ branch) => `\`${branch}\` has no unmerged commits.`,
-    residueWarning: (/** @type {{ operations: number, locks: number }} */ residue) => {
-      const parts = []
-      if (residue.operations > 0) parts.push(`${residue.operations} unresolved Edit Lock operation(s)`)
-      if (residue.locks > 0) parts.push(`${residue.locks} Edit Lock lock(s)`)
-      return `⚠️ **Edit Lock residue**: this lane's session left ${parts.join(' and ')} in the Edit Lock authority. Locks are reclaimed automatically by the stale-lock sweep; unresolved publications settle via crash self-heal (dead process) or one-click recovery in the Edit Lock maintenance panel (Settings → Editing). This is a warning only — cleanup still proceeds.`
-    },
     dirtyWarning: (/** @type {{ modified: number, untracked: number }} */ dirty) => {
       const parts = []
       if (dirty.modified > 0) parts.push(`${dirty.modified} modified`)
@@ -137,12 +131,6 @@ const COPY = {
     abandonLine: (/** @type {string} */ id, /** @type {string} */ title, /** @type {string} */ state) => `放弃车道 \`${id}\` —— ${title}（状态 ${state}）。`,
     unmergedLost: (/** @type {number} */ count, /** @type {string} */ branch) => `删除分支将**永久丢失** \`${branch}\` 上的 **${count} 个未合并提交**。`,
     noUnmerged: (/** @type {string} */ branch) => `\`${branch}\` 没有未合并的提交。`,
-    residueWarning: (/** @type {{ operations: number, locks: number }} */ residue) => {
-      const parts = []
-      if (residue.operations > 0) parts.push(`${residue.operations} 个未决 Edit Lock 操作`)
-      if (residue.locks > 0) parts.push(`${residue.locks} 把 Edit Lock 锁`)
-      return `⚠️ **Edit Lock 残留**：该车道的会话在 Edit Lock 权威中留有 ${parts.join(' 和 ')}。锁会由 stale-lock 自动清扫回收；未决发布会由崩溃自愈（进程死亡时）或 Edit Lock 维护面板（设置 → 编辑）的一键恢复结清。此仅为警示——清理仍会进行。`
-    },
     dirtyWarning: (/** @type {{ modified: number, untracked: number }} */ dirty) => {
       const parts = []
       if (dirty.modified > 0) parts.push(`${dirty.modified} 个已修改`)
@@ -193,15 +181,14 @@ export function cardCopy(locale) {
       ].join('\n')
     },
     /**
-     * @param {any} lane @param {{ files: number, added: number, removed: number }} stat @param {string} [root] @param {{ operations: number, locks: number } | null} [residue]
+     * @param {any} lane @param {{ files: number, added: number, removed: number }} stat @param {string} [root]
      * @param {{ modified: number, untracked: number } | null} [dirty] - dirty-content probe; disclosed as its own warning paragraph when non-zero
      */
-    cleanupDetail(lane, stat, root, residue = null, dirty = null) {
+    cleanupDetail(lane, stat, root, dirty = null) {
       return [
         `- ${copy.merged(lane.branch, lane.base.branch)} (${stat.files} ${copy.files}, +${stat.added} −${stat.removed}).`,
         `- ${copy.worktree}: \`${displayPath(lane.path, root)}\``,
         `- ${copy.scratch}`,
-        ...(residue ? ['', copy.residueWarning(residue)] : []),
         ...(hasDirtyContent(dirty) ? ['', copy.dirtyWarning(/** @type {any} */ (dirty))] : []),
       ].join('\n')
     },
@@ -216,11 +203,11 @@ export function cardCopy(locale) {
       return copy.disputedReasons.noEvidence
     },
     /**
-     * @param {any} lane @param {number} unmerged @param {string} [root] @param {{ operations: number, locks: number } | null} [residue]
+     * @param {any} lane @param {number} unmerged @param {string} [root]
      * @param {{ child: string, forced: boolean } | null} [reclaimed] - a binding this abandon already settled (design D1/D4), disclosed on the card
      * @param {{ modified: number, untracked: number } | null} [dirty] - dirty-content probe; disclosed as its own warning paragraph when non-zero
      */
-    abandonDetail(lane, unmerged, root, residue = null, reclaimed = null, dirty = null) {
+    abandonDetail(lane, unmerged, root, reclaimed = null, dirty = null) {
       return [
         `- ${copy.abandonLine(lane.id, lane.title, lane.state)}`,
         `- ${copy.worktree}: \`${displayPath(lane.path, root)}\``,
@@ -228,22 +215,20 @@ export function cardCopy(locale) {
         // The unmerged-commit warning stays its own paragraph for emphasis.
         unmerged > 0 ? copy.unmergedLost(unmerged, lane.branch) : copy.noUnmerged(lane.branch),
         ...(reclaimed ? ['', copy.reconciledNote(reclaimed.child, reclaimed.forced)] : []),
-        ...(residue ? ['', copy.residueWarning(residue)] : []),
         ...(hasDirtyContent(dirty) ? ['', copy.dirtyWarning(/** @type {any} */ (dirty))] : []),
       ].join('\n')
     },
     /**
      * The disputed-binding card body (design D4): lane facts, then the
      * reconciliation outcome as the warning paragraph.
-     * @param {any} lane @param {string} child @param {{ childAlive?: boolean, ownerAlive?: boolean, terminalEvidence?: any } | null} verdict @param {string} [root] @param {{ operations: number, locks: number } | null} [residue]
+     * @param {any} lane @param {string} child @param {{ childAlive?: boolean, ownerAlive?: boolean, terminalEvidence?: any } | null} verdict @param {string} [root]
      */
-    abandonDisputedDetail(lane, child, verdict, root, residue = null) {
+    abandonDisputedDetail(lane, child, verdict, root) {
       return [
         `- ${copy.abandonLine(lane.id, lane.title, lane.state)}`,
         `- ${copy.worktree}: \`${displayPath(lane.path, root)}\``,
         '',
         copy.disputedWarning(child, this.disputedReason(verdict)),
-        ...(residue ? ['', copy.residueWarning(residue)] : []),
       ].join('\n')
     },
   }

package/src/worktree/lane-core.js

@@ -16,7 +16,6 @@ import { normalizeRoot, parseRepoConfig } from './rules.js'
 import { reconcile } from './reconcile.js'
 import { createLedger } from './ledger.js'
 import { renderNotice, renderWatchExpired, renderWatchHit } from './prompts.js'
-import { authorityResidue } from './authority.js'
 
 export const CONFIG_FILE = '.config.json'
 const LOG_TAIL_LINES = 40
@@ -74,7 +73,6 @@ export function pathKey(path, platform = process.platform) {
  * @property {(handle: any) => void} [clearTimer]
  * @property {number} [pid] - this process id (tests)
  * @property {{ warn?: (message: string) => void }} [logger]
- * @property {(root: string, sessionId: string | null | undefined) => ({ operations: number, locks: number } | null)} [authorityResidue] - read-only Edit Lock residue probe feeding the cleanup/abandon warning (tests); defaults to the bounded snapshot read in ./authority.js
  * @property {(boundChild: string, ownerSession: string | null, context: { root: string }) => Promise<{ childAlive: boolean, ownerAlive: boolean, terminalEvidence: { source: string, detail: string } | null }>} [bindingLiveness] - read-only zombie-binding probe (design D2); absent = LANE_BUSY refusals stand unreconciled
  */
 
@@ -347,22 +345,6 @@ export function createLaneCore(deps) {
     }
   }
 
-  /**
-   * Best-effort Edit Lock authority-residue probe (design D5): does the
-   * lane's owner session still own unresolved operations or locks in the
-   * management domain? Warning input only — read-only, and a failed check
-   * is silent (never blocks the cleanup/abandon transition).
-   * @param {any} repo @param {any} lane @returns {{ operations: number, locks: number } | null}
-   */
-  function residueOf(repo, lane) {
-    try {
-      return (deps.authorityResidue ?? authorityResidue)(repo.mainRoot, lane?.ownerSession) ?? null
-    } catch (error) {
-      deps.logger?.warn?.(`worktree: authority-residue check failed: ${/** @type {any} */ (error)?.message ?? error}`)
-      return null
-    }
-  }
-
   /** @param {any} lane */
   function result(lane, summary, extra = {}) {
     return {
@@ -635,7 +617,7 @@ export function createLaneCore(deps) {
     approveModeSafe, approveModeSourceSafe,
     cwdOf, config, repoFor, repoCached,
     armWatch, disarmWatch,
-    laneOf, apply, patchLane, commitBinding, notifyOwner, residueOf, result, readConfig, logFile,
+    laneOf, apply, patchLane, commitBinding, notifyOwner, result, readConfig, logFile,
     refresh, reconcileNote, reconcileBinding, childSettled, check,
   }
 }

package/src/worktree/lane-workflows.js

@@ -21,21 +21,9 @@ import { CONFIG_FILE, pathKey } from './lane-core.js'
 
 const SETUP_TIMEOUT_MS = 600_000
 
-/**
- * Model-facing English residue warning appended to cleanup/abandon tool
- * results (the human-facing card copy localizes its own in cards.js).
- * @param {{ operations: number, locks: number }} residue
- */
-function residueNote(residue) {
-  const parts = []
-  if (residue.operations > 0) parts.push(`${residue.operations} unresolved Edit Lock operation(s)`)
-  if (residue.locks > 0) parts.push(`${residue.locks} Edit Lock lock(s)`)
-  return `warning: the lane's session left ${parts.join(' and ')} in the management authority; locks are reclaimed by the stale-lock sweep, unresolved publications settle via crash self-heal (dead process) or the Edit Lock maintenance panel's one-click recovery`
-}
-
 /** @param {ReturnType<typeof import('./lane-core.js').createLaneCore>} core */
 export function createLaneWorkflows(core) {
-  const { deps, git, now, pid, asking, approveModeSafe, cwdOf, config, repoFor, laneOf, apply, patchLane, commitBinding, notifyOwner, residueOf, result, readConfig, logFile, refresh, reconcileNote, reconcileBinding, armWatch, disarmWatch } = core
+  const { deps, git, now, pid, asking, approveModeSafe, cwdOf, config, repoFor, laneOf, apply, patchLane, commitBinding, notifyOwner, result, readConfig, logFile, refresh, reconcileNote, reconcileBinding, armWatch, disarmWatch } = core
 
   // ─── open / setup ─────────────────────────────────────────────────────
 
@@ -263,7 +251,7 @@ export function createLaneWorkflows(core) {
         id: 'abandon',
         header: copy.abandonHeader,
         question: copy.abandonQuestion(lane.title),
-        detail: copy.abandonDisputedDetail(lane, lane.boundChild, reconciliation?.verdict ?? null, repo.mainRoot, residueOf(repo, lane)),
+        detail: copy.abandonDisputedDetail(lane, lane.boundChild, reconciliation?.verdict ?? null, repo.mainRoot),
         options: [
           { label: copy.forceReclaim, description: copy.forceReclaimDescription },
           { label: copy.cancel, description: copy.abandonDescriptions.cancel },
@@ -452,10 +440,9 @@ export function createLaneWorkflows(core) {
     }
     // Auto cleanup after the merge (design D3): auto-keep → mode worktree,
     // auto-clean → mode all. The existing cleanup() body runs unchanged —
-    // scratch sync first, never --force on an auto path, the Edit Lock residue
-    // probe feeding the summary. A blocked removal stays `landed` and is
-    // reported concisely with the typed --force retry instead of a false
-    // success (the user can clean up later).
+    // scratch sync first, never --force on an auto path. A blocked removal
+    // stays `landed` and is reported concisely with the typed --force retry
+    // instead of a false success (the user can clean up later).
     const cleanupMode = approveMode === 'auto-keep' ? 'worktree' : 'all'
     try {
       const cleaned = await cleanup(session, laneId, /** @type {'worktree' | 'all'} */ (cleanupMode), { by: 'host', auto: true, approveMode })
@@ -488,7 +475,7 @@ export function createLaneWorkflows(core) {
         id: 'cleanup',
         header: copy.cleanupHeader,
         question: copy.cleanupQuestion(lane.title),
-        detail: copy.cleanupDetail(lane, lane.land?.stat ?? { files: 0, added: 0, removed: 0 }, repo.mainRoot, residueOf(repo, lane), dirtyCard ? dirty : null),
+        detail: copy.cleanupDetail(lane, lane.land?.stat ?? { files: 0, added: 0, removed: 0 }, repo.mainRoot, dirtyCard ? dirty : null),
         options: [
           { label: copy.choices.keep, description: copy.cleanupDescriptions.keep },
           { label: copy.choices.worktree, description: dirtyCard ? copy.cleanupDescriptionsDirty.worktree : copy.cleanupDescriptions.worktree },
@@ -539,9 +526,8 @@ export function createLaneWorkflows(core) {
    * Auto paths (design D3) reuse this exact body with `{ by: 'host', auto: true,
    * approveMode }`: the scratch sync, the removal (forced ONLY behind the
    * user's informed explicit choice — a disclosed card choice or a typed
-   * `--force`, never an auto/model path), the residue warning and the
-   * blocked-removal semantics are identical; only the audit payload gains the
-   * auto marker.
+   * `--force`, never an auto/model path) and the blocked-removal semantics are
+   * identical; only the audit payload gains the auto marker.
    * @param {any} session @param {string} laneId @param {'keep' | 'worktree' | 'all'} mode @param {{ by?: string, auto?: boolean, approveMode?: string, force?: boolean }} [options]
    */
   async function cleanup(session, laneId, mode, options = {}) {
@@ -557,9 +543,6 @@ export function createLaneWorkflows(core) {
       const kept = await apply(repo, laneId, { type: 'keep', by, patch: { cleanup: { mode: 'keep', at: now(), by } } })
       return result(kept, `kept ${kept.path}`)
     }
-    // Read-only residue probe BEFORE anything is removed (design D5): a
-    // warning only, never a gate, and it never mutates the authority.
-    const residue = residueOf(repo, lane)
     const scratch = existsSync(lane.path) ? syncScratch(repo, lane) : null
     // `force` reaches git only from an informed explicit user choice (a
     // disclosed card choice via askCleanup, or the typed `--force`); auto and
@@ -591,7 +574,7 @@ export function createLaneWorkflows(core) {
       ? await patchLane(repo, laneId, () => ({ cleanup: record }))
       : await apply(repo, laneId, { type: 'clean', by, patch: { cleanup: record } })
     deps.audit('cleanup', { lane: laneId, mode, by, scratch, ...(force ? { forced: true } : {}), ...(options.auto === true ? { auto: true, approveMode: options.approveMode ?? null } : {}) }, repo.mainRoot, lane.ownerSession)
-    return result(next, `removed ${lane.path}${branchNote}${scratch ? `; scratch copied to ${scratch}` : ''}${residue ? `; ${residueNote(residue)}` : ''}`)
+    return result(next, `removed ${lane.path}${branchNote}${scratch ? `; scratch copied to ${scratch}` : ''}`)
   }
 
   /**
@@ -651,7 +634,7 @@ export function createLaneWorkflows(core) {
           id: 'abandon',
           header: copy.abandonHeader,
           question: copy.abandonQuestion(lane.title),
-          detail: copy.abandonDetail(lane, unmerged, repo.mainRoot, residueOf(repo, lane), reconciliation?.settled ? { child: reconciliation.childId, forced: reconciliation.forced } : null, dirtyCard ? dirty : null),
+          detail: copy.abandonDetail(lane, unmerged, repo.mainRoot, reconciliation?.settled ? { child: reconciliation.childId, forced: reconciliation.forced } : null, dirtyCard ? dirty : null),
           options: [
             { label: copy.choices.keep, description: copy.abandonDescriptions.keep },
             { label: copy.choices.worktree, description: dirtyCard ? copy.abandonDescriptionsDirty.worktree : copy.abandonDescriptions.worktree },
@@ -678,10 +661,6 @@ export function createLaneWorkflows(core) {
     const auditExtra = { ...(auto ? { auto: true, approveMode } : {}), ...(force ? { forced: true } : {}) }
     const abandoned = await apply(repo, laneId, { type: 'abandon', by: auto ? 'host' : 'user', reason: auto ? `abandoned automatically (${approveMode} mode)` : 'abandoned by the user', audit: Object.keys(auditExtra).length > 0 ? auditExtra : undefined, patch: { cleanup: { mode, at: now(), by: auto ? 'host' : 'user' } } })
     if (mode === 'keep') return result(abandoned, `abandoned; ${abandoned.path} and ${abandoned.branch} are kept`)
-    // Read-only residue probe BEFORE anything is removed (design D5): a
-    // warning only, never a gate, and it never mutates the authority. The
-    // confirmation card already carried the warning when there was one.
-    const residue = residueOf(repo, lane)
     const scratch = existsSync(lane.path) ? syncScratch(repo, lane) : null
     if (existsSync(lane.path)) {
       try {
@@ -701,7 +680,7 @@ export function createLaneWorkflows(core) {
       branchNote = `; deleted ${lane.branch}${unmerged > 0 ? ` (${unmerged} unmerged commit(s) discarded)` : ''}`
     }
     const final = await patchLane(repo, laneId, (current) => ({ cleanup: { ...current.cleanup, scratch } }))
-    return result(final, `abandoned; removed ${lane.path}${branchNote}${residue ? `; ${residueNote(residue)}` : ''}`)
+    return result(final, `abandoned; removed ${lane.path}${branchNote}`)
   }
 
   // ─── watches (lane state subscriptions) ────────────────────────────────