cycode 3.22.2.dev3__py3-none-any.whl → 3.23.1.dev1__py3-none-any.whl

cycode/__init__.py

@@ -5,4 +5,4 @@ import time as _time
 # end-to-end scan duration from the moment the user actually triggered it.
 _BOOT_WALL: float = _time.time()
 
-__version__ = '3.22.2.dev3'  # DON'T TOUCH. Placeholder. Will be filled automatically on poetry build from Git Tag
+__version__ = '3.23.1.dev1'  # DON'T TOUCH. Placeholder. Will be filled automatically on poetry build from Git Tag

cycode/cli/apps/ai_guardrails/consts.py

@@ -22,6 +22,18 @@ class GuardrailsMode(str, Enum):
     BLOCK = 'block'
 
 
+class GuardrailCellMode(str, Enum):
+    """A guardrail x agent cell in the platform-resolved matrix.
+
+    Separate from GuardrailsMode because Off is a platform-only state: it is not an
+    install `--mode` choice, and an off guardrail reports no mode to the server.
+    """
+
+    OFF = 'off'
+    REPORT = GuardrailsMode.REPORT.value
+    BLOCK = GuardrailsMode.BLOCK.value
+
+
 # Base CLI commands invoked from installed hooks. IDE classes append --ide flags
 # (and any other suffix) on top of these.
 CYCODE_SCAN_PROMPT_COMMAND = 'cycode ai-guardrails scan'

cycode/cli/apps/ai_guardrails/hooks_manager.py

@@ -12,9 +12,9 @@ from typing import Optional
 
 import yaml
 
-from cycode.cli.apps.ai_guardrails.consts import PolicyMode
 from cycode.cli.apps.ai_guardrails.ides.base import IDE
 from cycode.cli.apps.ai_guardrails.scan.consts import DEFAULT_POLICY, POLICY_FILE_NAME
+from cycode.cli.apps.ai_guardrails.scan.policy import strip_platform_managed_keys
 from cycode.logger import get_logger
 
 logger = get_logger('AI Guardrails Hooks')
@@ -102,22 +102,21 @@ def _load_policy_dict(policy_path: Path) -> dict:
     return {**copy.deepcopy(DEFAULT_POLICY), **existing}
 
 
-def create_policy_file(scope: str, mode: PolicyMode, repo_path: Optional[Path] = None) -> tuple[bool, str]:
-    """Create or update the ai-guardrails.yaml policy file.
+def create_policy_file(scope: str, repo_path: Optional[Path] = None) -> tuple[bool, str]:
+    """Create or update the ai-guardrails.yaml policy file (operational knobs only).
 
-    If the file already exists, only the mode field is updated; otherwise a new
-    file is created from the default policy.
+    Enforcement mode and sensitive-path globs are platform-managed; those keys are stripped
+    (including ones an older CLI wrote), everything else the user customized is preserved.
     """
     config_dir = repo_path / '.cycode' if scope == 'repo' and repo_path else Path.home() / '.cycode'
     policy_path = config_dir / POLICY_FILE_NAME
 
-    policy = _load_policy_dict(policy_path)
-    policy['mode'] = mode.value
+    policy = strip_platform_managed_keys(_load_policy_dict(policy_path))
 
     try:
         config_dir.mkdir(parents=True, exist_ok=True)
         policy_path.write_text(yaml.dump(policy, default_flow_style=False, sort_keys=False), encoding='utf-8')
-        return True, f'AI guardrails policy ({mode.value} mode) set: {policy_path}'
+        return True, f'AI guardrails policy file set: {policy_path}'
     except Exception as e:
         logger.error('Failed to create policy file', exc_info=e)
         return False, f'Failed to create policy file: {policy_path}'

cycode/cli/apps/ai_guardrails/install_command.py

@@ -6,7 +6,7 @@ from typing import Annotated, Optional
 import typer
 
 from cycode.cli.apps.ai_guardrails.command_utils import console, resolve_repo_path, validate_scope
-from cycode.cli.apps.ai_guardrails.consts import GuardrailsMode, PolicyMode
+from cycode.cli.apps.ai_guardrails.consts import GuardrailsMode
 from cycode.cli.apps.ai_guardrails.hooks_manager import create_policy_file, install_hooks
 from cycode.cli.apps.ai_guardrails.ides import DEFAULT_IDE_NAME, IDES, resolve_ides
 
@@ -44,8 +44,7 @@ def install_command(
         typer.Option(
             '--mode',
             '-m',
-            help='Installation mode: "report" for async non-blocking hooks with warn policy, '
-            '"block" for sync blocking hooks.',
+            help='[Deprecated] Enforcement mode is platform-managed; configure guardrails in the Cycode platform.',
         ),
     ] = GuardrailsMode.REPORT,
 ) -> None:
@@ -80,32 +79,34 @@ def install_command(
             console.print(f'[red]✗[/] {message}', style='bold red')
             all_success = False
 
+    if mode == GuardrailsMode.BLOCK:
+        console.print(
+            '[yellow]--mode is deprecated:[/] enforcement mode is platform-managed; '
+            'configure guardrails in the Cycode platform.'
+        )
+
     if any_success:
-        policy_mode = PolicyMode.WARN if mode == GuardrailsMode.REPORT else PolicyMode.BLOCK
-        _install_policy(scope, repo_path, policy_mode)
-        _print_next_steps(results, mode)
+        _install_policy(scope, repo_path)
+        _print_next_steps(results)
 
     if not all_success:
         raise typer.Exit(1)
 
 
-def _install_policy(scope: str, repo_path: Optional[Path], policy_mode: PolicyMode) -> None:
-    policy_success, policy_message = create_policy_file(scope, policy_mode, repo_path)
+def _install_policy(scope: str, repo_path: Optional[Path]) -> None:
+    policy_success, policy_message = create_policy_file(scope, repo_path)
     if policy_success:
         console.print(f'[green]✓[/] {policy_message}')
     else:
         console.print(f'[red]✗[/] {policy_message}', style='bold red')
 
 
-def _print_next_steps(results: list[tuple[str, bool, str]], mode: GuardrailsMode) -> None:
+def _print_next_steps(results: list[tuple[str, bool, str]]) -> None:
     console.print()
     console.print('[bold]Next steps:[/]')
     successful_ides = [name for name, success, _ in results if success]
     ide_list = ', '.join(successful_ides)
     console.print(f'1. Restart {ide_list} to activate the hooks')
-    console.print('2. (Optional) Customize policy in ~/.cycode/ai-guardrails.yaml')
+    console.print('2. Configure guardrail enforcement in the Cycode platform')
     console.print()
-    if mode == GuardrailsMode.REPORT:
-        console.print('[dim]Report mode: policy is set to warn.[/]')
-    else:
-        console.print('[dim]The hooks will scan prompts, file reads, and MCP tool calls for secrets.[/]')
+    console.print('[dim]The hooks will scan prompts, file reads, and MCP tool calls for secrets.[/]')

cycode/cli/apps/ai_guardrails/scan/consts.py

@@ -1,48 +1,37 @@
 """
 Constants and default configuration for AI guardrails.
 
-These defaults can be overridden by:
-1. User-level config: ~/.cycode/ai-guardrails.yaml
-2. Repo-level config: <workspace>/.cycode/ai-guardrails.yaml
+Enforcement (which guardrails run, in which mode, over which paths) is platform-owned and
+resolved per scan; see scan/guardrail_config.py. What is left here is the operational knobs
+a local file may override - user-level ~/.cycode/ai-guardrails.yaml, then repo-level
+<workspace>/.cycode/ai-guardrails.yaml.
 """
 
 # Policy file name
 POLICY_FILE_NAME = 'ai-guardrails.yaml'
 
-# Default policy configuration
+# Sensitive-path globs used until the platform's own list is cached (cold start, or a tenant
+# that never customized them). Not a local knob: apply_platform_config always overwrites it.
+DEFAULT_SENSITIVE_PATH_GLOBS = [
+    '.env',
+    '.env.*',
+    '*.pem',
+    '*.p12',
+    '*.key',
+    '.aws/**',
+    '.ssh/**',
+    '*kubeconfig*',
+    '.npmrc',
+    '.netrc',
+]
+
+# Default policy configuration: operational knobs only.
 DEFAULT_POLICY = {
     'version': 1,
-    'mode': 'block',  # block | warn
     'fail_open': True,  # allow if scan fails/timeouts
     'secrets': {
         'scan_type': 'secret',
         'timeout_ms': 30000,
         'max_bytes': 200000,
     },
-    'prompt': {
-        'enabled': True,
-        'action': 'block',
-    },
-    'file_read': {
-        'enabled': True,
-        'action': 'block',
-        'deny_globs': [
-            '.env',
-            '.env.*',
-            '*.pem',
-            '*.p12',
-            '*.key',
-            '.aws/**',
-            '.ssh/**',
-            '*kubeconfig*',
-            '.npmrc',
-            '.netrc',
-        ],
-        'scan_content': True,
-    },
-    'mcp': {
-        'enabled': True,
-        'action': 'block',
-        'scan_arguments': True,
-    },
 }

cycode/cli/apps/ai_guardrails/scan/guardrail_config.py

@@ -0,0 +1,165 @@
+"""Platform guardrail config cache.
+
+session-start fetches the tenant's resolved guardrail config from the platform and writes it
+here; scans only read. Per-agent modes and sensitive-path globs are platform-owned - local
+policy files never carry them. An absent or corrupt cache means built-in defaults (Report
+everywhere + the default globs), always synchronous.
+"""
+
+import json
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+from cycode.cli.apps.ai_guardrails.consts import GuardrailCellMode, PolicyMode
+from cycode.cli.apps.ai_guardrails.scan.consts import DEFAULT_SENSITIVE_PATH_GLOBS
+from cycode.cli.apps.ai_guardrails.scan.types import BlockReason
+from cycode.cli.consts import CYCODE_CONFIGURATION_DIRECTORY
+from cycode.cli.utils.path_utils import atomic_write_text, quarantine_corrupt_file
+from cycode.logger import get_logger
+
+logger = get_logger('AI Guardrails')
+
+GUARDRAILS_CONFIG_FILE_NAME = 'ai-guardrails-config.json'
+
+_DEFAULT_TTL_SECONDS = 900
+
+# Guardrail keys are the CLI's block-reason vocabulary. Anything else in the payload (a future
+# guardrail this CLI doesn't implement) is ignored - unknown config must never fail closed.
+_KNOWN_GUARDRAIL_KEYS = frozenset(
+    reason.value
+    for reason in (
+        BlockReason.SECRETS_IN_PROMPT,
+        BlockReason.SECRETS_IN_FILE,
+        BlockReason.SENSITIVE_PATH,
+        BlockReason.SECRETS_IN_MCP_ARGS,
+    )
+)
+
+# CLI --ide names to matrix column names; identity for names not listed.
+_AGENT_BY_IDE_NAME = {'claude-code': 'claude'}
+
+
+def get_config_cache_path() -> Path:
+    return Path.home() / CYCODE_CONFIGURATION_DIRECTORY / GUARDRAILS_CONFIG_FILE_NAME
+
+
+def agent_for_ide(ide_name: Optional[str]) -> str:
+    ide_name = (ide_name or '').lower()
+    return _AGENT_BY_IDE_NAME.get(ide_name, ide_name)
+
+
+def _default_sensitive_globs() -> list:
+    return list(DEFAULT_SENSITIVE_PATH_GLOBS)
+
+
+@dataclass
+class GuardrailConfig:
+    payload: dict
+    fetched_at: float
+    tenant_id: Optional[str] = None
+    _guardrails: dict = field(init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        self._guardrails = {
+            guardrail.get('key'): guardrail
+            for guardrail in self.payload.get('guardrails') or []
+            if guardrail.get('key') in _KNOWN_GUARDRAIL_KEYS
+        }
+
+    def mode_for(self, guardrail_key: str, ide_name: Optional[str]) -> str:
+        agents = (self._guardrails.get(guardrail_key) or {}).get('agents') or {}
+        return str(agents.get(agent_for_ide(ide_name), GuardrailCellMode.REPORT.value)).lower()
+
+    def _modes_for_event(self, event_name: str, ide_name: Optional[str]) -> list:
+        return [
+            self.mode_for(key, ide_name)
+            for key, guardrail in self._guardrails.items()
+            if str(guardrail.get('event_type', '')).lower() == str(event_name).lower()
+        ]
+
+    def is_event_off(self, event_name: str, ide_name: Optional[str]) -> bool:
+        """Every guardrail for this event is Off - skip the scan entirely."""
+        modes = self._modes_for_event(event_name, ide_name)
+        return bool(modes) and all(mode == GuardrailCellMode.OFF for mode in modes)
+
+    def can_event_block(self, event_name: str, ide_name: Optional[str]) -> bool:
+        """At least one guardrail for this event is in Block mode - the scan must stay synchronous."""
+        return GuardrailCellMode.BLOCK in self._modes_for_event(event_name, ide_name)
+
+    def sensitive_globs(self) -> list:
+        settings = (self._guardrails.get(BlockReason.SENSITIVE_PATH) or {}).get('settings') or {}
+        globs = settings.get('globs')
+        return globs if isinstance(globs, list) and globs else _default_sensitive_globs()
+
+    def is_expired(self) -> bool:
+        ttl = self.payload.get('ttl_seconds') or _DEFAULT_TTL_SECONDS
+        return time.time() - self.fetched_at > ttl
+
+    def needs_refresh(self, tenant_id: Optional[str]) -> bool:
+        """Expired, or fetched for another tenant (the user switched tenants since)."""
+        return self.is_expired() or self.tenant_id != tenant_id
+
+
+def apply_platform_config(policy: dict, config: Optional[GuardrailConfig], ide_name: Optional[str]) -> None:
+    """Overlay the platform-owned enforcement config onto the local knobs-only policy.
+
+    The platform is the only mode source: no cache (cold start) means the built-in defaults -
+    Report everywhere with the default globs - which equal an unconfigured tenant's platform
+    config, so behaviour is uniform either way. Each matrix cell lands on its own per-feature
+    action, so the two FileRead guardrails (content scan vs. sensitive path) keep independent modes.
+    An all-Off event never reaches here at all: scan_command skips it.
+    """
+
+    def cell(guardrail_key: str) -> str:
+        return config.mode_for(guardrail_key, ide_name) if config is not None else GuardrailCellMode.REPORT.value
+
+    def action(guardrail_key: str) -> str:
+        return PolicyMode.BLOCK.value if cell(guardrail_key) == GuardrailCellMode.BLOCK else PolicyMode.WARN.value
+
+    policy.setdefault('prompt', {})['action'] = action(BlockReason.SECRETS_IN_PROMPT)
+
+    file_read = policy.setdefault('file_read', {})
+    file_read['scan_content'] = cell(BlockReason.SECRETS_IN_FILE) != GuardrailCellMode.OFF
+    file_read['action'] = action(BlockReason.SECRETS_IN_FILE)
+    file_read['deny_globs'] = (
+        (config.sensitive_globs() if config is not None else _default_sensitive_globs())
+        if cell(BlockReason.SENSITIVE_PATH) != GuardrailCellMode.OFF
+        else []
+    )
+    file_read['path_action'] = action(BlockReason.SENSITIVE_PATH)
+
+    policy.setdefault('mcp', {})['action'] = action(BlockReason.SECRETS_IN_MCP_ARGS)
+
+
+def save_guardrail_config(payload: dict, tenant_id: Optional[str]) -> None:
+    """Persist a fetched resolved config; a failed write just leaves the previous cache in place."""
+    path = get_config_cache_path()
+    content = {'fetched_at': time.time(), 'tenant_id': tenant_id, 'payload': payload}
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        atomic_write_text(str(path), json.dumps(content))
+    except Exception as e:
+        logger.debug('Failed to save guardrail config cache', exc_info=e)
+
+
+def load_guardrail_config() -> Optional[GuardrailConfig]:
+    """The cached platform config, or None when it is absent or corrupt (quarantined)."""
+    path = get_config_cache_path()
+    if not path.exists():
+        return None
+
+    try:
+        with open(path, encoding='UTF-8') as file:
+            content = json.load(file)
+        payload = content['payload']
+        if not isinstance(payload, dict):
+            raise ValueError('payload is not an object')
+        return GuardrailConfig(
+            payload=payload, fetched_at=float(content['fetched_at']), tenant_id=content.get('tenant_id')
+        )
+    except Exception as e:
+        logger.warning('Guardrail config cache is corrupt and will be moved aside', exc_info=e)
+        quarantine_corrupt_file(str(path))
+        return None

cycode/cli/apps/ai_guardrails/scan/handlers.py

@@ -13,10 +13,13 @@ import os
 from dataclasses import dataclass
 from multiprocessing.pool import ThreadPool
 from multiprocessing.pool import TimeoutError as PoolTimeoutError
-from typing import Callable, Optional
+from typing import TYPE_CHECKING, Callable, Optional
 
 import typer
 
+if TYPE_CHECKING:
+    from cycode.cli.apps.ai_guardrails.scan.guardrail_config import GuardrailConfig
+
 from cycode.cli.apps.ai_guardrails.consts import GuardrailsMode, PolicyMode
 from cycode.cli.apps.ai_guardrails.ides.base import HookDecision
 from cycode.cli.apps.ai_guardrails.scan.payload import AIHookPayload
@@ -48,11 +51,7 @@ def handle_before_submit_prompt(ctx: typer.Context, payload: AIHookPayload, poli
     ai_client = ctx.obj['ai_security_client']
 
     prompt_config = get_policy_value(policy, 'prompt', default={})
-    if not get_policy_value(prompt_config, 'enabled', default=True):
-        ai_client.create_event(payload, AiHookEventType.PROMPT, AIHookOutcome.ALLOWED)
-        return HookDecision.allow(AiHookEventType.PROMPT)
-
-    effective_mode = get_effective_mode(policy, prompt_config)
+    effective_mode = get_effective_mode(prompt_config)
     prompt = payload.prompt or ''
     max_bytes = get_policy_value(policy, 'secrets', 'max_bytes', default=200000)
     timeout_ms = get_policy_value(policy, 'secrets', 'timeout_ms', default=30000)
@@ -104,12 +103,9 @@ def handle_before_read_file(ctx: typer.Context, payload: AIHookPayload, policy:
     ai_client = ctx.obj['ai_security_client']
 
     file_read_config = get_policy_value(policy, 'file_read', default={})
-    if not get_policy_value(file_read_config, 'enabled', default=True):
-        ai_client.create_event(payload, AiHookEventType.FILE_READ, AIHookOutcome.ALLOWED)
-        return HookDecision.allow(AiHookEventType.FILE_READ)
-
     file_path = payload.file_path or ''
-    effective_mode = get_effective_mode(policy, file_read_config)
+    path_mode = get_effective_mode(file_read_config, action_key='path_action')
+    content_mode = get_effective_mode(file_read_config)
 
     scan_id = None
     block_reason = None
@@ -120,7 +116,7 @@ def handle_before_read_file(ctx: typer.Context, payload: AIHookPayload, policy:
         is_sensitive_path = is_denied_path(file_path, policy)
         if is_sensitive_path:
             block_reason = BlockReason.SENSITIVE_PATH
-            if effective_mode == GuardrailsMode.BLOCK:
+            if path_mode == GuardrailsMode.BLOCK:
                 outcome = AIHookOutcome.BLOCKED
                 user_message = f'Cycode blocked sending {file_path} to the AI (sensitive path policy).'
                 return HookDecision.deny(
@@ -144,11 +140,11 @@ def handle_before_read_file(ctx: typer.Context, payload: AIHookPayload, policy:
 
         if get_policy_value(file_read_config, 'scan_content', default=True):
             violation_summary, scan_id = _scan_path_for_secrets(
-                ctx, file_path, policy, payload=payload, effective_mode=effective_mode
+                ctx, file_path, policy, payload=payload, effective_mode=content_mode
             )
             if violation_summary:
                 block_reason = SECRETS_BLOCK_REASON_BY_EVENT_TYPE[AiHookEventType.FILE_READ]
-                if effective_mode == GuardrailsMode.BLOCK:
+                if content_mode == GuardrailsMode.BLOCK:
                     outcome = AIHookOutcome.BLOCKED
                     user_message = f'Cycode blocked reading {file_path}. {violation_summary}'
                     return HookDecision.deny(
@@ -201,7 +197,6 @@ class _ArgScanFeature:
     """
 
     policy_key: str  # 'mcp' or 'command_exec'
