nexo-brain 6.0.1 → 6.0.3

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "6.0.1",
+  "version": "6.0.3",
   "description": "Local cognitive runtime for Claude Code \u2014 persistent memory, overnight learning, doctor diagnostics, personal scripts, recovery-aware jobs, startup preflight, and optional dashboard/power helper.",
   "author": {
     "name": "NEXO Brain",

package/README.md

@@ -18,7 +18,11 @@
 
 [Watch the overview video](https://nexo-brain.com/watch/) · [Watch on YouTube](https://www.youtube.com/watch?v=i2lkGhKyVqI) · [Open the infographic](https://nexo-brain.com/assets/nexo-brain-infographic-v5.png)
 
-Version `6.0.1` is the current packaged-runtime line: hotfix on top of the 6.0.0 release. `protocol_settings.py` now treats the process as interactive when **either** stdin+stdout are TTYs **or** `NEXO_INTERACTIVE=1` is exported — closes the gap where NEXO Desktop 0.12.0 spawned `claude` through pipes and Brain fell back to `lenient` even with a human in the loop. The `PostToolUse` hook also gains an inbox autodetect stage: when the session has unread `nexo_send` messages and has gone 60s+ without a heartbeat, it emits a `systemMessage` asking the agent to run `nexo_heartbeat` and consume them. Rate-limited to one reminder per minute per SID (new `hook_inbox_reminders` table, migration m42). Added `sessions.last_heartbeat_ts`, stamped by every successful heartbeat. `NEXO_INTERACTIVE` is an internal Brain↔Electron contract — not user-facing, not a resurrection of the removed `NEXO_PROTOCOL_STRICTNESS`.
+Version `6.0.3` is the current packaged-runtime line: double-fix release. (1) `resonance_tiers.json` is now published to `~/.nexo/brain/resonance_tiers.json` — the public contract path defined by v6.0.0 and consumed by NEXO Desktop ≥ 0.12.0. Pre-v6.0.3 the installer wrote it to `~/.nexo/resonance_tiers.json`, so Desktop failed to start Claude with *"NEXO Brain contract missing"* on every fresh install and every update from 6.0.0 / 6.0.1 / 6.0.2 unless the user copied the file by hand. An idempotent migration in `auto_update.py` promotes legacy runtimes on `nexo update`. (2) `nexo_guard_check` now persists the caller's SID on every `guard_checks` row (env `NEXO_SID` → env `CLAUDE_SESSION_ID` via `sessions.external_session_id` → most-recently-updated `sessions` row). Pre-v6.0.3 it hardcoded `session_id=""`, so `hook_guardrails._session_has_guard_check` never matched and strict-protocol sessions tripped *"no guard_check seen for this session"* after every successful call.
+
+Previously in `6.0.2`: adds the reserved caller prefix `personal/*` so scripts living in `~/.nexo/scripts/` can invoke the automation backend with their own caller id without editing `src/resonance_map.py`. New kwarg `tier` (`"maximo"` / `"alto"` / `"medio"` / `"bajo"`) on `run_automation_prompt`, `run_automation_interactive`, `nexo_helper.run_automation_text`, `nexo_helper.run_automation_json`, and `nexo-agent-run.py --tier`. Precedence for `personal/*` callers: explicit `tier=` → explicit `reasoning_effort=` → `calibration.preferences.default_resonance` → `DEFAULT_RESONANCE` (`alto`). Registered callers keep their behaviour unchanged. New guide: [`docs/personal-scripts-guide.md`](docs/personal-scripts-guide.md).
+
+Previously in `6.0.1`: hotfix on top of the 6.0.0 release. `protocol_settings.py` now treats the process as interactive when **either** stdin+stdout are TTYs **or** `NEXO_INTERACTIVE=1` is exported — closes the gap where NEXO Desktop 0.12.0 spawned `claude` through pipes and Brain fell back to `lenient` even with a human in the loop. The `PostToolUse` hook also gains an inbox autodetect stage: when the session has unread `nexo_send` messages and has gone 60s+ without a heartbeat, it emits a `systemMessage` asking the agent to run `nexo_heartbeat` and consume them. Rate-limited to one reminder per minute per SID (new `hook_inbox_reminders` table, migration m42). Added `sessions.last_heartbeat_ts`, stamped by every successful heartbeat. `NEXO_INTERACTIVE` is an internal Brain↔Electron contract — not user-facing, not a resurrection of the removed `NEXO_PROTOCOL_STRICTNESS`.
 
 Previously in `6.0.0`: **BREAKING** tier-only setup. Onboarding asks for one resonance tier (`maximo`/`alto`/`medio`/`bajo`) and that choice drives every backend via `src/resonance_tiers.json`; the per-backend model/effort prompts are gone and the legacy `client_runtime_profiles.{claude_code,codex}.{model,reasoning_effort}` are silently purged from `schedule.json` on upgrade. Protocol strictness is no longer configurable — interactive TTY sessions run `strict`, non-TTY (crons, pipes, tests) run `lenient`; `NEXO_PROTOCOL_STRICTNESS` env, `preferences.protocol_strictness`, and the `default/normal/off/warn/soft` aliases are all removed. `preferences.show_pending_at_start` moves to NEXO Desktop's electron-store. The seven core hooks are now unified behind `src/hooks/manifest.json` (plugin and npm modes read the same file), two new hooks ship (`Notification` for live-session activity and `SubagentStop` for auto-closing stale `protocol_tasks`), and `auto_capture.py` is wired to both `UserPromptSubmit` and `PostToolUse` with a persistent 1h dedup table plus an automatic `nexo_learning_add` on correction matches. `~/.nexo/hooks_status.json` is published after every `registerAllCoreHooks()` so NEXO Desktop ≥0.12.0 can render Hooks activos X/Y. New `nexo-brain --skip` flag aliases `--yes`/`--defaults`. Full suite 1057 passed, 1 skipped.
 
@@ -1145,6 +1149,7 @@ If NEXO Brain is useful to you, consider:
 - **Share your experience** — tell others how you're using cognitive memory in your AI workflows
 - **Contribute** — see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines. Issues and PRs welcome
 - **Client parity / shared-brain maintenance** — see [docs/client-parity-checklist.md](docs/client-parity-checklist.md)
+- **Writing a personal script that calls the automation backend** — see [docs/personal-scripts-guide.md](docs/personal-scripts-guide.md)
 
 [![Star History Chart](https://api.star-history.com/svg?repos=wazionapps/nexo&type=Date)](https://star-history.com/#wazionapps/nexo&Date)
 

package/bin/nexo-brain.js

@@ -235,7 +235,6 @@ function getCoreRuntimeFlatFiles(srcDir = path.join(__dirname, "..", "src")) {
     "runtime_power.py",
     "requirements.txt",
     "model_defaults.json",
-    "resonance_tiers.json",
   ];
   const discoveredRootModules = fs.existsSync(srcDir)
     ? fs.readdirSync(srcDir)
@@ -257,6 +256,29 @@ function getCoreRuntimePackages() {
   return ["db", "cognitive", "doctor"];
 }
 
+// Brain contracts — files the NEXO Brain publishes to consumers like
+// NEXO Desktop under ~/.nexo/brain/. These are NOT code (they live outside
+// getCoreRuntimeFlatFiles for that reason) but data contracts with a stable
+// path that external clients read. Keep in sync with docs/contracts/.
+function publishBrainContracts(srcDir = path.join(__dirname, "..", "src"), nexoHome = NEXO_HOME) {
+  const brainDir = path.join(nexoHome, "brain");
+  fs.mkdirSync(brainDir, { recursive: true });
+  const contracts = ["resonance_tiers.json"];
+  contracts.forEach((name) => {
+    const src = path.join(srcDir, name);
+    if (fs.existsSync(src)) {
+      fs.copyFileSync(src, path.join(brainDir, name));
+    }
+  });
+  // Clean up legacy location: before v6.0.3 the file was written to
+  // NEXO_HOME/resonance_tiers.json. Remove it so only the contract path
+  // remains authoritative.
+  const legacy = path.join(nexoHome, "resonance_tiers.json");
+  if (fs.existsSync(legacy)) {
+    try { fs.unlinkSync(legacy); } catch (_) { /* best-effort */ }
+  }
+}
+
 function resolveLaunchAgentPath(home) {
   const parts = ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin",
     path.join(home, ".local/bin"), path.join(home, ".nexo/bin")];
@@ -1654,6 +1676,8 @@ async function main() {
             copyDirRec(pkgSrc, path.join(NEXO_HOME, pkg));
           }
         });
+        // Publish Brain contracts to ~/.nexo/brain/ (read by NEXO Desktop et al.)
+        publishBrainContracts(srcDir, NEXO_HOME);
         log("  Core files updated.");
 
         // Reconcile Python dependencies after updating code (mirrors fresh-install logic)
@@ -2490,6 +2514,9 @@ async function main() {
     }
   });
 
