@complior/engine 0.9.0

package/src/domain/scanner/attestations.ts

@@ -0,0 +1,97 @@
+import { z } from 'zod';
+import type { Finding } from '../../types/common.types.js';
+import type { ScanContext } from '../../ports/scanner.port.js';
+
+/**
+ * Manual attestation entry — for checks that cannot be code-verified.
+ * Stored in `.complior/attestations.json`.
+ */
+export interface Attestation {
+  readonly checkId: string;
+  readonly attested: boolean;
+  readonly attestedBy: string;
+  readonly attestedAt: string;
+  readonly expiresAt?: string;
+  readonly evidence?: string;
+  readonly notes?: string;
+}
+
+const AttestationSchema = z.object({
+  checkId: z.string().min(1),
+  attested: z.boolean(),
+  attestedBy: z.string().min(1),
+  attestedAt: z.string().regex(/^\d{4}-\d{2}-\d{2}/),
+  expiresAt: z.string().regex(/^\d{4}-\d{2}-\d{2}/).optional(),
+  evidence: z.string().optional(),
+  notes: z.string().optional(),
+});
+
+const AttestationsFileSchema = z.object({
+  attestations: z.array(AttestationSchema),
+});
+
+export type AttestationsFile = z.infer<typeof AttestationsFileSchema>;
+
+const ATTESTATIONS_PATH = '.complior/attestations.json';
+
+/** Default attestation validity period: 12 months. */
+const DEFAULT_EXPIRY_MONTHS = 12;
+
+const isExpired = (att: Attestation, now: Date): boolean => {
+  if (att.expiresAt) {
+    return new Date(att.expiresAt) <= now;
+  }
+  // No explicit expiry → default 12 months from attestedAt
+  const attDate = new Date(att.attestedAt);
+  attDate.setMonth(attDate.getMonth() + DEFAULT_EXPIRY_MONTHS);
+  return attDate <= now;
+};
+
+/**
+ * Load attestations from scan context files with Zod validation.
+ */
+const loadAttestations = (ctx: ScanContext): ReadonlyMap<string, Attestation> => {
+  const attestationFile = ctx.files.find((f) => f.relativePath === ATTESTATIONS_PATH);
+  if (!attestationFile) return new Map();
+
+  try {
+    const raw = JSON.parse(attestationFile.content);
+    const parsed = AttestationsFileSchema.parse(raw);
+
+    const now = new Date();
+    const map = new Map<string, Attestation>();
+    for (const att of parsed.attestations) {
+      if (att.attested && !isExpired(att, now)) {
+        map.set(att.checkId, att);
+      }
+    }
+    return map;
+  } catch {
+    return new Map();
+  }
+};
+
+/**
+ * Apply manual attestations to findings: convert matching `fail` results to `pass`
+ * when a valid, non-expired attestation exists. Attested findings are marked with a note.
+ */
+export const applyAttestations = (
+  findings: readonly Finding[],
+  ctx: ScanContext,
+): readonly Finding[] => {
+  const attestations = loadAttestations(ctx);
+  if (attestations.size === 0) return findings;
+
+  return findings.map((f) => {
+    if (f.type !== 'fail') return f;
+
+    const att = attestations.get(f.checkId);
+    if (!att) return f;
+
+    return {
+      ...f,
+      type: 'pass' as const,
+      message: `${f.message} [manually attested by ${att.attestedBy} on ${att.attestedAt}]`,
+    };
+  });
+};

package/src/domain/scanner/checks/ai-disclosure.test.ts

