weir-harness 2.0.0 → 2.1.1

package/src/capabilities/mcp-runtime.js

@@ -0,0 +1,103 @@
+// Synchronous per-identity replacement fence. The runtime phase is authoritative
+// for admission; registry/mount joins are for inventory, never for reopening a
+// closed replacement window early.
+import { randomUUID } from 'node:crypto'
+
+const OPEN = new Set(['mounted'])
+const RESTORABLE = new Set(['mounted', 'registered', 'saved-degraded', 'unknown', 'cleanup-failed', 'cleanup-unknown'])
+const clone = value => value == null ? value : structuredClone(value)
+
+export function createMcpRuntime() {
+  const states = new Map()
+
+  function snapshot(identity) {
+    const state = states.get(identity)
+    return state ? clone(state) : { phase: 'unknown', generation: null, incarnation: null, operationId: null }
+  }
+  function begin(identity, { phase = 'replacing', generation = null, incarnation = null, operationId = randomUUID() } = {}) {
+    const previous = states.get(identity) ?? null
+    const token = { identity, operationId, previous }
+    // This transition is deliberately synchronous and happens before the
+    // caller's first registry/credential/probe await.
+    states.set(identity, { phase, generation, incarnation, operationId })
+    return token
+  }
+  function current(token) {
+    return states.get(token.identity)?.operationId === token.operationId
+  }
+  function finish(token, phase, details = {}) {
+    if (!current(token)) return false
+    states.set(token.identity, {
+      phase,
+      generation: details.generation ?? states.get(token.identity).generation,
+      incarnation: details.incarnation === undefined ? states.get(token.identity).incarnation : details.incarnation,
+      operationId: token.operationId,
+    })
+    return true
+  }
+  function restore(token) {
+    if (!current(token)) return false
+    const previous = token.previous
+    if (previous && RESTORABLE.has(previous.phase)) states.set(token.identity, previous)
+    else states.set(token.identity, { phase: 'unknown', generation: null, incarnation: null, operationId: token.operationId })
+    return true
+  }
+  function enabledFor(identity) {
+    return OPEN.has(snapshot(identity).phase)
+  }
+  function registrationFor(identity) {
+    const state = snapshot(identity)
+    return enabledFor(identity)
+      ? { identity, generation: state.generation, incarnation: state.incarnation, operationId: state.operationId }
+      : null
+  }
+  function permit(identity, { generation, incarnation }) {
+    const state = snapshot(identity)
+    if (!enabledFor(identity) || state.generation !== generation || (state.incarnation ?? null) !== (incarnation ?? null)) return null
+    return { identity, generation, incarnation: incarnation ?? null, operationId: state.operationId }
+  }
+  function assertPermit(value) {
+    if (!value || typeof value !== 'object') return false
+    const state = snapshot(value.identity)
+    return enabledFor(value.identity)
+      && state.operationId === value.operationId
+      && state.generation === value.generation
+      && (state.incarnation ?? null) === (value.incarnation ?? null)
+  }
+  return {
+    begin, finish, restore, snapshot, enabledFor, registrationFor, permit, assertPermit,
+    beforeRead: enabledFor,
+    afterRead: enabledFor,
+    states,
+  }
+}
+
+/**
+ * Per-identity FIFO for every operation that opens a runtime fence
+ * (runtime.begin). Same-identity operations run strictly one after another
+ * (design D6), so a Restart can never begin while an edit-mode Test holds the
+ * fence and leave the server mounted but refusing calls. A task's failure never
+ * poisons the queue; different identities never wait on each other. Not
+ * reentrant: callers already inside serialize() pass their token instead.
+ */
+export function createMcpIdentityLock() {
+  const tails = new Map()
+  return function serialize(identity, task) {
+    const previous = tails.get(identity) ?? Promise.resolve()
+    const run = previous.then(() => task())
+    const tail = run.then(() => {}, () => {})
+    tails.set(identity, tail)
+    void tail.then(() => { if (tails.get(identity) === tail) tails.delete(identity) })
+    return run
+  }
+}
+
+const fallbackLocks = new WeakMap()
+/** The manager's own lock, or one stable lock per manager object for fakes/older faces. */
+export function mcpIdentityLockFor(manager) {
+  if (typeof manager?.serialize === 'function') return (identity, task) => manager.serialize(identity, task)
+  if (!manager || (typeof manager !== 'object' && typeof manager !== 'function')) return createMcpIdentityLock()
+  let lock = fallbackLocks.get(manager)
+  if (!lock) { lock = createMcpIdentityLock(); fallbackLocks.set(manager, lock) }
+  return lock
+}

