@bolloon/bolloon-agent 0.3.27 → 0.3.28

package/dist/bootstrap/context-os.js

@@ -0,0 +1,213 @@
+/**
+ * context-os.ts — Context OS 资产层 (2026-08-03, P5)
+ *
+ * 把 Ziye-Context-OS 的 12+3 层文件夹体系落地到 Bolloon:
+ *   ~/.bolloon/context-os/
+ *     01-Me ~ 12-Analysis + output / research / tmp
+ *
+ * 每层回答一种问题 (Context OS §3):
+ *   01-Me 我是谁 / 02-Network 我认识谁 / 03-Current 我现在在做什么
+ *   04-Projects 我正在推进什么 / 05-Prompts 哪些提示词已验证
+ *   06-Protocols AI 和系统该如何工作 / 07-Knowledge 哪些知识跨项目复用
+ *   08-Insights 哪些判断改变决策 / 09-Tools 哪些工具省时间
+ *   10-Skills 哪些能力可验证 / 11-Write 哪些表达可复用
+ *   12-Analysis 决策过程与复盘 / output 对外交付 / research 中间成果 / tmp 一次性草稿
+ *
+ * 价值判断标准 (Context OS §5): 每个资产进入前回答"未来哪个具体场景会用到它?".
+ * 回答不出 = 噪音, 不该进正式层.
+ *
+ * 设计 (减法):
+ *   - 每层一个 README.md 声明职责边界 (存什么/不该存什么/典型用途)
+ *   - 资产文件: <ts>-<slug>.md, frontmatter v2 (stage0 = 临时价值点, 与 judgeness 生命周期对应)
+ *   - 写操作失败静默, 不阻塞主对话
+ */
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+export const CONTEXT_OS_LAYERS = [
+    { key: '01-Me', name: '我是谁', store: '经过验证的原则、不可碰的边界、稳定偏好', notStore: '临时情绪、未经验证的念头', usage: '防止 AI 用错误的方式帮助你' },
+    { key: '02-Network', name: '我认识谁', store: '有真实关系、能力可定位、能在具体问题上调用的人', notStore: '只看过主页的陌生人', usage: '需要咨询、合作、求证时找到正确的人' },
+    { key: '03-Current', name: '我现在在做什么', store: '今天/本周的现实状态、工作现场、阻塞项', notStore: '长期知识、项目历史全文', usage: '防止 AI 按过期状态给建议' },
+    { key: '04-Projects', name: '我正在推进什么', store: '有明确交付、真实进度、可验证证据的项目', notStore: '只有想法的脑暴', usage: '让 AI 按项目真实边界推进' },
+    { key: '05-Prompts', name: '已验证可复用的提示词', store: '至少复用过、效果稳定的 Prompt', notStore: '一次性调试 Prompt', usage: '跨项目、跨工具复用工作方法' },
+    { key: '06-Protocols', name: 'AI 和系统该如何工作', store: '为防止真实错误而产生、被重复调用的规则', notStore: '纯理论流程', usage: '把"知道"变成"每次都会做"' },
+    { key: '07-Knowledge', name: '哪些领域知识未来复用', store: '未来至少三个项目可能复用的领域理解', notStore: '随手可搜的常识', usage: '技术/行业问题的长期积累' },
+    { key: '08-Insights', name: '哪些已验证的判断改变决策', store: '能改变决策、产品方向或自我认知的已验证判断', notStore: '情绪碎片、未经验证的直觉', usage: '防止重复踩同一种坑' },
+    { key: '09-Tools', name: '哪些工具和脚本省时间', store: '实际用过、能节约时间、包含回退方案的工具经验', notStore: '只安装未使用的软件', usage: '提升执行效率，避免重复试错' },
+    { key: '10-Skills', name: '哪些能力可验证交付', store: '可外部验证、能交付、有作品支撑的能力', notStore: '"我想学"的愿望', usage: '简历、分工、能力缺口识别' },
+    { key: '11-Write', name: '哪些写作可复用', store: '可以引用、改写、发布的成熟表达', notStore: '未整理草稿', usage: '保持跨场景表达一致' },
+    { key: '12-Analysis', name: '决策过程与复盘', store: '有推理链、可事后复盘的研究与决策', notStore: '只有结论的事后合理化', usage: '重要决策可追溯、可修正' },
+    { key: 'output', name: '对外交付物', store: '给外部的人看的最终交付物', notStore: '内部草稿', usage: '可直接分享给他人' },
+    { key: 'research', name: '研究中间成果', store: '研究中的中间成果', notStore: '结论已定型的资产', usage: '未完成研究的暂存' },
+    { key: 'tmp', name: '一次性草稿', store: '一次性草稿与临时文件', notStore: '任何未来要复用的东西', usage: '定期清理' },
+];
+const LAYER_KEYS = new Set(CONTEXT_OS_LAYERS.map((l) => l.key));
+// ============================================================
+// 路径
+// ============================================================
+export function getContextOsRoot(home = os.homedir()) {
+    return path.join(home, '.bolloon', 'context-os');
+}
+export function getLayerDir(layer, home = os.homedir()) {
+    return path.join(getContextOsRoot(home), layer);
+}
+/** 校验 layer 合法; 非法返回 null */
+export function resolveLayer(layer) {
+    const key = String(layer || '').trim();
+    return LAYER_KEYS.has(key) ? CONTEXT_OS_LAYERS.find((l) => l.key === key) : null;
+}
+function slugify(s) {
+    return s.replace(/[^a-zA-Z0-9\u4e00-\u9fa5_-]/g, '_').slice(0, 40) || 'untitled';
+}
+// ============================================================
+// 初始化: 建目录 + 每层 README (幂等)
+// ============================================================
+function layerReadme(l) {
+    return `# ${l.key} — ${l.name}
+
+## 这一层回答的问题
+${l.name}
+
+## 存什么
+${l.store}
+
+## 不该存什么
+${l.notStore}
+
+## 典型用途
+${l.usage}
+
+## 价值判断标准 (Context OS §5)
+写入前先回答: **未来哪个具体场景会用到它?**
+回答不出 = 噪音, 留在 tmp/, 不进正式层.
+
+## 价值生命周期
+阶段0 临时价值点 (对话中刚出现, 未验证) → 阶段1 验证 (被使用/确认)
+→ 阶段2 固化 (本层唯一位置) → 阶段3 索引化 (高频引用) → 阶段4 归档/删除.
+`;
+}
+export async function ensureContextOsDirs(home) {
+    const root = getContextOsRoot(home);
+    await fs.mkdir(root, { recursive: true });
+    for (const l of CONTEXT_OS_LAYERS) {
+        const dir = getLayerDir(l.key, home);
+        await fs.mkdir(dir, { recursive: true });
+        const readmePath = path.join(dir, 'README.md');
+        try {
+            await fs.access(readmePath);
+        }
+        catch {
+            await fs.writeFile(readmePath, layerReadme(l), 'utf-8');
+        }
+    }
+}
+/**
+ * 写入资产到指定层.
+ * 文件名: <ts>-<slug>.md; frontmatter v2 (stage0 = 临时价值点, 待验证).
+ * 幂等: 同层同 slug 已存在 → 跳过 (不重复造文件, Context OS §6 Step3).
+ */
+export async function writeContextAsset(input, home) {
+    const layer = resolveLayer(input.layer);
+    if (!layer) {
+        return { ok: false, error: `layer 非法: '${input.layer}'. 合法: ${CONTEXT_OS_LAYERS.map((l) => l.key).join(' / ')}` };
+    }
+    const title = String(input.title || '').trim();
+    if (!title)
+        return { ok: false, error: 'title 必填' };
+    const content = String(input.content || '').trim();
+    if (!content)
+        return { ok: false, error: 'content 必填' };
+    await ensureContextOsDirs(home);
+    const now = new Date().toISOString();
+    const ts = Date.now();
+    const slug = slugify(title);
+    const fileName = `${ts}-${slug}.md`;
+    const filePath = path.join(getLayerDir(layer.key, home), fileName);
+    // 幂等: 同 slug 已存在 → 跳过
+    try {
+        const files = await fs.readdir(getLayerDir(layer.key, home));
+        if (files.some((f) => f.endsWith(`-${slug}.md`))) {
+            return { ok: true, skipped: true, error: `同标题资产已存在 (${slug}.md), 未重复写入` };
+        }
+    }
+    catch { /* 目录不存在, 继续 */ }
+    const fm = [
+        '---',
+        `title: ${title.replace(/[\n\r]/g, ' ').slice(0, 80)}`,
+        `source: session`,
+        `created: ${now}`,
+        `layer: ${layer.key}`,
+        `stage: stage0`,
+        `tags: [${(input.tags || []).map((t) => t.replace(/[^\w\u4e00-\u9fa5-]/g, '')).filter(Boolean).join(', ')}]`,
+        input.domain ? `domain: ${input.domain.replace(/[\n\r]/g, ' ').slice(0, 40)}` : '',
+        'schema_version: 2',
+        '---',
+        '',
+        content,
+    ].filter(Boolean).join('\n');
+    try {
+        await fs.writeFile(filePath, fm, 'utf-8');
+        return {
+            ok: true,
+            asset: { layer: layer.key, file: fileName, title, path: filePath, createdAt: now, stage: 'stage0' },
+        };
+    }
+    catch (e) {
+        return { ok: false, error: `写入失败: ${e?.message || String(e)}` };
+    }
+}
+/** 列出层资产; layer 为空 → 全层汇总 */
+export async function readContextAssets(layer, keyword, home) {
+    const root = getContextOsRoot(home);
+    const kw = String(keyword || '').trim().toLowerCase();
+    const wanted = layer ? [resolveLayer(layer)].filter(Boolean).map((l) => l.key) : CONTEXT_OS_LAYERS.map((l) => l.key);
+    const out = [];
+    for (const key of wanted) {
+        const l = resolveLayer(key);
+        try {
+            const files = (await fs.readdir(getLayerDir(key, home))).filter((f) => f.endsWith('.md') && f !== 'README.md');
+            const entries = [];
+            for (const f of files) {
+                try {
+                    const raw = await fs.readFile(path.join(getLayerDir(key, home), f), 'utf-8');
+                    const titleM = raw.match(/^title:\s*(.+)$/m);
+                    const createdM = raw.match(/^created:\s*(.+)$/m);
+                    const title = titleM ? titleM[1].trim() : f.replace(/\.md$/, '');
+                    if (kw && !(title.toLowerCase().includes(kw) || raw.toLowerCase().includes(kw)))
+                        continue;
+                    entries.push({ file: f, title, createdAt: createdM ? createdM[1].trim() : '' });
+                }
+                catch { /* 单文件损坏跳过 */ }
+            }
+            entries.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+            out.push({ layer: key, name: l.name, fileCount: entries.length, files: entries.slice(0, 20) });
+        }
+        catch {
+            out.push({ layer: key, name: l.name, fileCount: 0, files: [] });
+        }
+    }
+    return out;
+}
+/** 读取单篇资产正文 (供工具输出完整内容) */
+export async function readAssetBody(layer, file, home) {
+    const l = resolveLayer(layer);
+    if (!l)
+        return { ok: false, error: `layer 非法: '${layer}'` };
+    const safeFile = path.basename(String(file || '').replace(/[^\w\u4e00-\u9fa5.-]/g, '_'));
+    if (!safeFile.endsWith('.md'))
+        return { ok: false, error: 'file 必须是 .md' };
+    try {
+        const raw = await fs.readFile(path.join(getLayerDir(l.key, home), safeFile), 'utf-8');
+        return { ok: true, body: raw };
+    }
+    catch (e) {
+        return { ok: false, error: `读取失败: ${e?.message || String(e)}` };
+    }
+}
+/** 层 → 上下文注入摘要 (给 LLM 的资产层目录) */
+export function formatLayerListing(listings) {
+    if (listings.length === 0)
+        return '';
+    const lines = listings.map((l) => `  - ${l.layer} (${l.name}): ${l.fileCount} 篇` + (l.files.length > 0 ? ` — ${l.files.slice(0, 3).map((f) => f.title).join(' / ')}` : ''));
+    return `[系统上下文] 资产层 (Context OS 12+3 层, 先看 03-Current 再按任务路由):\n${lines.join('\n')}\n\n`;
+}

