pi-vault-mind 0.16.29 → 0.16.30

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 0.16.30 — 2026-08-27
+
+### Added
+
+- **First-class `pvm` executable.** The npm package now exposes `pvm run [vault-path]`; it uses the current directory when the vault path is omitted and supports both global installation and `npx pi-vault-mind run`.
+- **Explicit launch modes.** `pvm run` stays in the current terminal by default, with `--same-terminal`, `--new-window`, and `--auto` overrides.
+
+### Fixed
+
+- **Portable vault launcher.** `vault-pi.sh` now handles interactive terminals directly, normalizes relative vault paths before deriving runtime state, removes inline-session PID files on exit, and rejects unknown flags instead of treating them as vault paths.
+
+### Verification
+
+- Root and Obsidian builds passed; full test suite: 910/910 passing.
+- `npm pack` includes `scripts/pvm.mjs` as an executable, and `npm exec` resolved the packed tarball's `pvm` command successfully.
+
 ## 0.16.29 — 2026-08-27
 
 ### Fixed

package/README.md

@@ -194,10 +194,25 @@ The Broadcaster agent can generate podcasts, study guides, and slide decks from
 
 ```bash
 pi install npm:pi-vault-mind              # latest
-pi install npm:pi-vault-mind@0.7.0        # pinned
+pi install npm:pi-vault-mind@0.16.30       # pinned release
 pi -e npm:pi-vault-mind                   # try without installing
 ```
 
+`pi install` loads the extension but does not expose its npm executable on your
+shell `PATH`. Install the first-class launcher once when you want the bare
+`pvm` command:
+
+```bash
+npm install --global pi-vault-mind
+pvm run /path/to/your/vault
+```
+
+Or run it without a global installation:
+
+```bash
+npx --yes pi-vault-mind run /path/to/your/vault
+```
+
 Or from git:
 
 ```bash
@@ -269,6 +284,174 @@ Edit `<vault>/.vault-mind/vault-mind.config.json` to match your domain:
 }
 ```
 
