voiceops 0.1.3__tar.gz

voiceops-0.1.3/.gitignore

@@ -0,0 +1,11 @@
+.env
+.env.*
+!.env.example
+.venv/
+__pycache__/
+*.pyc
+.DS_Store
+dist/
+.pytest_cache/
+.ruff_cache/
+recordings/

voiceops-0.1.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Digvijay Singh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

voiceops-0.1.3/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.5
+Name: voiceops
+Version: 0.1.3
+Summary: Deployment discipline for voice agents: safe defaults, a release gate, an audit ledger, deploy checks and call review.
+Project-URL: Repository, https://github.com/digvijaysingh-ai/voiceops
+Project-URL: Documentation, https://github.com/digvijaysingh-ai/voiceops/blob/main/docs/guide.md
+Author: Digvijay Singh
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.7
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: typer>=0.12
+Requires-Dist: voiceledger>=0.1.3
+Provides-Extra: fastapi
+Requires-Dist: fastapi>=0.110; extra == 'fastapi'
+Provides-Extra: postgres
+Requires-Dist: psycopg[binary]>=3.2; extra == 'postgres'
+Requires-Dist: voiceledger[postgres]; extra == 'postgres'
+Description-Content-Type: text/markdown
+
+# voiceops
+
+Deployment discipline for voice agents, as a kit: safety defaults, a release gate, a verifiable audit ledger, deploy checks and a real-call review loop.
+
+```bash
+uvx voiceops init claims-line --organisation "Example Insurance"
+cd claims-line && uv sync
+uv run voiceops gate
+```
+
+Commands: `init`, `build [--check]`, `push`, `gate`, `check`, `call`, `fetch`, `review`. Extras: `voiceops[fastapi]` (guard dependencies), `voiceops[postgres]` (token store, ledger storage).
+
+Guide: [https://github.com/digvijaysingh-ai/voiceops/blob/main/docs/guide.md](https://github.com/digvijaysingh-ai/voiceops/blob/main/docs/guide.md). MIT licence.

voiceops-0.1.3/README.md

@@ -0,0 +1,13 @@
+# voiceops
+
+Deployment discipline for voice agents, as a kit: safety defaults, a release gate, a verifiable audit ledger, deploy checks and a real-call review loop.
+
+```bash
+uvx voiceops init claims-line --organisation "Example Insurance"
+cd claims-line && uv sync
+uv run voiceops gate
+```
+
+Commands: `init`, `build [--check]`, `push`, `gate`, `check`, `call`, `fetch`, `review`. Extras: `voiceops[fastapi]` (guard dependencies), `voiceops[postgres]` (token store, ledger storage).
+
+Guide: [https://github.com/digvijaysingh-ai/voiceops/blob/main/docs/guide.md](https://github.com/digvijaysingh-ai/voiceops/blob/main/docs/guide.md). MIT licence.

voiceops-0.1.3/pyproject.toml

@@ -0,0 +1,28 @@
+[project]
+name = "voiceops"
+version = "0.1.3"
+description = "Deployment discipline for voice agents: safe defaults, a release gate, an audit ledger, deploy checks and call review."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Digvijay Singh" }]
+requires-python = ">=3.12"
+dependencies = ["voiceledger>=0.1.3", "pydantic>=2.7", "httpx>=0.27", "typer>=0.12", "python-dotenv>=1.0"]
+
+[project.urls]
+Repository = "https://github.com/digvijaysingh-ai/voiceops"
+Documentation = "https://github.com/digvijaysingh-ai/voiceops/blob/main/docs/guide.md"
+
+[project.optional-dependencies]
+fastapi = ["fastapi>=0.110"]
+postgres = ["psycopg[binary]>=3.2", "voiceledger[postgres]"]
+
+[project.scripts]
+voiceops = "voiceops.cli:app"
+
+[tool.uv.sources]
+voiceledger = { workspace = true }
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

voiceops-0.1.3/src/voiceops/__init__.py

@@ -0,0 +1,3 @@
+"""voiceops: deployment discipline for voice agents (see docs/PLAN.md)."""
+
+__version__ = "0.1.3"

voiceops-0.1.3/src/voiceops/_imports.py

@@ -0,0 +1,28 @@
+"""Load a project object named as "package.module:ATTR", relative to the project root."""
+
+from __future__ import annotations
+
+import importlib
+import sys
+from pathlib import Path
+from typing import Any
+
+
+class ImportSpecError(ValueError):
+    pass
+
+
+def load_object(spec: str, root: Path, what: str = "object") -> Any:
+    module_name, _, attr = spec.partition(":")
+    if not module_name or not attr:
+        raise ImportSpecError(f"{what} must look like 'package.module:ATTR', got {spec!r}")
+    added = str(root) not in sys.path
+    if added:
+        sys.path.insert(0, str(root))
+    try:
+        return getattr(importlib.import_module(module_name), attr)
+    except (ImportError, AttributeError) as e:
+        raise ImportSpecError(f"cannot load {what} from {spec!r}: {e}") from e
+    finally:
+        if added:
+            sys.path.remove(str(root))

voiceops-0.1.3/src/voiceops/cli.py

@@ -0,0 +1,237 @@
+"""The `voiceops` command. Subcommands land with their modules (PLAN §4.5)."""
+
+from pathlib import Path
+
+import typer
+from dotenv import load_dotenv
+
+from voiceops import __version__
+from voiceops.config import ConfigError, PushError, load_config, stale_files, write
+from voiceops.config import build as build_files
+from voiceops.config import dry_run as push_dry_run
+from voiceops.config import push as push_profile
+
+app = typer.Typer(help="Deployment discipline for voice agents.", no_args_is_help=True)
+CONFIG = typer.Option(Path("voiceops.toml"), "--config", "-c", help="Project config file.")
+DIRECTORY = typer.Option(None, help="Where to create it (default: ./<name>).")
+KIT_SOURCE = typer.Option(None, help="Use a local kit checkout (its packages/ folder), not PyPI.")
+
+
+@app.callback()
+def main() -> None:
+    """Deployment discipline for voice agents."""
+
+
+@app.command()
+def version() -> None:
+    """Print the kit version."""
+    typer.echo(__version__)
+
+
+@app.command()
+def init(
+    name: str = typer.Argument(..., help="Project name: lowercase, digits, dashes."),
+    organisation: str = typer.Option("Example Organisation", help="Who the agent speaks for."),
+    directory: Path = DIRECTORY,
+    kit_source: Path = KIT_SOURCE,
+) -> None:
+    """Create a new use-case project with the kit wired in."""
+    from voiceops.scaffold import init as scaffold
+
+    target = directory or Path(name)
+    try:
+        written = scaffold(target, name, organisation, kit_source)
+    except ConfigError as e:
+        typer.echo(f"error: {e}", err=True)
+        raise typer.Exit(2) from e
+    typer.echo(f"created {target} ({len(written)} files)")
+    typer.echo(f"next: cd {target} && uv sync && uv run voiceops gate")
+
+
+@app.command()
+def build(
+    check: bool = typer.Option(False, help="Fail if the committed build is stale (for CI)."),
+    config: Path = CONFIG,
+) -> None:
+    """Compose agent configs and tool schemas into the build directory."""
+    try:
+        cfg = load_config(config)
+        files = build_files(cfg)
+    except ConfigError as e:
+        typer.echo(f"error: {e}", err=True)
+        raise typer.Exit(2) from e
+    if check:
+        stale = stale_files(cfg, files)
+        if stale:
+            typer.echo(f"stale agent build files (run `voiceops build`): {stale}", err=True)
+            raise typer.Exit(1)
+        typer.echo("agent build up to date")
+        return
+    write(cfg, files)
+    typer.echo(f"wrote {len(files)} files to {cfg.path(cfg.agent.build_dir)}")
+
+
+@app.command()
+def push(
+    profile: str = typer.Option(..., help="Profile to push, as named in the profiles file."),
+    base_url: str = typer.Option(..., help="Public HTTPS URL of the project's tool API."),
+    dry_run: bool = typer.Option(False, help="Print the payloads, call nothing."),
+    config: Path = CONFIG,
+) -> None:
+    """Create or update the profile's tools and agent on the platform, idempotently."""
+    try:
+        cfg = load_config(config)
+        if dry_run:
+            typer.echo(push_dry_run(cfg, profile, base_url))
+            return
+        load_dotenv(cfg.root / ".env")
+        typer.echo(push_profile(cfg, profile, base_url))
+    except (ConfigError, PushError) as e:
+        typer.echo(f"error: {e}", err=True)
+        raise typer.Exit(2) from e
+
+
+@app.command()
+def gate(
+    level: str = typer.Option("all", help="tool | conversation | all"),
+    only: str = typer.Option("", help="Comma-separated scenario ids (writes partial.json)."),
+    smoke: bool = typer.Option(False, help="Only scenarios marked smoke."),
+    config: Path = CONFIG,
+) -> None:
+    """Run the release gate. Exit 0 = PASS, 1 = FAIL, 2 = ERRORED."""
+    from voiceops.evals import EXIT, gate_from_config, iter_failures
+
+    if level not in ("tool", "conversation", "all"):
+        typer.echo("error: --level must be tool, conversation or all", err=True)
+        raise typer.Exit(2)
+    try:
+        cfg = load_config(config)
+        load_dotenv(cfg.root / ".env")
+        report, out = gate_from_config(cfg, level, [s for s in only.split(",") if s], smoke)
+    except (ConfigError, ValueError) as e:
+        typer.echo(f"error: {e}", err=True)
+        raise typer.Exit(2) from e
+    status = report["gate"]["status"]
+    typer.echo(f"gate {status}: {report['gate']['summary']}")
+    for line in iter_failures(report):
+        typer.echo(f"  {line}")
+    typer.echo(f"report: {out}")
+    raise typer.Exit(EXIT[status])
+
+
+@app.command()
+def check(
+    base_url: str = typer.Argument(None, help="Override [deploy] base_url."),
+    config: Path = CONFIG,
+) -> None:
+    """Run the declared deploy checks against a live deployment."""
+    from voiceops.deploy.run import run_checks
+
+    try:
+        cfg = load_config(config)
+        load_dotenv(cfg.root / ".env")
+        results = run_checks(cfg, base_url)
+    except ConfigError as e:
+        typer.echo(f"error: {e}", err=True)
+        raise typer.Exit(2) from e
+    for r in results:
+        typer.echo(r.line())
+    raise typer.Exit(0 if all(r.ok for r in results) else 1)
+
+
+@app.command()
+def call(
+    setup: bool = typer.Option(False, help="Import the Twilio number into ElevenLabs first."),
+    config: Path = CONFIG,
+) -> None:
+    """Place one test call to the single allow-listed number."""
+    from voiceops._imports import load_object
+    from voiceops.review import import_number, place_call
+
+    try:
+        cfg = load_config(config)
+        load_dotenv(cfg.root / ".env")
+        if setup:
+            typer.echo(f"phone number imported: {import_number(cfg)}")
+            return
+        placed = place_call(cfg)
+    except ConfigError as e:
+        typer.echo(f"error: {e}", err=True)
+        raise typer.Exit(2) from e
+    typer.echo(f"calling your allow-listed number ending {placed['to']}")
+    typer.echo(f"conversation_id: {placed['conversation_id']}")
+    if cfg.review and cfg.review.instructions:
+        typer.echo(load_object(cfg.review.instructions, cfg.root, "[review] instructions")())
+    typer.echo("afterwards: voiceops fetch <conversation_id>")
+
+
+def _sheet_options(cfg):
+    from voiceops.evals import LeakDetector
+    from voiceops.review import SheetOptions
+
+    rv = cfg.review
+    vocab = cfg.path(cfg.evals.leak_vocabulary) if cfg.evals else None
+    return SheetOptions(
+        disclosure_markers=rv.disclosure_markers,
+        verify_tool=rv.verify_tool,
+        verified_status=rv.verified_status,
+        leak_context=rv.leak_context,
+        unbacked_promises=rv.unbacked_promises,
+        detector=LeakDetector.from_toml(vocab) if vocab and vocab.exists() else None,
+    )
+
+
+def _write_sheet(cfg, conv: dict, title: str | None) -> Path:
+    from voiceops.review import render
+
+    out = cfg.path(cfg.review.sheets)
+    out.mkdir(parents=True, exist_ok=True)
+    path = out / f"{conv.get('conversation_id', 'call')}.md"
+    path.write_text(render(conv, _sheet_options(cfg), title))
+    return path
+
+
+@app.command()
+def fetch(
+    conversation_id: str,
+    title: str = typer.Option(None, help="Sheet title, e.g. 'Call 02 · Confirm and reschedule'."),
+    config: Path = CONFIG,
+) -> None:
+    """Save a call's raw conversation and audio locally, and render its review sheet."""
+    from voiceops.review import fetch_conversation, recordings_ignored
+
+    try:
+        cfg = load_config(config)
+        load_dotenv(cfg.root / ".env")
+        conv, folder = fetch_conversation(cfg, conversation_id)
+    except ConfigError as e:
+        typer.echo(f"error: {e}", err=True)
+        raise typer.Exit(2) from e
+    if recordings_ignored(folder) is False:
+        typer.echo(f"warning: {folder} is not gitignored; recordings must stay local", err=True)
+    typer.echo(f"saved raw conversation and audio in {folder}")
+    typer.echo(f"review sheet: {_write_sheet(cfg, conv, title)}")
+
+
+@app.command()
+def review(
+    conversation_json: Path,
+    title: str = typer.Option(None, help="Sheet title."),
+    config: Path = CONFIG,
+) -> None:
+    """Render a review sheet from a saved raw conversation (no network)."""
+    import json
+
+    try:
+        cfg = load_config(config)
+        if cfg.review is None:
+            raise ConfigError("voiceops.toml has no [review] section")
+        conv = json.loads(conversation_json.read_text())
+    except (ConfigError, OSError, ValueError) as e:
+        typer.echo(f"error: {e}", err=True)
+        raise typer.Exit(2) from e
+    typer.echo(f"review sheet: {_write_sheet(cfg, conv, title)}")
+
+
+if __name__ == "__main__":
+    app()

voiceops-0.1.3/src/voiceops/config/__init__.py

@@ -0,0 +1,21 @@
+"""Agent configs from prompt fragments and profiles, with shipped safety defaults, tool schemas
+from Pydantic models, a drift check and an idempotent push (PLAN §2, §4.4)."""
+
+from voiceops.config.build import build, stale_files, write
+from voiceops.config.fragments import SAFETY_SLOTS, kit_fragment
+from voiceops.config.project import ConfigError, VoiceopsConfig, load_config
+from voiceops.config.push import PushError, dry_run, push
+
+__all__ = [
+    "SAFETY_SLOTS",
+    "ConfigError",
+    "PushError",
+    "VoiceopsConfig",
+    "build",
+    "dry_run",
+    "kit_fragment",
+    "load_config",
+    "push",
+    "stale_files",
+    "write",
+]

voiceops-0.1.3/src/voiceops/config/build.py

@@ -0,0 +1,118 @@
+"""Compose agent configs from fragments + profiles, and tool schemas from the request models.
+
+Output is deterministic and committed, so every prompt or tool change shows up as a
+reviewable diff; `check` fails on drift (for CI). Files written to [agent] build_dir:
+
+  tools.json        webhook tool definitions
+  <profile>.json    one agent config per profile
+  safety.json       how each safety slot was satisfied in each profile
+"""
+
+from __future__ import annotations
+
+import json
+
+from voiceops.config.fragments import check_safety_config, compose
+from voiceops.config.project import ConfigError, VoiceopsConfig
+from voiceops.config.tools import Tools, load_tools, tool_schema
+
+
+def _dump(obj) -> str:
+    return json.dumps(obj, indent=2, ensure_ascii=False, sort_keys=True) + "\n"
+
+
+def agent_config(key: str, p: dict, cfg: VoiceopsConfig, tools: Tools) -> tuple[dict, dict]:
+    a = cfg.agent
+    direction = a.directions.get(p["direction"])
+    if direction is None:
+        raise ConfigError(f"profile {key}: no [agent.directions.{p['direction']}]")
+    prompt, safety = compose(
+        key, p["fragments"], a, cfg.path(a.fragments), recording=p["record_voice"]
+    )
+    phone = direction.phone_audio
+    config = {
+        "name": p["name"],
+        "conversation_config": {
+            "agent": {
+                # A profile can override its direction's first message (e.g. no recording
+                # notice on a profile that doesn't record).
+                "first_message": p.get("first_message", direction.first_message),
+                "language": a.language,
+                "prompt": {
+                    "llm": a.llm,
+                    "temperature": a.temperature,
+                    "prompt": prompt,
+                    "tool_names": [n for n in tools if n not in direction.exclude_tools],
+                    # The agent hangs up itself after the goodbye, instead of looping on
+                    # goodbyes until the caller hangs up.
+                    "built_in_tools": {
+                        "end_call": {
+                            "name": "end_call",
+                            "description": a.end_call_description,
+                            "params": {"system_tool_type": "end_call"},
+                        }
+                    },
+                },
+            },
+            "tts": {
+                "model_id": a.tts_model,
+                "voice_id": a.voice_id,
+                **({"agent_output_audio_format": "ulaw_8000"} if phone else {}),
+            },
+            **({"asr": {"user_input_audio_format": "ulaw_8000"}} if phone else {}),
+        },
+        "platform_settings": {
+            "privacy": {
+                "record_voice": p["record_voice"],
+                "zero_retention_mode": p["zero_retention_mode"],
+            }
+        },
+    }
+    return config, safety
+
+
+# Platform constraint (ElevenLabs, 2026-10-17): agents whose language is English must use an
+# English TTS model; the multilingual v2.5 models are refused at push time.
+ENGLISH_TTS_MODELS = frozenset({"eleven_turbo_v2", "eleven_flash_v2"})
+
+
+def check_platform_constraints(cfg: VoiceopsConfig) -> None:
+    a = cfg.agent
+    if a.language == "en" and a.tts_model not in ENGLISH_TTS_MODELS:
+        raise ConfigError(
+            f'[agent] language = "en" needs tts_model in {sorted(ENGLISH_TTS_MODELS)}'
+            f" (got {a.tts_model!r}); the platform refuses other models for English agents"
+        )
+
+
+def build(cfg: VoiceopsConfig) -> dict[str, str]:
+    """Returns {filename: text} for the build directory. Raises ConfigError."""
+    check_safety_config(cfg.agent)
+    check_platform_constraints(cfg)
+    tools = load_tools(cfg.agent.tools, cfg.root)
+    for direction, d in cfg.agent.directions.items():
+        unknown = sorted(set(d.exclude_tools) - set(tools))
+        if unknown:
+            raise ConfigError(f"[agent.directions.{direction}] excludes unknown tools {unknown}")
+    profiles = json.loads(cfg.path(cfg.agent.profiles).read_text())
+    files = {"tools.json": _dump([tool_schema(n, tools, cfg) for n in tools])}
+    manifest = {}
+    for key, p in profiles.items():
+        if key.startswith("_"):
+            continue
+        files[f"{key}.json"], manifest[key] = agent_config(key, p, cfg, tools)
+        files[f"{key}.json"] = _dump(files[f"{key}.json"])
+    files["safety.json"] = _dump(manifest)
+    return files
+
+
+def stale_files(cfg: VoiceopsConfig, files: dict[str, str]) -> list[str]:
+    out = cfg.path(cfg.agent.build_dir)
+    return [n for n, t in files.items() if not (out / n).exists() or (out / n).read_text() != t]
+
+
+def write(cfg: VoiceopsConfig, files: dict[str, str]) -> None:
+    out = cfg.path(cfg.agent.build_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    for name, text in files.items():
+        (out / name).write_text(text)

voiceops-0.1.3/src/voiceops/config/fragments.py

@@ -0,0 +1,88 @@
+"""Prompt composition with the kit's safety defaults (PLAN §4.4).
+
+Each safety slot is satisfied in every profile in exactly one way:
+
+  reworded   the project maps the slot to its own fragment ([agent.safety]); that
+             fragment must then be in the profile, or the build fails.
+  default    the kit's wording (voiceops/config/safety/<slot>.md) is appended.
+  removed    only with a reason in [agent.allow_remove]; recorded in safety.json.
+
+So safety can be reworded, but never dropped silently.
+"""
+
+from __future__ import annotations
+
+import re
+from importlib.resources import files
+from pathlib import Path
+
+from voiceops.config.project import AgentSection, ConfigError
+
+SAFETY_SLOTS = (
+    "ai_disclosure",
+    "upset_caller",
+    "identity_before_detail",
+    "third_party_voicemail",
+    "human_on_request",
+    "no_unbacked_promises",
+    "closing",
+)
+_VAR = re.compile(r"\{\{(\w+)\}\}")
+
+
+def kit_fragment(slot: str) -> str:
+    return files("voiceops.config").joinpath("safety", f"{slot}.md").read_text().strip()
+
+
+def _fill(slot: str, text: str, values: dict[str, str]) -> str:
+    missing = sorted({v for v in _VAR.findall(text) if v not in values})
+    if missing:
+        raise ConfigError(
+            f"kit safety fragment {slot!r} needs [agent.vars] {', '.join(missing)}"
+            f' (or reword it with [agent.safety] {slot} = "<your fragment>")'
+        )
+    return _VAR.sub(lambda m: values[m.group(1)], text)
+
+
+def check_safety_config(agent: AgentSection) -> None:
+    unknown = sorted((set(agent.safety) | set(agent.allow_remove)) - set(SAFETY_SLOTS))
+    if unknown:
+        raise ConfigError(f"unknown safety slots {unknown} (known: {', '.join(SAFETY_SLOTS)})")
+    both = sorted(set(agent.safety) & set(agent.allow_remove))
+    if both:
+        raise ConfigError(f"safety slots both reworded and removed: {both}")
+    blank = sorted(k for k, why in agent.allow_remove.items() if not why.strip())
+    if blank:
+        raise ConfigError(f"allow_remove needs a reason for: {blank}")
+
+
+def compose(
+    key: str, fragments: list[str], agent: AgentSection, fragment_dir: Path, recording: bool
+) -> tuple[str, dict[str, str]]:
+    """Returns (prompt, how each safety slot was satisfied) for one profile."""
+    missing = [f for f in agent.required_fragments if f not in fragments]
+    if missing:
+        raise ConfigError(f"profile {key} is missing required fragments: {missing}")
+    parts = [(fragment_dir / f"{f}.md").read_text().strip() for f in fragments]
+    values = {"recording_notice": ", and that the call is recorded" if recording else ""}
+    values |= agent.vars
+    manifest: dict[str, str] = {}
+    for slot in SAFETY_SLOTS:
+        if slot in agent.allow_remove:
+            manifest[slot] = f"removed: {agent.allow_remove[slot]}"
+        elif slot in agent.safety:
+            # One fragment, or alternatives (e.g. a disclosure with and without a recording
+            # notice): the profile must include at least one of them.
+            options = agent.safety[slot]
+            options = [options] if isinstance(options, str) else options
+            present = [f for f in options if f in fragments]
+            if not present:
+                raise ConfigError(
+                    f"profile {key} drops safety slot {slot!r}: none of {options} is in the"
+                    " profile (add one, or [agent.allow_remove] with a reason)"
+                )
+            manifest[slot] = "project: " + ", ".join(present)
+        else:
+            parts.append(_fill(slot, kit_fragment(slot), values))
+            manifest[slot] = "kit default"
+    return "\n\n".join(parts) + "\n", manifest