feat(runtime+admin): A2 LLM异步提取接线 + A4 Tracing接线 + A6通知后端聚合

A2 异步记忆提取:
- loop/memory.go: asyncExtractor接口(ExtractAsync)+extractMemoryAsync(60s超时,WithOutCancel,dispatch即返回,后台落库,失败仅Warn)+persistMemories共用
- run.go 三个回合落定点改异步提取; 删除run.go逐步提取(design/03'每轮后', 避免多轮工具N次LLM调用/重复写)
- cmd/cyrene/extractor.go buildMemoryExtractor: llmGroupUsable为真→LLMExtractor, 否则回落ManualExtractor(日志说明); keylessEndpoint放行loopback/私网

A4 可观测性 Tracing:
- cmd/cyrene/observability.go: newAppTraceWriter+traceFanout(多sink)+gatewaySpanSink(走gw.ObserveSpan,喂环形缓冲+LLM/subagent指标)
- wire.go 注入; 未改trace/gateway数据结构

A6 通知后端:
- internal/services/gateway/notifications.go(311行): GET /admin/notifications?type=&before=&limit= (adminAuth)
- 聚合已有源(obs.audit SQLite + s.backthink), createdAt倒序, id=source:id; 类型派生(channel/system/audit/backthink); 无新建表/无新Deps/wire零改动
- 诚实: backthink仅shouldPush计, 未注入源为空, 报错500, 未读游标后置
- 契约与前端Y一致: {id,type,title,body,source,createdAt}, before含游标(<=), type未知400
- Docs/api-client v0.33

全仓 build/vet/test绿(56包)+win/darwin/linux-arm64交叉编译绿; 新增测试(memory_async/extractor/observability/notifications)

internal/runtime/loop/memory.go

@@ -3,11 +3,26 @@ package loop
 import (
 	"context"
 	"strings"
+	"time"
 
 	"git.yeij.top/AskaEth/Cyrene_v2/internal/runtime/memory"
 	"git.yeij.top/AskaEth/Cyrene_v2/internal/runtime/model"
 )
 
+// memoryExtractTimeout bounds one background extraction. It only governs the
+// detached extraction context, so a hung model call cannot leak a goroutine for
+// the process lifetime.
+const memoryExtractTimeout = 60 * time.Second
+
+// asyncExtractor is the extractor capability the loop detaches to a background
+// goroutine: memory.LLMExtractor implements it through ExtractAsync (design/03 §1
+// LLM 异步自动提取), returning a channel that delivers exactly one result.
+// Deterministic extractors (memory.ManualExtractor) do not implement it and stay
+// on the synchronous path.
+type asyncExtractor interface {
+	ExtractAsync(ctx context.Context, conversation []model.Message) (<-chan memory.AsyncResult, error)
+}
+
 // injectMemory retrieves the persona's relevant long-term memories and prepends
 // them as a leading system message, so the model can ground its answer in recalled
 // context (design §6 / §2). It is re-run every round via assembleContext so the
@@ -157,6 +172,66 @@ func (l *Loop) extractMemory(ctx context.Context, messages []model.Message, step
 		l.log.Warn("memory extract", "step", step, "error", err)
 		return
 	}
+	l.persistMemories(ctx, items, step)
+}
+
+// extractMemoryAsync triggers the extraction hook at the turn boundary without
+// blocking the reply (design/03 §1: 每轮对话后后台异步抽取). When the configured
+// extractor can extract asynchronously (the LLM extractor) the conversation is
+// handed to a background goroutine and this call returns immediately, so a slow
+// extraction model never delays the response. A deterministic extractor
+// (ManualExtractor) does not implement asyncExtractor and is run inline, which
+// keeps its cheap "记住 X" path observable and unchanged.
+//
+// The same gates as extractMemory apply: a restricted conversation is never
+// extracted (read-only isolation, design/02 §3 / design/11 §2), and a missing
+// extractor or store is a no-op. Extraction failures and store failures are
+// logged with the loop's source and never propagated.
+func (l *Loop) extractMemoryAsync(ctx context.Context, messages []model.Message, step int) {
+	env := sessionEnvFrom(ctx)
+	if env.Restricted() {
+		l.log.Debug("memory extract skipped: read-only context", "step", step, "env", env.ActorEnv)
+		return
+	}
+	if l.extractor == nil || l.memory == nil {
+		return
+	}
+	async, ok := l.extractor.(asyncExtractor)
+	if !ok {
+		l.extractMemory(ctx, messages, step)
+		return
+	}
+	// The turn's context dies with the request while the extraction deliberately
+	// outlives it, so the goroutine gets a detached copy of the context (values —
+	// the session env among them — are kept) under its own timeout.
+	dctx, cancel := context.WithTimeout(context.WithoutCancel(ctx), memoryExtractTimeout)
+	// The caller keeps appending to messages as the turn continues, so the
+	// goroutine reads a private snapshot instead of racing on the shared slice.
+	snapshot := append([]model.Message(nil), messages...)
+	results, err := async.ExtractAsync(dctx, snapshot)
+	if err != nil {
+		cancel()
+		l.log.Warn("memory extract dispatch", "step", step, "error", err)
+		return
+	}
+	go func() {
+		defer cancel()
+		res, ok := <-results
+		if !ok {
+			return
+		}
+		if res.Err != nil {
+			l.log.Warn("memory extract", "step", step, "error", res.Err)
+			return
+		}
+		l.persistMemories(dctx, res.Items, step)
+	}()
+}
+
+// persistMemories writes extracted items to the memory store, scoping any item
+// the extractor left unscoped to the loop's persona. Store failures are logged
+// and never fatal, so one rejected item cannot abort a turn.
+func (l *Loop) persistMemories(ctx context.Context, items []memory.MemoryItem, step int) {
 	for _, it := range items {
 		if it.PersonaID == "" && l.personaID != "" {
 			it.PersonaID = l.personaID