@jetrabbits/agentic 0.2.0 → 0.3.1

package/agentic

@@ -42,6 +42,7 @@ ACTIVE_THEME="dark"
 SELECTED_AGENT_OS=("$DEFAULT_AGENT_OS")
 SELECTED_AREAS=()
 SELECTED_SPECS=()
+INSTALL_SETTINGS_REPLAY=false
 
 SELF_INSTALL_FORCE=false
 SELF_INSTALL_BIN_DIR="${HOME}/.local/bin"
@@ -58,9 +59,18 @@ 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}"
+AGENTIC_MEMPALACE_TIMEOUT_SECONDS="${AGENTIC_MEMPALACE_TIMEOUT_SECONDS:-60}"
+
+OPENCODE_TELEGRAM_ENABLED=""
+OPENCODE_TELEGRAM_BOT_TOKEN=""
+OPENCODE_TELEGRAM_CHAT_ID=""
+OPENCODE_AGENT_MODEL_MAPPER_ENABLED=""
+OPENCODE_PLUGINS_CONFIGURED=false
 
 RUN_LOG_ACTIVE=false
 RUN_LOG_FILE=""
+CHANGED_PATHS_REPORT_FILE=""
 
 COLOR_RESET=""
 COLOR_HEADER=""
@@ -276,6 +286,7 @@ init_run_logging() {
   local stamp
   stamp="$(date '+%Y%m%d-%H%M%S')"
   RUN_LOG_FILE="$(mktemp "$base_dir/agentic-$stamp.XXXXXX")"
+  CHANGED_PATHS_REPORT_FILE="$RUN_LOG_FILE.changes"
   RUN_LOG_ACTIVE=true
   log "Run log initialized: $RUN_LOG_FILE"
 }
@@ -363,6 +374,55 @@ log_file_block() {
   write_run_log_line "$(timestamp_now) --- $label output end ---"
 }
 
