@remnic/plugin-openclaw 1.0.31 → 1.0.33

package/dist/index.js

@@ -90,7 +90,7 @@ import {
   parseOperatorAwareConsolidationResponse,
   renderExtensionsFooter,
   resolveExtensionsRoot
-} from "./chunk-HI5HX3S7.js";
+} from "./chunk-NDZNURDM.js";
 import {
   BoxBuilder,
   countRecallTokenOverlap,
@@ -115,7 +115,7 @@ import {
   CompoundingEngine,
   SharedContextManager,
   defaultTierMigrationCycleBudget
-} from "./chunk-UVQXEQBQ.js";
+} from "./chunk-7NMHI4IC.js";
 import {
   ZodError,
   external_exports
@@ -132,7 +132,7 @@ import {
   buildChatCompletionTokenLimit,
   findGatewayRuntimeModules,
   shouldAssumeOpenAiChatCompletions
-} from "./chunk-24MGN4E3.js";
+} from "./chunk-7NUFIRM3.js";
 import {
   extractJsonCandidates
 } from "./chunk-3A5ELHTT.js";
@@ -202,15 +202,13 @@ import {
   listConnectorStates,
   readConnectorState,
   writeConnectorState
-} from "./chunk-37NKFWSO.js";
-import {
-  expandTildePath
-} from "./chunk-OEI7GLV2.js";
+} from "./chunk-VRGUUHBV.js";
 import {
+  expandTildePath,
   mergeEnv,
   readEnvVar,
   resolveHomeDir
-} from "./chunk-I6B2W2IY.js";
+} from "./chunk-TDRJVMUP.js";
 import {
   __export
 } from "./chunk-MLKGABMK.js";
@@ -5917,7 +5915,9 @@ var ExtractionEngine = class {
       log.warn("no OpenAI API key \u2014 direct OpenAI client disabled; local and gateway fallback paths remain available");
     }
     this.localLlm = localLlm ?? new LocalLlmClient(config, modelRegistry);
