stratagate-dsh 0.3.15 → 0.3.16

package/dist/plugin.js

@@ -8521,6 +8521,329 @@ function parseJsonResponse(value, requiredKeys = []) {
   throw new ModelJsonResponseError(void 0, { response: value });
 }
 
+// src/llm.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+
+// src/diagnostics.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { createRequire as createRequire2 } from "node:module";
+import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
+var DAY = 864e5;
+var VERSION = (() => {
+  try {
+    return String(createRequire2(import.meta.url)("../package.json").version);
+  } catch {
+    return "unknown";
+  }
+})();
+var DIAGNOSTIC_STAGES = ["summarizer", "extractor", "projector", "graphProjector", "topicProjector", "externalMemoryExtractor", "externalMemoryDecider", "profileMaintenance", "dreamingStep", "chat", "ingestion", "autoContext", "directory", "tools", "frontend", "retrieval"];
+function diagnosticText(value, limit = 1500) {
+  return String(value instanceof Error ? value.message : value ?? "").slice(0, 8e3).split(/\nRaw response(?: preview| \(full\))/i)[0].replace(/\b(?:sk[-_]|gh[opasu]_|github_pat_)[A-Za-z0-9_-]{8,}\b/g, "[credential]").replace(/(["']?\b(?:api[_-]?key|token|password|passwd|secret|authorization|access[_-]?token|refresh[_-]?token)["']?\s*[:=]\s*)(["'])([\s\S]*?)\2/gi, "$1[credential]").replace(/\b(?:Bearer|Basic|Token)\s+[^\s,;}]+/gi, "[credential]").replace(/\b(?:api[_-]?key|token|password|passwd|secret|authorization)\s*[:=]\s*[^\s,;}]+/gi, "[credential]").replace(/https?:\/\/[^\s<>"']+/gi, "[url]").replace(/[A-Z]:[\\/][^\s"'<>]+/gi, "[path]").replace(/[\w.+-]+@[\w.-]+\.[a-z]{2,}/gi, "[email]").replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f]/g, "").slice(0, limit).replace(/[\uD800-\uDBFF]$/, "");
+}
+function isAbortError(error) {
+  return typeof error === "object" && error !== null && (error.name === "AbortError" || error.code === "ABORT_ERR");
+}
+function diagnosticCategory(error) {
+  if (isAbortError(error)) return "cancelled";
+  const text3 = String(error instanceof Error ? error.message : error ?? "");
+  if (/timeout|timed out|超时/i.test(text3)) return "timeout";
+  if (/429|rate.?limit/i.test(text3)) return "rate-limit";
+  if (/401|403|unauthori|forbidden|credential/i.test(text3)) return "authentication";
+  if (/token.*limit|truncat|max-tokens|context.*(window|length|limit)/i.test(text3)) return "token-limit";
+  if (/json|schema|invalid|validation/i.test(text3)) return "validation";
+  if (/sqlite|database|storage|EACCES|ENOSPC|write failed/i.test(text3)) return "storage";
+  if (/abort|cancel/i.test(text3)) return "cancelled";
+  if (/network|fetch|ECONN|ENOTFOUND/i.test(text3)) return "network";
+  return "internal";
+}
+var SCHEMA2 = `
+CREATE TABLE IF NOT EXISTS stratagate_dsh_diagnostic_records (
+ id TEXT PRIMARY KEY, at TEXT NOT NULL, namespace TEXT NOT NULL, record_json TEXT NOT NULL
+) STRICT;
+CREATE INDEX IF NOT EXISTS stratagate_dsh_diagnostic_scope ON stratagate_dsh_diagnostic_records(namespace, at);
+CREATE TABLE IF NOT EXISTS stratagate_dsh_diagnostic_daily (
+ namespace TEXT NOT NULL, day TEXT NOT NULL, stage TEXT NOT NULL, model TEXT NOT NULL,
+ version TEXT NOT NULL, counters_json TEXT NOT NULL,
+ PRIMARY KEY(namespace, day, stage, model, version)
+) STRICT;
+CREATE TABLE IF NOT EXISTS stratagate_dsh_diagnostic_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL) STRICT;
+`;
+var DiagnosticsRecorder = class {
+  constructor(filename) {
+    this.filename = filename;
+  }
+  filename;
+  database;
+  pending = [];
+  timer;
+  closed = false;
+  dropped = 0;
+  writeFailures = 0;
+  startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  record(scope, counters, options = {}) {
+    if (this.closed) return;
+    const bounded2 = Object.fromEntries(Object.entries(counters).filter(([, n]) => Number.isFinite(n) && n >= 0));
+    this.pending.push({
+      id: `diag_${randomUUID3()}`,
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      namespace: scope.namespace,
+      stage: scope.stage,
+      model: diagnosticText(options.model ?? "", 160),
+      version: VERSION,
+      counters: bounded2,
+      ...scope.taskId ? { taskId: scope.taskId } : {},
+      ...options.error !== void 0 ? { category: diagnosticCategory(options.error), detail: diagnosticText(options.error) } : {}
+    });
+    if (this.pending.length > 256) {
+      this.pending.shift();
+      this.dropped++;
+    }
+    if (!this.timer) {
+      this.timer = setTimeout(() => {
+        this.timer = void 0;
+        this.flush();
+      }, 5e3);
+      this.timer.unref?.();
+    }
+  }
+  open() {
+    if (this.database) return this.database;
+    const db = new DatabaseSync2(this.filename);
+    try {
+      db.exec("PRAGMA busy_timeout=0");
+      db.exec(SCHEMA2);
+      db.prepare("INSERT OR IGNORE INTO stratagate_dsh_diagnostic_meta VALUES ('startedAt', ?)").run(this.startedAt);
+      this.database = db;
+      return db;
+    } catch (error) {
+      db.close();
+      throw error;
+    }
+  }
+  flush() {
+    if (!this.pending.length) return;
+    try {
+      const db = this.open();
+      db.exec("BEGIN IMMEDIATE");
+      try {
+        const get = db.prepare("SELECT counters_json FROM stratagate_dsh_diagnostic_daily WHERE namespace=? AND day=? AND stage=? AND model=? AND version=?");
+        const put = db.prepare("INSERT OR REPLACE INTO stratagate_dsh_diagnostic_daily VALUES (?, ?, ?, ?, ?, ?)");
+        const insert = db.prepare("INSERT INTO stratagate_dsh_diagnostic_records VALUES (?, ?, ?, ?)");
+        for (const item of this.pending) {
+          const keys = [item.namespace, item.at.slice(0, 10), item.stage, item.model, item.version];
+          const row = get.get(...keys);
+          const counters = row ? JSON.parse(row.counters_json) : {};
+          for (const [key, value] of Object.entries(item.counters)) counters[key] = (counters[key] ?? 0) + value;
+          put.run(...keys, JSON.stringify(counters));
+          insert.run(item.id, item.at, item.namespace, JSON.stringify(item));
+        }
+        db.prepare("DELETE FROM stratagate_dsh_diagnostic_records WHERE at < ? OR id NOT IN (SELECT id FROM stratagate_dsh_diagnostic_records ORDER BY at DESC, id DESC LIMIT 2000)").run(new Date(Date.now() - 7 * DAY).toISOString());
+        db.prepare("DELETE FROM stratagate_dsh_diagnostic_daily WHERE day < ?").run(new Date(Date.now() - 90 * DAY).toISOString().slice(0, 10));
+        db.exec("DELETE FROM stratagate_dsh_diagnostic_daily WHERE rowid NOT IN (SELECT rowid FROM stratagate_dsh_diagnostic_daily ORDER BY day DESC LIMIT 10000)");
+        db.exec("COMMIT");
+        this.pending = [];
+      } catch (error) {
+        db.exec("ROLLBACK");
+        throw error;
+      }
+    } catch {
+      this.writeFailures++;
+    }
+  }
+  snapshot(namespace, options = {}) {
+    this.flush();
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const since = new Date(Date.parse(today) - 6 * DAY).toISOString().slice(0, 10);
+    const totals = {};
+    const stages = {};
+    let startedAt = this.startedAt;
+    let available = false;
+    let rows = [];
+    let records = [];
+    let totalRecords = 0;
+    let corruptRollups = 0;
+    let corruptRecords = 0;
+    let scannedRecords = 0;
+    const offset = Math.max(0, Math.min(2e3, Math.floor(options.offset ?? 0)));
+    const readCounters = (text3) => {
+      try {
+        const value = JSON.parse(text3);
+        if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Invalid counters");
+        const entries = Object.entries(value);
+        if (entries.some(([, n]) => typeof n !== "number" || !Number.isFinite(n) || n < 0)) throw new Error("Invalid counter value");
+        return Object.fromEntries(entries);
+      } catch {
+        corruptRollups++;
+        return {};
+      }
+    };
+    try {
+      const db = this.open();
+      available = true;
+      startedAt = db.prepare("SELECT value FROM stratagate_dsh_diagnostic_meta WHERE key='startedAt'").get().value;
+      rows = db.prepare("SELECT day, stage, model, version, counters_json FROM stratagate_dsh_diagnostic_daily WHERE namespace=? AND day>=? ORDER BY day, stage, model, version LIMIT 2001").all(namespace, since);
+      const where = options.id ? "namespace=? AND id=?" : "namespace=? AND at>=? AND json_extract(record_json, '$.category') IS NOT NULL";
+      const values = options.id ? [namespace, options.id] : [namespace, since];
+      totalRecords = Number(db.prepare(`SELECT count(*) AS count FROM stratagate_dsh_diagnostic_records WHERE ${where}`).get(...values).count);
+      const raw = db.prepare(`SELECT record_json FROM stratagate_dsh_diagnostic_records WHERE ${where} ORDER BY at DESC, id DESC LIMIT 20 OFFSET ?`).all(...values, offset);
+      scannedRecords = raw.length;
+      for (const row of raw) {
+        try {
+          const item = JSON.parse(row.record_json);
+          if (!item || item.namespace !== namespace || !DIAGNOSTIC_STAGES.includes(item.stage) || ["id", "at", "model", "version"].some((key) => typeof item[key] !== "string") || !item.counters || typeof item.counters !== "object" || Array.isArray(item.counters) || Object.values(item.counters).some((n) => typeof n !== "number" || !Number.isFinite(n) || n < 0)) throw new Error("Invalid diagnostic record");
+          records.push({
+            id: item.id,
+            at: item.at,
+            namespace,
+            stage: item.stage,
+            model: diagnosticText(item.model, 160),
+            version: item.version,
+            counters: item.counters,
+            ...typeof item.taskId === "string" ? { taskId: item.taskId } : {},
+            ...typeof item.category === "string" ? { category: diagnosticText(item.category, 80) } : {},
+            ...typeof item.detail === "string" ? { detail: diagnosticText(item.detail) } : {}
+          });
+        } catch {
+          corruptRecords++;
+        }
+      }
+    } catch {
+      available = false;
+    }
+    const parsedRows = rows.slice(0, 2e3).map((row) => ({ ...row, counters: readCounters(row.counters_json) }));
+    for (const row of parsedRows) {
+      const counters = row.counters;
+      const stage = stages[row.stage] ??= {};
+      for (const [key, value] of Object.entries(counters)) {
+        totals[key] = (totals[key] ?? 0) + value;
+        stage[key] = (stage[key] ?? 0) + value;
+      }
+    }
+    const routes = /* @__PURE__ */ new Map();
+    for (const row of parsedRows) {
+      const key = JSON.stringify([row.stage, row.model, row.version]);
+      const route = routes.get(key) ?? { stage: row.stage, model: row.model, version: row.version, counters: {} };
+      for (const [name2, n] of Object.entries(row.counters)) route.counters[name2] = (route.counters[name2] ?? 0) + n;
+      routes.set(key, route);
+    }
+    const rates = Object.fromEntries(Object.entries(stages).map(([stage, counts]) => [stage, {
+      sampledOperations: counts.operations ?? 0,
+      operationFailureRate: counts.operations ? (counts.operationsFailed ?? 0) / counts.operations : null,
+      firstAttemptSuccessRate: counts.operations ? (counts.firstAttemptSucceeded ?? 0) / counts.operations : null,
+      recoveredOperationRate: counts.operations ? (counts.operationsRecovered ?? 0) / counts.operations : null,
+      meanOperationMs: counts.operations ? (counts.operationMs ?? 0) / counts.operations : null,
+      meanModelMs: counts.modelCalls ? (counts.modelMs ?? 0) / counts.modelCalls : null
+    }]));
+    const chatTokens = stages.chat?.totalTokens ?? 0;
+    const backgroundTokens = (totals.totalTokens ?? 0) - chatTokens;
+    const totalsComplete = available && !corruptRollups && !this.dropped && totals.modelCalls && totals.totalTokenCalls === totals.modelCalls && !this.pending.length && rows.length <= 2e3;
+    return {
+      schemaVersion: 1,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      since,
+      through: today,
+      timezone: "UTC",
+      startedAt,
+      coverage: {
+        available,
+        corruptRollups,
+        corruptRecords,
+        processStartedAt: this.startedAt,
+        pendingRecords: this.pending.length,
+        droppedRecords: this.dropped,
+        writeFailures: this.writeFailures,
+        rollupTruncated: rows.length > 2e3,
+        historicalBackfill: false,
+        rawRetentionDays: 7,
+        rollupRetentionDays: 90,
+        totalChatCostRatio: null,
+        netSavings: null,
+        note: "\u7EDF\u8BA1\u4ECE\u91C7\u96C6\u542F\u7528\u540E\u5F00\u59CB\uFF1BToken \u4E3A\u9002\u914D\u5668\u62A5\u544A\u503C\uFF0C\u7F3A\u5931\u53E6\u8BA1\uFF1BmemoryInputEstimate \u4EC5\u4F30\u7B97\u5E38\u9A7B\u89C4\u5219\u3001\u5DE5\u5177\u5B9A\u4E49\u3001\u753B\u50CF\u548C\u81EA\u52A8\u4E0A\u4E0B\u6587\uFF0C\u5C1A\u672A\u5B8C\u6574\u5F52\u56E0\u5386\u53F2\u5DE5\u5177\u7ED3\u679C\u53CA\u5206\u5C42\u5BF9\u8BDD\u3002\u51C0\u6536\u76CA\u4E0E\u8D39\u7528\u5360\u6BD4\u5F85\u6D4B\u3002\u4E3B\u804A\u5929\u8986\u76D6\u5DF2\u89C2\u6D4B\u8BF7\u6C42\uFF0C\u65E0\u6CD5\u8BC1\u660E\u8D26\u5355\u5B8C\u6574\u3002"
+      },
+      totals,
+      stages,
+      rates,
+      observedBackgroundTokenShare: totalsComplete && totals.totalTokens ? backgroundTokens / totals.totalTokens : null,
+      definitions: "operations=\u4E00\u6B21\u8BB0\u5FC6\u6A21\u578B\u64CD\u4F5C\uFF08\u542B\u5185\u90E8\u91CD\u8BD5\uFF09\uFF1BmodelCalls=\u6D41\u5F0F\u8BF7\u6C42\u5C1D\u8BD5\uFF1Bpipeline=\u73B0\u5B58\u6301\u4E45\u4EFB\u52A1\u72B6\u6001\u3002\u540E\u53F0Token\u5360\u6BD4\u4EC5\u9488\u5BF9\u5F53\u524D\u7A7A\u95F4\u5DF2\u89C2\u6D4B\u8BF7\u6C42\uFF0C\u5E38\u9A7B\u8F93\u5165\u4F30\u7B97\u5355\u5217\uFF0C\u8D39\u7528\u4E0E\u51C0\u6536\u76CA\u672A\u6D4B\u3002",
+      routes: [...routes.values()].slice(0, 40),
+      omittedRoutes: Math.max(0, routes.size - 40),
+      totalRecords,
+      nextOffset: offset + scannedRecords < totalRecords ? offset + scannedRecords : null,
+      records: records.map(({ namespace: _namespace, detail, ...record3 }) => ({ ...record3, ...options.details && detail ? { detail } : {} }))
+    };
+  }
+  close() {
+    if (this.closed) return;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = void 0;
+    this.flush();
+    this.closed = true;
+    try {
+      this.database?.close();
+    } catch {
+    }
+    this.database = void 0;
+  }
+};
+async function* observeModelStream(recorder, scope, options, next) {
+  const start = Date.now();
+  let usage;
+  let finished = false;
+  let failure;
+  let cancelled = false;
+  scope.calls = (scope.calls ?? 0) + 1;
+  try {
+    for await (const chunk of next()) {
+      if (chunk.type === "usage") usage = chunk.usage;
+      if (chunk.type === "finish") {
+        finished = true;
+        if (chunk.reason.kind === "error" || chunk.reason.kind === "aborted") {
+          cancelled = chunk.reason.kind === "aborted";
+          failure = cancelled ? Object.assign(new Error(chunk.reason.failure?.message ?? "aborted"), { name: "AbortError" }) : chunk.reason.failure.message;
+        } else if (chunk.reason.kind === "max-tokens") failure = "max-tokens";
+      }
+      yield chunk;
+    }
+  } catch (error) {
+    failure = error;
+    cancelled = isAbortError(error);
+    throw error;
+  } finally {
+    const valid = (n) => typeof n === "number" && Number.isFinite(n) && n >= 0;
+    const known = usage && valid(usage.inputTokens) && valid(usage.outputTokens);
+    const counters = {
+      modelCalls: 1,
+      modelFailed: failure !== void 0 && !cancelled ? 1 : 0,
+      modelCancelled: cancelled || !finished && failure === void 0 ? 1 : 0,
+      modelMs: Date.now() - start,
+      usageCalls: known ? 1 : 0,
+      missingUsageCalls: known ? 0 : 1
+    };
+    if (scope.stage === "chat" && scope.memoryInputEstimate !== void 0) {
+      counters.memoryInputEstimate = scope.memoryInputEstimate;
+      counters.memoryInputEstimateCalls = 1;
+    }
+    if (known && usage) {
+      counters.inputTokens = usage.inputTokens;
+      counters.outputTokens = usage.outputTokens;
+      if (valid(usage.cacheReadTokens)) {
+        counters.cacheReadTokens = usage.cacheReadTokens;
+        counters.cacheReadKnownCalls = 1;
+      }
+      if (valid(usage.cacheWriteTokens)) {
+        counters.cacheWriteTokens = usage.cacheWriteTokens;
+        counters.cacheWriteKnownCalls = 1;
+      }
+      if (valid(usage.reasoningTokens)) counters.reasoningTokens = usage.reasoningTokens;
+      if (valid(usage.totalTokens) || valid(usage.cacheReadTokens) && valid(usage.cacheWriteTokens)) {
+        counters.totalTokens = valid(usage.totalTokens) ? usage.totalTokens : counters.inputTokens + counters.outputTokens + counters.cacheReadTokens + counters.cacheWriteTokens;
+        counters.totalTokenCalls = 1;
+      }
+    }
+    recorder.record(scope, counters, { model: `${options.provider}/${options.model}`, ...failure !== void 0 ? { error: failure } : {} });
+  }
+}
+
 // src/llm.ts
 var ELEMENT_TYPES2 = /* @__PURE__ */ new Set(["person", "project", "organization", "tool", "place"]);
 var CRITICALITIES = /* @__PURE__ */ new Set(["routine", "preference", "identity", "safety"]);
@@ -9085,6 +9408,16 @@ var DshModelBridge = class {
   ctx;
   config;
   liveStructuredReasoningEffort;
+  diagnosticScopes = new AsyncLocalStorage();
+  diagnostics;
+  diagnosticNamespace = () => "@shared";
+  setDiagnostics(recorder, namespace) {
+    this.diagnostics = recorder;
+    this.diagnosticNamespace = namespace;
+  }
+  currentDiagnosticScope() {
+    return this.diagnosticScopes.getStore();
+  }
   contextWindows = /* @__PURE__ */ new Map();
   sessions = new AsyncLocalStorage();
   successfulResponses = [];
@@ -9117,8 +9450,8 @@ var DshModelBridge = class {
   run(session, operation) {
     return this.sessions.run({ session, sessionId: session.id }, operation);
   }
-  runDetached(sessionId, operation, signal) {
-    return this.sessions.run({ sessionId, ...signal ? { signal } : {} }, operation);
+  runDetached(sessionId, operation, signal, namespace) {
+    return this.sessions.run({ sessionId, ...signal ? { signal } : {}, ...namespace ? { namespace } : {} }, operation);
   }
   dreamingModelOptions() {
     return { ...this.resolveRoute(), maxTokens: TOPIC_OUTPUT_TOKEN_BUDGET };
@@ -9399,6 +9732,40 @@ Use project scope for repository decisions, user scope for stable preferences/id
     return proposed;
   }
   async callStructured(kind, system, payload, validate, topicMetadata) {
+    const execution = this.sessions.getStore();
+    const scope = {
+      namespace: execution?.namespace ?? this.diagnosticNamespace(execution?.session, String(execution?.sessionId ?? "")),
+      stage: kind,
+      taskId: `task_${randomUUID4()}`,
+      calls: 0
+    };
+    const start = Date.now();
+    return this.diagnosticScopes.run(scope, async () => {
+      try {
+        const result = await this.callStructuredInner(kind, system, payload, validate, topicMetadata);
+        this.diagnostics?.record(scope, {
+          operations: 1,
+          operationsSucceeded: 1,
+          operationsFailed: 0,
+          operationsRecovered: (scope.calls ?? 0) > 1 ? 1 : 0,
+          firstAttemptSucceeded: (scope.calls ?? 0) === 1 ? 1 : 0,
+          retries: Math.max(0, (scope.calls ?? 0) - 1),
+          operationMs: Date.now() - start
+        });
+        return result;
+      } catch (error) {
+        this.diagnostics?.record(scope, {
+          operations: 1,
+          operationsSucceeded: 0,
+          operationsFailed: 1,
+          retries: Math.max(0, (scope.calls ?? 0) - 1),
+          operationMs: Date.now() - start
+        }, { error });
+        throw error;
+      }
+    });
+  }
+  async callStructuredInner(kind, system, payload, validate, topicMetadata) {
     const execution = this.sessions.getStore();
     if (!execution) throw new Error("StrataGate model callback ran without an execution context");
     const baseRoute = this.resolveRoute(execution.session);
@@ -9633,6 +10000,8 @@ Correct these canonical-name provenance fields: ${[...new Set(paths)].slice(0, 2
         return parsed;
       } catch (error) {
         if (!(error instanceof ModelJsonResponseError) && !(isTopic && error instanceof TopicProjectionError)) throw error;
+        const scope = this.diagnosticScopes.getStore();
+        if (scope) this.diagnostics?.record(scope, { validationFailures: 1 }, { error });
         let retryError = error;
         if (isTopic && error instanceof TopicProjectionError) {
           const safe = new TopicProjectionError(error.diagnostics.category, error.diagnostics.reason, { ...topicDiagnostics, ...error.diagnostics });
@@ -9734,7 +10103,9 @@ Correct the previous Topic output using these validation errors: ${JSON.stringif
     try {
       await Promise.race([
         (async () => {
-          for await (const chunk of this.ctx.llm.stream(timedRequest)) assembler.push(chunk);
+          const scope = this.diagnosticScopes.getStore();
+          const stream = this.diagnostics && scope ? observeModelStream(this.diagnostics, scope, timedRequest, () => this.ctx.llm.stream(timedRequest)) : this.ctx.llm.stream(timedRequest);
+          for await (const chunk of stream) assembler.push(chunk);
         })(),
         timeout,
         aborted
@@ -9776,7 +10147,7 @@ function isOffRejection(error) {
 }
 
 // src/metadata.ts
-import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
+import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
 var TOPIC_BOOTSTRAP_WINDOW_MS = 10 * 6e4;
 var TOPIC_BOOTSTRAP_WINDOW_CALLS = 2;
 var METADATA_SCHEMA = `
@@ -9799,7 +10170,7 @@ CREATE TABLE IF NOT EXISTS stratagate_dsh_feedback_drafts (
 ) STRICT;
 `;
 function dropLegacyAgentMemoriesTable(filename) {
-  const database = new DatabaseSync2(filename);
+  const database = new DatabaseSync3(filename);
   try {
     const legacyTable = database.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'stratagate_dsh_agent_memories'").get();
     if (!legacyTable) return;
@@ -9812,7 +10183,7 @@ function dropLegacyAgentMemoriesTable(filename) {
 var DshMetadataStore = class {
   database;
   constructor(filename) {
-    this.database = new DatabaseSync2(filename);
+    this.database = new DatabaseSync3(filename);
     this.database.exec(METADATA_SCHEMA);
   }
   /** Database-wide, durable reservation before any historical model attempt.
@@ -9942,15 +10313,10 @@ var DshMetadataStore = class {
 };
 
 // src/runtime.ts
-import { createHash as createHash3, randomUUID as randomUUID3 } from "node:crypto";
-
-// src/feedback-policy.ts
-var AGENT_FEEDBACK_ENABLED = false;
-
-// src/runtime.ts
+import { createHash as createHash3, randomUUID as randomUUID5 } from "node:crypto";
 import { existsSync } from "node:fs";
 import { dirname, resolve as resolve2 } from "node:path";
-import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
+import { DatabaseSync as DatabaseSync4 } from "node:sqlite";
 import { createUserMessage as createUserMessage2 } from "@deepseek-ai/dsh-llm";
 import { openNativePath } from "@deepseek-ai/dsh-native-command";
 import { validateArgs as validateArgs2 } from "@deepseek-ai/dsh-tools";
@@ -10507,7 +10873,6 @@ function graphProjectionCanRun(job, now = Date.now()) {
 var AUTO_EVENT_LIMIT = 4;
 var AUTO_ELEMENT_LIMIT = 4;
 var AUTO_MEMORY_TOKEN_BUDGET = 900;
-var FEEDBACK_PROMPT_COOLDOWN_MS = 5 * 24 * 60 * 60 * 1e3;
 function projectKey(cwd) {
   const canonical2 = resolve2(cwd ?? process.cwd()).replaceAll("\\", "/").toLowerCase();
   return createHash3("sha256").update(canonical2).digest("hex").slice(0, 20);
@@ -10590,6 +10955,8 @@ function normalizeFeedbackDraft(input, previous) {
     expected: replacesStructuredBody ? "" : has("expected") ? feedbackText(input.expected, 1e4) : previous?.expected ?? "",
     actual: replacesStructuredBody ? "" : has("actual") ? feedbackText(input.actual, 1e4) : previous?.actual ?? "",
     errorContext: replacesStructuredBody ? "" : has("errorContext") ? feedbackText(input.errorContext, 2e4) : previous?.errorContext ?? "",
+    ...previous?.aiPrepared ? { aiPrepared: true } : {},
+    ...previous?.diagnostics ? { diagnostics: previous.diagnostics } : {},
     ...bodyMarkdown ? { bodyMarkdown } : {},
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
@@ -10613,6 +10980,8 @@ var StrataGateRuntime = class {
     this.flushNativeSession = flushNativeSession;
     this.feedbackOrigin = feedbackOrigin;
     this.openPath = openPath;
+    this.diagnostics = new DiagnosticsRecorder(config.database);
+    this.models.setDiagnostics?.(this.diagnostics, (session, sessionId) => session ? this.namespaceFor(session) : this.diagnosticNamespaceForSession(sessionId ?? "") ?? "@shared");
     this.blockTurnSize = config.blockTurnSize;
     this.blockDecayLambda = config.blockDecayLambda;
     this.agentMemoryRetrievalWeight = config.agentMemoryRetrievalWeight ?? 1;
@@ -10626,6 +10995,9 @@ var StrataGateRuntime = class {
   flushNativeSession;
   feedbackOrigin;
   openPath;
+  diagnostics;
+  diagnosticSessionNamespaces = /* @__PURE__ */ new Map();
+  diagnosticMemoryEstimates = /* @__PURE__ */ new Map();
   profileStorage;
   folder = new TurnFolder();
   spaces = /* @__PURE__ */ new Map();
@@ -10642,11 +11014,10 @@ var StrataGateRuntime = class {
   externalImportRuns = /* @__PURE__ */ new Map();
   dreamingRuns = /* @__PURE__ */ new Map();
   dreamingControllers = /* @__PURE__ */ new Map();
-  dreamingOwner = randomUUID3();
+  dreamingOwner = randomUUID5();
   dreamingHost;
   adminJobRetryRuns = /* @__PURE__ */ new Map();
   feedbackDrafts = /* @__PURE__ */ new Map();
-  pendingFeedbackSuggestionSessions = /* @__PURE__ */ new Set();
   pendingTurns = /* @__PURE__ */ new Map();
   drainTimers = /* @__PURE__ */ new Map();
   drainBackoffMs = /* @__PURE__ */ new Map();
@@ -10666,7 +11037,6 @@ var StrataGateRuntime = class {
   blockTurnSize;
   blockDecayLambda;
   agentMemoryRetrievalWeight;
-  transientLastFeedbackPromptAt = null;
   get agentMemoryEnabled() {
     return this.config.agentMemoryEnabled !== false;
   }
@@ -10827,7 +11197,9 @@ var StrataGateRuntime = class {
               }
             }
             return resumed2;
-          }
+          },
+          void 0,
+          namespace
         );
         await this.persistSuccessfulResponses(memory);
         const sessionsToSync = /* @__PURE__ */ new Set();
@@ -11200,6 +11572,12 @@ var StrataGateRuntime = class {
     }
     const memory = await this.space(session);
     const assessment = memory.assessRetrieval(input, new Set(batch.refs.keys()));
+    this.diagnostics.record({ namespace: this.namespaceFor(session), stage: "retrieval" }, {
+      assessments: 1,
+      sufficient: assessment.verdict === "sufficient" ? 1 : 0,
+      partial: assessment.verdict === "partial" ? 1 : 0,
+      wrong: assessment.verdict === "wrong" ? 1 : 0
+    });
     batch.assessment = assessment;
     return {
       batchId: batch.id,
@@ -11516,10 +11894,10 @@ var StrataGateRuntime = class {
     await Promise.allSettled(this.externalImportRuns.values());
     await Promise.allSettled(this.dreamingRuns.values());
     await this.dreamingHost?.close();
+    this.diagnostics.close();
     await Promise.all(settled.flatMap((result) => result.status === "fulfilled" ? [result.value.close()] : []));
     if (this.profileStorage) await this.profileStorage.close();
     this.sessionsById.clear();
-    this.pendingFeedbackSuggestionSessions.clear();
     if (flushError !== void 0) throw flushError;
   }
   namespaceFor(session) {
@@ -11528,10 +11906,75 @@ var StrataGateRuntime = class {
     if (this.config.namespaceMode === "session") return `${prefix}:session:${String(session.id)}`;
     return `${prefix}:project:${projectKey(session.header.cwd)}`;
   }
+  trackDiagnosticSession(sessionId, namespace, memoryInputEstimate) {
+    this.diagnosticSessionNamespaces.set(sessionId, namespace);
+    if (memoryInputEstimate !== void 0) this.diagnosticMemoryEstimates.set(sessionId, memoryInputEstimate);
+    if (this.diagnosticSessionNamespaces.size > 256) {
+      const oldest = this.diagnosticSessionNamespaces.keys().next().value;
+      this.diagnosticSessionNamespaces.delete(oldest);
+      this.diagnosticMemoryEstimates.delete(oldest);
+    }
+  }
+  diagnosticMemoryEstimate(sessionId) {
+    return this.diagnosticMemoryEstimates.get(sessionId);
+  }
+  diagnosticNamespaceForSession(sessionId) {
+    const session = this.knownSessions.get(sessionId)?.deref();
+    return session ? this.namespaceFor(session) : this.diagnosticSessionNamespaces.get(sessionId);
+  }
+  async diagnosticReport(namespace, options = {}) {
+    const collected = this.diagnostics.snapshot(namespace, options);
+    const shared = this.diagnostics.snapshot("@shared");
+    const base = { ...collected, sharedOrUnattributed: {
+      stages: shared.stages,
+      note: "\u6570\u636E\u5E93\u5171\u4EAB\u753B\u50CF\u7EF4\u62A4\u6216\u65E0\u6CD5\u5F52\u5C5E\u7684\u6A21\u578B\u64CD\u4F5C\uFF0C\u5355\u5217\u5C55\u793A\uFF0C\u672A\u5206\u644A\u5230\u5F53\u524D\u5DE5\u4F5C\u533A\u3002"
+    } };
+    try {
+      const snapshot = await this.adminSnapshot(namespace);
+      if (!snapshot) return { ...base, pipeline: { available: false } };
+      const stages = {
+        summarizer: snapshot.summaryJobs,
+        extractor: snapshot.extractionJobs,
+        graphProjector: snapshot.graphProjectionJobs,
+        topicProjector: (snapshot.memoryTopicState?.jobs ?? []).filter((job) => !job.superseded),
+        externalMemoryImport: snapshot.externalMemoryImportJobs
+      };
+      const pipeline = Object.fromEntries(Object.entries(stages).map(([stage, jobs]) => [stage, {
+        total: jobs.length,
+        failed: jobs.filter((j) => j.status === "failed").length,
+        succeeded: jobs.filter((j) => ["succeeded", "completed"].includes(j.status)).length,
+        skipped: jobs.filter((j) => j.status === "skipped").length,
+        pending: jobs.filter((j) => ["pending", "running", "processing", "extracting", "deciding"].includes(j.status)).length,
+        oldestPendingUpdatedAt: jobs.filter((j) => ["pending", "running", "processing"].includes(j.status)).map((j) => j.updatedAt).sort()[0] ?? null
+      }]));
+      const adoptions = snapshot.usageReceipts.filter((r) => r.createdAt >= collected.since);
+      const adopted = adoptions.filter((r) => r.eventIds.length > 0 || r.elementIds.length > 0);
+      const sampledBlocks = snapshot.blocks.slice(-64);
+      const layerTokenEstimates = Object.fromEntries([0, 1, 2, 3, 4, 5].map((level) => [
+        `L${level}`,
+        sampledBlocks.reduce((sum, block) => sum + estimateTokens(renderBlock(block, level)), 0)
+      ]));
+      return { ...base, pipeline: { available: true, stages: pipeline }, benefits: {
+        retrievalReceipts: adoptions.length,
+        adoptionReceipts: adopted.length,
+        adoptedEvents: adopted.reduce((n, r) => n + r.eventIds.length, 0),
+        blocks: snapshot.blocks.length,
+        events: snapshot.events.length,
+        graphNodes: snapshot.graphNodes.length,
+        sampledBlocks: sampledBlocks.length,
+        layerTokenEstimates,
+        note: "\u5206\u5C42Token\u4E3A\u6700\u8FD1\u6700\u591A64\u4E2A\u5B58\u50A8\u5757\u7684\u5185\u5BB9\u4F53\u79EF\u4F30\u7B97\uFF0C\u5404\u4F1A\u8BDD\u5B9E\u9645\u5C42\u7EA7\u4E0D\u540C\uFF1B\u91C7\u7528\u6B21\u6570\u4E0E\u5185\u5BB9\u538B\u7F29\u6BD4\u4F8B\u4E0D\u7B49\u4E8E\u7B54\u6848\u8D28\u91CF\u6216\u8D26\u5355\u51C0\u6536\u76CA\u3002"
+      } };
+    } catch {
+      return { ...base, pipeline: { available: false } };
+    }
+  }
   async prepareFeedback(session, input) {
     const namespace = this.namespaceFor(session);
-    const previous = this.loadFeedbackDraft(namespace);
+    const previous = input.newDraft ? null : this.loadFeedbackDraft(namespace);
     const draft = normalizeFeedbackDraft(input, previous);
+    draft.aiPrepared = true;
+    draft.diagnostics = await this.diagnosticReport(namespace);
     this.saveFeedbackDraft(namespace, draft);
     const feedbackUrl = feedbackDraftUrl(namespace, this.feedbackOrigin());
     return {
@@ -11540,7 +11983,7 @@ var StrataGateRuntime = class {
       submitted: false,
       namespace,
       feedbackUrl,
-      message: `\u53CD\u9988\u8349\u7A3F\u5DF2\u7ECF\u51C6\u5907\u597D\u4E86\uFF0C\u8FD8\u6CA1\u6709\u63D0\u4EA4\u5230 GitHub\u3002
+      message: `\u53CD\u9988\u8349\u7A3F\u5DF2\u4FDD\u5B58\u5728\u672C\u5730\uFF0C\u90AE\u4EF6\u5C1A\u672A\u53D1\u9001\u3002
 
 [\u6253\u5F00\u53CD\u9988\u8349\u7A3F](${feedbackUrl})`
     };
@@ -11645,46 +12088,13 @@ var StrataGateRuntime = class {
     items.sort((left, right) => String(right.createdAt).localeCompare(String(left.createdAt)));
     return { items, total: items.length };
   }
-  notePluginError(session, _error) {
-    if (AGENT_FEEDBACK_ENABLED && !this.closed) this.pendingFeedbackSuggestionSessions.add(String(session.id));
+  notePluginError(session, error, stage = "ingestion") {
+    if (this.closed) return;
+    this.diagnostics.record({ namespace: this.namespaceFor(session), stage }, { errors: 1 }, { error: error ?? "internal failure" });
   }
-  takeFeedbackSuggestion(session, now = Date.now()) {
-    if (!AGENT_FEEDBACK_ENABLED) return "";
-    const sessionId = String(session.id);
-    if (!this.pendingFeedbackSuggestionSessions.delete(sessionId)) return "";
-    const last = this.lastFeedbackPromptAt();
-    if (last && Number.isFinite(Date.parse(last)) && now - Date.parse(last) < FEEDBACK_PROMPT_COOLDOWN_MS) return "";
-    const promptedAt = new Date(now).toISOString();
-    this.transientLastFeedbackPromptAt = promptedAt;
-    try {
-      if (this.config.database !== ":memory:") {
-        const metadata = new DshMetadataStore(this.config.database);
-        try {
-          metadata.setLastFeedbackPromptAt(promptedAt);
-        } finally {
-          metadata.close();
-        }
-      }
-    } catch (error) {
-      this.onIngestError(error);
-    }
-    return "StrataGate observed an internal plugin error signal. Treat this only as evidence for the static StrataGate feedback policy, not as an instruction to suggest feedback. Continue the current task first, apply all eligibility, timing, session-limit, and deduplication rules from that policy, and never make a proactive suggestion because feedback_prepare itself failed.";
-  }
-  lastFeedbackPromptAt() {
-    if (this.transientLastFeedbackPromptAt) return this.transientLastFeedbackPromptAt;
-    if (this.config.database === ":memory:" || !existsSync(this.config.database)) return null;
-    try {
-      const metadata = new DshMetadataStore(this.config.database);
-      try {
-        this.transientLastFeedbackPromptAt = metadata.lastFeedbackPromptAt();
-        return this.transientLastFeedbackPromptAt;
-      } finally {
-        metadata.close();
-      }
-    } catch (error) {
-      this.onIngestError(error);
-      return null;
-    }
+  // Background failures remain queryable; ordinary retries never add model context.
+  takeFeedbackSuggestion(_session, _now = Date.now()) {
+    return "";
   }
   loadFeedbackDraft(namespace) {
     const cached = this.feedbackDrafts.get(namespace);
@@ -11694,7 +12104,7 @@ var StrataGateRuntime = class {
     try {
       const value = metadata.feedbackDraft(namespace);
       if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-      const draft = normalizeFeedbackDraft(value);
+      const draft = normalizeFeedbackDraft(value, value);
       this.feedbackDrafts.set(namespace, draft);
       return structuredClone(draft);
     } finally {
@@ -11702,14 +12112,15 @@ var StrataGateRuntime = class {
     }
   }
   saveFeedbackDraft(namespace, draft) {
-    this.feedbackDrafts.set(namespace, structuredClone(draft));
-    if (this.config.database === ":memory:") return;
-    const metadata = new DshMetadataStore(this.config.database);
-    try {
-      metadata.setFeedbackDraft(namespace, draft);
-    } finally {
-      metadata.close();
+    if (this.config.database !== ":memory:") {
+      const metadata = new DshMetadataStore(this.config.database);
+      try {
+        metadata.setFeedbackDraft(namespace, draft);
+      } finally {
+        metadata.close();
+      }
     }
+    this.feedbackDrafts.set(namespace, structuredClone(draft));
   }
   async adminNamespaces() {
     if (this.config.database === ":memory:" || !existsSync(this.config.database)) return [];
@@ -11964,7 +12375,7 @@ var StrataGateRuntime = class {
           } finally {
             if (owned) await memory.close();
           }
-          const action = await this.models.runDetached(`dreaming:${run.id}`, () => this.models.dreamingStep(payload), controller.signal);
+          const action = await this.models.runDetached(`dreaming:${run.id}`, () => this.models.dreamingStep(payload), controller.signal, namespace);
           if (controller.signal.aborted) return;
           const repeated = run.trace.filter((entry) => entry.tool === action.tool && JSON.stringify(entry.args) === JSON.stringify(action.args)).length;
           if (repeated >= 3) {
@@ -12058,7 +12469,7 @@ var StrataGateRuntime = class {
         }
         try {
           if (job.status === "extracting") {
-            const recovered = await this.models.runDetached(`admin-import-recovery:${jobId}`, () => this.models.externalMemoryExtractor({ text: job.text, importedAt: job.importedAt }));
+            const recovered = await this.models.runDetached(`admin-import-recovery:${jobId}`, () => this.models.externalMemoryExtractor({ text: job.text, importedAt: job.importedAt }), void 0, namespace);
             const responses2 = this.takeSuccessfulResponses();
             await this.retryExternalImportWrite(namespace, (memory) => memory.completeExternalMemoryFallback(jobId, recovered));
             await this.persistExternalImportResponses(namespace, responses2);
@@ -12073,7 +12484,7 @@ var StrataGateRuntime = class {
             decision = await this.models.runDetached(`admin-import:${jobId}`, () => this.models.externalMemoryDecider({
               candidate: structuredClone(work.candidate),
               matches: structuredClone(work.matches)
-            }));
+            }), void 0, namespace);
             responses = this.takeSuccessfulResponses();
           }
           await this.retryExternalImportWrite(namespace, (memory) => memory.completeNextExternalMemoryImport(
@@ -12214,7 +12625,7 @@ var StrataGateRuntime = class {
     const remembered = this.workspaceNames.get(namespace);
     if (remembered) return remembered;
     if (this.config.database === ":memory:" || !existsSync(this.config.database)) return null;
-    const database = new DatabaseSync3(this.config.database, { readOnly: true });
+    const database = new DatabaseSync4(this.config.database, { readOnly: true });
     try {
       if (!database.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'stratagate_dsh_workspaces'").get()) {
         return null;
@@ -12344,7 +12755,7 @@ var StrataGateRuntime = class {
         if (!this.models.isReady(session)) {
           throw new Error("StrataGate model adapter is not ready; retry after DSH finishes registering adapters");
         }
-        const result = session && this.namespaceFor(session) === key ? await this.models.run(session, retry) : await this.models.runDetached(threadId, retry);
+        const result = session && this.namespaceFor(session) === key ? await this.models.run(session, retry) : await this.models.runDetached(threadId, retry, void 0, namespace);
         await this.persistSuccessfulResponses(memory);
         const currentBlock = blockId ? memory.listBlocks().find(({ id: candidateId }) => candidateId === blockId) : void 0;
         if (kind !== "graph-projection" && currentBlock?.processingStatus === "ready" && currentBlock.threadId) {
@@ -12719,6 +13130,12 @@ var StrataGateRuntime = class {
     }
     sessionBatches.set(id, { id, sequence, refs, status: "unresolved" });
     this.latestBatchIds.set(key, id);
+    this.diagnostics.record({ namespace: this.namespaceFor(session), stage: "retrieval" }, {
+      batches: 1,
+      emptyBatches: evidence.length === 0 ? 1 : 0,
+      returnedRefs: refs.size,
+      resultTokensEstimate: estimateTokens(JSON.stringify(output))
+    });
     return output;
   }
   requireBatch(session, batchId, operation) {
@@ -13308,6 +13725,7 @@ ${profile}
     throw new Error("\u672A\u627E\u5230\u672C\u76EE\u5F55\u6240\u5C5E\u4F1A\u8BDD\u7684\u5DE5\u4F5C\u533A\u8DEF\u5F84\uFF0C\u8BF7\u5148\u6253\u5F00\u8BE5\u5DE5\u4F5C\u533A\u7684\u666E\u901A\u4F1A\u8BDD\u540E\u91CD\u8BD5");
   }
   install(scoped, binding) {
+    this.runtime.trackDiagnosticSession(String(binding.agent.id), binding.namespace);
     if (typeof scoped.tools.restrict !== "function" || typeof scoped.tools.guard !== "function" || typeof DshTools.parameterSchemaSpecToJsonSchema !== "function" || !binding.agent.session.surface?.nodes || typeof binding.agent.whenIdle !== "function") throw new Error("\u5F53\u524D DSH \u7F3A\u5C11\u5B89\u5168\u7684 Dreaming Agent \u63A5\u53E3\uFF0C\u8BF7\u5347\u7EA7\u5BBF\u4E3B\u540E\u91CD\u8BD5");
     const modelTools = TOOLS.map((tool) => ({
       name: tool.name,
@@ -13566,6 +13984,11 @@ ${profile}
 
 // src/tools.ts
 import { defineTool as defineTool2 } from "@deepseek-ai/dsh-tools";
+
+// src/feedback-policy.ts
+var AGENT_FEEDBACK_ENABLED = true;
+
+// src/tools.ts
 var jsonOutput = {
   schema: { type: "json" },
   render: (_args, value) => [{
@@ -13606,17 +14029,19 @@ function registerMemoryTools(ctx, runtime) {
   }));
   if (AGENT_FEEDBACK_ENABLED) ctx.tools.register(defineTool2({
     name: "feedback_prepare",
-    description: 'This tool is provided by the StrataGate plugin. Create or revise a local StrataGate feedback draft when the user directly requests it, or after a proactive suggestion permitted by the StrataGate feedback policy and the user explicitly agrees. A direct user request is already authorization. Use only facts known from the current conversation; leave unknown fields empty and never invent versions, logs, Block counts, or diagnostics. Never submit anything to GitHub. After success, briefly say the draft is local and not submitted, then render feedbackUrl as a Markdown link labeled "\u6253\u5F00\u53CD\u9988\u8349\u7A3F". Then ask exactly once: "\u8981\u4E0D\u8981\u987A\u4FBF\u8BA9\u6211\u5C1D\u8BD5\u4FEE\u590D\u8FD9\u4E2A\u95EE\u9898\uFF0C\u5E76\u63D0\u4EA4\u4E00\u4E2A PR\uFF1F" If the user does not respond or declines, do not ask again. Do not use a popup or other additional UI. Do not print draft fields or an Issue-content table, and do not direct the user through Settings manually.',
+    description: "This tool is provided by the StrataGate plugin. \u6574\u7406 StrataGate \u63D2\u4EF6\u7684\u6545\u969C\u3001\u4F7F\u7528\u7591\u95EE\u548C\u6539\u8FDB\u5EFA\u8BAE\uFF0C\u751F\u6210\u672C\u5730\u90AE\u4EF6\u53CD\u9988\u8349\u7A3F\u5E76\u81EA\u52A8\u9644\u5E26\u8FD0\u884C\u6458\u8981\u3002\u7528\u6237\u76F4\u63A5\u8981\u6C42\u53EF\u8C03\u7528\uFF1B\u4E3B\u52A8\u5EFA\u8BAE\u987B\u5148\u83B7\u540C\u610F\u3002\u4F9D\u636E\u5F53\u524D\u4F1A\u8BDD\u4E8B\u5B9E\u586B\u5199\uFF0C\u672A\u77E5\u7559\u7A7A\uFF0C\u53BB\u9664\u51ED\u636E\u3002\u7701\u7565\u5B57\u6BB5\u4FDD\u7559\u539F\u503C\uFF0C\u7A7A\u5B57\u7B26\u4E32\u6216\u7A7A\u6570\u7EC4\u6E05\u7A7A\uFF1B\u65B0\u95EE\u9898\u4F20 new_draft=true\u3002\u6210\u529F\u540E\u8BF4\u660E\u8349\u7A3F\u5728\u672C\u5730\u3001\u90AE\u4EF6\u5C1A\u672A\u53D1\u9001\uFF0C\u5E76\u5C06 feedbackUrl \u663E\u793A\u4E3A\u201C\u6253\u5F00\u53CD\u9988\u8349\u7A3F\u201D\u94FE\u63A5\uFF0C\u4F9B\u7528\u6237\u68C0\u67E5\u540E\u624B\u52A8\u53D1\u90AE\u4EF6\u3002",
     parameters: {
-      title: { type: "string" },
-      description: { type: "string" },
-      reproduction: { type: "array", items: { type: "string" } },
-      expected: { type: "string" },
-      actual: { type: "string" },
-      error_context: { type: "string" }
+      new_draft: { type: "boolean", description: "\u65B0\u95EE\u9898\u4E3A true\uFF1B\u4FEE\u6539\u5DF2\u6709\u8349\u7A3F\u65F6\u7701\u7565\u3002" },
+      title: { type: "string", description: "\u7B80\u77ED\u95EE\u9898\u6807\u9898\u3002" },
+      description: { type: "string", description: "\u5DF2\u77E5\u95EE\u9898\u3001\u5EFA\u8BAE\u6216\u7591\u95EE\u3002" },
+      reproduction: { type: "array", items: { type: "string" }, description: "\u5B9E\u9645\u53D1\u751F\u8FC7\u7684\u590D\u73B0\u6B65\u9AA4\u3002" },
+      expected: { type: "string", description: "\u5DF2\u77E5\u9884\u671F\u7ED3\u679C\u3002" },
+      actual: { type: "string", description: "\u5B9E\u9645\u89C2\u5BDF\u5230\u7684\u7ED3\u679C\u3002" },
+      error_context: { type: "string", description: "\u5F53\u524D\u4F1A\u8BDD\u7684\u76F8\u5173\u9519\u8BEF\uFF1B\u672C\u5730\u8BCA\u65AD\u7531\u7A0B\u5E8F\u81EA\u52A8\u8865\u5145\u3002" }
     },
     output: jsonOutput,
     execute: async (args, exec) => runtime.prepareFeedback(sessionOf(exec), {
+      ...args.new_draft !== void 0 ? { newDraft: args.new_draft } : {},
       ...args.title !== void 0 ? { title: args.title } : {},
       ...args.description !== void 0 ? { description: args.description } : {},
       ...args.reproduction !== void 0 ? { reproduction: args.reproduction } : {},
@@ -13625,6 +14050,19 @@ function registerMemoryTools(ctx, runtime) {
       ...args.error_context !== void 0 ? { errorContext: args.error_context } : {}
     })
   }));
+  if (AGENT_FEEDBACK_ENABLED) ctx.tools.register(defineTool2({
+    name: "stratagate_diagnostics",
+    description: "This tool is provided by the StrataGate plugin. \u53EA\u8BFB\u67E5\u8BE2 StrataGate \u63D2\u4EF6\u5F53\u524D\u8BB0\u5FC6\u7A7A\u95F4\u7684\u8FD0\u884C\u8BCA\u65AD\uFF1A\u8FD1\u671F\u5931\u8D25\u3001\u4EFB\u52A1\u72B6\u6001\u3001\u8017\u65F6\u3001Token \u7528\u91CF\u4E0E\u91C7\u96C6\u8986\u76D6\u5EA6\u3002\u9ED8\u8BA4\u7ED9\u6458\u8981\uFF1B\u7528\u8FD4\u56DE\u7684\u8BCA\u65AD id \u8BFB\u53D6\u8131\u654F\u9519\u8BEF\u8BE6\u60C5\uFF0Coffset \u5206\u9875\u3002\u7528\u4E8E\u6392\u67E5\u6216\u56DE\u5E94\u7528\u6237\u7591\u95EE\uFF1B\u53CD\u9988\u8349\u7A3F\u4F1A\u81EA\u52A8\u9644\u5E26\u6458\u8981\u3002",
+    parameters: {
+      id: { type: "string", description: "\u6458\u8981\u4E2D\u8FD4\u56DE\u7684\u8BCA\u65AD ID\uFF1B\u63D0\u4F9B\u65F6\u8BFB\u53D6\u8BE5\u6761\u8BE6\u60C5\u3002" },
+      offset: { type: "integer", description: "\u4F7F\u7528\u8FD4\u56DE\u7684 nextOffset \u7EE7\u7EED\u8BFB\u53D6\u8FD1\u671F\u5F02\u5E38\u3002" }
+    },
+    output: jsonOutput,
+    execute: async (args, exec) => runtime.diagnosticReport(runtime.namespaceFor(sessionOf(exec)), {
+      ...args.id !== void 0 ? { id: args.id, details: true } : {},
+      ...args.offset !== void 0 ? { offset: args.offset } : {}
+    })
+  }));
   ctx.tools.register(defineTool2({
     name: "memory_list_topics",
     description: "This tool is provided by the StrataGate plugin. \u6D4F\u89C8\u5F53\u524D\u8BB0\u5FC6\u7A7A\u95F4\u7684\u4E3B\u9898\u76EE\u5F55\u3002\u53EF\u6309\u5206\u7C7B\u5206\u9875\uFF0C\u6216\u7528 query \u67E5\u4E3B\u9898\u540D\u79F0\u53CA\u7B80\u4ECB\u3002\u672A\u6574\u7406\u7684\u4E8B\u4EF6\u4E5F\u6709\u5165\u53E3\u3002\u76EE\u5F55\u4EC5\u4F9B\u5BFC\u822A\uFF0C\u4E0D\u521B\u5EFA\u8BC1\u636E\u6279\u6B21\uFF0C\u4E0D\u5F3A\u5316\u8BB0\u5FC6\uFF1B\u9700\u8981\u4E3B\u9898\u8109\u7EDC\u65F6\u8C03\u7528 memory_expand_topic\uFF1B\u9700\u8981\u4E8B\u5B9E\u8BC1\u636E\u53EF\u76F4\u63A5 memory_search_events(topic_id)\uFF0C\u5E76\u8BC4\u4F30\u6765\u6E90\u4E8B\u4EF6\u3002",
@@ -13803,7 +14241,7 @@ function registerMemoryTools(ctx, runtime) {
 
 // src/web.ts
 import { createHash as createHash4 } from "node:crypto";
-import { createRequire as createRequire2 } from "node:module";
+import { createRequire as createRequire3 } from "node:module";
 
 // src/graph-clustering.ts
 import createGraph from "ngraph.graph";
@@ -13917,7 +14355,7 @@ function clusterKnowledgeGraph(rawNodes, rawEdges) {
 
 // src/web.ts
 var LEGACY_THREAD_ID = "__legacy__";
-var nodeRequire2 = createRequire2(import.meta.url);
+var nodeRequire2 = createRequire3(import.meta.url);
 function currentPluginVersion() {
   try {
     const value = nodeRequire2("../package.json");
@@ -14676,7 +15114,8 @@ async function feedback(runtime, req, url) {
   if (req.method === "GET") {
     const namespace2 = url.searchParams.get("namespace")?.trim() ?? "";
     if (!namespace2) throw new AdminHttpError(400, "namespace is required");
-    return runtime.adminFeedbackDraft(namespace2);
+    const result = runtime.adminFeedbackDraft(namespace2);
+    return { ...result, diagnostics: result.draft?.diagnostics ?? await runtime.diagnosticReport?.(namespace2) };
   }
   if (req.method !== "PUT") throw new AdminHttpError(405, "StrataGate feedback requires GET or PUT");
   let suppliedBody = req.body;
@@ -15328,6 +15767,19 @@ async function handleAdminRequest(runtime, req, res) {
     const path = url.pathname.replace(/\/$/, "");
     if (path === "/api/stratagate/feedback") {
       sendJson(res, 200, await feedback(runtime, req, url));
+    } else if (path === "/api/stratagate/diagnostics") {
+      const namespace = url.searchParams.get("namespace")?.trim() ?? "";
+      if (!namespace) throw new AdminHttpError(400, "namespace is required");
+      if (req.method === "POST") {
+        const category = url.searchParams.get("category") ?? "";
+        if (!["timeout", "network", "request-failed"].includes(category)) throw new AdminHttpError(400, "Unknown frontend diagnostic category");
+        runtime.diagnostics.record({ namespace, stage: "frontend" }, { errors: 1 }, { error: category });
+        sendJson(res, 200, { recorded: true });
+        return;
+      }
+      if (req.method !== "GET") throw new AdminHttpError(405, "StrataGate diagnostics require GET or POST");
+      const id = url.searchParams.get("id") ?? void 0;
+      sendJson(res, 200, await runtime.diagnosticReport(namespace, { ...id ? { id, details: true } : {}, offset: numeric(url.searchParams.get("offset"), 0, 0, 2e3) }));
     } else if (path === "/api/stratagate/profile") {
       sendJson(res, 200, await persistentProfile(runtime, req), true);
     } else if (path === "/api/stratagate/settings") {
@@ -15494,7 +15946,7 @@ import {
   writeFile
 } from "node:fs/promises";
 import { basename, dirname as dirname2, join } from "node:path";
-import { createHash as createHash5, randomUUID as randomUUID4 } from "node:crypto";
+import { createHash as createHash5, randomUUID as randomUUID6 } from "node:crypto";
 import { encodeSeqRanges, KNOWN_SESSION_EVENT_TYPES } from "@deepseek-ai/dsh-session";
 var LEGACY_EVENT_TYPE = "stratagate/memory-citations";
 var COMPAT_EVENT_TYPE = "feedback/record";
@@ -15715,7 +16167,7 @@ async function exists(path) {
 }
 async function publishExclusive(path, bytes) {
   await mkdir(dirname2(path), { recursive: true });
-  const temporary = join(dirname2(path), `.${basename(path)}.stratagate-${randomUUID4()}.tmp`);
+  const temporary = join(dirname2(path), `.${basename(path)}.stratagate-${randomUUID6()}.tmp`);
   const handle = await open(temporary, "wx", 384);
   try {
     await handle.writeFile(bytes);
@@ -15840,15 +16292,8 @@ Memory writing:
 - Current city (currentCity) also belongs in the always-on Profile. Travel or business-trip location can be temporary while its saved value persists across sessions until the user updates or clears it; do not expire it automatically. A user request to remember their current trip city belongs here, not in retrieval-dependent memory_remember. Future trip plans, completed trips, and historical locations do not establish current whereabouts. Never copy currentCity into defaultLocation or homeCity. For local tasks use an explicit task location first, otherwise currentCity when set, then defaultLocation. Follow the same Profile consent rule for updates and clearing.
 - Use memory_remember for durable project facts, past decisions, corrections, experiences, and context-specific preferences. Record one self-contained, grounded fact per call, with necessary project, time, and scope. Never record speculation, secrets, credentials, or transient task state.`;
 var FEEDBACK_PROTOCOL = `[StrataGate feedback policy]
-The feedback_prepare tool creates a local draft for the user to review; it never submits the draft.
-
-- Consider proactively suggesting a feedback draft only when the current conversation contains a clear error signal: a tool call threw or returned an error; a result is clearly contrary to expectations and the user expresses confusion or dissatisfaction; or the same problem remains after the user retries it. Normal use, casual conversation, general complaints, and suspected problems without clear error evidence are not eligible.
-- An eligible error does not require a suggestion. Suggest only when the problem remains unresolved, recurs, or materially interferes with the user's task. Do not suggest for a minor failure that recovered automatically without affecting the task.
-- Always troubleshoot, solve the current problem, or offer a workaround first. If it cannot be solved, explain the blocker first. Only at the end of that turn may you add one unobtrusive sentence in the user's language, such as: "\u5982\u679C\u4F60\u613F\u610F\uFF0C\u6211\u53EF\u4EE5\u628A\u8FD9\u6B21\u5F02\u5E38\u6574\u7406\u6210\u53CD\u9988\u8349\u7A3F\uFF0C\u4F9B\u4F60\u68C0\u67E5\u540E\u81EA\u884C\u63D0\u4EA4\u3002" Do not use a popup, heading, interactive-question tool, or interruption for the suggestion.
-- Across the entire current conversation, make at most one proactive feedback suggestion in total, across all namespaces and problems. The suggestion consumes this allowance as soon as it is sent, whether the user accepts, declines, or does not reply. Use the conversation history to remember this; do not expose internal tracking or claim a cross-conversation, daily, or persistent limit.
-- A user's direct request to create or revise feedback is not a proactive suggestion, does not consume that allowance, and is not restricted by it. Necessary clarification for that request is also allowed. If the user says they are not interested, stop immediately and do not ask again.
-- Deduplicate a problem by namespace plus its substantive characteristics; changed wording or another retry does not make it a new problem. Never proactively suggest feedback for a problem that was already proactively suggested or already has a draft. A draft created at the user's request still makes that problem ineligible for a later proactive suggestion.
-- After a proactive suggestion, call feedback_prepare only if the user explicitly agrees. A direct request to create feedback is already authorization, so do not ask again. A failure of feedback_prepare itself must never trigger another proactive feedback suggestion.`;
+\u9488\u5BF9 StrataGate \u63D2\u4EF6\u7684\u6545\u969C\u3001\u4F7F\u7528\u7591\u95EE\u548C\u6539\u8FDB\u5EFA\u8BAE\uFF0C\u7528\u6237\u8981\u6C42\u65F6\u7528 feedback_prepare \u751F\u6210\u672C\u5730\u90AE\u4EF6\u53CD\u9988\u8349\u7A3F\u3002\u9700\u8981\u8FD0\u884C\u8BC1\u636E\u65F6\u7528 stratagate_diagnostics\uFF0C\u8349\u7A3F\u4F1A\u81EA\u52A8\u9644\u5E26\u672C\u5730\u8BCA\u65AD\u6458\u8981\u4F9B\u7528\u6237\u68C0\u67E5\u3002
+\u4EC5\u5728\u5F53\u524D\u4F1A\u8BDD\u5DF2\u6709\u660E\u786E\u7684 StrataGate \u9519\u8BEF\u8BC1\u636E\uFF0C\u4E14\u95EE\u9898\u6301\u7EED\u5F71\u54CD\u5F53\u524D\u4EFB\u52A1\u65F6\uFF0C\u5148\u5904\u7406\u95EE\u9898\uFF0C\u518D\u4E8E\u56DE\u590D\u672B\u5C3E\u8F7B\u58F0\u5EFA\u8BAE\u6574\u7406\u53CD\u9988\u3002\u6574\u4E2A\u4F1A\u8BDD\u6700\u591A\u4E3B\u52A8\u5EFA\u8BAE\u4E00\u6B21\uFF1B\u7528\u6237\u660E\u786E\u540C\u610F\u540E\u8C03\u7528\u3002\u7528\u6237\u76F4\u63A5\u8981\u6C42\u53EF\u76F4\u63A5\u6267\u884C\uFF1B\u62D2\u7EDD\u6216\u672A\u56DE\u5E94\u5C31\u7ED3\u675F\u5EFA\u8BAE\u3002\u6309\u8BB0\u5FC6\u7A7A\u95F4\u4E0E\u5B9E\u8D28\u95EE\u9898\u53BB\u91CD\u3002\u666E\u901A\u540E\u53F0\u91CD\u8BD5\u4FDD\u6301\u5B89\u9759\uFF1B\u53CD\u9988\u5DE5\u5177\u81EA\u8EAB\u5931\u8D25\u7EE7\u7EED\u539F\u4EFB\u52A1\u3002`;
 function renderError(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -15929,27 +16374,48 @@ async function apply(ctx, config) {
       autoMemory = { name: "stratagate:auto-memory", text: text3 };
     } catch (error) {
       ctx.logger.warn(`stratagate-memory auto-context failed: ${renderError(error)}`);
-      if (AGENT_FEEDBACK_ENABLED) runtime.notePluginError(session, error);
+      runtime.notePluginError(session, error, "autoContext");
     }
     try {
       const directory = await runtime.buildMemoryDirectory(session);
       if (directory) contexts.push({ name: "stratagate:memory-directory", text: directory });
     } catch (error) {
       ctx.logger.warn(`stratagate-memory directory failed: ${renderError(error)}`);
-      if (AGENT_FEEDBACK_ENABLED) runtime.notePluginError(session, error);
+      runtime.notePluginError(session, error, "directory");
     }
     if (autoMemory) contexts.push(autoMemory);
-    const feedbackSuggestion = AGENT_FEEDBACK_ENABLED ? runtime.takeFeedbackSuggestion(session) : "";
-    if (feedbackSuggestion) contexts.push({ name: "stratagate:feedback-suggestion", text: feedbackSuggestion });
+    const toolSchemas = ctx.tools.schemas(context.agent).filter(({ name: name2 }) => name2.startsWith("memory_") || name2 === "feedback_prepare" || name2 === "stratagate_diagnostics");
+    runtime.trackDiagnosticSession(String(session.id), runtime.namespaceFor(session), estimateTokens(JSON.stringify({
+      sections: assembled.sections.filter(({ name: name2 }) => name2.startsWith("tool:stratagate-")),
+      contexts: contexts.filter(({ name: name2 }) => name2.startsWith("stratagate:")),
+      tools: toolSchemas
+    })));
     return { ...assembled, contexts };
   });
   installRetrievalFinalization(ctx, runtime);
   registerMemoryTools(ctx, runtime);
-  ctx.on("tools/result", (exec, result) => {
-    if (!AGENT_FEEDBACK_ENABLED || !result.isError || !exec.agent) return;
-    if (exec.name === "feedback_prepare" || exec.name.startsWith("memory_")) {
-      runtime.notePluginError(exec.agent.session, result.error.message);
+  ctx.on("llm/stream", async function* (options, next) {
+    if (models.currentDiagnosticScope()) {
+      yield* next();
+      return;
+    }
+    const namespace = runtime.diagnosticNamespaceForSession(String(options.sessionId ?? ""));
+    if (!namespace || options.purpose) {
+      yield* next();
+      return;
     }
+    const stage = String(options.sessionId).startsWith("stratagate-dreaming:") ? "dreamingStep" : "chat";
+    const memoryInputEstimate = runtime.diagnosticMemoryEstimate(String(options.sessionId));
+    yield* observeModelStream(runtime.diagnostics, { namespace, stage, ...memoryInputEstimate !== void 0 ? { memoryInputEstimate } : {} }, options, next);
+  });
+  ctx.on("tools/result", (exec, result) => {
+    if (!exec.agent || !(exec.name === "feedback_prepare" || exec.name === "stratagate_diagnostics" || exec.name.startsWith("memory_"))) return;
+    const namespace = runtime.namespaceFor(exec.agent.session);
+    runtime.diagnostics.record(
+      { namespace, stage: "tools" },
+      { toolCalls: 1, toolFailures: result.isError ? 1 : 0 },
+      result.isError ? { error: result.error.message } : {}
+    );
   });
   const disposeAdminRoutes = registerAdminRoutes(ctx, runtime);
   ctx.on("session/event", (session, event) => runtime.acceptEvent(session, event));