weir-harness 1.2.3 → 2.1.0

package/src/process/index.js

@@ -475,9 +475,11 @@ export function spawnArgv(command, args = [], platform = process.platform, optio
       // Unknown shim, but nothing here can be re-parsed: let cmd run it.
       return ['cmd.exe', '/d', '/c', command, ...args]
     }
+    const subject = options.subject ?? 'lsp'
+    const setting = options.setting ?? 'lspServers'
     throw new Error(
-      `lsp: cannot start '${command}' on Windows — its .cmd shim could not be unwrapped and the path or an argument contains characters cmd.exe would re-parse. ` +
-        `Install the server as a plain .exe, or point lspServers at its node entry point.`,
+      `${subject}: cannot start '${command}' on Windows — its .cmd shim could not be unwrapped and the path or an argument contains characters cmd.exe would re-parse. ` +
+        `Install the server as a plain .exe, or point ${setting} at its node entry point.`,
     )
   }
   return [command, ...args]

package/src/settings/index.js

@@ -14,32 +14,14 @@ import { configValue } from './volatile.js'
 import { computeSections } from './sections.js'
 import { wireLspAdmin } from '../lsp/admin.js'
 import { wireEnvAdmin } from './env-admin.js'
-import { createEditLockEvidence, wireEditLockMaintenance } from '../edit-lock/maintenance.js'
-import { managementRootFor } from '../edit-lock/domains.js'
-import { createAudit, AUDIT_TYPES } from '../shared/audit.js'
-
-// Host lifetime, not settings-row lifetime: remounting settings must not forget
-// still-live preset rows. Weak keys isolate hosts and release stopped hosts.
-const evidenceByHost = new WeakMap()
 
 export { Config } from './sections.js'
 
 const name = 'weir-settings'
 const inject = []
 