-    this.fallbackLlm = new FallbackLlmClient(gatewayConfig);
+    this.fallbackLlm = new FallbackLlmClient(gatewayConfig, {
+      workspaceDir: config.workspaceDir
+    });
     this.modelRegistry = modelRegistry ?? new ModelRegistry(config.memoryDir);
     if (config.modelSource === "gateway") {
       log.debug(
@@ -14039,7 +14039,9 @@ var HourlySummarizer = class {
     this.modelRegistry = modelRegistry ?? new ModelRegistry(config.memoryDir);
     this.transcript = transcript;
     this.localLlm = new LocalLlmClient(config, this.modelRegistry);
-    this.fallbackLlm = new FallbackLlmClient(gatewayConfig);
+    this.fallbackLlm = new FallbackLlmClient(gatewayConfig, {
+      workspaceDir: config.workspaceDir
+    });
     if (!gatewayConfig?.agents?.defaults?.model?.primary && !config.localLlmEnabled && config.modelSource !== "gateway") {
       log.warn("no gateway default AI and local LLM disabled \u2014 hourly summarization disabled");
     }
@@ -23513,6 +23515,7 @@ async function collectTurnReferenceEvidence(options) {
   await collectContentLabelReferenceEvidence({
     engine: options.engine,
     sessionId: options.sessionId,
+    query: options.query,
     references,
     evidenceItems: options.evidenceItems,
     seenTurns: options.seenTurns
@@ -23565,7 +23568,9 @@ async function collectContentLabelReferenceEvidence(options) {
       if (appendedWindows >= CONTENT_LABEL_MAX_PAIRED_WINDOWS_PER_REFERENCE) {
         break;
       }
-      const { fromTurn, toTurn } = contentLabelEvidenceWindow(hit);
+      const { fromTurn, toTurn } = contentLabelEvidenceWindow(hit, {
+        includeSuccessor: hasSuccessorTrajectoryIntent(options.query)
+      });
       const expanded = await options.engine.expandContext(
         hit.session_id,
         fromTurn,
@@ -23644,18 +23649,75 @@ function nearestTurnDistance(turnIndex, candidates) {
   }
   return nearest;
 }
-function contentLabelEvidenceWindow(hit) {
+function contentLabelEvidenceWindow(hit, options = {}) {
+  const successorTurns = options.includeSuccessor === true ? 2 : 0;
   if (hit.labelKind === "action") {
     return {
       fromTurn: Math.max(0, hit.turn_index - 1),
-      toTurn: hit.turn_index + 1
+      toTurn: hit.turn_index + 1 + successorTurns
     };
   }
   return {
     fromTurn: Math.max(0, hit.turn_index - 1),
-    toTurn: hit.turn_index
+    toTurn: hit.turn_index + successorTurns
   };
 }
+function hasSuccessorTrajectoryIntent(query) {
+  const raw = query.toLowerCase();
+  const normalized = raw.replace(/[^a-z0-9]+/g, " ").trim();
+  if ([
+    /\bafter\s+(?:step|action|observation|turn)\s+\d+\b/,
+    /\b(?:next|following|subsequent|successor)\s+(?:step|action|observation|turn)\b/,
+    /\b(?:step|action|observation|turn)\s+\d+\s+(?:then|and then)\b/,
+    /\bwhat\s+(?:happened|came|occurred)\s+next\b/
+  ].some((pattern) => pattern.test(normalized))) {
+    return true;
+  }
+  if (!hasLoopExitIntent(normalized)) {
+    return false;
+  }
+  if (!hasBoundedTrajectoryReference(raw)) {
+    return true;
+  }
+  return !asksForActionInsideBoundedRange(normalized) && hasNamedTrajectoryActionCue(normalized);
+}
+function hasBoundedTrajectoryReference(query) {
+  return hasBoundedTrajectoryRange(query) || hasSingleTrajectoryReference(query);
+}
+function hasLoopExitIntent(normalizedQuery) {
+  const exitVerbs = "(?:breaks?|breaking|broke|ends?|ending|ended|stops?|stopping|stopped)";
+  const loopNouns = "(?:loop|cycle|pattern|sequence)";
+  return [
+    new RegExp(
+      `\\b${exitVerbs}\\s+(?:out\\s+of\\s+)?(?:this|that|the|a|an)?\\s*${loopNouns}\\b`
+    ),
+    new RegExp(
+      `\\b${loopNouns}\\s+(?:${exitVerbs}|is\\s+${exitVerbs}|was\\s+${exitVerbs})\\b`
+    )
+  ].some((pattern) => pattern.test(normalizedQuery));
+}
+function hasBoundedTrajectoryRange(query) {
+  return [
+    /\b(?:between|from|in|during|within)\s+(?:steps?|actions?|observations?|turns?)\s+#?\d+\s*(?:-|\u2013|\u2014|\bto\b|\bthrough\b|\bthru\b|\band\b)\s*#?\d+\b/,
+    /\b(?:steps?|actions?|observations?|turns?)\s+#?\d+\s*(?:-|\u2013|\u2014|\bto\b|\bthrough\b|\bthru\b)\s*#?\d+\b/
+  ].some((pattern) => pattern.test(query));
+}
+function hasSingleTrajectoryReference(query) {
+  return /\b(?:in|during|within|at|on)?\s*(?:steps?|actions?|observations?|turns?)\s+#?\d+\b/.test(
+    query
+  );
+}
+function asksForActionInsideBoundedRange(normalizedQuery) {
+  return /\b(?:which|what)\s+(?:single\s+)?(?:action|move|step|maneuver)\s+(?:broke|breaks|breaking|ended|ends|stopped|stops|mattered|accomplished|advanced)\b/.test(
+    normalizedQuery
+  );
+}
+function hasNamedTrajectoryActionCue(normalizedQuery) {
+  const actions = "(?:up|down|left|right|wait|stay|push|pull|open|close|use|enter|exit)";
+  return new RegExp(
+    `\\b(?:${actions}\\s+(?:action|move|step|maneuver)|(?:action|move|step|maneuver)\\s+${actions})\\b`
+  ).test(normalizedQuery);
+}
 function contentHasReferenceLabel(content, labelKind, referenceNumber) {
   const label = labelKind === "action" ? "Action" : "Observation";
   const escapedNumber = String(referenceNumber).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -25134,6 +25196,16 @@ function resolveObjectiveStateStoreDir(memoryDir, overrideDir) {
   }
   return path29.join(memoryDir, "state", "objective-state");
 }
+function objectiveStateStoreOverrideForNamespace(options) {
+  const configured = options.configuredStoreDir?.trim();
+  if (!configured) return void 0;
+  if (!options.namespacesEnabled) return configured;
+  const defaultStoreDir = path29.join(options.memoryDir, "state", "objective-state");
+  if (path29.resolve(configured) === path29.resolve(defaultStoreDir)) {
+    return void 0;
+  }
+  return path29.join(configured, "namespaces", options.namespace);
+}
 function validateObjectiveStateSnapshot(raw) {
   if (!isRecord(raw)) throw new Error("objective-state snapshot must be an object");
   if (raw.schemaVersion !== 1) throw new Error("schemaVersion must be 1");
@@ -27468,8 +27540,12 @@ function parseOpenAiMessageParts(input, _options = {}) {
     }
     if (type === "function_call") {
       const toolName = asNonEmptyString(item.name ?? item.tool_name);
+      const callId = asNonEmptyString(item.call_id ?? item.callId);
+      const itemId = asNonEmptyString(item.id);
       const payload = {
-        id: item.id ?? item.call_id,
+        id: callId ?? itemId,
+        ...callId ? { call_id: callId } : {},
+        ...itemId && itemId !== callId ? { response_item_id: itemId } : {},
         name: toolName,
         arguments: parseMaybeJson(item.arguments)
       };
@@ -27478,7 +27554,14 @@ function parseOpenAiMessageParts(input, _options = {}) {
     }
     if (type === "function_call_output") {
       const output = asNonEmptyString(item.output) ?? JSON.stringify(sanitizePayload(item.output ?? item));
-      parts.push(makePart("tool_result", { id: item.id ?? item.call_id, output }, {
+      const callId = asNonEmptyString(item.call_id ?? item.callId);
+      const itemId = asNonEmptyString(item.id);
+      parts.push(makePart("tool_result", {
+        id: callId ?? itemId,
+        ...callId ? { call_id: callId } : {},
+        ...itemId && itemId !== callId ? { response_item_id: itemId } : {},
+        output
+      }, {
         filePath: firstFilePath(output)
       }));
       continue;
@@ -27517,7 +27600,12 @@ function parseAnthropicMessageParts(input, _options = {}) {
     if (type === "tool_result") {
       const content = block.content;
       const rendered = renderUnknownContent(content);
-      parts.push(makePart("tool_result", { id: block.tool_use_id, content: sanitizePayload(content) }, {
+      parts.push(makePart("tool_result", {
+        id: block.tool_use_id,
+        content: sanitizePayload(content),
+        ...typeof block.is_error === "boolean" ? { is_error: block.is_error } : {},
+        ...typeof block.isError === "boolean" ? { isError: block.isError } : {}
+      }, {
         filePath: firstFilePath(rendered)
       }));
       continue;
@@ -27560,7 +27648,7 @@ function parseOpenClawMessageParts(input, options = {}) {
       })
     ]);
   }
-  const rendered = options.renderedContent ?? asNonEmptyString(obj.content);
+  const rendered = options.allowRenderedFallback === false ? null : options.renderedContent ?? asNonEmptyString(obj.content);
   return rendered ? withOrdinals(partsFromRenderedText(rendered)) : [];
 }
 function partsFromRenderedText(text) {
@@ -27648,6 +27736,9 @@ function withRenderedFallback(parts, options) {
   return parts.length > 0 ? parts : renderedFallbackParts(options);
 }
 function renderedFallbackParts(options) {
+  if (options.allowRenderedFallback === false) {
+    return [];
+  }
   const rendered = asNonEmptyString(options.renderedContent);
   return rendered ? partsFromRenderedText(rendered) : [];
 }
@@ -34221,7 +34312,9 @@ var Orchestrator = class _Orchestrator {
       client.disableThinking = true;
       return client;
     })() : this.localLlm;
-    this._fastGatewayLlm = config.modelSource === "gateway" ? new FallbackLlmClient(config.gatewayConfig) : null;
+    this._fastGatewayLlm = config.modelSource === "gateway" ? new FallbackLlmClient(config.gatewayConfig, {
+      workspaceDir: config.workspaceDir
+    }) : null;
     if (config.modelSource === "gateway") {
       log.debug(
         `orchestrator: gateway model source active` + (config.gatewayAgentId ? ` (primary: ${config.gatewayAgentId})` : "") + (config.fastGatewayAgentId ? ` (fast: ${config.fastGatewayAgentId})` : "")
@@ -34247,17 +34340,19 @@ var Orchestrator = class _Orchestrator {
       const summarizeFn = async (text, targetTokens, aggressive) => {
         const instructionText = aggressive ? `Compress the following into bullet points. One bullet per distinct fact or decision. Maximum ${targetTokens} tokens total. No prose.` : `Compress the following conversation segment into a dense summary. Preserve: decisions made, code artifacts mentioned, errors encountered, open questions, and any commitments or next-steps. Omit: pleasantries, restatements, and anything the agent would not need to recall later. Output a single paragraph, maximum ${targetTokens} tokens.`;
         try {
-          const result = await this.localLlm.chatCompletion(
-            [
-              { role: "system", content: instructionText },
-              { role: "user", content: text.slice(0, 12e3) }
-            ],
-            {
-              maxTokens: targetTokens * 2,
-              operation: "lcm-summarize",
-              priority: "background"
-            }
-          );
+          const messages = [
+            { role: "system", content: instructionText },
+            { role: "user", content: text.slice(0, 12e3) }
+          ];
+          const result = this.config.modelSource === "gateway" && this._fastGatewayLlm ? await this._fastGatewayLlm.chatCompletion(messages, {
+            maxTokens: targetTokens * 2,
+            timeoutMs: this.config.localLlmFastTimeoutMs,
+            agentId: this.config.fastGatewayAgentId || this.config.gatewayAgentId || void 0
+          }) : await this.localLlm.chatCompletion(messages, {
+            maxTokens: targetTokens * 2,
+            operation: "lcm-summarize",
+            priority: "background"
+          });
           return result?.content ?? null;
         } catch {
           return null;
@@ -35195,14 +35290,16 @@ ${doc.content}` : doc.content,
       );
       return result;
     }
-    const { FallbackLlmClient: FallbackLlmClient2 } = await import("./fallback-llm-EGB622FE.js");
+    const { FallbackLlmClient: FallbackLlmClient2 } = await import("./fallback-llm-33SPYXQY.js");
     const useGateway = this.config.modelSource === "gateway";
     const modelSetting = this.config.semanticConsolidationModel;
     if (modelSetting === "fast" && this.fastLlm && !useGateway) {
       log.info("[semantic-consolidation] using fast local LLM for synthesis");
     }
     const gatewayAgentId = useGateway ? modelSetting === "fast" && this.config.fastGatewayAgentId ? this.config.fastGatewayAgentId : this.config.gatewayAgentId || void 0 : void 0;
-    const llm = new FallbackLlmClient2(this.config.gatewayConfig);
+    const llm = new FallbackLlmClient2(this.config.gatewayConfig, {
+      workspaceDir: this.config.workspaceDir
+    });
     if (!llm.isAvailable(gatewayAgentId) && !(modelSetting === "fast" && this.fastLlm && !useGateway)) {
       log.warn(
         "[semantic-consolidation] no LLM available \u2014 skipping synthesis"
@@ -35356,7 +35453,9 @@ ${doc.content}` : doc.content,
     if (this.config.peerProfileReasonerEnabled) {
       try {
         const { runPeerProfileReasoner } = await import("./peers-KRFXWRQ6.js");
-        const llm2 = new FallbackLlmClient2(this.config.gatewayConfig);
+        const llm2 = new FallbackLlmClient2(this.config.gatewayConfig, {
+          workspaceDir: this.config.workspaceDir
+        });
         const peerResult = await runPeerProfileReasoner({
           memoryDir: targetStorage.dir,
           enabled: true,
@@ -37825,13 +37924,27 @@ ${lines.join("\n\n")}`;
           });
           return null;
         }
-        const results = await searchObjectiveStateSnapshots({
-          memoryDir: this.config.memoryDir,
-          objectiveStateStoreDir: this.config.objectiveStateStoreDir,
-          query: retrievalQuery,
-          maxResults,
-          sessionKey
-        });
+        const objectiveStateSearches = await Promise.all(
+          recallNamespaces.map(async (namespace) => {
+            const storage = this.config.namespacesEnabled ? await this.getStorage(namespace) : null;
+            return searchObjectiveStateSnapshots({
+              memoryDir: this.config.namespacesEnabled ? storage.dir : this.config.memoryDir,
+              objectiveStateStoreDir: objectiveStateStoreOverrideForNamespace({
+                memoryDir: this.config.memoryDir,
+                configuredStoreDir: this.config.objectiveStateStoreDir,
+                namespacesEnabled: this.config.namespacesEnabled,
+                namespace
+              }),
+              query: retrievalQuery,
+              maxResults,
+              sessionKey
+            });
+          })
+        );
+        const results = objectiveStateSearches.flat().sort((left, right) => {
+          if (right.score !== left.score) return right.score - left.score;
+          return right.snapshot.recordedAt.localeCompare(left.snapshot.recordedAt);
+        }).slice(0, maxResults);
         recordRecallSectionMetric({
           section: "objectiveState",
           priority: "core",
@@ -37960,7 +38073,7 @@ ${lines.join("\n\n")}`;
           return null;
         }
         try {
-          const { getCalibrationRulesForRecall, buildCalibrationRecallSection } = await import("./calibration-V6NBBNCD.js");
+          const { getCalibrationRulesForRecall, buildCalibrationRecallSection } = await import("./calibration-JD4AU7FB.js");
           const rules = await getCalibrationRulesForRecall(this.config.memoryDir);
           if (rules.length === 0) {
             recordRecallSectionMetric({
@@ -41418,7 +41531,9 @@ ${normalized}`).digest("hex");
           judgeCandidates,
           this.config,
           this.localLlm,
-          new FallbackLlmClient(this.config.gatewayConfig),
+          new FallbackLlmClient(this.config.gatewayConfig, {
+            workspaceDir: this.config.workspaceDir
+          }),
           this.judgeVerdictCache,
           this.judgeDeferCounts,
           judgeTelemetryHandler
@@ -55209,6 +55324,639 @@ async function recordMemoryOutcome(storage, input) {
   });
 }
 
+// ../remnic-core/src/objective-state-writers.ts
+import crypto2 from "crypto";
+var rawProviderParts = /* @__PURE__ */ new WeakSet();
+function markRawProviderParts(parts) {
+  for (const part of parts) {
+    rawProviderParts.add(part);
+  }
+  return parts;
+}
+function isRawProviderPart(part) {
+  return rawProviderParts.has(part);
+}
+function hashSha256(value) {
+  return crypto2.createHash("sha256").update(value).digest("hex");
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function optionalString2(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function toolNameTokens(toolName) {
+  if (!toolName) return [];
+  return toolName.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().split(/[^a-z0-9]+/).filter((token) => token.length > 0);
+}
+function normalizedToolName(toolName) {
+  return toolNameTokens(toolName).join("_");
+}
+function parseToolArguments(value) {
+  if (isRecord4(value)) return value;
+  if (typeof value !== "string") return void 0;
+  try {
+    const parsed = JSON.parse(value);
+    return isRecord4(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function stableStringify2(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map((entry) => stableStringify2(entry)).join(",")}]`;
+  }
+  if (isRecord4(value)) {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify2(value[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value) ?? String(value);
+}
+function extractTextContent(value) {
+  if (typeof value === "string") return value.trim();
+  if (Array.isArray(value)) {
+    return value.map((block) => {
+      if (typeof block === "string") return block.trim();
+      if (isRecord4(block) && block.type === "text" && typeof block.text === "string") {
+        return block.text.trim();
+      }
+      return "";
+    }).filter((item) => item.length > 0).join("\n");
+  }
+  if (isRecord4(value)) {
+    return JSON.stringify(value);
+  }
+  return "";
+}
+function parseToolResultPayload(content) {
+  const text = extractTextContent(content);
+  if (text.length === 0) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function resultHash(value) {
+  if (value === void 0) return void 0;
+  const canonical = typeof value === "string" ? value : stableStringify2(value);
+  if (!canonical || canonical.length === 0) return void 0;
+  return `sha256:${hashSha256(canonical)}`;
+}
+function getToolCallContexts(messages) {
+  const contexts = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    if (message.role !== "assistant") continue;
+    const toolCalls = message.tool_calls ?? message.toolCalls;
+    if (!Array.isArray(toolCalls)) continue;
+    for (const call of toolCalls) {
+      if (!isRecord4(call)) continue;
+      const toolCallId = optionalString2(call.id) ?? optionalString2(call.toolCallId);
+      if (!toolCallId) continue;
+      const fn = isRecord4(call.function) ? call.function : void 0;
+      const toolName = optionalString2(fn?.name) ?? optionalString2(call.name);
+      const args = parseToolArguments(fn?.arguments) ?? parseToolArguments(call.arguments) ?? parseToolArguments(call.args) ?? parseToolArguments(call.input);
+      contexts.set(toolCallId, { toolCallId, toolName, args });
+    }
+  }
+  return contexts;
+}
+function toolCallIdForMessage(message) {
+  return optionalString2(message.tool_call_id) ?? optionalString2(message.toolCallId) ?? optionalString2(message.tool_use_id) ?? optionalString2(message.toolUseId);
+}
+function toolNameForMessage(message, context) {
+  return optionalString2(message.name) ?? optionalString2(message.toolName) ?? optionalString2(message.tool) ?? context?.toolName;
+}
+function pickString(args, keys) {
+  if (!args) return void 0;
+  for (const key of keys) {
+    const value = optionalString2(args[key]);
+    if (value) return value;
+  }
+  return void 0;
+}
+function pickFirstStringArrayValue(args, key) {
+  const value = args?.[key];
+  if (!Array.isArray(value)) return void 0;
+  for (const item of value) {
+    const candidate = optionalString2(item);
+    if (candidate) return candidate;
+  }
+  return void 0;
+}
+function fileScopeFromArgs(args) {
+  const destinationPath = pickString(args, ["destination", "dest", "targetPath", "target", "to"]) ?? pickString(args, ["path", "filePath", "workspacePath", "projectPath"]) ?? pickFirstStringArrayValue(args, "paths");
+  const sourcePath = pickString(args, ["source", "src", "from", "oldPath"]);
+  const scope = destinationPath ?? sourcePath;
+  return { scope, sourcePath, destinationPath };
+}
+function fileContentHash(args) {
+  const content = pickString(args, ["content", "patch", "diff", "text", "value"]) ?? args?.updates;
+  return resultHash(content);
+}
+function inferOutcome(message, parsedPayload) {
+  if (message.isError === true) return "failure";
+  if (isRecord4(parsedPayload)) {
+    if (parsedPayload.partial === true || parsedPayload.status === "partial") return "partial";
+    if (parsedPayload.success === false || parsedPayload.ok === false) return "failure";
+    if (parsedPayload.success === true || parsedPayload.ok === true) return "success";
+    if (typeof parsedPayload.exitCode === "number") {
+      return parsedPayload.exitCode === 0 ? "success" : "failure";
+    }
+    if (optionalString2(parsedPayload.error)) return "failure";
+    if (parsedPayload.status === "error" || parsedPayload.status === "failed") return "failure";
+    if (parsedPayload.status === "ok" || parsedPayload.status === "success") return "success";
+    const outputText = [
+      optionalString2(parsedPayload.stdout),
+      optionalString2(parsedPayload.stderr)
+    ].filter((entry) => entry !== void 0).join("\n");
+    if (outputText) {
+      const outputOutcome = inferOutcome({}, outputText);
+      if (outputOutcome !== "unknown") return outputOutcome;
+    }
+  }
+  if (typeof parsedPayload === "string") {
+    const lowered = parsedPayload.toLowerCase();
+    const loweredForFailure = lowered.replace(/\b(?:previously\s+)?failed tests?\s+now\s+pass(?:ed|es)?\b/g, "");
+    const hasZeroCountMarker = /\b(?:0|no)\s+(?:errors?|failures?|exceptions?|timeouts?)\b/.test(lowered);
+    const loweredForFailureCounts = loweredForFailure.replace(/\b(?:0|no)\s+errors?\b/g, "").replace(/\b(?:0|no)\s+failures?\b/g, "").replace(/\b(?:0|no)\s+exceptions?\b/g, "").replace(/\b(?:0|no)\s+timeouts?\b/g, "");
+    const hasNonZeroErrorCounts = /\b[1-9]\d*\s+errors?\b/.test(loweredForFailureCounts);
+    const hasNegatedSuccessMarkers = /\b(?:not|did not|didn't|doesn't|isn't|aren't|wasn't|weren't|won't|can't|couldn't|shouldn't|wouldn't)\s+(?:ok|pass|passed|passes|succeeded|success)\b/.test(loweredForFailure);
+    const hasSuccessMarkers = /\b(success|succeeded|pass|passes|passed|ok)\b/.test(lowered) || hasZeroCountMarker;
+    const hasFailureMarkers = hasNegatedSuccessMarkers || /\b(exceptions?|failed|failures?|fatal|timeouts?|timed out)\b/.test(loweredForFailureCounts) || hasNonZeroErrorCounts || /\berrors?\b/.test(loweredForFailureCounts) || /\b[a-z]+error\b/.test(loweredForFailureCounts) || /\b[a-z]+exception\b/.test(loweredForFailureCounts);
+    if (hasFailureMarkers) return "failure";
+    if (hasSuccessMarkers) return "success";
+  }
+  return "unknown";
+}
+function isProcessTool(toolName, args) {
+  const tokens = toolNameTokens(toolName);
+  const normalizedName = normalizedToolName(toolName);
+  if (pickString(args, ["cmd", "command", "script"])) return true;
+  return ["exec", "shell", "bash", "terminal", "run_command", "exec_command"].some(
+    (token) => token.includes("_") ? normalizedName === token : tokens.includes(token)
+  );
+}
+function isFileTool(toolName, args) {
+  const tokens = toolNameTokens(toolName);
+  const fileScope = fileScopeFromArgs(args);
+  if (fileScope.scope) return true;
+  return ["file", "path", "patch", "directory", "mkdir", "rename", "move"].some(
+    (token) => tokens.includes(token)
+  );
+}
+function inferFileChangeKind(toolName, outcome) {
+  if (outcome === "failure") return "failed";
+  const tokens = toolNameTokens(toolName);
+  if (["delete", "remove", "unlink"].some((token) => tokens.includes(token))) return "deleted";
+  if (["create", "mkdir", "new"].some((token) => tokens.includes(token))) return "created";
+  if (["write", "edit", "patch", "update", "append", "move", "rename"].some((token) => tokens.includes(token))) {
+    return "updated";
+  }
+  return "observed";
+}
+function buildFileValueRefs(args, changeKind) {
+  const { sourcePath, destinationPath, scope } = fileScopeFromArgs(args);
+  const contentHash = fileContentHash(args);
+  if (changeKind === "failed") {
+    if (sourcePath && destinationPath && sourcePath !== destinationPath) {
+      return {
+        before: { ref: sourcePath },
+        after: { ref: destinationPath }
+      };
+    }
+    return {
+      before: sourcePath ? { ref: sourcePath } : void 0,
+      after: scope ? { ref: scope } : void 0
+    };
+  }
+  if (changeKind === "deleted") {
+    return {
+      before: scope ? { exists: true, ref: scope } : void 0,
+      after: { exists: false }
+    };
+  }
+  if (changeKind === "created") {
+    return {
+      after: {
+        exists: true,
+        ref: scope,
+        valueHash: contentHash
+      }
+    };
+  }
+  if (sourcePath && destinationPath && sourcePath !== destinationPath) {
+    return {
+      before: { exists: true, ref: sourcePath },
+      after: {
+        exists: true,
+        ref: destinationPath
+      }
+    };
+  }
+  return {
+    after: {
+      exists: true,
+      ref: scope,
+      valueHash: contentHash
+    }
+  };
+}
+function summarizeSnapshot(kind, changeKind, toolName, scope) {
+  const action = changeKind === "executed" ? "Executed" : changeKind === "failed" ? "Failed" : changeKind === "created" ? "Created" : changeKind === "deleted" ? "Deleted" : changeKind === "updated" ? "Updated" : "Observed";
+  if (kind === "process") return `${action} process via ${toolName}: ${scope}`;
+  if (kind === "file") return `${action} file via ${toolName}: ${scope}`;
+  return `${action} tool result from ${toolName}: ${scope}`;
+}
+function buildGenericToolAfterRef(outcome, parsedPayload) {
+  const valueHash = resultHash(parsedPayload);
+  return valueHash ? { valueHash } : { exists: outcome !== "failure" };
+}
+function snapshotIdFor(sessionKey, recordedAt, index, toolName, scope, stableKey2) {
+  const digest = crypto2.createHash("sha256").update(
+    stableKey2 ? `${sessionKey}|${recordedAt}|${index}|${toolName}|${scope}|stable|${stableKey2}` : `${sessionKey}|${recordedAt}|${index}|${toolName}|${scope}`
+  ).digest("hex").slice(0, 12);
+  return `obj-${digest}`;
+}
+function objectiveStatePartsForObservedMessage(message) {
+  if (message.role === "user") {
+    const explicitParts2 = Array.isArray(message.parts) && message.parts.length > 0 ? sanitizeUserRoleToolResultParts(message.parts) : [];
+    if (Array.isArray(message.parts) && message.parts.length > 0) {
+      const rawParts2 = userRawToolResultParts(message);
+      return mergeObservedEvidenceParts(explicitParts2, rawParts2);
+    }
+    return userRawToolResultParts(message);
+  }
+  if (message.role !== "assistant") {
+    return [];
+  }
+  const explicitParts = Array.isArray(message.parts) && message.parts.length > 0 ? message.parts : [];
+  const rawParts = assistantRawObjectiveStateParts(message);
+  return mergeObservedEvidenceParts(explicitParts, rawParts);
+}
+function userRawToolResultParts(message) {
+  const rawContent = message.rawContent ?? message.content;
+  if (!containsProviderToolResultBlock(rawContent)) {
+    return [];
+  }
+  return markRawProviderParts(
+    sanitizeUserRoleToolResultParts(parseMessageParts(rawContent, {
+      sourceFormat: message.sourceFormat,
+      allowRenderedFallback: false
+    }))
+  );
+}
+function assistantRawObjectiveStateParts(message) {
+  if (message.rawContent === void 0 || message.rawContent === null) {
+    return [];
+  }
+  return markRawProviderParts(parseMessageParts(message.rawContent, {
+    sourceFormat: message.sourceFormat,
+    allowRenderedFallback: false
+  }));
+}
+function mergeObservedEvidenceParts(explicitParts, rawParts) {
+  if (explicitParts.length === 0) return rawParts;
+  if (rawParts.length === 0) return explicitParts;
+  const merged = [...explicitParts];
+  const seen = new Set(
+    explicitParts.filter(isObjectiveStateEvidencePart).map(objectiveStateEvidencePartKey)
+  );
+  for (const part of rawParts) {
+    if (!isObjectiveStateEvidencePart(part)) continue;
+    const key = objectiveStateEvidencePartKey(part);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    merged.push(part);
+  }
+  return merged;
+}
+function isObjectiveStateEvidencePart(part) {
+  return part.kind === "tool_call" || part.kind === "tool_result" || part.kind === "file_write" || part.kind === "patch";
+}
+function objectiveStateEvidencePartKey(part) {
+  const id = partToolCallId(part);
+  if (id) return `${part.kind}:id:${id}`;
+  const toolName = partToolName(part) ?? "";
+  const filePath = partFilePath(part) ?? "";
+  return `${part.kind}:shape:${toolName}:${filePath}:${stableStringify2(partPayload(part))}`;
+}
+function flattenObservedParts(messages) {
+  const entries = [];
+  messages.forEach((message, messageIndex) => {
+    const parts = objectiveStatePartsForObservedMessage(message);
+    parts.forEach((part, partIndex) => {
+      entries.push({ messageIndex, partIndex, part });
+    });
+  });
+  return entries.sort((a, b) => {
+    if (a.messageIndex !== b.messageIndex) return a.messageIndex - b.messageIndex;
+    const aOrdinal = typeof a.part.ordinal === "number" ? a.part.ordinal : a.partIndex;
+    const bOrdinal = typeof b.part.ordinal === "number" ? b.part.ordinal : b.partIndex;
+    if (aOrdinal !== bOrdinal) return aOrdinal - bOrdinal;
+    return a.partIndex - b.partIndex;
+  });
+}
+function sanitizeUserRoleToolResultParts(parts) {
+  return parts.filter((part) => part.kind === "tool_result").map((part) => {
+    const payload = { ...partPayload(part) };
+    delete payload.name;
+    delete payload.tool;
+    delete payload.toolName;
+    delete payload.tool_name;
+    return {
+      ...part,
+      toolName: null,
+      tool_name: null,
+      payload
+    };
+  });
+}
+function containsProviderToolResultBlock(value) {
+  if (Array.isArray(value)) {
+    return value.some(containsProviderToolResultBlock);
+  }
+  if (!isRecord4(value)) return false;
+  const type = optionalString2(value.type ?? value.kind);
+  if (type === "tool_result" || type === "function_call_output") {
+    return true;
+  }
+  return containsProviderToolResultBlock(value.content) || containsProviderToolResultBlock(value.output) || containsProviderToolResultBlock(value.items);
+}
+function partPayload(part) {
+  return isRecord4(part.payload) ? part.payload : {};
+}
+function partToolCallId(part) {
+  const payload = partPayload(part);
+  return optionalString2(payload.call_id) ?? optionalString2(payload.callId) ?? optionalString2(payload.id) ?? optionalString2(payload.tool_call_id) ?? optionalString2(payload.toolCallId) ?? optionalString2(payload.tool_use_id) ?? optionalString2(payload.toolUseId);
+}
+function partToolName(part) {
+  const payload = partPayload(part);
+  return optionalString2(part.toolName) ?? optionalString2(part.tool_name) ?? optionalString2(payload.name) ?? optionalString2(payload.toolName) ?? optionalString2(payload.tool_name) ?? (part.kind === "patch" ? "apply_patch" : void 0) ?? (part.kind === "file_write" ? "file_write" : void 0);
+}
+function partFilePath(part) {
+  const payload = partPayload(part);
+  return optionalString2(part.filePath) ?? optionalString2(part.file_path) ?? optionalString2(payload.path) ?? optionalString2(payload.filePath) ?? optionalString2(payload.file_path);
+}
+function syntheticPartId(options) {
+  const digest = hashSha256(
+    [
+      options.sessionKey,
+      String(options.messageIndex),
+      String(options.part.ordinal ?? options.partIndex),
+      options.part.kind,
+      optionalString2(options.part.toolName) ?? "",
+      optionalString2(options.part.tool_name) ?? "",
+      optionalString2(options.part.filePath) ?? "",
+      optionalString2(options.part.file_path) ?? "",
+      stableStringify2(options.part.payload)
+    ].join("|")
+  ).slice(0, 12);
+  return `part-${digest}`;
+}
+function toolArgumentsFromPart(part) {
+  const payload = partPayload(part);
+  const parsedArgs = parseToolArguments(payload.arguments) ?? parseToolArguments(payload.input) ?? parseToolArguments(payload.args) ?? parseToolArguments(payload.params) ?? payload;
+  const args = { ...parsedArgs };
+  const filePath = partFilePath(part);
+  if (filePath && !pickString(args, ["path", "filePath", "file_path"])) {
+    args.path = filePath;
+  }
+  if (part.kind === "patch" && !pickString(args, ["patch", "diff", "text"])) {
+    const text = optionalString2(payload.text) ?? optionalString2(payload.patch);
+    if (text) args.patch = text;
+  }
+  return args;
+}
+function toolResultContentFromPart(part) {
+  const payload = partPayload(part);
+  if ("output" in payload) return payload.output;
+  if ("content" in payload) return payload.content;
+  if ("result" in payload) return payload.result;
+  if ("value" in payload) return payload.value;
+  return payload;
+}
+function inlineToolResultContentFromPart(part) {
+  const payload = partPayload(part);
+  if (hasDefinedPayloadKey(payload, "output")) return payload.output;
+  if (hasDefinedPayloadKey(payload, "result")) return payload.result;
+  if (part.kind === "tool_result" && hasDefinedPayloadKey(payload, "value")) {
+    return payload.value;
+  }
+  const statusPayload = {};
+  for (const key of ["exitCode", "ok", "success", "error", "stdout", "stderr"]) {
+    if (hasDefinedPayloadKey(payload, key)) {
+      statusPayload[key] = payload[key];
+    }
+  }
+  return Object.keys(statusPayload).length > 0 ? statusPayload : payload;
+}
+function hasDefinedPayloadKey(payload, key) {
+  return Object.prototype.hasOwnProperty.call(payload, key) && payload[key] !== void 0;
+}
+function partHasInlineToolResult(part) {
+  const payload = partPayload(part);
+  return hasDefinedPayloadKey(payload, "output") || hasDefinedPayloadKey(payload, "result") || part.kind === "tool_result" && hasDefinedPayloadKey(payload, "value") || hasDefinedPayloadKey(payload, "exitCode") || hasDefinedPayloadKey(payload, "ok") || hasDefinedPayloadKey(payload, "success") || hasDefinedPayloadKey(payload, "error") || hasDefinedPayloadKey(payload, "stdout") || hasDefinedPayloadKey(payload, "stderr");
+}
+function toolResultIsError(part) {
+  const payload = partPayload(part);
+  return payload.isError === true || payload.is_error === true || payload.ok === false || payload.success === false || optionalString2(payload.error) !== void 0;
+}
+function buildSyntheticAssistantToolCall(id, toolName, args) {
+  return {
+    role: "assistant",
+    tool_calls: [
+      {
+        id,
+        function: {
+          name: toolName,
+          arguments: JSON.stringify(args)
+        }
+      }
+    ]
+  };
+}
+function observedPartsToAgentMessages(options) {
+  const entries = flattenObservedParts(options.messages);
+  const resultIds = new Set(
+    entries.filter((entry) => entry.part.kind === "tool_result").map((entry) => partToolCallId(entry.part)).filter((id) => id !== void 0)
+  );
+  const synthetic = [];
+  let pendingIdlessToolCallId;
+  for (let entryIndex = 0; entryIndex < entries.length; entryIndex += 1) {
+    const entry = entries[entryIndex];
+    const { part } = entry;
+    if (part.kind === "tool_call" || part.kind === "file_write" || part.kind === "patch") {
+      const toolName = partToolName(part);
+      if (!toolName) continue;
+      const observedToolCallId = partToolCallId(part);
+      const id = observedToolCallId ?? syntheticPartId({
+        sessionKey: options.sessionKey,
+        messageIndex: entry.messageIndex,
+        partIndex: entry.partIndex,
+        part
+      });
+      const args = toolArgumentsFromPart(part);
+      synthetic.push(buildSyntheticAssistantToolCall(id, toolName, args));
+      const nextEntry = entries[entryIndex + 1];
+      const nextIsIdlessToolResult = nextEntry?.part.kind === "tool_result" && partToolCallId(nextEntry.part) === void 0;
+      pendingIdlessToolCallId = nextIsIdlessToolResult ? id : void 0;
+      const hasSeparateToolResult = resultIds.has(id) || nextIsIdlessToolResult;
+      if (partHasInlineToolResult(part) && !hasSeparateToolResult) {
+        synthetic.push({
+          role: "tool",
+          tool_call_id: id,
+          name: toolName,
+          content: inlineToolResultContentFromPart(part),
+          ...toolResultIsError(part) ? { isError: true } : {}
+        });
+        pendingIdlessToolCallId = void 0;
+        continue;
+      }
+      if ((part.kind === "file_write" || part.kind === "patch") && !nextIsIdlessToolResult && !resultIds.has(id) && !isRawProviderPart(part)) {
+        synthetic.push({
+          role: "tool",
+          tool_call_id: id,
+          name: toolName,
+          content: { ok: true, source: "message_part" }
+        });
+        pendingIdlessToolCallId = void 0;
+      }
+      continue;
+    }
+    if (part.kind === "tool_result") {
+      const id = partToolCallId(part) ?? pendingIdlessToolCallId;
+      const toolName = partToolName(part);
+      synthetic.push({
+        role: "tool",
+        ...id ? { tool_call_id: id } : {},
+        ...toolName ? { name: toolName } : {},
+        content: toolResultContentFromPart(part),
+        ...toolResultIsError(part) ? { isError: true } : {}
+      });
+      pendingIdlessToolCallId = void 0;
+    }
+  }
+  return synthetic;
+}
+function deriveObjectiveStateSnapshotsFromAgentMessages(options) {
+  const toolCallsById = getToolCallContexts(options.messages);
+  const snapshots = [];
+  for (const message of options.messages) {
+    if (message.role !== "tool") continue;
+    const toolCallId = toolCallIdForMessage(message);
+    const context = toolCallId ? toolCallsById.get(toolCallId) : void 0;
+    const toolName = toolNameForMessage(message, context);
+    if (!toolName) continue;
+    const parsedPayload = parseToolResultPayload(message.content);
+    const outcome = inferOutcome(message, parsedPayload);
+    const args = context?.args;
+    const command = pickString(args, ["cmd", "command", "script"]);
+    let kind = "tool";
+    let changeKind = outcome === "failure" ? "failed" : "observed";
+    let scope = toolName;
+    let before;
+    let after;
+    if (isProcessTool(toolName, args)) {
+      kind = "process";
+      changeKind = outcome === "failure" ? "failed" : "executed";
+      scope = command ?? toolName;
+      after = { exists: outcome !== "failure", valueHash: resultHash(parsedPayload) };
+    } else if (isFileTool(toolName, args)) {
+      kind = "file";
+      changeKind = inferFileChangeKind(toolName, outcome);
+      const fileScope = fileScopeFromArgs(args);
+      scope = fileScope.scope ?? toolName;
+      const refs = buildFileValueRefs(args, changeKind);
+      before = refs.before;
+      after = refs.after;
+    } else {
+      after = buildGenericToolAfterRef(outcome, parsedPayload);
+    }
+    snapshots.push({
+      schemaVersion: 1,
+      snapshotId: snapshotIdFor(
+        options.sessionKey,
+        options.recordedAt,
+        snapshots.length,
+        toolName,
+        scope,
+        toolCallId
+      ),
+      recordedAt: options.recordedAt,
+      sessionKey: options.sessionKey,
+      source: "tool_result",
+      kind,
+      changeKind,
+      scope,
+      summary: summarizeSnapshot(kind, changeKind, toolName, scope),
+      toolName,
+      command,
+      outcome,
+      before,
+      after,
+      tags: ["agent-end", `tool:${toolName}`],
+      metadata: toolCallId ? { toolCallId } : void 0
+    });
+  }
+  return snapshots;
+}
+function deriveObjectiveStateSnapshotsFromObservedMessages(options) {
+  const syntheticMessages = observedPartsToAgentMessages({
+    sessionKey: options.sessionKey,
+    messages: options.messages
+  });
+  if (syntheticMessages.length === 0) return [];
+  return deriveObjectiveStateSnapshotsFromAgentMessages({
+    sessionKey: options.sessionKey,
+    recordedAt: options.recordedAt,
+    messages: syntheticMessages
+  });
+}
+async function recordObjectiveStateSnapshotsFromAgentMessages(options) {
+  if (!options.objectiveStateMemoryEnabled || !options.objectiveStateSnapshotWritesEnabled) {
+    return { snapshots: [], filePaths: [] };
+  }
+  const snapshots = deriveObjectiveStateSnapshotsFromAgentMessages({
+    sessionKey: options.sessionKey,
+    recordedAt: options.recordedAt,
+    messages: options.messages
+  });
+  const filePaths = [];
+  for (const snapshot of snapshots) {
+    filePaths.push(
+      await recordObjectiveStateSnapshot({
+        memoryDir: options.memoryDir,
+        objectiveStateStoreDir: options.objectiveStateStoreDir,
+        snapshot
+      })
+    );
+  }
+  return { snapshots, filePaths };
+}
+async function recordObjectiveStateSnapshotsFromObservedMessages(options) {
+  if (!options.objectiveStateMemoryEnabled || !options.objectiveStateSnapshotWritesEnabled) {
+    return { snapshots: [], filePaths: [] };
+  }
+  const snapshots = deriveObjectiveStateSnapshotsFromObservedMessages({
+    sessionKey: options.sessionKey,
+    recordedAt: options.recordedAt,
+    messages: options.messages
+  });
+  const filePaths = [];
+  for (const snapshot of snapshots) {
+    filePaths.push(
+      await recordObjectiveStateSnapshot({
+        memoryDir: options.memoryDir,
+        objectiveStateStoreDir: options.objectiveStateStoreDir,
+        snapshot
+      })
+    );
+  }
+  return { snapshots, filePaths };
+}
+
 // ../remnic-core/src/access-service.ts
 var EngramAccessInputError = class extends Error {
 };
@@ -55431,6 +56179,24 @@ var EngramAccessService = class {
     }
     return resolved;
   }
+  async objectiveStateStoreLocationForNamespace(namespace) {
+    if (!this.orchestrator.config.namespacesEnabled) {
+      return {
+        memoryDir: this.orchestrator.config.memoryDir,
+        objectiveStateStoreDir: this.orchestrator.config.objectiveStateStoreDir
+      };
+    }
+    const storage = await this.orchestrator.getStorage(namespace);
+    return {
+      memoryDir: storage.dir,
+      objectiveStateStoreDir: objectiveStateStoreOverrideForNamespace({
+        memoryDir: this.orchestrator.config.memoryDir,
+        configuredStoreDir: this.orchestrator.config.objectiveStateStoreDir,
+        namespacesEnabled: this.orchestrator.config.namespacesEnabled,
+        namespace
+      })
+    };
+  }
   resolveReadableNamespace(namespace, principal) {
     const resolved = this.resolveNamespace(namespace);
     const namespacesEnabled = this.orchestrator.config.namespacesEnabled;
@@ -57160,16 +57926,54 @@ var EngramAccessService = class {
         throw new EngramAccessInputError(`invalid message role: ${msg.role} (expected 'user' or 'assistant')`);
       }
     }
+    const hasExplicitNamespace = typeof request.namespace === "string" && request.namespace.trim().length > 0;
+    const principal = this.resolveWritePrincipal(
+      request.sessionKey,
+      request.authenticatedPrincipal
+    );
     const namespace = this.resolveWritableNamespace(
       request.namespace,
       request.sessionKey,
       request.authenticatedPrincipal
     );
+    const shouldWriteObjectiveState = this.orchestrator.config.objectiveStateMemoryEnabled === true && this.orchestrator.config.objectiveStateSnapshotWritesEnabled === true;
+    const objectiveStateBaseNamespace = hasExplicitNamespace ? namespace : defaultNamespaceForPrincipal(principal, this.orchestrator.config);
+    if (shouldWriteObjectiveState && !hasExplicitNamespace && !canWriteNamespace(
+      principal,
+      objectiveStateBaseNamespace,
+      this.orchestrator.config
+    )) {
+      throw new EngramAccessInputError(
+        `namespace is not writable: ${objectiveStateBaseNamespace}`
+      );
+    }
     await this.maybeAttachCodingContext(request.sessionKey, {
       cwd: request.cwd,
       projectTag: request.projectTag
     });
+    const objectiveStateNamespace = hasExplicitNamespace ? namespace : this.orchestrator.applyCodingNamespaceOverlay(
+      request.sessionKey,
+      objectiveStateBaseNamespace
+    );
     const lcmSessionKey = namespace !== this.orchestrator.config.defaultNamespace ? `${namespace}:${request.sessionKey}` : request.sessionKey;
+    if (shouldWriteObjectiveState) {
+      try {
+        const objectiveStateLocation = await this.objectiveStateStoreLocationForNamespace(
+          objectiveStateNamespace
+        );
+        await recordObjectiveStateSnapshotsFromObservedMessages({
+          memoryDir: objectiveStateLocation.memoryDir,
+          objectiveStateStoreDir: objectiveStateLocation.objectiveStateStoreDir,
+          objectiveStateMemoryEnabled: this.orchestrator.config.objectiveStateMemoryEnabled,
+          objectiveStateSnapshotWritesEnabled: this.orchestrator.config.objectiveStateSnapshotWritesEnabled,
+          sessionKey: request.sessionKey,
+          recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          messages: request.messages
+        });
+      } catch (err) {
+        log.error(`access-observe objective-state snapshot write failed: ${err}`);
+      }
+    }
     let lcmArchived = false;
     if (this.orchestrator.lcmEngine && this.orchestrator.lcmEngine.enabled) {
       try {
@@ -64305,7 +65109,7 @@ async function runSemanticRulePromoteCliCommand(options) {
   });
 }
 async function runCompoundingPromoteCliCommand(options) {
-  const { CompoundingEngine: CompoundingEngine2 } = await import("./engine-XPEZBXIQ.js");
+  const { CompoundingEngine: CompoundingEngine2 } = await import("./engine-57HLTQBN.js");
   const config = parseConfig({
     memoryDir: options.memoryDir,
     qmdEnabled: false,
@@ -67153,7 +67957,7 @@ function registerCli(api, orchestrator, registerOptions = {}) {
             return;
           }
           const cfg = orchestrator.config.connectors;
-          const { readConnectorState: readConnectorState2, writeConnectorState: writeConnectorState2 } = await import("./state-store-LP5BO6SF.js");
+          const { readConnectorState: readConnectorState2, writeConnectorState: writeConnectorState2 } = await import("./state-store-N6TFBFSP.js");
           const sharedIngestFn = async (docs) => {
             const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
             const turns = docs.map((doc) => ({
@@ -69690,7 +70494,7 @@ Legacy identity-anchor files are untouched. Verify the migration result`);
         }
         if (typeof options.trace === "string" && options.trace.length > 0) {
           const { replayTrace, parseSpeedFlag } = await import("./trace-NJESSGH7.js");
-          const { expandTildePath: expandTildePath2 } = await import("./path-5LCUBAAZ.js");
+          const { expandTildePath: expandTildePath2 } = await import("./path-JIEGNWFL.js");
           const tracePath = expandTildePath2(options.trace);
           let speed;
           try {
@@ -69721,7 +70525,7 @@ Legacy identity-anchor files are untouched. Verify the migration result`);
         let recorder = null;
         if (typeof options.recordTrace === "string" && options.recordTrace.length > 0) {
           const { openTraceRecorder } = await import("./trace-NJESSGH7.js");
-          const { expandTildePath: expandTildePath2 } = await import("./path-5LCUBAAZ.js");
+          const { expandTildePath: expandTildePath2 } = await import("./path-JIEGNWFL.js");
           recorder = await openTraceRecorder(
             expandTildePath2(options.recordTrace)
           );
@@ -69773,309 +70577,6 @@ function parseDuration(duration) {
   return total || 12;
 }
 
-// ../remnic-core/src/objective-state-writers.ts
-import crypto2 from "crypto";
-function hashSha256(value) {
-  return crypto2.createHash("sha256").update(value).digest("hex");
-}
-function isRecord4(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function optionalString2(value) {
-  if (typeof value !== "string") return void 0;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : void 0;
-}
-function toolNameTokens(toolName) {
-  if (!toolName) return [];
-  return toolName.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().split(/[^a-z0-9]+/).filter((token) => token.length > 0);
-}
-function normalizedToolName(toolName) {
-  return toolNameTokens(toolName).join("_");
-}
-function parseToolArguments(value) {
-  if (isRecord4(value)) return value;
-  if (typeof value !== "string") return void 0;
-  try {
-    const parsed = JSON.parse(value);
-    return isRecord4(parsed) ? parsed : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function extractTextContent(value) {
-  if (typeof value === "string") return value.trim();
-  if (Array.isArray(value)) {
-    return value.map((block) => {
-      if (typeof block === "string") return block.trim();
-      if (isRecord4(block) && block.type === "text" && typeof block.text === "string") {
-        return block.text.trim();
-      }
-      return "";
-    }).filter((item) => item.length > 0).join("\n");
-  }
-  if (isRecord4(value)) {
-    return JSON.stringify(value);
-  }
-  return "";
-}
-function parseToolResultPayload(content) {
-  const text = extractTextContent(content);
-  if (text.length === 0) return void 0;
-  try {
-    return JSON.parse(text);
-  } catch {
-    return text;
-  }
-}
-function resultHash(value) {
-  if (value === void 0) return void 0;
-  const canonical = typeof value === "string" ? value : JSON.stringify(value);
-  if (!canonical || canonical.length === 0) return void 0;
-  return `sha256:${hashSha256(canonical)}`;
-}
-function getToolCallContexts(messages) {
-  const contexts = /* @__PURE__ */ new Map();
-  for (const message of messages) {
-    if (message.role !== "assistant") continue;
-    const toolCalls = message.tool_calls ?? message.toolCalls;
-    if (!Array.isArray(toolCalls)) continue;
-    for (const call of toolCalls) {
-      if (!isRecord4(call)) continue;
-      const toolCallId = optionalString2(call.id) ?? optionalString2(call.toolCallId);
-      if (!toolCallId) continue;
-      const fn = isRecord4(call.function) ? call.function : void 0;
-      const toolName = optionalString2(fn?.name) ?? optionalString2(call.name);
-      const args = parseToolArguments(fn?.arguments) ?? parseToolArguments(call.arguments) ?? parseToolArguments(call.args) ?? parseToolArguments(call.input);
-      contexts.set(toolCallId, { toolCallId, toolName, args });
-    }
-  }
-  return contexts;
-}
-function toolCallIdForMessage(message) {
-  return optionalString2(message.tool_call_id) ?? optionalString2(message.toolCallId) ?? optionalString2(message.tool_use_id) ?? optionalString2(message.toolUseId);
-}
-function toolNameForMessage(message, context) {
-  return optionalString2(message.name) ?? optionalString2(message.toolName) ?? optionalString2(message.tool) ?? context?.toolName;
-}
-function pickString(args, keys) {
-  if (!args) return void 0;
-  for (const key of keys) {
-    const value = optionalString2(args[key]);
-    if (value) return value;
-  }
-  return void 0;
-}
-function pickFirstStringArrayValue(args, key) {
-  const value = args?.[key];
-  if (!Array.isArray(value)) return void 0;
-  for (const item of value) {
-    const candidate = optionalString2(item);
-    if (candidate) return candidate;
-  }
-  return void 0;
-}
-function fileScopeFromArgs(args) {
-  const destinationPath = pickString(args, ["destination", "dest", "targetPath", "target", "to"]) ?? pickString(args, ["path", "filePath", "workspacePath", "projectPath"]) ?? pickFirstStringArrayValue(args, "paths");
-  const sourcePath = pickString(args, ["source", "src", "from", "oldPath"]);
-  const scope = destinationPath ?? sourcePath;
-  return { scope, sourcePath, destinationPath };
-}
-function fileContentHash(args) {
-  const content = pickString(args, ["content", "patch", "diff", "text", "value"]) ?? args?.updates;
-  return resultHash(content);
-}
-function inferOutcome(message, parsedPayload) {
-  if (message.isError === true) return "failure";
-  if (isRecord4(parsedPayload)) {
-    if (parsedPayload.partial === true || parsedPayload.status === "partial") return "partial";
-    if (parsedPayload.success === false || parsedPayload.ok === false) return "failure";
-    if (parsedPayload.success === true || parsedPayload.ok === true) return "success";
-    if (typeof parsedPayload.exitCode === "number") {
-      return parsedPayload.exitCode === 0 ? "success" : "failure";
-    }
-    if (optionalString2(parsedPayload.error)) return "failure";
-    if (parsedPayload.status === "error" || parsedPayload.status === "failed") return "failure";
-    if (parsedPayload.status === "ok" || parsedPayload.status === "success") return "success";
-  }
-  if (typeof parsedPayload === "string") {
-    const lowered = parsedPayload.toLowerCase();
-    const loweredForFailure = lowered.replace(/\b(?:previously\s+)?failed tests?\s+now\s+pass(?:ed|es)?\b/g, "");
-    const hasZeroCountMarker = /\b(?:0|no)\s+(?:errors?|failures?|exceptions?|timeouts?)\b/.test(lowered);
-    const loweredForFailureCounts = loweredForFailure.replace(/\b(?:0|no)\s+errors?\b/g, "").replace(/\b(?:0|no)\s+failures?\b/g, "").replace(/\b(?:0|no)\s+exceptions?\b/g, "").replace(/\b(?:0|no)\s+timeouts?\b/g, "");
-    const hasNonZeroErrorCounts = /\b[1-9]\d*\s+errors?\b/.test(loweredForFailureCounts);
-    const hasNegatedSuccessMarkers = /\b(?:not|did not|didn't|doesn't|isn't|aren't|wasn't|weren't|won't|can't|couldn't|shouldn't|wouldn't)\s+(?:ok|pass|passed|passes|succeeded|success)\b/.test(loweredForFailure);
-    const hasSuccessMarkers = /\b(success|succeeded|pass|passes|passed|ok)\b/.test(lowered) || hasZeroCountMarker;
-    const hasFailureMarkers = hasNegatedSuccessMarkers || /\b(exceptions?|failed|failures?|fatal|timeouts?|timed out)\b/.test(loweredForFailureCounts) || hasNonZeroErrorCounts || /\berrors?\b/.test(loweredForFailureCounts) || /\b[a-z]+error\b/.test(loweredForFailureCounts) || /\b[a-z]+exception\b/.test(loweredForFailureCounts);
-    if (hasFailureMarkers) return "failure";
-    if (hasSuccessMarkers) return "success";
-  }
-  return "unknown";
-}
-function isProcessTool(toolName, args) {
-  const tokens = toolNameTokens(toolName);
-  const normalizedName = normalizedToolName(toolName);
-  if (pickString(args, ["cmd", "command", "script"])) return true;
-  return ["exec", "shell", "bash", "terminal", "run_command", "exec_command"].some(
-    (token) => token.includes("_") ? normalizedName === token : tokens.includes(token)
-  );
-}
-function isFileTool(toolName, args) {
-  const tokens = toolNameTokens(toolName);
-  const fileScope = fileScopeFromArgs(args);
-  if (fileScope.scope) return true;
-  return ["file", "path", "patch", "directory", "mkdir", "rename", "move"].some(
-    (token) => tokens.includes(token)
-  );
-}
-function inferFileChangeKind(toolName, outcome) {
-  if (outcome === "failure") return "failed";
-  const tokens = toolNameTokens(toolName);
-  if (["delete", "remove", "unlink"].some((token) => tokens.includes(token))) return "deleted";
-  if (["create", "mkdir", "new"].some((token) => tokens.includes(token))) return "created";
-  if (["write", "edit", "patch", "update", "append", "move", "rename"].some((token) => tokens.includes(token))) {
-    return "updated";
-  }
-  return "observed";
-}
-function buildFileValueRefs(args, changeKind) {
-  const { sourcePath, destinationPath, scope } = fileScopeFromArgs(args);
-  const contentHash = fileContentHash(args);
-  if (changeKind === "failed") {
-    if (sourcePath && destinationPath && sourcePath !== destinationPath) {
-      return {
-        before: { ref: sourcePath },
-        after: { ref: destinationPath }
-      };
-    }
-    return {
-      before: sourcePath ? { ref: sourcePath } : void 0,
-      after: scope ? { ref: scope } : void 0
-    };
-  }
-  if (changeKind === "deleted") {
-    return {
-      before: scope ? { exists: true, ref: scope } : void 0,
-      after: { exists: false }
-    };
-  }
-  if (changeKind === "created") {
-    return {
-      after: {
-        exists: true,
-        ref: scope,
-        valueHash: contentHash
-      }
-    };
-  }
-  if (sourcePath && destinationPath && sourcePath !== destinationPath) {
-    return {
-      before: { exists: true, ref: sourcePath },
-      after: {
-        exists: true,
-        ref: destinationPath
-      }
-    };
-  }
-  return {
-    after: {
-      exists: true,
-      ref: scope,
-      valueHash: contentHash
-    }
-  };
-}
-function summarizeSnapshot(kind, changeKind, toolName, scope) {
-  const action = changeKind === "executed" ? "Executed" : changeKind === "failed" ? "Failed" : changeKind === "created" ? "Created" : changeKind === "deleted" ? "Deleted" : changeKind === "updated" ? "Updated" : "Observed";
-  if (kind === "process") return `${action} process via ${toolName}: ${scope}`;
-  if (kind === "file") return `${action} file via ${toolName}: ${scope}`;
-  return `${action} tool result from ${toolName}: ${scope}`;
-}
-function buildGenericToolAfterRef(outcome, parsedPayload) {
-  const valueHash = resultHash(parsedPayload);
-  return valueHash ? { valueHash } : { exists: outcome !== "failure" };
-}
-function snapshotIdFor(sessionKey, recordedAt, index, toolName, scope) {
-  const digest = crypto2.createHash("sha256").update(`${sessionKey}|${recordedAt}|${index}|${toolName}|${scope}`).digest("hex").slice(0, 12);
-  return `obj-${digest}`;
-}
-function deriveObjectiveStateSnapshotsFromAgentMessages(options) {
-  const toolCallsById = getToolCallContexts(options.messages);
-  const snapshots = [];
-  for (const message of options.messages) {
-    if (message.role !== "tool") continue;
-    const toolCallId = toolCallIdForMessage(message);
-    const context = toolCallId ? toolCallsById.get(toolCallId) : void 0;
-    const toolName = toolNameForMessage(message, context);
-    if (!toolName) continue;
-    const parsedPayload = parseToolResultPayload(message.content);
-    const outcome = inferOutcome(message, parsedPayload);
-    const args = context?.args;
-    const command = pickString(args, ["cmd", "command", "script"]);
-    let kind = "tool";
-    let changeKind = outcome === "failure" ? "failed" : "observed";
-    let scope = toolName;
-    let before;
-    let after;
-    if (isProcessTool(toolName, args)) {
-      kind = "process";
-      changeKind = outcome === "failure" ? "failed" : "executed";
-      scope = command ?? toolName;
-      after = { exists: outcome !== "failure", valueHash: resultHash(parsedPayload) };
-    } else if (isFileTool(toolName, args)) {
-      kind = "file";
-      changeKind = inferFileChangeKind(toolName, outcome);
-      const fileScope = fileScopeFromArgs(args);
-      scope = fileScope.scope ?? toolName;
-      const refs = buildFileValueRefs(args, changeKind);
-      before = refs.before;
-      after = refs.after;
-    } else {
-      after = buildGenericToolAfterRef(outcome, parsedPayload);
-    }
-    snapshots.push({
-      schemaVersion: 1,
-      snapshotId: snapshotIdFor(options.sessionKey, options.recordedAt, snapshots.length, toolName, scope),
-      recordedAt: options.recordedAt,
-      sessionKey: options.sessionKey,
-      source: "tool_result",
-      kind,
-      changeKind,
-      scope,
-      summary: summarizeSnapshot(kind, changeKind, toolName, scope),
-      toolName,
-      command,
-      outcome,
-      before,
-      after,
-      tags: ["agent-end", `tool:${toolName}`],
-      metadata: toolCallId ? { toolCallId } : void 0
-    });
-  }
-  return snapshots;
-}
-async function recordObjectiveStateSnapshotsFromAgentMessages(options) {
-  if (!options.objectiveStateMemoryEnabled || !options.objectiveStateSnapshotWritesEnabled) {
-    return { snapshots: [], filePaths: [] };
-  }
-  const snapshots = deriveObjectiveStateSnapshotsFromAgentMessages({
-    sessionKey: options.sessionKey,
-    recordedAt: options.recordedAt,
-    messages: options.messages
-  });
-  const filePaths = [];
-  for (const snapshot of snapshots) {
-    filePaths.push(
-      await recordObjectiveStateSnapshot({
-        memoryDir: options.memoryDir,
-        objectiveStateStoreDir: options.objectiveStateStoreDir,
-        snapshot
-      })
-    );
-  }
-  return { snapshots, filePaths };
-}
-
 // ../../src/qmd-availability-probe.ts
 async function probeQmdAvailability(host) {
   const qmd = host?.qmd;
@@ -72718,6 +73219,9 @@ var NODE_FS_MODULE_ID = ["node", "fs"].join(":");
 var NODE_FS_PROMISES_MODULE_ID = ["node", "fs/promises"].join(":");
 var READ_FILE_SYNC_FIELD = ["read", "File", "Sync"].join("");
 var EXISTS_SYNC_FIELD = ["exists", "Sync"].join("");
+function isMemoryArtifactPath(p) {
+  return /(?:^|[\\/])artifacts(?:[\\/]|$)/i.test(p);
+}
 function readTextFileNow(filePath) {
   const nodeRequire = createRequire3(import.meta.url);
   const fs19 = nodeRequire(NODE_FS_MODULE_ID);
@@ -74140,7 +74644,7 @@ Keep the reflection grounded in the evidence below.
         api.registerMemoryPromptSection(memoryBuildFn);
         memoryPromptBuilder = memoryBuildFn;
       }
-      if (sdkCaps.hasRegisterMemoryCapability && typeof api.registerMemoryCapability === "function") {
+      if (sdkCaps.hasRegisterMemoryCapability && typeof api.registerMemoryCapability === "function" || typeof api.registerMemoryRuntime === "function" || typeof api.registerMemoryFlushPlan === "function") {
         const capabilityPromptBuilder = memoryPromptBuilder ? (params) => {
           const key = params?.sessionKey ?? "default";
           return consumePromptMemoryLines2(key, { destructive: false });
@@ -74249,11 +74753,10 @@ Keep the reflection grounded in the evidence below.
                     namespaces: namespace ? [namespace] : void 0,
                     mode: resolvedMode
                   });
-                  const isArtifactPath2 = (p) => /(?:^|[\\/])artifacts(?:[\\/]|$)/i.test(p);
                   return rawResults.filter((result) => {
                     const candidate = result;
                     const p = typeof candidate.path === "string" ? candidate.path : typeof candidate.id === "string" ? candidate.id : "";
-                    return !isArtifactPath2(p);
+                    return !isMemoryArtifactPath(p);
                   }).map((result, index) => {
                     const candidate = result;
                     const rawPath = typeof candidate.path === "string" ? candidate.path : typeof candidate.id === "string" ? candidate.id : `memory-${index + 1}`;
@@ -74365,6 +74868,18 @@ Keep the reflection grounded in the evidence below.
           async closeAllMemorySearchManagers() {
           }
         };
+        const remnicMemoryFlushPlanResolver = () => {
+          const maxTurnChars = typeof cfg.extractionMaxTurnChars === "number" && Number.isFinite(cfg.extractionMaxTurnChars) ? Math.max(1e3, Math.floor(cfg.extractionMaxTurnChars)) : 8e3;
+          return {
+            softThresholdTokens: 24e3,
+            forceFlushTranscriptBytes: Math.max(16384, maxTurnChars * 4),
+            reserveTokensFloor: 2e3,
+            model: typeof cfg.summaryModel === "string" && cfg.summaryModel.length > 0 ? cfg.summaryModel : cfg.model,
+            prompt: "Flush the recent OpenClaw transcript into Remnic memory. Preserve durable user preferences, project facts, decisions, corrections, and commitments. Ignore runtime metadata, credentials, and transient command noise.",
+            systemPrompt: "You are Remnic's memory flush planner. Produce concise durable memory candidates only when the transcript contains information worth remembering.",
+            relativePath: ["state", "plugins", serviceId, "flush-plan.md"].join("/")
+          };
+        };
         const memoryCapability = {
           // Include the promptBuilder so runtimes that treat unified capability
           // registration as authoritative (SDK >=2026.4.5) continue to inject
@@ -74372,6 +74887,7 @@ Keep the reflection grounded in the evidence below.
           // Respect promptInjectionAllowed policy — omit promptBuilder if injection
           // is disabled, so the capability only provides publicArtifacts.
           ...promptInjectionAllowed ? { promptBuilder: capabilityPromptBuilder } : {},
+          flushPlanResolver: remnicMemoryFlushPlanResolver,
           runtime: remnicMemoryRuntime,
           publicArtifacts: {
             listArtifacts: async (_params) => {
@@ -74388,9 +74904,18 @@ Keep the reflection grounded in the evidence below.
             }
           }
         };
-        api.registerMemoryCapability(memoryCapability);
+        if (typeof api.registerMemoryCapability === "function") {
+          api.registerMemoryCapability(memoryCapability);
+        }
+        if (typeof api.registerMemoryRuntime === "function") {
+          api.registerMemoryRuntime(remnicMemoryRuntime);
+        }
+        if (typeof api.registerMemoryFlushPlan === "function") {
+          api.registerMemoryFlushPlan(remnicMemoryFlushPlanResolver);
+        }
         const builderDesc = !promptInjectionAllowed ? " (promptBuilder omitted \u2014 injection disabled by policy)" : memoryPromptBuilder ? " and promptBuilder (from registerMemoryPromptSection)" : " and promptBuilder (capability-only fallback)";
-        log.info(`registered memory capability with runtime and publicArtifacts provider${builderDesc}`);
+        const capabilityDesc = typeof api.registerMemoryCapability === "function" ? `memory capability with publicArtifacts provider${builderDesc}` : "split memory runtime/flush-plan surfaces";
+        log.info(`registered ${capabilityDesc}`);
       }
       api.on(
         "agent_end",
@@ -74444,9 +74969,16 @@ Keep the reflection grounded in the evidence below.
               }
             }
             try {
+              const objectiveStateNamespace = orchestrator.config.namespacesEnabled && typeof orchestrator.resolveSelfNamespace === "function" ? orchestrator.resolveSelfNamespace(sessionKey) : orchestrator.config.defaultNamespace;
+              const objectiveStateStorage = orchestrator.config.namespacesEnabled && typeof orchestrator.getStorageForNamespace === "function" ? await orchestrator.getStorageForNamespace(objectiveStateNamespace) : null;
               await recordObjectiveStateSnapshotsFromAgentMessages({
-                memoryDir: orchestrator.config.memoryDir,
-                objectiveStateStoreDir: orchestrator.config.objectiveStateStoreDir,
+                memoryDir: objectiveStateStorage?.dir ?? orchestrator.config.memoryDir,
+                objectiveStateStoreDir: objectiveStateStoreOverrideForNamespace({
+                  memoryDir: orchestrator.config.memoryDir,
+                  configuredStoreDir: orchestrator.config.objectiveStateStoreDir,
+                  namespacesEnabled: orchestrator.config.namespacesEnabled,
+                  namespace: objectiveStateNamespace
+                }),
                 objectiveStateMemoryEnabled: orchestrator.config.objectiveStateMemoryEnabled,
                 objectiveStateSnapshotWritesEnabled: orchestrator.config.objectiveStateSnapshotWritesEnabled,
                 sessionKey,
@@ -74992,6 +75524,151 @@ Keep the reflection grounded in the evidence below.
         log.error("failed to auto-register hourly summary cron job:", err);
       }
     }
+    if (typeof api.registerMemoryCorpusSupplement === "function") {
+      const normalizeCorpusLookup = (lookup) => typeof lookup === "string" && lookup.trim().length > 0 ? lookup.trim() : null;
+      const resolveCorpusStorage = async (agentSessionKey) => {
+        const namespace = typeof orchestrator.resolveSelfNamespace === "function" ? orchestrator.resolveSelfNamespace(agentSessionKey) : void 0;
+        return typeof orchestrator.getStorageForNamespace === "function" ? await orchestrator.getStorageForNamespace(namespace) : orchestrator.storage;
+      };
+      const normalizeCorpusPath = (value) => value.trim().replace(/\\/g, "/").replace(/^\.\//, "");
+      const pathIsInside = (root, candidate) => {
+        const relative = path99.relative(root, candidate);
+        return relative === "" || !relative.startsWith("..") && !path99.isAbsolute(relative);
+      };
+      const corpusPathCandidates = (rawPath, storageDir) => {
+        const candidates = /* @__PURE__ */ new Set();
+        const trimmed = rawPath.trim();
+        if (!trimmed) return [];
+        candidates.add(normalizeCorpusPath(trimmed));
+        if (path99.isAbsolute(trimmed)) {
+          const absolutePath = path99.resolve(trimmed);
+          const absoluteStorageDir = path99.resolve(storageDir);
+          if (pathIsInside(absoluteStorageDir, absolutePath)) {
+            candidates.add(normalizeCorpusPath(path99.relative(absoluteStorageDir, absolutePath)));
+          }
+        }
+        candidates.add(path99.basename(trimmed));
+        return [...candidates].filter((candidate) => candidate.length > 0);
+      };
+      const displayCorpusPath = (rawPath, storageDir) => {
+        const trimmed = rawPath.trim();
+        if (!trimmed) return "";
+        if (path99.isAbsolute(trimmed)) {
+          const absolutePath = path99.resolve(trimmed);
+          const absoluteStorageDir = path99.resolve(storageDir);
+          if (pathIsInside(absoluteStorageDir, absolutePath)) {
+            return normalizeCorpusPath(path99.relative(absoluteStorageDir, absolutePath));
+          }
+        }
+        return normalizeCorpusPath(trimmed);
+      };
+      const readMemoryByLookup = async (lookup, agentSessionKey) => {
+        const storage = await resolveCorpusStorage(agentSessionKey);
+        const storageDir = typeof storage.dir === "string" && storage.dir.length > 0 ? storage.dir : orchestrator.config.memoryDir;
+        const memories = await storage.readAllMemories();
+        const normalizedLookup = normalizeCorpusPath(lookup);
+        const matched = memories.find((memory) => memory.frontmatter.id === lookup) ?? memories.find(
+          (memory) => corpusPathCandidates(memory.path, storageDir).includes(normalizedLookup)
+        ) ?? null;
+        if (!matched) return null;
+        const displayPath = displayCorpusPath(matched.path, storageDir);
+        return { memory: matched, displayPath };
+      };
+      const corpusBackendError = (operation, err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        const error = new Error(`Remnic corpus ${operation} failed: ${message}`);
+        error.cause = err;
+        return error;
+      };
+      const remnicCorpusSupplement = {
+        id: `${serviceId}:remnic-memory-corpus`,
+        label: "Remnic Memory Corpus",
+        async search(params) {
+          const query = normalizeCorpusLookup(
+            typeof params === "string" ? params : params?.query
+          );
+          if (!query) return [];
+          const maxResults = typeof params === "object" && typeof params.maxResults === "number" && Number.isFinite(params.maxResults) ? Math.max(1, Math.floor(params.maxResults)) : 8;
+          const agentSessionKey = typeof params === "object" ? params.agentSessionKey : void 0;
+          const namespace = typeof orchestrator.resolveSelfNamespace === "function" ? orchestrator.resolveSelfNamespace(agentSessionKey) : void 0;
+          try {
+            const rawResults = await orchestrator.searchAcrossNamespaces({
+              query,
+              maxResults,
+              namespaces: namespace ? [namespace] : void 0,
+              mode: "search"
+            });
+            return rawResults.filter((result) => {
+              const candidate = result;
+              const p = typeof candidate.path === "string" ? candidate.path : typeof candidate.id === "string" ? candidate.id : "";
+              return !isMemoryArtifactPath(p);
+            }).map((result, index) => {
+              const candidate = result;
+              const lookupPath = typeof candidate.path === "string" ? candidate.path : typeof candidate.id === "string" ? candidate.id : `remnic-memory-${index + 1}`;
+              const startLine = typeof candidate.startLine === "number" && Number.isFinite(candidate.startLine) ? Math.max(1, Math.floor(candidate.startLine)) : 1;
+              const endLine = typeof candidate.endLine === "number" && Number.isFinite(candidate.endLine) ? Math.max(startLine, Math.floor(candidate.endLine)) : startLine;
+              return {
+                corpus: "remnic",
+                path: lookupPath,
+                title: typeof candidate.id === "string" && candidate.id.length > 0 ? candidate.id : lookupPath,
+                kind: "memory",
+                score: typeof candidate.score === "number" && Number.isFinite(candidate.score) ? candidate.score : 0,
+                snippet: typeof candidate.snippet === "string" ? candidate.snippet : typeof candidate.text === "string" ? candidate.text : "",
+                id: typeof candidate.id === "string" ? candidate.id : lookupPath,
+                startLine,
+                endLine,
+                citation: lookupPath,
+                source: "remnic",
+                provenanceLabel: "Remnic",
+                sourceType: "memory",
+                sourcePath: lookupPath,
+                updatedAt: typeof candidate.metadata?.updatedAt === "string" ? candidate.metadata.updatedAt : void 0
+              };
+            });
+          } catch (err) {
+            log.warn(`memory corpus search failed: ${err}`);
+            throw corpusBackendError("search", err);
+          }
+        },
+        async get(params) {
+          const lookup = normalizeCorpusLookup(
+            typeof params === "string" ? params : params?.lookup
+          );
+          if (!lookup || isMemoryArtifactPath(lookup)) return null;
+          const agentSessionKey = typeof params === "object" ? params.agentSessionKey : void 0;
+          try {
+            const resolved = await readMemoryByLookup(lookup, agentSessionKey);
+            if (!resolved) return null;
+            const { memory, displayPath } = resolved;
+            if (isMemoryArtifactPath(displayPath) || isMemoryArtifactPath(memory.path)) {
+              return null;
+            }
+            const allLines = memory.content.split(/\r?\n/);
+            const fromLine = typeof params === "object" && typeof params.fromLine === "number" && Number.isFinite(params.fromLine) ? Math.max(1, Math.floor(params.fromLine)) : 1;
+            const lineCount = typeof params === "object" && typeof params.lineCount === "number" && Number.isFinite(params.lineCount) ? Math.max(1, Math.floor(params.lineCount)) : allLines.length;
+            const selected = allLines.slice(fromLine - 1, fromLine - 1 + lineCount);
+            return {
+              corpus: "remnic",
+              path: displayPath,
+              title: memory.frontmatter.id,
+              kind: memory.frontmatter.category,
+              content: selected.join("\n"),
+              fromLine,
+              lineCount: selected.length,
+              id: memory.frontmatter.id,
+              provenanceLabel: "Remnic",
+              sourceType: "memory",
+              sourcePath: displayPath,
+              updatedAt: memory.frontmatter.updated
+            };
+          } catch (err) {
+            log.warn(`memory corpus get failed: ${err}`);
+            throw corpusBackendError("get", err);
+          }
+        }
+      };
+      api.registerMemoryCorpusSupplement(remnicCorpusSupplement);
+    }
     if (cfg.openclawToolsEnabled !== false && typeof api.registerTool === "function") {
       api.registerTool(
         buildMemorySearchTool(orchestrator, {