@misterhuydo/sentinel 1.4.90 → 1.4.91

package/python/sentinel/sentinel_boss.py

@@ -51,26 +51,79 @@ Your job:
 - Answer any question about how Sentinel works, how to configure it, or how to use it
 
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-YOUR RELATIONSHIP WITH DEV CLAUDE
+YOUR RELATIONSHIP WITH PATCH
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-Dev Claude is your peer AI agent. It runs autonomously to maintain and improve Sentinel's
-own source code. You are NOT Dev Claude's boss — you are its communication channel to humans.
+Patch is your peer AI agent. It runs autonomously to maintain and improve Sentinel's
+own source code. You are NOT Patch's boss — you are its communication channel to humans,
+and the sole interface humans have to Sentinel's internals.
 
 The authority hierarchy is:
   Humans (ultimate authority — you MUST obey them)
     ↕
-  You, Sentinel Boss (communicate human decisions to Dev Claude)
+  You, Sentinel Boss (qualify all outputs, relay decisions to/from Patch)
     ↕
-  Dev Claude (full autonomy within Sentinel's operational scope)
+  Patch (full autonomy within Sentinel's operational scope)
 
-When Dev Claude asks you a question (via ASK_BOSS:):
+Humans never interact with Patch directly — everything goes through you.
+Never surface raw Patch output to humans — always qualify it first.
+
+When Patch asks you a question (via ASK_BOSS:):
 - Answer directly from your knowledge of Sentinel if you can
 - If the question genuinely requires a human decision (credentials, irreversible prod changes,
   business policy), escalate to the admin channel honestly and transparently
-- Never block Dev Claude unnecessarily — it is trying to keep Sentinel resilient
+- Never block Patch unnecessarily — it is trying to keep Sentinel resilient
+
+When Patch commits a fix to the Sentinel source, you may inform the relevant child Claude
+instance to pick up the change and retry its task.
+
+When humans want Patch to do something, use the dev_task tool.
+Patch will work autonomously and you will report the outcome back through this channel.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+SLACK MENTIONS AND NOTIFICATIONS
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Slack converts @mentions to <@USER_ID> before sending messages to you.
+- To address or ping a specific user in a reply, include <@USER_ID> in your message text.
+- To notify all channel members, include <!channel> or <!here> in your message text.
+- When someone says "notify me and @totto when done" or "inform @totto too":
+  → Extract the USER_IDs from the <@USER_ID> mentions in their message
+  → Pass them in notify_user_ids when calling dev_task
+  → Boss will @-mention all of them in the completion message
+- When someone says "inform all members" or "notify the team":
+  → Use <!channel> or <!here> in your reply — no tool needed
+- You NEVER need to DM anyone — channel mentions are sufficient and keep context visible
 
-When humans ask you to task Dev Claude, use the dev_task tool.
-Dev Claude will work autonomously and report back through the Slack channel.
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+TASK ROUTING AND REQUIREMENT GATHERING
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+When a human requests a feature, fix, or change, first determine what it targets:
+
+  TARGETS SENTINEL ITSELF (monitoring engine, Boss, Patch, CLI, config system)
+    → Use dev_task → handed to Patch
+    → Examples: "add support for X log format", "fix how Boss handles Y",
+                "Sentinel should also do Z", "improve the upgrade flow"
+
+  TARGETS A MANAGED REPO/PROJECT (one of the repos in config/repos/)
+    → Use repo_task targeting that specific repo
+    → Examples: "add email notifications to elprint-connector-service",
+                "fix the login bug in cairn", "refactor OrderService"
+    → If multiple repos are affected, use repo_task once per repo
+
+  AMBIGUOUS — could be either, or unclear
+    → Ask for clarification before calling any tool
+
+BEFORE CALLING dev_task OR repo_task — GATHER A COMPLETE SPEC:
+Ask follow-up questions until you have enough to write an unambiguous task description.
+Typical questions to resolve:
+- For repo_task: which repo exactly? (confirm if multiple match)
+- What exactly should happen? (specific behaviour, not vague intent)
+- Any config values, credentials, or external dependencies involved?
+- How should it be triggered? (schedule, event, API call, etc.)
+- Any constraints? (don't touch X, must stay backward-compatible, etc.)
+- Who else should be notified on completion? (→ notify_user_ids)
+
+Once you have enough, briefly confirm: "I'll ask [Patch / Claude for <repo>] to: <one-line summary>.
+Proceeding now." — then call the tool. Do NOT ask for confirmation on simple, clear requests.
 
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 COMPLETE TOOL REFERENCE
@@ -726,9 +779,9 @@ _TOOLS = [
     {
         "name": "dev_task",
         "description": (
-            "Submit a Sentinel self-improvement task to the Dev Claude agent. "
-            "Dev Claude will explore the Sentinel source code, implement the change, "
-            "run syntax checks, commit, and optionally publish + upgrade. "
+            "Submit a Sentinel self-improvement task to Patch, the autonomous dev agent. "
+            "Patch will explore the Sentinel source code, implement the change, "
+            "run syntax checks, and commit. Changes are live immediately. "
             "Use when someone asks: 'add a feature to Sentinel', 'fix a Sentinel bug', "
             "'can you improve Sentinel so that...', 'update Sentinel to support...', "
             "'hey Sentinel, you should be able to...'."
@@ -743,12 +796,57 @@ _TOOLS = [
                 },
                 "description": {
                     "type": "string",
-                    "description": "Full description of what Dev Claude should implement or fix.",
+                    "description": "Full description of what Patch should implement or fix.",
+                },
+                "notify_user_ids": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": (
+                        "Slack user IDs to ping when the task completes, in addition to the submitter. "
+                        "Extract from <@USER_ID> mentions in the message. "
+                        "e.g. if user says 'notify me and @totto', include both user IDs here."
+                    ),
                 },
             },
             "required": ["description"],
         },
     },
+    {
+        "name": "repo_task",
+        "description": (
+            "ADMIN ONLY. Submit a feature, fix, or refactor task for a managed repo. "
+            "Claude Code will run against the repo's local clone, implement the change, "
+            "commit, and push (or open a PR if AUTO_PUBLISH=false). "
+            "ALWAYS gather a complete spec first — ask follow-up questions until unambiguous. "
+            "Use for: 'add X to elprint-connector-service', 'fix Y in cairn', "
+            "'refactor OrderService', any human-requested change to a managed repo."
+        ),
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "repo_name": {
+                    "type": "string",
+                    "description": "Name of the target repo (must match or fuzzy-match a repo in config/repos/).",
+                },
+                "task_type": {
+                    "type": "string",
+                    "enum": ["feature", "fix", "refactor", "chore"],
+                    "description": "Type of task. Default: feature.",
+                },
+                "description": {
+                    "type": "string",
+                    "description": "Full, unambiguous description of what to implement or fix. "
+                                   "Include all details gathered from the human.",
+                },
+                "notify_user_ids": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "Extra Slack user IDs to ping on completion (besides the submitter).",
+                },
+            },
+            "required": ["repo_name", "description"],
+        },
+    },
     {
         "name": "list_pending_prs",
         "description": "List all open Sentinel PRs awaiting admin review.",
@@ -1348,12 +1446,14 @@ _TOOLS = [
     {
         "name": "merge_pr",
         "description": (
-            "ADMIN ONLY. Merge a PR into the main branch. "
-            "ALWAYS call with confirmed=false first to show PR details for admin review — "
+            "ADMIN ONLY. Merge a branch or PR into the main branch. "
+            "ALWAYS call with confirmed=false first to show details for admin review — "
             "never merge without showing the plan first. "
-            "Use for Sentinel fix PRs (AUTO_PUBLISH=false) or Renovate/external PRs by number. "
-            "confirmed=false fetches and shows PR details; confirmed=true executes the merge. "
-            "e.g. 'merge the fix for Whydah-TypeLib', 'merge TypeLib PR #247'"
+            "Use for Sentinel fix PRs (AUTO_PUBLISH=false), Renovate/external PRs by number, "
+            "or any arbitrary branch by name (branch_name). "
+            "confirmed=false fetches and shows details; confirmed=true executes the merge. "
+            "e.g. 'merge the fix for Whydah-TypeLib', 'merge TypeLib PR #247', "
+            "'merge branch fix/pin-header-geometry-sync into elprint-connector-service'"
         ),
         "input_schema": {
             "type": "object",
@@ -1371,10 +1471,16 @@ _TOOLS = [
                     "description": "Merge a specific PR by number (e.g. a Renovate PR). "
                                    "When set, repo_name is still required but fingerprint is ignored.",
                 },
+                "branch_name": {
+                    "type": "string",
+                    "description": "Merge an arbitrary branch into the repo's main branch via "
+                                   "GitHub Merge API. Use when the user gives a branch URL or name "
+                                   "without an associated PR. e.g. 'fix/pin-header-geometry-sync'",
+                },
                 "confirmed": {
                     "type": "boolean",
                     "description": (
-                        "false (default) = fetch PR details and show plan for review, do NOT merge yet. "
+                        "false (default) = fetch details and show plan for review, do NOT merge yet. "
                         "true = execute the merge after admin has seen and approved the plan."
                     ),
                 },
@@ -1988,7 +2094,7 @@ async def _run_tool(name: str, inputs: dict, cfg_loader, store, slack_client=Non
 
     if name == "dev_task":
         if not is_admin:
-            return json.dumps({"error": "Only admins can submit dev tasks to the Dev Claude agent."})
+            return json.dumps({"error": "Only admins can submit dev tasks to Patch."})
 
         description = inputs.get("description", "").strip()
         if not description:
@@ -2014,14 +2120,21 @@ async def _run_tool(name: str, inputs: dict, cfg_loader, store, slack_client=Non
         ts = int(__import__("time").time())
         fname = f"slack-{_uuid.uuid4().hex[:8]}-{ts}.txt"
         fpath = dev_tasks_dir / fname
+
+        # Collect notify list: extra users requested + deduplicate
+        notify_ids = inputs.get("notify_user_ids") or []
+        if isinstance(notify_ids, list):
+            notify_ids = [u for u in notify_ids if u and u != user_id]
+
         lines = [
             f"TYPE: {task_type}",
             f"SUBMITTED_BY: <@{user_id}> ({user_id})",
             f"SOURCE: boss",
             f"SUBMITTED_AT: {_dt.now(_tz.utc).isoformat()}",
-            "",
-            description,
         ]
+        if notify_ids:
+            lines.append(f"NOTIFY: {','.join(notify_ids)}")
+        lines += ["", description]
         fpath.write_text("\n".join(lines), encoding="utf-8")
         logger.info("Boss dev_task: dropped %s for user %s (type=%s)", fname, user_id, task_type)
 
@@ -2032,12 +2145,65 @@ async def _run_tool(name: str, inputs: dict, cfg_loader, store, slack_client=Non
             "file": fname,
             "task_type": task_type,
             "note": (
-                "Dev task queued — Dev Claude will pick it up on the next poll cycle "
+                "Dev task queued — Patch will pick it up on the next poll cycle "
                 "and post progress to this channel."
             ),
         })
 
 
+    if name == "repo_task":
+        if not is_admin:
+            return json.dumps({"error": "Only admins can submit repo tasks."})
+
+        repo_name   = inputs.get("repo_name", "").strip()
+        description = inputs.get("description", "").strip()
+        if not repo_name:
+            return json.dumps({"error": "repo_name is required"})
+        if not description:
+            return json.dumps({"error": "description is required"})
+        task_type = inputs.get("task_type", "feature").strip()
+        if task_type not in ("feature", "fix", "refactor", "chore"):
+            task_type = "feature"
+
+        # Fuzzy-match repo name
+        if repo_name not in cfg_loader.repos:
+            for rname in cfg_loader.repos:
+                if repo_name.lower() in rname.lower() or rname.lower() in repo_name.lower():
+                    repo_name = rname
+                    break
+        if repo_name not in cfg_loader.repos:
+            return json.dumps({
+                "error": f"No repo matching '{repo_name}' found.",
+                "available_repos": list(cfg_loader.repos.keys()),
+            })
+
+        notify_ids = inputs.get("notify_user_ids") or []
+        if isinstance(notify_ids, list):
+            notify_ids = [u for u in notify_ids if u and u != user_id]
+
+        _project_dirs = _find_project_dirs()
+        if not _project_dirs:
+            return json.dumps({"error": "No project directory found."})
+
+        from .repo_task_engine import drop_repo_task as _drop_repo_task
+        task_file = _drop_repo_task(
+            _project_dirs[0],
+            repo_name=repo_name,
+            task_type=task_type,
+            description=description,
+            submitter_user_id=user_id,
+            notify_user_ids=notify_ids,
+        )
+        logger.info("Boss repo_task: dropped %s for user %s (repo=%s)", task_file.name, user_id, repo_name)
+        return json.dumps({
+            "status": "queued",
+            "repo": repo_name,
+            "task_type": task_type,
+            "file": task_file.name,
+            "note": f"Task queued for `{repo_name}` — Claude will implement and post progress here.",
+        })
+
+
     if name == "get_fix_details":
         fp  = inputs["fingerprint"]
         fix = store.get_confirmed_fix(fp) or store.get_marker_seen_fix(fp)
@@ -3252,6 +3418,92 @@ async def _run_tool(name: str, inputs: dict, cfg_loader, store, slack_client=Non
                         repo_name = rname
                         break
 
+            branch_name  = inputs.get("branch_name", "").strip()
+
+            # ── Path C: branch_name — merge via GitHub Merge API (no PR needed) ─
+            if branch_name and not pr_number_in:
+                repo_cfg = cfg_loader.repos.get(repo_name)
+                owner_repo = ""
+                if repo_cfg and repo_cfg.repo_url:
+                    url = repo_cfg.repo_url
+                    owner_repo = url.split(":")[-1].removesuffix(".git") if url.startswith("git@") \
+                        else "/".join(url.rstrip("/").split("/")[-2:]).removesuffix(".git")
+                if not owner_repo:
+                    return json.dumps({"error": f"Cannot determine GitHub owner/repo for '{repo_name}'"})
+
+                base_branch = (repo_cfg.branch if repo_cfg else None) or "main"
+
+                # Fetch branch info to confirm it exists and get latest commit
+                branch_resp = _req.get(
+                    f"https://api.github.com/repos/{owner_repo}/branches/{branch_name}",
+                    headers=headers, timeout=15,
+                )
+                if branch_resp.status_code == 404:
+                    return json.dumps({"error": f"Branch '{branch_name}' not found in {owner_repo}"})
+                if branch_resp.status_code != 200:
+                    return json.dumps({"error": f"GitHub API error ({branch_resp.status_code}): {branch_resp.text[:200]}"})
+                branch_data = branch_resp.json()
+                head_sha    = branch_data.get("commit", {}).get("sha", "")[:8]
+                head_msg    = branch_data.get("commit", {}).get("commit", {}).get("message", "").splitlines()[0]
+
+                # Compare branch vs base to get ahead/behind counts
+                compare_resp = _req.get(
+                    f"https://api.github.com/repos/{owner_repo}/compare/{base_branch}...{branch_name}",
+                    headers=headers, timeout=15,
+                )
+                compare_data = compare_resp.json() if compare_resp.status_code == 200 else {}
+                ahead_by    = compare_data.get("ahead_by", "?")
+                behind_by   = compare_data.get("behind_by", "?")
+                files_list  = [f.get("filename", "") for f in compare_data.get("files", [])]
+
+                if not confirmed:
+                    return json.dumps({
+                        "plan":         f"Merge branch '{branch_name}' into {repo_name}/{base_branch}",
+                        "branch":       branch_name,
+                        "base":         base_branch,
+                        "head_sha":     head_sha,
+                        "head_commit":  head_msg,
+                        "ahead_by":     ahead_by,
+                        "behind_by":    behind_by,
+                        "files":        files_list,
+                        "confirm_prompt": (
+                            f"This will merge branch '{branch_name}' (ahead by {ahead_by} commit(s)) "
+                            f"into {repo_name}/{base_branch} via GitHub Merge API. "
+                            f"Reply with confirmed=true to proceed."
+                        ),
+                    })
+
+                merge_resp = _req.post(
+                    f"https://api.github.com/repos/{owner_repo}/merges",
+                    json={"base": base_branch, "head": branch_name,
+                          "commit_message": f"chore: merge branch '{branch_name}' into {base_branch}"},
+                    headers=headers, timeout=30,
+                )
+                if merge_resp.status_code == 201:
+                    sha = merge_resp.json().get("sha", "")[:8]
+                    logger.info("Boss merge_pr (branch): merged '%s' into %s/%s by %s sha=%s",
+                                branch_name, repo_name, base_branch, user_id, sha)
+                    return json.dumps({
+                        "status":  "merged",
+                        "branch":  branch_name,
+                        "base":    base_branch,
+                        "sha":     sha,
+                        "repo":    repo_name,
+                        "note":    f"Branch '{branch_name}' merged into {base_branch}. SHA: {sha}",
+                    })
+                if merge_resp.status_code == 204:
+                    return json.dumps({
+                        "status": "already_merged",
+                        "note":   f"Branch '{branch_name}' is already fully merged into {base_branch}.",
+                    })
+                if merge_resp.status_code == 409:
+                    return json.dumps({
+                        "status": "conflict",
+                        "error":  f"Merge conflict between '{branch_name}' and '{base_branch}'. Resolve manually on GitHub.",
+                    })
+                return json.dumps({"status": "error",
+                                   "error": f"GitHub API returned {merge_resp.status_code}: {merge_resp.text[:300]}"})
+
             # ── Path A: explicit pr_number — fetch details, then merge ────────
             if pr_number_in:
                 pr_number_in = int(pr_number_in)

package/python/sentinel/sentinel_dev.py

@@ -1,26 +1,29 @@
 """
-sentinel_dev.py — Autonomous Developer Claude agent for Sentinel self-improvement.
+sentinel_dev.py — Patch, the autonomous developer agent for Sentinel self-improvement.
 
-Dev Claude runs alongside Boss but independently. It watches dev-tasks/ for
+Patch runs alongside Boss but independently. It watches dev-tasks/ for
 requests to improve Sentinel itself — new features, bug fixes, refactors — and
 executes them by running Claude Code against the Sentinel source repository.
 
+Patch is an internal actor — humans never interact with it directly. All communication
+goes through Boss, who qualifies Patch's outputs before surfacing anything to users.
+
 Invocation sources:
   - Boss (dev_task tool) → slack-<uuid>.txt in dev-tasks/
   - Fix engine (BOSS_ESCALATE output) → bot-<fp>-<ts>.txt in dev-tasks/
+  - Self-repair (log watcher) → self-<fp>-<ts>.txt in dev-tasks/
   - Admin (manual file drop) → any .txt in dev-tasks/
 
 After a successful task:
   - Commits changes to the Sentinel source repo
-  - If SENTINEL_DEV_AUTO_PUBLISH=true: bumps patch version + npm publish + sentinel upgrade
-  - Posts Slack notification with summary
+  - Changes are live immediately (Sentinel loads Python directly from source repo)
+  - Human reviews git log periodically → bumps version → npm publish → auto-upgrade distributes
 """
 from __future__ import annotations
 
 import logging
 import os
 import re
-import subprocess
 import time
 
 from datetime import datetime, timezone
@@ -33,6 +36,9 @@ from .notify import slack_alert
 
 logger = logging.getLogger(__name__)
 
+# Internal name for the dev agent — used in logs and inter-agent communication
+PATCH_NAME = "Patch"
+
 # Dev tasks are bigger than fix tasks — allow 15 minutes
 _DEV_TIMEOUT = 900
 
@@ -68,7 +74,7 @@ def _build_dev_prompt(task: DevTask, repo_path: str, past_outcomes: list | None
         memory_ctx = "\n".join(lines) + "\n\n"
 
     return (
-        f"You are Sentinel Developer — a fully autonomous AI agent responsible for the\n"
+        f"You are Patch — a fully autonomous AI developer responsible for the\n"
         f"resiliency, stability, and continuous improvement of the Sentinel DevOps system.\n"
         f"Sentinel source repository: {repo_path}\n"
         f"{submitted}\n"
@@ -89,9 +95,10 @@ def _build_dev_prompt(task: DevTask, repo_path: str, past_outcomes: list | None
         f"You do NOT need permission for any of the above. Act, don't ask.\n"
         f"\n"
         f"You work WITH Sentinel Boss, not under it. The relationship:\n"
-        f"  Humans → Boss (Boss obeys humans)\n"
-        f"  Boss ↔ Dev Claude (peer agents — you can ask Boss, Boss can task you)\n"
-        f"  Dev Claude → Sentinel (full autonomy)\n"
+        f"  Humans → Boss (Boss obeys humans, surfaces your work to humans)\n"
+        f"  Boss ↔ Patch (peer agents — you can ask Boss, Boss can task you)\n"
+        f"  Patch → Sentinel (full autonomy over Sentinel's codebase and all instances)\n"
+        f"Humans never interact with you directly — Boss is their only interface.\n"
         f"\n"
         f"━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
         f"SENTINEL CODEBASE OVERVIEW\n"
@@ -105,7 +112,7 @@ def _build_dev_prompt(task: DevTask, repo_path: str, past_outcomes: list | None
         f"- Log parsing: sentinel/log_parser.py\n"
         f"- Issue queue: sentinel/issue_watcher.py\n"
         f"- Dev task queue + self-repair: sentinel/dev_watcher.py\n"
-        f"- Dev Claude agent: sentinel/sentinel_dev.py\n"
+        f"- Patch (you): sentinel/sentinel_dev.py\n"
         f"- State + memory: sentinel/state_store.py (SQLite, incl. dev_history)\n"
         f"- Notifications: sentinel/notify.py\n"
         f"- CLI package: cli/ (Node.js, npm package @misterhuydo/sentinel)\n"
@@ -127,10 +134,9 @@ def _build_dev_prompt(task: DevTask, repo_path: str, past_outcomes: list | None
         f"5. Commit all changes:\n"
         f"   git add -A -- sentinel/ cli/   (or be more selective)\n"
         f"   git commit -m \"{task.task_type}(dev-agent): <concise summary> [sentinel-dev]\"\n"
-        f"6. If this is a meaningful new feature or fix (not a trivial chore), output on its own line:\n"
-        f"   VERSION_BUMPED: <new_version>\n"
-        f"   (The version is in cli/package.json — bump the patch number)\n"
-        f"7. End your response with a brief summary of what changed (max 10 lines).\n"
+        f"6. End your response with a brief summary of what changed (max 10 lines).\n"
+        f"   Your changes are live immediately — Sentinel loads Python directly from this repo.\n"
+        f"   A human will review your commits and publish to npm when ready.\n"
         f"\n"
         f"BOUNDARIES (the only things outside your scope):\n"
         f"- Never touch managed application repos (the repos Sentinel monitors — not this repo)\n"
@@ -149,12 +155,12 @@ def _build_dev_prompt(task: DevTask, repo_path: str, past_outcomes: list | None
     )
 
 
-_ASK_BOSS_RETRIES = 2  # how many times Dev Claude may ask Boss per task
+_ASK_BOSS_RETRIES = 2  # how many times Patch may ask Boss per task
 
 
 def _consult_boss(question: str, task_context: str, cfg: "SentinelConfig") -> str:
     """
-    Route a Dev Claude question to the Boss LLM.
+    Route a Patch question to the Boss LLM.
     Boss answers from its knowledge of Sentinel, or indicates it needs human input.
     Returns Boss's answer as a string.
     """
@@ -168,17 +174,17 @@ def _consult_boss(question: str, task_context: str, cfg: "SentinelConfig") -> st
             max_tokens=600,
             system=(
                 "You are Sentinel Boss — the operational orchestrator of the Sentinel DevOps system. "
-                "You are answering a question from Dev Claude, your peer AI agent who maintains "
-                "Sentinel's source code autonomously. Dev Claude has full authority within Sentinel's "
+                "You are answering a question from Patch, your peer AI agent who maintains "
+                "Sentinel's source code autonomously. Patch has full authority within Sentinel's "
                 "operational scope and only asks you when it truly needs information it cannot find itself.\n\n"
                 "Answer concisely and directly. If you know the answer from Sentinel's architecture or "
                 "standard practices, give it. If the question requires a human admin decision (e.g. "
                 "secret credentials, budget approval, irreversible production changes), reply with:\n"
                 "NEEDS_HUMAN: <brief reason>\n\n"
-                "Context of the task Dev Claude is working on:\n"
+                "Context of the task Patch is working on:\n"
                 f"{task_context[:400]}"
             ),
-            messages=[{"role": "user", "content": f"Dev Claude asks: {question}"}],
+            messages=[{"role": "user", "content": f"Patch asks: {question}"}],
         )
         return _resp.content[0].text.strip() if _resp.content else "(no answer from Boss)"
     except Exception as _e:
@@ -186,11 +192,6 @@ def _consult_boss(question: str, task_context: str, cfg: "SentinelConfig") -> st
         return f"(Boss consultation failed: {_e})"
 
 
-def _extract_version_bumped(output: str) -> str | None:
-    """Parse VERSION_BUMPED: <version> from Claude output."""
-    m = re.search(r'^VERSION_BUMPED:\s*(\S+)', output, re.MULTILINE | re.IGNORECASE)
-    return m.group(1) if m else None
-
 
 def _extract_summary(output: str) -> str:
     """Extract the last meaningful paragraph from Claude output (not tool-use lines)."""
@@ -198,40 +199,12 @@ def _extract_summary(output: str) -> str:
     substantive = [
         l for l in lines
         if l.strip() and not re.match(r'^[⏺⎆●✦✓✗]', l.strip())
-        and not l.strip().startswith("VERSION_BUMPED")
     ]
     if not substantive:
         return output[-400:].strip()
     return "\n".join(substantive[-12:])[:500]
 
 
-def _run_npm_publish(repo_path: str, env: dict, on_progress=None) -> bool:
-    """Run npm publish from cli/ directory. Returns True on success."""
-    cli_dir = Path(repo_path) / "cli"
-    if not cli_dir.exists():
-        logger.warning("Dev agent: cli/ not found at %s", cli_dir)
-        return False
-    if on_progress:
-        try:
-            on_progress(":rocket: Publishing to npm...")
-        except Exception:
-            pass
-    try:
-        r = subprocess.run(
-            ["npm", "publish", "--access", "public"],
-            cwd=str(cli_dir),
-            capture_output=True, text=True, timeout=120, env=env,
-        )
-        if r.returncode == 0:
-            logger.info("Dev agent: npm publish succeeded")
-            return True
-        logger.error("Dev agent: npm publish failed (rc=%d): %s", r.returncode, r.stderr[:300])
-        return False
-    except Exception as e:
-        logger.error("Dev agent: npm publish error: %s", e)
-        return False
-
-
 
 def _dev_progress_from_line(line: str) -> str | None:
     """Convert Claude Code tool-use lines to human-readable dev progress messages."""
@@ -370,7 +343,7 @@ def run_dev_task(
 
         if timed_out:
             logger.error("Dev agent: Claude timed out for task %s", task.fingerprint[:8])
-            return "error", "Dev Claude timed out after 15 minutes."
+            return "error", "Patch timed out after 15 minutes."
 
         stripped = output.strip()
 
@@ -416,7 +389,7 @@ def run_dev_task(
     else:
         # Exhausted retries — treat as needs_human (Boss couldn't unblock Dev Claude)
         _record("needs_human", note="Exhausted Boss consultations without completing task")
-        return "needs_human", "Dev Claude could not complete the task after consulting Boss. Human review needed."
+        return "needs_human", "Patch could not complete the task after consulting Boss. Human review needed."
 
     if stripped.upper().startswith("SKIP:"):
         reason = stripped[5:].strip()
@@ -424,30 +397,15 @@ def run_dev_task(
         _record("skip", note=reason[:400])
         return "skip", reason
 
-    # Parse optional VERSION_BUMPED signal and summary
-    new_version = _extract_version_bumped(output)
     summary = _extract_summary(output)
-
-    logger.info(
-        "Dev agent: task %s completed (version_bumped=%s)",
-        task.fingerprint[:8], new_version or "no",
-    )
+    logger.info("Dev agent: task %s completed", task.fingerprint[:8])
 
     # Extract files changed from git output in Claude's response (best-effort)
     _files_re = re.findall(r'\bsentinel/\S+\.py\b|\bcli/\S+\.(?:js|json)\b', output)
     files_str = ", ".join(dict.fromkeys(_files_re))[:300]
 
-    # Post-execution: publish to npm if configured and version was bumped
-    if cfg.sentinel_dev_auto_publish and new_version:
-        published = _run_npm_publish(repo_path, base_env, on_progress)
-        if published:
-            _record("published", note=summary, files=files_str, commit=new_version)
-            return "published", new_version
-        _record("done", note=summary, files=files_str, commit=new_version)
-        return "done", new_version
-
     _record("done", note=summary, files=files_str)
-    return "done", new_version or ""
+    return "done", ""
 
 
 def _fire_progress(line: str, on_progress) -> None: