yocto-security-tools 1.0.0__py3-none-any.whl

cve_agent/AGENT_INSTRUCTIONS.md

@@ -0,0 +1,161 @@
+<!-- SPDX-License-Identifier: MIT -->
+# CVE Backport Agent Instructions
+
+## Scope Rules
+
+You may ONLY modify files listed in the **Allowed Files** section of the context header.
+A git pre-commit hook enforces this — commits with unauthorized files will be rejected.
+
+**NEVER do any of these:**
+- `git add .` or `git add -A`
+- `git commit --no-verify` or `git cherry-pick --no-verify`
+- Cherry-pick additional upstream commits beyond what cve_corrector already applied
+- Create or rename files not in the Allowed Files list
+- Modify `.gitignore` or any file not in the Allowed Files list
+- Run `cve_corrector.py` (the agent handles workflow progression)
+- Read files outside the workspace directory
+- Use the `glob` tool
+
+**Prerequisite commits**: If the upstream fix depends on a prior commit, do NOT
+cherry-pick it separately. Instead, manually adapt the conflicting code to work
+without the prerequisite — inline the necessary changes into the files already
+being modified. The generated patch must only contain the upstream fix commit's
+changes, adapted for the stable branch.
+
+**Files not in the baseline**: If the upstream commit adds a NEW file that is
+in the Allowed Files list, include it — `git cherry-pick` will stage it
+automatically. If it conflicts or requires infrastructure not present in the
+stable branch, mention it in the commit message as:
+`<file>: omitted (depends on <missing infrastructure>)`
+
+Only omit a file if including it would break the build or if it depends on
+code/headers/build rules that don't exist in the stable branch.
+
+## Workflow
+
+### 1. Analyse (always)
+```bash
+git log original-version..HEAD --oneline   # what was applied
+git show HEAD                               # understand the fix
+```
+If the patch is incompatible with the stable base, adapt it.
+
+If the CVE fix is **not applicable** to this version (e.g. the vulnerable code
+path, function, struct, or feature does not exist in the stable branch), do NOT
+make any code changes. Instead, write a conclusion file:
+
+```bash
+cat > "<agent_dir>/conclusion.json" <<'EOF'
+{"not_applicable": true, "reason": "<one-line explanation of why the CVE does not apply>"}
+EOF
+```
+
+Replace `<agent_dir>` with the actual agent dir path from the context header.
+The reason should be specific — mention the missing function, struct, code path,
+or feature and the version. Example:
+`"PBMAC1 infrastructure (PBMAC1PARAM, PBMAC1_get1_pbkdf2_param) does not exist in 3.2.6; CVE-2025-11187 is not applicable to this version"`
+
+After writing the conclusion file, **stop — do not make any other changes.**
+
+### 2. Resolve Conflicts (exit code 1)
+```bash
+git status && git diff                      # examine conflicts
+git show <upstream_sha>                     # upstream fix intent
+git log --oneline -20 -- <file>             # file history for context
+```
+Resolve conflicts, then:
+```bash
+git add <resolved_files>                    # ONLY allowed files
+```
+
+If you adapted the patch (not a verbatim cherry-pick), append your backport
+notes to `.git/MERGE_MSG` — **read the file first**, keep the original content,
+and append your notes after a blank line. Then:
+```bash
+git cherry-pick --no-edit --continue
+```
+
+### 3. Fix Build Errors (exit code 4)
+Read the last 50 lines of the build log. If the failing task belongs to a
+**different recipe** than the one being patched, **abort immediately** — do not
+attempt to fix it. This indicates a pre-existing or environmental issue.
+Otherwise, fix the code and amend the commit.
+
+### 4. Fix Test Failures (exit code 3)
+Fix the **backported code in the allowed files only**.
+If the fix requires changing a file not in the allowed list, stop and
+flag for human review. Document which tests failed and what code change
+fixed them in the commit message.
+
+### 5. Build Verification (mandatory after every change)
+```bash
+BUILD_LOG="<agent_dir>/build_$$.log"
+devtool build <recipe> > "$BUILD_LOG" 2>&1
+echo "Exit code: $?"
+```
+On failure: `tail -50 "$BUILD_LOG"`, fix, `git commit --amend --no-edit`, retry.
+If `devtool build` logs are insufficient, check Yocto task logs at:
+`<yocto_tmp>/work/<arch>/<recipe>/*/temp/log.do_compile`
+(paths are in the context header).
+On success: **stop — your work is done.**
+
+For cross-compilation: use `bitbake -c devshell <recipe>`, never run
+make/cmake/gcc directly.
+
+## Resolution Principles
+
+- **Minimal changes only** — smallest adaptation to make the fix work on stable
+- **Preserve upstream intent** — adapt APIs/signatures, never change fix logic
+- **Match surrounding whitespace** — use the same indentation style (tabs vs spaces, alignment width) as the surrounding code in the stable branch, not the upstream patch
+- **Check dependencies** — look for `Link:` in commit, prerequisite patches
+- **If uncertain, stop** — flag for human review rather than guess
+
+## Common Conflict Patterns
+
+| Pattern | Resolution | Commit Note |
+|---|---|---|
+| Function signature changed | Keep fix logic, adapt to stable signature | `Adapted foo_v2() to foo_v1() API` |
+| Struct member renamed | Use stable member name with upstream logic | `Member renamed netdev→ndev in original patch` |
+| Function moved to different file | Apply fix where function lives in stable | `Function in old_file.c in original patch` |
+| Missing helper function | Inline it or use stable equivalent | `Inlined helper_foo() (not in stable)` |
+
+## Commit Message Format
+
+**IMPORTANT: Preserve the original upstream commit message.** The `.git/MERGE_MSG`
+file contains the original upstream commit subject and body. You MUST keep it
+intact and only **append** your backport notes after it. Never replace or rewrite
+the original message.
+
+Only append notes if you adapted the patch. Use EXACTLY this markdown format — no
+alternative headers like "Conflict resolution notes:" or "Backport changes:".
+
+Append the following block after the original commit message (separated by a
+blank line):
+
+```
+Backport Resolution: <One or two sentences explaining what the upstream commit does — the functional
+change, not the conflict details.>
+
+Conflicts Resolved:
+
+<file> (<N> conflict[s]):
+- <What was changed and why, referencing stable vs upstream differences.>
+
+<file> (<N> conflict[s]):
+- <What was changed and why.>
+```
+
+Rules:
+- **Never delete or rewrite the original subject line or body** from `.git/MERGE_MSG`
+- Append your notes after the existing message, separated by a blank line
+- Start with a summary of the upstream fix's purpose (what it changes, why)
+- List ONLY files that had conflicts or required adaptation — skip clean files
+- For each file, state the conflict count and describe each adaptation
+- Mention specific function names, types, APIs, and why the stable branch differs
+- Omitted files: `<file>: omitted (not in branch)`
+- Do NOT add a "Changes from upstream" section (the agent generates that)
+- If you adapted the patch (not a verbatim cherry-pick), add a trailer line
+  after a blank line at the end of the commit message:
+  `Assisted-by: <backend>:<model>` where `<backend>` and `<model>` are the
+  **Backend** and **Model** values from the context header (e.g.
+  `Assisted-by: kiro:claude-sonnet-4-20250514`)

