principles-disciple 1.111.0 → 1.113.0

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "principles-disciple",
   "name": "Principles Disciple",
   "description": "Evolutionary programming agent framework with strategic guardrails and reflection loops.",
-  "version": "1.111.0",
+  "version": "1.113.0",
   "activation": {
     "onCapabilities": [
       "hook"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "principles-disciple",
-  "version": "1.111.0",
+  "version": "1.113.0",
   "description": "Native OpenClaw plugin for Principles Disciple",
   "type": "module",
   "main": "./dist/bundle.js",

package/src/index.ts

@@ -52,6 +52,7 @@ import { handleSamplesCommand } from './commands/samples.js';
 import { handleWorkflowDebugCommand } from './commands/workflow-debug.js';
 import { EvolutionWorkerService } from './service/evolution-worker.js';
 import { CorrectionObserverService } from './service/correction-observer-service.js';
+import { InternalizationAutoConsumerService } from './service/internalization-auto-consumer-service.js';
 import { TrajectoryService } from './service/trajectory-service.js';
 import { PDTaskService } from './core/pd-task-service.js';
 import { CentralSyncService } from './service/central-sync-service.js';
@@ -149,6 +150,30 @@ export function shouldStartCorrectionObserver(
   return { shouldStart: false, flagSource: flag.source, disabledInfo };
 }
 
+export interface InternalizationAutoConsumerGateResult {
+  shouldStart: boolean;
+  flagSource: string;
+  disabledInfo: string | null;
+}
+
+export function shouldStartInternalizationAutoConsumer(
+  workspaceDir: string,
+  logger: { info?: (msg: string) => void; warn?: (msg: string) => void },
+): InternalizationAutoConsumerGateResult {
+  const flag = loadFeatureFlagFromWorkspace(workspaceDir, 'internalization_auto_consumer', logger);
+  if (flag.enabled) {
+    return { shouldStart: true, flagSource: flag.source, disabledInfo: null };
+  }
+  const disabledInfo = JSON.stringify({
+    reason: 'internalization_auto_consumer_disabled',
+    nextAction: `pd runtime internalization run-once --workspace "${workspaceDir}" --runner dreamer --runtime config --json`,
+    featureFlag: 'internalization_auto_consumer',
+    boundedContext: 'internalization_auto_consumer',
+    flagSource: flag.source,
+  });
+  return { shouldStart: false, flagSource: flag.source, disabledInfo };
+}
+
 const plugin = {
   name: "Principles Disciple",
   description: "Evolutionary programming agent framework with strategic guardrails and reflection loops.",
@@ -258,6 +283,23 @@ const plugin = {
               api.logger.info(`[PD] CorrectionObserver NOT started for workspace: ${workspaceDir}. ${corrGate.disabledInfo}`);
               SystemLogger.log(workspaceDir, 'CORRECTION_OBSERVER_DISABLED', corrGate.disabledInfo ?? '');
             }
+
+            // ── Start InternalizationAutoConsumer for THIS workspace ──
+            // PRI-381: Bounded auto-consumer for dreamer ready tasks.
+            // Default ON for dogfood; kill switch via features.internalization_auto_consumer.enabled=false.
+            const autoConsGate = shouldStartInternalizationAutoConsumer(workspaceDir, api.logger);
+            if (autoConsGate.shouldStart) {
+              InternalizationAutoConsumerService.start({
+                config: api.config,
+                workspaceDir,
+                stateDir: path.join(workspaceDir, '.state'),
+                logger: api.logger,
+              });
+              api.logger.info(`[PD] InternalizationAutoConsumer started for workspace: ${workspaceDir} (flag source: ${autoConsGate.flagSource})`);
+            } else {
+              api.logger.info(`[PD] InternalizationAutoConsumer NOT started for workspace: ${workspaceDir}. ${autoConsGate.disabledInfo}`);
+              SystemLogger.log(workspaceDir, 'INTERNALIZATION_CONSUMER_DISABLED', autoConsGate.disabledInfo ?? '');
+            }
           }
 
           const result = await handleBeforePromptBuild(event, { ...ctx, api: api as Parameters<typeof handleBeforePromptBuild>[1]['api'], workspaceDir });
@@ -562,6 +604,8 @@ const plugin = {
       if (guardedPdTask) api.registerService(guardedPdTask);
       const guardedCentralSync = guardService('service:central-sync', CentralSyncService, api.logger);
       if (guardedCentralSync) api.registerService(guardedCentralSync);
+      const guardedAutoConsumer = guardService('service:internalization-auto-consumer', InternalizationAutoConsumerService, api.logger);
+      if (guardedAutoConsumer) api.registerService(guardedAutoConsumer);
     } catch (err) {
       api.logger.error(`[PD] Failed to register services: ${String(err)}`);
     }

package/src/service/internalization-auto-consumer-service.ts

@@ -0,0 +1,327 @@
+import type { OpenClawPluginServiceContext, PluginLogger } from '../openclaw-sdk.js';
+import {
+  createRuntimeStateHandle,
+  InternalizationOrchestrator,
+  DreamerRunner,
+  DefaultDreamerValidator,
+  PiAiRuntimeAdapter,
+  storeEmitter,
+  resolveRuntimeConfigFromPdConfig,
+  isRuntimeConfigError,
+  computeConsumerDecision,
+  InternalizationQueueReadModel,
+  MVP_CORE_TASK_KINDS,
+} from '@principles/core/runtime-v2';
+import { loadPdConfigForPlugin, loadFeatureFlagFromConfig } from '../core/pd-config-loader.js';
+import { SystemLogger } from '../core/system-logger.js';
+
+const INTERNALIZATION_AUTO_CONSUMER_INTERVAL_MS = 120_000;
+const INTERNALIZATION_AUTO_CONSUMER_INITIAL_DELAY_MS = 30_000;
+const INTERNALIZATION_AUTO_CONSUMER_FLAG_ID = 'internalization_auto_consumer';
+
+export interface InternalizationAutoConsumerServiceShape {
+  id: string;
+  start: (ctx: OpenClawPluginServiceContext) => void;
+  stop?: (ctx: OpenClawPluginServiceContext) => void;
+}
+
+interface WorkspaceConsumerState {
+  stopped: boolean;
+  timeoutId: ReturnType<typeof setTimeout> | null;
+}
+
+const workspaceStates = new Map<string, WorkspaceConsumerState>();
+
+function getWorkspaceState(workspaceDir: string): WorkspaceConsumerState {
+  let state = workspaceStates.get(workspaceDir);
+  if (!state) {
+    state = { stopped: false, timeoutId: null };
+    workspaceStates.set(workspaceDir, state);
+  }
+  return state;
+}
+
+function formatRunOnceCommand(workspaceDir: string): string {
+  return `pd runtime internalization run-once --workspace "${workspaceDir}" --runner dreamer --runtime config --json`;
+}
+
+function getNextActionForError(category?: string): string {
+  if (category === 'lease_conflict') {
+    return 'Retry later or check for concurrent worker processes.';
+  }
+  if (category === 'timeout') {
+    return 'Check model provider service status/latency, or increase timeout settings in workflows.yaml.';
+  }
+  if (category === 'cancelled') {
+    return 'Re-enqueue or restart the task if it was cancelled by mistake.';
+  }
+  if (category === 'output_invalid') {
+    return 'Verify if model outputs conform to expected schema and adjust prompt or validation templates if needed.';
+  }
+  if (category === 'input_invalid') {
+    return 'Check predecessor task outputs and database integrity for malformed input references.';
+  }
+  if (category === 'max_attempts_exceeded') {
+    return 'Investigate persistent failures, correct the root issue, and clear last_error or reset attempt count.';
+  }
+  return 'Run: pd runtime internalization run-once --runner dreamer --runtime config --json to isolate the failure.';
+}
+
+async function runConsumerCycle(
+  workspaceDir: string,
+  logger: PluginLogger,
+): Promise<void> {
+  const flag = loadFeatureFlagFromConfig(workspaceDir, INTERNALIZATION_AUTO_CONSUMER_FLAG_ID, {
+    info: (msg: string) => logger.info(msg),
+    warn: (msg: string) => logger.warn(msg),
+  });
+
+  if (!flag.enabled) {
+    const disabledInfo = JSON.stringify({
+      reason: 'internalization_auto_consumer_disabled',
+      nextAction: formatRunOnceCommand(workspaceDir),
+      flagSource: flag.source,
+    });
+    SystemLogger.log(workspaceDir, 'INTERNALIZATION_CONSUMER_SKIP', disabledInfo);
+    logger.info(`[PD:AutoConsumer] Cycle skipped: auto-consumer disabled. Source: ${flag.source}`);
+    return;
+  }
+
+  const configResult = loadPdConfigForPlugin(workspaceDir);
+  if (!configResult.ok) {
+    const malformedInfo = JSON.stringify({
+      reason: 'config_malformed',
+      nextAction: configResult.errors[0]?.nextAction ?? 'Fix .pd/config.yaml and retry',
+      errors: configResult.errors.map((e) => e.reason),
+    });
+    SystemLogger.log(workspaceDir, 'INTERNALIZATION_CONSUMER_SKIP', malformedInfo);
+    logger.warn(`[PD:AutoConsumer] Config malformed, skipping cycle.`);
+    return;
+  }
+
+  const runtimeConfigResult = resolveRuntimeConfigFromPdConfig(
+    configResult.effective,
+    (name: string) => process.env[name],
+  );
+
+  if (isRuntimeConfigError(runtimeConfigResult)) {
+    const rtInfo = JSON.stringify({
+      reason: 'runtime_config_error',
+      message: runtimeConfigResult.message,
+      nextAction: runtimeConfigResult.nextAction,
+    });
+    SystemLogger.log(workspaceDir, 'INTERNALIZATION_CONSUMER_SKIP', rtInfo);
+    logger.warn(`[PD:AutoConsumer] Runtime config error: ${runtimeConfigResult.message}`);
+    return;
+  }
+
+  let handle: Awaited<ReturnType<typeof createRuntimeStateHandle>> | null = null;
+  try {
+    handle = await createRuntimeStateHandle({ workspaceDir, readonly: false });
+    const { stateManager } = handle;
+
+    const readModel = new InternalizationQueueReadModel(stateManager);
+    readModel.setPolicy({
+      enabledChannels: new Set(['prompt', 'code_tool_hook', 'defer_archive']),
+      actionableTaskKinds: new Set(MVP_CORE_TASK_KINDS),
+    });
+    const snapshot = await readModel.getSnapshot();
+
+    if (snapshot.readyTasks.length > 5) {
+      logger.warn(`[PD:AutoConsumer] Backlog detected: ${snapshot.readyTasks.length} tasks ready. Processing only one task.`);
+    }
+
+    const decision = computeConsumerDecision({
+      autoConsumerEnabled: true,
+      readyTaskCount: snapshot.readyTasks.length,
+    });
+
+    if (!decision.shouldConsume) {
+      SystemLogger.log(workspaceDir, 'INTERNALIZATION_CONSUMER_SKIP', JSON.stringify({
+        reason: decision.reason,
+        readyTaskCount: snapshot.readyTasks.length,
+      }));
+      return;
+    }
+
+    const orchestrator = new InternalizationOrchestrator(
+      { stateManager },
+      { owner: 'auto-consumer', runtimeKind: 'config', dryRun: true },
+    );
+
+    const wakeResult = await orchestrator.wakeOnce('dreamer');
+
+    if (wakeResult.decision !== 'would_lease') {
+      const skipPayload: Record<string, unknown> = {
+        decision: wakeResult.decision,
+      };
+      if (wakeResult.decision === 'no_ready_tasks') {
+        skipPayload.reason = wakeResult.reason;
+      }
+      SystemLogger.log(workspaceDir, 'INTERNALIZATION_CONSUMER_SKIP', JSON.stringify(skipPayload));
+      logger.info(`[PD:AutoConsumer] No task to consume: ${wakeResult.decision}`);
+      return;
+    }
+
+    const adapter = new PiAiRuntimeAdapter({
+      provider: runtimeConfigResult.provider ?? 'openai',
+      model: runtimeConfigResult.model ?? 'gpt-4o',
+      apiKeyEnv: runtimeConfigResult.apiKeyEnv ?? 'OPENAI_API_KEY',
+      maxRetries: runtimeConfigResult.maxRetries,
+      timeoutMs: runtimeConfigResult.timeoutMs,
+      baseUrl: runtimeConfigResult.baseUrl,
+      workspace: workspaceDir,
+    });
+
+    const validator = new DefaultDreamerValidator();
+    const runner = new DreamerRunner(
+      {
+        stateManager,
+        runtimeAdapter: adapter,
+        eventEmitter: storeEmitter,
+        artifactStore: stateManager.piArtifactStore,
+        validator,
+      },
+      {
+        owner: 'auto-consumer',
+        runtimeKind: 'config',
+      },
+    );
+
+    const taskId = wakeResult.taskId;
+    logger.info(`[PD:AutoConsumer] Running dreamer task: ${taskId}`);
+    SystemLogger.log(workspaceDir, 'INTERNALIZATION_CONSUMER_RUN', JSON.stringify({
+      taskId,
+      taskKind: 'dreamer',
+    }));
+
+    const runResult = await runner.run(taskId);
+
+    if (runResult.status === 'succeeded') {
+      const commitResult = await orchestrator.commitNextTaskProposal(taskId);
+      SystemLogger.log(workspaceDir, 'INTERNALIZATION_CONSUMER_SUCCESS', JSON.stringify({
+        taskId,
+        status: runResult.status,
+        successorDecision: commitResult.decision,
+      }));
+      logger.info(
+        `[PD:AutoConsumer] Task ${taskId} succeeded. Successor: ${commitResult.decision}`,
+      );
+    } else {
+      const errorCategory = runResult.errorCategory;
+      const failureReason = runResult.failureReason;
+      const nextAction = getNextActionForError(errorCategory);
+      SystemLogger.log(workspaceDir, 'INTERNALIZATION_CONSUMER_TASK_FAILED', JSON.stringify({
+        taskId,
+        status: runResult.status,
+        errorCategory,
+        failureReason,
+        nextAction,
+      }));
+      logger.warn(
+        `[PD:AutoConsumer] Task ${taskId} status: ${runResult.status}. Category: ${errorCategory}. Reason: ${failureReason}. Next Action: ${nextAction}`
+      );
+    }
+  } catch (err) {
+    SystemLogger.log(workspaceDir, 'INTERNALIZATION_CONSUMER_ERROR', String(err));
+    logger.error(`[PD:AutoConsumer] Cycle error: ${String(err)}`);
+  } finally {
+    if (handle) {
+      await handle.close().catch(() => {});
+    }
+  }
+}
+
+export const InternalizationAutoConsumerService: InternalizationAutoConsumerServiceShape = {
+  id: 'principles-internalization-auto-consumer',
+
+  start(ctx: OpenClawPluginServiceContext): void {
+    const maybeWorkspaceDir = ctx?.workspaceDir;
+    const logger = ctx?.logger || console;
+
+    if (!maybeWorkspaceDir) {
+      logger.warn('[PD:AutoConsumer] No workspace directory, not starting.');
+      return;
+    }
+
+    const workspaceDir: string = maybeWorkspaceDir;
+    const state = getWorkspaceState(workspaceDir);
+
+    if (!state.stopped && state.timeoutId !== null) {
+      logger.info(`[PD:AutoConsumer] Already started for workspace: ${workspaceDir}`);
+      return;
+    }
+
+    const flag = loadFeatureFlagFromConfig(workspaceDir, INTERNALIZATION_AUTO_CONSUMER_FLAG_ID, {
+      info: (msg: string) => logger.info(msg),
+      warn: (msg: string) => logger.warn(msg),
+    });
+
+    if (!flag.enabled) {
+      const disabledInfo = JSON.stringify({
+        reason: 'internalization_auto_consumer_disabled',
+        nextAction: formatRunOnceCommand(workspaceDir),
+        flagSource: flag.source,
+      });
+      SystemLogger.log(workspaceDir, 'INTERNALIZATION_CONSUMER_DISABLED', disabledInfo);
+      logger.info(
+        `[PD:AutoConsumer] NOT started for workspace: ${workspaceDir}. Disabled (source: ${flag.source}).`,
+      );
+      return;
+    }
+
+    state.stopped = false;
+
+    const interval = INTERNALIZATION_AUTO_CONSUMER_INTERVAL_MS;
+
+    function scheduleNext(): void {
+      if (state.stopped) return;
+      state.timeoutId = setTimeout(runCycle, interval);
+      state.timeoutId?.unref();
+    }
+
+    async function runCycle(): Promise<void> {
+      if (state.stopped) return;
+      await runConsumerCycle(workspaceDir, logger);
+      scheduleNext();
+    }
+
+    state.timeoutId = setTimeout(() => {
+      void runCycle().catch((err: unknown) => {
+        logger.error(`[PD:AutoConsumer] Startup cycle failed: ${String(err)}`);
+        if (state.stopped) return;
+        state.timeoutId = setTimeout(runCycle, interval);
+        state.timeoutId?.unref();
+      });
+    }, INTERNALIZATION_AUTO_CONSUMER_INITIAL_DELAY_MS);
+    state.timeoutId?.unref();
+
+    SystemLogger.log(workspaceDir, 'INTERNALIZATION_CONSUMER_STARTED', JSON.stringify({
+      intervalMs: interval,
+      initialDelayMs: INTERNALIZATION_AUTO_CONSUMER_INITIAL_DELAY_MS,
+    }));
+    logger.info(
+      `[PD:AutoConsumer] Started for workspace: ${workspaceDir} (interval: ${interval}ms, initial delay: ${INTERNALIZATION_AUTO_CONSUMER_INITIAL_DELAY_MS}ms)`,
+    );
+  },
+
+  stop(ctx: OpenClawPluginServiceContext): void {
+    const workspaceDir = ctx?.workspaceDir;
+    if (workspaceDir) {
+      const state = workspaceStates.get(workspaceDir);
+      if (state) {
+        state.stopped = true;
+        if (state.timeoutId) clearTimeout(state.timeoutId);
+        state.timeoutId = null;
+      }
+      workspaceStates.delete(workspaceDir);
+    } else {
+      for (const [, state] of workspaceStates) {
+        state.stopped = true;
+        if (state.timeoutId) clearTimeout(state.timeoutId);
+        state.timeoutId = null;
+      }
+      workspaceStates.clear();
+    }
+  },
+};

package/tests/evolution-worker-slimming.test.ts

@@ -174,6 +174,8 @@ describe('PRI-294: Surface registry coverage audit', () => {
       'startup:workspace-init',
       'startup:evolution-worker',
       'startup:correction-observer',
+      'service:internalization-auto-consumer',  // PRI-381: bounded auto-consumer
+      'startup:internalization-auto-consumer',  // PRI-381: auto-consumer startup
     ];
     const allowedIds = new Set([...usedSet, ...additionallyRegistered]);
     const unaccounted = PLUGIN_SURFACE_REGISTRY

package/tests/integration/mvp-surface-registry-guard.test.ts

@@ -244,6 +244,7 @@ describe('MVP Surface Registry Guard (PRI-289)', () => {
       const expectedIds = [
         'service:central-sync',
         'service:correction-observer',
+        'service:internalization-auto-consumer',
         'service:pd-task',
         'service:trajectory',
       ].sort();

package/tests/internalization-auto-consumer-gate.test.ts

@@ -0,0 +1,158 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import * as yaml from 'js-yaml';
+
+vi.mock('../src/core/dictionary-service.js', () => ({
+  DictionaryService: { get: vi.fn(() => ({ flush: vi.fn() })) },
+}));
+
+vi.mock('../src/core/session-tracker.js', () => ({
+  initPersistence: vi.fn(),
+  flushAllSessions: vi.fn(),
+  listSessions: vi.fn(() => []),
+}));
+
+vi.mock('../src/core/workspace-context.js', () => {
+  const mockCtx = {
+    stateDir: '',
+    workspaceDir: '',
+    config: { get: vi.fn() },
+    eventLog: { recordHookExecution: vi.fn() },
+    dictionary: { flush: vi.fn() },
+    resolve: vi.fn((key: string) => `/mock/${key}`),
+    trajectory: null,
+  };
+  return {
+    WorkspaceContext: {
+      fromHookContext: vi.fn(() => mockCtx),
+      clearCache: vi.fn(),
+    },
+  };
+});
+
+import {
+  shouldStartInternalizationAutoConsumer,
+  loadFeatureFlagFromWorkspace,
+} from '../src/index.js';
+
+function createTempWorkspace(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-auto-consumer-'));
+  fs.mkdirSync(path.join(dir, '.pd'), { recursive: true });
+  fs.mkdirSync(path.join(dir, '.state'), { recursive: true });
+  return dir;
+}
+
+function writeConfigYaml(workspaceDir: string, featureOverrides: Record<string, unknown>): void {
+  const configPath = path.join(workspaceDir, '.pd', 'config.yaml');
+  const defaultFeatures: Record<string, unknown> = {
+    prompt: { category: 'core', enabled: true },
+    code_tool_hook: { category: 'core', enabled: true },
+    defer_archive: { category: 'core', enabled: true },
+    correction_observer: { category: 'quiet', enabled: false },
+    empathy_observer: { category: 'quiet', enabled: false },
+    evolution_worker: { category: 'quiet', enabled: false },
+    internalization_auto_consumer: { category: 'quiet', enabled: true },
+    nocturnal: { category: 'gone', enabled: false },
+  };
+  const config = {
+    version: 1,
+    features: Object.assign({}, defaultFeatures, featureOverrides),
+    runtimeProfiles: {
+      'openclaw.default': { type: 'openclaw', source: 'default' },
+    },
+    internalAgents: {
+      defaultRuntime: 'openclaw.default',
+      agents: {
+        diagnostician: { enabled: true },
+        dreamer: { enabled: true },
+        scribe: { enabled: true },
+        artificer: { enabled: true },
+        philosopher: { enabled: false },
+        evaluator: { enabled: false },
+        rolloutReviewer: { enabled: false },
+        trainer: { enabled: false },
+        correctionObserver: { enabled: false },
+        empathyObserver: { enabled: false },
+      },
+    },
+  };
+  const content = yaml.dump(config, { schema: yaml.JSON_SCHEMA });
+  fs.writeFileSync(configPath, content, 'utf8');
+}
+
+function createMockLogger() {
+  return {
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    debug: vi.fn(),
+  };
+}
+
+describe('PRI-381: InternalizationAutoConsumer gate', () => {
+  let workspaceDir: string;
+
+  beforeEach(() => {
+    workspaceDir = createTempWorkspace();
+  });
+
+  afterEach(() => {
+    try {
+      fs.rmSync(workspaceDir, { recursive: true, force: true });
+    } catch { /* best-effort */ }
+  });
+
+  describe('shouldStartInternalizationAutoConsumer', () => {
+    it('returns shouldStart=true with defaults (quiet flag — default enabled)', () => {
+      const logger = createMockLogger();
+      const result = shouldStartInternalizationAutoConsumer(workspaceDir, logger);
+      expect(result.shouldStart).toBe(true);
+      expect(result.flagSource).toBeDefined();
+      expect(result.disabledInfo).toBeNull();
+    });
+
+    it('returns shouldStart=false when config disables the flag, with reason and nextAction', () => {
+      writeConfigYaml(workspaceDir, {
+        internalization_auto_consumer: { category: 'quiet', enabled: false },
+      });
+      const logger = createMockLogger();
+      const result = shouldStartInternalizationAutoConsumer(workspaceDir, logger);
+
+      expect(result.shouldStart).toBe(false);
+      expect(result.disabledInfo).not.toBeNull();
+      const info = JSON.parse(result.disabledInfo ?? '{}');
+      expect(info.reason).toBe('internalization_auto_consumer_disabled');
+      expect(info.nextAction).toContain('pd runtime internalization run-once');
+      expect(info.flagSource).toBeDefined();
+    });
+
+    it('returns shouldStart=true with explicit config enabling', () => {
+      writeConfigYaml(workspaceDir, {
+        internalization_auto_consumer: { category: 'quiet', enabled: true },
+      });
+      const logger = createMockLogger();
+      const result = shouldStartInternalizationAutoConsumer(workspaceDir, logger);
+      expect(result.shouldStart).toBe(true);
+    });
+  });
+
+  describe('loadFeatureFlagFromWorkspace for auto-consumer', () => {
+    it('returns enabled=true when no config.yaml exists (default)', () => {
+      const logger = createMockLogger();
+      const result = loadFeatureFlagFromWorkspace(workspaceDir, 'internalization_auto_consumer', logger);
+      expect(result.enabled).toBe(true);
+      expect(result.source).toBe('defaults');
+    });
+
+    it('returns enabled=false when config disables the flag (quiet flag can be disabled)', () => {
+      writeConfigYaml(workspaceDir, {
+        internalization_auto_consumer: { category: 'quiet', enabled: false },
+      });
+      const logger = createMockLogger();
+      const result = loadFeatureFlagFromWorkspace(workspaceDir, 'internalization_auto_consumer', logger);
+      expect(result.enabled).toBe(false);
+    });
+  });
+});