@ahmed-g-gad/apothem 0.1.1

package/src/apothem/harnesses/_shared/wrapper_factories.py

@@ -0,0 +1,448 @@
+# SPDX-License-Identifier: MIT
+
+"""Factories for the thin per-adapter wrapper shims.
+
+Every harness adapter's ``update.py`` / ``verify.py`` (and the project-scope
+adapters' ``install.py`` / ``plan()`` plus the native-config adapters'
+``install.py``) repeats byte-identical boilerplate that differs only by the
+harness's manifest key, scope, and a handful of per-adapter deltas. This
+module carries those wrapper shapes once as closure factories so each adapter
+holds only its harness-specific identity; the heavy materialization logic
+already lives in :mod:`apothem.harnesses._shared.install_driver` and its
+sibling modules and is untouched here.
+
+Behavior is identical to the hand-written shims these factories replace: the
+returned closures call the same driver entry points with the same arguments
+in the same order, so no rendered install output changes.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+from . import install_driver
+from .install_driver import MaterializationError, MaterializationRun
+
+# Lifecycle-delegate closure signatures shared by the class factories below.
+_ProjectInstallFn = Callable[..., MaterializationRun]
+_ProjectPlanFn = Callable[..., list[dict[str, str]]]
+_ProjectUninstallFn = Callable[..., None]
+_ProjectVerifyFn = Callable[..., bool]
+_NativeInstallFn = Callable[[Path, dict[str, Any]], MaterializationRun]
+_NativeUninstallFn = Callable[[Path], None]
+_NativeVerifyFn = Callable[[Path], bool]
+
+# Type aliases for the wrapper closure signatures.
+_UserScopeInstall = Callable[[Path, dict[str, Any]], MaterializationRun]
+_ProjectScopeInstall = Callable[..., MaterializationRun]
+_UserScopeUpdate = Callable[[Path, dict[str, Any]], MaterializationRun]
+_ProjectScopeUpdate = Callable[..., MaterializationRun]
+_UserScopeVerify = Callable[[Path], bool]
+_ProjectScopeVerify = Callable[..., bool]
+_ProjectScopePlan = Callable[..., list[dict[str, str]]]
+_MaterializeFn = Callable[[dict[str, Any]], str]
+
+_UPDATE_DOC = """Re-materialize the harness configuration from the updated profile.
+
+    Functionally equivalent to install; kept as a separate entry point
+    so future update semantics (diff, backup-before-overwrite, etc.)
+    can be added without changing the install contract."""
+
+_UPDATE_DOC_PROJECT = (
+    _UPDATE_DOC
+    + " Threads the\n    operator-supplied ``project`` root through to the install entry."
+)
+
+
+def make_update(install_fn: _UserScopeInstall) -> _UserScopeUpdate:
+    """Return a user-scope ``update`` shim delegating to *install_fn*.
+
+    The returned closure has the identical contract and behavior as the
+    hand-written user-scope ``update`` it replaces: ``return install(...)``.
+    """
+
+    def update(output_path: Path, profile: dict[str, Any]) -> MaterializationRun:
+        return install_fn(output_path, profile)
+
+    update.__doc__ = _UPDATE_DOC
+    return update
+
+
+def make_update_project(install_fn: _ProjectScopeInstall) -> _ProjectScopeUpdate:
+    """Return a project-scope ``update`` shim delegating to *install_fn*.
+
+    The returned closure threads the operator-supplied ``project`` keyword
+    through to *install_fn*, matching the hand-written project-scope shim.
+    """
+
+    def update(
+        output_path: Path,
+        profile: dict[str, Any],
+        *,
+        project: Path | None = None,
+    ) -> MaterializationRun:
+        return install_fn(output_path, profile, project=project)
+
+    update.__doc__ = _UPDATE_DOC_PROJECT
+    return update
+
+
+_VERIFY_DOC = """Return True when every manifest install-list target is present and valid.
+
+    Delegates to the shared manifest-walk verifier: every install entry's
+    resolved target must exist per its mode and parse if it is a JSON/YAML
+    config. The harness root is ``output_path.parent``."""
+
+_VERIFY_DOC_PROJECT = """Return True when every manifest install-list target is present and valid.
+
+    Project-scope: the manifest walk resolves targets from the project root, so
+    ``output_path`` (already resolved by the adapter wrapper) is unused here."""
+
+
+def make_verify_harness_root(harness_name: str) -> _UserScopeVerify:
+    """Return a user-scope ``verify`` shim for the harness-root cluster."""
+
+    def verify(output_path: Path) -> bool:
+        return install_driver.verify_install(
+            harness_name, harness_root=output_path.parent
+        )
+
+    verify.__doc__ = _VERIFY_DOC
+    return verify
+
+
+def make_verify_project(harness_name: str) -> _ProjectScopeVerify:
+    """Return a project-scope ``verify`` shim for the project-scope cluster."""
+
+    def verify(output_path: Path, *, project: Path | None = None) -> bool:
+        del output_path  # the manifest walk resolves targets from the project root
+        if project is None:
+            return False
+        return install_driver.verify_install(harness_name, project_root=project)
+
+    verify.__doc__ = _VERIFY_DOC_PROJECT
+    return verify
+
+
+def make_verify_native_config(harness_name: str) -> _UserScopeVerify:
+    """Return a verify shim for the native-config (materializer) cluster."""
+
+    def verify(output_path: Path) -> bool:
+        return install_driver.verify_install(
+            harness_name,
+            harness_root=output_path.parent,
+            native_config=output_path,
+        )
+
+    verify.__doc__ = _VERIFY_DOC
+    return verify
+
+
+def make_project_scope_install(
+    harness_name: str, *, error_message: str
+) -> _ProjectScopeInstall:
+    """Return a project-scope ``install`` shim for the rules-only cluster.
+
+    *error_message* is the adapter's distinct ``--project`` rejection message.
+    """
+
+    def install(
+        output_path: Path,
+        profile: dict[str, Any],
+        *,
+        project: Path | None = None,
+    ) -> MaterializationRun:
+        del output_path  # resolved per-entry from manifest + project root
+        if project is None:
+            raise ValueError(error_message)
+        return install_driver.finalize_install(
+            install_driver.run_install(
+                harness_name, project_root=project, profile=profile
+            ),
+            root=project,
+        )
+
+    return install
+
+
+def make_project_scope_plan(harness_name: str) -> _ProjectScopePlan:
+    """Return a project-scope ``plan`` shim for the rules-only cluster."""
+
+    def plan(output_path: Path, *, project: Path | None = None) -> list[dict[str, str]]:
+        del output_path  # resolved per-entry from manifest + project root
+        return install_driver.build_plan(harness_name, project_root=project)
+
+    return plan
+
+
+def make_native_config_install(
+    harness_name: str,
+    materialize_fn: _MaterializeFn,
+    *,
+    harness_id: str,
+    render_tokens: bool = False,
+    support_profile: bool = False,
+) -> _UserScopeInstall:
+    """Return a native-config (materializer) ``install`` shim.
+
+    The pipeline is identical for every native-config adapter: materialize the
+    native config, project capability warnings, apply the operator-owned write,
+    raise on a write error, run the support install, drop ``warning`` results,
+    project the profile document, and finalize. Per-adapter deltas:
+
+    - *render_tokens*: when True, the materialized content is passed through
+      :func:`install_driver.render_content_tokens` against the harness root
+      (qwen_code only).
+    - *support_profile*: when True, the support ``run_install`` receives the
+      ``profile`` keyword (qwen_code only).
+    """
+
+    def install(output_path: Path, profile: dict[str, Any]) -> MaterializationRun:
+        content = materialize_fn(profile)
+        if render_tokens:
+            content = install_driver.render_content_tokens(
+                content, harness_root=output_path.parent
+            )
+        capability_warnings = install_driver._capability_projection_results(
+            harness_name
+        )
+        native_result = install_driver.apply_operator_owned_content(
+            output_path,
+            content,
+            install_root=output_path.parent,
+            harness_name=harness_name,
+        )
+        if native_result.outcome == "error":
+            raise MaterializationError(
+                f"materialization write failed: {native_result.message}",
+                MaterializationRun(
+                    harness=harness_name,
+                    dry_run=False,
+                    results=(*capability_warnings, native_result),
+                ),
+            )
+        if support_profile:
+            support_run = install_driver.run_install(
+                harness_name,
+                harness_root=output_path.parent,
+                profile=profile,
+            )
+        else:
+            support_run = install_driver.run_install(
+                harness_name,
+                harness_root=output_path.parent,
+            )
+        support_results = tuple(
+            result for result in support_run.results if result.outcome != "warning"
+        )
+        profile_result = install_driver.project_profile_document(
+            output_path.parent,
+            harness_id=harness_id,
+            harness_name=harness_name,
+            profile=profile,
+        )
+        return install_driver.finalize_install(
+            MaterializationRun(
+                harness=harness_name,
+                dry_run=False,
+                results=(
+                    *capability_warnings,
+                    native_result,
+                    *support_results,
+                    profile_result,
+                ),
+            ),
+            root=output_path.parent,
+        )
+
+    return install
+
+
+def make_project_scope_adapter(
+    name: str,
+    *,
+    error_label: str,
+    relative_target: Path,
+    install_fn: _ProjectInstallFn,
+    plan_fn: _ProjectPlanFn,
+    uninstall_fn: _ProjectUninstallFn,
+    update_fn: _ProjectInstallFn,
+    verify_fn: _ProjectVerifyFn,
+    class_name: str,
+) -> type:
+    """Return a project-scope ``<Name>Adapter`` class.
+
+    Builds the byte-identical project-scope adapter class the rules-only
+    cohort (codebuddy, cursor, gemini_cli, github_copilot, kiro, trae,
+    windsurf, zed) each hand-rolled. The class opts into the
+    ``requires_project`` contract, resolves its on-disk target under the
+    operator-supplied ``--project`` root, and delegates every lifecycle
+    method to the per-adapter sibling functions passed in. Per-adapter
+    deltas captured as parameters:
+
+    - *name*: the canonical kebab-case identifier the ``name`` property returns.
+    - *error_label*: the package-name token the ``resolve_output_path``
+      ``ValueError`` message uses (underscore form, e.g. ``github_copilot``),
+      which is distinct from *name* for the hyphen-vs-underscore harnesses.
+    - *relative_target*: the sentinel relative path ``output_path`` returns
+      and the concrete target ``resolve_output_path`` joins onto the project
+      root.
+    - *class_name*: the ``__name__`` / ``__qualname__`` the returned class
+      carries so entry-point and discovery resolution find ``<Name>Adapter``.
+
+    Behavior is identical to the hand-written classes: same ``name``, same
+    resolved output paths, same ``requires_project`` flag, same method
+    delegation and argument order.
+    """
+    _relative = relative_target
+    _error = error_label
+    _name = name
+
+    class _ProjectScopeAdapter:
+        #: Opt-in to the project-scope adapter contract.
+        requires_project: bool = True
+
+        @property
+        def name(self) -> str:
+            """Return the canonical kebab-case harness identifier."""
+            return _name
+
+        @property
+        def output_path(self) -> Path:
+            """Return a display-only sentinel relative path."""
+            return _relative
+
+        def resolve_output_path(self, project: Path | None) -> Path:
+            """Return the concrete on-disk target under the project root."""
+            if project is None:
+                raise ValueError(
+                    f"{_error} adapter requires --project <path> to resolve output_path"
+                )
+            return project / _relative
+
+        def install(
+            self, profile: dict[str, Any], *, project: Path | None = None
+        ) -> MaterializationRun:
+            """Materialize the harness configuration into the project root."""
+            output_path = self.resolve_output_path(project)
+            return install_fn(output_path, profile, project=project)
+
+        def update(
+            self, profile: dict[str, Any], *, project: Path | None = None
+        ) -> MaterializationRun:
+            """Re-materialize the harness configuration into the project root."""
+            output_path = self.resolve_output_path(project)
+            return update_fn(output_path, profile, project=project)
+
+        def plan(
+            self,
+            output_path: Path | None = None,
+            *,
+            project: Path | None = None,
+        ) -> list[dict[str, str]]:
+            """Return the manifest-driven propagation plan without writing."""
+            resolved = output_path or (
+                self.resolve_output_path(project) if project is not None else _relative
+            )
+            return plan_fn(resolved, project=project)
+
+        def uninstall(self, *, project: Path | None = None) -> None:
+            """Remove the harness configuration file if present."""
+            output_path = self.resolve_output_path(project)
+            uninstall_fn(output_path, project=project)
+
+        def is_installed(self, *, project: Path | None = None) -> bool:
+            """Return True if the configuration file exists on disk."""
+            if project is None:
+                return False
+            return self.resolve_output_path(project).exists()
+
+        def verify(self, *, project: Path | None = None) -> bool:
+            """Return True if the installed configuration is valid."""
+            if project is None:
+                return False
+            return verify_fn(self.resolve_output_path(project), project=project)
+
+    _ProjectScopeAdapter.__name__ = class_name
+    _ProjectScopeAdapter.__qualname__ = class_name
+    _ProjectScopeAdapter.__doc__ = (
+        f"{class_name} — implements :class:`~apothem.harnesses.HarnessAdapter`.\n\n"
+        "    Project-scope adapter: opts into the ``requires_project`` contract\n"
+        "    declared at :func:`apothem.cli._adapter_requires_project`. The CLI\n"
+        "    threads the operator-supplied ``--project <path>`` value through\n"
+        "    ``_invoke_with_project`` for every lifecycle method."
+    )
+    return _ProjectScopeAdapter
+
+
+def make_native_config_adapter(
+    name: str,
+    *,
+    target_factory: Callable[[], Path],
+    install_fn: _NativeInstallFn,
+    uninstall_fn: _NativeUninstallFn,
+    update_fn: _NativeInstallFn,
+    verify_fn: _NativeVerifyFn,
+    class_name: str,
+) -> type:
+    """Return a native-config (materializer) ``<Name>Adapter`` class.
+
+    Builds the byte-identical user-scope adapter class the native-config
+    cohort (hermes, open_claw, opencode, qwen_code) each hand-rolled. The
+    class owns one absolute ``output_path`` anchor and delegates every
+    lifecycle method to the per-adapter sibling functions passed in.
+    Per-adapter deltas captured as parameters:
+
+    - *name*: the canonical kebab-case identifier the ``name`` property returns.
+    - *target_factory*: a zero-arg callable returning the absolute target
+      configuration path; called lazily on every ``output_path`` access so the
+      hand-rolled property's per-access ``Path.home()`` evaluation is preserved
+      (eager evaluation at import would bind the operator's real home directory
+      before test HOME-isolation could redirect it).
+    - *class_name*: the ``__name__`` / ``__qualname__`` the returned class
+      carries so entry-point and discovery resolution find ``<Name>Adapter``.
+
+    Behavior is identical to the hand-written classes: same ``name``, same
+    ``output_path``, same method delegation and argument order.
+    """
+    _name = name
+
+    class _NativeConfigAdapter:
+        @property
+        def name(self) -> str:
+            """Return the canonical kebab-case harness identifier."""
+            return _name
+
+        @property
+        def output_path(self) -> Path:
+            """Return the target configuration file path."""
+            return target_factory()
+
+        def install(self, profile: dict[str, Any]) -> MaterializationRun:
+            """Materialize the harness configuration from the shared profile."""
+            return install_fn(self.output_path, profile)
+
+        def update(self, profile: dict[str, Any]) -> MaterializationRun:
+            """Re-materialize the harness configuration from the updated profile."""
+            return update_fn(self.output_path, profile)
+
+        def uninstall(self) -> None:
+            """Remove the harness configuration file if present."""
+            uninstall_fn(self.output_path)
+
+        def is_installed(self) -> bool:
+            """Return True if the configuration file exists on disk."""
+            return self.output_path.exists()
+
+        def verify(self) -> bool:
+            """Return True if the installed configuration is valid."""
+            return verify_fn(self.output_path)
+
+    _NativeConfigAdapter.__name__ = class_name
+    _NativeConfigAdapter.__qualname__ = class_name
+    _NativeConfigAdapter.__doc__ = (
+        f"{class_name} implements :class:`~apothem.harnesses.HarnessAdapter`."
+    )
+    return _NativeConfigAdapter

package/src/apothem/harnesses/antigravity/STANDARD-CONVENTION-PIN.md

@@ -0,0 +1,91 @@
+<!-- SPDX-License-Identifier: MIT -->
+
+# Antigravity Standard Convention Pin
+
+## Snapshot
+
+- Snapshot date: 2026-06-25
+- Snapshot note: live re-verification via the official Antigravity codelabs (`codelabs.developers.google.com`) + launch blog (`antigravity.google/blog`) — the `antigravity.google/docs` SPA still returns empty bodies under fetch, so partial confidence persists, but official Google sources now CONFIRM the `~/.gemini/GEMINI.md` global anchor, the `~/.gemini/antigravity-cli/plugins/` plugin root, and plugin `skills/` auto-discovery (resolving the prior unverified skills-scan limitation below), and REFINE the MCP-config path toward `~/.gemini/config/mcp_config.json` (vs the prior `antigravity-cli/` reading — the adapter authors no MCP entries, so no write is affected). Previous 2026-05-31 / 2026-05-28.
+- Adapter source: `src/apothem/harnesses/antigravity/`.
+- Evidence level: **partial confidence.** The official `antigravity.google/docs/*`
+  pages are a JavaScript single-page app that returns empty bodies under fetch;
+  a browser-capable re-fetch on 2026-05-31 could not defeat the empty-body
+  problem. Every convention claim below rests on dated-2026 authority-domain
+  snapshots and third-party sources quoting the official docs, not raw official
+  page text. No vendor-native UI claim is made here.
+- Immutable pin: none — Antigravity is a hosted product with no version or
+  commit surface (the sitemap exposes a changelog but no pin); the
+  `no-immutable-source` exception stands for every claim.
+
+## Antigravity CLI Surface Projection (partial confidence)
+
+- Global context anchor: `~/.gemini/GEMINI.md` (shared with Gemini CLI; both
+  harnesses write this file). `AGENTS.md` continues working unchanged.
+- Migration: Gemini CLI sunsets 2026-06-18 and folds into Antigravity CLI
+  (binary `agy`); `GEMINI.md` and `AGENTS.md` continue working unchanged.
+- CLI customization root: `~/.gemini/antigravity-cli/`.
+- Apothem plugin root: `~/.gemini/antigravity-cli/plugins/apothem/`.
+- MCP: the `mcpServers` object in `~/.gemini/antigravity-cli/mcp_config.json`
+  (global) / `.agents/mcp_config.json` (workspace); stdio entries use
+  `command`/`args`/`env`, remote entries use `serverUrl`. Apothem names this
+  surface but does not author MCP server entries. The CLI path carries a known
+  ambiguity (one authority snapshot read `~/.gemini/antigravity/`, the
+  IDE-scoped path); cross-source consensus favors `antigravity-cli/` for the
+  CLI. The adapter writes no MCP entries, so the ambiguity affects no write.
+- Skills: the confirmed global discovery root is `~/.gemini/antigravity-cli/skills/`;
+  workspace skills live at `.agents/skills/`; the shared `~/.gemini/skills/`
+  still auto-loads. Apothem installs its skills cohort into its own
+  `plugins/apothem/skills/` namespace to avoid colliding with the operator's
+  skills and Gemini CLI project-local files. The agent's auto-discovery of
+  skills inside each plugin's `skills/` directory is confirmed by the official
+  Antigravity codelabs + launch blog (re-verified 2026-06-25), resolving the
+  prior tracked limitation; Apothem's `plugins/apothem/skills/` namespace is
+  therefore a confirmed-discovered placement.
+- Commands: converted into Antigravity skills under the Apothem plugin because the current CLI migration convention routes command-like prompts through skills.
+- Hooks: Antigravity now documents a simple-JSON lifecycle-hook surface
+  (global and workspace scope). Apothem retains its hook prose as support
+  material under the Apothem plugin and does not register Antigravity hook
+  events, because the adapter does not yet own a verified schema translation
+  layer for the Antigravity hook JSON; building one is deferred until the docs
+  are browser-verifiable.
+
+## Recommended Postfix Rendering
+
+- Status: supported as plain text.
+- Mechanism: Apothem emits the literal ` (Recommended)` suffix in the option label. The adapter forwards instruction text without transforming that suffix.
+- Boundary: this pin does not claim a harness-native recommended-option widget. It only pins the text-rendered convention used by `rules/interactive-questions.md`.
+
+## Long Context and Compaction
+
+- Status: profile-managed.
+- Mechanism: Apothem keeps full-suite `/plan-execute` runs continuous by externalizing state to `.apothem/plans/`, compacting or restarting the harness session at phase boundaries as needed, and restoring via the Blind Bootstrap sequence.
+- Boundary: this pin does not claim vendor-native autocompaction or a long-context size. It pins the adapter-local state handoff and compaction-restoration convention used by `rules/context-management.md`.
+
+## Large-Codebase Practice Projection
+
+- Layered context: declared in `capabilities.yml` under `layered_context_surface`; no vendor-native hierarchy is claimed beyond the adapter's documented file/template surface.
+- LSP symbol navigation: `tracked-gap` until a vendor-ratified plugin or tool surface is pinned.
+- Hook learning capture: routed through the `persistent-conventions-vigilance` artifact-evolution cycle; pass-class hooks stay silent and recurring findings become rule, skill, hook, or documentation updates.
+
+## Plugin-alone Persistence
+
+Antigravity has a plugin directory convention
+(`~/.gemini/antigravity-cli/plugins/apothem/`), but that tree is
+**engine-materialized**, not a standalone-installable bundle: the `plugin.json`
+and every cohort beneath it are written by `apothem install`, not shipped as a
+pre-built plugin an operator installs by itself. There is no Apothem-distributed
+plugin-alone install path for this harness; everything requires the full
+`apothem install --harness antigravity` engine run.
+
+| Artifact class | Persists standalone? | Mechanism / limit |
+|---|---|---|
+| Context anchor (rules-as-text) | No — requires `apothem install` | `~/.gemini/GEMINI.md` is engine-written; no pre-built bundle carries it. |
+| Commands / Skills / Agents / Rules | No — requires `apothem install` | The plugin tree (`plugins/apothem/{skills,agents,rules}/`) is engine-materialized; nothing exists before the install run. |
+| Hooks | No — tracked-gap | Antigravity documents a JSON lifecycle-hook surface, but the adapter owns no verified schema-translation layer yet, so it registers no hooks even via the engine. |
+| MCP / Settings | No — operator-owned | `mcpServers` lives in operator-owned `mcp_config.json`; the adapter authors no entries. |
+
+Platform note: a plugin directory exists, but as an engine-write target, not a
+distributable plugin-alone bundle. Building a standalone Antigravity plugin
+package is deferred until the docs are browser-verifiable (the docs SPA returns
+empty bodies under fetch — partial-confidence pin). The engine install is the
+sole persistence path today.

package/src/apothem/harnesses/antigravity/__init__.py

@@ -0,0 +1,70 @@
+# SPDX-License-Identifier: MIT
+
+"""Apothem harness adapter for antigravity — manifest-driven install.
+
+Materializes the apothem convention surface into the Antigravity CLI
+harness target. Antigravity reads ``~/.gemini/GEMINI.md`` as global
+context and stores CLI customization under ``~/.gemini/antigravity-cli/``;
+Apothem installs a named plugin at
+``~/.gemini/antigravity-cli/plugins/apothem/`` for cohorts that should not
+collide with Gemini CLI project-local files.
+
+Delegates installation to
+:mod:`apothem.harnesses.antigravity.install`, which consumes the
+canonical manifest at ``src/apothem/lib/propagation-manifest.yaml``.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from apothem.harnesses._shared.install_driver import MaterializationRun
+from apothem.harnesses.antigravity.install import install as _install
+from apothem.harnesses.antigravity.install import plan as _plan
+from apothem.harnesses.antigravity.uninstall import uninstall as _uninstall
+from apothem.harnesses.antigravity.update import update as _update
+from apothem.harnesses.antigravity.verify import verify as _verify
+
+
+class AntigravityAdapter:
+    """AntigravityAdapter — implements :class:`~apothem.harnesses.HarnessAdapter`."""
+
+    @property
+    def name(self) -> str:
+        """Return the canonical kebab-case harness identifier."""
+        return "antigravity"
+
+    @property
+    def output_path(self) -> Path:
+        """Return the always-propagated singleton config file path.
+
+        The adapter resolves the harness root as ``output_path.parent``
+        (``~/.gemini/``); ``is_installed()`` / ``verify()`` resolve
+        against the GEMINI.md anchor.
+        """
+        return Path.home() / ".gemini/GEMINI.md"
+
+    def install(self, profile: dict[str, Any]) -> MaterializationRun:
+        """Materialize the harness configuration from the shared profile."""
+        return _install(self.output_path, profile)
+
+    def update(self, profile: dict[str, Any]) -> MaterializationRun:
+        """Re-materialize the harness configuration from the updated profile."""
+        return _update(self.output_path, profile)
+
+    def plan(self, output_path: Path | None = None) -> list[dict[str, str]]:
+        """Return the manifest-driven propagation plan without writing."""
+        return _plan(output_path or self.output_path)
+
+    def uninstall(self) -> None:
+        """Remove the harness configuration file if present."""
+        _uninstall(self.output_path)
+
+    def is_installed(self) -> bool:
+        """Return True if the configuration file exists on disk."""
+        return self.output_path.exists()
+
+    def verify(self) -> bool:
+        """Return True if the installed configuration is valid."""
+        return _verify(self.output_path)

