pi-advisor-flow 0.5.1 → 0.5.2

package/CHANGELOG.md

@@ -4,6 +4,20 @@ All notable changes to this project are documented here.
 
 The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.5.2 - 2026-09-05
+
+### Changed
+
+- Reorganized configuration, UI, Advisor tool, and command code into smaller modules behind the existing public facades without changing the extension's public API.
+
+### Fixed
+
+- Kept failed or aborted Advisor streams from treating partial responses as successful advice or automatic gate permission.
+- Made malformed automatic-gate Markdown fences fail closed when their character or delimiter length does not match.
+- Applied optional secret redaction to targeted Advisor questions before sending provider requests while retaining the raw question for local displays.
+- Kept the TUI tab keybinding out of Socket's URL-string heuristic without changing its runtime behavior.
+- Made benchmark extension attestations follow the root `package.json` version instead of a duplicated constant.
+
 ## 0.5.1
 
 ### Changed

package/README.md

@@ -8,7 +8,8 @@ A configurable second-opinion workflow for <a href="https://github.com/earendil-
 
 </div>
 
-![d18m Downloads](https://img.shields.io/npm/d18m/pi-advisor-flow?style=flat) ![NPM Version](https://img.shields.io/npm/v/pi-advisor-flow?style=flat)
+![d18m Downloads](https://img.shields.io/npm/d18m/pi-advisor-flow?style=flat) ![NPM Version](https://img.shields.io/npm/v/pi-advisor-flow?style=flat) ![Pi Advisor Flow badge](https://img.shields.io/badge/advisor%20flow-fff?logo=pi&logoColor=000)
+
 
 `pi-advisor-flow` keeps one model focused on execution and makes a second, smarter model available for consequential decisions, stalled work, and final reviews. The Executor still owns the work. The Advisor challenges assumptions, exposes risks, and suggests verification steps without taking over or running tools.
 
@@ -70,7 +71,7 @@ Advisor Scout is off by default. When enabled, the Executor model first selects
 
 ## Privacy
 
-Advisor requests can include user messages, tool calls, tool results, and repository information. `/advisor-settings` controls context, tool disclosure, redaction, and explicit file handoff. Secret redaction is off by default, and tools without an explicit policy use full context. Settings are global, so a project cannot silently change them.
+Advisor requests can include user messages, tool calls, tool results, targeted questions, and repository information. `/advisor-settings` controls context, tool disclosure, redaction, and explicit file handoff. Secret redaction is off by default; when enabled, credential-shaped values in targeted questions are redacted before the provider request. Tools without an explicit policy use full context. Settings are global, so a project cannot silently change them.
 
 Read [Privacy and data handling](https://github.com/philipbrembeck/pi-advisor/blob/main/docs/privacy.md) before using pi-advisor with sensitive work.
 

package/extensions/index.ts

@@ -1,16 +1,16 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { registerCommands } from "../src/commands.js";
+import { registerCommands } from "../src/commands/registration.js";
 import { setHerdrBlockedEmitter } from "../src/herdr.js";
 import { AdvisorSessionState } from "../src/session-state.js";
 import {
   consultAdvisor as consultAdvisorImplementation,
-  parseAutomaticDecision as parseAutomaticDecisionImplementation,
-  registerAdvisorTool,
   runAdvisorGate as runAdvisorGateImplementation,
-  ScoutStatusManager,
-} from "../src/tools.js";
+} from "../src/tools/consultation.js";
+import { parseAutomaticDecision as parseAutomaticDecisionImplementation } from "../src/tools/gate-protocol.js";
+import { registerAdvisorTool } from "../src/tools/registration.js";
+import { ScoutStatusManager } from "../src/tools/scout-status.js";
 
-export type { AdvisorConfig, GateFailureMode } from "../src/config.js";
+export type { AdvisorConfig, GateFailureMode } from "../src/config/types.js";
 export type {
   AdvisorConsultationResult,
   AdvisorGateFailure,
@@ -19,7 +19,7 @@ export type {
   ConsultationTrigger,
   GateDecision,
   GateTrigger,
-} from "../src/tools.js";
+} from "../src/tools/types.js";
 export const consultAdvisor = (
   ...args: Parameters<typeof consultAdvisorImplementation>
 ) => consultAdvisorImplementation(...args);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-advisor-flow",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "description": "Advanced Executor/Advisor flow for Pi, fully configurable and extendable.",
   "keywords": [
     "pi-package",
@@ -32,6 +32,7 @@
     "bench:evaluate": "bun bench/src/cli.ts evaluate",
     "bench:replay": "bun bench/src/cli.ts replay",
     "bench:screen": "bun bench/src/cli.ts screen",
+    "check:boundaries": "node scripts/check-module-boundaries.mjs",
     "format": "bunx ultracite fix --linter-enabled=false",
     "lint": "bunx ultracite check",
     "lint:fix": "bunx ultracite fix",

package/src/commands/activation-preparation.ts

@@ -0,0 +1,117 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import {
+  advisorEffortRef,
+  advisorRef,
+  executorEffortRef,
+  executorRef,
+  getPersistedModelRefs,
+  setAdvisorEffortRef,
+  setAdvisorRef,
+  setExecutorEffortRef,
+  setExecutorRef,
+} from "../config/state.js";
+import { loadConfig } from "../config/storage.js";
+import {
+  getAvailableModelRefs,
+  getExplicitModelError,
+  planActivationModels,
+} from "./model-options.js";
+import { selectAdvisorModels } from "./model-picker.js";
+import { notify } from "./runtime.js";
+import type { CommandRuntime } from "./types.js";
+
+export interface PreparedActivationModels {
+  pendingExecutor?: string;
+  pickedModels: boolean;
+}
+
+export const loadCommandConfig = (ctx: ExtensionContext) => {
+  try {
+    loadConfig(ctx);
+    return true;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    notify(
+      ctx,
+      `Advisor command could not load configuration: ${message} Fix advisor.json and retry.`,
+      "error"
+    );
+    return false;
+  }
+};
+
+export const prepareActivationModels = async (
+  runtime: CommandRuntime,
+  ctx: ExtensionContext,
+  announce: boolean,
+  executorOverride: boolean,
+  advisorOverride: boolean
+): Promise<PreparedActivationModels | undefined> => {
+  const persisted = getPersistedModelRefs();
+  const availableRefs = getAvailableModelRefs(ctx);
+  const availableRefSet = availableRefs ? new Set(availableRefs) : undefined;
+  const explicitError =
+    getExplicitModelError(
+      ctx,
+      executorRef,
+      "Executor",
+      executorOverride,
+      availableRefSet
+    ) ??
+    getExplicitModelError(
+      ctx,
+      advisorRef,
+      "Advisor",
+      advisorOverride,
+      availableRefSet
+    );
+  if (explicitError) {
+    notify(ctx, explicitError, "error");
+    return;
+  }
+
+  const plan = planActivationModels(
+    ctx,
+    executorRef,
+    advisorRef,
+    runtime.pendingExecutorModelRef,
+    persisted,
+    executorOverride,
+    advisorOverride,
+    availableRefSet
+  );
+  setExecutorRef(plan.pendingExecutor ?? executorRef);
+  if (!(plan.selectExecutor || plan.selectAdvisor)) {
+    return { pendingExecutor: plan.pendingExecutor, pickedModels: false };
+  }
+
+  // Always-on startup cannot open an interactive picker, so it leaves the
+  // flow disabled until the user selects both models with `/advisor`.
+  if (!announce) {
+    notify(
+      ctx,
+      "Advisor models are not configured or available. Run /advisor to choose them.",
+      "error"
+    );
+    return;
+  }
+  const selection = await selectAdvisorModels(ctx, {
+    advisor: advisorOverride || persisted.advisor ? advisorRef : "",
+    advisorEffort: advisorEffortRef,
+    executor:
+      executorOverride || plan.pendingExecutor || persisted.executor
+        ? executorRef
+        : "",
+    executorEffort: executorEffortRef,
+    selectAdvisor: plan.selectAdvisor,
+    selectExecutor: plan.selectExecutor,
+  });
+  if (!selection) {
+    return;
+  }
+  setAdvisorRef(selection.advisor);
+  setAdvisorEffortRef(selection.advisorEffort);
+  setExecutorRef(selection.executor);
+  setExecutorEffortRef(selection.executorEffort);
+  return { pendingExecutor: plan.pendingExecutor, pickedModels: true };
+};

package/src/commands/activation.ts

@@ -0,0 +1,135 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { parseArgs } from "../config/args.js";
+import {
+  advisorEffortRef,
+  advisorRef,
+  contextMaxCharsRef,
+  executorEffortRef,
+  executorRef,
+  setAdvisorEffortRef,
+  setAdvisorRef,
+  setContextMaxCharsRef,
+  setExecutorEffortRef,
+  setExecutorRef,
+} from "../config/state.js";
+import { saveConfig } from "../config/storage.js";
+import {
+  loadCommandConfig,
+  prepareActivationModels,
+} from "./activation-preparation.js";
+import {
+  ADVISOR_ACTIVATION_EXPLANATION,
+  findConfiguredModel,
+  hasAdvisorOverride,
+  hasExecutorOverride,
+} from "./model-options.js";
+import { notify } from "./runtime.js";
+import type { CommandRuntime, ThinkingLevel } from "./types.js";
+
+const resolveActivationModels = async (
+  runtime: CommandRuntime,
+  ctx: ExtensionContext
+) => {
+  const executor = findConfiguredModel(ctx, executorRef);
+  if (!executor) {
+    return {
+      error: executorRef
+        ? `Executor model not found: ${executorRef}`
+        : "Executor model not configured",
+    };
+  }
+  const advisor = findConfiguredModel(ctx, advisorRef);
+  if (!advisor) {
+    return {
+      error: advisorRef
+        ? `Advisor model not found: ${advisorRef}`
+        : "Advisor model not configured",
+    };
+  }
+  const advisorAuth = await ctx.modelRegistry.getApiKeyAndHeaders(advisor);
+  if (!(advisorAuth.ok && advisorAuth.apiKey)) {
+    return { error: `No API key for Advisor ${advisorRef}` };
+  }
+  if (!(await runtime.setExecutorModel(executor))) {
+    return { error: `No API key for Executor ${executorRef}` };
+  }
+  return {};
+};
+
+export const activateAdvisor = async (
+  runtime: CommandRuntime,
+  args: string,
+  ctx: ExtensionContext,
+  announce = true
+) => {
+  if (!loadCommandConfig(ctx)) {
+    return;
+  }
+  const previous = {
+    advisor: advisorRef,
+    advisorEffort: advisorEffortRef,
+    contextMaxChars: contextMaxCharsRef,
+    executor: executorRef,
+    executorEffort: executorEffortRef,
+  };
+  const restoreRefs = () => {
+    setAdvisorRef(previous.advisor);
+    setAdvisorEffortRef(previous.advisorEffort);
+    setContextMaxCharsRef(previous.contextMaxChars);
+    setExecutorRef(previous.executor);
+    setExecutorEffortRef(previous.executorEffort);
+  };
+  const executorOverride = hasExecutorOverride(args);
+  const advisorOverride = hasAdvisorOverride(args);
+  const argumentError = parseArgs(args);
+  if (argumentError) {
+    restoreRefs();
+    notify(ctx, argumentError, "error");
+    return;
+  }
+
+  const prepared = await prepareActivationModels(
+    runtime,
+    ctx,
+    announce,
+    executorOverride,
+    advisorOverride
+  );
+  if (!prepared) {
+    restoreRefs();
+    return;
+  }
+  const { error } = await resolveActivationModels(runtime, ctx);
+  if (error) {
+    restoreRefs();
+    notify(ctx, error, "error");
+    return;
+  }
+  // parseArgs, model picking, and an inactive `/model` selection only mutate
+  // in-memory refs. Persist them once both models are known and authenticated,
+  // so an unusable model reference is never written to the configuration.
+  if (args.trim() || prepared.pickedModels || prepared.pendingExecutor) {
+    saveConfig(ctx, { persistAdvisor: true, persistExecutor: true });
+  }
+  // A successful activation has committed the effective Executor. Do not let
+  // an older inactive selection override an explicit activation argument on a
+  // later attempt.
+  runtime.pendingExecutorModelRef = undefined;
+  if (executorEffortRef) {
+    runtime.pi.setThinkingLevel(executorEffortRef as ThinkingLevel);
+  }
+  if (!runtime.flowEnabled()) {
+    runtime.pi.setActiveTools([
+      ...runtime.pi.getActiveTools(),
+      "ask_advisor",
+      "record_advisor_outcome",
+    ]);
+  }
+  if (announce) {
+    notify(
+      ctx,
+      `${ADVISOR_ACTIVATION_EXPLANATION}\n\nAdvisor flow ready — Executor: ${executorRef} (thinking: ${executorEffortRef || "default"}) · Advisor: ${advisorRef} (thinking: ${advisorEffortRef || "default"})`,
+      "info"
+    );
+  }
+};

package/src/commands/lifecycle.ts

@@ -0,0 +1,83 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import {
+  alwaysOnRef,
+  executorRef,
+  getPersistedModelRefs,
+  setExecutorRef,
+} from "../config/state.js";
+import { loadConfig, saveConfig } from "../config/storage.js";
+import { herdrAdvisorActivity } from "../herdr.js";
+import { notify } from "./runtime.js";
+import type { CommandRuntime } from "./types.js";
+
+export type ActivateAdvisor = (
+  args: string,
+  ctx: ExtensionContext,
+  announce?: boolean
+) => Promise<void>;
+
+export const registerCommandLifecycle = (
+  runtime: CommandRuntime,
+  activateAdvisor: ActivateAdvisor
+) => {
+  runtime.pi.on("session_start", async (_event, ctx) => {
+    runtime.pendingExecutorModelRef = undefined;
+    // A malformed advisor.json or a provider auth failure must not reject a
+    // lifecycle handler and break session startup.
+    try {
+      loadConfig(ctx);
+      if (alwaysOnRef) {
+        await activateAdvisor("", ctx, false);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      notify(ctx, `Advisor activation failed: ${message}`, "error");
+    }
+  });
+
+  runtime.pi.on("model_select", (event, ctx) => {
+    // "restore" replays a stored session model and "cycle" changes the active
+    // model without an explicit `/model` choice. Neither should redefine the
+    // configured Executor.
+    if (event.source !== "set" || runtime.suppressModelSelectionSync) {
+      return;
+    }
+    const selected = `${event.model.provider}/${event.model.id}`;
+    if (!runtime.flowEnabled()) {
+      // Defer persistence until `/advisor` succeeds. This keeps ordinary model
+      // selection global defaults untouched when the flow is not enabled.
+      runtime.pendingExecutorModelRef = selected;
+      return;
+    }
+    runtime.pendingExecutorModelRef = undefined;
+    if (selected === executorRef) {
+      return;
+    }
+    const persisted = getPersistedModelRefs();
+    setExecutorRef(selected);
+    saveConfig(ctx, {
+      persistAdvisor: Boolean(persisted.advisor),
+      persistExecutor: true,
+    });
+  });
+
+  runtime.pi.on("session_shutdown", (_event, ctx) => {
+    if (ctx.hasUI) {
+      ctx.ui.setStatus("advisor-usage", undefined);
+    }
+    for (const [controller, token] of runtime.manualConsultations) {
+      controller.abort();
+      const timer = runtime.manualProgressTimers.get(controller);
+      if (timer) {
+        clearInterval(timer);
+        runtime.manualProgressTimers.delete(controller);
+      }
+      runtime.scoutStatus.release(ctx, token);
+    }
+    runtime.scoutStatus.clear(ctx);
+    runtime.manualConsultations.clear();
+    runtime.manualProgressTimers.clear();
+    runtime.manualProgress.clear();
+    herdrAdvisorActivity.clear();
+  });
+};

package/src/commands/manual-command.ts

@@ -0,0 +1,107 @@
+import {
+  getAdvisorMaxCallsPerSession,
+  getAdvisorSettings,
+  isSimpleMode,
+} from "../config/state.js";
+import type { GitContextLevel } from "../git.js";
+import { resolveAdvisorRequest } from "../tools/render-common.js";
+import { ManualAdvisorDialog } from "../ui/manual-dialog.js";
+import type { ManualAdvisorRequest } from "../ui/types.js";
+import { loadCommandConfig } from "./activation-preparation.js";
+import { startManualConsultation } from "./manual-consultation.js";
+import type { CommandRuntime, ManualAdvisorProgressState } from "./types.js";
+
+export const registerManualCommand = (runtime: CommandRuntime) => {
+  runtime.pi.registerCommand("advisor-manual", {
+    description:
+      "Consult the Advisor in parallel; accepts an optional focused question and fans its response out to the Executor",
+    handler: async (args, ctx) => {
+      if (!loadCommandConfig(ctx)) {
+        return;
+      }
+      if (
+        !(
+          isSimpleMode() ||
+          runtime.advisorSessionState.canConsult(getAdvisorMaxCallsPerSession())
+        )
+      ) {
+        runtime.reportManualBudgetExhausted(ctx);
+        return;
+      }
+
+      let gitContext: GitContextLevel | undefined;
+      let question: string | undefined;
+      if (ctx.mode === "tui") {
+        const request = await ctx.ui.custom<ManualAdvisorRequest | undefined>(
+          (tui, theme, keybindings, done) =>
+            new ManualAdvisorDialog({
+              gitContext: getAdvisorSettings().gitContext,
+              initialMessage: args,
+              keybindings,
+              onCancel: () => done(undefined),
+              onSubmit: done,
+              theme,
+              tui,
+            }),
+          {
+            overlay: true,
+            overlayOptions: {
+              anchor: "center",
+              margin: 2,
+              maxHeight: "80%",
+              minWidth: 56,
+              width: 76,
+            },
+          }
+        );
+        if (!request) {
+          return;
+        }
+        if (
+          !(
+            isSimpleMode() ||
+            runtime.advisorSessionState.canConsult(
+              getAdvisorMaxCallsPerSession()
+            )
+          )
+        ) {
+          runtime.reportManualBudgetExhausted(ctx);
+          return;
+        }
+        const { gitContext: selectedGitContext, message } = request;
+        gitContext = selectedGitContext;
+        question = resolveAdvisorRequest(message);
+      } else {
+        question = resolveAdvisorRequest(args);
+      }
+
+      if (!isSimpleMode()) {
+        runtime.advisorSessionState.consumeCall();
+      }
+      // A single visible progress surface avoids competing consultations overwriting
+      // each other's streamed state. A newer manual request replaces the previous one.
+      for (const [pending, token] of runtime.manualConsultations) {
+        pending.abort();
+        runtime.scoutStatus.release(ctx, token);
+      }
+      runtime.manualConsultations.clear();
+      const controller = new AbortController();
+      const scoutStatusToken = Symbol("manual-scout");
+      const progressId = runtime.nextManualProgressId();
+      const progress: ManualAdvisorProgressState = { phase: "preparing" };
+      runtime.manualProgress.set(progressId, progress);
+      runtime.scoutStatus.register(scoutStatusToken);
+      runtime.manualConsultations.set(controller, scoutStatusToken);
+      runtime.pi.appendEntry?.("advisor-manual-call", { progressId, question });
+      startManualConsultation(
+        runtime,
+        ctx,
+        question,
+        controller,
+        scoutStatusToken,
+        progress,
+        gitContext
+      );
+    },
+  });
+};

package/src/commands/manual-consultation.ts

@@ -0,0 +1,144 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { advisorRef } from "../config/state.js";
+import type { GitContextLevel } from "../git.js";
+import { herdrAdvisorActivity, notifyHerdrAdvisorFailure } from "../herdr.js";
+import { appendScoutLifecycleEntry } from "../tools/scout-status.js";
+import type { ScoutToolDetails } from "../tools/types.js";
+import { advisorUsageCost, snapshotAdvisorUsage } from "../usage.js";
+import { notify } from "./runtime.js";
+import type { CommandRuntime, ManualAdvisorProgressState } from "./types.js";
+
+export const startManualConsultation = (
+  runtime: CommandRuntime,
+  ctx: ExtensionContext,
+  question: string | undefined,
+  controller: AbortController,
+  scoutStatusToken: symbol,
+  progress: ManualAdvisorProgressState,
+  gitContext?: GitContextLevel
+) => {
+  herdrAdvisorActivity.start();
+  progress.phase = "preparing";
+  runtime.requestManualRender(ctx);
+  if (ctx.hasUI) {
+    const timer = setInterval(() => {
+      if (
+        controller.signal.aborted ||
+        runtime.manualConsultations.get(controller) !== scoutStatusToken
+      ) {
+        clearInterval(timer);
+        return;
+      }
+      runtime.requestManualRender(ctx);
+    }, 80);
+    runtime.manualProgressTimers.set(controller, timer);
+  }
+  let scoutDetails: ScoutToolDetails | undefined;
+  return runtime
+    .requestAdvisor(
+      ctx,
+      question,
+      controller.signal,
+      (thinking, text) => {
+        if (controller.signal.aborted) {
+          return;
+        }
+        progress.phase = "active";
+        progress.thinking = thinking;
+        progress.text = text;
+        runtime.requestManualRender(ctx);
+      },
+      (event) => {
+        if (!controller.signal.aborted) {
+          runtime.scoutStatus.update(ctx, scoutStatusToken, event);
+          scoutDetails = appendScoutLifecycleEntry(
+            runtime.pi,
+            event,
+            scoutDetails
+          );
+          progress.scout = scoutDetails;
+          progress.phase = "active";
+          runtime.requestManualRender(ctx);
+        }
+      },
+      gitContext
+    )
+    .then(({ markdown, usage }) => {
+      if (controller.signal.aborted) {
+        return;
+      }
+      progress.phase = "complete";
+      runtime.advisorSessionState.recordInvocation({
+        cost: advisorUsageCost(usage),
+        executionEffect: "continued",
+        kind: "markdown",
+        model: advisorRef,
+        trigger: "manual",
+        usage,
+      });
+      runtime.updateAdvisorUsageStatus(ctx);
+      const normalizedUsage = snapshotAdvisorUsage(usage);
+      runtime.pi.sendMessage(
+        {
+          content: `Manual Advisor consultation${question ? ` (${question})` : ""}:\n\n${markdown}`,
+          customType: "advisor-manual-result",
+          details: {
+            advisor: advisorRef,
+            question,
+            text: markdown,
+            ...(normalizedUsage ? { usage: normalizedUsage } : {}),
+          },
+          display: true,
+        },
+        {
+          // Steer lets the current turn finish its active work; the Executor sees
+          // the result before its next model call rather than being interrupted.
+          deliverAs: "steer",
+          triggerTurn: true,
+        }
+      );
+    })
+    .catch((error: unknown) => {
+      if (controller.signal.aborted) {
+        return;
+      }
+      progress.phase = "error";
+      const message = error instanceof Error ? error.message : String(error);
+      runtime.advisorSessionState.recordInvocation({
+        executionEffect: "continued",
+        failure: "provider-error",
+        kind: "markdown",
+        model: advisorRef,
+        trigger: "manual",
+      });
+      runtime.updateAdvisorUsageStatus(ctx);
+      runtime.pi.sendMessage(
+        {
+          content: `Manual Advisor consultation failed: ${message}`,
+          customType: "advisor-manual-result",
+          details: {
+            advisor: advisorRef,
+            text: `**Advisor consultation failed:** ${message}`,
+          },
+          display: true,
+        },
+        { deliverAs: "steer", triggerTurn: true }
+      );
+      notify(ctx, `Advisor consultation failed: ${message}`, "error");
+      notifyHerdrAdvisorFailure("Advisor consultation failed", message);
+    })
+    .finally(() => {
+      if (controller.signal.aborted) {
+        progress.phase = "cancelled";
+      }
+      const timer = runtime.manualProgressTimers.get(controller);
+      if (timer) {
+        clearInterval(timer);
+        runtime.manualProgressTimers.delete(controller);
+      }
+      runtime.requestManualRender(ctx);
+      runtime.scoutStatus.release(ctx, scoutStatusToken);
+      runtime.manualConsultations.delete(controller);
+      herdrAdvisorActivity.finish();
+    });
+};