@aiwayds/dsh-topics-memory 0.24.1 → 0.25.1

package/lib/distill.d.ts

@@ -42,6 +42,16 @@ export interface DistillOp {
     conclusion?: string;
     recommendations?: string;
     status?: string;
+    /** Lesson distill branch (B2): lesson-kind create op — a behavior lesson. */
+    kind?: string;
+    /** Lesson scope (B2 §6.2, lesson 必带; the write defaults absent → workspace). */
+    scope?: string;
+    /**
+     * Conflict self-check markers (B2 决议 5, baseline): established lesson
+     * slugs from the prompt's baseline list that this draft contradicts. The
+     * draft still lands — the flag is ledgered for the B4 approval gate.
+     */
+    conflictsWith?: string[];
     observed_ids?: string[];
 }
 export interface DistillResult {
@@ -55,6 +65,17 @@ export interface DistillResult {
     detail?: string;
 }
 export declare const SYSTEM_PROMPT: string;
+/**
+ * The lesson distill branch's system prompt (B2 决议 3①, spec 卷二 §3.1):
+ * fed structured signals (`kind:'signal'` + `source:'fed'`, feature lines
+ * only — 对话原文结构上进不来) distill into behavior LESSONS, not factual
+ * topics. The 判定问句 is the gate: a signal batch that cannot yield an
+ * executable behavioral rule must come back EMPTY (宁缺勿滥 — a fabricated
+ * lesson is noise the approval gate then has to burn down). The lane stamps
+ * confidence='hint' + source='distilled' itself; promotion to established is
+ * the B4 approval gate's exclusive write path (setLessonStatus).
+ */
+export declare const LESSON_PROMPT: string;
 export declare class Distiller {
     private inFlight;
     private readonly service;
@@ -91,11 +112,36 @@ export declare class Distiller {
     private runInner;
     /**
      * One model call (plus at most one corrective retry) over one batch:
-     * payload build → ops → topic writes → marks. `budgetLeft` is the calls
-     * still available to the run including this batch's first call (≥ 1); the
-     * corrective retry only fires when it can stay inside that budget.
+     * payload build → ops → topic/lesson writes → marks. `budgetLeft` is the
+     * calls still available to the run including this batch's first call (≥ 1);
+     * the corrective retry only fires when it can stay inside that budget.
+     * `branch` picks the prompt and the payload: the topic branch carries the
+     * topic index (ops may update slugs), the lesson branch carries the
+     * established-lesson baseline for the conflict self-check instead — lesson
+     * ops never reference the topic roster. Both branches share the
+     * observed_ids sanitation, the schema gate, the corrective retry, the GC
+     * and the marks; only the payload/system/op-shape differ.
      */
     private runBatch;
+    /**
+     * The conflict self-check baseline (B2 决议 5): established lessons ONLY —
+     * hint drafts are not yet norms, so there is nothing for a candidate to
+     * contradict. Each brief carries the lesson's condition surface (title +
+     * triggers) and its slug (the only legal conflictsWith reference). Bounded
+     * reads like the topic index (first 100 roster entries); established
+     * lessons are post-gate artifacts and stay a handful in practice.
+     */
+    private establishedLessonBriefs;
+    /**
+     * B2 conflict self-check, LEDGER-ONLY disposition: a draft that declares
+     * `conflictsWith` still lands as a hint draft (新覆旧 is the B4 approval
+     * gate's call, never the distill lane's). Each declared slug is
+     * whitelist-checked against the established baseline the prompt carried;
+     * roster-unknown slugs are model noise and are dropped without an event (a
+     * hallucinated slug must not fabricate a conflict). The event is a flag for
+     * the approval surface — no lifecycle state changes here.
+     */
+    private ledgerLessonConflicts;
     /**
      * The ONE corrective retry for a zero-valid-observed_ids batch: re-ask with
      * the batch's legal id list spelled out verbatim. It spends a second call
@@ -144,6 +190,11 @@ export declare class Distiller {
      * the store transaction (先落 topic 再建边 — one write, no separate edge
      * pass). The set is locally seeded with this call's predicted op slugs and
      * grows as creates land, so same-batch references resolve in op order.
+     *
+     * Lesson creates (B2) ride the same sanitation and consume their
+     * observations through the same observed_ids bridge; the write goes through
+     * saveTopic's lesson branch (kind:'lesson', confidence hint, distilled
+     * provenance) — the observation→mark closure is identical to topics.
      */
     private applyOps;
     /**

package/lib/distill.js

@@ -28,6 +28,41 @@ export const SYSTEM_PROMPT = [
     '- 观察里有价值就沉淀，没价值就跳过该观察（被跳过观察的 id 不要出现在任何 op 里）；没有可沉淀内容时输出 {"ops":[]}。',
     '- 中文主题用中文写；tags 全小写。',
 ].join('\n');
+/**
+ * The lesson distill branch's system prompt (B2 决议 3①, spec 卷二 §3.1):
+ * fed structured signals (`kind:'signal'` + `source:'fed'`, feature lines
+ * only — 对话原文结构上进不来) distill into behavior LESSONS, not factual
+ * topics. The 判定问句 is the gate: a signal batch that cannot yield an
+ * executable behavioral rule must come back EMPTY (宁缺勿滥 — a fabricated
+ * lesson is noise the approval gate then has to burn down). The lane stamps
+ * confidence='hint' + source='distilled' itself; promotion to established is
+ * the B4 approval gate's exclusive write path (setLessonStatus).
+ */
+export const LESSON_PROMPT = [
+    '你是 lesson 记忆库的蒸馏引擎。输入是若干条来自改进回路的结构化信号观察（JSON，只含特征与计数，无对话原文）和现有 established lesson 清单。',
+    '任务：把信号提炼成行为教训（lesson）操作。只输出一个 JSON 对象，不要任何其他文字、Markdown 代码块或解释。',
+    '判定问句：「违反它会犯错误吗？」——只有当信号指向一条可执行的行为规则（遵守或违反它会直接改变做事的对错）才立 lesson；只是事实、环境描述或给不出行动指令的信号批没有教训可立：明确输出 {"ops":[]}（宁缺勿滥，禁止为凑数编造教训）。',
+    '输出格式：{"ops": [...]}，每个元素只允许 create：',
+    '  {"op":"create","kind":"lesson","title":"条件式短句（什么情境下）","triggers":["condition 触发词，恰好 3-8 个具体短语"],',
+    '   "conclusion":"action：怎么做，祈使句，自含可执行","scope":"workspace 或 global","observed_ids":["obs-..."]}',
+    '规则：',
+    '- 硬性要求：每个 op 必须带 observed_ids 字段，值只能从本次输入「信号观察」里列出的 id 中逐字复制（形如 "obs-..."）；含列表之外 id 的条目会被过滤；observed_ids 缺失、为空或过滤后不剩任何有效 id 的 op 会被整体丢弃。',
+    '- 硬性要求：每个 create 必须带 triggers（恰好 3-8 个「什么情境出现时应该想起这条教训」的 condition 触发短语）与 conclusion（祈使句行动指令）；缺失或数量不符的 create 会被补问一次，补全后仍不合规的 op 会被丢弃并落账。',
+    '- title 写情境侧（条件式短句），conclusion 写行动侧（怎么做，祈使句）；confidence 一律 hint、来源一律 distilled，由系统落库时固定，不要输出这两个字段。',
+    '- scope：只在本工作区适用的教训用 "workspace"（默认），跨项目普适的才用 "global"。',
+    '- 矛盾自查：输出前对照输入里的「现有 established lesson 清单」——若候选教训与某条已有教训在同一情境下给出相反做法，照常输出草稿并加 "conflictsWith":["该教训的slug"] 标记（只能引用清单里的 slug；是否新覆旧由审批门裁决，不要因此放弃输出）。',
+    '- 同一情境只允许一个 create；中文写。',
+].join('\n');
+/**
+ * The B-line routing predicate (B2 决议 3①): the write seam stamps fed
+ * structured signals `kind:'signal'` + `source:'fed'` (feedObservations);
+ * exactly that combination rides the lesson prompt branch. Every other
+ * observation keeps the topic prompt — the topic lane's behavior is
+ * byte-for-byte unchanged.
+ */
+function isFedSignal(o) {
+    return o.source === 'fed' && o.kind === 'signal';
+}
 /** Adaptive-batch floor — below this, shrinking cannot rescue an output limit. */
 const MIN_BATCH_SIZE = 5;
 /** Fallbacks when the config fields are absent (bare test harnesses). */
@@ -63,6 +98,29 @@ function checkCreateSchema(op) {
     }
     return { valid: problems.length === 0, missing: problems.join('、') };
 }
+/**
+ * The lesson-branch schema check (B2): a lesson create must carry the
+ * condition (triggers 3-8 — the same strong-field contract as topics) and the
+ * action (conclusion, the 祈使句 imperative). `description` is NOT required
+ * on lessons — the §6.2 frontmatter contract is scope/confidence/source and
+ * the title carries the condition side. An ABSENT scope is not a defect (the
+ * write defaults it to workspace — lesson 必带 scope is a storage invariant
+ * enforced at saveTopic, not a model-output demand); a present-but-illegal
+ * scope is.
+ */
+function checkLessonSchema(op) {
+    const problems = [];
+    if (typeof op.conclusion !== 'string' || op.conclusion.trim() === '')
+        problems.push('conclusion(action)');
+    const triggers = Array.isArray(op.triggers) ? op.triggers.filter((t) => typeof t === 'string' && t.trim() !== '') : [];
+    if (triggers.length < TRIGGERS_MIN || triggers.length > TRIGGERS_MAX) {
+        problems.push(`triggers(实际 ${triggers.length}，需 ${TRIGGERS_MIN}-${TRIGGERS_MAX})`);
+    }
+    if (op.scope !== undefined && op.scope !== 'workspace' && op.scope !== 'global') {
+        problems.push('scope(需 workspace|global)');
+    }
+    return { valid: problems.length === 0, missing: problems.join('、') };
+}
 export class Distiller {
     inFlight = new Map();
     service;
@@ -194,6 +252,7 @@ export class Distiller {
         let filteredTotal = 0;
         let invalidTotal = 0;
         let rejectedTotal = 0;
+        let conflictTotal = 0;
         let stallDetail;
         // GC bookkeeping (store.recordUnconsumed): every id the model EVALUATED
         // this run (parseable answer, however useless) minus the ids an op
@@ -218,15 +277,26 @@ export class Distiller {
                 stopped = 'budget';
                 break;
             }
+            // B-line routing (lesson distill branch): fed+signal observations carry
+            // the self-improve structured signals and distill through the lesson
+            // prompt branch into lesson ops; every other observation keeps the topic
+            // prompt byte-for-byte. A mixed window runs ONE sub-pool per iteration —
+            // the topic sub-pool first (the topic lane keeps its claim on the batch
+            // head and its existing stop semantics); the other sub-pool stays
+            // pending in the pool and is fetched by the next iteration.
+            const topicObs = observations.filter((o) => !isFedSignal(o));
+            const branch = topicObs.length > 0 ? 'topic' : 'lesson';
+            const pool = topicObs.length > 0 ? topicObs : observations;
             // The batch spends 1 call, or 2 when the corrective observed_ids retry
             // fires — the budget check above already guaranteed room for both.
-            const outcome = await this.runBatch(sessionId, observations, maxCalls - calls);
+            const outcome = await this.runBatch(sessionId, pool, maxCalls - calls, branch);
             calls += Math.max(1, outcome.callsUsed ?? 1);
             for (const id of outcome.consumedIds ?? [])
                 consumedRunIds.add(id);
             filteredTotal += outcome.filteredIds ?? 0;
             invalidTotal += outcome.invalidOps ?? 0;
             rejectedTotal += outcome.rejectedLinks ?? 0;
+            conflictTotal += outcome.conflictsFlagged ?? 0;
             created.push(...outcome.created);
             updated.push(...outcome.updated);
             marked += outcome.marked;
@@ -247,7 +317,7 @@ export class Distiller {
                 // Floor reached: repeated output-limit finishes ARE an evaluation
                 // verdict on this content (the model saw it and could not fit an
                 // answer) — the batch counts toward the GC.
-                for (const o of observations)
+                for (const o of pool)
                     fedIds.add(o.id);
                 stopped = 'max-tokens';
                 failureDetail = `批次无法再缩小（当前 ${this.batchSize} 条）仍触发输出上限：${outcome.detail ?? 'model finish: max-tokens'}`;
@@ -264,7 +334,7 @@ export class Distiller {
             }
             // Parseable answer (ops, empty or not): the batch was genuinely
             // evaluated — its unconsumed ids gain one failed attempt.
-            for (const o of observations)
+            for (const o of pool)
                 fedIds.add(o.id);
             if (outcome.noOps) {
                 stopped = 'no-ops';
@@ -310,7 +380,8 @@ export class Distiller {
             const filteredNote = filteredTotal > 0 ? `；filtered ${filteredTotal} invalid observed_ids` : '';
             const schemaNote = invalidTotal > 0 ? `；schema-dropped ${invalidTotal} create op(s)` : '';
             const linkNote = rejectedTotal > 0 ? `；rejected ${rejectedTotal} invalid link ref(s)` : '';
-            const notes = `${filteredNote}${schemaNote}${linkNote}`;
+            const conflictNote = conflictTotal > 0 ? `；conflict-flagged ${conflictTotal} lesson draft(s)` : '';
+            const notes = `${filteredNote}${schemaNote}${linkNote}${conflictNote}`;
             const base = head === undefined ? undefined : `partial: 已蒸馏标记 ${marked} 条观察（${calls} 次模型调用）；${head}`;
             result = {
                 ok: true,
@@ -347,35 +418,64 @@ export class Distiller {
     }
     /**
      * One model call (plus at most one corrective retry) over one batch:
-     * payload build → ops → topic writes → marks. `budgetLeft` is the calls
-     * still available to the run including this batch's first call (≥ 1); the
-     * corrective retry only fires when it can stay inside that budget.
+     * payload build → ops → topic/lesson writes → marks. `budgetLeft` is the
+     * calls still available to the run including this batch's first call (≥ 1);
+     * the corrective retry only fires when it can stay inside that budget.
+     * `branch` picks the prompt and the payload: the topic branch carries the
+     * topic index (ops may update slugs), the lesson branch carries the
+     * established-lesson baseline for the conflict self-check instead — lesson
+     * ops never reference the topic roster. Both branches share the
+     * observed_ids sanitation, the schema gate, the corrective retry, the GC
+     * and the marks; only the payload/system/op-shape differ.
      */
-    async runBatch(sessionId, observations, budgetLeft) {
+    async runBatch(sessionId, observations, budgetLeft, branch) {
+        const lesson = branch === 'lesson';
+        const system = lesson ? LESSON_PROMPT : SYSTEM_PROMPT;
         const metas = await this.service.store.listTopics();
-        // Real open questions need the docs; fetch for index (bounded).
-        const indexDetailed = [];
-        for (const m of metas.slice(0, 100)) {
-            const doc = await this.service.store.readTopic(m.slug).catch(() => undefined);
-            indexDetailed.push({
-                slug: m.slug,
-                title: m.title,
-                status: m.status,
-                tags: m.tags,
-                open_questions: doc?.fm.open_questions ?? [],
-                conclusion: (okf.firstParagraph(okf.sectionOf(doc?.body ?? '', okf.CONCLUSION_HEADING) ?? '')).slice(0, 200),
-            });
+        let establishedSlugs = new Set();
+        let user;
+        if (lesson) {
+            // Lesson branch payload: the conflict self-check baseline (B2 决议 5)
+            // rides IN the prompt — a same-prompt self-check, not a separate slow
+            // call; the B4 gate owns any 新覆旧 disposition afterwards.
+            const established = await this.establishedLessonBriefs(metas);
+            establishedSlugs = new Set(established.map((l) => l.slug));
+            const observationsPayload = observations.map((o) => ({ id: o.id, kind: o.kind, source: o.source, text: o.text }));
+            user = [
+                `现有 established lesson 清单（${established.length} 条）：`,
+                JSON.stringify(established),
+                '',
+                `信号观察（${observationsPayload.length} 条）：`,
+                JSON.stringify(observationsPayload),
+                '',
+                '请输出蒸馏结果（严格 JSON，{"ops":[...]}）：',
+            ].join('\n');
+        }
+        else {
+            // Real open questions need the docs; fetch for index (bounded).
+            const indexDetailed = [];
+            for (const m of metas.slice(0, 100)) {
+                const doc = await this.service.store.readTopic(m.slug).catch(() => undefined);
+                indexDetailed.push({
+                    slug: m.slug,
+                    title: m.title,
+                    status: m.status,
+                    tags: m.tags,
+                    open_questions: doc?.fm.open_questions ?? [],
+                    conclusion: (okf.firstParagraph(okf.sectionOf(doc?.body ?? '', okf.CONCLUSION_HEADING) ?? '')).slice(0, 200),
+                });
+            }
+            const observationsPayload = observations.map((o) => ({ id: o.id, kind: o.kind, source: o.source, text: o.text }));
+            user = [
+                `现有 topic 索引（${indexDetailed.length} 个）：`,
+                JSON.stringify(indexDetailed),
+                '',
+                `未蒸馏观察（${observationsPayload.length} 条）：`,
+                JSON.stringify(observationsPayload),
+                '',
+                '请输出蒸馏结果（严格 JSON，{"ops":[...]}）：',
+            ].join('\n');
         }
-        const observationsPayload = observations.map((o) => ({ id: o.id, kind: o.kind, source: o.source, text: o.text }));
-        const user = [
-            `现有 topic 索引（${indexDetailed.length} 个）：`,
-            JSON.stringify(indexDetailed),
-            '',
-            `未蒸馏观察（${observationsPayload.length} 条）：`,
-            JSON.stringify(observationsPayload),
-            '',
-            '请输出蒸馏结果（严格 JSON，{"ops":[...]}）：',
-        ].join('\n');
         let raw;
         const caller = this.caller;
         if (caller === undefined) {
@@ -384,7 +484,7 @@ export class Distiller {
             return { created: [], updated: [], marked: 0, fatalReason: 'model-error', detail: 'distill caller unavailable' };
         }
         try {
-            raw = await caller({ system: SYSTEM_PROMPT, user, purpose: 'topics-distill', sessionId, maxTokens: 4000 });
+            raw = await caller({ system, user, purpose: 'topics-distill', sessionId, maxTokens: 4000 });
         }
         catch (e) {
             const detail = String(e instanceof Error ? e.message : e).slice(0, 200);
@@ -405,6 +505,15 @@ export class Distiller {
                 detail: String(e instanceof Error ? e.message : e).slice(0, 200),
             };
         }
+        if (lesson) {
+            // The lesson branch drafts NEW lessons only — a lesson "update" would
+            // rewrite another lane's lifecycle state (confidence/status transitions
+            // are the B4 approval gate's exclusive write path), so non-create shapes
+            // are dropped before the gate. Their observations stay unconsumed and
+            // walk the existing GC path; an all-update batch resolves to the honest
+            // no-ops stop.
+            ops = ops.filter((o) => o.op === 'create');
+        }
         if (ops.length === 0) {
             return { created: [], updated: [], marked: 0, noOps: true, callsUsed: 1 };
         }
@@ -412,7 +521,7 @@ export class Distiller {
         // 补问 retry (budget-guarded), still-deficient ops are dropped and
         // ledgered — never a silent drop. Their observations simply stay
         // unconsumed and walk the existing GC/corrective path (three strikes).
-        const schema = await this.enforceSchema(sessionId, user, ops, budgetLeft);
+        const schema = await this.enforceSchema(sessionId, system, user, ops, budgetLeft, branch);
         let callsUsed = 1 + schema.retrySpent;
         for (const drop of schema.drops) {
             await recordPipelineEvent(this.service.store.root, {
@@ -428,9 +537,16 @@ export class Distiller {
                 marked: 0,
                 callsUsed,
                 invalidOps: schema.drops.length,
-                stallDetail: `全部 create op 未通过 schema 校验（description 必填 + triggers 3-8 条），已丢弃并落账（${schema.drops.length} 个）`,
+                stallDetail: lesson
+                    ? `全部 lesson op 未通过 schema 校验（triggers 3-8 条 + conclusion(action) 必填 + scope 枚举），已丢弃并落账（${schema.drops.length} 个）`
+                    : `全部 create op 未通过 schema 校验（description 必填 + triggers 3-8 条），已丢弃并落账（${schema.drops.length} 个）`,
             };
         }
+        // B2 conflict self-check ledgering: the draft still lands as a hint —
+        // the flag is for the approval surface, never a lifecycle write.
+        let conflictsFlagged = 0;
+        if (lesson)
+            conflictsFlagged = await this.ledgerLessonConflicts(schema.finalOps, establishedSlugs);
         // observed_ids are the ONLY bridge between ops and marks — without a valid
         // id the store cannot mark anything and the batch head can never advance
         // (the real-machine zero-consumption livelock: topics landed, backlog
@@ -465,7 +581,7 @@ export class Distiller {
                 };
             }
             const pass1 = applied;
-            const { applied: pass2, why } = await this.correctiveRetry(sessionId, user, idList, validIds, knownSlugs);
+            const { applied: pass2, why } = await this.correctiveRetry(sessionId, system, user, idList, validIds, knownSlugs);
             callsUsed += 1;
             if (pass2 === undefined || pass2.consumedIds.length === 0) {
                 const tail = pass2 === undefined
@@ -505,9 +621,60 @@ export class Distiller {
             filteredIds: applied.filteredIds,
             invalidOps: schema.drops.length,
             rejectedLinks: applied.rejectedLinks,
+            conflictsFlagged,
             consumedIds: applied.consumedIds,
         };
     }
+    /**
+     * The conflict self-check baseline (B2 决议 5): established lessons ONLY —
+     * hint drafts are not yet norms, so there is nothing for a candidate to
+     * contradict. Each brief carries the lesson's condition surface (title +
+     * triggers) and its slug (the only legal conflictsWith reference). Bounded
+     * reads like the topic index (first 100 roster entries); established
+     * lessons are post-gate artifacts and stay a handful in practice.
+     */
+    async establishedLessonBriefs(metas) {
+        const out = [];
+        for (const m of metas.slice(0, 100)) {
+            const doc = await this.service.store.readTopic(m.slug).catch(() => undefined);
+            if (doc === undefined)
+                continue;
+            if (okf.topicKindOf(doc.fm.type) !== 'lesson')
+                continue;
+            if ((doc.fm.confidence ?? 'hint') !== 'established')
+                continue;
+            out.push({ slug: m.slug, title: m.title, triggers: doc.fm.triggers ?? [] });
+        }
+        return out;
+    }
+    /**
+     * B2 conflict self-check, LEDGER-ONLY disposition: a draft that declares
+     * `conflictsWith` still lands as a hint draft (新覆旧 is the B4 approval
+     * gate's call, never the distill lane's). Each declared slug is
+     * whitelist-checked against the established baseline the prompt carried;
+     * roster-unknown slugs are model noise and are dropped without an event (a
+     * hallucinated slug must not fabricate a conflict). The event is a flag for
+     * the approval surface — no lifecycle state changes here.
+     */
+    async ledgerLessonConflicts(ops, establishedSlugs) {
+        let flagged = 0;
+        for (const op of ops) {
+            if (!Array.isArray(op.conflictsWith) || op.conflictsWith.length === 0)
+                continue;
+            const valid = [...new Set(op.conflictsWith)].filter((s) => typeof s === 'string' && establishedSlugs.has(s));
+            if (valid.length === 0)
+                continue;
+            await recordPipelineEvent(this.service.store.root, {
+                at: new Date().toISOString(),
+                kind: 'lesson-conflict-flagged',
+                // detail values are scalar-only (pipeline-events whitelist): the slug
+                // list rides as a comma join, the raw declaration count rides as a number.
+                detail: { op: opKey(op), conflictsWith: valid.join(','), declared: op.conflictsWith.length },
+            });
+            flagged += valid.length;
+        }
+        return flagged;
+    }
     /**
      * The ONE corrective retry for a zero-valid-observed_ids batch: re-ask with
      * the batch's legal id list spelled out verbatim. It spends a second call
@@ -516,7 +683,7 @@ export class Distiller {
      * stop — a max-tokens correction does NOT trigger the batch halving (that
      * escape hatch belongs to the main pass).
      */
-    async correctiveRetry(sessionId, originalUser, idList, validIds, knownSlugs) {
+    async correctiveRetry(sessionId, system, originalUser, idList, validIds, knownSlugs) {
         const caller = this.caller;
         if (caller === undefined)
             return { why: 'distill caller unavailable' };
@@ -531,7 +698,7 @@ export class Distiller {
         ].join('\n');
         let raw;
         try {
-            raw = await caller({ system: SYSTEM_PROMPT, user, purpose: 'topics-distill', sessionId, maxTokens: 4000 });
+            raw = await caller({ system, user, purpose: 'topics-distill', sessionId, maxTokens: 4000 });
         }
         catch (e) {
             return { why: `模型调用失败：${String(e instanceof Error ? e.message : e).slice(0, 160)}` };
@@ -560,7 +727,9 @@ export class Distiller {
      * GC/corrective path accounts for them, never a silent loss. Update ops
      * keep their narrower contract (slug only).
      */
-    async enforceSchema(sessionId, originalUser, ops, budgetLeft) {
+    async enforceSchema(sessionId, system, originalUser, ops, budgetLeft, branch) {
+        const lesson = branch === 'lesson';
+        const check = lesson ? checkLessonSchema : checkCreateSchema;
         const valid = [];
         const invalid = [];
         for (const op of ops) {
@@ -568,11 +737,11 @@ export class Distiller {
                 valid.push(op);
                 continue;
             }
-            const check = checkCreateSchema(op);
-            if (check.valid)
+            const verdict = check(op);
+            if (verdict.valid)
                 valid.push(op);
             else
-                invalid.push({ op, key: opKey(op), missing: check.missing });
+                invalid.push({ op, key: opKey(op), missing: verdict.missing });
         }
         if (invalid.length === 0)
             return { finalOps: valid, drops: [], retrySpent: 0 };
@@ -587,7 +756,7 @@ export class Distiller {
                 retrySpent: 0,
             };
         }
-        const rescued = await this.schemaRetryCall(sessionId, originalUser, invalid);
+        const rescued = await this.schemaRetryCall(sessionId, system, originalUser, invalid, branch);
         if (rescued === undefined) {
             return {
                 finalOps: valid,
@@ -602,7 +771,7 @@ export class Distiller {
         const drops = [];
         for (const c of invalid) {
             const replacement = rescued.get(c.key);
-            if (replacement !== undefined && checkCreateSchema(replacement).valid) {
+            if (replacement !== undefined && check(replacement).valid) {
                 valid.push(replacement);
             }
             else {
@@ -617,22 +786,27 @@ export class Distiller {
      * or undefined when the call itself failed / output was unparseable — the
      * caller then ledgeres `distill-op-retry-exhausted` for every deficient op.
      */
-    async schemaRetryCall(sessionId, originalUser, invalid) {
+    async schemaRetryCall(sessionId, system, originalUser, invalid, branch) {
         const caller = this.caller;
         if (caller === undefined)
             return undefined;
         const list = invalid.map((c) => `- create「${typeof c.op.title === 'string' ? c.op.title : ''}」（缺：${c.missing}）`).join('\n');
+        // The completion demand names the branch's own required fields; the topic
+        // line is byte-identical to its pre-lesson-branch form.
+        const instruction = branch === 'lesson'
+            ? '请只重新输出这些 op 的补全版本（严格 JSON，{"ops":[...]}）：每个 create 必须带 triggers（恰好 3-8 个 condition 触发短语）与 conclusion（祈使句行动指令），scope 只能是 workspace 或 global，并保留原有的 title/observed_ids 等字段。无法补全的 op 不要输出。'
+            : '请只重新输出这些 op 的补全版本（严格 JSON，{"ops":[...]}）：每个 create 必须带 description（一句话概括）与 triggers（恰好 3-8 条具体触发短语，禁止 dsh、配置、错误 之类的泛词），并保留原有的 title/conclusion/observed_ids 等字段。无法补全的 op 不要输出。';
         const user = [
             originalUser,
             '',
             '---',
             'schema 补问：你上一次返回的以下 create op 缺少必填字段：',
             list,
-            '请只重新输出这些 op 的补全版本（严格 JSON，{"ops":[...]}）：每个 create 必须带 description（一句话概括）与 triggers（恰好 3-8 条具体触发短语，禁止 dsh、配置、错误 之类的泛词），并保留原有的 title/conclusion/observed_ids 等字段。无法补全的 op 不要输出。',
+            instruction,
         ].join('\n');
         let raw;
         try {
-            raw = await caller({ system: SYSTEM_PROMPT, user, purpose: 'topics-distill', sessionId, maxTokens: 4000 });
+            raw = await caller({ system, user, purpose: 'topics-distill', sessionId, maxTokens: 4000 });
         }
         catch {
             return undefined;
@@ -670,6 +844,11 @@ export class Distiller {
      * the store transaction (先落 topic 再建边 — one write, no separate edge
      * pass). The set is locally seeded with this call's predicted op slugs and
      * grows as creates land, so same-batch references resolve in op order.
+     *
+     * Lesson creates (B2) ride the same sanitation and consume their
+     * observations through the same observed_ids bridge; the write goes through
+     * saveTopic's lesson branch (kind:'lesson', confidence hint, distilled
+     * provenance) — the observation→mark closure is identical to topics.
      */
     async applyOps(ops, validIds, knownSlugs) {
         const slugs = new Set(knownSlugs);
@@ -708,20 +887,39 @@ export class Distiller {
                 if (op.op === 'create' && typeof op.title === 'string' && typeof op.conclusion === 'string') {
                     const links = await this.acceptLinks(op, slugs);
                     applied.rejectedLinks += links.rejected;
-                    const res = await this.service.saveTopic({
-                        title: op.title,
-                        conclusion: op.conclusion,
-                        description: op.description,
-                        tags: op.tags,
-                        triggers: Array.isArray(op.triggers) ? op.triggers.filter((t) => typeof t === 'string') : undefined,
-                        depends: op.depends,
-                        openQuestions: op.open_questions,
-                        impact: op.impact,
-                        recommendations: op.recommendations,
-                        status: op.status === 'stable' ? 'stable' : 'draft',
-                        source: 'distill',
-                        links: links.targets,
-                    });
+                    const res = op.kind === 'lesson'
+                        ? // Lesson data plane (B2 §6.2): the draft lands as a hint with
+                            // distilled provenance — status derives from confidence, and
+                            // promotion to established is the B4 approval gate's exclusive
+                            // write path (setLessonStatus), so `status` is NOT taken from
+                            // the op. Scope: the op's explicit choice, default workspace
+                            // (lesson 必带 scope, global 需显式).
+                            await this.service.saveTopic({
+                                title: op.title,
+                                kind: 'lesson',
+                                conclusion: op.conclusion,
+                                description: op.description,
+                                triggers: Array.isArray(op.triggers) ? op.triggers.filter((t) => typeof t === 'string') : undefined,
+                                scope: op.scope === 'global' ? 'global' : 'workspace',
+                                confidence: 'hint',
+                                lessonSource: 'distilled',
+                                source: 'distill',
+                                links: links.targets,
+                            })
+                        : await this.service.saveTopic({
+                            title: op.title,
+                            conclusion: op.conclusion,
+                            description: op.description,
+                            tags: op.tags,
+                            triggers: Array.isArray(op.triggers) ? op.triggers.filter((t) => typeof t === 'string') : undefined,
+                            depends: op.depends,
+                            openQuestions: op.open_questions,
+                            impact: op.impact,
+                            recommendations: op.recommendations,
+                            status: op.status === 'stable' ? 'stable' : 'draft',
+                            source: 'distill',
+                            links: links.targets,
+                        });
                     applied.created.push(res.slug);
                     applied.consumedSlugs.push(res.slug);
                     slugs.add(res.slug);

package/lib/index.js

@@ -751,10 +751,11 @@ export async function apply(ctx, config = {}) {
     // `agent/created` listener and a throw or rejection ROLLS THE ENTIRE AGENT
     // CREATION BACK. This listener is therefore total and synchronous — it
     // never throws, never returns a promise — and the chain is deferred off
-    // the creation transaction entirely (setImmediate, unref'd): the pull /
+    // the creation transaction entirely (1.5s unref'd timer): the pull /
     // replay-distill / consolidation slow work starts only after the serial
-    // dispatch has moved on. Plugin initialization must never block, delay,
-    // or abort session startup; a chain failure at most warns.
+    // dispatch has moved on and the first frame is up. Plugin initialization
+    // must never block, delay, or abort session startup; a chain failure at
+    // most warns.
     const runBootChain = (sessionId) => {
         // Contained at the top too: a synchronous prologue throw (config read,
         // sync bookkeeping) must degrade to a warn, not leak toward the host.
@@ -852,11 +853,14 @@ export async function apply(ctx, config = {}) {
             const sessionId = String(payload?.agent?.id ?? '');
             if (sessionId === '')
                 return;
-            // Off the creation transaction: the unref'd immediate fires after the
-            // current serial dispatch slice, so the chain's synchronous prologue
-            // (config read, sync state) never delays the remaining listeners nor
-            // the loop start, and the timer cannot hold a dying process open.
-            const deferred = setImmediate(() => runBootChain(sessionId));
+            // Off the creation transaction AND off the boot window: the unref'd
+            // 1.5s timer fires after the serial dispatch has fully moved on and
+            // after the host's first frame, so the pull's git/DNS child processes
+            // never compete with startup I/O on a cold (possibly network-starved)
+            // machine — the 2026-10-19 boot-stall report showed the boot window
+            // and the fetch share the same constrained threadpool on a flaky VPN.
+            // The timer cannot hold a dying process open.
+            const deferred = setTimeout(() => runBootChain(sessionId), 1500);
             deferred.unref?.();
         }
         catch (error) {

package/lib/pipeline-events.d.ts

@@ -17,8 +17,11 @@
  *  the slow lane's per-run disposition row (quality.ts); the distill/link
  *  kinds are the A2/A6 producers' contract — they import this module. The
  *  two `seam-*` kinds are the B-line dual-write audit trail (卷二 §6.2:
- *  caller-identity audit — opts.actor — rides every seam call). */
-export type PipelineEventKind = 'slow-lane-outcome' | 'distill-op-invalid' | 'distill-op-retry-exhausted' | 'link-ref-rejected' | 'seam-observations-fed' | 'seam-lesson-status';
+ *  caller-identity audit — opts.actor — rides every seam call).
+ *  `lesson-conflict-flagged` is the lesson distill branch's conflict
+ *  self-check flag (B2 决议 5): informational for the B4 approval surface —
+ *  the draft still lands as hint, no lifecycle state changes on this event. */
+export type PipelineEventKind = 'slow-lane-outcome' | 'distill-op-invalid' | 'distill-op-retry-exhausted' | 'link-ref-rejected' | 'seam-observations-fed' | 'seam-lesson-status' | 'lesson-conflict-flagged';
 /** File NAME inside the bundle's meta dir (path via pipelineEventsFile). */
 export declare const PIPELINE_EVENTS_FILE = "pipeline-events.jsonl";
 export interface PipelineEvent {