+## Using Vault Mind agent identities
+
+Vault Mind keeps the interactive Pi session on the unrestricted `main` persona
+unless you explicitly select a specialist boundary. Bundled specialist skills
+are available resources; merely loading them does not change the active
+persona.
+
+### Start the vault-local main agent
+
+From the vault directory, start Pi in the current terminal:
+
+```bash
+pvm run
+```
+
+You can launch a different vault from anywhere or use the package without a
+global install:
+
+```bash
+pvm run /path/to/your/vault
+npx --yes pi-vault-mind run /path/to/your/vault
+```
+
+`pvm run` defaults to the current terminal. This is the recommended Obsidian
+Terminal profile command. Use a vault-path placeholder supplied by the plugin,
+or provide the vault's absolute path. Override the launch mode when needed:
+
+```bash
+pvm run --same-terminal /path/to/your/vault
+pvm run --new-window /path/to/your/vault
+pvm run --auto /path/to/your/vault
+```
+
+`--new-window` opens a dedicated Terminal/iTerm window. `--auto` uses the
+current terminal when attached to a TTY and falls back to a new window
+otherwise. The packaged shell launcher remains available for direct use as
+`scripts/vault-pi.sh`.
+
+In every mode, the launcher runs Pi inside the target vault with its
+configuration isolated under `<vault>/.vault-mind/.pi/agent/`. It also prevents
+two launcher-managed Pi processes from running for the same vault and removes
+the PID file when an inline session exits.
+
+Check the active persona after startup:
+
+```text
+/vm identity status
+```
+
+A normal main-agent session reports:
+
+```text
+Persona: main
+Effective boundary: none (main agent)
+```
+
+`Injection` may report `enabled` or `disabled`. An enabled injector still
+applies no boundary while the persona is `main`.
+
+### Use specialist agents without changing the main session
+
+Normally, leave the interactive session on `main` and dispatch specialist work
+through the passive watcher:
+
+```text
+@agent-Miner
+Research and extract the durable facts from this note.
+```
+
+The watcher runs that work as an isolated specialist job. It does not turn the
+interactive terminal into the Miner persona. The same distinction applies to
+`@agent-Broadcaster`, `@agent-Manager`, and `@agent-Heavy-Lifter`.
+
+### Explicitly change the interactive persona
+
+Use an identity boundary only when the current interactive session itself
+should follow a specialist capability contract:
+
+```text
+/vm identity set miner
+/vm identity set broadcaster
+/vm identity set manager
+/vm identity set heavy-lifter
+```
+
+| Persona | Intended interactive boundary |
+|---|---|
+| `main` | Unrestricted primary agent with the full configured toolset |
+| `manager` | Orchestrates collections, publishing, and subagents; does not run Bash |
+| `miner` | Extracts and stores knowledge; does not run Bash or publish |
+| `broadcaster` | Produces presentation artifacts; does not run Bash or write durable knowledge |
+| `heavy-lifter` | Performs file and Bash work in isolation; does not write durable knowledge or publish |
+
+`/vm identity set <role>` persists the selected persona, enables boundary
+injection, and applies on the next agent turn.
+
+Use the remaining controls to inspect or suspend that selection:
+
+```text
+/vm identity status
+/vm identity off
+/vm identity on
+```
+
+- `off` disables boundary injection without discarding the selected persona.
+- `on` re-enables the configured persona boundary on the next agent turn.
+- `status` shows the configured persona, injection switch, effective boundary,
+  and any environment overrides.
+
+Restore the safe main-agent default with:
+
+```text
+/vm identity set main
+/vm identity off
+/vm identity status
+```
+
+The final status should show `Effective boundary: none (main agent)`.
+
+### Configuration and environment overrides
+
+Identity controls are stored in the vault-local configuration:
+
+```json
+{
+  "vaultMind": {
+    "identities": {
+      "activeRole": "main",
+      "injectBoundaries": false
+    }
+  }
+}
+```
+
+The canonical path is
+`<vault>/.vault-mind/vault-mind.config.json` under
+`vaultMind.identities`. Identity commands preserve any existing
+`vaultMind.identities.roles` allowlists.
+
+Launch automation and explicit specialist forks can override the saved values
+for one process:
+
+```bash
+VAULT_MIND_AGENT_ROLE=miner VAULT_MIND_IDENTITY_INJECTION=on pi
+VAULT_MIND_IDENTITY_INJECTION=off pi
+```
+
+`VAULT_MIND_AGENT_ROLE` takes precedence over `activeRole`.
+`VAULT_MIND_IDENTITY_INJECTION=off` suppresses every boundary, while `on`
+enables the explicitly selected role. Missing, `main`, `none`, and unknown
+roles all resolve safely to the unrestricted main agent.
+
+### Troubleshoot an unexpected specialist boundary
+
+1. Run `/vm identity status` and check both the configured persona and any
+   reported environment overrides.
+2. If an environment override is present, exit Pi, unset
+   `VAULT_MIND_AGENT_ROLE` and `VAULT_MIND_IDENTITY_INJECTION`, then relaunch.
+3. Run `/vm identity set main`, followed by `/vm identity off`.
+4. Send the next agent turn and re-run `/vm identity status`; boundary changes
+   take effect on the next turn.
+5. Confirm Pi was started for the intended vault and uses
+   `<vault>/.vault-mind/.pi/agent/` as `PI_CODING_AGENT_DIR`.
+
+Do not edit `SYSTEM.md` or an agent skill to change the interactive identity.
+Those files provide operating instructions and resources; persona selection
+belongs in `vaultMind.identities` or an explicit environment override.
+
 ## Example domains
 
 ### Research project

package/dist/test/pvm-cli.test.js

