weir-harness 1.2.3 → 2.1.0

package/src/capabilities/skill-selection-plugin.js

@@ -15,6 +15,7 @@ import { createLifecycleSnapshots } from './lifecycle-snapshot.js'
 import { preloadLifecycleSnapshots } from './lifecycle-preload.js'
 import { classifySelectionFailure } from './selection-status.js'
 import { resolveInitialSelection, baselineSkillIdentities, bindDefaultSkillNames } from './initial-selection.js'
+import { partitionUnresolvedSkills } from './skill-applicability.js'
 import { workspaceKeyOf, createPresetVerbs } from './preset-library.js'
 import { createDefaultsVerbs } from './defaults-transaction.js'
 import { buildPresetsPayload, buildDefaultGetPayload } from './read-payloads.js'
@@ -23,8 +24,11 @@ import { createApplyEngine } from './apply-engine.js'
 import { createSessionDrainAdapter } from './mcp-drain.js'
 import { createSelectionNotifier } from './selection-notify.js'
 import { createMcpRegistry } from './mcp-registry.js'
+import { createMcpOperations } from './mcp-operations.js'
+import { mcpDiagnostic } from './mcp-diagnostics.js'
 import { buildReceiptPayload, buildListPayload, buildConditionsPayload } from './read-payloads.js'
-import { feedCapabilityReadBridge } from './capability-remote.js'
+import { feedCapabilityReadBridge, capabilityReadFeed, capabilityOwnership, createCapabilityMutationService, sameMutationOwner } from './capability-remote.js'
+import { createMcpInstallTool } from './mcp-install-tool.js'
 import { parseFrontmatter } from './frontmatter.js'
 import { createAudit } from '../shared/audit.js'
 
