pythia-plsql 0.10.0__tar.gz → 0.11.1__tar.gz

{pythia_plsql-0.10.0/scripts/pythia_plsql.egg-info → pythia_plsql-0.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythia-plsql
-Version: 0.10.0
+Version: 0.11.1
 Summary: PL/SQL development for AI agents on Oracle Database - expert data-dictionary queries, impact analysis, and a snapshot-verified write path with honest rollback.
 License: MIT
 Project-URL: Homepage, https://github.com/thaildhe172591/pythia
@@ -121,14 +121,14 @@ is in, it is doing none of them.
 ## Install
 
 ```bash
-npx pythia-plsql           # everything: pip install + skills picker + config scaffold
+npx pythia-plsql           # everything: pip install + skills picker + config scaffold + hooks
 ```
 
 Or the same thing piecewise:
 
 ```bash
 pip install pythia-plsql   # the CLI (thin driver — no Oracle Instant Client needed)
-python -m pythia install   # skills into your agent + .pythia/ scaffold
+python -m pythia install   # skills into your agent + .pythia/ scaffold + Claude Code hooks
 pythia check               # fill in connections.json first, then verify
 ```
 
@@ -204,7 +204,10 @@ hand with
 works just as well.
 `pythia check` warns when the session runs with more power than the task needs.
 
-Using Claude Code? [`examples/claude-code-settings.example.json`](examples/claude-code-settings.example.json)
+Using Claude Code? `pythia install` wires the two hooks — the approve-in-chat
+door and the session-start guide — and the deny rule into
+`.claude/settings.json`, merged into whatever is already there. The rest of
+[`examples/claude-code-settings.example.json`](examples/claude-code-settings.example.json)
 stops it prompting for the read-only commands and asks it to pause on
 writes — optional, and yours to install
 ([why pythia does not](GUIDE.md#11-optional-claude-code-permission-settings)).

{pythia_plsql-0.10.0 → pythia_plsql-0.11.1}/README.md

@@ -107,14 +107,14 @@ is in, it is doing none of them.
 ## Install
 
 ```bash
-npx pythia-plsql           # everything: pip install + skills picker + config scaffold
+npx pythia-plsql           # everything: pip install + skills picker + config scaffold + hooks
 ```
 
 Or the same thing piecewise:
 
 ```bash
 pip install pythia-plsql   # the CLI (thin driver — no Oracle Instant Client needed)
-python -m pythia install   # skills into your agent + .pythia/ scaffold
+python -m pythia install   # skills into your agent + .pythia/ scaffold + Claude Code hooks
 pythia check               # fill in connections.json first, then verify
 ```
 
@@ -190,7 +190,10 @@ hand with
 works just as well.
 `pythia check` warns when the session runs with more power than the task needs.
 
-Using Claude Code? [`examples/claude-code-settings.example.json`](examples/claude-code-settings.example.json)
+Using Claude Code? `pythia install` wires the two hooks — the approve-in-chat
+door and the session-start guide — and the deny rule into
+`.claude/settings.json`, merged into whatever is already there. The rest of
+[`examples/claude-code-settings.example.json`](examples/claude-code-settings.example.json)
 stops it prompting for the read-only commands and asks it to pause on
 writes — optional, and yours to install
 ([why pythia does not](GUIDE.md#11-optional-claude-code-permission-settings)).

{pythia_plsql-0.10.0 → pythia_plsql-0.11.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pythia-plsql"
-version = "0.10.0"
+version = "0.11.1"
 description = "PL/SQL development for AI agents on Oracle Database - expert data-dictionary queries, impact analysis, and a snapshot-verified write path with honest rollback."
 readme = "README.md"
 license = { text = "MIT" }

{pythia_plsql-0.10.0 → pythia_plsql-0.11.1}/scripts/pythia.py

@@ -713,7 +713,12 @@ def plscope_message(name, has_any_data):
 GROUPS = ("plsql_source", "data_dml", "structural", "grants", "session")
 
 PLSQL_SOURCE_RE = re.compile(
-    r"^create\s+(?:or\s+replace\s+)?(?:(?:no)?editionable\s+|(?:no)?force\s+)*"
+    # NONEDITIONABLE, not "noeditionable": Oracle's keyword has the middle N,
+    # and missing it dropped every NONEDITIONABLE object into structural —
+    # deny by default, and counted by semicolons, so a PL/SQL body read as
+    # "more than one statement". Both spellings are accepted here; only the
+    # database decides whether the statement is valid.
+    r"^create\s+(?:or\s+replace\s+)?(?:(?:non?)?editionable\s+|(?:no)?force\s+)*"
     r"(procedure|function|package\s+body|package|trigger|view|type\s+body|type)\b",
     re.I | re.S)
 
@@ -1231,12 +1236,29 @@ def prune_expired_grants(root, now=None):
     return gone
 
 
-def render_restore(obj_type, name, before_text):
+EDITIONABLE_KW_RE = re.compile(
+    r"^create\s+(?:or\s+replace\s+)?((?:non?)?editionable)\b", re.I)
+
+
+def create_prefix(after_text):
+    """The CREATE header ALL_SOURCE does not store, rebuilt for the version
+    held in the database. The editionable keyword is read off the file being
+    applied, because the database's own answer is not in ALL_SOURCE and
+    Oracle refuses to *change* the property through CREATE OR REPLACE
+    (ORA-38824) — so a file that applies cleanly already spells the property
+    the object has. Getting this wrong costs twice: a restore that fails
+    exactly when it is needed, and a phantom line in the diff the developer
+    approves."""
+    m = EDITIONABLE_KW_RE.match(skip_leading_noise(after_text))
+    return "CREATE OR REPLACE " + (f"{m.group(1).upper()} " if m else "")
+
+
+def render_restore(obj_type, name, before_text, after_text=""):
     """The statement that puts things back. For an object that did not exist,
     undo means DROP — a genuinely different promise than restoring source, so
     the caller records created=True and the report says it plainly."""
     if before_text.strip():
-        return "CREATE OR REPLACE " + before_text.rstrip() + "\n"
+        return create_prefix(after_text) + before_text.rstrip() + "\n"
     return f"DROP {obj_type} {name}\n"
 
 
@@ -1256,7 +1278,7 @@ def write_journal_entry(root, obj_type, name, before, after, meta, now=None):
     d.mkdir(parents=True)
     (d / "before.sql").write_text(before, encoding="utf-8")
     (d / "after.sql").write_text(after, encoding="utf-8")
-    (d / "restore.sql").write_text(render_restore(obj_type, name, before),
+    (d / "restore.sql").write_text(render_restore(obj_type, name, before, after),
                                    encoding="utf-8")
     full = {"object": name, "type": obj_type, "created": not before.strip(),
             "entry": eid, **meta}
@@ -2105,8 +2127,10 @@ def run_apply(conn, schema, ns, file_text, origin=None):
 
     # 3. PREVIEW — diff like against like: ALL_SOURCE never stores the
     # CREATE OR REPLACE header, so prepend it before comparing, or an
-    # unchanged object would show a phantom two-line change forever.
-    base = ("CREATE OR REPLACE " + db_source) if db_source.strip() else ""
+    # unchanged object would show a phantom two-line change forever. The
+    # editionable keyword is part of that header, or a NONEDITIONABLE file
+    # shows its own first line as a change that is not one.
+    base = (create_prefix(stmt) + db_source) if db_source.strip() else ""
     diff_text, changed = render_diff(base, stmt)
     warn = privilege_warning(conn, schema, ns.conn_user)
     style = (naming_violation(otype, name, load_conventions(ns.project_root))
@@ -3143,6 +3167,78 @@ def clean_legacy_skills(base_dir):
             _remove_link_first(pathlib.Path(base_dir) / rel / old_name)
 
 
+# What `install` wires into Claude Code's settings.json: the two hooks and
+# the deny rule, verbatim from examples/claude-code-settings.example.json (a
+# test keeps them equal). The allow list and autoMode stay in the example —
+# those are the developer's permission preferences, not pythia's to set.
+CLAUDE_HOOKS = {
+    "SessionStart": [{"hooks": [
+        {"type": "command", "command": "python -m pythia guide --brief"}]}],
+    "PostToolUse": [{"matcher": "AskUserQuestion", "hooks": [
+        {"type": "command", "command": "python -m pythia approve --hook",
+         "timeout": 15}]}],
+}
+CLAUDE_DENY = ["Bash(pythia approve --hook*)",
+               "Bash(python -m pythia approve --hook*)"]
+# a hook already present in any spelling (python3, the plugin's script path)
+# is recognised by what it runs, not by how it invokes it
+HOOK_MARKS = {"SessionStart": "guide --brief", "PostToolUse": "approve --hook"}
+
+
+def install_claude_hooks(base_dir, events=None):
+    """Merge the two hooks and the deny rule into <base>/.claude/settings.json
+    — the project's, or the home directory's for -g. The file is Claude
+    Code's, so every other key survives and a pythia hook already there in
+    any spelling counts as present. Returns (path, added): the pieces
+    written, [] when all were there, None when the file could not be parsed
+    and was therefore left alone. `events` narrows which hooks: -g writes
+    only PostToolUse, since ~/.claude/settings.json applies to every project
+    and the session guide would be noise outside Oracle work."""
+    path = pathlib.Path(base_dir) / ".claude" / "settings.json"
+    try:
+        s = json.loads(path.read_text(encoding="utf-8")) if path.is_file() else {}
+        hooks = s.setdefault("hooks", {})
+        deny = s.setdefault("permissions", {}).setdefault("deny", [])
+        added = []
+        for event in events or CLAUDE_HOOKS:
+            entries = CLAUDE_HOOKS[event]
+            present = hooks.setdefault(event, [])
+            cmds = " ".join(h.get("command", "")
+                            for e in present for h in e.get("hooks", []))
+            if HOOK_MARKS[event] not in cmds:
+                present.extend(json.loads(json.dumps(entries)))   # a copy
+                added.append(f"hooks.{event}")
+        missing = [d for d in CLAUDE_DENY if d not in deny]
+        if missing:
+            deny.extend(missing)
+            added.append("permissions.deny")
+    except (ValueError, TypeError, AttributeError):
+        return path, None
+    if added:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(json.dumps(s, indent=2, ensure_ascii=False) + "\n",
+                        encoding="utf-8")
+    return path, added
+
+
+def report_claude_hooks(base_dir, ns, events=None):
+    """install's last step, in both scopes: wire the hooks and say what
+    happened. --no-hooks leaves Claude Code's file alone."""
+    if getattr(ns, "no_hooks", False):
+        return
+    path, added = install_claude_hooks(base_dir, events)
+    if added is None:
+        print(f"\n! {path} is not valid JSON, so it was left untouched. Fix "
+              f"it and re-run {invocation()} install, or paste the hooks "
+              "block from GUIDE.md section 11.")
+    elif added:
+        print()
+        print(f"Wired Claude Code hooks into {path}: {', '.join(added)}.")
+        print("Restart the Claude Code session for them to load.")
+    else:
+        print(f"\nClaude Code hooks already in {path}.")
+
+
 def cmd_install(conn, schema, ns):
     import shutil
     en = getattr(ns, "color", False)
@@ -3158,6 +3254,9 @@ def cmd_install(conn, schema, ns):
             sys.exit(code)
         else:
             clean_legacy_skills(pathlib.Path.home())
+        # machine-wide: the approve hook is silent without a pythia token;
+        # the session guide would be noise in every other project
+        report_claude_hooks(pathlib.Path.home(), ns, events=("PostToolUse",))
         print("\nGlobal skills serve every project — per-project installs "
               "will now skip the skills step automatically.")
         return
@@ -3180,6 +3279,7 @@ def cmd_install(conn, schema, ns):
             sys.exit(code)
         else:
             clean_legacy_skills(ns.project_root)
+    report_claude_hooks(ns.project_root, ns)
     print(f"\nNext: fill in {path}")
     print(f"Then: {invocation()} check")
     scripts_dir = installed_scripts_dir()
@@ -3348,13 +3448,16 @@ def build_parser():
     s.add_argument("--loi", action="store_true",
                    help="wrap as 'loi:'||unistr(...)||':loi'")
     s = sub.add_parser("install", parents=[common()],
-                       help="install the skill pack and scaffold .pythia/ config")
+                       help="install the skill pack, scaffold .pythia/ config, wire the Claude Code hooks")
     s.add_argument("-g", "--global", dest="glob", action="store_true",
                    help="install the skill pack machine-wide (serves every "
                         "project; per-project installs then skip skills)")
     s.add_argument("--add-to-path", action="store_true", dest="add_to_path",
                    help="put the pythia command on your PATH without asking "
                         "(Windows; user PATH only)")
+    s.add_argument("--no-hooks", action="store_true", dest="no_hooks",
+                   help="leave Claude Code's .claude/settings.json alone "
+                        "(no approve-in-chat hook, no session-start guide)")
     s.add_argument("--source", default=DEFAULT_SKILLS_SOURCE,
                    help="skills repo for `npx skills add` "
                         f"(default {DEFAULT_SKILLS_SOURCE})")

{pythia_plsql-0.10.0 → pythia_plsql-0.11.1/scripts/pythia_plsql.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythia-plsql
-Version: 0.10.0
+Version: 0.11.1
 Summary: PL/SQL development for AI agents on Oracle Database - expert data-dictionary queries, impact analysis, and a snapshot-verified write path with honest rollback.
 License: MIT
 Project-URL: Homepage, https://github.com/thaildhe172591/pythia
@@ -121,14 +121,14 @@ is in, it is doing none of them.
 ## Install
 
 ```bash
-npx pythia-plsql           # everything: pip install + skills picker + config scaffold
+npx pythia-plsql           # everything: pip install + skills picker + config scaffold + hooks
 ```
 
 Or the same thing piecewise:
 
 ```bash
 pip install pythia-plsql   # the CLI (thin driver — no Oracle Instant Client needed)
-python -m pythia install   # skills into your agent + .pythia/ scaffold
+python -m pythia install   # skills into your agent + .pythia/ scaffold + Claude Code hooks
 pythia check               # fill in connections.json first, then verify
 ```
 
@@ -204,7 +204,10 @@ hand with
 works just as well.
 `pythia check` warns when the session runs with more power than the task needs.
 
-Using Claude Code? [`examples/claude-code-settings.example.json`](examples/claude-code-settings.example.json)
+Using Claude Code? `pythia install` wires the two hooks — the approve-in-chat
+door and the session-start guide — and the deny rule into
+`.claude/settings.json`, merged into whatever is already there. The rest of
+[`examples/claude-code-settings.example.json`](examples/claude-code-settings.example.json)
 stops it prompting for the read-only commands and asks it to pause on
 writes — optional, and yours to install
 ([why pythia does not](GUIDE.md#11-optional-claude-code-permission-settings)).

{pythia_plsql-0.10.0 → pythia_plsql-0.11.1}/tests/test_install.py

@@ -237,6 +237,119 @@ def test_cmd_install_runs_end_to_end():
         assert env is not None
 
 
+def test_claude_hook_block_matches_the_example_file():
+    """What install wires into .claude/settings.json is exactly the hooks
+    block and the deny rule of the example file — the reviewable source of
+    truth, as with the connections template. The allow list and autoMode
+    stay in the example: those are the developer's permission preferences."""
+    ex = json.loads((ROOT / "examples" / "claude-code-settings.example.json")
+                    .read_text(encoding="utf-8"))
+    assert pythia.CLAUDE_HOOKS == ex["hooks"]
+    assert pythia.CLAUDE_DENY == ex["permissions"]["deny"]
+
+
+def test_install_claude_hooks_creates_settings_and_is_idempotent():
+    with tempfile.TemporaryDirectory() as td:
+        path, added = pythia.install_claude_hooks(td)
+        assert path == pathlib.Path(td) / ".claude" / "settings.json"
+        assert added == ["hooks.SessionStart", "hooks.PostToolUse",
+                         "permissions.deny"]
+        s = json.loads(path.read_text(encoding="utf-8"))
+        assert s["hooks"] == pythia.CLAUDE_HOOKS
+        assert s["permissions"]["deny"] == pythia.CLAUDE_DENY
+        before = path.read_text(encoding="utf-8")
+        assert pythia.install_claude_hooks(td) == (path, [])
+        assert path.read_text(encoding="utf-8") == before
+
+
+def test_install_claude_hooks_merges_into_existing_settings():
+    """The file is Claude Code's, not pythia's: every key the developer put
+    there survives, their own hooks stay, and a pythia hook already present
+    in another spelling (python3, the plugin's path) is recognised, not
+    doubled. Only the missing pieces are added."""
+    with tempfile.TemporaryDirectory() as td:
+        path = pathlib.Path(td) / ".claude" / "settings.json"
+        path.parent.mkdir(parents=True)
+        path.write_text(json.dumps({
+            "model": "opus",
+            "permissions": {"allow": ["Bash(git status)"],
+                            "deny": ["Bash(rm -rf *)"]},
+            "hooks": {
+                "SessionStart": [{"hooks": [
+                    {"type": "command", "command": "echo hi"}]}],
+                "PostToolUse": [{"matcher": "AskUserQuestion", "hooks": [
+                    {"type": "command",
+                     "command": "python3 -m pythia approve --hook"}]}]}}),
+            encoding="utf-8")
+        _, added = pythia.install_claude_hooks(td)
+        assert added == ["hooks.SessionStart", "permissions.deny"]
+        s = json.loads(path.read_text(encoding="utf-8"))
+        assert s["model"] == "opus"
+        assert s["permissions"]["allow"] == ["Bash(git status)"]
+        assert s["permissions"]["deny"][0] == "Bash(rm -rf *)"
+        assert set(pythia.CLAUDE_DENY) <= set(s["permissions"]["deny"])
+        cmds = [h["command"] for ev in s["hooks"].values()
+                for e in ev for h in e["hooks"]]
+        assert "echo hi" in cmds
+        assert sum("approve --hook" in c for c in cmds) == 1   # not doubled
+        assert sum("guide --brief" in c for c in cmds) == 1
+
+
+def test_install_claude_hooks_refuses_a_file_it_cannot_parse():
+    """Broken JSON is still the developer's file. Touching it would destroy
+    what they wrote; say so and leave it byte-identical."""
+    with tempfile.TemporaryDirectory() as td:
+        path = pathlib.Path(td) / ".claude" / "settings.json"
+        path.parent.mkdir(parents=True)
+        path.write_text("{not json", encoding="utf-8")
+        assert pythia.install_claude_hooks(td) == (path, None)
+        assert path.read_text(encoding="utf-8") == "{not json"
+
+
+def test_cmd_install_wires_the_claude_hooks_unless_told_not_to():
+    """The chat approval door needs the hook; a pip user who never opened
+    GUIDE section 11 had none — seen in the 0.10.0 field test. install wires
+    it by default and says so; --no-hooks leaves Claude Code's file alone."""
+    import argparse
+    import contextlib
+    import io
+    old = os.environ.get("PATH")
+    os.environ["PATH"] = ""                    # no npx: bundled path, offline
+    try:
+        for no_hooks in (False, True):
+            with tempfile.TemporaryDirectory() as td:
+                ns = argparse.Namespace(project_root=td, glob=False,
+                                        source=None, color=False, json=False,
+                                        no_hooks=no_hooks)
+                buf = io.StringIO()
+                with contextlib.redirect_stdout(buf):
+                    pythia.cmd_install(None, None, ns)
+                settings = pathlib.Path(td) / ".claude" / "settings.json"
+                if no_hooks:
+                    assert not settings.exists()
+                    continue
+                s = json.loads(settings.read_text(encoding="utf-8"))
+                assert "approve --hook" in json.dumps(s["hooks"]["PostToolUse"])
+                assert set(pythia.CLAUDE_DENY) <= set(s["permissions"]["deny"])
+                assert "settings.json" in buf.getvalue()
+    finally:
+        if old is not None:
+            os.environ["PATH"] = old
+
+
+def test_global_install_wires_the_approve_hook_only():
+    """~/.claude/settings.json applies to every project on the machine. The
+    approve hook is silent unless a question carries a pythia token, so it
+    belongs there; the session-start guide would put 15 lines about pythia
+    into every session of every project, so that one stays per project."""
+    with tempfile.TemporaryDirectory() as td:
+        path, added = pythia.install_claude_hooks(td, events=("PostToolUse",))
+        assert added == ["hooks.PostToolUse", "permissions.deny"]
+        s = json.loads(path.read_text(encoding="utf-8"))
+        assert "SessionStart" not in s["hooks"]
+        assert s["hooks"]["PostToolUse"] == pythia.CLAUDE_HOOKS["PostToolUse"]
+
+
 # Native paths: on POSIX ':' is the PATH separator and would cut a
 # Windows path in half, so these are built from os.sep.
 SCRIPTS = os.path.join(os.sep + 'opt', 'a', 'Scripts')

{pythia_plsql-0.10.0 → pythia_plsql-0.11.1}/tests/test_phase3.py

@@ -32,6 +32,11 @@ def test_classify_groups():
     assert c("alter table t_order add (x number)") == "structural"  # session tested first
     assert c("CREATE OR REPLACE PROCEDURE p AS BEGIN NULL; END;") == "plsql_source"
     assert c("create or replace editionable package body pkg_order as end;") == "plsql_source"
+    # Oracle's keyword is NONEDITIONABLE, with the middle N. Missing it sent
+    # every such object to structural — deny by default, and counted by
+    # semicolons, so a PL/SQL body came back as "more than one statement".
+    assert c("create or replace NONEDITIONABLE procedure p as begin null; end;") == "plsql_source"
+    assert c("CREATE OR REPLACE NONEDITIONABLE PACKAGE BODY pkg AS END;") == "plsql_source"
     assert c("CREATE OR REPLACE FORCE VIEW v AS SELECT 1 FROM dual") == "plsql_source"
     assert c("CREATE TABLE t (x number)") == "structural"  # other CREATE
     assert c("insert into t values (1)") == "data_dml"
@@ -54,6 +59,27 @@ def test_parse_object():
     assert (t, n, s) == ("TYPE BODY", "T_THING", None)
     t, n, s = pythia.parse_object("CREATE OR REPLACE TRIGGER trg_x BEFORE INSERT ON t BEGIN NULL; END;")
     assert (t, n, s) == ("TRIGGER", "TRG_X", None)
+    # the identity drives the snapshot, so the editionable keyword must not
+    # shift what is parsed out of the statement
+    t, n, s = pythia.parse_object(
+        "CREATE OR REPLACE NONEDITIONABLE PROCEDURE core_bh.pbh_file_nh AS BEGIN NULL; END;")
+    assert (t, n, s) == ("PROCEDURE", "PBH_FILE_NH", "CORE_BH")
+
+
+def test_restore_keeps_the_editionable_property():
+    """ALL_SOURCE holds no CREATE prefix, so the restore builds one. On an
+    editions-enabled schema a bare CREATE OR REPLACE over a NONEDITIONABLE
+    object is ORA-38824 — an undo that fails exactly when it is needed."""
+    body = "PROCEDURE p AS BEGIN NULL; END;"
+    assert pythia.render_restore("PROCEDURE", "P", body, "CREATE OR REPLACE " + body) \
+        == "CREATE OR REPLACE " + body + "\n"
+    assert pythia.render_restore(
+        "PROCEDURE", "P", body,
+        "create or replace noneditionable procedure p as begin null; end;") \
+        == "CREATE OR REPLACE NONEDITIONABLE " + body + "\n"
+    # a new object still has no source to put back: undo is a DROP
+    assert pythia.render_restore("PROCEDURE", "P", "", "CREATE OR REPLACE NONEDITIONABLE PROCEDURE p") \
+        == "DROP PROCEDURE P\n"
 
 
 def test_prepare_statement_terminators():
@@ -1475,6 +1501,38 @@ def test_apply_reads_a_bom_file_as_the_statement_it_is():
         assert "approve --card" in buf.getvalue()      # it previewed
 
 
+def test_apply_previews_a_noneditionable_object_end_to_end():
+    """The reported bug, from the outside: NONEDITIONABLE missed the
+    classifier, fell through to structural — which counts statements by
+    semicolon — and a PL/SQL body came back as 'more than one statement'.
+    The only escape was dropping the keyword, which Oracle then met with
+    ORA-38824. Preview must produce a token, and the restore must keep the
+    property."""
+    import contextlib
+    import io
+    import pathlib
+    src = ("CREATE OR REPLACE NONEDITIONABLE PACKAGE BODY pkg_order AS\n"
+           "  new line;\nEND;\n/\n")
+    with tempfile.TemporaryDirectory() as td:
+        f = pathlib.Path(td) / "f.sql"
+        f.write_text(src, encoding="utf-8")
+        buf = io.StringIO()
+        with contextlib.redirect_stdout(buf):
+            pythia.cmd_apply(FakeConn(base_script()), "APP",
+                             apply_ns(td, file=str(f)))
+        out = buf.getvalue()
+        assert "more than one statement" not in out
+        assert "approve --card" in out                  # it previewed
+        entry = pythia.list_journal_entries(td)[0]
+        restore = (pythia.journal_root(td) / entry / "restore.sql").read_text(
+            encoding="utf-8")
+        assert restore.startswith("CREATE OR REPLACE NONEDITIONABLE ")
+        # and the keyword is not shown as a change it is not: ALL_SOURCE holds
+        # no header, so the diff's base has to carry the same one
+        assert "-CREATE OR REPLACE" not in out and "+CREATE OR REPLACE" not in out
+        assert "2 lines changed" in out          # the body line, not the header
+
+
 def test_apply_refuses_when_the_session_schema_is_not_the_configured_one():
     """A proxy into another user, or a stale `schema` in connections.json:
     an unqualified CREATE would land in one schema while pythia snapshots