package/src/capabilities/read-payloads.js

@@ -50,6 +50,7 @@ export async function buildReceiptPayload(deps, options) {
       skills: selected.map(candidate => candidate.name),
       skillIdentities,
       mcpServers,
+      ...(snapshot?.mcpIncarnations && typeof snapshot.mcpIncarnations === 'object' ? { mcpIncarnations: structuredClone(snapshot.mcpIncarnations) } : {}),
       digest: effectiveSelectionDigest(skillIdentities, mcpServers),
     },
     warnings: result?.complete === false || status?.error
@@ -78,7 +79,7 @@ export async function buildListPayload(deps, options) {
     if (!candidate.selected || !candidate.identity) continue
     try { selectedKeys.add(skillIdentityKey(candidate.identity)) } catch { /* an unstamped shape carries no mark */ }
   }
-  const listing = deps.mcpManager?.list?.() ?? { managed: [], unmanaged: [] }
+  const listing = await (deps.mcpManager?.list?.() ?? Promise.resolve({ managed: [], unmanaged: [] }))
   return {
     skills: candidates.map(candidate => {
       /** @type {string | null} */
@@ -95,9 +96,13 @@ export async function buildListPayload(deps, options) {
       }
     }),
     mcpServers: [
-      ...(listing.managed ?? []).map(server => ({ identity: server.identity, state: server.state })),
-      ...(listing.unmanaged ?? []).map(server => ({ serverName: server.serverName, state: 'unmanaged' })),
+      ...(listing.managed ?? []).map(server => ({ ...server })),
+      ...(listing.unmanaged ?? []).map(server => ({ ...server, state: 'unmanaged', readOnly: true })),
     ],
+    mcpWarnings: Array.isArray(listing.warnings) ? [...listing.warnings] : [],
+    mcpUnavailable: listing.unavailable ?? null,
+    mcpCapabilities: listing.capabilities ?? null,
+    mcpRegistryRevision: Number.isSafeInteger(listing.registryRevision) ? listing.registryRevision : 0,
   }
 }
 

package/src/capabilities/skill-applicability.js

