weir-harness 2.1.0 → 2.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weir-harness",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "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/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

@@ -30,9 +30,10 @@ const message = error => (error instanceof Error ? error.message : String(error)
  *   admit: (agent: unknown) => Promise<boolean>,
  *   isEnabledFor: (agent: unknown) => boolean,
  *   drain?: { enter(agentId: string, server: string, label?: string): number|null, exit(agentId: string, server: string, token: number|null): void },
+ *   onRegister?: (name: string, captureRollback: (rollback: () => void) => void) => void, onUnregister?: (name: string) => void,
  *   onError?: (reason: string, cause?: unknown) => void }} config
  */
-export function createMcpFacade({ host, identity, generation, admit, isEnabledFor, drain, onRegister, onError = () => {}, assertPermit }) {
+export function createMcpFacade({ host, identity, generation, admit, isEnabledFor, drain, onRegister, onUnregister, onError = () => {}, assertPermit }) {
   const wrapper = createMcpToolWrapper({ identity, generation, admit, drain, assertPermit })
 
   const unknown = (service, method) => {
@@ -43,14 +44,44 @@ export function createMcpFacade({ host, identity, generation, admit, isEnabledFo
 
   const tools = {
     register(definition) {
-      // Bind the public name to this configured identity at registration
-      // time, then wrap the definition with the last-moment admission check.
+      // Host registration happens first, then the generation-owned fact and
+      // every live agent converge in this same synchronous segment.
       const wrapped = wrapper.wrap(definition)
       const registration = /** @type {{ register(d: unknown): unknown }} */ (host.tools).register(wrapped)
-      // Report the binding back to the manager (creation-time schema hiding
-      // and the managed listing read this map).
-      if (typeof wrapped?.name === 'string') onRegister?.(wrapped.name)
-      return registration
+      if (typeof wrapped?.name !== 'string') return registration
+      const name = wrapped.name
+      const disposeHost = typeof registration === 'function' ? registration : () => {}
+      let rollbackRegistration = null
+      try {
+        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.
+        try { disposeHost() } catch (rollbackError) {
+          onError('facade-host-registration-rollback-failed', rollbackError)
+          throw cause
+        }
+        try {
+          if (typeof rollbackRegistration === 'function') rollbackRegistration()
+          else onUnregister?.(name) // legacy registration callbacks
+        } catch (rollbackError) {
+          onError('facade-owner-registration-rollback-failed', rollbackError)
+        }
+        throw cause
+      }
+      let hostRemoved = false
+      let completed = false
+      return () => {
+        if (completed) return
+        if (!hostRemoved) {
+          // Host-first is fail-closed: if removal throws, the manager fact and
+          // deny stay in place. A later retry does not double-dispose the Host.
+          disposeHost()
+          hostRemoved = true
+        }
+        onUnregister?.(name)
+        completed = true
+      }
     },
     get(...args) { return /** @type {{ get(...a: unknown[]): unknown }} */ (host.tools).get(...args) },
     list(...args) { return /** @type {{ list(...a: unknown[]): unknown }} */ (host.tools).list(...args) },

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 }
+}