@remnic/plugin-openclaw 9.69.40 → 9.69.42

package/dist/index.js

@@ -13,83 +13,27 @@ import {
   __reExport
 } from "./chunk-I2KLQ2HA.js";
 
-// ../../src/day-summary.ts
-var day_summary_exports = {};
-__reExport(day_summary_exports, day_summary_star);
-import * as day_summary_star from "@remnic/core/day-summary";
-
 // ../../src/index.ts
+import { loadDaySummaryPrompt } from "@remnic/core/day-summary";
 import OpenAI from "openai";
 import { createRequire } from "module";
 import { createHash as createHash4 } from "crypto";
-
-// ../../src/config.ts
-var config_exports = {};
-__reExport(config_exports, config_star);
-import * as config_star from "@remnic/core/config";
-
-// ../../src/logger.ts
-var logger_exports = {};
-__reExport(logger_exports, logger_star);
-import * as logger_star from "@remnic/core/logger";
-
-// ../../src/sdk-compat.ts
-import { detectSdkCapabilities } from "@remnic/core/sdk-compat";
-
-// ../../src/index.ts
+import { parseConfig } from "@remnic/core/config";
+import { initLogger, log as log8 } from "@remnic/core/logger";
+import {
+  detectSdkCapabilities
+} from "@remnic/core/sdk-compat";
 import {
   Orchestrator,
   sanitizeSessionKeyForFilename,
   defaultWorkspaceDir
 } from "@remnic/core/orchestrator";
-import { beginCodexSubscriptionShutdown, getCodexSubscriptionRunnerForOwner } from "@remnic/core";
+import { beginCodexSubscriptionShutdown, getCodexSubscriptionRunnerForOwner, terminateActiveCodexSubscriptionChildren } from "@remnic/core";
 
 // ../../src/tools.ts
 import { createHash as createHash2 } from "crypto";
