dsh-vibe-math 2.8.4 → 2.8.5

package/vibe-math-v5/vibe-math-v5.js

@@ -56,6 +56,40 @@
 // guessed; otherwise the host resolver (PATH) is tried first, then the known install locations for this
 // platform. Provenance is returned so the caller can report \`leanFoundVia: 'explicit'|'path'|'known-install'\`,
 // and the probed list travels on failure ("I looked here too"), never just "not found on PATH".
+// ── task-28: TeX Live's DOCUMENTED typical install positions + a bounded probe budget ────────────────
+// A real-host SLV v5 run (15.2 min, candidate PASS) archived compileStatus `not-detected` on a machine
+// whose TeX Live lives at `D:\texlive\2025\bin\windows\xelatex.exe`: the known list only covered
+// `<ProgramFiles>/texlive`, so an engine that IS installed but NOT on PATH was never found and the run
+// degraded to tex+md only. These are DOCUMENTED roots, never a search: no whole-drive scan, no install,
+// no write outside the workspace (the three hard boundaries stay in the guidance text).
+const TEX_CANDIDATE_CAP = 40            // hard cap on TeX known-root candidate paths probed per detection
+const TEX_YEAR_LOOKBACK = 4             // the newest N year dirs of a TeX Live root (current year + 3)
+const TEX_DRIVE_YEAR_ROOTS = ['D:/texlive', 'C:/texlive']               // Windows: TeX Live at a DRIVE ROOT
+const TEX_SYSTEM_BIN_ROOTS = ['/Library/TeX/texbin']                    // macOS: system MacTeX (already a bin dir)
+const TEX_SYSTEM_YEAR_ROOTS = ['/usr/local/texlive', '/opt/texlive']    // Unix: TeX Live (year-globbed)
+// ── feedback library (Shared/Feedback/) ──────────────────────────────────────────────────────────────
+// The METHODOLOGY / COLLABORATION layer: how the institute WORKS (organisation, workflow, cooperation,
+// obstacles, friction). Deliberately separate from Progress/ (research progress) and Verified/
+// (established results) — an entry here is never evidence for a mathematical claim.
+const FEEDBACK_CATEGORIES = ['cooperation', 'management', 'process', 'obstacle', 'conflict']
+const FEEDBACK_CATEGORY_LABELS = { cooperation: '合作', management: '管理', process: '流程', obstacle: '障碍', conflict: '矛盾' }
+// The three ROUTES decide what "handling" an entry means — and, crucially, WHO has to do anything:
+//   self          — my own way of working / habits / pitfalls ⇒ I adjust it MYSELF; nobody's approval,
+//                   at most a share so colleagues do not hit the same wall.
+//   team          — how the institute is organised/run (task assignment, workflow, organisation model)
+//                   ⇒ also self-regulation: no approval, change it as soon as it looks wrong.
+//   interpersonal — the problem is caused by SOMEONE ELSE and only they can fix it ⇒ the ONLY route that
+//                   needs a careful assessment first ("should anything change, and would the change
+//                   really be better?") and a written-back verification afterwards.
+const FEEDBACK_ROUTES = ['self', 'team', 'interpersonal']
+// `open` = recorded, not yet handled; `adjusted` = the initiator adjusted their own way of working
+// (for self/team this IS the closing record — no approval step exists); `closed` = a result was written
+// back (interpersonal REQUIRES that write-back); `dropped` = evaluated and deliberately NOT changed
+// (needs a reason). list's default "not yet closed" filter = open|adjusted.
+const FEEDBACK_STATUSES = ['open', 'adjusted', 'closed', 'dropped']
+const FEEDBACK_OPEN_STATUSES = ['open', 'adjusted']
+const FEEDBACK_DIR = 'Shared/Feedback'
+const FEEDBACK_DISABLED_MESSAGE = '反馈库已关闭（params.feedback = \'off\'）：本条未写入、也未改动任何条目'
 async function resolveKnownTool(sub, opts) {
   const name = String((opts && opts.name) || '')
   const explicit = String((opts && opts.explicit) || '').trim()
@@ -75,12 +109,27 @@ async function resolveKnownTool(sub, opts) {
     return null
   }
   const listDirs = async (p) => { try { const fs = await import('node:fs'); return fs.readdirSync(p, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name) } catch (err) { return [] } }
+  // task-29: TEST/DIAGNOSTIC sandbox seam (env-gated; UNSET = identity, i.e. exactly today's behaviour).
+  // When `V5_TEX_ROOTS_SANDBOX` is set, every known-install TeX candidate is REBASED under that directory
+  // (same relative tail) so a suite can pin its "no LaTeX installed here" premise on ANY host: the
+  // candidates are still probed ONE BY ONE (triedPaths stays named, TEX_CANDIDATE_CAP still bounds them,
+  // still no whole-drive scan) but a real install is never touched. It is not a product switch: it only
+  // relocates where the documented roots are looked for, and it is never set by the plugin itself.
+  const texSandbox = kind === 'tex' ? String(env.V5_TEX_ROOTS_SANDBOX || '').trim() : ''
+  const texProbeBase = (p) => {
+    if (!texSandbox) return p
+    const tail = String(p).replace(/\\/g, '/').replace(/^[A-Za-z]:/, '').replace(/^\/+/, '')
+    return texSandbox.replace(/\\/g, '/').replace(/\/+$/, '') + '/' + tail
+  }
   const knownLean = win
     ? [elan ? elan + '/bin' : null, home + '/.elan/bin', local ? local + '/Programs/lean' : null, pf + '/lean/bin']
     : [elan ? elan + '/bin' : null, home + '/.elan/bin', home + '/.local/bin', '/usr/local/bin', '/opt/lean/bin']
+  // task-28: the DRIVE-ROOT TeX Live positions come first on Windows (the observed real-host layout);
+  // the legacy entries keep their relative order. Unix keeps the legacy order and adds the system
+  // MacTeX bin dir last (a documented root, not a guess).
   const knownTex = win
-    ? [pf + '/texlive', pf86 + '/texlive', local ? local + '/Programs/MiKTeX/miktex/bin/x64' : null, pf + '/MiKTeX/miktex/bin/x64']
-    : [home + '/Library/TeX/texbin', '/usr/local/texlive', home + '/.TinyTeX/bin', '/opt/texlive']
+    ? TEX_DRIVE_YEAR_ROOTS.concat([pf + '/texlive', pf86 + '/texlive', local ? local + '/Programs/MiKTeX/miktex/bin/x64' : null, pf + '/MiKTeX/miktex/bin/x64'])
+    : [home + '/Library/TeX/texbin'].concat(TEX_SYSTEM_YEAR_ROOTS, [home + '/.TinyTeX/bin'], TEX_SYSTEM_BIN_ROOTS)
   const list = kind === 'tex' ? knownTex : knownLean
   // 1) EXPLICIT: only it, never a guess.
   if (explicit) {
@@ -93,19 +142,35 @@ async function resolveKnownTool(sub, opts) {
   if (typeof sub.resolveExecutable === 'function') {
     try { const p = await sub.resolveExecutable(name); if (p) return { exe: String(p), via: 'path', tried, name } } catch (e) { /* PATH miss is expected */ }
   }
-  // 3) KNOWN INSTALL LOCATIONS (Windows TeX roots are globbed per release: <root>/<year>/bin/windows).
+  // 3) KNOWN INSTALL LOCATIONS. A TeX root WITHOUT a `bin` segment is year-globbed
+  //    (`<root>/<year>/bin/<platform>`): the years actually on disk (newest first) first, then the
+  //    recent-year window, at most TEX_YEAR_LOOKBACK of them. task-28: the whole stage is BOUNDED by
+  //    TEX_CANDIDATE_CAP candidate paths — documented roots, never a whole-drive scan.
+  const texYearSubdirs = win ? ['bin/windows'] : ['bin/x86_64-linux', 'bin/aarch64-linux', 'bin/universal-darwin', 'bin']
+  const texRecentYears = () => { const now = new Date().getFullYear(); const out = []; for (let i = 0; i < TEX_YEAR_LOOKBACK; i++) out.push(String(now - i)); return out }
+  let texProbes = 0
   for (const base of list) {
     if (!base) continue
     if (kind === 'tex' && !/bin/i.test(base)) {
-      for (const year of await listDirs(base)) {
-        for (const sub2 of ['bin/windows', 'bin/x86_64-linux', 'bin/universal-darwin', 'bin']) {
-          const p = await resolvePath(base + '/' + year + '/' + sub2 + '/' + name)
+      const onDisk = (await listDirs(texProbeBase(base))).filter((d) => /^\d{4}$/.test(d)).sort((a, b) => Number(b) - Number(a))
+      const years = onDisk.concat(texRecentYears().filter((y) => onDisk.indexOf(y) < 0)).slice(0, TEX_YEAR_LOOKBACK)
+      for (const year of years) {
+        for (const sub2 of texYearSubdirs) {
+          if (texProbes >= TEX_CANDIDATE_CAP) break
+          texProbes++
+          const p = await resolvePath(texProbeBase(base) + '/' + year + '/' + sub2 + '/' + name)
           if (p) return { exe: p, via: 'known-install', tried, name }
         }
+        if (texProbes >= TEX_CANDIDATE_CAP) break
       }
+      if (texProbes >= TEX_CANDIDATE_CAP) break
       continue
     }
-    const p = await resolvePath(base + '/' + name)
+    if (kind === 'tex') {
+      if (texProbes >= TEX_CANDIDATE_CAP) break
+      texProbes++
+    }
+    const p = await resolvePath(texProbeBase(base) + '/' + name)
     if (p) return { exe: p, via: 'known-install', tried, name }
   }
   return { exe: null, via: null, tried, name, reason: 'not found on PATH or in the known install locations' }
@@ -188,15 +253,21 @@ const PAPER_SECTIONS = [
 // the model compete for the same CPU, and the parameter surface deliberately gains only
 // `leanAsync` (the per-compile budget reuses `leanTimeoutMs`).
 const LEAN_QUEUE_CONCURRENCY = 1
-// ONE place for the flag spelling: a toolchain that does not know `--search-path` only needs
-// this constant changed (never the interface).
-const LEAN_SEARCH_PATH_FLAG = '--search-path'
+// task-27 (real-host A round + local reproduction): Lean 4 accepts `-R`/`--root` (or LEAN_PATH); `--search-path`
+// is the **Lean 3** spelling and makes `lean` fail at ARGUMENT PARSING (rc=1) before it reads the file — so every
+// compile failed by default. Local check on Lean 4.34.0: `lean --search-path <dir> <f>` ⇒ rc=1; `lean -R <dir> <f>`
+// ⇒ accepted (the compiler then reads the file). ONE place for the flag spelling: change this constant only.
+const LEAN_SEARCH_PATH_FLAG = '-R'
 const LEAN_READ_MAX_BYTES = 64 * 1024
 // A user-supplied search root wins: never inject a second one (explicit override first).
 function leanHasSearchFlag(args) {
+  // task-27: the flag we INJECT is `-R` (Lean 4). A user may still state any of these in `leanArgs` — the legacy
+  // Lean-3 spelling included — and this guard's only job is "never inject a SECOND search root".
+  const ALSO_ACCEPTED = ['--search-path', '--root']
   return (Array.isArray(args) ? args : []).some((a) => {
     const t = String(a)
-    return t === LEAN_SEARCH_PATH_FLAG || t.indexOf(LEAN_SEARCH_PATH_FLAG + '=') === 0 || t === '-R' || t === '--root'
+    if (t === LEAN_SEARCH_PATH_FLAG || t.indexOf(LEAN_SEARCH_PATH_FLAG + '=') === 0) return true
+    return ALSO_ACCEPTED.some((f) => t === f || t.indexOf(f + '=') === 0)
   })
 }
 // Content identity for queue dedupe: CRLF normalised, trailing blank lines dropped.
@@ -413,6 +484,9 @@ export function apply(ctx) {
       // The final-paper flow (stage machine + its artifacts state). Durable like everything
       // else, so a restart resumes the same stage instead of writing a second paper.
       paper: null,
+      // Methodology/collaboration feedback (Shared/Feedback/). Durable like `verdicts`, so a restart
+      // keeps the loop closed instead of losing what the institute learned about working together.
+      feedback: [],
     }
   }
   // LOW (deep review): `state.order` used to be maintained here and preserved in the diagnostics
@@ -509,6 +583,15 @@ export function apply(ctx) {
               : patch.paper
             if (next !== undefined) n.paper = next
           }
+          // Durable methodology/collaboration feedback (Shared/Feedback/). A FUNCTION is a mutation
+          // applied INSIDE the fold (the same trick `paper` uses): several members may add or update
+          // entries between two commits, and a read-modify-write outside the fold would lose one.
+          if (patch.feedback !== undefined) {
+            const next = typeof patch.feedback === 'function'
+              ? patch.feedback(Array.isArray(n.feedback) ? n.feedback : [])
+              : patch.feedback
+            if (next !== undefined) n.feedback = Array.isArray(next) ? next : []
+          }
           return n
         })
       }
@@ -911,8 +994,8 @@ export function apply(ctx) {
       // today's behaviour (the reminder rides with formalVerify); 'eager' = push valuable small
       // lemmas/propositions/definitions into the library even in daily rounds.
       leanInitiative: 'normal',
-      // leanSearchPaths: extra `--search-path` roots injected BEFORE the automatic VibeMath
-      // root (deduped; an explicit --search-path/-R/--root in leanArgs wins).
+      // leanSearchPaths: extra `-R` roots injected BEFORE the automatic VibeMath
+      // root (deduped; an explicit -R/--root in leanArgs wins).
       leanSearchPaths: [],
       // leanJobsMaxParallel: how many background compiles may run at once (default 1 = serial).
       leanJobsMaxParallel: 1,
@@ -948,6 +1031,12 @@ export function apply(ctx) {
       paperCompilePdf: true,
       paperEditor: 'academician',
       paperLatexCommand: '',
+      // ── methodology / collaboration feedback (Shared/Feedback/) ──
+      // feedback — 'on' (default: the tool works AND the short per-round hint is injected) |
+      //            'off' (the hint is NOT injected and every write is refused BY NAME, never
+      //            silently dropped). It is a switch, not a severity: recording is encouraged,
+      //            never mandatory.
+      feedback: 'on',
       // ── model / tools ────────────────────────────────────────────────────
       provider: '',
       model: '',
@@ -2007,7 +2096,7 @@ export function apply(ctx) {
       // someone who never asked.
       if (m.kind === 'assign') return (m.from === 'office' ? '【所办分派】' : '【院士分派】') + m.text
       if (m.kind === 'nudge') return '【督办 from ' + m.from + '】' + m.text
-      if (m.kind === 'notice') return '【框架提示】' + m.text
+      if (m.kind === 'notice') return '【研究所提示】' + m.text
       return '【研究所·' + m.kind + ' from ' + m.from + '】' + m.text
     }
     // Batch plain chat so a chatty institute cannot cause a wake storm; anything
@@ -2436,6 +2525,7 @@ export function apply(ctx) {
       if (member.direction && !resume) { L.push('给你的起点方向：' + member.direction); L.push('') }
       mathPushLine(L)
       paperPushLine(L)
+      feedbackPushLine(L)
       L.push('------------')
       L.push(stateBlock(member, roundNo))
       L.push('------------')
@@ -2456,6 +2546,7 @@ export function apply(ctx) {
       if (leanDailyOn()) { L.push(''); L.push(formalWorkLine()) }
       mathPushLine(L)
       paperPushLine(L)
+      feedbackPushLine(L)
       L.push('')
       L.push('------------')
       L.push(stateBlock(member))
@@ -2474,6 +2565,7 @@ export function apply(ctx) {
       if (leanDailyOn()) { L.push(''); L.push(formalWorkLine()) }
       mathPushLine(L)
       paperPushLine(L)
+      feedbackPushLine(L)
       L.push('')
       L.push('------------')
       L.push(stateBlock(member))
@@ -2510,6 +2602,7 @@ export function apply(ctx) {
       L.push('一致认为是真时，本所才会停下来。')
       mathPushLine(L)
       paperPushLine(L)
+      feedbackPushLine(L)
       L.push('')
       L.push('------------')
       L.push(stateBlock(member))
@@ -2523,7 +2616,12 @@ export function apply(ctx) {
       L.push('')
       L.push('本所正在对下列对象发起共识验证：')
       L.push('  对象：' + vs.target + '（类型：' + kindLabel2(vs.kind) + '）')
-      if (vs.statement) L.push('  陈述：' + String(vs.statement).slice(0, 800))
+      if (vs.statement) {
+        // task-24: this line feeds the member prompt. Cutting it with a bare `.slice(0, 800)` hid the tail of a
+        // long statement with no trace; make the cut visible instead (the full text stays in the source card).
+        const _st = String(vs.statement)
+        L.push('  陈述：' + (_st.length > 800 ? _st.slice(0, 800) + '…（已截断；完整陈述见源卡片 ' + String(vs.rel || vs.target || '') + '）' : _st))
+      }
       L.push('')
       L.push('请给出你**诚实独立的判断**：')
       L.push('  verdict = 1  表示你认为该对象**绝对为真**；')
@@ -2556,6 +2654,7 @@ export function apply(ctx) {
       L.push('本所宁可留下未定论，也不要一个骗人的结论。')
       mathPushLine(L)
       paperPushLine(L)
+      feedbackPushLine(L)
       L.push('')
       L.push('------------')
       L.push(stateBlock(member))
@@ -2963,7 +3062,7 @@ export function apply(ctx) {
       for (const j of leanJobs.values()) if (j.state === 'queued' && (!best || (j.enqueuedAt || 0) < (best.enqueuedAt || 0))) best = j
       return best
     }
-    // The absolute VibeMath root handed to `--search-path` (the compile runs with cwd=instRoot()).
+    // The absolute VibeMath root handed to `-R` (the compile runs with cwd=instRoot()).
     function leanSearchRootView() { return vibeRoot().replace(/\\/g, '/') }
     async function leanSearchRoot() {
       const root = vibeRoot()
@@ -3536,14 +3635,194 @@ export function apply(ctx) {
     // is the "off means zero mention" discipline).
     function mathPushLine(L) { const b = mathPromptBlock('zh'); if (b) L.push(b) }
 
-    // task-9 2b: the LaTeX-missing guidance (four bounded steps + three hard boundaries). Kept
-    // BYTE-IDENTICAL with the other presets; per-preset voice may only follow this block.
+    // task-9 2b: the LaTeX-missing guidance (four bounded steps + three hard boundaries). Those four
+    // steps and three boundaries are the shared contract; task-28 (v5 PILOT) additionally names the
+    // "installed but NOT on PATH" case and TeX Live's documented positions — v4/v2/v3 adopt the same
+    // text once v5 is verified, so the wording deliberately leads on v5.
     function paperHintBlock(lang) {
       return lang === 'en'
-        ? '\nWhen no LaTeX engine is detected: (1) probe only the documented common TeX roots and PATH (e.g. where xelatex, latexmk --version) - never scan whole drives; (2) once the absolute path is found, write it into paperLatexCommand, re-detect, then continue; (3) if it is still missing, ask the user once (installing TeX requires the user\'s explicit approval); (4) with no answer, degrade exactly as today (deliver paper.tex and paper.md only). Hard boundaries: never auto-install; never write outside the workspace; never treat "not detected" as a failure.'
-        : '\n检测不到 LaTeX 引擎时：① 只在文档化的常见 TeX 根与 PATH 上做有界核查（如 where xelatex、latexmk --version），不要全盘扫描；② 找到绝对路径后写入 paperLatexCommand 并重新检测，再继续；③ 仍找不到就向用户问一次（安装 TeX 需用户明确同意）；④ 无应答则照旧降级（只交付 paper.tex 与 paper.md）。硬边界：绝不自动安装；绝不写工作区之外；绝不把"未检测到"当失败。'
+        ? '\nWhen no LaTeX engine is detected: (1) probe only the documented common TeX roots and PATH (e.g. where xelatex, latexmk --version) - never scan whole drives; the MOST COMMON case is an engine that IS installed but NOT on PATH — a DRIVE-ROOT Windows TeX Live lives under `texlive\\<year>\\bin\\windows` on that drive, Unix under the standard system paths `/usr/local/texlive/<year>/bin/*` or `/opt/texlive/<year>/bin/*`, macOS at `/Library/TeX/texbin`; (2) once the absolute path is found, write it into paperLatexCommand, re-detect, then continue; (3) if it is still missing, REPORT IT TO THE OFFICE (or the group chat) and let the OFFICE confirm with the user (installing TeX requires the user\'s explicit approval); (4) with no answer yet, degrade exactly as today (deliver paper.tex and paper.md only). Hard boundaries: never auto-install; never write outside the workspace; never treat "not detected" as a failure.'
+        : '\n检测不到 LaTeX 引擎时：① 只在文档化的常见 TeX 根与 PATH 上做有界核查（如 where xelatex、latexmk --version），不要全盘扫描——**最常见的情形是引擎装了但不在 PATH**：TeX Live 若装在 Windows 的某个**盘根**下，看该盘根里的 `texlive\\<年份>\\bin\\windows`；类 Unix 看标准系统路径 `/usr/local/texlive/<年份>/bin/*`、`/opt/texlive/<年份>/bin/*`；macOS 看 `/Library/TeX/texbin`；② 找到绝对路径后写入 paperLatexCommand 并重新检测，再继续；③ 仍找不到就**如实上报所办（或群聊）**，由**所办**向用户确认（安装 TeX 需用户明确同意）；④ 尚无回应则照旧降级（只交付 paper.tex 与 paper.md）。硬边界：绝不自动安装；绝不写工作区之外；绝不把"未检测到"当失败。'
+    }
+    function paperPushLine(L) {
+      const b = paperHintBlock('zh')
+      // Iron-rules fix (P4): this block only matters while the member is writing/compiling the paper, yet it was
+      // pushed into EVERY wake — founding, verify and meeting prompts included — where it reads as unexplained
+      // noise ("why is LaTeX guidance in my first round?"). Keep the guidance (the paper builders do NOT emit it,
+      // so removing it here would lose it entirely) but SAY WHEN IT APPLIES. The block itself stays byte-identical
+      // across presets; only this per-preset wrapper changes.
+      if (b) L.push('\n（**以下这段仅在你参与论文写作或编译时适用**；其他阶段可忽略。）' + b)
+    }
+
+    // ---- feedback library (Shared/Feedback/): methodology / collaboration, never research -----------
+    // Entries live in the DURABLE `feedback` array and are written through the fold (patchInstitute with
+    // an UPDATER), so two concurrent adds/updates cannot lose one. The human-readable mirror (one file per
+    // category + a JSON index) is WRITE-ONLY like Shared/TaskBoard.md; the state file stays authoritative.
+    function feedbackOn() { return String(params.feedback || 'on') !== 'off' }
+    function feedbackEntries() { const s = inst(); if (!Array.isArray(s.feedback)) s.feedback = []; return s.feedback }
+    function feedbackCounts() {
+      const all = feedbackEntries()
+      const byCategory = {}, byRoute = {}
+      for (const c of FEEDBACK_CATEGORIES) byCategory[c] = 0
+      for (const r of FEEDBACK_ROUTES) byRoute[r] = 0
+      let open = 0
+      for (const e of all) {
+        if (byCategory[e.category] !== undefined) byCategory[e.category] += 1
+        if (byRoute[e.route] !== undefined) byRoute[e.route] += 1
+        if (FEEDBACK_OPEN_STATUSES.indexOf(e.status) !== -1) open += 1
+      }
+      return { total: all.length, open, closed: all.length - open, byCategory, byRoute }
+    }
+    function feedbackView(e) {
+      return { id: e.id, at: e.at, by: e.by, category: e.category, route: e.route, status: e.status,
+        context: e.context || '', phenomenon: e.phenomenon || '', impact: e.impact || '',
+        action: e.action || '', assessment: e.assessment || '', outcome: e.outcome || '',
+        note: e.note || '', updatedAt: e.updatedAt || '', updatedBy: e.updatedBy || '' }
+    }
+    /** The human-readable mirror + structured index. A failure is REPORTED (mirror:false), never thrown
+     *  and never logged: it must not disturb the existing write-failure accounting (F6). */
+    async function feedbackMirror() {
+      const all = feedbackEntries()
+      let ok = true
+      for (const c of FEEDBACK_CATEGORIES) {
+        const rows = all.filter((e) => e.category === c)
+        const md = ['# 反馈库 · ' + FEEDBACK_CATEGORY_LABELS[c] + '（' + c + '）', '',
+          '> 方法论／协作层记录：怎么一起工作（组织、流程、合作、障碍、摩擦）。**不是研究结论**——研究进展见 Progress/，已确立结论见 Verified/。', '']
+        for (const e of rows) {
+          md.push('## ' + e.id + '｜' + e.route + '｜' + e.status + '｜' + (e.at || ''), '',
+            '- 发起人：' + (e.by || '') + '｜类别：' + c + '｜路由：' + e.route + '｜状态：' + e.status,
+            '- 情境：' + (e.context || '（未写）'),
+            '- 现象：' + (e.phenomenon || ''),
+            '- 影响：' + (e.impact || ''),
+            '- 已做的调整或建议：' + (e.action || ''))
+          if (e.route === 'interpersonal') md.push('- 评估（要不要改／改了是否真更优）：' + (e.assessment || ''))
+          if (e.outcome) md.push('- 事后验证／结果：' + e.outcome)
+          if (e.note) md.push('- 备注：' + e.note)
+          if (e.updatedAt) md.push('- 最近更新：' + e.updatedAt + '（' + (e.updatedBy || '') + '）')
+          md.push('')
+        }
+        if (!rows.length) md.push('（本类暂无条目）', '')
+        try { if (!(await writeTextRel(FEEDBACK_DIR + '/' + c + '.md', md.join('\n')))) ok = false } catch (err) { ok = false }
+      }
+      try {
+        if (!(await writeTextRel(FEEDBACK_DIR + '/index.json', JSON.stringify({ counts: feedbackCounts(), entries: all }, null, 2) + '\n'))) ok = false
+      } catch (err) { ok = false }
+      return ok
+    }
+    async function feedbackTool(caller, a) {
+      const op = String((a && a.op) || '').trim()
+      // `off` is NEVER a silent write: the call is refused BY NAME with the reason and the remedy.
+      if (!feedbackOn()) {
+        return { ok: false, code: 'V5_FEEDBACK_DISABLED', message: FEEDBACK_DISABLED_MESSAGE,
+          next: { kind: 'note', tool: 'vibe_v5_set', hint: '由所办把 feedback 设回 \'on\' 后重试（本条没有被静默写入）' } }
+      }
+      if (op === 'add') {
+        const category = String(a.category || '').trim()
+        const route = String(a.route || '').trim()
+        if (FEEDBACK_CATEGORIES.indexOf(category) < 0) {
+          return { ok: false, code: 'V5_FEEDBACK_BAD_CATEGORY', message: 'category 必须是 ' + FEEDBACK_CATEGORIES.join('|'),
+            next: { kind: 'note', hint: '合作=cooperation｜管理=management｜流程=process｜障碍=obstacle｜矛盾=conflict' } }
+        }
+        if (FEEDBACK_ROUTES.indexOf(route) < 0) {
+          return { ok: false, code: 'V5_FEEDBACK_BAD_ROUTE', message: 'route 必须是 ' + FEEDBACK_ROUTES.join('|'),
+            next: { kind: 'note', hint: 'self=自己的做法（自己调整即可）｜team=组织/工作流（自我调节，无需审批）｜interpersonal=别人造成的、要别人改变（须评估＋事后回填）' } }
+        }
+        const phenomenon = String(a.phenomenon || '').trim()
+        const impact = String(a.impact || '').trim()
+        const action = String(a.action || '').trim()
+        if (!phenomenon || !impact || !action) {
+          return { ok: false, code: 'V5_FEEDBACK_INCOMPLETE', message: 'add 需要 phenomenon／impact／action（现象、影响、已做的调整或建议）',
+            next: { kind: 'note', hint: '写清"看到了什么／造成什么／我已经或打算怎么调整"' } }
+        }
+        const assessment = String(a.assessment || '').trim()
+        // ONLY the interpersonal route gates on the careful evaluation: self/team are self-regulation
+        // (the user ruling: no approval step, adjust as soon as it looks wrong).
+        if (route === 'interpersonal' && !assessment) {
+          return { ok: false, code: 'V5_FEEDBACK_NEEDS_ASSESSMENT', message: 'interpersonal 路由必须带 assessment：先想清楚"要不要让别人改、改了是否真的更优"',
+            next: { kind: 'note', hint: '若发现只能靠自己调整，请改记 self；确实需要别人改变时，写完评估再跟进事后验证' } }
+        }
+        const base = { at: now(), by: caller, category, route, status: 'open',
+          context: String(a.context || ''), phenomenon, impact, action, assessment,
+          outcome: '', note: String(a.note || ''), updatedAt: '', updatedBy: '' }
+        let entry = null
+        await patchInstitute({ feedback: (cur) => {
+          const list = Array.isArray(cur) ? cur.slice() : []
+          entry = Object.assign({ id: 'fb-' + (list.length + 1) }, base)
+          list.push(entry)
+          return list
+        } })
+        const mirror = await feedbackMirror()
+        return { ok: true, entry: feedbackView(entry), mirror, counts: feedbackCounts(),
+          routeHint: route === 'interpersonal'
+            ? 'interpersonal：已记录。请按评估结论处理，并用 update 回填 outcome（事后验证）才算闭环。'
+            : 'self/team：无需任何人采纳——自己调整即可，并用 update 把状态/结果记下来（self/team 的记录本身就是闭环凭据）。' }
+      }
+      if (op === 'update') {
+        const id = String(a.id || '').trim()
+        if (!id) return { ok: false, code: 'V5_FEEDBACK_NO_ID', message: 'update 需要 id', next: { kind: 'note', hint: '先用 op=list（默认只看未闭环）确认 id（形如 fb-1）' } }
+        const cur = feedbackEntries().find((x) => x.id === id)
+        if (!cur) return { ok: false, code: 'V5_FEEDBACK_NOT_FOUND', message: '没有条目 ' + id, next: { kind: 'note', hint: '先用 op=list 确认 id' } }
+        // Permission: the INITIATOR updates their own entry; the OFFICE may update any (mark it resolved /
+        // write the result back). Anyone else is refused BY NAME — never silently ignored.
+        if (caller !== 'office' && caller !== cur.by) {
+          return { ok: false, code: 'V5_FEEDBACK_FORBIDDEN', message: '只有发起人（' + cur.by + '）或所办可以更新 ' + id,
+            next: { kind: 'note', hint: '别人的问题请自己另记一条（你只能更新自己发起的条目）' } }
+        }
+        const status = a.status === undefined ? '' : String(a.status).trim()
+        if (status && FEEDBACK_STATUSES.indexOf(status) < 0) {
+          return { ok: false, code: 'V5_FEEDBACK_BAD_STATUS', message: 'status 必须是 ' + FEEDBACK_STATUSES.join('|'),
+            next: { kind: 'note', hint: 'open=未处理｜adjusted=已自我调整｜closed=已回填结果｜dropped=评估后决定不改（需理由）' } }
+        }
+        const outcome = a.outcome === undefined ? '' : String(a.outcome).trim()
+        const note = a.note === undefined ? '' : String(a.note).trim()
+        // The interpersonal route is the ONLY one that must PROVE the change helped: closing it without
+        // the written-back verification is refused (that is exactly why the route exists).
+        if (cur.route === 'interpersonal' && status === 'closed' && !outcome) {
+          return { ok: false, code: 'V5_FEEDBACK_NEEDS_OUTCOME', message: 'interpersonal 条目闭环必须回填 outcome（事后验证：改了什么、结果如何）',
+            next: { kind: 'note', hint: '若评估结论是"不需要别人改"，请用 status=dropped ＋ note 写明理由' } }
+        }
+        if (status === 'dropped' && !outcome && !note) {
+          return { ok: false, code: 'V5_FEEDBACK_NEEDS_REASON', message: 'status=dropped 需要 note 或 outcome 说明"为什么不改"',
+            next: { kind: 'note', hint: '评估结论也要留痕，否则下一轮会重新提同一件事' } }
+        }
+        const changes = { updatedAt: now(), updatedBy: caller }
+        if (status) changes.status = status
+        if (outcome) changes.outcome = outcome
+        if (a.action !== undefined) changes.action = String(a.action)
+        if (a.assessment !== undefined) changes.assessment = String(a.assessment)
+        if (a.note !== undefined) changes.note = note
+        await patchInstitute({ feedback: (list) => (Array.isArray(list) ? list : []).map((x) => (x.id === id ? Object.assign({}, x, changes) : x)) })
+        const after = feedbackEntries().find((x) => x.id === id) || cur
+        const mirror = await feedbackMirror()
+        return { ok: true, entry: feedbackView(after), mirror, counts: feedbackCounts() }
+      }
+      if (op === 'list') {
+        const category = a.category === undefined ? '' : String(a.category).trim()
+        const route = a.route === undefined ? '' : String(a.route).trim()
+        const all = a.all === true
+        const rows = feedbackEntries()
+          .filter((e) => (!category || e.category === category) && (!route || e.route === route))
+          .filter((e) => all || FEEDBACK_OPEN_STATUSES.indexOf(e.status) !== -1)
+          .map(feedbackView)
+        return { ok: true, openOnly: !all, count: rows.length, entries: rows, counts: feedbackCounts(),
+          note: all ? '全部条目（含已闭环）' : '默认只列未闭环（open|adjusted）；要看全部用 all:true' }
+      }
+      if (op === 'summary') return { ok: true, counts: feedbackCounts() }
+      return { ok: false, code: 'V5_FEEDBACK_BAD_OP', message: 'op 必须是 add|update|list|summary',
+        next: { kind: 'note', hint: 'add=写一条；update=状态流转＋回填；list=看未闭环；summary=按类别/路由计数' } }
+    }
+    /** The per-round line. Deliberately SHORT (P4's lesson: every wake already carries the tool/paper
+     *  tails) and it answers WHY / WHAT / the three routes / what happens next, so recording is explained
+     *  rather than commanded. */
+    function feedbackPushLine(L) {
+      if (!feedbackOn()) return
+      L.push(''
+        + '\n【工作经验／流程反馈（鼓励积极记录）】' + FEEDBACK_DIR + '/'
+        + '\n· 为什么记：怎么一起工作（组织、流程、合作、障碍、摩擦）属于**方法论层**的自我调节；研究结论请进 Progress/ 与 Verified/，这里不记结论。'
+        + '\n· 记什么：类别（合作/管理/流程/障碍/矛盾）＋路由＋情境/现象/影响＋你**已做的调整或建议**；写到多细由你把控。'
+        + '\n· 三条路由：self＝你自己的做法⇒**自己调整，无需谁采纳**；team＝组织/工作流/团队运行的调整⇒**同样无需审批**，觉得不好就及时调整；interpersonal＝**别人造成的、要别人改变才能解决**⇒只有这条要先**缜密评估**"要不要改、改了是否真更优"，并**事后回填验证**。'
+        + '\n· 记了之后：未闭环条目会出现在汇报与总览的计数里；用 vibe_v5_feedback 的 update 回填结果即闭环（interpersonal 必须回填 outcome）。')
     }
-    function paperPushLine(L) { const b = paperHintBlock('zh'); if (b) L.push(b) }
 
     function formalPromptBlock(target) {
       if (!formalOn()) return ''
@@ -4168,7 +4447,7 @@ export function apply(ctx) {
       const expected = Number(args.expected_revision !== undefined ? args.expected_revision : args.expectedRevision)
       if (!Number.isFinite(expected)) return { ok: false, code: 'V5_INVALID_ARGUMENT', message: 'expected_revision is required' }
       if (expected !== task.revision) {
-        // F6 (deep-review 5): this message is routed into Chinese frames (`【框架提示】…`), where a
+        // F6 (deep-review 5): this message is routed into Chinese frames (`【研究所提示】…`), where a
         // raw English diagnostic reads as noise. The CODE stays (`V5_TASK_STALE_REVISION`) and the
         // revision numbers stay, but the sentence is Chinese now for the member reading it.
         return { ok: false, code: 'V5_TASK_STALE_REVISION', message: '任务 ' + id + ' 当前 revision 是 ' + task.revision + '，不是 ' + expected + ' —— 请先用 vibe_v5_task_get 重新读取（code: V5_TASK_STALE_REVISION）' }
@@ -4445,7 +4724,17 @@ export function apply(ctx) {
       if (!rel) return { rel: null, statement: '' }
       const text = (await readTextRel(rel)) || ''
       const m = /##\s*陈述\s*\n([\s\S]*?)(?:\n##\s|$)/.exec(text)
-      return { rel, statement: String(m ? m[1] : text).trim().slice(0, 1200) }
+      const full = String(m ? m[1] : text).trim()
+      // task-24 (real-host R2, D5'): this used to be `.slice(0, 1200)` with NO marker, so a long statement was
+      // cut silently — and the cut text is exactly what voters read and what the verified record carries
+      // (a real host registered statements >1200 chars). Keep a cap as generous as the paper sections
+      // (20000) and, when a cut DOES happen, say so in-band so the reader knows to open the source file.
+      const cap = 20000
+      if (full.length <= cap) return { rel, statement: full }
+      return {
+        rel, truncated: true,
+        statement: full.slice(0, cap) + '\n（注意：陈述超过 ' + cap + ' 字符已截断，完整文本见 ' + rel + '）',
+      }
     }
     // Update one `- 字段:` of a source card. Members hand-write cards in two shapes —
     // one field per line, or one line with '; '-separated fields — so the anchor may
@@ -4881,7 +5170,9 @@ export function apply(ctx) {
       const allVoted = need.length > 0 && need.every((id) => votes[id])
       if (allVoted) await continueVerifyRound(next)
       else await scheduleNext()
-      return { ok: true, voted: memberId, verdict: p, allVoted }
+      // task-25 (real-host R2): an incomplete electorate used to be reported only as `allVoted:false`, so the
+      // caller could not tell WHICH voter was still missing (members probed repeatedly to find out). Name them.
+      return { ok: true, voted: memberId, verdict: p, allVoted, pendingVoters: need.filter((id) => !votes[id]) }
     }
 
     // ---- chat log / meeting plumbing --------------------------------------
@@ -6115,7 +6406,7 @@ export function apply(ctx) {
       if (await fileExistsAbs(paperAbs(id, 'paper.pdf'))) files.push('paper.pdf')
       const warnings = (p.warnings || []).slice()
       if (compile.status === 'failed') warnings.push('LaTeX 编译失败（已保留 paper.tex 与 paper.md，不阻塞定稿）：' + (compile.attempts || []).map((a) => a.engine + '/' + a.label + ' exit=' + a.exitCode + (a.message ? '(' + a.message + ')' : '')).join('；'))
-      if (compile.status === 'not-detected') warnings.push('未检测到 LaTeX 引擎（' + (compile.reason || '') + '）：只交付 paper.tex 与 paper.md。已探测 PATH 与文档化的常见 TeX 根；可用 paperLatexCommand 指定绝对路径。')
+      if (compile.status === 'not-detected') warnings.push('未检测到 LaTeX 引擎（' + (compile.reason || '') + '）：只交付 paper.tex 与 paper.md。已探测 PATH 与文档化的常见 TeX 根；可用 paperLatexCommand 指定绝对路径。最常见的情形是引擎已安装但不在 PATH（Windows 盘根下的 texlive\\<年>\\bin\\windows、类 Unix /usr/local|/opt/texlive/<年>/bin/*、macOS /Library/TeX/texbin 已纳入有界探测）：把引擎的绝对路径写进 paperLatexCommand 再探测一次；仍找不到就如实上报所办（由所办向用户确认安装），随后照旧安全降级。')
       // F6: the failed REQUIRED writes are named ONCE (for this finalisation), before the meta is built,
       // so the warning lands in `meta.warnings`, in the flow log, in the state and in the return value.
       if (writeFailures.length) warnings.push(paperWriteFailureWarning(writeFailures))
@@ -6184,8 +6475,8 @@ export function apply(ctx) {
       const perCap = Math.max(1, Math.floor(Number(params.maxTempPerMember) || 3))
       const totalCap = Math.max(1, Math.floor(Number(params.maxTempTotal) || 12))
       const mine = employedTemps().filter((m) => m.hiredBy === (office ? 'office' : callerId)).length
-      if (mine >= perCap) return { ok: false, code: 'V5_MEMBER_LIMIT', message: '你名下同时最多 ' + perCap + ' 名临时工（先在册 ' + mine + ' 名）；请先解雇不再需要的' }
-      if (employedTemps().length >= totalCap) return { ok: false, code: 'V5_MEMBER_LIMIT', message: '全所同时在册临时工已达上限 ' + totalCap }
+      if (mine >= perCap) return { ok: false, code: 'V5_MEMBER_LIMIT', scope: 'per-member', message: '你名下同时最多 ' + perCap + ' 名临时工（先在册 ' + mine + ' 名）；请先解雇不再需要的' }
+      if (employedTemps().length >= totalCap) return { ok: false, code: 'V5_MEMBER_LIMIT', scope: 'institute', message: '全所同时在册临时工已达上限 ' + totalCap }
       const member = await newMember('temp', {
         direction: purpose, hiredBy: office ? 'office' : callerId, term: String(args.term || ''), provider: pickProvider(),
       })
@@ -6954,7 +7245,7 @@ export function apply(ctx) {
         'compactThreshold', 'compactAfterRounds', 'maxParallel', 'activityTimeoutMs', 'stallAutoMeetingMs',
         'chatDigestMs', 'chatDigestMax', 'meetingKeepEvery', 'leanTimeoutMs']
       const bools = ['academician', 'academicianLeads', 'memberMayRejectAssign', 'finalPaper', 'paperCompilePdf', 'leanAsync']
-      const strs = ['quorumMode', 'provider', 'model', 'staffPersona', 'formalVerify', 'leanCommand',
+      const strs = ['feedback', 'quorumMode', 'provider', 'model', 'staffPersona', 'formalVerify', 'leanCommand',
         'paperFormat', 'paperLanguage', 'paperEditor', 'paperLatexCommand', 'leanInitiative',
         'mathComputation', 'mathMode', 'mathInstallScope']
       const arrs = ['toolAllow', 'toolDeny', 'tempToolAllow', 'tempToolDeny', 'leanArgs', 'leanSearchPaths',
@@ -6990,6 +7281,11 @@ export function apply(ctx) {
       if (out.leanInitiative !== undefined) {
         out.leanInitiative = ['off', 'normal', 'eager'].indexOf(String(out.leanInitiative)) !== -1 ? String(out.leanInitiative) : 'normal'
       }
+      // `feedback` is a CLOSED enum too: a typo must keep the documented default ('on') rather than
+      // becoming an unreachable third mode that silently disables the recording hint.
+      if (out.feedback !== undefined) {
+        out.feedback = ['on', 'off'].indexOf(String(out.feedback).trim()) !== -1 ? String(out.feedback).trim() : 'on'
+      }
       // Concurrency floor, same discipline as quorumCap/verdictMaxRounds.
       if (out.leanJobsMaxParallel !== undefined && out.leanJobsMaxParallel < 1) out.leanJobsMaxParallel = 1
       // The six math_computation keys are normalised by the SHARED module (one implementation
@@ -7070,6 +7366,17 @@ export function apply(ctx) {
     async function setParams(input) {
       const droppedSet = []
       const patch = normalizeParams(input || {}, droppedSet)
+      // task-26 (real-host R2): an out-of-range value is coerced by normalizeParams (documented) and an unknown
+      // key is dropped into `droppedSet` (recorded in diagnostics) — but the RESPONSE carried neither, so the
+      // caller could not tell "changed" from "ignored" without a second `status` read. Report both, additively.
+      const adjusted = {}
+      for (const k of Object.keys(patch)) {
+        const raw = (input || {})[k]
+        if (raw === undefined) continue
+        const before = Array.isArray(raw) ? raw.join(',') : String(raw)
+        const after = Array.isArray(patch[k]) ? patch[k].join(',') : String(patch[k])
+        if (before !== after) adjusted[k] = { from: raw, to: patch[k] }
+      }
       reportDroppedStateKeys(inst(), droppedSet, 'set')
       const merged = Object.assign({}, params, patch)
       await patchInstitute({ params: merged })
@@ -7081,7 +7388,7 @@ export function apply(ctx) {
       // activityTimeoutMs (or a raised maxParallel) would not take effect until some
       // unrelated event drove a pass. Tuning must apply immediately.
       if (running && !autoDone) await scheduleNext()
-      return { ok: true, params: visibleParams() }
+      return { ok: true, params: visibleParams(), adjusted, dropped: droppedSet.slice() }
     }
     function visibleParams() {
       return {
@@ -7105,6 +7412,8 @@ export function apply(ctx) {
         mathComputation: params.mathComputation, mathMode: params.mathMode,
         mathEngines: (params.mathEngines || []).slice(), mathTimeoutMs: params.mathTimeoutMs,
         mathPackages: (params.mathPackages || []).slice(), mathInstallScope: params.mathInstallScope,
+        // 'on' | 'off' — methodology/collaboration feedback (Shared/Feedback/).
+        feedback: params.feedback,
         // ── final paper ──────────────────────────────────────────────────────
         finalPaper: params.finalPaper, paperFormat: params.paperFormat,
         paperLanguage: params.paperLanguage, paperCompilePdf: params.paperCompilePdf,
@@ -7450,8 +7759,8 @@ export function apply(ctx) {
         // payload, so a reader (or an operator comparing two sessions) cannot mistake them for
         // durable state. Durable = derived from the state file; session = rebuilt on load.
         fieldScopes: {
-          session: ['running', 'autoDone(session mirror of phase)', 'leanNotices', 'debug', 'members[].rounds', 'members[].busy', 'members[].contextPct', 'members[].childId', 'meeting', 'parkedMeeting', 'persistence.writeFailures', 'persistence.prematureReads', 'persistence.loadProblem', 'pendingSpawns[].attempts'],
-          durable: ['phase', 'runId', 'quorum', 'members[] (except the three session fields)', 'members[].failReason', 'tasks', 'failedMembers', 'pendingSpawns[] (derived from durable failed members)', 'chat', 'officeRequests', 'verify', 'verifyQueue', 'verified', 'undecided', 'solveVotes', 'formal', 'paper', 'lastProgressAt', 'params'],
+          session: ['running', 'autoDone(session mirror of phase)', 'leanNotices', 'debug', 'members[].rounds', 'members[].busy', 'members[].contextPct', 'members[].childId', 'meeting', 'parkedMeeting', 'persistence.writeFailures', 'persistence.prematureReads', 'persistence.loadProblem', 'pendingSpawns[].attempts', 'diagnostics', 'backend'],
+          durable: ['phase', 'runId', 'quorum', 'members[] (except the three session fields)', 'members[].failReason', 'tasks', 'failedMembers', 'pendingSpawns[] (derived from durable failed members)', 'chat', 'officeRequests', 'verify', 'verifyQueue', 'verified', 'verifiedTrue (derived from verdicts)', 'concludedFalse (derived from verdicts)', 'undecided (derived from verdicts)', 'verdicts', 'solve', 'solveVotes', 'formal', 'paper', 'lastProgressAt', 'params'],
         },
         backend: backend ? backend.kind : 'uninitialized',
         // Skipped/malformed events AND state-file load problems. Without this the two
@@ -7694,6 +8003,25 @@ export function apply(ctx) {
       // not a refusal: v5 cannot change the host's fence, and refusing would stop persisting work.
       if (sandboxPolicyMismatch) L.push('- ⚠ 沙箱策略根与会话工作目录不一致：策略=' + sandboxPolicyMismatch.policyRoot + '｜会话=' + sandboxPolicyMismatch.expected
         + '（v5 用会话工作目录拼所有路径；若宿主按策略根解析写操作，产物可能落在预期之外的那棵树——请核对 sandbox 策略的 workspaceRoot）')
+      // Methodology/collaboration feedback: the numbers an operator (and the academician's periodic
+      // summary) needs to see whether the loop is actually being USED and closed — not just collected.
+      L.push('')
+      L.push('## 反馈库（方法论／协作层；不是研究结论）')
+      {
+        const fc = feedbackCounts()
+        L.push('- 条目 ' + fc.total + '｜未闭环 ' + fc.open + '｜已闭环 ' + fc.closed
+          + '｜按类别：' + FEEDBACK_CATEGORIES.map((c) => c + '=' + fc.byCategory[c]).join('、')
+          + '（' + FEEDBACK_CATEGORIES.map((c) => FEEDBACK_CATEGORY_LABELS[c]).join('/') + '）'
+          + '｜按路由：' + FEEDBACK_ROUTES.map((r) => r + '=' + fc.byRoute[r]).join('、'))
+        if (!feedbackOn()) {
+          L.push('- 反馈开关：off（提示词不注入该段；写入请求会被具名拒绝）')
+        } else {
+          const openRows = feedbackEntries().filter((e) => FEEDBACK_OPEN_STATUSES.indexOf(e.status) !== -1)
+          const inter = openRows.filter((e) => e.route === 'interpersonal')
+          L.push('- 未闭环 ' + openRows.length + ' 条' + (inter.length ? '｜其中 interpersonal（需评估＋事后回填）：' + inter.map((e) => e.id + '(by ' + e.by + ')').join('、') : ''))
+          L.push('- 文件镜像：' + FEEDBACK_DIR + '/（按类别分文件）｜明细：vibe_v5_feedback {op:\'list\'}')
+        }
+      }
       return { ok: true, report: L.join('\n'), quorum: qv }
     }
     // Adding/removing a PERMANENT researcher is a change to the institute's public
@@ -7770,6 +8098,8 @@ export function apply(ctx) {
       maybeQueueVerify, castVerdict, currentVerify, hasVerifyInFlight, startMeeting, quorumM, voterCount,
       // final paper (docs/final-paper.md; the phase runs BEFORE finishRun)
       startPaper, paperStatus: paperSummary, finalizePaperByOffice,
+      // methodology/collaboration feedback (Shared/Feedback/): the tool handler + the observers
+      feedbackOn, feedbackCounts, feedbackTool,
       // authorization helpers (used by tool handlers)
       memberIdOfAgent, isOffice, isAcademician, isProvablyOffice, officeCaller, memberById, activeMembers,
       // diagnosis helpers (defects 1/2 of the architecture self-test)
@@ -7893,7 +8223,7 @@ export function apply(ctx) {
   registerTool('vibe_v5_stop', 'Stop the institute: interrupt every member, clear coordination state, and release their child sessions.', objParams({}), (s, a, x) => withOffice(s, x, 'stop the institute', () => s.initStop()))
   registerTool('vibe_v5_status', 'Machine-readable institute status (members, tasks, quorum, meetings, verification, mail).', objParams({}), (s) => s.status())
   registerTool('vibe_v5_report', 'Human-readable institute report (staffing, tasks, consensus, meetings, file locations).', objParams({}), (s) => s.report())
-  registerTool('vibe_v5_set', 'Tune institute parameters (persisted in State/<institute>.v5state.json). provider/model override staff LLM routes (empty = inherit the office route). toolAllow/toolDeny restrict PERMANENT staff tools; tempToolAllow/tempToolDeny restrict temp workers. quorumCap sets m = min(quorumCap, voters); an m-vote passes only when at least m Boolean votes (exactly 1 or exactly 0) exist AND no voter returns an opposing Boolean, so with the default roster it degenerates to unanimity among the current voters; only current voters count (a dismissed member\'s earlier ballot is dropped). quorumMode "m-unanimous" (v5) or "all-unanimous" (v4 legacy). formalVerify: "off" (default, no extra requirement) | "encourage" (agents decide by implementation difficulty whether to formalize in Lean; a passing Lean run turns the vote into a FIDELITY review of the Lean statements) | "require" (same, plus a gate: a true/false verdict is withheld as undecided until the object is Lean-passed or has an explicit reasoned blocker record). LEAN TOOLCHAIN: leanCommand names the Lean executable (e.g. "lake" with leanArgs ["env","lean"]); leanArgs are inserted before the file name (the framework appends --search-path <VibeMath root> unless leanArgs already sets one); leanTimeoutMs is the per-run budget in ms (>=1000, and the per-job budget of the async queue). FINAL PAPER: finalPaper (default true) writes the final paper when the run concludes — the paper phase runs BEFORE the run is marked complete, the permanent staff write their own part, cross-review each other, and the editor named by paperEditor finalises; paperFormat "both"|"md"|"tex"; paperLanguage "zh"|"en"; paperCompilePdf compiles a PDF when a LaTeX engine is detected; paperEditor "academician" (default, the only editor an unattended run can reach) | "office" (manual /v5 paper only — the office must first consult the whole institute: >=1 office message AND >=1 meeting, recorded in the finalisation note); paperLatexCommand forces one engine command instead of auto-detection (empty = auto: xelatex -> latexmk -> pdflatex -> lualatex -> tectonic, English prefers pdflatex). LEAN ASYNC: leanAsync (default true) compiles on a per-session background queue (vibe_v5_lean_run / vibe_v5_lean_archive run=true enqueue and return immediately; inspect them with vibe_v5_lean_job or vibe_v5_lean_lib.jobs and wait with vibe_v5_lean_job {jobId,waitMs}); leanAsync=false restores the previous synchronous behaviour. Only a settled job (exit 0, unchanged content hash AND the same build context) may mark an object passed; a job id is the content+build-context digest. leanInitiative "off"|"normal" (default)|"eager" separates DAILY eagerness about formalizing from formalVerify (which stays the verdict-time requirement). leanSearchPaths (string[]) adds extra --search-path roots before the automatic VibeMath root (deduped; an explicit --search-path/-R/--root in leanArgs wins). leanJobsMaxParallel (default 1) caps simultaneous background compiles. MATH COMPUTATION: mathComputation "off"|"auto" (default)|"on" gates the math_computation tool; mathMode "typed+shell" (default: the host shell may be used as a fallback, but a shell run carries no receipt and its conclusion must be marked 未经工具归档/not tool-archived) | "typed" (never mention the shell; engine=cli is refused); mathEngines lists the allowed engines (cli is on by default, SageMath is a later phase); mathTimeoutMs is the per-run budget (>=1000); mathPackages are packages a computation may require; mathInstallScope "user" (default) | "system" (per call only, never remembered). Installs are two-step (plan then confirm-token) and commercial engines are never installed. Unknown spellings of these enums fall back to the documented default.', objParams({
+  registerTool('vibe_v5_set', 'Tune institute parameters (persisted in State/<institute>.v5state.json). provider/model override staff LLM routes (empty = inherit the office route). toolAllow/toolDeny restrict PERMANENT staff tools; tempToolAllow/tempToolDeny restrict temp workers. quorumCap sets m = min(quorumCap, voters); an m-vote passes only when at least m Boolean votes (exactly 1 or exactly 0) exist AND no voter returns an opposing Boolean, so with the default roster it degenerates to unanimity among the current voters; only current voters count (a dismissed member\'s earlier ballot is dropped). quorumMode "m-unanimous" (v5) or "all-unanimous" (v4 legacy). formalVerify: "off" (default, no extra requirement) | "encourage" (agents decide by implementation difficulty whether to formalize in Lean; a passing Lean run turns the vote into a FIDELITY review of the Lean statements) | "require" (same, plus a gate: a true/false verdict is withheld as undecided until the object is Lean-passed or has an explicit reasoned blocker record). LEAN TOOLCHAIN: leanCommand names the Lean executable (e.g. "lake" with leanArgs ["env","lean"]); leanArgs are inserted before the file name (the framework appends -R <VibeMath root> unless leanArgs already sets one); leanTimeoutMs is the per-run budget in ms (>=1000, and the per-job budget of the async queue). FINAL PAPER: finalPaper (default true) writes the final paper when the run concludes — the paper phase runs BEFORE the run is marked complete, the permanent staff write their own part, cross-review each other, and the editor named by paperEditor finalises; paperFormat "both"|"md"|"tex"; paperLanguage "zh"|"en"; paperCompilePdf compiles a PDF when a LaTeX engine is detected; paperEditor "academician" (default, the only editor an unattended run can reach) | "office" (manual /v5 paper only — the office must first consult the whole institute: >=1 office message AND >=1 meeting, recorded in the finalisation note); paperLatexCommand forces one engine command instead of auto-detection (empty = auto: xelatex -> latexmk -> pdflatex -> lualatex -> tectonic, English prefers pdflatex). LEAN ASYNC: leanAsync (default true) compiles on a per-session background queue (vibe_v5_lean_run / vibe_v5_lean_archive run=true enqueue and return immediately; inspect them with vibe_v5_lean_job or vibe_v5_lean_lib.jobs and wait with vibe_v5_lean_job {jobId,waitMs}); leanAsync=false restores the previous synchronous behaviour. Only a settled job (exit 0, unchanged content hash AND the same build context) may mark an object passed; a job id is the content+build-context digest. leanInitiative "off"|"normal" (default)|"eager" separates DAILY eagerness about formalizing from formalVerify (which stays the verdict-time requirement). leanSearchPaths (string[]) adds extra compiler search roots before the automatic VibeMath root (deduped; an explicit -R/--root in leanArgs wins). leanJobsMaxParallel (default 1) caps simultaneous background compiles. MATH COMPUTATION: mathComputation "off"|"auto" (default)|"on" gates the math_computation tool; mathMode "typed+shell" (default: the host shell may be used as a fallback, but a shell run carries no receipt and its conclusion must be marked 未经工具归档/not tool-archived) | "typed" (never mention the shell; engine=cli is refused); mathEngines lists the allowed engines (cli is on by default, SageMath is a later phase); mathTimeoutMs is the per-run budget (>=1000); mathPackages are packages a computation may require; mathInstallScope "user" (default) | "system" (per call only, never remembered). Installs are two-step (plan then confirm-token) and commercial engines are never installed. Unknown spellings of these enums fall back to the documented default. feedback (default "on") = the methodology/collaboration feedback library (Shared/Feedback/): "on" records entries and injects a short per-round hint; "off" injects nothing and refuses every write BY NAME (a switch, not a severity).', objParams({
     academician: B, academicianLeads: B, memberMayRejectAssign: B, researcherCount: I,
     quorumCap: I, quorumMode: S, verdictMaxRounds: I,
     maxTempPerMember: I, maxTempTotal: I,
@@ -7907,6 +8237,7 @@ export function apply(ctx) {
     mathMode: { type: 'string', enum: ['typed', 'typed+shell'] },
     mathEngines: SA, mathTimeoutMs: I, mathPackages: SA,
     mathInstallScope: { type: 'string', enum: ['user', 'system'] },
+    feedback: { type: 'string', enum: ['on', 'off'] },
     finalPaper: B, paperFormat: { type: 'string', enum: ['both', 'md', 'tex'] },
     paperLanguage: { type: 'string', enum: ['zh', 'en'] },
     paperCompilePdf: B, paperEditor: { type: 'string', enum: ['office', 'academician'] }, paperLatexCommand: S,
@@ -7984,6 +8315,7 @@ export function apply(ctx) {
   })
   registerTool('vibe_v5_record_progress', '(member) Append to YOUR progress.md — your research log. Include what you tried, the routes and their obstacles, your current state, your plans, and failed/dead ends (they save the institute from repeating them).', objParams({ content: S }, ['content']), (s, a, x) => s.publishProgress(s.memberIdOfAgent(x), a.content))
   registerTool('vibe_v5_record_proposition', '(member) Record a proposition/lemma in your library. REQUIRES value (价值程度), motive (动机用途计划) and p (your probability that it is true).', objParams({ id: S, title: S, statement: S, value: N, motive: S, p: N }, ['statement', 'value', 'motive', 'p']), (s, a, x) => s.recordCard(s.memberIdOfAgent(x), 'proposition', a))
+  registerTool('vibe_v5_feedback', '(member) 工作经验／流程反馈库（Shared/Feedback/，方法论/协作层——不是研究结论）。op=add（写一条，需 category/route/phenomenon/impact/action；route=interpersonal 还必须带 assessment）| update（状态流转＋回填结果：id/status/outcome/note）| list（默认只看未闭环，可用 category/route 过滤，all:true 看全部）| summary（按类别/路由计数）。类别：cooperation 合作｜management 管理｜process 流程｜obstacle 障碍｜conflict 矛盾。路由：self 自己调整即可｜team 组织/工作流同样无需审批｜interpersonal 只有这条必须先评估、再事后回填验证。权限：成员/临时工可 add 且只能更新自己发起的条目；所办可更新任何条目。', objParams({ op: S, id: S, category: S, route: S, context: S, phenomenon: S, impact: S, action: S, assessment: S, outcome: S, status: S, note: S, all: B }, ['op']), (s, a, x) => withCaller(s, x, '使用反馈库', (caller) => s.feedbackTool(caller, a)))
   registerTool('vibe_v5_record_method', '(member) Record a theory/method/tool in your library. REQUIRES value, motive and p.', objParams({ id: S, title: S, type: S, content: S, notation: S, value: N, motive: S, p: N }, ['content', 'value', 'motive', 'p']), (s, a, x) => s.recordCard(s.memberIdOfAgent(x), 'method', a))
   registerTool('vibe_v5_record_subproblem', '(member) Record a sub-problem in your library. REQUIRES value, motive and p.', objParams({ id: S, title: S, statement: S, value: N, motive: S, p: N }, ['statement', 'value', 'motive', 'p']), (s, a, x) => s.recordCard(s.memberIdOfAgent(x), 'subproblem', a))
   registerTool('vibe_v5_read_library', '(member) Read anyone\'s library (read-only): their progress and recorded cards. Omit member to read everyone.', objParams({ member: S, kind: S, id: S }), (s, a) => s.readLibrary(a))
@@ -8029,6 +8361,19 @@ export function apply(ctx) {
       if (todo.length) parts.push('- 形式化待办（定论被搁置）：' + todo.map((t) => t.id).join('、') + '（见 Formal/TODO.md）')
       parts.push('- 可复用库：vibe_v5_lean_lib 可列出 Formal/Lib 与 Formal/Proved')
     }
+    // Methodology/collaboration feedback: the academician's periodic summary needs the SAME numbers the
+    // report shows, so "what did we learn about working together" is one glance away (and open
+    // interpersonal entries — the only route that needs a written-back verification — are named).
+    parts.push('## 反馈库（方法论／协作层）')
+    {
+      const fc = s.feedbackCounts()
+      parts.push('- 条目 ' + fc.total + '｜未闭环 ' + fc.open + '｜已闭环 ' + fc.closed
+        + '｜按类别：' + Object.keys(fc.byCategory).map((k) => k + '=' + fc.byCategory[k]).join('、')
+        + '｜按路由：' + Object.keys(fc.byRoute).map((k) => k + '=' + fc.byRoute[k]).join('、'))
+      parts.push(s.feedbackOn()
+        ? '- 未闭环明细用 vibe_v5_feedback {op:\'list\'}；interpersonal 条目必须回填 outcome 才算闭环'
+        : '- 反馈开关：off（提示词不注入该段；写入请求会被具名拒绝）')
+    }
     parts.push('## 停滞提示')
     const idleFor = Date.now() - st.lastProgressAt
     parts.push('- 距上次实质进展：' + Math.round(idleFor / 1000) + ' 秒')
@@ -8043,7 +8388,7 @@ export function apply(ctx) {
   // dynamic registration would depend on a runtime knob and break the effect discipline),
   // while the MODE only decides whether the framework TELLS members about them. In 'off'
   // mode they still work if a human or agent calls them deliberately.
-  registerTool('vibe_v5_lean_run', '(member) Execute the Lean toolchain on one .lean file inside the workspace and report the result. Parameters: file (required; `Formal/x.lean` or the full CWD-relative path — both name the same file), target (optional object id to record the run against), timeout_ms (optional per-run budget). There is NO run/run=false switch here — run-vs-archive are separate tools; use vibe_v5_lean_archive {run:false} to archive WITHOUT compiling. With leanAsync (default true) the compile is ENQUEUED and this returns immediately with async:{jobId,state} — nothing is compiled yet; the result is durable at Formal/Jobs/<jobId>.json (vibe_v5_lean_job {jobId} reads it), is listed by vibe_v5_lean_lib.jobs, and the initiator also gets ONE 【形式化结果】 announcement in its next round. With leanAsync=false it blocks and returns the compiler output (exitCode/stdout/stderr). Never throws: a host with no subprocess service returns NO_SUBPROCESS and a missing toolchain returns LEAN_NOT_FOUND (in both cases the code can still be written down with vibe_v5_lean_archive), a timeout terminates the process and returns LEAN_TIMEOUT. The framework appends `--search-path <VibeMath root>` before the file name (unless leanArgs already sets a search root).', objParams({ file: S, target: S, timeout_ms: I }, ['file']), (s, a, x) => withCaller(s, x, 'a Lean run', (caller) => s.leanRunTool(caller, a)))
+  registerTool('vibe_v5_lean_run', '(member) Execute the Lean toolchain on one .lean file inside the workspace and report the result. Parameters: file (required; `Formal/x.lean` or the full CWD-relative path — both name the same file), target (optional object id to record the run against), timeout_ms (optional per-run budget). There is NO run/run=false switch here — run-vs-archive are separate tools; use vibe_v5_lean_archive {run:false} to archive WITHOUT compiling. With leanAsync (default true) the compile is ENQUEUED and this returns immediately with async:{jobId,state} — nothing is compiled yet; the result is durable at Formal/Jobs/<jobId>.json (vibe_v5_lean_job {jobId} reads it), is listed by vibe_v5_lean_lib.jobs, and the initiator also gets ONE 【形式化结果】 announcement in its next round. With leanAsync=false it blocks and returns the compiler output (exitCode/stdout/stderr). Never throws: a host with no subprocess service returns NO_SUBPROCESS and a missing toolchain returns LEAN_NOT_FOUND (in both cases the code can still be written down with vibe_v5_lean_archive), a timeout terminates the process and returns LEAN_TIMEOUT. The framework appends `-R <VibeMath root>` before the file name (unless leanArgs already sets a search root).', objParams({ file: S, target: S, timeout_ms: I }, ['file']), (s, a, x) => withCaller(s, x, 'a Lean run', (caller) => s.leanRunTool(caller, a)))
   registerTool('vibe_v5_lean_archive', '(member) Archive Lean code. kind="def": a REUSABLE definition/object/assumption → the global cross-project library (Formal/Lib). kind="lemma": a machine-checked lemma → Formal/Proved. kind="proof": the formal proof of a project object → Formal/<target>.lean, and (only once the queued compile settles ok) also Verified/Lean/<target>.lean, marking the object Lean-passed. Re-archiving IDENTICAL content is de-duplicated (deduped:true, no rewrite/recompile). kind="blocked": record an explicit, reasoned "cannot/not worth formalizing" decision (note required). Optional `run` (default true): whether to COMPILE after writing — `run:false` archives the text only (useful when this host has no toolchain; the object then stays `attempted`/unset until something compiles it).', objParams({ kind: { type: 'string', enum: ['def', 'lemma', 'proof', 'blocked'] }, name: S, target: S, content: S, from: S, note: S, run: B }, ['kind']), (s, a, x) => withCaller(s, x, 'a Lean archive', (caller) => s.leanArchive(caller, a)))
   registerTool('vibe_v5_lean_lib', '(member) List (and by default rebuild) the Lean reuse library: your institute\'s Formal/Index.md (with an import-dependency column), plus the global cross-project Formal/Lib and Formal/Proved indexes, the background-compile jobs (jobs) and the injected search path (paths.searchPath). Look here BEFORE writing a new definition so you reuse instead of redefining.', objParams({ refresh: B }), async (s, a) => {
     const r = a && a.refresh === false ? { lib: null, proved: null, objects: Object.keys(s.formalRecords()).length } : await s.rebuildLeanLibIndexes()