stratagate-dsh 0.2.49 → 0.2.53

package/dist/index.js

@@ -179,7 +179,10 @@ function summarizeToolJson(value) {
   }
 }
 function removeStandaloneFillers(paragraph) {
-  return paragraph.split(/(?<=[。！？!?])|\n+/u).map((piece) => piece.trim()).filter((piece) => piece && !isFillerSentence(piece)).join("\n");
+  const pieces = paragraph.split(/(?<=[。！？!?])|\n+/u).map((piece) => piece.trim()).filter(Boolean);
+  const kept = pieces.filter((piece) => !isFillerSentence(piece));
+  if (kept.length === pieces.length) return paragraph.trim();
+  return kept.join("\n");
 }
 function splitTextAndCode(source) {
   const parts = [];
@@ -218,6 +221,32 @@ function formatReadableTranscript(messages) {
     return lines;
   }).join("\n\n");
 }
+function renderRawToolTrace(trace) {
+  return `Tool call (raw): ${JSON.stringify(trace)}`;
+}
+function formatRawTranscript(messages) {
+  return messages.flatMap((message) => [
+    `${message.role}: ${message.content}`,
+    ...(message.toolCalls ?? []).map(renderRawToolTrace)
+  ]).join("\n\n");
+}
+function estimateTokens(value) {
+  let tokens = 0;
+  let asciiRun = 0;
+  const flushAscii = () => {
+    if (asciiRun > 0) tokens += Math.ceil(asciiRun / 4);
+    asciiRun = 0;
+  };
+  for (const character of value) {
+    if (character.codePointAt(0) <= 127) asciiRun += 1;
+    else {
+      flushAscii();
+      tokens += 1;
+    }
+  }
+  flushAscii();
+  return tokens;
+}
 function condenseTranscript(messages) {
   const seen = /* @__PURE__ */ new Set();
   return messages.filter((message) => message.role !== "system").flatMap((message) => {
@@ -247,9 +276,14 @@ function cloneRawMessages(messages) {
   }));
 }
 function deterministicBlockLayers(messages) {
+  const l5Rendered = formatRawTranscript(messages);
+  const readable = formatReadableTranscript(messages);
+  const l4Readable = estimateTokens(readable) <= estimateTokens(l5Rendered) ? readable : l5Rendered;
+  const condensed = condenseTranscript(messages);
+  const l3Condensed = estimateTokens(condensed) <= estimateTokens(l4Readable) ? condensed : l4Readable;
   return {
-    l3Condensed: condenseTranscript(messages),
-    l4Readable: formatReadableTranscript(messages),
+    l3Condensed,
+    l4Readable,
     l5Raw: cloneRawMessages(messages)
   };
 }