@@ -0,0 +1,90 @@
+import { describe, it, expect } from 'vitest';
+import { checkAiDisclosure } from './ai-disclosure.js';
+import { createScanFile, createScanCtx } from '../../../test-helpers/factories.js';
+
+describe('checkAiDisclosure', () => {
+  it('passes when AI disclosure text found in UI code', () => {
+    const ctx = createScanCtx([
+      createScanFile('src/components/Chat.tsx', '<p>This is an AI-powered assistant</p>'),
+    ]);
+
+    const results = checkAiDisclosure(ctx);
+
+    expect(results).toHaveLength(1);
+    expect(results[0].type).toBe('pass');
+    expect(results[0].checkId).toBe('ai-disclosure');
+  });
+
+  it('passes when "artificial intelligence" disclosure found', () => {
+    const ctx = createScanCtx([
+      createScanFile('src/Bot.tsx', 'Powered by artificial intelligence technology'),
+    ]);
+
+    const results = checkAiDisclosure(ctx);
+
+    expect(results).toHaveLength(1);
+    expect(results[0].type).toBe('pass');
+  });
+
+  it('fails when chat code exists without disclosure', () => {
+    const ctx = createScanCtx([
+      createScanFile('src/components/ChatWidget.tsx', 'function ChatWidget() { return <div>chatbot interface</div> }'),
+    ]);
+
+    const results = checkAiDisclosure(ctx);
+
+    expect(results).toHaveLength(1);
+    expect(results[0].type).toBe('fail');
+    if (results[0].type === 'fail') {
+      expect(results[0].severity).toBe('high');
+      expect(results[0].obligationId).toBe('eu-ai-act-OBL-015');
+      expect(results[0].articleReference).toBe('Art. 50(1)');
+      expect(results[0].fix).toBeDefined();
+    }
+  });
+
+  it('fails when /api/chat endpoint exists without disclosure', () => {
+    const ctx = createScanCtx([
+      createScanFile('src/routes/chat.ts', 'app.post("/api/chat", handler)'),
+    ]);
+
+    const results = checkAiDisclosure(ctx);
+
+    expect(results).toHaveLength(1);
+    expect(results[0].type).toBe('fail');
+  });
+
+  it('skips when no chat or AI interaction code found', () => {
+    const ctx = createScanCtx([
+      createScanFile('src/App.tsx', 'function App() { return <div>Hello World</div> }'),
+    ]);
+
+    const results = checkAiDisclosure(ctx);
+
+    expect(results).toHaveLength(1);
+    expect(results[0].type).toBe('skip');
+  });
+
+  it('passes when disclosure exists alongside chat code', () => {
+    const ctx = createScanCtx([
+      createScanFile('src/Chat.tsx', 'function Chat() { return <div>chatbot</div> }'),
+      createScanFile('src/Disclosure.tsx', '<p>This is an AI-powered system</p>'),
+    ]);
+
+    const results = checkAiDisclosure(ctx);
+
+    expect(results).toHaveLength(1);
+    expect(results[0].type).toBe('pass');
+  });
+
+  it('ignores non-UI file extensions', () => {
+    const ctx = createScanCtx([
+      createScanFile('data/chat.json', '{"chatbot": true}'),
+    ]);
+
+    const results = checkAiDisclosure(ctx);
+
+    expect(results).toHaveLength(1);
+    expect(results[0].type).toBe('skip');
+  });
+});

package/src/domain/scanner/checks/ai-disclosure.ts