package/src/apothem/harnesses/antigravity/capabilities.yml

@@ -0,0 +1,40 @@
+# SPDX-License-Identifier: MIT
+
+# Per rules/agent-capability-discipline.md §1 and the
+# agent-capability-discipline-matrix companion §1 / §3 / §7. The
+# antigravity adapter keeps ~/.gemini/GEMINI.md as the global context
+# anchor and installs an Apothem plugin under
+# ~/.gemini/antigravity-cli/plugins/apothem/. Commands are converted to
+# skills because Antigravity CLI treats command migration as skill-based.
+# MCP is natively supported via the mcpServers object in the operator-owned
+# mcp_config.json; Apothem names the surface but does not author MCP server
+# entries. Antigravity ships an unfetchable JavaScript docs site, so these
+# claims carry partial confidence (re-fetched 2026-05-31 via authority-domain
+# snapshots; see STANDARD-CONVENTION-PIN.md).
+
+mcp_servers:
+  - mcp_config.json-mcpServers-stdio-and-http-operator-owned
+# Operator-owned MCP surface: the adapter recognizes it but authors no entries.
+mcp_servers_authored: false
+sub_agent_dispatch: true
+custom_command_support: "skills"
+recommended_postfix_rendering: "plain-text"
+long_context_compaction: "profile-managed"
+context_ignore_surface: "not-documented-in-current-pin"
+layered_context_surface: "~/.gemini/GEMINI.md plus ~/.gemini/antigravity-cli/plugins/apothem/"
+lsp_symbol_navigation: "tracked-gap-no-adapter-owned-LSP-surface"
+hook_learning_capture: "artifact-evolution-cycle"
+standard_convention_pin: "STANDARD-CONVENTION-PIN.md"
+# web-fetch / browser-retrieval surface — the backing capability dimension for
+# rules/source-accessibility.md step 1 ("retrieve through the host's browser /
+# fetch capability"). The pinned snapshot catalogs config-materialization
+# surfaces, not the vendor tool surface, so the web-fetch tool is not yet
+# discovered against the pin — discovery-pending per
+# rules/agent-capability-discipline-matrix.md §1.
+web_fetch: "discovery-pending"
+tool_surface_restrictions:
+  - secrets-paths
+  - destructive-shell-ops
+  - network-write-unsigned
+system_prompt_template_path: "templates/GEMINI.md"
+agent_memory_surface: "not-documented-in-current-pin"