alysis-code 0.14.3__tar.gz → 0.14.7__tar.gz

{alysis_code-0.14.3 → alysis_code-0.14.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alysis-code
-Version: 0.14.3
+Version: 0.14.7
 Summary: Local CLI coding agent powered by any API.
 Project-URL: Changelog, https://github.com/AlysisAi/alysis-code/blob/main/docs/CHANGELOG.md
 Project-URL: Documentation, https://github.com/AlysisAi/alysis-code/tree/main/docs
@@ -196,6 +196,8 @@ Persona changes made during a running turn apply after that turn finishes.
 
 Apache-2.0. You're free to use, modify, and distribute this code, including commercially, as long as
 you keep the attribution and license notices. See [LICENSE](LICENSE) and [NOTICE](NOTICE).
+The shared editor sidebar includes MIT-licensed adaptations from Kilo Code/OpenCode; retain its
+[third-party notices](extensions/shared-ui/THIRD_PARTY_NOTICES.txt).
 
 ## FAQ
 
@@ -218,3 +220,11 @@ More questions? See the [full FAQ](https://alysiscode.com/docs/faq).
 ---
 
 **Join the community** — [X](https://x.com/alysiscode) | [GitHub Issues](https://github.com/AlysisAi/alysis-code/issues)
+
+
+## Editor integrations
+
+[VS Code](extensions/vscode-alysis/README.md) uses the shared Alysis sidebar and Python IDE bridge.
+[JetBrains](extensions/jetbrains-alysis/README.md) is a development preview with a smaller feature set.
+The VS Code Marketplace pre-release is pending production signing and acceptance; see the
+[IDE release status](docs/vscode-marketplace-launch.md) before installing component packages.

{alysis_code-0.14.3 → alysis_code-0.14.7}/README.md

@@ -135,6 +135,8 @@ Persona changes made during a running turn apply after that turn finishes.
 
 Apache-2.0. You're free to use, modify, and distribute this code, including commercially, as long as
 you keep the attribution and license notices. See [LICENSE](LICENSE) and [NOTICE](NOTICE).
+The shared editor sidebar includes MIT-licensed adaptations from Kilo Code/OpenCode; retain its
+[third-party notices](extensions/shared-ui/THIRD_PARTY_NOTICES.txt).
 
 ## FAQ
 
@@ -157,3 +159,11 @@ More questions? See the [full FAQ](https://alysiscode.com/docs/faq).
 ---
 
 **Join the community** — [X](https://x.com/alysiscode) | [GitHub Issues](https://github.com/AlysisAi/alysis-code/issues)
+
+
+## Editor integrations
+
+[VS Code](extensions/vscode-alysis/README.md) uses the shared Alysis sidebar and Python IDE bridge.
+[JetBrains](extensions/jetbrains-alysis/README.md) is a development preview with a smaller feature set.
+The VS Code Marketplace pre-release is pending production signing and acceptance; see the
+[IDE release status](docs/vscode-marketplace-launch.md) before installing component packages.

{alysis_code-0.14.3 → alysis_code-0.14.7}/docs/CHANGELOG.md

@@ -1,5 +1,60 @@
 # Changelog
 
+## 0.14.7 — VSIX dependency audit and sidebar rendering
+
+- Update the VS Code extension's locked source-map-js dependency to 1.2.2,
+  resolving GHSA-68fv-2mgg-jv7q and restoring the release audit gate.
+- Avoid repainting unchanged permission controls and settings filters during
+  conversation updates, reducing sidebar render cost on Intel macOS.
+- Run extension CI on Intel macOS as well as Apple Silicon before tagging releases.
+- Synchronize the queued-command overflow test with actual input receipt so
+  loaded CI runners exercise the intended full-inbox behavior reliably.
+
+This replacement preserves the published 0.14.6 source tag and distributions.
+The VS Code 0.3.0 beta still requires candidate installation, acceptance, and
+promotion gates before Marketplace publication.
+
+## 0.14.6 — final VSIX attestation and startup validation
+
+- Give each final VSIX dependency report an RFC 4122 document ID accepted by
+  GitHub's attestation parser. Derive it from the exact package bytes so promotion
+  can reproduce the signed report without changing its identity.
+- Wait for startup runtime validation before reporting installed runtime evidence,
+  so a fresh installation does not report the bundled CLI as temporarily unavailable.
+
+All six 0.14.5 native runtimes and their assembled manifest passed signing, but
+final VSIX attestation failed before installation testing. This replacement
+preserves the existing tags; Marketplace pre-release 0.3.0 still requires the
+documented installation, acceptance, and promotion gates.
+
+## 0.14.5 — native managed-runtime packaging
+
+- Pin the six bundled runtimes to checksum-verified CPython 3.12.15 distributions,
+  including their observed OpenSSL and Expat versions in each dependency SBOM.
+- Build Linux executables with shared-library-capable Python on the existing
+  glibc 2.28 baseline, and build tested, static OpenSSL 3.5.9 for Windows ARM64
+  and Intel macOS cryptography.
+- Sign embedded macOS libraries during packaging and verify notarization using
+  Apple's documented check for standalone code. Preserve Windows API paths in Git Bash.
+- Add an unsigned native build and executable smoke check for all six targets.
+
+This source version prepares a replacement candidate after the protected `v0.14.4`
+native build failed. Marketplace pre-release 0.3.0 remains subject to the documented
+signing, installation, acceptance, and promotion gates.
+
+## 0.14.4 — IDE integrations and release tooling
+
+- Add the VS Code 0.3.0 integration with a shared sidebar, provider management, bounded editor
+  context, reviewed changes, recovery checkpoints, and native host actions.
+- Add shared UI transport and a JetBrains development preview using the same Python IDE bridge.
+- Isolate provider credentials, handle physical workspace paths, and keep unit tests portable.
+- Add six-target managed-runtime packaging, Azure OIDC Windows signing verification, Apple
+  notarization/provenance contracts, and protected evidence and Marketplace promotion workflows.
+- Update pinned sandbox build inputs; fresh image scans remain required.
+
+This is a CLI/source release. Production signed VSIX packages and Marketplace publication remain
+pending the [documented signing and acceptance gates](vscode-marketplace-launch.md).
+
 Notable user-facing changes to Alysis Code are recorded here. This project follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and uses
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html) while the public API remains pre-1.0.

{alysis_code-0.14.3 → alysis_code-0.14.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "alysis-code"
-version = "0.14.3"
+version = "0.14.7"
 description = "Local CLI coding agent powered by any API."
 readme = "README.md"
 requires-python = ">=3.11"

{alysis_code-0.14.3 → alysis_code-0.14.7}/src/alysis_code/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.14.3"
+__version__ = "0.14.7"

{alysis_code-0.14.3 → alysis_code-0.14.7}/src/alysis_code/config.py

@@ -1511,6 +1511,9 @@ def resolve_profile_api_key(
     profile = get_profile(cfg, profile_name)
     if profile is None:
         return ApiKeyResolution(key=None, source="missing")
+    ide_key = _resolve_ide_profile_api_key(cfg, profile_name)
+    if ide_key.key:
+        return ide_key
     stored_profile_key = _resolve_stored_profile_api_key(cfg, profile_name)
     if stored_profile_key.key:
         return stored_profile_key
@@ -1531,6 +1534,21 @@ def resolve_profile_api_key(
     return ApiKeyResolution(key=None, source="missing")
 
 
+def _resolve_ide_profile_api_key(cfg: AppConfig, profile_name: str) -> ApiKeyResolution:
+    """Honor an IDE's explicitly supplied profile key without overwriting CLI credentials."""
+    from .profiles import get_profile
+
+    profile = get_profile(cfg, profile_name)
+    if profile is not None:
+        # Match the extension's encoding; plain env-var names can collide between two profiles.
+        encoded = profile.name.encode("utf-8").hex().upper()
+        env_name = f"ALYSIS_IDE_PROFILE_{encoded}_API_KEY"
+        key = str(os.environ.get(env_name) or "").strip()
+        if key:
+            return ApiKeyResolution(key=key, source=f"env:{env_name}")
+    return ApiKeyResolution(key=None, source="missing")
+
+
 def _resolve_stored_profile_api_key(cfg: AppConfig, profile_name: str) -> ApiKeyResolution:
     from .profiles import get_profile
 
@@ -1552,6 +1570,9 @@ def resolve_api_key(
     if profile_name is None:
         profile_name = str((effective_cfg.extra_fields or {}).get("active_profile") or "").strip()
     if profile_name:
+        ide_key = _resolve_ide_profile_api_key(effective_cfg, profile_name)
+        if ide_key.key:
+            return ide_key
         stored_profile_key = _resolve_stored_profile_api_key(effective_cfg, profile_name)
         if stored_profile_key.key:
             return stored_profile_key

{alysis_code-0.14.3 → alysis_code-0.14.7}/src/alysis_code/git_evidence.py

@@ -11,7 +11,7 @@ from typing import Any, Literal
 
 from .file_classification import classify_path, is_generated_or_vendor_path
 from .git_ops import GitOpsError
-from .git_safe import build_git_cmd, build_git_process_env
+from .git_safe import build_git_cmd, build_git_process_env, configured_git_filter_drivers
 from .runtime_artifacts import is_runtime_artifact_path
 
 PatchCaptureStatus = Literal["complete", "partial", "failed"]
@@ -445,11 +445,13 @@ def _snapshot_git(
     args: list[str],
     *,
     env: dict[str, str] | None = None,
+    input_text: str | None = None,
 ) -> str:
     try:
         result = subprocess.run(
             build_git_cmd(root, args, env=env, disable_filters=True),
             env=build_git_process_env(env),
+            input=input_text.encode("utf-8") if input_text is not None else None,
             capture_output=True,
             check=False,
         )
@@ -504,17 +506,63 @@ def _check_snapshot_files(root: Path, *, excluded_paths: tuple[str, ...]) -> Non
         raise WorkspaceSnapshotError("unsupported_workspace_file", paths=tuple(sorted(unsupported)))
 
 
+def _check_snapshot_filters(root: Path, *, pathspecs: list[str]) -> None:
+    # Git status may recognize a size change without converting file content.
+    # Resolve attributes against the actual index before a HEAD-based temporary
+    # index can lose an index-only .gitattributes fallback.
+    try:
+        drivers = configured_git_filter_drivers(root)
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        raise WorkspaceSnapshotError("workspace_snapshot_unreadable") from exc
+    if not drivers:
+        return
+    paths = _snapshot_git(
+        root,
+        [
+            "--no-optional-locks",
+            "ls-files",
+            "--cached",
+            "--others",
+            "--exclude-standard",
+            "-z",
+            "--",
+            *pathspecs,
+        ],
+    )
+    attributes = _snapshot_git(
+        root, ["check-attr", "-z", "--stdin", "filter"], input_text=paths
+    ).split("\0")
+    if attributes[-1] != "" or (len(attributes) - 1) % 3:
+        raise WorkspaceSnapshotError("workspace_snapshot_unreadable")
+    affected = tuple(
+        sorted(
+            {
+                attributes[index]
+                for index in range(0, len(attributes) - 1, 3)
+                if attributes[index + 2] in drivers
+            }
+        )
+    )
+    if affected:
+        raise WorkspaceSnapshotError(
+            "workspace_snapshot_git_failed",
+            paths=affected,
+            detail="Git snapshot refused: external Git filters are disabled for isolated workspaces",
+        )
+
+
 def _working_tree_snapshot(
     root: Path, *, base_ref: str, excluded_paths: tuple[str, ...] = ()
 ) -> str:
     _check_snapshot_files(root, excluded_paths=excluded_paths)
+    pathspecs = [".", *(f":(top,exclude,literal){path}" for path in excluded_paths)]
+    _check_snapshot_filters(root, pathspecs=pathspecs)
     # A separate index preserves both staged and unstaged parent work. Git handles
     # binary data, modes, names and ignored paths; no filename classifier is used.
     with tempfile.TemporaryDirectory(prefix="alysis-git-snapshot-") as scratch:
         env = build_git_process_env()
         env["GIT_INDEX_FILE"] = os.fspath(Path(scratch) / "index")
         _snapshot_git(root, ["read-tree", base_ref], env=env)
-        pathspecs = [".", *(f":(top,exclude,literal){path}" for path in excluded_paths)]
         _snapshot_git(root, ["add", "--all", "--", *pathspecs], env=env)
         tree = _snapshot_git(root, ["write-tree"], env=env).strip()
         gitlinks = tuple(

{alysis_code-0.14.3 → alysis_code-0.14.7}/src/alysis_code/git_safe.py

@@ -77,11 +77,29 @@ def _disabled_filter_config(
     returned command, so unused drivers do not prevent ordinary repositories from
     working. Re-read for every command: a child can introduce filter configuration.
     """
+    drivers = configured_git_filter_drivers(root, extra_config=config, env=env)
+    overrides: dict[str, str] = {}
+    for driver in drivers:
+        # Empty all three commands, including the long-running process protocol.
+        # required=true makes an attempted conversion fail instead of passing
+        # through bytes that might differ from the real filter's representation.
+        overrides.update({f"filter.{driver}.{kind}": "" for kind in ("clean", "smudge", "process")})
+        overrides[f"filter.{driver}.required"] = "true"
+    return overrides
+
+
+def configured_git_filter_drivers(
+    root: Path,
+    *,
+    extra_config: dict[str, str] | None = None,
+    env: Mapping[str, str] | None = None,
+) -> tuple[str, ...]:
+    """Read effective nonempty filter commands without invoking any driver."""
     result = subprocess.run(
         build_git_cmd(
             root,
             ["config", "--null", "--get-regexp", r"^filter\..*\.(clean|smudge|process)$"],
-            extra_config=config,
+            extra_config=extra_config,
             env=env,
         ),
         env=build_git_process_env(env),
@@ -90,7 +108,7 @@ def _disabled_filter_config(
         timeout=5,
     )
     if result.returncode == 1:  # No configured filter commands.
-        return {}
+        return ()
     if result.returncode != 0:
         raise OSError("Could not inspect Git filter configuration")
     values: dict[str, str] = {}
@@ -100,12 +118,6 @@ def _disabled_filter_config(
             if not separator:
                 raise OSError("Could not read Git filter configuration")
             values[key] = value
-    drivers = {key.rsplit(".", 1)[0] for key, value in values.items() if value}
-    overrides: dict[str, str] = {}
-    for driver in sorted(drivers):
-        # Empty all three commands, including the long-running process protocol.
-        # required=true makes an attempted conversion fail instead of passing
-        # through bytes that might differ from the real filter's representation.
-        overrides.update({f"{driver}.{kind}": "" for kind in ("clean", "smudge", "process")})
-        overrides[f"{driver}.required"] = "true"
-    return overrides
+    return tuple(
+        sorted({key[len("filter.") :].rsplit(".", 1)[0] for key, value in values.items() if value})
+    )

{alysis_code-0.14.3 → alysis_code-0.14.7}/src/alysis_code/ide/activity_events.py

@@ -25,7 +25,7 @@ ActivityKind: TypeAlias = Literal[
     "other",
 ]
 ActivityStatus: TypeAlias = Literal[
-    "queued", "running", "succeeded", "failed", "cancelled", "blocked"
+    "queued", "running", "succeeded", "failed", "cancelled", "blocked", "completed_unverified"
 ]
 
 MAX_ACTIVITY_TEXT_CHARS = 500
@@ -47,7 +47,15 @@ ACTIVITY_KINDS = (
     "plan",
     "other",
 )
-ACTIVITY_STATUSES = ("queued", "running", "succeeded", "failed", "cancelled", "blocked")
+ACTIVITY_STATUSES = (
+    "queued",
+    "running",
+    "succeeded",
+    "failed",
+    "cancelled",
+    "blocked",
+    "completed_unverified",
+)
 
 _SAFE_METADATA_KEYS = frozenset(
     {
@@ -64,6 +72,8 @@ _SAFE_METADATA_KEYS = frozenset(
         "step",
         "truncated",
         "worker_id",
+        "task_outcome",
+        "verified_success",
     }
 )
 _INTERNAL_NAME_PATTERN = re.compile(r"(?:^|[._:/-])(?:rs|internal)(?:[._:/-]|$)", re.I)
@@ -335,6 +345,8 @@ def _normalize_status(status: str) -> ActivityStatus:
         return "queued"
     if normalized in {"running", "started", "in_progress", "progress"}:
         return "running"
+    if normalized == "completed_unverified":
+        return "completed_unverified"
     if normalized in {"done", "completed", "complete", "success", "succeeded", "ok"}:
         return "succeeded"
     if normalized in {"cancelled", "canceled", "interrupted"}:

{alysis_code-0.14.3 → alysis_code-0.14.7}/src/alysis_code/ide/artifacts.py

@@ -4,6 +4,7 @@ from dataclasses import dataclass
 from pathlib import Path, PurePosixPath
 from typing import Any
 
+from ..session_artifacts import ARTIFACT_HANDLE_INDEX_DIR
 from .protocol import ProtocolError, redact_secrets
 
 DEFAULT_MAX_ARTIFACT_BYTES = 64 * 1024
@@ -50,6 +51,8 @@ class ArtifactStore:
                 except OSError:
                     continue
                 for path in entries:
+                    if depth == 0 and path.name == ARTIFACT_HANDLE_INDEX_DIR:
+                        continue
                     if path.is_symlink():
                         continue
                     if path.is_dir():

{alysis_code-0.14.3 → alysis_code-0.14.7}/src/alysis_code/ide/change_ledger.py

@@ -60,6 +60,27 @@ class StaleWorkspaceError(ChangeLedgerError):
     """The workspace no longer matches the state being reversed."""
 
 
+def _checkpoint_storage_directory(workspace_root: Path, storage_root: Path | None = None) -> Path:
+    workspace = workspace_root.expanduser().resolve(strict=True)
+    workspace_key = hashlib.sha256(
+        os.path.normcase(os.fspath(workspace)).encode("utf-8")
+    ).hexdigest()[:24]
+    override = str(env_get("ALYSIS_DATA_DIR") or "").strip()
+    default_data_dir = Path(override).expanduser() if override else canonical_user_data_dir()
+    base = (storage_root or default_data_dir / "checkpoints").expanduser().resolve()
+    try:
+        base.relative_to(workspace)
+    except ValueError:
+        return base / workspace_key
+    raise ChangeLedgerError("Checkpoint storage must be outside the workspace.")
+
+
+def checkpoint_storage_exists(workspace_root: Path) -> bool:
+    """Check for durable checkpoint state without initializing storage or launching Git."""
+    storage = _checkpoint_storage_directory(workspace_root)
+    return (storage / "ledger.sqlite3").exists() or (storage / "objects.git").exists()
+
+
 @dataclass(frozen=True)
 class ChangeRecord:
     status: str
@@ -119,19 +140,7 @@ class ChangeLedger:
         self.workspace_root = workspace_root.expanduser().resolve(strict=True)
         if not self.workspace_root.is_dir():
             raise ChangeLedgerError("Checkpoint workspace must be a directory.")
-        workspace_key = hashlib.sha256(
-            os.path.normcase(os.fspath(self.workspace_root)).encode("utf-8")
-        ).hexdigest()[:24]
-        override = str(env_get("ALYSIS_DATA_DIR") or "").strip()
-        default_data_dir = Path(override).expanduser() if override else canonical_user_data_dir()
-        base = (storage_root or default_data_dir / "checkpoints").expanduser().resolve()
-        try:
-            base.relative_to(self.workspace_root)
-        except ValueError:
-            pass
-        else:
-            raise ChangeLedgerError("Checkpoint storage must be outside the workspace.")
-        self.storage_dir = base / workspace_key
+        self.storage_dir = _checkpoint_storage_directory(self.workspace_root, storage_root)
         self.git_dir = self.storage_dir / "objects.git"
         self.index_dir = self.storage_dir / "indexes"
         self.database_path = self.storage_dir / "ledger.sqlite3"
@@ -434,15 +443,25 @@ class ChangeLedger:
         self.storage_dir.mkdir(parents=True, exist_ok=True)
         self.index_dir.mkdir(parents=True, exist_ok=True)
         if not self.git_dir.exists():
-            result = subprocess.run(
-                ["git", "init", "--bare", "--quiet", os.fspath(self.git_dir)],
-                capture_output=True,
-                timeout=self.git_timeout_seconds,
-                check=False,
-                env=build_git_process_env(),
-            )
+            try:
+                result = subprocess.run(
+                    ["git", "init", "--bare", "--quiet", os.fspath(self.git_dir)],
+                    capture_output=True,
+                    timeout=self.git_timeout_seconds,
+                    check=False,
+                    env=build_git_process_env(),
+                )
+            except (OSError, subprocess.TimeoutExpired):
+                raise ChangeLedgerError(
+                    "Checkpoint storage could not start Git. Install Git and check that it can run."
+                ) from None
             if result.returncode != 0:
                 raise ChangeLedgerError("Unable to initialize external checkpoint storage.")
+        self._object_hash_name = (
+            self._git(["rev-parse", "--show-object-format"], check=True).stdout.decode().strip()
+        )
+        if self._object_hash_name not in {"sha1", "sha256"}:
+            raise ChangeLedgerError("Unsupported checkpoint Git object format.")
         info_dir = self.git_dir / "info"
         info_dir.mkdir(parents=True, exist_ok=True)
         exclude_path = info_dir / "exclude"
@@ -1397,6 +1416,16 @@ class ChangeLedger:
         path = _safe_workspace_path(self.workspace_root, rel_path)
         return self._path_identity(path)
 
+    def _blob_oid(self, data: bytes) -> str:
+        # Equivalent to `git hash-object --stdin` (no path or filters). Baseline
+        # capture checks every file twice; spawning Git for each hash adds
+        # thousands of process launches in a normal repository, especially costly
+        # on Windows. Keep the existing before/after stat and content checks.
+        digest = hashlib.new(self._object_hash_name, usedforsecurity=False)
+        digest.update(f"blob {len(data)}\0".encode("ascii"))
+        digest.update(data)
+        return digest.hexdigest()
+
     def _path_identity(self, path: Path) -> tuple[str, str] | None:
         if not os.path.lexists(path):
             return None
@@ -1406,12 +1435,7 @@ class ChangeLedger:
             after = path.lstat()
             if _stat_fingerprint(before) != _stat_fingerprint(after):
                 return "unstable", "unstable"
-            oid = (
-                self._git(["hash-object", "--stdin"], input_bytes=data, check=True)
-                .stdout.decode()
-                .strip()
-            )
-            return "120000", oid
+            return "120000", self._blob_oid(data)
         if not path.is_file():
             return "040000", "directory"
         try:
@@ -1423,13 +1447,8 @@ class ChangeLedger:
             return "unstable", "unstable"
         if _stat_fingerprint(before) != _stat_fingerprint(after):
             return "unstable", "unstable"
-        oid = (
-            self._git(["hash-object", "--stdin"], input_bytes=data, check=True)
-            .stdout.decode()
-            .strip()
-        )
         executable = bool(after.st_mode & stat.S_IXUSR) and os.name != "nt"
-        return ("100755" if executable else "100644"), oid
+        return ("100755" if executable else "100644"), self._blob_oid(data)
 
     def _session_git_env(self, session_id: str) -> dict[str, str]:
         env = build_git_process_env()

{alysis_code-0.14.3 → alysis_code-0.14.7}/src/alysis_code/ide/context_blocks.py

@@ -271,6 +271,14 @@ def sanitize_context_blocks(
     kinds: list[ContextKind] = []
     any_truncated = bool(dropped)
 
+    # A single context block whose path is git-ignored, or that resolved outside the workspace, must
+    # not abort the whole turn: the IDE attaches whatever the user has open, and a git-ignored editor
+    # among many is the common case that used to fail the entire message. Such a block is DROPPED —
+    # its content is still excluded, which is the point of the ignore policy — and the rest proceed.
+    # A policy that *throws* (path_policy_failed) stays fail-closed and still raises, because an
+    # unevaluable policy is an internal fault, not ordinary user content; likewise a sensitive-path
+    # deny and every structural/format error still raise.
+    droppable_reasons = {"ignored_path", "path_outside_workspace"}
     for index, raw_block in enumerate(raw_blocks[:accepted_count]):
         if not isinstance(raw_block, Mapping):
             raise ContextValidationError(
@@ -278,14 +286,21 @@ def sanitize_context_blocks(
                 "Each context block must be an object.",
                 block_index=index,
             )
-        block = _normalize_block(
-            raw_block,
-            roots=roots,
-            limits=active_limits,
-            is_ignored=is_ignored,
-            path_policy=path_policy,
-            block_index=index,
-        )
+        try:
+            block = _normalize_block(
+                raw_block,
+                roots=roots,
+                limits=active_limits,
+                is_ignored=is_ignored,
+                path_policy=path_policy,
+                block_index=index,
+            )
+        except ContextValidationError as error:
+            if error.code in droppable_reasons:
+                dropped += 1
+                any_truncated = True
+                continue
+            raise
         fitted, did_truncate = _fit_block(block, active_limits.max_block_bytes)
         normalized.append(fitted)
         kinds.append(fitted["type"])