+  // Publish Brain contracts to ~/.nexo/brain/ (read by NEXO Desktop et al.)
+  publishBrainContracts(srcDir, NEXO_HOME);
+
   // Runtime CLI wrapper lives in NEXO_HOME/bin so it survives npx installs.
   const runtimeCli = [
     "#!/usr/bin/env bash",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "6.0.1",
+  "version": "6.0.3",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO Brain \u2014 Shared brain for AI agents. Persistent memory, semantic RAG, natural forgetting, metacognitive guard, trust scoring, 150+ MCP tools. Works with Claude Code, Codex, Claude Desktop & any MCP client. 100% local, free.",
   "homepage": "https://nexo-brain.com",

package/src/agent_runner.py

@@ -531,6 +531,7 @@ def run_automation_interactive(
     env: dict | None = None,
     preferences: dict | None = None,
     session_type: str = "interactive_chat",
+    tier: str = "",
 ) -> subprocess.CompletedProcess:
     """Launch an interactive Claude/Codex session with automation_runs logging.
 
@@ -564,8 +565,13 @@ def run_automation_interactive(
         user_default = ""
         if isinstance(prefs, dict):
             user_default = str(prefs.get("default_resonance") or "").strip()
+        # v6.0.2 — respect explicit ``tier`` override so personal/* callers
+        # can force a resonance without registering in the core map.
+        explicit_tier_arg = (tier or "").strip() or None
         resonance_tier = resolve_tier_for_caller(
-            caller, user_default=user_default or None
+            caller,
+            user_default=user_default or None,
+            explicit_tier=explicit_tier_arg,
         )
     except Exception:
         resonance_tier = ""
@@ -848,6 +854,7 @@ def run_automation_prompt(
     env: dict | None = None,
     model: str = "",
     reasoning_effort: str = "",
+    tier: str = "",
     timeout: int = 300,
     output_format: str = "",
     append_system_prompt: str = "",
@@ -891,13 +898,22 @@ def run_automation_prompt(
     user_default = ""
     if isinstance(prefs, dict):
         user_default = str(prefs.get("default_resonance") or "").strip()
+    # v6.0.2 — ``tier`` kwarg propagates to the resolver as ``explicit_tier``
+    # so personal/* callers can pin their reasoning budget per-invocation
+    # without editing the registry. Registered callers remain unchanged.
+    explicit_tier_arg = (tier or "").strip() or None
     # This raises UnregisteredCallerError if caller is unknown — the
     # same fail-closed rule we wanted. No silent fallback.
     resonance_tier = resolve_tier_for_caller(
-        caller, user_default=user_default or None
+        caller,
+        user_default=user_default or None,
+        explicit_tier=explicit_tier_arg,
     )
     mapped_model, mapped_effort = resolve_model_and_effort(
-        caller, selected_backend, user_default=user_default or None
+        caller,
+        selected_backend,
+        user_default=user_default or None,
+        explicit_tier=explicit_tier_arg,
     )
     if mapped_model and not model:
         model = mapped_model

package/src/auto_update.py

@@ -973,6 +973,57 @@ def _migrate_effort_to_resonance(dest: Path = NEXO_HOME) -> list[str]:
     return actions
 
 
+def _relocate_resonance_tiers_contract(dest: Path = NEXO_HOME) -> list[str]:
+    """Ensure ``resonance_tiers.json`` lives at the public contract path
+    ``NEXO_HOME/brain/resonance_tiers.json`` and purge the legacy copy at
+    ``NEXO_HOME/resonance_tiers.json``.
+
+    Context: v6.0.0 defined the public contract (read by NEXO Desktop) as
+    ``~/.nexo/brain/resonance_tiers.json`` but the installer kept copying
+    the file to ``~/.nexo/resonance_tiers.json`` (legacy flat-file layout),
+    so Desktop failed with *"NEXO Brain contract missing"* until the user
+    moved the file by hand. v6.0.3 publishes straight to ``brain/`` and
+    this migration reconciles existing runtimes.
+
+    Idempotent: no-op once the contract file is in ``brain/`` and the
+    legacy file is gone. Never raises — migration must not block an update.
+    """
+    actions: list[str] = []
+    brain_dir = dest / "brain"
+    contract_path = brain_dir / "resonance_tiers.json"
+    legacy_path = dest / "resonance_tiers.json"
+
+    try:
+        brain_dir.mkdir(parents=True, exist_ok=True)
+    except Exception as exc:
+        actions.append(f"resonance-contract-relocate-warning:mkdir:{exc.__class__.__name__}")
+        return actions
+
+    # If the contract already exists in brain/, just drop the legacy copy.
+    if contract_path.is_file():
+        if legacy_path.is_file():
+            try:
+                legacy_path.unlink()
+                actions.append("resonance-contract-relocate:legacy-removed")
+            except Exception as exc:
+                actions.append(f"resonance-contract-relocate-warning:unlink:{exc.__class__.__name__}")
+        return actions
+
+    # Contract missing from brain/ — promote the legacy file if present.
+    if legacy_path.is_file():
+        try:
+            contract_path.write_bytes(legacy_path.read_bytes())
+            legacy_path.unlink()
+            actions.append("resonance-contract-relocate:moved-to-brain")
+        except Exception as exc:
+            actions.append(f"resonance-contract-relocate-warning:move:{exc.__class__.__name__}")
+    # If neither exists, the caller (nexo-brain.js publishBrainContracts)
+    # will write it from the package source on the next install pass; nothing
+    # for this Python migration to do.
+
+    return actions
+
+
 def _bootstrap_profile_from_calibration_meta(dest: Path = NEXO_HOME) -> list[str]:
     """Create ``brain/profile.json`` from ``calibration.json`` fields when the
     profile file does not exist yet.
@@ -2894,6 +2945,17 @@ def _run_runtime_post_sync(dest: Path = NEXO_HOME, progress_fn=None) -> tuple[bo
     except Exception as exc:
         actions.append(f"profile-bootstrap-warning:{exc.__class__.__name__}")
 
+    # v6.0.3 — relocate resonance_tiers.json from NEXO_HOME root (pre-v6.0.3
+    # layout) to NEXO_HOME/brain/ (public contract path consumed by
+    # NEXO Desktop). Idempotent; safe no-op once the move is done.
+    try:
+        _emit_progress(progress_fn, "Relocating resonance_tiers contract to brain/...")
+        reloc_actions = _relocate_resonance_tiers_contract(dest)
+        for action in reloc_actions:
+            actions.append(action)
+    except Exception as exc:
+        actions.append(f"resonance-contract-relocate-warning:{exc.__class__.__name__}")
+
     # v6.0.0 purge — drop legacy fields that moved elsewhere in v6.
     # client_runtime_profiles.*.{model,reasoning_effort} → resonance_tiers.json.
     # preferences.protocol_strictness → TTY/no-TTY detection.

package/src/plugins/guard.py

@@ -11,6 +11,55 @@ from pathlib import Path
 from db import get_db, find_similar_learnings, extract_keywords, search_learnings, search_changes
 
 
+def _resolve_active_sid(conn) -> str:
+    """Resolve the SID of the caller invoking this guard check.
+
+    Order of precedence:
+      1. ``NEXO_SID`` env var (headless crons + wrapped CLI set this).
+      2. ``CLAUDE_SESSION_ID`` env var translated via
+         ``sessions.external_session_id`` / ``sessions.claude_session_id``.
+      3. The most-recently-updated session in ``sessions`` (fallback for
+         MCP tool calls where the broker doesn't forward env vars but a
+         single active session exists).
+
+    Returns an empty string if nothing resolves. The caller MUST handle
+    the empty-string case explicitly — persisting ``session_id=""`` was
+    the v6.0.2 bug that left ``missing_file_guard`` blind to successful
+    guard checks.
+    """
+    env_sid = (os.environ.get("NEXO_SID") or "").strip()
+    if env_sid.startswith("nexo-"):
+        return env_sid
+
+    external_candidates = [env_sid] if env_sid else []
+    claude_sid = (os.environ.get("CLAUDE_SESSION_ID") or "").strip()
+    if claude_sid:
+        external_candidates.append(claude_sid)
+    for cand in external_candidates:
+        try:
+            row = conn.execute(
+                "SELECT sid FROM sessions "
+                "WHERE external_session_id = ? OR claude_session_id = ? "
+                "ORDER BY last_update_epoch DESC LIMIT 1",
+                (cand, cand),
+            ).fetchone()
+        except Exception:
+            row = None
+        if row and row["sid"]:
+            return str(row["sid"])
+
+    try:
+        row = conn.execute(
+            "SELECT sid FROM sessions "
+            "ORDER BY last_update_epoch DESC LIMIT 1"
+        ).fetchone()
+    except Exception:
+        row = None
+    if row and row["sid"]:
+        return str(row["sid"])
+    return ""
+
+
 def _split_applies_to(applies_to: str) -> list[str]:
     return [item.strip() for item in str(applies_to or "").split(",") if item.strip()]
 
@@ -370,11 +419,15 @@ def handle_guard_check(files: str = "", area: str = "", include_schemas: str = "
                 (time.time(), lid)
             )
 
-    # Log the guard check
+    # Log the guard check — v6.0.3 fix: resolve the caller's SID instead of
+    # inserting the empty string. Pre-v6.0.3 every row landed with
+    # session_id='' so missing_file_guard could not find the guard call
+    # from hook_guardrails._session_has_guard_check and blocked forever.
+    active_sid = _resolve_active_sid(conn)
     conn.execute(
         "INSERT INTO guard_checks (session_id, files, area, learnings_returned, blocking_rules_returned) "
         "VALUES (?, ?, ?, ?, ?)",
-        ("", files, area, len(result["learnings"]) + len(result["universal_rules"]),
+        (active_sid, files, area, len(result["learnings"]) + len(result["universal_rules"]),
          len(result["blocking_rules"]))
     )
     conn.commit()

package/src/resonance_map.py

@@ -46,6 +46,7 @@ future scripts from silently inheriting the wrong tier.
 from __future__ import annotations
 
 import json
+import os
 from pathlib import Path
 from typing import Tuple
 
@@ -65,7 +66,27 @@ from typing import Tuple
 
 TIERS = ("maximo", "alto", "medio", "bajo")
 
-_RESONANCE_JSON_PATH = Path(__file__).resolve().parent / "resonance_tiers.json"
+# Resolution order for the contract file:
+#   1) ~/.nexo/brain/resonance_tiers.json  (v6.0.3+ public contract path, shared
+#      with NEXO Desktop and any external client)
+#   2) Legacy NEXO_HOME/resonance_tiers.json (pre-v6.0.3 runtime layout)
+#   3) Package source src/resonance_tiers.json (dev checkouts / tests)
+def _resolve_resonance_path() -> Path:
+    nexo_home = os.environ.get("NEXO_HOME") or str(Path.home() / ".nexo")
+    candidates = [
+        Path(nexo_home) / "brain" / "resonance_tiers.json",
+        Path(nexo_home) / "resonance_tiers.json",
+        Path(__file__).resolve().parent / "resonance_tiers.json",
+    ]
+    for candidate in candidates:
+        if candidate.is_file():
+            return candidate
+    # No contract present: return the canonical path so the ValueError raised
+    # at load time points at where the contract should live.
+    return candidates[0]
+
+
+_RESONANCE_JSON_PATH = _resolve_resonance_path()
 
 
 def _normalize_tier_entry(entry: dict) -> dict[str, tuple[str, str]]:
@@ -213,6 +234,21 @@ ALL_REGISTERED_CALLERS: frozenset[str] = frozenset(
 )
 
 
+# v6.0.2 — Reserved caller prefix for user-owned personal scripts that live
+# outside this repo (``~/.nexo/scripts/``). Callers matching this prefix
+# bypass the registry entirely: they cannot be required to register because
+# they ship with each operator's own install. Instead, the script passes
+# either an explicit ``tier`` (semantic) or a ``reasoning_effort`` (direct
+# override) — or falls back to the user's ``default_resonance`` preference,
+# and finally to ``DEFAULT_RESONANCE`` as the last line of defence.
+#
+# The prefix is NOT a loophole for new core scripts. Anything inside the
+# ``src/`` tree or shipped via the core manifest continues to require a
+# registered entry. The docs (``docs/personal-scripts-guide.md``) explain
+# the split to any NEXO session helping an operator author a new script.
+PERSONAL_CALLER_PREFIX = "personal/"
+
+
 class UnregisteredCallerError(ValueError):
     """Raised when a caller string is not in the resonance registry.
 
@@ -271,22 +307,55 @@ def _load_user_default_resonance() -> str:
     return ""
 
 
-def resolve_tier_for_caller(caller: str, user_default: str | None = None) -> str:
-    """Return the resonance tier that should apply to ``caller``.
+def _normalise_tier(candidate: str | None) -> str:
+    """Coerce a tier string to canonical lowercase; empty when invalid."""
+    if not candidate:
+        return ""
+    value = str(candidate).strip().lower()
+    return value if value in TIERS else ""
 
-    - User-facing callers resolve to ``user_default`` (or ``DEFAULT_RESONANCE``
-      if the user has no preference recorded).
-    - System-owned callers resolve to their fixed tier.
-    - Unknown callers raise ``UnregisteredCallerError``.
 
-    When ``user_default`` is not passed, the function looks it up from the
-    calibration.json preferences first and schedule.json second.
+def resolve_tier_for_caller(
+    caller: str,
+    user_default: str | None = None,
+    *,
+    explicit_tier: str | None = None,
+) -> str:
+    """Return the resonance tier that should apply to ``caller``.
+
+    Resolution order:
+
+    1. ``caller`` is empty → raise ``UnregisteredCallerError`` (same as v6.0.0).
+    2. ``caller`` starts with ``PERSONAL_CALLER_PREFIX``:
+         a. ``explicit_tier`` if valid — semantic override from the script.
+         b. ``user_default`` if valid — operator's configured default.
+         c. Stored ``preferences.default_resonance`` via the loader.
+         d. ``DEFAULT_RESONANCE`` as the final fallback.
+       The registry is NEVER consulted for personal callers: scripts outside
+       the repo cannot register, and forcing them to pin a tier there would
+       defeat the whole purpose of the ``personal/`` contract.
+    3. User-facing callers: user default → DEFAULT (unchanged).
+    4. System-owned callers: fixed tier (unchanged).
+    5. Anything else: ``UnregisteredCallerError`` (unchanged).
     """
     if not caller:
         raise UnregisteredCallerError(
             "caller= is required. Every automation subprocess must be registered "
             "in src/resonance_map.py so its reasoning budget is deliberate."
         )
+
+    if caller.startswith(PERSONAL_CALLER_PREFIX):
+        explicit = _normalise_tier(explicit_tier)
+        if explicit:
+            return explicit
+        from_user = _normalise_tier(user_default)
+        if from_user:
+            return from_user
+        from_prefs = _normalise_tier(_load_user_default_resonance())
+        if from_prefs:
+            return from_prefs
+        return DEFAULT_RESONANCE
+
     if caller in USER_FACING_CALLERS:
         resolved_default = user_default
         if resolved_default is None:
@@ -308,6 +377,8 @@ def resolve_model_and_effort(
     caller: str,
     backend: str,
     user_default: str | None = None,
+    *,
+    explicit_tier: str | None = None,
 ) -> Tuple[str, str]:
     """Return ``(model, reasoning_effort)`` for ``caller`` on ``backend``.
 
@@ -316,7 +387,9 @@ def resolve_model_and_effort(
     empty pair; the caller is expected to handle that by raising or by
     passing its own explicit model/effort arguments.
     """
-    tier = resolve_tier_for_caller(caller, user_default=user_default)
+    tier = resolve_tier_for_caller(
+        caller, user_default=user_default, explicit_tier=explicit_tier
+    )
     backend_entry = _RESONANCE_TABLE.get(tier, {}).get(backend)
     if backend_entry is None:
         return "", ""

package/src/scripts/nexo-agent-run.py

@@ -33,6 +33,20 @@ def main(argv: list[str] | None = None) -> int:
     parser.add_argument("--task-profile", default="", help="Automation task profile: default|fast|balanced|deep")
     parser.add_argument("--model", default="", help="Backend model hint")
     parser.add_argument("--reasoning-effort", default="", help="Backend reasoning effort/profile")
+    parser.add_argument(
+        "--tier",
+        default="",
+        help="Resonance tier — 'maximo'/'alto'/'medio'/'bajo'. "
+             "v6.0.2+ — used by personal/* callers to override the "
+             "resonance without editing src/resonance_map.py.",
+    )
+    parser.add_argument(
+        "--caller",
+        default="",
+        help="Registered caller id (e.g. nexo_chat) or 'personal/<id>' for "
+             "user-owned scripts. Required in practice; empty falls back "
+             "to 'agent_run/generic' for backward compatibility.",
+    )
     parser.add_argument("--timeout", type=int, default=AUTOMATION_SUBPROCESS_TIMEOUT, help="Timeout in seconds")
     parser.add_argument("--output-format", default="text", help="Requested output format")
     parser.add_argument("--allowed-tools", default="", help="Claude-style allowed tools contract")
@@ -52,11 +66,12 @@ def main(argv: list[str] | None = None) -> int:
     try:
         result = run_automation_prompt(
             prompt,
-            caller=getattr(args, "caller", "") or "agent_run/generic",
+            caller=args.caller or "agent_run/generic",
             cwd=args.cwd or None,
             task_profile=args.task_profile,
             model=args.model,
             reasoning_effort=args.reasoning_effort,
+            tier=args.tier,
             timeout=args.timeout,
             output_format=args.output_format,
             append_system_prompt=append_system_prompt,

package/templates/nexo_helper.py

@@ -206,18 +206,29 @@ def run_automation_text(
     allowed_tools: str = DEFAULT_ALLOWED_TOOLS,
     append_system_prompt: str = "",
     include_bootstrap: bool = True,
+    caller: str = "",
+    tier: str = "",
 ) -> str:
     """Run the configured NEXO automation backend and return text output.
 
     This avoids hardcoding provider CLIs such as `claude -p` inside personal
     scripts. The runtime routes the call through the selected backend and its
     configured model profile.
+
+    Personal scripts (those living in ``~/.nexo/scripts/``) should pass
+    ``caller="personal/<descriptive-id>"`` and optionally ``tier="alto"``
+    (or another canonical tier) to pick their resonance without editing the
+    NEXO Brain repo. See ``docs/personal-scripts-guide.md`` for the rules.
     """
     runner = NEXO_HOME / "scripts" / "nexo-agent-run.py"
     if not runner.exists():
         raise RuntimeError(f"Automation runner not found: {runner}")
 
     cmd = [sys.executable, str(runner), "--prompt", prompt, "--output-format", "text"]
+    if caller:
+        cmd.extend(["--caller", caller])
+    if tier:
+        cmd.extend(["--tier", tier])
     if model:
         cmd.extend(["--model", model])
     if reasoning_effort:
@@ -261,13 +272,25 @@ def run_automation_json(
     allowed_tools: str = DEFAULT_ALLOWED_TOOLS,
     append_system_prompt: str = "",
     include_bootstrap: bool = True,
+    caller: str = "",
+    tier: str = "",
 ) -> dict:
-    """Run the configured backend and return a parsed JSON object."""
+    """Run the configured backend and return a parsed JSON object.
+
+    v6.0.2 adds ``caller`` and ``tier`` kwargs so personal scripts
+    (``~/.nexo/scripts/``) can identify themselves and pick a resonance
+    without registering in the core repo. See
+    ``docs/personal-scripts-guide.md``.
+    """
     runner = NEXO_HOME / "scripts" / "nexo-agent-run.py"
     if not runner.exists():
         raise RuntimeError(f"Automation runner not found: {runner}")
 
     cmd = [sys.executable, str(runner), "--prompt", prompt, "--output-format", "json"]
+    if caller:
+        cmd.extend(["--caller", caller])
+    if tier:
+        cmd.extend(["--tier", tier])
     if model:
         cmd.extend(["--model", model])
     if reasoning_effort: