@jetrabbits/agentic 0.1.0 → 0.3.0

package/agentic

@@ -15,7 +15,7 @@ APP_REPO_LINK="https://github.com/sawrus/agent-guides"
 PROJECT_MANIFEST_NAME=".agentic.json"
 
 DEFAULT_AGENT_OS="default"
-STATIC_AGENT_OS=(default opencode codex claude antigravity cursor agents)
+STATIC_AGENT_OS=(opencode codex claude antigravity cursor kilocode)
 INSTALL_DIRS=(rules skills workflows prompts)
 THEME_CHOICES=(auto dark light)
 
@@ -55,6 +55,13 @@ SKIPPED_MANAGED_PATHS=()
 WARNINGS=()
 
 CONTEXT7_API_KEY="${CONTEXT7_API_KEY:-}"
+AGENTIC_ENABLE_CONTEXT7="${AGENTIC_ENABLE_CONTEXT7:-}"
+AGENTIC_DOCTOR="${AGENTIC_DOCTOR:-1}"
+AGENTIC_DOCTOR_KEEP_TMP="${AGENTIC_DOCTOR_KEEP_TMP:-0}"
+AGENTIC_DOCTOR_TIMEOUT_SECONDS="${AGENTIC_DOCTOR_TIMEOUT_SECONDS:-10}"
+
+RUN_LOG_ACTIVE=false
+RUN_LOG_FILE=""
 
 COLOR_RESET=""
 COLOR_HEADER=""
@@ -67,7 +74,7 @@ FZF_COLOR_ARGS=()
 
 usage() {
   cat <<USAGE
-$APP_TITLE
+$APP_TITLE $(app_version_label)
 
 Usage:
   $SCRIPT_NAME list [agentos|areas|specs --area <name>]
@@ -75,6 +82,7 @@ Usage:
   $SCRIPT_NAME tui [--theme auto|dark|light]
   $SCRIPT_NAME upgrade
   $SCRIPT_NAME self-install [--bin-dir <dir>] [--force] [--install-fzf] [--dry-run]
+  $SCRIPT_NAME --version
 
 Behavior:
   - No arguments in interactive terminal: runs TUI mode
@@ -87,11 +95,13 @@ Options:
   --areas               Comma-separated area list (example: software)
   --specializations     Comma-separated specializations in area.spec format (example: software.backend,software.frontend)
   --theme               Interface theme: auto|dark|light (default: config value or auto)
+  --no-doctor           Skip real agent smoke checks after install
   --bin-dir             Installation directory for self-install (default: ~/.local/bin)
   --force               Overwrite existing binary for self-install
   --install-fzf         During self-install, try to auto-install fzf (optional)
   --dry-run             Show actions without writing files
   -h, --help            Show this help
+  -V, --version         Show agentic version
 
 Examples:
   $SCRIPT_NAME list agentos
@@ -102,6 +112,31 @@ Examples:
 USAGE
 }
 
