booking-agent-cli 0.6.0__tar.gz → 0.7.0__tar.gz

{booking_agent_cli-0.6.0 → booking_agent_cli-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: booking-agent-cli
-Version: 0.6.0
+Version: 0.7.0
 Summary: The Booking Agent CLI: a stateful USP booking flow with hard gates, plus its USP protocol library.
 Project-URL: Homepage, https://github.com/wix/booking-agent
 Project-URL: Documentation, https://github.com/wix/booking-agent/blob/master/booking-agent/README.md
@@ -78,7 +78,7 @@ Each release also publishes that skill at an immutable `skill-v<version>` tag an
 the release workflow, so a harness can pin and verify the exact text it follows:
 
 ```bash
-curl -fsSLO https://raw.githubusercontent.com/wix/booking-agent/skill-v0.54.0/booking-agent/skills/booking-agent/SKILL.md
+curl -fsSLO https://raw.githubusercontent.com/wix/booking-agent/skill-v0.55.0/booking-agent/skills/booking-agent/SKILL.md
 gh attestation verify SKILL.md --repo wix/booking-agent \
   --signer-workflow wix/booking-agent/.github/workflows/release.yml
 ```

{booking_agent_cli-0.6.0 → booking_agent_cli-0.7.0}/README.md

@@ -36,7 +36,7 @@ Each release also publishes that skill at an immutable `skill-v<version>` tag an
 the release workflow, so a harness can pin and verify the exact text it follows:
 
 ```bash
-curl -fsSLO https://raw.githubusercontent.com/wix/booking-agent/skill-v0.54.0/booking-agent/skills/booking-agent/SKILL.md
+curl -fsSLO https://raw.githubusercontent.com/wix/booking-agent/skill-v0.55.0/booking-agent/skills/booking-agent/SKILL.md
 gh attestation verify SKILL.md --repo wix/booking-agent \
   --signer-workflow wix/booking-agent/.github/workflows/release.yml
 ```

{booking_agent_cli-0.6.0 → booking_agent_cli-0.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "booking-agent-cli"
-version = "0.6.0"
+version = "0.7.0"
 description = "The Booking Agent CLI: a stateful USP booking flow with hard gates, plus its USP protocol library."
 readme = "README.md"
 license = "Apache-2.0"

{booking_agent_cli-0.6.0 → booking_agent_cli-0.7.0}/src/booking_agent/__init__.py

@@ -3,4 +3,4 @@
 Ships in the booking-agent-cli wheel and never imports ``booking_agent_cli``.
 """
 
-__version__ = "0.6.0"
+__version__ = "0.7.0"

{booking_agent_cli-0.6.0 → booking_agent_cli-0.7.0}/src/booking_agent/defaults.env

@@ -17,6 +17,9 @@ BOOKING_AGENT_SESSION_DIR=~/.booking-agent
 # Absolute folder a host keeps between runs. When set, booking-agent links its state and the
 # Link sign-in into it by itself before every command.
 # BOOKING_AGENT_PERSISTENT_ROOT=
+# Set to `none` by a host that keeps this runtime's files between conversations itself, so
+# `flow init` does not ask the agent how state is kept.
+# BOOKING_AGENT_PERSISTENCE=
 BOOKING_AGENT_MAX_SESSIONS=30
 LINK_CLI_BIN=link-cli
 

{booking_agent_cli-0.6.0 → booking_agent_cli-0.7.0}/src/booking_agent_cli/__init__.py

@@ -1,3 +1,3 @@
 """booking_agent_cli: typer-based stateful CLI for USP booking flows."""
 
-__version__ = "0.6.0"
+__version__ = "0.7.0"

{booking_agent_cli-0.6.0 → booking_agent_cli-0.7.0}/src/booking_agent_cli/bundled_skill.md

@@ -1,5 +1,5 @@
 ---
-version: 0.54.0
+version: 0.55.0
 name: booking-agent
 description: |
   Books time-based services via USP from a Link wallet. Use when the user wants to book, schedule, reserve, or pay for a service from a business (haircut, lesson, repair, class, appointment, consult). The `booking-agent` CLI owns the booking state machine and refuses to proceed when human gates are skipped. Sign the user in to Link on your own, right after install and at the start of every booking (`booking-agent flow link-auth connect`, then start `booking-agent flow link-auth poll` in the background and post the sign-in URL in the same turn, exactly like `pay poll`); never wait for the user to ask to sign in or to say they approved. After `booking-agent flow business use`, follow `next_command` through `use-ucp-checkout-mode`; businesses without native checkout fail closed. Payment uses `booking-agent flow pay request` (default returns immediately with the approval URL), then start `booking-agent flow pay poll` in the background and post the approval URL to the user in the same turn; the poll finishes checkout once they approve. Confirm through `booking-agent flow book poll --wait`; never start an inbound webhook. Surface the approval URL exactly once. Personal identification (name, phone, email, address) must always come from the user's Link account via `link-cli`, never from chat or placeholders. Before any location-based search, the CLI proposes the Link shipping address and the user confirms it or gives another; online services skip this. Talk to the user in plain everyday language only; never expose CLI, UCP, auth, session, or other implementation details unless they explicitly ask.
@@ -19,7 +19,7 @@ metadata:
         - link-cli
     install:
       - kind: uv
-        package: "booking-agent-cli==0.6.0"
+        package: "booking-agent-cli==0.7.0"
         bins: [booking-agent]
 user-invocable: true
 ---
@@ -220,7 +220,7 @@ To take a fixed, published version instead of the latest, fetch it at the releas
 workflow signs it under, and check the signature before you follow it:
 
 ```bash
-curl -fsSLO https://raw.githubusercontent.com/wix/booking-agent/skill-v0.54.0/booking-agent/skills/booking-agent/SKILL.md
+curl -fsSLO https://raw.githubusercontent.com/wix/booking-agent/skill-v0.55.0/booking-agent/skills/booking-agent/SKILL.md
 gh attestation verify SKILL.md \
   --repo wix/booking-agent \
   --signer-workflow wix/booking-agent/.github/workflows/release.yml
@@ -245,17 +245,17 @@ before installing:
 
 ```bash
 dir="$HOME/.booking-agent/verified-wheels"
-uvx pip download "booking-agent-cli==0.6.0" --no-deps --only-binary :all: -d "$dir"
+uvx pip download "booking-agent-cli==0.7.0" --no-deps --only-binary :all: -d "$dir"
 uvx pypi-attestations==0.0.30 verify pypi --repository https://github.com/wix/booking-agent \
-  "$dir/booking_agent_cli-0.6.0-py3-none-any.whl"
-uv tool install --force "$dir/booking_agent_cli-0.6.0-py3-none-any.whl"
+  "$dir/booking_agent_cli-0.7.0-py3-none-any.whl"
+uv tool install --force "$dir/booking_agent_cli-0.7.0-py3-none-any.whl"
 
 booking-agent --help
 ```
 
 Install only the wheel whose verify step passed, never one that failed it. If `uvx` is not
-available, install the same pinned release with `uv tool install booking-agent-cli==0.6.0` or
-`pipx install booking-agent-cli==0.6.0`; the CLI checks its own files against the signed release
+available, install the same pinned release with `uv tool install booking-agent-cli==0.7.0` or
+`pipx install booking-agent-cli==0.7.0`; the CLI checks its own files against the signed release
 on the first `booking-agent flow init` and refuses to book or pay if they do not match.
 
 Harnesses that read the `install` block in this skill's metadata do this for you. Do not go on
@@ -275,22 +275,21 @@ npm install -g @stripe/link-cli
 
 ### After installing
 
-**Keep state between conversations.** When the host names a folder that survives between
-conversations in `BOOKING_AGENT_PERSISTENT_ROOT`, the CLI links its state and the Link sign-in into
-it by itself before every command: do nothing and never mention it. Only when the variable is unset
-and this runtime gives you such a folder, run this once per conversation, before `booking-agent flow
-sessions list`:
-
-```bash
-booking-agent runtime prepare --persistent-root <absolute folder that survives>
-```
-
-Use the same folder every time; it merges what each folder holds (booking files by session, the
-newer copy of anything else) and deletes nothing. Add `--link <runtime folder>=<persistent folder>`
-for each extra cache folder the runtime asks you to keep. If the user is asked to sign in or
-reconnect right after a restart, run `booking-agent runtime doctor` and follow its `next_command`.
-When the runtime keeps its files anyway, skip all of this. Do not tell the user about it. If it
-fails, continue the booking without it.
+**Keep state between conversations.** `flow init` asks how this runtime keeps its files and refuses
+(`persistence_unresolved`) until you answer. Look at what the runtime offers. If it gives you a
+folder that survives between conversations, re-run the same init with `--persistent-root <absolute
+path of that folder>`: the CLI links saved bookings and the Link sign-in into it, merging what each
+folder holds (booking files by session, the newer copy of anything else) and deleting nothing. If
+the runtime keeps its files anyway, or gives no such folder, re-run it with `--no-persistent-root`.
+If it answers `persistence_folder_not_durable` the folder failed a basic check (a temporary or
+memory-backed place, or not writable): name the folder the runtime really keeps, or use
+`--no-persistent-root`. It sends you back at most twice and then uses the folder as given.
+`persistence_setup_failed` and `persistence_flags_conflict` say what to change. Use the same folder
+every time, never guess a path, never ask the user, and never mention it. A host
+that sets `BOOKING_AGENT_PERSISTENT_ROOT` or `BOOKING_AGENT_PERSISTENCE=none` is never asked. If the
+user is asked to sign in or reconnect right after a restart, run `booking-agent runtime doctor` and
+follow its `next_command`. For extra cache folders the runtime asks you to keep, run `booking-agent
+runtime prepare --persistent-root <folder> --link <runtime folder>=<persistent folder>`.
 
 **Sign the user in to Link**, as described in [Link sign-in](#link-sign-in-automatic). It works
 with no booking in progress. Do not wait for the user to offer to sign in.
@@ -309,7 +308,7 @@ prints each effective setting and where it came from; `booking-agent config init
 
 The CLI decides whether a newer version is worth mentioning; you never decide from version
 numbers or release pages. Pass this skill's version on every `flow init` (`--skill-version
-0.54.0`, from the frontmatter above), so the CLI can tell when these instructions and the
+0.55.0`, from the frontmatter above), so the CLI can tell when these instructions and the
 installed CLI no longer match.
 
 - When a command returns `awaiting_user: update_consent`, ask the question in `prompt` in plain
@@ -471,7 +470,7 @@ confirmation email or on the business's page (`booking_url`). Do not invent a lo
 **Step 1b — Create a new session:**
 
 ```bash
-booking-agent flow init --user-request "<user's exact request>" --skill-version 0.54.0 \
+booking-agent flow init --user-request "<user's exact request>" --skill-version 0.55.0 \
   --skill-path "<absolute path of the SKILL.md you loaded>"
 ```
 

{booking_agent_cli-0.6.0 → booking_agent_cli-0.7.0}/src/booking_agent_cli/commands/flow.py

@@ -399,8 +399,17 @@ def init(
     capability: Optional[List[str]] = typer.Option(
         None, "--capability", help="A capability the user's request needs; repeatable.",
     ),
+    persistent_root: Optional[str] = typer.Option(
+        None, "--persistent-root",
+        help="Absolute folder this runtime keeps between conversations; state is linked into it.",
+    ),
+    no_persistent_root: bool = typer.Option(
+        False, "--no-persistent-root",
+        help="This runtime keeps its files between conversations anyway, or has no such folder.",
+    ),
 ) -> None:
     """Initialize a new booking session."""
+    _resolve_persistence(persistent_root, no_persistent_root)
     store = load_store()
     # Before the session checks: a skill the agent points us at is checked whatever the
     # flow state, so a changed file is never masked by session_active.
@@ -613,6 +622,86 @@ def _upcoming_duplicate_bookings(store: Any, user_request: str) -> List[Dict[str
     return matches
 
 
+def _resolve_persistence(persistent_root: Optional[str], no_persistent_root: bool) -> None:
+    """Make the agent say how this runtime keeps saved state, before any state is written.
+
+    Skipping the setup used to be silent: nothing failed until the next restart lost the
+    booking, the calendar link, and the sign-in. The agent, not the CLI, can see what the runtime
+    offers, so it must answer with a folder or an explicit "no folder"; the CLI never guesses one.
+    """
+    from ..runtime_prepare import (
+        MAX_CORRECTIONS,
+        PrepareError,
+        acknowledge_no_persistence,
+        clear_attempts,
+        corrections_so_far,
+        durability_problem,
+        persistence_resolution,
+        prepare,
+        record_accepted_despite,
+        record_correction,
+    )
+
+    if persistent_root and no_persistent_root:
+        emit_error(
+            "INIT",
+            code="persistence_flags_conflict",
+            message="Pass either --persistent-root or --no-persistent-root, not both.",
+        )
+        raise typer.Exit(code=1)
+    if persistent_root:
+        problem = durability_problem(persistent_root)
+        if problem and corrections_so_far() < MAX_CORRECTIONS:
+            used = record_correction()
+            emit_error(
+                "INIT",
+                code="persistence_folder_not_durable",
+                message=(
+                    f"That folder cannot be relied on to survive a restart: {problem}. Nothing "
+                    "was moved. Re-run the same init command with the folder this runtime "
+                    "really keeps between conversations, or with --no-persistent-root if it keeps "
+                    f"its files anyway. (Correction {used} of {MAX_CORRECTIONS}; after that the "
+                    "folder you name is used as given so the booking is never stuck.)"
+                ),
+            )
+            raise typer.Exit(code=1)
+        if problem:
+            record_accepted_despite(problem)
+        else:
+            clear_attempts()
+        try:
+            prepare(persistent_root, [])
+        except (PrepareError, OSError) as exc:
+            emit_error(
+                "INIT",
+                code="persistence_setup_failed",
+                message=(
+                    f"Saved state could not be linked into that folder ({exc}). Re-run the same "
+                    "init command with the folder this runtime really keeps between "
+                    "conversations, or with --no-persistent-root to go on without it."
+                ),
+            )
+            raise typer.Exit(code=1)
+        return
+    if no_persistent_root:
+        acknowledge_no_persistence()
+        return
+    if persistence_resolution() is None:
+        emit_error(
+            "INIT",
+            code="persistence_unresolved",
+            message=(
+                "Saved bookings and the Link sign-in are not in a folder this runtime keeps "
+                "between conversations, so a restart would lose them. Look at what this runtime "
+                "offers. If it provides a folder that survives restarts, re-run this same init "
+                "command with --persistent-root <absolute path of that folder>. If its files are "
+                "kept anyway, or it offers no such folder, re-run it with --no-persistent-root. "
+                "Decide from the runtime, never ask the user, and never guess a path."
+            ),
+        )
+        raise typer.Exit(code=1)
+
+
 def _unfinished_similar_sessions(store: Any, user_request: str) -> List[Dict[str, Any]]:
     """Unfinished sessions whose request covers most of this one's key terms, newest first."""
     wanted = _request_terms(user_request)

{booking_agent_cli-0.6.0 → booking_agent_cli-0.7.0}/src/booking_agent_cli/runtime_prepare.py

@@ -14,6 +14,7 @@ import json
 import os
 import shutil
 import sys
+import tempfile
 import time
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple
@@ -25,6 +26,16 @@ STATE_SUBDIR = "booking-agent"
 LINK_SUBDIR = "link-cli"
 _LINK_CLI_APP = "link-cli-nodejs"
 ROOT_ENV = "BOOKING_AGENT_PERSISTENT_ROOT"
+# A host that keeps this runtime's files itself declares so with ``BOOKING_AGENT_PERSISTENCE=none``.
+PERSISTENCE_ENV = "BOOKING_AGENT_PERSISTENCE"
+_ACK_FILE = ".persistence-none"
+_ATTEMPTS_FILE = ".persistence-attempts"
+_BOOT_FILE = ".booking-agent-boot"
+# How many times the CLI sends the agent back after a folder fails the checks. The next one is
+# accepted, so a stubborn agent can never leave a booking stuck on this question.
+MAX_CORRECTIONS = 2
+_TEMP_ROOTS = ("/tmp", "/var/tmp", "/dev/shm", "/run")
+_MEMORY_FILESYSTEMS = frozenset({"tmpfs", "ramfs", "devtmpfs"})
 _SESSION_FILE = ".usp-session.json"
 # Order a booking moves through, used to keep the further-along copy of the same session.
 _PHASE_ORDER = (
@@ -311,6 +322,7 @@ def prepare(persistent_root: str, raw_links: List[str]) -> List[Dict[str, str]]:
         results.append(link_one(runtime, persistent, private=private))
     if lifted and results:
         results[0].update(lifted)
+    touch_boot_marker(root)
     return results
 
 
@@ -365,7 +377,21 @@ def diagnose() -> Dict[str, object]:
                 "kind": "configured_root_not_applied", "path": str(state), "severity": "problem",
             })
             root_hint = root_hint or configured
+    persistence: Dict[str, object] = {"folder": root_hint or None, "survived_restart": None}
+    if root_hint:
+        persistence["survived_restart"] = survived_restart(Path(root_hint))
+        if persistence["survived_restart"] is False:
+            findings.append({
+                "kind": "folder_not_yet_shown_to_survive_a_restart",
+                "path": root_hint, "severity": "info",
+            })
+    despite = _read_attempts().get("accepted_despite")
+    if despite:
+        findings.append({
+            "kind": "folder_accepted_despite_checks", "path": str(despite), "severity": "info",
+        })
     return {
+        "persistence": persistence,
         "configured_root": configured,
         "state": state_info,
         "link_sign_in": link_info,
@@ -396,3 +422,177 @@ def auto_prepare() -> Optional[List[Dict[str, str]]]:
         return prepare(root, [])
     except (PrepareError, OSError):
         return None
+
+
+def persistence_resolution() -> Optional[str]:
+    """Why ``flow init`` may go on without asking how this runtime keeps state, or None.
+
+    ``linked``: saved state already lives in a folder the CLI linked it into.
+    ``host_declared``: the host set ``BOOKING_AGENT_PERSISTENCE=none``.
+    ``acknowledged``: an agent already said this runtime keeps its files (kept beside the state,
+    so a fresh runtime that lost the state is asked again).
+    """
+    home = settings.booking_agent_home()
+    if home.is_symlink():
+        return "linked"
+    if (settings.get(PERSISTENCE_ENV) or "").strip().lower() == "none":
+        return "host_declared"
+    if (home / _ACK_FILE).is_file():
+        return "acknowledged"
+    return None
+
+
+def acknowledge_no_persistence() -> None:
+    home = ensure_private_dir(settings.booking_agent_home())
+    write_private_text(home / _ACK_FILE, time.strftime("%Y-%m-%d\n", time.gmtime()))
+
+
+# ---------------------------------------------------------------------------
+# Checks on the folder an agent names, and the record of how often it was sent back
+# ---------------------------------------------------------------------------
+
+def ephemeral_roots() -> List[Path]:
+    """Folders whose contents are not kept between runs, resolved."""
+    roots = [Path(p) for p in _TEMP_ROOTS] + [Path(tempfile.gettempdir())]
+    resolved = []
+    for root in roots:
+        try:
+            resolved.append(root.resolve())
+        except OSError:
+            continue
+    return resolved
+
+
+def fs_type(path: Path) -> Optional[str]:
+    """Filesystem type holding ``path`` (Linux only; None when it cannot be told)."""
+    try:
+        target = path.resolve()
+        best, best_type = "", None
+        with open("/proc/self/mountinfo", encoding="utf-8") as f:
+            for line in f:
+                left, _, right = line.partition(" - ")
+                fields = left.split()
+                if len(fields) < 5 or not right:
+                    continue
+                mount = fields[4].replace("\\040", " ")
+                if (str(target) == mount or str(target).startswith(mount.rstrip("/") + "/")) and len(mount) > len(best):
+                    best, best_type = mount, right.split()[0]
+        return best_type
+    except OSError:
+        return None
+
+
+def durability_problem(raw: str) -> Optional[str]:
+    """Why the folder an agent named cannot be a place that survives restarts, or None.
+
+    Only what can be known now: a path that cannot work, or one the OS itself says is not kept.
+    A folder on ordinary disk that the host simply never restores cannot be told apart here.
+    """
+    try:
+        path = _absolute(raw, what="The folder")
+    except PrepareError as exc:
+        return str(exc)
+    try:
+        resolved = path.resolve()
+    except OSError:
+        return "the path cannot be resolved"
+    if resolved == Path(resolved.anchor):
+        return "it is the filesystem root"
+    for root in ephemeral_roots():
+        if resolved == root or root in resolved.parents:
+            return f"it is under {root}, which is cleared between runs"
+    kind = fs_type(resolved)
+    if kind in _MEMORY_FILESYSTEMS:
+        return f"it is on {kind}, which lives in memory"
+    ancestor = resolved
+    while not ancestor.exists() and ancestor != ancestor.parent:
+        ancestor = ancestor.parent
+    if not ancestor.is_dir():
+        return f"{ancestor} is a file, not a folder"
+    if not os.access(ancestor, os.W_OK | os.X_OK):
+        return f"{ancestor} is not writable"
+    return None
+
+
+def _attempts_path() -> Path:
+    return settings.booking_agent_home() / _ATTEMPTS_FILE
+
+
+def _read_attempts() -> Dict[str, object]:
+    try:
+        raw = json.loads(_attempts_path().read_text())
+        return raw if isinstance(raw, dict) else {}
+    except (OSError, ValueError):
+        return {}
+
+
+def corrections_so_far() -> int:
+    value = _read_attempts().get("rejected")
+    return value if isinstance(value, int) else 0
+
+
+def record_correction() -> int:
+    """Count one more time the agent was sent back; returns the new count."""
+    n = corrections_so_far() + 1
+    ensure_private_dir(settings.booking_agent_home())
+    write_private_text(_attempts_path(), json.dumps({"rejected": n}))
+    return n
+
+
+def record_accepted_despite(problem: str) -> None:
+    ensure_private_dir(settings.booking_agent_home())
+    # The count starts over: this folder was used as given, and a later bad folder is a new
+    # decision that gets its own corrections instead of being waved through.
+    write_private_text(
+        _attempts_path(),
+        json.dumps({"rejected": 0, "accepted_despite": problem}),
+    )
+
+
+def clear_attempts() -> None:
+    try:
+        _attempts_path().unlink()
+    except OSError:
+        pass
+
+
+def current_boot_id() -> Optional[str]:
+    try:
+        return Path("/proc/sys/kernel/random/boot_id").read_text().strip() or None
+    except OSError:
+        return None
+
+
+def touch_boot_marker(root: Path) -> None:
+    """Remember which boot first used this folder, so a later boot proves it survived a restart."""
+    boot = current_boot_id()
+    if boot is None:
+        return
+    marker = root / _BOOT_FILE
+    try:
+        previous = json.loads(marker.read_text())
+    except (OSError, ValueError):
+        previous = {}
+    first = previous.get("first") or boot
+    data = {"first": first, "last": boot, "survived": bool(previous.get("survived")) or first != boot}
+    try:
+        write_private_text(marker, json.dumps(data))
+    except OSError:
+        pass
+
+
+def survived_restart(root: Path) -> Optional[bool]:
+    """True once this folder has been seen across two boots; None when boots cannot be told.
+
+    Never a false "yes": the marker lives in the folder, so seeing it again means the folder
+    came back. It can stay False after a real restart when sandboxes share one kernel (many
+    containers report the host's boot id), so False means "not shown", not "lost".
+    """
+    try:
+        previous = json.loads((root / _BOOT_FILE).read_text())
+    except (OSError, ValueError):
+        return None
+    boot = current_boot_id()
+    if boot is None:
+        return None
+    return bool(previous.get("survived")) or previous.get("first") != boot

{booking_agent_cli-0.6.0 → booking_agent_cli-0.7.0}/src/booking_agent_cli/support_report.py

@@ -109,14 +109,15 @@ SKILL_PROSE_CODES = frozenset({
     "discover_radius_required", "link_address_not_found", "missing_network_id_for_spt",
     "payment_already_captured", "payment_authentication_unsupported",
     "payment_captured_booking_unconfirmed", "payment_declined", "payment_failed",
-    "payment_not_processed", "payment_unrecoverable", "reschedule_at_business",
-    "reschedule_booking_not_active", "reschedule_failed", "reschedule_fee_unsupported",
-    "reschedule_price_changed", "reschedule_price_unknown", "reschedule_same_slot",
-    "reschedule_unauthorized", "search_area_input_invalid", "search_area_not_user_confirmed",
-    "search_area_unconfirmed", "service_address_unconfirmed", "service_details_changed",
-    "session_active", "session_not_found", "slot_not_selected", "spend_request_not_approved",
-    "spend_request_replacement_required", "timezone_confirmation_required",
-    "ucp_complete_failed",
+    "payment_not_processed", "payment_unrecoverable", "persistence_flags_conflict",
+    "persistence_folder_not_durable", "persistence_setup_failed", "persistence_unresolved",
+    "reschedule_at_business", "reschedule_booking_not_active", "reschedule_failed",
+    "reschedule_fee_unsupported", "reschedule_price_changed", "reschedule_price_unknown",
+    "reschedule_same_slot", "reschedule_unauthorized", "search_area_input_invalid",
+    "search_area_not_user_confirmed", "search_area_unconfirmed", "service_address_unconfirmed",
+    "service_details_changed", "session_active", "session_not_found", "slot_not_selected",
+    "spend_request_not_approved", "spend_request_replacement_required",
+    "timezone_confirmation_required", "ucp_complete_failed",
 })
 EXPECTED_CODES = SKILL_TABLE_CODES | SKILL_PROSE_CODES
 # The business is still working; seeing these again is progress, not a failed step.

{booking_agent_cli-0.6.0 → booking_agent_cli-0.7.0}/tests/conftest.py

@@ -13,6 +13,17 @@ def _reset_paid_bookings():
     reset_paid()
 
 
+@pytest.fixture(autouse=True)
+def _host_keeps_files(monkeypatch):
+    """Tests are a host that keeps its own files; the init gate has its own tests."""
+    monkeypatch.setenv("BOOKING_AGENT_PERSISTENCE", "none")
+    from booking_agent_cli import runtime_prepare
+
+    # Test folders live under the system temp dir; the durability checks have their own tests.
+    monkeypatch.setattr(runtime_prepare, "ephemeral_roots", lambda: [])
+    monkeypatch.setattr(runtime_prepare, "fs_type", lambda _path: None)
+
+
 @pytest.fixture
 def runner() -> CliRunner:
     return CliRunner()

{booking_agent_cli-0.6.0 → booking_agent_cli-0.7.0}/tests/integration/test_regression_index.py

@@ -22,6 +22,16 @@ REGRESSIONS = {
         ("test_runtime_prepare.py", "test_the_recorded_hosted_layout_is_repaired_without_losing_the_real_booking"),
         ("test_runtime_prepare.py", "test_the_further_along_copy_of_a_session_wins_and_no_booking_is_lost"),
     ],
+    "setting up persistence could be skipped without any error": [
+        ("test_runtime_prepare.py", "test_init_refuses_until_the_agent_says_how_state_is_kept"),
+        ("test_runtime_prepare.py", "test_a_folder_the_agent_names_is_set_up_and_then_not_asked_again"),
+        ("test_runtime_prepare.py", "test_saying_there_is_no_folder_is_remembered_beside_the_state"),
+    ],
+    "an agent named a folder that cannot survive, or insisted on one and got the flow stuck": [
+        ("test_runtime_prepare.py", "test_a_temporary_folder_is_turned_back_and_nothing_moves"),
+        ("test_runtime_prepare.py", "test_the_agent_is_sent_back_twice_and_the_third_time_is_accepted"),
+        ("test_runtime_prepare.py", "test_a_later_boot_shows_the_folder_survived_a_restart"),
+    ],
     "assistant had to remember to set up persistence": [
         ("test_runtime_prepare.py", "test_the_named_persistent_folder_is_prepared_before_any_command"),
     ],