@arcfold/dsh 0.0.0-stage → 0.4.0

package/src/tree/learning.mjs

@@ -0,0 +1,202 @@
+import { CONTRACT, canonicalJson, digest, fail, jsonClone, sourceRefs } from './contracts.mjs';
+import { ItemService } from './items.mjs';
+import { validateOutput, resolveSourceIds } from './prompts.mjs';
+import { ScriptWriter } from './script-writer.mjs';
+import { learningCorrections, LearningObservations, quotedSource } from './observations.mjs';
+import { MetricsService } from './metrics.mjs';
+
+const program = { kind: 'program', id: 'tree-learning' };
+const unique = values => [...new Map(values.map(v => [canonicalJson(v), v])).values()];
+export function itemInput({ item, version, method }) {
+  return { id: item.id, version: item.activeVersion, nodeId: item.nodeId, kind: item.kind, sourceKind: version.sourceKind, userProtected: item.userProtected,
+    originNodeId: item.originNodeId, originChain: item.originChain, content: version.content, method: method ?? null, validation: item.validation };
+}
+export function proposalInput(output, envelope) {
+  const refs = ids => resolveSourceIds(ids, envelope);
+  const method = proposal => {
+    const { sourceIds, origin: _origin, ...value } = proposal;
+    const category = envelope.trigger.directRequirement?.category;
+    return { ...value, expectedEffect: value.expectedEffect ?? { category, change: ['approved', 'adopted_proposal', 'confirmed_inference', 'proceeded'].includes(category) ? 'more' : 'less', text: `遵守本轮明确要求（${category}）` }, sourceRefs: refs(sourceIds) };
+  };
+  return { nodeId: envelope.scope.nodeIds[0], understandings: (output.understandings ?? []).map(({ sourceIds, origin: _origin, ...value }) => ({ ...value, sourceRefs: refs(sourceIds) })),
+    methods: (output.methods ?? []).map(method), supplements: (output.supplements ?? []).map(({ sourceIds, ...value }) => {
+      const actual = refs(sourceIds); if (!actual.some(ref => envelope.sources.some(s => digest(s.ref) === digest(ref) && s.role === 'user' && s.origin === 'user'))) fail('SUPPLEMENT_USER_REQUIRED', 'Learning supplements need a real user requirement');
+      return { ...value, sourceRefs: actual, traitEvidence: actual, universalStopgap: false };
+    }), revisions: (output.revisions ?? []).map(({ sourceIds, correctionEvidence: _evidence, ...value }) => ({ ...value, sourceRefs: refs(sourceIds) })) };
+}
+export function itemServiceFor(repo, resolveSource, job, corrections) {
+  const correction = job.trigger.correction;
+  return new ItemService({ repository: repo, resolveSource, context: () => ({ actor: { kind: 'model', id: job.id, role: job.role }, nodeIds: job.nodeIds,
+    ...(correction ? { correction: { ...correction, sourceRefs: resolveSourceIds(correction.sourceIds, job.input) } } : {}), ...(corrections ? { corrections } : {}) }) });
+}
+
+export class LearningService {
+  constructor({ repository, experience, contextBuilder, consolidation, jobs, modelConfig, signals, writerRouter, annotations = () => ({}), outputProtocol = 'correction-v1' }) {
+    Object.assign(this, { repo: repository, experience, builder: contextBuilder, consolidation, jobs, config: modelConfig, signals, writers: writerRouter, annotations, outputProtocol });
+    this.resolveSource = contextBuilder.resolveSource;
+    this.observations = new LearningObservations({ repository, metrics: new MetricsService({ repository, experience, signals }) });
+  }
+  existing(turn, nodeId) {
+    return this.repo.list('tree_jobs', j => j.role === 'learning' && j.trigger.turnId === turn.id && j.nodeIds[0] === nodeId && j.input.currentTurn.assignmentRevision === turn.assignmentRevision)
+      .sort((a, b) => b.enqueuedOrder - a.enqueuedOrder || b.createdAt.localeCompare(a.createdAt) || b.id.localeCompare(a.id))[0];
+  }
+  enqueue(turnId, nodeId) {
+    const turn = this.repo.get('tree_turns', turnId);
+    if (!turn || turn.status !== 'settled' || !turn.nodeIds.includes(nodeId)) fail('LEARNING_EXPERIENCE', 'Learning needs a settled own main turn');
+    const baseKey = digest(['turn-learning', turnId, nodeId, turn.assignmentRevision]), old = this.existing(turn, nodeId);
+    const session = this.repo.list('tree_learning_sessions', s => s.nodeId === nodeId)[0];
+    // Only an append stopped before submission may be frozen again after a
+    // successful epoch change. Paid/unknown and ordinary failures never retry.
+    const deferred = old?.status === 'failed' && old.error?.code === 'LEARNING_PRESSURE' && !old.submittedAt && !old.invocationIds.length;
+    if (old && (!deferred || session?.paused || session?.contextEpoch <= old.contextEpoch)) return old;
+    const key = old ? digest(['epoch-learning', baseKey, session.contextEpoch]) : baseKey;
+    // Freeze after previous receipts, not eagerly while an earlier turn is still
+    // producing the very constraints and acknowledgements this turn must read.
+    if (this.repo.list('tree_jobs', j => ['learning', 'consolidation'].includes(j.role) && j.nodeIds.includes(nodeId) && !['committed', 'failed', 'invalid_output', 'stale', 'cancelled'].includes(j.status)).length) fail('NODE_BUSY', 'Earlier learning/summary must settle before freezing the next turn');
+    const turns = this.experience.turns(nodeId, { includeInterrupted: false });
+    for (const prior of turns.slice(0, turns.findIndex(t => t.id === turnId))) {
+      const previous = this.existing(prior, nodeId);
+      if (!previous || !['committed', 'failed', 'invalid_output', 'stale', 'cancelled'].includes(previous.status)) fail('NODE_ORDER', 'Prior own experience has not been processed');
+    }
+    const material = this.experience.material(turn); if (material.revokedRefs.length) fail('SOURCE_CHANGED', 'Original experience was withdrawn');
+    const context = this.builder.build([nodeId], 'learning'), rows = this.builder.activeItems(context.ancestorPaths.flat(), 'learning');
+    const priorTurns = turns.slice(0, turns.findIndex(t => t.id === turnId));
+    const observed = this.outputProtocol === 'correction-v1' ? { proposals: [], fragments: [], sources: [] } : this.observations.freeze(nodeId, priorTurns.map(t => t.id));
+    const previousSources = this.outputProtocol === 'correction-v1' && priorTurns.length ? this.experience.material(priorTurns.at(-1)).sources : priorTurns.flatMap(t => t.userSourceRefs.map(this.resolveSource)).filter(Boolean);
+    const sources = unique([...material.sources, ...previousSources, ...observed.sources]);
+    const annotations = jsonClone(this.annotations(turn, nodeId));
+    if (annotations.correction) {
+      const c = annotations.correction;
+      if (!Array.isArray(c.itemIds) || !Array.isArray(c.sourceIds) || !c.sourceIds.length || c.sourceIds.some(id => !material.sources.some(s => s.id === id && s.role === 'user' && s.origin === 'user'))) fail('CORRECTION_REQUIRED', 'Correction must be bound to the current actual user input');
+    }
+    const scopedItems = this.repo.list('tree_items', i => context.ancestorPaths.flat().includes(i.nodeId));
+    const historicalIds = (session?.history ?? []).flatMap(h => ['understandings', 'methods', 'supplements'].flatMap(k => h.receipt?.[k]?.itemIds ?? []));
+    const observedIds = new Set([...scopedItems.map(i => i.id), ...historicalIds]);
+    const receipts = this.repo.list('tree_change_events', e => e.ordinal > (session?.appliedChangeOrdinal ?? 0) && e.entityIds.some(key => key.startsWith('tree_items:') && observedIds.has(key.slice(11)) || key === 'tree_nodes:' + nodeId || key === 'tree_turns:' + turnId));
+    const rejectedOutputs = session ? this.repo.list('tree_jobs', j => j.role === 'learning' && j.nativeSessionId === session.sessionId && ['invalid_output', 'failed'].includes(j.status))
+      .map(j => ({ jobId: j.id, turnId: j.trigger.turnId ?? null, state: j.status, adopted: false, error: j.error ?? null, rawHash: j.rawHash ?? null, nativeLogRef: j.nativeLogRef ?? null })) : [];
+    const previousReceipt = session?.history?.at(-1)?.receipt ?? null;
+    const input = { inputVersion: CONTRACT, role: 'learning', ...(this.outputProtocol === 'correction-v1' ? { outputProtocol: this.outputProtocol } : {}), scope: { nodeIds: [nodeId], ancestorPaths: context.ancestorPaths, treeRevision: context.treeRevision }, sources, knownItems: rows.map(itemInput),
+      allowedIds: { nodeIds: context.ancestorPaths.flat(), fileIds: annotations.fileIds ?? [], subjectIds: [...rows.map(r => r.item.id), ...observed.proposals.map(p => p.id), ...observed.fragments.map(f => f.id)] }, changeReceipts: receipts,
+      ...(this.outputProtocol === 'correction-v1' ? {} : { observationContext: { proposals: observed.proposals, fragments: observed.fragments } }),
+      currentTurn: { id: turnId, sourceIds: material.sources.map(s => s.id), assignmentRevision: turn.assignmentRevision }, constraints: context.segments.filter(s => s.nodeId !== null),
+      previousReceipt: rejectedOutputs.length ? { ...(previousReceipt ?? {}), rejectedOutputs } : previousReceipt, epochSeed: this.consolidation.learningSeed(nodeId), rootOnly: nodeId === this.repo.rootId() };
+    const revisionSet = { ['tree_turns:' + turnId]: turn.revision };
+    for (const row of rows) revisionSet['tree_items:' + row.item.id] = row.item.revision;
+    // Node changes invalidate scope, but ordinary newer settled turns need not
+    // stale this input. TreeService separately marks affected jobs invalidated.
+    const trigger = { kind: 'settled_main_turn', producerRole: 'main', status: 'settled', turnId, watermark: digest([turnId, turn.assignmentRevision]),
+      ...(annotations.correction ? { correction: annotations.correction } : {}), ...(annotations.directRequirement ? { directRequirement: annotations.directRequirement } : {}) };
+    return this.jobs.enqueue({ role: 'learning', key, nodeIds: [nodeId], input, revisionSet, config: this.config('learning', { turnId, nodeIds: [nodeId] }), trigger });
+  }
+  applyResult(result, { job, requestId }) {
+    const output = validateOutput('learning', result, job.input), turn = this.repo.get('tree_turns', job.trigger.turnId);
+    if (turn?.status !== 'settled' || !turn.nodeIds.includes(job.nodeIds[0]) || turn.assignmentRevision !== job.input.currentTurn.assignmentRevision) fail('JOB_STALE', 'Experience assignment changed');
+    // A current, source-bound correction can produce at most one item. An
+    // ordinary statement or a model inference alone cannot become learning.
+    const selected = { ...output, understandings: [], methods: [], supplements: [], revisions: [] };
+    const revision = output.revisions.find(value => value.correctionEvidence?.quotes?.length || job.trigger.correction?.itemIds?.includes(value.targetId));
+    if (revision) {
+      selected.understandings = [output.understandings[revision.replacedByIndex]];
+      selected.revisions = [{ ...revision, replacedByIndex: 0 }];
+    } else if (output.correctionClaim) {
+      const { kind, quote } = output.correctionClaim;
+      quotedSource(job.input, quote, 'user');
+      const partition = kind === 'understanding' ? 'understandings' : 'methods';
+      const item = output[partition].find(value => value.sourceIds.includes(quote.sourceId));
+      if (item) selected[partition] = [item];
+    }
+    return this.repo.transaction(() => {
+      const items = itemServiceFor(this.repo, this.resolveSource, job, learningCorrections(selected, job.input)), input = proposalInput(selected, job.input);
+      const receipt = items.commitProposal({ requestId: digest([requestId, 'items']), expected: job.inputRevisionSet, input }).result;
+      const categories = this.signals.recordCategories(output.categories, { job, requestId });
+      // Per-turn learning is limited to corrections and feedback categories.
+      // Do not promote model-extracted proposals, results or decisions into
+      // additional observation records; old records remain available to read.
+      const methodIds = receipt.methods.itemIds ?? [];
+      this.repo.command('recordLearningOrigins', { requestId, expected: {}, input: { jobId: job.id, receipt, categories } }, program, () => {
+        for (const partition of ['understandings', 'methods', 'supplements']) for (const id of receipt[partition].itemIds ?? []) {
+          const item = this.repo.get('tree_items', id); this.repo.save('tree_items', { ...item, producerJobId: job.id, producerRole: 'learning', sourceTurnId: turn.id }, item.revision);
+        }
+        for (const intent of this.repo.list('tree_jobs', j => !j.role && j.kind === 'learning' && j.scopeKey === job.nodeIds[0] && j.input.turnId === turn.id && j.input.assignmentRevision === turn.assignmentRevision && j.status === 'queued')) this.repo.save('tree_jobs', { ...intent, status: 'committed', ownedJobId: job.id }, intent.revision);
+        const meta = this.repo.meta();
+        if (!meta.progressEvidence?.[turn.id]) this.repo.save('tree_meta', { ...meta, progressEvidence: { ...meta.progressEvidence, [turn.id]: { turnId: turn.id, assignmentRevision: turn.assignmentRevision,
+          sourceRefs: this.experience.material(turn).sources.filter(s => s.role === 'assistant' && s.origin === 'model' || s.role === 'tool').map(s => s.ref), state: 'unclassified', confirmedOutputs: [], confirmedDecisions: [] } } }, meta.revision);
+        return { receipt, categories };
+      });
+      if (!this.writers && methodIds.some(id => this.repo.get('tree_items', id).lifecycle === 'draft')) fail('WRITER_ROUTER_REQUIRED', 'Script proposals require the owned writer router');
+      const writerJobs = this.writers ? methodIds.flatMap(id => this.writers.enqueueDraft(id, job).map(j => j.id)) : [];
+      return { ...receipt, categories, writerJobs };
+    });
+  }
+}
+
+/** Routes script creation only. Execution remains the separate native main tool. */
+export class WriterRouter {
+  constructor({ repository, jobs, modelConfig, artifacts, createWriterOptions, defineTool }) { Object.assign(this, { repo: repository, jobs, config: modelConfig, artifacts, createWriterOptions, defineTool }); this.instances = new Map(); }
+  request(input, { job, callId, nodeId, exposureId }) {
+    // B7 supplies these identities after validating the live native main call.
+    // Neither the model tool arguments nor generated files select an owner.
+    if (job.role !== 'main' || !job.nodeIds.includes(nodeId) || !callId) fail('MAIN_REQUIRED', 'An admitted native main call in this node is required');
+    this.jobs.assertCurrent(job);
+    const requestId = digest(['main-script-request', job.id, callId]), old = this.repo.get('tree_receipts', digest(['receipt', requestId]));
+    if (old) { if (old.result.requestHash !== digest(input)) fail('IDEMPOTENCY_CONFLICT', 'Native script request changed'); return old.result; }
+    const sourceRefs = resolveSourceIds(input.evidenceIds, job.input);
+    if (!sourceRefs.length) fail('WRITER_REQUEST_SOURCE', 'evidenceIds must include a current evidence id');
+    if (input.fileRefs.some(id => !job.input.allowedIds.fileIds?.includes(id))) fail('WRITER_REQUEST_SOURCE', 'fileRefs accepts only supplied logical file ids, not paths. If no file ids were supplied use []; describe workspace paths in purpose for the author to inspect.');
+    const scriptRequest = { purpose: input.purpose, evidence: input.evidenceIds, files: input.fileRefs };
+    const service = new ItemService({ repository: this.repo, resolveSource: this.artifacts.resolveSource, context: () => ({ actor: program }) });
+    return this.repo.transaction(() => {
+      let methodId = input.methodId;
+      if (methodId) {
+        const item = this.repo.get('tree_items', methodId);
+        if (!item || item.nodeId !== nodeId || item.kind !== 'method' || item.lifecycle !== 'active' || item.activeVersion !== input.expectedVersion || item.userProtected) fail('METHOD_REQUEST_SCOPE', 'Existing script request must target an own current unprotected method');
+        const version = this.repo.get('tree_item_versions', digest(['item_version', item.id, item.activeVersion]));
+        service.review({ requestId: digest([requestId, 'draft']), expected: { ['tree_items:' + item.id]: item.revision }, input: { itemId: item.id, version: item.activeVersion, exposureId, operation: 'rewrite', reason: '当前主轮请求制作脚本', sourceRefs,
+          windowId: requestId, opportunityRefs: [], replacement: { ...version.content, scriptRequests: [scriptRequest] } } });
+      } else {
+        const proposed = { kind: 'technique', short: null, long: { name: '当前明确请求的脚本', description: '按当前委托制作并提供调用说明', whenToUse: '', steps: input.purpose, pitfalls: '', verify: '' }, hooks: [], scriptRequests: [scriptRequest],
+          expectedEffect: { category: 'omitted', change: 'less', text: '当前明确要求的脚本可供调用' }, sourceRefs };
+        const receipt = service.commitProposal({ requestId: digest([requestId, 'draft']), expected: {}, input: { nodeId, understandings: [], methods: [proposed], supplements: [] } }).result;
+        if (receipt.methods.status !== 'applied') fail('SCRIPT_REQUEST_INVALID', receipt.methods.reason); methodId = receipt.methods.itemIds[0];
+      }
+      const jobs = this.enqueueDraft(methodId, job, { explicit: true });
+      return this.repo.command('requestMethodScript', { requestId, expected: {}, input }, program, () => ({ methodId, jobId: jobs[0].id, state: 'queued', requestHash: digest(input) })).result;
+    });
+  }
+  enqueueDraft(methodId, parentJob, { explicit = false } = {}) {
+    const item = this.repo.get('tree_items', methodId); if (!item || item.lifecycle !== 'draft') return [];
+    const bundle = this.repo.get('tree_methods', digest(['method', methodId, item.draftVersion]));
+    return bundle.pendingScriptRequests.map((request, requestIndex) => {
+      const key = digest(['write-method-script', methodId, item.draftVersion, requestIndex]), prior = this.repo.get('tree_jobs', digest(['model_job', 'script_writer', key])); if (prior) return prior;
+      const sources = parentJob.input.sources.filter(s => request.evidence.includes(s.id));
+      if (sources.length !== new Set(request.evidence).size || !sources.length || request.files.some(id => !parentJob.input.allowedIds.fileIds?.includes(id))) fail('WRITER_REQUEST_SOURCE', 'Script request must bind its source and allowed file references');
+      const binding = { methodId, draftVersion: item.draftVersion, requestIndex, scriptId: digest(['method-script', methodId, item.draftVersion, requestIndex]), version: 1 };
+      return this.jobs.enqueue({ role: 'script_writer', key, nodeIds: [item.nodeId], revisionSet: { ['tree_items:' + item.id]: item.revision }, config: this.config('script_writer', { parentJobId: parentJob.id, nodeIds: [item.nodeId] }),
+        trigger: { kind: explicit ? 'explicit_script_request' : 'learned_script_request', producerRole: parentJob.role, methodId, parentJobId: parentJob.id },
+        input: { scope: { nodeIds: [item.nodeId], ancestorPaths: [this.repo.ancestors(item.nodeId).map(n => n.id)], treeRevision: this.repo.meta().treeRevision }, sources, knownItems: [], allowedIds: { nodeIds: [item.nodeId], fileIds: request.files, subjectIds: [] }, changeReceipts: [], request, binding } });
+    });
+  }
+  writer(job) {
+    if (job.role !== 'script_writer') fail('WRITER_BINDING', 'Only an owned writer job may mount these tools');
+    let writer = this.instances.get(job.id);
+    if (!writer) {
+      const options = this.createWriterOptions(job);
+      writer = new ScriptWriter({ ...options, repository: this.repo, artifacts: this.artifacts, binding: { ...job.input.binding, jobId: job.id }, assertJob: id => {
+        const current = this.jobs.get(id); this.jobs.assertCurrent(current); return ['prepared', 'submitted', 'result_received', 'validated', 'committed'].includes(current.status);
+      } }); this.instances.set(job.id, writer);
+    }
+    return writer;
+  }
+  mount(agentContext, job) { this.writer(job).mount(agentContext, this.defineTool); }
+  applyResult(output, { job }) { return this.writer(job).verifyFinal(output); }
+  activateReady(methodId, draftVersion) {
+    const item = this.repo.get('tree_items', methodId);
+    if (item?.lifecycle === 'active' && item.activeVersion === draftVersion + 1) return { itemId: item.id, version: item.activeVersion, duplicate: true };
+    if (!item || item.lifecycle !== 'draft' || item.draftVersion !== draftVersion) fail('JOB_STALE', 'Method draft changed before activation');
+    const bundle = this.repo.get('tree_methods', digest(['method', methodId, draftVersion]));
+    const jobs = bundle.pendingScriptRequests.map((_, index) => this.repo.get('tree_jobs', digest(['model_job', 'script_writer', digest(['write-method-script', methodId, draftVersion, index])])));
+    if (jobs.some(j => !j || j.status !== 'committed')) return { itemId: methodId, state: jobs.some(j => j?.status === 'unknown') ? 'unknown' : jobs.some(j => ['failed', 'invalid_output', 'stale', 'cancelled'].includes(j?.status)) ? 'failed' : 'queued' };
+    return this.artifacts.activate({ methodId, draftVersion, artifactIds: jobs.map(j => j.resultRef.artifactId), requestId: digest(['activate-method-scripts', methodId, draftVersion]) }).result;
+  }
+}