@@ -0,0 +1,88 @@
+import { strict as assert } from "node:assert";
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import { tmpdir } from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { fileURLToPath } from "node:url";
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+const pvmCli = path.join(repoRoot, "scripts", "pvm.mjs");
+const vaultLauncher = path.join(repoRoot, "scripts", "vault-pi.sh");
+describe("pvm CLI", () => {
+    let testDir;
+    let vaultPath;
+    let binDir;
+    let outputPath;
+    beforeEach(() => {
+        testDir = path.join(tmpdir(), `pvm-cli-${process.pid}-${Date.now()}`);
+        vaultPath = path.join(testDir, "Test Vault");
+        binDir = path.join(testDir, "bin");
+        outputPath = path.join(testDir, "bash-args.txt");
+        fs.mkdirSync(vaultPath, { recursive: true });
+        fs.mkdirSync(binDir, { recursive: true });
+        fs.writeFileSync(path.join(binDir, "bash"), `#!/bin/bash
+set -euo pipefail
+printf '%s\n' "$@" > "$PVM_TEST_OUTPUT"
+exit "\${PVM_TEST_BASH_EXIT:-0}"
+`, { mode: 0o755 });
+    });
+    afterEach(() => {
+        fs.rmSync(testDir, { recursive: true, force: true });
+    });
+    function runCli(args, cwd = vaultPath, env = {}) {
+        return spawnSync(process.execPath, [pvmCli, ...args], {
+            cwd,
+            encoding: "utf-8",
+            env: {
+                ...process.env,
+                PATH: `${binDir}:${process.env.PATH ?? ""}`,
+                PVM_TEST_OUTPUT: outputPath,
+                ...env,
+            },
+        });
+    }
+    function capturedBashArgs() {
+        return fs.readFileSync(outputPath, "utf-8").trimEnd().split("\n");
+    }
+    it("runs the current vault in the same terminal by default", () => {
+        const result = runCli(["run"]);
+        assert.equal(result.status, 0, result.stderr || result.stdout);
+        assert.deepEqual(capturedBashArgs(), [
+            vaultLauncher,
+            "--same-terminal",
+            fs.realpathSync(vaultPath),
+        ]);
+    });
+    it("passes an explicit vault and launch mode to the packaged launcher", () => {
+        const result = runCli(["run", "--new-window", vaultPath], testDir);
+        assert.equal(result.status, 0, result.stderr || result.stdout);
+        assert.deepEqual(capturedBashArgs(), [vaultLauncher, "--new-window", vaultPath]);
+    });
+    it("preserves the launcher's automatic TTY mode when requested", () => {
+        const result = runCli(["run", vaultPath, "--auto"], testDir);
+        assert.equal(result.status, 0, result.stderr || result.stdout);
+        assert.deepEqual(capturedBashArgs(), [vaultLauncher, vaultPath]);
+    });
+    it("propagates the packaged launcher's exit status", () => {
+        const result = runCli(["run"], vaultPath, { PVM_TEST_BASH_EXIT: "23" });
+        assert.equal(result.status, 23);
+    });
+    it("reports when the shell launcher cannot be started", () => {
+        const emptyBinDir = path.join(testDir, "empty-bin");
+        fs.mkdirSync(emptyBinDir);
+        const result = runCli(["run"], vaultPath, { PATH: emptyBinDir });
+        assert.equal(result.status, 1);
+        assert.match(result.stderr, /pvm: failed to start launcher:/);
+    });
+    it("rejects unknown commands with usage help", () => {
+        const result = runCli(["launch"]);
+        assert.equal(result.status, 2);
+        assert.match(result.stderr, /Usage: pvm run/);
+        assert.equal(fs.existsSync(outputPath), false);
+    });
+    it("publishes pvm as an executable package bin", () => {
+        const packageJson = JSON.parse(fs.readFileSync(path.join(repoRoot, "package.json"), "utf-8"));
+        assert.equal(packageJson.bin?.pvm, "scripts/pvm.mjs");
+        assert.notEqual(fs.statSync(pvmCli).mode & 0o111, 0);
+    });
+});

package/dist/test/vault-pi-script.test.js

