fix: refresh role rules after compaction

src/agent-runner.ts

@@ -50,6 +50,10 @@ export interface AgentOutput {
   agentDone?: boolean;
   newSessionId?: string;
   error?: string;
+  compaction?: {
+    completed: boolean;
+    trigger?: string | null;
+  };
 }
 
 function readRoomSkillOverridesForRunner(

src/compact-refresh.test.ts

@@ -0,0 +1,104 @@
+import fs from 'fs';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+vi.mock('./config.js', () => ({
+  DATA_DIR: '/tmp/ejclaw-compact-refresh-test',
+}));
+
+import {
+  clearCompactRefreshIfUnchanged,
+  markCompactRefreshNeeded,
+  maybeApplyCompactRefresh,
+  readCompactRefreshFlag,
+} from './compact-refresh.js';
+
+const refreshDir = '/tmp/ejclaw-compact-refresh-test/compact-refresh';
+
+describe('compact-refresh', () => {
+  beforeEach(() => {
+    fs.rmSync(refreshDir, { recursive: true, force: true });
+  });
+
+  it('marks and reads compact refresh flags by session folder', () => {
+    const flag = markCompactRefreshNeeded({
+      sessionFolder: 'room:reviewer',
+      sessionId: 'session-1',
+      trigger: 'auto',
+    });
+
+    expect(readCompactRefreshFlag('room:reviewer')).toMatchObject({
+      sessionFolder: 'room:reviewer',
+      sessionId: 'session-1',
+      trigger: 'auto',
+      compactedAt: flag.compactedAt,
+    });
+  });
+
+  it('applies a one-shot compact refresh only for owner and reviewer roles', () => {
+    const flag = markCompactRefreshNeeded({
+      sessionFolder: 'room',
+      sessionId: 'session-1',
+    });
+
+    const applied = maybeApplyCompactRefresh({
+      sessionFolder: 'room',
+      sessionId: 'session-1',
+      role: 'owner',
+      prompt: 'continue task',
+    });
+
+    expect(applied?.flag).toEqual(flag);
+    expect(applied?.prompt).toContain('EJClaw compact refresh');
+    expect(applied?.prompt).toContain('continue task');
+
+    clearCompactRefreshIfUnchanged({
+      sessionFolder: 'room',
+      flag,
+    });
+
+    expect(readCompactRefreshFlag('room')).toBeNull();
+  });
+
+  it('does not apply to arbiter, compact commands, fresh sessions, or stale sessions', () => {
+    markCompactRefreshNeeded({
+      sessionFolder: 'room',
+      sessionId: 'session-1',
+    });
+
+    expect(
+      maybeApplyCompactRefresh({
+        sessionFolder: 'room',
+        sessionId: 'session-1',
+        role: 'arbiter',
+        prompt: 'judge',
+      }),
+    ).toBeNull();
+
+    expect(
+      maybeApplyCompactRefresh({
+        sessionFolder: 'room',
+        sessionId: 'session-1',
+        role: 'owner',
+        prompt: '/compact',
+      }),
+    ).toBeNull();
+
+    expect(
+      maybeApplyCompactRefresh({
+        sessionFolder: 'room',
+        role: 'owner',
+        prompt: 'fresh',
+      }),
+    ).toBeNull();
+
+    expect(
+      maybeApplyCompactRefresh({
+        sessionFolder: 'room',
+        sessionId: 'different-session',
+        role: 'owner',
+        prompt: 'stale',
+      }),
+    ).toBeNull();
+    expect(readCompactRefreshFlag('room')).toBeNull();
+  });
+});

src/compact-refresh.ts

@@ -0,0 +1,128 @@
+import fs from 'fs';
+import path from 'path';
+
+import { DATA_DIR } from './config.js';
+import type { PairedRoomRole } from './types.js';
+
+export interface CompactRefreshFlag {
+  sessionFolder: string;
+  sessionId: string;
+  compactedAt: string;
+  trigger?: string | null;
+}
+
+export interface AppliedCompactRefresh {
+  flag: CompactRefreshFlag;
+  prompt: string;
+}
+
+const COMPACT_REFRESH_DIR = path.join(DATA_DIR, 'compact-refresh');
+
+const COMPACT_REFRESH_PROMPT = `[EJClaw compact refresh]
+The previous run compacted this same SDK session. Continue following the current AGENTS.md/CLAUDE.md role rules exactly: required first-line status, paired-room role boundaries, output-only task context, concise Korean responses, and verification before completion. This is not new user scope.
+[/EJClaw compact refresh]`;
+
+function getFlagPath(sessionFolder: string): string {
+  return path.join(
+    COMPACT_REFRESH_DIR,
+    `${encodeURIComponent(sessionFolder)}.json`,
+  );
+}
+
+function isRefreshableRole(role: PairedRoomRole): boolean {
+  return role === 'owner' || role === 'reviewer';
+}
+
+function isSessionCommand(prompt: string): boolean {
+  return prompt.trim() === '/compact';
+}
+
+export function readCompactRefreshFlag(
+  sessionFolder: string,
+): CompactRefreshFlag | null {
+  const flagPath = getFlagPath(sessionFolder);
+  if (!fs.existsSync(flagPath)) return null;
+
+  try {
+    const parsed = JSON.parse(
+      fs.readFileSync(flagPath, 'utf-8'),
+    ) as Partial<CompactRefreshFlag>;
+    if (
+      parsed.sessionFolder !== sessionFolder ||
+      typeof parsed.sessionId !== 'string' ||
+      parsed.sessionId.length === 0 ||
+      typeof parsed.compactedAt !== 'string'
+    ) {
+      fs.rmSync(flagPath, { force: true });
+      return null;
+    }
+    return {
+      sessionFolder,
+      sessionId: parsed.sessionId,
+      compactedAt: parsed.compactedAt,
+      trigger:
+        typeof parsed.trigger === 'string' && parsed.trigger.length > 0
+          ? parsed.trigger
+          : null,
+    };
+  } catch {
+    fs.rmSync(flagPath, { force: true });
+    return null;
+  }
+}
+
+export function markCompactRefreshNeeded(args: {
+  sessionFolder: string;
+  sessionId: string;
+  trigger?: string | null;
+}): CompactRefreshFlag {
+  const flag: CompactRefreshFlag = {
+    sessionFolder: args.sessionFolder,
+    sessionId: args.sessionId,
+    compactedAt: new Date().toISOString(),
+    trigger: args.trigger ?? null,
+  };
+  fs.mkdirSync(COMPACT_REFRESH_DIR, { recursive: true });
+  fs.writeFileSync(
+    getFlagPath(args.sessionFolder),
+    `${JSON.stringify(flag)}\n`,
+  );
+  return flag;
+}
+
+export function clearCompactRefreshIfUnchanged(args: {
+  sessionFolder: string;
+  flag: CompactRefreshFlag;
+}): void {
+  const current = readCompactRefreshFlag(args.sessionFolder);
+  if (
+    current &&
+    current.sessionId === args.flag.sessionId &&
+    current.compactedAt === args.flag.compactedAt
+  ) {
+    fs.rmSync(getFlagPath(args.sessionFolder), { force: true });
+  }
+}
+
+export function maybeApplyCompactRefresh(args: {
+  sessionFolder: string;
+  sessionId?: string;
+  role: PairedRoomRole;
+  prompt: string;
+}): AppliedCompactRefresh | null {
+  if (!args.sessionId) return null;
+  if (!isRefreshableRole(args.role)) return null;
+  if (isSessionCommand(args.prompt)) return null;
+
+  const flag = readCompactRefreshFlag(args.sessionFolder);
+  if (!flag) return null;
+  if (flag.sessionId !== args.sessionId) {
+    fs.rmSync(getFlagPath(args.sessionFolder), { force: true });
+    return null;
+  }
+
+  return {
+    flag,
+    prompt: `${COMPACT_REFRESH_PROMPT}\n\n${args.prompt}`,
+  };
+}

src/message-agent-compact-refresh.test.ts

@@ -0,0 +1,114 @@
+import fs from 'fs';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+vi.mock('./config.js', () => ({
+  DATA_DIR: '/tmp/ejclaw-message-compact-refresh-test',
+}));
+
+vi.mock('./agent-runner.js', () => ({
+  runAgentProcess: vi.fn(),
+}));
+
+vi.mock('./codex-token-rotation.js', () => ({
+  getCodexAccountCount: vi.fn(() => 1),
+}));
+
+vi.mock('./session-recovery.js', () => ({
+  shouldResetCodexSessionOnAgentFailure: vi.fn(() => false),
+  shouldResetSessionOnAgentFailure: vi.fn(() => false),
+  shouldRetryFreshCodexSessionOnAgentFailure: vi.fn(() => false),
+}));
+
+import { runAgentProcess, type AgentOutput } from './agent-runner.js';
+import {
+  maybeApplyCompactRefresh,
+  readCompactRefreshFlag,
+} from './compact-refresh.js';
+import { runMessageAgentAttempt } from './message-agent-executor-attempt-runner.js';
+import type { RegisteredGroup } from './types.js';
+
+const dataDir = '/tmp/ejclaw-message-compact-refresh-test';
+
+const group: RegisteredGroup = {
+  name: 'Room',
+  folder: 'room',
+  trigger: '@Andy',
+  added_at: new Date().toISOString(),
+  agentType: 'claude-code',
+};
+
+function makeLifecycle() {
+  return {
+    updateSummary: vi.fn(),
+    recordFinalOutputBeforeDelivery: vi.fn(() => true),
+  };
+}
+
+function makeLogger(): any {
+  const logger = {
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    child: vi.fn(),
+  };
+  logger.child.mockReturnValue(logger);
+  return logger;
+}
+
+describe('message agent compact refresh', () => {
+  beforeEach(() => {
+    fs.rmSync(dataDir, { recursive: true, force: true });
+    vi.resetAllMocks();
+  });
+
+  it('marks compacted owner sessions so the next turn gets one minimal refresh', async () => {
+    const compactedOutput: AgentOutput = {
+      status: 'success',
+      result: 'done',
+      output: { visibility: 'public', text: 'done' },
+      newSessionId: 'session-1',
+      compaction: { completed: true, trigger: 'auto' },
+    };
+    vi.mocked(runAgentProcess).mockResolvedValue(compactedOutput);
+
+    await runMessageAgentAttempt({
+      provider: 'claude',
+      currentSessionId: 'session-1',
+      isClaudeCodeAgent: true,
+      canRetryClaudeCredentials: false,
+      shouldPersistSession: true,
+      effectiveGroup: group,
+      agentInput: {
+        prompt: 'work',
+        sessionId: 'session-1',
+        groupFolder: 'room',
+        chatJid: 'room@test',
+        runId: 'run-1',
+        isMain: false,
+        assistantName: 'Andy',
+      },
+      activeRole: 'owner',
+      effectiveServiceId: 'claude',
+      effectiveAgentType: 'claude-code',
+      sessionFolder: 'room',
+      onPersistSession: vi.fn(),
+      registerProcess: vi.fn(),
+      pairedExecutionLifecycle: makeLifecycle(),
+      log: makeLogger(),
+    });
+
+    expect(readCompactRefreshFlag('room')).toMatchObject({
+      sessionId: 'session-1',
+      trigger: 'auto',
+    });
+
+    const applied = maybeApplyCompactRefresh({
+      sessionFolder: 'room',
+      sessionId: 'session-1',
+      role: 'owner',
+      prompt: 'next work',
+    });
+    expect(applied?.prompt).toContain('EJClaw compact refresh');
+    expect(applied?.prompt).toContain('next work');
+  });
+});

src/message-agent-executor-attempt-runner.ts

@@ -3,6 +3,7 @@ import type { Logger } from 'pino';
 import { createEvaluatedOutputHandler } from './agent-attempt.js';
 import type { AttemptStreamedTrigger } from './agent-attempt-retry.js';
 import { runAgentProcess, type AgentOutput } from './agent-runner.js';
+import { markCompactRefreshNeeded } from './compact-refresh.js';
 import { getCodexAccountCount } from './codex-token-rotation.js';
 import type { PreparedPairedExecutionContext } from './paired-execution-context.js';
 import {
@@ -34,6 +35,35 @@ interface AgentInput {
   roomRoleContext?: RoomRoleContext;
 }
 
+function maybeMarkCompactRefreshForOutput(args: {
+  output: AgentOutput;
+  activeRole: string;
+  sessionFolder: string;
+}): void {
+  if (
+    (args.activeRole !== 'owner' && args.activeRole !== 'reviewer') ||
+    args.output.compaction?.completed !== true ||
+    !args.output.newSessionId
+  ) {
+    return;
+  }
+  markCompactRefreshNeeded({
+    sessionFolder: args.sessionFolder,
+    sessionId: args.output.newSessionId,
+    trigger: args.output.compaction.trigger ?? null,
+  });
+}
+
+function createProviderLog(
+  log: Logger,
+  provider: 'claude' | 'codex',
+  agentType: AgentType,
+): Logger {
+  const providerLog = log.child({ provider, agentType });
+  providerLog.info('Using provider');
+  return providerLog;
+}
+
 export async function runMessageAgentAttempt(args: {
   provider: 'claude' | 'codex';
   currentSessionId: string | undefined;
@@ -111,6 +141,7 @@ export async function runMessageAgentAttempt(args: {
       structuredOutput,
       evaluation,
     }) => {
+      maybeMarkCompactRefreshForOutput({ output, activeRole, sessionFolder });
       const outputPhase = output.phase ?? 'final';
       if (outputPhase !== 'final') {
         log.info(
@@ -252,11 +283,7 @@ export async function runMessageAgentAttempt(args: {
     await streamedOutputHandler.handleOutput(output);
   };
 
-  const providerLog = log.child({
-    provider,
-    agentType: effectiveAgentType,
-  });
-  providerLog.info('Using provider');
+  const providerLog = createProviderLog(log, provider, effectiveAgentType);
 
   try {
     const output = await runAgentProcess(
@@ -273,6 +300,7 @@ export async function runMessageAgentAttempt(args: {
     if (output.newSessionId && shouldPersistSession) {
       onPersistSession(output.newSessionId);
     }
+    maybeMarkCompactRefreshForOutput({ output, activeRole, sessionFolder });
 
     providerLog.info(
       {

src/message-agent-executor.ts

@@ -1,5 +1,6 @@
 import { AgentOutput } from './agent-runner.js';
 import { GroupQueue } from './group-queue.js';
+import type { Logger } from 'pino';
 import type { AgentTriggerReason } from './agent-error-detection.js';
 import { getMoaConfig } from './config.js';
 import { createPairedExecutionLifecycle } from './message-agent-executor-paired.js';
@@ -12,9 +13,82 @@ import { collectMoaReferences, formatMoaReferencesForPrompt } from './moa.js';
 import { readArbiterPrompt } from './platform-prompts.js';
 import { shouldRetryFreshSessionOnAgentFailure } from './session-recovery.js';
 import type { AgentType, PairedRoomRole, RegisteredGroup } from './types.js';
+import {
+  clearCompactRefreshIfUnchanged,
+  maybeApplyCompactRefresh,
+  type AppliedCompactRefresh,
+} from './compact-refresh.js';
 
 // ── Main executor ─────────────────────────────────────────────────
 
+function buildPromptWithCompactRefresh(args: {
+  prompt: string;
+  sessionFolder: string;
+  sessionId?: string;
+  role: PairedRoomRole;
+}): { effectivePrompt: string; compactRefresh: AppliedCompactRefresh | null } {
+  const compactRefresh = maybeApplyCompactRefresh({
+    sessionFolder: args.sessionFolder,
+    sessionId: args.sessionId,
+    role: args.role,
+    prompt: args.prompt,
+  });
+  return {
+    effectivePrompt: compactRefresh?.prompt ?? args.prompt,
+    compactRefresh,
+  };
+}
+
+function clearAppliedCompactRefreshAfterSuccess(args: {
+  result: 'success' | 'error';
+  sessionFolder: string;
+  compactRefresh: AppliedCompactRefresh | null;
+}): void {
+  if (args.result !== 'success' || !args.compactRefresh) return;
+  clearCompactRefreshIfUnchanged({
+    sessionFolder: args.sessionFolder,
+    flag: args.compactRefresh.flag,
+  });
+}
+
+async function enrichArbiterPromptWithMoa(args: {
+  prompt: string;
+  enabled: boolean;
+  log: Pick<Logger, 'info' | 'warn'>;
+}): Promise<string> {
+  const moaConfig = getMoaConfig();
+  if (!args.enabled || !moaConfig.enabled) return args.prompt;
+  args.log.info(
+    { models: moaConfig.referenceModels.map((m) => m.name) },
+    'MoA: collecting reference opinions before arbiter',
+  );
+  const systemPrompt =
+    readArbiterPrompt(process.cwd()) || 'You are an arbiter.';
+  try {
+    const references = await collectMoaReferences({
+      config: moaConfig,
+      systemPrompt,
+      contextPrompt: args.prompt,
+    });
+    const moaSection = formatMoaReferencesForPrompt(references);
+    if (!moaSection) return args.prompt;
+    args.log.info(
+      {
+        successCount: references.filter((r) => !r.error).length,
+        totalCount: references.length,
+      },
+      'MoA: injected reference opinions into arbiter prompt',
+    );
+    return args.prompt + '\n' + moaSection;
+  } catch (err) {
+    args.log.warn(
+      { err, models: moaConfig.referenceModels.map((m) => m.name) },
+      'MoA: failed to collect reference opinions; continuing without enrichment',
+    );
+    return args.prompt;
+  }
+}
+
 export interface MessageAgentExecutorDeps {
   assistantName: string;
   queue: Pick<GroupQueue, 'registerProcess' | 'enqueueMessageCheck'> &
@@ -81,54 +155,18 @@ export async function runAgentForGroup(
     clearRoleSdkSessions();
   }
 
-  // ── MoA prompt enrichment ─────────────────────────────────────
-  // When MoA is enabled and we're in arbiter mode, query external API
-  // models (Kimi, GLM, etc.) in parallel for their opinions, then inject
-  // those opinions into the arbiter's prompt. The SDK-based arbiter
-  // agent naturally aggregates all perspectives.
-  let moaEnrichedPrompt = prompt;
-  const moaConfig = getMoaConfig();
-  if (arbiterMode && moaConfig.enabled && pairedExecutionContext) {
-    log.info(
-      {
-        models: moaConfig.referenceModels.map((m) => m.name),
-      },
-      'MoA: collecting reference opinions before arbiter',
-    );
+  const moaEnrichedPrompt = await enrichArbiterPromptWithMoa({
+    prompt,
+    enabled: arbiterMode && Boolean(pairedExecutionContext),
+    log,
+  });
 
-    const systemPrompt =
-      readArbiterPrompt(process.cwd()) || 'You are an arbiter.';
-
-    try {
-      const references = await collectMoaReferences({
-        config: moaConfig,
-        systemPrompt,
-        contextPrompt: prompt,
-      });
-
-      const moaSection = formatMoaReferencesForPrompt(references);
-      if (moaSection) {
-        moaEnrichedPrompt = prompt + '\n' + moaSection;
-        log.info(
-          {
-            successCount: references.filter((r) => !r.error).length,
-            totalCount: references.length,
-          },
-          'MoA: injected reference opinions into arbiter prompt',
-        );
-      }
-    } catch (err) {
-      log.warn(
-        {
-          err,
-          models: moaConfig.referenceModels.map((m) => m.name),
-        },
-        'MoA: failed to collect reference opinions; continuing without enrichment',
-      );
-    }
-  }
-
-  const effectivePrompt = moaEnrichedPrompt;
+  const { effectivePrompt, compactRefresh } = buildPromptWithCompactRefresh({
+    prompt: moaEnrichedPrompt,
+    sessionFolder,
+    sessionId: currentSessionId,
+    role: activeRole,
+  });
   const pairedExecutionLifecycle = createPairedExecutionLifecycle({
     pairedExecutionContext,
     pairedTurnIdentity: runtimePairedTurnIdentity,
@@ -237,7 +275,7 @@ export async function runAgentForGroup(
     });
 
   try {
-    return await executeMessageAgentAttemptLifecycle({
+    const result = await executeMessageAgentAttemptLifecycle({
       provider,
       runAttempt,
       isClaudeCodeAgent,
@@ -260,6 +298,12 @@ export async function runAgentForGroup(
       },
       log,
     });
+    clearAppliedCompactRefreshAfterSuccess({
+      result,
+      sessionFolder,
+      compactRefresh,
+    });
+    return result;
   } finally {
     await pairedExecutionLifecycle.asyncFinalize();
   }