@remnic/plugin-openclaw 9.69.39 → 9.69.41

package/dist/index.js

@@ -42,11 +42,11 @@ import {
   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";
+import { Type as Type2 } from "@sinclair/typebox";
 
 // ../../src/temporal-index.ts
 var temporal_index_exports = {};
@@ -213,6 +213,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,6 +227,198 @@ 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";
@@ -279,15 +475,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;
@@ -512,7 +708,7 @@ 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}`
@@ -526,7 +722,7 @@ Content: ${candidate.content}`
         }
       }
       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 +733,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})` : ""}
@@ -546,7 +742,7 @@ 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)}`);
+        return toolResult2(`Memory capture failed: ${error instanceof Error ? error.message : String(error)}`);
       }
     }
   }
@@ -565,24 +761,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 +821,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 +832,7 @@ Score: ${r.score.toFixed(3)}
 ${snippet}
 \`\`\``;
           }).join("\n\n");
-          return toolResult(
+          return toolResult2(
             `## Memory Search: "${query}"
 
 ${filtered.length} result(s)
@@ -653,32 +849,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 +884,7 @@ ${formatted}`
           period,
           key
         });
-        return toolResult(
+        return toolResult2(
           `OK
 
 period: ${audit.period}
@@ -704,40 +900,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)
@@ -748,7 +944,7 @@ report: ${audit.reportPath}`
           suspectedCause: typeof params.suspectedCause === "string" ? params.suspectedCause : void 0
         });
         logger_exports.log.info(`continuity-incident open id=${created.id}`);
-        return toolResult(`Continuity incident opened.
+        return toolResult2(`Continuity incident opened.
 
 ${formatContinuityIncidentSummary(created)}`);
       }
@@ -760,35 +956,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 +992,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 +1003,9 @@ ${formatContinuityIncidentSummary(created)}`);
           verificationResult,
           preventiveRule
         });
-        if (!closed) return toolResult(`Incident not found: ${id}`);
+        if (!closed) return toolResult2(`Incident not found: ${id}`);
         logger_exports.log.info(`continuity-incident close id=${id}`);
-        return toolResult(`Continuity incident closed.
+        return toolResult2(`Continuity incident closed.
 
 ${formatContinuityIncidentSummary(closed)}`);
       }
@@ -821,20 +1017,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 +1039,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 +1051,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 +1066,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."
           );
         }
@@ -924,11 +1120,11 @@ ${body}`);
             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.
+          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 +1135,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 +1178,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}`);
+          if (!reviewed) return toolResult2(`Continuity loop not found: ${id}`);
           logger_exports.log.info(`continuity-loop review id=${id} status=${reviewed.status}`);
-          return toolResult(`Continuity loop reviewed.
+          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 +1195,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 +1213,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 +1229,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 +1272,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."
           );
         }
@@ -1090,7 +1286,7 @@ ${anchor}`);
         logger_exports.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 +1300,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 +1317,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 +1334,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 +1345,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 +1370,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 +1382,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 +1392,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 +1412,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 +1422,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 +1442,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 +1452,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 +1488,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 +1509,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 +1527,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 +1586,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 +1611,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 +1621,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 +1643,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 +1655,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 +1757,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 +1783,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 +1827,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 +1842,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 +1855,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 +1871,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 +1883,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 +1941,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 +1962,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 +1998,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 +2041,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 +2065,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 +2077,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 +2096,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 +2121,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 +2133,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 +2181,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 +2239,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 +2297,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 +2327,7 @@ Best for:
           orchestrator,
           params
         );
-        return toolResult(message);
+        return toolResult2(message);
       }
     },
     { name: "memory_promote" }
@@ -2149,9 +2345,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 +2357,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 +2380,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 +2392,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 +2424,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 +2441,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 +2459,7 @@ ${q.question}
 
 _Context: ${q.context}_`
         ).join("\n\n");
-        return toolResult(`## Questions (${questions.length})
+        return toolResult2(`## Questions (${questions.length})
 
 ${formatted}`);
       }
@@ -2283,9 +2479,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 +2491,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 +2513,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 +2546,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 +2590,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 +2613,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 +2644,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 +2668,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 +2680,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 +2802,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 +2896,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 +2918,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 +2946,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 +2987,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 +3022,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 +3039,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 +3049,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 +3083,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 +3093,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 +3110,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 +3120,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 +3154,7 @@ Returns: Performance trace data with timing breakdown`,
             lines.push("");
           }
         }
-        return toolResult(lines.join("\n"));
+        return toolResult2(lines.join("\n"));
       }
     },
     { name: "engram_profiling_report" }
@@ -3403,17 +3434,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
@@ -12486,6 +12517,7 @@ Keep the reflection grounded in the evidence below.
           } finally {
             finishCodex();
           }
+          terminateActiveCodexSubscriptionChildren("SIGKILL", getCodexSubscriptionRunnerForOwner(cfg));
           if (globalThis[keys.ORCHESTRATOR] === orchestrator) {
             delete globalThis[keys.ORCHESTRATOR];
           }