@@ -0,0 +1,101 @@
+import { strict as assert } from "node:assert";
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import { tmpdir } from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { fileURLToPath } from "node:url";
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+const launcher = path.join(repoRoot, "scripts", "vault-pi.sh");
+describe("vault-pi launcher", () => {
+    let testDir;
+    let vaultPath;
+    let binDir;
+    let outputPath;
+    beforeEach(() => {
+        testDir = path.join(tmpdir(), `pvm-vault-pi-${process.pid}-${Date.now()}`);
+        vaultPath = path.join(testDir, "Test Vault");
+        binDir = path.join(testDir, "bin");
+        outputPath = path.join(testDir, "pi-output.txt");
+        fs.mkdirSync(vaultPath, { recursive: true });
+        fs.mkdirSync(binDir, { recursive: true });
+        fs.writeFileSync(path.join(binDir, "pi"), `#!/usr/bin/env bash
+set -euo pipefail
+pid_file="$PWD/.vault-mind/.pi/agent/daemon.pid"
+printf 'cwd=%s\nagent=%s\nargs=%s\npid=%s\n' \
+  "$PWD" "$PI_CODING_AGENT_DIR" "$*" "$(cat "$pid_file")" > "$PVM_TEST_OUTPUT"
+`, { mode: 0o755 });
+        for (const command of ["open", "osascript"]) {
+            fs.writeFileSync(path.join(binDir, command), "#!/usr/bin/env bash\nexit 97\n", {
+                mode: 0o755,
+            });
+        }
+    });
+    afterEach(() => {
+        fs.rmSync(testDir, { recursive: true, force: true });
+    });
+    it("runs Pi in the current terminal when same-terminal mode is requested", () => {
+        const result = spawnSync("bash", [launcher, "--same-terminal", vaultPath], {
+            cwd: testDir,
+            encoding: "utf-8",
+            env: {
+                ...process.env,
+                PATH: `${binDir}:${process.env.PATH ?? ""}`,
+                PVM_TEST_OUTPUT: outputPath,
+            },
+        });
+        assert.equal(result.status, 0, result.stderr || result.stdout);
+        const output = fs.readFileSync(outputPath, "utf-8");
+        assert.match(output, new RegExp(`^cwd=${vaultPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`, "m"));
+        assert.match(output, new RegExp(`^agent=${path.join(vaultPath, ".vault-mind", ".pi", "agent").replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`, "m"));
+        assert.match(output, /^args=$/m);
+        assert.match(output, /^pid=\d+$/m);
+        assert.equal(fs.existsSync(path.join(vaultPath, ".vault-mind", ".pi", "agent", "daemon.pid")), false);
+    });
+    it("normalizes a relative vault path before changing directories", () => {
+        const relativeVaultPath = path.relative(testDir, vaultPath);
+        const result = spawnSync("bash", [launcher, "--same-terminal", relativeVaultPath], {
+            cwd: testDir,
+            encoding: "utf-8",
+            env: {
+                ...process.env,
+                PATH: `${binDir}:${process.env.PATH ?? ""}`,
+                PVM_TEST_OUTPUT: outputPath,
+            },
+        });
+        assert.equal(result.status, 0, result.stderr || result.stdout);
+        const output = fs.readFileSync(outputPath, "utf-8");
+        const cwd = output.match(/^cwd=(.*)$/m)?.[1];
+        const agentDir = output.match(/^agent=(.*)$/m)?.[1];
+        assert.ok(cwd, "fake Pi did not report its working directory");
+        assert.equal(agentDir, path.join(cwd, ".vault-mind", ".pi", "agent"));
+        assert.equal(fs.existsSync(path.join(vaultPath, ".vault-mind", ".pi", "agent", "daemon.pid")), false);
+    });
+    it("falls back to a new window for non-interactive automatic launches", () => {
+        const result = spawnSync("bash", [launcher, vaultPath], {
+            cwd: testDir,
+            encoding: "utf-8",
+            env: {
+                ...process.env,
+                PATH: `${binDir}:${process.env.PATH ?? ""}`,
+                PVM_TEST_OUTPUT: outputPath,
+            },
+        });
+        assert.equal(result.status, 97);
+        assert.equal(fs.existsSync(outputPath), false);
+    });
+    it("rejects an unknown launch flag with usage help", () => {
+        const result = spawnSync("bash", [launcher, "--new-widnow"], {
+            cwd: testDir,
+            encoding: "utf-8",
+            env: {
+                ...process.env,
+                PATH: `${binDir}:${process.env.PATH ?? ""}`,
+                PVM_TEST_OUTPUT: outputPath,
+            },
+        });
+        assert.equal(result.status, 2);
+        assert.match(result.stderr, /Usage: vault-pi\.sh/);
+        assert.equal(fs.existsSync(path.join(testDir, "--new-widnow")), false);
+    });
+});

