weir-harness 2.1.1 → 2.1.3

package/lib/client.js

@@ -1,4 +1,4 @@
-// Weir client chunks: {"client.blackboard-model.js":"2e5abdd44edb599d10d9d547fa07133e84250d6007161c2c8704b58151896f93","client.blackboard-panel.js":"c9d6a0f02623075fc884f3519f982574ad33ad871f7bcd7e8c36f12512f0de39","client.capability-badge.js":"f5c5d21293360d00815446beb8455794a1778ae033e270af37e436329ac09185","client.capability-manager.js":"f02e08174487f2f70e90a5c50a4a44cbeb4d462f115a2d2ab8a52ed8b4e70aee","client.capability-model.js":"57127dc5ea7ca6aa70c619480684f4de84fcbff4922f70df9886f55fad66abbf","client.capability-presets.js":"12ac8da3568d013abd76b67cfe473a329f4af2feaac9cd55a82d8881e5bc1017","client.chain-editor.js":"1e9a33bc68cabc43bc27b91ef83eab5028a33256596c147e15722d684687765b","client.chain-model.js":"2e885922cf8c2972725c6eef8bf20c7d1202d961edfb8ad41574dac062d74371","client.disabled-categories-editor.js":"f9103fd2e2691eda9afd199e1a5462189097a9f3dee0518be5fa3587d896e033","client.file-lease-badge.js":"cd30546307c91c94fe05484557e46f58c53fe55657f62b0a0415a072dfb3b582","client.file-lease-tool-model.js":"f72d87b049454ec489b4dffac1f32dabc273947b8a4c55fe07c91ddf320bd899","client.file-lease-tool-view.js":"7004caa06b36d8497a1d2e448b6ce5e4c8efd22ad903d8b39e26220de64bb1fe","client.hash-edit-model.js":"71727d47a6ef32ebd2abfb063fa93499a5e607d6716e3ec8983ae056c4fb317f","client.hash-edit-view.js":"fc0f4dabddab9a48527553ad4232b3715e46e6863aab75e02ae2dcd6687265c2","client.lsp-model.js":"30943ed1ed11c1f2770a724da855ea2417c11566c2778c79e17cfc2de499cd80","client.lsp-panel.js":"61629a4d317dae9ed01c1cc0355632fb752788dc23f7606257188050734cd030","client.lsp-toggle.js":"d6af81be5e5b854e98563bbb9349a6db89834a9d7dee9cf0e97759ecb32090e8","client.mcp-manager.js":"cfcd4792251fcca8bfa6a2c35b80881ab6f6480cf2ebce24a8ce304cddf940a7","client.model-picker.js":"57f96826e00b37ae6d6474a6750f31b4e128e5fdb37e302875a41cdb2e18f14a","client.notify-permissions.js":"2be9bdbeffef96baa3cbe4ce430ab30a1d1bf797782453d287d54602ea47db8e","client.notify-web.js":"0943f67d5526ff0fb7cb4f69580e0a9ea54ed06465c513afc51a5a7fb1c55ccf","client.robash-editor.js":"cd6a283b72cb02598e32ca4ce03a1b8de5f328ecdd1f5f920377524f3bdcbe1c","client.robash-model.js":"f4395338a773e8bb48e4f96aeb737cd634edcca0b90af992a7dbbe47be42e451","client.settings-page.js":"f3c04a5b33cdb963357bc653f7050e598f19efc4cc833694379a4ba055e949d3","client.worktree-model.js":"8bfbaaa080f20e90a0128afccb9b4e232514615a8f2fee3a32a42dde78b34a8f","client.worktree-view.js":"356c3f5f683b8509ae8679243a6460ca02957fd15e057a629b2ac4fdd12ed057"}
+// Weir client chunks: {"client.blackboard-model.js":"2e5abdd44edb599d10d9d547fa07133e84250d6007161c2c8704b58151896f93","client.blackboard-panel.js":"c9d6a0f02623075fc884f3519f982574ad33ad871f7bcd7e8c36f12512f0de39","client.capability-badge.js":"f5c5d21293360d00815446beb8455794a1778ae033e270af37e436329ac09185","client.capability-manager.js":"0c5b0e469b66b1ccdf720bb3db91ae15fd0be70c84287739de36a3bfceaed223","client.capability-model.js":"9beddda506617152c51d8159964fee74aecb99e8d50b50de82ab050d597ec9d1","client.capability-presets.js":"12ac8da3568d013abd76b67cfe473a329f4af2feaac9cd55a82d8881e5bc1017","client.chain-editor.js":"1e9a33bc68cabc43bc27b91ef83eab5028a33256596c147e15722d684687765b","client.chain-model.js":"2e885922cf8c2972725c6eef8bf20c7d1202d961edfb8ad41574dac062d74371","client.disabled-categories-editor.js":"f9103fd2e2691eda9afd199e1a5462189097a9f3dee0518be5fa3587d896e033","client.file-lease-badge.js":"cd30546307c91c94fe05484557e46f58c53fe55657f62b0a0415a072dfb3b582","client.file-lease-tool-model.js":"f72d87b049454ec489b4dffac1f32dabc273947b8a4c55fe07c91ddf320bd899","client.file-lease-tool-view.js":"7004caa06b36d8497a1d2e448b6ce5e4c8efd22ad903d8b39e26220de64bb1fe","client.hash-edit-model.js":"71727d47a6ef32ebd2abfb063fa93499a5e607d6716e3ec8983ae056c4fb317f","client.hash-edit-view.js":"fc0f4dabddab9a48527553ad4232b3715e46e6863aab75e02ae2dcd6687265c2","client.lsp-model.js":"30943ed1ed11c1f2770a724da855ea2417c11566c2778c79e17cfc2de499cd80","client.lsp-panel.js":"61629a4d317dae9ed01c1cc0355632fb752788dc23f7606257188050734cd030","client.lsp-toggle.js":"d6af81be5e5b854e98563bbb9349a6db89834a9d7dee9cf0e97759ecb32090e8","client.mcp-manager.js":"cfcd4792251fcca8bfa6a2c35b80881ab6f6480cf2ebce24a8ce304cddf940a7","client.model-picker.js":"57f96826e00b37ae6d6474a6750f31b4e128e5fdb37e302875a41cdb2e18f14a","client.notify-permissions.js":"2be9bdbeffef96baa3cbe4ce430ab30a1d1bf797782453d287d54602ea47db8e","client.notify-web.js":"0943f67d5526ff0fb7cb4f69580e0a9ea54ed06465c513afc51a5a7fb1c55ccf","client.robash-editor.js":"cd6a283b72cb02598e32ca4ce03a1b8de5f328ecdd1f5f920377524f3bdcbe1c","client.robash-model.js":"f4395338a773e8bb48e4f96aeb737cd634edcca0b90af992a7dbbe47be42e451","client.settings-page.js":"f3c04a5b33cdb963357bc653f7050e598f19efc4cc833694379a4ba055e949d3","client.worktree-model.js":"8bfbaaa080f20e90a0128afccb9b4e232514615a8f2fee3a32a42dde78b34a8f","client.worktree-view.js":"356c3f5f683b8509ae8679243a6460ca02957fd15e057a629b2ac4fdd12ed057"}
 window.__ModuleLoader__.load({
 	id: "weir-harness",
 	factory: (require) => {
@@ -891,6 +891,10 @@ window.__ModuleLoader__.load({
 			const capabilityVerbs = (sessionId) => ({
 				sessionId,
 				fetchReceipt: (sid) => capabilityRead("receipt", sid, null),
+				fetchSkillPaths: (sid) => capabilityRead("skillPaths", sid, {
+					status: "unavailable", saved: false, revision: 0, paths: [],
+					error: { code: "unavailable", message: "Skill scan paths are unavailable." }
+				}),
 				// Forwarded host events arrive via ctx.remote.$on — NOT a
 				// remote.session.subscribe (that API does not exist; the old
 				// wiring silently never subscribed, which is why cold sessions
@@ -910,6 +914,8 @@ window.__ModuleLoader__.load({
 				mcpPreview: (sid, request) => capabilityMutation("mutate", sid, request),
 				mcpMutate: (sid, request) => capabilityMutation("mutate", sid, request),
 				mcpBatch: (sid, request) => capabilityMutation("batch", sid, request),
+				skillPathAdd: (sid, request) => capabilityMutation("skillPathAdd", sid, request),
+				skillPathRemove: (sid, request) => capabilityMutation("skillPathRemove", sid, request),
 				fetchListing: (sid) => capabilityRead("list", sid, { error: true }),
 				fetchConditions: (sid) => capabilityRead("conditions", sid, { error: true }),
 				// The manager forwards only its established props. Adapt the lazy view
@@ -935,6 +941,10 @@ window.__ModuleLoader__.load({
 			// True once the right-sidebar package mounted the capabilities tab
 			// (the optional inject below ran); the Badge's openPanel verb exists
 			// only then — without it the Badge falls back to its composer popover.
+			const capabilityDictionaries = (model, panel) => ({
+				en: { ...model.dictionaries?.en, ...panel.dictionaries?.en },
+				zh: { ...model.dictionaries?.zh, ...panel.dictionaries?.zh }
+			});
 			let capabilitySidebarTab = false;
 			const CapabilityBadgeWrapper = (props) => {
 				const [impl, setImpl] = react.useState(null);
@@ -946,8 +956,19 @@ window.__ModuleLoader__.load({
 						require.async("./client.capability-manager.js"),
 						require.async("./client.mcp-manager.js").catch(() => null),
 					]).then(([badge, model, panel, mcp]) => {
-						registerChunkDictionaries("settings.weir.capability", model.dictionaries);
-						if (alive) setImpl(() => ({ Badge: badge.CapabilityBadge, model, Panel: panel.CapabilityManagerPanel, McpManagerView: mcp?.McpManagerView, McpManagerBoundary: mcp?.McpManagerBoundary }));
+						registerChunkDictionaries("settings.weir.capability", capabilityDictionaries(model, panel));
+						if (alive) setImpl(() => {
+							// The Badge chunk's established prop bridge is intentionally unchanged.
+							// Bind the new verbs once at this composition-root adapter so the
+							// composer popover and sidebar drive the identical path child.
+							const Panel = (panelProps) => react_jsx_runtime.jsx(panel.CapabilityManagerPanel, {
+								...panelProps,
+								fetchSkillPaths: props.fetchSkillPaths,
+								skillPathAdd: props.skillPathAdd,
+								skillPathRemove: props.skillPathRemove
+							});
+							return { Badge: badge.CapabilityBadge, model, Panel, McpManagerView: mcp?.McpManagerView, McpManagerBoundary: mcp?.McpManagerBoundary };
+						});
 					});
 					return () => { alive = false; };
 				}, [props.sessionId]);
@@ -984,7 +1005,7 @@ window.__ModuleLoader__.load({
 				require.async("./client.capability-manager.js"),
 				require.async("./client.mcp-manager.js").catch(() => null),
 			]).then((chunks) => {
-				registerChunkDictionaries("settings.weir.capability", chunks[0].dictionaries);
+				registerChunkDictionaries("settings.weir.capability", capabilityDictionaries(chunks[0], chunks[1]));
 				return chunks;
 			}));
 			function CapabilityPanelWrapper(props) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weir-harness",
-  "version": "2.1.1",
+  "version": "2.1.3",
   "type": "module",
   "description": "Weir \u2014 orchestrator-centric DSH agent preset: intent gate, category delegation, todo driver, pull-based background jobs, auto-compaction, hashline edit.",
   "license": "MIT",

package/src/capabilities/apply-engine.js

@@ -42,10 +42,11 @@ export const APPLY_AUDIT_TYPE = AUDIT_TYPES.capabilityApply
  * of the removed servers FOR THAT SESSION and returns a handle: snapshot()
  * reports the live in-flight counts (sent with the response, never awaited)
  * and abort() reopens exactly the gates begin() closed when the Apply does
- * not commit — abort() and begin() act on the SAME drain, so a failed Apply
- * never leaves a session permanently gated. Production wires the manager's
- * (agent, server)-keyed drain here (createSessionDrainAdapter, mcp-drain.js).
- * @typedef {{ begin(removed: string[], sessionId: string): { snapshot(): DrainStatus[], abort(): void } }} ApplyDrain
+ * not commit. After acceptance, reopen(restored, sessionId) opens only the
+ * servers the committed-over basis shows this Apply restored for that session.
+ * Production wires the manager's (agent, server)-keyed drain here
+ * (createSessionDrainAdapter, mcp-drain.js).
+ * @typedef {{ begin(removed: string[], sessionId: string): { snapshot(): DrainStatus[], abort(): void }, reopen(restored: string[], sessionId: string): void }} ApplyDrain
  * A step-tagged rejection keeps the old authority and the user's draft.
  * @typedef {{ status: 'applied', revision: number, receipt: unknown, effective: unknown, unresolvedWarnings: UnresolvedRef[], draining?: DrainStatus[], warnings?: string[] }
  *   | { status: 'duplicate', revision: number, receipt: unknown, effective: unknown, warnings?: string[] }
@@ -164,6 +165,9 @@ export function createDrainCoordinator() {
         },
       }
     },
+    reopen(restored) {
+      for (const server of restored) stateOf(server).closed = false
+    },
   }
 }
 
@@ -607,6 +611,18 @@ export function createApplyEngine(options) {
    *   degraded: (code: string, error?: unknown) => void }} segment
    */
   function publishAccepted({ sessionId, revision, payload, prepared, viewOptions, basisSets, lease, settle = null, degraded }) {
+    // The accepted set, not the transaction-start read, owns restoration. This
+    // runs only after a durable commit (or receipt proof), inside the held fence
+    // and before lifecycle publication/manager synchronization. A reopen failure
+    // cannot reject or roll back the landed write: degrade the response honestly.
+    const restoredServers = safeSets(payload).mcpServers.filter(server => !basisSets.mcpServers.includes(server))
+    if (restoredServers.length) {
+      try {
+        drain.reopen(restoredServers, sessionId)
+      } catch (error) {
+        degraded('drain-reopen-degraded', error)
+      }
+    }
     // Task 12.4: the net accepted delta is known only HERE (durable pre-write
     // record vs the just-committed payload); notify consumers queue it for
     // the next safe request. durable-pending-notice D2: the acceptance revision

package/src/capabilities/capability-remote.js

@@ -22,13 +22,14 @@ import { buildReceiptPayload, buildListPayload, buildConditionsPayload, buildPre
 import { PRESET_SELECTED_EVENT } from './preset-invalidation.js'
 import { createAudit } from '../shared/audit.js'
 import { mcpDiagnostic, sanitizeMcpPayload } from './mcp-diagnostics.js'
+import { createSkillScanPathRegistry } from './skill-scan-path-registry.js'
 
 /** The host-root service key the typert gateway resolves (S27: ctx.get from the host root). */
 export const CAPABILITY_READ_SERVICE_KEY = 'weirCapabilityRead'
 /** The wire namespace: POST /api/weirCapabilities/<method>, client ctx.remote.weirCapabilities.*. */
 export const CAPABILITY_READ_NAMESPACE = 'weirCapabilities'
-/** The five read methods, each taking exactly one parameter. */
-export const CAPABILITY_READ_METHODS = ['receipt', 'list', 'conditions', 'presets', 'defaultGet']
+/** The six read methods, each taking exactly one parameter. */
+export const CAPABILITY_READ_METHODS = ['receipt', 'list', 'conditions', 'presets', 'defaultGet', 'skillPaths']
 
 /** Typed infrastructure/ownership failure, distinct from domain status values. */
 export class CapabilityReadError extends Error {
@@ -157,6 +158,7 @@ export function capabilityOwnership(observation, sessionId) {
 export function createCapabilityReadService(dependencies = {}) {
   const bridgeFor = feedResolver(dependencies)
   const storeFor = dependencies.store ?? (profileContext => openCapabilityStore({ profileContext }))
+  const skillPathRegistryFor = dependencies.skillPathRegistry ?? (profileContext => createSkillScanPathRegistry({ store: storeFor(profileContext) }))
   const ensure = dependencies.ensureRegistered ?? (() => true)
   const onDegraded = dependencies.onDegraded ?? (() => {})
   const observeSession = dependencies.observeSession ?? (sessionId => dependencies.sessionQuery?.()?.observeSession(sessionId))
@@ -242,12 +244,13 @@ export function createCapabilityReadService(dependencies = {}) {
     defaultGet: sessionId => read(sessionId, 'defaultGet', (faces, options) => buildDefaultGetPayload({
       store: storeFor(faces.profileContext?.()),
     }, options)),
+    skillPaths: sessionId => read(sessionId, 'skillPaths', faces => skillPathRegistryFor(faces.profileContext?.()).read()),
   }
 }
 
 export const CAPABILITY_MUTATION_SERVICE_KEY = 'weirCapabilityMutation'
 export const CAPABILITY_MUTATION_NAMESPACE = 'weirCapabilityMutations'
-export const CAPABILITY_MUTATION_METHODS = ['mutate', 'batch']
+export const CAPABILITY_MUTATION_METHODS = ['mutate', 'batch', 'skillPathAdd', 'skillPathRemove']
 
 export function sameMutationOwner(first, second) {
   const profile = value => value ? `${value.home ?? ''}\0${value.name ?? ''}` : ''
@@ -257,9 +260,38 @@ export function sameMutationOwner(first, second) {
     && profile(first.profile) === profile(second.profile)
 }
 
+/** Call every accepting-process provider for exactly one changed Profile. */
+export function invalidateSkillScanPathProviders(profile) {
+  const failures = []
+  if (typeof profile?.home !== 'string' || typeof profile?.name !== 'string') {
+    return [new Error('changed Profile identity is unavailable')]
+  }
+  for (const feeds of bridgeFeeds.values()) {
+    for (const token of feeds) {
+      const faces = token.faces ?? token
+      try {
+        const candidate = faces.profileContext?.()
+        if (candidate?.home !== profile.home || candidate?.name !== profile.name) continue
+        if (typeof faces.provider?.sourceChanged !== 'function') throw new Error('mounted Skill provider cannot invalidate')
+        faces.provider.sourceChanged()
+      } catch (cause) {
+        failures.push(cause)
+      }
+    }
+  }
+  return failures
+}
+
+const pathDiagnostic = (cause, code = cause?.code ?? 'validation-failed') => ({
+  code,
+  message: cause instanceof Error ? cause.message : String(cause),
+})
+
 /** Session-preset/profile/feed ownership for mutations; selectionSeq is not compared. */
 export function createCapabilityMutationService(dependencies = {}) {
   const bridgeFor = feedResolver(dependencies)
+  const storeFor = dependencies.store ?? (profileContext => openCapabilityStore({ profileContext }))
+  const skillPathRegistryFor = dependencies.skillPathRegistry ?? (profileContext => createSkillScanPathRegistry({ store: storeFor(profileContext) }))
   const ensure = dependencies.ensureRegistered ?? (() => true)
   const observeSession = dependencies.observeSession ?? (sessionId => dependencies.sessionQuery?.()?.observeSession(sessionId))
   const observe = async sessionId => {
@@ -278,16 +310,18 @@ export function createCapabilityMutationService(dependencies = {}) {
       throw new CapabilityReadError('unknown-session', `capability mutation: cannot observe session ${JSON.stringify(sessionId)}`, { cause })
     }
   }
+  // The same exact observation/feed/Profile recheck serves MCP and path writes.
+  const ownershipAssertion = (sessionId, first) => async () => {
+    const current = await observe(sessionId)
+    try {
+      if (!sameMutationOwner(first, current)) throw new CapabilityReadError('owner-changed', 'capability mutation: session preset/profile/feed owner changed')
+    } finally { current.lease[Symbol.dispose]() }
+  }
   async function mutate(sessionId, request, batch = false) {
     if (!ensure()) throw new CapabilityReadError('channel-unavailable', 'capability mutation channel is not registered')
     const first = await observe(sessionId)
     try {
-      const assertOwner = async () => {
-        const current = await observe(sessionId)
-        try {
-          if (!sameMutationOwner(first, current)) throw new CapabilityReadError('owner-changed', 'capability mutation: session preset/profile/feed owner changed')
-        } finally { current.lease[Symbol.dispose]() }
-      }
+      const assertOwner = ownershipAssertion(sessionId, first)
       if (typeof first.faces.mcpOperations !== 'function') throw new CapabilityReadError('bridge-absent', 'capability mutation: owning preset has no MCP operations')
       const operations = first.faces.mcpOperations({ id: sessionId, header: { cwd: first.owner.cwd } }, { assertOwner })
       let result
@@ -322,9 +356,62 @@ export function createCapabilityMutationService(dependencies = {}) {
       first.lease[Symbol.dispose]()
     }
   }
+
+  async function mutatePath(sessionId, request, kind) {
+    if (!ensure()) throw new CapabilityReadError('channel-unavailable', 'capability mutation channel is not registered')
+    const first = await observe(sessionId)
+    try {
+      const assertOwner = ownershipAssertion(sessionId, first)
+      let result
+      try {
+        const registry = skillPathRegistryFor(first.profile)
+        result = kind === 'add'
+          ? await registry.add(request?.path, request?.expectedRevision, { assertOwner })
+          : await registry.remove(request?.path, request?.expectedRevision, { assertOwner })
+      } catch (cause) {
+        result = {
+          status: cause?.code === 'owner-changed' ? 'owner-changed' : 'validation-failed',
+          saved: false, revision: null, paths: null,
+          error: pathDiagnostic(cause, cause?.code ?? 'validation-failed'),
+        }
+      }
+
+      // A known or possibly landed registry write may already have changed the
+      // durable discovery scope. Invalidate every same-Profile mount before the
+      // response, without converting an ambiguous outcome into a definite one.
+      const indeterminate = result.status === 'indeterminate'
+      let invalidationFailure = null
+      if (result.saved === true || indeterminate) {
+        const failures = invalidateSkillScanPathProviders(first.profile)
+        if (failures.length > 0) invalidationFailure = failures.map(failure => pathDiagnostic(failure).message).join('; ')
+      }
+      try {
+        await assertOwner()
+      } catch (cause) {
+        return {
+          ...result,
+          status: indeterminate ? 'indeterminate' : 'owner-changed', ownerChanged: true, saved: result.saved === true,
+          error: pathDiagnostic(cause, 'owner-changed'),
+        }
+      }
+      if (invalidationFailure !== null) {
+        return {
+          ...result,
+          status: indeterminate ? 'indeterminate' : 'invalidation-failed',
+          error: { code: 'invalidation-failed', message: invalidationFailure },
+        }
+      }
+      return result
+    } finally {
+      first.lease[Symbol.dispose]()
+    }
+  }
+
   return {
     mutate: (sessionId, request) => mutate(sessionId, request, false),
     batch: (sessionId, request) => mutate(sessionId, request, true),
+    skillPathAdd: (sessionId, request) => mutatePath(sessionId, request, 'add'),
+    skillPathRemove: (sessionId, request) => mutatePath(sessionId, request, 'remove'),
   }
 }
 
@@ -343,7 +430,7 @@ export const CAPABILITY_ENDPOINTS = [
  * codecs, no zod, no generated artifacts). Parameters and results are plain
  * JSON; the envelope validates the argument name only.
  *
- * ALL five read and two mutation invocations live in ONE contribution, because
+ * ALL six read and four mutation invocations live in ONE contribution, because
  * the registry keys exactly one record per package+face and rejects any second
  * registration while that record is live: two separate `weir-harness` host-face
  * contributions could never overlap generations, and the face the mutation half

package/src/capabilities/lifecycle-feed.js

@@ -0,0 +1,47 @@
+// Per-mount Capability Lifecycle Snapshot ownership. A live token authorizes a
+// manager only when its lazy accessor returns that exact mutable manager face.
+// No mount-order, process-face, preset-name, or sole-feed fallback is permitted.
+
+/** @typedef {{ lifecycle: any, manager: (() => any) | null | undefined }} LifecycleFeedToken */
+/**
+ * Create an isolated registry for tests or an explicit in-process composition.
+ * Registration returns an ownership-scoped, idempotent disposer.
+ */
+export function createLifecycleFeedRegistry() {
+  /** @type {Set<LifecycleFeedToken>} */
+  const tokens = new Set()
+  return {
+    register({ lifecycle, manager }) {
+      const token = { lifecycle, manager }
+      tokens.add(token)
+      let live = true
+      return () => {
+        if (!live) return
+        live = false
+        tokens.delete(token)
+      }
+    },
+    lifecycleFor(managerFace) {
+      if (managerFace == null) return null
+      /** @type {LifecycleFeedToken | null} */
+      let owner = null
+      for (const token of tokens) {
+        let manager
+        try {
+          manager = typeof token.manager === 'function' ? token.manager() : null
+        } catch {
+          // A late, absent, or failing manager is denied on this adjudication.
+          // Do not cache either the failure or a previous successful owner.
+          continue
+        }
+        if (manager !== managerFace) continue
+        if (owner) return null
+        owner = token
+      }
+      return owner?.lifecycle ?? null
+    },
+  }
+}
+
+/** Internal module-local bridge shared by selection and manager rows. */
+export const lifecycleFeedRegistry = createLifecycleFeedRegistry()

package/src/capabilities/mcp-drain.js

@@ -130,5 +130,11 @@ export function createSessionDrainAdapter(resolveDrain) {
         abort: () => { for (const server of removed) drain.reopen(sessionId, server) },
       }
     },
+    /** Reopen only servers restored by an accepted Apply for this session. */
+    reopen(restored, sessionId) {
+      const drain = resolveDrain()
+      if (!drain) return
+      for (const server of restored) drain.reopen(sessionId, server)
+    },
   }
 }

package/src/capabilities/mcp-facade-plugin.js

@@ -14,13 +14,23 @@ import { createMcpFacade } from './mcp-facade.js'
  */
 const bridge = new Map()
 
-export function registerMcpFacadeBridge(groupId, payload) {
-  bridge.set(groupId, payload)
-  return () => bridge.delete(groupId)
+export function registerMcpFacadeBridge(groupId, payload, owner = payload) {
+  if (bridge.has(groupId)) {
+    throw Object.assign(new Error(`MCP facade group ${groupId} already has an owner`), { code: 'duplicate-mcp-facade-owner' })
+  }
+  const record = { payload, owner }
+  bridge.set(groupId, record)
+  return () => {
+    // A stale/repeated disposer compares the exact registration and owner. It
+    // can never delete a later registration that reused the confirmed-free ID.
+    if (bridge.get(groupId) !== record || record.owner !== owner) return false
+    bridge.delete(groupId)
+    return true
+  }
 }
 
 export function mcpFacadeBridgeFor(groupId) {
-  return bridge.get(groupId) ?? null
+  return bridge.get(groupId)?.payload ?? null
 }
 
 export const name = 'weir-mcp-facade'

package/src/capabilities/mcp-facade.js

@@ -53,7 +53,7 @@ export function createMcpFacade({ host, identity, generation, admit, isEnabledFo
       const disposeHost = typeof registration === 'function' ? registration : () => {}
       let rollbackRegistration = null
       try {
-        onRegister?.(name, rollback => { rollbackRegistration = rollback })
+        onRegister?.(name, rollback => { rollbackRegistration = rollback }, wrapped)
       } catch (cause) {
         // Host-first rollback is fail-closed: owner facts and partial denies
         // stay in place unless Host removal is confirmed.

package/src/capabilities/mcp-inventory.js

@@ -0,0 +1,152 @@
+// The one read-only MCP Inventory Projection. Registry/runtime/mount/receipt and
+// Loader facts are joined here; probing, mutation, credential resolution, agent
+// visibility and every other operation remain with their existing owners.
+// Pure dependencies keep this module independently testable and typechecked.
+import { resolveMcpGroupIdentity } from './mcp-mount-ownership.js'
+
+/**
+ * Classify Loader rows once and retain the facts needed by both public views.
+ * Every actual group remains a separate fact; same-identity groups never
+ * overwrite each other in an identity-keyed Map.
+ *
+ * @param {any[]} rows
+ * @param {Map<string, any>} mounted
+ * @param {Record<string, any>} registryServers
+ * @param {{ isResidue: (id: string) => boolean, groupPrefix: string, ownership?: any }} options
+ */
+function joinLoaderRows(rows, mounted, registryServers, { isResidue, groupPrefix, ownership = null }) {
+  const managed = []
+  const unmanaged = []
+  for (const row of rows) {
+    if (typeof row?.id === 'string' && isResidue(row.id)) {
+      const resolved = resolveMcpGroupIdentity({ groupId: row.id, mounted, ownership, row })
+      // Unresolved generated suffixes are conservative residue, not evidence
+      // from which a logical registry identity or mount health may be invented.
+      if (!resolved) continue
+      managed.push({
+        identity: resolved.identity,
+        groupId: row.id,
+        registry: registryServers[resolved.identity],
+        isMounted: resolved.mount != null,
+        mount: resolved.mount,
+        source: resolved.source,
+        allocation: resolved.allocation,
+      })
+    } else if (row?.name === '@deepseek-ai/dsh-mcp-client' && !(typeof row.id === 'string' && row.id.startsWith(groupPrefix))) {
+      unmanaged.push({ serverName: row.config?.serverName ?? row.id ?? 'unknown', state: 'unmanaged', readOnly: true })
+    }
+  }
+  return { managed, unmanaged }
+}
+
+/**
+ * Internal implementation behind mcp-manager.js's exported partitionMcpRows.
+ * Its field selection is the historical compatibility contract; production
+ * manager.list() uses the same Loader join and the full projection below.
+ *
+ * @param {any[]} rows
+ * @param {Map<string, any>} mounted
+ * @param {Record<string, any>} registryServers
+ * @param {{ isResidue: (id: string) => boolean, groupPrefix: string, ownership?: any }} options
+ */
+export function partitionMcpInventory(rows, mounted, registryServers, options) {
+  const joined = joinLoaderRows(rows, mounted, registryServers, options)
+  return {
+    managed: joined.managed.map(fact => ({
+      identity: fact.identity,
+      groupId: fact.groupId,
+      label: fact.registry?.label ?? fact.identity,
+      generation: fact.mount?.generation ?? fact.registry?.generation ?? null,
+      state: fact.isMounted ? 'mounted' : 'registered',
+    })),
+    unmanaged: joined.unmanaged,
+  }
+}
+
+/**
+ * @param {{
+ *   registry: { read: () => Promise<any> },
+ *   runtime: { snapshot: (identity: string) => any },
+ *   mounted: Map<string, any>,
+ *   receipts: { mount: Map<string, any>, test: Map<string, any> },
+ *   listRows: () => any[],
+ *   startErrors: Array<{ identity: string | null, reason: string }>,
+ *   discoveryFor: (identity: string, generation: any) => any,
+ *   support: () => any,
+ *   isResidue: (id: string) => boolean,
+ *   groupPrefix: string,
+ *   ownership?: any,
+ *   holdsReservation: (rows: any[], serverName: any) => any,
+ *   redactEntry: (entry: any) => any,
+ *   fingerprintEntry: (entry: any) => string,
+ * }} dependencies
+ */
+export function createMcpInventoryProjection(dependencies) {
+  const {
+    registry, runtime, mounted, receipts, listRows, startErrors,
+    discoveryFor, support, isResidue, groupPrefix, ownership = null, holdsReservation,
+    redactEntry, fingerprintEntry,
+  } = dependencies
+
+  async function list() {
+    const current = await registry.read()
+    const rows = listRows()
+    const registryServers = current.kind === 'ok' ? current.servers : {}
+    const loader = joinLoaderRows(rows, mounted, registryServers, { isResidue, groupPrefix, ownership })
+    if (current.kind === 'absent') {
+      return { managed: [], unmanaged: loader.unmanaged, warnings: [], registryRevision: 0, capabilities: support() }
+    }
+    if (current.kind !== 'ok') {
+      return { managed: [], unmanaged: loader.unmanaged, unavailable: { status: current.kind }, registryRevision: current.revision ?? 0, capabilities: support() }
+    }
+
+    // Registry authority starts the full view. Join every actual Loader group,
+    // then select only this manager's exact own mount as mounted evidence.
+    const loaderByIdentity = new Map()
+    for (const fact of loader.managed) {
+      const facts = loaderByIdentity.get(fact.identity) ?? []
+      facts.push(fact)
+      loaderByIdentity.set(fact.identity, facts)
+    }
+    const defaults = new Set(current.enabled)
+    const managed = Object.values(current.servers).map(entry => {
+      const phase = runtime.snapshot(entry.identity)
+      const facts = loaderByIdentity.get(entry.identity) ?? []
+      const ownMount = mounted.get(entry.identity) ?? null
+      const ownLoaderFact = ownMount ? facts.find(fact => fact.groupId === ownMount.groupId) : null
+      // Some supported bare/test compositions expose no Loader listing. Keep
+      // their existing mount readback, but never let a different actual group
+      // satisfy this manager's strict mount evidence.
+      const mountedRecord = ownMount && (facts.length === 0 || ownLoaderFact) ? ownMount : null
+      const isMounted = phase.phase === 'mounted' && phase.generation === entry.generation && mountedRecord?.generation === entry.generation
+      const holder = holdsReservation(rows, entry.client?.serverName ?? entry.identity)
+      const state = holder ? 'conflict' : isMounted ? 'mounted' : phase.phase === 'saved-degraded' ? 'degraded' : ['cleanup-failed', 'cleanup-unknown'].includes(phase.phase) ? phase.phase : 'registered'
+      const discovery = discoveryFor(entry.identity, entry.generation)
+      return {
+        identity: entry.identity,
+        label: entry.label,
+        serverName: entry.client?.serverName ?? entry.identity,
+        transport: entry.transport?.kind ?? entry.client?.transport ?? 'unknown',
+        incarnation: entry.incarnation ?? null,
+        generation: entry.generation,
+        defaultEnabled: defaults.has(entry.identity),
+        state,
+        statusSource: isMounted ? 'registry-runtime-mount-readback' : holder ? 'serverName-reservation' : 'registry-runtime',
+        runtimePhase: phase.phase,
+        discovery: isMounted ? discovery : { toolCount: null, toolNamesPreview: [], truncated: false },
+        lastMount: receipts.mount.get(entry.identity) ?? null,
+        lastTest: receipts.test.get(entry.identity) ?? null,
+        startErrors: startErrors.filter(error => error.identity === entry.identity).map(error => ({ reason: error.reason })),
+        liveReconnect: 'unknown',
+        processExit: 'unknown',
+        stderr: 'unknown',
+        readOnly: false,
+        config: redactEntry(entry),
+        fingerprint: fingerprintEntry(entry),
+      }
+    })
+    return { managed, unmanaged: loader.unmanaged, warnings: current.warnings, registryRevision: current.revision, capabilities: support() }
+  }
+
+  return { list }
+}