cve_agent/__init__.py

@@ -0,0 +1,138 @@
+# Copyright (C) 2026 Ericsson AB
+# SPDX-License-Identifier: MIT
+"""CVE Agent - Orchestrates CVE backporting with AI-assisted conflict resolution.
+
+Wraps cve_corrector and spawns AI sessions to resolve conflicts, build errors,
+and test failures during CVE backporting.
+"""
+import sys
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+from typing import Optional
+
+# Exit codes (single source of truth: shared/exit_codes.py)
+from shared.exit_codes import (
+    EXIT_AGENT_ERROR,
+    EXIT_AI_TIMEOUT,
+    EXIT_ALREADY_APPLIED,
+    EXIT_BUILD_ERROR,
+    EXIT_BUILD_PREEXISTING,
+    EXIT_CHECKOUT_ERROR,
+    EXIT_CONFLICT,
+    EXIT_DEVTOOL_ERROR,
+    EXIT_GIT_ERROR,
+    EXIT_METADATA_ERROR,
+    EXIT_NOT_APPLICABLE,
+    EXIT_PATCH_ERROR,
+    EXIT_PTEST_ERROR,
+    EXIT_PTEST_PREEXISTING,
+    EXIT_SUCCESS,
+    EXIT_TRUST_DECLINED,
+)
+from shared.paths import data_dir
+
+# Exit codes that trigger the resolution loop (agent can attempt to fix)
+RECOVERABLE_EXITS = {EXIT_CONFLICT, EXIT_PTEST_ERROR, EXIT_BUILD_ERROR}
+
+# Exit codes that require immediate escalation (no point retrying)
+UNRECOVERABLE_EXITS = {EXIT_CHECKOUT_ERROR, EXIT_PATCH_ERROR,
+                       EXIT_METADATA_ERROR, EXIT_GIT_ERROR,
+                       EXIT_PTEST_PREEXISTING, EXIT_DEVTOOL_ERROR,
+                       EXIT_BUILD_PREEXISTING, EXIT_NOT_APPLICABLE}
+
+# Default paths
+DEFAULT_KNOWLEDGE_PATH = data_dir() / 'knowledge.json'
+DEFAULT_MAX_RETRIES = 3
+DEFAULT_SESSION_TIMEOUT = 600
+CORRECTOR_CMD = [sys.executable, '-m', 'cve_corrector']
+AGENT_INSTRUCTIONS = Path(__file__).resolve().parent / 'AGENT_INSTRUCTIONS.md'
+
+
+class ResultStatus(Enum):
+    """Outcome status for a CVE processing attempt."""
+    SUCCESS = "success"
+    CONFLICT_RESOLVED = "conflict_resolved"
+    FAILED = "failed"
+    ESCALATED = "escalated"
+    SKIPPED = "skipped"
+
+
+@dataclass
+class AgentConfig:
+    """Configuration for a single CVE agent run."""
+    cve_id: str
+    cve_info_path: Optional[Path] = None
+    trust_mode: bool = False
+    max_retries: int = DEFAULT_MAX_RETRIES
+    max_total_attempts: int = 0  # 0 = no cap beyond per-step max_retries
+    mirror_dir: Optional[Path] = None
+    meta_layer: Optional[Path] = None
+    skip_ptest: bool = False
+    clean: bool = False
+    model: str = "claude-sonnet-4.6"
+    session_timeout: int = DEFAULT_SESSION_TIMEOUT
+    interactive: bool = False
+    bbappend: bool = False
+    skip_cve_applicability: bool = False
+    fix_url: Optional[str] = None
+    recipe: Optional[str] = None
+    backend: str = "kiro"
+
+
+@dataclass
+class CveResult:
+    """Outcome of processing a single CVE."""
+    cve_id: str
+    status: ResultStatus
+    retries: int = 0
+    duration: float = 0.0
+    resolution_summary: str = ""
+
+
+def get_build_dir(workspace_path: Path) -> Path:
+    """Derive the Yocto build directory from a devtool workspace path.
+
+    The devtool workspace structure is: <build>/workspace/sources/<recipe>,
+    so the build directory is three levels up from the workspace path.
+
+    Args:
+        workspace_path: Path to the devtool workspace source directory.
+
+    Returns:
+        Path to the Yocto build directory.
+    """
+    return workspace_path.parent.parent.parent
+
+
+def get_agent_dir(workspace_path: Path) -> Path:
+    """Get or create the agent working directory outside the git workspace.
+
+    Uses the build workspace's cve_agent/ directory to avoid polluting
+    the source git repo with agent artifacts.
+
+    Args:
+        workspace_path: Path to the devtool workspace source directory.
+
+    Returns:
+        Path to the cve_agent/<recipe> directory, created if needed.
+    """
+    recipe = workspace_path.name
+    build_workspace = workspace_path.parent.parent
+    agent_dir = build_workspace / 'cve_agent' / recipe
+    agent_dir.mkdir(parents=True, exist_ok=True)
+    return agent_dir
+
+
+__all__ = [
+    'AgentConfig', 'CveResult', 'ResultStatus',
+    'RECOVERABLE_EXITS', 'UNRECOVERABLE_EXITS',
+    'DEFAULT_KNOWLEDGE_PATH', 'DEFAULT_MAX_RETRIES', 'DEFAULT_SESSION_TIMEOUT',
+    'CORRECTOR_CMD', 'AGENT_INSTRUCTIONS',
+    'get_build_dir', 'get_agent_dir',
+    'EXIT_SUCCESS', 'EXIT_CONFLICT', 'EXIT_CHECKOUT_ERROR', 'EXIT_PTEST_ERROR',
+    'EXIT_BUILD_ERROR', 'EXIT_PATCH_ERROR', 'EXIT_METADATA_ERROR', 'EXIT_GIT_ERROR',
+    'EXIT_PTEST_PREEXISTING', 'EXIT_DEVTOOL_ERROR', 'EXIT_BUILD_PREEXISTING',
+    'EXIT_ALREADY_APPLIED', 'EXIT_NOT_APPLICABLE',
+    'EXIT_TRUST_DECLINED', 'EXIT_AGENT_ERROR', 'EXIT_AI_TIMEOUT',
+]