+write_changed_paths_report() {
+  if [[ -z "$CHANGED_PATHS_REPORT_FILE" ]]; then
+    local base_dir="${TMPDIR:-/tmp}"
+    local stamp
+    stamp="$(date '+%Y%m%d-%H%M%S')"
+    CHANGED_PATHS_REPORT_FILE="$(mktemp "$base_dir/agentic-changed-paths-$stamp.XXXXXX")"
+  fi
+
+  {
+    printf 'Agentic changed paths report\n'
+    printf 'Generated at: %s\n' "$(timestamp_now)"
+    printf 'Project dir: %s\n' "$PROJECT_DIR"
+    printf 'Knowledge base repo: %s\n' "$REPO_ROOT"
+    printf '\n'
+
+    printf 'Created directories (%s)\n' "${#CREATED_PATHS[@]}"
+    if [[ "${#CREATED_PATHS[@]}" -eq 0 ]]; then
+      printf -- '- (none)\n'
+    else
+      local created_path
+      for created_path in "${CREATED_PATHS[@]}"; do
+        printf -- '- %s\n' "$created_path"
+      done
+    fi
+    printf '\n'
+
+    printf 'Copied/generated paths (%s)\n' "${#COPIED_PATHS[@]}"
+    if [[ "${#COPIED_PATHS[@]}" -eq 0 ]]; then
+      printf -- '- (none)\n'
+    else
+      local copied_path
+      for copied_path in "${COPIED_PATHS[@]}"; do
+        printf -- '- %s\n' "$copied_path"
+      done
+    fi
+    printf '\n'
+
+    printf 'Warnings (%s)\n' "${#WARNINGS[@]}"
+    if [[ "${#WARNINGS[@]}" -eq 0 ]]; then
+      printf -- '- (none)\n'
+    else
+      local warning
+      for warning in "${WARNINGS[@]}"; do
+        printf -- '- %s\n' "$warning"
+      done
+    fi
+  } > "$CHANGED_PATHS_REPORT_FILE"
+}
+
 unique_append() {
   local value="$1"
   local arr_name="$2"
@@ -972,7 +1032,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[*]}"
@@ -980,8 +1040,21 @@ write_agentic_manifest() {
   specs_csv="${SELECTED_SPECS[*]}"
   IFS="$old_ifs"
 
+  # 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)" <<'PY'
+  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" "$OPENCODE_TELEGRAM_ENABLED" "$OPENCODE_TELEGRAM_BOT_TOKEN" "$OPENCODE_TELEGRAM_CHAT_ID" "$OPENCODE_AGENT_MODEL_MAPPER_ENABLED" <<'PY'
 import json
 import sys
 from datetime import datetime, timezone
@@ -996,6 +1069,11 @@ 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 []
+telegram_enabled = sys.argv[11].lower() == "true" if len(sys.argv) > 11 and sys.argv[11] else None
+telegram_bot_token = sys.argv[12] if len(sys.argv) > 12 else ""
+telegram_chat_id = sys.argv[13] if len(sys.argv) > 13 else ""
+mapper_enabled = sys.argv[14].lower() == "true" if len(sys.argv) > 14 and sys.argv[14] else None
 now = datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
 
 existing = {}
@@ -1037,7 +1115,26 @@ for line in records_file.read_text(encoding="utf-8").splitlines():
 
 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 {}
+old_settings = old_data.get("settings", {}) if isinstance(old_data, dict) else {}
 created_by = old_agentic.get("created_by", app_version)
+opencode_plugins = old_settings.get("opencode_plugins", {}) if isinstance(old_settings, dict) else {}
+if not isinstance(opencode_plugins, dict):
+    opencode_plugins = {}
+telegram = opencode_plugins.get("telegram", {}) if isinstance(opencode_plugins.get("telegram"), dict) else {}
+agent_model_mapper = opencode_plugins.get("agentModelMapper", {}) if isinstance(opencode_plugins.get("agentModelMapper"), dict) else {}
+if telegram_enabled is not None:
+    telegram = {
+        "enabled": telegram_enabled,
+        "botToken": telegram_bot_token,
+        "chatId": telegram_chat_id,
+    }
+if mapper_enabled is not None:
+    agent_model_mapper = {"enabled": mapper_enabled}
+if telegram or agent_model_mapper:
+    opencode_plugins = {
+        "telegram": telegram or {"enabled": False},
+        "agentModelMapper": agent_model_mapper or {"enabled": False},
+    }
 data = {
     "_agentic": {
         "generated_by": "agentic",
@@ -1052,6 +1149,8 @@ data = {
         "agent_os": agent_os,
         "areas": areas,
         "specializations": specs,
+        "mcp_integrations": mcp_integrations,
+        "opencode_plugins": opencode_plugins,
         "source_repo": repo_link,
         "source_checkout": repo_root,
     },
@@ -1085,6 +1184,7 @@ load_install_settings_from_manifest() {
   local manifest="$1"
   [[ -f "$manifest" ]] || return 1
   ensure_python_available
+  INSTALL_SETTINGS_REPLAY=true
 
   local values=()
   readlines values < <(python3 - "$manifest" <<'PY'
@@ -1094,10 +1194,28 @@ 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)
+plugins = settings.get("opencode_plugins", {})
+if isinstance(plugins, dict):
+    telegram = plugins.get("telegram", {})
+    if isinstance(telegram, dict):
+        print("::opencode_telegram_enabled")
+        if telegram.get("enabled") is not None:
+            print("true" if telegram.get("enabled") is True else "false")
+        print("::opencode_telegram_bot_token")
+        if telegram.get("botToken"):
+            print(telegram.get("botToken"))
+        print("::opencode_telegram_chat_id")
+        if telegram.get("chatId"):
+            print(telegram.get("chatId"))
+    mapper = plugins.get("agentModelMapper", {})
+    if isinstance(mapper, dict):
+        print("::opencode_agent_model_mapper_enabled")
+        if mapper.get("enabled") is not None:
+            print("true" if mapper.get("enabled") is True else "false")
 PY
 )
 
@@ -1105,17 +1223,28 @@ PY
   local loaded_agent_os=()
   local loaded_areas=()
   local loaded_specs=()
+  local loaded_mcp_integrations=()
+  local loaded_telegram_enabled=""
+  local loaded_telegram_bot_token=""
+  local loaded_telegram_chat_id=""
+  local loaded_mapper_enabled=""
   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") ;;
+          opencode_telegram_enabled) loaded_telegram_enabled="$value" ;;
+          opencode_telegram_bot_token) loaded_telegram_bot_token="$value" ;;
+          opencode_telegram_chat_id) loaded_telegram_chat_id="$value" ;;
+          opencode_agent_model_mapper_enabled) loaded_mapper_enabled="$value" ;;
         esac
         ;;
     esac