package/package.json

@@ -1,10 +1,13 @@
 {
 	"name": "pi-vault-mind",
-	"version": "0.16.29",
+	"version": "0.16.30",
 	"description": "Passive Obsidian vault extension for pi. Watches @agent markers, dispatches forked subagents (Miner, Broadcaster, Heavy-Lifter), stores in LanceDB with vector + FTS + graph. Multi-agent 'Drop & Forget' workflow for the pi agent ecosystem.",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"type": "module",
+	"bin": {
+		"pvm": "scripts/pvm.mjs"
+	},
 	"files": [
 		"dist",
 		"agents",

package/scripts/pvm.mjs

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const USAGE = `Usage: pvm run [--same-terminal | --new-window | --auto] [vault-path]
+
+Commands:
+  run  Start Pi with the vault-local Vault Mind agent environment.
+
+Run options:
+  --same-terminal  Run Pi in the current terminal (default).
+  --new-window     Open Pi in a new Terminal/iTerm window.
+  --auto           Use the current terminal when attached to a TTY; otherwise open a new window.
+
+When vault-path is omitted, pvm uses the current working directory.`;
+
+function fail(message) {
+	if (message) console.error(`pvm: ${message}\n`);
+	console.error(USAGE);
+	process.exitCode = 2;
+}
+
+const [command, ...args] = process.argv.slice(2);
+
+if (!command || command === "-h" || command === "--help" || command === "help") {
+	console.log(USAGE);
+} else if (command !== "run") {
+	fail(`unknown command: ${command}`);
+} else {
+	let mode = "same-terminal";
+	let vaultPath;
+	let invalid = false;
+
+	for (const arg of args) {
+		if (arg === "-h" || arg === "--help") {
+			console.log(USAGE);
+			process.exit(0);
+		}
+		if (arg === "--same-terminal") {
+			mode = "same-terminal";
+			continue;
+		}
+		if (arg === "--new-window") {
+			mode = "new-window";
+			continue;
+		}
+		if (arg === "--auto") {
+			mode = "auto";
+			continue;
+		}
+		if (arg.startsWith("-")) {
+			fail(`unknown option: ${arg}`);
+			invalid = true;
+			break;
+		}
+		if (vaultPath !== undefined) {
+			fail("run accepts at most one vault path");
+			invalid = true;
+			break;
+		}
+		vaultPath = arg;
+	}
+
+	if (!invalid) {
+		const launcher = fileURLToPath(new URL("./vault-pi.sh", import.meta.url));
+		const launchMode = mode === "auto" ? [] : [`--${mode}`];
+		const result = spawnSync("bash", [launcher, ...launchMode, vaultPath ?? process.cwd()], {
+			stdio: "inherit",
+			env: process.env,
+		});
+
+		if (result.error) {
+			console.error(`pvm: failed to start launcher: ${result.error.message}`);
+			process.exitCode = 1;
+		} else {
+			process.exitCode = result.status ?? 1;
+		}
+	}
+}

package/scripts/vault-pi.sh

@@ -2,20 +2,59 @@
 # vault-pi.sh — Start pi for a vault, ensuring only one instance runs.
 #
 # Usage:
-#   bash scripts/vault-pi.sh /path/to/vault
+#   bash scripts/vault-pi.sh [--same-terminal | --new-window] /path/to/vault
 #
-# Obsidian Shell Commands integration:
-#   Command: bash /path/to/pi-vault-mind/scripts/vault-pi.sh {{vault_path}}
+# Obsidian Terminal integration:
+#   bash /path/to/pi-vault-mind/scripts/vault-pi.sh {{vault_path}}
 #
 # The script:
 #   1. Checks for an existing PID file at <vault>/.vault-mind/.pi/agent/daemon.pid
 #   2. If the PID is alive → exits silently (already running)
 #   3. If stale/dead → cleans up and starts fresh
-#   4. Opens a new terminal window with pi using the vault-local config dir
+#   4. Runs in the current terminal when attached to a TTY
+#   5. Falls back to a new Terminal/iTerm window for non-interactive callers
 
 set -euo pipefail
 
-VAULT="${1:?Usage: vault-pi.sh <vault-path>}"
+usage() {
+	cat <<'EOF'
+Usage: vault-pi.sh [--same-terminal | --new-window] <vault-path>
+
+Launch modes:
+  auto             Use the current terminal when attached to a TTY; otherwise open a new window.
+  --same-terminal  Force Pi to run in the current terminal.
+  --new-window     Force Pi to open in a new Terminal/iTerm window.
+EOF
+}
+
+MODE="auto"
+case "${1:-}" in
+	--same-terminal)
+		MODE="same-terminal"
+		shift
+		;;
+	--new-window)
+		MODE="new-window"
+		shift
+		;;
+	-h | --help)
+		usage
+		exit 0
+		;;
+	-*)
+		usage >&2
+		exit 2
+		;;
+esac
+
+if [ "$#" -ne 1 ]; then
+	usage >&2
+	exit 2
+fi
+
+VAULT="$1"
+mkdir -p "${VAULT}"
+VAULT="$(cd "${VAULT}" && pwd)"
 PI_DIR="${VAULT}/.vault-mind/.pi/agent"
 PID_FILE="${PI_DIR}/daemon.pid"
 
