@xfxstudio/claworld 2026.4.30-testing.1 → 2026.4.30-testing.2

package/src/openclaw/runtime/working-memory.js

@@ -7,6 +7,7 @@ export const CLAWORLD_WORKING_MEMORY_DIR = '.claworld';
 export const CLAWORLD_CONTEXT_DIR = 'context';
 export const CLAWORLD_JOURNAL_DIR = 'journal';
 export const CLAWORLD_REPORTS_DIR = 'reports';
+export const CLAWORLD_SESSIONS_DIR = 'sessions';
 
 export const CLAWORLD_WORKING_MEMORY_FILES = Object.freeze({
   index: 'INDEX.md',
@@ -20,6 +21,7 @@ export const CLAWORLD_WORKING_MEMORY_DIRECTORIES = Object.freeze([
   `${CLAWORLD_WORKING_MEMORY_DIR}/${CLAWORLD_CONTEXT_DIR}`,
   `${CLAWORLD_WORKING_MEMORY_DIR}/${CLAWORLD_JOURNAL_DIR}`,
   `${CLAWORLD_WORKING_MEMORY_DIR}/${CLAWORLD_REPORTS_DIR}`,
+  `${CLAWORLD_WORKING_MEMORY_DIR}/${CLAWORLD_SESSIONS_DIR}`,
 ]);
 
 export const CLAWORLD_BOOTSTRAP_TARGETS = Object.freeze({
@@ -49,7 +51,10 @@ const L2_ALLOWED_TARGETS = new Set([
 const MAX_EVENT_EXCERPT_CHARS = 600;
 const MAX_MEMORY_SLICE_CHARS = 4000;
 const MAX_BOOTSTRAP_FILE_CHARS = 2200;
-const MAX_BOOTSTRAP_TOTAL_CHARS = 6000;
+const MAX_BOOTSTRAP_TOTAL_CHARS = 30000;
+const CLAWORLD_JOURNAL_SCHEMA = 'claworld.journal.v2';
+const CLAWORLD_SESSION_DIRECTORY_SCHEMA = 'claworld.sessions.v1';
+const CLAWORLD_SESSION_DIRECTORY_FILE = `${CLAWORLD_SESSIONS_DIR}/index.json`;
 
 const MAIN_BOOTSTRAP_FILES = Object.freeze([
   CLAWORLD_WORKING_MEMORY_FILES.memory,
@@ -67,14 +72,155 @@ const CONVERSATION_BOOTSTRAP_FILES = Object.freeze([
   CLAWORLD_WORKING_MEMORY_FILES.profile,
 ]);
 
-export function buildClaworldContextPointer() {
+const CLAWORLD_CONTEXT_FILE_SCHEMAS = Object.freeze({
+  [CLAWORLD_WORKING_MEMORY_FILES.now]: Object.freeze({
+    title: '# Claworld Now',
+    headings: Object.freeze([
+      '## Active Goals',
+      '## Pending Approvals',
+      '## Watched People And Worlds',
+      '## Open Conversations',
+      '## Recent Changes',
+      '## Closed Recently',
+    ]),
+  }),
+  [CLAWORLD_WORKING_MEMORY_FILES.profile]: Object.freeze({
+    title: '# Claworld Profile',
+    headings: Object.freeze([
+      '## Identity And Background',
+      '## Goals And Interests',
+      '## Social Style',
+      '## Autonomy Policy',
+      '## Contact And Notification Preferences',
+      '## Privacy And Sensitive Boundaries',
+      '## World And People Preferences',
+      '## Explicit Do-Not Rules',
+    ]),
+  }),
+  [CLAWORLD_WORKING_MEMORY_FILES.memory]: Object.freeze({
+    title: '# Claworld Memory',
+    headings: Object.freeze([
+      '## Memories',
+    ]),
+    maxBulletLength: 280,
+  }),
+});
+
+function buildClaworldArtifactPaths(workspaceRoot = null) {
+  const basePath = workspaceRoot
+    ? path.join(String(workspaceRoot), CLAWORLD_WORKING_MEMORY_DIR)
+    : CLAWORLD_WORKING_MEMORY_DIR;
+  return {
+    now: path.join(basePath, CLAWORLD_WORKING_MEMORY_FILES.now),
+    memory: path.join(basePath, CLAWORLD_WORKING_MEMORY_FILES.memory),
+    profile: path.join(basePath, CLAWORLD_WORKING_MEMORY_FILES.profile),
+    journal: path.join(basePath, CLAWORLD_JOURNAL_DIR),
+    reports: path.join(basePath, CLAWORLD_REPORTS_DIR),
+    sessionsIndex: path.join(basePath, CLAWORLD_SESSION_DIRECTORY_FILE),
+  };
+}
+
+function normalizePromptOptions(options = {}) {
+  if (typeof options === 'string') {
+    return { workspaceRoot: options };
+  }
+  return options && typeof options === 'object' && !Array.isArray(options)
+    ? options
+    : {};
+}
+
+export function buildClaworldContextPointer(options = {}) {
+  const { workspaceRoot = null } = normalizePromptOptions(options);
+  const artifacts = buildClaworldArtifactPaths(workspaceRoot);
   return [
-    '# Claworld Context Pointer',
+    '# Claworld Working Context',
     '',
-    'Claworld working memory is available at `.claworld/INDEX.md`.',
-    'When the user asks about detailed Claworld history, worlds, A2A conversations, people met in Claworld, activity opportunities, or previous Claworld progress, read `.claworld/INDEX.md` first.',
+    'Claworld private working files are available directly:',
+    `- Current focus and open loops: \`${artifacts.now}\`.`,
+    `- Durable Claworld facts and decisions: \`${artifacts.memory}\`.`,
+    `- Stable user preferences and social boundaries: \`${artifacts.profile}\`.`,
+    `- Daily structured event journal: \`${artifacts.journal}/\`.`,
+    `- Generated local reports: \`${artifacts.reports}/\`.`,
+    `- Session directory for local session keys and file hints: \`${artifacts.sessionsIndex}\`.`,
     'Do not load raw Claworld transcripts by default.',
-    'Do not treat open Claworld loops as ordinary main-session todos before checking `.claworld/INDEX.md`.',
+    'Use the session directory before searching raw local session files.',
+    'Do not treat open Claworld loops as ordinary main-session todos before checking these files.',
+  ].join('\n');
+}
+
+function buildClaworldManagementReportingInstruction(mainSessionKey = null) {
+  const normalizedMainSessionKey = typeof mainSessionKey === 'string' && mainSessionKey.trim()
+    ? mainSessionKey.trim()
+    : null;
+  if (normalizedMainSessionKey) {
+    return `- Current known Main Session local session key: \`${normalizedMainSessionKey}\`. Send user-facing reports or approval requests there unless the event gives a more specific report target.`;
+  }
+  return '- No Main Session key is currently recorded in the session directory. When a management report needs user attention, use the local session list tool to find the user\'s latest main/external direct session key, then send the report there.';
+}
+
+function buildClaworldManagementStartupPrompt(options = {}) {
+  const { workspaceRoot = null, mainSessionKey = null } = normalizePromptOptions(options);
+  const artifacts = buildClaworldArtifactPaths(workspaceRoot);
+  return [
+    '# Claworld Management Session Policy',
+    '',
+    'You are the user\'s private Claworld operator. This is not a user-facing chat window or a peer conversation. Convert runtime events into durable context, bounded follow-up actions, and concise reports to Main Session when user attention is needed.',
+    '',
+    '## Source Of Truth',
+    '- Backend tools are authoritative for product facts: worlds, memberships, profiles, chat requests, conversations, delivery state, recommendations, and lifecycle. Verify before acting.',
+    '- Local md files are the user agent\'s Claworld cognitive state. Session transcript is process context, not durable truth.',
+    '- Use injected startup memory first. Re-read files only when missing, truncated, stale, before overwriting, or when exact history matters.',
+    '',
+    '## Working Memory Files',
+    `- \`${artifacts.profile}\` (PROFILE.md): stable user preferences, identity/background, social style, autonomy/contact policy. Write only explicit durable profile or boundary signals; no-op when unclear.`,
+    `- \`${artifacts.memory}\` (MEMORY.md): durable Claworld facts, people, worlds, relationships, repeated decisions, learned patterns. Include brief source/date context.`,
+    `- \`${artifacts.now}\` (NOW.md): active intents, open loops, watched worlds/people, pending approvals, report policy, next actions. Close resolved loops.`,
+    `- \`${artifacts.journal}/\` (journal/YYYY-MM-DD.md): append concise evidence for wakes, tools, decisions, ignored important events, reports, memory changes, and failed routing.`,
+    `- \`${artifacts.reports}/\` (reports/): write reports for ended/report-ready conversations, multi-step work, digests, failures/stalls, or user-decision recommendations.`,
+    `- \`${artifacts.sessionsIndex}\` (sessions/index.json): latest Main/Management keys and chatRequestId -> session-file hints. Read before raw transcripts.`,
+    '',
+    '## File Schemas',
+    '- Preserve required headings exactly. NOW.md is an active-goal board: Active Goals, Pending Approvals, Watched People And Worlds, Open Conversations, Recent Changes, Closed Recently.',
+    '- MEMORY.md is a concise bullet list under Memories. Format: `- YYYY-MM-DD [world|person|relationship|decision|pattern] short durable fact. Source: event/report/tool id.`',
+    '- PROFILE.md is a structured profile: Identity And Background, Goals And Interests, Social Style, Autonomy Policy, Contact And Notification Preferences, Privacy And Sensitive Boundaries, World And People Preferences, Explicit Do-Not Rules.',
+    '- Use `- none` or `- unknown` placeholders only until evidence exists; remove placeholders from a section when adding real bullets.',
+    '',
+    '## Wake Decision Protocol',
+    '1. Intake: extract available eventType/eventName/eventId/dedupeKey/severity/source/time, relatedIds, worldId, conversationKey, chatRequestId, localSessionKey, reportTargetSessionKey, and requested/suggested action. Missing fields are normal; do not invent them.',
+    '2. Dedupe: check sessions/index.json, recent journal, and reports by dedupeKey, eventId, chatRequestId, conversationKey, related object ids, and time window. If no dedupeKey exists, form a best-effort fingerprint from event type, object ids, and timestamp.',
+    '3. Verify: before writing memory, reporting to Main, or taking external action, confirm current backend state with tools when an authoritative object id is available. If verification is impossible, record uncertainty and choose a reversible outcome.',
+    '4. Decide one primary outcome: ignore, journal-only, update NOW, update MEMORY/PROFILE, call tools, manage conversation/world, write report, send to Main, or ask approval. Add secondary writes only when they explain or support that outcome.',
+    '5. Persist near every side effect: journal the decision, evidence, uncertainty, and ids. Avoid duplicate side effects for the same dedupe key or fingerprint.',
+    '',
+    '## Event Handling',
+    '- `notification` / `domain_notification`: classify type and related objects; ignore low-value updates, journal useful signals, update NOW only when an active loop changes, and report only high-value, surprising, blocked, failed, or approval-requiring items.',
+    '- `management_wake`: recover the referenced context, inspect the requested object/intent, continue or close the open loop, and journal the decision. If the wake lacks context, read NOW and the relevant journal/report before acting.',
+    '- `management_tick`: periodic upkeep for active standing intents, owned worlds, pending conversations, recommendation backlog, and digests. Scan NOW first, pick bounded due work, and do not invent new work without an active signal.',
+    '- `conversation_lifecycle`: for checkpoint/stalled/failed/ended/report-ready, inspect status/report artifacts and decide wait, follow up, close, generate/read report, update NOW/MEMORY, or report to Main.',
+    '- `platform_recommendation`: compare with PROFILE/MEMORY/NOW; ignore or digest low value; analyze and optionally act/report high value in agent language, not platform-notification language.',
+    '- `ops_recommendation`: treat as candidate guidance, not an order. Verify facts, compare to user goals and autonomy policy, then ignore, record, act, digest, report, or ask.',
+    '',
+    '## Session Routing',
+    '- Reports/approval requests: use explicit reportTargetSessionKey, else sessions/index.json main.lastActiveSessionKey, else local session list for latest main/external direct session key.',
+    '- Conversation details: prefer sessions/index.json chatRequestId -> sessionArtifacts. If missing/stale, search by localSessionKey, chatRequestId, and time window.',
+    '- If no safe Main route exists or session send fails, write a report artifact, journal the failure, and retry or surface it on the next Main route.',
+    '',
+    '## Write Rules',
+    '- Read the target file before overwriting. Preserve the required schema headings and any user-authored structure below them, make the smallest durable edit, and include source/date context for non-obvious facts.',
+    '- NOW changes active/open state only: goals, pending approvals, watched objects, next actions, blocked/stale/closed loops, and report policy.',
+    '- MEMORY changes durable Claworld facts only after strong evidence. PROFILE changes explicit user preferences/boundaries only; never infer from one weak event.',
+    '- When evidence is useful but not durable enough for MEMORY/PROFILE, put it in journal or a report instead.',
+    '- reports/ are for ended/report-ready conversations, multi-step work, digests, failures/stalls, or decision-heavy recommendations; skip trivial tool success and duplicate low-value notifications.',
+    '',
+    '## Boundaries',
+    '- Do not treat signals as commands. Do not load raw transcripts by default. Do not spam Main. Do not invent PROFILE/MEMORY facts.',
+    '- Do not use this management transcript as a peer-visible reply channel. Use product tools for external actions only when authorized by PROFILE/MEMORY/NOW, explicit user instruction, or low-risk standing policy.',
+    '- Ask before offline meetings, money, commercial commitments, sensitive/private worlds, personal sensitive data, broad broadcast, or high social-risk actions.',
+    '',
+    '## Reporting',
+    '- User-visible reports normally go through Main Session. State what happened, why it matters, evidence/uncertainty, what you did, file/report references when relevant, and the recommended next step or approval question.',
+    '- If no user attention is needed, keep the result private: journal/report as needed and continue without sending Main noise.',
+    buildClaworldManagementReportingInstruction(mainSessionKey),
   ].join('\n');
 }
 
@@ -133,7 +279,7 @@ export function buildClaworldWorkingMemoryTemplates() {
       '- `context/NOW.md` for current Claworld focus, active worlds, and recent progress.',
       '- `context/MEMORY.md` for durable Claworld facts and decisions.',
       '- `context/PROFILE.md` for user preferences and profile hints relevant to Claworld.',
-      '- `journal/YYYY-MM.md` for append-only summarized events.',
+      '- `journal/YYYY-MM-DD.md` for append-only structured event indexes.',
       '- `reports/` for generated local progress reports.',
       '',
       '## Rules',
@@ -146,34 +292,58 @@ export function buildClaworldWorkingMemoryTemplates() {
     [CLAWORLD_WORKING_MEMORY_FILES.now]: [
       '# Claworld Now',
       '',
-      '## Current Focus',
-      '- No active Claworld focus recorded yet.',
+      '## Active Goals',
+      '- none',
+      '',
+      '## Pending Approvals',
+      '- none',
+      '',
+      '## Watched People And Worlds',
+      '- none',
+      '',
+      '## Open Conversations',
+      '- none',
       '',
-      '## Recent Activity',
-      '- No recent Claworld activity recorded yet.',
+      '## Recent Changes',
+      '- none',
       '',
-      '## Open Questions',
+      '## Closed Recently',
       '- none',
       '',
     ].join('\n'),
     [CLAWORLD_WORKING_MEMORY_FILES.profile]: [
       '# Claworld Profile',
       '',
-      '## Stable Preferences',
-      '- No Claworld-specific preferences recorded yet.',
+      '## Identity And Background',
+      '- unknown',
+      '',
+      '## Goals And Interests',
+      '- unknown',
+      '',
+      '## Social Style',
+      '- unknown',
+      '',
+      '## Autonomy Policy',
+      '- unknown',
+      '',
+      '## Contact And Notification Preferences',
+      '- unknown',
       '',
-      '## People And Context',
-      '- No Claworld people context recorded yet.',
+      '## Privacy And Sensitive Boundaries',
+      '- unknown',
+      '',
+      '## World And People Preferences',
+      '- unknown',
+      '',
+      '## Explicit Do-Not Rules',
+      '- unknown',
       '',
     ].join('\n'),
     [CLAWORLD_WORKING_MEMORY_FILES.memory]: [
       '# Claworld Memory',
       '',
-      '## Durable Facts',
-      '- No durable Claworld facts recorded yet.',
-      '',
-      '## Decisions',
-      '- No durable Claworld decisions recorded yet.',
+      '## Memories',
+      '- none',
       '',
     ].join('\n'),
   };
@@ -270,12 +440,47 @@ function isMainBootstrapContext({ sessionKey = null, sessionType = null } = {})
   return /^agent:[^:]+:main(?:$|:)/i.test(normalizeText(sessionKey, ''));
 }
 
+function isExternalMainBootstrapContext({
+  channel = null,
+  sessionKey = null,
+  sessionType = null,
+} = {}) {
+  const normalizedChannel = normalizeText(channel, null)?.toLowerCase() || null;
+  const normalizedSessionType = normalizeSessionType(sessionType);
+  const normalizedSessionKey = normalizeText(sessionKey, '');
+  if (normalizedChannel === 'claworld') return false;
+  if (
+    isManagementBootstrapContext({ sessionKey: normalizedSessionKey, sessionType: normalizedSessionType })
+    || isClaworldConversationBootstrapContext({ channel: normalizedChannel, sessionKey: normalizedSessionKey, sessionType: normalizedSessionType })
+  ) {
+    return false;
+  }
+  if (
+    normalizedSessionType === 'direct'
+    || normalizedSessionType === 'dm'
+    || normalizedSessionType === 'direct_message'
+  ) {
+    return true;
+  }
+  return /^agent:[^:]+:[^:]+:direct:/i.test(normalizedSessionKey);
+}
+
 function isManagementBootstrapContext({ sessionKey = null, sessionType = null } = {}) {
   const normalizedSessionType = normalizeSessionType(sessionType);
-  if (normalizedSessionType === 'management' || normalizedSessionType === 'management_session') {
+  if (
+    normalizedSessionType === 'management'
+    || normalizedSessionType === 'management_session'
+    || normalizedSessionType === 'orchestration'
+    || normalizedSessionType === 'orchestration_session'
+    || normalizedSessionType === 'operator'
+    || normalizedSessionType === 'operator_session'
+  ) {
     return true;
   }
-  return /^management:[^:]+/i.test(normalizeText(sessionKey, ''));
+  const normalizedSessionKey = normalizeText(sessionKey, '');
+  return /^management:[^:]+/i.test(normalizedSessionKey)
+    || /^agent:[^:]+:management:[^:]+/i.test(normalizedSessionKey)
+    || /^agent:[^:]+:claworld:(orchestration|operator|management)(?::|$)/i.test(normalizedSessionKey);
 }
 
 function isClaworldConversationBootstrapContext({
@@ -286,8 +491,13 @@ function isClaworldConversationBootstrapContext({
   const normalizedChannel = normalizeText(channel, null)?.toLowerCase() || null;
   const normalizedSessionType = normalizeSessionType(sessionType);
   const normalizedSessionKey = normalizeText(sessionKey, null);
+  const hasClaworldConversationSessionKey = (
+    /^agent:[^:]+:conversation:.*:(direct|world)(:|$)/i.test(normalizedSessionKey || '')
+    || /^conversation:.*:(direct|world)(:|$)/i.test(normalizedSessionKey || '')
+  );
   const hasClaworldChannel = normalizedChannel === 'claworld'
-    || /:claworld:/i.test(normalizedSessionKey || '');
+    || /:claworld:/i.test(normalizedSessionKey || '')
+    || hasClaworldConversationSessionKey;
   if (!hasClaworldChannel) return false;
   if (
     normalizedSessionType === 'conversation'
@@ -300,6 +510,7 @@ function isClaworldConversationBootstrapContext({
   }
   return (
     /^agent:[^:]+:claworld:(direct|world):/i.test(normalizedSessionKey || '')
+    || /^agent:[^:]+:conversation:.*:(direct|world)(:|$)/i.test(normalizedSessionKey || '')
     || /^conversation:.*:(direct|world)(:|$)/i.test(normalizedSessionKey || '')
   );
 }
@@ -407,9 +618,9 @@ export function resolveClaworldBootstrapContext(...sources) {
     collectBootstrapRecords(source, records);
   }
   return {
-    channel: firstBootstrapField(records, ['channel', 'channelId']),
-    sessionKey: firstBootstrapField(records, ['sessionKey', 'localSessionKey']),
-    sessionType: firstBootstrapField(records, ['sessionType', 'sessionKind', 'sessionMode', 'mode']),
+    channel: firstBootstrapField(records, ['channel', 'channelId', 'OriginatingChannel', 'Provider', 'Surface']),
+    sessionKey: firstBootstrapField(records, ['sessionKey', 'localSessionKey', 'SessionKey', 'RelaySessionKey']),
+    sessionType: firstBootstrapField(records, ['sessionType', 'sessionKind', 'sessionMode', 'mode', 'SessionType', 'ChatType']),
   };
 }
 
@@ -424,9 +635,43 @@ export function resolveClaworldBootstrapTarget(context = {}) {
   if (isClaworldConversationBootstrapContext(normalizedContext)) {
     return CLAWORLD_BOOTSTRAP_TARGETS.CLAWORLD_CONVERSATION;
   }
+  if (isExternalMainBootstrapContext(normalizedContext)) {
+    return CLAWORLD_BOOTSTRAP_TARGETS.MAIN;
+  }
   return CLAWORLD_BOOTSTRAP_TARGETS.NONE;
 }
 
+function resolveClaworldSessionDirectoryKind(input = {}, relations = {}) {
+  const explicitScope = normalizeText(input.scope, null);
+  if (explicitScope === 'main') return 'main';
+  if (explicitScope === 'management') return 'management';
+  if (explicitScope === 'conversation') return 'conversation';
+  const context = isPlainObject(input.context) ? input.context : {};
+  const target = resolveClaworldBootstrapTarget({
+    sessionKey: firstText(
+      relations.localSessionKey,
+      relations.sessionKey,
+      input.localSessionKey,
+      input.sessionKey,
+      context.SessionKey,
+      context.sessionKey,
+    ),
+    sessionType: firstText(
+      input.sessionType,
+      input.sessionKind,
+      context.SessionType,
+      context.ChatType,
+      context.sessionType,
+      context.sessionKind,
+    ),
+    channel: firstText(context.OriginatingChannel, context.channel),
+  });
+  if (target === CLAWORLD_BOOTSTRAP_TARGETS.MAIN) return 'main';
+  if (target === CLAWORLD_BOOTSTRAP_TARGETS.MANAGEMENT) return 'management';
+  if (target === CLAWORLD_BOOTSTRAP_TARGETS.CLAWORLD_CONVERSATION) return 'conversation';
+  return null;
+}
+
 async function readTextIfPresent(filePath) {
   try {
     return await fs.readFile(filePath, 'utf8');
@@ -436,6 +681,17 @@ async function readTextIfPresent(filePath) {
   }
 }
 
+async function readJsonIfPresent(filePath) {
+  const text = await readTextIfPresent(filePath);
+  if (text == null) return null;
+  try {
+    const parsed = JSON.parse(text);
+    return isPlainObject(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
 async function atomicWriteText(filePath, content, {
   backup = true,
   rejectEmptyOverwrite = true,
@@ -530,8 +786,8 @@ function toIsoTimestamp(value = null) {
   return date.toISOString();
 }
 
-function toMonthKey(timestamp) {
-  return toIsoTimestamp(timestamp).slice(0, 7);
+function toDayKey(timestamp) {
+  return toIsoTimestamp(timestamp).slice(0, 10);
 }
 
 function truncateText(value, maxChars = MAX_EVENT_EXCERPT_CHARS) {
@@ -540,10 +796,387 @@ function truncateText(value, maxChars = MAX_EVENT_EXCERPT_CHARS) {
   return `${text.slice(0, Math.max(0, maxChars - 3))}...`;
 }
 
+function resolveClaworldSessionDirectoryPath(workspaceRoot) {
+  return path.join(
+    workspaceRoot,
+    CLAWORLD_WORKING_MEMORY_DIR,
+    CLAWORLD_SESSION_DIRECTORY_FILE,
+  );
+}
+
+function createEmptyClaworldSessionDirectory(timestamp = null) {
+  return {
+    schema: CLAWORLD_SESSION_DIRECTORY_SCHEMA,
+    version: 1,
+    updatedAt: toIsoTimestamp(timestamp),
+    main: {},
+    management: {},
+    conversationSessions: {},
+  };
+}
+
+function normalizeClaworldSessionDirectory(value = null) {
+  const source = isPlainObject(value) ? value : {};
+  const directory = {
+    ...source,
+    schema: CLAWORLD_SESSION_DIRECTORY_SCHEMA,
+    version: 1,
+    updatedAt: normalizeText(source.updatedAt, toIsoTimestamp()),
+    main: isPlainObject(source.main) ? { ...source.main } : {},
+    management: isPlainObject(source.management) ? { ...source.management } : {},
+    conversationSessions: isPlainObject(source.conversationSessions)
+      ? { ...source.conversationSessions }
+      : {},
+  };
+  return directory;
+}
+
+function normalizeChatRequestId(input = {}, relations = {}) {
+  return firstText(
+    relations.chatRequestId,
+    relations.requestId,
+    input.chatRequestId,
+    input.requestId,
+    input.refs?.chatRequestId,
+    input.refs?.requestId,
+  );
+}
+
+function compactDirectoryObject(value = {}) {
+  return cleanJournalObject(value);
+}
+
+function upsertSessionArtifact(artifacts = [], artifact = {}) {
+  const normalizedArtifact = compactDirectoryObject(artifact);
+  if (
+    !normalizedArtifact.sessionId
+    && !normalizedArtifact.sessionFile
+    && !normalizedArtifact.transcriptPath
+  ) {
+    return artifacts;
+  }
+  const key = [
+    normalizedArtifact.sessionId || '',
+    normalizedArtifact.sessionFile || '',
+    normalizedArtifact.transcriptPath || '',
+  ].join('\u0000');
+  const nextArtifacts = Array.isArray(artifacts) ? [...artifacts] : [];
+  const index = nextArtifacts.findIndex((entry) => [
+    entry?.sessionId || '',
+    entry?.sessionFile || '',
+    entry?.transcriptPath || '',
+  ].join('\u0000') === key);
+  if (index >= 0) {
+    nextArtifacts[index] = compactDirectoryObject({
+      ...nextArtifacts[index],
+      ...normalizedArtifact,
+      firstSeenAt: nextArtifacts[index].firstSeenAt || normalizedArtifact.firstSeenAt,
+      lastSeenAt: normalizedArtifact.lastSeenAt || nextArtifacts[index].lastSeenAt,
+    });
+    return nextArtifacts;
+  }
+  nextArtifacts.push(normalizedArtifact);
+  return nextArtifacts;
+}
+
+function applySessionArtifactHints(target = {}, relations = {}) {
+  const nextTarget = { ...target };
+  if (relations.sessionId) nextTarget.latestSessionId = relations.sessionId;
+  if (relations.sessionFile) nextTarget.latestSessionFile = relations.sessionFile;
+  if (relations.transcriptPath) nextTarget.latestTranscriptPath = relations.transcriptPath;
+  return nextTarget;
+}
+
+function buildSessionArtifact({ relations = {}, timestamp = null } = {}) {
+  return compactDirectoryObject({
+    sessionId: relations.sessionId,
+    sessionFile: relations.sessionFile,
+    sessionStorePath: relations.sessionStorePath,
+    transcriptPath: relations.transcriptPath,
+    deliveryId: relations.deliveryId,
+    eventId: relations.eventId,
+    firstSeenAt: timestamp,
+    lastSeenAt: timestamp,
+  });
+}
+
+function applyClaworldSessionDirectoryUpdate(directory = {}, input = {}) {
+  const refs = isPlainObject(input.refs) ? input.refs : {};
+  const relations = resolveJournalRelations(input, refs);
+  const kind = resolveClaworldSessionDirectoryKind(input, relations);
+  const timestamp = toIsoTimestamp(input.timestamp || Date.now());
+  const localSessionKey = firstText(relations.localSessionKey, relations.sessionKey, input.localSessionKey, input.sessionKey);
+  const relaySessionKey = firstText(relations.relaySessionKey, input.relaySessionKey);
+  if (!kind || !localSessionKey) {
+    return { updated: false, reason: 'missing_session_reference', directory };
+  }
+
+  const nextDirectory = normalizeClaworldSessionDirectory(directory);
+  nextDirectory.updatedAt = timestamp;
+
+  if (kind === 'main') {
+    nextDirectory.main = compactDirectoryObject({
+      ...nextDirectory.main,
+      lastActiveSessionKey: localSessionKey,
+      lastUpdatedAt: timestamp,
+      localAgentId: relations.localAgentId,
+      source: input.source,
+    });
+    return { updated: true, kind, directory: nextDirectory };
+  }
+
+  if (kind === 'management') {
+    nextDirectory.management = compactDirectoryObject({
+      ...nextDirectory.management,
+      lastActiveLocalSessionKey: localSessionKey,
+      relaySessionKey,
+      localAgentId: relations.localAgentId,
+      targetAgentId: relations.targetAgentId,
+      lastUpdatedAt: timestamp,
+    });
+    return { updated: true, kind, directory: nextDirectory };
+  }
+
+  const conversationSessions = isPlainObject(nextDirectory.conversationSessions)
+    ? { ...nextDirectory.conversationSessions }
+    : {};
+  const currentSession = isPlainObject(conversationSessions[localSessionKey])
+    ? conversationSessions[localSessionKey]
+    : {};
+  let nextSession = applySessionArtifactHints(
+    compactDirectoryObject({
+      ...currentSession,
+      localSessionKey,
+      relaySessionKey,
+      conversationKey: firstText(currentSession.conversationKey, relations.conversationKey),
+      worldId: firstText(currentSession.worldId, relations.worldId),
+      localAgentId: firstText(currentSession.localAgentId, relations.localAgentId),
+      firstSeenAt: currentSession.firstSeenAt || timestamp,
+      lastSeenAt: timestamp,
+    }),
+    relations,
+  );
+
+  const chatRequestId = normalizeChatRequestId(input, relations);
+  if (chatRequestId) {
+    const chatRequests = isPlainObject(nextSession.chatRequests)
+      ? { ...nextSession.chatRequests }
+      : {};
+    const currentRequest = isPlainObject(chatRequests[chatRequestId])
+      ? chatRequests[chatRequestId]
+      : {};
+    const artifact = buildSessionArtifact({ relations, timestamp });
+    const nextRequest = applySessionArtifactHints(
+      compactDirectoryObject({
+        ...currentRequest,
+        chatRequestId,
+        firstSeenAt: currentRequest.firstSeenAt || timestamp,
+        lastSeenAt: timestamp,
+        sessionArtifacts: upsertSessionArtifact(currentRequest.sessionArtifacts, artifact),
+      }),
+      relations,
+    );
+    chatRequests[chatRequestId] = nextRequest;
+    nextSession = compactDirectoryObject({
+      ...nextSession,
+      chatRequests,
+    });
+  }
+
+  conversationSessions[localSessionKey] = nextSession;
+  nextDirectory.conversationSessions = conversationSessions;
+  return { updated: true, kind, directory: nextDirectory };
+}
+
+export async function readClaworldSessionDirectory(options = {}, readOptions = {}) {
+  const workspaceRoot = resolveClaworldWorkspaceRoot(options, readOptions.homeDir || os.homedir());
+  const sessionDirectoryPath = resolveClaworldSessionDirectoryPath(workspaceRoot);
+  const current = await readJsonIfPresent(sessionDirectoryPath);
+  return {
+    workspaceRoot,
+    sessionDirectoryPath,
+    directory: normalizeClaworldSessionDirectory(current || createEmptyClaworldSessionDirectory()),
+    exists: current != null,
+  };
+}
+
+export async function updateClaworldSessionDirectory(options = {}, input = {}, updateOptions = {}) {
+  const workspaceRoot = resolveClaworldWorkspaceRoot(options, updateOptions.homeDir || os.homedir());
+  await ensureClaworldWorkingMemory(workspaceRoot, updateOptions);
+  const sessionDirectoryPath = resolveClaworldSessionDirectoryPath(workspaceRoot);
+  const current = await readJsonIfPresent(sessionDirectoryPath);
+  const baseDirectory = current || createEmptyClaworldSessionDirectory(input.timestamp || updateOptions.timestamp);
+  const result = applyClaworldSessionDirectoryUpdate(baseDirectory, input);
+  if (!result.updated) {
+    return {
+      ok: true,
+      updated: false,
+      reason: result.reason,
+      workspaceRoot,
+      sessionDirectoryPath,
+      directory: normalizeClaworldSessionDirectory(baseDirectory),
+    };
+  }
+  await atomicWriteText(
+    sessionDirectoryPath,
+    `${JSON.stringify(result.directory, null, 2)}\n`,
+    {
+      backup: false,
+      rejectEmptyOverwrite: false,
+    },
+  );
+  return {
+    ok: true,
+    updated: true,
+    kind: result.kind,
+    workspaceRoot,
+    sessionDirectoryPath,
+    directory: result.directory,
+  };
+}
+
 function flattenInline(value) {
   return truncateText(String(value ?? '').replace(/\s+/g, ' ').trim());
 }
 
+function firstText(...values) {
+  for (const value of values) {
+    const normalized = normalizeText(value, null);
+    if (normalized) return normalized;
+  }
+  return null;
+}
+
+function hasStructuredValue(value) {
+  if (value == null) return false;
+  if (typeof value === 'string') return normalizeText(value, null) != null;
+  if (Array.isArray(value)) return value.length > 0;
+  if (isPlainObject(value)) return Object.keys(value).length > 0;
+  return true;
+}
+
+function cleanJournalValue(value) {
+  if (value == null) return null;
+  if (value instanceof Date) return toIsoTimestamp(value);
+  if (typeof value === 'string') return normalizeText(value, null);
+  if (typeof value === 'number' || typeof value === 'boolean') return value;
+  if (Array.isArray(value)) {
+    const cleanedArray = value
+      .map((entry) => cleanJournalValue(entry))
+      .filter(hasStructuredValue);
+    return cleanedArray.length > 0 ? cleanedArray : null;
+  }
+  if (isPlainObject(value)) {
+    const cleanedObject = {};
+    for (const [key, entry] of Object.entries(value)) {
+      const cleaned = cleanJournalValue(entry);
+      if (hasStructuredValue(cleaned)) {
+        cleanedObject[key] = cleaned;
+      }
+    }
+    return Object.keys(cleanedObject).length > 0 ? cleanedObject : null;
+  }
+  return normalizeText(value, null);
+}
+
+function cleanJournalObject(value = {}) {
+  return cleanJournalValue(value) || {};
+}
+
+function resolveJournalScope(input = {}, relations = {}) {
+  const directScope = normalizeText(input.scope, null);
+  if (directScope) return directScope;
+  const context = isPlainObject(input.context) ? input.context : {};
+  const normalizedTarget = resolveClaworldBootstrapTarget({
+    sessionKey: firstText(
+      input.localSessionKey,
+      input.sessionKey,
+      relations.localSessionKey,
+      relations.sessionKey,
+      context.SessionKey,
+      context.sessionKey,
+    ),
+    sessionType: firstText(
+      input.sessionType,
+      input.sessionKind,
+      context.SessionType,
+      context.ChatType,
+      context.sessionType,
+      context.sessionKind,
+    ),
+    channel: firstText(context.OriginatingChannel, context.channel),
+  });
+  if (normalizedTarget === CLAWORLD_BOOTSTRAP_TARGETS.CLAWORLD_CONVERSATION) return 'conversation';
+  if (normalizedTarget === CLAWORLD_BOOTSTRAP_TARGETS.MANAGEMENT) return 'management';
+  if (normalizedTarget === CLAWORLD_BOOTSTRAP_TARGETS.MAIN) return 'main';
+  return firstText(input.sessionKind, input.sessionType, context.sessionKind, context.SessionType, 'runtime');
+}
+
+function resolveJournalRelations(input = {}, refs = {}) {
+  const relations = isPlainObject(input.relations)
+    ? input.relations
+    : isPlainObject(input.correlation)
+      ? input.correlation
+      : {};
+  const context = isPlainObject(input.context) ? input.context : {};
+  const artifacts = isPlainObject(input.artifacts) ? input.artifacts : {};
+  const requestId = firstText(
+    relations.requestId,
+    relations.chatRequestId,
+    input.requestId,
+    input.chatRequestId,
+    refs.requestId,
+    refs.chatRequestId,
+    refs.friendRequestId,
+  );
+  return cleanJournalObject({
+    requestId,
+    chatRequestId: firstText(relations.chatRequestId, input.chatRequestId, refs.chatRequestId, requestId),
+    deliveryId: firstText(relations.deliveryId, input.deliveryId, refs.deliveryId, context.RelayDeliveryId),
+    eventId: firstText(relations.eventId, input.eventId, input.id, refs.eventId, context.RelayEventId),
+    notificationId: firstText(relations.notificationId, refs.notificationId),
+    inboxItemId: firstText(relations.inboxItemId, refs.inboxItemId),
+    conversationKey: firstText(relations.conversationKey, input.conversationKey, refs.conversationKey),
+    worldId: firstText(relations.worldId, input.worldId, refs.worldId),
+    accountId: firstText(relations.accountId, input.accountId, refs.accountId, context.AccountId),
+    agentCode: firstText(relations.agentCode, refs.agentCode),
+    localAgentId: firstText(relations.localAgentId, input.localAgentId, context.AgentId, context.agentId),
+    targetAgentId: firstText(relations.targetAgentId, input.targetAgentId, refs.targetAgentId, context.RelayTargetAgentId),
+    fromAgentId: firstText(relations.fromAgentId, input.fromAgentId, refs.fromAgentId, context.RelayFromAgentId),
+    sessionKey: firstText(relations.sessionKey, input.sessionKey, context.SessionKey, context.sessionKey),
+    localSessionKey: firstText(relations.localSessionKey, input.localSessionKey, context.LocalSessionKey, context.SessionKey),
+    relaySessionKey: firstText(relations.relaySessionKey, input.relaySessionKey, context.RelaySessionKey),
+    sessionId: firstText(relations.sessionId, input.sessionId, artifacts.sessionId, context.SessionId),
+    sessionFile: firstText(relations.sessionFile, input.sessionFile, artifacts.sessionFile, artifacts.sessionPath, context.SessionFile),
+    sessionStorePath: firstText(relations.sessionStorePath, input.sessionStorePath, artifacts.sessionStorePath),
+    transcriptPath: firstText(relations.transcriptPath, input.transcriptPath, artifacts.transcriptPath),
+    reportPath: firstText(relations.reportPath, input.reportPath, artifacts.reportPath),
+  });
+}
+
+function buildJournalKey(relations = {}, fallbackEventId = null) {
+  const event = firstText(relations.eventId, fallbackEventId);
+  const request = firstText(relations.requestId, relations.chatRequestId);
+  const session = firstText(relations.localSessionKey, relations.relaySessionKey, relations.sessionKey);
+  const continuity = request
+    ? `request:${request}`
+    : firstText(
+      relations.conversationKey ? `conversation:${relations.conversationKey}` : null,
+      session ? `session:${session}` : null,
+      relations.worldId ? `world:${relations.worldId}` : null,
+      event ? `event:${event}` : null,
+    );
+  return cleanJournalObject({
+    event,
+    continuity,
+    request,
+    session,
+    sessionId: relations.sessionId,
+    world: relations.worldId,
+    conversation: relations.conversationKey,
+  });
+}
+
 export function buildClaworldMaintenanceEvent(input = {}) {
   const toolName = normalizeText(input.toolName, null);
   const source = normalizeText(input.source, toolName ? 'claworld_tool' : 'claworld_runtime');
@@ -557,14 +1190,26 @@ export function buildClaworldMaintenanceEvent(input = {}) {
         .filter(([, value]) => value != null),
     )
     : {};
+  const id = normalizeText(input.id, `${source}:${kind}:${timestamp}`);
+  const relations = resolveJournalRelations({ ...input, eventId: input.eventId || id }, refs);
+  const scope = resolveJournalScope(input, relations);
   return {
-    id: normalizeText(input.id, `${source}:${kind}:${timestamp}`),
+    schema: CLAWORLD_JOURNAL_SCHEMA,
+    id,
     timestamp,
     source,
     kind,
+    eventType: normalizeText(input.eventType, kind),
+    scope,
     summary,
     excerpt: truncateText(input.excerpt || ''),
     refs,
+    key: buildJournalKey(relations, id),
+    relations,
+    actor: cleanJournalObject(input.actor || {}),
+    tool: cleanJournalObject(input.tool || {}),
+    artifacts: cleanJournalObject(input.artifacts || {}),
+    maintenance: cleanJournalObject(input.maintenance || {}),
   };
 }
 
@@ -597,9 +1242,11 @@ function compactResultPayload(payload = {}) {
   const keys = [
     'status',
     'tool',
+    'action',
     'accountId',
     'worldId',
     'displayName',
+    'requestId',
     'chatRequestId',
     'conversationKey',
     'feedbackId',
@@ -616,29 +1263,96 @@ function compactResultPayload(payload = {}) {
   return compact;
 }
 
+function readNestedObject(value, key) {
+  const nested = value?.[key];
+  return nested && typeof nested === 'object' && !Array.isArray(nested) ? nested : {};
+}
+
 export function buildClaworldToolMaintenanceEvent({
   toolName,
   params = {},
   result = null,
   timestamp = null,
+  context = {},
 } = {}) {
   const normalizedToolName = normalizeText(toolName, null);
   if (!normalizedToolName || !normalizedToolName.startsWith('claworld_')) return null;
   const payload = parseToolResultPayload(result) || {};
+  const chatRequest = readNestedObject(payload, 'chatRequest');
+  const request = readNestedObject(payload, 'request');
+  const kickoff = readNestedObject(payload, 'kickoff');
+  const conversation = readNestedObject(payload, 'conversation');
   const compactPayload = compactResultPayload(payload);
+  const requestId = firstText(
+    params.requestId,
+    params.chatRequestId,
+    payload.requestId,
+    payload.chatRequestId,
+    chatRequest.chatRequestId,
+    chatRequest.requestId,
+    request.requestId,
+  );
+  const localSessionKey = firstText(
+    context.sessionKey,
+    context.SessionKey,
+    context.localSessionKey,
+    payload.localSessionKey,
+    kickoff.localSessionKey,
+  );
+  const relaySessionKey = firstText(
+    context.RelaySessionKey,
+    payload.sessionKey,
+    kickoff.sessionKey,
+    conversation.sessionKey,
+  );
+  const sessionKind = resolveJournalScope({
+    sessionKey: localSessionKey || relaySessionKey,
+    sessionType: firstText(context.sessionType, context.SessionType, context.ChatType, context.sessionKind),
+    context,
+  });
   const refs = {
     accountId: params.accountId || payload.accountId,
     worldId: params.worldId || payload.worldId,
-    chatRequestId: params.chatRequestId || payload.chatRequestId,
-    conversationKey: params.conversationKey || payload.conversationKey,
+    requestId,
+    chatRequestId: params.chatRequestId || payload.chatRequestId || chatRequest.chatRequestId,
+    conversationKey: params.conversationKey || payload.conversationKey || conversation.conversationKey,
     agentCode: params.agentCode || payload.agentCode,
+    sessionKey: localSessionKey || relaySessionKey,
+    relaySessionKey,
   };
   return buildClaworldMaintenanceEvent({
     source: 'claworld_tool',
     kind: normalizedToolName,
+    eventType: 'tool_call',
+    scope: sessionKind,
     toolName: normalizedToolName,
     timestamp,
     refs,
+    relations: {
+      requestId,
+      chatRequestId: refs.chatRequestId,
+      conversationKey: refs.conversationKey,
+      worldId: refs.worldId,
+      accountId: refs.accountId,
+      agentCode: refs.agentCode,
+      localSessionKey,
+      relaySessionKey,
+      sessionKey: localSessionKey || relaySessionKey,
+      localAgentId: firstText(context.agentId, context.AgentId),
+      sessionId: firstText(context.sessionId, context.SessionId),
+      sessionFile: firstText(context.sessionFile, context.SessionFile, context.sessionPath),
+      transcriptPath: firstText(context.transcriptPath),
+    },
+    actor: {
+      sessionKind,
+      agentId: firstText(context.agentId, context.AgentId),
+      sessionKey: localSessionKey || relaySessionKey,
+    },
+    tool: {
+      name: normalizedToolName,
+      action: firstText(params.action, payload.action),
+      status: firstText(payload.status, 'succeeded'),
+    },
     summary: `${normalizedToolName} succeeded.`,
     excerpt: Object.keys(compactPayload).length > 0
       ? JSON.stringify(compactPayload)
@@ -646,45 +1360,84 @@ export function buildClaworldToolMaintenanceEvent({
   });
 }
 
-function formatRefs(refs = {}) {
-  return Object.entries(refs)
-    .filter(([, value]) => value != null)
-    .map(([key, value]) => `${key}=${flattenInline(value)}`)
-    .join(', ');
+function buildJournalEntryPayload(event = {}) {
+  return cleanJournalObject({
+    schema: CLAWORLD_JOURNAL_SCHEMA,
+    id: event.id,
+    key: event.key,
+    timestamp: event.timestamp,
+    source: event.source,
+    scope: event.scope,
+    eventType: event.eventType,
+    kind: event.kind,
+    summary: event.summary,
+    refs: event.refs,
+    relations: event.relations,
+    actor: event.actor,
+    tool: event.tool,
+    artifacts: event.artifacts,
+    maintenance: event.maintenance,
+    excerpt: event.excerpt || null,
+  });
+}
+
+function buildJournalEntry(event = {}) {
+  const title = flattenInline(event.summary || event.kind || 'Claworld event recorded.');
+  const heading = [
+    event.timestamp,
+    event.scope || event.source,
+    event.kind,
+    title,
+  ].filter(Boolean).join(' · ');
+  return [
+    `## ${heading}`,
+    '',
+    '```json',
+    JSON.stringify(buildJournalEntryPayload(event), null, 2),
+    '```',
+    '',
+  ].join('\n');
 }
 
 export async function appendClaworldJournalEvent(options = {}, event = {}, appendOptions = {}) {
   const workspaceRoot = resolveClaworldWorkspaceRoot(options, appendOptions.homeDir || os.homedir());
   await ensureClaworldWorkingMemory(workspaceRoot, appendOptions);
   const normalizedEvent = buildClaworldMaintenanceEvent(event);
-  const monthKey = toMonthKey(normalizedEvent.timestamp);
+  const dayKey = toDayKey(normalizedEvent.timestamp);
   const journalPath = path.join(
     workspaceRoot,
     CLAWORLD_WORKING_MEMORY_DIR,
     CLAWORLD_JOURNAL_DIR,
-    `${monthKey}.md`,
+    `${dayKey}.md`,
   );
   const currentContent = await readTextIfPresent(journalPath);
-  const refsLine = formatRefs(normalizedEvent.refs);
-  const entry = [
-    `## ${normalizedEvent.timestamp} - ${normalizedEvent.kind}`,
-    `- Source: ${normalizedEvent.source}`,
-    `- Summary: ${flattenInline(normalizedEvent.summary)}`,
-    normalizedEvent.excerpt ? `- Excerpt: ${flattenInline(normalizedEvent.excerpt)}` : null,
-    refsLine ? `- Refs: ${refsLine}` : null,
-    '',
-  ].filter((line) => line != null).join('\n');
+  const entry = buildJournalEntry(normalizedEvent);
   if (currentContent == null) {
-    await atomicWriteText(journalPath, `# Claworld Journal ${monthKey}\n\n${entry}`, {
+    await atomicWriteText(journalPath, `# Claworld Journal ${dayKey}\n\n${entry}`, {
       backup: false,
       rejectEmptyOverwrite: false,
     });
   } else {
     await fs.appendFile(journalPath, `${currentContent.endsWith('\n') ? '' : '\n'}${entry}`, 'utf8');
   }
+  let sessionDirectory = null;
+  if (appendOptions.updateSessionDirectory !== false) {
+    try {
+      sessionDirectory = await updateClaworldSessionDirectory(workspaceRoot, normalizedEvent, {
+        ...appendOptions,
+        timestamp: normalizedEvent.timestamp,
+      });
+    } catch (error) {
+      sessionDirectory = {
+        ok: false,
+        error: error?.message || String(error),
+      };
+    }
+  }
   return {
     ok: true,
     journalPath,
+    sessionDirectory,
     event: normalizedEvent,
   };
 }
@@ -731,11 +1484,27 @@ export async function buildClaworldBootstrapPromptContext(context = {}, options
     })
     : { slices: {} };
   const pointerInjected = target === CLAWORLD_BOOTSTRAP_TARGETS.MAIN;
+  const managementPolicyInjected = target === CLAWORLD_BOOTSTRAP_TARGETS.MANAGEMENT;
+  let managementMainSessionKey = null;
+  if (managementPolicyInjected && resolvedWorkspaceRoot) {
+    try {
+      const sessionDirectory = await readClaworldSessionDirectory(resolvedWorkspaceRoot);
+      managementMainSessionKey = normalizeText(
+        sessionDirectory.directory?.main?.lastActiveSessionKey,
+        null,
+      );
+    } catch {
+      managementMainSessionKey = null;
+    }
+  }
   const parts = [];
   let truncated = false;
   if (pointerInjected) {
     const pointerBudget = maxTotalChars - measureBootstrapParts(parts) - (parts.length > 0 ? 2 : 0);
-    const fittedPointer = truncateBootstrapText(buildClaworldContextPointer(), pointerBudget);
+    const fittedPointer = truncateBootstrapText(
+      buildClaworldContextPointer({ workspaceRoot: resolvedWorkspaceRoot }),
+      pointerBudget,
+    );
     if (fittedPointer.text) {
       parts.push(fittedPointer.text);
     }
@@ -743,6 +1512,22 @@ export async function buildClaworldBootstrapPromptContext(context = {}, options
       truncated = true;
     }
   }
+  if (managementPolicyInjected) {
+    const policyBudget = maxTotalChars - measureBootstrapParts(parts) - (parts.length > 0 ? 2 : 0);
+    const fittedPolicy = truncateBootstrapText(
+      buildClaworldManagementStartupPrompt({
+        workspaceRoot: resolvedWorkspaceRoot,
+        mainSessionKey: managementMainSessionKey,
+      }),
+      policyBudget,
+    );
+    if (fittedPolicy.text) {
+      parts.push(fittedPolicy.text);
+    }
+    if (fittedPolicy.truncated) {
+      truncated = true;
+    }
+  }
   const sectionTitle = target === CLAWORLD_BOOTSTRAP_TARGETS.MAIN
     ? '# Claworld Startup Memory'
     : target === CLAWORLD_BOOTSTRAP_TARGETS.MANAGEMENT
@@ -773,6 +1558,7 @@ export async function buildClaworldBootstrapPromptContext(context = {}, options
     workspaceRoot: resolvedWorkspaceRoot,
     files: selectedFiles.map((relativePath) => buildBootstrapFileLabel(relativePath)),
     pointerInjected,
+    managementPolicyInjected,
     fallbackFiles: fileSections.fallbackFiles,
     omittedFiles: fileSections.omittedFiles,
     truncated,
@@ -834,6 +1620,40 @@ function assertAllowedTarget(runType, target) {
   }
 }
 
+function normalizeMarkdownNewlines(content) {
+  return String(content ?? '').replace(/\r\n/g, '\n');
+}
+
+function assertContextMarkdownUsesBullets(target, normalizedContent, schema) {
+  const maxBulletLength = schema.maxBulletLength || null;
+  const lines = normalizedContent.split('\n');
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    if (!trimmed.startsWith('- ')) {
+      throw new Error(`Claworld maintenance patch for ${target} must use bullet lines under schema sections.`);
+    }
+    if (maxBulletLength && trimmed.length > maxBulletLength) {
+      throw new Error(`Claworld maintenance patch for ${target} has a bullet longer than ${maxBulletLength} characters.`);
+    }
+  }
+}
+
+function assertContextFileSchema(target, content) {
+  const schema = CLAWORLD_CONTEXT_FILE_SCHEMAS[target];
+  if (!schema) return;
+  const normalizedContent = normalizeMarkdownNewlines(content);
+  if (!normalizedContent.startsWith(`${schema.title}\n`)) {
+    throw new Error(`Claworld maintenance patch for ${target} must start with ${schema.title}.`);
+  }
+  for (const heading of schema.headings) {
+    if (!normalizedContent.includes(`\n${heading}\n`)) {
+      throw new Error(`Claworld maintenance patch for ${target} is missing required section ${heading}.`);
+    }
+  }
+  assertContextMarkdownUsesBullets(target, normalizedContent, schema);
+}
+
 function normalizeReportPatch(report, index) {
   const filename = normalizeText(report?.filename ?? report?.name, `report-${index + 1}.md`);
   const normalizedFilename = path.posix.basename(filename.endsWith('.md') ? filename : `${filename}.md`);
@@ -890,10 +1710,10 @@ export function normalizeClaworldMaintenanceOutput(runType, output = {}, options
     patches.push(normalizeFilePatchValue(output.memoryMd, CLAWORLD_WORKING_MEMORY_FILES.memory, 'memoryMd'));
   }
   if (Object.prototype.hasOwnProperty.call(output, 'journalAppendMd')) {
-    const monthKey = toMonthKey(options.timestamp || output.timestamp || Date.now());
+    const dayKey = toDayKey(options.timestamp || output.timestamp || Date.now());
     patches.push({
       operation: 'append_section',
-      target: `${CLAWORLD_JOURNAL_DIR}/${monthKey}.md`,
+      target: `${CLAWORLD_JOURNAL_DIR}/${dayKey}.md`,
       content: String(output.journalAppendMd ?? ''),
     });
   }
@@ -926,6 +1746,9 @@ export function normalizeClaworldMaintenanceOutput(runType, output = {}, options
       target,
       content: String(patch.content ?? ''),
     };
+    if (operation === 'replace') {
+      assertContextFileSchema(target, normalizedPatch.content);
+    }
     const rationale = normalizeText(patch.rationale, null);
     if (rationale) normalizedPatch.rationale = rationale;
     return normalizedPatch;
@@ -955,8 +1778,8 @@ async function applyMaintenancePatch(workspaceRoot, patch) {
     await fs.mkdir(path.dirname(absolutePath), { recursive: true });
     const currentContent = await readTextIfPresent(absolutePath);
     if (currentContent == null) {
-      const monthKey = path.basename(patch.target, '.md');
-      await atomicWriteText(absolutePath, `# Claworld Journal ${monthKey}\n\n${patch.content}`, {
+      const dayKey = path.basename(patch.target, '.md');
+      await atomicWriteText(absolutePath, `# Claworld Journal ${dayKey}\n\n${patch.content}`, {
         backup: false,
         rejectEmptyOverwrite: false,
       });