@rubytech/create-siteoffice-code 0.1.256

package/payload/platform/plugins/admin/mcp/dist/index.js

@@ -0,0 +1,3120 @@
+import { initStderrTee } from "../../../../lib/mcp-stderr-tee/dist/index.js";
+initStderrTee("admin");
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { eagerTool } from "../../../../lib/mcp-eager/dist/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { readFile, writeFile } from "node:fs/promises";
+import { resolve, join } from "node:path";
+import { execFileSync } from "node:child_process";
+import { appendFileSync, cpSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { writeAdminEntry, removeAdminFromAccount } from "../../../../lib/admins-write/dist/index.js";
+import { embed } from "../../../../lib/embed-client/dist/index.js";
+import { requirePortEnv } from "../../../../lib/require-port-env/dist/index.js";
+import { deviceUrlBlock } from "../../../../lib/device-url/dist/index.js";
+import { substituteBrandPlaceholders } from "../../../../lib/brand-templating/dist/index.js";
+import { resolveEntitlement } from "../../../../lib/entitlement/dist/index.js";
+import { createHash, randomInt, randomUUID } from "node:crypto";
+import { createConnection } from "node:net";
+import { homedir, hostname as osHostname } from "node:os";
+import QRCode from "qrcode";
+import { getSession, closeDriver } from "./lib/neo4j.js";
+import { findSkillOwners, computePluginReadHint, loadSkill, parseRequiredInputs, adminAuthoringSkillBlock, skillSlugFromReadArgs, AUTHORING_DISPATCH_HINT } from "./skill-resolution.js";
+import { resolvePublicHostname } from "./lib/public-hostname.js";
+import { publishSite } from "./tools/publish-site.js";
+import { resolveCapabilitiesHere } from "./tools/capabilities-here.js";
+import { runCatalogueCensus } from "./lib/catalogue-census.js";
+import { runAuthenticate } from "./tools/admin-identity-authenticate.js";
+function refusalGuidance(kind) {
+    switch (kind) {
+        case "unsafe-slug":
+            return "Operator action: pick a slug whose segments match /^[a-z0-9_][a-z0-9_.-]{0,99}$/i, no leading dot, no `..`.";
+        case "destination-occupied":
+            return "Operator action: the target directory already exists with contents. Clean it up explicitly or pick a different slug.";
+        case "symlink-in-source":
+            return "Operator action: the source tree contains a symlink. Resolve or remove the symlink before publishing.";
+        case "zero-html":
+            return "Operator action: the source has no top-level .html file. Confirm the tree shape.";
+        case "ambiguous-html":
+            return "Operator action: pick which top-level .html file is the landing page (or add an index.html to the source).";
+    }
+}
+const server = new McpServer({
+    name: "admin",
+    version: "0.1.0",
+});
+const PLATFORM_ROOT = process.env.PLATFORM_ROOT ?? resolve(import.meta.dirname, "../../../..");
+// Plugin-system boot tolerance — see Task 202.
+// Module-init must never throw; plugin-system spawn enumerates tools/list
+// before any per-account env is set. Per-call refusal preserves account
+// isolation in metadata-only mode.
+const ACCOUNT_ID = process.env.ACCOUNT_ID ?? null;
+process.stderr.write(`[admin] boot accountId=${ACCOUNT_ID ?? "null"}\n`);
+function refuseNoAccount(toolName) {
+    process.stderr.write(`[admin] tool=${toolName} refuse reason=no-account-context\n`);
+    return {
+        content: [
+            {
+                type: "text",
+                text: `${toolName} cannot execute: this MCP instance was launched without ACCOUNT_ID (plugin-system metadata-only mode). Per-account admin tools require ACCOUNT_ID at spawn.`,
+            },
+        ],
+        isError: true,
+    };
+}
+// Task 142 — `PLATFORM_PORT` is the internal loopback port, stamped on
+// the claude-session-manager systemd unit and forwarded to this MCP
+// process via the per-spawn `maxy-mcp-*.json` env block written by
+// `pty-spawner.writePerSpawnMcpConfig`. `MAXY_BRAND_PORT` is the brand's
+// public UI port, used only for display-surface `.local` URLs.
+// Ports are best-effort at boot: plugin-system metadata-only spawn has no
+// port env, so we capture the loud-fail message instead of crashing. Real
+// per-account spawns supply both; any handler reaching the port-using code
+// paths is gated upstream by the accountId refusal.
+let PLATFORM_PORT = "";
+let MAXY_BRAND_PORT = "";
+try {
+    PLATFORM_PORT = String(requirePortEnv("PLATFORM_PORT", { tag: "admin:module-init" }));
+    MAXY_BRAND_PORT = String(requirePortEnv("MAXY_BRAND_PORT", { tag: "admin:module-init" }));
+}
+catch (err) {
+    process.stderr.write(`[admin] boot port-env unavailable — ${err.message}\n`);
+}
+// Brand-aware config — reads configDir, productName, and commercialMode from
+// brand.json stamped at install time. commercialMode gates the
+// entitlement verifier: false (default) preserves personal-mode installs;
+// true requires a Rubytech-signed entitlement.json or the install runs locked.
+// No fallback: if brand.json is missing or incomplete, the platform wasn't properly installed.
+function resolveBrandConfig() {
+    const brandPath = resolve(PLATFORM_ROOT, "config", "brand.json");
+    if (!existsSync(brandPath)) {
+        throw new Error(`brand.json not found at ${brandPath} — platform not properly installed`);
+    }
+    try {
+        const brand = JSON.parse(readFileSync(brandPath, "utf-8"));
+        if (!brand.configDir) {
+            throw new Error(`brand.json at ${brandPath} is missing the configDir field`);
+        }
+        if (!brand.productName) {
+            throw new Error(`brand.json at ${brandPath} is missing the productName field`);
+        }
+        // brand.json is the single source of truth for the
+        // four brand-scoped port fields. An admin MCP probe must see the exact
+        // same numbers the rest of the platform binds; silent vncDisplay-derived
+        // fallback was a recurrence-class silent-fallback-masks-root-cause
+        // violation and is now loud-fail.
+        const brandLabel = String(brand.configDir).replace(/^\./, "");
+        if (typeof brand.vncDisplay !== "number") {
+            console.error(`[mcp:admin] error reason=cdp-port-unresolved brand=${brandLabel} path=${brandPath} field=vncDisplay json_keys=${Object.keys(brand).join(",")}`);
+            throw new Error(`brand.json at ${brandPath} missing required field: vncDisplay`);
+        }
+        for (const field of ["rfbPort", "websockifyPort", "cdpPort"]) {
+            if (typeof brand[field] !== "number") {
+                console.error(`[mcp:admin] error reason=cdp-port-unresolved brand=${brandLabel} path=${brandPath} field=${field} json_keys=${Object.keys(brand).join(",")}`);
+                throw new Error(`brand.json at ${brandPath} missing required field: ${field}`);
+            }
+        }
+        return {
+            configDir: brand.configDir,
+            productName: brand.productName,
+            commercialMode: brand.commercialMode === true,
+            vncDisplay: brand.vncDisplay,
+            rfbPort: brand.rfbPort,
+            websockifyPort: brand.websockifyPort,
+            cdpPort: brand.cdpPort,
+        };
+    }
+    catch (err) {
+        if (err instanceof SyntaxError) {
+            throw new Error(`brand.json at ${brandPath} is not valid JSON: ${err.message}`);
+        }
+        throw err;
+    }
+}
+const BRAND_CONFIG = resolveBrandConfig();
+const CONFIG_DIR = resolve(homedir(), BRAND_CONFIG.configDir);
+const BRAND_NAME = BRAND_CONFIG.productName;
+// Boot-time catalogue census — emits one [catalogue-census] line per spawn
+// naming any specialist on disk that has no matching reference row in the
+// shipped platform-architecture skill body. Closes the F5 silent-drift
+// blind spot (template added, doc row missed). 24h periodic tick is
+// deferred to Task 562.
+try {
+    const brandPath = resolve(PLATFORM_ROOT, "config", "brand.json");
+    const brandJson = JSON.parse(readFileSync(brandPath, "utf-8"));
+    const shipsBundles = Array.isArray(brandJson.shipsPremiumBundles) ? brandJson.shipsPremiumBundles : [];
+    // Census against the shipped skill body — only bundles whose docs/references/
+    // tree is baked into the per-brand corpus contribute specialists that the
+    // body is expected to row. Bundles without docs/references/ (e.g. writer-craft,
+    // venture-studio, teaching today) ship agents but no SKILL body rows, so
+    // including them produces F5 false-positives.
+    const premiumRoot = resolve(PLATFORM_ROOT, "..", "premium-plugins");
+    const enabledBundles = shipsBundles.filter((b) => existsSync(resolve(premiumRoot, b, "docs", "references")));
+    const census = runCatalogueCensus({
+        platformRoot: PLATFORM_ROOT,
+        premiumPluginsRoot: premiumRoot,
+        enabledBundles,
+        shippedSkillPath: resolve(PLATFORM_ROOT, "plugins", "admin", "skills", "platform-architecture", "SKILL.md"),
+    });
+    process.stderr.write(`[catalogue-census] disk=${census.diskCount} documented=${census.documentedCount} missing=${census.missing.join(",")} stale=${census.stale.join(",")}\n`);
+}
+catch (err) {
+    process.stderr.write(`[catalogue-census] error reason=${err.message}\n`);
+}
+// Entitlement input shape for the verifier. configDir is rooted under $HOME
+// (where entitlement.json is delivered post-purchase). platformRoot is needed
+// because the verifier runs in two bundle contexts (CJS dist for MCP, ESM tsup
+// bundle for UI) — caller passes the root rather than the verifier guessing.
+const ENTITLEMENT_BRAND = {
+    configDir: CONFIG_DIR,
+    platformRoot: PLATFORM_ROOT,
+    commercialMode: BRAND_CONFIG.commercialMode,
+};
+/** Resolve current effective entitlement. Memoized inside the verifier. */
+async function currentEntitlement() {
+    const config = await readAccountConfig();
+    return resolveEntitlement(ENTITLEMENT_BRAND, {
+        accountId: typeof config.accountId === "string" ? config.accountId : "",
+        customerEmail: typeof config.customerEmail === "string" ? config.customerEmail : undefined,
+        tier: typeof config.tier === "string" ? config.tier : undefined,
+        purchasedPlugins: Array.isArray(config.purchasedPlugins)
+            ? config.purchasedPlugins
+            : undefined,
+    });
+}
+const REMOTE_PASSWORD_FILE = resolve(CONFIG_DIR, ".remote-password");
+// Resolve account directory
+function getAccountDir() {
+    if (!ACCOUNT_ID) {
+        throw new Error("getAccountDir() called without ACCOUNT_ID — handler guard missing");
+    }
+    const dir = resolve(PLATFORM_ROOT, "..", "data/accounts", ACCOUNT_ID);
+    if (!existsSync(dir)) {
+        throw new Error(`Account directory not found: ${dir}`);
+    }
+    return dir;
+}
+async function readAccountConfig() {
+    const configPath = join(getAccountDir(), "account.json");
+    const content = await readFile(configPath, "utf-8");
+    return JSON.parse(content);
+}
+const STAGING_ROOT = resolve(PLATFORM_ROOT, "../premium-plugins");
+const PLUGINS_DIR = resolve(PLATFORM_ROOT, "plugins");
+const CORE_PLUGINS = ["admin", "memory", "docs", "cloudflare"];
+// users.json lives under CONFIG_DIR (persistent) — see paths.ts comment for
+// the regression that motivated the move. Both platform/ui and this MCP plugin
+// resolve the same file via brand-aware $HOME/<configDir>, so the device-level
+// admin auth store is single-pathed across both processes.
+const USERS_FILE = resolve(CONFIG_DIR, "users.json");
+/** Maximum number of admin users allowed per tier. */
+const MAX_ADMINS_BY_TIER = {
+    solo: 1,
+    family: 5,
+    pro: 5,
+};
+const MAX_ADMINS_DEFAULT = 5;
+function hashPin(pin) {
+    return createHash("sha256").update(pin).digest("hex");
+}
+function readUsersJson() {
+    if (!existsSync(USERS_FILE)) {
+        throw new Error("users.json not found — run the seed script first");
+    }
+    const raw = readFileSync(USERS_FILE, "utf-8").trim();
+    if (!raw)
+        return [];
+    return JSON.parse(raw);
+}
+function writeUsersJson(users) {
+    writeFileSync(USERS_FILE, JSON.stringify(users, null, 2) + "\n", "utf-8");
+}
+function generateUniquePin(users, maxRetries = 10) {
+    const existingPins = new Set(users.map(u => u.pin));
+    for (let i = 0; i < maxRetries; i++) {
+        const raw = String(randomInt(0, 10000)).padStart(4, "0");
+        const hashed = hashPin(raw);
+        if (!existingPins.has(hashed)) {
+            return raw;
+        }
+        console.error(`[admin] PIN collision during admin-add: rejecting duplicate (attempt ${i + 1}/${maxRetries})`);
+    }
+    throw new Error("Could not generate a unique PIN after multiple attempts. Specify a PIN manually.");
+}
+const VALID_PLUGIN_NAME = /^[a-z0-9-]+$/;
+/** Parse YAML frontmatter from markdown content. Returns key-value pairs. */
+function parseFrontmatter(content) {
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match)
+        return {};
+    const result = {};
+    let currentKey = "";
+    let currentArray = null;
+    for (const line of match[1].split("\n")) {
+        const kvMatch = line.match(/^(\w[\w-]*):\s*(.*)$/);
+        if (kvMatch) {
+            if (currentArray && currentKey) {
+                result[currentKey] = currentArray;
+                currentArray = null;
+            }
+            const [, key, rawValue] = kvMatch;
+            const value = rawValue.replace(/^["']|["']$/g, "").trim();
+            if (value) {
+                result[key] = value;
+                currentKey = key;
+            }
+            else {
+                // Key with no inline value — next lines may be array items
+                currentKey = key;
+                currentArray = [];
+            }
+        }
+        else if (currentArray !== null) {
+            const itemMatch = line.match(/^\s*-\s+(.+)$/);
+            if (itemMatch) {
+                currentArray.push(itemMatch[1].trim());
+            }
+        }
+    }
+    if (currentArray && currentKey) {
+        result[currentKey] = currentArray;
+    }
+    return result;
+}
+// ===================================================================
+// System tools
+// ===================================================================
+function checkPort(port, timeoutMs = 1000) {
+    return new Promise((res) => {
+        const socket = createConnection(port, "127.0.0.1");
+        socket.setTimeout(timeoutMs);
+        socket.once("connect", () => { socket.destroy(); res(true); });
+        socket.once("error", () => { socket.destroy(); res(false); });
+        socket.once("timeout", () => { socket.destroy(); res(false); });
+    });
+}
+eagerTool(server, "system-status", "Check health of all Maxy platform services: Neo4j, Ollama, Cloudflare tunnel, crontab (Maxy cron entries), VNC, Chrome (CDP), specialist agents, and deployed brand identity.", {}, async () => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("system-status");
+    const checks = {};
+    try {
+        // NEO4J_URI must be explicit. The outer try/catch surfaces the
+        // unset condition as `checks.neo4j = "unreachable: NEO4J_URI unset..."`
+        // so system-status still reports cleanly — the misconfig appears in the
+        // check output instead of taking down the whole tool.
+        const neo4jUri = process.env.NEO4J_URI;
+        if (!neo4jUri) {
+            throw new Error("NEO4J_URI unset (no silent default)");
+        }
+        // NOTE: the port-replace below only works when the URI ends in :7687.
+        // For non-default bolt ports (e.g. :7688 on realagent) the HTTP port is
+        // bolt - 213 (see graph-proxy.ts). Pre-existing fragility — flagged as a
+        // follow-up in.docs/neo4j-uri-audit.md. Not in scope.
+        const res = await fetch(neo4jUri.replace("bolt://", "http://").replace("7687", "7474"), { signal: AbortSignal.timeout(3000) });
+        checks.neo4j = res.ok ? "healthy" : `unhealthy (${res.status})`;
+    }
+    catch (err) {
+        checks.neo4j = `unreachable: ${err instanceof Error ? err.message : String(err)}`;
+    }
+    try {
+        const ollamaUrl = process.env.OLLAMA_URL ?? "http://localhost:11434";
+        const res = await fetch(`${ollamaUrl}/api/tags`, {
+            signal: AbortSignal.timeout(3000),
+        });
+        if (res.ok) {
+            const data = (await res.json());
+            const models = data.models?.map((m) => m.name).join(", ") ?? "none";
+            checks.ollama = `healthy (models: ${models})`;
+        }
+        else {
+            checks.ollama = `unhealthy (${res.status})`;
+        }
+    }
+    catch (err) {
+        checks.ollama = `unreachable: ${err instanceof Error ? err.message : String(err)}`;
+    }
+    // Cloudflare tunnel: lightweight process check (full status via tunnel-status in cloudflare plugin)
+    try {
+        execFileSync("pgrep", ["-x", "cloudflared"], { timeout: 2000 });
+        checks.cloudflare = "running";
+    }
+    catch {
+        // pgrep exits non-zero if no process found
+        try {
+            execFileSync("which", ["cloudflared"], { encoding: "utf-8", timeout: 3000 });
+            checks.cloudflare = "installed but not running";
+        }
+        catch {
+            checks.cloudflare = "not installed";
+        }
+    }
+    // Crontab — brand cron entries registered by the installer
+    try {
+        const crontabOutput = execFileSync("crontab", ["-l"], {
+            encoding: "utf-8",
+            timeout: 3000,
+        });
+        const cronBeginMarker = `# BEGIN ${BRAND_NAME.toUpperCase()} CRONS`;
+        const cronEndMarker = `# END ${BRAND_NAME.toUpperCase()} CRONS`;
+        const beginIdx = crontabOutput.indexOf(cronBeginMarker);
+        const endIdx = crontabOutput.indexOf(cronEndMarker);
+        if (beginIdx === -1 || endIdx === -1) {
+            checks.crontab = `no ${BRAND_NAME} crons registered — run the installer to register them`;
+        }
+        else {
+            const block = crontabOutput.slice(beginIdx, endIdx);
+            const entries = block
+                .split("\n")
+                .filter((line) => line.trim() && !line.startsWith("#"));
+            if (entries.length === 0) {
+                checks.crontab = `${BRAND_NAME} cron block present but empty`;
+            }
+            else {
+                const names = entries.map((line) => {
+                    const commentMatch = line.match(/#\s*(.+)$/);
+                    if (commentMatch)
+                        return commentMatch[1].trim();
+                    const scriptMatch = line.match(/([^/\s]+)\.js/);
+                    if (scriptMatch)
+                        return scriptMatch[1];
+                    return line.trim().split(/\s+/).slice(-1)[0];
+                });
+                checks.crontab = `${entries.length} registered: ${names.join(", ")}`;
+            }
+        }
+    }
+    catch {
+        checks.crontab = "no crontab configured for this user";
+    }
+    // VNC display server (this brand's rfbPort)
+    checks.vnc = (await checkPort(BRAND_CONFIG.rfbPort)) ? "running" : "not running";
+    // Chrome CDP (this brand's cdpPort); personal-assistant
+    // browser tools depend on this.
+    const chromeUp = await checkPort(BRAND_CONFIG.cdpPort);
+    checks.chrome = chromeUp
+        ? "running"
+        : `not running — personal-assistant browser tools degraded (CDP port ${BRAND_CONFIG.cdpPort} not listening)`;
+    // WiFi — current connection state
+    try {
+        const wifiScan = execFileSync("nmcli", ["-t", "-f", "ACTIVE,SSID,SIGNAL", "device", "wifi", "list"], { encoding: "utf-8", timeout: 5000 });
+        const activeLine = wifiScan.split("\n").find((l) => l.startsWith("yes:"));
+        if (activeLine) {
+            const fields = activeLine.split(/(?<!\\):/).map((f) => f.replace(/\\:/g, ":"));
+            checks.wifi = `connected to ${fields[1]} (${fields[2]}%)`;
+        }
+        else {
+            checks.wifi = "not connected";
+        }
+    }
+    catch {
+        checks.wifi = "not available";
+    }
+    // Specialist agents — read AGENTS.md registry, verify files exist
+    try {
+        const accountDir = getAccountDir();
+        const agentsMdPath = join(accountDir, "agents/admin/AGENTS.md");
+        const specialistsAgentsDir = join(accountDir, "specialists/agents");
+        if (!existsSync(agentsMdPath)) {
+            checks.specialists = "not configured (AGENTS.md missing)";
+        }
+        else {
+            const content = readFileSync(agentsMdPath, "utf-8");
+            const entries = content.match(/^- \*\*specialists:([^*]+)\*\*/gm);
+            if (!entries || entries.length === 0) {
+                checks.specialists = "not configured (AGENTS.md empty)";
+            }
+            else {
+                const lines = [];
+                for (const entry of entries) {
+                    const nameMatch = entry.match(/specialists:([^*]+)/);
+                    if (!nameMatch)
+                        continue;
+                    const name = nameMatch[1];
+                    const fileExists = existsSync(join(specialistsAgentsDir, `${name}.md`));
+                    let status = fileExists ? "ok" : "missing file";
+                    if (name === "personal-assistant" && !chromeUp) {
+                        status = "degraded — chrome not running";
+                    }
+                    lines.push(`  ${name}: ${status}`);
+                }
+                checks.specialists = `${entries.length} registered\n${lines.join("\n")}`;
+            }
+        }
+    }
+    catch {
+        checks.specialists = "error reading specialist registry";
+    }
+    // OS hostname — the device's actual network name, used for URL construction
+    try {
+        checks.hostname = osHostname();
+    }
+    catch (err) {
+        console.error("[system-status] os.hostname() failed, falling back to brand.hostname", err);
+        checks.hostname = "unknown (os.hostname failed)";
+    }
+    // Task 142: `port` shown to the operator is the brand's public port
+    // (the one external clients reach via `.local`), not the internal
+    // loopback. Loud-fail if absent (Task 139 doctrine).
+    checks.port = String(requirePortEnv("MAXY_BRAND_PORT", { tag: "system-status" }));
+    console.error(`[system-status] port=${checks.port} hostname=${checks.hostname}`);
+    // Local URL — pre-computed for agent URL construction (avoids hostname/port assembly errors)
+    checks.localUrl = `http://${checks.hostname}.local:${checks.port}`;
+    // Brand identity — read build-time manifest stamped by the bundler
+    try {
+        const brandPath = resolve(PLATFORM_ROOT, "config/brand.json");
+        if (!existsSync(brandPath)) {
+            checks.brand = "not configured (dev environment)";
+        }
+        else {
+            const brand = JSON.parse(readFileSync(brandPath, "utf-8"));
+            checks.brand = `${brand.productName ?? "unknown"} (hostname: ${brand.hostname ?? "unknown"})`;
+        }
+    }
+    catch (err) {
+        checks.brand = `error reading brand config: ${err instanceof Error ? err.message : String(err)}`;
+    }
+    // configDir — the brand-specific config directory name (e.g. ".maxy", ".realagent").
+    // Resolved from brand.json at module load. Exposed here so skills can reference
+    // the actual value instead of deriving it from the brand name via LLM inference.
+    checks.configDir = BRAND_CONFIG.configDir;
+    const formatted = Object.entries(checks)
+        .map(([service, status]) => `${service}: ${status}`)
+        .join("\n");
+    return { content: [{ type: "text", text: formatted }] };
+});
+eagerTool(server, "public-hostname", "Resolve this account's canonical public hostname. Reads cloudflared ingress + alias-domains.json — the same files the platform server trusts to route. Returns a single deterministic answer; use this immediately after publish-site to construct the full URL.", {}, async () => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("public-hostname");
+    const TAG = "[admin:public-hostname]";
+    try {
+        const result = resolvePublicHostname(CONFIG_DIR);
+        if (result.hostname !== null) {
+            console.error(`${TAG} resolved accountId=${ACCOUNT_ID} hostname=${result.hostname} source=${result.source}`);
+            const body = `hostname: ${result.hostname}\n` +
+                `isApex: ${result.isApex}\n` +
+                `source: ${result.source}\n` +
+                `usage: paste \`https://${result.hostname}<path-slug>\` to the operator — the <path-slug> comes from publish-site.`;
+            return { content: [{ type: "text", text: body }] };
+        }
+        console.error(`${TAG} empty accountId=${ACCOUNT_ID} reason=${result.reason} files-checked=cloudflared-config.yml,alias-domains.json`);
+        return {
+            content: [{
+                    type: "text",
+                    text: `hostname: (none)\nreason: ${result.reason}\n` +
+                        `No Cloudflare tunnel is configured for this account. Run the cloudflare skill before publishing externally.`,
+                }],
+        };
+    }
+    catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        console.error(`${TAG} error accountId=${ACCOUNT_ID} message="${errMsg.replace(/"/g, "'")}"`);
+        return {
+            content: [{ type: "text", text: `error resolving public hostname: ${errMsg}` }],
+            isError: true,
+        };
+    }
+});
+server.tool("publish-site", "Publish an already-extracted static-site tree under <accountDir>/sites/<slug>/. Validates the slug, scans the source for symlinks, refuses on ambiguous landing pages, performs a single mv, then refreshes llms.txt + llms-full.txt at the site root via the AEO writer (best-effort — failure never unwinds the mv). Returns the canonical path slug; pair with public-hostname to build the full URL. Refusals are structured (unsafe-slug | destination-occupied | symlink-in-source | zero-html | ambiguous-html), each carrying a fixed operator message.", {
+    source: z
+        .string()
+        .min(1)
+        .describe("Absolute path to the extracted source directory (typically the output of unzip-attachment under <accountDir>/extracted/<id>/). Must be a directory tree of HTML + assets."),
+    slug: z
+        .string()
+        .min(1)
+        .describe("Operator-supplied path under <accountDir>/sites/. One or more `/`-separated segments; each segment matches /^[a-z0-9_][a-z0-9_.-]{0,99}$/i, no leading dot, no `..`."),
+    siteName: z
+        .string()
+        .optional()
+        .describe("Optional display name used in the generated llms.txt header. Defaults to the last slug segment."),
+    siteDescription: z
+        .string()
+        .optional()
+        .describe("Optional one-line description rendered as a blockquote under the llms.txt header."),
+}, async (args) => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("publish-site");
+    const accountDir = getAccountDir();
+    try {
+        const result = await publishSite({
+            accountId: ACCOUNT_ID,
+            accountDir,
+            source: args.source,
+            slug: args.slug,
+            siteName: args.siteName,
+            siteDescription: args.siteDescription,
+        }, { getSession });
+        if (!result.ok) {
+            const body = `refused: ${result.refusal}\n` +
+                `detail: ${JSON.stringify(result.detail)}\n` +
+                refusalGuidance(result.refusal);
+            return { content: [{ type: "text", text: body }] };
+        }
+        const aeoLine = result.aeo.ok
+            ? `aeo: ok wrote=${result.aeo.indexPath} indexBytes=${result.aeo.indexBytes}`
+            : `aeo: failed reason=${result.aeo.reason}`;
+        const body = `pathSlug: ${result.pathSlug}\n` +
+            `kind: ${result.kind}\n` +
+            `movedFiles: ${result.movedFiles}\n` +
+            `destination: ${result.destination}\n` +
+            `${aeoLine}\n` +
+            `usage: call public-hostname next and concatenate \`https://<hostname>${result.pathSlug}\` to surface the full URL to the operator.`;
+        return { content: [{ type: "text", text: body }] };
+    }
+    catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[publish-site] error accountId=${ACCOUNT_ID} message="${errMsg.replace(/"/g, "'")}"\n`);
+        return {
+            content: [
+                { type: "text", text: `publish-site failed: ${errMsg}` },
+            ],
+            isError: true,
+        };
+    }
+});
+eagerTool(server, "remote-auth-status", "Check whether the remote access password is configured. When not configured, emits a device-bound URL affordance (maxy-device-url fenced block) pointing at the password setup page — this URL opens on the device's own screen when the operator clicks it. The agent never constructs the password file path or runs shell commands — this tool is the single authority.", {}, async () => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("remote-auth-status");
+    const TAG = "[remote-auth-status]";
+    // Task 142: `.local` URL is a display surface — read the brand's
+    // public port. The loopback fetch reads PLATFORM_PORT (internal).
+    const brandPort = parseInt(MAXY_BRAND_PORT, 10);
+    const internalPort = parseInt(PLATFORM_PORT, 10);
+    const setupUrl = `http://${osHostname()}.local:${brandPort}/__remote-auth/setup`;
+    try {
+        const res = await fetch(`http://127.0.0.1:${internalPort}/api/remote-auth/status`, {
+            signal: AbortSignal.timeout(5000),
+        });
+        const body = await res.json();
+        const configured = body.configured === true;
+        console.error(`${TAG} configured=${configured} brandPort=${brandPort} internalPort=${internalPort}`);
+        // Shape the response for both the agent (deciding what to say) and
+        // the user (seeing the device-URL button when they need to act).
+        // Configured → plain status, no URL. Unconfigured → include the
+        // fenced block so the agent can surface the button verbatim.
+        const text = configured
+            ? `Remote access password is configured.`
+            : `Remote access password is not configured. The admin interface will refuse to expose over the tunnel until one is set.\n\n` +
+                `${deviceUrlBlock({ url: setupUrl, intent: "Set remote access password", hostname: osHostname() })}\n\n` +
+                `Ask the operator to set a password — either by clicking the button above (opens the setup page on the device) or by telling you one you can pass to \`remote-auth-set-password\`.`;
+        return {
+            content: [{ type: "text", text }],
+        };
+    }
+    catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        console.error(`${TAG} failed to check remote-auth status: ${errMsg}`);
+        return {
+            content: [{
+                    type: "text",
+                    text: `Cannot verify remote authentication — the web server at http://127.0.0.1:${internalPort} is not reachable: ${errMsg}. Ensure the ${BRAND_NAME} platform is running.`,
+                }],
+            isError: true,
+        };
+    }
+});
+eagerTool(server, "brand-settings", "Read the brand/styling configuration (name, tagline, colours, fonts, plugin sets). Reads from config/brand.json (stamped by the bundler at install time).", {}, async () => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("brand-settings");
+    try {
+        const brandPath = resolve(PLATFORM_ROOT, "config", "brand.json");
+        if (!existsSync(brandPath)) {
+            return { content: [{ type: "text", text: "No brand.json found — platform not properly installed." }], isError: true };
+        }
+        const brand = JSON.parse(readFileSync(brandPath, "utf-8"));
+        return { content: [{ type: "text", text: JSON.stringify(brand, null, 2) }] };
+    }
+    catch (err) {
+        return {
+            content: [{ type: "text", text: `Failed: ${err instanceof Error ? err.message : String(err)}` }],
+            isError: true,
+        };
+    }
+});
+eagerTool(server, "account-manage", "Read the account configuration (tier, domains, settings).", {}, async () => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("account-manage");
+    try {
+        const config = await readAccountConfig();
+        return {
+            content: [{ type: "text", text: JSON.stringify(config, null, 2) }],
+        };
+    }
+    catch (err) {
+        return {
+            content: [{ type: "text", text: `Failed: ${err instanceof Error ? err.message : String(err)}` }],
+            isError: true,
+        };
+    }
+});
+eagerTool(server, "capabilities-here", "Returns the live install set on the current account as a single JSON object: enabledPlugins (account config), tier, adminModel, publicModel, installedPlatformSpecialists (disk), installedPremiumSpecialists (disk, gated by brand.shipsPremiumBundles), registeredAgentTypes (Claude Code agent registry under $CLAUDE_CONFIG_DIR/agents/), and the brand block. Call this whenever you are about to make a claim about what this account can do, what is enabled, or what specialists are dispatchable. Do not infer install state from the platform-architecture skill — that skill is the catalogue of what the platform can ship, not what is enabled here.", {}, async () => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("capabilities-here");
+    const requestId = randomUUID();
+    const t0 = Date.now();
+    process.stderr.write(`[capabilities-here] op=invoke accountId=${ACCOUNT_ID} requestId=${requestId}\n`);
+    try {
+        const accountConfigPath = join(getAccountDir(), "account.json");
+        const brandConfigPath = resolve(PLATFORM_ROOT, "config", "brand.json");
+        const premiumPluginsRoot = resolve(PLATFORM_ROOT, "..", "premium-plugins");
+        const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
+        const result = await resolveCapabilitiesHere({
+            accountId: ACCOUNT_ID,
+            accountConfigPath,
+            brandConfigPath,
+            platformRoot: PLATFORM_ROOT,
+            premiumPluginsRoot,
+            claudeConfigDir,
+        }, new Date().toISOString());
+        const elapsed = Date.now() - t0;
+        process.stderr.write(`[capabilities-here] op=resolve requestId=${requestId} enabledPlugins=${result.enabledPlugins.length} platformSpecialists=${result.installedPlatformSpecialists.length} premiumSpecialists=${result.installedPremiumSpecialists.length} agentTypes=${result.registeredAgentTypes.length} elapsedMs=${elapsed}\n`);
+        const body = JSON.stringify(result, null, 2);
+        process.stderr.write(`[capabilities-here] op=return requestId=${requestId} bytesOut=${body.length}\n`);
+        return { content: [{ type: "text", text: body }] };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[capabilities-here] op=error requestId=${requestId} reason=${msg}\n`);
+        return {
+            content: [{ type: "text", text: `capabilities-here failed: ${msg}` }],
+            isError: true,
+        };
+    }
+});
+eagerTool(server, "account-update", "Update a user-configurable setting in account.json. Valid fields: outputStyle (default|explanatory), thinkingView (default|expanded|collapsed), effort (low|medium|high|max|auto), adminModel (any Anthropic model ID), publicModel (any Anthropic model ID), defaultAgent (slug of an existing public agent, or empty string to clear). Changes take effect on the next session.", {
+    field: z.enum(["outputStyle", "thinkingView", "effort", "adminModel", "publicModel", "defaultAgent"]),
+    value: z.string(),
+}, async ({ field, value }) => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("account-update");
+    const VALID = {
+        outputStyle: ["default", "explanatory"],
+        thinkingView: ["default", "expanded", "collapsed"],
+        effort: ["low", "medium", "high", "max", "auto"],
+    };
+    // defaultAgent: non-empty slug must reference an existing agent; empty string clears the field
+    if (field === "defaultAgent") {
+        const slug = value.trim();
+        if (slug) {
+            const agentConfigPath = join(getAccountDir(), "agents", slug, "config.json");
+            if (!existsSync(agentConfigPath)) {
+                return {
+                    content: [{ type: "text", text: `Agent '${slug}' not found — no config.json in agents/${slug}/` }],
+                    isError: true,
+                };
+            }
+        }
+        // empty slug is valid — handled below as a delete operation
+    }
+    // Model fields accept any non-empty string (model IDs change frequently)
+    const FREE_FORM_FIELDS = ["adminModel", "publicModel"];
+    if (FREE_FORM_FIELDS.includes(field)) {
+        if (!value.trim()) {
+            return {
+                content: [{ type: "text", text: `Invalid value for ${field}. Must be a non-empty model ID.` }],
+                isError: true,
+            };
+        }
+    }
+    else if (field !== "defaultAgent" && !VALID[field].includes(value)) {
+        console.error(`[admin:account-update] rejected field=${field} value="${value}" valid=[${VALID[field].join(", ")}]`);
+        return {
+            content: [{ type: "text", text: `Invalid value "${value}" for ${field}. Valid values: ${VALID[field].join(", ")}` }],
+            isError: true,
+        };
+    }
+    try {
+        const configPath = join(getAccountDir(), "account.json");
+        const config = await readAccountConfig();
+        const oldDefault = field === "defaultAgent" ? config.defaultAgent ?? "(none)" : undefined;
+        if (field === "defaultAgent" && !value.trim()) {
+            delete config.defaultAgent;
+        }
+        else {
+            config[field] = value;
+        }
+        await writeFile(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+        console.error(`[admin:account-update] wrote field=${field} value="${value}" path=${configPath}`);
+        if (field === "defaultAgent") {
+            if (!value.trim()) {
+                return {
+                    content: [{ type: "text", text: `Default agent cleared (was "${oldDefault}"). Visitors to the root URL will see the first available agent, or a "no agents" message if none exist. Takes effect on next page load.` }],
+                };
+            }
+            return {
+                content: [{ type: "text", text: `Default agent changed from "${oldDefault}" to "${value}". Takes effect on next page load.` }],
+            };
+        }
+        return {
+            content: [{ type: "text", text: `Updated ${field} to "${value}". Takes effect on next session.` }],
+        };
+    }
+    catch (err) {
+        return {
+            content: [{ type: "text", text: `Failed: ${err instanceof Error ? err.message : String(err)}` }],
+            isError: true,
+        };
+    }
+});
+// Plugin enable/disable: deterministic write to account.json.enabledPlugins.
+// IDENTITY.md doctrine forbids the agent's direct Edit on account.json,
+// so the agent must not toggle enablement by hand-editing the file. This
+// tool is the legitimate path: validates the plugin name, refuses core plugins,
+// confirms the plugin directory exists, and atomically updates the array.
+// Entitlement-bearing fields (tier, purchasedPlugins) are NOT writable here.
+server.tool("plugin-toggle-enabled", "Enable or disable a plugin in this account by adding/removing its name from account.json's enabledPlugins array. Validates the plugin exists under platform/plugins/, refuses to disable core plugins (admin, memory, docs, cloudflare), and writes atomically. Takes effect on next session start. Does NOT change purchasedPlugins or tier — those derive from the signed entitlement payload.", {
+    pluginName: z.string().describe("Plugin slug (lowercase a-z0-9-)."),
+    action: z.enum(["enable", "disable"]).describe("enable adds to enabledPlugins; disable removes."),
+}, async ({ pluginName, action }) => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("plugin-toggle-enabled");
+    const TAG = "[admin:plugin-toggle-enabled]";
+    if (!VALID_PLUGIN_NAME.test(pluginName)) {
+        return { content: [{ type: "text", text: `${TAG} Invalid plugin name "${pluginName}". Must match ${VALID_PLUGIN_NAME}.` }], isError: true };
+    }
+    if (CORE_PLUGINS.includes(pluginName)) {
+        return { content: [{ type: "text", text: `${TAG} "${pluginName}" is a core plugin and cannot be toggled.` }], isError: true };
+    }
+    const pluginDir = resolve(PLUGINS_DIR, pluginName);
+    if (!existsSync(pluginDir) || !existsSync(join(pluginDir, "PLUGIN.md"))) {
+        return { content: [{ type: "text", text: `${TAG} Plugin "${pluginName}" not installed at ${pluginDir} (no PLUGIN.md). Install via premium-deliver or platform release.` }], isError: true };
+    }
+    try {
+        const configPath = join(getAccountDir(), "account.json");
+        const config = await readAccountConfig();
+        const current = Array.isArray(config.enabledPlugins) ? config.enabledPlugins : [];
+        let next;
+        if (action === "enable") {
+            if (current.includes(pluginName)) {
+                return { content: [{ type: "text", text: `${TAG} "${pluginName}" is already enabled.` }] };
+            }
+            next = [...current, pluginName];
+        }
+        else {
+            if (!current.includes(pluginName)) {
+                return { content: [{ type: "text", text: `${TAG} "${pluginName}" is not enabled — nothing to disable.` }] };
+            }
+            next = current.filter((n) => n !== pluginName);
+        }
+        config.enabledPlugins = next;
+        await writeFile(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+        console.error(`${TAG} ${action}d plugin=${pluginName} path=${configPath}`);
+        return { content: [{ type: "text", text: `Plugin "${pluginName}" ${action}d. Takes effect on next session.` }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `${TAG} Failed: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+    }
+});
+// ===================================================================
+// Admin user management tools
+// ===================================================================
+eagerTool(server, "admin-add", "Add a new admin user to this account. Creates a device-level user entry (users.json) and adds them to this account's admins list (account.json). PIN must be at least 4 digits. If no PIN is provided, a unique 4-digit PIN is generated. Returns the userId and PIN to share with the new admin.\n\nIMPORTANT — retry behaviour: if the user already stated a specific PIN earlier in the conversation and a first admin-add call failed (e.g. tier cap reached, PIN collision), every retry MUST re-pass that PIN as the `pin` parameter. Omitting `pin` on the retry auto-generates a different 4-digit PIN, silently substituting what the user asked for.", {
+    name: z.string().describe("Display name for the new admin (stored on the AdminUser node in Neo4j)."),
+    pin: z.string().optional().describe("Optional PIN (minimum 4 digits). If omitted, a unique 4-digit PIN is generated."),
+}, async ({ name, pin: rawPin }) => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("admin-add");
+    const TAG = "[admin]";
+    if (!name.trim()) {
+        return { content: [{ type: "text", text: `${TAG} Name is required.` }], isError: true };
+    }
+    let users;
+    try {
+        users = readUsersJson();
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `${TAG} ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+    }
+    // Enforce per-tier admin limit. Effective tier comes from the signed
+    // entitlement payload — editing account.json.tier directly
+    // has no effect; the verifier uses the signed value and emits a
+    // [entitlement] tampered: line if disk and signed diverge.
+    try {
+        const config = await readAccountConfig();
+        const currentAdmins = (config.admins ?? []);
+        const entitlement = await currentEntitlement();
+        const tier = entitlement.tier;
+        const maxAdmins = MAX_ADMINS_BY_TIER[tier] ?? MAX_ADMINS_DEFAULT;
+        if (currentAdmins.length >= maxAdmins) {
+            return { content: [{ type: "text", text: `${TAG} Admin limit reached (${maxAdmins} for ${tier || "this"} tier). Remove an existing admin before adding a new one.` }], isError: true };
+        }
+    }
+    catch (err) {
+        console.error(`${TAG} failed to check admin limit: ${err instanceof Error ? err.message : String(err)}`);
+        // Fail open would be unsafe — fail closed
+        return { content: [{ type: "text", text: `${TAG} Unable to verify admin limit — cannot add admin.` }], isError: true };
+    }
+    // Resolve the calling user's identity from the session environment
+    const callerUserId = process.env.USER_ID;
+    // PIN: use provided or generate. Constraint: minimum 4 digits, no upper bound.
+    let plaintextPin;
+    if (rawPin) {
+        if (rawPin.length < 4) {
+            return { content: [{ type: "text", text: `${TAG} PIN must be at least 4 digits.` }], isError: true };
+        }
+        const hashed = hashPin(rawPin);
+        if (users.some(u => u.pin === hashed)) {
+            return { content: [{ type: "text", text: `${TAG} That PIN is already in use. Choose a different PIN.` }], isError: true };
+        }
+        plaintextPin = rawPin;
+    }
+    else {
+        try {
+            plaintextPin = generateUniquePin(users);
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `${TAG} ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+        }
+    }
+    const pinHash = hashPin(plaintextPin);
+    const userId = crypto.randomUUID();
+    // Three-store admin auth invariant: users.json
+    // (device-level PIN auth) and account.json admins[] (account-level role)
+    // route through the shared `admins-write` helper so the dual write has a
+    // single chokepoint. Per-leg `[admins-write]` and legacy `[admin-auth-store]`
+    // log lines fire so existing dashboards continue to grep. Neo4j AdminUser
+    // (display + graph identity) writes below remain inline because they have
+    // no dual-file invariant.
+    const userIdShort = userId.slice(0, 8);
+    const authResult = writeAdminEntry({
+        userId,
+        pin: pinHash,
+        role: "admin",
+        usersFile: USERS_FILE,
+        accountDir: getAccountDir(),
+        caller: "admin-add",
+    });
+    console.error(`[admin-auth-store] action=add userId=${userIdShort} result=${authResult.usersJsonResult} store=users${authResult.usersError ? ` error=${authResult.usersError}` : ""}`);
+    if (authResult.usersJsonResult !== "ok") {
+        return { content: [{ type: "text", text: `${TAG} Failed to write users.json: ${authResult.usersError ?? "unknown error"}` }], isError: true };
+    }
+    console.error(`[admin-auth-store] action=add userId=${userIdShort} result=${authResult.accountJsonResult} store=account${authResult.accountError ? ` error=${authResult.accountError}` : ""}`);
+    if (authResult.accountJsonResult === "fail") {
+        return { content: [{ type: "text", text: `${TAG} users.json updated; account.json write FAILED — manual reconciliation needed: ${authResult.accountError ?? "unknown error"}` }], isError: true };
+    }
+    // 3. Write to Neo4j (graph-level): AdminUser + Person + OWNS atomically,
+    //    plus ADMIN_OF edge to the LocalBusiness for this account.
+    //    deterministic identity creation: never delegate node
+    //    creation to the LLM. Person reuse rule mirrors writeAdminUserAndPerson
+    //    in platform/ui/app/lib/neo4j-store.ts (case-insensitive exact match
+    //    on givenName + familyName; partial-name ambiguity does NOT match —
+    //    rationalisation is a separate agent-mediated concern).
+    //    Neo4j-leg failure now returns is_error: true with the
+    //    [admin-auth-store] line; previously it set a soft warning string and
+    //    returned success, which is what hid the Adam Mackay incident from
+    //    the recovery agent. The user is still functional via users.json +
+    //    account.json, but the graph state is divergent and the operator
+    //    must know.
+    let personReused = false;
+    try {
+        const session = getSession();
+        try {
+            const createdAt = new Date().toISOString();
+            const trimmedName = name.trim();
+            const firstSpace = trimmedName.search(/\s/);
+            const givenName = firstSpace === -1 ? trimmedName : trimmedName.slice(0, firstSpace).trim();
+            const familyName = firstSpace === -1 ? null : (trimmedName.slice(firstSpace + 1).trim() || null);
+            // Task 636 — :Person is vector-indexed; embed the admin-personal Person
+            // at write time so it is findable by semantic memory-search, not only
+            // after a reindex. A failed embed sets null (audit catches it) and the
+            // write proceeds — embedding must never block PIN setup.
+            let personEmbedding = null;
+            try {
+                personEmbedding = await embed(`[Person] ${[givenName, familyName].filter(Boolean).join(" ")} role: admin-personal`);
+            }
+            catch (err) {
+                process.stderr.write(`[graph-write] warn reason=embed-failed labels=Person agent=admin-add detail=${err instanceof Error ? err.message : String(err)}\n`);
+            }
+            // stamp `accountId` on every AdminUser at MERGE time, both
+            // ON CREATE and ON MATCH (the latter via COALESCE so a pre-existing
+            // value isn't overwritten if it differs — which would itself be a
+            // graph-invariant violation worth surfacing). Pre-897 the missing
+            // accountId fingerprint produced :AdminUser nodes that migration 004
+            // pruned silently, costing the admin pin during onboarding.
+            const result = await session.run(`MERGE (au:AdminUser {userId: $userId})
+           ON CREATE SET au.accountId = $accountId,
+                         au.name = $name,
+                         au.createdAt = $createdAt
+           ON MATCH SET au.accountId = COALESCE(au.accountId, $accountId),
+                        au.name = $name,
+                        au.updatedAt = $createdAt
+           WITH au
+           MATCH (b:LocalBusiness {accountId: $accountId})
+           MERGE (au)-[r:ADMIN_OF]->(b)
+           ON CREATE SET r.role = 'admin', r.grantedAt = $createdAt
+           WITH au
+           OPTIONAL MATCH (existingPerson:Person {accountId: $accountId})
+           WHERE toLower(existingPerson.givenName) = toLower($givenName)
+             AND coalesce(toLower(existingPerson.familyName), '') = coalesce(toLower($familyName), '')
+           WITH au, existingPerson
+           CALL {
+             WITH au, existingPerson
+             WITH au, existingPerson WHERE existingPerson IS NOT NULL
+             MERGE (au)-[:OWNS]->(existingPerson)
+             RETURN true AS reused
+             UNION
+             WITH au, existingPerson
+             WITH au WHERE existingPerson IS NULL
+             CREATE (newPerson:Person {
+               accountId: $accountId,
+               givenName: $givenName,
+               familyName: $familyName,
+               role: 'admin-personal',
+               scope: 'admin',
+               embedding: $personEmbedding,
+               createdAt: $createdAt
+             })
+             MERGE (au)-[:OWNS]->(newPerson)
+             RETURN false AS reused
+           }
+           RETURN reused`, { userId, name: trimmedName, createdAt, accountId: ACCOUNT_ID, givenName, familyName, personEmbedding });
+            if (result.records.length > 0) {
+                personReused = result.records[0].get("reused");
+            }
+            // post-write assertion mirroring the one in neo4j-store.ts.
+            // MATCH back the AdminUser we just wrote and verify every required
+            // field landed. Loud-fail the tool call if accountId or name is null
+            // so a Cypher regression that drops the field is grep-detectable.
+            const verify = await session.run(`MATCH (au:AdminUser {userId: $userId})
+           RETURN coalesce(au.accountId, '') AS accountId,
+                  coalesce(au.name, '')      AS name`, { userId });
+            const verifiedAccountId = verify.records[0]?.get("accountId") || "";
+            const verifiedName = verify.records[0]?.get("name") || "";
+            if (!verifiedAccountId || !verifiedName) {
+                throw new Error(`post-write assertion failed: AdminUser userId=${userIdShort} accountId=${verifiedAccountId || "(null)"} name=${verifiedName || "(null)"} — required fields missing after MERGE`);
+            }
+        }
+        finally {
+            await session.close();
+        }
+        console.error(`[admin] admin-add success userId=${userIdShort} accountId=${ACCOUNT_ID} name=${name.trim()} required-fields=ok personReused=${personReused}`);
+    }
+    catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        console.error(`[admin-auth-store] action=add userId=${userIdShort} result=fail store=neo4j error=${errMsg}`);
+        return {
+            content: [{
+                    type: "text",
+                    text: `${TAG} users.json + account.json updated for userId ${userId} (PIN: ${plaintextPin}); Neo4j sync FAILED — manual reconciliation needed: ${errMsg}`,
+                }],
+            isError: true,
+        };
+    }
+    console.error(`${TAG} [admin-identity] adminuser-bound userId=${userIdShort} name=${name.trim()} personReused=${personReused}`);
+    console.error(`${TAG} admin added: userId=${userId} userName=${name.trim()} accountId=${ACCOUNT_ID} role=admin addedBy=${callerUserId ?? "unknown"}`);
+    return {
+        content: [{
+                type: "text",
+                text: `Admin added successfully.\n\n- **Name:** ${name.trim()}\n- **userId:** ${userId}\n- **PIN:** ${plaintextPin}\n- **Role:** admin\n\nShare the PIN with ${name.trim()} so they can log in.`,
+            }],
+    };
+});
+eagerTool(server, "admin-remove", "Remove an admin from this account. Removes them from the account's admins list (account.json) and deletes the ADMIN_OF relationship in Neo4j. Does NOT remove the device-level user entry (they may admin other accounts). Cannot remove the last admin on the account.", {
+    userId: z.string().describe("The userId of the admin to remove (use admin-list to find userIds)"),
+}, async ({ userId }) => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("admin-remove");
+    const TAG = "[admin]";
+    const callerUserId = process.env.USER_ID;
+    // Read account.json and validate
+    let config;
+    let admins;
+    try {
+        config = await readAccountConfig();
+        admins = (config.admins ?? []);
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `${TAG} Failed to read account config: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+    }
+    const targetIndex = admins.findIndex(a => a.userId === userId);
+    if (targetIndex === -1) {
+        return { content: [{ type: "text", text: `${TAG} User ${userId} is not an admin of this account.` }], isError: true };
+    }
+    if (admins.length <= 1) {
+        return { content: [{ type: "text", text: `${TAG} Cannot remove the last admin. At least one admin must remain on the account.` }], isError: true };
+    }
+    // Resolve the admin's name from Neo4j (canonical) for the confirmation
+    // message. Best-effort — fall back to userId if the graph is unreachable.
+    let removedName = userId;
+    try {
+        const session = getSession();
+        try {
+            const result = await session.run(`MATCH (au:AdminUser {userId: $userId}) RETURN au.name AS name LIMIT 1`, { userId });
+            if (result.records.length > 0) {
+                const name = result.records[0].get("name");
+                if (name && name.trim())
+                    removedName = name.trim();
+            }
+        }
+        finally {
+            await session.close();
+        }
+    }
+    catch { /* name lookup is best-effort */ }
+    // 1. Remove from account.json — single-file write through the shared
+    // chokepoint helper. users.json is intentionally untouched (the user may
+    // admin other accounts on this device); the helper logs `usersJsonResult=skip`.
+    const removeResult = removeAdminFromAccount({
+        userId,
+        accountDir: getAccountDir(),
+        caller: "admin-remove",
+    });
+    if (removeResult.accountJsonResult === "fail") {
+        return { content: [{ type: "text", text: `${TAG} Failed to write account.json: ${removeResult.accountError ?? "unknown error"}` }], isError: true };
+    }
+    // 2. Delete ADMIN_OF relationship in Neo4j — partial failure is a warning
+    let neo4jWarning = "";
+    try {
+        const session = getSession();
+        try {
+            await session.run(`MATCH (au:AdminUser {userId: $userId})-[r:ADMIN_OF]->(b:LocalBusiness {accountId: $accountId})
+           DELETE r`, { userId, accountId: ACCOUNT_ID });
+        }
+        finally {
+            await session.close();
+        }
+    }
+    catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        console.error(`${TAG} Neo4j sync failed during admin-remove: userId=${userId} error=${errMsg}`);
+        neo4jWarning = ` Note: Neo4j relationship deletion failed (${errMsg}) — will be reconciled on next seed.`;
+    }
+    console.error(`${TAG} admin removed: userId=${userId} accountId=${ACCOUNT_ID} removedBy=${callerUserId ?? "unknown"}`);
+    return {
+        content: [{
+                type: "text",
+                text: `Removed ${removedName} from this account's admin list. Their PIN still works for any other accounts they administer.${neo4jWarning}`,
+            }],
+    };
+});
+eagerTool(server, "admin-list", "List all admins for this account with their names and roles.", {}, async () => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("admin-list");
+    const TAG = "[admin]";
+    let admins;
+    try {
+        const config = await readAccountConfig();
+        admins = (config.admins ?? []);
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `${TAG} Failed to read account config: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+    }
+    if (admins.length === 0) {
+        return { content: [{ type: "text", text: `${TAG} No admins configured for this account.` }] };
+    }
+    // Enrich with names from Neo4j AdminUser (canonical). Best
+    // effort — render "(unknown)" for any userId without a graph entry.
+    const userMap = new Map();
+    try {
+        const session = getSession();
+        try {
+            const result = await session.run(`UNWIND $userIds AS uid
+           MATCH (au:AdminUser {userId: uid})
+           RETURN au.userId AS userId, au.name AS name`, { userIds: admins.map(a => a.userId) });
+            for (const record of result.records) {
+                const uid = record.get("userId");
+                const name = record.get("name");
+                if (name && name.trim())
+                    userMap.set(uid, name.trim());
+            }
+        }
+        finally {
+            await session.close();
+        }
+    }
+    catch { /* name lookup is best-effort — userIds shown when graph is unreachable */ }
+    const lines = admins.map(a => {
+        const name = userMap.get(a.userId) ?? "(unknown)";
+        return `- **${name}** — role: ${a.role}, userId: ${a.userId}`;
+    });
+    return {
+        content: [{ type: "text", text: `Admins for this account:\n\n${lines.join("\n")}` }],
+    };
+});
+eagerTool(server, "admin-update-pin", "Update an existing admin user's PIN. Defaults to the calling admin if no userId is given. PIN must be at least 4 digits and unique across all users on the device. PINs are device-level: updating another admin's PIN does not require shared account membership — any admin on the device can rotate any other admin's PIN, matching the existing trust model used by admin-remove.", {
+    userId: z.string().optional().describe("The userId of the admin whose PIN to update. Defaults to the caller (the admin invoking this tool)."),
+    newPin: z.string().describe("The new PIN. Minimum 4 digits, no upper bound."),
+}, async ({ userId: targetUserId, newPin }) => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("admin-update-pin");
+    const TAG = "[admin-update-pin]";
+    const callerUserId = process.env.USER_ID;
+    const userId = targetUserId ?? callerUserId;
+    const userIdLabel = userId ? userId.slice(0, 8) : "unknown";
+    if (!userId) {
+        console.error(`${TAG} userId=${userIdLabel} result=user-not-found reason=no-caller-context`);
+        return { content: [{ type: "text", text: `${TAG} No userId supplied and no caller context — cannot update.` }], isError: true };
+    }
+    if (newPin.length < 4) {
+        console.error(`${TAG} userId=${userIdLabel} result=too-short`);
+        return { content: [{ type: "text", text: `${TAG} PIN must be at least 4 digits.` }], isError: true };
+    }
+    let users;
+    try {
+        users = readUsersJson();
+    }
+    catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        console.error(`${TAG} userId=${userIdLabel} result=user-not-found reason=users-json-read-failed`);
+        console.error(`[admin-auth-store] action=update-pin userId=${userIdLabel} result=fail store=users error=${errMsg}`);
+        return { content: [{ type: "text", text: `${TAG} ${errMsg}` }], isError: true };
+    }
+    const targetIndex = users.findIndex(u => u.userId === userId);
+    if (targetIndex === -1) {
+        console.error(`${TAG} userId=${userIdLabel} result=user-not-found`);
+        console.error(`[admin-auth-store] action=update-pin userId=${userIdLabel} result=fail store=users error=user-not-found`);
+        return { content: [{ type: "text", text: `${TAG} User ${userId} not found in users.json.` }], isError: true };
+    }
+    const newHash = hashPin(newPin);
+    const collidesWithOther = users.some((u, i) => i !== targetIndex && u.pin === newHash);
+    if (collidesWithOther) {
+        console.error(`${TAG} userId=${userIdLabel} result=collision`);
+        console.error(`[admin-auth-store] action=update-pin userId=${userIdLabel} result=fail store=users error=pin-collision`);
+        return { content: [{ type: "text", text: `${TAG} That PIN is already in use by another user. Choose a different PIN.` }], isError: true };
+    }
+    users[targetIndex].pin = newHash;
+    try {
+        writeUsersJson(users);
+    }
+    catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        console.error(`[admin-auth-store] action=update-pin userId=${userIdLabel} result=fail store=users error=${errMsg}`);
+        return { content: [{ type: "text", text: `${TAG} Failed to write users.json: ${errMsg}` }], isError: true };
+    }
+    console.error(`${TAG} userId=${userIdLabel} result=ok`);
+    console.error(`[admin-auth-store] action=update-pin userId=${userIdLabel} result=ok store=users`);
+    const self = userId === callerUserId;
+    return {
+        content: [{ type: "text", text: `PIN updated${self ? "" : ` for userId ${userId}`}. The new PIN takes effect on the next login.` }],
+    };
+});
+server.tool("agent-image", "Upload, update, or remove an agent's image. action=set: copy the file at filePath to the agent's assets directory and update config.json with image URL and shape. action=remove: delete the image file and clear the image fields from config.json. imageShape: 'circle' for avatars/icons, 'rounded' for logos.", {
+    agentSlug: z.string().describe("Agent slug (e.g. 'coaching', 'sales')"),
+    action: z.enum(["set", "remove"]),
+    filePath: z.string().optional().describe("Absolute path to the image file (required for action=set)"),
+    imageShape: z.enum(["circle", "rounded"]).optional().describe("Image shape: circle for avatars, rounded for logos (required for action=set)"),
+}, async ({ agentSlug, action, filePath, imageShape }) => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("agent-image");
+    const VALID_IMAGE_EXTENSIONS = [".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg"];
+    try {
+        const accountDir = getAccountDir();
+        const agentDir = resolve(accountDir, "agents", agentSlug);
+        const configPath = resolve(agentDir, "config.json");
+        if (!existsSync(configPath)) {
+            return {
+                content: [{ type: "text", text: `Agent '${agentSlug}' not found — no config.json at agents/${agentSlug}/` }],
+                isError: true,
+            };
+        }
+        if (action === "set") {
+            if (!filePath) {
+                return {
+                    content: [{ type: "text", text: "filePath is required for action=set" }],
+                    isError: true,
+                };
+            }
+            if (!imageShape) {
+                return {
+                    content: [{ type: "text", text: "imageShape is required for action=set — use 'circle' for avatars/icons or 'rounded' for logos" }],
+                    isError: true,
+                };
+            }
+            if (!existsSync(filePath)) {
+                return {
+                    content: [{ type: "text", text: `File not found: ${filePath}` }],
+                    isError: true,
+                };
+            }
+            // Validate image extension
+            const ext = filePath.toLowerCase().split(".").pop();
+            if (!ext || !VALID_IMAGE_EXTENSIONS.includes(`.${ext}`)) {
+                return {
+                    content: [{ type: "text", text: `Not a valid image file. Supported formats: ${VALID_IMAGE_EXTENSIONS.join(", ")}` }],
+                    isError: true,
+                };
+            }
+            // Copy file to agent assets directory
+            const assetsDir = resolve(agentDir, "assets");
+            const { mkdirSync: mkdirSyncFs, copyFileSync, writeFileSync: writeFileSyncFs, renameSync } = await import("node:fs");
+            mkdirSyncFs(assetsDir, { recursive: true });
+            const filename = `agent-image.${ext}`;
+            const destPath = resolve(assetsDir, filename);
+            copyFileSync(filePath, destPath);
+            // Atomic config update: read → modify → write temp → rename
+            const configRaw = await readFile(configPath, "utf-8");
+            let config;
+            try {
+                config = JSON.parse(configRaw);
+            }
+            catch {
+                config = {};
+            }
+            config.image = `/agent-assets/${agentSlug}/${filename}`;
+            config.imageShape = imageShape;
+            const tmpPath = configPath + ".tmp";
+            writeFileSyncFs(tmpPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+            renameSync(tmpPath, configPath);
+            console.error(`[agent-config] ${agentSlug}: image=${config.image} imageShape=${imageShape} (set)`);
+            return {
+                content: [{ type: "text", text: `Image set for agent '${agentSlug}':\n  File: ${destPath}\n  URL: ${config.image}\n  Shape: ${imageShape}\n\nThe image is now accessible at ${config.image} and will appear in the public chat header.` }],
+            };
+        }
+        // action === "remove"
+        const configRaw = await readFile(configPath, "utf-8");
+        let config;
+        try {
+            config = JSON.parse(configRaw);
+        }
+        catch {
+            config = {};
+        }
+        // Delete the image file if it exists
+        if (typeof config.image === "string") {
+            const filename = config.image.split("/").pop();
+            if (filename) {
+                const imgPath = resolve(agentDir, "assets", filename);
+                if (existsSync(imgPath)) {
+                    const { unlinkSync } = await import("node:fs");
+                    unlinkSync(imgPath);
+                }
+            }
+        }
+        // Remove image fields from config
+        delete config.image;
+        delete config.imageShape;
+        const { writeFileSync: writeFileSyncRm, renameSync: renameSyncRm } = await import("node:fs");
+        const tmpPath = configPath + ".tmp";
+        writeFileSyncRm(tmpPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+        renameSyncRm(tmpPath, configPath);
+        console.error(`[agent-config] ${agentSlug}: image removed`);
+        return {
+            content: [{ type: "text", text: `Image removed for agent '${agentSlug}'. The public chat header will fall back to the account brand logo.` }],
+        };
+    }
+    catch (err) {
+        console.error(`[agent-config] agent-image failed: ${err instanceof Error ? err.message : String(err)}`);
+        return {
+            content: [{ type: "text", text: `Failed: ${err instanceof Error ? err.message : String(err)}` }],
+            isError: true,
+        };
+    }
+});
+// ---------------------------------------------------------------------------
+// Agent config tools — deterministic reads for agent configuration
+// ---------------------------------------------------------------------------
+server.tool("agent-config-read", "Read the full config.json for a specific public agent by slug. Returns the complete configuration including slug, displayName, model, plugins, status, and any other fields.", {
+    slug: z.string().describe("Agent slug (directory name under agents/)"),
+}, async ({ slug }) => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("agent-config-read");
+    const TAG = "[admin:agent-config-read]";
+    // Path traversal guard
+    if (slug.includes("/") || slug.includes("\\") || slug.includes("..")) {
+        console.error(`${TAG} rejected slug="${slug}" — contains path separator or traversal sequence`);
+        return {
+            content: [{ type: "text", text: `Invalid agent slug: "${slug}" — slug must not contain path separators or traversal sequences` }],
+            isError: true,
+        };
+    }
+    try {
+        const accountDir = getAccountDir();
+        const configPath = resolve(accountDir, "agents", slug, "config.json");
+        if (!existsSync(configPath)) {
+            console.error(`${TAG} agent not found: slug="${slug}"`);
+            return {
+                content: [{ type: "text", text: `Agent "${slug}" not found — no config.json at agents/${slug}/` }],
+                isError: true,
+            };
+        }
+        const raw = readFileSync(configPath, "utf-8");
+        JSON.parse(raw); // validate JSON before returning
+        return {
+            content: [{ type: "text", text: raw }],
+        };
+    }
+    catch (err) {
+        console.error(`${TAG} failed for slug="${slug}": ${err instanceof Error ? err.message : String(err)}`);
+        return {
+            content: [{ type: "text", text: `Failed to read config for agent "${slug}": ${err instanceof Error ? err.message : String(err)}` }],
+            isError: true,
+        };
+    }
+});
+server.tool("agent-list", "List all public (non-admin) agents with their full configuration: slug, displayName, model, plugins, status, and whether each is the account's default agent.", {}, async () => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("agent-list");
+    const TAG = "[admin:agent-list]";
+    try {
+        const accountDir = getAccountDir();
+        const agentsDir = resolve(accountDir, "agents");
+        if (!existsSync(agentsDir)) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ agents: [], skipped: [] }, null, 2) }],
+            };
+        }
+        // Best-effort defaultAgent lookup — don't fail the whole list if account.json is unreadable
+        let defaultAgent;
+        try {
+            const accountConfig = await readAccountConfig();
+            defaultAgent = accountConfig.defaultAgent;
+        }
+        catch (err) {
+            console.error(`${TAG} failed to read account config for defaultAgent lookup: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        const agents = [];
+        const skipped = [];
+        const entries = readdirSync(agentsDir, { withFileTypes: true });
+        for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+            if (!entry.isDirectory())
+                continue;
+            if (entry.name === "admin")
+                continue;
+            const configPath = resolve(agentsDir, entry.name, "config.json");
+            if (!existsSync(configPath))
+                continue;
+            try {
+                const config = JSON.parse(readFileSync(configPath, "utf-8"));
+                agents.push({
+                    slug: entry.name,
+                    displayName: config.displayName ?? entry.name,
+                    model: config.model,
+                    plugins: config.plugins,
+                    status: config.status,
+                    isDefault: entry.name === defaultAgent,
+                });
+            }
+            catch (err) {
+                console.error(`${TAG} failed to parse config.json for agent "${entry.name}" — skipping: ${err instanceof Error ? err.message : String(err)}`);
+                skipped.push(entry.name);
+            }
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify({ agents, skipped }, null, 2) }],
+        };
+    }
+    catch (err) {
+        console.error(`${TAG} failed: ${err instanceof Error ? err.message : String(err)}`);
+        return {
+            content: [{ type: "text", text: `Failed to list agents: ${err instanceof Error ? err.message : String(err)}` }],
+            isError: true,
+        };
+    }
+});
+eagerTool(server, "logs-read", "Read recent logs. Stream logs (type=agent-stream/error/session/public) are per-session — pass `sessionKey` (preferred) or the legacy `sessionId` alias to retrieve a single session's log from first [spawn] to final [process-exit]. type=agent-stream: per-session tool-use/tool-result archive (every `[tool-use]` and `[tool-result]` pair with full input + output JSON, plus raw Claude stream-json, agent events, and MCP server stderr via tee). USE THIS when investigating what an agent ACTUALLY did with its tools — server.log only carries `[persist] tool-call persisted` markers, not bodies. (`type=system` is a backwards-compatible alias for the same archive.) type=session: SSE events sent to client. type=error: Claude subprocess stderr (raw — NODE_DEBUG HTTP/NET/UNDICI traces land in agent-stream via the stream tee, not here). type=heartbeat: platform event dispatcher (check-due-events cron). type=public: public agent diagnostic log. type=server: platform server log. type=mcp: MCP server stderr (per-plugin raw). type=vnc: VNC browser viewer lifecycle.", {
+    type: z.enum(["agent-stream", "system", "session", "error", "heartbeat", "public", "server", "mcp", "vnc"]).optional(),
+    lines: z.number().optional(),
+    sessionKey: z.string().optional(),
+    sessionId: z.string().optional(),
+}, async ({ type, lines = 50, sessionKey, sessionId }) => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("logs-read");
+    try {
+        // Account-scoped per-session log dir. `<installDir>/data/accounts/
+        // <accountId>/logs/` mirrors the resolution in
+        // `platform/scripts/logs-read.sh`. This dir may not exist on a Pi
+        // where no claude session has yet tee'd stream output — that is NOT
+        // a fatal condition for platform-scoped types like `server` / `vnc`,
+        // which resolve against CONFIG_DIR below. Task 579 — the previous
+        // early-existence check returned "Log directory does not exist" for
+        // every type, including those whose actual target file lived
+        // elsewhere. Each branch now checks its own resolved path.
+        const LOG_DIR = resolve(getAccountDir(), "logs");
+        // sessionKey is the single identifier on disk.
+        // `sessionId` is retained as a legacy alias that maps to the
+        // sessionKey-named file will collapse the alias in the UI.
+        const idForResolve = sessionKey ?? sessionId;
+        if (idForResolve) {
+            if (!existsSync(LOG_DIR)) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `No per-session logs for this account yet (resolved dir does not exist on disk): ${LOG_DIR}. The directory is created on first claude session spawn.`,
+                        }],
+                };
+            }
+            const prefixMap = {
+                "agent-stream": "claude-agent-stream",
+                system: "claude-agent-stream", // backwards-compatible alias for agent-stream
+                error: "claude-agent-stderr",
+                session: "sse-events",
+                public: "public-agent-stream",
+            };
+            const resolvedType = type ?? "agent-stream";
+            const prefix = prefixMap[resolvedType];
+            if (!prefix) {
+                return {
+                    content: [{ type: "text", text: `type=${resolvedType} is not per-session. Valid per-session types: agent-stream, error, session, public. For platform-scoped types (server, vnc, heartbeat, mcp) omit the id.` }],
+                    isError: true,
+                };
+            }
+            const fileName = `${prefix}-${idForResolve}.log`;
+            const filePath = resolve(LOG_DIR, fileName);
+            if (existsSync(filePath)) {
+                const result = execFileSync("tail", ["-n", String(lines), filePath], { timeout: 5000 }).toString();
+                return { content: [{ type: "text", text: `# ${fileName}\n\n${result}` }] };
+            }
+            // Emit missing-on-resolve so the writer-side existence contract is
+            // the authoritative signal. One such line on any device is a P0.
+            try {
+                const ts = new Date().toISOString();
+                appendFileSync(resolve(CONFIG_DIR, "logs", "server.log"), `${ts} [log-tee] missing-on-resolve sessionKey=${idForResolve.slice(0, 8)} surface=mcp-logs-read reason="file-not-found-in-LOG_DIR"\n`);
+            }
+            catch {
+                // best-effort
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: `No log file found for id=${idForResolve} type=${resolvedType}. tried=[${filePath}] reason=file-not-found`,
+                    }],
+            };
+        }
+        // Note: no early existence check on LOG_DIR here. Platform-scoped
+        // types (server, vnc, heartbeat) resolve against CONFIG_DIR below
+        // and must run even when the account log dir has not been created
+        // yet. Account-scoped types check LOG_DIR before they reach for it.
+        // --- Session-key filtered mode: grep across log files ---
+        if (sessionKey) {
+            const prefixes = {
+                "agent-stream": "claude-agent-stream-",
+                system: "claude-agent-stream-", // backwards-compatible alias
+                error: "claude-agent-stderr-",
+                session: "sse-events-",
+                public: "public-agent-stream-",
+                mcp: "mcp-",
+            };
+            // When a type is explicitly provided, search only that type's files.
+            // When type is omitted, search all prefix-based log types (excludes heartbeat — no session context).
+            // server and vnc are single-file (configDir-scoped), so they have no prefix search;
+            // their matches are produced by dedicated blocks below.
+            const searchPrefixes = type && type !== "heartbeat" && type !== "server" && type !== "vnc" && prefixes[type]
+                ? { [type]: prefixes[type] }
+                : (type === "server" || type === "vnc") ? {} : prefixes;
+            // LOG_DIR may not exist on a Pi with no per-session logs yet. The
+            // platform-scoped fallback dirs (CONFIG_DIR/logs/) are searched
+            // below; this branch simply contributes nothing rather than
+            // throwing on readdir.
+            const allFiles = existsSync(LOG_DIR)
+                ? readdirSync(LOG_DIR).filter(f => f.endsWith(".log"))
+                : [];
+            const sections = [];
+            // Search account-scoped prefix-based log files
+            for (const [logType, prefix] of Object.entries(searchPrefixes)) {
+                const typeFiles = allFiles
+                    .filter(f => f.startsWith(prefix))
+                    .sort(); // chronological by date suffix
+                for (const file of typeFiles) {
+                    const filePath = resolve(LOG_DIR, file);
+                    try {
+                        const result = execFileSync("grep", ["-F", sessionKey, filePath], { timeout: 5000 }).toString().trim();
+                        if (result) {
+                            sections.push(`## ${file} (${logType})\n${result}`);
+                        }
+                    }
+                    catch (grepErr) {
+                        // grep exits 1 when no lines match — that's not an error
+                        const exitCode = grepErr.status;
+                        if (exitCode !== 1)
+                            throw grepErr;
+                    }
+                }
+            }
+            // Search server.log (platform-scoped, in configDir — not account-scoped)
+            const includeServer = !type || type === "server";
+            if (includeServer) {
+                const serverLog = resolve(CONFIG_DIR, "logs", "server.log");
+                if (existsSync(serverLog)) {
+                    try {
+                        const result = execFileSync("grep", ["-F", sessionKey, serverLog], { timeout: 5000 }).toString().trim();
+                        if (result) {
+                            sections.push(`## server.log (server)\n${result}`);
+                        }
+                    }
+                    catch (grepErr) {
+                        const exitCode = grepErr.status;
+                        if (exitCode !== 1)
+                            throw grepErr;
+                    }
+                }
+            }
+            // Search vnc-boot.log (platform-scoped, in configDir) — the
+            // consolidated VNC browser viewer lifecycle log.
+            const includeVnc = !type || type === "vnc";
+            if (includeVnc) {
+                const vncLog = resolve(CONFIG_DIR, "logs", "vnc-boot.log");
+                if (existsSync(vncLog)) {
+                    try {
+                        const result = execFileSync("grep", ["-F", sessionKey, vncLog], { timeout: 5000 }).toString().trim();
+                        if (result) {
+                            sections.push(`## vnc-boot.log (vnc)\n${result}`);
+                        }
+                    }
+                    catch (grepErr) {
+                        const exitCode = grepErr.status;
+                        if (exitCode !== 1)
+                            throw grepErr;
+                    }
+                }
+            }
+            if (sections.length === 0) {
+                return { content: [{ type: "text", text: `No log lines found for session key "${sessionKey}".` }] };
+            }
+            return { content: [{ type: "text", text: `# Session timeline: ${sessionKey}\n\n${sections.join("\n\n")}` }] };
+        }
+        // --- Standard mode: tail most recent file of the requested type ---
+        const resolvedType = type ?? "agent-stream";
+        // Heartbeat log is a single fixed file, not prefix-based
+        if (resolvedType === "heartbeat") {
+            const logFile = resolve(LOG_DIR, "check-due-events.log");
+            if (!existsSync(logFile)) {
+                return { content: [{ type: "text", text: "No heartbeat log found yet. The platform cron may not have run." }] };
+            }
+            const result = execFileSync("tail", ["-n", String(lines), logFile], {
+                timeout: 5000,
+            }).toString();
+            return { content: [{ type: "text", text: `# check-due-events.log\n\n${result}` }] };
+        }
+        // Server log is a single fixed file in configDir (platform-scoped, not account-scoped)
+        if (resolvedType === "server") {
+            const serverLog = resolve(CONFIG_DIR, "logs", "server.log");
+            if (!existsSync(serverLog)) {
+                return { content: [{ type: "text", text: `No server log found at ${serverLog}` }] };
+            }
+            const result = execFileSync("tail", ["-n", String(lines), serverLog], {
+                timeout: 5000,
+            }).toString();
+            return { content: [{ type: "text", text: `# server.log\n\n${result}` }] };
+        }
+        // VNC log is a single platform-scoped file covering the full
+        // browser viewer lifecycle — see tool description for signals.
+        if (resolvedType === "vnc") {
+            const vncLogFile = resolve(CONFIG_DIR, "logs", "vnc-boot.log");
+            if (!existsSync(vncLogFile)) {
+                return { content: [{ type: "text", text: `No vnc-boot log found at ${vncLogFile}` }] };
+            }
+            const result = execFileSync("tail", ["-n", String(lines), vncLogFile], {
+                timeout: 5000,
+            }).toString();
+            return { content: [{ type: "text", text: `# vnc-boot.log\n\n${result}` }] };
+        }
+        // agent-stream and the legacy system alias both map to
+        // claude-agent-stream-. The fall-through default also covers them.
+        const prefix = resolvedType === "error" ? "claude-agent-stderr-"
+            : resolvedType === "session" ? "sse-events-"
+                : resolvedType === "public" ? "public-agent-stream-"
+                    : resolvedType === "mcp" ? "mcp-"
+                        : "claude-agent-stream-";
+        // Find the most recently modified file with the matching prefix.
+        // LOG_DIR may not exist yet on a Pi with no per-session logs; return
+        // the resolved path in the error envelope so the operator can
+        // verify on disk in one step rather than re-tracing the resolver.
+        if (!existsSync(LOG_DIR)) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `No per-session logs for this account yet (resolved dir does not exist on disk): ${LOG_DIR}. The directory is created on first claude session spawn.`,
+                    }],
+            };
+        }
+        const match = readdirSync(LOG_DIR)
+            .filter(f => f.startsWith(prefix) && f.endsWith(".log"))
+            .map(f => ({ file: f, mtime: statSync(resolve(LOG_DIR, f)).mtimeMs }))
+            .sort((a, b) => b.mtime - a.mtime)[0];
+        if (!match) {
+            return { content: [{ type: "text", text: `No log file found for type '${resolvedType}' (resolved dir: ${LOG_DIR}, prefix: ${prefix})` }] };
+        }
+        const logFile = resolve(LOG_DIR, match.file);
+        const result = execFileSync("tail", ["-n", String(lines), logFile], {
+            timeout: 5000,
+        }).toString();
+        return { content: [{ type: "text", text: `# ${match.file}\n\n${result}` }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `Failed to read logs: ${err instanceof Error ? err.message : String(err)}` }] };
+    }
+});
+// operator-authored skills are written to disk as a plugin so the
+// existing plugin-manifest loader picks them up (parsePluginFrontmatter +
+// assemblePublicPluginContent + loadEmbeddedPlugins all read from
+// <PLATFORM_ROOT>/plugins/<dir>/). Canonical = <accountDir>/plugins/<plugin>
+// survives installer rmSync (data/ excluded); the mirror under
+// <PLATFORM_ROOT>/plugins/<plugin> is rehydrated at admin session start by
+// autoDeliverUserPlugins. The agent supplies pluginName/skillName/body —
+// path is computed by this tool from ACCOUNT_ID. Symmetric write counterpart
+// to plugin-read.
+eagerTool(server, "store-skill", "Save an operator-authored skill on disk as part of an admin-managed plugin. " +
+    "The skill becomes immediately discoverable by the admin agent (and the public agent if publicEmbed=true). " +
+    "Path is computed internally from the active account; the agent supplies content + names only. " +
+    "Re-running for the same skillName overwrites in place (drops orphan reference files).", {
+    pluginName: z.string().describe("Plugin directory name in lowercase kebab-case (e.g. 'beacons-skills'). Must not collide with a shipped plugin name."),
+    skillName: z.string().describe("Skill directory name in lowercase kebab-case (e.g. 'lead-capture')."),
+    description: z.string().describe("One-sentence skill description used in SKILL.md frontmatter and as the trigger hint for the agent."),
+    publicEmbed: z.boolean().describe("True to embed this skill in the public agent's system prompt; false for admin-only."),
+    body: z.string().describe("SKILL.md body content WITHOUT frontmatter. Frontmatter (name, description, publicEmbed) is composed by the tool."),
+    references: z.array(z.object({
+        filename: z.string().describe("Reference filename matching ^[a-z0-9-]+\\.md$ (no path separators)."),
+        content: z.string().describe("Reference file body content."),
+    })).default([]).describe("Optional reference files written under skills/<skillName>/references/."),
+}, async ({ pluginName, skillName, description, publicEmbed, body, references }) => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("store-skill");
+    const KEBAB_RE = /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/;
+    const REF_RE = /^[a-z0-9-]+\.md$/;
+    if (!KEBAB_RE.test(pluginName)) {
+        console.error(`[store-skill] ERROR pluginName=${pluginName} reason=invalid-kebab path=-`);
+        return { content: [{ type: "text", text: `pluginName must be lowercase kebab-case (1-64 chars, no leading/trailing hyphen): "${pluginName}"` }], isError: true };
+    }
+    if (!KEBAB_RE.test(skillName)) {
+        console.error(`[store-skill] ERROR pluginName=${pluginName} skillName=${skillName} reason=invalid-kebab path=-`);
+        return { content: [{ type: "text", text: `skillName must be lowercase kebab-case (1-64 chars, no leading/trailing hyphen): "${skillName}"` }], isError: true };
+    }
+    for (const ref of references) {
+        if (!REF_RE.test(ref.filename)) {
+            console.error(`[store-skill] ERROR pluginName=${pluginName} skillName=${skillName} reason=invalid-ref-filename ref=${ref.filename} path=-`);
+            return { content: [{ type: "text", text: `reference filename must match ^[a-z0-9-]+\\.md$: "${ref.filename}"` }], isError: true };
+        }
+    }
+    const accountDir = getAccountDir();
+    const canonicalPluginDir = resolve(accountDir, "plugins", pluginName);
+    const mirrorPluginDir = resolve(PLATFORM_ROOT, "plugins", pluginName);
+    const canonicalPluginMd = resolve(canonicalPluginDir, "PLUGIN.md");
+    const mirrorPluginMd = resolve(mirrorPluginDir, "PLUGIN.md");
+    // Collision: mirror dir exists from a shipped plugin (no canonical mirror).
+    // Refuse rather than silently shadow.
+    if (existsSync(mirrorPluginMd) && !existsSync(canonicalPluginMd)) {
+        console.error(`[store-skill] ERROR pluginName=${pluginName} skillName=${skillName} reason=collision-with-shipped path=${mirrorPluginDir}`);
+        return { content: [{ type: "text", text: `pluginName "${pluginName}" collides with a shipped plugin. Choose a different pluginName.` }], isError: true };
+    }
+    const skillDir = resolve(canonicalPluginDir, "skills", skillName);
+    const action = existsSync(resolve(skillDir, "SKILL.md")) ? "overwrite" : "create";
+    try {
+        mkdirSync(canonicalPluginDir, { recursive: true });
+        // Compose PLUGIN.md only on first write. embed=["admin","public"] +
+        // optional=false matches assemblePublicPluginContent / loadEmbeddedPlugins
+        // expectations. metadata is single-line JSON (parsePluginFrontmatter at
+        // plugin-manifest.ts:67 expects single-line) — multi-line silently falls
+        // back to platform={}.
+        if (!existsSync(canonicalPluginMd)) {
+            const pluginMd = `---
+name: ${pluginName}
+description: "Operator-authored plugin"
+tools: []
+hidden: []
+requires: []
+metadata: {"platform":{"embed":["admin","public"],"optional":false}}
+---
+
+# ${pluginName}
+
+Operator-authored plugin. Skills under \`skills/\` were created via the admin skill-builder.
+`;
+            writeFileSync(canonicalPluginMd, pluginMd);
+        }
+        // Reset skill dir before write so removed reference files don't linger.
+        if (existsSync(skillDir)) {
+            rmSync(skillDir, { recursive: true, force: true });
+        }
+        mkdirSync(skillDir, { recursive: true });
+        // Normalise description — strip newlines and tabs to keep YAML
+        // frontmatter on a single line. parsePluginFrontmatter uses a
+        // single-line regex; an embedded newline (or `\n---\n`) would
+        // otherwise corrupt the frontmatter parse and silently drop body
+        // content from the agent prompt.
+        const singleLineDescription = description.replace(/[\r\n\t]+/g, " ").trim();
+        const escapedDescription = singleLineDescription.replace(/"/g, '\\"');
+        const skillMd = `---
+name: ${skillName}
+description: "${escapedDescription}"
+publicEmbed: ${publicEmbed}
+---
+
+${body}
+`;
+        writeFileSync(resolve(skillDir, "SKILL.md"), skillMd);
+        let refCount = 0;
+        if (references.length > 0) {
+            const refsDir = resolve(skillDir, "references");
+            mkdirSync(refsDir, { recursive: true });
+            for (const ref of references) {
+                writeFileSync(resolve(refsDir, ref.filename), ref.content);
+                refCount++;
+            }
+        }
+        // Write the `.user-mirror` marker to CANONICAL first — cpSync will
+        // carry it into the platform-side mirror as part of the same recursive
+        // copy. This eliminates the post-cpSync writeFileSync race: if cpSync
+        // succeeds, the marker is already in target; if cpSync fails partway,
+        // canonical's marker is intact and the next autoDeliverUserPlugins
+        // call retries the copy. autoDeliverUserPlugins relies on the marker
+        // arriving with the source tree — never writes its own marker.
+        writeFileSync(resolve(canonicalPluginDir, ".user-mirror"), `pluginName=${pluginName}\nsource=${canonicalPluginDir}\n`);
+        // Mirror to <PLATFORM_ROOT>/plugins/<pluginName>/ so the change is
+        // visible to the loader without a session restart.
+        mkdirSync(mirrorPluginDir, { recursive: true });
+        cpSync(canonicalPluginDir, mirrorPluginDir, { recursive: true, force: true });
+        const bodyBytes = Buffer.byteLength(body, "utf-8");
+        console.log(`[store-skill] write pluginName=${pluginName} skillName=${skillName} publicEmbed=${publicEmbed} path=${canonicalPluginDir} bodyBytes=${bodyBytes} referenceCount=${refCount} action=${action}`);
+        return {
+            content: [{
+                    type: "text",
+                    text: `Skill "${skillName}" saved to plugin "${pluginName}" (${action}). publicEmbed=${publicEmbed}, references=${refCount}. Active immediately for the admin agent${publicEmbed ? "; surfaces in the public agent on next session start" : ""}.`,
+                }],
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`[store-skill] ERROR pluginName=${pluginName} skillName=${skillName} reason=${msg.slice(0, 120)} path=${canonicalPluginDir}`);
+        return { content: [{ type: "text", text: `Failed to write skill: ${msg}` }], isError: true };
+    }
+});
+eagerTool(server, "plugin-read", "Read a plugin definition (PLUGIN.md) or one of its reference files.", {
+    pluginName: z.string().describe("Name of the plugin directory (e.g. 'sales', 'business-assistant')"),
+    file: z.string().optional().describe("Specific file to read (e.g. 'references/pricing.md'). Defaults to PLUGIN.md."),
+}, async ({ pluginName, file }) => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("plugin-read");
+    try {
+        const resolvedFile = file ?? "PLUGIN.md";
+        // Task 516 — plugin-read is the raw-SKILL.md read path that would
+        // otherwise bypass the skill-load authoring gate. Block the admin seat
+        // from reading any content-producer-owned authoring skill's files
+        // (SKILL.md or its references); the slug is extracted from the file
+        // path or pluginName. Same fail-open contract as skill-load.
+        const authoringSlug = skillSlugFromReadArgs(pluginName, resolvedFile);
+        if (adminAuthoringSkillBlock(authoringSlug, process.env)) {
+            console.log(`[admin-skill-gate] role=admin skill=${authoringSlug} decision=block reason=content-producer-owned`);
+            return { content: [{ type: "text", text: AUTHORING_DISPATCH_HINT }], isError: true };
+        }
+        const pluginPath = resolve(PLATFORM_ROOT, "plugins", pluginName, resolvedFile);
+        if (!existsSync(pluginPath)) {
+            // when the agent's pluginName/file combination misses
+            // a skill that DOES live under `plugins/*/skills/<slug>/SKILL.md`,
+            // surface the corrected pluginName AND the canonical file path so
+            // the next call is deterministic. Both wrong-`file` and wrong-`pluginName`
+            // shapes feed through `computePluginReadHint`.
+            const hint = computePluginReadHint(PLATFORM_ROOT, pluginName, resolvedFile);
+            const hintText = hint ? ` Did you mean pluginName="${hint.pluginName}", file="${hint.file}"?` : "";
+            console.log(`[plugin-read] ${pluginName}/${resolvedFile} not-found hint=${hint ? hint.pluginName : "none"}`);
+            return {
+                content: [{ type: "text", text: `Plugin file not found: ${pluginPath}.${hintText}` }],
+                isError: true,
+            };
+        }
+        console.log(`[plugin-read] ${pluginName}/${resolvedFile}`);
+        const rawContent = await readFile(pluginPath, "utf-8");
+        // Brand-substitute every plugin file before it reaches the agent —
+        // PLUGIN.md, skills/<name>/SKILL.md, references/*.md all flow through
+        // here. Missing brand.json hard-throws (Tasks 787/788 doctrine).
+        const content = substituteBrandPlaceholders(rawContent, pluginPath);
+        // Append file inventory on default calls (PLUGIN.md) so agents can discover
+        // skill and reference paths without guessing
+        if (resolvedFile === "PLUGIN.md") {
+            const pluginRoot = resolve(PLATFORM_ROOT, "plugins", pluginName);
+            const skills = [];
+            const references = [];
+            const scanDir = (base, prefix, target) => {
+                const scanPath = resolve(pluginRoot, base);
+                if (!existsSync(scanPath))
+                    return;
+                try {
+                    const walk = (current, rel) => {
+                        for (const entry of readdirSync(current)) {
+                            const full = resolve(current, entry);
+                            try {
+                                const stat = statSync(full);
+                                if (stat.isDirectory()) {
+                                    walk(full, `${rel}${entry}/`);
+                                }
+                                else if (entry.endsWith(".md")) {
+                                    target.push(`${prefix}${rel}${entry}`);
+                                }
+                            }
+                            catch { /* skip unreadable entries */ }
+                        }
+                    };
+                    walk(scanPath, "");
+                }
+                catch { /* skip unreadable directories */ }
+            };
+            scanDir("skills", "skills/", skills);
+            scanDir("references", "references/", references);
+            let inventory = "";
+            if (skills.length > 0)
+                inventory += `\nSkills: ${skills.join(", ")}`;
+            if (references.length > 0)
+                inventory += `\nReferences: ${references.join(", ")}`;
+            return { content: [{ type: "text", text: content + inventory }] };
+        }
+        return { content: [{ type: "text", text: content }] };
+    }
+    catch (err) {
+        return {
+            content: [{ type: "text", text: `Failed: ${err instanceof Error ? err.message : String(err)}` }],
+            isError: true,
+        };
+    }
+});
+// agent-side `Glob` fallthrough when "set up cloudflare" maps a
+// SKILL.md to the wrong plugin: skill-find walks
+// `${PLATFORM_ROOT}/plugins/*/skills/<skillName>/SKILL.md` once and returns
+// the owner. With one tool call the agent learns the correct plugin name.
+//
+// `skill-load` (below) is the canonical single-call surface that
+// most agents want (resolve + read body in one shot). `skill-find` is kept
+// for callers that need only the path (e.g. tooling that lists owners
+// without reading the body).
+server.tool("skill-find", "Find which plugin owns a skill by name. Walks plugins/*/skills/<skillName>/SKILL.md and returns the owning plugin (unique), every candidate (ambiguous), or not-found. For the common resolve-and-read case, prefer `skill-load skillName=<name>` — it returns the SKILL.md body in the same call.", {
+    skillName: z.string().regex(/^[a-z0-9][a-z0-9-]*$/, "skillName must be lowercase kebab-case (a-z, 0-9, -)"),
+}, async ({ skillName }) => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("skill-find");
+    const start = Date.now();
+    const result = findSkillOwners(PLATFORM_ROOT, skillName);
+    const ms = Date.now() - start;
+    console.log(`[skill-find] skillName=${skillName} result=${result.status} candidates=${result.candidates.length} ms=${ms}`);
+    if (result.status === "unique") {
+        const [{ pluginName, file }] = result.candidates;
+        return {
+            content: [{
+                    type: "text",
+                    text: `pluginName="${pluginName}" file="${file}"\nTo read the body in one call, use: skill-load skillName="${skillName}"`,
+                }],
+        };
+    }
+    if (result.status === "ambiguous") {
+        const lines = result.candidates.map(c => `  pluginName="${c.pluginName}" file="${c.file}"`).join("\n");
+        return {
+            content: [{
+                    type: "text",
+                    text: `Ambiguous — skill "${skillName}" exists in ${result.candidates.length} plugins:\n${lines}`,
+                }],
+        };
+    }
+    return {
+        content: [{ type: "text", text: `not_found — no plugin owns a skill named "${skillName}"` }],
+        isError: true,
+    };
+});
+// `skill-load` collapses skill resolve+read into one call.
+//
+// Why: 21 prose call sites previously said *"Load `admin/skills/plainly/SKILL.md`
+// via `plugin-read`"*. The LLM kept passing the path as `pluginName`, tripping
+// the not-found branch with the corrected-pluginName hint.
+// The recurring failure is recorded in the corrections ledger. One slug-arg
+// tool removes the path-format ambiguity at the source.
+//
+// Shape mirrors `plugin-read` (eagerTool registration, same brand-substitution
+// call) so SKILL.md bodies are byte-identical regardless of which tool reads
+// them. `plugin-read` is retained for `references/*` and `PLUGIN.md` reads —
+// those are plugin-scoped by nature and the path-as-pluginName failure pattern
+// is specific to skills (addressed by slug in prose).
+eagerTool(server, "skill-load", "Load a plugin skill's SKILL.md body by skill name. One call: resolves the owning plugin and reads the body, with brand placeholders substituted. Returns the SKILL.md body when exactly one plugin owns the skill, a candidate list when multiple plugins own it (ambiguous), or an error when no plugin owns it.", {
+    skillName: z.string().regex(/^[a-z0-9][a-z0-9-]*$/, "skillName must be lowercase kebab-case (a-z, 0-9, -)"),
+}, async ({ skillName }) => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("skill-load");
+    // Task 516 — the admin seat may not load content-producer-owned
+    // authoring skills inline; it must dispatch content-producer instead.
+    // The gate is a pure name+env check before any filesystem read, and
+    // fails open for non-admin / unidentified seats (content-producer's own
+    // spawns carry MAXY_SPECIALIST and resolve normally).
+    if (adminAuthoringSkillBlock(skillName, process.env)) {
+        console.log(`[admin-skill-gate] role=admin skill=${skillName} decision=block reason=content-producer-owned`);
+        return { content: [{ type: "text", text: AUTHORING_DISPATCH_HINT }], isError: true };
+    }
+    const start = Date.now();
+    try {
+        const outcome = await loadSkill(PLATFORM_ROOT, skillName);
+        if (outcome.status === "ambiguous") {
+            const ms = Date.now() - start;
+            console.log(`[skill-load] skillName=${skillName} result=ambiguous pluginName=none file=none bodyBytes=0 ms=${ms}`);
+            const lines = outcome.candidates.map(c => `  pluginName="${c.pluginName}" file="${c.file}"`).join("\n");
+            return {
+                content: [{
+                        type: "text",
+                        text: `Ambiguous — skill "${skillName}" exists in ${outcome.candidates.length} plugins:\n${lines}\nUse plugin-read with one of the listed pluginName/file pairs.`,
+                    }],
+                isError: true,
+            };
+        }
+        if (outcome.status === "not-found") {
+            const ms = Date.now() - start;
+            console.log(`[skill-load] skillName=${skillName} result=not-found pluginName=none file=none bodyBytes=0 ms=${ms}`);
+            return {
+                content: [{ type: "text", text: `not_found — no plugin owns a skill named "${skillName}"` }],
+                isError: true,
+            };
+        }
+        const content = substituteBrandPlaceholders(outcome.body, outcome.absolutePath);
+        // prepend a skill-input-contract notice when the skill's
+        // frontmatter declares `requiredInputs:`. The notice tells the agent
+        // to route missing inputs through AskUserQuestion (per IDENTITY.md
+        // "Skill-input resolution"); the embedded `<!-- skill-input-contract
+        // requiredInputs=... -->` marker is the per-turn keying signal that
+        // parseClaudeStream uses to fire [skill-input-resolution] /
+        // [skill-input-missing] observability lines.
+        const requiredInputs = parseRequiredInputs(outcome.body);
+        let bodyOut = content;
+        if (requiredInputs) {
+            const slotLabels = requiredInputs.map(s => s.join(" | ")).join(", ");
+            const marker = JSON.stringify(requiredInputs);
+            const notice = `<!-- skill-input-contract requiredInputs=${marker} -->\nREQUIRED INPUTS: ${slotLabels}\nIf the operator has not supplied each of these inputs, your next tool call MUST be AskUserQuestion. Do not use memory-search, conversation-search, graph-read, or work-get to guess the missing input.\n<!-- /skill-input-contract -->\n\n`;
+            bodyOut = notice + content;
+        }
+        const ms = Date.now() - start;
+        const reqLog = requiredInputs ? ` requiredInputs=${JSON.stringify(requiredInputs)}` : "";
+        console.log(`[skill-load] skillName=${skillName} result=unique pluginName=${outcome.pluginName} file=${outcome.file} bodyBytes=${bodyOut.length}${reqLog} ms=${ms}`);
+        return { content: [{ type: "text", text: bodyOut }] };
+    }
+    catch (err) {
+        const ms = Date.now() - start;
+        console.log(`[skill-load] skillName=${skillName} result=read-error pluginName=unknown file=unknown bodyBytes=0 ms=${ms}`);
+        return {
+            content: [{ type: "text", text: `Failed to load skill "${skillName}": ${err instanceof Error ? err.message : String(err)}` }],
+            isError: true,
+        };
+    }
+});
+// the inline UI-component tool is gone from the admin surface
+// on native Claude Code. The PTY runtime has no host bridge for the UI
+// primitives the legacy tool wrapped; calling it logged a "rendered"
+// sentinel that read like a successful render to the agent while the
+// chat surface saw nothing. Admin flows now use plain markdown for
+// reviewable artefacts and the `file-presentation` skill for downloadable
+// artefacts (written under output/ and delivered by stating their location).
+// The :Component / :KnowledgeDocument
+// persistence pipeline is preserved for historical conversations that
+// already carry the rows; no new conversations write to it.
+eagerTool(server, "session-reset", "Reset the current session. Compacts conversation history to memory, clears the visible conversation, " +
+    "and starts a fresh session with a new greeting. Call when the user asks to start a new session, " +
+    "clear the conversation, or start fresh.", {}, async () => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("session-reset");
+    return { content: [{ type: "text", text: "reset" }] };
+});
+eagerTool(server, "session-resume", "Resume a previous session. Loads the selected session's message history into the chat timeline " +
+    "and routes new messages to that conversation. Call after the user selects a session from the " +
+    "session-list results. Pass the sessionId from the selected session.", { sessionId: z.string().uuid().describe("The sessionId of the session to resume") }, async () => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("session-resume");
+    return { content: [{ type: "text", text: "resumed" }] };
+});
+server.tool("remote-auth-set-password", "Set the remote access password. Hashes with scrypt and writes to the platform's brand-specific config directory with mode 0600. " +
+    "Validates strength (8+ chars, digit, special character, no spaces anywhere). " +
+    "Protects the admin interface when exposed over the tunnel — has no effect on the public endpoint or the tunnel itself. " +
+    "Set before configuring the Cloudflare tunnel — the post-restart `curl -I https://<admin-hostname>` verification fails if remote-auth is not configured.", { password: z.string() }, async ({ password }) => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("remote-auth-set-password");
+    // Validate strength — same rules as the web server's validatePasswordStrength
+    const checks = [
+        { label: "at least 8 characters", met: password.length >= 8 },
+        { label: "contains a number", met: /\d/.test(password) },
+        { label: "contains a special character", met: /[^A-Za-z0-9]/.test(password) },
+        { label: "no spaces", met: password.length > 0 && !/\s/.test(password) },
+    ];
+    const failed = checks.filter((c) => !c.met);
+    if (failed.length > 0) {
+        return {
+            content: [{ type: "text", text: `Password requirements not met: ${failed.map((c) => c.label).join(", ")}` }],
+            isError: true,
+        };
+    }
+    try {
+        const { scrypt, randomBytes } = await import("node:crypto");
+        const salt = randomBytes(32);
+        const hash = await new Promise((res, rej) => {
+            scrypt(password, salt, 64, { N: 16384, r: 8, p: 1 }, (err, key) => {
+                if (err)
+                    rej(err);
+                else
+                    res(key);
+            });
+        });
+        const stored = `${salt.toString("hex")}:${hash.toString("hex")}`;
+        const pwPath = REMOTE_PASSWORD_FILE;
+        await writeFile(pwPath, stored, { mode: 0o600 });
+        return { content: [{ type: "text", text: "Remote access password set." }] };
+    }
+    catch (err) {
+        return {
+            content: [{ type: "text", text: `Failed to set password: ${err instanceof Error ? err.message : String(err)}` }],
+            isError: true,
+        };
+    }
+});
+// ===================================================================
+// Utility tools
+// ===================================================================
+eagerTool(server, "qr-generate", "Generate a QR code PNG from text or a URL. Writes the PNG under accounts/<accountId>/output/qr/ and returns the file path. Pass outputPath to write to a specific location instead (used by the brochure pipeline for qr-listing.png / qr-video.png).", {
+    data: z.string().describe("The text or URL to encode in the QR code"),
+    outputPath: z
+        .string()
+        .optional()
+        .describe("Absolute file path to save the PNG. Defaults to <accountDir>/output/qr/qr-<timestamp>.png."),
+    width: z.number().optional().describe("Width in pixels (default 300)"),
+}, async ({ data, outputPath, width }) => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("qr-generate");
+    try {
+        const options = { width: width ?? 300, margin: 2 };
+        const dest = outputPath ?? (() => {
+            const qrDir = join(getAccountDir(), "output", "qr");
+            mkdirSync(qrDir, { recursive: true });
+            return join(qrDir, `qr-${Date.now()}.png`);
+        })();
+        await QRCode.toFile(dest, data, options);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `QR code saved to ${dest}`,
+                },
+            ],
+        };
+    }
+    catch (err) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `QR generation failed: ${err instanceof Error ? err.message : String(err)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// ===================================================================
+// WiFi management
+// ===================================================================
+eagerTool(server, "wifi", "Manage WiFi connections on this device. Actions: " +
+    "scan (list visible networks with signal strength and security), " +
+    "connect (join a network by SSID and password — warn user first if signal is below 30%), " +
+    "status (current WiFi connection details), " +
+    "saved (list remembered networks), " +
+    "forget (remove a saved network — if the user is forgetting their currently active WiFi " +
+    "connection, warn them that they may lose connectivity before calling this action).", {
+    action: z.enum(["scan", "connect", "status", "saved", "forget"]).describe("The WiFi operation to perform"),
+    ssid: z.string().optional().describe("Network name — required for connect and forget actions"),
+    password: z.string().optional().describe("Network password — required for connect action (WPA/WPA2/WPA3 PSK)"),
+}, async ({ action, ssid, password }) => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("wifi");
+    /** Parse nmcli terse output into rows of colon-separated fields.
+     *  nmcli -t escapes literal colons in values as \: — split on
+     *  unescaped colons only, then unescape the fields. */
+    const parseNmcliLines = (output) => output.split("\n").filter(Boolean).map((l) => l.split(/(?<!\\):/).map((f) => f.replace(/\\:/g, ":")));
+    const logPrefix = "[wifi]";
+    try {
+        switch (action) {
+            // ── scan ──────────────────────────────────────────────────
+            case "scan": {
+                const raw = execFileSync("nmcli", ["-t", "-f", "SSID,SIGNAL,SECURITY", "device", "wifi", "list", "--rescan", "yes"], { encoding: "utf-8", timeout: 15000 });
+                const lines = parseNmcliLines(raw);
+                // Filter hidden networks (empty SSID) and deduplicate by SSID
+                const seen = new Set();
+                const networks = [];
+                for (const [name, sig, sec] of lines) {
+                    if (!name || seen.has(name))
+                        continue;
+                    seen.add(name);
+                    networks.push({ ssid: name, signal: parseInt(sig, 10) || 0, security: sec || "open" });
+                }
+                // Sort by signal strength descending
+                networks.sort((a, b) => b.signal - a.signal);
+                console.error(`${logPrefix} action="scan" result="ok" networks=${networks.length}`);
+                if (networks.length === 0) {
+                    return {
+                        content: [{ type: "text", text: "No WiFi networks found. Make sure your router is powered on and within range." }],
+                    };
+                }
+                const formatted = networks
+                    .map((n) => `${n.ssid}  (${n.signal}%  ${n.security})`)
+                    .join("\n");
+                return {
+                    content: [{ type: "text", text: `# WiFi Networks\n\n${formatted}` }],
+                };
+            }
+            // ── connect ──────────────────────────────────────────────
+            case "connect": {
+                if (!ssid) {
+                    return {
+                        content: [{ type: "text", text: "SSID is required for connect action." }],
+                        isError: true,
+                    };
+                }
+                if (!password) {
+                    return {
+                        content: [{ type: "text", text: "Password is required for connect action." }],
+                        isError: true,
+                    };
+                }
+                // Check signal strength before connecting (cherry-pick 1)
+                try {
+                    const scanRaw = execFileSync("nmcli", ["-t", "-f", "SSID,SIGNAL", "device", "wifi", "list"], { encoding: "utf-8", timeout: 10000 });
+                    const scanLines = parseNmcliLines(scanRaw);
+                    const match = scanLines.find(([name]) => name === ssid);
+                    const signal = match ? parseInt(match[1], 10) || 0 : 0;
+                    if (signal > 0 && signal < 30) {
+                        // Include warning in result but proceed with connection
+                        console.error(`${logPrefix} action="connect" ssid="${ssid}" signal=${signal} warning="weak_signal"`);
+                    }
+                }
+                catch {
+                    // Scan check is best-effort — proceed with connect regardless
+                }
+                execFileSync("nmcli", ["device", "wifi", "connect", ssid, "password", password, "--wait", "30"], { encoding: "utf-8", timeout: 35000 });
+                console.error(`${logPrefix} action="connect" ssid="${ssid}" result="connecting" password=[REDACTED]`);
+                // Post-connect verification: confirm IP assignment on wlan0 (cherry-pick 2)
+                let ip = "";
+                try {
+                    const deviceInfo = execFileSync("nmcli", ["-t", "-f", "IP4.ADDRESS", "device", "show", "wlan0"], { encoding: "utf-8", timeout: 5000 });
+                    const ipLine = deviceInfo.split("\n").find((l) => l.startsWith("IP4.ADDRESS"));
+                    if (ipLine) {
+                        // Format: IP4.ADDRESS[1]:192.168.1.100/24
+                        ip = ipLine.split(":").slice(1).join(":").split("/")[0].trim();
+                    }
+                }
+                catch {
+                    // IP check failed — connection may still be establishing
+                }
+                if (ip) {
+                    console.error(`${logPrefix} action="connect" ssid="${ssid}" result="connected" ip="${ip}"`);
+                    // Check if signal was weak and include warning
+                    let warning = "";
+                    try {
+                        const scanRaw = execFileSync("nmcli", ["-t", "-f", "SSID,SIGNAL", "device", "wifi", "list"], { encoding: "utf-8", timeout: 5000 });
+                        const match = parseNmcliLines(scanRaw).find(([name]) => name === ssid);
+                        const signal = match ? parseInt(match[1], 10) || 0 : 0;
+                        if (signal > 0 && signal < 30) {
+                            warning = `\n\nWarning: Signal strength is weak (${signal}%). Connection may be unreliable.`;
+                        }
+                    }
+                    catch {
+                        // Signal check is best-effort
+                    }
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `Connected to ${ssid}. IP address: ${ip}. You can safely unplug ethernet.${warning}`,
+                            }],
+                    };
+                }
+                else {
+                    console.error(`${logPrefix} action="connect" ssid="${ssid}" result="connected_no_ip"`);
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `Connected to ${ssid} but no IP address was assigned. Stay on ethernet. The network may require additional configuration — check with your network administrator.`,
+                            }],
+                    };
+                }
+            }
+            // ── status ───────────────────────────────────────────────
+            case "status": {
+                // Check if wlan0 exists
+                let deviceStatus;
+                try {
+                    deviceStatus = execFileSync("nmcli", ["-t", "-f", "DEVICE,TYPE,STATE", "device", "status"], { encoding: "utf-8", timeout: 5000 });
+                }
+                catch (err) {
+                    console.error(`${logPrefix} action="status" result="failed" error="${err instanceof Error ? err.message : String(err)}"`);
+                    return {
+                        content: [{ type: "text", text: `WiFi status check failed: ${err instanceof Error ? err.message : String(err)}` }],
+                        isError: true,
+                    };
+                }
+                const wifiDevice = parseNmcliLines(deviceStatus).find(([, type]) => type === "wifi");
+                if (!wifiDevice) {
+                    console.error(`${logPrefix} action="status" result="no_hardware"`);
+                    return {
+                        content: [{ type: "text", text: "No WiFi hardware detected on this device." }],
+                    };
+                }
+                if (wifiDevice[2] !== "connected") {
+                    console.error(`${logPrefix} action="status" result="not_connected" state="${wifiDevice[2]}"`);
+                    return {
+                        content: [{ type: "text", text: `WiFi is not connected. Device state: ${wifiDevice[2]}.` }],
+                    };
+                }
+                // Get detailed connection info
+                const details = execFileSync("nmcli", ["-t", "-f", "GENERAL.CONNECTION,IP4.ADDRESS,IP4.GATEWAY,GENERAL.HWADDR", "device", "show", "wlan0"], { encoding: "utf-8", timeout: 5000 });
+                const detailLines = parseNmcliLines(details);
+                const conn = detailLines.find(([k]) => k === "GENERAL.CONNECTION")?.[1] ?? "unknown";
+                const ipAddr = detailLines.find(([k]) => k.startsWith("IP4.ADDRESS"))?.[1] ?? "none";
+                const gateway = detailLines.find(([k]) => k.startsWith("IP4.GATEWAY"))?.[1] ?? "none";
+                // Get signal strength
+                let signal = "unknown";
+                try {
+                    const scanRaw = execFileSync("nmcli", ["-t", "-f", "SSID,SIGNAL", "device", "wifi", "list"], { encoding: "utf-8", timeout: 5000 });
+                    const match = parseNmcliLines(scanRaw).find(([name]) => name === conn);
+                    if (match)
+                        signal = `${match[1]}%`;
+                }
+                catch {
+                    // Signal lookup is best-effort
+                }
+                console.error(`${logPrefix} action="status" result="connected" ssid="${conn}"`);
+                return {
+                    content: [{
+                            type: "text",
+                            text: `WiFi: connected\nSSID: ${conn}\nIP: ${ipAddr}\nGateway: ${gateway}\nSignal: ${signal}`,
+                        }],
+                };
+            }
+            // ── saved ────────────────────────────────────────────────
+            case "saved": {
+                const raw = execFileSync("nmcli", ["-t", "-f", "NAME,TYPE", "connection", "show"], { encoding: "utf-8", timeout: 5000 });
+                const wifiConns = parseNmcliLines(raw).filter(([, type]) => type === "802-11-wireless");
+                console.error(`${logPrefix} action="saved" count=${wifiConns.length}`);
+                if (wifiConns.length === 0) {
+                    return {
+                        content: [{ type: "text", text: "No saved WiFi networks." }],
+                    };
+                }
+                const formatted = wifiConns.map(([name]) => name).join("\n");
+                return {
+                    content: [{ type: "text", text: `# Saved WiFi Networks\n\n${formatted}` }],
+                };
+            }
+            // ── forget ───────────────────────────────────────────────
+            case "forget": {
+                if (!ssid) {
+                    return {
+                        content: [{ type: "text", text: "SSID is required for forget action." }],
+                        isError: true,
+                    };
+                }
+                execFileSync("nmcli", ["connection", "delete", ssid], { encoding: "utf-8", timeout: 10000 });
+                console.error(`${logPrefix} action="forget" ssid="${ssid}" result="ok"`);
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Forgotten network: ${ssid}. It will no longer auto-connect.`,
+                        }],
+                };
+            }
+            default:
+                return {
+                    content: [{ type: "text", text: `Unknown WiFi action: ${action}` }],
+                    isError: true,
+                };
+        }
+    }
+    catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        console.error(`${logPrefix} action="${action}" ssid="${ssid ?? ""}" result="failed" error="${errMsg}"`);
+        // Parse common nmcli error patterns into user-friendly messages
+        if (errMsg.includes("NetworkManager is not running")) {
+            return {
+                content: [{ type: "text", text: "NetworkManager is not running. Start it with: sudo systemctl start NetworkManager" }],
+                isError: true,
+            };
+        }
+        if (errMsg.includes("No network with SSID") || errMsg.includes("not found")) {
+            return {
+                content: [{ type: "text", text: `Network '${ssid}' not found — it may be out of range or the name may be incorrect.` }],
+                isError: true,
+            };
+        }
+        if (errMsg.includes("Secrets were required") || errMsg.includes("802-11-wireless-security.psk")) {
+            return {
+                content: [{ type: "text", text: `Authentication failed for '${ssid}' — the password may be incorrect.` }],
+                isError: true,
+            };
+        }
+        if (errMsg.includes("no wifi device found") || errMsg.includes("Wi-Fi device not found")) {
+            return {
+                content: [{ type: "text", text: "No WiFi hardware detected on this device." }],
+                isError: true,
+            };
+        }
+        if (errMsg.includes("ENOENT")) {
+            return {
+                content: [{ type: "text", text: "nmcli not found — NetworkManager may not be installed on this device." }],
+                isError: true,
+            };
+        }
+        if (errMsg.includes("ETIMEDOUT") || errMsg.includes("timed out") || errMsg.includes("Timeout")) {
+            return {
+                content: [{ type: "text", text: `WiFi operation timed out. The adapter may be busy — try again.` }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: `WiFi ${action} failed: ${errMsg}` }],
+            isError: true,
+        };
+    }
+});
+// ===================================================================
+// Premium plugin tools
+// ===================================================================
+server.tool("premium-list", "List available premium plugins and their delivery status. Returns structured data " +
+    "for each premium plugin in the staging area: name, type (standalone/bundle), description, " +
+    "purchase status, and delivery status (per sub-plugin for bundles).", {}, async () => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("premium-list");
+    try {
+        if (!existsSync(STAGING_ROOT)) {
+            return {
+                content: [{ type: "text", text: "No premium plugins available. The staging directory does not exist — premium plugins become available after the next platform update." }],
+            };
+        }
+        const config = await readAccountConfig();
+        // Effective purchasedPlugins from signed entitlement.
+        const entitlement = await currentEntitlement();
+        const purchased = entitlement.purchasedPlugins;
+        const enabled = Array.isArray(config.enabledPlugins) ? config.enabledPlugins : [];
+        const entries = readdirSync(STAGING_ROOT, { withFileTypes: true })
+            .filter(e => e.isDirectory())
+            .sort((a, b) => a.name.localeCompare(b.name));
+        if (entries.length === 0) {
+            return {
+                content: [{ type: "text", text: "No premium plugins found in the staging area." }],
+            };
+        }
+        const plugins = [];
+        for (const entry of entries) {
+            const stagingDir = resolve(STAGING_ROOT, entry.name);
+            const bundlePath = join(stagingDir, "BUNDLE.md");
+            const pluginPath = join(stagingDir, "PLUGIN.md");
+            if (existsSync(bundlePath)) {
+                // Bundle
+                const fm = parseFrontmatter(readFileSync(bundlePath, "utf-8"));
+                const subPlugins = (Array.isArray(fm.plugins) ? fm.plugins : [])
+                    .filter(name => VALID_PLUGIN_NAME.test(name));
+                const subStatus = subPlugins.map(name => ({
+                    name,
+                    delivered: existsSync(join(PLUGINS_DIR, name, "PLUGIN.md")),
+                    enabled: enabled.includes(name),
+                }));
+                plugins.push({
+                    name: entry.name,
+                    type: "bundle",
+                    description: typeof fm.description === "string" ? fm.description : "",
+                    purchased: purchased.includes(entry.name),
+                    subPlugins: subStatus,
+                });
+            }
+            else if (existsSync(pluginPath)) {
+                // Standalone
+                const fm = parseFrontmatter(readFileSync(pluginPath, "utf-8"));
+                plugins.push({
+                    name: entry.name,
+                    type: "standalone",
+                    description: typeof fm.description === "string" ? fm.description : "",
+                    purchased: purchased.includes(entry.name),
+                    delivered: existsSync(join(PLUGINS_DIR, entry.name, "PLUGIN.md")),
+                    enabled: enabled.includes(entry.name),
+                });
+            }
+            // Skip directories that have neither BUNDLE.md nor PLUGIN.md
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(plugins, null, 2) }],
+        };
+    }
+    catch (err) {
+        return {
+            content: [{ type: "text", text: `Failed to list premium plugins: ${err instanceof Error ? err.message : String(err)}` }],
+            isError: true,
+        };
+    }
+});
+server.tool("premium-deliver", "Deliver a purchased premium plugin. Copies plugin files from the staging area to the active " +
+    "plugin directory, verifies each copy, updates enabledPlugins in account.json, and scans for " +
+    "agent templates. Handles both standalone plugins and bundles (auto-detected). Idempotent — " +
+    "already-delivered sub-plugins are skipped. Returns a structured result with per-sub-plugin " +
+    "status and available templates.", {
+    pluginName: z.string().describe("Name of the premium plugin to deliver (e.g. 'real-agent', 'teaching')"),
+}, async ({ pluginName }) => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("premium-deliver");
+    const TAG = "[premium-deliver]";
+    // --- Validate plugin name ---
+    if (!pluginName || !VALID_PLUGIN_NAME.test(pluginName)) {
+        return {
+            content: [{ type: "text", text: `${TAG} Invalid plugin name "${pluginName}". Must match [a-z0-9-].` }],
+            isError: true,
+        };
+    }
+    // --- Guard against clobbering core plugins ---
+    if (CORE_PLUGINS.includes(pluginName)) {
+        return {
+            content: [{ type: "text", text: `${TAG} "${pluginName}" is a core plugin and cannot be delivered as a premium plugin.` }],
+            isError: true,
+        };
+    }
+    // --- Check staging directory ---
+    if (!existsSync(STAGING_ROOT)) {
+        return {
+            content: [{ type: "text", text: `${TAG} Premium plugins staging directory does not exist. Premium plugins become available after the next platform update.` }],
+            isError: true,
+        };
+    }
+    const stagingDir = resolve(STAGING_ROOT, pluginName);
+    if (!existsSync(stagingDir)) {
+        return {
+            content: [{ type: "text", text: `${TAG} No premium plugin named "${pluginName}" found in the staging area.` }],
+            isError: true,
+        };
+    }
+    // --- Read account config ---
+    let config;
+    try {
+        config = await readAccountConfig();
+    }
+    catch (err) {
+        return {
+            content: [{ type: "text", text: `${TAG} Failed to read account config: ${err instanceof Error ? err.message : String(err)}` }],
+            isError: true,
+        };
+    }
+    // Effective purchasedPlugins from signed entitlement. The
+    // raw account.json value is ignored on commercial installs; verifier
+    // returns the signed list (or [] on anonymous-fallback).
+    const entitlement = await resolveEntitlement(ENTITLEMENT_BRAND, {
+        accountId: typeof config.accountId === "string" ? config.accountId : "",
+        customerEmail: typeof config.customerEmail === "string" ? config.customerEmail : undefined,
+        tier: typeof config.tier === "string" ? config.tier : undefined,
+        purchasedPlugins: Array.isArray(config.purchasedPlugins) ? config.purchasedPlugins : undefined,
+    });
+    const purchased = entitlement.purchasedPlugins;
+    // --- Check purchase status ---
+    if (!purchased.includes(pluginName)) {
+        return {
+            content: [{ type: "text", text: `${TAG} "${pluginName}" is not in purchasedPlugins. Record the purchase first.` }],
+            isError: true,
+        };
+    }
+    // --- Detect type: bundle vs standalone ---
+    const bundlePath = join(stagingDir, "BUNDLE.md");
+    const pluginMdPath = join(stagingDir, "PLUGIN.md");
+    const isBundle = existsSync(bundlePath);
+    const isStandalone = !isBundle && existsSync(pluginMdPath);
+    if (!isBundle && !isStandalone) {
+        return {
+            content: [{ type: "text", text: `${TAG} Staging directory "${pluginName}" contains neither BUNDLE.md nor PLUGIN.md. Invalid premium plugin.` }],
+            isError: true,
+        };
+    }
+    const items = [];
+    if (isBundle) {
+        const fm = parseFrontmatter(readFileSync(bundlePath, "utf-8"));
+        const subPluginNames = Array.isArray(fm.plugins) ? fm.plugins : [];
+        if (subPluginNames.length === 0) {
+            return {
+                content: [{ type: "text", text: `${TAG} BUNDLE.md for "${pluginName}" has an empty or missing plugins array.` }],
+                isError: true,
+            };
+        }
+        for (const sub of subPluginNames) {
+            if (!VALID_PLUGIN_NAME.test(sub)) {
+                return {
+                    content: [{ type: "text", text: `${TAG} Sub-plugin name "${sub}" in BUNDLE.md contains invalid characters. Aborting delivery.` }],
+                    isError: true,
+                };
+            }
+            if (CORE_PLUGINS.includes(sub)) {
+                return {
+                    content: [{ type: "text", text: `${TAG} Sub-plugin "${sub}" collides with a core plugin name. Aborting delivery.` }],
+                    isError: true,
+                };
+            }
+            items.push({ name: sub, sourcePath: resolve(stagingDir, "plugins", sub) });
+        }
+    }
+    else {
+        items.push({ name: pluginName, sourcePath: stagingDir });
+    }
+    const results = [];
+    const newlyEnabled = [];
+    for (const item of items) {
+        const destPath = resolve(PLUGINS_DIR, item.name);
+        // Already delivered — skip (preserves user's enable/disable state)
+        if (existsSync(join(destPath, "PLUGIN.md"))) {
+            console.log(`${TAG} ${item.name} already delivered — skipping`);
+            results.push({ name: item.name, status: "skipped" });
+            continue;
+        }
+        // Validate source
+        if (!existsSync(join(item.sourcePath, "PLUGIN.md"))) {
+            const msg = `Source PLUGIN.md missing at ${item.sourcePath}`;
+            console.error(`${TAG} FAILED ${item.name}: ${msg}`);
+            results.push({ name: item.name, status: "failed", error: msg });
+            continue;
+        }
+        // Copy
+        try {
+            cpSync(item.sourcePath, destPath, { recursive: true });
+            console.log(`${TAG} copied ${item.name} from staging`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`${TAG} FAILED to copy ${item.name}: ${msg}`);
+            results.push({ name: item.name, status: "failed", error: msg });
+            continue;
+        }
+        // Verify
+        const verifyPath = join(destPath, "PLUGIN.md");
+        if (!existsSync(verifyPath)) {
+            console.error(`${TAG} FAILED to verify ${item.name}: PLUGIN.md missing after copy`);
+            results.push({ name: item.name, status: "failed", error: "PLUGIN.md missing after copy" });
+            continue;
+        }
+        // Count skills
+        const skillsDir = join(destPath, "skills");
+        let skillCount = 0;
+        if (existsSync(skillsDir)) {
+            skillCount = readdirSync(skillsDir, { withFileTypes: true })
+                .filter(e => e.isDirectory()).length;
+        }
+        console.log(`${TAG} verified ${item.name} (${skillCount} skills)`);
+        results.push({ name: item.name, status: "delivered", skills: skillCount });
+        newlyEnabled.push(item.name);
+    }
+    // --- Update enabledPlugins (only add newly delivered, deduplicate) ---
+    if (newlyEnabled.length > 0) {
+        try {
+            // Re-read config to reduce race window
+            const freshConfig = await readAccountConfig();
+            const freshEnabled = Array.isArray(freshConfig.enabledPlugins)
+                ? freshConfig.enabledPlugins
+                : [];
+            const merged = [...new Set([...freshEnabled, ...newlyEnabled])];
+            freshConfig.enabledPlugins = merged;
+            const configPath = join(getAccountDir(), "account.json");
+            await writeFile(configPath, JSON.stringify(freshConfig, null, 2) + "\n", "utf-8");
+            console.log(`${TAG} updated enabledPlugins: added ${newlyEnabled.join(", ")}`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`${TAG} FAILED to update account.json: ${msg}`);
+            return {
+                content: [{
+                        type: "text",
+                        text: `${TAG} Plugins were copied but account.json update failed: ${msg}\n\nDelivery results:\n${JSON.stringify(results, null, 2)}`,
+                    }],
+                isError: true,
+            };
+        }
+    }
+    const templates = [];
+    // For bundles, templates live in the staging agents/ dir; for standalone, in the delivered plugin
+    const agentsSearchDirs = [];
+    if (isBundle) {
+        const bundleAgentsDir = join(stagingDir, "agents");
+        if (existsSync(bundleAgentsDir))
+            agentsSearchDirs.push(bundleAgentsDir);
+    }
+    else {
+        const pluginAgentsDir = join(PLUGINS_DIR, pluginName, "agents");
+        if (existsSync(pluginAgentsDir))
+            agentsSearchDirs.push(pluginAgentsDir);
+    }
+    for (const agentsDir of agentsSearchDirs) {
+        const subdirs = readdirSync(agentsDir, { withFileTypes: true })
+            .filter(e => e.isDirectory());
+        for (const sub of subdirs) {
+            const templateJsonPath = join(agentsDir, sub.name, "template.json");
+            if (!existsSync(templateJsonPath))
+                continue;
+            try {
+                const templateData = JSON.parse(readFileSync(templateJsonPath, "utf-8"));
+                const identityExists = existsSync(join(agentsDir, sub.name, "IDENTITY.md"));
+                const soulExists = existsSync(join(agentsDir, sub.name, "SOUL.md"));
+                if (!identityExists || !soulExists) {
+                    console.log(`${TAG} template ${sub.name} incomplete — missing ${!identityExists ? "IDENTITY.md" : "SOUL.md"}, skipping`);
+                    continue;
+                }
+                templates.push({
+                    directory: join(agentsDir, sub.name),
+                    displayName: templateData.displayName ?? sub.name,
+                    description: templateData.description ?? "",
+                    suggestedSlug: templateData.suggestedSlug,
+                });
+            }
+            catch {
+                console.log(`${TAG} template ${sub.name} has invalid template.json, skipping`);
+            }
+        }
+    }
+    // --- Build structured result ---
+    const delivered = results.filter(r => r.status === "delivered");
+    const skipped = results.filter(r => r.status === "skipped");
+    const failed = results.filter(r => r.status === "failed");
+    const totalSkills = delivered.reduce((sum, r) => sum + (r.skills ?? 0), 0);
+    const output = {
+        pluginName,
+        type: isBundle ? "bundle" : "standalone",
+        delivered: delivered.map(r => ({ name: r.name, skills: r.skills })),
+        skipped: skipped.map(r => r.name),
+        failed: failed.map(r => ({ name: r.name, error: r.error })),
+        totalDelivered: delivered.length,
+        totalSkipped: skipped.length,
+        totalFailed: failed.length,
+        totalSkills,
+        templates: templates.map(t => ({
+            displayName: t.displayName,
+            description: t.description,
+            suggestedSlug: t.suggestedSlug,
+            directory: t.directory,
+        })),
+    };
+    return {
+        content: [{ type: "text", text: JSON.stringify(output, null, 2) }],
+    };
+});
+// ===================================================================
+// Action approval tools (EU AI Act Article 14 — human oversight)
+//
+//   Hook queues require-review actions to {accountDir}/pending-actions/.
+//   These tools let the admin list, approve, reject, or edit pending actions.
+//   On approval, the target plugin MCP server is spawned directly (dispatchStep
+//   pattern) to execute the original tool call.
+// ===================================================================
+let _pendingDir;
+function getPendingDir() {
+    if (!_pendingDir)
+        _pendingDir = resolve(getAccountDir(), "pending-actions");
+    return _pendingDir;
+}
+function readPendingActions() {
+    const pendingDir = getPendingDir();
+    if (!existsSync(pendingDir))
+        return [];
+    const files = readdirSync(pendingDir)
+        .filter(f => f.endsWith(".json") && !f.startsWith("."));
+    const actions = [];
+    for (const file of files) {
+        try {
+            const raw = readFileSync(resolve(pendingDir, file), "utf-8");
+            const parsed = JSON.parse(raw);
+            if (parsed.state === "pending") {
+                actions.push(parsed);
+            }
+        }
+        catch (err) {
+            console.error(`[approval] Failed to read pending action ${file}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    return actions.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+function readPendingAction(actionId) {
+    const filePath = resolve(getPendingDir(), `${actionId}.json`);
+    if (!existsSync(filePath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(filePath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function resolvePendingAction(actionId, state, editedInput) {
+    const filePath = resolve(getPendingDir(), `${actionId}.json`);
+    if (!existsSync(filePath))
+        return false;
+    try {
+        const action = JSON.parse(readFileSync(filePath, "utf-8"));
+        if (action.state !== "pending")
+            return false;
+        action.state = state;
+        action.resolvedAt = new Date().toISOString();
+        if (editedInput)
+            action.editedInput = editedInput;
+        writeFileSync(filePath, JSON.stringify(action, null, 2), "utf-8");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function cleanupPendingAction(actionId) {
+    const pendingDir = getPendingDir();
+    const filePath = resolve(pendingDir, `${actionId}.json`);
+    try {
+        if (existsSync(filePath)) {
+            const archiveDir = resolve(pendingDir, "resolved");
+            if (!existsSync(archiveDir)) {
+                mkdirSync(archiveDir, { recursive: true });
+            }
+            renameSync(filePath, resolve(archiveDir, `${actionId}.json`));
+        }
+    }
+    catch (err) {
+        console.error(`[approval] Failed to archive pending action ${actionId}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+async function persistApprovalToolCall(opts) {
+    // Write doctrine: a ToolCall without its owning Conversation is
+    // noise — every admin tool call belongs to a chat. When sessionId is
+    // missing or its Conversation cannot be matched, we log and skip the
+    // persist rather than create an orphan ToolCall node. The legacy
+    // OPTIONAL-MATCH + FOREACH pattern created orphans silently.
+    if (!opts.sessionId) {
+        console.error(`[approval] ToolCall skipped (no sessionId): tool=${opts.toolName} state=${opts.approvalState}`);
+        return;
+    }
+    if (!ACCOUNT_ID) {
+        // Boot-tolerance refusal handlers gate every caller, so reaching here is
+        // a guard regression rather than a steady-state condition. Throw loud so
+        // the missing handler-level guard is identified, not silently default to
+        // empty-string accountId (which would mint orphan ToolCall nodes).
+        throw new Error(`[approval] persistApprovalToolCall reached without ACCOUNT_ID — handler guard missing for tool=${opts.toolName}`);
+    }
+    const session = getSession();
+    try {
+        const optionalFields = [
+            opts.originalInput != null ? ", originalInput: $originalInput" : "",
+        ].join("");
+        const res = await session.run(`MATCH (c:Conversation {sessionId: $sessionId})
+       CREATE (c)-[:HAS_TOOL_CALL]->(tc:ToolCall {
+         callId: $callId,
+         toolName: $toolName,
+         pluginName: $pluginName,
+         input: $input,
+         output: $output,
+         isError: $isError,
+         agentType: 'admin',
+         accountId: $accountId,
+         approvalState: $approvalState,
+         sessionId: $sessionId,
+         createdBySource: 'admin-approval',
+         startedAt: datetime($startedAt),
+         completedAt: datetime($completedAt)
+         ${optionalFields}
+       })`, {
+            callId: randomUUID(),
+            toolName: opts.toolName,
+            pluginName: opts.pluginName,
+            input: opts.input.slice(0, 300),
+            output: opts.output.slice(0, 300),
+            isError: opts.isError,
+            accountId: ACCOUNT_ID,
+            approvalState: opts.approvalState,
+            sessionId: opts.sessionId,
+            startedAt: new Date().toISOString(),
+            completedAt: new Date().toISOString(),
+            ...(opts.originalInput != null ? { originalInput: opts.originalInput.slice(0, 300) } : {}),
+        });
+        if (res.summary.counters.updates().nodesCreated === 0) {
+            console.error(`[approval] ToolCall skipped (conversation ${opts.sessionId} not found): tool=${opts.toolName}`);
+            return;
+        }
+        console.error(`[approval] ToolCall persisted: ${opts.toolName} state=${opts.approvalState}`);
+    }
+    catch (err) {
+        console.error(`[approval] ToolCall persist failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    finally {
+        await session.close();
+    }
+}
+/**
+ * Spawn a plugin MCP server and execute a tool call directly.
+ * Same pattern as workflow-execute.ts dispatchStep.
+ */
+async function dispatchApprovedAction(plugin, tool, args, timeoutMs = 30_000) {
+    const serverPath = resolve(PLATFORM_ROOT, "plugins", plugin, "mcp", "dist", "index.js");
+    // Path traversal check
+    const pluginsRoot = resolve(PLATFORM_ROOT, "plugins");
+    if (!serverPath.startsWith(pluginsRoot + "/")) {
+        throw new Error(`Invalid plugin name: "${plugin}" — path traversal blocked`);
+    }
+    if (!existsSync(serverPath)) {
+        throw new Error(`Plugin MCP server not found: ${serverPath}`);
+    }
+    const { Client } = await import("@modelcontextprotocol/sdk/client/index.js");
+    const { StdioClientTransport } = await import("@modelcontextprotocol/sdk/client/stdio.js");
+    const env = {};
+    for (const [k, v] of Object.entries(process.env)) {
+        if (v !== undefined)
+            env[k] = v;
+    }
+    env.PLATFORM_ROOT = PLATFORM_ROOT;
+    if (!ACCOUNT_ID) {
+        throw new Error("dispatchApprovedAction called without ACCOUNT_ID — handler guard missing");
+    }
+    env.ACCOUNT_ID = ACCOUNT_ID;
+    const transport = new StdioClientTransport({
+        command: process.execPath,
+        args: [serverPath],
+        env,
+        stderr: "pipe",
+    });
+    let childStderr = "";
+    const stderrStream = transport.stderr;
+    if (stderrStream) {
+        stderrStream.on("data", (chunk) => {
+            if (childStderr.length < 4096) {
+                childStderr += chunk.toString("utf-8").slice(0, 4096 - childStderr.length);
+            }
+        });
+    }
+    const client = new Client({ name: "approval-executor", version: "1.0.0" });
+    let timedOut = false;
+    const timeout = setTimeout(() => {
+        timedOut = true;
+        client.close().catch(() => { });
+    }, timeoutMs);
+    try {
+        await client.connect(transport);
+        const result = await client.callTool({ name: tool, arguments: args });
+        const contentArr = Array.isArray(result.content) ? result.content : [];
+        const text = contentArr
+            .filter((c) => c.type === "text")
+            .map((c) => c.text)
+            .join("\n");
+        return { text, isError: result.isError === true };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        const stderrSuffix = childStderr ? `\nChild stderr: ${childStderr.trim()}` : "";
+        if (timedOut) {
+            throw new Error(`Tool "${tool}" on plugin "${plugin}" timed out after ${timeoutMs}ms${stderrSuffix}`);
+        }
+        throw new Error(`Tool "${tool}" on plugin "${plugin}" failed: ${msg}${stderrSuffix}`);
+    }
+    finally {
+        clearTimeout(timeout);
+        await client.close().catch(() => { });
+    }
+}
+eagerTool(server, "action-pending", "List actions that are queued for human approval. Returns each pending action's ID, " +
+    "tool name, input summary, and when it was queued. Use this to review what the agent " +
+    "wanted to do before approving or rejecting.", {}, async () => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("action-pending");
+    const actions = readPendingActions();
+    if (actions.length === 0) {
+        return {
+            content: [{ type: "text", text: "No pending actions. All actions are either approved, rejected, or auto-executed." }],
+        };
+    }
+    const lines = actions.map((a) => {
+        const inputSummary = JSON.stringify(a.hookPayload?.tool_input ?? {}).slice(0, 200);
+        return `- **${a.actionId}** | ${a.toolName} | queued ${a.createdAt}\n  Input: ${inputSummary}`;
+    });
+    return {
+        content: [{ type: "text", text: `## Pending Actions (${actions.length})\n\n${lines.join("\n\n")}` }],
+    };
+});
+eagerTool(server, "action-approve", "Approve a pending action and execute it immediately. The original tool call is " +
+    "executed via the target plugin's MCP server. The result is returned and an audit " +
+    "record is written to Neo4j with approvalState: approved.", {
+    actionId: z.string().describe("The action ID to approve (from action-pending)"),
+    sessionId: z.string().optional().describe("Current conversation ID for audit trail linking"),
+}, async ({ actionId, sessionId }) => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("action-approve");
+    const action = readPendingAction(actionId);
+    if (!action) {
+        return {
+            content: [{ type: "text", text: `Action ${actionId} not found. It may have already been resolved or the ID is incorrect.` }],
+            isError: true,
+        };
+    }
+    if (action.state !== "pending") {
+        return {
+            content: [{ type: "text", text: `Action ${actionId} is already ${action.state}. Cannot approve a resolved action.` }],
+            isError: true,
+        };
+    }
+    if (!action.pluginName) {
+        return {
+            content: [{ type: "text", text: `Action ${actionId} has no plugin name — cannot determine which MCP server to execute.` }],
+            isError: true,
+        };
+    }
+    // Mark as approved before execution
+    if (!resolvePendingAction(actionId, "approved")) {
+        return {
+            content: [{ type: "text", text: `Failed to update action ${actionId} state. The file may have been modified concurrently.` }],
+            isError: true,
+        };
+    }
+    const toolInput = action.hookPayload?.tool_input ?? {};
+    console.error(`[approval] Executing approved action: ${action.toolName} plugin=${action.pluginName} actionId=${actionId}`);
+    try {
+        const result = await dispatchApprovedAction(action.pluginName, action.toolName, toolInput);
+        // Persist audit record
+        await persistApprovalToolCall({
+            toolName: action.toolName,
+            pluginName: action.pluginName,
+            input: JSON.stringify(toolInput),
+            output: result.text,
+            isError: result.isError,
+            approvalState: "approved",
+            sessionId,
+        });
+        cleanupPendingAction(actionId);
+        return {
+            content: [{ type: "text", text: `Action approved and executed.\n\nTool: ${action.toolName}\nResult:\n${result.text}` }],
+            isError: result.isError,
+        };
+    }
+    catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        console.error(`[approval] Execution failed for ${actionId}: ${errMsg}`);
+        await persistApprovalToolCall({
+            toolName: action.toolName,
+            pluginName: action.pluginName,
+            input: JSON.stringify(toolInput),
+            output: errMsg,
+            isError: true,
+            approvalState: "approved",
+            sessionId,
+        });
+        return {
+            content: [{ type: "text", text: `Action approved but execution failed: ${errMsg}` }],
+            isError: true,
+        };
+    }
+});
+eagerTool(server, "action-reject", "Reject a pending action. The action is not executed. An audit record is written " +
+    "to Neo4j with approvalState: rejected.", {
+    actionId: z.string().describe("The action ID to reject (from action-pending)"),
+    reason: z.string().optional().describe("Optional reason for rejection"),
+    sessionId: z.string().optional().describe("Current conversation ID for audit trail linking"),
+}, async ({ actionId, reason, sessionId }) => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("action-reject");
+    const action = readPendingAction(actionId);
+    if (!action) {
+        return {
+            content: [{ type: "text", text: `Action ${actionId} not found. It may have already been resolved or the ID is incorrect.` }],
+            isError: true,
+        };
+    }
+    if (action.state !== "pending") {
+        return {
+            content: [{ type: "text", text: `Action ${actionId} is already ${action.state}. Cannot reject a resolved action.` }],
+            isError: true,
+        };
+    }
+    if (!resolvePendingAction(actionId, "rejected")) {
+        return {
+            content: [{ type: "text", text: `Failed to update action ${actionId} state.` }],
+            isError: true,
+        };
+    }
+    const reasonSuffix = reason ? ` Reason: ${reason}` : "";
+    console.error(`[approval] Action rejected: ${action.toolName} actionId=${actionId}${reasonSuffix}`);
+    await persistApprovalToolCall({
+        toolName: action.toolName,
+        pluginName: action.pluginName ?? "unknown",
+        input: JSON.stringify(action.hookPayload?.tool_input ?? {}),
+        output: `Rejected by admin.${reasonSuffix}`,
+        isError: false,
+        approvalState: "rejected",
+        sessionId,
+    });
+    cleanupPendingAction(actionId);
+    return {
+        content: [{ type: "text", text: `Action rejected. ${action.toolName} will not be executed.${reasonSuffix}` }],
+    };
+});
+eagerTool(server, "action-edit", "Edit a pending action's input and then execute the modified version. The original " +
+    "input is preserved in the audit trail. Use this when the admin wants to modify the " +
+    "action (e.g., change the email subject) before approving.", {
+    actionId: z.string().describe("The action ID to edit (from action-pending)"),
+    editedInput: z.string().describe("The modified tool input as a JSON string"),
+    sessionId: z.string().optional().describe("Current conversation ID for audit trail linking"),
+}, async ({ actionId, editedInput, sessionId }) => {
+    if (!ACCOUNT_ID)
+        return refuseNoAccount("action-edit");
+    const action = readPendingAction(actionId);
+    if (!action) {
+        return {
+            content: [{ type: "text", text: `Action ${actionId} not found.` }],
+            isError: true,
+        };
+    }
+    if (action.state !== "pending") {
+        return {
+            content: [{ type: "text", text: `Action ${actionId} is already ${action.state}. Cannot edit a resolved action.` }],
+            isError: true,
+        };
+    }
+    if (!action.pluginName) {
+        return {
+            content: [{ type: "text", text: `Action ${actionId} has no plugin name — cannot determine which MCP server to execute.` }],
+            isError: true,
+        };
+    }
+    let parsedInput;
+    try {
+        parsedInput = JSON.parse(editedInput);
+    }
+    catch {
+        return {
+            content: [{ type: "text", text: `Invalid JSON in editedInput. Please provide valid JSON for the tool input.` }],
+            isError: true,
+        };
+    }
+    const originalInput = action.hookPayload?.tool_input ?? {};
+    // Mark as approved with the edited input
+    if (!resolvePendingAction(actionId, "approved", parsedInput)) {
+        return {
+            content: [{ type: "text", text: `Failed to update action ${actionId} state.` }],
+            isError: true,
+        };
+    }
+    console.error(`[approval] Executing edited action: ${action.toolName} plugin=${action.pluginName} actionId=${actionId}`);
+    try {
+        const result = await dispatchApprovedAction(action.pluginName, action.toolName, parsedInput);
+        await persistApprovalToolCall({
+            toolName: action.toolName,
+            pluginName: action.pluginName,
+            input: JSON.stringify(parsedInput),
+            output: result.text,
+            isError: result.isError,
+            approvalState: "approved",
+            originalInput: JSON.stringify(originalInput),
+            sessionId,
+        });
+        cleanupPendingAction(actionId);
+        return {
+            content: [{ type: "text", text: `Action edited, approved, and executed.\n\nTool: ${action.toolName}\nResult:\n${result.text}` }],
+            isError: result.isError,
+        };
+    }
+    catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        console.error(`[approval] Edited execution failed for ${actionId}: ${errMsg}`);
+        await persistApprovalToolCall({
+            toolName: action.toolName,
+            pluginName: action.pluginName,
+            input: JSON.stringify(parsedInput),
+            output: errMsg,
+            isError: true,
+            approvalState: "approved",
+            originalInput: JSON.stringify(originalInput),
+            sessionId,
+        });
+        return {
+            content: [{ type: "text", text: `Action edited and approved but execution failed: ${errMsg}` }],
+            isError: true,
+        };
+    }
+});
+// Task 619 — native-CC admin PIN identity gate. Eager-loaded so it is visible
+// from the first turn: the operator must authenticate before any other tool is
+// reachable (the PreToolUse pin-identity-gate hook enforces that; this tool is
+// the agent-callable PIN-submit surface and returns the operator's profile).
+eagerTool(server, "admin-identity-authenticate", "Authenticate the current operator by PIN. MUST be the first tool you call in a session: submit the operator's PIN to bind their identity. No other tool is reachable until this succeeds. Returns the authenticated operator's profile.", { pin: z.string().describe("The operator's PIN, exactly as they typed it.") }, async ({ pin }) => ({
+    content: [{ type: "text", text: await runAuthenticate(pin) }],
+}));
+// Cleanup on exit (SIGTERM for systemd service stops on Pi)
+const cleanup = async () => {
+    await closeDriver();
+    process.exit(0);
+};
+process.on("SIGINT", cleanup);
+process.on("SIGTERM", cleanup);
+const transport = new StdioServerTransport();
+await server.connect(transport);
+//# sourceMappingURL=index.js.map