+read_package_version() {
+  local package_file="$1"
+  [[ -f "$package_file" ]] || return 1
+
+  sed -n 's/^[[:space:]]*"version"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' "$package_file" | head -n 1
+}
+
+app_version() {
+  local version=""
+  local candidate
+  for candidate in "$SCRIPT_DIR/package.json" "$REPO_ROOT/package.json" "$APP_REPO_DIR/package.json"; do
+    [[ -n "$candidate" ]] || continue
+    version="$(read_package_version "$candidate" || true)"
+    if [[ -n "$version" ]]; then
+      printf '%s\n' "$version"
+      return
+    fi
+  done
+  printf 'unknown\n'
+}
+
+app_version_label() {
+  printf 'v%s\n' "$(app_version)"
+}
+
 is_interactive_terminal() {
   if [[ "${AGENTIC_FORCE_INTERACTIVE:-${AGENTOS_FORCE_INTERACTIVE:-}}" == "1" ]]; then
     return 0
@@ -217,16 +252,116 @@ set_theme_colors() {
 }
 
 log() {
-  printf '%s[agentic]%s %s\n' "$COLOR_INFO" "$COLOR_RESET" "$1"
+  emit_log_line stdout "[agentic]" "$1" "$COLOR_INFO"
 }
 
 warn() {
-  printf '%s[agentic][warn]%s %s\n' "$COLOR_WARN" "$COLOR_RESET" "$1"
+  emit_log_line stdout "[agentic][warn]" "$1" "$COLOR_WARN"
   WARNINGS+=("$1")
 }
 
 error() {
-  printf '%s[agentic][error]%s %s\n' "$COLOR_ERROR" "$COLOR_RESET" "$1" >&2
+  emit_log_line stderr "[agentic][error]" "$1" "$COLOR_ERROR"
+}
+
+timestamp_now() {
+  date '+%Y-%m-%d %H:%M:%S'
+}
+
+init_run_logging() {
+  if [[ "$RUN_LOG_ACTIVE" == true ]]; then
+    return
+  fi
+
+  local base_dir="${TMPDIR:-/tmp}"
+  local stamp
+  stamp="$(date '+%Y%m%d-%H%M%S')"
+  RUN_LOG_FILE="$(mktemp "$base_dir/agentic-$stamp.XXXXXX")"
+  RUN_LOG_ACTIVE=true
+  log "Run log initialized: $RUN_LOG_FILE"
+}
+
+write_run_log_line() {
+  local line="$1"
+  if [[ "$RUN_LOG_ACTIVE" == true && -n "$RUN_LOG_FILE" ]]; then
+    printf '%s\n' "$line" >> "$RUN_LOG_FILE"
+  fi
+}
+
+emit_log_line() {
+  local stream="$1"
+  local tag="$2"
+  local message="$3"
+  local color="${4:-}"
+
+  local line plain_line ts
+  if [[ "$RUN_LOG_ACTIVE" == true ]]; then
+    ts="$(timestamp_now)"
+    plain_line="$ts $tag $message"
+    if [[ -n "$color" ]]; then
+      line="$ts ${color}${tag}${COLOR_RESET} $message"
+    else
+      line="$plain_line"
+    fi
+  else
+    plain_line="$tag $message"
+    if [[ -n "$color" ]]; then
+      line="${color}${tag}${COLOR_RESET} $message"
+    else
+      line="$plain_line"
+    fi
+  fi
+
+  if [[ "$stream" == "stderr" ]]; then
+    printf '%s\n' "$line" >&2
+  else
+    printf '%s\n' "$line"
+  fi
+  write_run_log_line "$plain_line"
+}
+
+out() {
+  local message="${1:-}"
+  local color="${2:-}"
+  local line plain_line ts
+
+  if [[ -z "$message" ]]; then
+    printf '\n'
+    write_run_log_line ""
+    return
+  fi
+
+  if [[ "$RUN_LOG_ACTIVE" == true ]]; then
+    ts="$(timestamp_now)"
+    plain_line="$ts $message"
+    if [[ -n "$color" ]]; then
+      line="$ts ${color}${message}${COLOR_RESET}"
+    else
+      line="$plain_line"
+    fi
+  else
+    plain_line="$message"
+    if [[ -n "$color" ]]; then
+      line="${color}${message}${COLOR_RESET}"
+    else
+      line="$plain_line"
+    fi
+  fi
+
+  printf '%s\n' "$line"
+  write_run_log_line "$plain_line"
+}
+
+log_file_block() {
+  local label="$1"
+  local path="$2"
+  [[ "$RUN_LOG_ACTIVE" == true && -n "$RUN_LOG_FILE" && -f "$path" ]] || return 0
+
+  write_run_log_line "$(timestamp_now) --- $label output begin ---"
+  while IFS= read -r line || [[ -n "$line" ]]; do
+    write_run_log_line "$(timestamp_now) $line"
+  done < "$path"
+  write_run_log_line "$(timestamp_now) --- $label output end ---"
 }
 
 unique_append() {
@@ -519,6 +654,42 @@ ensure_python_available() {
   fi
 }
 
+pip_command() {
+  if command -v pip >/dev/null 2>&1; then
+    printf '%s\n' "pip"
+    return 0
+  fi
+  if command -v pip3 >/dev/null 2>&1; then
+    printf '%s\n' "pip3"
+    return 0
+  fi
+  if command -v python3 >/dev/null 2>&1 && python3 -m pip --version >/dev/null 2>&1; then
+    printf '%s\n' "python3 -m pip"
+    return 0
+  fi
+  return 1
+}
+
+ensure_pip_available() {
+  if ! pip_command >/dev/null; then
+    error "pip is required to run agentic install/tui. Install pip for Python 3 and make 'pip3', 'pip', or 'python3 -m pip' available."
+    exit 1
+  fi
+}
+
+ensure_hash_available() {
+  if ! command -v shasum >/dev/null 2>&1 && ! command -v sha256sum >/dev/null 2>&1; then
+    error "shasum or sha256sum is required to track managed files"
+    exit 1
+  fi
+}
+
+ensure_agentic_runtime_requirements() {
+  ensure_python_available
+  ensure_pip_available
+  ensure_hash_available
+}
+
 selected_agent_os_contains() {
   local expected="$1"
   local agent
@@ -547,8 +718,7 @@ hash_file() {
   elif command -v sha256sum >/dev/null 2>&1; then
     sha256sum "$path" | awk '{print $1}'
   else
-    error "shasum or sha256sum is required to track managed files"
-    exit 1
+    ensure_hash_available
   fi
 }
 
@@ -634,12 +804,15 @@ register_managed_file() {
   local dest="$1"
   local source_ref="$2"
   local marker="$3"
+  local copied="${4:-true}"
   local rel
   rel="$(project_rel_path "$dest")"
   local digest
   digest="$(hash_file "$dest")"
   MANAGED_RECORDS+=("$rel|$source_ref|$digest|$marker")
-  unique_append "$dest" COPIED_PATHS
+  if [[ "$copied" == true ]]; then
+    unique_append "$dest" COPIED_PATHS
+  fi
 }
 
 record_agentic_event() {
@@ -679,8 +852,10 @@ write_file_with_agentic_marker() {
   can_write_managed_file "$dest" || return 0
 
   ensure_dir "$(dirname -- "$dest")"
-  python3 - "$src" "$dest" "$source_ref" "$APP_REPO_LINK" <<'PY'
+  local write_status
+  write_status="$(python3 - "$src" "$dest" "$source_ref" "$APP_REPO_LINK" "$(app_version_label)" <<'PY'
 import json
+import re
 import sys
 from pathlib import Path
 
@@ -688,6 +863,7 @@ src = Path(sys.argv[1])
 dest = Path(sys.argv[2])
 source_ref = sys.argv[3]
 repo = sys.argv[4]
+version = sys.argv[5]
 text = src.read_text(encoding="utf-8")
 suffix = dest.suffix.lower()
 marker = f"Generated by agentic; source: {source_ref}; repository: {repo}"
@@ -697,12 +873,28 @@ def yaml_quote(value: str) -> str:
     return json.dumps(value, ensure_ascii=False)
 
 
+def existing_created_by() -> str:
+    if not dest.exists():
+        return version
+    try:
+        old = dest.read_text(encoding="utf-8")
+    except Exception:
+        return version
+    match = re.search(r"(?m)^  created_by:\s*(.+?)\s*$", old)
+    if not match:
+        return version
+    return match.group(1).strip().strip('"')
+
+
 def markdown_with_marker(body: str) -> str:
+    created_by = existing_created_by()
     block = (
         "agentic:\n"
         "  generated_by: agentic\n"
         f"  source: {yaml_quote(source_ref)}\n"
         f"  repository: {yaml_quote(repo)}\n"
+        f"  created_by: {yaml_quote(created_by)}\n"
+        f"  updated_by: {yaml_quote(version)}\n"
     )
     if body.startswith("---\n"):
         end = body.find("\n---", 4)
@@ -739,9 +931,23 @@ elif suffix in {".sh", ".toml", ".py", ".yml", ".yaml"}:
 else:
     output = commented(text, "#")
 
+if dest.exists():
+    try:
+        if dest.read_text(encoding="utf-8") == output:
+            print("unchanged")
+            raise SystemExit(0)
+    except UnicodeDecodeError:
+        pass
+
 dest.write_text(output, encoding="utf-8")
+print("written")
 PY
-  register_managed_file "$dest" "$source_ref" "internal"
+)"
+  if [[ "$write_status" == "unchanged" ]]; then
+    register_managed_file "$dest" "$source_ref" "internal" false
+  else
+    register_managed_file "$dest" "$source_ref" "internal"
+  fi
 }
 
 write_agentic_manifest() {
@@ -767,7 +973,7 @@ write_agentic_manifest() {
     : > "$skipped_file"
   fi
 
-  local agent_os_csv areas_csv specs_csv
+  local agent_os_csv areas_csv specs_csv mcp_integrations_csv
   local old_ifs="$IFS"
   IFS=,
   agent_os_csv="${SELECTED_AGENT_OS[*]}"
@@ -775,7 +981,21 @@ write_agentic_manifest() {
   specs_csv="${SELECTED_SPECS[*]}"
   IFS="$old_ifs"
 
-  python3 - "$manifest" "$records_file" "$skipped_file" "$APP_REPO_LINK" "$REPO_ROOT" "$agent_os_csv" "$areas_csv" "$specs_csv" <<'PY'
+  # Build mcp_integrations list from current env selections
+  local mcp_integrations=()
+  if [[ "${AGENTIC_ENABLE_CONTEXT7:-}" =~ ^[Yy](es)?$ ]]; then
+    mcp_integrations+=("context7")
+  fi
+  if [[ "${AGENTIC_ENABLE_MEMPALACE:-}" =~ ^[Yy](es)?$ ]]; then
+    mcp_integrations+=("mempalace")
+  fi
+  old_ifs="$IFS"
+  IFS=,
+  mcp_integrations_csv="${mcp_integrations[*]:-}"
+  IFS="$old_ifs"
+
+  local manifest_status
+  manifest_status="$(python3 - "$manifest" "$records_file" "$skipped_file" "$APP_REPO_LINK" "$REPO_ROOT" "$agent_os_csv" "$areas_csv" "$specs_csv" "$(app_version_label)" "$mcp_integrations_csv" <<'PY'
 import json
 import sys
 from datetime import datetime, timezone
@@ -789,37 +1009,56 @@ repo_root = sys.argv[5]
 agent_os = [x for x in sys.argv[6].split(",") if x]
 areas = [x for x in sys.argv[7].split(",") if x]
 specs = [x for x in sys.argv[8].split(",") if x]
+app_version = sys.argv[9]
+mcp_integrations = [x for x in sys.argv[10].split(",") if x] if len(sys.argv) > 10 else []
 now = datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
 
 existing = {}
 created_at = now
+old_data = None
 if manifest.exists():
     try:
         old = json.loads(manifest.read_text(encoding="utf-8"))
+        old_data = old
         created_at = old.get("created_at", created_at)
         for item in old.get("managed_files", []):
             if item.get("path"):
                 existing[item["path"]] = item
     except Exception:
         existing = {}
+original_existing = json.loads(json.dumps(existing))
 
 for line in records_file.read_text(encoding="utf-8").splitlines():
     if not line:
         continue
     path, source, digest, marker = (line.split("|", 3) + ["", "", "", ""])[:4]
+    old_item = original_existing.get(path, {})
+    old_updated_at = old_item.get("updated_at", now)
+    if (
+        old_item.get("source") == source
+        and old_item.get("content_hash") == digest
+        and old_item.get("marker") == marker
+    ):
+        item_updated_at = old_updated_at
+    else:
+        item_updated_at = now
     existing[path] = {
         "path": path,
         "source": source,
         "content_hash": digest,
         "marker": marker,
-        "updated_at": now,
+        "updated_at": item_updated_at,
     }
 
 skipped = [x for x in skipped_file.read_text(encoding="utf-8").splitlines() if x]
+old_agentic = old_data.get("_agentic", {}) if isinstance(old_data, dict) else {}
+created_by = old_agentic.get("created_by", app_version)
 data = {
     "_agentic": {
         "generated_by": "agentic",
         "repository": repo_link,
+        "created_by": created_by,
+        "updated_by": app_version,
     },
     "version": 1,
     "created_at": created_at,
@@ -828,15 +1067,33 @@ data = {
         "agent_os": agent_os,
         "areas": areas,
         "specializations": specs,
+        "mcp_integrations": mcp_integrations,
         "source_repo": repo_link,
         "source_checkout": repo_root,
     },
     "managed_files": sorted(existing.values(), key=lambda x: x["path"]),
     "skipped_files": skipped,
 }
+
+if old_data is not None:
+    old_compare = json.loads(json.dumps(old_data))
+    new_compare = json.loads(json.dumps(data))
+    for payload in (old_compare, new_compare):
+        payload.pop("updated_at", None)
+        if isinstance(payload.get("_agentic"), dict):
+            payload["_agentic"].pop("updated_by", None)
+    if old_compare == new_compare:
+        print("unchanged")
+        raise SystemExit(0)
+
 manifest.write_text(json.dumps(data, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+print("written")
 PY
+)"
   rm -f "$records_file" "$skipped_file"
+  if [[ "$manifest_status" == "unchanged" ]]; then
+    return
+  fi
   unique_append "$manifest" COPIED_PATHS
 }
 
@@ -853,7 +1110,7 @@ from pathlib import Path
 
 data = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
 settings = data.get("settings", {})
-for key in ("agent_os", "areas", "specializations"):
+for key in ("agent_os", "areas", "specializations", "mcp_integrations"):
     print("::" + key)
     for value in settings.get(key, []):
         print(value)
@@ -864,17 +1121,20 @@ PY
   local loaded_agent_os=()
   local loaded_areas=()
   local loaded_specs=()
+  local loaded_mcp_integrations=()
   local value
   for value in "${values[@]}"; do
     case "$value" in
       "::agent_os") section="agent_os" ;;
       "::areas") section="areas" ;;
       "::specializations") section="specializations" ;;
+      "::mcp_integrations") section="mcp_integrations" ;;
       *)
         case "$section" in
           agent_os) loaded_agent_os+=("$value") ;;
           areas) loaded_areas+=("$value") ;;
           specializations) loaded_specs+=("$value") ;;
+          mcp_integrations) loaded_mcp_integrations+=("$value") ;;
         esac
         ;;
     esac
@@ -889,6 +1149,23 @@ PY
   if [[ "${#SELECTED_SPECS[@]}" -eq 0 && "${#loaded_specs[@]}" -gt 0 ]]; then
     SELECTED_SPECS=("${loaded_specs[@]}")
   fi
