stratagate-dsh 0.2.81 → 0.2.83

package/dist/plugin.js

@@ -1610,8 +1610,68 @@ function normalizeRetrievalAssessment(input, batchEvidenceRefs) {
   };
 }
 
+// packages/core/src/profile.ts
+var PROFILE_FIELDS = {
+  userPreferredName: { label: "User preferred name", maxLength: 100 },
+  assistantPreferredName: { label: "Assistant preferred name", 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;
+function profileLength(value) {
+  return Array.from(value).length;
+}
+function emptyProfile() {
+  return Object.fromEntries(Object.keys(PROFILE_FIELDS).map((field) => [field, ""]));
+}
+function isProfileField(value) {
+  return Object.prototype.hasOwnProperty.call(PROFILE_FIELDS, value);
+}
+function validateProfile(profile) {
+  let total = 0;
+  for (const field of Object.keys(PROFILE_FIELDS)) {
+    if (typeof profile[field] !== "string") throw new TypeError(`${field} must be a string`);
+    const length = profileLength(profile[field]);
+    if (length > PROFILE_FIELDS[field].maxLength) throw new RangeError(`${field} exceeds ${PROFILE_FIELDS[field].maxLength} characters`);
+    total += length;
+  }
+  if (total > PROFILE_TOTAL_MAX_LENGTH) throw new RangeError(`Persistent Profile exceeds ${PROFILE_TOTAL_MAX_LENGTH} characters`);
+}
+function profileMaintenanceDue(profile, timeBasisAt, now = Date.now()) {
+  const lengths = Object.keys(PROFILE_FIELDS).map((field) => ({ field, length: profileLength(profile[field]) }));
+  const total = lengths.reduce((sum, item) => sum + item.length, 0);
+  if (total === 0) return false;
+  return timeBasisAt !== null && now - Date.parse(timeBasisAt) >= PROFILE_MAINTENANCE_INTERVAL_MS || total >= PROFILE_MAINTENANCE_TOTAL_THRESHOLD || lengths.some(({ field, length }) => length >= PROFILE_FIELDS[field].maxLength * 0.8);
+}
+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")}`;
+}
+
 // packages/core/src/storage.ts
-var STRATAGATE_STORAGE_SCHEMA_VERSION = 11;
+var STRATAGATE_STORAGE_SCHEMA_VERSION = 12;
 var KNOWLEDGE_GRAPH_PROJECTOR_VERSION = 1;
 var DERIVATION_MAX_ATTEMPTS = 3;
 var StorageConflictError = class extends Error {
@@ -1751,6 +1811,8 @@ function normalizeSnapshot(value) {
       ...structuredClone(value),
       schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION
     };
+  } else if (schemaVersion === 11) {
+    snapshot = { ...structuredClone(value), schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION };
   } else if (schemaVersion === STRATAGATE_STORAGE_SCHEMA_VERSION) {
     snapshot = structuredClone(value);
   } else {
@@ -1965,6 +2027,38 @@ function nowUtc8() {
 
 // packages/core/src/sqlite.ts
 var SCHEMA = `
+CREATE TABLE IF NOT EXISTS persistent_profile (
+  field TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+) STRICT;
+
+CREATE TABLE IF NOT EXISTS persistent_profile_changes (
+  id INTEGER PRIMARY KEY,
+  field TEXT NOT NULL,
+  old_value TEXT NOT NULL,
+  new_value TEXT NOT NULL,
+  source TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  source_message_id TEXT
+) STRICT;
+CREATE TABLE IF NOT EXISTS persistent_profile_maintenance (
+  id INTEGER PRIMARY KEY CHECK (id = 1),
+  last_succeeded_at TEXT NOT NULL,
+  input_json TEXT NOT NULL
+) STRICT;
+
+CREATE TABLE IF NOT EXISTS persistent_profile_maintenance_baseline (
+  id INTEGER PRIMARY KEY CHECK (id = 1),
+  started_at TEXT NOT NULL
+) STRICT;
+
+CREATE TABLE IF NOT EXISTS persistent_profile_maintenance_failures (
+  id INTEGER PRIMARY KEY CHECK (id = 1),
+  input_json TEXT NOT NULL,
+  failure_count INTEGER NOT NULL,
+  next_retry_at TEXT NOT NULL
+) STRICT;
+
 CREATE TABLE IF NOT EXISTS memory_spaces (
   namespace TEXT PRIMARY KEY,
   schema_version INTEGER NOT NULL,
@@ -2554,6 +2648,117 @@ var SqliteStorage = class {
     this.database.close();
     this.closed = true;
   }
+  /** Installation-wide state; intentionally has no namespace column. */
+  getPersistentProfile() {
+    this.assertOpen();
+    const profile = emptyProfile();
+    const rows = this.database.prepare("SELECT field, value FROM persistent_profile").all();
+    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();
+    return rows.map((row) => ({
+      field: row.field,
+      oldValue: row.old_value,
+      newValue: row.new_value,
+      source: row.source,
+      updatedAt: row.updated_at,
+      sourceMessageId: row.source_message_id
+    }));
+  }
+  getProfileMaintenanceStartedAt() {
+    this.assertOpen();
+    const row = this.database.prepare("SELECT started_at FROM persistent_profile_maintenance_baseline WHERE id = 1").get();
+    return row?.started_at ?? null;
+  }
+  getProfileMaintenanceState() {
+    this.assertOpen();
+    const row = this.database.prepare("SELECT last_succeeded_at, input_json FROM persistent_profile_maintenance WHERE id = 1").get();
+    return row ? { lastSucceededAt: row.last_succeeded_at, inputJson: row.input_json } : null;
+  }
+  recordProfileMaintenanceFailure(profile, now = Date.now()) {
+    this.assertOpen();
+    const inputJson = JSON.stringify(profile);
+    const previous = this.database.prepare("SELECT input_json, failure_count, next_retry_at FROM persistent_profile_maintenance_failures WHERE id = 1").get();
+    const sameWindow = previous?.input_json === inputJson && !(previous.failure_count >= 3 && now >= Date.parse(previous.next_retry_at));
+    const count = sameWindow ? previous.failure_count + 1 : 1;
+    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, 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");
+    if (!["settings", "user_explicit", "agent_tool", "maintenance"].includes(source)) throw new TypeError("Invalid Profile change source");
+    return this.immediateTransaction(() => {
+      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);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      this.writeProfileField(field, oldValue, value, source, sourceMessageId ?? null, now);
+      const isNonempty = Object.values(profile).some((entry) => entry.length > 0);
+      if (!wasNonempty && isNonempty) {
+        this.database.prepare("INSERT INTO persistent_profile_maintenance_baseline (id, started_at) VALUES (1, ?) ON CONFLICT (id) DO UPDATE SET started_at = excluded.started_at").run(now);
+        this.database.prepare("DELETE FROM persistent_profile_maintenance WHERE id = 1").run();
+        this.database.prepare("DELETE FROM persistent_profile_maintenance_failures WHERE id = 1").run();
+      } else if (!isNonempty) {
+        this.database.prepare("DELETE FROM persistent_profile_maintenance_baseline WHERE id = 1").run();
+      }
+      return { field, value, modified: true };
+    });
+  }
+  /** Compare the complete input snapshot before writing a model result. */
+  applyProfileMaintenance(expected, proposed, now = (/* @__PURE__ */ new Date()).toISOString()) {
+    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;
+      for (const field of Object.keys(PROFILE_FIELDS)) {
+        if (current[field] !== proposed[field]) this.writeProfileField(field, current[field], proposed[field], "maintenance", null, now);
+      }
+      this.database.prepare("INSERT INTO persistent_profile_maintenance (id, last_succeeded_at, input_json) VALUES (1, ?, ?) ON CONFLICT (id) DO UPDATE SET last_succeeded_at = excluded.last_succeeded_at, input_json = excluded.input_json").run(now, JSON.stringify(proposed));
+      this.database.prepare("DELETE FROM persistent_profile_maintenance_failures WHERE id = 1").run();
+      return true;
+    });
+  }
+  profileMaintenanceDue(now = Date.now()) {
+    const profile = this.getPersistentProfile();
+    const failed = this.database.prepare("SELECT input_json, failure_count, next_retry_at FROM persistent_profile_maintenance_failures WHERE id = 1").get();
+    if (failed?.input_json === JSON.stringify(profile) && now < Date.parse(failed.next_retry_at)) return false;
+    const state = this.getProfileMaintenanceState();
+    if (!profileMaintenanceDue(profile, state?.lastSucceededAt ?? this.getProfileMaintenanceStartedAt(), now)) return false;
+    return !state || now - Date.parse(state.lastSucceededAt) >= 24 * 60 * 60 * 1e3 || state.inputJson !== JSON.stringify(profile);
+  }
+  writeProfileField(field, oldValue, newValue, source, sourceMessageId, now = (/* @__PURE__ */ new Date()).toISOString()) {
+    this.database.prepare("INSERT INTO persistent_profile (field, value) VALUES (?, ?) ON CONFLICT (field) DO UPDATE SET value = excluded.value").run(field, newValue);
+    this.database.prepare("INSERT INTO persistent_profile_changes (field, old_value, new_value, source, updated_at, source_message_id) VALUES (?, ?, ?, ?, ?, ?)").run(field, oldValue, newValue, source, now, sourceMessageId);
+  }
   searchRawMessageIds(namespace, tokens, limit, threadId, includeUnthreaded = false) {
     this.assertOpen();
     if (!this.rawSearchFtsAvailable || tokens.length === 0) return null;
@@ -3057,6 +3262,19 @@ var SqliteStorage = class {
       this.database.exec(THREAD_INDEXES);
       this.enableRawSearchFts();
     }
+    this.immediateTransaction(() => {
+      this.database.exec("DROP INDEX IF EXISTS persistent_profile_single_consent");
+      this.database.exec(`
+        INSERT INTO persistent_profile_maintenance_baseline (id, started_at)
+        SELECT 1, COALESCE(
+          (SELECT MIN(updated_at) FROM persistent_profile_changes WHERE new_value <> ''),
+          strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+        )
+        WHERE EXISTS (SELECT 1 FROM persistent_profile WHERE value <> '')
+        ON CONFLICT (id) DO NOTHING
+      `);
+      this.database.exec("DELETE FROM persistent_profile_maintenance_baseline WHERE NOT EXISTS (SELECT 1 FROM persistent_profile WHERE value <> '')");
+    });
     this.assertSchemaVersion();
   }
   enableRawSearchFts() {
@@ -5531,7 +5749,8 @@ var STRUCTURED_FIELDS = {
   projector: ["reason", "changes"],
   graphProjector: ["reason", "nodes", "edges"],
   externalMemoryExtractor: ["reason", "candidates"],
-  externalMemoryDecider: ["action", "reason", "confidence"]
+  externalMemoryDecider: ["action", "reason", "confidence"],
+  profileMaintenance: Object.keys(PROFILE_FIELDS)
 };
 var STRING_ARRAY = { type: "array", items: { type: "string" } };
 var OPEN_OBJECT = { type: "object", additionalProperties: true };
@@ -5665,6 +5884,9 @@ var EXTERNAL_MEMORY_EXTRACTOR_PARAMETERS = {
   reason: { type: "string", required: true },
   candidates: { type: "array", items: OPEN_OBJECT, required: true }
 };
+var PROFILE_MAINTENANCE_PARAMETERS = Object.fromEntries(
+  Object.keys(PROFILE_FIELDS).map((field) => [field, { type: "string", required: true }])
+);
 var STRUCTURED_TOOLS = {
   summarizer: {
     name: "stratagate_summarize_block",
@@ -5695,6 +5917,11 @@ var STRUCTURED_TOOLS = {
     name: "stratagate_recover_external_memory",
     description: "Recover structured external-memory candidates from malformed JSON or plain text.",
     parameters: EXTERNAL_MEMORY_EXTRACTOR_PARAMETERS
+  },
+  profileMaintenance: {
+    name: "stratagate_maintain_profile",
+    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
   }
 };
 function toolSchema(kind) {
@@ -5987,6 +6214,22 @@ var DshModelBridge = class {
     }));
     return { candidates: parsed.candidates, reason: text2(raw.reason, parsed.reason) };
   };
+  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 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))) {
+      throw new Error("Profile maintenance returned unexpected fields");
+    }
+    const proposed = raw;
+    validateProfile(proposed);
+    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;
+  }
   async callStructured(kind, system, payload) {
     const execution = this.sessions.getStore();
     if (!execution) throw new Error("StrataGate model callback ran without an execution context");
@@ -6020,7 +6263,7 @@ ${JSON_RETRY_INSTRUCTION}`,
           type: "function",
           function: { name: STRUCTURED_TOOLS[kind].name }
         },
-        maxTokens: this.config.maxOutputTokens,
+        maxTokens: kind === "profileMaintenance" ? Math.max(this.config.maxOutputTokens, Math.min(12e3, 512 + 2 * Array.from(JSON.stringify(payload)).length)) : this.config.maxOutputTokens,
         sessionId: execution.sessionId,
         purpose: "compaction"
       };
@@ -6103,13 +6346,15 @@ ${JSON_RETRY_INSTRUCTION}`,
             );
           }
         }
-        this.successfulResponses.push({
-          id: `model_response_${crypto.randomUUID()}`,
-          kind,
-          response: responseForError,
-          createdAt: nowUtc8()
-        });
-        if (this.successfulResponses.length > 5) this.successfulResponses.shift();
+        if (kind !== "profileMaintenance") {
+          this.successfulResponses.push({
+            id: `model_response_${crypto.randomUUID()}`,
+            kind,
+            response: responseForError,
+            createdAt: nowUtc8()
+          });
+          if (this.successfulResponses.length > 5) this.successfulResponses.shift();
+        }
         return parsed;
       } catch (error) {
         if (!(error instanceof ModelJsonResponseError)) throw error;
@@ -6675,6 +6920,7 @@ var StrataGateRuntime = class {
   flushNativeSession;
   feedbackOrigin;
   openPath;
+  profileStorage;
   folder = new TurnFolder();
   spaces = /* @__PURE__ */ new Map();
   batches = /* @__PURE__ */ new Map();
@@ -6701,6 +6947,7 @@ var StrataGateRuntime = class {
   backgroundWorkerTimer;
   backgroundWorkerRun;
   backgroundWorkerWakePending = false;
+  profileMaintenanceRun;
   disposeAdaptersUpdated;
   settingsTail = Promise.resolve();
   batchSequence = 0;
@@ -6726,6 +6973,7 @@ var StrataGateRuntime = class {
   }
   async runBackgroundWorker() {
     if (this.closed || !this.models.isReady()) return;
+    void this.runProfileMaintenance().catch((error) => this.onIngestError(error));
     let namespaces;
     try {
       namespaces = await this.adminNamespaces();
@@ -6742,6 +6990,49 @@ var StrataGateRuntime = class {
       }
     }
   }
+  async runProfileMaintenance(now = Date.now()) {
+    if (this.profileMaintenanceRun) return this.profileMaintenanceRun;
+    if (this.closed || !this.models.isReady() || !this.profileStore().profileMaintenanceDue(now)) return false;
+    const run = (async () => {
+      const current = this.profileStore().getPersistentProfile();
+      try {
+        const proposed = await this.models.runDetached("stratagate-profile-maintenance", () => this.models.maintainProfile(current));
+        return this.profileStore().applyProfileMaintenance(current, proposed, new Date(now).toISOString());
+      } catch (error) {
+        this.profileStore().recordProfileMaintenanceFailure(current, now);
+        throw error;
+      }
+    })();
+    this.profileMaintenanceRun = run;
+    try {
+      return await run;
+    } finally {
+      if (this.profileMaintenanceRun === run) this.profileMaintenanceRun = void 0;
+    }
+  }
+  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, expectedValue, expectedRevision) {
+    const result = this.profileStore().updateProfileField(field, value, source, sourceMessageId, expectedValue, expectedRevision);
+    if (result.modified) this.wakeBackgroundWorker();
+    return result;
+  }
+  profileStore() {
+    return this.profileStorage ??= new SqliteStorage({ filename: this.config.database });
+  }
+  updatePersistentProfileFromTool(field, value) {
+    return this.updatePersistentProfile(field, value, "agent_tool");
+  }
   async runBackgroundNamespace(namespace) {
     if (this.closed || !this.models.isReady()) return;
     const existing = this.backgroundNamespaceRuns.get(namespace);
@@ -7319,10 +7610,12 @@ var StrataGateRuntime = class {
     const settled = await Promise.allSettled(this.spaces.values());
     await Promise.allSettled(this.backgroundNamespaceRuns.values());
     if (this.backgroundWorkerRun) await Promise.allSettled([this.backgroundWorkerRun]);
+    if (this.profileMaintenanceRun) await Promise.allSettled([this.profileMaintenanceRun]);
     await Promise.allSettled(this.migrationRuns.values());
     await Promise.allSettled(this.derivationRuns.values());
     await Promise.allSettled(this.externalImportRuns.values());
     await Promise.all(settled.flatMap((result) => result.status === "fulfilled" ? [result.value.close()] : []));
+    if (this.profileStorage) await this.profileStorage.close();
     this.sessionsById.clear();
     if (flushError !== void 0) throw flushError;
   }
@@ -8547,6 +8840,35 @@ function sessionOf(exec) {
   return exec.agent.session;
 }
 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, 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.
+
+When the user explicitly asks to make a persistent change, that request is already authorization and the tool may be called immediately.
+
+If the assistant only infers that something might be a useful persistent preference or profile fact, it must not update the profile immediately. It must first tell the user exactly which field it proposes to change and what the new value would be, and ask the user to reply exactly "\u540C\u610F". Only a directly subsequent "\u540C\u610F" authorizes that single proposed change. If the user refuses, does not reply "\u540C\u610F", changes the subject, or proposes a different change, do not perform the update.
+
+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", "reasoningLanguage", "responsePreferences", "standingInstructions", "userBackground", "longTermGoals", "persistentNotes"] },
+      value: { type: "string", required: true }
+    },
+    output: jsonOutput,
+    execute: async (args, exec) => {
+      if (Object.keys(args).some((key) => key !== "field" && key !== "value")) throw new TypeError("Unknown Profile update argument");
+      sessionOf(exec);
+      return runtime.updatePersistentProfileFromTool(args.field, args.value);
+    }
+  }));
   ctx.tools.register(defineTool({
     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.',
@@ -8866,11 +9188,11 @@ function installedPackageVersion(names) {
   }
   return "unknown";
 }
-function sendJson(res, status, body) {
+function sendJson(res, status, body, preserveProfileText = false) {
   res.statusCode = status;
   res.setHeader("Content-Type", "application/json; charset=utf-8");
   res.setHeader("Cache-Control", "no-store");
-  res.end(JSON.stringify(redactValue(body)));
+  res.end(JSON.stringify(preserveProfileText ? body : redactValue(body)));
 }
 function numeric(value, fallback, minimum, maximum) {
   const parsed = Number(value);
@@ -9294,6 +9616,47 @@ async function updateSettings(runtime, url) {
   if (lambda !== void 0) result.blockDecayLambda = await runtime.adminSetBlockDecayLambda(lambda);
   return result;
 }
+async function persistentProfile(runtime, req) {
+  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") {
+    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 > 16 * 1024) throw new AdminHttpError(413, "Profile update exceeds 16 KB");
+      chunks.push(value);
+    }
+    suppliedBody = Buffer.concat(chunks).toString("utf8");
+  }
+  let body = suppliedBody;
+  if (typeof body === "string") {
+    try {
+      body = JSON.parse(body);
+    } catch {
+      throw new AdminHttpError(400, "Profile update must be valid JSON");
+    }
+  }
+  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 !== 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 {
+    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;
+  }
+}
 async function feedback(runtime, req, url) {
   if (req.method === "GET") {
     const namespace2 = url.searchParams.get("namespace")?.trim() ?? "";
@@ -9944,6 +10307,8 @@ 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/profile") {
+      sendJson(res, 200, await persistentProfile(runtime, req), true);
     } 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));
@@ -10381,9 +10746,16 @@ async function apply(ctx, config) {
   ctx.systemPrompt.section({ name: "tool:stratagate-feedback", order: 114, text: FEEDBACK_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 profile = runtime.renderProfileContext();
+      if (profile) contexts.push({ name: "stratagate:persistent-profile", text: profile });
+    } catch (error) {
+      ctx.logger.warn(`stratagate-memory profile context failed: ${renderError(error)}`);
+      throw error;
+    }
+    const session = context.agent?.session;
+    if (!session) return { ...assembled, contexts };
     try {
       const text3 = await runtime.buildAutoContext(session);
       contexts.push({ name: "stratagate:auto-memory", text: text3 });