@@ -84,8 +88,14 @@ export function createSkillSelectionPlugin(dependencies = {}) {
             // between the host's session publication and our capture, or a
             // hand-built session) is REFUSED — never granted the root
             // baseline (6.4 subagent rule; explicit resume recaptures).
+            //
+            // Only a TRUE delegated child (depth > 0) is refused: a depth-0
+            // fork also carries a parentSession header, and when its source
+            // never established any effective snapshot the creation-time
+            // capture is skipped on purpose so that this read performs the
+            // ordinary root initialization for the fork itself.
             const header = options.scope?.session?.header ?? {}
-            const isSubagent = (header.delegationDepth ?? 0) > 0 || typeof header.parentSession === 'string'
+            const isDelegatedChild = (header.delegationDepth ?? 0) > 0
             let inherited
             try {
               inherited = await store.read({ kind: 'inherited', sessionId })
@@ -94,7 +104,12 @@ export function createSkillSelectionPlugin(dependencies = {}) {
             }
             if (inherited.kind === 'ok') return inherited.payload?.skills
             if (inherited.kind !== 'absent') throw new Error(`Inherited skill snapshot is ${inherited.kind}`)
-            if (isSubagent) throw new Error('Inherited skill snapshot is absent')
+            if (isDelegatedChild) throw new Error('Inherited skill snapshot is absent')
+            // Root initialization is only for a PROVEN absent source. A depth-0
+            // fork whose capture or existing policy already became BLOCKED must
+            // keep the inherited-snapshot failure, never bypass it with a fresh
+            // baseline; an explicit accepted Apply remains the recovery path.
+            if (lifecycle?.snapshotFor?.(sessionId)?.state === 'blocked') throw new Error('Inherited skill snapshot is absent')
             return initialSelection(options)
           }
           if (record.kind !== 'ok') throw new Error(`Skill selection policy is ${record.kind}`)
@@ -151,18 +166,26 @@ export function createSkillSelectionPlugin(dependencies = {}) {
           }
           let builtinIdentities = []
           let enabledMcpIdentities = []
+          const registry = await createMcpRegistry({ store }).read()
+          if (registry.kind !== 'ok' && registry.kind !== 'absent') throw new Error(`MCP registry is ${registry.kind}`)
+          const registryServers = registry.kind === 'ok' ? registry.servers : {}
+          // Only a FULLY formed initial result may become a lifecycle snapshot:
+          // a baseline or a name binding derived from an incomplete inventory is
+          // a best-effort view, never an inheritable set (D2).
+          let complete = true
           if (defaultsRecord.kind === 'absent') {
             const snapshot = await inventory(options)
+            complete = snapshot?.complete !== false
             // Baseline scopes are row-configurable (default builtin-only);
             // the weir-creative preset adds 'custom' for its fused skills.
             builtinIdentities = baselineSkillIdentities(snapshot?.candidates, config.baselineScopes)
-            try {
-              const registry = await store.read({ kind: 'mcp-registry' })
-              const payload = registry.kind === 'ok' ? registry.payload ?? {} : {}
-              enabledMcpIdentities = Array.isArray(/** @type {Record<string, unknown>} */ (payload).enabled) ? /** @type {string[]} */ (/** @type {Record<string, unknown>} */ (payload).enabled) : []
-            } catch { /* an unreadable registry enables no managed identity by default */ }
+            enabledMcpIdentities = registry.kind === 'ok' ? registry.enabled : []
           }
           const resolved = resolveInitialSelection({ defaultsRecord, builtinIdentities, enabledMcpIdentities })
+          for (const identity of resolved.selection.mcpServers) {
+            if (!registryServers[identity]) resolved.missing.push({ kind: 'mcp', ref: identity, reason: 'configured default is not registered' })
+          }
+          resolved.selection.mcpIncarnations = Object.fromEntries(resolved.selection.mcpServers.filter(identity => registryServers[identity]).map(identity => [identity, registryServers[identity].incarnation ?? null]))
           // Name-string skill entries in a workspace default (the client
           // draft's wire shape, written by default-save from:'draft') bind
           // against the live inventory by unique name; unbindable entries
@@ -171,6 +194,7 @@ export function createSkillSelectionPlugin(dependencies = {}) {
           // entirely — it still only runs on the builtin-baseline path.
           if (resolved.source === 'workspace-default' && resolved.selection.skills.some(entry => typeof entry === 'string')) {
             const snapshot = await inventory(options)
+            complete = complete && snapshot?.complete !== false
             const bound = bindDefaultSkillNames(resolved.selection.skills, snapshot?.candidates)
             resolved.selection.skills = bound.skills
             resolved.missing = [...resolved.missing, ...bound.missing]
@@ -178,6 +202,23 @@ export function createSkillSelectionPlugin(dependencies = {}) {
           const sessionId = options.scope?.session?.id
           if (typeof sessionId === 'string' && sessionId.length) {
             initialReports.set(sessionId, { source: resolved.source, missing: resolved.missing, mcpServers: resolved.selection.mcpServers })
+            // Effective-set publication for Fork inheritance: a depth-0 fork of a
+            // session whose initial set was already resolved must inherit THAT
+            // set, not an empty one. The result is published as the session's
+            // revision-0 lifecycle snapshot — never persisted, never an accepted
+            // record. A snapshot that appeared while this async resolution was
+            // in flight (an accepted Apply, a captured inheritance) wins, and a
+            // partially resolved/incomplete result is not published at all.
+            if (complete && lifecycle && typeof lifecycle.peek === 'function' && typeof lifecycle.publish === 'function'
+              && lifecycle.peek(sessionId) === null) {
+              lifecycle.publish(sessionId, {
+                revision: 0,
+                skills: resolved.selection.skills,
+                mcpServers: resolved.selection.mcpServers,
+                mcpIncarnations: resolved.selection.mcpIncarnations,
+                captured: null,
+              })
+            }
           }
           return resolved.selection.skills
         })
@@ -262,6 +303,7 @@ export function createSkillSelectionPlugin(dependencies = {}) {
         locateSession: session => session,
         inventory: (options) => inventory(options),
         provider,
+        mcpRegistry: createMcpRegistry({ store: storeFor() }),
         ...applyEngineHooks({ ctx, lifecycle, notifier, audit }),
       })
       return sharedEngine
@@ -403,6 +445,11 @@ export function createSkillSelectionPlugin(dependencies = {}) {
               matches.push(candidate)
               parsedByName.set(candidate.name, matches)
             }
+            // The unresolved draft entries keep their ORIGINAL shape: a legacy
+            // name string is not an identity and cannot be classified by
+            // workspace, while an identity object carries the scope/root the
+            // cross-workspace partition needs. Collapsing both to a name here
+            // is what made a foreign project reference unactionable.
             const missing = []
             const identities = []
             const admitted = new Set()
@@ -415,7 +462,7 @@ export function createSkillSelectionPlugin(dependencies = {}) {
               } else {
                 const identity = createSkillIdentity(entry)
                 candidate = byKey.get(skillIdentityKey(identity))
-                if (!candidate) missing.push(identity.name)
+                if (!candidate) missing.push(identity)
               }
               if (!candidate) continue
               const key = skillIdentityKey(candidate.identity)
@@ -423,19 +470,26 @@ export function createSkillSelectionPlugin(dependencies = {}) {
               admitted.add(key)
               identities.push(candidate.identity)
             }
-            // preset-skill-applicability (D2): partition the missing names —
-            // KNOWN-BUT-INAPPLICABLE (resolvable in a profile-supplemental
-            // directory, e.g. creative-preset skills carried by a workspace
-            // default) are SKIPPED with a per-name reason while the
-            // resolvable remainder commits; genuinely unknown names keep the
-            // hard-failure contract. Records are never rewritten for
-            // applicability, so a preset round-trip stays lossless.
-            const unknown = []
-            const skipped = []
-            for (const name of missing) {
-              if (supplementalSkillKnown(config.supplementalSkillDirs, name)) skipped.push({ name, reason: 'not applicable in this agent preset' })
-              else unknown.push(name)
-            }
+            // preset applicability partition (D2 + cross-workspace D4):
+            // - KNOWN-BUT-INAPPLICABLE names (resolvable in a profile-supplemental
+            //   directory, e.g. creative-preset skills carried by a workspace
+            //   default) are SKIPPED with a per-name reason;
+            // - a project identity PROVEN to belong to another workspace (its
+            //   canonical root is outside every current project Skill root of a
+            //   COMPLETE inventory) is SKIPPED as not applicable in this
+            //   workspace — the preset contract, not a same-name conflict, and
+            //   never a local same-name substitute;
+            // - everything else keeps the hard-failure contract with the draft
+            //   preserved (a local identity the inventory no longer resolves, a
+            //   project identity of THIS workspace, an incomplete inventory, or
+            //   an unresolvable current-workspace root set authorizes no skip).
+            // Records are never rewritten for applicability, so a preset
+            // round-trip stays lossless.
+            const { skipped, unknown } = partitionUnresolvedSkills(missing, {
+              roots: inventoryResult?.roots,
+              complete: inventoryResult?.complete,
+              knownSupplemental: name => supplementalSkillKnown(config.supplementalSkillDirs, name),
+            })
             if (unknown.length > 0) return { kind: 'error', text: JSON.stringify({ status: 'missing', missing: unknown, ...(skipped.length > 0 ? { skipped } : {}) }) }
             const response = await face.applySelection(
               { sessionId: agent.id, cwd: agent.session?.header?.cwd, presetId: 'weir' },
@@ -448,41 +502,36 @@ export function createSkillSelectionPlugin(dependencies = {}) {
           }
         }
 
-        /**
-         * mcp-add: register a new managed MCP server and mount it
-         * immediately (8.1 registry + manager start). Payload:
-         * {identity, label, command, args?: [], env?: {}, serverName?}
-         */
-        const mcpAddVerb = async (spec) => {
+        const mcpVerb = (action) => async (spec = {}, { agent }) => {
           try {
-            if (typeof spec.identity !== 'string' || typeof spec.label !== 'string' || typeof spec.command !== 'string' || spec.command.length === 0) {
+            if (action === 'mcp-add' && (typeof spec.identity !== 'string' || typeof spec.label !== 'string' || typeof spec.command !== 'string' || spec.command.length === 0)) {
               return { kind: 'error', text: 'mcp-add needs identity, label and command strings' }
             }
-            const store = openStore()
-            const registry = createMcpRegistry({ store })
-            const current = await registry.read()
-            const expectedRevision = current.kind === 'ok' ? current.revision : 0
-            const entry = {
-              identity: spec.identity,
-              label: spec.label,
-              owner: { kind: 'global', key: 'installation' },
-              transport: { kind: 'stdio', ref: `cmd:${spec.command}` },
-              client: {
-                transport: 'stdio',
-                serverName: typeof spec.serverName === 'string' && spec.serverName.length ? spec.serverName : spec.identity,
-                command: spec.command,
-                args: Array.isArray(spec.args) ? spec.args.map(String) : [],
-                env: spec.env && typeof spec.env === 'object' && !Array.isArray(spec.env) ? spec.env : {},
-                reconnect: { enabled: true },
-              },
+            const { expectedRevision, confirmNamespaceChange, targetFingerprint, attemptId, batch, mode, refsOnly, surface: _ignoredSurface, ...fields } = spec
+            const operation = action === 'mcp-default' ? 'setDefault' : action === 'mcp-preview' ? 'preview' : action === 'mcp-batch' ? 'batch' : action.slice(4)
+            const request = {
+              ...spec,
+              action: operation === 'batch' ? 'add' : operation,
+              refsOnly: action === 'mcp-add' ? false : true,
+              // The command channel is refs-only (legacy mcp-add aside). A
+              // caller-supplied `surface` is ignored here: only the Host UI
+              // mutation channel may accept transient literal secrets.
+              surface: action === 'mcp-add' ? 'legacy' : 'refs',
             }
-            const committed = await registry.register(entry, expectedRevision)
-            if (committed.status !== 'committed') return { kind: 'error', text: JSON.stringify({ status: committed.status }) }
-            const manager = ctx.get?.('weirMcpManager')
-            if (manager?.start) await manager.start()
-            return { kind: 'success', text: JSON.stringify({ status: 'registered', identity: entry.identity, generation: 1, mounted: Boolean(manager?.start) }) }
+            if (!spec.config && !spec.document && !['remove', 'restart', 'setDefault', 'recover'].includes(operation)) {
+              if (operation === 'batch' || fields.mcpServers) request.document = fields
+              else request.config = fields
+            }
+            const operations = face.mcpOperations(agent.session)
+            const result = operation === 'preview'
+              ? await operations.preview(request)
+              : operation === 'batch'
+                ? await operations.executeBatch(request)
+                : await operations.execute(request)
+            const successful = new Set(['preview', 'mounted', 'saved', 'removed', 'recovered'])
+            return { kind: successful.has(result.status) ? 'success' : 'error', text: JSON.stringify(result) }
           } catch (cause) {
-            return { kind: 'error', text: `capabilities mcp-add failed: ${cause instanceof Error ? cause.message : String(cause)}` }
+            return { kind: 'error', text: JSON.stringify({ status: 'validation-failed', saved: false, error: mcpDiagnostic(cause, { code: cause?.code ?? 'validation-failed' }) }) }
           }
         }
 
@@ -498,7 +547,15 @@ export function createSkillSelectionPlugin(dependencies = {}) {
           receipt: { payload: 'none', run: receiptVerb },
           list: { payload: 'none', run: listVerb },
           apply: { payload: 'required', usage: 'Usage: /capabilities apply <json selection>', run: applyVerb },
-          'mcp-add': { payload: 'required', usage: 'Usage: /capabilities mcp-add <json {identity,label,command,args?,env?,serverName?}>', run: mcpAddVerb },
+          'mcp-add': { payload: 'required', usage: 'Usage: /capabilities mcp-add <json {identity,label,command,args?,env?,serverName?}>', run: mcpVerb('mcp-add') },
+          'mcp-preview': { payload: 'required', usage: 'Usage: /capabilities mcp-preview <json server|{mcpServers:{...}}>', run: mcpVerb('mcp-preview') },
+          'mcp-batch': { payload: 'required', usage: 'Usage: /capabilities mcp-batch <json {mcpServers:{...},mode?:"add"|"edit"}>', run: mcpVerb('mcp-batch') },
+          'mcp-edit': { payload: 'required', usage: 'Usage: /capabilities mcp-edit <json {identity,expectedRevision,...config}>', run: mcpVerb('mcp-edit') },
+          'mcp-remove': { payload: 'required', usage: 'Usage: /capabilities mcp-remove <json {identity,expectedRevision}>', run: mcpVerb('mcp-remove') },
+          'mcp-restart': { payload: 'required', usage: 'Usage: /capabilities mcp-restart <json {identity,expectedRevision}>', run: mcpVerb('mcp-restart') },
+          'mcp-test': { payload: 'required', usage: 'Usage: /capabilities mcp-test <json config>', run: mcpVerb('mcp-test') },
+          'mcp-default': { payload: 'required', usage: 'Usage: /capabilities mcp-default <json {identity,enabled,expectedRevision?}>', run: mcpVerb('mcp-default') },
+          'mcp-recover': { payload: 'optional', usage: 'Usage: /capabilities mcp-recover [json {identity?}]', run: mcpVerb('mcp-recover') },
           presets: { payload: 'none', run: presetVerbs.presets },
           'preset-save': { payload: 'required', usage: 'Usage: /capabilities preset-save <json>', run: presetVerbs['preset-save'] },
           'preset-rename': { payload: 'required', usage: 'Usage: /capabilities preset-rename <json>', run: presetVerbs['preset-rename'] },
@@ -515,7 +572,7 @@ export function createSkillSelectionPlugin(dependencies = {}) {
 
         ctx.effect(() => commands.register({
           name: 'capabilities',
-          description: 'Session capability surface for the Weir Badge and manager (receipt | list | conditions | presets | preset-save | preset-rename | preset-resave | preset-load | preset-delete | preset-export | preset-import | default-get | default-save | default-clear).',
+          description: 'Session capability surface (receipt | list | apply | mcp-preview | mcp-add | mcp-batch | mcp-edit | mcp-remove | mcp-restart | mcp-test | mcp-default | mcp-recover | presets and workspace defaults).',
           handler: async (invocation) => {
             const agent = invocation?.agent
             if (!agent) return { kind: 'error', text: 'capabilities: requires an owning agent session' }
@@ -528,8 +585,11 @@ export function createSkillSelectionPlugin(dependencies = {}) {
             const head = verb.split(' ', 1)[0]
             const entry = verbTable[head]
             const hasArgs = verb.length > head.length
-            if (!entry || (entry.payload === 'none' && hasArgs) || (entry.payload === 'required' && !hasArgs)) {
-              return { kind: 'error', text: 'Usage: /capabilities receipt|list|conditions|presets|preset-save|preset-load|preset-delete|preset-export|preset-import|default-get|default-save|default-clear' }
+            if (!entry || (entry.payload === 'none' && hasArgs)) {
+              return { kind: 'error', text: 'Usage: /capabilities receipt|list|apply|mcp-preview|mcp-add|mcp-batch|mcp-edit|mcp-remove|mcp-restart|mcp-test|mcp-default|mcp-recover|presets|default-get|default-save|default-clear' }
+            }
+            if (entry.payload === 'required' && !hasArgs) {
+              return { kind: 'error', text: entry.usage ?? 'Usage: /capabilities <verb> <json>' }
             }
             let spec
             if (entry.payload !== 'none' && hasArgs) {
@@ -572,6 +632,14 @@ export function createSkillSelectionPlugin(dependencies = {}) {
       clearFailure: options => provider?.clearFailure(options),
       /** Shared Apply entry (group 12 manager UI commits here). */
       applySelection: (session, request, options) => engineFor().apply(session, request, options),
+      mcpOperations: (session, options = {}) => createMcpOperations({
+        registry: createMcpRegistry({ store: storeFor() }),
+        manager: ctx.get?.('weirMcpManager'),
+        credentials: ctx.get?.('credentials'),
+        audit,
+        session,
+        assertOwner: options.assertOwner,
+      }),
       /** 12.4 diagnostics: whether a removal notice is queued for a session. */
       hasPendingNotification: sessionId => notifier.has(sessionId),
     }
@@ -587,11 +655,48 @@ export function createSkillSelectionPlugin(dependencies = {}) {
         inventory: (options, previous) => inventory(options, previous),
         lifecycle,
         mcpManager: () => ctx.get?.('weirMcpManager'),
+        mcpOperations: face.mcpOperations,
         profileContext: () => ctx.get?.('profileContext'),
       }), 'weir-capability-read-bridge')
     } catch (cause) {
       ctx.logger?.warn?.(`capability read bridge feed failed: ${cause instanceof Error ? cause.message : String(cause)}`)
     }
+    // Primary-Orchestrator AI installation rides the same selection row. All
+    // Host services are resolved lazily; missing confirmation/ownership support
+    // disables install without affecting inert preview or manual management.
+    try {
+      const tools = ctx.get?.('tools')
+      if (tools?.register) {
+        const sessionQuery = () => ctx.get?.('sessionQuery')
+        // Two retained revisions of this preset may feed the bridge at once;
+        // the owner is resolved per session through the agent's own revision.
+        const runtime = { agents: () => ctx.get?.('agents'), agentPresets: () => ctx.get?.('agentPresets') }
+        const mutations = createCapabilityMutationService({ sessionQuery, ...runtime })
+        const captureOwnership = async sessionId => {
+          const lease = await sessionQuery()?.observeSession?.(sessionId)
+          if (!lease || typeof lease[Symbol.dispose] !== 'function') throw Object.assign(new Error('MCP install session observation is unavailable'), { code: 'owner-unavailable' })
+          try {
+            const owner = capabilityOwnership(lease, sessionId)
+            const feed = capabilityReadFeed(owner.presetId, sessionId, runtime)
+            const faces = feed.faces ?? feed
+            return { owner, feed, profile: faces.profileContext?.() }
+          } finally { lease[Symbol.dispose]() }
+        }
+        const tool = createMcpInstallTool({
+          operationsFor: session => face.mcpOperations(session),
+          mutate: (sessionId, request) => mutations.mutate(sessionId, request),
+          captureOwnership,
+          sameOwnership: sameMutationOwner,
+          describeExecution: entry => ctx.get?.('weirMcpManager')?.describeExecution?.(entry),
+          userQuestions: () => ctx.get?.('userQuestions'),
+          isLiveRoot: agent => Boolean(agent && ctx.get?.('agents')?.get?.(agent.id) === agent),
+        })
+        if (typeof ctx.effect === 'function') ctx.effect(() => tools.register(tool), 'weir-mcp-install-tool')
+        else tools.register(tool)
+      }
+    } catch (cause) {
+      ctx.logger?.warn?.(`MCP install tool registration failed: ${cause instanceof Error ? cause.message : String(cause)}`)
+    }
   }
 }
 

package/src/capabilities/store/checked-contract.d.ts

@@ -1,6 +1,6 @@
 // Augmentations of the narrow checked-graph platform contract
-// (types/platform.d.ts) for the capability-store liveness/lock modules: the
-// edit-lock reservation reuses them, which pulls them into the checked graph.
+// (types/platform.d.ts) for the capability-store liveness/lock modules: they
+// pull these declarations into the checked graph.
 // Same discipline as the base contract — runtime modules remain supplied by
 // Node; these declarations only describe what the checked graph uses.
 declare module 'node:fs' {

package/src/capabilities/store/fs-adapter.js

@@ -21,9 +21,8 @@ import { link, mkdir, open, readFile, readdir, rename, unlink } from 'node:fs/pr
 // Directory fsync is a POSIX crash-durability idiom: on Windows the directory
 // handle opens but sync fails EPERM (verified on Node v24, NTFS). The win32
 // store row (SUPPORTED_PLATFORMS in store.js) therefore commits with
-// file-level fsync + atomic rename only — the same platform stance the
-// edit-lock reservation already takes (reservation.js SYNC_SUPPORTED). The
-// durability tradeoff is documented in docs/features/session-capability-manager.md.
+// file-level fsync + atomic rename only. The durability tradeoff is documented
+// in docs/features/session-capability-manager.md.
 const DIR_SYNC_SUPPORTED = process.platform === 'darwin' || process.platform === 'linux'
 
 // Windows file-locking etiquette: antivirus and the search indexer briefly

package/src/context-guard/index.js

@@ -118,7 +118,7 @@ function apply(ctx, config = {}) {
     const request = state.request
     if (!live(agent) || request?.kind !== 'applied' || request.delivered) return
     fresh(agent)
-    if (request.kind !== 'applied' || request.controller.signal.aborted || ctx.get?.('weirEditLock')?.blocksContinuation?.(agent)) {
+    if (request.kind !== 'applied' || request.controller.signal.aborted) {
       state.blocked = true
       request.delivered = true
       record(agent, request, 'resume-blocked')
@@ -197,7 +197,7 @@ function apply(ctx, config = {}) {
     if (decision.kind !== 'enter') return decision
     let resume
     const current = state.request
-    if (current?.kind === 'applied' && !current.delivered && !signal?.aborted && !ctx.get?.('weirEditLock')?.blocksContinuation?.(agent)) {
+    if (current?.kind === 'applied' && !current.delivered && !signal?.aborted) {
       current.delivered = true
       current.detach?.(); current.detachMaintenance?.()
       resume = RESUME_AFTER_COMPACTION

package/src/delegate/supervision-mount.js

@@ -10,7 +10,6 @@ import { auditFilePathOf, isTerminalStatus, readAuditTail, readChildFinalText }
 import { AUDIT_TYPES } from '../shared/audit.js'
 import { userTextMessage } from '../shared/user-message.js'
 import { contentText } from '../shared/content-text.js'
-import { withSupervisedEditResume, settleDelegateEditLifecycle } from '../shared/delegate-edit-lifecycle.js'
 
 /**
  * Mount the supervision subsystem on the plugin ctx.
@@ -81,8 +80,8 @@ export function mountSupervision({ ctx, audit, settings, supervisionNow, onChild
           sendTo: async (childId, text) => {
             await ctx.subagents.sendMessage(parent, childId, [{ type: 'text', text }], { signal: new AbortController().signal })
           },
-          resumeTo: (childId, text) => withSupervisedEditResume(parent, childId, () =>
-            ctx.subagents.sendMessage(parent, childId, [{ type: 'text', text }], { signal: new AbortController().signal })),
+          resumeTo: (childId, text) =>
+            ctx.subagents.sendMessage(parent, childId, [{ type: 'text', text }], { signal: new AbortController().signal }),
           interruptChild: (childId) => {
             ctx.subagents.interrupt(childId, { kind: 'ancestor', agent: parent })
           },
@@ -107,8 +106,9 @@ export function mountSupervision({ ctx, audit, settings, supervisionNow, onChild
               const runtime = runtimeFor(fact.childId)
               // No observed quiescence means no automatic handoff, including
               // a cold bookkeeping fact. Lane reconciliation owns that case.
-              const disposition = settleDelegateEditLifecycle(parent, fact.childId, runtime.agent)
-              void Promise.all([runtime.promise, disposition])
+              // Runtime quiescence is the ONLY gate: the retired Edit Lock
+              // disposition acknowledgement used to join here as well.
+              void runtime.promise
                 .then(() => onChildSettled?.(fact.childId, parent))
                 .catch(error => {
                   const note = `child ${fact.childId}: terminal handoff failed; lane remains bound: ${error?.message ?? error}`

package/src/delegate/tool.js

@@ -5,7 +5,6 @@ import { parseEscalation } from './escalate.js'
 import { continuableLane, oneShotLane, spawnGuardedChild, supervisedLane } from './spawn-adapter.js'
 import { WORKTREE_CODES } from '../worktree/errors.js'
 import { contentText } from '../shared/content-text.js'
-import { settleDelegateEditLifecycle } from '../shared/delegate-edit-lifecycle.js'
 
 export const DELEGATE_TOOL_NAME = 'delegate'
 export const BATCH_LIMIT = 16
@@ -319,16 +318,9 @@ async function spawnBackground(item, args, deps, exec) {
   return { job_id: jobId, label }
 }
 
-async function settledResult(started, parent) {
-  try { return await started.result } finally {
-    // subagent/end is emit, not an awaited barrier. Explicitly join the
-    // incarnation's standard edit disposition before result/escalation/handoff.
-    await settleDelegateEditLifecycle(parent, started.id, started.agent)
-  }
-}
 /** Await one child, honoring the one-level ESCALATE contract. */
 async function withEscalation(started, item, deps, exec, binding = null) {
-  const first = await settledResult(started, exec.agent)
+  const first = await started.result
   const text = contentText(first.output)
   const escalation = parseEscalation(text)
   if (!escalation) {
@@ -345,7 +337,7 @@ async function withEscalation(started, item, deps, exec, binding = null) {
   // The escalated respawn works in the same lane under the same binding (the
   // lane's bound child stays the first child; it settles once, after this).
   const respawned = await spawnGuardedChild({ target, prompt, parent: exec.agent, signal: exec.signal, label: `${laneLabel(target.label, binding)} (escalated)`, laneGuard: laneGuardOf(binding, deps, exec) }, oneShotLane(), deps)
-  const second = await settledResult(respawned, exec.agent)
+  const second = await respawned.result
   return {
     id: respawned.id,
     status: second.stopReason,