weir-harness 1.1.7 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weir-harness",
-  "version": "1.1.7",
+  "version": "1.2.0",
   "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/edit-lock/domains.js

@@ -97,6 +97,73 @@ export function createDomainRegistry(open, resolveRoot = managementRootFor) {
   })
 }
 
+/** @type {WeakMap<object, Map<string, {registry: any, settled: WeakMap<object, any>, recoveryNotices: Map<string, string>, mounts: number}>>} */
+const sharedRegistriesByHost = new WeakMap()
+
+/** Process-shared domain registry container (change
+ * edit-lock-shared-domain-mounts, design D1): several preset mounts of this
+ * bundle coexist for the whole process, and every mount of one management
+ * root must resolve the SAME domain — one runtime, one publisher reservation,
+ * one lifecycle and one endpoint — instead of the second mount degrading to a
+ * same-process remote client of the first.
+ *
+ * The container is keyed by host (`ctx.root ?? ctx`, the same key expression
+ * the write-scope store uses — proven to be shared across preset mounts) plus
+ * a caller-supplied configuration discriminator: mounts whose effective
+ * domain configuration differs (a fixed root/authority row) NEVER share; they
+ * keep today's independent-registry semantics exactly.
+ *
+ * Reference-counted by mount: each apply takes one count, each disposer
+ * releases exactly one (idempotently); a factory that throws enters no count.
+ * Only the LAST release closes every domain through the established drain
+ * discipline (`registry.all() → domain.close()`), revoking sessions and
+ * releasing reservations; the entry is then dropped, so a later generation
+ * reopens fresh. The per-entry `settled` store and the per-root
+ * automatic-recovery notice queue share the entry's lifetime: they outlive
+ * any single mount (a preset switch lets a sibling mount's listeners read
+ * the binding the first mount settled, and the mount that hears the first
+ * post-recovery turn drains the summary), and they die with the last
+ * release so a closed domain is never mistaken for a live binding.
+ *
+ * @template T
+ * @param {object} host
+ * @param {string} discriminator
+ * @param {() => ReturnType<typeof createDomainRegistry<T>>} makeRegistry
+ * @returns {{registry: ReturnType<typeof createDomainRegistry<T>>, settled: WeakMap<object, T>, recoveryNotices: Map<string, string>, release: () => Promise<void>}} */
+export function sharedDomainRegistryFor(host, discriminator, makeRegistry) {
+  let entries = sharedRegistriesByHost.get(host)
+  if (!entries?.has(discriminator)) {
+    // A throwing factory mutates nothing and enters no count.
+    const created = makeRegistry()
+    if (!entries) {
+      entries = new Map()
+      sharedRegistriesByHost.set(host, entries)
+    }
+    entries.set(discriminator, { registry: created, settled: new WeakMap(), recoveryNotices: new Map(), mounts: 0 })
+  }
+  const entry = /** @type {{registry: any, settled: WeakMap<object, any>, recoveryNotices: Map<string, string>, mounts: number}} */ (entries.get(discriminator))
+  entry.mounts += 1
+  let released = false
+  return Object.freeze({
+    registry: entry.registry,
+    settled: entry.settled,
+    /** One queued automatic-recovery summary per root, shared so the mount
+     * that hears the first post-recovery turn drains it (design D3). */
+    recoveryNotices: entry.recoveryNotices,
+    /** Idempotent: only the first call counts; only the last call closes. */
+    async release() {
+      if (released) return
+      released = true
+      entry.mounts -= 1
+      if (entry.mounts > 0 || entries.get(discriminator) !== entry) return
+      entries.delete(discriminator)
+      const results = await Promise.allSettled(entry.registry.all().map(async domain => (await domain).close()))
+      const failure = results.find(result => result.status === 'rejected')
+      if (failure?.status === 'rejected') throw failure.reason
+    },
+  })
+}
+
 /** @param {string} path */
 export function isDirectory(path) {
   try { return lstatSync(path).isDirectory() } catch { return false }

package/src/edit-lock/index.js

@@ -26,7 +26,7 @@ import { createStaleSweepScheduler } from './stale-sweep.js'
 import { createRemoteEditLockDomain, endpointFor, serveEditLockEndpoint } from './remote.js'
 import { registerBindingRuntime, createBindingAttester } from './binding-attestation.js'
 import { localDomain, remoteDomain } from './domain.js'
-import { AUTHORITY_DIR, createDomainRegistry, excludeFromGit, managementRootFor } from './domains.js'
+import { AUTHORITY_DIR, createDomainRegistry, excludeFromGit, managementRootFor, sharedDomainRegistryFor } from './domains.js'
 import { createRecoveryDriver } from './recovery.js'
 import { createSettlementDriver } from './settle.js'
 import { editLockLimits } from '../settings/sections.js'
@@ -41,6 +41,29 @@ const inject = ['tools', 'fs', 'agents']
 /** Tool names whose definitions must be Edit Lock routed when enabled. */
 export const GUARDED_TOOLS = Object.freeze(['write', 'edit', 'hash_edit', 'lsp_rename', 'str_replace_editor'])
 
+/** Claimed managed-editor executions, shared by every mount of this bundle in
+ * the process (change edit-lock-shared-domain-mounts, design D3): membership
+ * is execute-object identity, so cross-host admission is impossible and an
+ * execution claimed by a disposed mount is harmless — no live guard reads it.
+ * Whichever mount's guard stage hears an execution, the verdict is the same.
+ * @type {WeakSet<Function>} */
+const managed = new WeakSet()
+
+/** Host-lifetime live weirEditLock services (design D3): every mount registers
+ * its service at apply and unregisters at dispose, so the endpoint currency
+ * proof can accept any live sibling mount's service identity.
+ * @type {WeakMap<object, Set<object>>} */
+const liveServicesByHost = new WeakMap()
+/** @param {object} host @returns {Set<object>} */
+function liveServicesFor(host) {
+  let services = liveServicesByHost.get(host)
+  if (!services) {
+    services = new Set()
+    liveServicesByHost.set(host, services)
+  }
+  return services
+}
+
 /** Row config wins over the settings section; `root` + `authorityDirectory`
  * pin one fixed domain (development compositions and probes).
  * @param {unknown} config @param {unknown} [settings] */
@@ -370,6 +393,10 @@ return (ctx, config = {}) => {
     evidence?.failed(platformFailure)
     ctx.logger?.warn?.(platformFailure.message)
   }
+  /** The shared-registry handle, assigned inside the mount try so a failed
+   * apply can release its count (design D1: a failed mount enters no count).
+   * @type {any} */
+  let shared = null
   try {
   /** @type {any} */
   let sandboxPolicyRef = null
@@ -377,6 +404,11 @@ return (ctx, config = {}) => {
   // Capture the original host filesystem once; the manager is its only writer.
   const fs = ctx.fs
   const audit = createAudit(ctx)
+  // The host-lifetime key shared by the write-scope store, the domain registry
+  // container and the live-service set (design D1/D3) — identical to the key
+  // expression the settings evidence store uses.
+  const host = ctx.root ?? ctx
+  const liveServices = liveServicesFor(host)
   /** Successful undefined means no live runtime; missing service means unknown.
    * @param {string} sessionId */
   const servingRuntime = sessionId => {
@@ -396,12 +428,12 @@ return (ctx, config = {}) => {
   const disposedAgents = new WeakSet()
   /** One queued automatic-recovery summary notice per management root (design
    * D3): delivered to the first agent that finishes domain start, then gone.
-   * @type {Map<string, string>} */
-  const recoveryNotices = new Map()
-  // The tool registry may hand back a normalized copy of a definition; the
-  // claimed execute function is what actually runs, so it is the identity.
-  /** @type {WeakSet<Function>} */
-  const managed = new WeakSet()
+   * Shared across sibling mounts with the domain registry (change
+   * edit-lock-shared-domain-mounts): the domain opens through the first
+   * mount's closure, so the queue must live in the shared entry for the
+   * mount that hears the first post-recovery turn to drain it. Assigned
+   * with `shared` below. @type {Map<string, string>} */
+  let recoveryNotices
   /** Managed write registrations outlive this mount: the tool is installed
    * into the agent's OWN scope layer, which a preset rebind never disposes.
    * Their disposers live in a host-lifetime store so any later generation can
@@ -410,7 +442,7 @@ return (ctx, config = {}) => {
    * tearing the managed write down mid-gap would expose the stock writers
    * until the next mount's per-agent re-install.
    * @type {WeakMap<object, import('./write-scopes.js').WriteScopeEntry>} */
-  const writeScopes = writeScopesFor(ctx.root ?? ctx)
+  const writeScopes = writeScopesFor(host)
   let closed = false
   /** Remote channel agents on the publisher side → their notice sink.
    * @type {WeakMap<object, (event: unknown) => void>} */
@@ -419,8 +451,11 @@ return (ctx, config = {}) => {
   const startFailures = new WeakMap()
   /** Publisher-classified failures, never inferred from text. @type {WeakMap<object, any>} */
   const bindingFailures = new WeakMap()
-  /** Settled domain per bound agent, for synchronous gates. @type {WeakMap<object, any>} */
-  const settled = new WeakMap()
+  /** Settled domain per bound agent, for synchronous gates. Shared across
+   * sibling mounts with the domain registry (design D3): whichever mount
+   * hears an event reads the same binding. Assigned with `shared` below.
+   * @type {WeakMap<object, any>} */
+  let settled
   /** In-flight setup per agent, shared by every entry point (creation,
    * preset-switch, catch-up, lazy re-bind) so concurrent callers can never
    * double-register. @type {WeakMap<object, Promise<void>>} */
@@ -524,8 +559,11 @@ return (ctx, config = {}) => {
           } else if (requireProof) return false
           // Fresh creation keeps the established missing/throwing-registry
           // fallback. A reclaim or retry never uses that fallback as proof.
+          // Currency proof (design D3): the agent's resolved service must be a
+          // LIVE service of this process — after a preset switch that is the
+          // sibling mount's service, never this mount's own necessarily.
           if (typeof presets?.serviceFor === 'function') {
-            try { return presets.serviceFor(agent, 'weirEditLock') === service }
+            try { return liveServices.has(presets.serviceFor(agent, 'weirEditLock')) }
             catch { return !requireProof }
           }
           return true
@@ -541,12 +579,21 @@ return (ctx, config = {}) => {
       throw error
     }
   }
-  const registry = createDomainRegistry(root => {
+  // One domain registry per host + effective domain configuration, shared by
+  // every same-process preset mount of this bundle (design D1): a sibling
+  // mount never degrades to a same-process remote client, and the LAST
+  // disposer closes all domains through the established drain discipline. The
+  // first mount's `open` closure serves every sharing mount — mounts are
+  // process-persistent, so the capture is safe (design D1 trade-off).
+  shared = sharedDomainRegistryFor(host, options.fixed ? `${options.fixed.root}\n${options.fixed.directory}` : '', () => createDomainRegistry(root => {
     const fixed = options.fixed
     if (fixed) return openDomain(fixed.root, fixed.directory, root)
     try { exclude(root) } catch (error) { ctx.logger?.warn?.(`edit lock: could not update .git/info/exclude: ${/** @type {any} */ (error)?.message ?? error}`) }
     return openDomain(root, join(root, AUTHORITY_DIR), root)
-  }, resolveRoot)
+  }, resolveRoot))
+  const registry = shared.registry
+  settled = shared.settled
+  recoveryNotices = shared.recoveryNotices
   /** @param {any} agent */
   const domainOf = agent => registry.forAgent(agent)
   /** Lazy re-bind (design D2): an own-preset main agent with no binding —
@@ -734,6 +781,9 @@ return (ctx, config = {}) => {
     },
   })
   ctx.reflect.provide('weirEditLock', service)
+  // Any live sibling mount's service identity attests endpoint currency
+  // (design D3); unregister at dispose.
+  liveServices.add(service)
 
   const offTools = registerLockTools(ctx, service)
 
@@ -1394,6 +1444,7 @@ return (ctx, config = {}) => {
   return async () => {
     if (closed) return
     closed = true
+    liveServices.delete(service)
     offDelegateLifecycle()
     evidence?.disposing()
     try {
@@ -1405,10 +1456,9 @@ return (ctx, config = {}) => {
       offView()
       offCommand?.()
       for (const off of offTools) off?.()
-      // Retain uncertain evidence until every generation-owned domain is drained.
-      const results = await Promise.allSettled(registry.all().map(async domain => (await domain).close()))
-      const failure = results.find(result => result.status === 'rejected')
-      if (failure?.status === 'rejected') throw failure.reason
+      // Retain uncertain evidence until every generation-owned domain is
+      // drained; only the LAST sharing disposer closes them (design D1).
+      await shared.release()
       evidence?.dispose()
     } catch (error) {
       evidence?.failed(error)
@@ -1417,6 +1467,10 @@ return (ctx, config = {}) => {
   }
   } catch (error) {
     evidence?.failed(error)
+    // A mount that failed mid-apply must not stay counted in the shared
+    // registry (design D1); domains are lazy, so this release closes nothing
+    // unless a sibling mount already opened one — its count keeps it alive.
+    if (shared) void shared.release().catch(() => {})
     throw error
   }
 }

package/src/edit-lock/lifecycle.js

@@ -195,11 +195,25 @@ export function createEditLockLifecycle(runtime, sessionForAgent, options = {})
   }
   /** Register once before publishing an agent's editing tools. A session the
    * manager already knows (restart, re-created agent) is never re-armed: it
-   * starts interrupted and needs trusted resume. @param {object} agent
+   * starts interrupted and needs trusted resume. Presenting the SAME agent
+   * object again adopts the established entry instead of registering twice
+   * (change edit-lock-shared-domain-mounts, design D2). @param {object} agent
    * @returns {Promise<'active'|'interrupted'>} */
   function start(agent) {
     if (closed) return Promise.reject(new Error('edit lifecycle closed'))
-    if (entries.has(agent)) return Promise.reject(new Error('agent already registered'))
+    const existing = entries.get(agent)
+    if (existing) {
+      // Same-agent binding adoption: a sibling mount's idempotent re-setup
+      // presents the same agent object and takes the established start result
+      // verbatim — no openSession, no revocation, no epoch advance, no state
+      // change. A stopped/revoked entry keeps its state: adoption returns its
+      // established result, and business ingress stays gated by
+      // denyStopped/business until a trusted resume. Identity continuity is
+      // required — a host that reused the agent object for a different
+      // session keeps the duplicate-registration refusal.
+      if (sessionForAgent(agent) === existing.sessionId) return existing.ready
+      return Promise.reject(new Error('agent already registered'))
+    }
     const sessionId = sessionForAgent(agent)
     if (!sessionId) return Promise.reject(new Error('unregistered lifecycle agent'))
     const prior = [...entries].find(([, entry]) => entry.sessionId === sessionId)