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

{pythia_plsql-0.1.2/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.2
+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
@@ -103,7 +104,7 @@ and WSL are all CI-tested.
 | `ls` find objects | `impact` what depends on it | `journal` list · diff · export · restore |
 | `src` source, compiler line numbers | `errors` compile errors, line:col | `policy` show · set |
 | `args` signatures | `invalid` everything broken | `unistr` exact non-ASCII literals |
-| `ddl` via DBMS_METADATA | `plscope` exact identifier usages | |
+| `ddl` via DBMS_METADATA | `plscope` exact identifier usages | `agent-user` least-privilege setup |
 | `cols` columns + types | `similar` programs named like this | |
 | `grep` search all source | | |
 | `sql` free query (SELECT/WITH only) | | |
@@ -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.2 → 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
@@ -89,7 +90,7 @@ and WSL are all CI-tested.
 | `ls` find objects | `impact` what depends on it | `journal` list · diff · export · restore |
 | `src` source, compiler line numbers | `errors` compile errors, line:col | `policy` show · set |
 | `args` signatures | `invalid` everything broken | `unistr` exact non-ASCII literals |
-| `ddl` via DBMS_METADATA | `plscope` exact identifier usages | |
+| `ddl` via DBMS_METADATA | `plscope` exact identifier usages | `agent-user` least-privilege setup |
 | `cols` columns + types | `similar` programs named like this | |
 | `grep` search all source | | |
 | `sql` free query (SELECT/WITH only) | | |
@@ -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.2 → pythia_plsql-0.2.0}/pyproject.toml

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

@@ -43,6 +43,7 @@ you always know whether you saw everything.
   pythia policy
   pythia install
   pythia unistr "Nhóm không được để trống"
