principles-disciple 1.71.0 → 1.73.0

package/tests/core-anti-growth.test.ts

@@ -0,0 +1,192 @@
+import { describe, it, expect } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+
+// ── PRI-212: Plugin core anti-growth architecture guard ─────────────────────
+//
+// Prevents new unclassified files from being added to packages/openclaw-plugin/src/core/
+// without explicit allowlisting. New pure domain logic MUST go to @principles/core.
+//
+// Baseline from PRI-211 inventory (2026-05-21).
+// Reference: docs/reviews/plugin-core-inventory-2026-05.md
+//
+// How to add a new file:
+//   1. Is it pure domain logic? → add to @principles/core, NOT here
+//   2. Is it a plugin I/O adapter/binding? → add to PLUGIN_IO_FILES
+//      with a comment explaining why it belongs in plugin core
+//   3. NEVER add to/from FROZEN_LEGACY (ADR-0005) — those must NOT be modified
+
+describe('PRI-212 plugin core anti-growth guard', () => {
+  // Category 1: Frozen Legacy (ADR-0005) — deleted in PRI-230
+  const FROZEN_LEGACY = [
+  ] as const;
+
+  // Category 2: Pure domain logic with zero I/O imports — should migrate to @principles/core
+  const ZERO_IMPORT_CANDIDATES = [
+    'trajectory-types.ts',
+    'profile.ts',
+    'pain-signal.ts',
+    'pd-task-types.ts',
+    'evolution-types.ts',
+    'telemetry-event.ts',
+    'empathy-types.ts',
+    'correction-types.ts',
+    'principle-injection.ts',
+    'principle-compiler/template-generator.ts',
+  ] as const;
+
+  // Categories 3-5: Plugin I/O adapters, Do Not Move, I/O boundary
+  const PLUGIN_IO_FILES = [
+    // Thin adapter candidates
+    'local-worker-routing.ts',
+    'principle-tree-migration.ts',
+    'principle-internalization/principle-lifecycle-service.ts',
+    'principle-tree-ledger-adapter.ts',
+    'principle-compiler/ledger-registrar.ts',
+    'principle-compiler/code-validator.ts',
+    'principle-injector.ts',
+    'pd-task-service.ts',
+    'principle-internalization/lifecycle-read-model.ts',
+    'principle-internalization/filesystem-lifecycle-datasource.ts',
+    'config-service.ts',
+    'principle-compiler/index.ts',
+    'principle-internalization/lifecycle-refresh.ts',
+    // Do Not Move
+    'event-log.ts',
+    'schema/schema-definitions.ts',
+    'path-resolver.ts',
+    'init.ts',
+    'workspace-context.ts',
+    'reflection/reflection-context.ts',
+    'bootstrap-rules.ts',
+    'schema/migration-runner.ts',
+    'rule-host.ts',
+    'principle-training-state.ts',
+    'pain-diagnostic-gate.ts',
+    'hygiene/tracker.ts',
+    'schema/migrations/002-init-central.ts',
+    'workspace-dir-service.ts',
+    'paths.ts',
+    'schema/migrations/004-add-thinking-and-gfi.ts',
+    'evolution-hook.ts',
+    'storage-adapter.ts',
+    'schema/migrations/003-init-workflow.ts',
+    'workspace-dir-validation.ts',
+    'pain-signal-adapter.ts',
+    'rule-implementation-runtime.ts',
+    'detection-service.ts',
+    'schema/migrations/index.ts',
+    'dictionary-service.ts',
+    'schema/index.ts',
+    'schema/db-types.ts',
+    'rule-host-types.ts',
+    'rule-host-helpers.ts',
+    'schema/migrations/001-init-trajectory.ts',
+    // I/O boundary
+    'trajectory.ts',
+    'evolution-reducer.ts',
+    'promotion-gate.ts',
+    'model-training-registry.ts',
+    'focus-history.ts',
+    'model-deployment-registry.ts',
+    'training-program.ts',
+    'replay-engine.ts',
+    'external-training-contract.ts',
+    'merge-gate-audit.ts',
+    'shadow-observation-registry.ts',
+    'confirm-first-gate.ts',
+    'control-ui-db.ts',
+    'thinking-models.ts',
+    'pd-task-reconciler.ts',
+    'correction-cue-learner.ts',
+    'principle-compiler/compiler.ts',
+    'pain.ts',
+    'pain-context-extractor.ts',
+    'config.ts',
+    'code-implementation-storage.ts',
+    'observability.ts',
+    'file-storage-adapter.ts',
+    'workflow-funnel-loader.ts',
+    'dictionary.ts',
+    'thinking-os-parser.ts',
+    'system-logger.ts',
+    'detection-funnel.ts',
+    'risk-calculator.ts',
+    'migration.ts',
+    'file-store.ts',
+    'pd-task-store.ts',
+    'evolution-migration.ts',
+    'empathy-keyword-matcher.ts',
+    'pain-lifecycle.ts',
+    'session-tracker.ts',
+    'principle-tree-ledger.ts',
+    'evolution-logger.ts',
+    'evolution-engine.ts',
+    'runtime-v2-prompt-activation-reader.ts',
+  ] as const;
+
+  // Category 6: Test files
+  const KNOWN_TEST_FILES = [
+    '__tests__/focus-history.test.ts',
+    'principle-compiler/__tests__/compiler-replay-gate.test.ts',
+  ] as const;
+
+  const ALL_KNOWN = [
+    ...FROZEN_LEGACY,
+    ...ZERO_IMPORT_CANDIDATES,
+    ...PLUGIN_IO_FILES,
+    ...KNOWN_TEST_FILES,
+  ];
+
+  function enumerateFiles(dir: string, prefix = ''): string[] {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    const files: string[] = [];
+    for (const entry of entries) {
+      const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+      const fullPath = path.resolve(dir, entry.name);
+      if (entry.isDirectory()) {
+        files.push(...enumerateFiles(fullPath, relPath));
+      } else if (entry.name.endsWith('.ts')) {
+        files.push(relPath.replace(/\\/g, '/'));
+      }
+    }
+    return files;
+  }
+
+  it('no new unclassified files in plugin core', () => {
+    const coreDir = path.resolve(__dirname, '../src/core');
+    const actualFiles = enumerateFiles(coreDir).sort();
+    const expectedFiles = [...ALL_KNOWN].sort();
+
+    const actualSet = new Set(actualFiles);
+    const knownSet = new Set(expectedFiles);
+
+    const unknownFiles = actualFiles.filter((f) => !knownSet.has(f));
+    const missingFiles = expectedFiles.filter((f) => !actualSet.has(f));
+
+    expect(unknownFiles, [
+      `\nUnclassified files detected in packages/openclaw-plugin/src/core/:`,
+      ...unknownFiles.map((f) => `  + ${f}`),
+      ``,
+      `New pure domain logic MUST go to @principles/core (packages/principles-core/).`,
+      `Plugin I/O adapter additions must be explicitly allowlisted in`,
+      `packages/openclaw-plugin/tests/core-anti-growth.test.ts`,
+      `ADR-0005 frozen files must NOT be modified.`,
+      `Reference: docs/reviews/plugin-core-inventory-2026-05.md (PRI-211)`,
+    ].join('\n')).toEqual([]);
+
+    expect(missingFiles, [
+      `\nBaseline files missing from packages/openclaw-plugin/src/core/:`,
+      ...missingFiles.map((f) => `  - ${f}`),
+      ``,
+      `Missing baseline files may indicate:`,
+      `  - File was moved or deleted (update inventory if intentional)`,
+      `  - Stale-main rollback (ERR-012): rebase on latest origin/main`,
+      `  - File was renamed (update inventory with new name)`,
+    ].join('\n')).toEqual([]);
+  });
+
+  it('zero-import candidates are tracked for migration awareness', () => {
+    expect(ZERO_IMPORT_CANDIDATES.length).toBeGreaterThan(0);
+  });
+});