@@ -1130,6 +1259,36 @@ 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
+  if [[ "${#loaded_mcp_integrations[@]}" -gt 0 ]]; then
+    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
+  fi
+
+  if [[ -n "$loaded_telegram_enabled" ]]; then
+    OPENCODE_TELEGRAM_ENABLED="$loaded_telegram_enabled"
+    OPENCODE_TELEGRAM_BOT_TOKEN="$loaded_telegram_bot_token"
+    OPENCODE_TELEGRAM_CHAT_ID="$loaded_telegram_chat_id"
+    OPENCODE_PLUGINS_CONFIGURED=true
+  fi
+  if [[ -n "$loaded_mapper_enabled" ]]; then
+    OPENCODE_AGENT_MODEL_MAPPER_ENABLED="$loaded_mapper_enabled"
+    OPENCODE_PLUGINS_CONFIGURED=true
+  fi
 }
 
 path_ref_for_shell_export() {
@@ -1704,6 +1863,39 @@ 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."
+}
+
+configure_context7_key_interactive() {
+  is_interactive_terminal || return 0
+
+  local choice
+  if fzf_available; then
+    choice="$(choose_single_fzf "Context7 API key mode:" "Use without API key" "Enter CONTEXT7_API_KEY" || true)"
+  else
+    echo "Context7 API key mode:" >&2
+    echo "  1) Use without API key" >&2
+    echo "  2) Enter CONTEXT7_API_KEY" >&2
+    local answer
+    read -r -p "Select one (empty=1): " answer
+    answer="$(trim "$answer")"
+    case "$answer" in
+      ""|1) choice="Use without API key" ;;
+      2) choice="Enter CONTEXT7_API_KEY" ;;
+      *) error "Invalid choice"; exit 1 ;;
+    esac
+  fi
+
+  if [[ "$choice" == "Enter CONTEXT7_API_KEY" ]]; then
+    CONTEXT7_API_KEY="$(prompt_text_interactive "CONTEXT7_API_KEY" "$CONTEXT7_API_KEY")"
+  else
+    CONTEXT7_API_KEY=""
+  fi
+}
+
 write_mempalace_opencode_config() {
   local dest="$1"
   local body
@@ -1747,65 +1939,380 @@ servers["mempalace"] = {"command": "mempalace-mcp"}
 }
 
 print_mempalace_project_setup_instructions() {
-  log "MemPalace setup instructions for target project: $PROJECT_DIR"
+  local project_wing
+  project_wing="$(mempalace_project_wing)"
+  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) Initialize project-local MemPalace cache:"
-  out "   mempalace init \"$PROJECT_DIR\" --yes --auto-mine"
-  out "4) 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."
+  out "3) Initialize the project memory taxonomy without LLM calls:"
+  out "   mempalace init \"$PROJECT_DIR\" --yes --no-llm"
+  out "4) Mine project knowledge into its isolated wing:"
+  out "   mempalace mine \"$PROJECT_DIR\" --wing \"$project_wing\""
+  if [[ -d "$PROJECT_DIR/docs" ]]; then
+    out "5) Mine shared project docs into the cross-project docs wing:"
+    out "   mempalace mine \"$PROJECT_DIR/docs\" --wing shared_docs"
+    out "6) Verify in your IDE/agent that MemPalace MCP tools are connected."
+  else
+    out "5) Verify in your IDE/agent that MemPalace MCP tools are connected."
+  fi
+  out "Note: agentic uses --no-llm by default to keep MemPalace setup low-cost."
+}
+
+mempalace_sanitize_wing_name() {
+  local raw="$1"
+  local sanitized
+  sanitized="$(printf '%s' "$raw" | tr '[:upper:]' '[:lower:]' | sed -E 's/[^a-z0-9]+/_/g; s/^_+//; s/_+$//; s/_+/_/g')"
+  if [[ -z "$sanitized" ]]; then
+    sanitized="project"
+  fi
+  printf '%s\n' "$sanitized"
+}
+
+mempalace_project_wing() {
+  mempalace_sanitize_wing_name "$(basename "$PROJECT_DIR")"
+}
+
+mempalace_shared_docs_wing() {
+  printf '%s\n' "shared_docs"
+}
+
+write_mempalace_ignore_file() {
+  local dest="$PROJECT_DIR/.mempalaceignore"
+  local content
+  content='node_modules/
+.venv/
+venv/
+dist/
+logs/
+build/
+target/
+coverage/
+.ai/
+.git/
+.github/
+.cursor/
+.agent/
+.opencode/
+.claude/
+.gemini/
+.codex/
+.idea/
+*.csv
+*.parquet
+*.log
+*.jsonl
+
+data/
+dumps/
+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
+}
+
+warn_mempalace_pip_failure_reason() {
+  local output_file="$1"
+  [[ -f "$output_file" ]] || return 0
+
+  local reason
+  reason="$(sed -n '/[^[:space:]]/{p;q;}' "$output_file" 2>/dev/null || true)"
+  if [[ -n "$reason" ]]; then
+    warn "pip failure reason: $reason"
+  else
+    warn "pip failure output was empty; inspect the MemPalace pip install log for details."
+  fi
+}
+
+mempalace_timeout_seconds() {
+  local value="${AGENTIC_MEMPALACE_TIMEOUT_SECONDS:-60}"
+  if [[ "$value" =~ ^[0-9]+$ ]] && (( value > 0 )); then
+    printf '%s\n' "$value"
+    return
+  fi
+  printf '%s\n' "60"
+}
+
+run_mempalace_command() {
+  local label="$1"
+  shift
+  local output_file timeout_seconds child_pid elapsed status
+  output_file="$(mktemp "${TMPDIR:-/tmp}/agentic-mempalace.XXXXXX")"
+  timeout_seconds="$(mempalace_timeout_seconds)"
+
+  "$@" >"$output_file" 2>&1 &
+  child_pid=$!
+  elapsed=0
+  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
+      warn "Timed out after ${timeout_seconds}s: $* (log: $output_file)"
+      log_file_block "$label" "$output_file"
+      return 1
+    fi
+    sleep 1
+    elapsed=$((elapsed + 1))
+  done
+
+  if wait "$child_pid"; then
+    log "$label completed"
+    log_file_block "$label" "$output_file"
+    rm -f "$output_file"
+    return 0
+  fi
+  status=$?
+
+  warn "Failed: $* (exit $status, log: $output_file)"
+  log_file_block "$label" "$output_file"
+  warn_mempalace_failure_reason "$output_file"
+  return 1
 }
 