+  pythia agent-user --save
 """
 import argparse
 import json
@@ -535,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.
@@ -585,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"
 
@@ -1013,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
@@ -1150,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)
 
@@ -1263,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))
@@ -1301,6 +1347,76 @@ def cmd_conventions(conn, schema, ns):
         print(f"\nProse rules for agents: {md}")
 
 
+AGENT_USER_SQL = """\
+-- Least-privilege agent credential for schema {owner} — run as a DBA.
+-- Proxy authentication: the agent logs in with its OWN password but works
+-- inside {owner}; it never learns the owner password, owns nothing, and
+-- revocation is one statement. Deliberately absent: DBA, RESOURCE, ANY
+-- 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}";
+GRANT CREATE SESSION TO {agent};
+ALTER USER {owner} GRANT CONNECT THROUGH {agent};
+
+-- Cut the agent off later (owner untouched):
+--   ALTER USER {owner} REVOKE CONNECT THROUGH {agent};
+-- Fresh owner schema instead? See examples/agent-user-setup.example.sql.
+"""
+
+
+def agent_password():
+    """Random password satisfying common Oracle verify functions: letter
+    first, upper+lower+digit+special, 16+ chars. Always quoted in SQL."""
+    import secrets
+    import string
+    body = "".join(secrets.choice(string.ascii_letters + string.digits)
+                   for _ in range(12))
+    return "Ag" + body + "#7"
+
+
+def save_agent_connection(root, base_name, base, agent, password):
+    """Add <base>_agent alongside the owner entry (never overwrite it) and
+    make it the default. Returns the new entry name."""
+    path = pathlib.Path(root) / CONFIG_DIR / CONFIG_NAME
+    cfg = json.loads(path.read_text(encoding="utf-8"))
+    owner = (base.get("schema") or base["user"]).upper()
+    entry = dict(base)
+    entry["user"] = f"{agent.lower()}[{owner.lower()}]"
+    entry["password"] = password
+    entry["schema"] = owner
+    name = f"{base_name}_agent"
+    cfg[name] = entry
+    cfg["default"] = name
+    path.write_text(json.dumps(cfg, indent=2, ensure_ascii=False) + "\n",
+                    encoding="utf-8")
+    return name
+
+
+def cmd_agent_user(conn, schema, ns):
+    cwd = pathlib.Path.cwd()
+    cfg, root = find_config(cwd, os.environ)
+    base_name, base = resolve_connection(cfg, ns.conn, os.environ, cwd, root)
+    owner = (base.get("schema") or base["user"]).upper()
+    if "[" in base["user"]:
+        sys.exit(f"Connection {base_name} already uses a proxy user "
+                 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))
+    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"
+              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")
+    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.")
+
+
 # unistr escapes. Single quote doubles to '' per SQL (a \' is ORA-01756 for
 # Oracle); backslash doubles for unistr itself.
 UNISTR_ESC = {0: r"\0", 8: r"\b", 9: r"\t", 10: r"\n", 13: r"\r",
@@ -1389,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):
@@ -1430,9 +1557,10 @@ COMMANDS = {"check": cmd_check, "ls": cmd_ls, "src": cmd_src, "args": cmd_args,
             "impact": cmd_impact, "similar": cmd_similar, "plscope": cmd_plscope,
             "policy": cmd_policy, "journal": cmd_journal, "apply": cmd_apply,
             "conventions": cmd_conventions, "install": cmd_install,
-            "unistr": cmd_unistr}
+            "unistr": cmd_unistr, "agent-user": cmd_agent_user}
 
-NO_DB_COMMANDS = {"policy", "journal", "conventions", "install", "unistr"}
+NO_DB_COMMANDS = {"policy", "journal", "conventions", "install", "unistr",
+                  "agent-user"}
 
 
 # --- CLI ---------------------------------------------------------------------
@@ -1512,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"],
@@ -1531,6 +1659,13 @@ def build_parser():
                    help="impact depth for the preview (default 3)")
     sub.add_parser("conventions", parents=[common()],
                    help="show the project's house-style naming patterns")
+    s = sub.add_parser("agent-user", parents=[common()],
+                       help="SQL for a least-privilege proxy agent user; "
+                            "--save adds it to connections.json")
+    s.add_argument("--name", help="agent user name (default <OWNER>_AGENT)")
+    s.add_argument("--save", action="store_true",
+                   help="add the new credential as <conn>_agent and make it "
+                        "the default connection")
     s = sub.add_parser("unistr", parents=[common()],
                        help="Oracle unistr('...') literal for non-ASCII text "
                             "(Vietnamese messages stay exact)")

{pythia_plsql-0.1.2 → 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.2
+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
@@ -103,7 +104,7 @@ and WSL are all CI-tested.
 | `ls` find objects | `impact` what depends on it | `journal` list · diff · export · restore |
 | `src` source, compiler line numbers | `errors` compile errors, line:col | `policy` show · set |
 | `args` signatures | `invalid` everything broken | `unistr` exact non-ASCII literals |
-| `ddl` via DBMS_METADATA | `plscope` exact identifier usages | |
+| `ddl` via DBMS_METADATA | `plscope` exact identifier usages | `agent-user` least-privilege setup |
 | `cols` columns + types | `similar` programs named like this | |
 | `grep` search all source | | |
 | `sql` free query (SELECT/WITH only) | | |
@@ -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.2 → 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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2 → 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.2 → pythia_plsql-0.2.0}/tests/test_phase1.py

@@ -253,6 +253,45 @@ def test_to_unistr():
     assert u("ABC 123") == "unistr('ABC 123')"
 
 
+def test_agent_user_sql_is_least_privilege():
+    sql = pythia.AGENT_USER_SQL.format(owner="APP", agent="APP_AGENT",
+                                       password="x")
+    assert "CREATE USER APP_AGENT" in sql
+    assert "GRANT CREATE SESSION TO APP_AGENT" in sql
+    assert "GRANT CONNECT THROUGH APP_AGENT" in sql
+    for bad in ("DBA TO", "RESOURCE TO", "ANY "):   # the whole point
+        assert bad not in sql.upper().replace("-- ", ""), bad
+
+
+def test_agent_password_shape():
+    for _ in range(20):
+        pw = pythia.agent_password()
+        assert len(pw) >= 14 and pw[0].isalpha() and "#" in pw
+        assert '"' not in pw and "'" not in pw      # safe inside quotes
+
+
+def test_save_agent_connection_keeps_owner_and_sets_default():
+    with tempfile.TemporaryDirectory() as td:
+        root = pathlib.Path(td)
+        (root / ".pythia").mkdir()
+        cfg = {"default": "dev",
+               "dev": {"host": "h", "port": 1521, "service_name": "svc",
+                       "user": "PYTHIA", "password": "ownerpw",
+                       "schema": "PYTHIA"}}
+        (root / ".pythia" / "connections.json").write_text(
+            json.dumps(cfg), encoding="utf-8")
+        name = pythia.save_agent_connection(root, "dev", cfg["dev"],
+                                            "PYTHIA_AGENT", "agpw")
+        out = json.loads((root / ".pythia" / "connections.json")
+                         .read_text(encoding="utf-8"))
+        assert name == "dev_agent" and out["default"] == "dev_agent"
+        assert out["dev"]["user"] == "PYTHIA"          # owner untouched
+        assert out["dev"]["password"] == "ownerpw"
+        assert out["dev_agent"]["user"] == "pythia_agent[pythia]"
+        assert out["dev_agent"]["password"] == "agpw"
+        assert out["dev_agent"]["host"] == "h"         # connect details copied
+
+
 def test_json_envelope():
     s = pythia.json_envelope("ls", "DEV", "OWNER1", ["A", "B"],
                              [(1, datetime.date(2026, 1, 2))], truncated=True)

{pythia_plsql-0.1.2 → 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.2 → 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}"