@@ -0,0 +1,54 @@
+import type { FileInfo } from '../../../ports/scanner.port.js';
+import { CORE_DISCLOSURE_PATTERNS } from '../../shared/disclosure-patterns.js';
+import { createPatternCheck } from './pattern-check-factory.js';
+
+/** Source-code-specific disclosure patterns (beyond core). */
+const SOURCE_CODE_PATTERNS: readonly RegExp[] = [
+  /\bautomated system\b/i,
+  /\bAI disclosure\b/i,
+  /\btransparency notice\b/i,
+  /\bautomated decision[- ]?making\b/i,
+  /\byou are (?:interacting|chatting|speaking) with (?:an? )?AI\b/i,
+  /\bthis (?:is|uses) (?:an? )?(?:AI|artificial intelligence)\b/i,
+  /\bgenerated (?:by|using|with) (?:an? )?AI\b/i,
+  /\bAI[- ]?assisted\b/i,
+  /\bnot a human\b/i,
+  /\bdisclosure[_-]?text\b/i,
+  /\btransparency[_-]?label\b/i,
+  /\bai[_-]?notice\b/i,
+];
+
+const CHAT_INDICATORS: readonly RegExp[] = [
+  /\bchatbot\b/i,
+  /\bchat[- ]?widget\b/i,
+  /\bconversational[- ]?ai\b/i,
+  /\bvirtual[- ]?assistant\b/i,
+  /\bai[- ]?assistant\b/i,
+  /\bchat[- ]?endpoint\b/i,
+  /\/api\/chat\b/i,
+  /\bmessage.*bot\b/i,
+  /\bvoice[- ]?assistant\b/i,
+  /\bspeech[- ]?to[- ]?text\b/i,
+  /\btext[- ]?to[- ]?speech\b/i,
+  /\brecommendation[- ]?engine\b/i,
+  /\bdecision[- ]?support\b/i,
+  /\bautomated[- ]?scoring\b/i,
+  /\bai[- ]?agent\b/i,
+];
+
+const UI_EXTENSIONS: ReadonlySet<string> = new Set(['.tsx', '.jsx', '.html', '.ts', '.js']);
+const isUiFile = (file: FileInfo): boolean => UI_EXTENSIONS.has(file.extension);
+
+export const checkAiDisclosure = createPatternCheck({
+  checkId: 'ai-disclosure',
+  articleRef: 'Art. 50(1)',
+  obligationId: 'eu-ai-act-OBL-015',
+  severity: 'high',
+  positivePatterns: [...CORE_DISCLOSURE_PATTERNS, ...SOURCE_CODE_PATTERNS],
+  contextPatterns: CHAT_INDICATORS,
+  passMessage: 'AI disclosure patterns found in UI code',
+  failMessage: 'Chat/bot code detected without AI disclosure notice',
+  skipReason: 'No chat/bot or AI interaction code detected',
+  fix: 'Add a visible disclosure that users are interacting with an AI system',
+  fileFilter: isUiFile,
+});

package/src/domain/scanner/checks/ai-literacy.ts

@@ -0,0 +1,163 @@
+import type { CheckResult } from '../../../types/common.types.js';
+import type { ScanContext } from '../../../ports/scanner.port.js';
+import { DOCUMENT_VALIDATORS } from '../validators.js';
+
+const CHECK_ID = 'ai-literacy';
+const ARTICLE_REF = 'Art. 4';
+const OBLIGATION_ID = 'eu-ai-act-OBL-001';
+
+// Derive file patterns from validators.ts (single source of truth)
+const VALIDATOR_FILE_PATTERNS: readonly string[] =
+  DOCUMENT_VALIDATORS.find((v) => v.document === 'ai-literacy')?.file_patterns ?? [];
+
+const LITERACY_CONTENT_PATTERNS: readonly RegExp[] = [
+  /\bai literacy\b/i,
+  /\bai training\b.*\bpolicy\b/i,
+  /\bai competency\b/i,
+  /\bai awareness\b/i,
+  /\bstaff training\b.*\bai\b/i,
+  /\bai education\b/i,
+];
+
+const isPolicyFile = (relativePath: string): boolean => {
+  const filename = relativePath.split('/').pop() ?? '';
+  return VALIDATOR_FILE_PATTERNS.some((p) => filename.toLowerCase() === p.toLowerCase());
+};
+
+const isTrainingRecordsDir = (relativePath: string): boolean =>
+  /training[-_]?records/i.test(relativePath);
+
+const hasLiteracyContent = (content: string): boolean =>
+  LITERACY_CONTENT_PATTERNS.some((p) => p.test(content));
+
+const GENERATED_DOC_PATHS: readonly RegExp[] = [
+  /^\.complior\/documents\/.*ai[-_]?literacy/i,
+  /^\.complior\/reports\/.*ai[-_]?literacy/i,
+  /^docs\/compliance\/.*ai[-_]?literacy/i,
+];
+
+const isGeneratedDoc = (relativePath: string): boolean =>
+  GENERATED_DOC_PATHS.some((p) => p.test(relativePath));
+
+const TRAINING_STALE_MONTHS = 12;
+
+const isTrainingStale = (lastTrainingDate: string): boolean => {
+  const last = new Date(lastTrainingDate);
+  if (isNaN(last.getTime())) return false; // Invalid date — don't flag
+  const now = new Date();
+  const monthsDiff = (now.getFullYear() - last.getFullYear()) * 12 + (now.getMonth() - last.getMonth());
+  return monthsDiff > TRAINING_STALE_MONTHS;
+};
+
+export const checkAiLiteracy = (ctx: ScanContext): readonly CheckResult[] => {
+  const results: CheckResult[] = [];
+  let docFound = false;
+
+  // Phase 1: Check for policy file by name
+  for (const file of ctx.files) {
+    if (isPolicyFile(file.relativePath)) {
+      docFound = true;
+      results.push({
+        type: 'pass',
+        checkId: CHECK_ID,
+        message: `AI literacy policy file found: ${file.relativePath} (${ARTICLE_REF})`,
+      });
+      break;
+    }
+  }
+
+  // Phase 2: Check for training-records directory
+  if (!docFound) {
+    for (const file of ctx.files) {
+      if (isTrainingRecordsDir(file.relativePath)) {
+        docFound = true;
+        results.push({
+          type: 'pass',
+          checkId: CHECK_ID,
+          message: `AI training records directory found (${ARTICLE_REF})`,
+        });
+        break;
+      }
+    }
+  }
+
+  // Phase 3: Check for generated docs in .complior/documents/
+  if (!docFound) {
+    for (const file of ctx.files) {
+      if (isGeneratedDoc(file.relativePath)) {
+        docFound = true;
+        results.push({
+          type: 'pass',
+          checkId: CHECK_ID,
+          message: `AI literacy document found: ${file.relativePath} (${ARTICLE_REF})`,
+        });
+        break;
+      }
+    }
+  }
+
+  // Phase 4: Content scan in docs/
+  if (!docFound) {
+    const docsFiles = ctx.files.filter((f) =>
+      f.relativePath.startsWith('docs/') && f.extension === '.md',
+    );
+    for (const file of docsFiles) {
+      if (hasLiteracyContent(file.content)) {
+        docFound = true;
+        results.push({
+          type: 'pass',
+          checkId: CHECK_ID,
+          message: `AI literacy content found in docs: ${file.relativePath} (${ARTICLE_REF})`,
+        });
+        break;
+      }
+    }
+  }
+
+  // Phase 5: Check passport for training actuality
+  if (ctx.passportManifests && ctx.passportManifests.length > 0) {
+    for (const manifest of ctx.passportManifests) {
+      try {
+        const passport = JSON.parse(manifest.content);
+        const literacy = passport?.compliance?.ai_literacy;
+        if (literacy?.last_training_date && isTrainingStale(literacy.last_training_date)) {
+          results.push({
+            type: 'fail',
+            checkId: 'ai-literacy-stale',
+            message: `AI literacy training is overdue — last training: ${literacy.last_training_date} (>${TRAINING_STALE_MONTHS} months) (${ARTICLE_REF})`,
+            severity: 'medium',
+            obligationId: 'eu-ai-act-OBL-001a',
+            articleReference: ARTICLE_REF,
+            fix: 'Schedule AI literacy refresher training. Art. 4 requires training proportionate to role and risk level.',
+          });
+        }
+        if (literacy?.training_completed === false) {
+          results.push({
+            type: 'fail',
+            checkId: 'ai-literacy-incomplete',
+            message: `AI literacy training not yet completed for this system (${ARTICLE_REF})`,
+            severity: 'medium',
+            obligationId: 'eu-ai-act-OBL-001a',
+            articleReference: ARTICLE_REF,
+            fix: 'Complete AI literacy training and update passport field compliance.ai_literacy.training_completed',
+          });
+        }
+      } catch { /* skip unparseable passport */ }
+    }
+  }
+
+  // No document found at all
+  if (!docFound) {
+    results.push({
+      type: 'fail',
+      checkId: CHECK_ID,
+      message: `No AI literacy policy or training documentation found (${ARTICLE_REF})`,
+      severity: 'medium',
+      obligationId: OBLIGATION_ID,
+      articleReference: ARTICLE_REF,
+      fix: 'Create an AI-LITERACY.md policy document covering staff AI competency requirements',
+    });
+  }
+
+  return results;
+};

package/src/domain/scanner/checks/behavioral-constraints.test.ts

@@ -0,0 +1,167 @@
+import { describe, it, expect } from 'vitest';
+import { checkBehavioralConstraints } from './behavioral-constraints.js';
+import { createScanFile, createScanCtx } from '../../../test-helpers/factories.js';
+
+const makePassport = (overrides: Record<string, unknown> = {}): string =>
+  JSON.stringify({
+    name: 'test-bot',
+    compliance: { eu_ai_act: { risk_class: 'high' } },
+    constraints: {
+      escalation_rules: [
+        { condition: 'action == "deploy"', action: 'require_approval', description: 'Deploy approval', timeout_minutes: 5 },
+      ],
+    },
+    permissions: {
+      tools: ['search'],
+      data_boundaries: { pii_handling: 'redact' },
+    },
+    ...overrides,
+  });
+
+describe('checkBehavioralConstraints', () => {
+  it('returns empty when no passport files', () => {
+    const ctx = createScanCtx([
+      createScanFile('package.json', '{"dependencies":{}}'),
+    ]);
+    const results = checkBehavioralConstraints(ctx);
+    expect(results).toHaveLength(0);
+  });
+
+  it('passes for high-risk with escalation rules and data boundaries', () => {
+    const ctx = createScanCtx([
+      createScanFile('.complior/agents/test-bot-manifest.json', makePassport()),
+    ]);
+    const results = checkBehavioralConstraints(ctx);
+    const passes = results.filter((r) => r.type === 'pass');
+    expect(passes).toHaveLength(2);
+    expect(results.every((r) => r.type === 'pass')).toBe(true);
+  });
+
+  it('fails high-risk missing escalation rules', () => {
+    const passport = makePassport({
+      constraints: { prohibited_actions: [] },
+    });
+    const ctx = createScanCtx([
+      createScanFile('.complior/agents/test-bot-manifest.json', passport),
+    ]);
+    const results = checkBehavioralConstraints(ctx);
+    const fails = results.filter((r) => r.type === 'fail');
+    expect(fails).toHaveLength(1);
+    expect(fails[0].type === 'fail' && fails[0].severity).toBe('high');
+    expect(fails[0].message).toContain('escalation rules');
+  });
+
+  it('fails high-risk missing data boundaries', () => {
+    const passport = makePassport({
+      permissions: { tools: ['search'] },
+    });
+    const ctx = createScanCtx([
+      createScanFile('.complior/agents/test-bot-manifest.json', passport),
+    ]);
+    const results = checkBehavioralConstraints(ctx);
+    const dataBoundaryFail = results.find(
+      (r) => r.type === 'fail' && r.message.includes('data boundaries'),
+    );
+    expect(dataBoundaryFail).toBeDefined();
+    expect(dataBoundaryFail!.type === 'fail' && dataBoundaryFail!.severity).toBe('high');
+  });
+
+  it('does not require escalation rules for limited-risk', () => {
+    const passport = makePassport({
+      compliance: { eu_ai_act: { risk_class: 'limited' } },
+      constraints: { prohibited_actions: [] },
+    });
+    const ctx = createScanCtx([
+      createScanFile('.complior/agents/test-bot-manifest.json', passport),
+    ]);
+    const results = checkBehavioralConstraints(ctx);
+    const escalationFail = results.find(
+      (r) => r.type === 'fail' && r.message.includes('escalation'),
+    );
+    expect(escalationFail).toBeUndefined();
+  });
+
+  it('fails limited-risk missing data boundaries with medium severity', () => {
+    const passport = makePassport({
+      compliance: { eu_ai_act: { risk_class: 'limited' } },
+      permissions: { tools: ['search'] },
+    });
+    const ctx = createScanCtx([
+      createScanFile('.complior/agents/test-bot-manifest.json', passport),
+    ]);
+    const results = checkBehavioralConstraints(ctx);
+    const dataBoundaryFail = results.find(
+      (r) => r.type === 'fail' && r.message.includes('data boundaries'),
+    );
+    expect(dataBoundaryFail).toBeDefined();
+    expect(dataBoundaryFail!.type === 'fail' && dataBoundaryFail!.severity).toBe('medium');
+  });
+
+  it('passes limited-risk with pii_handling defined', () => {
+    const passport = makePassport({
+      compliance: { eu_ai_act: { risk_class: 'limited' } },
+      constraints: { prohibited_actions: [] },
+      permissions: {
+        tools: ['search'],
+        data_boundaries: { pii_handling: 'block' },
+      },
+    });
+    const ctx = createScanCtx([
+      createScanFile('.complior/agents/test-bot-manifest.json', passport),
+    ]);
+    const results = checkBehavioralConstraints(ctx);
+    expect(results.every((r) => r.type === 'pass')).toBe(true);
+  });
+
+  it('handles invalid JSON without crashing', () => {
+    const ctx = createScanCtx([
+      createScanFile('.complior/agents/broken-manifest.json', '{ invalid json'),
+    ]);
+    const results = checkBehavioralConstraints(ctx);
+    expect(results).toHaveLength(0);
+  });
+
+  it('treats minimal-risk same as limited — no escalation required, medium data boundary', () => {
+    const passport = makePassport({
+      compliance: { eu_ai_act: { risk_class: 'minimal' } },
+      constraints: { prohibited_actions: [] },
+      permissions: { tools: ['search'] },
+    });
+    const ctx = createScanCtx([
+      createScanFile('.complior/agents/test-bot-manifest.json', passport),
+    ]);
+    const results = checkBehavioralConstraints(ctx);
+    const escalationFail = results.find(
+      (r) => r.type === 'fail' && r.message.includes('escalation'),
+    );
+    expect(escalationFail).toBeUndefined();
+    const dataBoundaryFail = results.find(
+      (r) => r.type === 'fail' && r.message.includes('data boundaries'),
+    );
+    expect(dataBoundaryFail).toBeDefined();
+    expect(dataBoundaryFail!.type === 'fail' && dataBoundaryFail!.severity).toBe('medium');
+  });
+
+  it('handles multiple passports independently', () => {
+    const highRiskPassport = makePassport({
+      name: 'high-bot',
+      compliance: { eu_ai_act: { risk_class: 'high' } },
+    });
+    const limitedPassport = makePassport({
+      name: 'limited-bot',
+      compliance: { eu_ai_act: { risk_class: 'limited' } },
+      constraints: { prohibited_actions: [] },
+    });
+    const ctx = createScanCtx([
+      createScanFile('.complior/agents/high-bot-manifest.json', highRiskPassport),
+      createScanFile('.complior/agents/limited-bot-manifest.json', limitedPassport),
+    ]);
+    const results = checkBehavioralConstraints(ctx);
+    // high-risk: escalation pass + data boundary pass = 2
+    // limited-risk: no escalation check + data boundary pass = 1
+    expect(results).toHaveLength(3);
+    expect(results.every((r) => r.type === 'pass')).toBe(true);
+    expect(results.some((r) => r.message.includes('high-bot'))).toBe(true);
+    expect(results.some((r) => r.message.includes('limited-bot'))).toBe(true);
+  });
+});