-setup_mempalace_for_agentic_opencode() {
+install_mempalace_with_pip() {
+    local pip_bin="$1"
+    local output_file status
+    local py_bin venv_dir venv_python
+
+    output_file="$(mktemp "${TMPDIR:-/tmp}/agentic-mempalace-pip.XXXXXX")"
+
+    if $pip_bin install mempalace >"$output_file" 2>&1; then
+        log "MemPalace package installed via '$pip_bin install mempalace'"
+        log_file_block "MemPalace pip install" "$output_file"
+        rm -f "$output_file"
+        return 0
+    else
+        status=$?
+    fi
+
+    if grep -qi "externally-managed-environment" "$output_file"; then
+        log "Detected PEP 668 externally-managed Python environment; retrying inside isolated venv"
+
+        py_bin="$(command -v python3 || command -v python)"
+        if [[ -z "$py_bin" ]]; then
+            warn "python3/python executable not found"
+            return 1
+        fi
+
+        venv_dir="${HOME}/.agentic/mempalace-venv"
+
+        if [[ ! -d "$venv_dir" ]]; then
+            mkdir -p "$(dirname "$venv_dir")"
+
+            if ! "$py_bin" -m venv "$venv_dir" >>"$output_file" 2>&1; then
+                warn "Unable to create virtual environment at $venv_dir"
+                log_file_block "MemPalace pip install" "$output_file"
+                return 1
+            fi
+        fi
+
+        venv_python="$venv_dir/bin/python"
+
+        if ! "$venv_python" -m pip install --upgrade pip setuptools wheel >>"$output_file" 2>&1; then
+            warn "Unable to upgrade pip inside virtual environment"
+            log_file_block "MemPalace pip install" "$output_file"
+            return 1
+        fi
+
+        if ! "$venv_python" -m pip install --no-cache-dir --upgrade mempalace >>"$output_file" 2>&1; then
+            warn "Unable to install mempalace inside virtual environment"
+            log_file_block "MemPalace pip install" "$output_file"
+            return 1
+        fi
+
+        local_bin_dir="$HOME/.local/bin"
+
+        mkdir -p "$local_bin_dir"
+
+        ln -sf "$venv_dir/bin/mempalace" "$local_bin_dir/mempalace"
+
+        export PATH="$local_bin_dir:$venv_dir/bin:$PATH"
+
+        shell_name="$(basename "${SHELL:-}")"
+
+        if [[ "$shell_name" == "zsh" ]]; then
+            grep -qxF 'export PATH="$HOME/.local/bin:$PATH"' "$HOME/.zshrc" 2>/dev/null || \
+                echo 'export PATH="$HOME/.local/bin:$PATH"' >> "$HOME/.zshrc"
+        else
+            grep -qxF 'export PATH="$HOME/.local/bin:$PATH"' "$HOME/.bashrc" 2>/dev/null || \
+                echo 'export PATH="$HOME/.local/bin:$PATH"' >> "$HOME/.bashrc"
+        fi
+
+        log "MemPalace installed successfully inside virtual environment: $venv_dir"
+        log "MemPalace binary linked to: $local_bin_dir/mempalace"
+        log_file_block "MemPalace pip install" "$output_file"
+
+        rm -f "$output_file"
+        return 0
+    fi
+
+    warn "Unable to auto-install mempalace via pip; continuing with manual setup instructions (exit $status, log: $output_file)"
+    log_file_block "MemPalace pip install" "$output_file"
+    warn_mempalace_pip_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"
+  local project_wing shared_docs_wing
+  project_wing="$(mempalace_project_wing)"
+  shared_docs_wing="$(mempalace_shared_docs_wing)"
+  log "$step_prefix [4/4] Initializing project memory at $PROJECT_DIR (wing: $project_wing)"
+  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 --no-llm; then
+    print_mempalace_project_setup_instructions
+    return 1
+  fi
+  if ! run_mempalace_command "MemPalace mine project wing" mempalace mine "$PROJECT_DIR" --wing "$project_wing"; then
+    print_mempalace_project_setup_instructions
+    return 1
+  fi
+  if [[ -d "$PROJECT_DIR/docs" ]]; then
+    if ! run_mempalace_command "MemPalace mine shared docs wing" mempalace mine "$PROJECT_DIR/docs" --wing "$shared_docs_wing"; then
+      print_mempalace_project_setup_instructions
+      return 1
+    fi
+  fi
+  log "$step_prefix [4/4] Initialization step finished"
+}
+
+setup_mempalace_for_agentic() {
+  local initialize_project="${1:-false}"
   local step_prefix="MemPalace setup"
 
+  if [[ "${AGENTIC_MEMPALACE_SETUP:-}" == "skip" ]]; then
+    log "$step_prefix skipped by AGENTIC_MEMPALACE_SETUP=skip"
+    if command -v mempalace-mcp >/dev/null 2>&1; then
+      return 0
+    fi
+    return 1
+  fi
+
   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"
   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_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"
+  if ! install_mempalace_with_pip "$pip_bin"; then
     print_mempalace_project_setup_instructions
     return 1
   fi
 
-  log "$step_prefix [4/4] Initializing project memory at $PROJECT_DIR"
-  if command -v mempalace >/dev/null 2>&1; then
-    if mempalace init "$PROJECT_DIR" --yes --auto-mine >/dev/null 2>&1; then
-      log "MemPalace init completed"
-    else
-      warn "Failed: mempalace init \"$PROJECT_DIR\" --yes --auto-mine"
-    fi
-    if mempalace mine "$PROJECT_DIR" >/dev/null 2>&1; then
-      log "MemPalace mine completed"
-    else
-      warn "Failed: mempalace mine \"$PROJECT_DIR\""
-    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() {
@@ -1832,16 +2339,18 @@ configure_mempalace_if_needed() {
     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
-    log "MemPalace MCP binary found: mempalace-mcp"
+  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
@@ -1883,7 +2392,6 @@ configure_context7_if_needed() {
   fi
 
   if is_interactive_terminal; then
-    local answer
     if [[ -z "$enable_context7" ]]; then
       read -r -p "Enable Context7 MCP configuration? [y/N]: " enable_context7
       enable_context7="$(trim "$enable_context7")"
@@ -1892,10 +2400,12 @@ configure_context7_if_needed() {
       log "Context7 MCP configuration disabled"
       return
     fi
+    configure_context7_key_interactive
 
-    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"
@@ -1930,10 +2440,17 @@ 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() {
   ensure_dir "$APP_CONFIG_DIR"
+  OPENCODE_TELEGRAM_ENABLED="false"
+  OPENCODE_TELEGRAM_BOT_TOKEN=""
+  OPENCODE_TELEGRAM_CHAT_ID=""
+  OPENCODE_AGENT_MODEL_MAPPER_ENABLED="false"
+  OPENCODE_PLUGINS_CONFIGURED=true
   if [[ "$DRY_RUN" == true ]]; then
     log "DRY-RUN write disabled opencode plugin config to $OPENCODE_PLUGIN_CONFIG_FILE"
   else
@@ -1944,13 +2461,40 @@ 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
 }
 
+load_opencode_plugin_config_globals() {
+  [[ -f "$OPENCODE_PLUGIN_CONFIG_FILE" ]] || return 1
+  local values=()
+  readlines values < <(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:
+    data = {}
+telegram = data.get("telegram", {}) if isinstance(data, dict) else {}
+mapper = data.get("agentModelMapper", {}) if isinstance(data, dict) else {}
+print("true" if telegram.get("enabled") is True else "false")
+print(telegram.get("botToken") or "")
+print(telegram.get("chatId") or "")
+print("true" if mapper.get("enabled") is True else "false")
+PY
+)
+  OPENCODE_TELEGRAM_ENABLED="${values[0]:-false}"
+  OPENCODE_TELEGRAM_BOT_TOKEN="${values[1]:-}"
+  OPENCODE_TELEGRAM_CHAT_ID="${values[2]:-}"
+  OPENCODE_AGENT_MODEL_MAPPER_ENABLED="${values[3]:-false}"
+  OPENCODE_PLUGINS_CONFIGURED=true
+}
+
 configure_opencode_plugins_if_needed() {
   selected_agent_os_contains "opencode" || return 0
 
@@ -1962,14 +2506,27 @@ configure_opencode_plugins_if_needed() {
   ensure_python_available
   ensure_dir "$APP_CONFIG_DIR"
 
+  # During manifest replay/re-install, keep current global plugin settings and avoid prompts.
+  if [[ "$INSTALL_SETTINGS_REPLAY" == true && "$OPENCODE_PLUGINS_CONFIGURED" == true ]]; then
+    log "OpenCode plugin settings loaded from .agentic.json"
+    return
+  fi
+  if [[ "$INSTALL_SETTINGS_REPLAY" == true && -f "$OPENCODE_PLUGIN_CONFIG_FILE" ]]; then
+    load_opencode_plugin_config_globals || true
+    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
+    else
+      load_opencode_plugin_config_globals || true
     fi
     return
   fi
 
-  local plugin_options=("telegram-opencode-notifier" "llm-quota-checker")
+  local plugin_options=("telegram-notification" "agent-model-mapper")
   local selected_plugins=()
   local use_fzf_plugins=false
   if fzf_available; then
@@ -1986,47 +2543,472 @@ configure_opencode_plugins_if_needed() {
     readlines selected_plugins <<< "$selected_plugins_output"
   fi
 
-  local enable_telegram="n" telegram_token telegram_chat enable_model_checker="n"
+  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" ;;
-      llm-quota-checker) enable_model_checker="y" ;;
+      telegram-notification|telegram-opencode-notifier) enable_telegram="y" ;;
+      agent-model-mapper) enable_agent_model_mapper="y" ;;
     esac
   done
 
-  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")"
+    OPENCODE_TELEGRAM_BOT_TOKEN="$(prompt_text_interactive "Telegram botToken" "$OPENCODE_TELEGRAM_BOT_TOKEN")"
+    OPENCODE_TELEGRAM_CHAT_ID="$(prompt_text_interactive "Telegram chatId" "$OPENCODE_TELEGRAM_CHAT_ID")"
+    if [[ -z "$OPENCODE_TELEGRAM_BOT_TOKEN" || -z "$OPENCODE_TELEGRAM_CHAT_ID" ]]; then
+      warn "Telegram plugin credentials are incomplete; disabling telegram-notification"
+      enable_telegram="n"
+      OPENCODE_TELEGRAM_BOT_TOKEN=""
+      OPENCODE_TELEGRAM_CHAT_ID=""
+    else
+      log "Telegram plugin enabled; credentials will be stored in project .agentic.json"
+    fi
   fi
+  OPENCODE_TELEGRAM_ENABLED=$([[ "$enable_telegram" =~ ^[Yy]$ ]] && echo "true" || echo "false")
+  OPENCODE_AGENT_MODEL_MAPPER_ENABLED=$([[ "$enable_agent_model_mapper" =~ ^[Yy]$ ]] && echo "true" || echo "false")
+  OPENCODE_PLUGINS_CONFIGURED=true
 
-  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() {
+  if [[ "$OPENCODE_AGENT_MODEL_MAPPER_ENABLED" == "true" ]]; then
+    return 0
+  fi
+  if [[ "$OPENCODE_AGENT_MODEL_MAPPER_ENABLED" == "false" ]]; then
+    return 1
+  fi
+  [[ -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"
+  local auth_path="$HOME/.local/share/opencode/auth.json"
+  local models_cache_path="$HOME/.cache/opencode/models.json"
+  python3 - "$config_path" "$auth_path" "$models_cache_path" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+fallback = ["opencode/minimax-m2.5-free"]
+config_path = Path(sys.argv[1])
+auth_path = Path(sys.argv[2])
+models_cache_path = Path(sys.argv[3])
+models = []
+
+def add_model(model):
+    if isinstance(model, str) and model.strip() and "/" in model:
+        models.append(model.strip())
+
+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():
+                add_model(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:
+            add_model(item)
+        if key == "fallback" and isinstance(item, list):
+            for model in item:
+                add_model(model)
+        collect(item)
+
+def read_json(path):
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return None
+
+def is_deprecated(model_data):
+    if not isinstance(model_data, dict):
+        return False
+    status = str(model_data.get("status", "")).lower()
+    lifecycle = str(model_data.get("lifecycle", "")).lower()
+    return (
+        model_data.get("deprecated") is True
+        or status in {"deprecated", "retired", "removed"}
+        or lifecycle in {"deprecated", "retired", "removed"}
+    )
+
+def collect_authenticated_provider_models(auth_data, cache_data):
+    if not isinstance(auth_data, dict) or not isinstance(cache_data, dict):
+        return
+    for provider_name, auth in auth_data.items():
+        if not isinstance(provider_name, str) or not provider_name.strip():
+            continue
+        if auth in (None, False):
+            continue
+        provider_data = cache_data.get(provider_name)
+        if not isinstance(provider_data, dict):
+            continue
+        provider_models = provider_data.get("models")
+        if isinstance(provider_models, dict):
+            for model_name, model_data in provider_models.items():
+                if isinstance(model_name, str) and model_name.strip() and not is_deprecated(model_data):
+                    add_model(f"{provider_name}/{model_name}")
+        elif isinstance(provider_models, list):
+            for item in provider_models:
+                if isinstance(item, str):
+                    add_model(f"{provider_name}/{item}")
+                elif isinstance(item, dict) and not is_deprecated(item):
+                    model_name = item.get("id") or item.get("name")
+                    if isinstance(model_name, str) and model_name.strip():
+                        add_model(f"{provider_name}/{model_name}")
+
+try:
+    data = json.loads(config_path.read_text(encoding="utf-8"))
+    collect_provider_models(data)
+    collect(data)
+except Exception:
+    pass
+
+collect_authenticated_provider_models(read_json(auth_path), read_json(models_cache_path))
+
+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"
+}
+
+confirm_opencode_agent_model_mapping() {
+  local mapping_file="$1"
+  if fzf_available; then
+    local summary selected
+    summary="$(python3 - "$mapping_file" <<'PY'
+import sys
+from pathlib import Path
+
+for line in Path(sys.argv[1]).read_text(encoding="utf-8").splitlines():
+    if not line:
+        continue
+    name, model, fallback = (line.split("\t") + ["", "", ""])[:3]
+    print(f"{name}: main={model} fallback={fallback}")
+PY
+)"
+    set +e
+    selected="$(printf '%s\n' "Confirm" "Cancel" | fzf \
+      --ansi \
+      --border \
+      --height=70% \
+      --layout=reverse \
+      --no-sort \
+      --prompt "Save OpenCode model mapping? " \
+      --header "$summary")"
+    local fzf_status=$?
+    set -e
+    [[ "$fzf_status" -eq 0 ]] || return 1
+    [[ "$selected" == "Confirm" ]]
+    return
+  fi
+
+  out "agent-model-mapper selected mapping:"
+  python3 - "$mapping_file" <<'PY'
+import sys
+from pathlib import Path
+
+for line in Path(sys.argv[1]).read_text(encoding="utf-8").splitlines():
+    if not line:
+        continue
+    name, model, fallback = (line.split("\t") + ["", "", ""])[:3]
+    print(f"  - {name}: main={model} fallback={fallback}")
+PY
+  confirm_action_interactive "Write .opencode/opencode.json agent model mapping?"
+}
+
+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"
+
+  exec 3<&-
+  if ! confirm_opencode_agent_model_mapping "$mapping_file"; 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() {
@@ -2052,7 +3034,6 @@ copy_extension_for_agent() {
   local project_dir="$2"
 
   if [[ "$agent_os" == "$DEFAULT_AGENT_OS" ]] || [[ "$agent_os" == "agents" ]]; then
-    log "Agent OS '$agent_os': skipping extension copy"
     return
   fi
 
@@ -2064,7 +3045,6 @@ copy_extension_for_agent() {
     return
   fi
 
-  log "Copy extension: $src -> $dest"
   copy_dir_contents "$src" "$dest"
 }
 
@@ -2109,7 +3089,6 @@ copy_specialization_assets() {
         local dest_dir
         dest_dir="$(get_dest_dir "$target" "$bucket")"
         if [[ "$dest_dir" == "-" ]]; then
-          log "Skip $spec_key/$bucket (not supported by '$target')"
           continue
         fi
         unique_append "$dest_dir" dest_dirs
@@ -2118,7 +3097,6 @@ copy_specialization_assets() {
       local resolved_dir
       for resolved_dir in "${dest_dirs[@]}"; do
         local dest="$project_dir/$resolved_dir"
-        log "Copy $spec_key/$bucket -> $dest"
         copy_dir_contents "$src" "$dest"
       done
     done
@@ -2232,6 +3210,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)"
@@ -2299,6 +3311,8 @@ validate_inputs() {
 }
 
 print_report() {
+  write_changed_paths_report
+
   out
   out "=== Installation report ===" "$COLOR_HEADER"
   out "Agentic version: $(app_version_label)"
@@ -2310,26 +3324,9 @@ print_report() {
   out "Specializations: ${SELECTED_SPECS[*]}"
 
   out
-  out "Created directories:"
-  if [[ "${#CREATED_PATHS[@]}" -eq 0 ]]; then
-    out "- (none)"
-  else
-    local created_path
-    for created_path in "${CREATED_PATHS[@]}"; do
-      out "- $created_path"
-    done
-  fi
-
-  out
-  out "Copied/generated paths:"
-  if [[ "${#COPIED_PATHS[@]}" -eq 0 ]]; then
-    out "- (none)"
-  else
-    local copied_path
-    for copied_path in "${COPIED_PATHS[@]}"; do
-      out "- $copied_path"
-    done
-  fi
+  out "Created directories: ${#CREATED_PATHS[@]}"
+  out "Copied/generated paths: ${#COPIED_PATHS[@]}"
+  out "Changed paths report: $CHANGED_PATHS_REPORT_FILE"
 
   out
   out "Warnings:"
@@ -2469,7 +3466,15 @@ doctor_enabled() {
 }
 
 doctor_prompt() {
-  printf '%s\n' "/develop-feature напиши hello world python"
+  printf '%s\n' "Reply with exactly: AGENTIC_DOCTOR_OK"
+}
+
+doctor_prompt_for_agent() {
+  doctor_prompt
+}
+
+doctor_smoke_label() {
+  printf '%s\n' "lightweight smoke"
 }
 
 doctor_output_has_fatal_patterns() {
@@ -2477,6 +3482,40 @@ doctor_output_has_fatal_patterns() {
   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"
@@ -2490,14 +3529,14 @@ run_doctor_command() {
   local work_dir="$2"
   local output_file="$3"
   local prompt
-  prompt="$(doctor_prompt)"
+  prompt="$(doctor_prompt_for_agent "$agent_os")"
 
   case "$agent_os" in
     codex)
-      codex exec --skip-git-repo-check --full-auto -C "$work_dir" "$prompt" >"$output_file" 2>&1
+      codex exec --skip-git-repo-check --ephemeral --sandbox workspace-write -C "$work_dir" "$prompt" </dev/null >"$output_file" 2>&1
       ;;
     opencode)
-      opencode run --dir "$work_dir" --dangerously-skip-permissions --format json --command develop-feature "напиши hello world python" >"$output_file" 2>&1
+      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
@@ -2522,29 +3561,40 @@ run_doctor_for_agent() {
     return 1
   fi
 
-  local work_dir output_file status
+  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
-  run_doctor_command "$agent_os" "$work_dir" "$output_file"
+  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: /develop-feature smoke failed (exit $status, log: $output_file)"
+    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: /develop-feature smoke reported integration errors (log: $output_file)"
+    out "❌ $agent_os: $smoke_label reported integration errors (exit $status, elapsed ${elapsed}s, log: $output_file)"
     return 1
   fi
 
-  out "✅ $agent_os: /develop-feature smoke passed"
+  out "✅ $agent_os: $smoke_label passed (exit $status, elapsed ${elapsed}s)"
   return 0
 }
 
@@ -2572,6 +3622,7 @@ run_agentic_doctor() {
   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
@@ -2603,8 +3654,10 @@ run_install() {
   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"
@@ -2681,6 +3734,84 @@ prompt_with_default_fzf() {
   printf '%s\n' "$default"
 }
 
+prompt_text_fzf() {
+  local prompt="$1"
+  local default="${2:-}"
+  local header="Type value and press Enter to confirm"
+  if [[ -n "$default" ]]; then
+    header="$header (empty = current value)"
+  fi
+  local fzf_args=(
+    --ansi
+    --border
+    --height=70%
+    --layout=reverse
+    --cycle
+    --no-sort
+    --phony
+    --print-query
+    --bind "enter:accept"
+    --prompt "$prompt "
+    --header "$header"
+  )
+  if [[ "${#FZF_COLOR_ARGS[@]}" -gt 0 ]]; then
+    fzf_args+=("${FZF_COLOR_ARGS[@]}")
+  fi
+
+  local output selected
+  if ! output="$(printf '%s\n' "<press Enter to confirm>" | fzf "${fzf_args[@]}")"; then
+    return 1
+  fi
+  selected="$(printf '%s\n' "$output" | sed -n '1p')"
+  selected="$(trim "$selected")"
+  if [[ -n "$selected" ]]; then
+    printf '%s\n' "$selected"
+  else
+    printf '%s\n' "$default"
+  fi
+}
+
+prompt_text_tui() {
+  local prompt="$1"
+  local default="${2:-}"
+  local answer
+  if [[ -n "$default" ]]; then
+    read -r -p "$prompt [keep current]: " answer
+  else
+    read -r -p "$prompt: " answer
+  fi
+  answer="$(trim "$answer")"
+  if [[ -n "$answer" ]]; then
+    printf '%s\n' "$answer"
+  else
+    printf '%s\n' "$default"
+  fi
+}
+
+prompt_text_interactive() {
+  local prompt="$1"
+  local default="${2:-}"
+  if fzf_available; then
+    prompt_text_fzf "$prompt" "$default"
+  else
+    prompt_text_tui "$prompt" "$default"
+  fi
+}
+
+confirm_action_interactive() {
+  local prompt="$1"
+  local selected
+  if fzf_available; then
+    selected="$(choose_single_fzf "$prompt" "Confirm" "Cancel" || true)"
+    [[ "$selected" == "Confirm" ]]
+    return
+  fi
+  local answer
+  read -r -p "$prompt [y/N]: " answer
+  answer="$(trim "$answer")"
+  [[ "$answer" =~ ^[Yy]([Ee][Ss])?$ ]]
+}
+
 choose_single_by_index() {
   local prompt="$1"
   shift
@@ -3237,6 +4368,45 @@ sync_current_project_after_upgrade() {
   load_install_settings_from_manifest "$manifest"
   ensure_repo_layout
   run_install
+  upgrade_mempalace_graph
+}
+
+upgrade_mempalace_graph() {
+  local project_wing shared_docs_wing
+  # 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
+
+  project_wing="$(mempalace_project_wing)"
+  shared_docs_wing="$(mempalace_shared_docs_wing)"
+  if [[ "$DRY_RUN" == true ]]; then
+    log "DRY-RUN mempalace mine \"$PROJECT_DIR\" --wing \"$project_wing\""
+    if [[ -d "$PROJECT_DIR/docs" ]]; then
+      log "DRY-RUN mempalace mine \"$PROJECT_DIR/docs\" --wing \"$shared_docs_wing\""
+    fi
+    return
+  fi
+
+  log "Refreshing MemPalace knowledge graph for $PROJECT_DIR (wing: $project_wing)"
+  if mempalace mine "$PROJECT_DIR" --wing "$project_wing" >/dev/null 2>&1; then
+    log "MemPalace graph updated"
+  else
+    warn "mempalace mine failed; graph may be stale — run manually: mempalace mine \"$PROJECT_DIR\" --wing \"$project_wing\""
+  fi
+
+  if [[ -d "$PROJECT_DIR/docs" ]]; then
+    log "Refreshing shared MemPalace docs wing from $PROJECT_DIR/docs"
+    if mempalace mine "$PROJECT_DIR/docs" --wing "$shared_docs_wing" >/dev/null 2>&1; then
+      log "MemPalace shared docs wing updated"
+    else
+      warn "mempalace docs mine failed; shared docs may be stale — run manually: mempalace mine \"$PROJECT_DIR/docs\" --wing \"$shared_docs_wing\""
+    fi
+  fi
 }
 
 parse_theme_option() {