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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythia-plsql
-Version: 0.1.3
+Version: 0.2.2
 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
@@ -121,7 +122,17 @@ 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).
+
+```bash
+pythia agent-user --save   # SQL for the DBA + matching credential saved as <conn>_agent
+pythia check               # after the DBA ran it: proxy session, warning gone
+```
+
+One run does both — the password is regenerated each run, so the SQL and the
+saved config must come from the same run. Optional convenience: doing it by
+hand with
+[`examples/agent-user-setup.example.sql`](examples/agent-user-setup.example.sql)
+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 +157,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.2}/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
@@ -107,7 +108,17 @@ 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).
+
+```bash
+pythia agent-user --save   # SQL for the DBA + matching credential saved as <conn>_agent
+pythia check               # after the DBA ran it: proxy session, warning gone
+```
+
+One run does both — the password is regenerated each run, so the SQL and the
+saved config must come from the same run. Optional convenience: doing it by
+hand with
+[`examples/agent-user-setup.example.sql`](examples/agent-user-setup.example.sql)
+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 +143,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.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pythia-plsql"
-version = "0.1.3"
+version = "0.2.2"
 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.2}/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))
@@ -1310,7 +1355,7 @@ AGENT_USER_SQL = """\
 -- privileges, utility grants — the agent needs none of them to develop
 -- PL/SQL, and every extra grant widens the blast radius.
 
-CREATE USER {agent} IDENTIFIED BY "{password}";
+{create_line}
 GRANT CREATE SESSION TO {agent};
 ALTER USER {owner} GRANT CONNECT THROUGH {agent};
 
@@ -1320,6 +1365,23 @@ ALTER USER {owner} GRANT CONNECT THROUGH {agent};
 """
 
 
+def agent_user_sql(owner, agent, password, exists):
+    """exists True: the user is already there — CREATE would be ORA-01920,
+    so reset the password and unlock in one statement (harmless if it was
+    never locked). exists None: no database to ask — emit CREATE plus the
+    fallback as a comment so the DBA can pick."""
+    if exists:
+        line = (f'ALTER USER {agent} IDENTIFIED BY "{password}" ACCOUNT '
+                f"UNLOCK;  -- user already exists; CREATE would be ORA-01920")
+    else:
+        line = f'CREATE USER {agent} IDENTIFIED BY "{password}";'
+        if exists is None:
+            line += ("\n-- (if the user already exists — ORA-01920 — run "
+                     "instead:\n--  ALTER USER "
+                     f'{agent} IDENTIFIED BY "{password}" ACCOUNT UNLOCK;)')
+    return AGENT_USER_SQL.format(owner=owner, agent=agent, create_line=line)
+
+
 def agent_password():
     """Random password satisfying common Oracle verify functions: letter
     first, upper+lower+digit+special, 16+ chars. Always quoted in SQL."""
@@ -1358,18 +1420,51 @@ def cmd_agent_user(conn, schema, ns):
                  f"({base['user']}) — nothing to set up.")
     agent = (ns.name or f"{owner}_AGENT").upper()
     password = agent_password()
-    print(AGENT_USER_SQL.format(owner=owner, agent=agent, password=password))
+    exists, dangerous = None, None
+    if conn is not None:
+        _, rows = run_query(conn, "select username from all_users "
+                                  "where username = :n", {"n": agent})
+        exists = bool(rows)
+        _, prows = run_query(conn, load_query("session-privileges.sql"))
+        dangerous = [r[0] for r in prows]
+    sql = agent_user_sql(owner, agent, password, exists)
+    saved = None
     if ns.save:
-        name = save_agent_connection(root, base_name, base, agent, password)
-        print(f"Saved connection '{name}' (now the default) in "
-              f"{pathlib.Path(root) / CONFIG_DIR / CONFIG_NAME};\n"
+        saved = save_agent_connection(root, base_name, base, agent, password)
+    if ns.json:
+        print(json.dumps({
+            "owner": owner, "agent": agent, "password": password, "sql": sql,
+            "agent_user_exists": exists, "saved_connection": saved,
+            "owner_connection": base_name,
+            "check_will_warn": bool(dangerous) if dangerous is not None else None,
+            "owner_dangerous_privs": dangerous,
+            "next": ["have a DBA run the sql", f"{invocation()} check"]}))
+        return
+    print(sql)
+    print("-- The password is regenerated on EVERY run — only the SQL from")
+    print("-- this exact run matches what --save writes. One run, not two.")
+    if dangerous:
+        print(f"\n! Even after this, {invocation()} check will STILL warn: "
+              f"the owner {owner} holds\n  {', '.join(dangerous[:3])}"
+              + ("…" if len(dangerous) > 3 else "")
+              + " — every proxy session inherits it.\n"
+              "  Trim the owner's grants to reach the no-warning goal state "
+              "(see README, Security).")
+    elif dangerous is not None:
+        print(f"\nOwner grants look clean: after the DBA runs this, "
+              f"{invocation()} check should pass with no warning.")
+    if saved:
+        print(f"\nSaved connection '{saved}' (now the default) in "
+              f"{pathlib.Path(root) / CONFIG_DIR / CONFIG_NAME} — its "
+              f"password matches the SQL above;\n"
               f"the owner entry '{base_name}' is untouched — switch back "
               f"any time with --conn {base_name}.")
-        print(f"\nNext: run the SQL above as a DBA, then: {invocation()} check")
+        print(f"\nNext: relay the SQL above to the developer verbatim for a "
+              f"DBA to run, then: {invocation()} check")
     else:
-        print(f"-- Rerun with --save to add this credential to "
-              f"connections.json as '{base_name}_agent' and make it the "
-              f"default once the DBA has run it.")
+        print(f"-- Nothing was saved. Use --save to also write this "
+              f"credential to connections.json as '{base_name}_agent' in "
+              f"the same run.")
 
 
 # unistr escapes. Single quote doubles to '' per SQL (a \' is ORA-01756 for
@@ -1460,20 +1555,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):
@@ -1503,8 +1609,7 @@ COMMANDS = {"check": cmd_check, "ls": cmd_ls, "src": cmd_src, "args": cmd_args,
             "conventions": cmd_conventions, "install": cmd_install,
             "unistr": cmd_unistr, "agent-user": cmd_agent_user}
 
-NO_DB_COMMANDS = {"policy", "journal", "conventions", "install", "unistr",
-                  "agent-user"}
+NO_DB_COMMANDS = {"policy", "journal", "conventions", "install", "unistr"}
 
 
 # --- CLI ---------------------------------------------------------------------
@@ -1584,7 +1689,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.2/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.2
 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
@@ -121,7 +122,17 @@ 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).
+
+```bash
+pythia agent-user --save   # SQL for the DBA + matching credential saved as <conn>_agent
+pythia check               # after the DBA ran it: proxy session, warning gone
+```
+
+One run does both — the password is regenerated each run, so the SQL and the
+saved config must come from the same run. Optional convenience: doing it by
+hand with
+[`examples/agent-user-setup.example.sql`](examples/agent-user-setup.example.sql)
+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 +157,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.2}/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.2/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.2/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.2/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.2/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.2/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),
@@ -41,8 +41,15 @@ connects *through* the schema owner. The agent never learns the owner's
 password, revocation is one statement, the audit trail shows who really
 connected, and the blast radius is the one development schema.
 
-Run `examples/agent-user-setup.example.sql` (as a DBA, names adapted), then
-set the connection's user to `"agent_user[schema_owner]"`.
+Run `pythia agent-user --save` — ONE run, in the project directory. It
+prints the three-statement proxy SQL with a generated password and saves
+the matching credential as connection `<conn>_agent` (the new default; the
+owner entry stays untouched). The password is regenerated on every run, so
+never preview first and save later — the SQL and the saved config must
+come from the same run. Relay the SQL to the developer verbatim for a DBA
+to execute, then verify with `pythia check`. `--json` gives the same
+result machine-readable. Manual alternative:
+`examples/agent-user-setup.example.sql`, names adapted.
 
 Oracle's own guidance for LLM access, follow it: grant minimum privileges,
 never point an LLM at a production database, audit its activity regularly.