@@ -2663,9 +2697,10 @@ function renderBlock(block, level) {
 Tags: ${block.l0Tags.join(", ") || "none"}`;
   if (level === 1) return block.l1Summary;
   if (level === 2) return block.l2Keypoints.map((point) => `- ${point}`).join("\n") || block.l1Summary;
-  if (level === 3) return block.l3Condensed;
-  if (level === 4) return block.l4Readable;
-  return block.l5Raw.map((message) => `${message.role}: ${message.content}`).join("\n\n");
+  const deterministic = deterministicBlockLayers(block.l5Raw);
+  if (level === 3) return deterministic.l3Condensed;
+  if (level === 4) return deterministic.l4Readable;
+  return formatRawTranscript(block.l5Raw);
 }
 function sameIds(left, right) {
   return left.length === right.length && left.every((id, index) => id === right[index]);
@@ -5378,6 +5413,12 @@ CREATE TABLE IF NOT EXISTS stratagate_dsh_workspaces (
   display_name TEXT NOT NULL,
   updated_at TEXT NOT NULL
 ) STRICT;
+
+CREATE TABLE IF NOT EXISTS stratagate_dsh_feedback_drafts (
+  namespace TEXT PRIMARY KEY,
+  draft_json TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+) STRICT;
 `;
 var DshMetadataStore = class {
   database;
@@ -5407,12 +5448,22 @@ var DshMetadataStore = class {
     }
     this.setSetting("blockDecayLambda", value);
   }
+  lastFeedbackPromptAt() {
+    const row = this.database.prepare("SELECT value FROM stratagate_dsh_settings WHERE key = 'lastFeedbackPromptAt'").get();
+    return row?.value ?? null;
+  }
+  setLastFeedbackPromptAt(value) {
+    this.setSettingValue("lastFeedbackPromptAt", value);
+  }
   setSetting(key, value) {
+    this.setSettingValue(key, String(value));
+  }
+  setSettingValue(key, value) {
     this.database.prepare(`
       INSERT INTO stratagate_dsh_settings (key, value, updated_at)
       VALUES (?, ?, ?)
       ON CONFLICT (key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
-    `).run(key, String(value), (/* @__PURE__ */ new Date()).toISOString());
+    `).run(key, value, (/* @__PURE__ */ new Date()).toISOString());
   }
   workspaceName(namespace) {
     const row = this.database.prepare("SELECT display_name FROM stratagate_dsh_workspaces WHERE namespace = ?").get(namespace);
@@ -5427,6 +5478,22 @@ var DshMetadataStore = class {
       ON CONFLICT (namespace) DO UPDATE SET display_name = excluded.display_name, updated_at = excluded.updated_at
     `).run(namespace, name2, (/* @__PURE__ */ new Date()).toISOString());
   }
+  feedbackDraft(namespace) {
+    const row = this.database.prepare("SELECT draft_json FROM stratagate_dsh_feedback_drafts WHERE namespace = ?").get(namespace);
+    if (!row) return null;
+    try {
+      return JSON.parse(row.draft_json);
+    } catch {
+      return null;
+    }
+  }
+  setFeedbackDraft(namespace, draft) {
+    this.database.prepare(`
+      INSERT INTO stratagate_dsh_feedback_drafts (namespace, draft_json, updated_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT (namespace) DO UPDATE SET draft_json = excluded.draft_json, updated_at = excluded.updated_at
+    `).run(namespace, JSON.stringify(draft), (/* @__PURE__ */ new Date()).toISOString());
+  }
   close() {
     this.database.close();
   }
@@ -5437,6 +5504,7 @@ var AUTO_EVENT_LIMIT = 4;
 var AUTO_ELEMENT_LIMIT = 4;
 var AUTO_MEMORY_TOKEN_BUDGET = 900;
 var COMPACTION_SOURCE_PLUGIN = "stratagate-memory";