-import { Type } from "@sinclair/typebox";
-
-// ../../src/temporal-index.ts
-var temporal_index_exports = {};
-__export(temporal_index_exports, {
-  clearIndexes: () => clearIndexes,
-  clearIndexesAsync: () => clearIndexesAsync,
-  deindexMemory: () => deindexMemory,
-  deindexMemoryAsync: () => deindexMemoryAsync,
-  extractTagsFromPrompt: () => extractTagsFromPrompt,
-  indexMemoriesBatch: () => indexMemoriesBatch,
-  indexMemoriesBatchAsync: () => indexMemoriesBatchAsync,
-  indexMemory: () => indexMemory,
-  indexMemoryAsync: () => indexMemoryAsync,
-  indexesExist: () => indexesExist,
-  indexesExistAsync: () => indexesExistAsync,
-  isTemporalQuery: () => isTemporalQuery,
-  queryByDateRangeAsync: () => queryByDateRangeAsync,
-  queryByTagsAsync: () => queryByTagsAsync,
-  recencyWindowBoundsFromPrompt: () => recencyWindowBoundsFromPrompt,
-  recencyWindowFromPrompt: () => recencyWindowFromPrompt,
-  resolvePromptTagPrefilterAsync: () => resolvePromptTagPrefilterAsync
-});
-__reExport(temporal_index_exports, temporal_index_star);
-import {
-  clearIndexes,
-  clearIndexesAsync,
-  deindexMemory,
-  deindexMemoryAsync,
-  extractTagsFromPrompt,
-  indexMemoriesBatch,
-  indexMemoriesBatchAsync,
-  indexMemory,
-  indexMemoryAsync,
-  indexesExist,
-  indexesExistAsync,
-  isTemporalQuery,
-  queryByDateRangeAsync,
-  queryByTagsAsync,
-  recencyWindowBoundsFromPrompt,
-  recencyWindowFromPrompt,
-  resolvePromptTagPrefilterAsync
-} from "@remnic/core/temporal-index";
-import * as temporal_index_star from "@remnic/core/temporal-index";
+import { Type as Type2 } from "@sinclair/typebox";
+import { indexMemoryAsync as indexMemoryAsync2, indexesExistAsync as indexesExistAsync2 } from "@remnic/core/temporal-index";
 
 // ../../src/explicit-capture.ts
 import {
@@ -114,6 +58,7 @@ function mergeInlineCaptureDedupeKeys(messageKeys, fallbackDedupeKeys = []) {
 }
 
 // ../../src/tools.ts
+import { log } from "@remnic/core/logger";
 import { composeSalvagedEnvelope as composeSalvagedEnvelope2 } from "@remnic/core/salvage-envelope";
 
 // ../../src/memory-promote.ts
@@ -127,6 +72,7 @@ import { stripAttributesSuffix } from "@remnic/core/storage";
 import { isSupportPassportPrivateMemory } from "@remnic/core/support-passport";
 import { displayErrorDetail } from "@remnic/core/runtime/better-sqlite";
 import { isSafeRouteNamespace } from "@remnic/core/routing/engine";
+import { indexMemoryAsync, indexesExistAsync } from "@remnic/core/temporal-index";
 function buildPromotionOrigin(srcNamespace, memoryId) {
   const memoryIdHash = createHash("sha256").update(memoryId).digest("hex");
   const fullTag = `promotedFrom:${srcNamespace}:${memoryId}`;
@@ -213,6 +159,10 @@ async function executeMemoryPromote(orchestrator, params) {
   return `Promoted ${srcNs}:${memoryId} \u2192 ${dstNs}:${newId}`;
 }
 
+// ../../src/shared-context-tools.ts
+import { Type } from "@sinclair/typebox";
+import { parseSharedWriteOutputControls } from "@remnic/core/shared-context/write-output-controls";
+
 // ../../src/tool-write-origin.ts
 var UNATTRIBUTED_TOOL_WRITE_ORIGIN = "unattributed:openclaw-host";
 function openClawToolWriteOrigin(runtimeAgentId, requestedAgentId) {
@@ -223,18 +173,204 @@ function openClawToolWriteOrigin(runtimeAgentId, requestedAgentId) {
   return { agentId: requestedAgentId, unattributedOrigin: UNATTRIBUTED_TOOL_WRITE_ORIGIN };
 }
 
+// ../../src/shared-context-tools.ts
+function toolResult(text) {
+  return { content: [{ type: "text", text }], details: void 0 };
+}
+function registerSharedContextTools(api, orchestrator, hostRuntimeAgentId) {
+  api.registerTool(
+    {
+      name: "shared_context_write_output",
+      label: "Write Shared Agent Output",
+      description: "Write an agent work product into the shared-context directory (v4.0). Other agents can read these files to coordinate without explicit message passing.",
+      parameters: Type.Object({
+        // Provenance is server-derived from the host runtime agent; a
+        // mismatching value here is rejected, never used as the origin.
+        agentId: Type.String({ description: "Agent ID producing this output; must match this host's runtime agent id when the host exposes one." }),
+        title: Type.String({ description: "Short title for the output." }),
+        content: Type.String({ description: "Markdown content to write." }),
+        authority: Type.Optional(Type.String({
+          enum: ["informational", "advisory", "binding"],
+          description: "Envelope authority class. `binding` additionally requires the operator config `sharedContextAllowBindingAuthority: true`."
+        })),
+        expiresAt: Type.Optional(Type.String({
+          description: "ISO-8601 instant strictly after the write time and at most 10 years out. Past, invalid, or over-bound values are rejected."
+        })),
+        supersedes: Type.Optional(Type.String({
+          description: "Id of the shared item this output supersedes (non-empty, single line)."
+        }))
+      }),
+      async execute(_toolCallId, params) {
+        const { agentId, title, content } = params;
+        if (!orchestrator.sharedContext) {
+          return toolResult(
+            "Shared context is disabled. Enable `sharedContextEnabled: true` to use shared-context tools."
+          );
+        }
+        try {
+          const controls = parseSharedWriteOutputControls(params);
+          const fp = await orchestrator.sharedContext.writeAgentOutput({
+            title,
+            content,
+            ...openClawToolWriteOrigin(hostRuntimeAgentId, agentId),
+            ...controls
+          });
+          return toolResult(`Wrote shared agent output: ${fp}`);
+        } catch (err) {
+          return toolResult(`shared_context_write_output error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+    },
+    { name: "shared_context_write_output" }
+  );
+  api.registerTool(
+    {
+      name: "shared_feedback_record",
+      label: "Record Shared Feedback",
+      description: "Append an approval/rejection decision into shared-context feedback inbox (v4.0/v5.0). Intended to power compounding learning.",
+      parameters: Type.Object({
+        agent: Type.String({ description: "Agent name that produced the recommendation/output." }),
+        decision: Type.String({
+          enum: ["approved", "approved_with_feedback", "rejected"],
+          description: "Decision outcome."
+        }),
+        reason: Type.String({ description: "Why the decision was made (short but specific)." }),
+        date: Type.Optional(Type.String({ description: "ISO timestamp. Defaults to now." })),
+        learning: Type.Optional(Type.String({ description: "Optional distilled learning/pattern." })),
+        outcome: Type.Optional(Type.String({ description: "Optional downstream outcome (day-one supported; may be empty initially)." })),
+        severity: Type.Optional(Type.String({
+          enum: ["low", "medium", "high"],
+          description: "Optional severity rating for the mistake/outcome."
+        })),
+        confidence: Type.Optional(Type.Number({ description: "Optional confidence score from 0 to 1." })),
+        workflow: Type.Optional(Type.String({ description: "Optional workflow or playbook name associated with the feedback." })),
+        tags: Type.Optional(Type.Array(Type.String(), { description: "Optional tags for rubric grouping and recall matching." })),
+        evidenceWindowStart: Type.Optional(Type.String({ description: "Optional start timestamp for the evidence window." })),
+        evidenceWindowEnd: Type.Optional(Type.String({ description: "Optional end timestamp for the evidence window." })),
+        refs: Type.Optional(Type.Array(Type.String(), { description: "Optional references (URLs, IDs, filenames)." }))
+      }),
+      async execute(_toolCallId, params) {
+        if (!orchestrator.sharedContext) {
+          return toolResult(
+            "Shared context is disabled. Enable `sharedContextEnabled: true` to record shared feedback."
+          );
+        }
+        const p = params;
+        const isDecision = (v) => v === "approved" || v === "approved_with_feedback" || v === "rejected";
+        if (!isDecision(p.decision)) {
+          return toolResult(
+            "shared_feedback_record error: decision must be one of approved, approved_with_feedback, rejected"
+          );
+        }
+        const isSeverity = (v) => v === "low" || v === "medium" || v === "high";
+        const entry = {
+          agent: typeof p.agent === "string" ? p.agent : "",
+          decision: p.decision,
+          reason: typeof p.reason === "string" ? p.reason : "",
+          date: typeof p.date === "string" && p.date.length > 0 ? p.date : (/* @__PURE__ */ new Date()).toISOString(),
+          learning: typeof p.learning === "string" ? p.learning : void 0,
+          outcome: typeof p.outcome === "string" ? p.outcome : void 0,
+          severity: isSeverity(p.severity) ? p.severity : void 0,
+          confidence: typeof p.confidence === "number" && Number.isFinite(p.confidence) ? p.confidence : void 0,
+          workflow: typeof p.workflow === "string" ? p.workflow : void 0,
+          tags: Array.isArray(p.tags) ? p.tags.map(String) : void 0,
+          evidenceWindowStart: typeof p.evidenceWindowStart === "string" ? p.evidenceWindowStart : void 0,
+          evidenceWindowEnd: typeof p.evidenceWindowEnd === "string" ? p.evidenceWindowEnd : void 0,
+          refs: Array.isArray(p.refs) ? p.refs.map(String) : void 0
+        };
+        await orchestrator.sharedContext.appendFeedback(entry);
+        return toolResult("OK");
+      }
+    },
+    { name: "shared_feedback_record" }
+  );
+  api.registerTool(
+    {
+      name: "shared_priorities_append",
+      label: "Append Priorities Inbox",
+      description: "Append text into shared-context priorities inbox. A curator run should merge this into priorities.md.",
+      parameters: Type.Object({
+        agentId: Type.String({ description: "Agent ID appending priorities." }),
+        text: Type.String({ description: "Priority notes to append (markdown)." })
+      }),
+      async execute(_toolCallId, params) {
+        if (!orchestrator.sharedContext) {
+          return toolResult(
+            "Shared context is disabled. Enable `sharedContextEnabled: true` to write priorities inbox."
+          );
+        }
+        const { agentId, text } = params;
+        await orchestrator.sharedContext.appendPrioritiesInbox({ agentId, text });
+        return toolResult("OK");
+      }
+    },
+    { name: "shared_priorities_append" }
+  );
+  api.registerTool(
+    {
+      name: "shared_context_cross_signals_run",
+      label: "Run Cross-Signal Synthesis",
+      description: "Generate today's shared-context cross-signal markdown + JSON artifacts on demand, without requiring a full roundtable curation pass.",
+      parameters: Type.Object({
+        date: Type.Optional(Type.String({ description: "YYYY-MM-DD. Defaults to today." }))
+      }),
+      async execute(_toolCallId, params) {
+        if (!orchestrator.sharedContext) {
+          return toolResult(
+            "Shared context is disabled. Enable `sharedContextEnabled: true` to synthesize cross-signals."
+          );
+        }
+        const { date } = params;
+        const result = await orchestrator.sharedContext.synthesizeCrossSignals({ date });
+        return toolResult(
+          [
+            `Cross-signals markdown: ${result.crossSignalsMarkdownPath}`,
+            `Cross-signals JSON: ${result.crossSignalsPath}`,
+            `Source outputs analyzed: ${result.report.sourceCount}`,
+            `Feedback entries analyzed: ${result.report.feedbackCount}`,
+            `Overlap count: ${result.overlapCount}`
+          ].join("\n")
+        );
+      }
+    },
+    { name: "shared_context_cross_signals_run" }
+  );
+  api.registerTool(
+    {
+      name: "shared_context_curate_daily",
+      label: "Curate Daily Roundtable",
+      description: "Curator tool: generate today's roundtable summary in shared-context/roundtable (deterministic baseline).",
+      parameters: Type.Object({
+        date: Type.Optional(Type.String({ description: "YYYY-MM-DD. Defaults to today." }))
+      }),
+      async execute(_toolCallId, params) {
+        if (!orchestrator.sharedContext) {
+          return toolResult(
+            "Shared context is disabled. Enable `sharedContextEnabled: true` to curate roundtables."
+          );
+        }
+        const { date } = params;
+        const result = await orchestrator.sharedContext.curateDaily({ date });
+        return toolResult(
+          [
+            `Roundtable: ${result.roundtablePath}`,
+            `Cross-signals markdown: ${result.crossSignalsMarkdownPath}`,
+            `Cross-signals JSON: ${result.crossSignalsPath}`,
+            `Overlap count: ${result.overlapCount}`
+          ].join("\n")
+        );
+      }
+    },
+    { name: "shared_context_curate_daily" }
+  );
+}
+
 // ../../src/tools.ts
 import { WorkStorage } from "@remnic/core/work/storage";
 import { exportWorkBoardMarkdown, exportWorkBoardSnapshot, importWorkBoardSnapshot } from "@remnic/core/work/board";
 import { wrapWorkLayerContext } from "@remnic/core/work/boundary";
-
-// ../../src/profiling.ts
-import {
-  formatProfileTraceAscii,
-  ProfilingCollector
-} from "@remnic/core/profiling";
-
-// ../../src/tools.ts
+import { VALID_MEMORY_CATEGORIES } from "@remnic/core/config";
+import { formatProfileTraceAscii } from "@remnic/core/profiling";
 import { runMemoryGovernance } from "@remnic/core/maintenance/memory-governance";
 
 // ../../src/memory-action-target.ts
@@ -279,15 +415,15 @@ function blocksSupportPassportMutation(action, memory) {
 }
 
 // ../../src/tools.ts
-function toolResult(text) {
+function toolResult2(text) {
   return { content: [{ type: "text", text }], details: void 0 };
 }
 function toolJsonResult(value, options) {
   const payload = JSON.stringify(value, null, 2);
-  return toolResult(wrapWorkLayerContext(payload, { linkToMemory: options?.linkToMemory === true }));
+  return toolResult2(wrapWorkLayerContext(payload, { linkToMemory: options?.linkToMemory === true }));
 }
 function workLayerTextResult(text, options) {
-  return toolResult(wrapWorkLayerContext(text, { linkToMemory: options?.linkToMemory === true }));
+  return toolResult2(wrapWorkLayerContext(text, { linkToMemory: options?.linkToMemory === true }));
 }
 function asNonEmptyString(value) {
   if (typeof value !== "string") return void 0;
@@ -468,7 +604,7 @@ function registerTools(api, orchestrator, hostRuntimeAgentId) {
   function normalizeMemoryCategory(value, fallback) {
     const normalized = asNonEmptyString(value);
     if (!normalized) return fallback;
-    if (!config_exports.VALID_MEMORY_CATEGORIES.has(normalized)) return void 0;
+    if (!VALID_MEMORY_CATEGORIES.has(normalized)) return void 0;
     return normalized;
   }
   function isKnownMemoryActionType(value) {
@@ -512,21 +648,21 @@ function registerTools(api, orchestrator, hostRuntimeAgentId) {
       const result = await persistExplicitCapture(orchestrator, candidate, source);
       if (result.tombstoneBlocked) {
         orchestrator.requestQmdMaintenanceForTool(maintenanceReason);
-        return toolResult(
+        return toolResult2(
           `Memory queued for review (tombstone-blocked): ${result.id}${candidate.namespace ? ` (namespace: ${candidate.namespace})` : ""} \u2014 no active copy was created.
 
 Content: ${candidate.content}`
         );
       }
-      if (!result.duplicateOf && orchestrator.config.queryAwareIndexingEnabled && await indexesExistAsync(orchestrator.config.memoryDir)) {
+      if (!result.duplicateOf && orchestrator.config.queryAwareIndexingEnabled && await indexesExistAsync2(orchestrator.config.memoryDir)) {
         const storage = await orchestrator.getStorage(candidate.namespace);
         const mem = await storage.getMemoryById(result.id).catch(() => null);
         if (mem?.path && mem.frontmatter?.created) {
-          await indexMemoryAsync(orchestrator.config.memoryDir, mem.path, mem.frontmatter.created, mem.frontmatter.tags ?? []);
+          await indexMemoryAsync2(orchestrator.config.memoryDir, mem.path, mem.frontmatter.created, mem.frontmatter.tags ?? []);
         }
       }
       orchestrator.requestQmdMaintenanceForTool(maintenanceReason);
-      return toolResult(
+      return toolResult2(
         result.duplicateOf ? `Memory already exists: ${result.duplicateOf}${candidate.namespace ? ` (namespace: ${candidate.namespace})` : ""}
 
 Content: ${candidate.content}` : `Memory stored: ${result.id}${candidate.namespace ? ` (namespace: ${candidate.namespace})` : ""}
@@ -537,7 +673,7 @@ Content: ${candidate.content}`
       try {
         const queued = await queueExplicitCaptureForReview(orchestrator, rawInput, source, error);
         orchestrator.requestQmdMaintenanceForTool(`${maintenanceReason}.review`);
-        return toolResult(
+        return toolResult2(
           queued.duplicateOf ? `Memory already queued for review: ${queued.duplicateOf}${namespace ? ` (namespace: ${namespace})` : ""}
 
 Content: ${content}` : `Memory queued for review: ${queued.id}${namespace ? ` (namespace: ${namespace})` : ""}
@@ -545,8 +681,8 @@ Content: ${content}` : `Memory queued for review: ${queued.id}${namespace ? ` (n
 Content: ${content}`
         );
       } catch (queueError) {
-        logger_exports.log.warn(`explicit tool capture rejected: ${error}; review queue fallback failed: ${queueError}`);
-        return toolResult(`Memory capture failed: ${error instanceof Error ? error.message : String(error)}`);
+        log.warn(`explicit tool capture rejected: ${error}; review queue fallback failed: ${queueError}`);
+        return toolResult2(`Memory capture failed: ${error instanceof Error ? error.message : String(error)}`);
       }
     }
   }
@@ -565,24 +701,24 @@ Best for:
 - Finding previously learned facts about the user
 - Checking what you know about a topic
 - Locating past decisions or corrections`,
-        parameters: Type.Object({
-          query: Type.String({
+        parameters: Type2.Object({
+          query: Type2.String({
             description: "Search query \u2014 keywords, phrases, or natural language"
           }),
-          namespace: Type.Optional(
-            Type.String({
+          namespace: Type2.Optional(
+            Type2.String({
               description: "Optional namespace filter. When set, only returns results under memoryDir/namespaces/<namespace>/ (default namespace uses legacy root)."
             })
           ),
-          maxResults: Type.Optional(
-            Type.Number({
+          maxResults: Type2.Optional(
+            Type2.Number({
               description: "Maximum results (default: 8)",
               minimum: 1,
               maximum: 50
             })
           ),
-          collection: Type.Optional(
-            Type.String({
+          collection: Type2.Optional(
+            Type2.String({
               description: "QMD collection to search. Omit for memory collection, use 'global' for all collections."
             })
           )
@@ -625,7 +761,7 @@ Best for:
           }
           filtered = filtered.slice(0, resultLimit);
           if (filtered.length === 0) {
-            return toolResult(`No memories found matching: "${query}"`);
+            return toolResult2(`No memories found matching: "${query}"`);
           }
           const formatted = filtered.map((r, i) => {
             const snippet = r.snippet ? r.snippet.slice(0, 800) : "(no preview)";
@@ -636,7 +772,7 @@ Score: ${r.score.toFixed(3)}
 ${snippet}
 \`\`\``;
           }).join("\n\n");
-          return toolResult(
+          return toolResult2(
             `## Memory Search: "${query}"
 
 ${filtered.length} result(s)
@@ -653,32 +789,32 @@ ${formatted}`
       name: "continuity_audit_generate",
       label: "Generate Continuity Audit",
       description: "Generate a deterministic identity continuity audit report (weekly/monthly) and persist it under identity/audits.",
-      parameters: Type.Object({
-        period: Type.Optional(
-          Type.String({
+      parameters: Type2.Object({
+        period: Type2.Optional(
+          Type2.String({
             enum: ["weekly", "monthly"],
             description: "Audit period. Defaults to weekly."
           })
         ),
-        key: Type.Optional(
-          Type.String({
+        key: Type2.Optional(
+          Type2.String({
             description: "Optional period key (weekly: YYYY-Www, monthly: YYYY-MM). Defaults to current period."
           })
         )
       }),
       async execute(_toolCallId, params) {
         if (!orchestrator.config.identityContinuityEnabled) {
-          return toolResult(
+          return toolResult2(
             "Identity continuity is disabled. Enable `identityContinuityEnabled: true` to generate continuity audits."
           );
         }
         if (!orchestrator.config.continuityAuditEnabled) {
-          return toolResult(
+          return toolResult2(
             "Continuity audits are disabled. Enable `continuityAuditEnabled: true` to generate continuity audits."
           );
         }
         if (!orchestrator.compounding) {
-          return toolResult(
+          return toolResult2(
             "Compounding engine is disabled. Enable `compoundingEnabled: true` to generate continuity audits."
           );
         }
@@ -688,7 +824,7 @@ ${formatted}`
           period,
           key
         });
-        return toolResult(
+        return toolResult2(
           `OK
 
 period: ${audit.period}
@@ -704,40 +840,40 @@ report: ${audit.reportPath}`
       name: "continuity_incident_open",
       label: "Open Continuity Incident",
       description: "Create a new continuity incident record in append-only storage.",
-      parameters: Type.Object({
-        symptom: Type.String({
+      parameters: Type2.Object({
+        symptom: Type2.String({
           description: "Observed continuity failure symptom."
         }),
-        namespace: Type.Optional(
-          Type.String({
+        namespace: Type2.Optional(
+          Type2.String({
             description: "Optional namespace override. Defaults to the default namespace."
           })
         ),
-        triggerWindow: Type.Optional(
-          Type.String({
+        triggerWindow: Type2.Optional(
+          Type2.String({
             description: "Optional time window when incident occurred."
           })
         ),
-        suspectedCause: Type.Optional(
-          Type.String({
+        suspectedCause: Type2.Optional(
+          Type2.String({
             description: "Optional suspected root cause."
           })
         )
       }),
       async execute(_toolCallId, params) {
         if (!orchestrator.config.identityContinuityEnabled) {
-          return toolResult(
+          return toolResult2(
             "Identity continuity is disabled. Enable `identityContinuityEnabled: true` to open incidents."
           );
         }
         if (!orchestrator.config.continuityIncidentLoggingEnabled) {
-          return toolResult(
+          return toolResult2(
             "Continuity incident logging is disabled. Enable `continuityIncidentLoggingEnabled: true` to open incidents."
           );
         }
         const symptom = typeof params.symptom === "string" ? params.symptom.trim() : "";
         if (!symptom) {
-          return toolResult("Missing required field: symptom");
+          return toolResult2("Missing required field: symptom");
         }
         const storage = await orchestrator.getStorageForNamespace(
           normalizeToolNamespace(params.namespace)
@@ -747,8 +883,8 @@ report: ${audit.reportPath}`
           triggerWindow: typeof params.triggerWindow === "string" ? params.triggerWindow : void 0,
           suspectedCause: typeof params.suspectedCause === "string" ? params.suspectedCause : void 0
         });
-        logger_exports.log.info(`continuity-incident open id=${created.id}`);
-        return toolResult(`Continuity incident opened.
+        log.info(`continuity-incident open id=${created.id}`);
+        return toolResult2(`Continuity incident opened.
 
 ${formatContinuityIncidentSummary(created)}`);
       }
@@ -760,35 +896,35 @@ ${formatContinuityIncidentSummary(created)}`);
       name: "continuity_incident_close",
       label: "Close Continuity Incident",
       description: "Close an open continuity incident with required verification details.",
-      parameters: Type.Object({
-        id: Type.String({
+      parameters: Type2.Object({
+        id: Type2.String({
           description: "Incident ID to close."
         }),
-        namespace: Type.Optional(
-          Type.String({
+        namespace: Type2.Optional(
+          Type2.String({
             description: "Optional namespace override. Defaults to the default namespace."
           })
         ),
-        fixApplied: Type.String({
+        fixApplied: Type2.String({
           description: "What fix was applied."
         }),
-        verificationResult: Type.String({
+        verificationResult: Type2.String({
           description: "How closure was verified."
         }),
-        preventiveRule: Type.Optional(
-          Type.String({
+        preventiveRule: Type2.Optional(
+          Type2.String({
             description: "Optional preventive follow-up rule."
           })
         )
       }),
       async execute(_toolCallId, params) {
         if (!orchestrator.config.identityContinuityEnabled) {
-          return toolResult(
+          return toolResult2(
             "Identity continuity is disabled. Enable `identityContinuityEnabled: true` to close incidents."
           );
         }
         if (!orchestrator.config.continuityIncidentLoggingEnabled) {
-          return toolResult(
+          return toolResult2(
             "Continuity incident logging is disabled. Enable `continuityIncidentLoggingEnabled: true` to close incidents."
           );
         }
@@ -796,9 +932,9 @@ ${formatContinuityIncidentSummary(created)}`);
         const fixApplied = typeof params.fixApplied === "string" ? params.fixApplied.trim() : "";
         const verificationResult = typeof params.verificationResult === "string" ? params.verificationResult.trim() : "";
         const preventiveRule = typeof params.preventiveRule === "string" ? params.preventiveRule.trim() : void 0;
-        if (!id) return toolResult("Missing required field: id");
-        if (!fixApplied) return toolResult("Missing required field: fixApplied");
-        if (!verificationResult) return toolResult("Missing required field: verificationResult");
+        if (!id) return toolResult2("Missing required field: id");
+        if (!fixApplied) return toolResult2("Missing required field: fixApplied");
+        if (!verificationResult) return toolResult2("Missing required field: verificationResult");
         const storage = await orchestrator.getStorageForNamespace(
           normalizeToolNamespace(params.namespace)
         );
@@ -807,9 +943,9 @@ ${formatContinuityIncidentSummary(created)}`);
           verificationResult,
           preventiveRule
         });
-        if (!closed) return toolResult(`Incident not found: ${id}`);
-        logger_exports.log.info(`continuity-incident close id=${id}`);
-        return toolResult(`Continuity incident closed.
+        if (!closed) return toolResult2(`Incident not found: ${id}`);
+        log.info(`continuity-incident close id=${id}`);
+        return toolResult2(`Continuity incident closed.
 
 ${formatContinuityIncidentSummary(closed)}`);
       }
@@ -821,20 +957,20 @@ ${formatContinuityIncidentSummary(closed)}`);
       name: "continuity_incident_list",
       label: "List Continuity Incidents",
       description: "List continuity incidents and optionally filter by state.",
-      parameters: Type.Object({
-        state: Type.Optional(
-          Type.String({
+      parameters: Type2.Object({
+        state: Type2.Optional(
+          Type2.String({
             enum: ["open", "closed", "all"],
             description: "Incident state filter (default: open)."
           })
         ),
-        namespace: Type.Optional(
-          Type.String({
+        namespace: Type2.Optional(
+          Type2.String({
             description: "Optional namespace override. Defaults to the default namespace."
           })
         ),
-        limit: Type.Optional(
-          Type.Number({
+        limit: Type2.Optional(
+          Type2.Number({
             description: "Max incidents to return (default: 25, max: 200).",
             minimum: 1,
             maximum: 200
@@ -843,7 +979,7 @@ ${formatContinuityIncidentSummary(closed)}`);
       }),
       async execute(_toolCallId, params) {
         if (!orchestrator.config.identityContinuityEnabled) {
-          return toolResult(
+          return toolResult2(
             "Identity continuity is disabled. Enable `identityContinuityEnabled: true` to list incidents."
           );
         }
@@ -855,10 +991,10 @@ ${formatContinuityIncidentSummary(closed)}`);
         );
         const filtered = await storage.readContinuityIncidents(limit, state);
         if (filtered.length === 0) {
-          return toolResult(`No continuity incidents found for state=${state}.`);
+          return toolResult2(`No continuity incidents found for state=${state}.`);
         }
         const body = filtered.map((incident, index) => formatContinuityIncidentSummary(incident, index)).join("\n\n");
-        return toolResult(`## Continuity Incidents (${filtered.length}, state=${state})
+        return toolResult2(`## Continuity Incidents (${filtered.length}, state=${state})
 
 ${body}`);
       }
@@ -870,43 +1006,43 @@ ${body}`);
       name: "continuity_loop_add_or_update",
       label: "Add or Update Continuity Loop",
       description: "Add or update a continuity improvement loop entry in identity/improvement-loops.md.",
-      parameters: Type.Object({
-        id: Type.String({
+      parameters: Type2.Object({
+        id: Type2.String({
           description: "Stable loop identifier."
         }),
-        namespace: Type.Optional(
-          Type.String({
+        namespace: Type2.Optional(
+          Type2.String({
             description: "Optional namespace override. Defaults to the default namespace."
           })
         ),
-        cadence: Type.String({
+        cadence: Type2.String({
           enum: ["daily", "weekly", "monthly", "quarterly"],
           description: "Review cadence."
         }),
-        purpose: Type.String({
+        purpose: Type2.String({
           description: "What this recurring loop improves."
         }),
-        status: Type.String({
+        status: Type2.String({
           enum: ["active", "paused", "retired"],
           description: "Current lifecycle status for the loop."
         }),
-        killCondition: Type.String({
+        killCondition: Type2.String({
           description: "Clear condition for retiring this loop."
         }),
-        lastReviewed: Type.Optional(
-          Type.String({
+        lastReviewed: Type2.Optional(
+          Type2.String({
             description: "Optional ISO timestamp for last review. Defaults to now."
           })
         ),
-        notes: Type.Optional(
-          Type.String({
+        notes: Type2.Optional(
+          Type2.String({
             description: "Optional operator notes."
           })
         )
       }),
       async execute(_toolCallId, params) {
         if (!orchestrator.config.identityContinuityEnabled) {
-          return toolResult(
+          return toolResult2(
             "Identity continuity is disabled. Enable `identityContinuityEnabled: true` to manage continuity loops."
           );
         }
@@ -923,12 +1059,12 @@ ${body}`);
             lastReviewed: typeof params.lastReviewed === "string" ? params.lastReviewed : void 0,
             notes: typeof params.notes === "string" ? params.notes : void 0
           });
-          logger_exports.log.info(`continuity-loop upsert id=${loop.id} status=${loop.status}`);
-          return toolResult(`Continuity loop saved.
+          log.info(`continuity-loop upsert id=${loop.id} status=${loop.status}`);
+          return toolResult2(`Continuity loop saved.
 
 ${formatContinuityLoopSummary(loop)}`);
         } catch (err) {
-          return toolResult(`Failed to save continuity loop: ${String(err)}`);
+          return toolResult2(`Failed to save continuity loop: ${String(err)}`);
         }
       }
     },
@@ -939,40 +1075,40 @@ ${formatContinuityLoopSummary(loop)}`);
       name: "continuity_loop_review",
       label: "Review Continuity Loop",
       description: "Update review metadata (lastReviewed/status/notes) for an existing continuity loop.",
-      parameters: Type.Object({
-        id: Type.String({
+      parameters: Type2.Object({
+        id: Type2.String({
           description: "Loop ID to review."
         }),
-        namespace: Type.Optional(
-          Type.String({
+        namespace: Type2.Optional(
+          Type2.String({
             description: "Optional namespace override. Defaults to the default namespace."
           })
         ),
-        status: Type.Optional(
-          Type.String({
+        status: Type2.Optional(
+          Type2.String({
             enum: ["active", "paused", "retired"],
             description: "Optional status update."
           })
         ),
-        notes: Type.Optional(
-          Type.String({
+        notes: Type2.Optional(
+          Type2.String({
             description: "Optional notes update."
           })
         ),
-        reviewedAt: Type.Optional(
-          Type.String({
+        reviewedAt: Type2.Optional(
+          Type2.String({
             description: "Optional ISO timestamp for review event. Defaults to now."
           })
         )
       }),
       async execute(_toolCallId, params) {
         if (!orchestrator.config.identityContinuityEnabled) {
-          return toolResult(
+          return toolResult2(
             "Identity continuity is disabled. Enable `identityContinuityEnabled: true` to manage continuity loops."
           );
         }
         const id = typeof params.id === "string" ? params.id.trim() : "";
-        if (!id) return toolResult("Missing required field: id");
+        if (!id) return toolResult2("Missing required field: id");
         try {
           const storage = await orchestrator.getStorageForNamespace(
             normalizeToolNamespace(params.namespace)
@@ -982,13 +1118,13 @@ ${formatContinuityLoopSummary(loop)}`);
             notes: typeof params.notes === "string" ? params.notes : void 0,
             reviewedAt: typeof params.reviewedAt === "string" ? params.reviewedAt : void 0
           });
-          if (!reviewed) return toolResult(`Continuity loop not found: ${id}`);
-          logger_exports.log.info(`continuity-loop review id=${id} status=${reviewed.status}`);
-          return toolResult(`Continuity loop reviewed.
+          if (!reviewed) return toolResult2(`Continuity loop not found: ${id}`);
+          log.info(`continuity-loop review id=${id} status=${reviewed.status}`);
+          return toolResult2(`Continuity loop reviewed.
 
 ${formatContinuityLoopSummary(reviewed)}`);
         } catch (err) {
-          return toolResult(`Failed to review continuity loop: ${String(err)}`);
+          return toolResult2(`Failed to review continuity loop: ${String(err)}`);
         }
       }
     },
@@ -999,16 +1135,16 @@ ${formatContinuityLoopSummary(reviewed)}`);
       name: "identity_anchor_get",
       label: "Get Identity Anchor",
       description: "Read the identity continuity anchor document used for recovery-safe identity context.",
-      parameters: Type.Object({
-        namespace: Type.Optional(
-          Type.String({
+      parameters: Type2.Object({
+        namespace: Type2.Optional(
+          Type2.String({
             description: "Optional namespace override. Defaults to the default namespace."
           })
         )
       }),
       async execute(_toolCallId, params) {
         if (!orchestrator.config.identityContinuityEnabled) {
-          return toolResult(
+          return toolResult2(
             "Identity continuity is disabled. Enable `identityContinuityEnabled: true` to use identity anchor tools."
           );
         }
@@ -1017,11 +1153,11 @@ ${formatContinuityLoopSummary(reviewed)}`);
         );
         const anchor = await storage.readIdentityAnchor();
         if (!anchor) {
-          return toolResult(
+          return toolResult2(
             "No identity anchor found yet. Use `identity_anchor_update` to create one."
           );
         }
-        return toolResult(`## Identity Anchor
+        return toolResult2(`## Identity Anchor
 
 ${anchor}`);
       }
@@ -1033,36 +1169,36 @@ ${anchor}`);
       name: "identity_anchor_update",
       label: "Update Identity Anchor",
       description: "Conservatively update identity anchor sections without overwriting existing material.",
-      parameters: Type.Object({
-        namespace: Type.Optional(
-          Type.String({
+      parameters: Type2.Object({
+        namespace: Type2.Optional(
+          Type2.String({
             description: "Optional namespace override. Defaults to the default namespace."
           })
         ),
-        identityTraits: Type.Optional(
-          Type.String({
+        identityTraits: Type2.Optional(
+          Type2.String({
             description: "Updates for the 'Identity Traits' section."
           })
         ),
-        communicationPreferences: Type.Optional(
-          Type.String({
+        communicationPreferences: Type2.Optional(
+          Type2.String({
             description: "Updates for the 'Communication Preferences' section."
           })
         ),
-        operatingPrinciples: Type.Optional(
-          Type.String({
+        operatingPrinciples: Type2.Optional(
+          Type2.String({
             description: "Updates for the 'Operating Principles' section."
           })
         ),
-        continuityNotes: Type.Optional(
-          Type.String({
+        continuityNotes: Type2.Optional(
+          Type2.String({
             description: "Updates for the 'Continuity Notes' section."
           })
         )
       }),
       async execute(_toolCallId, params) {
         if (!orchestrator.config.identityContinuityEnabled) {
-          return toolResult(
+          return toolResult2(
             "Identity continuity is disabled. Enable `identityContinuityEnabled: true` to use identity anchor tools."
           );
         }
@@ -1076,7 +1212,7 @@ ${anchor}`);
           (value) => typeof value === "string" && value.trim().length > 0
         );
         if (!hasUpdate) {
-          return toolResult(
+          return toolResult2(
             "No updates provided. Supply at least one section field to update the identity anchor."
           );
         }
@@ -1087,10 +1223,10 @@ ${anchor}`);
         const merged = mergeIdentityAnchor(existing, updates);
         await storage.writeIdentityAnchor(merged);
         const updatedSections = Object.entries(updates).filter(([, value]) => typeof value === "string" && value.trim().length > 0).map(([name]) => name);
-        logger_exports.log.info(
+        log.info(
           `identity-anchor update sections=${updatedSections.join(",")} chars=${merged.length}`
         );
-        return toolResult(
+        return toolResult2(
           `Identity anchor updated (${updatedSections.length} section${updatedSections.length === 1 ? "" : "s"}).
 
 ${merged}`
@@ -1104,16 +1240,16 @@ ${merged}`
       name: "memory_feedback",
       label: "Memory Feedback",
       description: "Thumbs up/down a memory's relevance. Stored locally and used as a soft ranking bias when enabled.",
-      parameters: Type.Object({
-        memoryId: Type.String({
+      parameters: Type2.Object({
+        memoryId: Type2.String({
           description: "Memory ID (filename without .md), e.g. fact-123"
         }),
-        vote: Type.String({
+        vote: Type2.String({
           enum: ["up", "down"],
           description: "up or down"
         }),
-        note: Type.Optional(
-          Type.String({
+        note: Type2.Optional(
+          Type2.String({
             description: "Optional note explaining the feedback (stored locally)."
           })
         )
@@ -1121,12 +1257,12 @@ ${merged}`
       async execute(_toolCallId, params) {
         const { memoryId, vote, note } = params;
         if (!orchestrator.config.feedbackEnabled) {
-          return toolResult(
+          return toolResult2(
             "Feedback is disabled. Enable `feedbackEnabled: true` in the Engram plugin config to store feedback."
           );
         }
         await orchestrator.recordMemoryFeedback(memoryId, vote, note);
-        return toolResult(
+        return toolResult2(
           `Recorded feedback for ${memoryId}: ${vote}${note ? ` (note: ${note})` : ""}`
         );
       }
@@ -1138,9 +1274,9 @@ ${merged}`
       name: "memory_last_recall",
       label: "Last Recall Snapshot",
       description: "Fetch the last set of memory IDs that were injected into context for a session. Useful when the user says things like 'why did you say that?' or 'that's not right' and you want to identify which memories may have misled the response.",
-      parameters: Type.Object({
-        sessionKey: Type.Optional(
-          Type.String({
+      parameters: Type2.Object({
+        sessionKey: Type2.Optional(
+          Type2.String({
             description: "Session key to look up. If omitted, returns the most recent snapshot across all sessions (may be wrong under concurrency)."
           })
         )
@@ -1149,12 +1285,12 @@ ${merged}`
         const { sessionKey } = params;
         const snap = sessionKey ? orchestrator.lastRecall.get(sessionKey) : orchestrator.lastRecall.getMostRecent();
         if (!snap) {
-          return toolResult("No last-recall snapshot found yet.");
+          return toolResult2("No last-recall snapshot found yet.");
         }
         const prefix = sessionKey ? `## Last Recall (${snap.sessionKey})` : `## Last Recall (most recent: ${snap.sessionKey})
 
 NOTE: You did not provide sessionKey; under concurrency this may not match your current session.`;
-        return toolResult(
+        return toolResult2(
           [
             prefix,
             "",
@@ -1174,9 +1310,9 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
       name: "memory_intent_debug",
       label: "Inspect Intent Debug",
       description: "Inspect the last persisted planner/intent snapshot, including recall mode selection, query intent classification, and graph fallback decisions.",
-      parameters: Type.Object({
-        namespace: Type.Optional(
-          Type.String({
+      parameters: Type2.Object({
+        namespace: Type2.Optional(
+          Type2.String({
             description: "Optional namespace to inspect. Defaults to defaultNamespace."
           })
         )
@@ -1186,7 +1322,7 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
         const text = await orchestrator.recallIntrospection.explainLastIntent({
           namespace
         });
-        return toolResult(text);
+        return toolResult2(text);
       }
     },
     { name: "memory_intent_debug" }
@@ -1196,14 +1332,14 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
       name: "memory_qmd_debug",
       label: "Inspect QMD Recall",
       description: "Inspect the last persisted QMD recall snapshot, including any intent hint, explain trace capture, and whether hybrid top-up was skipped or used.",
-      parameters: Type.Object({
-        namespace: Type.Optional(
-          Type.String({
+      parameters: Type2.Object({
+        namespace: Type2.Optional(
+          Type2.String({
             description: "Optional namespace to inspect. Defaults to defaultNamespace."
           })
         ),
-        maxResults: Type.Optional(
-          Type.Number({
+        maxResults: Type2.Optional(
+          Type2.Number({
             description: "Maximum results to show (default: 10, max: 25).",
             minimum: 1,
             maximum: 25
@@ -1216,7 +1352,7 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
           namespace,
           maxResults
         });
-        return toolResult(text);
+        return toolResult2(text);
       }
     },
     { name: "memory_qmd_debug" }
@@ -1226,14 +1362,14 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
       name: "memory_graph_explain_last_recall",
       label: "Explain Graph Recall",
       description: "Inspect the last graph-mode recall expansion snapshot (seed paths + expanded candidates) to explain why graph memories were included.",
-      parameters: Type.Object({
-        namespace: Type.Optional(
-          Type.String({
+      parameters: Type2.Object({
+        namespace: Type2.Optional(
+          Type2.String({
             description: "Optional namespace to inspect. Defaults to defaultNamespace."
           })
         ),
-        maxExpanded: Type.Optional(
-          Type.Number({
+        maxExpanded: Type2.Optional(
+          Type2.Number({
             description: "Maximum expanded paths to show (default: 10, max: 50).",
             minimum: 1,
             maximum: 50
@@ -1246,7 +1382,7 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
           namespace,
           maxExpanded
         });
-        return toolResult(text);
+        return toolResult2(text);
       }
     },
     { name: "memory_graph_explain_last_recall" }
@@ -1256,29 +1392,29 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
       name: "memory_feedback_last_recall",
       label: "Feedback Last Recall",
       description: "Batch feedback tool for the last recall snapshot. Can mark retrieved memories as 'not useful' (negative examples) so they are softly penalized in future ranking when negative examples are enabled.",
-      parameters: Type.Object({
-        sessionKey: Type.Optional(
-          Type.String({
+      parameters: Type2.Object({
+        sessionKey: Type2.Optional(
+          Type2.String({
             description: "Session key. If omitted, uses the most recent snapshot across all sessions (may be wrong under concurrency)."
           })
         ),
-        notUsefulMemoryIds: Type.Optional(
-          Type.Array(Type.String(), {
+        notUsefulMemoryIds: Type2.Optional(
+          Type2.Array(Type2.String(), {
             description: "Memory IDs to mark as not useful. If omitted, you may use usefulMemoryIds + autoMarkOthersNotUseful to mark the rest as not useful."
           })
         ),
-        usefulMemoryIds: Type.Optional(
-          Type.Array(Type.String(), {
+        usefulMemoryIds: Type2.Optional(
+          Type2.Array(Type2.String(), {
             description: "Memory IDs that were useful. Only used when autoMarkOthersNotUseful=true."
           })
         ),
-        autoMarkOthersNotUseful: Type.Optional(
-          Type.Boolean({
+        autoMarkOthersNotUseful: Type2.Optional(
+          Type2.Boolean({
             description: "If true, marks all last-recall memory IDs not listed in usefulMemoryIds as not useful. Safer than auto-marking without an explicit useful list."
           })
         ),
-        note: Type.Optional(
-          Type.String({
+        note: Type2.Optional(
+          Type2.String({
             description: "Optional note explaining why these were not useful (stored locally)."
           })
         )
@@ -1292,20 +1428,20 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
           note
         } = params;
         if (!orchestrator.config.negativeExamplesEnabled) {
-          return toolResult(
+          return toolResult2(
             "Negative examples are disabled. Enable `negativeExamplesEnabled: true` in the Engram plugin config to store retrieved-but-not-useful feedback and apply penalties."
           );
         }
         const snap = sessionKey ? orchestrator.lastRecall.get(sessionKey) : orchestrator.lastRecall.getMostRecent();
         if (!snap) {
-          return toolResult("No last-recall snapshot found yet.");
+          return toolResult2("No last-recall snapshot found yet.");
         }
         let toMark = null;
         if (Array.isArray(notUsefulMemoryIds) && notUsefulMemoryIds.length > 0) {
           toMark = notUsefulMemoryIds;
         } else if (autoMarkOthersNotUseful) {
           if (!Array.isArray(usefulMemoryIds) || usefulMemoryIds.length === 0) {
-            return toolResult(
+            return toolResult2(
               "autoMarkOthersNotUseful=true requires a non-empty usefulMemoryIds list (to avoid accidental mass-negative marking)."
             );
           }
@@ -1313,13 +1449,13 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
           toMark = snap.memoryIds.filter((id) => !useful.has(id));
         }
         if (!toMark || toMark.length === 0) {
-          return toolResult(
+          return toolResult2(
             "Nothing to record. Provide notUsefulMemoryIds, or provide usefulMemoryIds with autoMarkOthersNotUseful=true."
           );
         }
         await orchestrator.recordNotUsefulMemories(toMark, note);
         const warn = sessionKey ? "" : "\n\nNOTE: You did not provide sessionKey; under concurrency this may not match your current session.";
-        return toolResult(
+        return toolResult2(
           `Recorded ${toMark.length} not-useful memory ID(s) for last recall (${snap.sessionKey}).${warn}`
         );
       }
@@ -1331,50 +1467,50 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
       name: "context_checkpoint",
       label: "Context Checkpoint",
       description: "Create or validate a transcript checkpoint and record the corresponding context-compression action event (v8.3).",
-      parameters: Type.Object({
-        summary: Type.String({
+      parameters: Type2.Object({
+        summary: Type2.String({
           description: "Short summary of what was checkpointed."
         }),
-        sessionKey: Type.Optional(
-          Type.String({
+        sessionKey: Type2.Optional(
+          Type2.String({
             description: "Session key for the checkpoint source transcript."
           })
         ),
-        turns: Type.Optional(
-          Type.Array(
-            Type.Object({
-              timestamp: Type.String(),
-              role: Type.String({ enum: ["user", "assistant"] }),
-              content: Type.String(),
-              sessionKey: Type.String(),
-              turnId: Type.String()
+        turns: Type2.Optional(
+          Type2.Array(
+            Type2.Object({
+              timestamp: Type2.String(),
+              role: Type2.String({ enum: ["user", "assistant"] }),
+              content: Type2.String(),
+              sessionKey: Type2.String(),
+              turnId: Type2.String()
             })
           )
         ),
-        ttlHours: Type.Optional(
-          Type.Number({
+        ttlHours: Type2.Optional(
+          Type2.Number({
             description: "Optional checkpoint TTL in hours."
           })
         ),
-        sourcePrompt: Type.Optional(
-          Type.String({
+        sourcePrompt: Type2.Optional(
+          Type2.String({
             description: "Optional source prompt text used for hashing in telemetry."
           })
         ),
-        namespace: Type.Optional(
-          Type.String({
+        namespace: Type2.Optional(
+          Type2.String({
             description: "Optional namespace. Defaults to defaultNamespace."
           })
         ),
-        dryRun: Type.Optional(
-          Type.Boolean({
+        dryRun: Type2.Optional(
+          Type2.Boolean({
             description: "When true, validate and log without persisting the checkpoint file."
           })
         )
       }),
       async execute(_toolCallId, params) {
         if (!orchestrator.config.contextCompressionActionsEnabled) {
-          return toolResult(
+          return toolResult2(
             "Context compression actions are disabled. Enable `contextCompressionActionsEnabled: true` to use this tool."
           );
         }
@@ -1390,9 +1526,9 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
             promptHash: promptHashForTelemetry(sourcePrompt)
           });
           if (!wrote2) {
-            return toolResult("Checkpoint recorded best-effort failed (fail-open).");
+            return toolResult2("Checkpoint recorded best-effort failed (fail-open).");
           }
-          return toolResult(`Recorded context checkpoint telemetry in namespace=${ns}.`);
+          return toolResult2(`Recorded context checkpoint telemetry in namespace=${ns}.`);
         }
         const validationErrors = [];
         if (!asNonEmptyString(sessionKey)) validationErrors.push("sessionKey is required");
@@ -1415,7 +1551,7 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
             status: "rejected",
             reason: `validation: ${validationErrors.join("; ")}`
           });
-          return toolResult(`Validation failed: ${validationErrors.join("; ")}.`);
+          return toolResult2(`Validation failed: ${validationErrors.join("; ")}.`);
         }
         const structuredEvent = {
           ...baseEvent,
@@ -1425,7 +1561,7 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
         if (preview.policyDecision !== "allow") {
           const wrote2 = await orchestrator.appendMemoryActionEvent(structuredEvent);
           const suffix2 = wrote2 ? "" : " Telemetry write failed (fail-open).";
-          return toolResult(
+          return toolResult2(
             `Context checkpoint blocked by policy: action=${preview.action}, namespace=${preview.namespace}, policy=${preview.policyDecision}, rationale=${preview.policyRationale}.${suffix2}`
           );
         }
@@ -1447,9 +1583,9 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
         });
         const suffix = wrote ? "" : " Telemetry write failed (fail-open).";
         if (dryRun === true) {
-          return toolResult(`Validated context checkpoint for session=${sessionKey} without saving it.${suffix}`);
+          return toolResult2(`Validated context checkpoint for session=${sessionKey} without saving it.${suffix}`);
         }
-        return toolResult(`Saved context checkpoint for session=${sessionKey} in namespace=${ns}.${suffix}`);
+        return toolResult2(`Saved context checkpoint for session=${sessionKey} in namespace=${ns}.${suffix}`);
       }
     },
     { name: "context_checkpoint" }
@@ -1459,86 +1595,86 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
       name: "memory_action_apply",
       label: "Apply Memory Action",
       description: "Record a memory-action application event for policy-learning telemetry (v8.3).",
-      parameters: Type.Object({
-        action: Type.String({
+      parameters: Type2.Object({
+        action: Type2.String({
           enum: actionTypes,
           description: "Memory action type."
         }),
-        category: Type.Optional(
-          Type.String({
+        category: Type2.Optional(
+          Type2.String({
             description: "Optional memory category for write-style actions."
           })
         ),
-        content: Type.Optional(
-          Type.String({
+        content: Type2.Optional(
+          Type2.String({
             description: "Content payload for store, update, artifact, or summarize actions."
           })
         ),
-        outcome: Type.Optional(
-          Type.String({
+        outcome: Type2.Optional(
+          Type2.String({
             enum: ["applied", "skipped", "failed"],
             description: "Outcome status (default: applied)."
           })
         ),
-        reason: Type.Optional(
-          Type.String({
+        reason: Type2.Optional(
+          Type2.String({
             description: "Optional reason/notes for this action outcome."
           })
         ),
-        memoryId: Type.Optional(
-          Type.String({
+        memoryId: Type2.Optional(
+          Type2.String({
             description: "Optional memory ID targeted by this action."
           })
         ),
-        sessionKey: Type.Optional(
-          Type.String({
+        sessionKey: Type2.Optional(
+          Type2.String({
             description: "Optional source session key for audit logging."
           })
         ),
-        linkTargetId: Type.Optional(
-          Type.String({
+        linkTargetId: Type2.Optional(
+          Type2.String({
             description: "Target memory ID for link_graph actions."
           })
         ),
-        linkType: Type.Optional(
-          Type.String({
+        linkType: Type2.Optional(
+          Type2.String({
             description: "Link type for link_graph actions."
           })
         ),
-        linkStrength: Type.Optional(
-          Type.Number({
+        linkStrength: Type2.Optional(
+          Type2.Number({
             description: "Optional edge strength for link_graph actions."
           })
         ),
-        artifactType: Type.Optional(
-          Type.String({
+        artifactType: Type2.Optional(
+          Type2.String({
             description: "Optional artifact type for create_artifact."
           })
         ),
-        execute: Type.Optional(
-          Type.Boolean({
+        execute: Type2.Optional(
+          Type2.Boolean({
             description: "When true, force structured execution mode even for target-only actions like discard."
           })
         ),
-        sourcePrompt: Type.Optional(
-          Type.String({
+        sourcePrompt: Type2.Optional(
+          Type2.String({
             description: "Optional source prompt text used for hashing in telemetry."
           })
         ),
-        namespace: Type.Optional(
-          Type.String({
+        namespace: Type2.Optional(
+          Type2.String({
             description: "Optional namespace. Defaults to defaultNamespace."
           })
         ),
-        dryRun: Type.Optional(
-          Type.Boolean({
+        dryRun: Type2.Optional(
+          Type2.Boolean({
             description: "When true, validate and report without persisting telemetry."
           })
         )
       }),
       async execute(_toolCallId, params) {
         if (!orchestrator.config.contextCompressionActionsEnabled) {
-          return toolResult(
+          return toolResult2(
             "Context compression actions are disabled. Enable `contextCompressionActionsEnabled: true` to use this tool."
           );
         }
@@ -1561,7 +1697,7 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
         } = params;
         const ns = typeof namespace === "string" && namespace.length > 0 ? namespace : orchestrator.config.defaultNamespace;
         if (!isKnownMemoryActionType(action)) {
-          return toolResult(`Validation failed: invalid action ${String(action)}.`);
+          return toolResult2(`Validation failed: invalid action ${String(action)}.`);
         }
         const validationErrors = [];
         const contentValue = asNonEmptyString(content);
@@ -1587,15 +1723,15 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
           };
           const preview2 = orchestrator.previewMemoryActionEvent(event);
           if (dryRun === true) {
-            return toolResult(
+            return toolResult2(
               `Dry run: memory action would be recorded with action=${preview2.action}, outcome=${preview2.outcome}, namespace=${preview2.namespace}, policy=${preview2.policyDecision}.`
             );
           }
           const wrote2 = await orchestrator.appendMemoryActionEvent(event);
           if (!wrote2) {
-            return toolResult("Memory action telemetry write failed (fail-open).");
+            return toolResult2("Memory action telemetry write failed (fail-open).");
           }
-          return toolResult(
+          return toolResult2(
             `Recorded memory action telemetry: action=${preview2.action}, outcome=${preview2.outcome}, namespace=${preview2.namespace}.`
           );
         }
@@ -1631,7 +1767,7 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
             outputMemoryIds: [],
             reason: `validation: ${validationErrors.join("; ")}`
           });
-          return toolResult(
+          return toolResult2(
             `Validation failed: ${validationErrors.join("; ")}.`
           );
         }
@@ -1646,7 +1782,7 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
             reason: `validation: invalid category ${String(category)}`
           });
           const suffix = wrote2 ? "" : " Telemetry write failed (fail-open).";
-          return toolResult(`Validation failed: invalid category ${String(category)}.${suffix}`);
+          return toolResult2(`Validation failed: invalid category ${String(category)}.${suffix}`);
         }
         const storage = typeof orchestrator.getStorage === "function" ? await orchestrator.getStorage(ns) : orchestrator.storage;
         const referencedMemory = await readReferencedMemoryForPolicyEligibility(storage, memoryIdValue);
@@ -1659,7 +1795,7 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
             outputMemoryIds: [],
             reason: "validation: support passport records require the owner surface"
           });
-          return toolResult(
+          return toolResult2(
             "Validation failed: support passport records can only be changed through the support passport owner surface."
           );
         }
@@ -1675,11 +1811,11 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
           const wrote2 = await orchestrator.appendMemoryActionEvent(structuredEvent);
           const suffix = wrote2 ? "" : " Telemetry write failed (fail-open).";
           if (preview2.policyDecision !== "allow") {
-            return toolResult(
+            return toolResult2(
               `Memory action blocked by policy during validation: action=${preview2.action}, namespace=${preview2.namespace}, policy=${preview2.policyDecision}, rationale=${preview2.policyRationale}.${suffix}`
             );
           }
-          return toolResult(
+          return toolResult2(
             `Validated memory action without applying it: action=${preview2.action}, namespace=${preview2.namespace}, policy=${preview2.policyDecision}.${suffix}`
           );
         }
@@ -1687,7 +1823,7 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
         if (preview.policyDecision !== "allow") {
           const wrote2 = await orchestrator.appendMemoryActionEvent(structuredEvent);
           const suffix = wrote2 ? "" : " Telemetry write failed (fail-open).";
-          return toolResult(
+          return toolResult2(
             `Memory action execution blocked by policy: action=${preview.action}, namespace=${preview.namespace}, policy=${preview.policyDecision}, rationale=${preview.policyRationale}.${suffix}`
           );
         }
@@ -1745,7 +1881,7 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
                 reason: `execution: unable to update memory ${memoryIdValue}`
               });
               const suffix = wrote2 ? "" : " Telemetry write failed (fail-open).";
-              return toolResult(`Validation failed: unable to update memory ${memoryIdValue}.${suffix}`);
+              return toolResult2(`Validation failed: unable to update memory ${memoryIdValue}.${suffix}`);
             }
             outputMemoryIds.push(memoryIdValue);
             appliedMessage = `Applied memory action: action=${action}, memoryId=${memoryIdValue}, namespace=${ns}.`;
@@ -1766,7 +1902,7 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
                 reason: "execution: unable to create artifact"
               });
               const suffix = wrote2 ? "" : " Telemetry write failed (fail-open).";
-              return toolResult(`Validation failed: unable to create artifact.${suffix}`);
+              return toolResult2(`Validation failed: unable to create artifact.${suffix}`);
             }
             outputMemoryIds.push(createdId);
             appliedMessage = `Applied memory action: action=${action}, memoryId=${createdId}, namespace=${ns}.`;
@@ -1802,7 +1938,7 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
                 reason: `execution: unable to find memory ${memoryIdValue}`
               });
               const suffix = wrote2 ? "" : " Telemetry write failed (fail-open).";
-              return toolResult(`Validation failed: unable to find memory ${memoryIdValue}.${suffix}`);
+              return toolResult2(`Validation failed: unable to find memory ${memoryIdValue}.${suffix}`);
             }
             await storage.writeMemoryFrontmatter(
               target,
@@ -1845,7 +1981,7 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
                 reason: `execution: unable to link memory ${memoryIdValue}`
               });
               const suffix = wrote2 ? "" : " Telemetry write failed (fail-open).";
-              return toolResult(`Validation failed: unable to link memory ${memoryIdValue}.${suffix}`);
+              return toolResult2(`Validation failed: unable to link memory ${memoryIdValue}.${suffix}`);
             }
             outputMemoryIds.push(memoryIdValue);
             appliedMessage = `Applied memory action: action=${action}, memoryId=${memoryIdValue}, namespace=${ns}.`;
@@ -1869,9 +2005,9 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
           ...queuedForReview ? { reason: "tombstone-blocked: write landed pending_review, no active copy created" } : {}
         });
         if (!wrote) {
-          return toolResult(`${appliedMessage} Telemetry write failed (fail-open).`);
+          return toolResult2(`${appliedMessage} Telemetry write failed (fail-open).`);
         }
-        return toolResult(appliedMessage);
+        return toolResult2(appliedMessage);
       }
     },
     { name: "memory_action_apply" }
@@ -1881,14 +2017,14 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
       name: "compression_guidelines_optimize",
       label: "Optimize Compression Guidelines",
       description: "Run compression guideline optimizer and optionally persist the new guideline/state (v8.11).",
-      parameters: Type.Object({
-        dryRun: Type.Optional(
-          Type.Boolean({
+      parameters: Type2.Object({
+        dryRun: Type2.Optional(
+          Type2.Boolean({
             description: "When true, compute candidate/output but do not persist changes."
           })
         ),
-        eventLimit: Type.Optional(
-          Type.Number({
+        eventLimit: Type2.Optional(
+          Type2.Number({
             description: "Max telemetry events to analyze (default: 500)."
           })
         )
@@ -1900,11 +2036,11 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
           eventLimit
         });
         if (!result.enabled) {
-          return toolResult(
+          return toolResult2(
             "Compression guideline learning is disabled. Enable `compressionGuidelineLearningEnabled: true` to run optimizer."
           );
         }
-        return toolResult(
+        return toolResult2(
           [
             "Compression guideline optimization complete.",
             `dryRun=${result.dryRun}`,
@@ -1925,9 +2061,9 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
       name: "compression_guidelines_activate",
       label: "Activate Compression Guideline Draft",
       description: "Promote the staged compression guideline draft to the active guideline/state after review (v8.11).",
-      parameters: Type.Object({
-        expectedContentHash: Type.Optional(Type.String()),
-        expectedGuidelineVersion: Type.Optional(Type.Number())
+      parameters: Type2.Object({
+        expectedContentHash: Type2.Optional(Type2.String()),
+        expectedGuidelineVersion: Type2.Optional(Type2.Number())
       }),
       async execute(_toolCallId, params) {
         const expectedContentHash = typeof params.expectedContentHash === "string" ? params.expectedContentHash.trim() : "";
@@ -1937,32 +2073,32 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
           ...typeof expectedGuidelineVersion === "number" ? { expectedGuidelineVersion } : {}
         });
         if (!result.enabled) {
-          return toolResult(
+          return toolResult2(
             "Compression guideline learning is disabled. Enable `compressionGuidelineLearningEnabled: true` before activating drafts."
           );
         }
         if (!result.activated) {
           if (result.reason === "missing_draft") {
-            return toolResult("No staged compression guideline draft is available to activate.");
+            return toolResult2("No staged compression guideline draft is available to activate.");
           }
           if (result.reason === "expected_revision_required") {
-            return toolResult(
+            return toolResult2(
               "Activation requires `expectedContentHash` or `expectedGuidelineVersion` so the reviewed draft identity is pinned."
             );
           }
           if (result.reason === "content_hash_mismatch" || result.reason === "draft_changed") {
-            return toolResult(
+            return toolResult2(
               "The staged compression guideline draft changed after review. Re-read the current draft and retry activation with its latest identity."
             );
           }
           if (result.reason === "guideline_version_mismatch") {
-            return toolResult(
+            return toolResult2(
               "The staged draft guidelineVersion no longer matches the reviewed revision. Re-read the current draft and retry activation with its latest identity."
             );
           }
-          return toolResult("Compression guideline draft activation was rejected.");
+          return toolResult2("Compression guideline draft activation was rejected.");
         }
-        return toolResult(
+        return toolResult2(
           [
             "Compression guideline draft activated.",
             `guidelineVersion=${result.guidelineVersion ?? "unknown"}`
@@ -1985,45 +2121,45 @@ Best for:
 - User says "remember that..." or "note that..."
 - Critical corrections or preferences
 - Important decisions or facts`,
-      parameters: Type.Object({
-        content: Type.String({
+      parameters: Type2.Object({
+        content: Type2.String({
           description: "The memory to store \u2014 a clear, standalone statement"
         }),
-        namespace: Type.Optional(
-          Type.String({
+        namespace: Type2.Optional(
+          Type2.String({
             description: "Namespace to store into (v3.0+). Omit to store into defaultNamespace."
           })
         ),
-        category: Type.Optional(
-          Type.String({
+        category: Type2.Optional(
+          Type2.String({
             description: 'Category: "fact", "preference", "correction", "entity", "decision", "relationship", "principle", "commitment", "moment", "skill", "rule", "procedure", "reasoning_trace" (default: "fact")',
             enum: ["fact", "preference", "correction", "entity", "decision", "relationship", "principle", "commitment", "moment", "skill", "rule", "procedure", "reasoning_trace"]
           })
         ),
-        tags: Type.Optional(
-          Type.Array(Type.String(), {
+        tags: Type2.Optional(
+          Type2.Array(Type2.String(), {
             description: "Tags for categorization"
           })
         ),
-        entityRef: Type.Optional(
-          Type.String({
+        entityRef: Type2.Optional(
+          Type2.String({
             description: "Entity reference (e.g., person-jane-doe, project-my-app)"
           })
         ),
-        confidence: Type.Optional(
-          Type.Number({
+        confidence: Type2.Optional(
+          Type2.Number({
             description: "Explicit capture confidence (0-1). Defaults to 0.95.",
             minimum: 0,
             maximum: 1
           })
         ),
-        ttl: Type.Optional(
-          Type.String({
+        ttl: Type2.Optional(
+          Type2.String({
             description: "Optional TTL expression to attach to the stored memory."
           })
         ),
-        sourceReason: Type.Optional(
-          Type.String({
+        sourceReason: Type2.Optional(
+          Type2.String({
             description: "Optional reason code for audit history."
           })
         )
@@ -2043,45 +2179,45 @@ Best for:
       name: "memory_capture",
       label: "Capture Memory",
       description: "Store a validated explicit memory note. Preferred tool for explicit capture modes and operator-controlled memory creation.",
-      parameters: Type.Object({
-        content: Type.String({
+      parameters: Type2.Object({
+        content: Type2.String({
           description: "The memory to store \u2014 one standalone validated statement."
         }),
-        namespace: Type.Optional(
-          Type.String({
+        namespace: Type2.Optional(
+          Type2.String({
             description: "Namespace to store into. Omit to store into defaultNamespace."
           })
         ),
-        category: Type.Optional(
-          Type.String({
+        category: Type2.Optional(
+          Type2.String({
             description: "Memory category.",
             enum: ["fact", "preference", "correction", "entity", "decision", "relationship", "principle", "commitment", "moment", "skill", "rule", "procedure", "reasoning_trace"]
           })
         ),
-        tags: Type.Optional(
-          Type.Array(Type.String(), {
+        tags: Type2.Optional(
+          Type2.Array(Type2.String(), {
             description: "Tags for categorization"
           })
         ),
-        entityRef: Type.Optional(
-          Type.String({
+        entityRef: Type2.Optional(
+          Type2.String({
             description: "Entity reference (e.g., person-jane-doe, project-my-app)"
           })
         ),
-        confidence: Type.Optional(
-          Type.Number({
+        confidence: Type2.Optional(
+          Type2.Number({
             description: "Explicit capture confidence (0-1). Defaults to 0.95.",
             minimum: 0,
             maximum: 1
           })
         ),
-        ttl: Type.Optional(
-          Type.String({
+        ttl: Type2.Optional(
+          Type2.String({
             description: "Optional TTL expression to attach to the stored memory."
           })
         ),
-        sourceReason: Type.Optional(
-          Type.String({
+        sourceReason: Type2.Optional(
+          Type2.String({
             description: "Optional reason code for audit history."
           })
         )
@@ -2101,29 +2237,29 @@ Best for:
       name: "memory_promote",
       label: "Promote Memory To Shared",
       description: "Copy a memory into the shared namespace (v3.0+). This is intended for curated promotion of agent-specific learning into a shared brain.",
-      parameters: Type.Object({
-        memoryId: Type.String({
+      parameters: Type2.Object({
+        memoryId: Type2.String({
           description: "Memory ID (filename without .md), e.g. fact-123"
         }),
-        fromNamespace: Type.Optional(
-          Type.String({
+        fromNamespace: Type2.Optional(
+          Type2.String({
             description: "Source namespace (default: defaultNamespace)."
           })
         ),
-        toNamespace: Type.Optional(
-          Type.String({
+        toNamespace: Type2.Optional(
+          Type2.String({
             description: "Target namespace (default: sharedNamespace)."
           })
         ),
-        note: Type.Optional(
-          Type.String({
+        note: Type2.Optional(
+          Type2.String({
             description: "Optional note explaining why this should be shared (stored as a tag-like annotation)."
           })
         )
       }),
       async execute(_toolCallId, params) {
         if (!orchestrator.config.namespacesEnabled) {
-          return toolResult(
+          return toolResult2(
             "Namespaces are disabled. Enable `namespacesEnabled: true` to use memory promotion."
           );
         }
@@ -2131,7 +2267,7 @@ Best for:
           orchestrator,
           params
         );
-        return toolResult(message);
+        return toolResult2(message);
       }
     },
     { name: "memory_promote" }
@@ -2149,9 +2285,9 @@ Best for:
 - Understanding the user holistically
 - Checking preferences before making decisions
 - "What do you know about me?"`,
-      parameters: Type.Object({
-        namespace: Type.Optional(
-          Type.String({
+      parameters: Type2.Object({
+        namespace: Type2.Optional(
+          Type2.String({
             description: "Optional namespace override. Defaults to the default namespace."
           })
         )
@@ -2161,11 +2297,11 @@ Best for:
         const storage = await orchestrator.getStorageForNamespace(namespace);
         const profile = await storage.readProfile();
         if (!profile) {
-          return toolResult(
+          return toolResult2(
             "No profile built yet. The profile builds automatically through conversations."
           );
         }
-        return toolResult(`## User Profile
+        return toolResult2(`## User Profile
 
 ${profile}`);
       }
@@ -2184,9 +2320,9 @@ Speed: Instant
 Best for:
 - Seeing all known entities
 - Looking up facts about a specific entity`,
-      parameters: Type.Object({
-        name: Type.Optional(
-          Type.String({
+      parameters: Type2.Object({
+        name: Type2.Optional(
+          Type2.String({
             description: "Specific entity to look up (e.g., person-jane-doe)"
           })
         )
@@ -2196,17 +2332,17 @@ Best for:
         if (name) {
           const content = await orchestrator.storage.readEntity(name);
           if (!content) {
-            return toolResult(`Entity "${name}" not found.`);
+            return toolResult2(`Entity "${name}" not found.`);
           }
-          return toolResult(content);
+          return toolResult2(content);
         }
         const entities = await orchestrator.storage.readEntities();
         if (entities.length === 0) {
-          return toolResult(
+          return toolResult2(
             "No entities tracked yet. Entities build automatically through conversations."
           );
         }
-        return toolResult(
+        return toolResult2(
           `## Known Entities (${entities.length})
 
 ${entities.map((e) => `- ${e}`).join("\n")}`
@@ -2228,15 +2364,15 @@ Best for:
 - Seeing what questions have been generated from past conversations
 - Resolving questions that have been answered
 - "What questions do you have for me?"`,
-      parameters: Type.Object({
-        action: Type.Optional(
-          Type.String({
+      parameters: Type2.Object({
+        action: Type2.Optional(
+          Type2.String({
             description: '"list" (default) to show unresolved questions, "all" to show all, "resolve" to mark one as answered',
             enum: ["list", "all", "resolve"]
           })
         ),
-        questionId: Type.Optional(
-          Type.String({
+        questionId: Type2.Optional(
+          Type2.String({
             description: "Question ID to resolve (required when action is 'resolve')"
           })
         )
@@ -2245,15 +2381,15 @@ Best for:
         const { action = "list", questionId } = params;
         if (action === "resolve") {
           if (!questionId) {
-            return toolResult("Error: questionId is required when action is 'resolve'");
+            return toolResult2("Error: questionId is required when action is 'resolve'");
           }
           const resolved = await orchestrator.storage.resolveQuestion(questionId);
-          return toolResult(resolved ? `Question ${questionId} marked as resolved.` : `Question ${questionId} not found.`);
+          return toolResult2(resolved ? `Question ${questionId} marked as resolved.` : `Question ${questionId} not found.`);
         }
         const unresolvedOnly = action !== "all";
         const questions = await orchestrator.storage.readQuestions({ unresolvedOnly });
         if (questions.length === 0) {
-          return toolResult(unresolvedOnly ? "No unresolved questions. Questions are generated automatically during memory extraction." : "No questions found.");
+          return toolResult2(unresolvedOnly ? "No unresolved questions. Questions are generated automatically during memory extraction." : "No questions found.");
         }
         const formatted = questions.map(
           (q, i) => `### [${i + 1}] ${q.id}
@@ -2263,7 +2399,7 @@ ${q.question}
 
 _Context: ${q.context}_`
         ).join("\n\n");
-        return toolResult(`## Questions (${questions.length})
+        return toolResult2(`## Questions (${questions.length})
 
 ${formatted}`);
       }
@@ -2283,9 +2419,9 @@ Best for:
 - Understanding the agent's self-model and growth
 - "What have you learned about yourself?"
 - Reviewing identity development over time`,
-      parameters: Type.Object({
-        namespace: Type.Optional(
-          Type.String({
+      parameters: Type2.Object({
+        namespace: Type2.Optional(
+          Type2.String({
             description: "Optional namespace override. Defaults to the default namespace."
           })
         )
@@ -2295,9 +2431,9 @@ Best for:
         const storage = await orchestrator.getStorageForNamespace(namespace);
         const identity = await storage.readIdentityReflections();
         if (!identity) {
-          return toolResult("No identity reflections found. Identity reflections build automatically through conversations when identityEnabled is true.");
+          return toolResult2("No identity reflections found. Identity reflections build automatically through conversations when identityEnabled is true.");
         }
-        return toolResult(`## Agent Identity
+        return toolResult2(`## Agent Identity
 
 ${identity}`);
       }
@@ -2317,32 +2453,32 @@ Best for:
 - Nightly incremental governance sweeps
 - Manual shadow runs on recent memory windows
 - Small-batch review queue generation without scanning the full corpus at once`,
-      parameters: Type.Object({
-        namespace: Type.Optional(
-          Type.String({
+      parameters: Type2.Object({
+        namespace: Type2.Optional(
+          Type2.String({
             description: "Optional namespace override. Defaults to the default namespace."
           })
         ),
-        mode: Type.Optional(
-          Type.Union([
-            Type.Literal("shadow"),
-            Type.Literal("apply")
+        mode: Type2.Optional(
+          Type2.Union([
+            Type2.Literal("shadow"),
+            Type2.Literal("apply")
           ], {
             description: "Governance mode. Defaults to shadow."
           })
         ),
-        recentDays: Type.Optional(
-          Type.Number({
+        recentDays: Type2.Optional(
+          Type2.Number({
             description: "Only scan memories updated within the last N days."
           })
         ),
-        maxMemories: Type.Optional(
-          Type.Number({
+        maxMemories: Type2.Optional(
+          Type2.Number({
             description: "Maximum number of memories to scan in this run."
           })
         ),
-        batchSize: Type.Optional(
-          Type.Number({
+        batchSize: Type2.Optional(
+          Type2.Number({
             description: "File-read batch size for bounded governance runs."
           })
         )
@@ -2350,7 +2486,7 @@ Best for:
       async execute(_toolCallId, params) {
         const deepSleep = orchestrator.config.dreamsPhases.deepSleep;
         if (deepSleep.enabled === false && deepSleep.enabledExplicitlySet === true) {
-          return toolResult(
+          return toolResult2(
             "Memory governance is disabled by `dreams.phases.deepSleep.enabled=false`."
           );
         }
@@ -2394,13 +2530,13 @@ Best for:
 - Cron job scheduled hourly summarization
 - Manual trigger to summarize recent conversations
 - Building conversation summaries for context preservation`,
-      parameters: Type.Object({}),
+      parameters: Type2.Object({}),
       async execute() {
         try {
           await orchestrator.summarizer.runHourly();
-          return toolResult("Hourly summarization completed. Check the summaries directory for results.");
+          return toolResult2("Hourly summarization completed. Check the summaries directory for results.");
         } catch (err) {
-          return toolResult(`Hourly summarization failed: ${err}`);
+          return toolResult2(`Hourly summarization failed: ${err}`);
         }
       }
     },
@@ -2417,28 +2553,28 @@ This is optional and default-off (see config: conversationIndexEnabled).
 Best for:
 - Cron jobs to keep the conversation index fresh
 - Manual rebuild after changing chunk sizes or retention`,
-      parameters: Type.Object({
-        sessionKey: Type.Optional(
-          Type.String({
+      parameters: Type2.Object({
+        sessionKey: Type2.Optional(
+          Type2.String({
             description: "Session key to index. If omitted, Engram will best-effort scan transcript storage and index all discovered sessionKeys."
           })
         ),
-        hours: Type.Optional(
-          Type.Number({
+        hours: Type2.Optional(
+          Type2.Number({
             description: "How many hours of transcript history to include (default: 24).",
             minimum: 1,
             maximum: 24 * 30
           })
         ),
-        embed: Type.Optional(
-          Type.Boolean({
+        embed: Type2.Optional(
+          Type2.Boolean({
             description: "If true, run QMD embed after update for this invocation. If omitted, uses conversationIndexEmbedOnUpdate config."
           })
         )
       }),
       async execute(_toolCallId, params) {
         if (!orchestrator.config.conversationIndexEnabled) {
-          return toolResult(
+          return toolResult2(
             "Conversation indexing is disabled. Enable `conversationIndexEnabled: true` in the Engram plugin config to use this tool."
           );
         }
@@ -2448,11 +2584,11 @@ Best for:
           const res = await orchestrator.conversationIndexCoordinator.update(sessionKey, h, { embed });
           if (res.skipped && res.reason === "min_interval") {
             const retrySec = Math.max(1, Math.ceil((res.retryAfterMs ?? 0) / 1e3));
-            return toolResult(
+            return toolResult2(
               `Skipped for sessionKey=${sessionKey} due to min interval. Retry in ~${retrySec}s or pass a higher interval config.`
             );
           }
-          return toolResult(
+          return toolResult2(
             `Indexed ${res.chunks} chunk(s) for sessionKey=${sessionKey}.${res.embedded ? " Ran embed." : ""}`
           );
         }
@@ -2472,7 +2608,7 @@ Best for:
         }
         const skippedSummary = skipped > 0 ? ` Skipped ${skipped} session(s) due to min-interval gating: ${skippedIds.slice(0, 6).join(", ")}${skippedIds.length > 6 ? "..." : ""}.` : "";
         const embedSummary = embeddedRuns > 0 ? ` Ran embed for ${embeddedRuns} session update(s).` : "";
-        return toolResult(
+        return toolResult2(
           `Indexed ${total} total chunk(s) across ${sessions.length} session(s).${skippedSummary}${embedSummary}`
         );
       }
@@ -2484,21 +2620,21 @@ Best for:
       name: "work_task",
       label: "Manage Work Tasks",
       description: "Manage Engram work-layer tasks (create, get, list, update, transition, delete). Responses are marked as work-layer context and excluded from default memory extraction.",
-      parameters: Type.Object({
-        action: Type.String({
+      parameters: Type2.Object({
+        action: Type2.String({
           enum: ["create", "get", "list", "update", "transition", "delete"],
           description: "Task action to run."
         }),
-        id: Type.Optional(Type.String({ description: "Task ID for get/update/transition/delete." })),
-        title: Type.Optional(Type.String({ description: "Task title (create/update)." })),
-        description: Type.Optional(Type.String({ description: "Task description (create/update)." })),
-        status: Type.Optional(Type.String({ enum: ["todo", "in_progress", "blocked", "done", "cancelled"] })),
-        priority: Type.Optional(Type.String({ enum: ["low", "medium", "high"] })),
-        owner: Type.Optional(Type.String()),
-        assignee: Type.Optional(Type.String()),
-        projectId: Type.Optional(Type.String()),
-        tags: Type.Optional(Type.Array(Type.String())),
-        dueAt: Type.Optional(Type.String())
+        id: Type2.Optional(Type2.String({ description: "Task ID for get/update/transition/delete." })),
+        title: Type2.Optional(Type2.String({ description: "Task title (create/update)." })),
+        description: Type2.Optional(Type2.String({ description: "Task description (create/update)." })),
+        status: Type2.Optional(Type2.String({ enum: ["todo", "in_progress", "blocked", "done", "cancelled"] })),
+        priority: Type2.Optional(Type2.String({ enum: ["low", "medium", "high"] })),
+        owner: Type2.Optional(Type2.String()),
+        assignee: Type2.Optional(Type2.String()),
+        projectId: Type2.Optional(Type2.String()),
+        tags: Type2.Optional(Type2.Array(Type2.String())),
+        dueAt: Type2.Optional(Type2.String())
       }),
       async execute(_toolCallId, params) {
         const p = params;
@@ -2606,19 +2742,19 @@ Best for:
       name: "work_project",
       label: "Manage Work Projects",
       description: "Manage Engram work-layer projects (create, get, list, update, delete, link_task). Responses are marked as work-layer context and excluded from default memory extraction.",
-      parameters: Type.Object({
-        action: Type.String({
+      parameters: Type2.Object({
+        action: Type2.String({
           enum: ["create", "get", "list", "update", "delete", "link_task"],
           description: "Project action to run."
         }),
-        id: Type.Optional(Type.String({ description: "Project ID for get/update/delete." })),
-        name: Type.Optional(Type.String({ description: "Project name (create/update)." })),
-        description: Type.Optional(Type.String({ description: "Project description (create/update)." })),
-        status: Type.Optional(Type.String({ enum: ["active", "on_hold", "completed", "archived"] })),
-        owner: Type.Optional(Type.String()),
-        tags: Type.Optional(Type.Array(Type.String())),
-        taskId: Type.Optional(Type.String({ description: "Task ID for link_task action." })),
-        projectId: Type.Optional(Type.String({ description: "Project ID for link_task action." }))
+        id: Type2.Optional(Type2.String({ description: "Project ID for get/update/delete." })),
+        name: Type2.Optional(Type2.String({ description: "Project name (create/update)." })),
+        description: Type2.Optional(Type2.String({ description: "Project description (create/update)." })),
+        status: Type2.Optional(Type2.String({ enum: ["active", "on_hold", "completed", "archived"] })),
+        owner: Type2.Optional(Type2.String()),
+        tags: Type2.Optional(Type2.Array(Type2.String())),
+        taskId: Type2.Optional(Type2.String({ description: "Task ID for link_task action." })),
+        projectId: Type2.Optional(Type2.String({ description: "Project ID for link_task action." }))
       }),
       async execute(_toolCallId, params) {
         const p = params;
@@ -2700,15 +2836,15 @@ Best for:
       name: "work_board",
       label: "Work Board Import/Export",
       description: "Export/import work-layer board snapshots and markdown. Outputs are marked as work-layer context and excluded from default memory extraction unless explicitly linked.",
-      parameters: Type.Object({
-        action: Type.String({
+      parameters: Type2.Object({
+        action: Type2.String({
           enum: ["export_markdown", "export_snapshot", "import_snapshot"],
           description: "Board action to run."
         }),
-        projectId: Type.Optional(Type.String({ description: "Optional project filter/id." })),
-        snapshotJson: Type.Optional(Type.String({ description: "Snapshot JSON payload for import_snapshot." })),
-        linkToMemory: Type.Optional(
-          Type.Boolean({
+        projectId: Type2.Optional(Type2.String({ description: "Optional project filter/id." })),
+        snapshotJson: Type2.Optional(Type2.String({ description: "Snapshot JSON payload for import_snapshot." })),
+        linkToMemory: Type2.Optional(
+          Type2.Boolean({
             description: "If true, wrap output as linkable work context so extraction can retain it as long-term memory."
           })
         )
@@ -2722,7 +2858,7 @@ Best for:
           await new WorkStorage(orchestrator.config.memoryDir).ensureDirectories();
           if (action === "export_markdown") {
             const markdown = await exportWorkBoardMarkdown({ memoryDir: orchestrator.config.memoryDir, projectId });
-            return toolResult(wrapWorkLayerContext(markdown, { linkToMemory }));
+            return toolResult2(wrapWorkLayerContext(markdown, { linkToMemory }));
           }
           if (action === "export_snapshot") {
             const snapshot = await exportWorkBoardSnapshot({ memoryDir: orchestrator.config.memoryDir, projectId });
@@ -2750,193 +2886,28 @@ Best for:
     },
     { name: "work_board" }
   );
-  api.registerTool(
-    {
-      name: "shared_context_write_output",
-      label: "Write Shared Agent Output",
-      description: "Write an agent work product into the shared-context directory (v4.0). Other agents can read these files to coordinate without explicit message passing.",
-      parameters: Type.Object({
-        // Provenance is server-derived from the host runtime agent; a
-        // mismatching value here is rejected, never used as the origin.
-        agentId: Type.String({ description: "Agent ID producing this output; must match this host's runtime agent id when the host exposes one." }),
-        title: Type.String({ description: "Short title for the output." }),
-        content: Type.String({ description: "Markdown content to write." })
-      }),
-      async execute(_toolCallId, params) {
-        const { agentId, title, content } = params;
-        if (!orchestrator.sharedContext) {
-          return toolResult(
-            "Shared context is disabled. Enable `sharedContextEnabled: true` to use shared-context tools."
-          );
-        }
-        try {
-          const fp = await orchestrator.sharedContext.writeAgentOutput({
-            title,
-            content,
-            ...openClawToolWriteOrigin(hostRuntimeAgentId, agentId)
-          });
-          return toolResult(`Wrote shared agent output: ${fp}`);
-        } catch (err) {
-          return toolResult(`shared_context_write_output error: ${err instanceof Error ? err.message : String(err)}`);
-        }
-      }
-    },
-    { name: "shared_context_write_output" }
-  );
-  api.registerTool(
-    {
-      name: "shared_feedback_record",
-      label: "Record Shared Feedback",
-      description: "Append an approval/rejection decision into shared-context feedback inbox (v4.0/v5.0). Intended to power compounding learning.",
-      parameters: Type.Object({
-        agent: Type.String({ description: "Agent name that produced the recommendation/output." }),
-        decision: Type.String({
-          enum: ["approved", "approved_with_feedback", "rejected"],
-          description: "Decision outcome."
-        }),
-        reason: Type.String({ description: "Why the decision was made (short but specific)." }),
-        date: Type.Optional(Type.String({ description: "ISO timestamp. Defaults to now." })),
-        learning: Type.Optional(Type.String({ description: "Optional distilled learning/pattern." })),
-        outcome: Type.Optional(Type.String({ description: "Optional downstream outcome (day-one supported; may be empty initially)." })),
-        severity: Type.Optional(Type.String({
-          enum: ["low", "medium", "high"],
-          description: "Optional severity rating for the mistake/outcome."
-        })),
-        confidence: Type.Optional(Type.Number({ description: "Optional confidence score from 0 to 1." })),
-        workflow: Type.Optional(Type.String({ description: "Optional workflow or playbook name associated with the feedback." })),
-        tags: Type.Optional(Type.Array(Type.String(), { description: "Optional tags for rubric grouping and recall matching." })),
-        evidenceWindowStart: Type.Optional(Type.String({ description: "Optional start timestamp for the evidence window." })),
-        evidenceWindowEnd: Type.Optional(Type.String({ description: "Optional end timestamp for the evidence window." })),
-        refs: Type.Optional(Type.Array(Type.String(), { description: "Optional references (URLs, IDs, filenames)." }))
-      }),
-      async execute(_toolCallId, params) {
-        if (!orchestrator.sharedContext) {
-          return toolResult(
-            "Shared context is disabled. Enable `sharedContextEnabled: true` to record shared feedback."
-          );
-        }
-        const p = params;
-        const entry = {
-          agent: String(p.agent ?? ""),
-          decision: p.decision,
-          reason: String(p.reason ?? ""),
-          date: typeof p.date === "string" && p.date.length > 0 ? p.date : (/* @__PURE__ */ new Date()).toISOString(),
-          learning: typeof p.learning === "string" ? p.learning : void 0,
-          outcome: typeof p.outcome === "string" ? p.outcome : void 0,
-          severity: p.severity === "low" || p.severity === "medium" || p.severity === "high" ? p.severity : void 0,
-          confidence: typeof p.confidence === "number" && Number.isFinite(p.confidence) ? p.confidence : void 0,
-          workflow: typeof p.workflow === "string" ? p.workflow : void 0,
-          tags: Array.isArray(p.tags) ? p.tags.map(String) : void 0,
-          evidenceWindowStart: typeof p.evidenceWindowStart === "string" ? p.evidenceWindowStart : void 0,
-          evidenceWindowEnd: typeof p.evidenceWindowEnd === "string" ? p.evidenceWindowEnd : void 0,
-          refs: Array.isArray(p.refs) ? p.refs.map(String) : void 0
-        };
-        await orchestrator.sharedContext.appendFeedback(entry);
-        return toolResult("OK");
-      }
-    },
-    { name: "shared_feedback_record" }
-  );
-  api.registerTool(
-    {
-      name: "shared_priorities_append",
-      label: "Append Priorities Inbox",
-      description: "Append text into shared-context priorities inbox. A curator run should merge this into priorities.md.",
-      parameters: Type.Object({
-        agentId: Type.String({ description: "Agent ID appending priorities." }),
-        text: Type.String({ description: "Priority notes to append (markdown)." })
-      }),
-      async execute(_toolCallId, params) {
-        if (!orchestrator.sharedContext) {
-          return toolResult(
-            "Shared context is disabled. Enable `sharedContextEnabled: true` to write priorities inbox."
-          );
-        }
-        const { agentId, text } = params;
-        await orchestrator.sharedContext.appendPrioritiesInbox({ agentId, text });
-        return toolResult("OK");
-      }
-    },
-    { name: "shared_priorities_append" }
-  );
-  api.registerTool(
-    {
-      name: "shared_context_cross_signals_run",
-      label: "Run Cross-Signal Synthesis",
-      description: "Generate today's shared-context cross-signal markdown + JSON artifacts on demand, without requiring a full roundtable curation pass.",
-      parameters: Type.Object({
-        date: Type.Optional(Type.String({ description: "YYYY-MM-DD. Defaults to today." }))
-      }),
-      async execute(_toolCallId, params) {
-        if (!orchestrator.sharedContext) {
-          return toolResult(
-            "Shared context is disabled. Enable `sharedContextEnabled: true` to synthesize cross-signals."
-          );
-        }
-        const { date } = params;
-        const result = await orchestrator.sharedContext.synthesizeCrossSignals({ date });
-        return toolResult(
-          [
-            `Cross-signals markdown: ${result.crossSignalsMarkdownPath}`,
-            `Cross-signals JSON: ${result.crossSignalsPath}`,
-            `Source outputs analyzed: ${result.report.sourceCount}`,
-            `Feedback entries analyzed: ${result.report.feedbackCount}`,
-            `Overlap count: ${result.overlapCount}`
-          ].join("\n")
-        );
-      }
-    },
-    { name: "shared_context_cross_signals_run" }
-  );
-  api.registerTool(
-    {
-      name: "shared_context_curate_daily",
-      label: "Curate Daily Roundtable",
-      description: "Curator tool: generate today's roundtable summary in shared-context/roundtable (deterministic baseline).",
-      parameters: Type.Object({
-        date: Type.Optional(Type.String({ description: "YYYY-MM-DD. Defaults to today." }))
-      }),
-      async execute(_toolCallId, params) {
-        if (!orchestrator.sharedContext) {
-          return toolResult(
-            "Shared context is disabled. Enable `sharedContextEnabled: true` to curate roundtables."
-          );
-        }
-        const { date } = params;
-        const result = await orchestrator.sharedContext.curateDaily({ date });
-        return toolResult(
-          [
-            `Roundtable: ${result.roundtablePath}`,
-            `Cross-signals markdown: ${result.crossSignalsMarkdownPath}`,
-            `Cross-signals JSON: ${result.crossSignalsPath}`,
-            `Overlap count: ${result.overlapCount}`
-          ].join("\n")
-        );
-      }
-    },
-    { name: "shared_context_curate_daily" }
-  );
+  registerSharedContextTools(api, orchestrator, hostRuntimeAgentId);
   api.registerTool(
     {
       name: "compounding_weekly_synthesize",
       label: "Synthesize Weekly Learning",
       description: "Generate weekly compounding outputs (v5.0): weekly markdown + JSON reports, stable mistake registry, and rubric artifacts. Designed to work from day one (writes even if no feedback exists yet).",
-      parameters: Type.Object({
-        weekId: Type.Optional(
-          Type.String({
+      parameters: Type2.Object({
+        weekId: Type2.Optional(
+          Type2.String({
             description: "ISO week ID like YYYY-Www. Omit to use current week."
           })
         )
       }),
       async execute(_toolCallId, params) {
         if (!orchestrator.compounding) {
-          return toolResult(
+          return toolResult2(
             "Compounding engine is disabled. Enable `compoundingEnabled: true` to use this tool."
           );
         }
         const { weekId } = params;
         const res = await orchestrator.compounding.synthesizeWeekly({ weekId });
-        return toolResult(
+        return toolResult2(
           `OK
 
 weekId: ${res.weekId}
@@ -2956,26 +2927,26 @@ promotionCandidates: ${res.promotionCandidateCount}`
       name: "compounding_promote_candidate",
       label: "Promote Compounding Candidate",
       description: "Persist one advisory compounding promotion candidate into durable rule/principle memory. Never auto-promotes; this is an explicit operator action.",
-      parameters: Type.Object({
-        weekId: Type.String({
+      parameters: Type2.Object({
+        weekId: Type2.String({
           description: "ISO week ID like YYYY-Www matching the synthesized weekly artifact."
         }),
-        candidateId: Type.String({
+        candidateId: Type2.String({
           description: "Promotion candidate id from the weekly compounding report or JSON artifact."
         }),
-        dryRun: Type.Optional(Type.Boolean({
+        dryRun: Type2.Optional(Type2.Boolean({
           description: "If true, preview the promoted guidance without writing memory."
         }))
       }),
       async execute(_toolCallId, params) {
         if (!orchestrator.compounding) {
-          return toolResult(
+          return toolResult2(
             "Compounding engine is disabled. Enable `compoundingEnabled: true` to use this tool."
           );
         }
         const { weekId, candidateId, dryRun } = params;
         const result = await orchestrator.compounding.promoteCandidate({ weekId, candidateId, dryRun });
-        return toolResult(JSON.stringify(result, null, 2));
+        return toolResult2(JSON.stringify(result, null, 2));
       }
     },
     { name: "compounding_promote_candidate" }
@@ -2991,14 +2962,14 @@ Requires profilingEnabled: true in plugin config.
 Shows per-step timing with parallel vs sequential structure, bottleneck identification, and aggregate stats.
 
 Returns: Performance trace data with timing breakdown`,
-      parameters: Type.Object({
-        format: Type.Optional(
-          Type.String({
+      parameters: Type2.Object({
+        format: Type2.Optional(
+          Type2.String({
             description: 'Output format: "ascii" for human-readable or "json" for structured data'
           })
         ),
-        limit: Type.Optional(
-          Type.Number({
+        limit: Type2.Optional(
+          Type2.Number({
             description: "Number of recent traces to include (1-20, default 5)",
             minimum: 1,
             maximum: 20
@@ -3008,7 +2979,7 @@ Returns: Performance trace data with timing breakdown`,
       async execute(_toolCallId, params) {
         const profiler = orchestrator.profiler;
         if (!profiler.isEnabled) {
-          return toolResult(
+          return toolResult2(
             "Profiling is disabled. Set profilingEnabled: true in your plugin config to enable."
           );
         }
@@ -3018,7 +2989,7 @@ Returns: Performance trace data with timing breakdown`,
         const stats = profiler.getStats();
         const bottleneck = profiler.identifyBottleneck();
         if (format === "json") {
-          return toolResult(JSON.stringify({ traces, stats, bottleneck }, null, 2));
+          return toolResult2(JSON.stringify({ traces, stats, bottleneck }, null, 2));
         }
         const lines = [];
         lines.push("Engram Profiling Report");
@@ -3052,7 +3023,7 @@ Returns: Performance trace data with timing breakdown`,
             lines.push("");
           }
         }
-        return toolResult(lines.join("\n"));
+        return toolResult2(lines.join("\n"));
       }
     },
     { name: "remnic_profiling_report" }
@@ -3062,14 +3033,14 @@ Returns: Performance trace data with timing breakdown`,
       name: "engram_profiling_report",
       label: "Profiling Report",
       description: `Legacy alias for remnic_profiling_report.`,
-      parameters: Type.Object({
-        format: Type.Optional(
-          Type.String({
+      parameters: Type2.Object({
+        format: Type2.Optional(
+          Type2.String({
             description: 'Output format: "ascii" for human-readable or "json" for structured data'
           })
         ),
-        limit: Type.Optional(
-          Type.Number({
+        limit: Type2.Optional(
+          Type2.Number({
             description: "Number of recent traces to include (1-20, default 5)",
             minimum: 1,
             maximum: 20
@@ -3079,7 +3050,7 @@ Returns: Performance trace data with timing breakdown`,
       async execute(_toolCallId, params) {
         const profiler = orchestrator.profiler;
         if (!profiler.isEnabled) {
-          return toolResult(
+          return toolResult2(
             "Profiling is disabled. Set profilingEnabled: true in your plugin config to enable."
           );
         }
@@ -3089,7 +3060,7 @@ Returns: Performance trace data with timing breakdown`,
         const stats = profiler.getStats();
         const bottleneck = profiler.identifyBottleneck();
         if (format === "json") {
-          return toolResult(JSON.stringify({ traces, stats, bottleneck }, null, 2));
+          return toolResult2(JSON.stringify({ traces, stats, bottleneck }, null, 2));
         }
         const lines = [];
         lines.push("Engram Profiling Report");
@@ -3123,7 +3094,7 @@ Returns: Performance trace data with timing breakdown`,
             lines.push("");
           }
         }
-        return toolResult(lines.join("\n"));
+        return toolResult2(lines.join("\n"));
       }
     },
     { name: "engram_profiling_report" }
@@ -3138,16 +3109,8 @@ import {
   FallbackLlmClient as FallbackLlmClient2,
   fallbackLlmRuntimeContextFromConfig as fallbackLlmRuntimeContextFromConfig2
 } from "@remnic/core/fallback-llm";
-
-// ../../src/objective-state.ts
-var objective_state_exports = {};
-__reExport(objective_state_exports, objective_state_star);
-import * as objective_state_star from "@remnic/core/objective-state";
-
-// ../../src/objective-state-writers.ts
-var objective_state_writers_exports = {};
-__reExport(objective_state_writers_exports, objective_state_writers_star);
-import * as objective_state_writers_star from "@remnic/core/objective-state-writers";
+import { objectiveStateStoreOverrideForNamespace } from "@remnic/core/objective-state";
+import { recordObjectiveStateSnapshotsFromAgentMessages } from "@remnic/core/objective-state-writers";
 
 // ../../src/qmd-availability-probe.ts
 async function probeQmdAvailability(host) {
@@ -3196,27 +3159,14 @@ var EngramAccessService = class extends CoreEngramAccessService {
   }
 };
 
-// ../../src/access-http.ts
-var access_http_exports = {};
-__reExport(access_http_exports, access_http_star);
-import * as access_http_star from "@remnic/core/access-http";
-
 // ../../src/index.ts
+import { EngramAccessHttpServer } from "@remnic/core/access-http";
 import path11 from "path";
 import os from "os";
-
-// ../../src/opik-exporter.ts
-import { createOpikExporter, OpikExporter } from "@remnic/core/opik-exporter";
-
-// ../../src/index.ts
+import { createOpikExporter } from "@remnic/core/opik-exporter";
 import { readEnvVar, resolveHomeDir as resolveHomeDir3 } from "@remnic/core/runtime/env";
 import { displayErrorDetail as displayErrorDetail2 } from "@remnic/core/runtime/better-sqlite";
-
-// ../../src/migrate/from-engram.ts
-import {
-  migrateFromEngram,
-  rollbackFromEngramMigration
-} from "@remnic/core/migrate/from-engram";
+import { migrateFromEngram } from "@remnic/core/migrate/from-engram";
 
 // ../../src/user-message-cleaning.ts
 import { cleanUserMessageWithPattern } from "@remnic/core/user-message-cleaning";
@@ -3403,17 +3353,17 @@ import {
 } from "@remnic/core";
 
 // src/openclaw-tools/shapes.ts
-import { Type as Type2 } from "@sinclair/typebox";
-var MemorySearchInputSchema = Type2.Object({
-  query: Type2.String(),
-  limit: Type2.Optional(Type2.Number({ minimum: 1, maximum: 50 })),
-  sessionKey: Type2.Optional(Type2.String()),
-  filters: Type2.Optional(Type2.Record(Type2.String(), Type2.Unknown()))
+import { Type as Type3 } from "@sinclair/typebox";
+var MemorySearchInputSchema = Type3.Object({
+  query: Type3.String(),
+  limit: Type3.Optional(Type3.Number({ minimum: 1, maximum: 50 })),
+  sessionKey: Type3.Optional(Type3.String()),
+  filters: Type3.Optional(Type3.Record(Type3.String(), Type3.Unknown()))
 });
-var MemoryGetInputSchema = Type2.Object({
-  id: Type2.String(),
-  sessionKey: Type2.Optional(Type2.String()),
-  namespace: Type2.Optional(Type2.String())
+var MemoryGetInputSchema = Type3.Object({
+  id: Type3.String(),
+  sessionKey: Type3.Optional(Type3.String()),
+  namespace: Type3.Optional(Type3.String())
 });
 
 // src/openclaw-tools/tool-json-result.ts
@@ -9263,7 +9213,7 @@ async function loadOpenClawProviderAuthRuntimeModule() {
         if (typeof mod.resolveApiKeyForProvider === "function" || typeof mod.getRuntimeAuthForModel === "function") {
           providerAuthRuntimeModule = mod;
           providerAuthRuntimeLoaded = true;
-          logger_exports.log.debug("loaded OpenClaw provider auth runtime module");
+          log8.debug("loaded OpenClaw provider auth runtime module");
           return providerAuthRuntimeModule;
         }
       } catch {
@@ -9272,7 +9222,7 @@ async function loadOpenClawProviderAuthRuntimeModule() {
   } catch {
   }
   providerAuthRuntimeNextRetryAt = Date.now() + SECRET_REF_RESOLVER_RETRY_BACKOFF_MS;
-  logger_exports.log.debug(
+  log8.debug(
     `OpenClaw provider auth runtime not available \u2014 will retry after ${SECRET_REF_RESOLVER_RETRY_BACKOFF_MS / 1e3}s`
   );
   return null;
@@ -9311,7 +9261,7 @@ async function loadOpenClawSecretRefResolver() {
             if (typeof fn === "function") {
               secretRefResolver = fn;
               secretRefResolverLoaded = true;
-              logger_exports.log.debug(
+              log8.debug(
                 `loaded OpenClaw SecretRef resolver "${exportName}" from ${prefix}*.js`
               );
               return secretRefResolver;
@@ -9324,7 +9274,7 @@ async function loadOpenClawSecretRefResolver() {
   } catch {
   }
   secretRefResolverNextRetryAt = Date.now() + SECRET_REF_RESOLVER_RETRY_BACKOFF_MS;
-  logger_exports.log.debug(
+  log8.debug(
     `OpenClaw SecretRef resolver not available \u2014 will retry after ${SECRET_REF_RESOLVER_RETRY_BACKOFF_MS / 1e3}s`
   );
   return null;
@@ -9367,7 +9317,7 @@ function loadPluginEntryFromFile(pluginId) {
     const config = JSON.parse(content);
     return resolveRemnicPluginEntry(config, pluginId);
   } catch (err) {
-    logger_exports.log.warn(`Failed to load config from file: ${err}`);
+    log8.warn(`Failed to load config from file: ${err}`);
     return void 0;
   }
 }
@@ -9385,7 +9335,7 @@ function loadRawConfigFromFile() {
     const config = JSON.parse(content);
     return config && typeof config === "object" ? config : void 0;
   } catch (err) {
-    logger_exports.log.warn(`Failed to load raw OpenClaw config from file: ${err}`);
+    log8.warn(`Failed to load raw OpenClaw config from file: ${err}`);
     return void 0;
   }
 }
@@ -9400,7 +9350,7 @@ async function maybeRegisterLiveConnectorCron(orchestrator) {
   const jobsPath = path11.join(resolveHomeDir3(), ".openclaw", "cron", "jobs.json");
   try {
     if (!fileExistsNow(jobsPath)) {
-      logger_exports.log.debug("live connectors cron: jobs.json not found, skipping auto-register");
+      log8.debug("live connectors cron: jobs.json not found, skipping auto-register");
       return;
     }
     const result = await ensureLiveConnectorCron(jobsPath, {
@@ -9408,12 +9358,12 @@ async function maybeRegisterLiveConnectorCron(orchestrator) {
       connectors: orchestrator.config.connectors
     });
     if (result.created || result.updated) {
-      logger_exports.log.info(`live connectors cron ${result.created ? "auto-registered" : "reconciled"} (${result.jobId})`);
+      log8.info(`live connectors cron ${result.created ? "auto-registered" : "reconciled"} (${result.jobId})`);
     } else {
-      logger_exports.log.debug("live connectors cron already exists, skipping auto-register");
+      log8.debug("live connectors cron already exists, skipping auto-register");
     }
   } catch (err) {
-    logger_exports.log.debug(`live connectors cron auto-register error: ${err}`);
+    log8.debug(`live connectors cron auto-register error: ${err}`);
   }
 }
 function isBundledActiveMemoryEnabledForAgent(runtimeConfig, fileBackedRuntimeConfig, agentId) {
@@ -9582,13 +9532,13 @@ function registerOpenClawHostEmbeddingProvider(params) {
     }).then((result) => {
       providerInstance = result && typeof result === "object" ? result.provider ?? null : null;
       if (!providerInstance) {
-        logger_exports.log.debug(
+        log8.debug(
           `OpenClaw host embedding provider ${selected.adapter.id} did not create a provider; using Remnic fallback embeddings`
         );
       }
       return providerInstance;
     }).catch((error) => {
-      logger_exports.log.debug(
+      log8.debug(
         `OpenClaw host embedding provider ${selected.adapter.id} unavailable: ${error}`
       );
       return null;
@@ -9620,7 +9570,7 @@ function registerOpenClawHostEmbeddingProvider(params) {
     }
   };
   const unregister = registerHostEmbeddingProvider(cfg.memoryDir, hostProvider);
-  logger_exports.log.info(
+  log8.info(
     `registered OpenClaw host embedding provider bridge (${selected.adapter.id}) for ${serviceId}`
   );
   return unregister;
@@ -9773,13 +9723,13 @@ var pluginDefinition = {
     const registerThis = typeof this === "object" && this !== null ? this : void 0;
     const serviceId = typeof registerThis?.id === "string" && registerThis.id.trim().length > 0 ? registerThis.id : REMNIC_OPENCLAW_PLUGIN_ID;
     const keys = buildServiceKeys(serviceId);
-    (0, logger_exports.initLogger)(api.logger, false);
+    initLogger(api.logger, false);
     sdkCaps = detectSdkCapabilities(api);
-    logger_exports.log.info(
+    log8.info(
       `SDK detection: version=${sdkCaps.sdkVersion}, beforePromptBuild=${sdkCaps.hasBeforePromptBuild}, memoryPromptSection=${sdkCaps.hasRegisterMemoryPromptSection}, memoryCapability=${sdkCaps.hasRegisterMemoryCapability}, typedHooks=${sdkCaps.hasTypedHooks}`
     );
     if (isNonRuntimeRegistrationMode(sdkCaps.registrationMode)) {
-      logger_exports.log.info(
+      log8.info(
         `registrationMode=${sdkCaps.registrationMode} \u2014 skipping runtime initialization`
       );
       return;
@@ -9788,9 +9738,9 @@ var pluginDefinition = {
     if (!disableRegisterMigration) {
       const migrationPromise = globalThis[ENGRAM_MIGRATION_PROMISE] ??= migrateFromEngram({
         quiet: true,
-        logger: (message) => logger_exports.log.info(message)
+        logger: (message) => log8.info(message)
       }).catch((error) => {
-        logger_exports.log.warn(`register migration failed: ${error}`);
+        log8.warn(`register migration failed: ${error}`);
       });
       void migrationPromise;
     }
@@ -9801,7 +9751,7 @@ var pluginDefinition = {
       ...fileConfig,
       ...api.pluginConfig
     };
-    const cfg = (0, config_exports.parseConfig)(
+    const cfg = parseConfig(
       {
         ...rawPluginConfig,
         gatewayConfig: api.config
@@ -9823,11 +9773,11 @@ var pluginDefinition = {
     );
     cfg.providerApiKeyResolver = resolveOpenClawProviderApiKey;
     cfg.runtimeAuthForModelResolver = getOpenClawRuntimeAuthForModel;
-    (0, logger_exports.initLogger)(api.logger, cfg.debug);
-    logger_exports.log.info(
+    initLogger(api.logger, cfg.debug);
+    log8.info(
       `initialized (debug=${cfg.debug}, qmdEnabled=${cfg.qmdEnabled}, transcriptEnabled=${cfg.transcriptEnabled}, hourlySummariesEnabled=${cfg.hourlySummariesEnabled})`
     );
-    logger_exports.log.debug(
+    log8.debug(
       `init llm routing (modelSource=${cfg.modelSource}, localLlmEnabled=${cfg.localLlmEnabled}${cfg.localLlmFastEnabled ? `, fastLlm=${cfg.localLlmFastModel || "(primary)"}` : ""})`
     );
     const fileBackedRawRuntimeConfig = loadRawConfigFromFile();
@@ -9841,7 +9791,7 @@ var pluginDefinition = {
     });
     const passiveMode = slotValidationMode === "passive";
     if (passiveMode) {
-      logger_exports.log.info(
+      log8.info(
         `[remnic] memory slot not assigned to ${serviceId}; running passively`
       );
     }
@@ -9923,14 +9873,14 @@ var pluginDefinition = {
     }
     const hookApis = globalThis[keys.HOOK_APIS] ??= /* @__PURE__ */ new WeakSet();
     if (hookApis.has(api)) {
-      logger_exports.log.debug(
+      log8.debug(
         "register: this api already has hooks bound \u2014 skipping duplicate hook registration"
       );
       return;
     }
     hookApis.add(api);
     if (!isFirstRegistration) {
-      logger_exports.log.debug(
+      log8.debug(
         "register called again (new registry); re-registering hooks with shared orchestrator"
       );
     }
@@ -9951,7 +9901,7 @@ var pluginDefinition = {
     };
     const authTokensFromSecretRef = () => accessHttpAuthState.resolvedSecretRefAuthToken ? [accessHttpAuthState.resolvedSecretRefAuthToken] : [];
     const existingAccessHttpServer = globalThis[keys.ACCESS_HTTP_SERVER];
-    const accessHttpServer = existingAccessHttpServer && existingAccessHttpServer ? existingAccessHttpServer : new access_http_exports.EngramAccessHttpServer({
+    const accessHttpServer = existingAccessHttpServer && existingAccessHttpServer ? existingAccessHttpServer : new EngramAccessHttpServer({
       service: accessService,
       host: cfg.agentAccessHttp.host,
       port: cfg.agentAccessHttp.port,
@@ -10014,7 +9964,7 @@ var pluginDefinition = {
       }
       const remainingMs = Math.max(0, deadlineMs - Date.now());
       if (remainingMs === 0) {
-        logger_exports.log.warn(
+        log8.warn(
           `OpenClaw flush-plan processing timed out before queue wait for ${reason}`
         );
         return Promise.resolve();
@@ -10024,7 +9974,7 @@ var pluginDefinition = {
         task,
         new Promise((resolve) => {
           timeout = setTimeout(() => {
-            logger_exports.log.warn(
+            log8.warn(
               `OpenClaw flush-plan processing timed out while waiting for ${reason}; current drain remains fenced until it settles`
             );
             resolve();
@@ -10036,7 +9986,7 @@ var pluginDefinition = {
     }
     async function runOpenClawFlushPlanProcessing(reason, workspaceRoot, deadlineMs) {
       if (typeof deadlineMs === "number" && Date.now() >= deadlineMs) {
-        logger_exports.log.warn(
+        log8.warn(
           `OpenClaw flush-plan processing timed out before starting for ${reason}`
         );
         return;
@@ -10048,26 +9998,26 @@ var pluginDefinition = {
           serviceId,
           ingestor: orchestrator,
           logger: {
-            debug: (message) => logger_exports.log.debug(message),
-            info: (message) => logger_exports.log.info(message),
-            warn: (message) => logger_exports.log.warn(message)
+            debug: (message) => log8.debug(message),
+            info: (message) => log8.info(message),
+            warn: (message) => log8.warn(message)
           },
           reason,
           deadlineMs,
           maxTurnChars: cfg.extractionMaxTurnChars
         });
         if (result.status === "processed" || result.status === "processed_preserved_tail" || result.status === "processed_marker_recovered" || result.status === "processed_marker_recovered_tail" || result.status === "processed_cleanup_deferred") {
-          logger_exports.log.info(
+          log8.info(
             `OpenClaw flush-plan ${result.status}: ${result.bytesProcessed ?? 0} bytes` + (result.preservedBytes ? ` (${result.preservedBytes} bytes preserved)` : "")
           );
         } else if (result.status === "skipped") {
-          logger_exports.log.warn(
+          log8.warn(
             `OpenClaw flush-plan processing skipped: ${result.reason ?? "unknown reason"}`
           );
         }
       } catch (error) {
         const detail = displayErrorDetail2(error) || "unknown error";
-        logger_exports.log.warn(`OpenClaw flush-plan processing failed: ${detail}`);
+        log8.warn(`OpenClaw flush-plan processing failed: ${detail}`);
       }
     }
     async function queueOpenClawFlushPlanProcessing(reason, runtimeWorkspaceDir, options = {}) {
@@ -10148,7 +10098,7 @@ var pluginDefinition = {
                 });
               },
               logger: {
-                debug: (message) => logger_exports.log.debug(message)
+                debug: (message) => log8.debug(message)
               }
             });
           }
@@ -10160,7 +10110,7 @@ var pluginDefinition = {
       if (!cfg.dreaming.enabled) return;
       const route = resolveDreamNarrativeRoute(cfg, !!dreamNarrativeClient);
       if (route.kind === "skip") {
-        logger_exports.log.debug(
+        log8.debug(
           "dreaming narrative skipped: no LLM available (set openaiApiKey or use modelSource=gateway)"
         );
         return;
@@ -10191,7 +10141,7 @@ Keep the reflection grounded in the evidence below.
             fallbackLlmRuntimeContextFromConfig2(cfg)
           );
           if (!route.hasExplicitModel && !llm.isAvailable(route.options)) {
-            logger_exports.log.debug(
+            log8.debug(
               "dreaming narrative skipped: no gateway model configured (set dreaming.narrativeModel or taskModelChain)"
             );
             return;
@@ -10215,7 +10165,7 @@ Keep the reflection grounded in the evidence below.
           rawNarrative = typeof response.output_text === "string" ? response.output_text : JSON.stringify(response.output_text ?? "");
         }
       } catch (error) {
-        logger_exports.log.warn(`dreaming narrative generation failed: ${String(error)}`);
+        log8.warn(`dreaming narrative generation failed: ${String(error)}`);
         return;
       }
       const parsed = parseDreamNarrativeResponse(
@@ -10235,7 +10185,7 @@ Keep the reflection grounded in the evidence below.
       recallAuditDir,
       cfg.recallTranscriptRetentionDays
     ).catch((error) => {
-      logger_exports.log.debug(`recall audit prune failed: ${String(error)}`);
+      log8.debug(`recall audit prune failed: ${String(error)}`);
     });
     const sessionCommandDescriptors = buildSessionCommandDescriptors(serviceId, {
       toggles: sessionToggleStore,
@@ -10682,7 +10632,7 @@ Keep the reflection grounded in the evidence below.
           return;
         }
         if (typeof orchestrator.flushSession !== "function") {
-          logger_exports.log.warn("codexCompat provider-switch flush unavailable; preserving binding");
+          log8.warn("codexCompat provider-switch flush unavailable; preserving binding");
           return;
         }
         try {
@@ -10692,7 +10642,7 @@ Keep the reflection grounded in the evidence below.
           });
           forgetCodexThread2(sessionKey, sessionIdentity.previousCodexThreadId);
         } catch (error) {
-          logger_exports.log.warn(`codexCompat provider-switch flush failed: ${String(error)}`);
+          log8.warn(`codexCompat provider-switch flush failed: ${String(error)}`);
         }
       }
       async function flushAndForgetRememberedCodexThreadOnMetadataLoss(sessionKey, sessionIdentity) {
@@ -10710,7 +10660,7 @@ Keep the reflection grounded in the evidence below.
           return;
         }
         if (typeof orchestrator.flushSession !== "function") {
-          logger_exports.log.warn("codexCompat metadata-loss flush unavailable; preserving binding");
+          log8.warn("codexCompat metadata-loss flush unavailable; preserving binding");
           return;
         }
         try {
@@ -10720,7 +10670,7 @@ Keep the reflection grounded in the evidence below.
           });
           forgetCodexThread2(sessionKey, rememberedThreadId);
         } catch (error) {
-          logger_exports.log.warn(`codexCompat metadata-loss flush failed: ${String(error)}`);
+          log8.warn(`codexCompat metadata-loss flush failed: ${String(error)}`);
         }
       }
       async function resolveBeforeResetBufferKeys(sessionKey, sessionIdentity) {
@@ -10848,7 +10798,7 @@ Keep the reflection grounded in the evidence below.
         rememberCodexThread2(sessionKey, sessionIdentity.providerThreadId);
         if (sessionIdentity.isCodex && !codexCompactionModeLogged) {
           const mode = cfg.codexCompat.compactionFlushMode === "auto" ? "auto compaction flush mode (signal + heuristic)" : `${cfg.codexCompat.compactionFlushMode} compaction flush mode`;
-          logger_exports.log.info(
+          log8.info(
             `codexCompat enabled: using ${mode} for bundled Codex sessions`
           );
           codexCompactionModeLogged = true;
@@ -10872,12 +10822,12 @@ Keep the reflection grounded in the evidence below.
               });
               clearCodexCompatCaches2(sessionKey, sessionIdentity.providerThreadId);
               rememberCodexThread2(sessionKey, sessionIdentity.providerThreadId);
-              logger_exports.log.info(
+              log8.info(
                 `codexCompat heuristic flush: thread=${sessionIdentity.providerThreadId} messages ${previousCount} -> ${currentCount}`
               );
             } catch (error) {
               shouldPersistMessageCount = false;
-              logger_exports.log.warn(`codexCompat heuristic flush failed: ${String(error)}`);
+              log8.warn(`codexCompat heuristic flush failed: ${String(error)}`);
             }
           }
           if (typeof currentCount === "number" && shouldPersistMessageCount && codexBaselineKey) {
@@ -10888,10 +10838,10 @@ Keep the reflection grounded in the evidence below.
         const runtimeAgent = ctx.runtime?.agent;
         const agentId = ctx?.agentId ?? runtimeAgent?.id ?? "main";
         const verboseRequested = cfg.verboseRecallVisibility !== false && isVerboseRecallRequested(event, ctx);
-        logger_exports.log.debug(
+        log8.debug(
           `${hookLabel}: sessionKey=${sessionKey}, promptLen=${prompt.length}`
         );
-        logger_exports.log.debug(
+        log8.debug(
           `${hookLabel}: cronRecallMode=${cfg.cronRecallMode}, allowlistCount=${cfg.cronRecallAllowlist.length}`
         );
         if (sessionKey.includes(":cron:") && cfg.cronRecallMode === "allowlist") {
@@ -10899,12 +10849,12 @@ Keep the reflection grounded in the evidence below.
             const re = wildcardToRegExp(pattern);
             return re.test(sessionKey);
           });
-          logger_exports.log.debug(
+          log8.debug(
             `${hookLabel}: cron allowlist match=${matchedPattern ? "yes" : "no"} pattern=${matchedPattern ?? "none"}`
           );
         }
         if (shouldSkipRecallForSession(sessionKey, cfg)) {
-          logger_exports.log.debug(
+          log8.debug(
             `${hookLabel}: skip recall for cron session ${sessionKey} (mode=${cfg.cronRecallMode})`
           );
           return;
@@ -10928,7 +10878,7 @@ Keep the reflection grounded in the evidence below.
               injectedChars: 0,
               toggleState: auditToggleState
             }).catch((error) => {
-              logger_exports.log.debug(`recall audit append failed: ${String(error)}`);
+              log8.debug(`recall audit append failed: ${String(error)}`);
             });
           }
           if (!verboseRequested) return;
@@ -10982,7 +10932,7 @@ Keep the reflection grounded in the evidence below.
           const shouldWarnAndSuppressBundledActiveMemoryCollision = cfg.activeRecallEnabled && !cfg.activeRecallAllowChainedActiveMemory && bundledActiveMemoryEnabledForAgent;
           if (shouldWarnAndSuppressBundledActiveMemoryCollision && !warnedBundledActiveMemoryCollisionAgents.has(agentId)) {
             warnedBundledActiveMemoryCollisionAgents.add(agentId);
-            logger_exports.log.warn(
+            log8.warn(
               `active recall suppressed because bundled active-memory plugin is enabled for agent "${agentId}" while activeRecallAllowChainedActiveMemory=false`
             );
           }
@@ -10996,7 +10946,7 @@ Keep the reflection grounded in the evidence below.
             ),
             currentMessage: prompt
           }).catch((error) => {
-            logger_exports.log.debug(`active recall fallback failed: ${String(error)}`);
+            log8.debug(`active recall fallback failed: ${String(error)}`);
             return null;
           });
           const activeRecallLines = activeRecallResult?.summary && activeRecallResult.summary.length > 0 ? ["## Active Recall (Remnic)", "", activeRecallResult.summary, ""] : [];
@@ -11011,7 +10961,7 @@ Keep the reflection grounded in the evidence below.
             }
           });
           recallComposition ??= { context };
-          logger_exports.log.debug(
+          log8.debug(
             `${hookLabel}: recall returned ${context?.length ?? 0} chars`
           );
           const lastRecall = orchestrator.getLastRecall(sessionKey);
@@ -11058,7 +11008,7 @@ Keep the reflection grounded in the evidence below.
                 requestedMode: lastRecall?.requestedMode,
                 fallbackUsed: lastRecall?.fallbackUsed
               }).catch((error) => {
-                logger_exports.log.debug(`recall audit append failed: ${String(error)}`);
+                log8.debug(`recall audit append failed: ${String(error)}`);
               });
             }
             if (mergedLines.length === 0) return;
@@ -11085,7 +11035,7 @@ Keep the reflection grounded in the evidence below.
               requestedMode: lastRecall?.requestedMode,
               fallbackUsed: lastRecall?.fallbackUsed
             }).catch((error) => {
-              logger_exports.log.debug(`recall audit append failed: ${String(error)}`);
+              log8.debug(`recall audit append failed: ${String(error)}`);
             });
           }
           const verboseLines = verboseRequested ? buildVerboseRecallHeader({
@@ -11105,12 +11055,12 @@ Keep the reflection grounded in the evidence below.
           const memorySectionLines = memoryContext.lines;
           const memoryLines = useMemoryPromptSection ? memorySectionLines : [...auxiliaryLines, ...memorySectionLines];
           const promptWithVerbose = useMemoryPromptSection ? auxiliaryLines.length > 0 ? auxiliaryLines.join("\n").replace(/\n$/, "") : void 0 : auxiliaryLines.length > 0 ? [...auxiliaryLines, ...memorySectionLines].join("\n").replace(/\n$/, "") : memoryContext.prompt;
-          logger_exports.log.debug(
+          log8.debug(
             `${hookLabel}: returning memory context with ${trimmed.length} chars`
           );
           return promptWithVerbose ? { prependSystemContext: promptWithVerbose, memoryLines } : { memoryLines };
         } catch (err) {
-          logger_exports.log.error("recall failed", err);
+          log8.error("recall failed", err);
           lastRecallSummaryBySession.set(sessionKey, null);
           clearCodexCompatCaches2(sessionKey, void 0, {
             preserveMessageCount: true,
@@ -11161,7 +11111,7 @@ Keep the reflection grounded in the evidence below.
       if (useMemoryPromptSection && api.registerMemoryPromptSection) {
         if (cfg.activeRecallEnabled && !globalThis[ACTIVE_RECALL_OVERLAP_WARNED]) {
           globalThis[ACTIVE_RECALL_OVERLAP_WARNED] = true;
-          logger_exports.log.warn(
+          log8.warn(
             "activeRecallEnabled=true while memory-slot prompt injection is active (registerMemoryPromptSection). Prompt injection does NOT require active recall; this runs a second blocking retrieval per turn. Disable activeRecallEnabled unless the secondary pre-reply summary block is intentional (issue #1550)."
           );
         }
@@ -11372,7 +11322,7 @@ Keep the reflection grounded in the evidence below.
                   agentIds: capabilityAgentIds
                 });
               } catch (err) {
-                logger_exports.log.error("publicArtifacts.listArtifacts failed", err);
+                log8.error("publicArtifacts.listArtifacts failed", err);
                 return [];
               }
             }
@@ -11389,14 +11339,14 @@ Keep the reflection grounded in the evidence below.
         }
         const builderDesc = !promptInjectionAllowed ? " (promptBuilder omitted \u2014 injection disabled by policy)" : memoryPromptBuilder ? " and promptBuilder (from registerMemoryPromptSection)" : " and promptBuilder (capability-only fallback)";
         const capabilityDesc = typeof api.registerMemoryCapability === "function" ? `memory capability with publicArtifacts provider${builderDesc}` : "split memory runtime/flush-plan surfaces";
-        logger_exports.log.info(`registered ${capabilityDesc}`);
+        log8.info(`registered ${capabilityDesc}`);
       }
       if (cfg.openclawMessageReceivedCaptureEnabled) {
         api.on(
           "message_received",
           async (event, ctx) => {
             if (cfg.heartbeat.enabled && cfg.heartbeat.gateExtractionDuringHeartbeat && isHeartbeatTrigger2(event, ctx)) {
-              logger_exports.log.debug(
+              log8.debug(
                 `message_received: skipping transcript capture during heartbeat run for ${ctx?.sessionKey ?? "default"}`
               );
               return;
@@ -11484,7 +11434,7 @@ Keep the reflection grounded in the evidence below.
                 rememberPendingSparseInboundContentFingerprint2(sparseInboundContentFingerprint);
               }
             } catch (err) {
-              logger_exports.log.debug(`message_received transcript append failed: ${err}`);
+              log8.debug(`message_received transcript append failed: ${err}`);
             }
           }
         );
@@ -11495,7 +11445,7 @@ Keep the reflection grounded in the evidence below.
           if (!event.success || !Array.isArray(event.messages)) return;
           if (event.messages.length === 0) return;
           if (cfg.heartbeat.enabled && cfg.heartbeat.gateExtractionDuringHeartbeat && isHeartbeatTrigger2(event, ctx)) {
-            logger_exports.log.debug(
+            log8.debug(
               `agent_end: skipping transcript/extraction buffering during heartbeat run for ${ctx?.sessionKey ?? "default"}`
             );
             return;
@@ -11543,9 +11493,9 @@ 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 (0, objective_state_writers_exports.recordObjectiveStateSnapshotsFromAgentMessages)({
+              await recordObjectiveStateSnapshotsFromAgentMessages({
                 memoryDir: objectiveStateStorage?.dir ?? orchestrator.config.memoryDir,
-                objectiveStateStoreDir: (0, objective_state_exports.objectiveStateStoreOverrideForNamespace)({
+                objectiveStateStoreDir: objectiveStateStoreOverrideForNamespace({
                   memoryDir: orchestrator.config.memoryDir,
                   configuredStoreDir: orchestrator.config.objectiveStateStoreDir,
                   namespacesEnabled: orchestrator.config.namespacesEnabled,
@@ -11558,7 +11508,7 @@ Keep the reflection grounded in the evidence below.
                 messages
               });
             } catch (error) {
-              logger_exports.log.debug(
+              log8.debug(
                 `agent_end objective-state writer skipped due to error: ${error}`
               );
             }
@@ -11676,11 +11626,11 @@ Keep the reflection grounded in the evidence below.
                   );
                 }
               } catch (lcmErr) {
-                logger_exports.log.debug(`LCM agent_end indexing error: ${lcmErr}`);
+                log8.debug(`LCM agent_end indexing error: ${lcmErr}`);
               }
             }
           } catch (err) {
-            logger_exports.log.error("agent_end processing failed", err);
+            log8.error("agent_end processing failed", err);
           }
         }
       );
@@ -11706,7 +11656,7 @@ Keep the reflection grounded in the evidence below.
                 clearCodexCompatCaches2(sessionKey, signalThreadId);
                 rememberCodexThread2(sessionKey, signalThreadId);
               } catch (error) {
-                logger_exports.log.warn(`codexCompat signal flush failed: ${String(error)}`);
+                log8.warn(`codexCompat signal flush failed: ${String(error)}`);
               }
             }
             if (orchestrator.lcmEngine?.enabled) {
@@ -11734,7 +11684,7 @@ Keep the reflection grounded in the evidence below.
                 );
                 await orchestrator.lcmEngine.preCompactionFlush(sessionKey);
               } catch (lcmErr) {
-                logger_exports.log.debug(`LCM before_compaction error: ${lcmErr}`);
+                log8.debug(`LCM before_compaction error: ${lcmErr}`);
               }
             }
             if (!orchestrator.config.checkpointEnabled) {
@@ -11754,10 +11704,10 @@ Keep the reflection grounded in the evidence below.
                 turns: checkpointTurns,
                 ttl: new Date(Date.now() + 24 * 60 * 60 * 1e3).toISOString()
               });
-              logger_exports.log.info(`saved checkpoint for ${sessionKey} before compaction`);
+              log8.info(`saved checkpoint for ${sessionKey} before compaction`);
             }
           } catch (err) {
-            logger_exports.log.error("before_compaction hook failed", err);
+            log8.error("before_compaction hook failed", err);
           }
         }
       );
@@ -11797,24 +11747,24 @@ Keep the reflection grounded in the evidence below.
                 );
                 await orchestrator.lcmEngine.verifyPostCompaction(sessionKey);
               } catch (lcmErr) {
-                logger_exports.log.debug(`LCM after_compaction error: ${lcmErr}`);
+                log8.debug(`LCM after_compaction error: ${lcmErr}`);
               }
             }
             void queueOpenClawFlushPlanProcessing("after_compaction", workspaceDir);
             if (!orchestrator.config.compactionResetEnabled) {
-              logger_exports.log.debug(
+              log8.debug(
                 `compaction completed for ${sessionKey}, reset disabled \u2014 skipping`
               );
               return;
             }
-            logger_exports.log.info(
+            log8.info(
               `compaction completed for ${sessionKey}, triggering session reset`
             );
             const apiAny = api;
             if (typeof apiAny.resetSession === "function") {
               const result = await apiAny.resetSession(sessionKey, "new");
               if (result?.ok === true) {
-                logger_exports.log.info(
+                log8.info(
                   `session reset via API for ${sessionKey}, new sessionId=${result.sessionId}`
                 );
                 const safeSessionKey = sanitizeSessionKeyForFilename(sessionKey);
@@ -11834,17 +11784,17 @@ Keep the reflection grounded in the evidence below.
                 const errorDetail = result && typeof result === "object" && "error" in result ? String(
                   result.error ?? "unknown error"
                 ) : `invalid result: ${JSON.stringify(result)}`;
-                logger_exports.log.error(
+                log8.error(
                   `api.resetSession failed for ${sessionKey}: ${errorDetail}`
                 );
               }
             } else {
-              logger_exports.log.error(
+              log8.error(
                 `api.resetSession not available \u2014 compaction reset requires OC fork with PR #29985. Session ${sessionKey} will continue without reset.`
               );
             }
           } catch (err) {
-            logger_exports.log.error("after_compaction reset failed", err);
+            log8.error("after_compaction reset failed", err);
           }
         }
       );
@@ -11877,7 +11827,7 @@ Keep the reflection grounded in the evidence below.
                 ).catch((error) => {
                   if (!flushAbort.signal.aborted) {
                     flushFailed = true;
-                    logger_exports.log.warn(
+                    log8.warn(
                       `before_reset flush failed for ${bufferKey}: ${String(error)}`
                     );
                   }
@@ -11910,7 +11860,7 @@ Keep the reflection grounded in the evidence below.
               );
             }
             if (flushTimedOut) {
-              logger_exports.log.warn(
+              log8.warn(
                 `before_reset flush timed out after ${cfg.beforeResetTimeoutMs}ms`
               );
             }
@@ -11925,18 +11875,18 @@ Keep the reflection grounded in the evidence below.
           }
         );
       } catch (error) {
-        logger_exports.log.debug(`before_reset hook unavailable on this runtime: ${String(error)}`);
+        log8.debug(`before_reset hook unavailable on this runtime: ${String(error)}`);
       }
       if (!passiveMode && sdkCaps.hasBeforePromptBuild) {
         api.on(
           "session_start",
           async (event, ctx) => {
             const sessionKey = event.sessionKey ?? "default";
-            logger_exports.log.debug(`session_start: ${sessionKey}`);
+            log8.debug(`session_start: ${sessionKey}`);
             try {
               await orchestrator.maybeRunFileHygiene().catch(() => void 0);
             } catch (err) {
-              logger_exports.log.debug(`session_start file hygiene failed: ${err}`);
+              log8.debug(`session_start file hygiene failed: ${err}`);
             }
             void queueOpenClawFlushPlanProcessing(
               "session_start",
@@ -11949,7 +11899,7 @@ Keep the reflection grounded in the evidence below.
           "session_end",
           async (event, ctx) => {
             const sessionKey = event.sessionKey ?? ctx.sessionKey ?? "default";
-            logger_exports.log.debug(`session_end: ${sessionKey}`);
+            log8.debug(`session_end: ${sessionKey}`);
             const sessionIdentity = resolveSessionIdentity2(sessionKey, event, ctx);
             const rememberedThreadId = sessionIdentity.providerThreadId ?? resolveStoredCodexThreadId2(sessionKey);
             const bufferKeys = await resolveBeforeResetBufferKeys(sessionKey, {
@@ -11967,7 +11917,7 @@ Keep the reflection grounded in the evidence below.
                   });
                 } catch (error) {
                   flushFailed = true;
-                  logger_exports.log.warn(
+                  log8.warn(
                     `session_end flush failed for ${bufferKey}: ${String(error)}`
                   );
                 }
@@ -11992,7 +11942,7 @@ Keep the reflection grounded in the evidence below.
           "before_tool_call",
           async (event, _ctx) => {
             if (event.toolName) {
-              logger_exports.log.debug(`before_tool_call: ${event.toolName}`);
+              log8.debug(`before_tool_call: ${event.toolName}`);
             }
           }
         );
@@ -12000,7 +11950,7 @@ Keep the reflection grounded in the evidence below.
           "after_tool_call",
           async (event, _ctx) => {
             if (event.toolName) {
-              logger_exports.log.debug(
+              log8.debug(
                 `after_tool_call: ${event.toolName} (${event.durationMs ?? "?"}ms)`
               );
             }
@@ -12011,7 +11961,7 @@ Keep the reflection grounded in the evidence below.
           async (event, ctx) => {
             const sessionKey = ctx?.sessionKey ?? "default";
             if (event.tokenUsage) {
-              logger_exports.log.debug(
+              log8.debug(
                 `llm_output: model=${event.model ?? "?"}, tokens=${event.tokenUsage.input ?? 0}/${event.tokenUsage.output ?? 0}, ${event.durationMs ?? "?"}ms, session=${sessionKey}`
               );
             }
@@ -12020,7 +11970,7 @@ Keep the reflection grounded in the evidence below.
         api.on(
           "subagent_spawned",
           async (event, _ctx) => {
-            logger_exports.log.debug(
+            log8.debug(
               `subagent_spawned: ${event.subagentId ?? "?"} purpose=${event.purpose ?? "?"} parent=${event.parentSessionKey ?? "?"}`
             );
           }
@@ -12028,7 +11978,7 @@ Keep the reflection grounded in the evidence below.
         api.on(
           "subagent_ended",
           async (event, _ctx) => {
-            logger_exports.log.debug(
+            log8.debug(
               `subagent_ended: ${event.subagentId ?? "?"} success=${event.success ?? "?"} ${event.durationMs ?? "?"}ms`
             );
           }
@@ -12046,7 +11996,7 @@ Keep the reflection grounded in the evidence below.
       try {
         const loadedJobs = await loadHourlySummaryCronJobsData(cronFilePath);
         if (loadedJobs.status === "invalid") {
-          logger_exports.log.error(
+          log8.error(
             `hourly summary cron auto-registration skipped: existing jobs file is invalid at ${cronFilePath}`,
             loadedJobs.error
           );
@@ -12061,7 +12011,7 @@ Keep the reflection grounded in the evidence below.
             { nowMs: Date.now() }
           );
           if (!changed) {
-            logger_exports.log.debug("hourly summary cron job already up to date");
+            log8.debug("hourly summary cron job already up to date");
             return;
           }
           jobsData.jobs[existingIndex] = job;
@@ -12069,7 +12019,7 @@ Keep the reflection grounded in the evidence below.
             cronFilePath,
             JSON.stringify(jobsData, null, 2)
           );
-          logger_exports.log.info("reconciled hourly summary cron job routing to configured task model");
+          log8.info("reconciled hourly summary cron job routing to configured task model");
           return;
         }
         const randomMinute = Math.floor(Math.random() * 59) + 1;
@@ -12083,9 +12033,9 @@ Keep the reflection grounded in the evidence below.
           cronFilePath,
           JSON.stringify(jobsData, null, 2)
         );
-        logger_exports.log.info("auto-registered hourly summary cron job");
+        log8.info("auto-registered hourly summary cron job");
       } catch (err) {
-        logger_exports.log.error("failed to auto-register hourly summary cron job:", err);
+        log8.error("failed to auto-register hourly summary cron job:", err);
       }
     }
     if (typeof api.registerMemoryCorpusSupplement === "function") {
@@ -12195,7 +12145,7 @@ Keep the reflection grounded in the evidence below.
               };
             });
           } catch (err) {
-            logger_exports.log.warn(`memory corpus search failed: ${err}`);
+            log8.warn(`memory corpus search failed: ${err}`);
             throw corpusBackendError("search", err);
           }
         },
@@ -12231,7 +12181,7 @@ Keep the reflection grounded in the evidence below.
               updatedAt: memory.frontmatter.updated
             };
           } catch (err) {
-            logger_exports.log.warn(`memory corpus get failed: ${err}`);
+            log8.warn(`memory corpus get failed: ${err}`);
             throw corpusBackendError("get", err);
           }
         }
@@ -12254,7 +12204,7 @@ Keep the reflection grounded in the evidence below.
           commandApi.registerCommand(descriptor);
         }
       } else if (typeof commandApi.registerCommand !== "function") {
-        logger_exports.log.debug(
+        log8.debug(
           "registerCommand unavailable on this runtime; skipping Remnic session command descriptors because commands.list is a gateway RPC surface, not a typed plugin hook"
         );
       }
@@ -12293,7 +12243,7 @@ Keep the reflection grounded in the evidence below.
             if (globalThis[keys.SERVICE_STARTED]) return;
           }
           if (globalThis[keys.SERVICE_STARTED]) {
-            logger_exports.log.debug(
+            log8.debug(
               `${serviceId}: service.start() called again \u2014 skipping duplicate init`
             );
             return;
@@ -12306,10 +12256,10 @@ Keep the reflection grounded in the evidence below.
         globalThis[keys.ORCHESTRATOR] = orchestrator;
         const initPromise = (async () => {
           try {
-            logger_exports.log.info("initializing engram memory system...");
+            log8.info("initializing engram memory system...");
             await orchestrator.initialize();
             if (!didCountStart) return;
-            activeOpikExporter = createOpikExporter({}, logger_exports.log);
+            activeOpikExporter = createOpikExporter({}, log8);
             if (activeOpikExporter) activeOpikExporter.subscribe();
             if (orchestrator.config.transcriptEnabled) {
               await orchestrator.transcript.cleanup(
@@ -12321,7 +12271,7 @@ Keep the reflection grounded in the evidence below.
               await ensureHourlySummaryCron(api);
               if (!didCountStart) return;
             } else if (orchestrator.config.hourlySummariesEnabled) {
-              logger_exports.log.info(
+              log8.info(
                 "hourly summaries enabled; cron auto-register is disabled. To schedule summaries, create an isolated/agentTurn cron job that calls `memory_summarize_hourly`."
               );
             }
@@ -12337,7 +12287,7 @@ Keep the reflection grounded in the evidence below.
                   resolveDreamJournalPath(),
                   () => {
                     void queueDreamSurfaceSync().catch((error) => {
-                      logger_exports.log.debug(`dream surface watch sync failed: ${String(error)}`);
+                      log8.debug(`dream surface watch sync failed: ${String(error)}`);
                     });
                   }
                 );
@@ -12357,7 +12307,7 @@ Keep the reflection grounded in the evidence below.
                   resolveHeartbeatJournalPath(),
                   () => {
                     void queueHeartbeatSurfaceSync().catch((error) => {
-                      logger_exports.log.debug(`heartbeat surface watch sync failed: ${String(error)}`);
+                      log8.debug(`heartbeat surface watch sync failed: ${String(error)}`);
                     });
                   }
                 );
@@ -12378,17 +12328,17 @@ Keep the reflection grounded in the evidence below.
               }
               try {
                 const status = await accessHttpServer.start();
-                logger_exports.log.info(
+                log8.info(
                   `engram access HTTP ready at http://${status.host}:${status.port}`
                 );
               } catch (err) {
-                logger_exports.log.error("failed to start engram access HTTP server", err);
+                log8.error("failed to start engram access HTTP server", err);
               }
             }
             if (!didCountStart) return;
             globalThis[keys.SERVICE_STARTED] = true;
-            logger_exports.log.info("engram memory system ready");
-            logger_exports.log.info(
+            log8.info("engram memory system ready");
+            log8.info(
               `gateway_start fired \u2014 Remnic memory plugin is active (id=${pluginDefinition.id}, memoryDir=${cfg.memoryDir})`
             );
             void queueOpenClawFlushPlanProcessing(
@@ -12462,7 +12412,7 @@ Keep the reflection grounded in the evidence below.
           try {
             activeOpikExporter?.unsubscribe();
           } catch (err) {
-            logger_exports.log.debug(`engram opik exporter unsubscribe failed: ${err}`);
+            log8.debug(`engram opik exporter unsubscribe failed: ${err}`);
           }
           activeOpikExporter = null;
           const finishCodex = beginCodexSubscriptionShutdown(getCodexSubscriptionRunnerForOwner(cfg));
@@ -12470,7 +12420,7 @@ Keep the reflection grounded in the evidence below.
             try {
               await accessHttpServer.stop();
             } catch (err) {
-              logger_exports.log.debug(`engram access HTTP stop failed: ${err}`);
+              log8.debug(`engram access HTTP stop failed: ${err}`);
             }
             stopDreamWatcher?.();
             stopDreamWatcher = null;
@@ -12481,11 +12431,12 @@ Keep the reflection grounded in the evidence below.
             try {
               await orchestrator.destroy();
             } catch (err) {
-              logger_exports.log.debug(`engram orchestrator destroy on stop failed: ${err}`);
+              log8.debug(`engram orchestrator destroy on stop failed: ${err}`);
             }
           } finally {
             finishCodex();
           }
+          terminateActiveCodexSubscriptionChildren("SIGKILL", getCodexSubscriptionRunnerForOwner(cfg));
           if (globalThis[keys.ORCHESTRATOR] === orchestrator) {
             delete globalThis[keys.ORCHESTRATOR];
           }
@@ -12506,7 +12457,7 @@ Keep the reflection grounded in the evidence below.
         if (!secondaryTookOver) {
           globalThis[keys.SERVICE_STARTED] = false;
         }
-        logger_exports.log.info("stopped");
+        log8.info("stopped");
       }
     });
   }
@@ -12649,7 +12600,6 @@ async function resolveFlushPlanProcessingChainKey(workspaceRoot) {
     return lexicalRoot;
   }
 }
-var export_loadDaySummaryPrompt = day_summary_exports.loadDaySummaryPrompt;
 export {
   buildHourlySummaryCronJob,
   checkDaemonHealth,
@@ -12659,7 +12609,7 @@ export {
   detectDaemonBridgeMode,
   embedWithOpenClawProvider,
   listRemnicPublicArtifacts,
-  export_loadDaySummaryPrompt as loadDaySummaryPrompt,
+  loadDaySummaryPrompt,
   loadHourlySummaryCronJobsData,
   loadOpenClawMemoryEmbeddingSdk,
   parseHourlySummaryCronJobsData,