+
+  # Restore MCP integration selections so configure_*_if_needed skip interactive prompts
+  local mcp_item
+  for mcp_item in "${loaded_mcp_integrations[@]}"; do
+    case "$mcp_item" in
+      context7)
+        if [[ -z "${AGENTIC_ENABLE_CONTEXT7:-}" ]]; then
+          AGENTIC_ENABLE_CONTEXT7="y"
+        fi
+        ;;
+      mempalace)
+        if [[ -z "${AGENTIC_ENABLE_MEMPALACE:-}" ]]; then
+          AGENTIC_ENABLE_MEMPALACE="y"
+        fi
+        ;;
+    esac
+  done
 }
 
 path_ref_for_shell_export() {
@@ -976,9 +1253,10 @@ copy_dir_contents() {
 
   local event kind value events_file
   events_file="$(mktemp "${TMPDIR:-/tmp}/agentic-copy-events.XXXXXX")"
-  python3 - "$src" "$dest" "$REPO_ROOT" "$PROJECT_DIR" "$(project_manifest_path)" "$APP_REPO_LINK" > "$events_file" <<'PY'
+  python3 - "$src" "$dest" "$REPO_ROOT" "$PROJECT_DIR" "$(project_manifest_path)" "$APP_REPO_LINK" "$(app_version_label)" > "$events_file" <<'PY'
 import hashlib
 import json
+import re
 import sys
 from pathlib import Path
 
@@ -988,6 +1266,7 @@ repo_root = Path(sys.argv[3])
 project_dir = Path(sys.argv[4])
 manifest = Path(sys.argv[5])
 repo = sys.argv[6]
+version = sys.argv[7]
 
 
 def emit(kind: str, value: str) -> None:
@@ -1010,7 +1289,7 @@ if manifest.exists():
         for item in data.get("managed_files", []):
             rel = item.get("path")
             if rel:
-                managed[rel] = item.get("content_hash", "")
+                managed[rel] = item
     except Exception:
         managed = {}
 
@@ -1033,12 +1312,28 @@ def yaml_quote(value: str) -> str:
     return json.dumps(value, ensure_ascii=False)
 
 
-def markdown_with_marker(body: str, source_ref: str) -> str:
+def existing_created_by(target: Path) -> str:
+    if not target.exists():
+        return version
+    try:
+        old = target.read_text(encoding="utf-8")
+    except Exception:
+        return version
+    match = re.search(r"(?m)^  created_by:\s*(.+?)\s*$", old)
+    if not match:
+        return version
+    return match.group(1).strip().strip('"')
+
+
+def markdown_with_marker(body: str, source_ref: str, target: Path) -> str:
+    created_by = existing_created_by(target)
     block = (
         "agentic:\n"
         "  generated_by: agentic\n"
         f"  source: {yaml_quote(source_ref)}\n"
         f"  repository: {yaml_quote(repo)}\n"
+        f"  created_by: {yaml_quote(created_by)}\n"
+        f"  updated_by: {yaml_quote(version)}\n"
     )
     if body.startswith("---\n"):
         end = body.find("\n---", 4)
@@ -1061,7 +1356,7 @@ def add_marker(file_path: Path, target: Path, source_ref: str) -> str:
     text = file_path.read_text(encoding="utf-8")
     suffix = target.suffix.lower()
     if suffix == ".md":
-        return markdown_with_marker(text, source_ref)
+        return markdown_with_marker(text, source_ref, target)
     if suffix == ".json":
         data = json.loads(text)
         if not isinstance(data, dict):
@@ -1087,15 +1382,27 @@ for file_path in sorted(p for p in src.rglob("*") if p.is_file()):
                 emit("WARN", f"Skipping unmanaged target on rerun: {project_rel}")
                 emit("SKIP", project_rel)
                 continue
-        expected_hash = managed.get(project_rel, "")
+        managed_item = managed.get(project_rel, {})
+        if managed_item.get("marker") == "config":
+            continue
+        expected_hash = managed_item.get("content_hash", "")
         if target.exists() and expected_hash and sha256(target) != expected_hash:
             emit("WARN", f"Skipping user-modified managed file: {project_rel}")
             emit("SKIP", project_rel)
             continue
 
+    output = add_marker(file_path, target, source_ref)
     target.parent.mkdir(parents=True, exist_ok=True)
     emit("DIR", str(target.parent))
-    target.write_text(add_marker(file_path, target, source_ref), encoding="utf-8")
+    if target.exists():
+        try:
+            if target.read_text(encoding="utf-8") == output:
+                digest = sha256(target)
+                emit("RECORD", f"{project_rel}|{source_ref}|{digest}|internal")
+                continue
+        except UnicodeDecodeError:
+            pass
+    target.write_text(output, encoding="utf-8")
     digest = sha256(target)
     emit("RECORD", f"{project_rel}|{source_ref}|{digest}|internal")
     emit("COPIED", str(target))
@@ -1146,7 +1453,8 @@ write_json_file_with_agentic_metadata() {
 
   can_write_managed_file "$dest" || return 0
   ensure_dir "$(dirname -- "$dest")"
-  python3 - "$dest" "$source_ref" "$APP_REPO_LINK" "$CONTEXT7_API_KEY" "$python_body" <<'PY'
+  local write_status
+  write_status="$(python3 - "$dest" "$source_ref" "$APP_REPO_LINK" "$CONTEXT7_API_KEY" "$python_body" "$(app_version_label)" <<'PY'
 import json
 import sys
 from pathlib import Path
@@ -1156,11 +1464,15 @@ source_ref = sys.argv[2]
 repo = sys.argv[3]
 context7_api_key = sys.argv[4]
 body = sys.argv[5]
+version = sys.argv[6]
 
 data = {}
+created_by = version
 if path.exists():
     try:
         data = json.loads(path.read_text(encoding="utf-8"))
+        if isinstance(data, dict):
+            created_by = data.get("_agentic", {}).get("created_by", version)
     except Exception:
         data = {}
 if not isinstance(data, dict):
@@ -1172,9 +1484,28 @@ namespace = {
 }
 exec(body, namespace)
 data = namespace["data"]
+metadata = data.setdefault("_agentic", {})
+metadata["generated_by"] = "agentic"
+metadata["repository"] = repo
+metadata["created_by"] = created_by
+metadata["updated_by"] = version
+output = json.dumps(data, indent=2, ensure_ascii=False) + "\n"
+if path.exists():
+    try:
+        if path.read_text(encoding="utf-8") == output:
+            print("unchanged")
+            raise SystemExit(0)
+    except UnicodeDecodeError:
+        pass
 path.write_text(json.dumps(data, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+print("written")
 PY
-  register_managed_file "$dest" "$source_ref" "internal"
+)"
+  if [[ "$write_status" == "unchanged" ]]; then
+    register_managed_file "$dest" "$source_ref" "internal" false
+  else
+    register_managed_file "$dest" "$source_ref" "internal"
+  fi
 }
 
 write_json_config_file() {
@@ -1190,7 +1521,8 @@ write_json_config_file() {
 
   can_write_managed_file "$dest" || return 0
   ensure_dir "$(dirname -- "$dest")"
-  python3 - "$dest" "$CONTEXT7_API_KEY" "$python_body" <<'PY'
+  local write_status
+  write_status="$(python3 - "$dest" "$CONTEXT7_API_KEY" "$python_body" <<'PY'
 import json
 import sys
 from pathlib import Path
@@ -1214,9 +1546,62 @@ namespace = {
 }
 exec(body, namespace)
 data = namespace["data"]
-path.write_text(json.dumps(data, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+output = json.dumps(data, indent=2, ensure_ascii=False) + "\n"
+if path.exists():
+    try:
+        if path.read_text(encoding="utf-8") == output:
+            print("unchanged")
+            raise SystemExit(0)
+    except UnicodeDecodeError:
+        pass
+path.write_text(output, encoding="utf-8")
+print("written")
+PY
+)"
+  if [[ "$write_status" == "unchanged" ]]; then
+    register_managed_file "$dest" "$source_ref" "config" false
+  else
+    register_managed_file "$dest" "$source_ref" "config"
+  fi
+}
+
+write_text_config_file() {
+  local dest="$1"
+  local source_ref="$2"
+  local content="$3"
+
+  if [[ "$DRY_RUN" == true ]]; then
+    log "DRY-RUN write text config file $dest"
+    unique_append "$dest" COPIED_PATHS
+    return
+  fi
+
+  can_write_managed_file "$dest" || return 0
+  ensure_dir "$(dirname -- "$dest")"
+
+  local write_status
+  write_status="$(python3 - "$dest" "$content" <<'PY'
+import sys
+from pathlib import Path
+
+path = Path(sys.argv[1])
+content = sys.argv[2]
+if path.exists():
+    try:
+        if path.read_text(encoding="utf-8") == content:
+            print("unchanged")
+            raise SystemExit(0)
+    except UnicodeDecodeError:
+        pass
+path.write_text(content, encoding="utf-8")
+print("written")
 PY
-  register_managed_file "$dest" "$source_ref" "config"
+)"
+  if [[ "$write_status" == "unchanged" ]]; then
+    register_managed_file "$dest" "$source_ref" "config" false
+  else
+    register_managed_file "$dest" "$source_ref" "config"
+  fi
 }
 
 write_context7_opencode_config() {
@@ -1250,22 +1635,32 @@ if context7_api_key:
     context7["headers"] = {"CONTEXT7_API_KEY": context7_api_key}
 mcp["context7"] = context7
 '
-  write_json_file_with_agentic_metadata "$dest" "generated:context7-opencode-legacy-config" "$body"
+  write_json_config_file "$dest" "generated:context7-opencode-legacy-config" "$body"
 }
 
 write_context7_codex_config() {
   local dest="$PROJECT_DIR/.codex/config.toml"
-  local headers=""
-  if [[ -n "$CONTEXT7_API_KEY" ]]; then
-    local escaped_key
-    escaped_key="${CONTEXT7_API_KEY//\\/\\\\}"
-    escaped_key="${escaped_key//\"/\\\"}"
-    headers="http_headers = { \"CONTEXT7_API_KEY\" = \"$escaped_key\" }
-"
-  fi
-  write_generated_text_file "$dest" "generated:context7-codex-config" "[mcp_servers.context7]
-url = \"https://mcp.context7.com/mcp\"
-${headers}"
+  local body
+  body="$(python3 - "$dest" "$CONTEXT7_API_KEY" <<'PY'
+import re
+import sys
+from pathlib import Path
+
+path = Path(sys.argv[1])
+api_key = sys.argv[2]
+text = path.read_text(encoding="utf-8") if path.exists() else ""
+text = re.sub(r"(?ms)^\[mcp_servers\.context7\]\n.*?(?=^\[|\Z)", "", text).strip()
+block = '[mcp_servers.context7]\nurl = "https://mcp.context7.com/mcp"\n'
+if api_key:
+    escaped = api_key.replace("\\", "\\\\").replace('"', '\\"')
+    block += f'http_headers = {{ "CONTEXT7_API_KEY" = "{escaped}" }}\n'
+if text:
+    print(block + "\n" + text.rstrip() + "\n", end="")
+else:
+    print(block, end="")
+PY
+)"
+  write_text_config_file "$dest" "generated:context7-codex-config" "$body"
 }
 
 write_context7_claude_config() {
@@ -1345,12 +1740,49 @@ mcp_servers["context7"] = context7
   write_json_config_file "$dest" "generated:context7-gemini-config" "$body"
 }
 
+print_context7_key_recommendation() {
+  [[ -z "$CONTEXT7_API_KEY" ]] || return 0
+
+  out "Context7 MCP configured without an API key."
+  out "To add a Context7 API key later, set CONTEXT7_API_KEY before rerunning agentic or edit the generated config:"
+
+  if selected_agent_os_contains "opencode"; then
+    out "  - $PROJECT_DIR/opencode.json"
+    out "  - $PROJECT_DIR/.opencode/opencode.json"
+    out '    Example: "headers": {"CONTEXT7_API_KEY": "ctx7_your_api_key_here"}'
+  fi
+  if selected_agent_os_contains "codex"; then
+    out "  - $PROJECT_DIR/.codex/config.toml"
+    out '    Example: http_headers = { "CONTEXT7_API_KEY" = "ctx7_your_api_key_here" }'
+  fi
+  if selected_agent_os_contains "claude"; then
+    out "  - $PROJECT_DIR/.mcp.json"
+    out '    Example: "headers": {"CONTEXT7_API_KEY": "ctx7_your_api_key_here"}'
+  fi
+  if selected_agent_os_contains "cursor"; then
+    out "  - $PROJECT_DIR/.cursor/mcp.json"
+    out '    Example: "headers": {"CONTEXT7_API_KEY": "ctx7_your_api_key_here"}'
+  fi
+  if selected_agent_os_contains "gemini"; then
+    out "  - $PROJECT_DIR/.gemini/settings.json"
+    out '    Example: "headers": {"CONTEXT7_API_KEY": "ctx7_your_api_key_here"}'
+  fi
+  if selected_agent_os_contains "kilocode"; then
+    out "  - $PROJECT_DIR/.kilocode/mcp.json"
+    out '    Example: "headers": {"CONTEXT7_API_KEY": "ctx7_your_api_key_here"}'
+  fi
+  if selected_agent_os_contains "antigravity"; then
+    out "  - $HOME/.gemini/antigravity/mcp_config.json"
+    out '    Example: "headers": {"CONTEXT7_API_KEY": "ctx7_your_api_key_here"}'
+  fi
+}
+
 write_mempalace_opencode_config() {
   local dest="$1"
   local body
   body='
 mcp = data.setdefault("mcp", {})
-mcp["mempalace"] = {"type": "local", "command": ["mempalace-mcp", "--palace", ".mempalace"]}
+mcp["mempalace"] = {"type": "local", "command": ["mempalace-mcp"]}
 '
   write_json_config_file "$dest" "generated:mempalace-opencode-config" "$body"
 }
@@ -1359,18 +1791,21 @@ write_mempalace_codex_config() {
   local dest="$PROJECT_DIR/.codex/config.toml"
   local body
   body="$(python3 - "$dest" <<'PYCODE'
-import pathlib, sys
+import re
+import pathlib
+import sys
+
 path = pathlib.Path(sys.argv[1])
 text = path.read_text(encoding='utf-8') if path.exists() else ''
-block = "[mcp_servers.mempalace]\ncommand = \"mempalace-mcp\"\nargs = [\"--palace\", \".mempalace\"]\n"
-if block not in text:
-    if text and not text.endswith("\n"):
-        text += "\n"
-    text += block
-print(text, end="")
+block = "[mcp_servers.mempalace]\ncommand = \"mempalace-mcp\"\n"
+text = re.sub(r"(?ms)^\[mcp_servers\.mempalace\]\n.*?(?=^\[|\Z)", "", text).strip()
+if text:
+    print(text.rstrip() + "\n\n" + block, end="")
+else:
+    print(block, end="")
 PYCODE
 )"
-  write_generated_text_file "$dest" "generated:mempalace-codex-config" "$body"
+  write_text_config_file "$dest" "generated:mempalace-codex-config" "$body"
 }
 
 write_mempalace_generic_json_config() {
@@ -1379,74 +1814,204 @@ write_mempalace_generic_json_config() {
   local body
   body='
 servers = data.setdefault("mcpServers", {})
-servers["mempalace"] = {"command": "mempalace-mcp", "args": ["--palace", ".mempalace"]}
+servers["mempalace"] = {"command": "mempalace-mcp"}
 '
   write_json_config_file "$dest" "$marker" "$body"
 }
 
 print_mempalace_project_setup_instructions() {
-  log "MemPalace setup instructions for target project: $PROJECT_DIR"
-  cat <<EOF
-1) Ensure Python is installed and available in PATH.
-2) Install MemPalace:
-   pip install mempalace
-3) Initialize project-local MemPalace cache:
-   mkdir -p "$PROJECT_DIR/.mempalace"
-   mempalace init "$PROJECT_DIR/.mempalace" --yes --auto-mine
-4) Index existing project memory:
-   # optional if --auto-mine was skipped
-   mempalace mine "$PROJECT_DIR/.mempalace"
-5) Verify in your IDE/agent that MemPalace MCP tools are connected.
-Note: Ollama at localhost:11434 is optional; MemPalace can run heuristics-only without it.
-EOF
-}
-
-setup_mempalace_for_agentic_opencode() {
+  log "Optional MemPalace project indexing instructions for target project: $PROJECT_DIR"
+  out "1) Ensure Python is installed and available in PATH."
+  out "2) Install MemPalace:"
+  out "   pip install mempalace"
+  out "3) Optionally initialize project-local MemPalace cache:"
+  out "   mempalace init \"$PROJECT_DIR\" --yes --auto-mine"
+  out "4) Optionally index existing project memory:"
+  out "   # optional if --auto-mine was skipped"
+  out "   mempalace mine \"$PROJECT_DIR\""
+  out "5) Verify in your IDE/agent that MemPalace MCP tools are connected."
+  out "Note: Ollama at localhost:11434 is optional; MemPalace can run heuristics-only without it."
+}
+
+write_mempalace_ignore_file() {
+  local dest="$PROJECT_DIR/.mempalaceignore"
+  local content
+  content='node_modules/
+.venv/
+venv/
+dist/
+build/
+target/
+coverage/
+.git/
+
+*.csv
+*.parquet
+*.log
+*.jsonl
+
+data/
+tmp/
+'
+
+  if [[ -e "$dest" ]]; then
+    log "MemPalace ignore file already exists: $dest"
+    return 0
+  fi
+
+  write_text_config_file "$dest" "generated:mempalace-ignore" "$content"
+}
+
+warn_mempalace_failure_reason() {
+  local output_file="$1"
+  [[ -f "$output_file" ]] || return 0
+
+  if grep -Fq "incompatible architecture" "$output_file" && grep -Fq "numpy" "$output_file"; then
+    warn "MemPalace failed because Python/NumPy architecture is inconsistent. Reinstall MemPalace dependencies with the same architecture as the Python running 'mempalace'."
+    warn "Typical fix: reinstall numpy/chromadb/mempalace in the active Python environment, or use a matching arm64/x86_64 Python. See the MemPalace log above for the exact Python path."
+    return 0
+  fi
+
+  if grep -Fq "No LLM provider reachable" "$output_file"; then
+    warn "MemPalace could not reach an LLM provider and continued heuristics-only; this is non-fatal unless a later dependency error appears."
+  fi
+}
+
+run_mempalace_command() {
+  local label="$1"
+  shift
+  local output_file
+  output_file="$(mktemp "${TMPDIR:-/tmp}/agentic-mempalace.XXXXXX")"
+  if "$@" >"$output_file" 2>&1; then
+    log "$label completed"
+    log_file_block "$label" "$output_file"
+    rm -f "$output_file"
+    return 0
+  fi
+
+  warn "Failed: $* (log: $output_file)"
+  log_file_block "$label" "$output_file"
+  warn_mempalace_failure_reason "$output_file"
+  return 1
+}
+
+mempalace_venv_dir() {
+  printf '%s\n' "${AGENTIC_MEMPALACE_VENV:-$HOME/.venvs/mempalace}"
+}
+
+mempalace_bin_dir() {
+  printf '%s\n' "${AGENTIC_MEMPALACE_BIN_DIR:-$HOME/.local/bin}"
+}
+
+python3_command() {
+  if command -v python3 >/dev/null 2>&1; then
+    printf '%s\n' "python3"
+    return 0
+  fi
+  if command -v python >/dev/null 2>&1; then
+    printf '%s\n' "python"
+    return 0
+  fi
+  return 1
+}
+
+install_mempalace_managed() {
+  local py_bin venv_dir bin_dir venv_python venv_mempalace
+
+  py_bin="$(python3_command)" || return 1
+  venv_dir="$(mempalace_venv_dir)"
+  bin_dir="$(mempalace_bin_dir)"
+
+  mkdir -p "$(dirname "$venv_dir")" "$bin_dir"
+
+  if [[ ! -x "$venv_dir/bin/python" ]]; then
+    "$py_bin" -m venv "$venv_dir" || return 1
+  fi
+
+  venv_python="$venv_dir/bin/python"
+  venv_mempalace="$venv_dir/bin/mempalace"
+
+  "$venv_python" -m pip install --upgrade pip setuptools wheel >/dev/null 2>&1 || return 1
+  "$venv_python" -m pip install --upgrade --no-cache-dir mempalace >/dev/null 2>&1 || return 1
+
+  [[ -x "$venv_mempalace" ]] || return 1
+
+  ln -sf "$venv_mempalace" "$bin_dir/mempalace"
+
+  if [[ -x "$venv_dir/bin/mempalace-mcp" ]]; then
+    ln -sf "$venv_dir/bin/mempalace-mcp" "$bin_dir/mempalace-mcp"
+  fi
+
+  export PATH="$bin_dir:$PATH"
+
+  command -v mempalace >/dev/null 2>&1
+}
+
+initialize_mempalace_project() {
+  local step_prefix="$1"
+  log "$step_prefix [4/4] Initializing project memory at $PROJECT_DIR"
+  if ! command -v mempalace >/dev/null 2>&1; then
+    warn "mempalace command is unavailable after install; please run setup manually"
+    print_mempalace_project_setup_instructions
+    return 1
+  fi
+
+  if ! run_mempalace_command "MemPalace init" mempalace init "$PROJECT_DIR" --yes --auto-mine; then
+    print_mempalace_project_setup_instructions
+    return 1
+  fi
+  log "$step_prefix [4/4] Initialization step finished"
+}
+
+setup_mempalace_for_agentic() {
+  local initialize_project="${1:-false}"
   local step_prefix="MemPalace setup"
 
   log "$step_prefix [1/4] Checking Python availability"
   if ! command -v python3 >/dev/null 2>&1 && ! command -v python >/dev/null 2>&1; then
     warn "Python is not installed. Install Python 3 first, then run: pip install mempalace"
     warn "Install help: https://www.python.org/downloads/"
+    print_mempalace_project_setup_instructions
     return 1
   fi
   log "$step_prefix [1/4] Python check passed"
 
+  if [[ -z "${AGENTIC_TEST_SOURCE_AGENTIC:-}" ]] && command -v mempalace-mcp >/dev/null 2>&1; then
+    if [[ "$initialize_project" != "true" ]] || command -v mempalace >/dev/null 2>&1; then
+      log "$step_prefix [2/4] MemPalace binaries already available; skipping pip install"
+      if [[ "$initialize_project" != "true" ]]; then
+        log "$step_prefix [4/4] Project memory initialization skipped for selected agent target(s)"
+        return 0
+      fi
+      initialize_mempalace_project "$step_prefix"
+      return $?
+    fi
+  fi
+
   log "$step_prefix [2/4] Checking pip availability"
-  if ! command -v pip >/dev/null 2>&1 && ! command -v pip3 >/dev/null 2>&1; then
+  local pip_bin
+  if ! pip_bin="$(pip_command)"; then
     warn "pip is not available. Install pip for Python 3, then run: pip install mempalace"
+    print_mempalace_project_setup_instructions
     return 1
   fi
   log "$step_prefix [2/4] pip check passed"
 
   log "$step_prefix [3/4] Installing mempalace package"
-  if pip install mempalace >/dev/null 2>&1; then
-    log "MemPalace package installed via 'pip install mempalace'"
+  if $pip_bin install mempalace >/dev/null 2>&1; then
+    log "MemPalace package installed via '$pip_bin install mempalace'"
   else
     warn "Unable to auto-install mempalace via pip; continuing with manual setup instructions"
     print_mempalace_project_setup_instructions
     return 1
   fi
 
-  log "$step_prefix [4/4] Initializing project memory at $PROJECT_DIR/.mempalace"
-  if command -v mempalace >/dev/null 2>&1; then
-    mkdir -p "$PROJECT_DIR/.mempalace" || warn "Failed: mkdir -p \"$PROJECT_DIR/.mempalace\""
-    if mempalace init "$PROJECT_DIR/.mempalace" --yes --auto-mine >/dev/null 2>&1; then
-      log "MemPalace init completed"
-    else
-      warn "Failed: mempalace init \"$PROJECT_DIR/.mempalace\" --yes --auto-mine"
-    fi
-    if mempalace mine "$PROJECT_DIR/.mempalace" >/dev/null 2>&1; then
-      log "MemPalace mine completed"
-    else
-      warn "Failed: mempalace mine \"$PROJECT_DIR/.mempalace\""
-    fi
-    log "$step_prefix [4/4] Initialization step finished"
-  else
-    warn "mempalace command is unavailable after install; please run setup manually"
-    print_mempalace_project_setup_instructions
-    return 1
+  if [[ "$initialize_project" != "true" ]]; then
+    log "$step_prefix [4/4] Project memory initialization skipped for selected agent target(s)"
+    return 0
   fi
+
+  initialize_mempalace_project "$step_prefix"
 }
 
 configure_mempalace_if_needed() {
@@ -1455,6 +2020,7 @@ configure_mempalace_if_needed() {
     && ! selected_agent_os_contains "claude" \
     && ! selected_agent_os_contains "cursor" \
     && ! selected_agent_os_contains "gemini" \
+    && ! selected_agent_os_contains "kilocode" \
     && ! selected_agent_os_contains "antigravity"; then
     return
   fi
@@ -1464,28 +2030,26 @@ configure_mempalace_if_needed() {
     enable_mempalace="$(trim "${AGENTIC_ENABLE_MEMPALACE}")"
   elif is_interactive_terminal && [[ -z "${AGENTIC_TEST_SOURCE_AGENTIC:-}" ]]; then
     read -r -p "Enable MemPalace MCP memory integration? [y/N]: " enable_mempalace
-    enable_mempalace="$(trim "${enable_mempalace:-y}")"
-    if [[ -z "$enable_mempalace" ]]; then enable_mempalace="y"; fi
+    enable_mempalace="$(trim "${enable_mempalace:-n}")"
+    if [[ -z "$enable_mempalace" ]]; then enable_mempalace="n"; fi
   fi
   if [[ "$enable_mempalace" =~ ^[Nn]$ ]]; then
     log "Skipped MemPalace MCP configuration"
     return
   fi
 
-  if selected_agent_os_contains "opencode"; then
-    setup_mempalace_for_agentic_opencode || true
-  else
-    print_mempalace_project_setup_instructions
-  fi
+  write_mempalace_ignore_file
 
-  if command -v mempalace-mcp >/dev/null 2>&1; then
-    if mempalace-mcp --help >/dev/null 2>&1; then
-      log "MemPalace MCP runtime check succeeded via 'mempalace-mcp'"
-    else
-      warn "MemPalace MCP runtime check failed; continuing without runtime validation"
+  local initialize_mempalace_project="true"
+  local mempalace_setup_ok="true"
+  setup_mempalace_for_agentic "$initialize_mempalace_project" || mempalace_setup_ok="false"
+
+  if [[ "$mempalace_setup_ok" != "true" ]]; then
+    if ! command -v mempalace-mcp >/dev/null 2>&1; then
+      warn "mempalace-mcp is unavailable; install/repair MemPalace and re-run setup"
     fi
   else
-    warn "mempalace-mcp is unavailable; install/repair MemPalace and re-run setup"
+    log "MemPalace MCP binary found: mempalace-mcp"
   fi
 
   if selected_agent_os_contains "opencode"; then
@@ -1502,6 +2066,9 @@ configure_mempalace_if_needed() {
   if selected_agent_os_contains "gemini"; then
     write_mempalace_generic_json_config "$PROJECT_DIR/.gemini/settings.json" "generated:mempalace-gemini-config"
   fi
+  if selected_agent_os_contains "kilocode"; then
+    write_mempalace_generic_json_config "$PROJECT_DIR/.kilocode/mcp.json" "generated:mempalace-kilocode-config"
+  fi
   if selected_agent_os_contains "antigravity"; then
     write_mempalace_generic_json_config "$HOME/.gemini/antigravity/mcp_config.json" "generated:mempalace-antigravity-config"
   fi
@@ -1518,18 +2085,25 @@ configure_context7_if_needed() {
     return
   fi
 
-  if is_interactive_terminal; then
-    local enable_context7 answer
-    read -r -p "Enable Context7 MCP configuration? [y/N]: " enable_context7
+  local enable_context7="${AGENTIC_ENABLE_CONTEXT7:-}"
+  if [[ -n "$enable_context7" ]]; then
     enable_context7="$(trim "$enable_context7")"
+  fi
+
+  if is_interactive_terminal; then
+    if [[ -z "$enable_context7" ]]; then
+      read -r -p "Enable Context7 MCP configuration? [y/N]: " enable_context7
+      enable_context7="$(trim "$enable_context7")"
+    fi
     if [[ ! "$enable_context7" =~ ^[Yy]$ ]]; then
       log "Context7 MCP configuration disabled"
       return
     fi
 
-    if [[ -z "$CONTEXT7_API_KEY" ]]; then
-      read -r -p "Context7 API key (optional, empty = no key): " answer
-      CONTEXT7_API_KEY="$(trim "$answer")"
+  elif [[ -n "$enable_context7" ]]; then
+    if [[ ! "$enable_context7" =~ ^[Yy]$ ]]; then
+      log "Context7 MCP configuration disabled"
+      return
     fi
   elif [[ -z "$CONTEXT7_API_KEY" ]]; then
     log "Context7 MCP configuration skipped; set CONTEXT7_API_KEY or use an interactive install to enable it"
@@ -1564,6 +2138,8 @@ configure_context7_if_needed() {
   if selected_agent_os_contains "antigravity"; then
     write_context7_antigravity_config
   fi
+
+  print_context7_key_recommendation
 }
 
 write_default_opencode_plugin_config() {
@@ -1578,8 +2154,8 @@ from pathlib import Path
 
 path = Path(sys.argv[1])
 path.write_text(json.dumps({
-    "telegram": {"enabled": False, "botToken": "", "chatId": ""},
-    "modelChecker": {"enabled": False},
+    "telegram": {"enabled": False},
+    "agentModelMapper": {"enabled": False},
 }, indent=2) + "\n", encoding="utf-8")
 PY
   fi
@@ -1596,6 +2172,12 @@ configure_opencode_plugins_if_needed() {
   ensure_python_available
   ensure_dir "$APP_CONFIG_DIR"
 
+  # During upgrade/re-install with existing plugin config, keep current settings
+  if [[ -f "$OPENCODE_PLUGIN_CONFIG_FILE" && ( -n "${AGENTIC_ENABLE_MEMPALACE:-}" || -n "${AGENTIC_ENABLE_CONTEXT7:-}" ) ]]; then
+    log "OpenCode plugin config already exists; keeping current settings"
+    return
+  fi
+
   if ! is_interactive_terminal; then
     if [[ ! -f "$OPENCODE_PLUGIN_CONFIG_FILE" ]]; then
       write_default_opencode_plugin_config
@@ -1603,42 +2185,378 @@ configure_opencode_plugins_if_needed() {
     return
   fi
 
-  local enable_telegram telegram_token telegram_chat enable_model_checker
-  read -r -p "Enable OpenCode Telegram notifications? [y/N]: " enable_telegram
-  enable_telegram="$(trim "$enable_telegram")"
-  telegram_token=""
-  telegram_chat=""
-  if [[ "$enable_telegram" =~ ^[Yy]$ ]]; then
-    read -r -p "Telegram bot token (empty disables plugin): " telegram_token
-    read -r -p "Telegram chat id (empty disables plugin): " telegram_chat
-    telegram_token="$(trim "$telegram_token")"
-    telegram_chat="$(trim "$telegram_chat")"
+  local plugin_options=("telegram-opencode-notifier" "agent-model-mapper")
+  local selected_plugins=()
+  local use_fzf_plugins=false
+  if fzf_available; then
+    use_fzf_plugins=true
+  elif ensure_fzf_or_fallback; then
+    use_fzf_plugins=true
   fi
 
-  read -r -p "Enable OpenCode model checker plugin? [y/N]: " enable_model_checker
-  enable_model_checker="$(trim "$enable_model_checker")"
+  if [[ "$use_fzf_plugins" == true ]]; then
+    readlines selected_plugins < <(choose_multi_fzf_strict "Select optional OpenCode plugin(s):" "${plugin_options[@]}")
+  else
+    local selected_plugins_output
+    selected_plugins_output="$(choose_multi_by_index "Select optional OpenCode plugin(s):" "${plugin_options[@]}")"
+    readlines selected_plugins <<< "$selected_plugins_output"
+  fi
+
+  local enable_telegram="n" enable_agent_model_mapper="n"
+  local selected_plugin
+  for selected_plugin in "${selected_plugins[@]}"; do
+    selected_plugin="$(trim "$selected_plugin")"
+    [[ -z "$selected_plugin" ]] && continue
+    case "$selected_plugin" in
+      telegram-opencode-notifier) enable_telegram="y" ;;
+      agent-model-mapper) enable_agent_model_mapper="y" ;;
+    esac
+  done
+
+  if [[ "$enable_telegram" =~ ^[Yy]$ ]]; then
+    log "Telegram plugin enabled; credentials are read only from OPENCODE_TELEGRAM_BOT_TOKEN and OPENCODE_TELEGRAM_CHAT_ID"
+  fi
 
-  python3 - "$OPENCODE_PLUGIN_CONFIG_FILE" "$telegram_token" "$telegram_chat" "$enable_model_checker" <<'PY'
+  python3 - "$OPENCODE_PLUGIN_CONFIG_FILE" "$enable_telegram" "$enable_agent_model_mapper" <<'PY'
 import json
 import sys
 from pathlib import Path
 
 path = Path(sys.argv[1])
-token = sys.argv[2]
-chat = sys.argv[3]
-enable_model = sys.argv[4].lower() == "y"
+enable_telegram = sys.argv[2].lower() == "y"
+enable_mapper = sys.argv[3].lower() == "y"
 data = {
     "telegram": {
-        "enabled": bool(token and chat),
-        "botToken": token,
-        "chatId": chat,
+        "enabled": enable_telegram,
     },
-    "modelChecker": {
-        "enabled": enable_model,
+    "agentModelMapper": {
+        "enabled": enable_mapper,
     },
 }
 path.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
 PY
+
+}
+
+opencode_agent_model_mapper_config_enabled() {
+  [[ -f "$OPENCODE_PLUGIN_CONFIG_FILE" ]] || return 1
+  python3 - "$OPENCODE_PLUGIN_CONFIG_FILE" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+try:
+    data = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
+except Exception:
+    raise SystemExit(1)
+raise SystemExit(0 if data.get("agentModelMapper", {}).get("enabled") is True else 1)
+PY
+}
+
+opencode_mapper_read_roles() {
+  local agents_dir="$PROJECT_DIR/.opencode/agents"
+  [[ -d "$agents_dir" ]] || return 0
+  python3 - "$agents_dir" <<'PY'
+import sys
+from pathlib import Path
+
+agents_dir = Path(sys.argv[1])
+
+def parse_frontmatter(text):
+    if not text.startswith("---\n"):
+        return {}
+    end = text.find("\n---", 4)
+    if end == -1:
+        return {}
+    result = {}
+    for line in text[4:end].splitlines():
+        if ":" not in line:
+            continue
+        key, value = line.split(":", 1)
+        result[key.strip()] = value.strip().strip("'\"")
+    return result
+
+for path in sorted(agents_dir.glob("*.md")):
+    frontmatter = parse_frontmatter(path.read_text(encoding="utf-8"))
+    name = path.stem.replace("\t", " ")
+    mode = (frontmatter.get("mode") or "subagent").replace("\t", " ")
+    description = (frontmatter.get("description") or "OpenCode agent").replace("\t", " ")
+    print(f"{name}\t{mode}\t{description}")
+PY
+}
+
+opencode_mapper_discover_models() {
+  local config_path="$HOME/.config/opencode/opencode.json"
+  python3 - "$config_path" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+fallback = ["opencode/minimax-m2.5-free"]
+path = Path(sys.argv[1])
+models = []
+
+def collect_provider_models(data):
+    """Extract models from provider.<name>.models dict keys."""
+    providers = data.get("provider")
+    if not isinstance(providers, dict):
+        return
+    for provider_name, provider_data in providers.items():
+        if not isinstance(provider_data, dict):
+            continue
+        provider_models = provider_data.get("models")
+        if not isinstance(provider_models, dict):
+            continue
+        for model_name in provider_models:
+            if isinstance(model_name, str) and model_name.strip():
+                models.append(f"{provider_name}/{model_name}")
+
+def collect(value):
+    if isinstance(value, list):
+        for item in value:
+            collect(item)
+        return
+    if not isinstance(value, dict):
+        return
+    for key, item in value.items():
+        if key in {"model", "id"} and isinstance(item, str) and "/" in item:
+            models.append(item)
+        if key == "fallback" and isinstance(item, list):
+            models.extend(model for model in item if isinstance(model, str))
+        collect(item)
+
+try:
+    data = json.loads(path.read_text(encoding="utf-8"))
+    collect_provider_models(data)
+    collect(data)
+except Exception:
+    pass
+
+seen = set()
+for model in models or fallback:
+    model = model.strip()
+    if model and model not in seen:
+        seen.add(model)
+        print(model)
+PY
+}
+
+opencode_mapper_has_complete_mapping() {
+  local roles_file="$1"
+  local config_path="$PROJECT_DIR/.opencode/opencode.json"
+  local state_path="$PROJECT_DIR/.opencode/agent-model-mapper.state.json"
+  python3 - "$roles_file" "$config_path" "$state_path" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+roles_file, config_path, state_path = map(Path, sys.argv[1:])
+try:
+    state = json.loads(state_path.read_text(encoding="utf-8"))
+    config = json.loads(config_path.read_text(encoding="utf-8"))
+except Exception:
+    raise SystemExit(1)
+if not state.get("configured"):
+    raise SystemExit(1)
+agents = config.get("agent")
+if not isinstance(agents, dict):
+    raise SystemExit(1)
+roles = [line.split("\t", 1)[0] for line in roles_file.read_text(encoding="utf-8").splitlines() if line]
+for role in roles:
+    agent = agents.get(role)
+    if not isinstance(agent, dict) or not str(agent.get("model", "")).strip():
+        raise SystemExit(1)
+raise SystemExit(0)
+PY
+}
+
+choose_opencode_mapper_model() {
+  local role_name="$1"
+  local role_mode="$2"
+  local role_description="$3"
+  local kind="$4"
+  shift 4
+  local models=("$@")
+
+  if [[ "${AGENTIC_AGENT_MODEL_MAPPER_NO_FZF:-}" != "1" ]] && fzf_available; then
+    local selected selected_model fzf_status
+    set +e
+    selected="$(for i in "${!models[@]}"; do printf '%s\t%s\n' "$((i + 1))" "${models[$i]}"; done | fzf \
+      --ansi \
+      --border \
+      --height=70% \
+      --layout=reverse \
+      --no-sort \
+      --prompt "$role_name $kind> " \
+      --header "Select $kind model for $role_name" \
+      --with-nth=2..)"
+    fzf_status=$?
+    set -e
+    if [[ "$fzf_status" -eq 0 && -n "$(trim "$selected")" ]]; then
+      selected_model="${selected#*	}"
+      local model
+      for model in "${models[@]}"; do
+        if [[ "$model" == "$selected_model" ]]; then
+          printf '%s\n' "$selected_model"
+          return 0
+        fi
+      done
+    fi
+  fi
+
+  echo >&2
+  echo "$role_name ($role_mode) - $role_description" >&2
+  local i
+  for i in "${!models[@]}"; do
+    echo "  $((i + 1))) ${models[$i]}" >&2
+  done
+  local answer
+  read -r -p "Select $kind model for $role_name [1]: " answer
+  answer="$(trim "$answer")"
+  if [[ -z "$answer" ]]; then
+    printf '%s\n' "${models[0]}"
+    return 0
+  fi
+  if [[ "$answer" =~ ^[0-9]+$ ]] && (( answer >= 1 && answer <= ${#models[@]} )); then
+    printf '%s\n' "${models[$((answer - 1))]}"
+    return 0
+  fi
+  local model
+  for model in "${models[@]}"; do
+    if [[ "$model" == "$answer" ]]; then
+      printf '%s\n' "$answer"
+      return 0
+    fi
+  done
+  warn "Unknown model '$answer', using ${models[0]}"
+  printf '%s\n' "${models[0]}"
+}
+
+write_opencode_agent_model_mapping() {
+  local roles_file="$1"
+  local mapping_file="$2"
+  local config_path="$PROJECT_DIR/.opencode/opencode.json"
+  local state_path="$PROJECT_DIR/.opencode/agent-model-mapper.state.json"
+
+  python3 - "$roles_file" "$mapping_file" "$config_path" "$state_path" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+roles_file, mapping_file, config_path, state_path = map(Path, sys.argv[1:])
+roles = []
+for line in roles_file.read_text(encoding="utf-8").splitlines():
+    if not line:
+        continue
+    name, mode, description = (line.split("\t") + ["", "", ""])[:3]
+    roles.append({"name": name, "mode": mode, "description": description})
+
+mapping = {}
+for line in mapping_file.read_text(encoding="utf-8").splitlines():
+    if not line:
+        continue
+    name, model, fallback = (line.split("\t") + ["", "", ""])[:3]
+    mapping[name] = {"model": model, "fallback": [fallback] if fallback and fallback != model else []}
+
+try:
+    data = json.loads(config_path.read_text(encoding="utf-8"))
+except Exception:
+    data = {}
+if not isinstance(data, dict):
+    data = {}
+agents = data.setdefault("agent", {})
+for role in roles:
+    selected = mapping.get(role["name"])
+    if not selected:
+        continue
+    current = agents.get(role["name"])
+    if not isinstance(current, dict):
+        current = {}
+    current.update({
+        "mode": current.get("mode") or role["mode"],
+        "description": current.get("description") or role["description"],
+        "model": selected["model"],
+        "fallback": selected["fallback"],
+    })
+    agents[role["name"]] = current
+
+config_path.write_text(json.dumps(data, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+state_path.write_text(json.dumps({
+    "configured": True,
+    "roles": [role["name"] for role in roles],
+}, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+PY
+
+  register_managed_file "$config_path" "generated:opencode-agent-model-mapper-config" "config"
+  register_managed_file "$state_path" "generated:opencode-agent-model-mapper-state" "config"
+}
+
+configure_opencode_agent_model_mapper_if_needed() {
+  selected_agent_os_contains "opencode" || return 0
+  opencode_agent_model_mapper_config_enabled || return 0
+
+  if ! is_interactive_terminal; then
+    log "agent-model-mapper install-time setup skipped because no interactive terminal is available"
+    return 0
+  fi
+
+  local config_path="$PROJECT_DIR/.opencode/opencode.json"
+  local state_path="$PROJECT_DIR/.opencode/agent-model-mapper.state.json"
+  can_write_managed_file "$config_path" || return 0
+  if [[ -e "$state_path" ]]; then
+    can_write_managed_file "$state_path" || return 0
+  fi
+
+  local roles_file models_file mapping_file
+  roles_file="$(mktemp "${TMPDIR:-/tmp}/agentic-opencode-roles.XXXXXX")"
+  models_file="$(mktemp "${TMPDIR:-/tmp}/agentic-opencode-models.XXXXXX")"
+  mapping_file="$(mktemp "${TMPDIR:-/tmp}/agentic-opencode-mapping.XXXXXX")"
+  opencode_mapper_read_roles > "$roles_file"
+
+  if [[ ! -s "$roles_file" ]]; then
+    log "agent-model-mapper: skipped because .opencode/agents/*.md was not found"
+    rm -f "$roles_file" "$models_file" "$mapping_file"
+    return 0
+  fi
+
+  if opencode_mapper_has_complete_mapping "$roles_file"; then
+    log "agent-model-mapper: skipped because all Agentic roles already have model mappings"
+    rm -f "$roles_file" "$models_file" "$mapping_file"
+    return 0
+  fi
+
+  opencode_mapper_discover_models > "$models_file"
+  local models=()
+  readlines models < "$models_file"
+  if [[ "${#models[@]}" -eq 0 ]]; then
+    models=("opencode/minimax-m2.5-free")
+  fi
+
+  out "agent-model-mapper: choose OpenCode models for Agentic roles"
+  local role_name role_mode role_description model fallback
+  exec 3<&0
+  while IFS=$'\t' read -r role_name role_mode role_description || [[ -n "${role_name:-}" ]]; do
+    [[ -n "$role_name" ]] || continue
+    model="$(choose_opencode_mapper_model "$role_name" "$role_mode" "$role_description" "main" "${models[@]}" <&3)"
+    fallback="$(choose_opencode_mapper_model "$role_name" "$role_mode" "$role_description" "fallback" "${models[@]}" <&3)"
+    printf '%s\t%s\t%s\n' "$role_name" "$model" "$fallback" >> "$mapping_file"
+  done < "$roles_file"
+
+  local confirm
+  if ! read -r -p "Write .opencode/opencode.json agent model mapping? [y/N]: " confirm <&3; then
+    confirm=""
+  fi
+  exec 3<&-
+  confirm="$(trim "$confirm")"
+  if [[ ! "$confirm" =~ ^[Yy]([Ee][Ss])?$ ]]; then
+    log "agent-model-mapper: skipped by user; no files changed"
+    rm -f "$roles_file" "$models_file" "$mapping_file"
+    return 0
+  fi
+
+  write_opencode_agent_model_mapping "$roles_file" "$mapping_file"
+  log "agent-model-mapper: updated .opencode/opencode.json"
+  rm -f "$roles_file" "$models_file" "$mapping_file"
 }
 
 normalize_selected_agent_os() {
@@ -1744,7 +2662,7 @@ build_header() {
   {
     echo "# Agentic Project Guidelines"
     echo
-    echo "Generated by $SCRIPT_NAME on $(date -u +'%Y-%m-%dT%H:%M:%SZ')."
+    echo "Generated by $SCRIPT_NAME."
     echo
     echo "## Installation Context"
     echo "- Agent OS targets: ${SELECTED_AGENT_OS[*]}"
@@ -1844,6 +2762,40 @@ generate_agents_md() {
   rm -f "$tmp"
 }
 
+copy_memory_md() {
+  local project_dir="$1"
+  local src="$REPO_ROOT/MEMORY.md"
+
+  if [[ ! -f "$src" ]]; then
+    warn "MEMORY.md not found in knowledge base at $src; skipping"
+    return
+  fi
+
+  local outputs=()
+
+  if selected_agent_os_contains "opencode"; then
+    unique_append "$project_dir/.opencode/MEMORY.md" outputs
+  fi
+
+  local needs_root=false
+  local agent_os
+  for agent_os in "${SELECTED_AGENT_OS[@]}"; do
+    if [[ "$agent_os" != "opencode" ]]; then
+      needs_root=true
+      break
+    fi
+  done
+
+  if [[ "$needs_root" == true ]] || ! selected_agent_os_contains "opencode"; then
+    unique_append "$project_dir/MEMORY.md" outputs
+  fi
+
+  local out
+  for out in "${outputs[@]}"; do
+    write_file_with_agentic_marker "$src" "$out" "generated:MEMORY.md"
+  done
+}
+
 validate_inputs() {
   local available_areas
   available_areas="$(list_areas || true)"
@@ -1911,37 +2863,47 @@ validate_inputs() {
 }
 
 print_report() {
-  echo
-  echo "${COLOR_HEADER}=== Installation report ===${COLOR_RESET}"
-  echo "Project dir: $PROJECT_DIR"
-  echo "Knowledge base repo: $REPO_ROOT"
-  echo "Config file: $APP_CONFIG_FILE"
-  echo "Agent OS targets: ${SELECTED_AGENT_OS[*]}"
-  echo "Areas: ${SELECTED_AREAS[*]}"
-  echo "Specializations: ${SELECTED_SPECS[*]}"
-
-  echo
-  echo "Created directories:"
+  out
+  out "=== Installation report ===" "$COLOR_HEADER"
+  out "Agentic version: $(app_version_label)"
+  out "Project dir: $PROJECT_DIR"
+  out "Knowledge base repo: $REPO_ROOT"
+  out "Config file: $APP_CONFIG_FILE"
+  out "Agent OS targets: ${SELECTED_AGENT_OS[*]}"
+  out "Areas: ${SELECTED_AREAS[*]}"
+  out "Specializations: ${SELECTED_SPECS[*]}"
+
+  out
+  out "Created directories:"
   if [[ "${#CREATED_PATHS[@]}" -eq 0 ]]; then
-    echo "- (none)"
+    out "- (none)"
   else
-    printf -- '- %s\n' "${CREATED_PATHS[@]}"
+    local created_path
+    for created_path in "${CREATED_PATHS[@]}"; do
+      out "- $created_path"
+    done
   fi
 
-  echo
-  echo "Copied/generated paths:"
+  out
+  out "Copied/generated paths:"
   if [[ "${#COPIED_PATHS[@]}" -eq 0 ]]; then
-    echo "- (none)"
+    out "- (none)"
   else
-    printf -- '- %s\n' "${COPIED_PATHS[@]}"
+    local copied_path
+    for copied_path in "${COPIED_PATHS[@]}"; do
+      out "- $copied_path"
+    done
   fi
 
-  echo
-  echo "Warnings:"
+  out
+  out "Warnings:"
   if [[ "${#WARNINGS[@]}" -eq 0 ]]; then
-    echo "- (none)"
+    out "- (none)"
   else
-    printf -- '- %s\n' "${WARNINGS[@]}"
+    local warning
+    for warning in "${WARNINGS[@]}"; do
+      out "- $warning"
+    done
   fi
 }
 
@@ -2004,27 +2966,289 @@ print_missing_agent_binary_guides() {
     return
   fi
 
-  echo
-  echo "${COLOR_HEADER}=== Agent binary setup recommendations ===${COLOR_RESET}"
-  printf '%s\n' "${missing_lines[@]}"
+  out
+  out "=== Agent binary setup recommendations ===" "$COLOR_HEADER"
+  local missing_line
+  for missing_line in "${missing_lines[@]}"; do
+    out "$missing_line"
+  done
+}
+
+changelog_file_path() {
+  local candidate
+  for candidate in "$SCRIPT_DIR/CHANGELOG.md" "$REPO_ROOT/CHANGELOG.md" "$APP_REPO_DIR/CHANGELOG.md"; do
+    [[ -f "$candidate" ]] || continue
+    printf '%s\n' "$candidate"
+    return 0
+  done
+  return 1
+}
+
+print_current_changelog() {
+  local changelog version
+  changelog="$(changelog_file_path || true)"
+  version="$(app_version_label)"
+  if [[ -z "$changelog" ]]; then
+    warn "CHANGELOG.md not found; skipping changelog output"
+    return
+  fi
+
+  local section_file
+  section_file="$(mktemp "${TMPDIR:-/tmp}/agentic-changelog.XXXXXX")"
+  awk -v wanted="## $version" '
+    $0 == wanted { in_section = 1; print; next }
+    in_section && /^## / { exit }
+    in_section { print }
+  ' "$changelog" > "$section_file"
+
+  if [[ ! -s "$section_file" ]]; then
+    rm -f "$section_file"
+    warn "No changelog section found for $version"
+    return
+  fi
+
+  out
+  out "=== Changelog $version ===" "$COLOR_HEADER"
+  while IFS= read -r line || [[ -n "$line" ]]; do
+    if [[ "$line" == "## $version" ]]; then
+      continue
+    fi
+    out "$line"
+  done < "$section_file"
+  rm -f "$section_file"
+}
+
+doctor_agent_supported() {
+  case "$1" in
+    codex|opencode|claude|gemini) return 0 ;;
+    *) return 1 ;;
+  esac
+}
+
+doctor_enabled() {
+  [[ "$DRY_RUN" != true ]] || return 1
+  [[ "${AGENTIC_DOCTOR:-1}" != "0" ]] || return 1
+  [[ "${AGENTIC_TEST_SOURCE_AGENTIC:-}" != "1" ]] || return 1
+  return 0
+}
+
+doctor_prompt() {
+  printf '%s\n' "/develop-feature напиши hello world python"
+}
+
+doctor_prompt_for_agent() {
+  local agent_os="$1"
+  case "$agent_os" in
+    opencode)
+      printf '%s\n' "Reply with exactly: AGENTIC_DOCTOR_OK"
+      ;;
+    *)
+      doctor_prompt
+      ;;
+  esac
+}
+
+doctor_smoke_label() {
+  local agent_os="$1"
+  case "$agent_os" in
+    opencode)
+      printf '%s\n' "lightweight smoke"
+      ;;
+    *)
+      printf '%s\n' "/develop-feature smoke"
+      ;;
+  esac
+}
+
+doctor_output_has_fatal_patterns() {
+  local output_file="$1"
+  grep -Eiq 'MCP.*(error|failed|failure|connection|connect|startup)|plugin.*(error|failed|failure)|auth.*(required|failed)|login required|permission.*(denied|required)|SyntaxError|Traceback|Invalid regular expression flags|An unexpected critical error occurred|FatalError|RuntimeError|EPERM|EACCES|panic:' "$output_file"
+}
+
+doctor_timeout_seconds() {
+  local value="${AGENTIC_DOCTOR_TIMEOUT_SECONDS:-10}"
+  if [[ ! "$value" =~ ^[0-9]+$ ]] || (( value < 1 )); then
+    value=10
+  fi
+  printf '%s\n' "$value"
+}
+
+run_with_doctor_timeout() {
+  local timeout_seconds="$1"
+  shift
+
+  "$@" &
+  local child_pid=$!
+  local elapsed=0
+  local status=0
+  while kill -0 "$child_pid" 2>/dev/null; do
+    if (( elapsed >= timeout_seconds )); then
+      pkill -TERM -P "$child_pid" 2>/dev/null || true
+      kill "$child_pid" 2>/dev/null || true
+      sleep 1
+      pkill -KILL -P "$child_pid" 2>/dev/null || true
+      kill -9 "$child_pid" 2>/dev/null || true
+      wait "$child_pid" 2>/dev/null || true
+      return 124
+    fi
+    sleep 1
+    elapsed=$((elapsed + 1))
+  done
+  wait "$child_pid"
+  status=$?
+  return "$status"
+}
+
+doctor_copy_project() {
+  local dest="$1"
+  mkdir -p "$dest"
+  if [[ -d "$PROJECT_DIR" ]]; then
+    cp -R "$PROJECT_DIR/." "$dest/"
+  fi
+}
+
+run_doctor_command() {
+  local agent_os="$1"
+  local work_dir="$2"
+  local output_file="$3"
+  local prompt
+  prompt="$(doctor_prompt_for_agent "$agent_os")"
+
+  case "$agent_os" in
+    codex)
+      codex exec --skip-git-repo-check --ephemeral --sandbox workspace-write -C "$work_dir" "$prompt" </dev/null >"$output_file" 2>&1
+      ;;
+    opencode)
+      OPENCODE_DISABLE_AUTOUPDATE=1 opencode run --pure --dir "$work_dir" --dangerously-skip-permissions --format json --log-level ERROR "$prompt" >"$output_file" 2>&1
+      ;;
+    claude)
+      (cd "$work_dir" && claude -p --permission-mode bypassPermissions --output-format stream-json "$prompt") >"$output_file" 2>&1
+      ;;
+    gemini)
+      (cd "$work_dir" && gemini --prompt "$prompt") >"$output_file" 2>&1
+      ;;
+    *)
+      return 2
+      ;;
+  esac
+}
+
+run_doctor_for_agent() {
+  local agent_os="$1"
+  local doctor_root="$2"
+  local binary_name
+  binary_name="$(get_agent_binary_name "$agent_os")"
+
+  if [[ -z "$binary_name" ]] || ! command -v "$binary_name" >/dev/null 2>&1; then
+    out "❌ $agent_os: binary '$binary_name' is not installed"
+    return 1
+  fi
+
+  local work_dir output_file status timeout_seconds started_at elapsed smoke_label
+  work_dir="$doctor_root/$agent_os"
+  output_file="$doctor_root/$agent_os.log"
+  timeout_seconds="$(doctor_timeout_seconds)"
+  smoke_label="$(doctor_smoke_label "$agent_os")"
+  doctor_copy_project "$work_dir"
+
+  set +e
+  started_at="$(date +%s)"
+  run_with_doctor_timeout "$timeout_seconds" run_doctor_command "$agent_os" "$work_dir" "$output_file"
+  status=$?
+  elapsed=$(( $(date +%s) - started_at ))
+  set -e
+
+  log "$agent_os doctor finished: timeout=${timeout_seconds}s exit=$status elapsed=${elapsed}s"
+
+  log_file_block "doctor $agent_os" "$output_file"
+
+  if [[ "$status" -eq 124 || "$status" -eq 137 ]]; then
+    out "❌ $agent_os: $smoke_label timed out after ${timeout_seconds}s (exit $status, elapsed ${elapsed}s, log: $output_file)"
+    return 1
+  fi
+
+  if [[ "$status" -ne 0 ]]; then
+    out "❌ $agent_os: $smoke_label failed (exit $status, elapsed ${elapsed}s, log: $output_file)"
+    return 1
+  fi
+
+  if doctor_output_has_fatal_patterns "$output_file"; then
+    out "❌ $agent_os: $smoke_label reported integration errors (exit $status, elapsed ${elapsed}s, log: $output_file)"
+    return 1
+  fi
+
+  out "✅ $agent_os: $smoke_label passed (exit $status, elapsed ${elapsed}s)"
+  return 0
+}
+
+run_agentic_doctor() {
+  if ! doctor_enabled; then
+    log "Agentic doctor skipped"
+    return
+  fi
+
+  local selected_doctor_agents=()
+  local agent_os
+  for agent_os in "${SELECTED_AGENT_OS[@]}"; do
+    if doctor_agent_supported "$agent_os"; then
+      selected_doctor_agents+=("$agent_os")
+    fi
+  done
+
+  if [[ "${#selected_doctor_agents[@]}" -eq 0 ]]; then
+    log "Agentic doctor skipped: no supported real agentos selected"
+    return
+  fi
+
+  local doctor_root
+  doctor_root="$(mktemp -d "${TMPDIR:-/tmp}/agentic-doctor.XXXXXX")"
+  out
+  out "=== Agentic doctor ===" "$COLOR_HEADER"
+  out "Doctor temp root: $doctor_root"
+  out "Doctor timeout: $(doctor_timeout_seconds)s per agent"
+
+  local failures=0
+  for agent_os in "${selected_doctor_agents[@]}"; do
+    if ! run_doctor_for_agent "$agent_os" "$doctor_root"; then
+      failures=$((failures + 1))
+    fi
+  done
+
+  if [[ "$AGENTIC_DOCTOR_KEEP_TMP" == "1" || "$failures" -gt 0 ]]; then
+    out "Doctor temp root kept: $doctor_root"
+  else
+    rm -rf "$doctor_root"
+  fi
+
+  if [[ "$failures" -gt 0 ]]; then
+    warn "Agentic doctor completed with $failures failing check(s)"
+  else
+    log "Agentic doctor completed successfully"
+  fi
 }
 
 run_install() {
+  init_run_logging
   ensure_repo_layout
-  ensure_python_available
+  ensure_agentic_runtime_requirements
   normalize_selected_agent_os
   validate_inputs
 
   ensure_dir "$PROJECT_DIR"
   configure_opencode_plugins_if_needed
   copy_extensions "$PROJECT_DIR"
+  configure_opencode_agent_model_mapper_if_needed
   copy_specialization_assets "$PROJECT_DIR"
   generate_agents_md "$PROJECT_DIR"
+  copy_memory_md "$PROJECT_DIR"
   configure_context7_if_needed
   configure_mempalace_if_needed
   write_agentic_manifest "$PROJECT_DIR"
   print_report
   print_missing_agent_binary_guides
+  print_current_changelog
+  run_agentic_doctor
+  out "Agentic log file: $RUN_LOG_FILE"
 }
 
 ascii_banner() {
@@ -2318,6 +3542,28 @@ choose_single_fzf() {
   printf '%s\n' "${options[@]}" | fzf "${fzf_args[@]}"
 }
 
+
+choose_multi_fzf_strict() {
+  local prompt="$1"
+  shift
+  local options=("$@")
+
+  if [[ "${#options[@]}" -eq 0 ]]; then
+    return
+  fi
+
+  local sentinel="<none>"
+  local picked=()
+  readlines picked < <(choose_multi_fzf "$prompt" "$sentinel" "${options[@]}")
+
+  local item
+  for item in "${picked[@]}"; do
+    item="$(trim "$item")"
+    [[ -z "$item" || "$item" == "$sentinel" ]] && continue
+    printf '%s\n' "$item"
+  done
+}
+
 choose_multi_fzf() {
   local prompt="$1"
   shift
@@ -2373,11 +3619,13 @@ run_tui() {
     exit 1
   fi
 
+  ensure_agentic_runtime_requirements
+
   pick_theme_if_needed
   set_theme_colors
 
   ascii_banner
-  echo "${COLOR_HEADER}$APP_TUI_TITLE${COLOR_RESET}"
+  echo "${COLOR_HEADER}$APP_TUI_TITLE $(app_version_label)${COLOR_RESET}"
   echo "${COLOR_DIM}Theme: $THEME (resolved: $ACTIVE_THEME)${COLOR_RESET}"
   echo
 
@@ -2413,6 +3661,26 @@ run_tui() {
     SELECTED_AGENT_OS=("${picked_agent_os[@]}")
   fi
 
+  local mcp_options=("context7" "mempalace")
+  local picked_mcps=()
+  if [[ "$use_fzf" == true ]]; then
+    readlines picked_mcps < <(choose_multi_fzf_strict "Select optional MCP integration(s):" "${mcp_options[@]}")
+  else
+    local picked_mcps_output
+    picked_mcps_output="$(choose_multi_by_index "Select optional MCP integration(s):" "<none>" "${mcp_options[@]}")"
+    readlines picked_mcps <<< "$picked_mcps_output"
+  fi
+
+  AGENTIC_ENABLE_CONTEXT7="n"
+  AGENTIC_ENABLE_MEMPALACE="n"
+  local picked_mcp
+  for picked_mcp in "${picked_mcps[@]}"; do
+    case "$picked_mcp" in
+      context7) AGENTIC_ENABLE_CONTEXT7="y" ;;
+      mempalace) AGENTIC_ENABLE_MEMPALACE="y" ;;
+    esac
+  done
+
   local areas=()
   readlines areas < <(list_areas)
 
@@ -2605,6 +3873,30 @@ sync_current_project_after_upgrade() {
   load_install_settings_from_manifest "$manifest"
   ensure_repo_layout
   run_install
+  upgrade_mempalace_graph
+}
+
+upgrade_mempalace_graph() {
+  # Only run if mempalace was enabled for this project
+  if [[ ! "${AGENTIC_ENABLE_MEMPALACE:-}" =~ ^[Yy] ]]; then
+    return
+  fi
+
+  if ! command -v mempalace >/dev/null 2>&1; then
+    return
+  fi
+
+  if [[ "$DRY_RUN" == true ]]; then
+    log "DRY-RUN mempalace mine \"$PROJECT_DIR\""
+    return
+  fi
+
+  log "Refreshing MemPalace knowledge graph for $PROJECT_DIR"
+  if mempalace mine "$PROJECT_DIR" >/dev/null 2>&1; then
+    log "MemPalace graph updated"
+  else
+    warn "mempalace mine failed; graph may be stale — run manually: mempalace mine \"$PROJECT_DIR\""
+  fi
 }
 
 parse_theme_option() {
@@ -2704,6 +3996,10 @@ case "$COMMAND" in
           DRY_RUN=true
           shift
           ;;
+        --no-doctor)
+          AGENTIC_DOCTOR=0
+          shift
+          ;;
         -h|--help)
           usage
           exit 0
@@ -2745,6 +4041,10 @@ case "$COMMAND" in
           DRY_RUN=true
           shift
           ;;
+        --no-doctor)
+          AGENTIC_DOCTOR=0
+          shift
+          ;;
         -h|--help)
           usage
           exit 0
@@ -2831,6 +4131,10 @@ case "$COMMAND" in
     usage
     ;;
 
+  -V|--version|version)
+    app_version_label
+    ;;
+
   *)
     usage
     exit 1