{pythia_plsql-0.1.3/skills/plsql-skill-author → pythia_plsql-0.2.2/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.2/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.2}/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,39 @@ 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_agent_user_json_saves_the_same_password_it_prints():
+    """The agent flow: one --json --save run must be self-consistent — the
+    password inside the SQL is the password written to connections.json."""
+    import argparse
+    import contextlib
+    import io
+    import os
+    with tempfile.TemporaryDirectory() as td:
+        root = pathlib.Path(td)
+        (root / ".pythia").mkdir()
+        (root / ".pythia" / "connections.json").write_text(json.dumps(
+            {"dev": {"host": "h", "port": 1521, "service_name": "s",
+                     "user": "OWNER", "password": "p", "schema": "OWNER"}}),
+            encoding="utf-8")
+        cwd = os.getcwd()
+        os.chdir(td)
+        try:
+            ns = argparse.Namespace(conn=None, json=True, save=True, name=None)
+            buf = io.StringIO()
+            with contextlib.redirect_stdout(buf):
+                pythia.cmd_agent_user(None, None, ns)
+            d = json.loads(buf.getvalue())
+            assert d["saved_connection"] == "dev_agent"
+            assert d["password"] in d["sql"]
+            cfg = json.loads((root / ".pythia" / "connections.json")
+                             .read_text(encoding="utf-8"))
+            assert cfg["dev_agent"]["password"] == d["password"]
+            assert cfg["dev"]["password"] == "p"        # owner untouched
+        finally:
+            os.chdir(cwd)
 
 
 def test_one_version_across_every_manifest():

{pythia_plsql-0.1.3 → pythia_plsql-0.2.2}/tests/test_phase1.py

@@ -254,8 +254,7 @@ def test_to_unistr():
 
 
 def test_agent_user_sql_is_least_privilege():
-    sql = pythia.AGENT_USER_SQL.format(owner="APP", agent="APP_AGENT",
-                                       password="x")
+    sql = pythia.agent_user_sql("APP", "APP_AGENT", "x", exists=False)
     assert "CREATE USER APP_AGENT" in sql
     assert "GRANT CREATE SESSION TO APP_AGENT" in sql
     assert "GRANT CONNECT THROUGH APP_AGENT" in sql

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

@@ -489,6 +489,108 @@ 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 test_agent_user_alter_form_and_warning_prediction():
+    """DB-aware agent-user: an existing agent user gets the ALTER+UNLOCK
+    form (CREATE would be ORA-01920), and a dirty owner is called out —
+    check will STILL warn — before the DBA runs anything."""
+    import argparse
+    import contextlib
+    import io
+    import os
+    script = {"from all_users": ([("USERNAME",)], [("APP_AGENT",)]),
+              "from session_privs": ([("PRIVILEGE",)], [("DROP ANY TABLE",)])}
+    with tempfile.TemporaryDirectory() as td:
+        (pathlib.Path(td) / ".pythia").mkdir()
+        (pathlib.Path(td) / ".pythia" / "connections.json").write_text(
+            json.dumps({"dev": {"host": "h", "user": "APP", "password": "p",
+                                "schema": "APP"}}), encoding="utf-8")
+        cwd = os.getcwd()
+        os.chdir(td)
+        try:
+            ns = argparse.Namespace(conn=None, json=True, save=False, name=None)
+            buf = io.StringIO()
+            with contextlib.redirect_stdout(buf):
+                pythia.cmd_agent_user(FakeConn(script), "APP", ns)
+            d = json.loads(buf.getvalue())
+        finally:
+            os.chdir(cwd)
+        assert d["agent_user_exists"] is True
+        assert "ALTER USER APP_AGENT IDENTIFIED BY" in d["sql"]
+        assert "ACCOUNT UNLOCK" in d["sql"]
+        assert "CREATE USER" not in d["sql"]
+        assert d["check_will_warn"] is True
+        assert d["owner_dangerous_privs"] == ["DROP ANY TABLE"]
+
+
 def main():
     failed = 0
     for name, fn in sorted(globals().items()):

{pythia_plsql-0.1.3 → pythia_plsql-0.2.2}/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}"