cve_agent/__main__.py

@@ -0,0 +1,341 @@
+#!/usr/bin/env python3
+# Copyright (C) 2026 Ericsson AB
+# SPDX-License-Identifier: MIT
+"""CVE Backporting Agent — CLI entry point and batch processing.
+
+Run with: python3 -m cve_agent [options]
+"""
+import argparse
+import dataclasses
+import os
+import signal
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+from shared.paths import data_dir
+
+from . import (
+    DEFAULT_MAX_RETRIES,
+    DEFAULT_SESSION_TIMEOUT,
+    EXIT_AGENT_ERROR,
+    EXIT_TRUST_DECLINED,
+    AgentConfig,
+    CveResult,
+    ResultStatus,
+)
+from .corrector import get_workspace_path, load_cve_metadata
+from .git import run_git_stdout
+from .knowledge import KnowledgeBase
+from .orchestrator import process_single_cve
+from .setup import ensure_agents
+
+logger = __import__('logging').getLogger(__name__)
+
+
+def _get_version() -> str:
+    from importlib.metadata import PackageNotFoundError, version
+    try:
+        return version('yocto-security-tools')
+    except PackageNotFoundError:
+        return 'dev'
+
+
+# --- Trust Mode Warning ---
+
+def _show_trust_warning() -> bool:
+    """Display trust mode warning and require explicit confirmation."""
+    print(
+        "\n\u26a0\ufe0f  WARNING: --trust mode enabled. The agent will operate "
+        "without human review.\n\n"
+        "This is NOT recommended. Automated conflict resolution may:\n"
+        "  - Introduce subtle bugs that change fix semantics\n"
+        "  - Miss context that requires human judgment\n"
+        "  - Produce patches that pass build/ptest but are logically "
+        "incorrect\n\n"
+        "Human review of conflict resolutions is strongly recommended.\n"
+    )
+    response = input("Continue in trust mode? [y/N]: ").strip().lower()
+    return response == 'y'
+
+
+# --- Logging ---
+
+def _log_result(config: AgentConfig, result: CveResult,
+                workspace_path: Optional[Path] = None) -> None:
+    """Append result entry to the CVE agent log file."""
+    bbpath = os.environ.get('BBPATH', '')
+    if not bbpath:
+        return
+    build_ws = Path(bbpath.split(':')[0]) / 'workspace' / 'cve_agent'
+    build_ws.mkdir(parents=True, exist_ok=True)
+    log_file = build_ws / 'cve_agent.log'
+
+    lines = [
+        f"[{datetime.now(timezone.utc).isoformat()}] "
+        f"{result.cve_id} | {result.status.value} | "
+        f"{result.duration:.1f}s | retries={result.retries} | "
+        f"{result.resolution_summary}"
+    ]
+
+    ws_path = workspace_path
+    if ws_path is None:
+        try:
+            cve_data = load_cve_metadata(config.cve_info_path)
+            ws_path = get_workspace_path(config, cve_data)
+        except Exception:
+            logger.debug("Could not resolve workspace for %s", result.cve_id, exc_info=True)
+
+    try:
+        if ws_path:
+            diff_stat = run_git_stdout(['diff', '--stat', 'original-version..HEAD'], ws_path)
+            if diff_stat:
+                lines.append(f"  diff-stat: {diff_stat}")
+            diff = run_git_stdout(['diff', 'original-version..HEAD'], ws_path)
+            if diff:
+                if len(diff) > 50_000:
+                    diff = diff[:50_000] + "\n... (truncated, >50KB)"
+                lines.append(f"  diff:\n{diff}")
+    except Exception:
+        logger.debug("Failed to capture diff for %s", result.cve_id, exc_info=True)
+
+    with open(log_file, 'a', encoding='utf-8') as log_fh:
+        log_fh.write('\n'.join(lines) + '\n\n')
+
+
+# --- Batch Processing ---
+
+def _process_batch(cve_list: list[str], config_template: AgentConfig,
+                   knowledge_base: KnowledgeBase) -> list[CveResult]:
+    """Process a list of CVEs sequentially."""
+    results: list[CveResult] = []
+    total = len(cve_list)
+
+    for idx, cve_id in enumerate(cve_list, 1):
+        print(f"\n[{idx}/{total}] {cve_id}")
+        config = dataclasses.replace(config_template, cve_id=cve_id)
+
+        result = process_single_cve(config, knowledge_base)
+        _log_result(config, result)
+        results.append(result)
+        print(f"  Result: {result.status.value} — {result.resolution_summary}")
+
+        if result.status in (ResultStatus.FAILED, ResultStatus.ESCALATED) and not config_template.trust_mode:
+            response = input(
+                "Skip and continue to next CVE? [Y/n]: "
+            ).strip().lower()
+            if response in ('n', 'no'):
+                break
+
+    return results
+
+
+def _print_batch_summary(results: list[CveResult]) -> None:
+    """Print a summary of batch processing results."""
+    print(f"\n{'=' * 60}")
+    print("BATCH SUMMARY")
+    print(f"{'=' * 60}")
+    print(f"Total CVEs processed: {len(results)}")
+
+    counts: dict[str, int] = {}
+    for result in results:
+        counts[result.status.value] = counts.get(result.status.value, 0) + 1
+
+    for status, count in sorted(counts.items()):
+        print(f"  {status}: {count}")
+
+    print("\nPer-CVE results:")
+    for result in results:
+        retries_info = f" ({result.retries} retries)" if result.retries else ""
+        print(f"  {result.cve_id}: {result.status.value}{retries_info}")
+
+    print(f"{'=' * 60}")
+
+
+def _save_results(results: list[CveResult]) -> None:
+    """Save detailed results to a timestamped file."""
+    results_dir = data_dir() / 'results'
+    results_dir.mkdir(parents=True, exist_ok=True)
+    timestamp = datetime.now(timezone.utc).strftime('%Y%m%d_%H%M%S')
+    filepath = results_dir / f"backport_agent_results_{timestamp}.txt"
+    with open(filepath, 'w', encoding='utf-8') as file:
+        file.write(f"CVE Agent Results - {timestamp}\n")
+        file.write("=" * 60 + "\n\n")
+        for result in results:
+            file.write(
+                f"{result.cve_id}: {result.status.value} "
+                f"(retries={result.retries}, "
+                f"duration={result.duration:.1f}s)\n"
+                f"  {result.resolution_summary}\n\n"
+            )
+    print(f"Results saved to: {filepath}")
+
+
+# --- Signal Handling ---
+
+def _sigint_handler(results: list[CveResult]):
+    """Return a SIGINT handler that saves partial results on interrupt."""
+    def handler(signum, frame) -> None:
+        print("\n\nInterrupted by user (Ctrl+C).")
+        if results:
+            _print_batch_summary(results)
+            _save_results(results)
+            print(f"\nPartial progress saved ({len(results)} CVEs completed).")
+        else:
+            print("No results to save.")
+        sys.exit(EXIT_AGENT_ERROR)
+    return handler
+
+
+# --- CLI Entry Point ---
+
+def _parse_args() -> argparse.Namespace:
+    """Parse command-line arguments."""
+    parser = argparse.ArgumentParser(
+        description="CVE Backporting Agent - AI-assisted CVE fix orchestration"
+    )
+    parser.add_argument('--version', action='version',
+                        version=f'%(prog)s {_get_version()}')
+
+    # --- Input ---
+    input_group = parser.add_argument_group('input')
+    cve_group = input_group.add_mutually_exclusive_group(required=True)
+    cve_group.add_argument('--cve-id', help='Single CVE identifier')
+    cve_group.add_argument('--cve-list', type=Path,
+                           help='File with CVE IDs, one per line')
+    input_group.add_argument('--cve-info', type=Path,
+                        help='JSON file with CVE metadata')
+    input_group.add_argument('--fix-url',
+                        help='URL of fix commit or pull request')
+    input_group.add_argument('--recipe',
+                        help='Recipe name (required with --fix-url without --cve-info)')
+
+    # --- AI session ---
+    ai_group = parser.add_argument_group('AI session')
+    ai_group.add_argument('--backend', default='kiro',
+                        help='AI backend to use (default: %(default)s)')
+    ai_group.add_argument('--model', default='claude-sonnet-4.6',
+                        help='Model for AI sessions (default: %(default)s)')
+    ai_group.add_argument('--max-retries', type=int, default=DEFAULT_MAX_RETRIES,
+                        help='Max resolution attempts (default: %(default)s)')
+    ai_group.add_argument('--session-timeout', type=int,
+                        default=DEFAULT_SESSION_TIMEOUT,
+                        help='Timeout per session in seconds (default: %(default)s)')
+    ai_group.add_argument('--trust', action='store_true',
+                        help='Skip human review (NOT recommended)')
+    ai_group.add_argument('--interactive', action='store_true',
+                        help='Enable interactive mode')
+
+    # --- Build control ---
+    build_group = parser.add_argument_group('build control')
+    build_group.add_argument('--skip-ptest', action='store_true',
+                        help='Skip ptest execution')
+    build_group.add_argument('--skip-cve-applicability', action='store_true',
+                        help='Skip git-blame based CVE applicability check')
+    build_group.add_argument('--clean', action='store_true',
+                        help='Clean workspace before starting')
+
+    # --- Output ---
+    output_group = parser.add_argument_group('output')
+    output_group.add_argument('--meta-layer', type=Path,
+                        help='Destination meta-layer for devtool finish')
+    output_group.add_argument('--bbappend', action='store_true',
+                        help='Create a bbappend instead of modifying the original recipe')
+
+    # --- Environment ---
+    env_group = parser.add_argument_group('environment')
+    env_group.add_argument('--mirror-dir', type=Path,
+                        help='Directory with bare repository mirrors')
+
+    return parser.parse_args()
+
+
+def _read_cve_list(cve_list_path: Path) -> list[str]:
+    """Read CVE IDs from a file, one per line."""
+    if not cve_list_path.exists():
+        print(f"Error: CVE list file not found: {cve_list_path}",
+              file=sys.stderr)
+        sys.exit(EXIT_AGENT_ERROR)
+
+    lines = cve_list_path.read_text(encoding='utf-8').splitlines()
+    return [line.strip() for line in lines if line.strip()]
+
+
+def _config_from_args(args: argparse.Namespace,
+                      cve_id: Optional[str] = None) -> AgentConfig:
+    """Create an AgentConfig from parsed CLI arguments."""
+    return AgentConfig(
+        cve_id=cve_id if cve_id is not None else (args.cve_id or ""),
+        cve_info_path=args.cve_info,
+        trust_mode=args.trust,
+        max_retries=args.max_retries,
+        mirror_dir=args.mirror_dir,
+        meta_layer=args.meta_layer,
+        skip_ptest=args.skip_ptest,
+        clean=args.clean,
+        model=args.model,
+        session_timeout=args.session_timeout,
+        bbappend=args.bbappend,
+        skip_cve_applicability=args.skip_cve_applicability,
+        interactive=args.interactive,
+        fix_url=args.fix_url,
+        recipe=args.recipe,
+        backend=args.backend,
+    )
+
+
+def main() -> None:
+    """Main entry point for the CVE agent."""
+    results: list[CveResult] = []
+    signal.signal(signal.SIGINT, _sigint_handler(results))
+    args = _parse_args()
+
+    if not args.cve_info and not args.fix_url:
+        print("Error: --cve-info or --fix-url is required", file=sys.stderr)
+        sys.exit(EXIT_AGENT_ERROR)
+    if args.fix_url and not args.cve_info and not args.recipe:
+        print("Error: --recipe is required when using --fix-url without "
+              "--cve-info", file=sys.stderr)
+        sys.exit(EXIT_AGENT_ERROR)
+
+    if args.backend == 'kiro':
+        ensure_agents(interactive=not args.trust)
+
+    if args.trust and not _show_trust_warning():
+        print("Trust mode declined. Exiting.")
+        sys.exit(EXIT_TRUST_DECLINED)
+
+    knowledge_base = KnowledgeBase()
+
+    if args.cve_id:
+        from .corrector import validate_cve_id
+        if not validate_cve_id(args.cve_id):
+            print(f"Invalid CVE ID format: {args.cve_id}", file=sys.stderr)
+            sys.exit(EXIT_AGENT_ERROR)
+        config = _config_from_args(args, args.cve_id)
+        result = process_single_cve(config, knowledge_base)
+        print(f"\n\u2713 {result.cve_id}: {result.status.value}")
+        _log_result(config, result)
+        if result.resolution_summary:
+            print(f"  {result.resolution_summary}")
+        if result.status not in (ResultStatus.SUCCESS,
+                                 ResultStatus.CONFLICT_RESOLVED,
+                                 ResultStatus.SKIPPED):
+            sys.exit(EXIT_AGENT_ERROR)
+    else:
+        cve_list = _read_cve_list(args.cve_list)
+        config_template = _config_from_args(args)
+        results = _process_batch(cve_list, config_template, knowledge_base)
+        _print_batch_summary(results)
+        _save_results(results)
+        failed = sum(
+            1 for r in results
+            if r.status in (ResultStatus.FAILED, ResultStatus.ESCALATED)
+        )
+        if failed:
+            sys.exit(EXIT_AGENT_ERROR)
+
+
+if __name__ == '__main__':
+    main()