-    scan_key: str  # 'scan_arguments' or 'scan_command'
     event_type: AiHookEventType
     deny_message: Callable[[str], str]
     deny_agent_message: str
@@ -220,14 +215,10 @@ def _handle_arg_scan(
     ai_client = ctx.obj['ai_security_client']
 
     feature_config = get_policy_value(policy, feature.policy_key, default={})
-    if not get_policy_value(feature_config, 'enabled', default=True):
-        ai_client.create_event(payload, feature.event_type, AIHookOutcome.ALLOWED)
-        return HookDecision.allow(feature.event_type)
-
     max_bytes = get_policy_value(policy, 'secrets', 'max_bytes', default=200000)
     timeout_ms = get_policy_value(policy, 'secrets', 'timeout_ms', default=30000)
     clipped = truncate_utf8(scan_text, max_bytes)
-    effective_mode = get_effective_mode(policy, feature_config)
+    effective_mode = get_effective_mode(feature_config)
 
     scan_id = None
     block_reason = None
@@ -235,30 +226,29 @@ def _handle_arg_scan(
     error_message = None
 
     try:
-        if get_policy_value(feature_config, feature.scan_key, default=True):
-            violation_summary, scan_id = _scan_text_for_secrets(
-                ctx,
-                clipped,
-                timeout_ms,
-                payload=payload,
-                event_type=feature.event_type,
-                effective_mode=effective_mode,
-            )
-            if violation_summary:
-                block_reason = SECRETS_BLOCK_REASON_BY_EVENT_TYPE[feature.event_type]
-                if effective_mode == GuardrailsMode.BLOCK:
-                    outcome = AIHookOutcome.BLOCKED
-                    return HookDecision.deny(
-                        feature.event_type,
-                        feature.deny_message(violation_summary),
-                        feature.deny_agent_message,
-                    )
-                outcome = AIHookOutcome.WARNED
-                return HookDecision.ask(
+        violation_summary, scan_id = _scan_text_for_secrets(
+            ctx,
+            clipped,
+            timeout_ms,
+            payload=payload,
+            event_type=feature.event_type,
+            effective_mode=effective_mode,
+        )
+        if violation_summary:
+            block_reason = SECRETS_BLOCK_REASON_BY_EVENT_TYPE[feature.event_type]
+            if effective_mode == GuardrailsMode.BLOCK:
+                outcome = AIHookOutcome.BLOCKED
+                return HookDecision.deny(
                     feature.event_type,
-                    feature.ask_message(violation_summary),
-                    feature.ask_agent_message,
+                    feature.deny_message(violation_summary),
+                    feature.deny_agent_message,
                 )
+            outcome = AIHookOutcome.WARNED
+            return HookDecision.ask(
+                feature.event_type,
+                feature.ask_message(violation_summary),
+                feature.ask_agent_message,
+            )
 
         return HookDecision.allow(feature.event_type)
     except Exception as e:
@@ -290,7 +280,6 @@ def handle_before_mcp_execution(ctx: typer.Context, payload: AIHookPayload, poli
         policy,
         _ArgScanFeature(
             policy_key='mcp',
-            scan_key='scan_arguments',
             event_type=AiHookEventType.MCP_EXECUTION,
             deny_message=lambda v: f'Cycode blocked MCP tool call "{tool}". {v}',
             deny_agent_message='Do not pass secrets to tools. Use secret references (name/id) instead.',
@@ -311,35 +300,29 @@ def get_handler_for_event(event_type: str) -> Optional[HandlerFn]:
     return handlers.get(event_type)
 
 
-def get_effective_mode(policy: dict, feature_config: dict) -> GuardrailsMode:
-    """The event only blocks when both the global mode and the per-guardrail action are block."""
-    mode = get_policy_value(policy, 'mode', default=PolicyMode.BLOCK)
-    action = get_policy_value(feature_config, 'action', default=PolicyMode.BLOCK)
-    return GuardrailsMode.BLOCK if (mode == PolicyMode.BLOCK and action == PolicyMode.BLOCK) else GuardrailsMode.REPORT
-
+def get_effective_mode(feature_config: dict, action_key: str = 'action') -> GuardrailsMode:
+    """A guardrail's action is its matrix cell: block, or warn (report) for everything else."""
+    action = get_policy_value(feature_config, action_key, default=PolicyMode.BLOCK)
+    return GuardrailsMode.BLOCK if action == PolicyMode.BLOCK else GuardrailsMode.REPORT
 
-# The policy section each event's handler reads its feature config from.
-_FEATURE_KEY_BY_EVENT_TYPE: dict[str, str] = {
-    AiHookEventType.PROMPT.value: 'prompt',
-    AiHookEventType.FILE_READ.value: 'file_read',
-    AiHookEventType.MCP_EXECUTION.value: 'mcp',
-}
 
-
-def should_detach_scan(policy: dict, event_name: str) -> bool:
+def should_detach_scan(
+    config: Optional['GuardrailConfig'],
+    policy: dict,
+    event_name: str,
+    ide_name: Optional[str],
+) -> bool:
     """Whether this event's scan is safe to run detached.
 
-    Report mode never blocks, so nobody consumes the verdict. Fail-closed
-    configs stay synchronous even in report mode: their deny on scan failure
-    must reach the IDE. Unknown events stay synchronous - they exit fast anyway.
+    Report mode never blocks, so nobody consumes the verdict. The platform config is the only
+    mode source: without a cache the scan stays synchronous (never detach on an assumption).
+    Fail-closed configs also stay synchronous: their deny on scan failure must reach the IDE.
     """
-    feature_key = _FEATURE_KEY_BY_EVENT_TYPE.get(event_name)
-    if feature_key is None:
+    if config is None:
         return False
     if not get_policy_value(policy, 'fail_open', default=True):
         return False
-    feature_config = get_policy_value(policy, feature_key, default={})
-    return get_effective_mode(policy, feature_config) == GuardrailsMode.REPORT
+    return not config.can_event_block(event_name, ide_name)
 
 
 def build_ai_guardrails_scan_parameters(

cycode/cli/apps/ai_guardrails/scan/policy.py

@@ -1,11 +1,14 @@
 """
 Policy loading and configuration management for AI guardrails.
 
-Policies are loaded and merged in order (later overrides earlier):
+Operational knobs are loaded and merged in order (later overrides earlier):
 1. Built-in defaults (consts.DEFAULT_POLICY)
 2. Machine-wide config (admin/MDM-provisioned; see get_machine_policy_path)
 3. User-level config (~/.cycode/ai-guardrails.yaml)
 4. Repo-level config (<workspace>/.cycode/ai-guardrails.yaml)
+
+Enforcement is not part of that merge: the platform resolves it and apply_platform_config
+overlays it on top of the result (see scan/guardrail_config.py).
 """
 
 import json
@@ -17,6 +20,34 @@ from typing import Any, Optional
 import yaml
 
 from cycode.cli.apps.ai_guardrails.scan.consts import DEFAULT_POLICY, POLICY_FILE_NAME
+from cycode.logger import get_logger
+
+logger = get_logger('AI Guardrails')
+
+# A local policy file may only contribute operational knobs; enforcement comes from the
+# platform. Read as a whitelist rather than a strip-list, so a key we forget to enumerate
+# is ignored by default instead of silently weakening enforcement.
+_LOCAL_POLICY_KEYS = ('version', 'fail_open', 'secrets')
+
+# The sections the platform resolves. Only used when rewriting a user's file: keys an older
+# CLI wrote there still read as enforcement to a human, so drop them on the way out.
+_PLATFORM_OWNED_KEYS = ('mode', 'prompt', 'file_read', 'mcp')
+
+
+def pick_local_knobs(config: dict, filename: str) -> dict:
+    """Keep only the keys a local policy file is allowed to contribute."""
+    ignored = [key for key in config if key not in _LOCAL_POLICY_KEYS]
+    if ignored:
+        logger.debug(
+            'Ignoring non-knob keys in local policy file, %s',
+            {'filename': filename, 'keys': ignored},
+        )
+    return {key: value for key, value in config.items() if key in _LOCAL_POLICY_KEYS}
+
+
+def strip_platform_managed_keys(config: dict) -> dict:
+    """Drop the enforcement sections a local file may carry (older CLIs wrote them)."""
+    return {key: value for key, value in config.items() if key not in _PLATFORM_OWNED_KEYS}
 
 
 def get_machine_policy_path() -> Path:
@@ -83,21 +114,22 @@ def load_policy(workspace_root: Optional[str] = None) -> dict:
     policy = load_defaults()
 
     # Merge machine-wide config (admin/MDM-provisioned) - overrides defaults, below user/repo.
-    machine_config = load_yaml_file(get_machine_policy_path())
+    machine_policy_path = get_machine_policy_path()
+    machine_config = load_yaml_file(machine_policy_path)
     if machine_config:
-        policy = deep_merge(policy, machine_config)
+        policy = deep_merge(policy, pick_local_knobs(machine_config, str(machine_policy_path)))
 
     # Merge user-level config (if exists)
     user_policy_path = Path.home() / '.cycode' / POLICY_FILE_NAME
     user_config = load_yaml_file(user_policy_path)
     if user_config:
-        policy = deep_merge(policy, user_config)
+        policy = deep_merge(policy, pick_local_knobs(user_config, str(user_policy_path)))
 
     # Merge repo-level config (if exists) - highest precedence
     if workspace_root:
         repo_policy_path = Path(workspace_root) / '.cycode' / POLICY_FILE_NAME
         repo_config = load_yaml_file(repo_policy_path)
         if repo_config:
-            policy = deep_merge(policy, repo_config)
+            policy = deep_merge(policy, pick_local_knobs(repo_config, str(repo_policy_path)))
 
     return policy

cycode/cli/apps/ai_guardrails/scan/scan_command.py

@@ -14,8 +14,9 @@ import click
 import typer
 
 from cycode.cli.apps.ai_guardrails.ides import DEFAULT_IDE_NAME, get_ide
-from cycode.cli.apps.ai_guardrails.ides.base import HookDecision
+from cycode.cli.apps.ai_guardrails.ides.base import IDE, HookDecision
 from cycode.cli.apps.ai_guardrails.scan.detach import is_detached_child, respawn_detached
+from cycode.cli.apps.ai_guardrails.scan.guardrail_config import apply_platform_config, load_guardrail_config
 from cycode.cli.apps.ai_guardrails.scan.handlers import get_handler_for_event, should_detach_scan
 from cycode.cli.apps.ai_guardrails.scan.policy import load_policy
 from cycode.cli.apps.ai_guardrails.scan.types import AiHookEventType
@@ -61,6 +62,31 @@ def _deny_for_event(
     return HookDecision.deny(target, user_message, agent_message)
 
 
+def _should_skip_payload(ide_integration: IDE, payload: Optional[dict]) -> bool:
+    """Fast exits that never scan: empty/foreign/synthetic payloads all answer a plain allow."""
+    if not payload:
+        logger.debug('Empty or invalid JSON payload received')
+        return True
+
+    # Prevent cross-IDE processing (e.g. Cursor reading Claude Code hooks
+    # from ~/.claude/settings.json).
+    if not ide_integration.matches_payload(payload):
+        logger.debug(
+            'Payload event does not match expected IDE, skipping',
+            extra={'hook_event_name': payload.get('hook_event_name'), 'expected_ide': ide_integration.name},
+        )
+        return True
+
+    # Fork/subagent completions arrive as synthetic user turns (e.g. Claude Code's
+    # <task-notification>); they are agent-generated, not user prompts - skip before
+    # parse_hook_payload, which reads the transcript and IDE config from disk.
+    if ide_integration.is_synthetic_prompt(payload):
+        logger.debug('Synthetic prompt detected, skipping scan')
+        return True
+
+    return False
+
+
 def _initialize_clients(ctx: typer.Context) -> None:
     """Initialize API clients.
 
@@ -95,26 +121,7 @@ def scan_command(
     stdin_data = read_stdin_text().strip()
     payload = safe_json_parse(stdin_data)
 
-    if not payload:
-        logger.debug('Empty or invalid JSON payload received')
-        output_json(ide_integration.build_hook_response(HookDecision.allow(AiHookEventType.PROMPT)))
-        return
-
-    # Prevent cross-IDE processing (e.g. Cursor reading Claude Code hooks
-    # from ~/.claude/settings.json).
-    if not ide_integration.matches_payload(payload):
-        logger.debug(
-            'Payload event does not match expected IDE, skipping',
-            extra={'hook_event_name': payload.get('hook_event_name'), 'expected_ide': ide_integration.name},
-        )
-        output_json(ide_integration.build_hook_response(HookDecision.allow(AiHookEventType.PROMPT)))
-        return
-
-    # Fork/subagent completions arrive as synthetic user turns (e.g. Claude Code's
-    # <task-notification>); they are agent-generated, not user prompts - skip before
-    # parse_hook_payload, which reads the transcript and IDE config from disk.
-    if ide_integration.is_synthetic_prompt(payload):
-        logger.debug('Synthetic prompt detected, skipping scan')
+    if _should_skip_payload(ide_integration, payload):
         output_json(ide_integration.build_hook_response(HookDecision.allow(AiHookEventType.PROMPT)))
         return
 
@@ -136,14 +143,27 @@ def scan_command(
         output_json(ide_integration.build_hook_response(HookDecision.allow(AiHookEventType.PROMPT)))
         return
 
+    # Scans only read the cache; session-start refreshes it, so the hot path never waits on the
+    # network. Every guardrail for this event Off: skip entirely - no scan, no event, no auth.
+    config = load_guardrail_config()
+    if config is not None and config.is_event_off(event_name, ide_integration.name):
+        logger.debug('Guardrails are off for this event, allowing', extra={'event_name': event_name})
+        output_json(ide_integration.build_hook_response(HookDecision.allow(AiHookEventType.PROMPT)))
+        return
+
     # `or` (not a .get default) - Cursor sends workspace_roots=[] when no folder is open.
     workspace_roots = payload.get('workspace_roots') or ['.']
     policy = load_policy(workspace_roots[0])
+    apply_platform_config(policy, config, ide_integration.name)
 
     # Report mode: nobody consumes the verdict, so hand the scan to a detached
     # child and release the IDE immediately. Runs before any client or network
     # work. A failed respawn falls through to the synchronous path.
-    if not is_detached_child() and should_detach_scan(policy, event_name) and respawn_detached(stdin_data):
+    if (
+        not is_detached_child()
+        and should_detach_scan(config, policy, event_name, ide_integration.name)
+        and respawn_detached(stdin_data)
+    ):
         return
 
     try:

cycode/cli/apps/ai_guardrails/session_start_command.py

@@ -15,6 +15,7 @@ from cycode.cli.apps.ai_guardrails.ides import (
     collect_all_skills,
     get_ide,
 )
+from cycode.cli.apps.ai_guardrails.scan.guardrail_config import load_guardrail_config, save_guardrail_config
 from cycode.cli.apps.ai_guardrails.scan.utils import read_stdin_text, safe_json_parse
 from cycode.cli.apps.auth.auth_common import get_authorization_info
 from cycode.cli.apps.auth.auth_manager import AuthManager
@@ -167,3 +168,23 @@ def session_start_command(
 
     # Report session context (device + cross-IDE MCP servers and plugins)
     _report_session_context(ai_client, session_payload.ide_user_email, auth_info.tenant_id)
+
+    # SessionStart precedes the first prompt hook in every IDE, so scans normally find a cache.
+    _sync_guardrail_config(ai_client, auth_info.tenant_id)
+
+
+def _sync_guardrail_config(ai_client: 'AISecurityManagerClient', tenant_id: Optional[str]) -> None:
+    """Refresh the guardrail config cache when it is expired or belongs to another tenant.
+
+    Every step here swallows its own failures - a broken cache or an unreachable platform
+    must never fail the session.
+    """
+    cached = load_guardrail_config()
+    if cached is not None and not cached.needs_refresh(tenant_id):
+        logger.debug('Guardrail config cache is fresh, skipping fetch')
+        return
+
+    resolved = ai_client.get_resolved_guardrails()
+    if resolved:
+        save_guardrail_config(resolved, tenant_id)
+        logger.debug('Guardrail config cache updated')

cycode/cli/utils/path_utils.py

@@ -1,5 +1,6 @@
 import json
 import os
+import tempfile
 from functools import cache
 from typing import TYPE_CHECKING, AnyStr, Optional, Union
 
@@ -86,6 +87,32 @@ def get_file_content(file_path: Union[str, 'PathLike']) -> Optional[AnyStr]:
         logger.warn('Permission denied to read the file: %s', file_path)
 
 
+def atomic_write_text(filename: str, content: str) -> None:
+    """Write via a temp file + rename so concurrent CLI processes never read a torn file."""
+    directory = os.path.dirname(filename)
+    file_descriptor, temp_filename = tempfile.mkstemp(dir=directory, prefix=f'.{os.path.basename(filename)}.')
+    try:
+        with os.fdopen(file_descriptor, 'w', encoding='UTF-8') as file:
+            file.write(content)
+            file.flush()
+            os.fsync(file.fileno())
+
+        os.replace(temp_filename, filename)
+    except Exception:
+        if os.path.exists(temp_filename):
+            os.remove(temp_filename)
+        raise
+
+
+def quarantine_corrupt_file(filename: str) -> None:
+    # Renamed rather than deleted: the file may hold the only copy of the user's credentials,
+    # and keeping it around leaves something to look at in the next bug report.
+    try:
+        os.replace(filename, f'{filename}.corrupt')
+    except OSError as e:
+        logger.warning('Failed to quarantine corrupt file, %s', {'filename': filename}, exc_info=e)
+
+
 def load_json(txt: str) -> Optional[dict]:
     try:
         return json.loads(txt)

cycode/cli/utils/yaml_utils.py

@@ -1,10 +1,10 @@
 import os
-import tempfile
 from collections.abc import Hashable
 from typing import Any, TextIO
 
 import yaml
 
+from cycode.cli.utils.path_utils import atomic_write_text, quarantine_corrupt_file
 from cycode.logger import get_logger
 
 logger = get_logger('YAML Utils')
@@ -35,15 +35,6 @@ def _yaml_object_safe_load(file: TextIO) -> dict[Hashable, Any]:
     return loaded_file
 
 
-def _quarantine_corrupt_file(filename: str) -> None:
-    # Renamed rather than deleted: the file may hold the only copy of the user's credentials,
-    # and keeping it around leaves something to look at in the next bug report.
-    try:
-        os.replace(filename, f'{filename}.corrupt')
-    except OSError as e:
-        logger.warning('Failed to quarantine corrupt file, %s', {'filename': filename}, exc_info=e)
-
-
 def read_yaml_file(filename: str) -> dict[Hashable, Any]:
     if not os.access(filename, os.R_OK) or not os.path.exists(filename):
         logger.debug('Config file is not accessible or does not exist: %s', {'filename': filename})
@@ -54,7 +45,7 @@ def read_yaml_file(filename: str) -> dict[Hashable, Any]:
             return _yaml_object_safe_load(file)
     except yaml.YAMLError as e:
         logger.warning('Config file is corrupt and will be moved aside, %s', {'filename': filename}, exc_info=e)
-        _quarantine_corrupt_file(filename)
+        quarantine_corrupt_file(filename)
         return {}
 
 
@@ -64,19 +55,7 @@ def write_yaml_file(filename: str, content: dict[Hashable, Any]) -> None:
         logger.warning('No write permission for file. Cannot save config, %s', {'filename': filename})
         return
 
-    # Atomic write to avoid race conditions between concurrent CLI processes
-    file_descriptor, temp_filename = tempfile.mkstemp(dir=directory, prefix=f'.{os.path.basename(filename)}.')
-    try:
-        with os.fdopen(file_descriptor, 'w', encoding='UTF-8') as file:
-            yaml.safe_dump(content, file)
-            file.flush()
-            os.fsync(file.fileno())
-
-        os.replace(temp_filename, filename)
-    except Exception:
-        if os.path.exists(temp_filename):
-            os.remove(temp_filename)
-        raise
+    atomic_write_text(filename, yaml.safe_dump(content))
 
 
 def update_yaml_file(filename: str, content: dict[Hashable, Any]) -> None:

cycode/cyclient/ai_security_manager_client.py

@@ -18,6 +18,7 @@ class AISecurityManagerClient:
     _CONVERSATIONS_PATH = 'v4/ai-security/interactions/conversations'
     _EVENTS_PATH = 'v4/ai-security/interactions/events'
     _SESSION_CONTEXT_PATH = 'v4/ai-security/interactions/session-context'
+    _RESOLVED_GUARDRAILS_PATH = 'v4/ai-security/guardrails/resolved'
 
     def __init__(self, client: CycodeClientBase, service_config: 'AISecurityManagerServiceConfigBase') -> None:
         self.client = client
@@ -92,6 +93,15 @@ class AISecurityManagerClient:
             logger.debug('Failed to create AI hook event', exc_info=e)
             # Don't fail the hook if tracking fails
 
+    def get_resolved_guardrails(self) -> Optional[dict]:
+        """Fetch the tenant's resolved guardrail config (per-agent modes + sensitive-path globs)."""
+        try:
+            response = self.client.get(self._build_endpoint_path(self._RESOLVED_GUARDRAILS_PATH))
+            return response.json()
+        except Exception as e:
+            logger.debug('Failed to fetch resolved guardrail config', exc_info=e)
+            return None
+
     def report_session_context(
         self,
         hostname: Optional[str] = None,

{cycode-3.22.2.dev3.dist-info → cycode-3.23.1.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cycode
-Version: 3.22.2.dev3
+Version: 3.23.1.dev1
 Summary: Boost security in your dev lifecycle via SAST, SCA, Secrets & IaC scanning.
 License-Expression: MIT
 License-File: LICENCE

{cycode-3.22.2.dev3.dist-info → cycode-3.23.1.dev1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-cycode/__init__.py,sha256=Y1jHOAiaY2fAHhU4emWEFYVky7rvEWjAbscgjIcFwmM,396
+cycode/__init__.py,sha256=9avEgdZkCaD_4Klbu5ohfcM_MidKc6b4_XrsOWD1zjU,396
 cycode/__main__.py,sha256=Z3bD5yrA7yPvAChcADQrqCaZd0ChGI1gdiwALwbWJ6U,104
 cycode/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cycode/cli/app.py,sha256=AlR2durAEbsa47PDfIj7JtMvJDWA_Dq6wPtVuMJYSCs,10250
@@ -6,8 +6,8 @@ cycode/cli/apps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cycode/cli/apps/activation_manager.py,sha256=Hz9PDJFB-ZmYi4HSG8iYC-fR8j5v25VuUU-l95Otsdk,1678
 cycode/cli/apps/ai_guardrails/__init__.py,sha256=NsqB1Ca83BIjJMcDSt6suec6Ed0iNnacC0gBqkuuTtI,1367
 cycode/cli/apps/ai_guardrails/command_utils.py,sha256=NVwd0-2RGRKIqhsQ-4LNDR1D0gVm_o7n-z5LxG2bqAo,800
-cycode/cli/apps/ai_guardrails/consts.py,sha256=U9lToL22ik3oX6bcZxT5de79Fu0eZA5D5p-q9daE5Iw,778
-cycode/cli/apps/ai_guardrails/hooks_manager.py,sha256=zLUtZJ3yFu9n0r71lhhx9gUUXclTwgCyU38ULbVB--0,9329
+cycode/cli/apps/ai_guardrails/consts.py,sha256=CO3j7CiVoc0CuWtIjYEWmGSXNAd2DfiPhffW-gZMRT4,1152
+cycode/cli/apps/ai_guardrails/hooks_manager.py,sha256=gIP4LGyOL1OFmCfxM1nrjedrBpCwLc_mcb7k40bIz_Q,9398
 cycode/cli/apps/ai_guardrails/ides/__init__.py,sha256=5odqWNfvvbFfAtR8ioEytXZ5VczWAOGyr1xuASC_OnQ,3346
 cycode/cli/apps/ai_guardrails/ides/_plugin_utils.py,sha256=XPIc9pZFEgdGVTSSAl9yqI48F88GKlFnJ5FsLUhHjCE,3981
 cycode/cli/apps/ai_guardrails/ides/_skill_utils.py,sha256=Xk8z-uquTMvg4JxNwZxnclR79ME7ZKq7rxht3aFQUeo,3972
@@ -16,17 +16,18 @@ cycode/cli/apps/ai_guardrails/ides/claude_code.py,sha256=JCSB2PRPtZETFSskxV02hUw
 cycode/cli/apps/ai_guardrails/ides/codex.py,sha256=P3dCa2bHLoeKs10TN6OmwP6BjcuJkNMkfUFa4T7n9Vo,12335
 cycode/cli/apps/ai_guardrails/ides/copilot.py,sha256=XK2CLdB3oLJrP5Z-pGNsLbnwfehv4AW4vTLdvSE3eb0,21894
 cycode/cli/apps/ai_guardrails/ides/cursor.py,sha256=cqi12ELV5ZF7ANUA9n33gc8Hj9hURqEBLJ3gzf-v68w,5850
-cycode/cli/apps/ai_guardrails/install_command.py,sha256=3IV_MHpc7R-OJ2kUTDAtemkGZUQ9YAWX3lJBgTsi0zo,4190
+cycode/cli/apps/ai_guardrails/install_command.py,sha256=3T-Wj_Fr871uhfTe77CGqrkeAwvHafK_aEv7BZ0jAJU,4069
 cycode/cli/apps/ai_guardrails/scan/__init__.py,sha256=qJc82XiQGiAuc1sYY8Ij_A-qXpxgLPuayQq8xWlouMA,48
-cycode/cli/apps/ai_guardrails/scan/consts.py,sha256=drAslw6vW3kxmbCs2qPCUbUPR7PJouT2lsXtu5sD-lQ,1094
+cycode/cli/apps/ai_guardrails/scan/consts.py,sha256=8H8JXlgm65sYkgTXqsBInHhHe80UPjqY4vumZXB4GGM,1060
 cycode/cli/apps/ai_guardrails/scan/detach.py,sha256=8BRgBq9Qi8nXEx6NKlE8scSRPkO30XCfsiI5PLvq6Gk,2700
-cycode/cli/apps/ai_guardrails/scan/handlers.py,sha256=wxDY2-bxc9MNVWWediQPpm635IiW0WSNaetrZOH39WQ,18823
+cycode/cli/apps/ai_guardrails/scan/guardrail_config.py,sha256=QSBwmkTdlC9zXIqI3gIiOlefviJWrpeJHzFu1Cs-zgE,7051
+cycode/cli/apps/ai_guardrails/scan/handlers.py,sha256=vOAvknrlCN-G_AUE7adlZAg0V7BhtGTYKB4r1yZDBu0,17695
 cycode/cli/apps/ai_guardrails/scan/payload.py,sha256=sWsWq5yXP54MVCajsb180kLuprI_M2kspMOzQGh7r_o,1534
-cycode/cli/apps/ai_guardrails/scan/policy.py,sha256=BZoNNdDQ9tqnfwhB4X1-bDtudaOQc_gXizm3IVwa28o,3351
-cycode/cli/apps/ai_guardrails/scan/scan_command.py,sha256=YpfGVmP05qjeoCr_6UVW3rO_MAJ6CJZDfrR1v2OJZ8Y,7465
+cycode/cli/apps/ai_guardrails/scan/policy.py,sha256=3HuDoL_NYE3lyHRAlIMleq6pi-stIDQwotHsKhUFhTQ,5000
+cycode/cli/apps/ai_guardrails/scan/scan_command.py,sha256=fgV32phgkBPwqSau7oFDISZ58CVpq214JlYwZQM9bnM,8318
 cycode/cli/apps/ai_guardrails/scan/types.py,sha256=ybQm242QN0l_4SSNX4xMHXxzqEK-MW-hfIOixI7zvGU,1497
 cycode/cli/apps/ai_guardrails/scan/utils.py,sha256=QzR_zmivDYwg2-F8g4bFfsycHhNo-pPuJly0P_l0gm8,2879
-cycode/cli/apps/ai_guardrails/session_start_command.py,sha256=OxpqSROhN3NTKE3TiDTsKrYu8dXRrUDdwUEUzlRxnlQ,6215
+cycode/cli/apps/ai_guardrails/session_start_command.py,sha256=oEW-OsHXkf8P7SX1vKa9Ddlv_hASRiQ42JZR3MnJfRg,7171
 cycode/cli/apps/ai_guardrails/status_command.py,sha256=Uqss68TEPCYPXpLix6Bh-4J3g-khxWsAqlIGYH5x4bQ,3203
 cycode/cli/apps/ai_guardrails/uninstall_command.py,sha256=dOmePfZmlHAPy2zEJM1yMtSuDqvzDwtqgmLKYK-T9PI,2698
 cycode/cli/apps/ai_remediation/__init__.py,sha256=8vYthY9RQeJqEni3AIF5sryz8n-XJQ6VNqG4aEFBAdY,553
@@ -182,7 +183,7 @@ cycode/cli/utils/git_proxy.py,sha256=FPHMBiyLFK9X9vKYpKySRKJH6Dc9Cb3nO241Q95dASE
 cycode/cli/utils/host_info.py,sha256=ba3scmnOJQOtNpVT-rf2-FKb0ocGzpPUONsG-uxmhro,6249
 cycode/cli/utils/ignore_utils.py,sha256=cODqhnOHA2kRo8rMY0YcmcKkmXNPOC9UTCmFu62RRqE,15567
 cycode/cli/utils/jwt_utils.py,sha256=EGI-0CKhCGY8hIcZ9b9diq9hqtOUf8Ha8ukeVJIf974,818
-cycode/cli/utils/path_utils.py,sha256=U5te1unzhs9pnU5d9BWExgFWElHQkgKvFxKiOF-lp-w,3245
+cycode/cli/utils/path_utils.py,sha256=zc48CSU7hxqjSgfH6h5M1B0kIcKW44BOJrUa_6z-mAo,4317
 cycode/cli/utils/progress_bar.py,sha256=bKBWHHdZsVkdDdWMJLfgLGR0cBYeB44P_DpRM8pvWqU,9528
 cycode/cli/utils/scan_batch.py,sha256=5xKGVDVqoRxdKhuZkK11x4QrNqKmU20Q83E_fy8Nndk,5188
 cycode/cli/utils/scan_utils.py,sha256=sTj7j9dVHcgeMqfYp8sO78ZiWX8LnhpgjCOi1N1gmAM,2248
@@ -192,10 +193,10 @@ cycode/cli/utils/task_timer.py,sha256=wxfM2TtJGjc1F17CIja_Qmt6zd4a1qdMwuz0ltgTDA
 cycode/cli/utils/trust_store.py,sha256=nEVyaDHhBu2f1Lw1CeHogaD8lQIp6u-sxaVDEKEhIW8,1992
 cycode/cli/utils/url_utils.py,sha256=2ZhRCbQsKnvAl5MBugQ5CrwuALP8uivsCI6chlqxahM,2304
 cycode/cli/utils/version_checker.py,sha256=0f5PaTk02ZkDxzBqZOeMV9mU_CWcx6HKW80jUKFOOZs,8239
-cycode/cli/utils/yaml_utils.py,sha256=ty4FlwrM49OoYSMv8U6ZGlB0JRds8nxaijHQZebBVoU,2991
+cycode/cli/utils/yaml_utils.py,sha256=eyOcfNtqvmRMKrKY5jCdwwKKOsXAFchcBAoES0F_o7c,2167
 cycode/config.py,sha256=jHORGZQcAXkAGSf2XreC-RQoc8sdNWja69QKtPWTbWo,1044
 cycode/cyclient/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cycode/cyclient/ai_security_manager_client.py,sha256=Ljv93RQvh0cy-dh84zGw7UnVdN2KPulmmSvrvFfXdNw,4939
+cycode/cyclient/ai_security_manager_client.py,sha256=LXOLtA2Moa4bb0r1W9y6gQ9MLN3VPWhaNMGs1GILx9E,5450
 cycode/cyclient/ai_security_manager_service_config.py,sha256=83pQzgOb93JW6E-dznJkI4c0NEXmQRlx9YZKMmjVwp8,808
 cycode/cyclient/auth_client.py,sha256=TwbmZ358Ancf-Q-IZolvfljZ8691_6botsqd0R0PLPk,2105
 cycode/cyclient/base_token_auth_client.py,sha256=mn5580d7A8Z2_zcdFKIJk78ADK7mViwTcV-4QCpRCGo,4369
@@ -216,8 +217,8 @@ cycode/cyclient/report_client.py,sha256=Scq30NeJPzgXv0hPLO1U05AdE9i_2iu6cIrSKpEJ
 cycode/cyclient/scan_client.py,sha256=DqAZ7u6Z_cvw9A9RlLkAQUgLRwPCCAsUq5U9umt4F7Y,16955
 cycode/cyclient/scan_config_base.py,sha256=mXsPZGYCtp85rv5GIige40yQZXuRcEKUW-VQJ0vgFzk,1201
 cycode/logger.py,sha256=EfZGRK6VC5rE_LAjIcRrHFiQCueylCDXoG6bvGkrIME,2111
-cycode-3.22.2.dev3.dist-info/METADATA,sha256=8JTX553WEOga3CDpNP6QDIVruDmUg_DphQFSQldBwaI,93687
-cycode-3.22.2.dev3.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-cycode-3.22.2.dev3.dist-info/entry_points.txt,sha256=iDcVJM8ByLElVgvBgtYxDjw1kT7O8Mo0LcWZIT5L3Ig,45
-cycode-3.22.2.dev3.dist-info/licenses/LICENCE,sha256=2Wx4N6mD_4xB7-E3hPkZ3MPhpJy__k_I8MaCSO-PDRo,1068
-cycode-3.22.2.dev3.dist-info/RECORD,,
+cycode-3.23.1.dev1.dist-info/METADATA,sha256=4vnnUjN1UZGDWdXBApe-U2DMEicw9nRjMpXBNMt-C5A,93687
+cycode-3.23.1.dev1.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+cycode-3.23.1.dev1.dist-info/entry_points.txt,sha256=iDcVJM8ByLElVgvBgtYxDjw1kT7O8Mo0LcWZIT5L3Ig,45
+cycode-3.23.1.dev1.dist-info/licenses/LICENCE,sha256=2Wx4N6mD_4xB7-E3hPkZ3MPhpJy__k_I8MaCSO-PDRo,1068
+cycode-3.23.1.dev1.dist-info/RECORD,,