stratagate-dsh 0.2.82 → 0.2.84

package/dist/plugin.js

@@ -1614,13 +1614,15 @@ function normalizeRetrievalAssessment(input, batchEvidenceRefs) {
 var PROFILE_FIELDS = {
   userPreferredName: { label: "User preferred name", maxLength: 100 },
   assistantPreferredName: { label: "Assistant preferred name", maxLength: 100 },
-  preferredLanguage: { label: "Preferred language", maxLength: 100 },
+  preferredLanguage: { label: "Preferred answer language", maxLength: 100 },
+  reasoningLanguage: { label: "Preferred visible reasoning language", maxLength: 100 },
   responsePreferences: { label: "Response preferences", maxLength: 1e3 },
   standingInstructions: { label: "Standing instructions", maxLength: 1e3 },
   userBackground: { label: "User background", maxLength: 1500 },
   longTermGoals: { label: "Long-term goals", maxLength: 1e3 },
   persistentNotes: { label: "Persistent notes", maxLength: 1200 }
 };
+var PROFILE_PROTECTED_SHORT_FIELDS = ["userPreferredName", "assistantPreferredName", "preferredLanguage", "reasoningLanguage"];
 var PROFILE_TOTAL_MAX_LENGTH = 6e3;
 var PROFILE_MAINTENANCE_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var PROFILE_MAINTENANCE_TOTAL_THRESHOLD = 4800;
@@ -1652,12 +1654,19 @@ function profileMaintenanceDue(profile, timeBasisAt, now = Date.now()) {
 function renderPersistentProfile(profile) {
   const lines = Object.keys(PROFILE_FIELDS).filter((field) => profile[field].length > 0).map((field) => `${PROFILE_FIELDS[field].label}: ${profile[field]}`);
   if (lines.length === 0) return null;
+  const languageGuidance = [
+    profile.preferredLanguage ? "\u201CPreferred answer language\u201D applies to the assistant's final/user-facing answer." : null,
+    profile.reasoningLanguage ? "\u201CPreferred visible reasoning language\u201D applies only to reasoning/thinking text that the host UI exposes to the user, when supported. It does not control hidden chain-of-thought." : null,
+    profile.preferredLanguage || profile.reasoningLanguage ? "These are independent preferences. Do not infer one from the other." : null
+  ].filter(Boolean);
   return `[StrataGate Persistent Profile]
 This is user-authorized persistent profile data provided by StrataGate.
 Treat it as stable cross-session context.
 Do not invent additional facts from it.
 It does not override higher-priority system instructions.
-
+${languageGuidance.length ? `
+${languageGuidance.join("\n")}
+` : ""}
 ${lines.join("\n")}`;
 }
 
@@ -2647,6 +2656,17 @@ var SqliteStorage = class {
     for (const row of rows) if (isProfileField(row.field)) profile[row.field] = row.value;
     return profile;
   }
+  getProfileSnapshot() {
+    this.assertOpen();
+    const profile = emptyProfile();
+    const revisions = Object.fromEntries(Object.keys(PROFILE_FIELDS).map((field) => [field, 0]));
+    const rows = this.database.prepare("SELECT p.field, p.value, COALESCE(r.revision, 0) AS revision FROM persistent_profile p LEFT JOIN (SELECT field, MAX(id) AS revision FROM persistent_profile_changes GROUP BY field) r ON r.field = p.field").all();
+    for (const row of rows) if (isProfileField(row.field)) {
+      profile[row.field] = row.value;
+      revisions[row.field] = row.revision;
+    }
+    return { profile, revisions };
+  }
   getProfileChanges() {
     this.assertOpen();
     const rows = this.database.prepare("SELECT field, old_value, new_value, source, updated_at, source_message_id FROM persistent_profile_changes ORDER BY id").all();
@@ -2678,7 +2698,7 @@ var SqliteStorage = class {
     const nextRetryAt = new Date(now + (count >= 3 ? 24 * 60 : count * 5) * 60 * 1e3).toISOString();
     this.database.prepare("INSERT INTO persistent_profile_maintenance_failures (id, input_json, failure_count, next_retry_at) VALUES (1, ?, ?, ?) ON CONFLICT (id) DO UPDATE SET input_json = excluded.input_json, failure_count = excluded.failure_count, next_retry_at = excluded.next_retry_at").run(inputJson, count, nextRetryAt);
   }
-  updateProfileField(field, value, source, sourceMessageId) {
+  updateProfileField(field, value, source, sourceMessageId, expectedValue, expectedRevision) {
     this.assertOpen();
     if (!isProfileField(field)) throw new TypeError(`Unknown Persistent Profile field: ${field}`);
     if (typeof value !== "string") throw new TypeError("Persistent Profile value must be a string");
@@ -2687,6 +2707,11 @@ var SqliteStorage = class {
       const profile = this.getPersistentProfile();
       const wasNonempty = Object.values(profile).some((entry) => entry.length > 0);
       const oldValue = profile[field];
+      if (expectedRevision !== void 0) {
+        const row = this.database.prepare("SELECT COALESCE(MAX(id), 0) AS revision FROM persistent_profile_changes WHERE field = ?").get(field);
+        if (row.revision !== expectedRevision) return { field, value: oldValue, modified: false, conflict: true };
+      }
+      if (expectedValue !== void 0 && oldValue !== expectedValue) return { field, value: oldValue, modified: false, conflict: true };
       if (oldValue === value) return { field, value, modified: false };
       profile[field] = value;
       validateProfile(profile);
@@ -2708,6 +2733,9 @@ var SqliteStorage = class {
     this.assertOpen();
     validateProfile(proposed);
     if (Object.keys(proposed).length !== Object.keys(PROFILE_FIELDS).length || Object.keys(proposed).some((field) => !isProfileField(field))) throw new TypeError("Maintenance returned unknown or missing Profile fields");
+    for (const field of PROFILE_PROTECTED_SHORT_FIELDS) {
+      if (proposed[field].trim() !== expected[field].trim()) throw new Error(`Profile maintenance changed protected short field ${field}`);
+    }
     return this.immediateTransaction(() => {
       const current = this.getPersistentProfile();
       if (JSON.stringify(current) !== JSON.stringify(expected)) return false;
@@ -5727,12 +5755,26 @@ var STRUCTURED_FIELDS = {
 var STRING_ARRAY = { type: "array", items: { type: "string" } };
 var OPEN_OBJECT = { type: "object", additionalProperties: true };
 var SUMMARIZER_PARAMETERS = {
-  l0Title: { type: "string", required: true },
-  l0Tags: { ...STRING_ARRAY, required: true },
-  l1Summary: { type: "string", required: true },
-  l2Keypoints: { ...STRING_ARRAY, required: true },
-  shouldExtract: { type: "boolean", required: true }
+  l0Title: { type: "string", description: "L0: a short phrase naming the Block's central subject for quick recognition; do not turn it into a sentence-length summary.", required: true },
+  l0Tags: { ...STRING_ARRAY, description: "L0: a few distinctive topical labels (usually 2-5) for rapid recognition of the Block, such as named people, projects, organizations, tools, technical topics, or specific task concepts; omit generic labels such as discussion, conversation, problem, or task.", required: true },
+  l1Summary: { type: "string", description: "L1: a compact, self-contained overview of what happened across the Block, its conclusions or results, significant state changes, and key unresolved work; richer than L0 but still quick to read.", required: true },
+  l2Keypoints: { ...STRING_ARRAY, description: "L2: specific, self-contained points needed to recover context later. Make each point mostly atomic: one decision, constraint, preference, fact, result, failure reason, or open item. Add detail beyond L1 without splitting or repeating its sentences.", required: true },
+  shouldExtract: { type: "boolean", description: "High-recall pre-screen for Event extraction, not the final Event decision. True when this Block clearly contains or may reasonably contain a long-term Event; when uncertain, use true so the Event Extractor can decide. False only when it clearly lacks lasting value, such as greetings, repeated confirmations, or disposable process noise. Mere presence of a fact is not sufficient.", required: true }
 };
+var SUMMARIZER_SYSTEM_PROMPT = `You are the Block Summarizer in StrataGate's memory pipeline. Compress one sealed conversation Block, typically about six turns, from the supplied provenance-preserving derivation messages into L0-L2 layered memory and decide whether it warrants later Event extraction. You are a background model, not the main Agent; you have no other conversation context. L5 retains the complete original source, while L3/L4 are produced separately. Your L0-L2 may later replace detailed chat in the Agent's context, so preserve what future work needs without inventing missing context.
+
+L0 -> L1 -> L2 are progressively higher-resolution views of the same history, not three independent or repetitive summaries:
+- L0: l0Title is a short subject phrase for rapid recognition, ideally under about 60 characters; l0Tags are a few distinctive topical labels for rapid recognition, usually 2-5. Prefer named people, projects, organizations, tools, technical topics, and specific task concepts. Avoid generic tags such as discussion, conversation, problem, or task.
+- L1: l1Summary is a compact, self-contained overview of the whole Block: what happened, conclusions or results, meaningful state changes, and key unresolved work. Usually 1-3 sentences; do not retell the conversation turn by turn.
+- L2: l2Keypoints retain concrete details needed to resume work. Usually 3-8 concise points when there is enough substance, fewer for a thin Block. Each point should stand alone and express mainly one decision, constraint, preference, fact, result, significant failure reason, or open item. Be more specific than L1; do not merely split L1 into repeated sentences.
+
+Prioritize important decisions, constraints, user preferences, final outcomes, significant failure causes, and unresolved work; then task-relevant process details. Omit repetition, greetings, and disposable execution noise. Do not discard a constraint or conclusion that would change how later work is understood just to shorten the output.
+
+Keep provenance and uncertainty. Distinguish what the user stated or decided, what the assistant only proposed or suspected, and what a tool actually observed. Do not promote an assistant hypothesis or a recollection of older memory into a verified fact or new outcome. Preserve uncertainty about timing, causes, status, results, and relationships. Ordinary user/assistant text is retained, but large tool arguments or results may be compacted; use only retained tool names, evidence summaries, and excerpts, and never guess omitted payload details.
+
+shouldExtract is a high-recall pre-screen, not the final Event decision. If it is false, Event extraction is skipped entirely; if true, the Event Extractor makes the final evidence-based decision. Set true when this Block clearly contains or may reasonably contain a long-term Event, such as a decision, stable preference, material project change, meaningful task result, important failure and possible cause, future-useful fact, or open item worth tracking. When uncertain whether a plausible candidate has lasting value, choose true and let the Event Extractor decide. Set false only when the Block clearly lacks such value, for example greetings, repeated confirmations, or disposable execution noise. Do not set true merely because some fact appears; an unsupported assistant suggestion or recap of older memory alone does not establish a new Event candidate.
+
+Call stratagate_summarize_block exactly once with l0Title, l0Tags, l1Summary, l2Keypoints, and shouldExtract. Do not return the summary as ordinary text.`;
 var EVENT_ITEM = {
   type: "object",
   additionalProperties: false,
@@ -5862,7 +5904,7 @@ var PROFILE_MAINTENANCE_PARAMETERS = Object.fromEntries(
 var STRUCTURED_TOOLS = {
   summarizer: {
     name: "stratagate_summarize_block",
-    description: "Submit the completed durable summary for the supplied conversation block.",
+    description: "Submit the L0-L2 layered compression of one sealed StrataGate conversation Block and decide whether it should proceed to Event extraction.",
     parameters: SUMMARIZER_PARAMETERS
   },
   extractor: {
@@ -5892,7 +5934,7 @@ var STRUCTURED_TOOLS = {
   },
   profileMaintenance: {
     name: "stratagate_maintain_profile",
-    description: "Return the same eight Persistent Profile fields with only safe wording and redundancy cleanup.",
+    description: "Return the same nine Persistent Profile fields with only safe wording and redundancy cleanup; preserve the four short fields apart from necessary whitespace cleanup.",
     parameters: PROFILE_MAINTENANCE_PARAMETERS
   }
 };
@@ -6001,7 +6043,7 @@ var DshModelBridge = class {
   summarizer = async (messages) => {
     const raw = object(await this.callStructured(
       "summarizer",
-      `You compress agent conversations into durable memory blocks. Read the supplied provenance-preserving derivation messages and call ${STRUCTURED_TOOLS.summarizer.name} exactly once with l0Title, l0Tags, l1Summary, l2Keypoints, and shouldExtract. Preserve decisions, constraints, preferences, outcomes, and unresolved work. Tool code and oversized tool payloads may be marked compacted; use the retained tool names, evidence summaries, and excerpts without inventing omitted details. shouldExtract is true only when durable events or facts exist. Do not return the summary as text.`,
+      SUMMARIZER_SYSTEM_PROMPT,
       { messages: buildMemoryDerivationMessages(messages) }
     ));
     return {
@@ -6189,7 +6231,7 @@ var DshModelBridge = class {
   async maintainProfile(profile) {
     const raw = object(await this.callStructured(
       "profileMaintenance",
-      `You maintain only the supplied StrataGate Persistent Profile. Call ${STRUCTURED_TOOLS.profileMaintenance.name} exactly once with all eight string fields. You may deduplicate, merge repeated meaning, shorten redundant wording, and improve organization. Preserve every unique fact, uncertainty, constraint, and instruction. Never infer or add facts, broaden meaning, or read Event, Graph, or conversation history. If two statements might conflict or cannot safely merge, retain both. Keep userPreferredName, assistantPreferredName, and preferredLanguage unchanged except necessary whitespace cleanup. Character limits (Unicode code points): ${JSON.stringify(Object.fromEntries(Object.entries(PROFILE_FIELDS).map(([field, spec]) => [field, spec.maxLength])))}. Total maximum: 6000. If safe compression is impossible, return the original value.`,
+      `You maintain only the supplied StrataGate Persistent Profile. Call ${STRUCTURED_TOOLS.profileMaintenance.name} exactly once with all nine string fields. You may deduplicate, merge repeated meaning, shorten redundant wording, and improve organization. Preserve every unique fact, uncertainty, constraint, and instruction. Never infer or add facts, broaden meaning, or read Event, Graph, or conversation history. If two statements might conflict or cannot safely merge, retain both. Keep userPreferredName, assistantPreferredName, preferredLanguage, and reasoningLanguage unchanged except necessary whitespace cleanup. preferredLanguage and reasoningLanguage are independent: never infer, copy, or merge either language field into the other. reasoningLanguage is only for user-visible reasoning/thinking text when supported, not hidden chain-of-thought. Character limits (Unicode code points): ${JSON.stringify(Object.fromEntries(Object.entries(PROFILE_FIELDS).map(([field, spec]) => [field, spec.maxLength])))}. Total maximum: 6000. If safe compression is impossible, return the original value.`,
       { profile, fieldDefinitions: PROFILE_FIELDS }
     ));
     if (Object.keys(raw).length !== Object.keys(PROFILE_FIELDS).length || Object.keys(raw).some((field) => !(field in PROFILE_FIELDS))) {
@@ -6197,7 +6239,7 @@ var DshModelBridge = class {
     }
     const proposed = raw;
     validateProfile(proposed);
-    for (const field of ["userPreferredName", "assistantPreferredName", "preferredLanguage"]) {
+    for (const field of PROFILE_PROTECTED_SHORT_FIELDS) {
       if (proposed[field].trim() !== profile[field].trim()) throw new Error(`Profile maintenance changed protected short field ${field}`);
     }
     return proposed;
@@ -6985,14 +7027,17 @@ var StrataGateRuntime = class {
   getPersistentProfile() {
     return this.profileStore().getPersistentProfile();
   }
+  getProfileSnapshot() {
+    return this.profileStore().getProfileSnapshot();
+  }
   renderProfileContext() {
     return renderPersistentProfile(this.getPersistentProfile());
   }
   getProfileChanges() {
     return this.profileStore().getProfileChanges();
   }
-  updatePersistentProfile(field, value, source, sourceMessageId) {
-    const result = this.profileStore().updateProfileField(field, value, source, sourceMessageId);
+  updatePersistentProfile(field, value, source, sourceMessageId, expectedValue, expectedRevision) {
+    const result = this.profileStore().updateProfileField(field, value, source, sourceMessageId, expectedValue, expectedRevision);
     if (result.modified) this.wakeBackgroundWorker();
     return result;
   }
@@ -8811,7 +8856,14 @@ function sessionOf(exec) {
 function registerMemoryTools(ctx, runtime) {
   ctx.tools.register(defineTool({
     name: "memory_profile_update",
-    description: `This tool is provided by the StrataGate plugin. Update exactly one field of the user's global Persistent Profile. Persistent Profile data is injected into every future conversation without retrieval, so use this tool only for information that should remain continuously available or continuously affect future behavior, such as how to address the user, what the user wants the assistant to be called, the default language, stable response preferences, standing instructions, stable user background, long-term goals, or other genuinely persistent notes.
+    description: `This tool is provided by the StrataGate plugin. Update exactly one field of the user's global Persistent Profile. Persistent Profile data is injected into every future conversation without retrieval, so use this tool only for information that should remain continuously available or continuously affect future behavior, such as how to address the user, what the user wants the assistant to be called, language preferences, stable response preferences, standing instructions, stable user background, long-term goals, or other genuinely persistent notes.
+
+preferredLanguage sets only the default language of the final/user-facing answer. reasoningLanguage sets only the desired language of reasoning/thinking text visible to the user in the DSH or host UI, when supported; it cannot control hidden internal chain-of-thought. An empty reasoningLanguage adds no visible-reasoning language requirement. These are independent settings: never infer one from the other, and never change one merely because the other changed.
+
+Examples:
+User: \u201C\u4EE5\u540E\u90FD\u7528\u4E2D\u6587\u56DE\u7B54\u6211\u201D \u2192 call memory_profile_update with preferredLanguage = \u4E2D\u6587; do not change reasoningLanguage.
+User: \u201C\u4EE5\u540E\u601D\u8003\u8FC7\u7A0B\u7528\u4E2D\u6587\u201D or \u201C\u601D\u8003\u94FE\u7528\u4E2D\u6587\u201D \u2192 call memory_profile_update with reasoningLanguage = \u4E2D\u6587; do not change preferredLanguage.
+User: \u201C\u4EE5\u540E\u56DE\u7B54\u548C\u601D\u8003\u8FC7\u7A0B\u90FD\u7528\u4E2D\u6587\u201D \u2192 make two separate memory_profile_update calls: first preferredLanguage = \u4E2D\u6587, then reasoningLanguage = \u4E2D\u6587. Each call still changes exactly one field.
 
 Do not use this tool merely because the user says "remember". If the information describes something that happened, a decision, an activity, a project change, a dated fact, or something that only needs to be recalled when relevant, it belongs in Event memory instead. A separate Event-memory tool is reserved for that purpose and is not part of this implementation.
 
@@ -8821,7 +8873,7 @@ If the assistant only infers that something might be a useful persistent prefere
 
 Each call changes exactly one predefined Profile field. Never create, delete, or rename Profile fields, and never rewrite the complete Profile when only one field is being changed.`,
     parameters: {
-      field: { type: "string", required: true, enum: ["userPreferredName", "assistantPreferredName", "preferredLanguage", "responsePreferences", "standingInstructions", "userBackground", "longTermGoals", "persistentNotes"] },
+      field: { type: "string", required: true, enum: ["userPreferredName", "assistantPreferredName", "preferredLanguage", "reasoningLanguage", "responsePreferences", "standingInstructions", "userBackground", "longTermGoals", "persistentNotes"] },
       value: { type: "string", required: true }
     },
     output: jsonOutput,
@@ -9579,7 +9631,10 @@ async function updateSettings(runtime, url) {
   return result;
 }
 async function persistentProfile(runtime, req) {
-  if (req.method === "GET") return runtime.getPersistentProfile();
+  if (req.method === "GET") {
+    const snapshot = runtime.getProfileSnapshot();
+    return { ...snapshot.profile, _revisions: snapshot.revisions };
+  }
   if (req.method !== "PATCH") throw new AdminHttpError(405, "Persistent Profile requires GET or PATCH");
   let suppliedBody = req.body;
   if (suppliedBody === void 0 && typeof req[Symbol.asyncIterator] === "function") {
@@ -9603,11 +9658,14 @@ async function persistentProfile(runtime, req) {
   }
   if (!body || typeof body !== "object" || Array.isArray(body)) throw new AdminHttpError(400, "Profile update must be an object");
   const input = body;
-  if (Object.keys(input).length !== 2 || !Object.hasOwn(input, "field") || !Object.hasOwn(input, "value") || typeof input.field !== "string" || typeof input.value !== "string") {
-    throw new AdminHttpError(400, "Profile update requires exactly field and value strings");
+  if (Object.keys(input).length !== 4 || !Object.hasOwn(input, "field") || !Object.hasOwn(input, "value") || !Object.hasOwn(input, "expectedValue") || !Object.hasOwn(input, "expectedRevision") || typeof input.field !== "string" || typeof input.value !== "string" || typeof input.expectedValue !== "string" || !Number.isSafeInteger(input.expectedRevision) || input.expectedRevision < 0) {
+    throw new AdminHttpError(400, "Profile update requires field, value, expectedValue strings and expectedRevision number");
   }
   try {
-    return runtime.updatePersistentProfile(input.field, input.value, "settings");
+    const result = runtime.updatePersistentProfile(input.field, input.value, "settings", null, input.expectedValue, input.expectedRevision);
+    if (result.conflict) throw new AdminHttpError(409, "\u8BE5\u9879\u521A\u521A\u5728\u5176\u4ED6\u4F4D\u7F6E\u66F4\u65B0");
+    const snapshot = runtime.getProfileSnapshot();
+    return { ...result, snapshot: { ...snapshot.profile, _revisions: snapshot.revisions } };
   } catch (error) {
     if (error instanceof TypeError || error instanceof RangeError) throw new AdminHttpError(400, error.message);
     throw error;