package/dist/bootstrap/lifecycle-hooks.js

@@ -9,7 +9,7 @@ import * as os from 'os';
 import * as path from 'path';
 import { getCachedBolloonContext, clearBolloonContextCache } from './context-collector.js';
 import { formatContextForSystemPrompt } from './project-context.js';
-import { loadPersonaDocs, formatPersonaForSystemPrompt } from './persona-loader.js';
+import { loadPersonaDocs, formatPersonaForSystemPrompt, loadPersonaJudgmentDeclaration, formatJudgmentDeclaration } from './persona-loader.js';
 let lastSessionStartAt = 0;
 const MIN_INTERVAL_MS = 5000; // 同一进程 5s 内最多触发一次, 防止循环
 export async function onSessionStart(opts = {}) {
@@ -30,7 +30,13 @@ export async function onSessionStart(opts = {}) {
         if (opts.agentId) {
             try {
                 const docs = await loadPersonaDocs(opts.agentId);
-                const personaText = formatPersonaForSystemPrompt(docs);
+                let personaText = formatPersonaForSystemPrompt(docs);
+                // 2026-08-03 (Context OS P1): 追加 persona frontmatter 里的判断力声明
+                //   (judgment_style / stakes_default / revisable) — 与 judgeness 5 维对应
+                const decl = await loadPersonaJudgmentDeclaration(opts.agentId);
+                const declText = formatJudgmentDeclaration(decl);
+                if (declText)
+                    personaText = personaText ? `${personaText}\n\n${declText}` : declText;
                 if (personaText) {
                     systemAddition = personaText + '\n\n' + systemAddition;
                 }

package/dist/bootstrap/memory-compressor.js

@@ -144,7 +144,8 @@ export async function compressSessionToMemory(opts) {
     const timestamp = new Date().toISOString();
     let summaryBody;
     try {
-        const sysPrompt = '你是 bolloon 记忆压缩助手. 输入是一段 session 消息历史 (用户问题 + AI 回答), 输出 200-400 字中文摘要, 包含 3-5 条关键发现和未完成事项. 不要寒暄, 不要复述已知. 格式: ## 关键发现 / ## 待办.';
+        // 2026-08-03 (Context OS P4): 摘要 prompt 要求输出"价值点"段 — 供收尾路由入库 judgeness
+        const sysPrompt = '你是 bolloon 记忆压缩助手. 输入是一段 session 消息历史 (用户问题 + AI 回答), 输出 200-400 字中文摘要, 包含 3-5 条关键发现和未完成事项. 不要寒暄, 不要复述已知. 格式: ## 关键发现 / ## 待办. 最后单独输出 ## 价值点 段: 0-3 行, 每行 `- (类型) 一句话内容`, 类型 ∈ decision|lesson|knowledge|insight (decision=做出了什么决定; lesson=哪里出错下次怎么避免; knowledge=修正了什么认知; insight=改变了判断的洞察). 没有就写 `- (无)`';
         const recentSnippet = newMessages.slice(-10).map(m => `[${m.type}] ${m.content}`).join('\n---\n').slice(0, 6000);
         const userPrompt = `Channel: ${opts.channelId}\nSession: ${opts.sessionId}\n时间: ${timestamp}\n新增消息数: ${newMessages.length}\n\n最近消息:\n${recentSnippet}`;
         summaryBody = await tryLlmSummary(sysPrompt, userPrompt);
@@ -161,6 +162,18 @@ export async function compressSessionToMemory(opts) {
     await fs.mkdir(path.dirname(summaryPath), { recursive: true });
     await fs.appendFile(summaryPath, block, 'utf-8');
     await writeCursor(cursorPath, allMessages.length);
+    // 2026-08-03 (Context OS P4): 价值点分类路由 — 把摘要里的 decision/lesson/knowledge/insight
+    //   自动写入 human-values + judgeness (Context OS §6 对话收尾: 价值不流失).
+    //   失败静默, 不阻塞主对话. 幂等: 相同 decision 文本跳过.
+    try {
+        await routeValuePointsToJudgeness({
+            agentId,
+            channelId: opts.channelId,
+            summaryBody,
+            home,
+        });
+    }
+    catch { /* 静默 */ }
     // 2026-07-22 设计 C: 废气采样 — 压缩成功 = 上下文需要压缩的信号, 记入涡轮 (隐式)
     //   废气不进 prompt, 只调参 (背压高 → judgment 注入收紧). 落 log/memory.
     try {
@@ -179,3 +192,115 @@ export async function compressSessionToMemory(opts) {
         bytesWritten: Buffer.byteLength(block, 'utf-8'),
     };
 }
+/**
+ * 解析摘要里的 `## 价值点` 段.
+ * 容错 3 种行格式: `- (decision) 内容` / `- decision: 内容` / `- decision 内容`
+ * 无该段 / `- (无)` → 返回 [].
+ */
+export function extractValuePoints(summaryBody) {
+    if (!summaryBody)
+        return [];
+    const m = summaryBody.match(/##\s*价值点\s*\n([\s\S]*?)(?=\n##\s|\n---\s*$|$)/);
+    if (!m)
+        return [];
+    const lines = m[1].split('\n').map((l) => l.trim()).filter(Boolean);
+    const out = [];
+    const typeSet = ['decision', 'lesson', 'knowledge', 'insight'];
+    for (const line of lines) {
+        const stripped = line.replace(/^[-*•]\s*/, '');
+        if (stripped === '(无)' || stripped === '无' || stripped === '')
+            continue;
+        // - (type) content | - type: content | - type content
+        const m2 = stripped.match(/^\(?(\w+)\)?\s*[:：]?\s+(.+)$/);
+        if (!m2)
+            continue;
+        const t = m2[1].toLowerCase();
+        if (!typeSet.includes(t))
+            continue;
+        const content = m2[2].trim();
+        if (content.length < 4)
+            continue;
+        out.push({ type: t, content });
+    }
+    return out.slice(0, 3);
+}
+/** 幂等检查: human-values 里已有相同 decision 文本 → 跳过 (防重复入库) */
+async function alreadyRouted(decisionText, home) {
+    try {
+        const { loadAllJudgments } = await import('../pi-ecosystem-judgment/human-value-store.js');
+        const all = await loadAllJudgments();
+        return all.some((j) => String(j.decision).trim() === decisionText.trim());
+    }
+    catch {
+        return false; // 读失败 → 不跳过 (重试语义)
+    }
+}
+/**
+ * 把摘要里的价值点路由到 human-values + judgeness + Context OS 资产层.
+ * 失败静默 (由调用方 try/catch), 单条失败不影响其余.
+ * 落点 (Context OS §6 Step2 唯一落点):
+ *   decision → decisions/ (decision-store, 不重复写资产层)
+ *   lesson   → human-values + judgeness + 12-Analysis/ (复盘)
+ *   knowledge→ human-values + judgeness + 07-Knowledge/
+ *   insight  → human-values + judgeness + 08-Insights/
+ * 返回写入条数 (测试/日志用).
+ */
+export async function routeValuePointsToJudgeness(opts) {
+    const points = extractValuePoints(opts.summaryBody);
+    if (points.length === 0)
+        return 0;
+    let written = 0;
+    for (const p of points) {
+        try {
+            const decisionText = p.content.slice(0, 300);
+            if (await alreadyRouted(decisionText, opts.home))
+                continue;
+            const { storeHumanJudgment } = await import('../pi-ecosystem-judgment/human-value-store.js');
+            const { reflectAfterJudgment } = await import('../judgeness/reflect.js');
+            const isLesson = p.type === 'lesson';
+            const judgment = await storeHumanJudgment({
+                decision: decisionText,
+                decision_type: isLesson ? 'reject' : 'approve',
+                reasons: [`来源: session 摘要价值点 (${p.type})`],
+                values_derived: [],
+                context: {
+                    domain: opts.channelId?.startsWith('ch_') ? '通用' : (opts.channelId || '通用'),
+                    complexity: 'simple',
+                    stakes: 'low',
+                    time_pressure: 'low',
+                },
+                metadata: {
+                    source: isLesson ? 'trajectory' : 'implicit',
+                    confidence: 0.6,
+                    revisable: true,
+                },
+                status: 'active',
+                appliesTo: [],
+            });
+            await reflectAfterJudgment(judgment, 'agent', sanitizeAgentId(opts.agentId)).catch(() => null);
+            written += 1;
+            // 2026-08-03 (Context OS P5): 唯一落点 — knowledge/insight/lesson 写入资产层
+            //   (幂等: 同标题已存在则跳过; 失败静默不影响主流程)
+            const assetLayer = p.type === 'knowledge' ? '07-Knowledge' :
+                p.type === 'insight' ? '08-Insights' :
+                    p.type === 'lesson' ? '12-Analysis' : null;
+            if (assetLayer) {
+                try {
+                    const { writeContextAsset } = await import('./context-os.js');
+                    await writeContextAsset({
+                        layer: assetLayer,
+                        title: p.content.slice(0, 40),
+                        content: `> 来源: session 价值点自动路由 (${p.type})\n\n${p.content}\n\n## 价值判断自检\n未来哪个具体场景会用到它? (待确认后固化, 当前 stage0)`,
+                        tags: [p.type, 'auto-routed'],
+                        domain: opts.channelId,
+                    }, opts.home);
+                }
+                catch { /* 资产层写入失败不影响 */ }
+            }
+        }
+        catch {
+            /* 单条失败跳过 */
+        }
+    }
+    return written;
+}

package/dist/bootstrap/persona-loader.js

@@ -4,6 +4,12 @@
  * 失败静默: 文件不存在 → 字段 = '', 不抛错
  * 安全: agentId sanitize (防路径穿越)
  * 6 段输出顺序: identity → soul → project → user → agent → wiki
+ *
+ * 2026-08-03 (Context OS 融合 P1):
+ *   - 支持 persona 文件 frontmatter 里的判断力声明 (judgment_style / stakes_default / revisable),
+ *     与 judgeness 5 维 facets 对应 — persona 提供"这个人怎么判断"的入口.
+ *   - formatPersonaForSystemPrompt 固定追加 INJECT 工作纪律段 (Context OS 读取协议),
+ *     任何 channel 即使无 persona 文件也有纪律约束.
  */
 import * as fs from 'fs/promises';
 import * as os from 'os';
@@ -45,6 +51,71 @@ export async function loadPersonaDocs(agentId, home) {
     }));
     return docs;
 }
+/**
+ * 轻量 frontmatter 解析 (不依赖 js-yaml).
+ * 只认 `key: value` 单行字段; 无 frontmatter (不以 --- 开头) → 返回 {}.
+ */
+export function parseSimpleFrontmatter(content) {
+    const out = {};
+    const m = content.match(/^---\s*\r?\n([\s\S]*?)\r?\n---/);
+    if (!m)
+        return out;
+    for (const line of m[1].split('\n')) {
+        const kv = line.match(/^\s*([A-Za-z0-9_-]+)\s*:\s*(.*?)\s*$/);
+        if (kv)
+            out[kv[1]] = kv[2].replace(/^['"]|['"]$/g, '').trim();
+    }
+    return out;
+}
+/**
+ * 读 persona 6 文件 frontmatter 里的判断力声明 (Context OS 入口层 ↔ judgeness 5 维).
+ * 聚合所有文件中的 judgment_style / stakes_default / revisable 字段 (后者优先).
+ * 失败静默: 无 persona 文件 → 全部空值, 不抛错.
+ */
+export async function loadPersonaJudgmentDeclaration(agentId, home) {
+    const safeId = sanitizeAgentId(agentId);
+    const root = home || os.homedir();
+    const baseDir = path.join(root, '.bolloon', 'persona', safeId);
+    const decl = {
+        judgmentStyle: '',
+        stakesDefault: '',
+        revisable: true,
+        raw: {},
+    };
+    await Promise.all(FILE_KEYS.map(async (key) => {
+        try {
+            const content = await fs.readFile(path.join(baseDir, `${key}.md`), 'utf-8');
+            const fm = parseSimpleFrontmatter(content);
+            for (const [k, v] of Object.entries(fm)) {
+                if (k.startsWith('judgment_') || k === 'stakes_default' || k === 'revisable') {
+                    decl.raw[k] = v;
+                }
+            }
+        }
+        catch {
+            /* 单文件缺失/损坏跳过 */
+        }
+    }));
+    decl.judgmentStyle = decl.raw['judgment_style'] || decl.raw['judgmentStyle'] || '';
+    decl.stakesDefault = decl.raw['stakes_default'] || decl.raw['stakesDefault'] || '';
+    decl.revisable = decl.raw['revisable'] !== 'false';
+    return decl;
+}
+/** 把判断力声明格式化成一行段 (server contextHint 注入用) */
+export function formatJudgmentDeclaration(decl) {
+    if (!decl.judgmentStyle && !decl.stakesDefault && !decl.raw['revisable'])
+        return '';
+    const parts = [];
+    if (decl.judgmentStyle)
+        parts.push(`风格: ${decl.judgmentStyle}`);
+    if (decl.stakesDefault)
+        parts.push(`默认风险等级: ${decl.stakesDefault}`);
+    if (decl.raw['revisable'] === 'false')
+        parts.push('偏好不可回滚的决策 (谨慎)');
+    else if (decl.raw['revisable'] === 'true')
+        parts.push('偏好可回滚的决策');
+    return `[系统上下文] 判断风格声明 (来自 persona frontmatter, 与 judgeness 判断资产对应):\n  ${parts.join(' / ')}\n\n`;
+}
 const DEFAULT_MAX_CHARS = 4000;
 const SECTION_LABELS = {
     identity: 'Identity',
@@ -60,6 +131,9 @@ const OUTPUT_ORDER = ['identity', 'soul', 'project', 'user', 'agent', 'wiki'];
  *
  * 超 maxChars 时按比例截断: 每个字段都保留头部,
  * 保证 6 段标识都出现, 不砍段.
+ *
+ * 2026-08-03: 固定追加 INJECT 工作纪律段 (Context OS 读取协议 §4/§10).
+ *   纪律段不参与动态预算 — 即使没有 persona 文件也有纪律约束.
  */
 export function formatPersonaForSystemPrompt(docs, maxChars) {
     const cap = maxChars ?? DEFAULT_MAX_CHARS;
@@ -71,11 +145,20 @@ export function formatPersonaForSystemPrompt(docs, maxChars) {
             sections.push({ key, text: `## ${SECTION_LABELS[key]}\n${v}` });
         }
     }
-    if (sections.length === 0)
-        return '';
-    // 预算每段 (去掉 ## 标识和换行的固定开销)
+    // INJECT 工作纪律 (Context OS §4 最小读取集 + §10 工作规则, 精简 4 条)
+    const discipline = '## 工作纪律 (INJECT)\n' +
+        '1. 先看动态状态 (历史记忆 / 进行中的计划), 再按任务路由读取对应文档; 不读到的内容不假装知道.\n' +
+        '2. 区分: 已知事实 / 你的判断 / 需要用户确认的内容.\n' +
+        '3. 重要决策前列出: 选项 (含不做)、成本、收益、风险、信息缺口、回滚条件 — 决策可追溯.\n' +
+        '4. 对话收尾提取可复用的决策/知识/教训, 归档到唯一位置, 不制造重复文件.';
     const header = `# Persona (agentId=${docs.agentId})\n\n`;
-    const fixedOverhead = header.length + (sections.length - 1) * 2;
+    // 无 persona 文件 → 只输出纪律段
+    if (sections.length === 0) {
+        const solo = `${header}${discipline}`;
+        return solo.length > cap ? solo.slice(0, cap) : solo;
+    }
+    // 预算每段 (去掉 ## 标识和换行的固定开销; 纪律段固定, 动态段让出预算)
+    const fixedOverhead = header.length + discipline.length + (sections.length - 1) * 2;
     const perSectionBudget = Math.max(50, Math.floor((cap - fixedOverhead) / sections.length));
     const parts = [header.trim()];
     for (const sec of sections) {
@@ -85,7 +168,7 @@ export function formatPersonaForSystemPrompt(docs, maxChars) {
         }
         parts.push(body);
     }
-    let result = parts.join('\n\n');
+    let result = parts.join('\n\n') + '\n\n' + discipline;
     if (result.length > cap) {
         const truncateMarker = '\n... (截断)';
         result = result.substring(0, Math.max(0, cap - truncateMarker.length)) + truncateMarker;