cve_agent/agents/yocto-cve-backport-interactive.json

@@ -0,0 +1,52 @@
+{
+  "name": "yocto-cve-backport-interactive",
+  "description": "Interactive CVE backport agent — same capabilities but requires human approval for writes and commands",
+  "prompt": "file://cve_agent/AGENT_INSTRUCTIONS.md",
+  "tools": ["fs_read", "fs_write", "execute_bash"],
+  "allowedTools": ["fs_read"],
+  "toolsSettings": {
+    "execute_bash": {
+      "allowedCommands": [
+        "git status",
+        "git status --porcelain",
+        "git diff",
+        "git diff *",
+        "git log *",
+        "git show *",
+        "git add *",
+        "git cherry-pick --continue",
+        "git cherry-pick --abort",
+        "git am --continue",
+        "git am --abort",
+        "git checkout -- *",
+        "git rev-parse *",
+        "git merge-base *",
+        "git format-patch *",
+        "devtool build *",
+        "cat *",
+        "head *",
+        "tail *",
+        "find . *",
+        "grep *"
+      ]
+    },
+    "fs_write": {
+      "deniedPaths": [
+        "/etc/**",
+        "/proc/**",
+        "/sys/**",
+        "~/.ssh/**",
+        "~/.aws/**",
+        "~/.kiro/**",
+        "~/.gitconfig",
+        "~/.netrc",
+        "**/cve_agent/**/*.py",
+        "**/cve_corrector/**/*.py",
+        "**/cve_metadata_extractor/**/*.py",
+        "**/shared/**/*.py",
+        "**/tests/**"
+      ]
+    }
+  },
+  "welcomeMessage": "CVE backport session ready. I'll resolve conflicts and verify builds — you approve each tool action."
+}