@@ -37,14 +76,39 @@ fi
 # extension isn't installed makes pi reject the whole invocation with
 # "Unknown option: --op-env" — only pass it when both the env file exists
 # AND pi-1password is actually installed in the vault-local agent dir.
-OP_ENV_ARG=""
+USE_OP_ENV="false"
 if [ -f "${VAULT}/.vault-mind/.env.1pass" ] && [ -d "${PI_DIR}/npm/node_modules/pi-1password" ]; then
-	OP_ENV_ARG="--op-env .vault-mind/.env.1pass"
+	USE_OP_ENV="true"
 fi
 
-# Start pi in a new terminal window.
-# macOS: open -a Terminal or open -a iTerm
-# The trap writes the PID and cleans up on exit.
+# Auto mode keeps interactive callers, including Obsidian Terminal, in place.
+# Non-interactive runners retain the legacy new-window behavior.
+if [ "${MODE}" = "auto" ]; then
+	if [ -t 0 ] && [ -t 1 ]; then
+		MODE="same-terminal"
+	else
+		MODE="new-window"
+	fi
+fi
+
+if [ "${MODE}" = "same-terminal" ]; then
+	echo "$$" > "${PID_FILE}"
+	trap 'rm -f "${PID_FILE}"' EXIT
+	cd "${VAULT}"
+	echo "[vault-pi] Starting pi for ${VAULT} in the current terminal"
+	if [ "${USE_OP_ENV}" = "true" ]; then
+		PI_CODING_AGENT_DIR="${PI_DIR}" pi --op-env .vault-mind/.env.1pass
+	else
+		PI_CODING_AGENT_DIR="${PI_DIR}" pi
+	fi
+	exit $?
+fi
+
+# New-window mode is retained for non-interactive launchers and explicit use.
+OP_ENV_ARG=""
+if [ "${USE_OP_ENV}" = "true" ]; then
+	OP_ENV_ARG="--op-env .vault-mind/.env.1pass"
+fi
 PI_CMD="PI_CODING_AGENT_DIR='${PI_DIR}' pi ${OP_ENV_ARG}; rm -f '${PID_FILE}'"
 
 if [ -d "/Applications/iTerm.app" ]; then
@@ -52,8 +116,8 @@ if [ -d "/Applications/iTerm.app" ]; then
 elif [ -d "/Applications/Utilities/Terminal.app" ] || [ -d "/System/Applications/Utilities/Terminal.app" ]; then
 	osascript -e "tell application \"Terminal\" to do script \"echo \$\$ > '${PID_FILE}'; cd '${VAULT}'; ${PI_CMD}\""
 else
-	echo "[vault-pi] No supported terminal found (iTerm or Terminal.app)"
+	echo "[vault-pi] No supported terminal found (iTerm or Terminal.app)" >&2
 	exit 1
 fi
 
-echo "[vault-pi] Started pi for ${VAULT}"
+echo "[vault-pi] Started pi for ${VAULT} in a new terminal window"