package/tests/hook-workspace-nextaction-contract.test.ts

@@ -0,0 +1,42 @@
+import { describe, it, expect } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const INDEX_TS = fs.readFileSync(
+  path.resolve(__dirname, '../src/index.ts'),
+  'utf-8',
+);
+
+describe('Hook workspace resolution NextAction contract', () => {
+  const FORBIDDEN_NEXT_ACTION_PATTERNS = [
+    /PD_WORKSPACE_DIR/,
+    /principles-disciple\.json/,
+  ];
+
+  it('does not claim PD_WORKSPACE_DIR env var as recovery in NextAction', () => {
+    const matches = INDEX_TS.match(/NextAction:[^`]*PD_WORKSPACE_DIR/g);
+    expect(matches).toBeNull();
+  });
+
+  it('does not claim principles-disciple.json as recovery in NextAction', () => {
+    const matches = INDEX_TS.match(/NextAction:[^`]*principles-disciple\.json/g);
+    expect(matches).toBeNull();
+  });
+
+  it('all hook failure NextActions reference canonical workspace migration', () => {
+    const nextActionLines = INDEX_TS.match(/NextAction: \${HOOK_WORKSPACE_RESOLUTION_NEXT_ACTION}/g);
+    expect(nextActionLines).not.toBeNull();
+    expect(nextActionLines!.length).toBeGreaterThanOrEqual(7);
+  });
+
+  it('HOOK_WORKSPACE_RESOLUTION_NEXT_ACTION constant exists and does not contain forbidden patterns', () => {
+    const constantMatch = INDEX_TS.match(
+      /const HOOK_WORKSPACE_RESOLUTION_NEXT_ACTION\s*=\s*'([^']+)'/,
+    );
+    expect(constantMatch).not.toBeNull();
+    const constantValue = constantMatch![1];
+    for (const pattern of FORBIDDEN_NEXT_ACTION_PATTERNS) {
+      expect(pattern.test(constantValue)).toBe(false);
+    }
+  });
+});