-// Explicit resolver seam keeps root-discovery tests away from ancestor authorities.
-export function maintenanceRoots(agents, resolveRoot = managementRootFor) {
-  const roots = new Set()
-  for (const agent of agents?.roots?.() ?? []) {
-    const cwd = agent.session?.header?.cwd
-    if (typeof cwd !== 'string') continue
-    try { roots.add(resolveRoot(cwd)) } catch { /* unavailable root */ }
-  }
-  return [...roots]
-}
-/** @param {{ resolveRoot?: typeof managementRootFor }} [dependencies] */
-export function createSettingsPlugin({ resolveRoot = managementRootFor } = {}) {
 // Arrow apply: cordis must retain the returned endpoint disposer, not construct it.
+export function createSettingsPlugin() {
 return (ctx, config = {}) => {
   // The whitelist defaults cache: the defaults file is read once per process,
   // and an explicit reload entry (robashDefaultsReload) clears it. Nothing here
@@ -55,21 +37,9 @@ return (ctx, config = {}) => {
   // Compute eagerly: malformed categoryChains/lspServers/robash lists fail
   // activation loud.
   compute()
-  const host = ctx.root ?? ctx
-  let editLockEvidence = evidenceByHost.get(host)
-  if (!editLockEvidence) {
-    editLockEvidence = createEditLockEvidence()
-    evidenceByHost.set(host, editLockEvidence)
-  }
-  const candidateRoots = () => maintenanceRoots(ctx.get?.('agents'), resolveRoot)
-  const savedEnabled = () => compute().editLock?.enabled === true
-  const audit = createAudit(ctx)
-  let lastEnabled = savedEnabled()
-
   const listeners = new Set()
   // Host-plane service: preset modules read their override section on demand.
   ctx.reflect.provide('weirSettings', {
-    editLockEvidence,
     get(key) {
       return compute()[key]
     },
@@ -97,17 +67,6 @@ return (ctx, config = {}) => {
   observeReloadEntry()
   ctx.on('loader/volatile-update', () => {
     observeReloadEntry()
-    const enabled = savedEnabled()
-    if (enabled !== lastEnabled) {
-      lastEnabled = enabled
-      // Profile intent has no session log. Mirror only when a server-derived
-      // workspace exists; no cwd fallback to the developer's current directory.
-      const data = { kind: enabled ? 'enable-requested' : 'disable-requested', scope: 'profile', appliesAfterRestart: true }
-      let roots = []
-      try { roots = candidateRoots() } catch { /* emit remains available */ }
-      if (roots.length) for (const root of roots) audit(null, AUDIT_TYPES.editLockMaintenance, data, { root })
-      else audit(null, AUDIT_TYPES.editLockMaintenance, data)
-    }
     for (const callback of listeners) callback()
   })
 
@@ -126,11 +85,10 @@ return (ctx, config = {}) => {
   // built-in catalog.
   const offLspAdmin = wireLspAdmin(ctx, () => compute().lsp?.servers)
 
-  const offMaintenance = wireEditLockMaintenance(ctx, { savedEnabled, evidence: editLockEvidence, candidateRoots })
   // Environment facts endpoint (settings-page `when: { env }` rows): same
   // settings-row wiring as the LSP endpoints above (S19).
   const offEnvAdmin = wireEnvAdmin(ctx)
-  return () => { offMaintenance(); offLspAdmin(); offEnvAdmin(); listeners.clear() }
+  return () => { offLspAdmin(); offEnvAdmin(); listeners.clear() }
 }
 }
 const apply = createSettingsPlugin()

package/src/settings/sections.js

@@ -43,17 +43,6 @@ const FIELDS = [
   { key: 'guardSoftThreshold', section: 'contextGuard', field: 'softThreshold', type: 'number', description: 'Soft pressure threshold (live advisory; 0 < soft < hard < 1)' },
   { key: 'guardHardThreshold', section: 'contextGuard', field: 'hardThreshold', type: 'number', description: 'Hard pressure threshold (live maintenance request; not a completion guarantee)' },
   { key: 'hashlineHideStockEdit', section: 'hashlineEdit', field: 'hideStockEdit', type: 'boolean', description: 'Hide the stock edit tool (hash_edit only)', restart: true },
-  { key: 'editLockEnabled', section: 'editLock', field: 'enabled', type: 'boolean', description: 'Edit Lock cross-session file ownership (default on; explicit off applies after restart)', restart: true },
-  // Retention (design D1/D2): one lock batch shares one cumulative allowance, so a
-  // session reads one expiry instead of N countdowns. These keys are policy, not
-  // mechanism: the kernel never sees them, the lifecycle resolves them per call.
-  { key: 'editLockHoldDefaultMinutes', section: 'editLock', field: 'holdDefaultMinutes', type: 'number', description: 'Edit Lock: retention minutes used when a session asks to keep its locks without giving a period (default 30)', page: false },
-  { key: 'editLockHoldSingleMaxMinutes', section: 'editLock', field: 'holdSingleMaxMinutes', type: 'number', description: 'Edit Lock: most minutes one retention request may ask for (default 30)', page: false },
-  { key: 'editLockHoldCumulativeMaxMinutes', section: 'editLock', field: 'holdCumulativeMaxMinutes', type: 'number', description: 'Edit Lock: cumulative retention minutes one batch of locks may use; asks beyond it are refused and only release remains (default 120)', page: false },
-  { key: 'editLockNudgeAttempts', section: 'editLock', field: 'nudgeAttempts', type: 'number', description: 'Edit Lock: how many times a finished turn is continued to ask for still-held locks to be released or retained (default 2)', page: false },
-  { key: 'editLockNudgeFallback', section: 'editLock', field: 'nudgeFallback', type: { union: ['release', 'abnormal'] }, description: 'Edit Lock: disposition of locks still held after those notices are used up; release frees the files for other sessions, abnormal keeps them for the user (default release)', page: false },
-  { key: 'editLockAutoResume', section: 'editLock', field: 'autoResume', type: 'boolean', description: 'Edit Lock: a genuine user message automatically resumes a stopped or administratively revoked session and retries a duplicate-binding failure (default on)' },
-  { key: 'editLockStaleSweep', section: 'editLock', field: 'staleSweep', type: 'boolean', description: 'Edit Lock: a genuine user message silently releases locks whose target file no longer exists (default on; read per message, applies immediately)' },
   { key: 'robashEnabled', section: 'robash', field: 'enabled', type: 'boolean', description: 'Guarded read-only bash for curated agents (master switch)' },
   { key: 'robashAllow', section: 'robash', field: 'allow', type: 'string', list: true, description: 'JSON array of command names to APPEND to the product-default bash allow list (empty adds nothing; the defaults are always in effect)' },
   { key: 'robashGitAllow', section: 'robash', field: 'gitAllow', type: 'string', list: true, description: 'JSON array of git subcommands to APPEND to the product-default git allow list (empty adds nothing; the defaults are always in effect)' },
@@ -98,8 +87,8 @@ export { FIELDS }
 
 /** Product defaults of the flat settings keys, mirrored from the consuming
  * modules' code defaults (intent-gate classifier, delegate supervision,
- * todo driver, context guard, edit-lock retention, robash, lsp, worktree,
- * notify). This is the canonical declaration: the cordis.patch.yml
+ * todo driver, context guard, robash, lsp, worktree, notify). This is the
+ * canonical declaration: the cordis.patch.yml
  * weir-settings row carries the same values so saved profiles resolve
  * them, and the settings page mirrors this table client-side to SHOW the
  * effective default of an unset field (both directions pinned by test).
@@ -121,14 +110,6 @@ export const FIELD_DEFAULTS = Object.freeze({
   guardSoftThreshold: 0.72,
   guardHardThreshold: 0.88,
   hashlineHideStockEdit: true,
-  editLockEnabled: true,
-  editLockHoldDefaultMinutes: 30,
-  editLockHoldSingleMaxMinutes: 30,
-  editLockHoldCumulativeMaxMinutes: 120,
-  editLockNudgeAttempts: 2,
-  editLockNudgeFallback: 'release',
-  editLockAutoResume: true,
-  editLockStaleSweep: true,
   robashEnabled: true,
   lspEnabled: false,
   lspIdleMs: 600000,
@@ -360,9 +341,6 @@ export function computeSections(config, { readDefaults } = {}) {
         }
       }
     }
-    // A saved profile row replaces the bundle row wholesale. An omitted key
-    // must still activate protection; a saved false remains an explicit opt-out.
-    if (key === 'editLock' && out.enabled === undefined) out.enabled = FIELD_DEFAULTS.editLockEnabled
     if (key === 'contextGuard') guardOptions(out)
     if (key === 'lsp' && typeof out.servers === 'string' && out.servers.trim().length > 0) {
       out.servers = parseJsonField(validateLspServers, out.servers)

package/src/shared/audit.js

@@ -23,7 +23,6 @@ export const AUDIT_TYPES = Object.freeze({
   compaction: 'compaction',
   supervision: 'supervision',
   worktree: 'worktree',
-  editLockMaintenance: 'edit-lock-maintenance',
   // Session capability manager (tasks 4.2+): one record per durable Apply
   // acceptance or receipt-query recovery; never commit evidence by itself.
   capabilityApply: 'capability-apply',
@@ -35,6 +34,9 @@ export const AUDIT_TYPES = Object.freeze({
   // identity, feed census and provider status, never skill names; the receipt
   // itself stays the only effective-state authority.
   capabilityRead: 'capability-read',
+  // MCP management mutations: operation/status/identity/generation/incarnation
+  // only. Never config, credential refs or values, argv, URLs, or raw errors.
+  capabilityMcp: 'capability-mcp',
   // The pending model-facing capability notice (durable-pending-notice D7):
   // queue / degrade / deliver / clear outcomes of the durable notice unit.
   // Counts only, never names — the same rule as capability-read above; the
@@ -48,6 +50,12 @@ export const AUDIT_TYPES = Object.freeze({
   // spawn carrying the composition the child's creation window applies, so a
   // host restart can replay it — the shim itself is runtime-only state.
   delegate: 'delegate',
+  // File-lease degraded managed writes (edit-lock-rebuild D7): one record per
+  // degradation, carrying the kind, the owner (session and lineage), the path
+  // COUNT and the failure reason — never path contents. The lease client owns
+  // the per-process rate limit (one record per window); the emit site adds no
+  // throttle of its own and a failed emit never blocks a write.
+  fileLease: 'file-lease',
 })
 /**
  * Known dynamic sub-event kinds: `<type>/<kind>` events emitted beside a base

package/src/shared/child-scope.js

@@ -44,6 +44,7 @@ export const CHILD_DENY_TOOLS = [
   'worktree_check',
   'exit_plan_mode',
   'ask_user_question',
+  'mcp_install',
   'present',
   'edit_lock_acquire',
   'edit_lock_hold',
@@ -51,6 +52,7 @@ export const CHILD_DENY_TOOLS = [
   'edit_lock_release',
   'edit_lock_status',
   'edit_lock_try_steal',
+  'edit_lock_watch',
 ]
 
 /**

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) ────────────────────────────────

package/src/worktree/rules.js

@@ -91,7 +91,7 @@ import { bareSetupCommand } from './pkgmgr.js'
  * Lockfile-derived package MANAGER, or null when the repository has none.
  * Only the manager is decided here: how it is invoked (system tool, DSH
  * bundled runtime, or nothing available) is resolved separately so a bare
- * `pnpm` is never assumed to exist on PATH (AGENTS.md §2, S21).
+ * `pnpm` is never assumed to exist on PATH (docs/contributing/development.md §1, S21).
  * @param {Iterable<string>} fileNames - names present at the lane root
  * @returns {'pnpm' | 'bun' | 'yarn' | 'npm' | null}
  */