@jetrabbits/agentic 0.3.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"
@@ -59,9 +60,17 @@ 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=""
@@ -277,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"
 }
@@ -364,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"
@@ -995,7 +1054,7 @@ write_agentic_manifest() {
   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'
+  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
@@ -1011,6 +1070,10 @@ 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 = {}
@@ -1052,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",
@@ -1068,6 +1150,7 @@ data = {
         "areas": areas,
         "specializations": specs,
         "mcp_integrations": mcp_integrations,
+        "opencode_plugins": opencode_plugins,
         "source_repo": repo_link,
         "source_checkout": repo_root,
     },
@@ -1101,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'
@@ -1114,6 +1198,24 @@ 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
 )
 
@@ -1122,6 +1224,10 @@ PY
   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
@@ -1135,6 +1241,10 @@ PY
           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
@@ -1152,20 +1262,33 @@ PY
 
   # 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
+  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() {
@@ -1744,36 +1867,32 @@ 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"}'
+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 selected_agent_os_contains "antigravity"; then
-    out "  - $HOME/.gemini/antigravity/mcp_config.json"
-    out '    Example: "headers": {"CONTEXT7_API_KEY": "ctx7_your_api_key_here"}'
+
+  if [[ "$choice" == "Enter CONTEXT7_API_KEY" ]]; then
+    CONTEXT7_API_KEY="$(prompt_text_interactive "CONTEXT7_API_KEY" "$CONTEXT7_API_KEY")"
+  else
+    CONTEXT7_API_KEY=""
   fi
 }
 
@@ -1820,17 +1939,42 @@ servers["mempalace"] = {"command": "mempalace-mcp"}
 }
 
 print_mempalace_project_setup_instructions() {
+  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) 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."
+  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() {
@@ -1840,17 +1984,27 @@ write_mempalace_ignore_file() {
 .venv/
 venv/
 dist/
+logs/
 build/
 target/
 coverage/
+.ai/
 .git/
-
+.github/
+.cursor/
+.agent/
+.opencode/
+.claude/
+.gemini/
+.codex/
+.idea/
 *.csv
 *.parquet
 *.log
 *.jsonl
 
 data/
+dumps/
 tmp/
 '
 
@@ -1877,24 +2031,153 @@ warn_mempalace_failure_reason() {
   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
+  local output_file timeout_seconds child_pid elapsed status
   output_file="$(mktemp "${TMPDIR:-/tmp}/agentic-mempalace.XXXXXX")"
-  if "$@" >"$output_file" 2>&1; then
+  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: $* (log: $output_file)"
+  warn "Failed: $* (exit $status, log: $output_file)"
   log_file_block "$label" "$output_file"
   warn_mempalace_failure_reason "$output_file"
   return 1
 }
 
+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}"
 }
@@ -1949,17 +2232,30 @@ install_mempalace_managed() {
 
 initialize_mempalace_project() {
   local step_prefix="$1"
-  log "$step_prefix [4/4] Initializing project memory at $PROJECT_DIR"
+  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 --auto-mine; then
+  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"
 }
 
@@ -1967,6 +2263,14 @@ 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"
@@ -1998,10 +2302,7 @@ setup_mempalace_for_agentic() {
   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
@@ -2099,6 +2400,7 @@ configure_context7_if_needed() {
       log "Context7 MCP configuration disabled"
       return
     fi
+    configure_context7_key_interactive
 
   elif [[ -n "$enable_context7" ]]; then
     if [[ ! "$enable_context7" =~ ^[Yy]$ ]]; then
@@ -2144,6 +2446,11 @@ configure_context7_if_needed() {
 
 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
@@ -2161,6 +2468,33 @@ 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
 
@@ -2172,8 +2506,13 @@ 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
+  # 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
@@ -2181,11 +2520,13 @@ configure_opencode_plugins_if_needed() {
   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" "agent-model-mapper")
+  local plugin_options=("telegram-notification" "agent-model-mapper")
   local selected_plugins=()
   local use_fzf_plugins=false
   if fzf_available; then
@@ -2208,14 +2549,26 @@ configure_opencode_plugins_if_needed() {
     selected_plugin="$(trim "$selected_plugin")"
     [[ -z "$selected_plugin" ]] && continue
     case "$selected_plugin" in
-      telegram-opencode-notifier) enable_telegram="y" ;;
+      telegram-notification|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"
+    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" "$enable_telegram" "$enable_agent_model_mapper" <<'PY'
 import json
@@ -2239,6 +2592,12 @@ 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
@@ -2287,15 +2646,23 @@ PY
 
 opencode_mapper_discover_models() {
   local config_path="$HOME/.config/opencode/opencode.json"
-  python3 - "$config_path" <<'PY'
+  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"]
-path = Path(sys.argv[1])
+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")
@@ -2309,7 +2676,7 @@ def collect_provider_models(data):
             continue
         for model_name in provider_models:
             if isinstance(model_name, str) and model_name.strip():
-                models.append(f"{provider_name}/{model_name}")
+                add_model(f"{provider_name}/{model_name}")
 
 def collect(value):
     if isinstance(value, list):
@@ -2320,18 +2687,63 @@ def collect(value):
         return
     for key, item in value.items():
         if key in {"model", "id"} and isinstance(item, str) and "/" in item:
-            models.append(item)
+            add_model(item)
         if key == "fallback" and isinstance(item, list):
-            models.extend(model for model in item if isinstance(model, str))
+            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(path.read_text(encoding="utf-8"))
+    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()
@@ -2491,6 +2903,51 @@ PY
   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
@@ -2542,13 +2999,8 @@ configure_opencode_agent_model_mapper_if_needed() {
     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
+  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
@@ -2582,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
 
@@ -2594,7 +3045,6 @@ copy_extension_for_agent() {
     return
   fi
 
-  log "Copy extension: $src -> $dest"
   copy_dir_contents "$src" "$dest"
 }
 
@@ -2639,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
@@ -2648,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
@@ -2863,6 +3311,8 @@ validate_inputs() {
 }
 
 print_report() {
+  write_changed_paths_report
+
   out
   out "=== Installation report ===" "$COLOR_HEADER"
   out "Agentic version: $(app_version_label)"
@@ -2874,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:"
@@ -3033,31 +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() {
-  local agent_os="$1"
-  case "$agent_os" in
-    opencode)
-      printf '%s\n' "Reply with exactly: AGENTIC_DOCTOR_OK"
-      ;;
-    *)
-      doctor_prompt
-      ;;
-  esac
+  doctor_prompt
 }
 
 doctor_smoke_label() {
-  local agent_os="$1"
-  case "$agent_os" in
-    opencode)
-      printf '%s\n' "lightweight smoke"
-      ;;
-    *)
-      printf '%s\n' "/develop-feature smoke"
-      ;;
-  esac
+  printf '%s\n' "lightweight smoke"
 }
 
 doctor_output_has_fatal_patterns() {
@@ -3317,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
@@ -3877,6 +4372,7 @@ sync_current_project_after_upgrade() {
 }
 
 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
@@ -3886,16 +4382,30 @@ upgrade_mempalace_graph() {
     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\""
+    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"
-  if mempalace mine "$PROJECT_DIR" >/dev/null 2>&1; then
+  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\""
+    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
 }