pythia-plsql 0.1.3__tar.gz → 0.2.0__tar.gz

{pythia_plsql-0.1.3/scripts/pythia_plsql.egg-info → pythia_plsql-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythia-plsql
-Version: 0.1.3
+Version: 0.2.0
 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
@@ -82,7 +82,8 @@ pythia check               # fill in connections.json first, then verify
 The pip package is the whole kit: with Node.js present, `pythia install`
 runs `npx skills add` (77 agents, symlinked updates; `--source <git-url>`
 for internal mirrors) — without Node it copies the bundled skill pack into
-`.claude/skills/` and `.agents/skills/`. Skills alone: `npx skills add
+`.agents/skills/`, the universal layout Claude Code, Codex and Cursor all
+read (one copy, so no skill shows up twice). Skills alone: `npx skills add
 thaildhe172591/pythia`, or `/plugin marketplace add thaildhe172591/pythia`.
 
 `pip install` is **once per machine**; `pythia install` is **once per
@@ -120,8 +121,12 @@ every agent read them first (`pythia conventions` shows both).
 
 **The account is the real security layer** — the policy file is an application-side
 fence. Give the agent its own revocable credential with proxy authentication
-(`agent_user[schema_owner]`, no `ANY` privileges, no owner password shared):
-see [`examples/agent-user-setup.example.sql`](examples/agent-user-setup.example.sql).
+(`agent_user[schema_owner]`, no `ANY` privileges, no owner password shared).
+`pythia agent-user` generates that SQL for your current connection — password
+included, `--save` drops the credential into `connections.json` — but it is
+optional convenience: running
+[`examples/agent-user-setup.example.sql`](examples/agent-user-setup.example.sql)
+by hand works just as well.
 `pythia check` warns when the session runs with more power than the task needs.
 
 Per-group write policy, `.pythia/policy.json` (defaults shown):
@@ -146,10 +151,10 @@ it audits every interaction in `DBTOOLS$MCP_LOG`. **Writes never do** — only
 
 Seven skills teach the agent the workflow — superpowers-style gates, not suggestions:
 
-`plsql-setup` · `plsql-explore` · `plsql-impact` (impact **before** any change) ·
-`plsql-write` (copy the codebase's conventions) · `plsql-apply` (the gate: the
+`pythia-setup` · `pythia-explore` · `pythia-impact` (impact **before** any change) ·
+`pythia-write` (copy the codebase's conventions) · `pythia-apply` (the gate: the
 developer sees the preview and approves in chat before anything is written) ·
-`plsql-review` (seven antipatterns) · `plsql-skill-author` (capture *your team's*
+`pythia-review` (seven antipatterns) · `pythia-skill-author` (capture *your team's*
 workflow as a new skill, mined from the live schema).
 
 ## Compatibility

{pythia_plsql-0.1.3 → pythia_plsql-0.2.0}/README.md

@@ -68,7 +68,8 @@ pythia check               # fill in connections.json first, then verify
 The pip package is the whole kit: with Node.js present, `pythia install`
 runs `npx skills add` (77 agents, symlinked updates; `--source <git-url>`
 for internal mirrors) — without Node it copies the bundled skill pack into
-`.claude/skills/` and `.agents/skills/`. Skills alone: `npx skills add
+`.agents/skills/`, the universal layout Claude Code, Codex and Cursor all
+read (one copy, so no skill shows up twice). Skills alone: `npx skills add
 thaildhe172591/pythia`, or `/plugin marketplace add thaildhe172591/pythia`.
 
 `pip install` is **once per machine**; `pythia install` is **once per
@@ -106,8 +107,12 @@ every agent read them first (`pythia conventions` shows both).
 
 **The account is the real security layer** — the policy file is an application-side
 fence. Give the agent its own revocable credential with proxy authentication
-(`agent_user[schema_owner]`, no `ANY` privileges, no owner password shared):
-see [`examples/agent-user-setup.example.sql`](examples/agent-user-setup.example.sql).
+(`agent_user[schema_owner]`, no `ANY` privileges, no owner password shared).
+`pythia agent-user` generates that SQL for your current connection — password
+included, `--save` drops the credential into `connections.json` — but it is
+optional convenience: running
+[`examples/agent-user-setup.example.sql`](examples/agent-user-setup.example.sql)
+by hand works just as well.
 `pythia check` warns when the session runs with more power than the task needs.
 
 Per-group write policy, `.pythia/policy.json` (defaults shown):
@@ -132,10 +137,10 @@ it audits every interaction in `DBTOOLS$MCP_LOG`. **Writes never do** — only
 
 Seven skills teach the agent the workflow — superpowers-style gates, not suggestions:
 
-`plsql-setup` · `plsql-explore` · `plsql-impact` (impact **before** any change) ·
-`plsql-write` (copy the codebase's conventions) · `plsql-apply` (the gate: the
+`pythia-setup` · `pythia-explore` · `pythia-impact` (impact **before** any change) ·
+`pythia-write` (copy the codebase's conventions) · `pythia-apply` (the gate: the
 developer sees the preview and approves in chat before anything is written) ·
-`plsql-review` (seven antipatterns) · `plsql-skill-author` (capture *your team's*
+`pythia-review` (seven antipatterns) · `pythia-skill-author` (capture *your team's*
 workflow as a new skill, mined from the live schema).
 
 ## Compatibility

{pythia_plsql-0.1.3 → pythia_plsql-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pythia-plsql"
-version = "0.1.3"
+version = "0.2.0"
 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.1.3 → pythia_plsql-0.2.0}/scripts/pythia.py

@@ -536,7 +536,7 @@ POLICY_DEFAULTS = {"plsql_source": "confirm", "data_dml": "deny",
                    "structural": "deny", "grants": "deny", "session": "allow"}
 
 ROLLBACK_TABLE = """\
-Is rollback real?  (this table also appears in README.md and plsql-apply)
+Is rollback real?  (this table also appears in README.md and pythia-apply)
   plsql_source  Yes - completely. Source is recoverable from ALL_SOURCE.
   data_dml      No. After commit only Flashback Query remains, within undo retention.
   structural    Almost never. DROP COLUMN is permanent; a dropped table may be in the Recycle Bin.
@@ -586,6 +586,17 @@ def load_policy(root):
         sys.exit(f"Cannot parse {path}: {e}")
 
 
+def load_settings(root):
+    """Optional .pythia/settings.json — an absent file means defaults."""
+    path = pathlib.Path(root) / CONFIG_DIR / "settings.json"
+    if not path.is_file():
+        return {}
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except ValueError as e:
+        sys.exit(f"Cannot parse {path}: {e}")
+
+
 def journal_root(root):
     return pathlib.Path(root) / CONFIG_DIR / "journal"
 
@@ -1014,6 +1025,19 @@ def privilege_warning(conn, schema, conn_user):
     this session is running with more power than the task needs."""
     _, rows = run_query(conn, load_query("session-privileges.sql"))
     dangerous = [r[0] for r in rows]
+    with conn.cursor() as cur:
+        cur.execute("select sys_context('userenv','proxy_user') from dual")
+        prow = cur.fetchall()
+    proxy = prow[0][0] if prow and prow[0] and prow[0][0] else None
+    if proxy:
+        # sanctioned least-privilege entrance; any excess power is the
+        # OWNER's, inherited by every proxied session — say that
+        if not dangerous:
+            return None
+        return (f"! Proxy session ({proxy} → {schema}), but the owner holds "
+                f"{', '.join(dangerous[:3])}" + ("…" if len(dangerous) > 3 else "")
+                + ":\n  every proxied session inherits this — trim the "
+                "owner's grants; pythia policy explains what is at stake.")
     owner = bool(conn_user) and conn_user.upper() == schema
     if not owner and not dangerous:
         return None
@@ -1151,6 +1175,14 @@ def run_apply(conn, schema, ns, file_text, origin=None):
         return 0
 
     # 4. APPLY
+    if group == "plsql_source" and load_settings(ns.project_root).get(
+            "plscope_on_apply", True):
+        # session-scoped: every object applied through pythia builds the
+        # PL/Scope index as a side effect; opt out with
+        # {"plscope_on_apply": false} in .pythia/settings.json
+        with conn.cursor() as cur:
+            cur.execute("ALTER SESSION SET plscope_settings = "
+                        "'IDENTIFIERS:ALL, STATEMENTS:ALL'")
     with conn.cursor() as cur:
         cur.execute(stmt)
 
@@ -1264,9 +1296,22 @@ def cmd_journal(conn, schema, ns):
             state = "applied" if meta.get("applied") else "preview"
             print(f"{eid}  [{state}]")
         return
+    if ns.action == "prune":
+        import shutil
+        removed = 0
+        for eid in list_journal_entries(root):
+            if not read_journal_entry(root, eid)["meta"].get("applied"):
+                shutil.rmtree(journal_root(root) / eid)
+                removed += 1
+        if ns.json:
+            print(json.dumps({"pruned": removed}))
+        else:
+            print(f"-- pruned {removed} preview-only entries; applied entries "
+                  "(the real snapshots) are all kept")
+        return
     if not ns.id:
         sys.exit(f"Usage: {invocation()} journal "
-                 "{list | show <id> | diff <id> | export <id> | restore <id>}")
+                 "{list | show <id> | diff <id> | export <id> | prune | restore <id>}")
     e = read_journal_entry(root, ns.id)
     if ns.action == "show":
         print(json.dumps(e["meta"], indent=2))
@@ -1460,20 +1505,31 @@ def run_skills_add(source, interactive=False):
     return subprocess.run(cmd).returncode
 
 
+LEGACY_SKILLS = ("plsql-setup", "plsql-explore", "plsql-impact",
+                 "plsql-write", "plsql-apply", "plsql-review",
+                 "plsql-skill-author")
+
+
 def copy_bundled_skills(root):
-    """No-Node fallback: copy the wheel-bundled pack into the two
-    conventional project layouts — Claude Code and the universal .agents one
-    (Codex, Cursor, Copilot, Gemini CLI and friends all read it)."""
+    """No-Node fallback: copy the wheel-bundled pack into .agents/skills/
+    ONLY — the universal layout that Claude Code, Codex, Cursor, Copilot and
+    friends all read. A second copy in .claude/skills/ would show every
+    skill twice in Claude Code's menu. The copy merges: only the pack's own
+    skills are refreshed, anything else in the directory is untouched.
+    Stale copies under the pack's old plsql-* names are removed from both
+    conventional roots (real directories only, never symlinks)."""
     import shutil
-    targets = []
-    for rel in (".claude/skills", ".agents/skills"):
-        dest_root = pathlib.Path(root) / rel
-        for pack in sorted(SKILLS_DIR.iterdir()):
-            if not (pack / "SKILL.md").is_file():
-                continue
-            shutil.copytree(pack, dest_root / pack.name, dirs_exist_ok=True)
-        targets.append(dest_root)
-    return targets
+    dest_root = pathlib.Path(root) / ".agents" / "skills"
+    for pack in sorted(SKILLS_DIR.iterdir()):
+        if not (pack / "SKILL.md").is_file():
+            continue
+        shutil.copytree(pack, dest_root / pack.name, dirs_exist_ok=True)
+    for rel in (".agents/skills", ".claude/skills"):
+        for old_name in LEGACY_SKILLS:
+            legacy = pathlib.Path(root) / rel / old_name
+            if legacy.is_dir() and not legacy.is_symlink():
+                shutil.rmtree(legacy)
+    return [dest_root]
 
 
 def cmd_install(conn, schema, ns):
@@ -1584,7 +1640,7 @@ def build_parser():
     s = sub.add_parser("journal", parents=[common()],
                        help="list, inspect, export and restore write snapshots")
     s.add_argument("action", nargs="?",
-                   choices=["list", "show", "diff", "export", "restore"],
+                   choices=["list", "show", "diff", "export", "prune", "restore"],
                    default="list")
     s.add_argument("id", nargs="?")
     s.add_argument("--what", choices=["after", "before", "restore"],

{pythia_plsql-0.1.3 → pythia_plsql-0.2.0/scripts/pythia_plsql.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythia-plsql
-Version: 0.1.3
+Version: 0.2.0
 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
@@ -82,7 +82,8 @@ pythia check               # fill in connections.json first, then verify
 The pip package is the whole kit: with Node.js present, `pythia install`
 runs `npx skills add` (77 agents, symlinked updates; `--source <git-url>`
 for internal mirrors) — without Node it copies the bundled skill pack into
-`.claude/skills/` and `.agents/skills/`. Skills alone: `npx skills add
+`.agents/skills/`, the universal layout Claude Code, Codex and Cursor all
+read (one copy, so no skill shows up twice). Skills alone: `npx skills add
 thaildhe172591/pythia`, or `/plugin marketplace add thaildhe172591/pythia`.
 
 `pip install` is **once per machine**; `pythia install` is **once per
@@ -120,8 +121,12 @@ every agent read them first (`pythia conventions` shows both).
 
 **The account is the real security layer** — the policy file is an application-side
 fence. Give the agent its own revocable credential with proxy authentication
-(`agent_user[schema_owner]`, no `ANY` privileges, no owner password shared):
-see [`examples/agent-user-setup.example.sql`](examples/agent-user-setup.example.sql).
+(`agent_user[schema_owner]`, no `ANY` privileges, no owner password shared).
+`pythia agent-user` generates that SQL for your current connection — password
+included, `--save` drops the credential into `connections.json` — but it is
+optional convenience: running
+[`examples/agent-user-setup.example.sql`](examples/agent-user-setup.example.sql)
+by hand works just as well.
 `pythia check` warns when the session runs with more power than the task needs.
 
 Per-group write policy, `.pythia/policy.json` (defaults shown):
@@ -146,10 +151,10 @@ it audits every interaction in `DBTOOLS$MCP_LOG`. **Writes never do** — only
 
 Seven skills teach the agent the workflow — superpowers-style gates, not suggestions:
 
-`plsql-setup` · `plsql-explore` · `plsql-impact` (impact **before** any change) ·
-`plsql-write` (copy the codebase's conventions) · `plsql-apply` (the gate: the
+`pythia-setup` · `pythia-explore` · `pythia-impact` (impact **before** any change) ·
+`pythia-write` (copy the codebase's conventions) · `pythia-apply` (the gate: the
 developer sees the preview and approves in chat before anything is written) ·
-`plsql-review` (seven antipatterns) · `plsql-skill-author` (capture *your team's*
+`pythia-review` (seven antipatterns) · `pythia-skill-author` (capture *your team's*
 workflow as a new skill, mined from the live schema).
 
 ## Compatibility

{pythia_plsql-0.1.3 → pythia_plsql-0.2.0}/scripts/pythia_plsql.egg-info/SOURCES.txt

@@ -20,16 +20,16 @@ scripts/pythia_plsql.egg-info/dependency_links.txt
 scripts/pythia_plsql.egg-info/entry_points.txt
 scripts/pythia_plsql.egg-info/requires.txt
 scripts/pythia_plsql.egg-info/top_level.txt
-skills/plsql-apply/SKILL.md
-skills/plsql-explore/SKILL.md
-skills/plsql-explore/reference/data-dictionary.md
-skills/plsql-impact/SKILL.md
-skills/plsql-review/SKILL.md
-skills/plsql-review/reference/antipatterns.md
-skills/plsql-setup/SKILL.md
-skills/plsql-skill-author/SKILL.md
-skills/plsql-write/SKILL.md
-skills/plsql-write/reference/patterns.md
+skills/pythia-apply/SKILL.md
+skills/pythia-explore/SKILL.md
+skills/pythia-explore/reference/data-dictionary.md
+skills/pythia-impact/SKILL.md
+skills/pythia-review/SKILL.md
+skills/pythia-review/reference/antipatterns.md
+skills/pythia-setup/SKILL.md
+skills/pythia-skill-author/SKILL.md
+skills/pythia-write/SKILL.md
+skills/pythia-write/reference/patterns.md
 tests/test_install.py
 tests/test_phase1.py
 tests/test_phase2.py

{pythia_plsql-0.1.3/skills/plsql-apply → pythia_plsql-0.2.0/skills/pythia-apply}/SKILL.md

@@ -1,11 +1,11 @@
 ---
-name: plsql-apply
+name: pythia-apply
 description: Use when a PL/SQL change is ready to reach the database - applying a CREATE OR REPLACE, restoring from the journal, or any other write. Runs the six-step flow through pythia apply and enforces the gate - the developer sees the preview and approves in chat before anything is written, and a broken result is never reported as success.
 ---
 
 # Applying PL/SQL Changes
 
-**Announce at start:** "Using plsql-apply — I'll preview the change first."
+**Announce at start:** "Using pythia-apply — I'll preview the change first."
 
 DDL in Oracle commits itself. There is no transaction to roll back — the
 snapshot pythia takes before writing is the only undo that exists. This skill
@@ -24,7 +24,7 @@ dependents.
 ## The Workflow
 
 **Before step 1:** if this conversation has not yet seen a standalone impact
-analysis for this object, run `plsql-impact` first. The `impact:` line inside
+analysis for this object, run `pythia-impact` first. The `impact:` line inside
 apply's preview is confirmation of a number you already knew — if it is the
 first time anyone sees it, a step was skipped.
 
@@ -114,8 +114,8 @@ the stakes are highest.
 
 ## When NOT to use this skill
 
-- Reading or exploring — use `plsql-explore`.
-- Judging blast radius before editing — use `plsql-impact` (always run it
+- Reading or exploring — use `pythia-explore`.
+- Judging blast radius before editing — use `pythia-impact` (always run it
   before proposing a change; apply's preview is confirmation, not discovery).
 - Editing files the developer has not asked to land on the database yet.
 

{pythia_plsql-0.1.3/skills/plsql-explore → pythia_plsql-0.2.0/skills/pythia-explore}/SKILL.md

@@ -1,11 +1,11 @@
 ---
-name: plsql-explore
+name: pythia-explore
 description: Use when you need to understand anything in an Oracle schema - finding objects, reading PL/SQL source, signatures, table columns, DDL, searching code, or asking who uses what. The database is the only source of truth; repo dumps and exports drift and lie.
 ---
 
 # Exploring the Schema
 
-**Announce at start:** "Using plsql-explore — asking the database directly."
+**Announce at start:** "Using pythia-explore — asking the database directly."
 
 ## The principle: ask the database, never the dump
 

{pythia_plsql-0.1.3/skills/plsql-impact → pythia_plsql-0.2.0/skills/pythia-impact}/SKILL.md

@@ -1,11 +1,11 @@
 ---
-name: plsql-impact
+name: pythia-impact
 description: Use before proposing or writing any change to an Oracle object - a procedure, package, function, trigger, view, or table. Impact analysis comes first, because what depends on an object decides how careful the change must be, and Oracle invalidates dependents in cascade.
 ---
 
 # Impact Before Change
 
-**Announce at start:** "Using plsql-impact to measure the blast radius first."
+**Announce at start:** "Using pythia-impact to measure the blast radius first."
 
 Changing an Oracle object recompiles or invalidates everything that depends
 on it — immediately, schema-wide, for every user of a shared database. The
@@ -51,6 +51,6 @@ program that would be invalidated by an `ALTER`.
 
 ## Hand-off
 
-Impact known and acceptable → `plsql-write` to write the change following
-the codebase's conventions → `plsql-apply` to land it with preview and
+Impact known and acceptable → `pythia-write` to write the change following
+the codebase's conventions → `pythia-apply` to land it with preview and
 verification.

{pythia_plsql-0.1.3/skills/plsql-review → pythia_plsql-0.2.0/skills/pythia-review}/SKILL.md

@@ -1,11 +1,11 @@
 ---
-name: plsql-review
+name: pythia-review
 description: Use when reviewing PL/SQL - a changed procedure or package, a proposed file, or an object suspected of causing trouble. Combines the database's own correctness signals with the antipattern checklist, and reports findings anchored to line numbers.
 ---
 
 # Reviewing PL/SQL
 
-**Announce at start:** "Using plsql-review — checking the database's signals first."
+**Announce at start:** "Using pythia-review — checking the database's signals first."
 
 Review in two passes: what the database *knows* is wrong, then what the
 checklist says is *likely* wrong. Machine signals first — they are free and
@@ -45,6 +45,6 @@ style).
 
 ## When NOT to use this skill
 
-- Reviewing whether a change is *safe to apply* — that is `plsql-impact`
-  plus `plsql-apply`'s preview; this skill judges the code itself.
+- Reviewing whether a change is *safe to apply* — that is `pythia-impact`
+  plus `pythia-apply`'s preview; this skill judges the code itself.
 - Reviewing non-PL/SQL application code — outside this skill's scope.

{pythia_plsql-0.1.3/skills/plsql-setup → pythia_plsql-0.2.0/skills/pythia-setup}/SKILL.md

@@ -1,11 +1,11 @@
 ---
-name: plsql-setup
+name: pythia-setup
 description: Use when setting pythia up for a project or a machine - writing connections.json, creating a least-privilege agent user, wiring the SQLcl MCP server, or diagnosing a connection that will not open. Also the place to start when check prints a privilege warning.
 ---
 
 # Setting Up
 
-**Announce at start:** "Using plsql-setup to configure the database access."
+**Announce at start:** "Using pythia-setup to configure the database access."
 
 Set up in this order: connection first (everything else needs it), the
 least-privilege user second (the only protection that cannot be bypassed),

{pythia_plsql-0.1.3/skills/plsql-skill-author → pythia_plsql-0.2.0/skills/pythia-skill-author}/SKILL.md

@@ -1,11 +1,11 @@
 ---
-name: plsql-skill-author
+name: pythia-skill-author
 description: Use when the developer wants their own way of working captured as a new skill - "make a skill for how we do X", a house convention or preference worth teaching every future session, a team ritual, or the same correction arriving for the second time. Interviews the developer, mines the real conventions from the database, and writes a skill in this pack's format.
 ---
 
 # Authoring a New Skill
 
-**Announce at start:** "Using plsql-skill-author — let's capture how you actually work."
+**Announce at start:** "Using pythia-skill-author — let's capture how you actually work."
 
 A skill is a decision captured so it never has to be re-argued. Capture what
 the team *actually does* — with evidence from the database — not what anyone

{pythia_plsql-0.1.3/skills/plsql-write → pythia_plsql-0.2.0/skills/pythia-write}/SKILL.md

@@ -1,11 +1,11 @@
 ---
-name: plsql-write
+name: pythia-write
 description: Use when writing or modifying PL/SQL source - a procedure, function, package, trigger, or view - after impact is known. The codebase's conventions already exist; copy them instead of inventing style, and anchor every type to the database's reality.
 ---
 
 # Writing PL/SQL
 
-**Announce at start:** "Using plsql-write — mining the codebase's conventions first."
+**Announce at start:** "Using pythia-write — mining the codebase's conventions first."
 
 **Before anything:** if the project has `.pythia/conventions.md`, read it —
 house rules there outrank every generic pattern below, and
@@ -49,7 +49,7 @@ propose style changes to the developer separately, never silently.
 
 ## When NOT to use this skill
 
-- Understanding existing code → `plsql-explore`.
-- Measuring what a change breaks → `plsql-impact` (must already be done).
-- Landing the file on the database → `plsql-apply`, always — never
+- Understanding existing code → `pythia-explore`.
+- Measuring what a change breaks → `pythia-impact` (must already be done).
+- Landing the file on the database → `pythia-apply`, always — never
   `run-sql`, never `sqlplus`.

{pythia_plsql-0.1.3 → pythia_plsql-0.2.0}/tests/test_install.py

@@ -35,8 +35,11 @@ def test_scaffold_creates_config_once_and_never_clobbers():
 
 
 def test_missing_npx_falls_back_to_the_bundled_pack():
-    """No Node -> the whole kit still installs: run_skills_add signals None
-    and the bundled skills are copied into both conventional layouts."""
+    """No Node -> the whole kit still installs. One target only
+    (.agents/skills, the universal layout) — a second copy in
+    .claude/skills would double every skill in Claude Code's menu. The
+    copy merges: foreign skills survive, and stale plsql-* copies of the
+    pack's old names are cleaned from both conventional roots."""
     import shutil
     old = shutil.which
     shutil.which = lambda name: None
@@ -45,14 +48,23 @@ def test_missing_npx_falls_back_to_the_bundled_pack():
     finally:
         shutil.which = old
     with tempfile.TemporaryDirectory() as td:
+        agents = pathlib.Path(td) / ".agents" / "skills"
+        claude = pathlib.Path(td) / ".claude" / "skills"
+        # pre-existing content: a custom skill, and stale old-name copies
+        (agents / "my-team-skill").mkdir(parents=True)
+        (agents / "my-team-skill" / "SKILL.md").write_text("x", encoding="utf-8")
+        (agents / "plsql-apply").mkdir()
+        (claude / "plsql-review").mkdir(parents=True)
         targets = pythia.copy_bundled_skills(td)
-        assert [t.name for t in targets] == ["skills", "skills"]
-        for root in (pathlib.Path(td) / ".claude" / "skills",
-                     pathlib.Path(td) / ".agents" / "skills"):
-            assert (root / "plsql-apply" / "SKILL.md").is_file()
-            assert (root / "plsql-review" / "reference" / "antipatterns.md").is_file()
-        # second run must not fail on the existing copies
-        pythia.copy_bundled_skills(td)
+        assert targets == [agents]
+        assert (agents / "pythia-apply" / "SKILL.md").is_file()
+        assert (agents / "pythia-review" / "reference" / "antipatterns.md").is_file()
+        assert not (claude / "pythia-apply").exists()      # single target
+        assert (agents / "my-team-skill" / "SKILL.md").read_text(
+            encoding="utf-8") == "x"                        # merge, not wipe
+        assert not (agents / "plsql-apply").exists()        # legacy cleaned
+        assert not (claude / "plsql-review").exists()       # in both roots
+        pythia.copy_bundled_skills(td)                      # idempotent
 
 
 def test_invocation_names_the_dash_m_form():
@@ -72,7 +84,7 @@ def test_invocation_names_the_dash_m_form():
 
 def test_pack_dirs_resolve_in_the_source_layout():
     assert (pythia.QUERY_DIR / "impact.sql").is_file()
-    assert (pythia.SKILLS_DIR / "plsql-apply" / "SKILL.md").is_file()
+    assert (pythia.SKILLS_DIR / "pythia-apply" / "SKILL.md").is_file()
 
 
 def test_one_version_across_every_manifest():

{pythia_plsql-0.1.3 → pythia_plsql-0.2.0}/tests/test_phase3.py

@@ -489,6 +489,75 @@ def test_preview_diff_ignores_the_create_header():
         assert "lines changed" not in out
 
 
+def test_apply_builds_plscope_index_by_default():
+    """The write session sets plscope_settings before the CREATE, so every
+    object applied through pythia carries the semantic index."""
+    with tempfile.TemporaryDirectory() as td:
+        conn = FakeConn(base_script())
+        code = pythia.run_apply(conn, "APP", apply_ns(td, file="f.sql", yes=True),
+                                NEW_FILE)
+        assert code == 0
+        stmts = [s for s, _ in conn.executed]
+        alter = [i for i, s in enumerate(stmts) if "plscope_settings" in s.lower()]
+        create = [i for i, s in enumerate(stmts)
+                  if s.lstrip().lower().startswith("create")]
+        assert alter and create and alter[0] < create[0]
+
+
+def test_apply_plscope_opt_out_via_settings():
+    with tempfile.TemporaryDirectory() as td:
+        (pathlib.Path(td) / ".pythia").mkdir()
+        (pathlib.Path(td) / ".pythia" / "settings.json").write_text(
+            '{"plscope_on_apply": false}', encoding="utf-8")
+        conn = FakeConn(base_script())
+        code = pythia.run_apply(conn, "APP", apply_ns(td, file="f.sql", yes=True),
+                                NEW_FILE)
+        assert code == 0
+        assert not any("plscope_settings" in s.lower()
+                       for s, _ in conn.executed)
+
+
+def test_privilege_warning_speaks_proxy():
+    """A proxy session inheriting ANY privileges: the warning must blame the
+    owner's grants, not the entrance; a clean proxy session warns not at all."""
+    dangerous = {"from session_privs": ([("PRIVILEGE",)],
+                                        [("DROP ANY TABLE",), ("SELECT ANY TABLE",)]),
+                 "proxy_user": ([("P",)], [("CORE_BH_AGENT",)])}
+    msg = pythia.privilege_warning(FakeConn(dangerous), "CORE_BH",
+                                   "core_bh_agent[core_bh]")
+    assert "Proxy session" in msg and "CORE_BH_AGENT" in msg
+    assert "owner holds" in msg and "DROP ANY TABLE" in msg
+    clean = {"from session_privs": ([("PRIVILEGE",)], []),
+             "proxy_user": ([("P",)], [("CORE_BH_AGENT",)])}
+    assert pythia.privilege_warning(FakeConn(clean), "CORE_BH",
+                                    "core_bh_agent[core_bh]") is None
+    # no proxy, direct owner: the original warning stands
+    direct = {"from session_privs": ([("PRIVILEGE",)], [])}
+    assert "schema owner" in pythia.privilege_warning(
+        FakeConn(direct), "APP", "APP")
+
+
+def test_journal_prune_keeps_applied_entries():
+    import argparse
+    import datetime
+    with tempfile.TemporaryDirectory() as td:
+        base = datetime.datetime(2026, 8, 26, 12, 0, 0)
+        pythia.write_journal_entry(td, "PROCEDURE", "P_PREVIEW", "a", "b",
+                                   {"applied": False}, now=base)
+        kept = pythia.write_journal_entry(
+            td, "PROCEDURE", "P_APPLIED", "a", "b", {"applied": True},
+            now=base.replace(minute=1))
+        ns = argparse.Namespace(action="prune", project_root=td, json=False,
+                                id=None)
+        import contextlib
+        import io
+        buf = io.StringIO()
+        with contextlib.redirect_stdout(buf):
+            pythia.cmd_journal(None, None, ns)
+        assert "pruned 1" in buf.getvalue()
+        assert pythia.list_journal_entries(td) == [kept]
+
+
 def main():
     failed = 0
     for name, fn in sorted(globals().items()):

{pythia_plsql-0.1.3 → pythia_plsql-0.2.0}/tests/test_phase5.py

@@ -10,9 +10,9 @@ import sys
 ROOT = pathlib.Path(__file__).resolve().parent.parent
 SKILLS = ROOT / "skills"
 
-EXPECTED = {"plsql-setup", "plsql-explore", "plsql-impact",
-            "plsql-write", "plsql-apply", "plsql-review",
-            "plsql-skill-author"}
+EXPECTED = {"pythia-setup", "pythia-explore", "pythia-impact",
+            "pythia-write", "pythia-apply", "pythia-review",
+            "pythia-skill-author"}
 
 # spec: SKILL.md under 150 lines, detail pushed to reference/
 MAX_LINES = 150
@@ -65,19 +65,19 @@ def test_skill_bodies_stay_within_budget():
 
 
 def test_apply_skill_keeps_the_honest_rollback_table():
-    path = SKILLS / "plsql-apply" / "SKILL.md"
+    path = SKILLS / "pythia-apply" / "SKILL.md"
     if not path.is_file():
         return
     text = path.read_text(encoding="utf-8")
     for needle in ("Yes — completely", "Flashback Query", "Recycle Bin",
                    "Almost never", "exit 3", "run-sql"):
-        assert needle in text, f"plsql-apply: missing {needle!r}"
+        assert needle in text, f"pythia-apply: missing {needle!r}"
 
 
 def test_reference_files_exist_where_promised():
-    for rel in ("plsql-explore/reference/data-dictionary.md",
-                "plsql-write/reference/patterns.md",
-                "plsql-review/reference/antipatterns.md"):
+    for rel in ("pythia-explore/reference/data-dictionary.md",
+                "pythia-write/reference/patterns.md",
+                "pythia-review/reference/antipatterns.md"):
         assert (SKILLS / rel).is_file(), f"missing {rel}"