package/src/tree/metrics.mjs

@@ -0,0 +1,203 @@
+import { canonicalJson, digest, fail, CATEGORIES, integer, text } from './contracts.mjs';
+import { effectiveSignals, signalPolarity } from './signals.mjs';
+
+export const METRIC_VERSION = 'arcfold.observed-metrics/1';
+const program = { kind: 'program', id: 'tree-metrics' };
+const unique = values => [...new Map(values.map(v => [canonicalJson(v), v])).values()];
+export function ratio(numerator, denominator) {
+  if (!denominator) return { numerator, denominator, value: null, interval: null };
+  const p = numerator / denominator, z = 1.95996398454, d = 1 + z * z / denominator, center = (p + z * z / (2 * denominator)) / d, margin = z * Math.sqrt(p * (1 - p) / denominator + z * z / (4 * denominator * denominator)) / d;
+  return { numerator, denominator, value: p, interval: [Math.max(0, center - margin), Math.min(1, center + margin)], intervalMethod: 'Wilson95-descriptive-not-causal' };
+}
+
+export class MetricsService {
+  constructor({ repository, experience, signals }) { Object.assign(this, { repo: repository, experience, signals }); this.resolveSource = signals.resolveSource; }
+  ordinal(kind, id, { first = false } = {}) {
+    const values = this.repo.list('tree_change_events', e => e.entityIds.includes(kind + ':' + id) && (!first || e.beforeVersions[e.entityIds.indexOf(kind + ':' + id)] === 0)).map(e => e.ordinal);
+    return values.length ? (first ? Math.min(...values) : Math.max(...values)) : 0;
+  }
+  turns(scopeNodeId = null) {
+    return this.repo.list('tree_turns', t => t.status === 'settled' && (!scopeNodeId || t.nodeIds.includes(scopeNodeId))).map(t => ({ ...t, ordinal: this.ordinal('tree_turns', t.id, { first: true }) })).sort((a, b) => a.ordinal - b.ordinal || a.id.localeCompare(b.id));
+  }
+  proposal({ proposalRef, nodeIds, requestId, start = 0, end }) {
+    const source = this.resolveSource(proposalRef); if (source?.role !== 'assistant' || source.origin !== 'model') fail('PROPOSAL_SOURCE', 'An actual assistant proposal source is required');
+    end ??= source.text.length; integer(start, 'start', 0, source.text.length); integer(end, 'end', start + 1, source.text.length);
+    const turn = this.repo.list('tree_turns', t => t.status === 'settled' && t.experienceRefs?.some(ref => digest(ref) === digest(proposalRef)))[0];
+    if (!turn || !nodeIds.length || nodeIds.some(id => !turn.nodeIds.includes(id))) fail('PROPOSAL_SCOPE', 'A proposal must belong to the actual settled turn');
+    const id = digest(['initiative-proposal', proposalRef, start, end]);
+    return this.repo.command('recordInitiativeProposal', { requestId, expected: {}, input: { proposalRef, nodeIds, start, end } }, program, () => {
+      const meta = this.repo.meta(), old = meta.proposals?.[id];
+      if (!old || nodeIds.some(n => !old.nodeIds.includes(n))) this.repo.save('tree_meta', { ...meta, proposals: { ...meta.proposals, [id]: old ? { ...old, nodeIds: [...new Set([...old.nodeIds, ...nodeIds])] } : { id, proposalRef, start, end, nodeIds, turnId: turn.id, state: 'unknown', responseRefs: [], ordinal: meta.lastEventOrdinal + 1 } } }, meta.revision); return { proposalId: id };
+    }).result;
+  }
+  respond({ proposalId, outcome, responseRefs, requestId }) {
+    if (!['adopted', 'rejected', 'ignored', 'unknown'].includes(outcome)) fail('PROPOSAL_OUTCOME', 'Unknown proposal outcome');
+    const proposal = this.repo.meta().proposals?.[proposalId]; if (!proposal) fail('PROPOSAL_NOT_FOUND', 'Proposal missing');
+    if (outcome !== 'unknown' && !responseRefs.length || responseRefs.some(ref => { const s = this.resolveSource(ref); return s?.role !== 'user' || s.origin !== 'user'; })) fail('USER_SOURCE_REQUIRED', 'A known proposal outcome needs actual human response');
+    for (const ref of responseRefs) this.responseTurn(proposal.turnId, proposal.nodeIds, ref);
+    // Called only from trusted source-bound classification, not text matching.
+    return this.repo.command('recordProposalOutcome', { requestId, expected: {}, input: { proposalId, outcome, sourceRefs: responseRefs } }, program, () => {
+      const meta = this.repo.meta(), old = meta.proposals[proposalId];
+      this.repo.save('tree_meta', { ...meta, proposals: { ...meta.proposals, [proposalId]: { ...old, state: outcome, responseRefs, history: [...(old.history ?? []), { outcome, responseRefs, ordinal: meta.lastEventOrdinal + 1 }] } } }, meta.revision); return { proposalId, outcome };
+    }).result;
+  }
+  responseTurn(beforeTurnId, nodeIds, ref) {
+    const before = this.repo.get('tree_turns', beforeTurnId), response = this.repo.list('tree_turns', t => t.status === 'settled' && t.userSourceRefs.some(r => digest(r) === digest(ref)))[0];
+    if (!before || !response || !response.nodeIds.some(id => nodeIds.includes(id) && before.nodeIds.includes(id))) fail('PROPOSAL_SCOPE', 'Response belongs to another goal');
+    if (this.ordinal('tree_turns', response.id, { first: true }) <= this.ordinal('tree_turns', before.id, { first: true })) fail('RESPONSE_ORDER', 'A response must follow the actual result');
+    return response;
+  }
+  // The integration classifier must identify a task fragment explicitly. Broad
+  // proceeded/redo labels alone cannot establish that this was a first attempt.
+  fragment({ firstResultRef, nodeIds, fragmentKey, requestId, outputPaths = [], span }) {
+    text(fragmentKey, 'fragmentKey', 256); const source = this.resolveSource(firstResultRef);
+    const turn = this.repo.list('tree_turns', t => t.status === 'settled' && t.experienceRefs?.some(r => digest(r) === digest(firstResultRef)))[0];
+    if (source?.role !== 'assistant' || source.origin !== 'model' || !turn || !nodeIds.length || nodeIds.some(id => !turn.nodeIds.includes(id))) fail('FRAGMENT_SOURCE', 'A fragment needs its actual first assistant result');
+    if (span) { integer(span.start, 'start', 0, source.text.length); integer(span.end, 'end', span.start + 1, source.text.length); }
+    if (!Array.isArray(outputPaths) || outputPaths.some(p => typeof p !== 'string' || !p || p.startsWith('/') || p.split('/').includes('..'))) fail('FRAGMENT_OUTPUTS', 'Output paths must be workspace-relative evidence from the trusted result classifier');
+    const id = digest(['task-fragment', firstResultRef, fragmentKey]);
+    return this.repo.command('recordTaskFragment', { requestId, expected: {}, input: { firstResultRef, nodeIds, fragmentKey, outputPaths, ...(span ? { span } : {}) } }, program, () => {
+      const meta = this.repo.meta(), old = meta.taskFragments?.[id];
+      if (!old || nodeIds.some(n => !old.nodeIds.includes(n))) this.repo.save('tree_meta', { ...meta, taskFragments: { ...meta.taskFragments, [id]: old ? { ...old, nodeIds: [...new Set([...old.nodeIds, ...nodeIds])] } : { id, firstResultRef, nodeIds, turnId: turn.id, fragmentKey, outputPaths, feedbackRefs: [], ...(span ? { span } : {}) } } }, meta.revision); return { fragmentId: id };
+    }).result;
+  }
+  fragmentFeedback({ fragmentId, responseRefs, requestId, outcome }) {
+    const fragment = this.repo.meta().taskFragments?.[fragmentId]; if (!fragment) fail('FRAGMENT_MISSING', 'Task fragment missing');
+    if (!responseRefs.length) fail('USER_SOURCE_REQUIRED', 'Actual feedback is required');
+    if (outcome !== undefined && !['proceeded', 'redo', 'unknown'].includes(outcome)) fail('FRAGMENT_OUTCOME', 'Unknown result feedback');
+    for (const ref of responseRefs) { const s = this.resolveSource(ref); if (s?.role !== 'user' || s.origin !== 'user') fail('USER_SOURCE_REQUIRED', 'Actual human feedback required'); this.responseTurn(fragment.turnId, fragment.nodeIds, ref); }
+    return this.repo.command('bindFragmentFeedback', { requestId, expected: {}, input: { fragmentId, responseRefs, ...(outcome === undefined ? {} : { outcome }) } }, program, () => {
+      const meta = this.repo.meta(), old = meta.taskFragments[fragmentId]; this.repo.save('tree_meta', { ...meta, taskFragments: { ...meta.taskFragments, [fragmentId]: { ...old, feedbackRefs: unique([...old.feedbackRefs, ...responseRefs]),
+        ...(outcome === undefined ? {} : { classifiedFeedback: [...(old.classifiedFeedback ?? []), { outcome, responseRefs, ordinal: meta.lastEventOrdinal + 1 }] }) } } }, meta.revision); return { fragmentId };
+    }).result;
+  }
+  freeze(scopeNodeId = null, { afterOrdinal = 0, throughOrdinal = this.repo.meta().lastEventOrdinal } = {}) {
+    integer(afterOrdinal, 'afterOrdinal', 0); integer(throughOrdinal, 'throughOrdinal', afterOrdinal);
+    if (scopeNodeId && !this.repo.get('tree_nodes', scopeNodeId)) fail('NODE_NOT_FOUND', 'Metric scope missing');
+    let turns = this.turns(scopeNodeId).filter(t => t.ordinal > afterOrdinal && t.ordinal <= throughOrdinal); if (!scopeNodeId && turns.length > 100) { turns = turns.slice(-100); afterOrdinal = Math.max(afterOrdinal, turns[0].ordinal - 1); }
+    const turnIds = new Set(turns.map(t => t.id)), refs = unique(turns.flatMap(t => t.userSourceRefs)), validRefs = refs.filter(ref => { const s = this.resolveSource(ref); return s?.role === 'user' && s.origin === 'user'; });
+    const messages = new Set(validRefs.map(digest)), signals = effectiveSignals(this.repo, this.resolveSource).filter(s => s.sourceRefs.some(ref => messages.has(digest(ref))));
+    const categoryRefs = names => new Set(signals.filter(s => names.includes(s.category)).flatMap(s => s.sourceRefs.filter(r => messages.has(digest(r))).map(digest)));
+    const counts = Object.fromEntries(CATEGORIES.map(name => [name, categoryRefs([name]).size]));
+    const negative = categoryRefs(CATEGORIES.filter(c => signalPolarity(c) === 'negative'));
+    const fragments = Object.values(this.repo.meta().taskFragments ?? {}).filter(f => (!scopeNodeId || f.nodeIds.includes(scopeNodeId)) && this.resolveSource(f.firstResultRef));
+    const restores = Object.values(this.repo.meta().restoreIntents ?? {}).filter(r => r.state === 'completed' && r.changes?.length).flatMap(r => {
+      const turnId = this.repo.get('tree_snapshots', r.snapshotId)?.logicalTurnId;
+      const ordinal = this.repo.list('tree_change_events', event => { const receipt = event.commandType === 'recordTreeRestore' && this.repo.get('tree_receipts', event.receiptId); return receipt?.result?.id === r.id && receipt.result.state === 'completed'; })[0]?.ordinal;
+      return turnId && ordinal ? [{ id: r.id, turnId, ordinal, paths: r.changes.map(c => c.path) }] : [];
+    });
+    const assessedFragments = fragments.flatMap(f => {
+      const feedback = this.turns().flatMap(t => t.userSourceRefs.filter(r => f.feedbackRefs.some(ref => digest(ref) === digest(r))).map(ref => ({ ref, ordinal: t.ordinal }))).sort((a, b) => a.ordinal - b.ordinal);
+      // A human message can accept result A and reject result B. Source-bound
+      // per-fragment classifications take precedence over broad message labels.
+      const classified = feedback.map(entry => ({ ...entry, classification: f.classifiedFeedback?.find(c => c.ordinal <= throughOrdinal && c.responseRefs.some(r => digest(r) === digest(entry.ref))) }));
+      const first = classified.find(entry => entry.classification ? entry.classification.outcome !== 'unknown' : effectiveSignals(this.repo, this.resolveSource).some(s => ['proceeded', 'redo'].includes(s.category) && s.sourceRefs.some(r => digest(r) === digest(entry.ref))));
+      const restore = restores.filter(r => r.turnId === f.turnId && r.paths.some(path => f.outputPaths?.includes(path))).sort((a, b) => a.ordinal - b.ordinal)[0];
+      if (restore && (!first || restore.ordinal < first.ordinal)) return restore.ordinal > afterOrdinal && restore.ordinal <= throughOrdinal ? [{ id: f.id, outcome: 'redo', restoreId: restore.id }] : [];
+      if (!first || !messages.has(digest(first.ref))) return [];
+      const categories = signals.filter(s => s.sourceRefs.some(r => digest(r) === digest(first.ref))).map(s => s.category);
+      return [{ id: f.id, outcome: first.classification?.outcome ?? (categories.includes('redo') ? 'redo' : 'proceeded'), ref: first.ref }];
+    });
+    const boundFeedback = new Set(fragments.flatMap(f => f.feedbackRefs).map(digest));
+    const proposals = Object.values(this.repo.meta().proposals ?? {}).filter(p => turnIds.has(p.turnId) && this.resolveSource(p.proposalRef)).map(p => {
+      const response = p.history?.filter(h => h.ordinal <= throughOrdinal).at(-1); return { ...p, state: response?.outcome ?? 'unknown', responseRefs: response?.responseRefs ?? [] };
+    });
+    const decidedProposals = proposals.filter(p => ['adopted', 'rejected', 'ignored'].includes(p.state) && p.responseRefs.length && p.responseRefs.every(this.resolveSource));
+    const inferred = new Map(), methods = new Map();
+    for (const item of this.repo.list('tree_items', i => !scopeNodeId || i.nodeId === scopeNodeId)) {
+      const versions = this.repo.list('tree_item_versions', v => v.itemId === item.id);
+      if (item.kind === 'understanding') for (const version of versions.filter(v => v.sourceKind === 'assistant_inferred')) {
+        const confirmation = versions.find(v => v.supersedes === version.version && v.confirmationRef && this.ordinal('tree_item_versions', v.id, { first: true }) > afterOrdinal && this.ordinal('tree_item_versions', v.id, { first: true }) <= throughOrdinal);
+        const evaluations = (item.reviews ?? []).filter(r => r.version === version.version && ['met', 'not_met'].includes(r.result) && r.opportunityRefs.some(ref => messages.has(digest(ref))));
+        if (confirmation || evaluations.length) inferred.set(item.id + ':' + version.version, confirmation ? 'met' : evaluations.at(-1).result);
+      }
+      if (item.kind === 'method') for (const evaluation of item.evaluations ?? []) {
+        const job = this.repo.list('tree_jobs', j => j.role === 'verification' && j.status === 'committed' && j.input.window?.id === evaluation.windowId)[0];
+        if (job && this.ordinal('tree_jobs', job.id) > afterOrdinal && this.ordinal('tree_jobs', job.id) <= throughOrdinal && job.input.window.throughTurnIds.some(id => turnIds.has(id))) methods.set(item.id + ':' + evaluation.version, evaluation);
+      }
+    }
+    const methodEvaluated = [...methods.values()].filter(e => e.opportunityCount > 0 && e.result !== 'unclear');
+    const hooks = this.signals.hookCandidates().filter(h => turnIds.has(h.logicalTurnId));
+    const unrecovered = hooks.filter(h => !h.recovered && !signals.some(s => s.category === 'omitted' && this.repo.list('tree_turns', t => t.sessionId === this.repo.get('tree_turns', h.logicalTurnId)?.sessionId && t.nativeTurn > this.repo.get('tree_turns', h.logicalTurnId)?.nativeTurn).sort((a, b) => a.nativeTurn - b.nativeTurn)[0]?.userSourceRefs.some(ref => s.sourceRefs.some(r => digest(r) === digest(ref)))));
+    const recurrentRefs = new Set(this.repo.list('tree_clusters', c => c.recurrence && !c.needsRecheck).flatMap(c => c.evidenceRefs ?? []).map(digest).filter(ref => negative.has(ref)));
+    const learned = this.repo.list('tree_items', i => ['understanding', 'method'].includes(i.kind) && (!scopeNodeId || i.nodeId === scopeNodeId) && this.ordinal('tree_items', i.id, { first: true }) <= throughOrdinal);
+    // Lifecycle rows are mutable; do not invent historical state when asked to
+    // reconstruct an older watermark. Saved live windows retain their snapshot.
+    const currentLifecycle = throughOrdinal === this.repo.meta().lastEventOrdinal;
+    const learningInventory = { learned: learned.length, methodsCreated: learned.filter(i => i.kind === 'method' && this.ordinal('tree_items', i.id, { first: true }) > afterOrdinal).length, invalidOrWithdrawn: currentLifecycle ? learned.filter(i => ['invalid', 'withdrawn'].includes(i.lifecycle) || i.validation === 'contradicted').length : null, historicalStateMissing: !currentLifecycle };
+    const rates = { understandingProblems: ratio(categoryRefs(['not_understood', 'misread', 'restart']).size, messages.size), negativeFeedback: ratio(negative.size, messages.size),
+      confirmedInferences: ratio([...inferred.values()].filter(v => v === 'met').length, inferred.size), adoption: ratio(decidedProposals.filter(p => p.state === 'adopted').length, decidedProposals.length),
+      firstPass: ratio(assessedFragments.filter(f => f.outcome === 'proceeded').length, assessedFragments.length), methodExpectations: ratio(methodEvaluated.filter(e => e.result === 'met').length, methodEvaluated.length), recurrence: ratio(recurrentRefs.size, negative.size) };
+    const scope = scopeNodeId ?? 'global', identity = [scope, afterOrdinal, throughOrdinal, turns.map(t => [t.id, t.assignmentRevision]), signals.map(s => s.id), [...inferred], [...methods], proposals, assessedFragments];
+    return { id: digest(['metric-window', identity]), scope, fromOrdinal: afterOrdinal, toOrdinal: throughOrdinal, observations: { logicalTurns: turns.length, userMessages: messages.size, turnIds: [...turnIds], counts,
+      strong: categoryRefs(['approved', 'adopted_proposal', 'confirmed_inference']).size, weakProgress: counts.proceeded, unresolvedProposals: proposals.filter(p => p.state === 'unknown').length, hookRecovered: hooks.filter(h => h.recovered).length, hookOmissionCandidates: unrecovered.length,
+      methodUnclear: [...methods.values()].filter(e => e.result === 'unclear').length, learningInventory, restores: restores.filter(r => r.ordinal > afterOrdinal && r.ordinal <= throughOrdinal && turnIds.has(r.turnId)).length, unboundRestores: restores.filter(r => r.ordinal > afterOrdinal && r.ordinal <= throughOrdinal && turnIds.has(r.turnId) && !fragments.some(f => f.turnId === r.turnId && r.paths.some(path => f.outputPaths?.includes(path)))).length, rates, growth: this.growth({ afterOrdinal, throughOrdinal, scopeNodeId }) },
+      numerators: Object.fromEntries(Object.entries(rates).map(([k, v]) => [k, v.numerator])), denominators: Object.fromEntries(Object.entries(rates).map(([k, v]) => [k, v.denominator])),
+      missing: { revokedUserSources: refs.length - validRefs.length, unboundFirstAttemptFeedback: [...categoryRefs(['proceeded', 'redo'])].filter(ref => !boundFeedback.has(ref)).length, unassessedInferences: this.repo.list('tree_items', i => i.kind === 'understanding' && i.validation === 'unverified' && (!scopeNodeId || i.nodeId === scopeNodeId)).length, unboundAdoptionSignals: signals.filter(s => s.category === 'adopted_proposal' && !s.subjectRefs.some(id => proposals.some(p => p.id === id))).length },
+      algorithmVersion: METRIC_VERSION, needsRecheck: false, caveat: '观察统计；沉默不等于认可，样本间未保证独立，不构成因果收益证明。' };
+  }
+  saveWindow(scopeNodeId, options) {
+    const value = this.freeze(scopeNodeId, options), existing = this.repo.get('tree_metric_windows', value.id); if (existing && !existing.needsRecheck) return existing;
+    return this.repo.command('recordMetricWindow', { requestId: digest(['metrics', value.id, existing?.revision ?? 0]), expected: {}, input: { scopeNodeId, from: value.fromOrdinal, to: value.toOrdinal } }, program, () => {
+      this.repo.save('tree_metric_windows', value, existing?.revision ?? null); return { windowId: value.id };
+    }).result.windowId && this.repo.get('tree_metric_windows', value.id);
+  }
+  compare(previous, current) {
+    if (!previous || !current || previous.needsRecheck || current.needsRecheck || previous.algorithmVersion !== current.algorithmVersion || previous.scope !== current.scope || previous.toOrdinal !== current.fromOrdinal || previous.observations.logicalTurns < 10 || current.observations.logicalTurns < 10) return { comparable: false, reason: '需要两个相邻、算法相同且各至少10轮的有效窗口', trends: {} };
+    const trends = Object.fromEntries(Object.entries(current.observations.rates).map(([name, now]) => { const before = previous.observations.rates[name]; return [name, now.value === null || before.value === null ? null : { previous: before.value, current: now.value, delta: now.value - before.value }]; }));
+    return { comparable: true, trends, notImproved: Object.entries(trends).filter(([name, value]) => value && (['understandingProblems', 'negativeFeedback', 'recurrence'].includes(name) ? value.delta >= 0 : value.delta <= 0)).map(([name]) => name), caveat: current.caveat };
+  }
+  observeTree(receipt, beforeNodes, { logicalTurnId = receipt.result?.turnId ?? null } = {}) {
+    const event = this.repo.get('tree_change_events', receipt.eventIds[0]); if (!event) fail('TREE_RECEIPT', 'Actual tree command receipt required');
+    if (logicalTurnId && !this.repo.get('tree_turns', logicalTurnId)) fail('TURN_NOT_FOUND', 'Tree observation must belong to a real turn');
+    const key = digest(['tree-observation', receipt.id]); if (this.repo.meta().treeObservations?.[key]) return this.repo.meta().treeObservations[key];
+    const observations = [];
+    for (const id of event.entityIds.filter(k => k.startsWith('tree_nodes:')).map(k => k.slice(11))) {
+      if (id === this.repo.rootId()) continue; const before = beforeNodes.find(n => n.id === id), after = this.repo.get('tree_nodes', id);
+      for (const type of ['created', 'name', 'parentId', 'status', 'deleted']) {
+        if (type === 'created' ? Boolean(before) : !before || canonicalJson(before[type] ?? null) === canonicalJson(after[type] ?? null)) continue;
+        const origin = type === 'status' && after.statusOrigin === 'cascade' ? 'cascade' : event.actor.kind === 'user' ? 'user' : event.actor.role === 'attribution' || event.commandType === 'applyAttribution' ? 'attribution' : 'assistant';
+        observations.push({ id: digest([key, id, type]), nodeId: id, type, before: before?.[type] ?? null, after: type === 'created' ? after.parentId : after[type], origin, ordinal: event.ordinal, sourceRefs: event.sourceRefs, commandReceiptId: receipt.id, logicalTurnId, reversalOf: receipt.result?.reversalOf ?? null,
+          beforeStatusOrigin: before?.statusOrigin ?? null, beforeCascadeFromId: before?.cascadeFromId ?? null, afterRevision: after.revision });
+      }
+    }
+    this.repo.command('observeTreeChanges', { requestId: key, expected: {}, input: { receiptId: receipt.id } }, program, () => { const meta = this.repo.meta(); this.repo.save('tree_meta', { ...meta, treeObservations: { ...meta.treeObservations, [key]: observations } }, meta.revision); return { observations }; }); return observations;
+  }
+  growth({ afterOrdinal = 0, throughOrdinal = this.repo.meta().lastEventOrdinal, scopeNodeId = null } = {}) {
+    const observations = Object.values(this.repo.meta().treeObservations ?? {}).flat().filter(o => o.ordinal > afterOrdinal && o.ordinal <= throughOrdinal && (!scopeNodeId || o.nodeId === scopeNodeId));
+    const all = Object.values(this.repo.meta().treeObservations ?? {}).flat();
+    const unreversed = observations.filter(o => !o.reversalOf && o.origin !== 'cascade' && !this.repo.get('tree_nodes', o.nodeId)?.deleted && !all.some(later => later.ordinal > o.ordinal && later.nodeId === o.nodeId && later.type === o.type && canonicalJson(later.after) === canonicalJson(o.before)));
+    const eligible = unreversed.filter(o => o.origin === 'user'), weak = unreversed.filter(o => o.origin === 'attribution' && o.type === 'created' && this.turns().some(t => t.ordinal > o.ordinal));
+    const turns = this.turns(scopeNodeId).filter(t => t.ordinal > afterOrdinal && t.ordinal <= throughOrdinal), assignedNodeCount = new Set(turns.flatMap(t => t.nodeIds).filter(id => id !== this.repo.rootId())).size;
+    const completions = unreversed.filter(o => o.type === 'status' && o.after === 'completed').map(o => { const created = all.find(c => c.nodeId === o.nodeId && c.type === 'created' && c.ordinal <= o.ordinal); return { nodeId: o.nodeId, origin: o.origin, userTurnsSinceCreation: created ? this.turns(o.nodeId).filter(t => t.ordinal > created.ordinal && t.ordinal <= o.ordinal).length : null }; });
+    return { raw: observations.length, excludingCascadeAndReversed: unreversed.length, confirmedUserChanges: eligible.length, weakUnretractedCreations: weak.length, weakAssistantCompletions: completions.filter(c => c.origin !== 'user').length, completions,
+      assignedNodeCount, logicalTurns: turns.length, assignedNodesPer100Turns: turns.length >= 100 ? assignedNodeCount * 100 / turns.length : null,
+      userStatusChoices: Object.fromEntries(['active', 'paused', 'completed', 'abandoned'].map(status => [status, eligible.filter(o => o.type === 'status' && o.after === status).length])), byType: Object.fromEntries(['created', 'name', 'parentId', 'status'].map(type => [type, eligible.filter(o => o.type === type).length])), observations, valueJudgment: null };
+  }
+  stagnation(nodeId) {
+    const node = this.repo.get('tree_nodes', nodeId), turns = this.turns(nodeId).slice(-10); if (node?.status !== 'active' || turns.length < 10) return null;
+    const progress = turns.map(t => this.repo.meta().progressEvidence?.[t.id] ?? { turnId: t.id, state: 'unclassified', sourceRefs: this.experience.material(t).sources.map(s => s.ref), confirmedOutputs: [], confirmedDecisions: [] });
+    if (progress.some(p => p.confirmedOutputs.length || p.confirmedDecisions.length)) return null;
+    return { nodeId, turnIds: turns.map(t => t.id), progress, status: 'candidate_only', needsSemanticReview: true };
+  }
+}
+
+export class ReflectionTriggers {
+  constructor({ repository, metrics, clusters, verification }) { Object.assign(this, { repo: repository, metrics, clusters, verification }); }
+  once(key, input, enqueue) {
+    const old = this.repo.meta().reflectionTriggers?.[key]; if (old) return this.repo.get('tree_jobs', old.jobId);
+    return this.repo.transaction(() => {
+      const job = enqueue(); this.repo.command('recordReflectionTrigger', { requestId: key, expected: {}, input }, program, () => { const meta = this.repo.meta(); this.repo.save('tree_meta', { ...meta, reflectionTriggers: { ...meta.reflectionTriggers, [key]: { ...input, jobId: job.id } } }, meta.revision); return { jobId: job.id }; }); return job;
+    });
+  }
+  scan(nodeId, { summaryId = null, previousWindow = null, currentWindow = null, parentJobId = null } = {}) {
+    const jobs = [];
+    for (const category of CATEGORIES.filter(c => c !== 'proceeded')) { const cluster = this.clusters.candidate(category, signalPolarity(category)); if (cluster) jobs.push(this.once(digest(['reflect-cluster', cluster.id, cluster.revision]), { kind: 'cluster', clusterId: cluster.id }, () => this.verification.enqueue(cluster.nodeId, { reason: 'cluster', clusterIds: [cluster.id], parentJobId }))); }
+    if (summaryId) jobs.push(this.once(digest(['reflect-summary', summaryId]), { kind: 'routine', summaryId }, () => this.verification.enqueue(nodeId, { reason: 'window', summaryId, parentJobId })));
+    const stagnation = this.metrics.stagnation(nodeId);
+    if (stagnation) jobs.push(this.once(digest(['reflect-stagnation', nodeId, stagnation.turnIds]), { kind: 'stagnation', ...stagnation }, () => this.verification.enqueue(nodeId, { reason: 'stagnation', parentJobId })));
+    const trend = this.metrics.compare(previousWindow, currentWindow);
+    if (trend.comparable && trend.notImproved.length) jobs.push(this.once(digest(['reflect-trend', previousWindow.id, currentWindow.id]), { kind: 'trend', previousWindow: previousWindow.id, currentWindow: currentWindow.id, trend }, () => this.verification.enqueue(nodeId, { reason: 'window', summaryId, parentJobId })));
+    return [...new Map(jobs.map(j => [j.id, j])).values()];
+  }
+}