+var FEEDBACK_PROMPT_COOLDOWN_MS = 5 * 24 * 60 * 60 * 1e3;
 function projectKey(cwd) {
   const canonical = resolve(cwd ?? process.cwd()).replaceAll("\\", "/").toLowerCase();
   return createHash("sha256").update(canonical).digest("hex").slice(0, 20);
@@ -5445,14 +5513,43 @@ function workspaceDisplayName(cwd) {
   const canonical = (cwd ?? process.cwd()).replace(/[\\/]+$/, "");
   return canonical.split(/[\\/]/).at(-1) || "\u5F53\u524D\u5DE5\u4F5C\u533A";
 }
+function feedbackText(value, maximum) {
+  return typeof value === "string" ? value.trim().slice(0, maximum) : "";
+}
+function normalizeFeedbackDraft(input, previous) {
+  const has = (key) => Object.prototype.hasOwnProperty.call(input, key);
+  const replacesStructuredBody = has("bodyMarkdown");
+  const reproduction = replacesStructuredBody ? [] : has("reproduction") ? (Array.isArray(input.reproduction) ? input.reproduction : []).map((value) => feedbackText(value, 2e3)).filter(Boolean).slice(0, 20) : previous?.reproduction ?? [];
+  const bodyMarkdown = has("bodyMarkdown") ? feedbackText(input.bodyMarkdown, 5e4) : previous?.bodyMarkdown;
+  return {
+    title: has("title") ? feedbackText(input.title, 240) : previous?.title ?? "",
+    description: replacesStructuredBody ? "" : has("description") ? feedbackText(input.description, 2e4) : previous?.description ?? "",
+    reproduction,
+    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 ?? "",
+    ...bodyMarkdown ? { bodyMarkdown } : {},
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function feedbackDraftUrl(namespace, origin) {
+  const params = new URLSearchParams({
+    settings: "stratagate-memory",
+    stratagateView: "feedback",
+    namespace
+  });
+  const route = `/?${params.toString()}`;
+  return origin ? new URL(route, origin).href : route;
+}
 var StrataGateRuntime = class {
   constructor(config, models, onIngestError = () => {
   }, flushNativeSession = async () => {
-  }) {
+  }, feedbackOrigin = () => void 0) {
     this.config = config;
     this.models = models;
     this.onIngestError = onIngestError;
     this.flushNativeSession = flushNativeSession;
+    this.feedbackOrigin = feedbackOrigin;
     this.blockTurnSize = config.blockTurnSize;
     this.blockDecayLambda = config.blockDecayLambda;
   }
@@ -5460,6 +5557,7 @@ var StrataGateRuntime = class {
   models;
   onIngestError;
   flushNativeSession;
+  feedbackOrigin;
   folder = new TurnFolder();
   spaces = /* @__PURE__ */ new Map();
   batches = /* @__PURE__ */ new Map();
@@ -5470,6 +5568,8 @@ var StrataGateRuntime = class {
   derivationRuns = /* @__PURE__ */ new Map();
   adminSnapshotCache = /* @__PURE__ */ new Map();
   externalImportRuns = /* @__PURE__ */ new Map();
+  feedbackDrafts = /* @__PURE__ */ new Map();
+  pendingFeedbackSuggestionSessions = /* @__PURE__ */ new Set();
   ingestTail = Promise.resolve();
   settingsTail = Promise.resolve();
   batchSequence = 0;
@@ -5477,6 +5577,7 @@ var StrataGateRuntime = class {
   ingestError;
   blockTurnSize;
   blockDecayLambda;
+  transientLastFeedbackPromptAt = null;
   acceptEvent(session, event) {
     if (this.closed) return;
     if (!this.config.ingestSubagents && session.header.origin === "subagent") return;
@@ -5493,6 +5594,7 @@ var StrataGateRuntime = class {
       }
     }).catch((error) => {
       this.ingestError = error;
+      this.notePluginError(session, error);
       this.onIngestError(error);
     });
   }
@@ -5866,6 +5968,99 @@ var StrataGateRuntime = class {
     if (this.config.namespaceMode === "session") return `${prefix}:session:${String(session.id)}`;
     return `${prefix}:project:${projectKey(session.header.cwd)}`;
   }
+  async prepareFeedback(session, input) {
+    const namespace = this.namespaceFor(session);
+    const draft = normalizeFeedbackDraft(input);
+    this.saveFeedbackDraft(namespace, draft);
+    const feedbackUrl = feedbackDraftUrl(namespace, this.feedbackOrigin());
+    return {
+      prepared: true,
+      draftCreated: true,
+      submitted: false,
+      namespace,
+      feedbackUrl,
+      message: `\u53CD\u9988\u8349\u7A3F\u5DF2\u7ECF\u51C6\u5907\u597D\u4E86\uFF0C\u8FD8\u6CA1\u6709\u63D0\u4EA4\u5230 GitHub\u3002
+
+[\u6253\u5F00\u53CD\u9988\u8349\u7A3F](${feedbackUrl})`
+    };
+  }
+  adminFeedbackDraft(namespace) {
+    const key = namespace.trim();
+    if (!key) throw new TypeError("StrataGate feedback namespace must not be empty");
+    return { namespace: key, draft: this.loadFeedbackDraft(key) };
+  }
+  adminSaveFeedbackDraft(namespace, input) {
+    const key = namespace.trim();
+    if (!key) throw new TypeError("StrataGate feedback namespace must not be empty");
+    const draft = normalizeFeedbackDraft(input, this.loadFeedbackDraft(key));
+    this.saveFeedbackDraft(key, draft);
+    return { namespace: key, draft };
+  }
+  notePluginError(session, _error) {
+    if (!this.closed) this.pendingFeedbackSuggestionSessions.add(String(session.id));
+  }
+  takeFeedbackSuggestion(session, now = Date.now()) {
+    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 detected a plugin error. Briefly ask whether the user wants help preparing a GitHub Issue report. If they agree, use only facts from the current conversation and call feedback_prepare. Do not invent missing details or submit anything to GitHub.";
+  }
+  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;
+    }
+  }
+  loadFeedbackDraft(namespace) {
+    const cached = this.feedbackDrafts.get(namespace);
+    if (cached) return structuredClone(cached);
+    if (this.config.database === ":memory:" || !existsSync(this.config.database)) return null;
+    const metadata = new DshMetadataStore(this.config.database);
+    try {
+      const value = metadata.feedbackDraft(namespace);
+      if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+      const draft = normalizeFeedbackDraft(value);
+      this.feedbackDrafts.set(namespace, draft);
+      return structuredClone(draft);
+    } finally {
+      metadata.close();
+    }
+  }
+  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();
+    }
+  }
   async adminNamespaces() {
     if (this.config.database === ":memory:" || !existsSync(this.config.database)) return [];
     const storage = new SqliteStorage({ filename: this.config.database, readonly: true });
@@ -6403,8 +6598,10 @@ var StrataGateRuntime = class {
     const timer = setTimeout(() => {
       this.derivationTimers.delete(key);
       if (this.closed) return;
+      const failedBefore = this.failedCoreJobs(memory);
       const run = this.models.run(session, () => memory.resumePendingWork({ threadId })).then(async (resumed) => {
         await this.persistSuccessfulResponses(memory);
+        this.noteNewCoreJobFailures(session, failedBefore, memory);
         const contexts = memory.getBlockContext(threadId);
         for (const block of resumed.readyBlocks) {
           if (block.threadId !== threadId) continue;
@@ -6415,6 +6612,7 @@ var StrataGateRuntime = class {
         const changed = this.syncDecayedBlockSurface(session, contexts);
         if (resumed.readyBlocks.length > 0 || changed) await this.flushNativeSession(session);
       }).catch((error) => {
+        this.notePluginError(session, error);
         this.onIngestError(error);
       }).finally(() => {
         this.derivationRuns.delete(key);
@@ -6434,18 +6632,32 @@ var StrataGateRuntime = class {
     const timer = setTimeout(() => {
       this.migrationTimers.delete(namespace);
       if (this.closed) return;
+      const failedBefore = this.failedCoreJobs(memory);
       const completedBefore = memory.listGraphProjectionJobs().filter(({ status }) => status === "completed").length;
       void this.models.run(session, () => memory.resumePendingWork()).then(async () => {
         await this.persistSuccessfulResponses(memory);
+        this.noteNewCoreJobFailures(session, failedBefore, memory);
         const completedAfter = memory.listGraphProjectionJobs().filter(({ status }) => status === "completed").length;
         if (completedAfter > completedBefore) this.scheduleGraphMigration(session, memory);
       }).catch((error) => {
+        this.notePluginError(session, error);
         this.onIngestError(error);
       });
     }, 1500);
     timer.unref?.();
     this.migrationTimers.set(namespace, timer);
   }
+  failedCoreJobs(memory) {
+    const fingerprint = (kind, id, job) => `${kind}:${id}:${job.attempts}:${job.updatedAt}:${job.lastError ?? ""}`;
+    return /* @__PURE__ */ new Set([
+      ...memory.listSummaryJobs().filter(({ status }) => status === "failed").map((job) => fingerprint("summary", job.blockId, job)),
+      ...memory.listExtractionJobs().filter(({ status }) => status === "failed").map((job) => fingerprint("extraction", job.blockId, job)),
+      ...memory.listGraphProjectionJobs().filter(({ status }) => status === "failed").map((job) => fingerprint("graph", job.id, job))
+    ]);
+  }
+  noteNewCoreJobFailures(session, before, memory) {
+    if ([...this.failedCoreJobs(memory)].some((failure) => !before.has(failure))) this.notePluginError(session);
+  }
   async openAdminMemory(namespace) {
     const active = this.spaces.get(namespace);
     if (active) return { memory: await active, owned: false };
@@ -6810,23 +7022,6 @@ KnowledgeGraph:
   if (eventCount === 0 && nodeCount === 0) lines.push("(no activated memory)");
   return lines.join("\n");
 }
-function estimateTokens(value) {
-  let tokens = 0;
-  let asciiRun = 0;
-  const flushAscii = () => {
-    if (asciiRun > 0) tokens += Math.ceil(asciiRun / 4);
-    asciiRun = 0;
-  };
-  for (const character of value) {
-    if (character.codePointAt(0) <= 127) asciiRun += 1;
-    else {
-      flushAscii();
-      tokens += 1;
-    }
-  }
-  flushAscii();
-  return tokens;
-}
 function activeTurn(session) {
   for (let index = session.events.length - 1; index >= 0; index -= 1) {
     const event = session.events[index];
@@ -6849,6 +7044,27 @@ function sessionOf(exec) {
   return exec.agent.session;
 }
 function registerMemoryTools(ctx, runtime) {
+  ctx.tools.register(defineTool({
+    name: "feedback_prepare",
+    description: 'Prepare a local StrataGate feedback draft from facts known in the current conversation. Unknown fields must stay empty. Never invent versions, logs, Block counts, or diagnostics, and never submit anything to GitHub. After success, respond briefly that the draft is local and not submitted, then render feedbackUrl as a Markdown link labeled "\u6253\u5F00\u53CD\u9988\u8349\u7A3F". Do not print the draft fields or an Issue-content table, and do not direct the user through Settings manually.',
+    parameters: {
+      title: { type: "string" },
+      description: { type: "string" },
+      reproduction: { type: "array", items: { type: "string" } },
+      expected: { type: "string" },
+      actual: { type: "string" },
+      error_context: { type: "string" }
+    },
+    output: jsonOutput,
+    execute: async (args, exec) => runtime.prepareFeedback(sessionOf(exec), {
+      ...args.title !== void 0 ? { title: args.title } : {},
+      ...args.description !== void 0 ? { description: args.description } : {},
+      ...args.reproduction !== void 0 ? { reproduction: args.reproduction } : {},
+      ...args.expected !== void 0 ? { expected: args.expected } : {},
+      ...args.actual !== void 0 ? { actual: args.actual } : {},
+      ...args.error_context !== void 0 ? { errorContext: args.error_context } : {}
+    })
+  }));
   ctx.tools.register(defineTool({
     name: "memory_search_events",
     description: "Search durable StrataGate event memories. Returns a compact batch of event cards (id, title, summary, time, and evidence refs); call memory_expand_event for narrative/quotes/source messages. rankScore is BM25/RRF ordering only, never confidence or factual accuracy. Pass batchId to memory_assess before relying on evidence.",
@@ -7099,7 +7315,7 @@ function clusterKnowledgeGraph(rawNodes, rawEdges) {
 }
 
 // src/web.ts
-var STRATAGATE_DSH_VERSION = "0.2.48";
+var STRATAGATE_DSH_VERSION = "0.2.52";
 var LEGACY_THREAD_ID = "__legacy__";
 var nodeRequire = createRequire(import.meta.url);
 function installedPackageVersion(names) {
@@ -7164,11 +7380,12 @@ function withLayerMetrics(layers) {
   });
 }
 function blockLayers(block) {
+  const deterministic = deterministicBlockLayers(block.l5Raw);
   if (block.processingStatus !== "ready" || !block.l0Title || !block.l0Tags || !block.l1Summary || !block.l2Keypoints) {
     return withLayerMetrics([
-      { level: 3, content: block.l3Condensed },
-      { level: 4, content: block.l4Readable },
-      { level: 5, content: block.l5Raw.map((message) => `${message.role}: ${message.content}`).join("\n\n") }
+      { level: 3, content: deterministic.l3Condensed },
+      { level: 4, content: deterministic.l4Readable },
+      { level: 5, content: formatRawTranscript(block.l5Raw) }
     ]);
   }
   return withLayerMetrics([
@@ -7176,9 +7393,9 @@ function blockLayers(block) {
 Tags: ${block.l0Tags.join(", ") || "none"}` },
     { level: 1, content: block.l1Summary || block.l0Title },
     { level: 2, content: block.l2Keypoints.map((point) => `- ${point}`).join("\n") || block.l1Summary || block.l0Title },
-    { level: 3, content: block.l3Condensed || block.l2Keypoints.join("\n") || block.l1Summary },
-    { level: 4, content: block.l4Readable || block.l3Condensed },
-    { level: 5, content: block.l5Raw.map((message) => `${message.role}: ${message.content}`).join("\n\n") }
+    { level: 3, content: deterministic.l3Condensed || block.l2Keypoints.join("\n") || block.l1Summary },
+    { level: 4, content: deterministic.l4Readable || deterministic.l3Condensed },
+    { level: 5, content: formatRawTranscript(block.l5Raw) }
   ]);
 }
 function eventSummary(event) {
@@ -7333,6 +7550,49 @@ async function updateSettings(runtime, url) {
   if (lambda !== void 0) result.blockDecayLambda = await runtime.adminSetBlockDecayLambda(lambda);
   return result;
 }
+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);
+  }
+  if (req.method !== "PUT") throw new AdminHttpError(405, "StrataGate feedback requires GET or PUT");
+  let suppliedBody = req.body;
+  if (suppliedBody === void 0 && typeof req[Symbol.asyncIterator] === "function") {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+      const value = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      size += value.length;
+      if (size > 128 * 1024) throw new AdminHttpError(413, "feedback draft cannot exceed 128 KB");
+      chunks.push(value);
+    }
+    suppliedBody = Buffer.concat(chunks).toString("utf8");
+  }
+  let body;
+  if (typeof suppliedBody === "string") {
+    try {
+      body = JSON.parse(suppliedBody);
+    } catch {
+      throw new AdminHttpError(400, "feedback draft must be valid JSON");
+    }
+  } else if (suppliedBody && typeof suppliedBody === "object" && !Array.isArray(suppliedBody)) {
+    body = suppliedBody;
+  } else {
+    throw new AdminHttpError(400, "feedback request requires a JSON body");
+  }
+  const namespace = typeof body.namespace === "string" ? body.namespace.trim() : "";
+  if (!namespace) throw new AdminHttpError(400, "namespace is required");
+  const draft = {};
+  if (typeof body.title === "string") draft.title = body.title;
+  if (typeof body.description === "string") draft.description = body.description;
+  if (Array.isArray(body.reproduction)) draft.reproduction = body.reproduction.filter((value) => typeof value === "string");
+  if (typeof body.expected === "string") draft.expected = body.expected;
+  if (typeof body.actual === "string") draft.actual = body.actual;
+  if (typeof body.errorContext === "string") draft.errorContext = body.errorContext;
+  if (typeof body.bodyMarkdown === "string") draft.bodyMarkdown = body.bodyMarkdown;
+  return runtime.adminSaveFeedbackDraft(namespace, draft);
+}
 async function importExternalMemory(runtime, req) {
   let suppliedBody = req.body;
   if (suppliedBody === void 0 && typeof req[Symbol.asyncIterator] === "function") {
@@ -7503,7 +7763,7 @@ function virtualBlockLayers(block) {
     { level: 2, content: keypoints.map((point) => `\u2022 ${point}`).join("\n") || summary || title },
     { level: 3, content: deterministic.l3Condensed },
     { level: 4, content: deterministic.l4Readable },
-    { level: 5, content: block.messages.map((message) => `${message.role}: ${message.content}`).join("\n\n") }
+    { level: 5, content: formatRawTranscript(block.messages) }
   ]);
 }
 function conversationRows(snapshot, view = recoverSnapshotView(snapshot)) {
@@ -7857,7 +8117,9 @@ async function handleAdminRequest(runtime, req, res) {
   try {
     const url = new URL(req.url ?? "/", "http://localhost");
     const path = url.pathname.replace(/\/$/, "");
-    if (path === "/api/stratagate/settings") {
+    if (path === "/api/stratagate/feedback") {
+      sendJson(res, 200, await feedback(runtime, req, url));
+    } else if (path === "/api/stratagate/settings") {
       if (req.method !== "PATCH") throw new AdminHttpError(405, "StrataGate settings require PATCH");
       sendJson(res, 200, await updateSettings(runtime, url));
     } else if (path === "/api/stratagate/blocks/expand") {
@@ -7915,6 +8177,10 @@ StrataGate provides durable, evidence-gated memory through memory_* tools.
 function renderError(error) {
   return error instanceof Error ? error.message : String(error);
 }
+function feedbackWebOrigin(ctx) {
+  const port = ctx.get("webServer")?.port;
+  return typeof port === "number" && Number.isInteger(port) && port > 0 && port <= 65535 ? `http://127.0.0.1:${String(port)}` : void 0;
+}
 async function apply(ctx, config) {
   const resolved = resolveConfig(config);
   await mkdir(dirname(resolved.database), { recursive: true });
@@ -7923,23 +8189,24 @@ async function apply(ctx, config) {
     ctx.logger.error(`stratagate-memory ingestion failed: ${renderError(error)}`);
   }, async (session) => {
     await ctx.sessions.flush(session);
-  });
+  }, () => feedbackWebOrigin(ctx));
   await runtime.syncConfiguredSettings();
   ctx.systemPrompt.section({ name: "tool:stratagate-memory", order: 113, text: MEMORY_PROTOCOL });
   ctx.on("system-prompt/assemble", async (_assembly, context, next) => {
     const assembled = await next();
     const session = context.agent?.session;
     if (!session) return assembled;
+    const contexts = [...assembled.contexts];
     try {
       const text3 = await runtime.buildAutoContext(session);
-      return {
-        ...assembled,
-        contexts: [...assembled.contexts, { name: "stratagate:auto-memory", text: text3 }]
-      };
+      contexts.push({ name: "stratagate:auto-memory", text: text3 });
     } catch (error) {
       ctx.logger.warn(`stratagate-memory auto-context failed: ${renderError(error)}`);
-      return assembled;
+      runtime.notePluginError(session, error);
     }
+    const feedbackSuggestion = runtime.takeFeedbackSuggestion(session);
+    if (feedbackSuggestion) contexts.push({ name: "stratagate:feedback-suggestion", text: feedbackSuggestion });
+    return { ...assembled, contexts };
   });
   ctx.on("agent/turn-stopping", ({ agent }) => {
     if (!runtime.needsRecordUse(agent.session)) return;
@@ -7952,6 +8219,12 @@ async function apply(ctx, config) {
     }));
   });
   registerMemoryTools(ctx, runtime);
+  ctx.on("tools/result", (exec, result) => {
+    if (!result.isError || !exec.agent) return;
+    if (exec.name === "feedback_prepare" || exec.name.startsWith("memory_")) {
+      runtime.notePluginError(exec.agent.session, result.error.message);
+    }
+  });
   const disposeAdminRoutes = registerAdminRoutes(ctx, runtime);
   ctx.on("session/event", (session, event) => runtime.acceptEvent(session, event));
   ctx.logger.info(`stratagate-memory ready (${resolved.namespaceMode} namespaces, ${resolved.database})`);