weir-harness 1.2.2 → 1.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weir-harness",
-  "version": "1.2.2",
+  "version": "1.2.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/intent-gate/matcher.js

@@ -20,6 +20,7 @@ export function stripQuotedRegions(text) {
  * @property {string} id
  * @property {RegExp[]} patterns - compiled matchers
  * @property {boolean} oncePerSession
+ * @property {string} [summary] - one-line catalog description for the semantic classifier
  * @property {{ kind: 'skill-pointer', skill: string }
  *   | { kind: 'message', text: string }
  *   | { kind: 'effort', reasoningEffort: string }} injection
@@ -76,6 +77,7 @@ export function compileIntentTable(raw) {
       id: entry.id,
       patterns,
       oncePerSession: entry.oncePerSession !== false,
+      ...(typeof entry.summary === 'string' && entry.summary.length > 0 ? { summary: entry.summary } : {}),
       injection,
     }
   })
@@ -91,6 +93,16 @@ export function matchIntents(stripped, intents) {
   return intents.filter((intent) => intent.patterns.some((pattern) => pattern.test(stripped)))
 }
 
+/** Verbatim directive injected on every writing intent hit. */
+export const WRITING_DIRECTIVE = `<intent-gate id="writing">
+Write the deliverable as the finished product, not as a record of producing it.
+- Keep the agent's thinking, implementation rationale, design reasoning, debugging narrative, and next-step plans out of the deliverable.
+- Do not write explanatory UI copy — "I will", "we can", "this page shows", "here you'll find", "used to illustrate", "implemented" — unless it is genuine product help text or empty-state copy.
+- Put implementation approach, verification method, limitations, and trade-offs only in the chat reply, code comments, the PR/MR description, docs, or plan files.
+- Exception: include design notes, methodology, implementation walkthrough, or a work log in the deliverable only when the user explicitly asks for them.
+- Unless there is a real need, a change leaves no trace: no comments, notes, markers, or any "why this changed" evidence. Code should look like it was always that way. The best change looks like no change was made — present the result, not the change itself.
+</intent-gate>`
+
 /** The default intent table (English templates; runtime content follows the session language). */
 export const DEFAULT_INTENTS = [
   {
@@ -113,6 +125,21 @@ export const DEFAULT_INTENTS = [
     matchers: ['\\bdebug\\b', '\\bdebugging\\b', '调试', '排查'],
     injection: { kind: 'skill-pointer', skill: 'debugging' },
   },
+  {
+    id: 'writing',
+    matchers: [
+      '\\bwrite (?:a |an |the |some )?(?:[a-z][\\w-]* )?(?:doc|docs|document|documents|documentation|readme|guide|manual|report|spec)\\b',
+      '\\b(?:draft|compose|author|produce|prepare|rewrite|revise|update|polish) (?:a |an |the |some )?(?:[a-z][\\w-]* )?(?:doc|docs|document|documentation|readme|guide|manual|report)\\b',
+      '\\bwrite[- ]?up\\b',
+      '\\bdocument (?:the|this|these|a|an)\\b',
+      '(?:写|撰写|编写|起草|整理成|写成|润色|补全|更新)[^\\n]{0,8}(?:文档|说明|报告|指南|手册|教程|文案)',
+      '(?:写|撰写|编写|起草|润色|补全|更新)[^\\n]{0,8}readme',
+      '文档(?:撰写|编写|写作|润色|补全|更新)',
+    ],
+    oncePerSession: false,
+    summary: 'author a documentation-style deliverable (docs, README, guide, report) as the finished result',
+    injection: { kind: 'message', text: WRITING_DIRECTIVE },
+  },
   {
     id: 'think',
     matchers: ['\\bthink hard\\b', '\\bultrathink\\b', '深思熟虑'],

package/src/lsp/admin.js

@@ -3,7 +3,7 @@
 // the community catalog). Plain ESM, ctx-only; `connection`/`subprocess`
 // resolve through ctx.get so the module mounts harmlessly in compositions
 // without them (headless).
-import { buildRegistry, DEFAULT_SERVERS, displayInstallCommand, installSpecFor, languageIdsForFamily } from './registry.js'
+import { buildRegistry, displayInstallCommand, installSpecFor, languageIdsForFamily, serverForPlatform } from './registry.js'
 import { npmGlobalPrefix, resolveExecutable as extendedResolveExecutable, runBounded, spawnArgv } from '../process/index.js'
 import { jsonResponse, readJsonBody } from '../shared/http-json.js'
 
@@ -39,20 +39,27 @@ export async function probeVersion(subprocess, executable, args = ['--version'],
   return first ?? null
 }
 
-/** Per-family status rows over the community catalog. */
+/**
+ * Per-family status rows over the community catalog. `options.platform`
+ * (default: the host) resolves each family's platform row first, so every
+ * displayed value — command, version probe, install command, hint — belongs to
+ * the platform being reported (D2/D5).
+ */
 export async function lspStatusFor(registry, subprocess, options = {}) {
   const probeTimeoutMs = options.probeTimeoutMs ?? VERSION_PROBE_TIMEOUT_MS
   const dirs = options.dirs ?? undefined
+  const platform = options.platform ?? process.platform
   const servers = []
   for (const [family, entry] of Object.entries(registry)) {
+    const resolved = serverForPlatform(entry, platform)
     let installed = false
     let version = null
     try {
-      const executable = await extendedResolveExecutable(subprocess, entry.command, dirs)
+      const executable = await extendedResolveExecutable(subprocess, resolved.command, dirs)
       installed = Boolean(executable)
       if (executable) {
         try {
-          version = await probeVersion(subprocess, executable, entry.versionArgs ?? ['--version'], probeTimeoutMs)
+          version = await probeVersion(subprocess, executable, resolved.versionArgs ?? ['--version'], probeTimeoutMs)
         } catch {
           version = null
         }
@@ -61,7 +68,7 @@ export async function lspStatusFor(registry, subprocess, options = {}) {
       // unresolvable command = not installed
     }
     let installerAvailable = false
-    const installerSpec = installSpecFor(entry)
+    const installerSpec = installSpecFor(resolved, platform)
     if (installerSpec) {
       try {
         installerAvailable = Boolean(await extendedResolveExecutable(subprocess, installerSpec.command, dirs))
@@ -72,11 +79,11 @@ export async function lspStatusFor(registry, subprocess, options = {}) {
     servers.push({
       family,
       languageIds: languageIdsForFamily(family),
-      command: entry.command,
+      command: resolved.command,
       installed,
       version,
-      installCommand: displayInstallCommand(entry),
-      installHint: entry.installHint ?? '',
+      installCommand: displayInstallCommand(resolved, platform),
+      installHint: resolved.installHint ?? '',
       installerAvailable,
     })
   }
@@ -87,13 +94,15 @@ export async function lspStatusFor(registry, subprocess, options = {}) {
  * Run one family's install command: argv-only (no shell), output captured,
  * bounded by a timeout. Resolves `{ output, exitCode, timedOut }`; throws a
  * structured Error for unknown families, missing installers, or a missing
- * installer binary. `dirs` overrides the extra bin-directory scan (tests).
+ * installer binary. `dirs` overrides the extra bin-directory scan (tests);
+ * `platform` selects the family's platform row and its install spec (D2).
  */
-export async function runInstall(registry, subprocess, family, timeoutMs = DEFAULT_INSTALL_TIMEOUT_MS, dirs = undefined) {
+export async function runInstall(registry, subprocess, family, timeoutMs = DEFAULT_INSTALL_TIMEOUT_MS, dirs = undefined, platform = process.platform) {
   const entry = registry[family]
   if (!entry) throw new Error(`lsp: unknown language family '${family}'`)
-  const spec = installSpecFor(entry)
-  if (!spec) throw new Error(`lsp: no installer for '${family}' on this platform — ${entry.installHint ?? 'see the install hint'}`)
+  const resolved = serverForPlatform(entry, platform)
+  const spec = installSpecFor(resolved, platform)
+  if (!spec) throw new Error(`lsp: no installer for '${family}' on this platform — ${resolved.installHint ?? 'see the install hint'}`)
   const executable = await extendedResolveExecutable(subprocess, spec.command, dirs).catch(() => undefined)
   if (!executable) throw new Error(`lsp: installer '${spec.command}' not found on PATH — install it first`)
   // npm installs pin a user-writable prefix: the resolved npm may belong to
@@ -127,7 +136,9 @@ export function registerLspAdminEndpoints(ctx, options = {}) {
     ctx.logger?.warn?.('weir-lsp-admin: connection/subprocess unavailable — LSP management endpoints not registered')
     return () => {}
   }
-  const registryProvider = typeof options.registry === 'function' ? options.registry : () => DEFAULT_SERVERS
+  // The catalog is platform-scoped: an absent provider builds the registry for
+  // the running host (rows resolved), never the raw unresolved DEFAULT_SERVERS.
+  const registryProvider = typeof options.registry === 'function' ? options.registry : () => buildRegistry()
   const installTimeoutMs = options.installTimeoutMs ?? DEFAULT_INSTALL_TIMEOUT_MS
   const dirs = options.dirs ?? undefined
   const disposers = []

package/src/lsp/index.js

@@ -81,7 +81,10 @@ function apply(ctx, config = {}) {
     manager = createLspManager({
       subprocess: ctx.subprocess,
       fs: ctx.fs,
-      registry: buildRegistry(option('servers', config.servers)),
+      // `config.platform` is the test seam: the registry resolves the running
+      // host's rows unless a caller pins the platform (D2 — consumers below
+      // only ever see flat, already-resolved entries).
+      registry: buildRegistry(option('servers', config.servers), config.platform ?? process.platform),
       // config.extraBinDirs overrides the extended-resolution scan dirs
       // (hermetic tests; power users with exotic install locations)
       resolveExecutable: (command) => extendedResolveExecutable(ctx.subprocess, command, config.extraBinDirs),
@@ -244,7 +247,7 @@ function apply(ctx, config = {}) {
         diagnosticsWaitMs: option('diagnosticsWaitMs', config.diagnosticsWaitMs),
       }
       manager.setOptions(Object.fromEntries(Object.entries(next).filter(([, value]) => value !== undefined)))
-      manager.setRegistry(buildRegistry(option('servers', config.servers)))
+      manager.setRegistry(buildRegistry(option('servers', config.servers), config.platform ?? process.platform))
     }
   })
   applyGate()

package/src/lsp/registry.js

@@ -64,6 +64,14 @@ export const LANGUAGE_FAMILY = {
   cpp: 'cpp',
 }
 
+/**
+ * Built-in catalog. An entry may carry `platforms: { darwin?, linux?, win32?,
+ * default? }`; every row has the entry shape (all fields optional) and
+ * overrides only the fields it declares for that platform (D1). A family whose
+ * data is identical on every platform declares it once as the shared base
+ * (npm/pipx/go/rustup); the rest keep a platform-NEUTRAL base plus one row per
+ * platform, so no platform ever sees another platform's installer (D5).
+ */
 export const DEFAULT_SERVERS = {
   typescript: {
     command: 'typescript-language-server',
@@ -155,19 +163,41 @@ export const DEFAULT_SERVERS = {
     command: 'lua-language-server',
     args: [],
     manifests: ['*.lua'],
-    installHint: 'brew install lua-language-server (macOS); see https://luals.github.io for other platforms',
-    install: {
-      darwin: { command: 'brew', args: ['install', 'lua-language-server'] },
+    installHint: 'install LuaLS from https://luals.github.io',
+    platforms: {
+      darwin: {
+        installHint: 'brew install lua-language-server',
+        install: { command: 'brew', args: ['install', 'lua-language-server'] },
+      },
+      linux: {
+        // no package-managed LuaLS on Linux: hint only, pointing at the release
+        // page (a one-click install would be a guess, not a recipe)
+        installHint: 'no package-managed LuaLS on Linux — download it from https://github.com/LuaLS/lua-language-server/releases',
+      },
+      win32: {
+        installHint: 'winget install --id LuaLS.lua-language-server -e --accept-source-agreements --accept-package-agreements',
+        install: { command: 'winget', args: ['install', '--id', 'LuaLS.lua-language-server', '-e', '--accept-source-agreements', '--accept-package-agreements'] },
+      },
     },
   },
   cpp: {
     command: 'clangd',
     args: [],
     manifests: ['*.c', '*.cpp', 'compile_commands.json'],
-    installHint: 'brew install llvm (macOS); sudo apt-get install clangd (Debian/Ubuntu)',
-    install: {
-      darwin: { command: 'brew', args: ['install', 'llvm'] },
-      linux: { command: 'sudo', args: ['apt-get', 'install', '-y', 'clangd'] },
+    installHint: 'install clangd from https://clangd.llvm.org/installation',
+    platforms: {
+      darwin: {
+        installHint: 'brew install llvm',
+        install: { command: 'brew', args: ['install', 'llvm'] },
+      },
+      linux: {
+        installHint: 'sudo apt-get install clangd',
+        install: { command: 'sudo', args: ['apt-get', 'install', '-y', 'clangd'] },
+      },
+      win32: {
+        installHint: 'winget install --id LLVM.LLVM -e --accept-source-agreements --accept-package-agreements',
+        install: { command: 'winget', args: ['install', '--id', 'LLVM.LLVM', '-e', '--accept-source-agreements', '--accept-package-agreements'] },
+      },
     },
   },
 }
@@ -192,26 +222,62 @@ export function languageIdsForFamily(family) {
   return Object.entries(LANGUAGE_FAMILY).filter(([, value]) => value === family).map(([id]) => id)
 }
 
-/** Platform-resolved install spec for a registry entry, or undefined. */
+/**
+ * Resolve one entry for a platform: `{...entry, ...platforms[platform]}` with
+ * the `platforms` key removed (D1/D2). An entry without a `platforms` map is
+ * returned unchanged — the platform is never guessed. A platform with no row
+ * (and no `default` row) keeps the entry's base fields, which are
+ * platform-neutral by contract — never another platform's recipe (D5).
+ */
+export function serverForPlatform(entry, platform = process.platform) {
+  const platforms = entry?.platforms
+  if (!platforms || typeof platforms !== 'object' || Array.isArray(platforms)) return entry
+  const row = platforms[platform] ?? platforms.default
+  const resolved = { ...entry, ...(row && typeof row === 'object' ? row : {}) }
+  delete resolved.platforms
+  return resolved
+}
+
+/**
+ * Platform-resolved install spec for a registry entry, or undefined. The entry
+ * is resolved first when it declares `platforms`. A single spec is identified
+ * by `install.command` being a string (a platform map never has a `command`
+ * key — D7); anything else is the legacy platform map, kept so existing user
+ * configs keep resolving.
+ */
 export function installSpecFor(entry, platform = process.platform) {
-  const install = entry?.install
+  const resolved = entry?.platforms ? serverForPlatform(entry, platform) : entry
+  const install = resolved?.install
   if (!install) return undefined
-  if (Array.isArray(install.args)) return install // single-spec form
+  if (typeof install.command === 'string') return install // single-spec form
   return install[platform] ?? install.default
 }
 
-/** Display form of the install command for a registry entry. */
+/**
+ * Display form of the install command for a registry entry. Where the platform
+ * declares no install spec the fallback is the RESOLVED entry's `installHint`
+ * — never another platform's command.
+ */
 export function displayInstallCommand(entry, platform = process.platform) {
-  const spec = installSpecFor(entry, platform)
-  if (!spec) return entry?.installHint ?? ''
+  const resolved = entry?.platforms ? serverForPlatform(entry, platform) : entry
+  const spec = installSpecFor(resolved, platform)
+  if (!spec) return resolved?.installHint ?? ''
   return [spec.command, ...(spec.args ?? [])].join(' ')
 }
 
-/** Merge user `lsp.servers` config over the defaults (per-language overlay). */
-export function buildRegistry(configServers) {
-  const registry = { ...DEFAULT_SERVERS }
+/**
+ * Merge user `lspServers` config over the platform-resolved catalog. Built-ins
+ * resolve first; each user override is then merged onto the resolved built-in
+ * and resolved again, so a user row overrides only the fields it declares and
+ * a user platform row wins over the built-in one (D2/D6).
+ */
+export function buildRegistry(configServers, platform = process.platform) {
+  const registry = {}
+  for (const [language, entry] of Object.entries(DEFAULT_SERVERS)) {
+    registry[language] = serverForPlatform(entry, platform)
+  }
   for (const [language, entry] of Object.entries(configServers ?? {})) {
-    registry[language] = { ...registry[language], ...entry }
+    registry[language] = serverForPlatform({ ...registry[language], ...entry }, platform)
   }
   return registry
 }

package/src/notify/commands.js

@@ -54,7 +54,10 @@ function linux(note, sound) {
   }
 }
 
-/** PowerShell source of the Windows toast; reads title/body from the environment. */
+/**
+ * PowerShell source of the Windows toast; reads title/body from the environment
+ * and reports an OS-level block through stderr plus a non-zero exit.
+ */
 const WINDOWS_SCRIPT = [
   "$ErrorActionPreference = 'Stop'",
   '[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null',
@@ -66,7 +69,17 @@ const WINDOWS_SCRIPT = [
   '$xml.LoadXml("<toast><visual><binding template=\'ToastGeneric\'><text>$title</text><text>$body</text></binding></visual>$audio</toast>")',
   '$toast = [Windows.UI.Notifications.ToastNotification]::new($xml)',
   "$appId = '{1AC14E77-02E7-4E5D-B744-2EB1AE5198B7}\\WindowsPowerShell\\v1.0\\powershell.exe'",
-  '[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier($appId).Show($toast)',
+  // `Show()` has no synchronous failure return, and the asynchronous
+  // `ToastNotification.Failed` event cannot be awaited by a process that exits
+  // right after firing, so `ToastNotifier.Setting` is the synchronous proxy: a
+  // non-`Enabled` value (disabled for the app, the user, by group policy or by
+  // manifest) becomes a non-zero exit whose stderr reaches the warn-once path
+  // instead of vanishing into silence. Explicit variables, not a chained
+  // expression: PowerShell 5.1 chaining behaviour must not be relied on.
+  '$notifier = [Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier($appId)',
+  '$setting = $notifier.Setting',
+  'if ("$setting" -ne \'Enabled\') { [Console]::Error.WriteLine("Windows toast notifications are unavailable: $setting"); exit 3 }',
+  '$notifier.Show($toast)',
 ].join('\n')
 
 /**

package/src/notify/index.js

@@ -30,6 +30,32 @@ const STALE_EVENT_MS = 60_000
 /** Longest parent chain walked to find the session the user actually sees. */
 const MAX_ANCESTORS = 8
 
+/**
+ * Platforms whose page can both DISPLAY a notification and REPORT whether it
+ * appeared, so handing the note to the page first is sound there: macOS and
+ * Linux. Windows is deliberately absent — the page's web `Notification` can
+ * neither display nor report failure there. Electron only shows a toast for an
+ * app that owns a Start Menu shortcut with an AppUserModelID and a
+ * ToastActivatorCLSID (the DSH desktop bundle declares no app identity), so
+ * Chromium drops it with nothing but a debug log; and in a secure context with
+ * permission granted, Blink never fails the constructor and never fires
+ * `error`. The page could therefore only answer `shown`/`pending`, both
+ * terminal, which would suppress the fallback forever. So Windows goes
+ * straight to the platform command, whose AUMID points at an OS-registered
+ * shortcut. The cost: Windows attributes the toast to "Windows PowerShell".
+ */
+export const PAGE_DELIVERY_PLATFORMS = Object.freeze(['darwin', 'linux'])
+
+/**
+ * Whether the page leg can carry a delivery on this platform.
+ *
+ * @param {string} platform - a `process.platform` value
+ * @returns {boolean}
+ */
+export function usesPageDelivery(platform) {
+  return PAGE_DELIVERY_PLATFORMS.includes(platform)
+}
+
 /**
  * Resolve the effective options NOW (the settings service is live: a
  * volatile commit takes effect on the next event, no remount). Unusable
@@ -238,26 +264,38 @@ export function wire(ctx, config, { notifier, channel, now = Date.now, setTimer,
   }
 }
 
-/** @param {any} ctx @param {object} [config] */
-function apply(ctx, config = {}) {
-  const notifier = createNotifier({ logger: ctx.logger })
-  if (!notifier.supported) ctx.logger?.warn?.(`notify: system notifications are not supported on platform "${process.platform}"`)
-  // The page delivers (as DeepSeek Harness); the system command is the fallback.
-  const channel = createWebChannel({ fallback: (note, options) => notifier.send(note, options), logger: ctx.logger })
+/**
+ * @param {any} ctx
+ * @param {object} [config]
+ * @param {{ platform?: string }} [options] - test seam; cordis calls (ctx, config) only
+ */
+function apply(ctx, config = {}, { platform = process.platform } = {}) {
+  const notifier = createNotifier({ platform, logger: ctx.logger })
+  if (!notifier.supported) ctx.logger?.warn?.(`notify: system notifications are not supported on platform "${platform}"`)
+  // The page delivers (as DeepSeek Harness) where it can also confirm; on the
+  // other platforms the system command is the only leg (PAGE_DELIVERY_PLATFORMS).
+  const channel = usesPageDelivery(platform)
+    ? createWebChannel({ fallback: (note, options) => notifier.send(note, options), logger: ctx.logger })
+    : undefined
   const offWire = wire(ctx, config, { notifier, channel })
   // Page endpoints (pull/ack) and the macOS permission panel's endpoints. They
   // register from this row, whose `./notify` subpath already exists, so no new
   // package subpath is needed (S19); services come through ctx.inject (S20).
   const offEndpoints = wireNotifyPermissions(ctx, {
+    platform,
     channel,
-    // The permission panel's test goes through the real path, and shows even
-    // with the window in front (the user is looking at the settings page).
-    sendTest: () => channel.send({ ...TEST_NOTE, tag: tagFor('test', 'test'), renotify: RENOTIFY, sound: true, foreground: 'always' }),
+    // The permission panel's test goes through whichever path the platform
+    // uses, and shows even with the window in front (the user is looking at
+    // the settings page).
+    sendTest: () =>
+      channel
+        ? channel.send({ ...TEST_NOTE, tag: tagFor('test', 'test'), renotify: RENOTIFY, sound: true, foreground: 'always' })
+        : notifier.send(TEST_NOTE, { sound: true }),
   })
   return () => {
     offWire()
     offEndpoints()
-    channel.close()
+    channel?.close()
   }
 }
 

package/src/notify/web-channel.js

@@ -9,8 +9,13 @@
 //
 // Safety contract (spec "待发通知通道对失败与异常页面安全"):
 //   - a note is handed to exactly ONE puller;
-//   - a note is delivered at most once: a page that showed it, or suppressed it
-//     on purpose (window in the foreground), is final — no fallback;
+//   - a note is delivered at most once: a page that showed it, suppressed it on
+//     purpose (window in the foreground), or handed it off without confirmation
+//     (`pending`) is final — no fallback;
+//   - `pending` is final but is NOT confirmation: it means the page could not
+//     tell whether the notification appeared, so it is reported once per cause
+//     through the logger instead of falling back — a silent platform drop would
+//     otherwise be invisible to the user and to the log;
 //   - a note is never lost: no puller, a failed page, or a missing ack all fall
 //     back to the system command;
 //   - nothing here touches a session. Plain ESM, ctx-free; clock and timers are
@@ -25,11 +30,16 @@ export const ACK_TIMEOUT_MS = 4_000
 
 /**
  * What the page may report. `shown`/`pending`/`suppressed` are final (no
- * fallback); everything else falls back.
+ * fallback); everything else falls back. `pending` is final without being
+ * confirmation — the page handed the note off and could not tell whether it
+ * appeared — so it is reported through the logger instead of falling back.
  */
 export const FINAL_RESULTS = Object.freeze(['shown', 'pending', 'suppressed'])
 export const FALLBACK_RESULTS = Object.freeze(['blocked', 'error', 'threw', 'unsupported'])
 
+/** Reported once per channel when a page hands a note off but never confirms it. */
+const UNCONFIRMED = 'the page sent a notification but could not confirm it appeared'
+
 /**
  * @typedef {{ title: string, body: string, urgent: boolean }} Note
  * @typedef {Note & { tag: string, renotify: boolean, sound: boolean, foreground: 'skip' | 'always' }} WebNote
@@ -63,6 +73,15 @@ export function createWebChannel({ fallback, now = Date.now, setTimer, clearTime
   let nextId = 1
   let closed = false
 
+  /** Distinct warnings already emitted (one per cause, like the notifier). @type {Set<string>} */
+  const reported = new Set()
+  /** @param {string} cause */
+  const warnOnce = (cause) => {
+    if (reported.has(cause)) return
+    reported.add(cause)
+    logger?.warn?.(`notify: ${cause}`)
+  }
+
   const hasPuller = () => waiters.length > 0 || now() - lastPullAt < PULLER_FRESH_MS
 
   /** @param {WebNote} note */
@@ -165,6 +184,10 @@ export function createWebChannel({ fallback, now = Date.now, setTimer, clearTime
       inFlight.delete(id)
       stop(entry.timer)
       if (!FINAL_RESULTS.includes(result)) useFallback(entry.note)
+      // `pending` is final (never fall back) but it is not confirmation: the
+      // page handed the note off and could not tell whether it appeared. Say so
+      // once per cause, or a silent platform drop stays invisible.
+      else if (result === 'pending') warnOnce(UNCONFIRMED)
       return true
     },
 

package/src/process/index.js

@@ -39,6 +39,8 @@ export function extraBinDirectories(env = process.env, platform = process.platfo
     // describe, not which separator to spell, so a test on any host can point
     // the seam at a real fixture directory.
     const roaming = env.APPDATA ?? join(home, 'AppData', 'Roaming')
+    const localAppData = env.LOCALAPPDATA ?? join(home, 'AppData', 'Local')
+    const programFiles = env.ProgramFiles ?? 'C:\\Program Files'
     return [
       // npm's own global prefix: the .cmd/.ps1 shims live directly here.
       join(roaming, 'npm'),
@@ -51,6 +53,15 @@ export function extraBinDirectories(env = process.env, platform = process.platfo
       join(home, 'go', 'bin'),
       join(home, 'scoop', 'shims'),
       join(roaming, 'npm', 'node_modules', '.bin'),
+      // LLVM's NSIS installer skips the "add to PATH" step in silent mode, so
+      // these two are the ONLY way a winget-installed clangd resolves (D4).
+      join(programFiles, 'LLVM', 'bin'),
+      join(localAppData, 'Programs', 'LLVM', 'bin'),
+      // WinGet portable packages expose their command aliases here (LuaLS).
+      join(localAppData, 'Microsoft', 'WinGet', 'Links'),
+      // winget.exe itself lives here; a long-running GUI's PATH can predate the
+      // App Installer update, so the directory scan must cover it too.
+      join(localAppData, 'Microsoft', 'WindowsApps'),
     ]
   }
   const nvmBins = []

package/src/settings/sections.js

@@ -72,7 +72,7 @@ const FIELDS = [
   { key: 'worktreeAutoSetup', section: 'worktree', field: 'autoSetup', type: 'boolean', description: 'Install dependencies in a new lane automatically (configured setup, else lockfile-derived)' },
   { key: 'worktreeWatchTimeoutMinutes', section: 'worktree', field: 'watchTimeoutMinutes', type: 'number', description: 'Minutes a lane-state watch (worktree_watch) lives before expiring with one notice (default 360 = 6 hours, minimum 1); frozen per watch at subscribe time' },
   { key: 'worktreeAutoApprove', section: 'worktree', field: 'autoApprove', type: { union: ['manual', 'auto-keep', 'auto-clean'] }, description: 'Worktree auto-approve mode: manual shows every decision card; auto-keep auto-approves merges and abandons, removing the worktree but keeping the branch; auto-clean also deletes the branch. The initial mode for sessions without a /worktree approve override (default auto-clean); a session override wins over this global value' },
-  { key: 'lspServers', section: 'lsp', field: 'servers', type: 'string', description: 'JSON map of custom language servers: family → { command, args?, manifests?, installHint?, install? }' },
+  { key: 'lspServers', section: 'lsp', field: 'servers', type: 'string', description: 'JSON map of custom language servers: family → { command, args?, manifests?, installHint?, platforms?, install? }; a platforms map ({ darwin?, linux?, win32?, default? }) overrides only the fields its row declares for that platform' },
   { key: 'notifyEnabled', section: 'notify', field: 'enabled', type: 'boolean', description: 'System notifications master switch: tell the user when a session needs them or a turn finishes' },
   { key: 'notifyOnComplete', section: 'notify', field: 'onComplete', type: 'boolean', description: 'Notify when a turn finishes (only turns longer than notifyMinTurnSeconds)' },
   { key: 'notifyOnAttention', section: 'notify', field: 'onAttention', type: 'boolean', description: 'Notify when a session needs the user: approval, question, plan review, a failed or stopped turn' },
@@ -227,19 +227,42 @@ function chainsValidator(key) {
   return validate
 }
 
-/** Parse + validate the lspServers JSON map (bad input fails activation loud). */
+/** True for a JSON object literal (arrays and null are not plain objects). */
+function isPlainObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+}
+
+/** Parse + validate the lspServers JSON map (bad input fails activation loud).
+ *  A family may declare `platforms: { darwin?, linux?, win32?, default? }`,
+ *  each row shaped like an entry with every field optional; a malformed row
+ *  names the family and field so activation failure is diagnosable (D6). */
 function validateLspServers(raw) {
   const parsed = JSON.parse(raw)
-  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+  if (!isPlainObject(parsed)) {
     throw new Error('weir-settings: lspServers must be a JSON object map')
   }
   for (const [family, entry] of Object.entries(parsed)) {
-    if (!entry || typeof entry !== 'object' || typeof entry.command !== 'string' || entry.command.trim().length === 0) {
+    if (!isPlainObject(entry) || typeof entry.command !== 'string' || entry.command.trim().length === 0) {
       throw new Error(`weir-settings: lspServers.${family} needs a { command } entry`)
     }
     if (entry.args !== undefined && !Array.isArray(entry.args)) {
       throw new Error(`weir-settings: lspServers.${family}.args must be an array`)
     }
+    if (entry.platforms === undefined) continue
+    if (!isPlainObject(entry.platforms)) {
+      throw new Error(`weir-settings: lspServers.${family}.platforms must be a JSON object map`)
+    }
+    for (const [platform, row] of Object.entries(entry.platforms)) {
+      if (!isPlainObject(row)) {
+        throw new Error(`weir-settings: lspServers.${family}.platforms.${platform} must be a JSON object`)
+      }
+      if (row.command !== undefined && (typeof row.command !== 'string' || row.command.trim().length === 0)) {
+        throw new Error(`weir-settings: lspServers.${family}.platforms.${platform}.command must be a non-empty string`)
+      }
+      if (row.args !== undefined && !Array.isArray(row.args)) {
+        throw new Error(`weir-settings: lspServers.${family}.platforms.${platform}.args must be an array`)
+      }
+    }
   }
   return parsed
 }