package/src/domain/scanner/checks/behavioral-constraints.ts

@@ -0,0 +1,86 @@
+import type { CheckResult } from '../../../types/common.types.js';
+import type { ScanContext } from '../../../ports/scanner.port.js';
+import { filterPassportManifests, extractRiskClass } from '../../passport/builder/manifest-files.js';
+
+const CHECK_ID = 'behavioral-constraints';
+const ARTICLE_REF_ESCALATION = 'Art. 14(4)';
+const ARTICLE_REF_DATA = 'Art. 9(2)';
+const OBLIGATION_ID_ESCALATION = 'eu-ai-act-OBL-014';
+const OBLIGATION_ID_DATA = 'eu-ai-act-OBL-009';
+
+const checkEscalation = (
+  manifest: Record<string, unknown>,
+  isHighRisk: boolean,
+  name: string,
+  filePath: string,
+): CheckResult | undefined => {
+  if (!isHighRisk) return undefined;
+
+  const constraints = manifest.constraints as Record<string, unknown> | undefined;
+  const rules = constraints?.escalation_rules as unknown[] | undefined;
+
+  if (!rules || rules.length === 0) {
+    return {
+      type: 'fail',
+      checkId: CHECK_ID,
+      message: `Missing escalation rules for high-risk agent: ${name} (${ARTICLE_REF_ESCALATION})`,
+      severity: 'high',
+      obligationId: OBLIGATION_ID_ESCALATION,
+      articleReference: ARTICLE_REF_ESCALATION,
+      fix: 'Add constraints.escalation_rules to passport with structured human oversight measures',
+      file: filePath,
+    };
+  }
+
+  return { type: 'pass', checkId: CHECK_ID, message: `Escalation rules defined for high-risk agent: ${name}` };
+};
+
+const checkDataBoundary = (
+  manifest: Record<string, unknown>,
+  isHighRisk: boolean,
+  name: string,
+  filePath: string,
+): CheckResult => {
+  const permissions = manifest.permissions as Record<string, unknown> | undefined;
+  const boundaries = permissions?.data_boundaries as Record<string, unknown> | undefined;
+
+  if (!boundaries || !boundaries.pii_handling) {
+    return {
+      type: 'fail',
+      checkId: CHECK_ID,
+      message: `Missing data boundaries for agent: ${name} (${ARTICLE_REF_DATA})`,
+      severity: isHighRisk ? 'high' : 'medium',
+      obligationId: OBLIGATION_ID_DATA,
+      articleReference: ARTICLE_REF_DATA,
+      fix: 'Add permissions.data_boundaries with pii_handling mode to passport',
+      file: filePath,
+    };
+  }
+
+  return { type: 'pass', checkId: CHECK_ID, message: `Data boundaries defined for agent: ${name}` };
+};
+
+export const checkBehavioralConstraints = (ctx: ScanContext): readonly CheckResult[] => {
+  const passportFiles = filterPassportManifests(ctx.files);
+  if (passportFiles.length === 0) return [];
+
+  const results: CheckResult[] = [];
+
+  for (const file of passportFiles) {
+    try {
+      const manifest = JSON.parse(file.content) as Record<string, unknown>;
+      const riskClass = extractRiskClass(manifest);
+      const isHighRisk = riskClass === 'high' || riskClass === 'prohibited';
+      const name = (manifest.name as string) ?? file.relativePath;
+
+      const escalationResult = checkEscalation(manifest, isHighRisk, name, file.relativePath);
+      if (escalationResult) results.push(escalationResult);
+
+      results.push(checkDataBoundary(manifest, isHighRisk, name, file.relativePath));
+    } catch {
+      // Invalid JSON — skip silently, passport-presence handles parse errors
+    }
+  }
+
+  return results;
+};