weir-harness 1.2.2 → 2.0.0

package/src/edit-lock/domains.js

@@ -1,170 +0,0 @@
-import { execFileSync } from 'node:child_process'
-import { appendFileSync, existsSync, lstatSync, mkdirSync, readFileSync, realpathSync } from 'node:fs'
-import { dirname, isAbsolute, join, resolve, relative, sep } from 'node:path'
-
-/** Authority location inside a management root. */
-export const AUTHORITY_DIR = join('.weir', 'edit-lock')
-const EXCLUDE_LINES = ['/.weir/edit-lock/', '/.weir/.edit-lock.publisher-reservation/']
-
-/** @param {string} cwd @param {string[]} args @returns {string | undefined} */
-function git(cwd, args) {
-  try {
-    return execFileSync('git', args, { cwd, encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'] }).trim() || undefined
-  } catch { return undefined }
-}
-
-/** Management root for a session working directory: the git top level when
- * inside a repository, else the directory itself; an enclosing directory that
- * already hosts an Edit Lock authority wins so nested sessions share one domain.
- * Optional discovery ceiling and Git adapter are for isolated embeddings;
- * omitted dependencies retain the normal ancestor-authority discovery.
- * @param {string} cwd
- * @param {{ ceiling?: string, runGit?: typeof git }} [dependencies] */
-export function managementRootFor(cwd, { ceiling, runGit = git } = {}) {
-  if (typeof cwd !== 'string' || !isAbsolute(cwd)) throw new Error('edit lock: absolute session cwd required')
-  const start = realpathSync.native(cwd)
-  const limit = ceiling === undefined ? undefined : realpathSync.native(ceiling)
-  const within = path => { const rel = relative(limit ?? path, path); return rel === '' || (!isAbsolute(rel) && rel !== '..' && !rel.startsWith(`..${sep}`)) }
-  if (!within(start)) throw new Error('edit lock: cwd outside discovery ceiling')
-  const top = runGit(start, ['rev-parse', '--show-toplevel'])
-  let root = top ? realpathSync.native(top) : start
-  if (!within(root)) throw new Error('edit lock: git root outside discovery ceiling')
-  for (let candidate = dirname(root); candidate !== dirname(candidate); candidate = dirname(candidate)) {
-    if (root === limit || !within(candidate)) break
-    if (existsSync(join(candidate, AUTHORITY_DIR))) { root = candidate; break }
-  }
-  return root
-}
-
-/** Keep authority state out of version control without touching tracked files:
- * append to the repository's own info/exclude (worktree aware). Best effort.
- * @param {string} root
- * @param {typeof git} [runGit] */
-export function excludeFromGit(root, runGit = git) {
-  const relativePath = runGit(root, ['rev-parse', '--git-path', 'info/exclude'])
-  if (!relativePath) return false
-  const file = resolve(root, relativePath)
-  mkdirSync(dirname(file), { recursive: true })
-  const current = existsSync(file) ? readFileSync(file, 'utf8') : ''
-  const lines = new Set(current.split('\n').map(line => line.trim()))
-  const missing = EXCLUDE_LINES.filter(line => !lines.has(line))
-  if (missing.length === 0) return true
-  appendFileSync(file, `${current && !current.endsWith('\n') ? '\n' : ''}# Weir Edit Lock authority state\n${missing.join('\n')}\n`)
-  return true
-}
-
-/** Per-root lazy domain registry; a failed open is retried on next demand.
- * @template T
- * @param {(root: string) => Promise<T>} open
- * @param {(cwd: string) => string} [resolveRoot] */
-export function createDomainRegistry(open, resolveRoot = managementRootFor) {
-  /** @type {Map<string, Promise<T>>} */
-  const domains = new Map()
-  /** @type {WeakMap<object, string>} */
-  const roots = new WeakMap()
-  return Object.freeze({
-    /** Bind once at agent creation; the session cwd never re-binds later.
-     * @param {object} agent @param {string} cwd */
-    bind(agent, cwd) {
-      const root = resolveRoot(cwd)
-      roots.set(agent, root)
-      return root
-    },
-    /** @param {object} agent */
-    rootOf(agent) { return roots.get(agent) },
-    /** @param {object} agent @returns {Promise<T>} */
-    forAgent(agent) {
-      const root = roots.get(agent)
-      if (!root) return Promise.reject(new Error('agent has no Edit Lock domain'))
-      return this.forRoot(root)
-    },
-    /** @param {string} root @returns {Promise<T>} */
-    forRoot(root) {
-      let domain = domains.get(root)
-      if (!domain) {
-        domain = open(root)
-        domains.set(root, domain)
-        domain.catch(() => { if (domains.get(root) === domain) domains.delete(root) })
-      }
-      return domain
-    },
-    /** Membership only, never an open: the settings-plane online recovery
-     * endpoint accepts only roots this registry already serves.
-     * @param {string} root */
-    known(root) { return domains.has(root) },
-    /** @returns {Promise<T>[]} */
-    all() { return [...domains.values()] },
-  })
-}
-
-/** @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/host.js

@@ -1,149 +0,0 @@
-import { createEditLockAdapter } from './adapter.js'
-import { randomUUID } from 'node:crypto'
-import { canonicalRequestData } from './request-data.js'
-
-/** Trusted host binding. Registration is an explicit lifecycle action, never a
- * tool argument or inference from a user-message source tag. Not auto-mounted.
- * @param {Awaited<ReturnType<typeof import('./runtime.js').openEditLockRuntime>>} runtime
- * @param {(agent: object) => boolean} isRegisteredAgent */
-export function createEditLockHost(runtime, isRegisteredAgent) {
-  // Provider tool-call ids are not unique across turns (some reuse call_0):
-  // one operation identity per actual execution object, stable within it.
-  /** @type {WeakMap<object, string>} */
-  const operationIds = new WeakMap()
-  /** @param {{callId: string}} exec */
-  function operationIdFor(exec) {
-    let id = operationIds.get(exec)
-    if (!id) { id = `${exec.callId}@${randomUUID()}`; operationIds.set(exec, id) }
-    return id
-  }
-  const adapter = createEditLockAdapter(runtime)
-  /** @type {WeakMap<object, import('./state.js').Execution>} */
-  const executions = new WeakMap()
-  const activeBatches = new Set()
-  let closed = false
-  function live() { if (closed) throw new Error('edit lock host closed') }
-  return Object.freeze({
-    /** Called by the authenticated host lifecycle after durable registration or resume.
-     * @param {object} agent @param {import('./state.js').Execution} execution */
-    attach(agent, execution) {
-      live()
-      if (!isRegisteredAgent(agent)) throw new Error('unregistered host agent')
-      executions.set(agent, Object.freeze({ ...execution }))
-    },
-    /** Revoke admission before waiting for durable cancellation.
-     * @param {object} agent */
-    detach(agent) {
-      live()
-      const execution = executions.get(agent)
-      executions.delete(agent)
-      if (!execution) throw new Error('agent has no edit execution')
-      return runtime.control.cancelSession(execution.sessionId)
-    },
-    /** Trusted lifecycle lookup of the current admitted execution only.
-     * @param {object} agent */
-    executionFor(agent) {
-      live()
-      const execution = executions.get(agent)
-      if (!execution || !isRegisteredAgent(agent)) throw new Error('agent has no authenticated edit execution')
-      return execution
-    },
-    /** Tool implementation ingress AFTER effective policy resolution.
-     * @param {{agent: object, signal: AbortSignal, callId: string}} exec
-     * @param {Parameters<typeof adapter.publish>[1] & {cwd: string, effectivePolicy: unknown}} request */
-    async publish(exec, request) {
-      live()
-      const execution = executions.get(exec.agent)
-      if (!execution || !isRegisteredAgent(exec.agent)) throw new Error('agent has no authenticated edit execution')
-      const call = adapter.bind(execution, { cwd: request.cwd, effectivePolicy: request.effectivePolicy,
-        callId: operationIdFor(exec), signal: exec.signal })
-      const operation = await adapter.publish(call, request)
-      return operation.outcome
-    },
-    /** Existing-file batch only. Failed batches retain every temporary lock.
-     * @param {{agent: object, signal: AbortSignal, callId: string}} exec
-     * @param {{cwd: string, effectivePolicy: any, args: unknown, plans: Array<{filePath: string, content: string, version: string}>}} request */
-    async publishBatch(exec, request) {
-      live()
-      request = JSON.parse(canonicalRequestData(request))
-      if (typeof exec.callId !== 'string' || !exec.callId.trim()) throw new Error('call id required')
-      const execution = executions.get(exec.agent)
-      if (!execution || !isRegisteredAgent(exec.agent)) throw new Error('agent has no authenticated edit execution')
-      if (exec.signal.aborted) throw new Error('call aborted')
-      if (!['workspace-write', 'danger-full-access'].includes(request.effectivePolicy?.mode)) throw new Error('writable effective policy required')
-      const operation = operationIdFor(exec)
-      const ids = request.plans.map((_, index) => JSON.stringify(['lsp_rename', operation, index]))
-      // Never restart a partially applied batch by reacquiring released ownership.
-      for (const id of ids) if (runtime.control.history(execution.sessionId, id)) throw new Error('rename batch has history; inspect retained outcomes before retry')
-      const batchKey = JSON.stringify([execution.sessionId, exec.callId])
-      if (activeBatches.has(batchKey)) throw new Error('rename batch already in progress')
-      activeBatches.add(batchKey)
-      const abort = () => { try { void runtime.control.cancel(execution).catch(() => {}) } catch {} }
-      exec.signal.addEventListener('abort', abort, {once: true})
-      const written = []
-      let index = 0
-      try {
-        const ownership = await runtime.requests.acquireBatch(execution, request.plans.map(plan => plan.filePath), request.cwd)
-        for (const plan of request.plans) {
-          live()
-          const batchOwnership = ownership.ordered[index]
-          if (!batchOwnership) throw new Error('missing batch ownership')
-          const call = adapter.bind(execution, {cwd: request.cwd, effectivePolicy: request.effectivePolicy, callId: ids[index], signal: exec.signal})
-          await adapter.publish(call, {tool: 'lsp_rename', filePath: plan.filePath, content: plan.content,
-            batchOwnership, args: request.args, expected: {kind: 'replaceIfVersion', version: plan.version}})
-          written.push(plan.filePath)
-          index++
-        }
-        if (exec.signal.aborted) throw new Error('call aborted before temporary ownership cleanup')
-        await runtime.control.releaseMany(ownership.temporary)
-        return { written }
-      } catch (error) {
-        /** @type {string[]} */
-        let uncertain = []
-        if (index < request.plans.length) {
-          try {
-            const operation = runtime.control.history(execution.sessionId, ids[index])
-            if (operation && ['publishing', 'unknown', 'created', 'updated'].includes(operation.phase)) uncertain = [request.plans[index].filePath]
-          } catch { uncertain = [request.plans[index].filePath] }
-        }
-        const notWritten = request.plans.slice(index).map(plan => plan.filePath).filter(path => !uncertain.includes(path))
-        throw new Error(`rename stopped: ${String(error)};\nfilesAlreadyWritten: ${JSON.stringify(written)};\nfilesNotWritten: ${JSON.stringify(notWritten)};\nfilesUncertain: ${JSON.stringify(uncertain)};\nownership retained (no rollback)`, {cause: error})
-      } finally {
-        activeBatches.delete(batchKey)
-        exec.signal.removeEventListener('abort', abort)
-      }
-    },
-    /** Ordinary owner tool: acquire one existing file. Activates this
-     * session's own pending-confirmation lock; never steals another owner's.
-     * @param {{agent: object}} exec @param {{filePath: string, cwd: string}} request */
-    async acquire(exec, request) {
-      live()
-      const execution = executions.get(exec.agent)
-      if (!execution || !isRegisteredAgent(exec.agent)) throw new Error('agent has no authenticated edit execution')
-      const resourceId = runtime.requests.resource(request.filePath, request.cwd)
-      const token = await runtime.control.acquire(execution, resourceId)
-      return { resourceId, generation: token.generation }
-    },
-    /** Ordinary owner tool: release one owned lock. Release never asserts
-     * content correctness. @param {{agent: object}} exec @param {{filePath: string, cwd: string}} request */
-    async release(exec, request) {
-      live()
-      const execution = executions.get(exec.agent)
-      if (!execution || !isRegisteredAgent(exec.agent)) throw new Error('agent has no authenticated edit execution')
-      const { resourceId, observation } = runtime.requests.releaseResource(request.filePath, request.cwd)
-      const lock = runtime.control.status().locks.find(/** @param {any} item */ item => item.resourceId === resourceId)
-      if (!lock || lock.owner !== execution.sessionId) throw new Error('lock not owned by this session')
-      await runtime.requests.release({ ...execution, resourceId, generation: lock.generation }, observation)
-      return { resourceId, released: true }
-    },
-    /** Effective lock observation for one admitted agent; grants nothing.
-     * @param {{agent: object}} exec */
-    locks(exec) {
-      live()
-      const execution = executions.get(exec.agent)
-      if (!execution || !isRegisteredAgent(exec.agent)) throw new Error('agent has no authenticated edit execution')
-      return runtime.control.status().locks.map(/** @param {any} lock */ lock => ({ ...lock, mine: lock.owner === execution.sessionId }))
-    },
-    close() { closed = true; return adapter.close() },
-  })
-}

package/src/edit-lock/incarnations.js

@@ -1,150 +0,0 @@
-// Manager incarnation process identity (design D2, openspec
-// edit-lock-autonomous-recovery). The v6 authority image carries a registry of
-// every manager incarnation it references with the process identity of that
-// incarnation ({pid, host, osStart, bootNonce} from the shared Liveness
-// adapter) or null for incarnations that predate the registry. Null
-// identities NEVER participate in automatic settlement.
-
-/**
- * @typedef {{ pid: number, host: string, osStart: string|null, bootNonce: string }} ProcessIdentity
- * @typedef {{ incarnation: string, process: ProcessIdentity|null }} IncarnationEntry
- */
-
-import { canonical } from './snapshot.js'
-
-/** @param {unknown} condition @param {string} message @returns {asserts condition} */
-function valid(condition, message) {
-  if (!condition) throw new Error(`invalid incarnation ${message}`)
-}
-/** @param {unknown} value @returns {value is string} */
-const id = value => typeof value === 'string' && value.length > 0
-/** @param {unknown} value @param {string[]} keys @returns {asserts value is Record<string, unknown>} */
-function shape(value, keys) {
-  valid(value !== null && typeof value === 'object' && !Array.isArray(value), 'object')
-  valid(Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null, 'object prototype')
-  valid(Reflect.ownKeys(value).length === keys.length && keys.every(key => Object.hasOwn(value, key)), 'schema keys')
-}
-
-/** Every incarnation the image references: the current manager incarnation
- * plus every operation origin. @param {any} state @returns {Set<string>} */
-export function referencedIncarnations(state) {
-  /** @type {Set<string>} */
-  const ids = new Set()
-  if (id(state?.managerIncarnation)) ids.add(state.managerIncarnation)
-  for (const operation of state?.operations ?? []) ids.add(operation.origin.managerIncarnation)
-  return ids
-}
-
-/** The lossless seed for an image that predates the registry: one null-identity
- * entry per referenced incarnation. @param {any} state @returns {IncarnationEntry[]} */
-export function seedIncarnations(state) {
-  return [...referencedIncarnations(state)].map(incarnation => ({ incarnation, process: null }))
-}
-
-/**
- * The exact registry a transition to (or within) v6 must carry: every entry of
- * the previous registry (or the lossless null seed for a pre-v6 image)
- * identically, plus at most one new entry — for the CURRENT manager
- * incarnation — which is taken from `after` and so may carry the process
- * identity of the manager that is committing. Any other registry (reordered,
- * rewritten, backfilled identities, extra entries) is rejected.
- * @param {any} before @param {any} after @returns {IncarnationEntry[]}
- */
-export function expectedRegistry(before, after) {
-  const seeded = before.version === 6 ? before.incarnations : seedIncarnations(before)
-  const known = new Set(seeded.map(/** @param {IncarnationEntry} entry */ entry => entry.incarnation))
-  /** @type {IncarnationEntry[]} */
-  const registry = [...seeded]
-  if (id(after.managerIncarnation) && !known.has(after.managerIncarnation)) {
-    const entry = (after.incarnations ?? []).find(/** @param {IncarnationEntry} candidate */ candidate => candidate.incarnation === after.managerIncarnation)
-    if (entry) registry.push(entry)
-  }
-  return registry
-}
-
-/**
- * The only version transition an ordinary (non-administrative) record may
- * perform: the v6 registry upgrade. The image gains the exact expected
- * registry and an admin ledger (empty when the pre-v6 image had none);
- * everything else is covered by the ordinary transition validators.
- * @param {any} before @param {any} after @returns {boolean}
- */
-export function isRegistryUpgrade(before, after) {
-  if (!(after?.version === 6 && (before?.version === 4 || before?.version === 5))) return false
-  // The committing incarnation must be covered: a registry that drops it is
-  // never the upgrade (coverage is also enforced by validateIncarnations).
-  if (id(after.managerIncarnation) && !(after.incarnations ?? []).some(entry => entry.incarnation === after.managerIncarnation)) return false
-  return canonical(after.incarnations) === canonical(expectedRegistry(before, after)) &&
-    canonical(after.adminRecoveries ?? []) === canonical(before.adminRecoveries ?? [])
-}
-
-/**
- * Register the committing manager's incarnation in the durable image. No-op
- * when no process identity is supplied (the registry exists only for images
- * written by identity-aware managers) or when the incarnation is already
- * registered (entries are immutable). Otherwise upgrades the image to v6:
- * null seeds for every pre-existing incarnation (including the previous
- * manager incarnation, which the new state no longer references) plus one
- * entry carrying this process identity.
- * @param {any} state @param {string} incarnation @param {ProcessIdentity|null} process
- * @param {string|null} [previousIncarnation] @returns {any}
- */
-export function withIncarnation(state, incarnation, process, previousIncarnation = null) {
-  if (!process) return state
-  if ((state.incarnations ?? []).some(/** @param {IncarnationEntry} entry */ entry => entry.incarnation === incarnation)) return state
-  // Pre-v6 migration seed, byte-identical to the one the transition validator
-  // derives from the UNCHANGED pre-image (expectedRegistry →
-  // seedIncarnations): the pre-image's current manager incarnation FIRST,
-  // then every operation origin in encounter order. The candidate already
-  // carries the NEW manager incarnation (recovery replaced it), so the
-  // pre-image manager is the explicitly supplied previous incarnation; the
-  // committing incarnation itself is never seeded — it is appended below with
-  // its process identity.
-  /** @type {IncarnationEntry[]} */
-  const seeded = []
-  const known = new Set()
-  /** @param {unknown} value */
-  const seedNull = value => {
-    if (id(value) && value !== incarnation && !known.has(value)) {
-      known.add(value)
-      seeded.push({ incarnation: value, process: null })
-    }
-  }
-  if (state.version !== 6) {
-    seedNull(id(previousIncarnation) ? previousIncarnation : state.managerIncarnation)
-    for (const operation of state.operations ?? []) seedNull(operation.origin.managerIncarnation)
-  }
-  const base = state.version === 6 ? state.incarnations : seeded
-  return { ...state, version: 6, adminRecoveries: state.adminRecoveries ?? [], incarnations: [...base, { incarnation, process }] }
-}
-
-/** The recorded process identity of one incarnation, or null (no identity or
- * no entry): null is never eligible for automatic settlement.
- * @param {any} state @param {string} incarnation @returns {ProcessIdentity|null} */
-export function incarnationProcess(state, incarnation) {
-  const entry = (state.incarnations ?? []).find(/** @param {IncarnationEntry} candidate */ candidate => candidate.incarnation === incarnation)
-  return entry?.process ?? null
-}
-
-/**
- * The durable registry invariant for a v6 image: exact entry shapes, unique
- * incarnations, valid process identities, and coverage of every incarnation
- * the image references. Called from validateImage; throws on any deviation.
- * @param {any} state
- */
-export function validateIncarnations(state) {
-  valid(Array.isArray(state.incarnations), 'registry')
-  const known = new Set()
-  for (const entry of state.incarnations) {
-    shape(entry, ['incarnation', 'process'])
-    valid(id(entry.incarnation) && !known.has(entry.incarnation), 'entry')
-    known.add(entry.incarnation)
-    if (entry.process === null) continue
-    shape(entry.process, ['pid', 'host', 'osStart', 'bootNonce'])
-    const process = /** @type {Record<string, any>} */ (entry.process)
-    valid(Number.isSafeInteger(process.pid) && process.pid > 0, 'pid')
-    valid(id(process.host) && id(process.bootNonce), 'identity')
-    valid(process.osStart === null || typeof process.osStart === 'string', 'start time')
-  }
-  for (const incarnation of referencedIncarnations(state)) valid(known.has(incarnation), 'coverage')
-}