package/tests/hooks/confirm-first-gate.test.ts

@@ -0,0 +1,333 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as os from 'os';
+import * as path from 'path';
+import * as fs from 'fs';
+import {
+  evaluateConfirmFirstGateSync,
+  detectApprovalMarker,
+  setConfirmFirstDirective,
+  setConfirmFirstApproval,
+  resetConfirmFirst,
+  isSessionApproved,
+  hasActiveDirective,
+  clearAllConfirmFirstState,
+  setConfirmFirstStore,
+  hydrateFromStore,
+} from '../../src/core/confirm-first-gate.js';
+import { SqliteConnection } from '@principles/core/runtime-v2';
+import { SqliteConfirmFirstStateStore } from '@principles/core/runtime-v2';
+
+describe('Confirm-First Gate', () => {
+  beforeEach(() => {
+    clearAllConfirmFirstState();
+  });
+
+  describe('detectApprovalMarker', () => {
+    it('detects Chinese approval markers', () => {
+      expect(detectApprovalMarker('确认')).toBe(true);
+      expect(detectApprovalMarker('批准')).toBe(true);
+      expect(detectApprovalMarker('按计划执行')).toBe(true);
+      expect(detectApprovalMarker('可以执行')).toBe(true);
+      expect(detectApprovalMarker('就这么做')).toBe(true);
+      expect(detectApprovalMarker('去执行')).toBe(true);
+      expect(detectApprovalMarker('开始执行')).toBe(true);
+      expect(detectApprovalMarker('执行吧')).toBe(true);
+      expect(detectApprovalMarker('同意')).toBe(true);
+    });
+
+    it('detects English approval markers', () => {
+      expect(detectApprovalMarker('approved')).toBe(true);
+      expect(detectApprovalMarker('go ahead')).toBe(true);
+      expect(detectApprovalMarker('lgtm')).toBe(true);
+      expect(detectApprovalMarker('yes, do it')).toBe(true);
+      expect(detectApprovalMarker('do it')).toBe(true);
+      expect(detectApprovalMarker('yes, proceed')).toBe(true);
+      expect(detectApprovalMarker('yes, execute')).toBe(true);
+      expect(detectApprovalMarker('proceed with the plan')).toBe(true);
+      expect(detectApprovalMarker('execute the plan')).toBe(true);
+      expect(detectApprovalMarker('please proceed with the plan')).toBe(true);
+    });
+
+    it('rejects vague text', () => {
+      expect(detectApprovalMarker('看看')).toBe(false);
+      expect(detectApprovalMarker('继续想想')).toBe(false);
+      expect(detectApprovalMarker('你决定')).toBe(false);
+      expect(detectApprovalMarker('hello world')).toBe(false);
+      expect(detectApprovalMarker('')).toBe(false);
+    });
+
+    it('rejects negated Chinese approval', () => {
+      expect(detectApprovalMarker('不同意')).toBe(false);
+      expect(detectApprovalMarker('不确认')).toBe(false);
+      expect(detectApprovalMarker('先不执行')).toBe(false);
+      expect(detectApprovalMarker('还没准备好确认')).toBe(false);
+      expect(detectApprovalMarker('暂不批准')).toBe(false);
+    });
+
+    it('rejects negated English approval', () => {
+      expect(detectApprovalMarker("don't proceed")).toBe(false);
+      expect(detectApprovalMarker("don't do it")).toBe(false);
+      expect(detectApprovalMarker("not ready to confirm")).toBe(false);
+      expect(detectApprovalMarker("can't approve yet")).toBe(false);
+      expect(detectApprovalMarker("won't proceed")).toBe(false);
+      expect(detectApprovalMarker("stop")).toBe(false);
+    });
+
+    it('rejects ambiguous English phrases without explicit approval context', () => {
+      expect(detectApprovalMarker('please confirm requirements before proceeding')).toBe(false);
+      expect(detectApprovalMarker('how should we proceed?')).toBe(false);
+      expect(detectApprovalMarker('confirm the requirement first')).toBe(false);
+      expect(detectApprovalMarker('should I proceed?')).toBe(false);
+      expect(detectApprovalMarker('I need to confirm something')).toBe(false);
+      expect(detectApprovalMarker('let me confirm the plan')).toBe(false);
+    });
+  });
+
+  describe('evaluateConfirmFirstGateSync', () => {
+    it('skips when no sessionId', () => {
+      const result = evaluateConfirmFirstGateSync(undefined, 'write', {});
+      expect(result.action).toBe('skip');
+    });
+
+    it('skips when no confirm-first directive active', () => {
+      const result = evaluateConfirmFirstGateSync('session-1', 'write', {});
+      expect(result.action).toBe('skip');
+    });
+
+    it('allows non-mutating tools even with active directive', () => {
+      setConfirmFirstDirective('session-1', true, 'princ-mvp-acceptance-confirm-first');
+      const result = evaluateConfirmFirstGateSync('session-1', 'read', {});
+      expect(result.action).toBe('allow');
+    });
+
+    it('blocks write tool when directive active and not approved', () => {
+      setConfirmFirstDirective('session-1', true, 'princ-mvp-acceptance-confirm-first');
+      const result = evaluateConfirmFirstGateSync('session-1', 'write', { path: 'test.json' });
+      expect(result.action).toBe('block');
+      expect(result.reason).toBe('confirm_first_required');
+      expect(result.principleId).toBe('princ-mvp-acceptance-confirm-first');
+      expect(result.nextAction).toContain('owner approval');
+    });
+
+    it('blocks edit tool when directive active and not approved', () => {
+      setConfirmFirstDirective('session-1', true, 'princ-mvp-acceptance-confirm-first');
+      const result = evaluateConfirmFirstGateSync('session-1', 'edit', { file_path: 'test.ts' });
+      expect(result.action).toBe('block');
+      expect(result.reason).toBe('confirm_first_required');
+    });
+
+    it('blocks delete_file when directive active and not approved', () => {
+      setConfirmFirstDirective('session-1', true, 'princ-mvp-acceptance-confirm-first');
+      const result = evaluateConfirmFirstGateSync('session-1', 'delete_file', { path: 'test.txt' });
+      expect(result.action).toBe('block');
+    });
+
+    it('blocks mutating exec when directive active and not approved', () => {
+      setConfirmFirstDirective('session-1', true, 'princ-mvp-acceptance-confirm-first');
+      const result = evaluateConfirmFirstGateSync('session-1', 'exec', { command: 'rm -rf /tmp/test' });
+      expect(result.action).toBe('block');
+    });
+
+    it('allows non-mutating exec when directive active and not approved', () => {
+      setConfirmFirstDirective('session-1', true, 'princ-mvp-acceptance-confirm-first');
+      const result = evaluateConfirmFirstGateSync('session-1', 'exec', { command: 'ls -la' });
+      expect(result.action).toBe('allow');
+    });
+
+    it('allows bash with undefined params when directive active', () => {
+      setConfirmFirstDirective('session-1', true, 'princ-mvp-acceptance-confirm-first');
+      const result = evaluateConfirmFirstGateSync('session-1', 'bash', undefined);
+      expect(result.action).toBe('allow');
+    });
+
+    it('allows read tool when directive active and not approved', () => {
+      setConfirmFirstDirective('session-1', true, 'princ-mvp-acceptance-confirm-first');
+      const result = evaluateConfirmFirstGateSync('session-1', 'read', { file_path: 'test.ts' });
+      expect(result.action).toBe('allow');
+    });
+
+    it('allows write after approval', () => {
+      setConfirmFirstDirective('session-1', true, 'princ-mvp-acceptance-confirm-first');
+      setConfirmFirstApproval('session-1');
+      const result = evaluateConfirmFirstGateSync('session-1', 'write', { path: 'test.json' });
+      expect(result.action).toBe('allow');
+      expect(isSessionApproved('session-1')).toBe(true);
+    });
+
+    it('approval is session-scoped', () => {
+      setConfirmFirstDirective('session-1', true, 'princ-mvp-acceptance-confirm-first');
+      setConfirmFirstDirective('session-2', true, 'princ-mvp-acceptance-confirm-first');
+      setConfirmFirstApproval('session-1');
+
+      expect(evaluateConfirmFirstGateSync('session-1', 'write', {}).action).toBe('allow');
+      expect(evaluateConfirmFirstGateSync('session-2', 'write', {}).action).toBe('block');
+    });
+
+    it('blocks apply_patch with no path when directive active', () => {
+      setConfirmFirstDirective('session-1', true, 'princ-mvp-acceptance-confirm-first');
+      const result = evaluateConfirmFirstGateSync('session-1', 'apply_patch', { patch: '@@ -1 +1 @@\n-old\n+new' });
+      expect(result.action).toBe('block');
+      expect(result.reason).toBe('confirm_first_required');
+    });
+
+    it('allows apply_patch after approval', () => {
+      setConfirmFirstDirective('session-1', true, 'princ-mvp-acceptance-confirm-first');
+      setConfirmFirstApproval('session-1');
+      const result = evaluateConfirmFirstGateSync('session-1', 'apply_patch', { patch: '@@ -1 +1 @@\n-old\n+new' });
+      expect(result.action).toBe('allow');
+    });
+
+    it('reset clears both directive and approval state', () => {
+      setConfirmFirstDirective('session-1', true, 'princ-mvp-acceptance-confirm-first');
+      setConfirmFirstApproval('session-1');
+      resetConfirmFirst('session-1');
+
+      expect(hasActiveDirective('session-1')).toBe(false);
+      expect(isSessionApproved('session-1')).toBe(false);
+      expect(evaluateConfirmFirstGateSync('session-1', 'write', {}).action).toBe('skip');
+    });
+  });
+});
+
+describe('Cross-restart persistence', () => {
+  let tmpDir: string;
+  let connection: SqliteConnection;
+  let store: SqliteConfirmFirstStateStore;
+
+  beforeEach(() => {
+    clearAllConfirmFirstState();
+    setConfirmFirstStore(null);
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-cf-test-'));
+    connection = new SqliteConnection(tmpDir);
+    store = new SqliteConfirmFirstStateStore(connection);
+  });
+
+  afterEach(() => {
+    setConfirmFirstStore(null);
+    clearAllConfirmFirstState();
+    try {
+      connection.close();
+    } catch {}
+    try {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    } catch {}
+  });
+
+  it('directive + approval survive restart', () => {
+    setConfirmFirstStore(store);
+    setConfirmFirstDirective('sess-restart', true, 'princ-123');
+    setConfirmFirstApproval('sess-restart');
+
+    expect(evaluateConfirmFirstGateSync('sess-restart', 'write', {}).action).toBe('allow');
+
+    setConfirmFirstStore(null);
+    clearAllConfirmFirstState();
+    setConfirmFirstStore(store);
+    hydrateFromStore('sess-restart');
+
+    expect(evaluateConfirmFirstGateSync('sess-restart', 'write', {}).action).toBe('allow');
+    expect(hasActiveDirective('sess-restart')).toBe(true);
+    expect(isSessionApproved('sess-restart')).toBe(true);
+  });
+
+  it('directive without approval survives restart', () => {
+    setConfirmFirstStore(store);
+    setConfirmFirstDirective('sess-restart', true, 'princ-456');
+
+    expect(evaluateConfirmFirstGateSync('sess-restart', 'write', {}).action).toBe('block');
+
+    setConfirmFirstStore(null);
+    clearAllConfirmFirstState();
+    setConfirmFirstStore(store);
+    hydrateFromStore('sess-restart');
+
+    expect(evaluateConfirmFirstGateSync('sess-restart', 'write', {}).action).toBe('block');
+    expect(hasActiveDirective('sess-restart')).toBe(true);
+    expect(isSessionApproved('sess-restart')).toBe(false);
+  });
+
+  it('no directive survives restart', () => {
+    setConfirmFirstStore(store);
+
+    setConfirmFirstStore(null);
+    clearAllConfirmFirstState();
+    setConfirmFirstStore(store);
+    hydrateFromStore('sess-noexist');
+
+    expect(evaluateConfirmFirstGateSync('sess-noexist', 'write', {}).action).toBe('skip');
+    expect(hasActiveDirective('sess-noexist')).toBe(false);
+  });
+});
+
+describe('Store degradation (ERR-002)', () => {
+  afterEach(() => {
+    setConfirmFirstStore(null);
+    clearAllConfirmFirstState();
+  });
+
+  it('store write failure degrades gracefully to cache-only', () => {
+    const throwingStore = {
+      upsertDirective: () => { throw new Error('DB unavailable'); },
+      upsertApproval: () => { throw new Error('DB unavailable'); },
+      getState: () => null,
+      deleteState: () => { throw new Error('DB unavailable'); },
+      deleteAllState: () => { throw new Error('DB unavailable'); },
+      pruneStaleRows: () => 0,
+      getAllState: () => [],
+    } as unknown as SqliteConfirmFirstStateStore;
+
+    setConfirmFirstStore(throwingStore);
+    setConfirmFirstDirective('sess-degrade', true, 'princ-123');
+
+    expect(hasActiveDirective('sess-degrade')).toBe(true);
+
+    setConfirmFirstApproval('sess-degrade');
+    expect(isSessionApproved('sess-degrade')).toBe(true);
+    expect(evaluateConfirmFirstGateSync('sess-degrade', 'write', {}).action).toBe('allow');
+  });
+});
+
+describe('Stale directive cleared on reset (PRI-266)', () => {
+  beforeEach(() => {
+    clearAllConfirmFirstState();
+  });
+
+  it('resetConfirmFirst clears directive and approval from cache and store', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-cf-stale-'));
+    try {
+      const connection = new SqliteConnection(tmpDir);
+      const store = new SqliteConfirmFirstStateStore(connection);
+      setConfirmFirstStore(store);
+
+      setConfirmFirstDirective('sess-stale', true, 'princ-stale');
+      setConfirmFirstApproval('sess-stale');
+
+      expect(hasActiveDirective('sess-stale')).toBe(true);
+      expect(isSessionApproved('sess-stale')).toBe(true);
+
+      resetConfirmFirst('sess-stale');
+
+      expect(hasActiveDirective('sess-stale')).toBe(false);
+      expect(isSessionApproved('sess-stale')).toBe(false);
+      expect(evaluateConfirmFirstGateSync('sess-stale', 'write', {}).action).toBe('skip');
+
+      connection.close();
+    } finally {
+      setConfirmFirstStore(null);
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it('resetConfirmFirst without store clears in-memory cache only', () => {
+    setConfirmFirstDirective('sess-nostore', true, 'princ-nostore');
+    setConfirmFirstApproval('sess-nostore');
+
+    expect(hasActiveDirective('sess-nostore')).toBe(true);
+    expect(isSessionApproved('sess-nostore')).toBe(true);
+
+    resetConfirmFirst('sess-nostore');
+
+    expect(hasActiveDirective('sess-nostore')).toBe(false);
+    expect(isSessionApproved('sess-nostore')).toBe(false);
+  });
+});