@@ -0,0 +1,185 @@
+// Cross-workspace preset applicability (fix-capability-fork-and-preset-workspaces
+// D4): the server-side partition of Skill entries an Apply draft names but the
+// CURRENT inventory did not resolve exactly.
+//
+// A project-scoped Skill identity is machine-local: its canonical root names
+// the workspace it was discovered in. A global preset carrying such an identity
+// therefore names an entry that does not exist in another workspace at all —
+// the preset contract is "skip it, warn, keep the rest", never an unactionable
+// same-name conflict with a local Skill that happens to share the invocation
+// name, and never a silent substitution.
+//
+// Evidence discipline (the whole point of this module): ABSENCE IS NEVER PROOF.
+// The current workspace's project Skill roots are derived from the inventory's
+// own root observations (canonical `projectRoot` + the two project Skill root
+// suffixes, plus each observed project root path). A skip is authorized only
+// when the inventory is COMPLETE (`inventoryResult.complete === true`) and at
+// least one current project root resolved. An incomplete inventory, a root set
+// that cannot be resolved, and a legacy name string with no identity all keep
+// the pre-existing behavior: profile-supplemental knowledge may still skip with
+// its own reason, everything else stays a hard failure with the draft kept.
+//
+// Path comparison is by canonical exact key — never a string prefix — so a
+// lexical alias of this very workspace (`/var` vs `/private/var`, a symlinked
+// checkout, win32 case folding) is NOT misread as another workspace. A local
+// identity whose root IS one of this workspace's project roots but which the
+// inventory did not resolve stays a hard failure: it is missing, not external.
+import { realpathSync } from 'node:fs'
+import { basename, dirname, isAbsolute, join, sep } from 'node:path'
+
+/** Reason reported for a project identity proven to belong to another workspace. */
+export const NOT_APPLICABLE_IN_WORKSPACE = 'not applicable in this workspace'
+/** Reason reported for a name known only to a profile-supplemental preset root. */
+export const NOT_APPLICABLE_IN_PRESET = 'not applicable in this agent preset'
+
+/** The two project Skill discovery roots of one workspace, relative to its project root. */
+const PROJECT_SKILL_SUFFIXES = Object.freeze(['.dsh/skills', '.agents/skills'])
+
+/**
+ * Comparable form of a path: realpath when it exists, '/'-separated, and
+ * case-folded on win32. A path that does not exist yet keeps its lexical form
+ * with the deepest EXISTING ancestor canonicalized, so the macOS `/var` →
+ * `/private/var` alias is resolved for `<root>/.dsh/skills` even before that
+ * directory is created.
+ * (Same contract as the worktree lane's `pathKey`; kept local so the capability
+ * modules never depend on the worktree feature's internals.)
+ * @param {unknown} path
+ * @param {string} [platform]
+ * @returns {string | null} canonical key, or null when the path cannot be resolved safely
+ */
+export function canonicalPathKey(path, platform = process.platform) {
+  const lexical = String(path)
+  let real = lexical
+  const missing = error => error?.code === 'ENOENT' || error?.code === 'ENOTDIR'
+  try {
+    real = realpathSync.native(lexical)
+  } catch (error) {
+    // Only a genuinely absent path may be reconstructed through its deepest
+    // existing ancestor. EINVAL/EACCES/ELOOP/etc. prove nothing and must not
+    // become a lexical key that could authorize a cross-workspace skip.
+    if (!missing(error)) return null
+    let parent = dirname(lexical)
+    const tail = [basename(lexical)]
+    while (parent !== dirname(parent)) {
+      try {
+        real = join(realpathSync.native(parent), ...tail.reverse())
+        break
+      } catch (ancestorError) {
+        if (!missing(ancestorError)) return null
+        tail.push(basename(parent))
+        parent = dirname(parent)
+      }
+    }
+  }
+  const slashed = real.split(sep).join('/').replace(/\/+$/, '')
+  return platform === 'win32' ? slashed.toLowerCase() : slashed
+}
+
+/**
+ * The canonical project Skill roots of the workspace the inventory observed.
+ * Empty means "this inventory proves nothing about the current workspace";
+ * callers must treat that as NO skip authorization, never as a foreign verdict.
+ * @param {unknown} roots inventory root observations (`inventoryResult.roots`)
+ * @param {{ platform?: string }} [options]
+ * @returns {Set<string>}
+ */
+export function workspaceProjectSkillRoots(roots, options = {}) {
+  const platform = options.platform ?? process.platform
+  const keys = new Set()
+  for (const observation of Array.isArray(roots) ? roots : []) {
+    const root = /** @type {Record<string, unknown> | undefined} */ (
+      observation && typeof observation === 'object' ? (/** @type {any} */ (observation).root ?? observation) : undefined)
+    if (!root || root.scope !== 'project') continue
+    if (typeof root.projectRoot === 'string' && root.projectRoot.length > 0) {
+      const projectRoot = canonicalPathKey(root.projectRoot, platform)
+      if (projectRoot !== null) {
+        for (const suffix of PROJECT_SKILL_SUFFIXES) {
+          const key = canonicalPathKey(join(projectRoot, suffix), platform)
+          if (key !== null) keys.add(key)
+        }
+      }
+    }
+    // The observed root itself is canonicalized by discovery (a symlinked
+    // project Skill root keeps ITS OWN identity), so it names this workspace
+    // too: a broken local Skill must fail as missing, never read as external.
+    if (typeof root.path === 'string' && root.path.length > 0) {
+      const key = canonicalPathKey(root.path, platform)
+      if (key !== null) keys.add(key)
+    }
+  }
+  return keys
+}
+
+/**
+ * Is this identity a project identity rooted OUTSIDE every current project root?
+ * The caller must have authorized the classification (complete inventory and a
+ * non-empty project root set) — this predicate only answers the path question.
+ * @param {unknown} identity
+ * @param {Set<string>} projectRoots
+ * @param {{ platform?: string }} [options]
+ * @returns {boolean}
+ */
+export function isForeignProjectIdentity(identity, projectRoots, options = {}) {
+  const value = /** @type {Record<string, unknown> | null} */ (
+    identity && typeof identity === 'object' ? identity : null)
+  if (!value || value.scope !== 'project') return false
+  if (typeof value.root !== 'string' || value.root.length === 0 || !isAbsolute(value.root)) return false
+  const key = canonicalPathKey(value.root, options.platform ?? process.platform)
+  return key !== null && !projectRoots.has(key)
+}
+
+/**
+ * Partition the draft Skill entries the CURRENT inventory did not resolve
+ * exactly. Order follows the draft; duplicates are preserved (the request is
+ * reported as received, never silently deduplicated).
+ *
+ * - an identity proven to be a project identity of another workspace →
+ *   `skipped` with `not applicable in this workspace`
+ * - a legacy name or identity name known to a profile-supplemental preset root →
+ *   `not applicable in this agent preset` (the pre-existing contract)
+ * - everything else → `unknown` (the caller keeps the hard-failure contract and
+ *   preserves the draft)
+ * @param {unknown[]} entries unresolved draft entries (identity objects or name strings)
+ * @param {{
+ *   roots?: unknown,
+ *   complete?: unknown,
+ *   knownSupplemental?: (name: string) => boolean,
+ *   platform?: string,
+ * }} [options]
+ * @returns {{ skipped: Array<{ name: string, reason: string }>, unknown: string[] }}
+ */
+export function partitionUnresolvedSkills(entries, options = {}) {
+  const knownSupplemental = typeof options.knownSupplemental === 'function' ? options.knownSupplemental : () => false
+  // Evidence gate: an incomplete inventory, or a current workspace whose project
+  // roots did not resolve, authorizes no cross-workspace skip at all.
+  const projectRoots = options.complete === true
+    ? workspaceProjectSkillRoots(options.roots, options)
+    : new Set()
+  const canProveForeign = projectRoots.size > 0
+  const skipped = []
+  const unknown = []
+  for (const entry of Array.isArray(entries) ? entries : []) {
+    if (typeof entry === 'string') {
+      if (knownSupplemental(entry)) skipped.push({ name: entry, reason: NOT_APPLICABLE_IN_PRESET })
+      else unknown.push(entry)
+      continue
+    }
+    const identity = /** @type {Record<string, unknown> | null} */ (
+      entry && typeof entry === 'object' ? entry : null)
+    if (!identity) {
+      unknown.push(String(entry))
+      continue
+    }
+    const name = typeof identity.name === 'string' && identity.name.length > 0 ? identity.name : String(entry)
+    if (knownSupplemental(name)) {
+      skipped.push({ name, reason: NOT_APPLICABLE_IN_PRESET })
+      continue
+    }
+    if (canProveForeign && isForeignProjectIdentity(identity, projectRoots, options)) {
+      skipped.push({ name, reason: NOT_APPLICABLE_IN_WORKSPACE })
+      continue
+    }
+    unknown.push(name)
+  }
+  return { skipped, unknown }
+}

package/src/capabilities/skill-builtin-migration.js

@@ -14,6 +14,7 @@ export const WEIR_BUILTIN_SKILLS = Object.freeze([
   'debugging',
   'deep-work',
   'git-master',
+  'mcp-server-setup',
   'programming',
   'refactor',
   'remove-ai-slops',
@@ -33,7 +34,7 @@ export const MIGRATION_FAILURE = 'Weir builtin skill migration check failed'
 /**
  * Verify a discovery snapshot against the pre-migration contract: exactly one
  * readable weir-builtin root whose parsed candidates are exactly the
- * contracted ten, each carrying the custom source label and rank 300.
+ * contracted catalog, each carrying the custom source label and rank 300.
  * @param {{ roots?: Array<{ root: Record<string, unknown>, complete: boolean, error?: string }>,
  *   candidates?: Array<Record<string, any>> }} snapshot
  * @returns {{ ok: true } | { ok: false, reason: string }}