@awesomate/hosting-mcp 0.91.1 → 0.93.0

package/dist/index.js

@@ -40082,11 +40082,23 @@ ${JSON.stringify(details, null, 2)}`;
 }
 function keyHolder(ctx) {
   const c = ctx && typeof ctx === "object" ? ctx : {};
-  const email2 = typeof c.email === "string" ? c.email : null;
+  const k = c.key && typeof c.key === "object" ? c.key : {};
+  const email2 = typeof k.email === "string" ? k.email : typeof c.email === "string" ? c.email : null;
+  if (k.holder === "person") {
+    const name = typeof k.name === "string" && k.name ? k.name : email2 ?? "a team member";
+    const level = k.level === "full" ? "full" : "view";
+    return {
+      holder: "person",
+      email: email2,
+      name,
+      level,
+      note: `This key belongs to ${name}${email2 && name !== email2 ? ` (${email2})` : ""}, a team member${level === "view" ? " with view-only access" : ""}: Claude does only what they can do in the hub, never more, and never with a shell on the hosting account. Do not offer anything their access does not include; if they ask, say the account owner can do it.`
+    };
+  }
   return {
     holder: "account_owner",
     email: email2,
-    note: `This key belongs to the account owner${email2 ? ` (${email2})` : ""}: everything Claude does with it is done as the owner. Team members cannot connect Claude Code with their own key yet.`
+    note: `This key belongs to the account owner${email2 ? ` (${email2})` : ""}: everything Claude does with it is done as the owner. Team members connect their own Claude Code, at their own access, once the owner turns it on for them.`
   };
 }
 
@@ -40735,6 +40747,21 @@ function installedSkillVersion(name) {
     return null;
   }
 }
+function compareVersions(a, b) {
+  const pa = a.split(/[.-]/).map((x) => Number.parseInt(x, 10) || 0);
+  const pb = b.split(/[.-]/).map((x) => Number.parseInt(x, 10) || 0);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (d !== 0) return d < 0 ? -1 : 1;
+  }
+  return 0;
+}
+function oldestInstalledVersion(perSkill) {
+  return perSkill.reduce(
+    (min, s) => s.installed !== null && (min === null || compareVersions(s.installed, min) < 0) ? s.installed : min,
+    null
+  );
+}
 function skillVersions(sourceRoot = DEFAULT_SOURCE_ROOT) {
   return bundledSkillNames(sourceRoot).map((name) => ({ name, installed: installedSkillVersion(name) }));
 }
@@ -40791,8 +40818,9 @@ function installSkills(version2, sourceRoot = DEFAULT_SOURCE_ROOT) {
 }
 
 // src/knowledge.ts
-function scrubKeyMaterial(text) {
-  return text.replace(/amk_[a-z]_[A-Za-z0-9]{6,}/g, "[redacted:platform-key]").replace(/amt_[a-z]+_[A-Za-z0-9]{6,}/g, "[redacted:hub-token]");
+import { createHash } from "node:crypto";
+function scrubKeyMaterial(text, opts = {}) {
+  return text.replace(/amk_([a-z])_[A-Za-z0-9]{6,}/g, (m, cls) => opts.keepWebsiteKeys && cls === "p" ? m : "[redacted:platform-key]").replace(/amt_[a-z]+_[A-Za-z0-9]{6,}/g, "[redacted:hub-token]");
 }
 var KNOWLEDGE_GATE_COPY = {
   displayName: "Knowledge Base",
@@ -40878,13 +40906,33 @@ function storageFullPayload(body) {
     note: "The Knowledge Base storage is full and the source was NOT added. Relay the message exactly as it is; offer no purchase, because none is open to this account or this person right now. Removing sources they no longer need frees space."
   };
 }
+async function deleteOrNotFound(config3, path) {
+  try {
+    return await hubDelete(config3, path) ?? { deleted: true };
+  } catch (err) {
+    if (err instanceof HubApiError && err.status === 404 && bodyOf(err)?.error === "not_found") {
+      return {
+        deleted: false,
+        not_found: true,
+        note: "Nothing with that id was there. It may already be deleted (an earlier attempt can go through even when its answer never arrives), or the id is wrong. List again to check before telling the user either way."
+      };
+    }
+    throw err;
+  }
+}
 function bodyOf(err) {
   return err.body && typeof err.body === "object" ? err.body : null;
 }
 function mapKnowledgeError(err, apiBase) {
   if (!(err instanceof HubApiError)) throw err;
   const body = bodyOf(err);
-  if (err.status === 404) return notAvailablePayload(apiBase);
+  if (err.status === 404) {
+    if (typeof body?.error !== "string" || !/^[a-z0-9_]+$/.test(body.error)) return notAvailablePayload(apiBase);
+    if (body.error === "not_found") {
+      return { error: "not_found", note: typeof body.message === "string" ? body.message : "There is no such item on this account. List again for the current ids." };
+    }
+    throw err;
+  }
   if ((err.status === 403 || err.status === 402) && body?.upgrade_required) return upsellPayload(apiBase, body.plan, body);
   if (err.status === 403 && body?.consent_required) {
     return consentPayload(typeof body.error === "string" ? body.error : 'Knowledge is not using your content: "Use your content for Knowledge" is off', apiBase);
@@ -41135,10 +41183,7 @@ async function knowledgeSources(config3, args) {
     }
     if (args.action === "remove") {
       if (!args.sourceId) throw new Error("sourceId is required for remove");
-      return await hubDelete(
-        config3,
-        `/api/knowledge/sources/${encodeURIComponent(args.sourceId)}`
-      );
+      return deleteOrNotFound(config3, `/api/knowledge/sources/${encodeURIComponent(args.sourceId)}`);
     }
     if (!args.url && !args.sitemap) {
       return {
@@ -41182,15 +41227,18 @@ function renderAnswer(meta, streamedAnswer, streamError = null) {
   const session = typeof meta.session === "string" && meta.session ? { session: meta.session } : {};
   const fallback = typeof meta.answer_plain === "string" && meta.answer_plain || typeof meta.no_answer_message === "string" && meta.no_answer_message || null;
   if (status === "error") {
+    const errorCode = typeof meta.error_code === "string" ? meta.error_code : null;
+    const ownKey = errorCode === "byok_key_invalid" || errorCode === "byok_no_credit";
     return {
       status: "error",
       answer: null,
       platform_error: true,
       not_in_verified_content: false,
+      ...errorCode ? { error_code: errorCode } : {},
       detail: streamError ?? (streamedAnswer || null),
       configured_fallback: fallback,
       ...session,
-      note: "The knowledge platform failed to answer: a service problem, NOT a content gap. Do not tell the user their content lacks this. Say the service hit a problem, retry once, and if it persists raise it via awesomate_support. configured_fallback is only what an end customer would have seen meanwhile."
+      note: ownKey ? `The agent runs on this account's own OpenRouter key, and OpenRouter ${errorCode === "byok_no_credit" ? "says it is out of credit" : "refused it"}. This is NOT a content gap. Tell the user to top up or replace the key at Settings, Integrations (hub.awesomate.ai/settings?tab=integrations), or to clear the agent's model so it runs on Awesomate's.` : "The knowledge platform failed to answer: a service problem, NOT a content gap. Do not tell the user their content lacks this. Say the service hit a problem, retry once, and if it persists raise it via awesomate_support. configured_fallback is only what an end customer would have seen meanwhile."
     };
   }
   if (status !== "ok") {
@@ -41624,6 +41672,17 @@ function mapAgentsError(err, apiBase) {
   }
   if (err instanceof HubApiError && err.status === 403) {
     const body = bodyOf(err);
+    if (body && body.error === "upgrade_required" && body.capability === "public_widget") {
+      const requiredPlan = typeof body.requiredPlan === "string" ? body.requiredPlan : "Support Plus";
+      return {
+        upgrade_required: true,
+        capability: "public_widget",
+        requiredPlan,
+        ...typeof body.message === "string" ? { message: body.message } : {},
+        billingUrl: `${apiBase}/billing?upgrade=${encodeURIComponent(requiredPlan)}`,
+        note: "Nothing was made. Relay the message as it is and let the user decide; never retry."
+      };
+    }
     if (body && body.error === "upgrade_required" && body.capability === "knowledge_questions") {
       const requiredPlan = typeof body.requiredPlan === "string" ? body.requiredPlan : "Support Plus";
       return {
@@ -41638,6 +41697,107 @@ function mapAgentsError(err, apiBase) {
   }
   return mapKnowledgeError(err, apiBase);
 }
+var WEBSITE_KEY_MAX_ORIGINS = 16;
+function websiteOrigins(input) {
+  const raw = (input ?? []).map((s) => s.trim()).filter(Boolean);
+  if (!raw.length) return { ok: false, error: "website_key needs origins: the website addresses the chat will run on, like https://example.com.au" };
+  const out = [];
+  for (const r of raw) {
+    if (r.includes("*")) return { ok: false, error: `"${r}": a wildcard is not allowed, because the key would then answer on any website.` };
+    let u;
+    try {
+      u = new URL(r.includes("://") ? r : `https://${r}`);
+    } catch {
+      return { ok: false, error: `"${r}" is not a website address.` };
+    }
+    if (u.protocol !== "https:") return { ok: false, error: `"${r}" must be an https:// address.` };
+    if (u.username || u.password) return { ok: false, error: `"${r}" must not include a username or password.` };
+    if (u.pathname !== "/" || u.search || u.hash) return { ok: false, error: `"${r}" should be just the site address, without a path, for example ${u.origin}` };
+    if (!out.includes(u.origin)) out.push(u.origin);
+  }
+  if (out.length > WEBSITE_KEY_MAX_ORIGINS) return { ok: false, error: `At most ${WEBSITE_KEY_MAX_ORIGINS} websites per key.` };
+  return { ok: true, origins: out };
+}
+var htmlAttr = (v) => v.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+function websiteSnippet(widgetUrl, key, agentId, title) {
+  const attrs = [["data-key", key], ["data-agent", agentId]];
+  if (title?.trim()) attrs.push(["data-title", title.trim()]);
+  const lines = attrs.map(([k, v], i) => `        ${k}="${htmlAttr(v)}"${i === attrs.length - 1 ? "></script>" : ""}`);
+  return [`<script src="${htmlAttr(widgetUrl)}"`, ...lines].join("\n");
+}
+function websiteKeyRequestId(agentId, origins, label, cap, liveKeyIds) {
+  const h = createHash("sha256").update(`${agentId}|${[...origins].sort().join(",")}|${label}|${cap ?? "default"}|${[...liveKeyIds].sort().join(",")}`).digest("hex");
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-4${h.slice(13, 16)}-8${h.slice(17, 20)}-${h.slice(20, 32)}`;
+}
+function liveWebsiteKeys(keys, agentId) {
+  const now = Date.now();
+  return keys.filter(
+    (k) => k.class === "p" && (!agentId || k.agent_id === agentId) && !k.revoked_at && !(typeof k.expires_at === "string" && new Date(k.expires_at).getTime() <= now)
+  );
+}
+function websiteAgentRefusal(agent) {
+  const name = typeof agent.name === "string" && agent.name ? `"${agent.name}"` : "This agent";
+  if (agent.status !== "published") return `${name} is not published yet, so a website chat would have nothing to answer with. Test it, then publish it (with the user's yes) first.`;
+  if (agent.audience !== "public") return `${name} serves a ${typeof agent.audience === "string" ? agent.audience : "private"} audience, and a website chat answers the public. Change its audience to public and publish again (with the user's yes) first.`;
+  if (agent.suspended_at) return `${name} is paused, so a website chat would not answer. Resume it (with the user's yes) first.`;
+  return null;
+}
+var WEBSITE_KEY_NOTE = "A website key is meant to sit in page source: it only answers from the websites listed, only as this agent, and only from sources marked public. It carries its own monthly answer cap (by default half the account's answers), so one busy site cannot use up every answer.";
+async function websiteKeyAction(config3, args) {
+  const base = "/api/knowledge/agents";
+  if (args.action === "website_keys") {
+    const r = await hubGet(config3, `${base}/keys`);
+    return { keys: liveWebsiteKeys(r.keys ?? [], args.agentId), note: `${WEBSITE_KEY_NOTE} The key itself is shown only once, when it is made; it cannot be read back.` };
+  }
+  if (args.action === "revoke_website_key") {
+    if (!args.keyId) return { error: "invalid_request", note: "revoke_website_key needs keyId (from website_keys)." };
+    const r = await hubGet(config3, `${base}/keys`);
+    if (!liveWebsiteKeys(r.keys ?? []).some((k) => k.key_id === args.keyId)) {
+      return { error: "not_found", note: "There is no working website key with that id. Read website_keys for the ids; other kinds of key are managed in the hub only." };
+    }
+    if (args.confirm !== true) {
+      return { error: "confirmation_required", note: "Revoking this key stops the chat on every website using it at once. Tell the owner, and call again with confirm:true only after they say yes." };
+    }
+    return deleteOrNotFound(config3, `${base}/keys/${encodeURIComponent(args.keyId)}`);
+  }
+  if (!args.agentId) return { error: "invalid_request", note: "website_key needs agentId (from list) and origins." };
+  const origins = websiteOrigins(args.origins);
+  if (!origins.ok) return { error: "invalid_request", note: `${origins.error} Nothing was made.` };
+  const agent = agentOf(await hubGet(config3, `${base}/${encodeURIComponent(args.agentId)}`));
+  const notReady = websiteAgentRefusal(agent);
+  if (notReady) return { error: "agent_not_ready", note: `${notReady} Nothing was made.` };
+  if (args.confirm !== true) {
+    return {
+      error: "confirmation_required",
+      note: `Making a website key puts this agent on ${origins.origins.join(", ")}, where anyone visiting can ask it questions, and those answers count against the account's monthly answers. Tell the owner that, and call again with confirm:true only after they say yes.`
+    };
+  }
+  const status = await hubGet(config3, "/api/knowledge/status");
+  const widgetUrl = typeof status.widget_url === "string" && status.widget_url ? status.widget_url : null;
+  if (!widgetUrl) return { error: "widget_unavailable", note: "This hub has no website chat loader configured, so a key would have nowhere to run. Nothing was made; tell the user to contact Awesomate support." };
+  const listed = await hubGet(config3, `${base}/keys`);
+  const liveIds = liveWebsiteKeys(listed.keys ?? [], args.agentId).map((k) => String(k.key_id));
+  const label = (args.label?.trim() || `website: ${origins.origins.map((o) => o.replace(/^https:\/\//, "")).join(", ")}`).slice(0, 120);
+  const minted = await hubPost(config3, `${base}/keys`, {
+    class: "p",
+    agent_id: args.agentId,
+    allowed_origins: origins.origins,
+    label,
+    request_id: websiteKeyRequestId(args.agentId, origins.origins, label, args.monthlyAnswerCap, liveIds),
+    ...args.monthlyAnswerCap !== void 0 ? { monthly_answer_cap: args.monthlyAnswerCap } : {}
+  });
+  const key = typeof minted.key === "string" ? minted.key : "";
+  const title = args.title?.trim() || (typeof agent.name === "string" ? agent.name : "");
+  const cap = typeof minted.monthly_answer_cap === "number" ? minted.monthly_answer_cap : null;
+  return {
+    key_id: minted.key_id ?? null,
+    key,
+    allowed_origins: origins.origins,
+    monthly_answer_cap: cap,
+    snippet: key ? websiteSnippet(widgetUrl, key, args.agentId, title) : null,
+    note: `${WEBSITE_KEY_NOTE} The key is shown ONCE: hand the snippet straight to the user to paste before </body> on those sites (or add it to the site for them), and do not repeat the key anywhere else.` + (cap !== null ? ` Tell the user this key has its own limit of ${cap} answers a month. A key's limit cannot be changed once it is made: to change it, make a new key with monthlyAnswerCap, swap the snippet on the site, then revoke this one.` : "")
+  };
+}
 var VISITOR_TEST_MAX_CHARS = 2e3;
 var POLICY_TAGS_MAX = 50;
 function policyScope(args) {
@@ -41656,6 +41816,9 @@ var POLICY_NOTE = "An access policy narrows what a key or a signed-in person may
 async function knowledgeAgents(config3, args) {
   try {
     const base = "/api/knowledge/agents";
+    if (args.action === "website_key" || args.action === "website_keys" || args.action === "revoke_website_key") {
+      return await websiteKeyAction(config3, args);
+    }
     if (args.action === "logs") {
       const q2 = new URLSearchParams();
       if (args.agentId) q2.set("agent_id", args.agentId);
@@ -41733,19 +41896,20 @@ async function knowledgeAgents(config3, args) {
         const current = scope && typeof scope === "object" && !Array.isArray(scope) ? scope : {};
         return touchesScope(scopeArgs) ? { scope: agentPatchBody(scopeArgs, current).scope } : scope !== void 0 ? { scope } : {};
       };
+      const callerFields = agentPatchBody({ ...args, collectionIds: void 0, kinds: void 0, sourceIds: void 0 });
       let created;
       let sentScope;
       let extra = {};
       if (args.goal) {
         const draft = await hubPost(config3, "/api/knowledge/agents/draft", { goal: args.goal });
         if (!draft.proposal) return { error: "draft_failed", detail: draft };
-        const body = { ...draft.proposal, ...withScope(draft.proposal.scope), ...args.audience ? { audience: args.audience } : {} };
+        const body = { ...draft.proposal, ...callerFields, ...withScope(draft.proposal.scope) };
         sentScope = body.scope;
         created = await hubPost(config3, "/api/knowledge/agents", body);
         extra = { test_questions: draft.test_questions ?? [], status_note: `Created as a private DRAFT serving audience '${args.audience ?? "private"}': test it, then publish when the user approves.` };
       } else {
         if (!args.name) return { error: "name (or goal) is required for create" };
-        const body = { name: args.name, ...args.audience ? { audience: args.audience } : {}, ...withScope(void 0) };
+        const body = { ...callerFields, name: args.name, ...withScope(void 0) };
         sentScope = body.scope;
         created = await hubPost(config3, "/api/knowledge/agents", body);
       }
@@ -41844,7 +42008,7 @@ async function knowledgeCollections(config3, args) {
       return await hubPatch(config3, `/api/knowledge/collections/${encodeURIComponent(args.collectionId)}`, body);
     }
     if (args.action === "delete") {
-      return await hubDelete(config3, `/api/knowledge/collections/${encodeURIComponent(args.collectionId)}`);
+      return deleteOrNotFound(config3, `/api/knowledge/collections/${encodeURIComponent(args.collectionId)}`);
     }
     if (!args.sourceIds?.length) return { error: "invalid_request", note: `${args.action} needs sourceIds` };
     return await hubPost(config3, `/api/knowledge/collections/${encodeURIComponent(args.collectionId)}/sources`, {
@@ -42123,10 +42287,7 @@ function changelogSince(installed) {
 function skillUpdateInfo() {
   const perSkill = skillVersions();
   const staleSkills = perSkill.filter((s) => s.installed !== SERVER_VERSION).map((s) => s.name);
-  const oldest = perSkill.reduce(
-    (min, s) => s.installed !== null && (min === null || s.installed < min) ? s.installed : min,
-    null
-  );
+  const oldest = oldestInstalledVersion(perSkill);
   const updateAvailable = perSkill.length === 0 || staleSkills.length > 0;
   return {
     serverVersion: SERVER_VERSION,
@@ -42388,7 +42549,7 @@ server.registerTool(
   "awesomate_get_context",
   {
     annotations: annotate("awesomate_get_context", READ_ONLY),
-    description: "THE session entry point: call it FIRST, before any domain context. Returns the connected account: plan, capabilities, limits, scopes, token expiry, cPanel routing, PLUS `key` (whose key this is: always the account owner's today, so everything done with it is done as the owner; say so if the user is not the owner; team members cannot connect Claude Code with their own key yet; a tool the key's scopes do not cover answers at once with the hub's own refusal), PLUS `attention` ({unreadNotifications, erroringWorkflows7d, patExpiresInDays}: null means unknown, never zero; when something is non-zero, mention it to the user in one line before starting the asked task), `features` ({key: {available, reason, message}}: what this account has; never offer one whose available is false, say its message instead), `latestMcpVersion` (if serverVersion still lags it after a restart, the npx cache is stale; remedy: rm -rf ~/.npm/_npx, then restart), and `skill` ({updateAvailable, staleSkills, whatsNew}: if updateAvailable, mention ONCE with a whatsNew line, offer awesomate_skill_update, never mid-task). If the token is near expiry (patExpiresInDays < 7), re-running Connect Claude Code from hub.awesomate.ai/claude refreshes skills AND renews the token in one go.",
+    description: "THE session entry point: call it FIRST, before any domain context. Returns the connected account: plan, capabilities, limits, scopes, token expiry, cPanel routing, PLUS `key` (whose key this is: the account owner's, so everything is done as the owner, or a team member's own (`holder: 'person'`), which does only what that person can do in the hub and never has a shell: say whose it is, and never offer work outside a person's access; a tool the key's scopes do not cover answers at once with the hub's own refusal), PLUS `attention` ({unreadNotifications, erroringWorkflows7d, patExpiresInDays}: null means unknown, never zero; when something is non-zero, mention it to the user in one line before starting the asked task), `features` ({key: {available, reason, message}}: what this account has; never offer one whose available is false, say its message instead), `latestMcpVersion` (if serverVersion still lags it after a restart, the npx cache is stale; remedy: rm -rf ~/.npm/_npx, then restart), and `skill` ({updateAvailable, staleSkills, whatsNew}: if updateAvailable, mention ONCE with a whatsNew line, offer awesomate_skill_update, never mid-task). If the token is near expiry (patExpiresInDays < 7), re-running Connect Claude Code from hub.awesomate.ai/claude refreshes skills AND renews the token in one go.",
     inputSchema: {}
   },
   async () => {
@@ -43079,7 +43240,7 @@ server.registerTool(
   "awesomate_site_staging_promote",
   {
     annotations: annotate("awesomate_site_staging_promote", DESTRUCTIVE),
-    description: "Publish the staging copy to the LIVE site (overwrites live files + database with staging). The live site is auto-snapshotted first \u2014 the result includes preSnapshotId, which awesomate_rollback_site can restore if anything looks wrong. **Confirm with the user before promoting \u2014 it replaces the live site.** Requires shell access (Support Plus+).",
+    description: "Publish the staging copy to the LIVE site (overwrites live files + database with staging). The live site is auto-snapshotted first: the result includes preSnapshotId, which awesomate_rollback_site can restore if anything looks wrong. The live site keeps its own search engine visibility (staging is always hidden from search engines; that setting is not copied to live); if searchEngineVisibility.warning is present, live may now be hidden from search engines, so relay it to the user. **Confirm with the user before promoting: it replaces the live site.** Requires shell access (Support Plus+).",
     inputSchema: {
       domain: external_exports.string().describe("The LIVE site domain whose staging copy should go live")
     }
@@ -43414,13 +43575,13 @@ server.registerTool(
     }
   }
 );
-function knowledgeResult(data) {
+function knowledgeResult(data, opts = {}) {
   return {
     content: [
       {
         type: "text",
         text: `${accountStamp()}
-${scrubKeyMaterial(JSON.stringify(data, null, 2))}`
+${scrubKeyMaterial(JSON.stringify(data, null, 2), opts)}`
       }
     ]
   };
@@ -43452,7 +43613,7 @@ server.registerTool(
   "awesomate_knowledge_provision",
   {
     annotations: annotate("awesomate_knowledge_provision", MUTATING),
-    description: `Enable the Knowledge Base for this account (creates their isolated tenant on the Awesomate knowledge platform and wires the n8n credential). Idempotent \u2014 safe to re-call; a pending:true response means provisioning continues in the background: poll awesomate_knowledge_status. consent_required \u2192 send the user to Settings \u2192 Features (hub.awesomate.ai/settings?tab=features): under the Knowledge row, the second line "Use your content for Knowledge". Switching on Knowledge itself is NOT the consent. They must switch it themselves; re-check, then retry. upgrade_required \u2192 relay the upsell, don't retry. Get the user's explicit go-ahead before enabling.`,
+    description: `Enable the Knowledge Base for this account (creates their isolated tenant on the Awesomate knowledge platform and wires the n8n credential). Idempotent: safe to re-call, and the account owner re-calling on an active account puts back a missing "Awesomate Knowledge Base" n8n credential. The response's credential is {status, verified?, reason?}: created / exists are fine; adopted with verified:false means an existing credential was kept and its key may be stale (tell the user to rotate the Knowledge key); skipped or failed carries the reason (for example no n8n API key stored, so the user connects n8n first); a pending:true response means provisioning continues in the background: poll awesomate_knowledge_status. consent_required \u2192 send the user to Settings \u2192 Features (hub.awesomate.ai/settings?tab=features): under the Knowledge row, the second line "Use your content for Knowledge". Switching on Knowledge itself is NOT the consent. They must switch it themselves; re-check, then retry. upgrade_required \u2192 relay the upsell, don't retry. Get the user's explicit go-ahead before enabling.`,
     inputSchema: {}
   },
   async () => {
@@ -43552,7 +43713,7 @@ server.registerTool(
         author: external_exports.array(external_exports.string().max(200)).max(10).optional(),
         year: external_exports.array(external_exports.string().regex(/^\d{4}$/)).max(10).optional(),
         doc: external_exports.array(external_exports.string().max(200)).max(50).optional().describe("doc_ids from search hits")
-      }).optional().describe("Ask within a slice of the library: EXACTLY the awesomate_knowledge_search input shapes, reusable verbatim; filters only ever narrow")
+      }).optional().describe("Ask within a slice of the library: EXACTLY the awesomate_knowledge_search input shapes, reusable verbatim; filters only ever narrow. A filtered question is answered by the workspace's 'knowledge' agent (the default agent takes no filters), so its tone can differ from an unfiltered one")
     }
   },
   async ({ question, session, filters }) => {
@@ -43595,7 +43756,7 @@ server.registerTool(
   "awesomate_knowledge_agents",
   {
     annotations: annotate("awesomate_knowledge_agents", MUTATING),
-    description: "The agent builder (multi-agent; the older awesomate_knowledge_agent tool is the single workspace default). action 'list': every agent with status (draft/published vN/suspended). 'get' {agentId}: full config incl. system message and scope. 'create' {goal}: AI drafts the whole setup (instructions, scope, tone, test questions) from the account's own content and saves it as a PRIVATE DRAFT (never live, nothing lost); or {name} for a blank draft. The drafted scope is often too wide: it can come back limited to no collection (so it answers from every business's and every audience's content) or limited to kinds that leave out PDFs (stored as 'book'), FAQs ('faq') or images. Pass collectionIds (and kinds if needed) WITH create to scope it in one step; when the account has collections and the new agent reads none of them, or its kinds skip content the library holds, the result carries a warning listing the collections: fix it with update before testing or publishing. 'update' {agentId, ...fields}: edit the DRAFT config: name, description, systemMessage, noAnswerMessage, grounding, audience, collectionIds (scope to collections from awesomate_knowledge_collections), kinds, sourceIds, maxSources, temperature. Nothing changes for callers until 'publish'. 'test' {agentId, message, sessionId?}: chat with the DRAFT config: free, unmetered, the right way to check wording and scope before going live. WARNING: the draft test ignores the agent's audience, so it is NOT what the public sees for anything touching internal or private sources (seen live: a public-audience draft quoted an internal staff handbook's door code and Wi-Fi password, which the published agent correctly refused a visitor). 'visitor_test' {agentId, message (max 2000 chars), sessionId?}: ask the PUBLISHED agent through the real public visitor path, the only way to check what a website visitor actually gets; run it after publishing whenever the agent is public-facing or its scope includes internal/private sources. It needs the plan the public widget ships with (upgrade_required below it: relay, never retry), and a question it cannot answer lands in the owner's Questions inbox like a real visitor's, so say so before using it. 'publish' {agentId}: makes the draft LIVE immediately for every key bound to the agent: get the user's explicit approval first, and read the version back. 'suspend' / 'resume' {agentId}: stop the agent answering on every key bound to it, or start it again (its last published version); both change what live callers get at once, so get the owner's explicit approval first. 'delete' {agentId, confirm:true}: removes the agent for good and every key bound to it stops answering; tell the owner that and pass confirm:true only after they say yes. 'logs' {agentId?, since?, until?, endpoint?, status?, limit?, cursor?}: the request log (each call to the agents: when, which endpoint, its status), newest first. 'answer_rates' {days? 1-92, default 30}: how each agent is answering, in bands, counts only. 'where_used': each agent with its audience, scope and status, to see which agent a website or automation is using. 'ai_key_status': whether the account has its own AI key saved (names and dates, never a key); saving or removing one is the owner's, in the hub at Settings, Integrations. 'models': the models the account's own AI key can use. Access policies (customer groups): 'policies' lists them; 'policy_get' {policyId}; 'policy_create' {name, description?, collectionIds?|kinds?|sourceIds?|tags?}: a policy named segment:all or segment:<group> is what an agent's customer groups use, so a person in that group answers only from what it allows; 'policy_update' {policyId, name?|description?|scope fields} (a scope REPLACES the stored one); 'policy_delete', 'policy_suspend', 'policy_resume' {policyId}. Every policy change applies to live callers at once: show the owner what changes and get a yes first. API keys are shown once in the hub (Knowledge, Agents) and never pass through this tool.",
+    description: "The agent builder (multi-agent; the older awesomate_knowledge_agent tool is the single workspace default). action 'list': every agent with status (draft/published vN/suspended). 'get' {agentId}: full config incl. system message and scope. 'create' {goal}: AI drafts the whole setup (instructions, scope, tone, test questions) from the account's own content and saves it as a PRIVATE DRAFT (never live, nothing lost); or {name} for a blank draft. The drafted scope is often too wide: it can come back limited to no collection (so it answers from every business's and every audience's content) or limited to kinds that leave out PDFs (stored as 'book'), FAQs ('faq') or images. Pass collectionIds (and kinds if needed) WITH create to scope it in one step; when the account has collections and the new agent reads none of them, or its kinds skip content the library holds, the result carries a warning listing the collections: fix it with update before testing or publishing. 'update' {agentId, ...fields}: edit the DRAFT config: name, description, systemMessage, noAnswerMessage, grounding, audience, collectionIds (scope to collections from awesomate_knowledge_collections), kinds, sourceIds, maxSources, temperature. Nothing changes for callers until 'publish'. 'test' {agentId, message, sessionId?}: chat with the DRAFT config: free, unmetered, the right way to check wording and scope before going live. WARNING: the draft test ignores the agent's audience, so it is NOT what the public sees for anything touching internal or private sources (seen live: a public-audience draft quoted an internal staff handbook's door code and Wi-Fi password, which the published agent correctly refused a visitor). 'visitor_test' {agentId, message (max 2000 chars), sessionId?}: ask the PUBLISHED agent through the real public visitor path, the only way to check what a website visitor actually gets; run it after publishing whenever the agent is public-facing or its scope includes internal/private sources. It needs the plan the public widget ships with (upgrade_required below it: relay, never retry), and a question it cannot answer lands in the owner's Questions inbox like a real visitor's, so say so before using it. 'publish' {agentId}: makes the draft LIVE immediately for every key bound to the agent: get the user's explicit approval first, and read the version back. 'suspend' / 'resume' {agentId}: stop the agent answering on every key bound to it, or start it again (its last published version); both change what live callers get at once, so get the owner's explicit approval first. 'delete' {agentId, confirm:true}: removes the agent for good and every key bound to it stops answering; tell the owner that and pass confirm:true only after they say yes. 'logs' {agentId?, since?, until?, endpoint?, status?, limit?, cursor?}: the request log (each call to the agents: when, which endpoint, its status), newest first. 'answer_rates' {days? 1-92, default 30}: how each agent is answering, in bands, counts only. 'where_used': each agent with its audience, scope and status, to see which agent a website or automation is using. 'ai_key_status': whether the account has its own AI key saved (names and dates, never a key); saving or removing one is the owner's, in the hub at Settings, Integrations. 'models': the models the account's own AI key can use. Access policies (customer groups): 'policies' lists them; 'policy_get' {policyId}; 'policy_create' {name, description?, collectionIds?|kinds?|sourceIds?|tags?}: a policy named segment:all or segment:<group> is what an agent's customer groups use, so a person in that group answers only from what it allows; 'policy_update' {policyId, name?|description?|scope fields} (a scope REPLACES the stored one); 'policy_delete', 'policy_suspend', 'policy_resume' {policyId}. Every policy change applies to live callers at once: show the owner what changes and get a yes first. Website chat (owner only; Support Plus and above, upgrade_required below it: relay it, never retry): 'website_keys' {agentId?}: the working website keys (no key text: a key is shown once, when made). 'website_key' {agentId, origins, title?, label?, monthlyAnswerCap?, confirm:true}: makes a website key for a PUBLISHED, public-audience agent (refused otherwise, with what to do first) and returns it ONCE with the ready <script> snippet to paste before </body>; anyone on those sites can then ask the agent, and answers count against the account's monthly answers. Each key has its own monthly answer limit (by default half the account's at the time it is made), returned as monthly_answer_cap: tell the user the number. A key's limit cannot be changed later; a different limit is a new key, then revoke the old one. Ask the owner which sites, say what it means, and pass confirm:true only after they say yes. 'revoke_website_key' {keyId, confirm:true}: stops the chat on every site using that key at once; ask first. Other keys (for automations and servers) are made in the hub (Knowledge, Agents) and never pass through this tool.",
     inputSchema: {
       action: external_exports.enum([
         "list",
@@ -43619,9 +43780,17 @@ server.registerTool(
         "policy_update",
         "policy_delete",
         "policy_suspend",
-        "policy_resume"
+        "policy_resume",
+        "website_key",
+        "website_keys",
+        "revoke_website_key"
       ]),
-      confirm: external_exports.boolean().optional().describe("delete: true only after the owner said yes to deleting this agent"),
+      confirm: external_exports.boolean().optional().describe("delete, website_key, revoke_website_key: true only after the owner said yes"),
+      origins: external_exports.array(external_exports.string().max(200)).max(16).optional().describe("website_key: the websites the chat runs on, https://host only (no path, no wildcard), e.g. https://example.com.au and https://www.example.com.au"),
+      title: external_exports.string().max(60).optional().describe("website_key: the chat window's title in the snippet (data-title); defaults to the agent's name"),
+      label: external_exports.string().max(120).optional().describe("website_key: a name for the key in key lists"),
+      monthlyAnswerCap: external_exports.number().int().min(1).optional().describe("website_key: this key's own monthly answer cap; leave it out for half the account's monthly answers"),
+      keyId: external_exports.string().max(128).optional().describe("revoke_website_key: key_id from website_keys"),
       since: external_exports.string().max(40).optional().describe("logs: ISO time to read from"),
       until: external_exports.string().max(40).optional().describe("logs: ISO time to read to"),
       endpoint: external_exports.string().max(200).optional().describe("logs: only calls to this endpoint, e.g. /v1/answer"),
@@ -43635,22 +43804,22 @@ server.registerTool(
       name: external_exports.string().max(120).optional().describe("create: blank draft with this name (max 80); update: rename; policy_create/update: the policy name, e.g. segment:members"),
       goal: external_exports.string().max(2e3).optional().describe("create: describe the agent and AI drafts it from the account content"),
       audience: external_exports.enum(["private", "internal", "public"]).optional().describe("create/update: who the agent serves: 'public' for anything customers or a website will talk to (it then answers from sources marked public ONLY), 'internal' for the team, 'private' (default) for the owner's own tools. Widening later is a publish, so choose now."),
-      description: external_exports.string().max(300).optional().describe("update: one-line description shown in the hub; policy_create/update: what the policy is for"),
-      systemMessage: external_exports.string().max(8e3).optional().describe("update: the agent instructions (system message)"),
-      noAnswerMessage: external_exports.string().max(500).optional().describe("update: what the agent says when the grounding gate declines to answer"),
-      grounding: external_exports.enum(["strict", "grounded_chat"]).optional().describe("update: 'strict' refuses anything not in the retrieved content (use it for anything customer-facing); 'grounded_chat' may add general knowledge around the cited content"),
+      description: external_exports.string().max(300).optional().describe("create/update: one-line description shown in the hub; policy_create/update: what the policy is for"),
+      systemMessage: external_exports.string().max(8e3).optional().describe("create/update: the agent instructions (system message); with goal, it replaces the drafted ones"),
+      noAnswerMessage: external_exports.string().max(500).optional().describe("create/update: what the agent says when the grounding gate declines to answer"),
+      grounding: external_exports.enum(["strict", "grounded_chat"]).optional().describe("create/update: 'strict' refuses anything not in the retrieved content (use it for anything customer-facing); 'grounded_chat' may add general knowledge around the cited content"),
       collectionIds: external_exports.array(external_exports.string().max(64)).max(16).optional().describe("create/update: scope the agent to these collections (collection_id from awesomate_knowledge_collections list); replaces the collection scope only, other scope fields and free-form tags are kept. policy_create/update: the collections the policy allows"),
       kinds: external_exports.array(external_exports.string().max(40)).max(16).optional().describe("create/update: restrict retrieval to source kinds (web, document, video, audio, image, book, faq, dataset; PDFs are stored as 'book'); omit for all kinds. policy_create/update: the kinds the policy allows"),
       sourceIds: external_exports.array(external_exports.string().max(200)).max(500).optional().describe("create/update, policy_create/update: pin the scope to specific sources"),
-      maxSources: external_exports.number().int().min(1).max(10).optional().describe("update: how many sources one answer may cite (1-10)"),
-      temperature: external_exports.number().min(0).max(1).optional().describe("update: 0 is the most literal"),
+      maxSources: external_exports.number().int().min(1).max(10).optional().describe("create/update: how many sources one answer may cite (1-10)"),
+      temperature: external_exports.number().min(0).max(1).optional().describe("create/update: 0 is the most literal"),
       message: external_exports.string().max(4e3).optional().describe("test: the question to ask the draft; visitor_test: the question a visitor asks the published agent (max 2000 characters)"),
       sessionId: external_exports.string().max(128).optional().describe("test/visitor_test: keep follow-ups in one thread")
     }
   },
   async (args) => {
     try {
-      return knowledgeResult(await knowledgeAgents(requireConfig(), args));
+      return knowledgeResult(await knowledgeAgents(requireConfig(), args), { keepWebsiteKeys: args.action === "website_key" });
     } catch (err) {
       return knowledgeError(err);
     }
@@ -43793,7 +43962,7 @@ server.registerTool(
   "awesomate_knowledge_data",
   {
     annotations: annotate("awesomate_knowledge_data", MUTATING),
-    description: "The knowledge platform's business-data warehouse (every plan, within the plan's row and dataset limits). action 'metrics': headline numbers for the data tab. 'datasets': the datasets imported and their columns: read this FIRST, measures/dimensions must name real columns. 'imports': import job statuses. 'query' {dataset, measures:[{column, agg}], plus optional dimensions/filters passed through}: answer QUANTITATIVE questions from the user's own imported business data (revenue by month, top customers); read-only, results come back as rows to present honestly. 'dataset' {datasetId}: one dataset with its columns and how each is read. 'dataset_update' {datasetId, name?, description?, columns?:[{column_id, name?, semantic_type?, role?, unit?, currency?, canonical_metric_key?, pii?}]}: rename it or settle how its columns are read (show the owner the change first). 'import' {importId}: one import, with any questions it is waiting on. 'import_action' {importId, importAction: approve|reject|withdraw|reimport|answer, answers?}: approve lets a waiting import in, reject turns one away, withdraw takes an import that is already in back out again (confirm:true, after the owner says yes), reimport runs it again, answer {answers: {question key: answer}} replies to its questions. Every import_action changes the owner's numbers: say what it does and get a yes first. New data is imported in the hub UI, not here.",
+    description: "The knowledge platform's business-data warehouse (every plan, within the plan's row and dataset limits). action 'metrics': headline numbers for the data tab. 'datasets': the datasets imported (names and ids, no columns): read this FIRST, then 'dataset' {datasetId} for a dataset's columns, because measures/dimensions must name real columns. 'imports': import job statuses. 'query' {dataset, measures:[{column, agg}], plus optional dimensions/filters passed through}: answer QUANTITATIVE questions from the user's own imported business data (revenue by month, top customers); read-only, results come back as rows to present honestly. 'dataset' {datasetId}: one dataset with its columns and how each is read. 'dataset_update' {datasetId, name?, description?, columns?:[{column_id, name?, semantic_type?, role?, unit?, currency?, canonical_metric_key?, pii?}]}: rename it or settle how its columns are read (show the owner the change first). 'import' {importId}: one import, with any questions it is waiting on. 'import_action' {importId, importAction: approve|reject|withdraw|reimport|answer, answers?}: approve lets a waiting import in, reject turns one away, withdraw takes an import that is already in back out again (confirm:true, after the owner says yes), reimport runs it again, answer {answers: {question key: answer}} replies to its questions. Every import_action changes the owner's numbers: say what it does and get a yes first. New data is imported in the hub UI, not here.",
     inputSchema: {
       action: external_exports.enum(["metrics", "datasets", "imports", "query", "dataset", "dataset_update", "import", "import_action"]),
       datasetId: external_exports.string().max(200).optional().describe("dataset, dataset_update: the dataset id from datasets"),
@@ -45286,19 +45455,25 @@ server.registerTool(
   "awesomate_knowledge_upload",
   {
     annotations: annotate("awesomate_knowledge_upload", MUTATING),
-    description: "Ingest ONE file from the user's own computer into their Knowledge Base. Pass a LOCAL PATH \u2014 this server runs on their machine and streams the file to the hub itself, so the file contents never pass through the conversation. Handles documents (pdf, md, txt), spreadsheets (csv, tsv, xls, xlsx, xlsm, json; these NEED kind, see below), audio and video (transcribed, Pro and above), and images (OCR, Pro and above). Word/PowerPoint/RTF/EPUB files are NOT parseable yet \u2014 the tool refuses them with the workaround (export to PDF, or save as .md/.txt). Max 100 MB per file; bigger media goes through the hub's Knowledge \u2192 Sources page. SPREADSHEETS: pass kind, or the tool refuses before uploading. kind 'sheet' makes each row a searchable, citable record: price lists, fee tables, timetables, FAQs, policies, product lists, anything a customer asks about. kind 'data-import' builds a reportable dataset for totals and trends: job or invoice history, sales by month, read with awesomate_knowledge_data. If it is not obvious which the user wants, ask them; never guess. The same goes for a spreadsheet in the File Manager (fromFilesPath): pass kind with it. The source's title comes from the filename, slugified (spaces, punctuation and non-ASCII letters become _), even when title is passed; fix it afterwards with awesomate_knowledge_sources {action:'rename'}. INGESTING COSTS MONEY and counts against the monthly allowance, so ALWAYS get explicit approval for the specific file(s) first and say what it will consume. For several files, call once per file and report progress \u2014 do not loop silently. Returns a job with its live status; poll awesomate_knowledge_sources {action:'jobs'} until it succeeds (a duplicate upload replays the earlier job \u2014 a response already reading succeeded needs no polling), then probe the content with awesomate_knowledge_ask before building anything on it. A pack_required response means the allowance is exhausted: nothing was ingested and nothing was purchased.",
+    description: "Ingest ONE file from the user's own computer into their Knowledge Base. Pass a LOCAL PATH: this server runs on their machine and streams the file to the hub itself, so the file contents never pass through the conversation. Handles documents (pdf, md, txt), spreadsheets (csv, tsv, xls, xlsx, xlsm, json; these NEED kind, see below), audio and video (transcribed, Pro and above), and images (OCR, Pro and above). Word/PowerPoint/RTF/EPUB files are NOT parseable yet: the tool refuses them with the workaround (export to PDF, or save as .md/.txt). Max 100 MB per file; bigger media goes through the hub's Knowledge \u2192 Sources page. SPREADSHEETS: pass kind, or the tool refuses before uploading. kind 'sheet' makes each row a searchable, citable record: price lists, fee tables, timetables, FAQs, policies, product lists, anything a customer asks about. kind 'data-import' builds a reportable dataset for totals and trends: job or invoice history, sales by month, read with awesomate_knowledge_data. If it is not obvious which the user wants, ask them; never guess. The same goes for a spreadsheet in the File Manager (fromFilesPath): pass kind with it. The source's title comes from the filename, slugified (spaces, punctuation and non-ASCII letters become _), even when title is passed; fix it afterwards with awesomate_knowledge_sources {action:'rename'}. visibility 'public' publishes the file, so it needs confirm: the account slug, passed only after the user agreed in so many words (the same rule as awesomate_knowledge_sources add). INGESTING COSTS MONEY and counts against the monthly allowance, so ALWAYS get explicit approval for the specific file(s) first and say what it will consume. For several files, call once per file and report progress; do not loop silently. Returns a job with its live status; poll awesomate_knowledge_sources {action:'jobs'} until it succeeds (a duplicate upload replays the earlier job, and a response already reading succeeded needs no polling), then probe the content with awesomate_knowledge_ask before building anything on it. A pack_required response means the allowance is exhausted: nothing was ingested and nothing was purchased.",
     inputSchema: {
       path: external_exports.string().min(1).max(4096).optional().describe("Path to the file on the user's machine (~ is expanded). Omit when using fromFilesPath."),
       fromFilesPath: external_exports.string().max(1024).optional().describe("Instead of a local file: a path in the account's File Manager (their n8n file system), relative to files/, e.g. 'public/reports/weekly.md'. The hub streams it from their storage \u2014 nothing leaves this machine."),
       title: external_exports.string().max(300).optional().describe("Used as the uploaded file's name (local uploads only). The platform slugifies it (spaces, punctuation and non-ASCII letters become _), so for a readable title rename the source after the job succeeds"),
       kind: external_exports.enum(["sheet", "data-import"]).optional().describe("Spreadsheets only (csv, tsv, xls, xlsx, xlsm, json), and required for them: 'sheet' = each row a searchable, citable record (price lists, timetables, fee tables, FAQs); 'data-import' = a reportable dataset for totals and trends (job or invoice history). Ask the user if unclear; never guess"),
-      visibility: external_exports.enum(["private", "internal", "public"]).optional().describe("Who may retrieve this source (default private). public = customers and public chatbots; irreversible once fetched \u2014 ask first."),
+      visibility: external_exports.enum(["private", "internal", "public"]).optional().describe("Who may retrieve this source (default private). public = customers and public chatbots; irreversible once fetched, so it also needs confirm."),
+      confirm: external_exports.string().max(64).optional().describe("visibility 'public' only: the account slug, after the user agreed in so many words"),
       tags: external_exports.array(external_exports.string().max(64)).max(64).optional().describe("Free-form tags for the new source"),
       collectionIds: external_exports.array(external_exports.string().max(64)).max(16).optional().describe("Put the new source in these collections (awesomate_knowledge_collections list)")
     }
   },
-  async ({ path: rawPath, fromFilesPath, title, kind, visibility, tags, collectionIds }) => {
+  async ({ path: rawPath, fromFilesPath, title, kind, visibility, confirm, tags, collectionIds }) => {
     try {
+      if (visibility === "public" && !confirm) {
+        return errorResult(
+          new Error("Adding a file as public cannot be undone once it has been fetched or crawled. Ask the user in plain words, then call again with confirm: the account slug. Nothing was uploaded.")
+        );
+      }
       if (fromFilesPath) {
         const dot = fromFilesPath.lastIndexOf(".");
         const filesExt = dot > fromFilesPath.lastIndexOf("/") ? fromFilesPath.slice(dot).toLowerCase() : "";
@@ -45313,6 +45488,7 @@ server.registerTool(
           path: fromFilesPath,
           ...kind ? { kind } : {},
           ...visibility ? { visibility } : {},
+          ...visibility === "public" && confirm ? { confirm } : {},
           ...tags?.length ? { tags } : {},
           ...collectionIds?.length ? { collection_ids: collectionIds } : {}
         });
@@ -45367,6 +45543,7 @@ server.registerTool(
       const filename = title?.trim() ? `${title.trim()}${ext}` : basename(abs);
       const uploadQuery = new URLSearchParams();
       if (visibility) uploadQuery.set("visibility", visibility);
+      if (visibility === "public" && confirm) uploadQuery.set("confirm", confirm);
       if (kind) uploadQuery.set("kind", kind);
       for (const t of tags ?? []) uploadQuery.append("tags", t);
       for (const c of collectionIds ?? []) uploadQuery.append("collection_ids", c);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awesomate/hosting-mcp",
-  "version": "0.91.1",
+  "version": "0.93.0",
   "description": "Awesomate MCP server — lets Claude manage your Awesomate WordPress hosting, plan, limits, n8n automations, and build Node/static apps + databases",
   "license": "UNLICENSED",
   "type": "module",

package/skill/CHANGELOG.json

@@ -1,5 +1,35 @@
 {
   "versions": [
+    {
+      "version": "0.93.0",
+      "highlights": [
+        "Claude can put a published agent on your website: it makes a website key for the sites you name, after your yes, and hands you the code to paste. Each website key has its own monthly answer limit, half your account's by default, and Claude tells you the number",
+        "Uploading a file as public now needs the same typed confirmation as adding a public page",
+        "A delete that finds nothing says the item may already be gone or the id may be wrong, and a delete that timed out says it may have gone through instead of saying nothing changed",
+        "Asking within filters works with the workspace's default agent, and a new agent drafted from a goal keeps the name you gave it",
+        "Skill update checks compare version numbers properly (0.10 is newer than 0.9)",
+        "When a Knowledge agent fails because the account's own OpenRouter key is refused or out of credit, Claude says so and where to fix it, instead of a generic service problem"
+      ]
+    },
+    {
+      "version": "0.92.2",
+      "highlights": [
+        "Publishing a staging copy keeps the live site's search engine setting, instead of hiding the live site from Google like the staging copy, and says so if it could not"
+      ]
+    },
+    {
+      "version": "0.92.1",
+      "highlights": [
+        "Turning on Knowledge again now puts back a missing n8n credential for it, and says why when it cannot (for example, n8n is not connected yet)"
+      ]
+    },
+    {
+      "version": "0.92.0",
+      "highlights": [
+        "Claude says whose key it is: the account owner's, or a team member's own, which does only what that person can do",
+        "Connecting on a computer already connected to the same account as someone else stops and asks, instead of replacing their key"
+      ]
+    },
     {
       "version": "0.91.1",
       "highlights": [

package/skill/awesomate-hosting/SKILL.md

@@ -40,6 +40,7 @@ before any work** — every tool response is stamped `account: <slug> (source:
 once (plus `awesomate_get_limits` before any create/change) and cache:
 
 - **`plan`** and **`capabilities.shell`** — decides which branch below you're on.
+- **`key`**: whose key this is. When `key.holder` is `person`, say so first ("This is Mia's own Claude Code, with view-only access") and never offer work their access does not include; if they ask for it, say the account owner can do it. A person's key never has a shell.
 - **`attention`** — `{unreadNotifications, erroringWorkflows7d, patExpiresInDays}`.
   If it shows erroring workflows or unread notifications, say so in ONE line
   ("two of your automations failed this week — want me to look?") before the
@@ -230,7 +231,7 @@ MCP, so say that rather than stopping.
 | Tool | Reach for it when |
 |---|---|
 | `awesomate_whoami` | First call of every session — which account this folder acts on (zero network) |
-| `awesomate_get_context` | Session start: plan, capabilities, PAT expiry, `attention`, skill updates, and `key`: whose key this is (always the account owner's today, so everything is done as the owner; team members cannot connect their own yet). A tool the key's scopes do not cover is refused at once in the hub's words: relay it, never retry |
+| `awesomate_get_context` | Session start: plan, capabilities, PAT expiry, `attention`, skill updates, and `key`: whose key this is (the account owner's, so everything is done as the owner, or a team member's own, `holder: 'person'`, which does only what they can do in the hub). A tool the key's scopes do not cover is refused at once in the hub's words: relay it, never retry |
 | `awesomate_get_limits` | Before any create/change — live plan limits + workflow/AI-editor credit balances |
 | `awesomate_get_plan_features` | The live plan ladder, so upgrade talk is accurate |
 | `awesomate_business` | Before writing anything in the business's name: its own name, services, voice, colours, contact details. `read:'documents'` / `read:'document'` for the brand guide, voice guide and business summary; `read:'suggestions'` for details awaiting the owner's yes |
@@ -462,7 +463,10 @@ AI crawlers — anyone with the link can view, perfect for client review).
   `--domain <staging domain>`), send the user the staging URL to review.
 - `awesomate_site_staging_promote <live domain>` — publishes staging over live.
   Live is auto-snapshotted first; report the returned `preSnapshotId` as the
-  undo handle (`awesomate_rollback_site`). **Confirm before promoting.**
+  undo handle (`awesomate_rollback_site`). Live keeps its own search engine
+  setting; if the result carries `searchEngineVisibility.warning`, tell the
+  user live may now be hidden from search engines and how to check.
+  **Confirm before promoting.**
 - `awesomate_site_staging_discard <live domain>` — deletes the staging copy;
   live untouched. **Confirm — unpublished staging changes are lost.**
 

package/skill/awesomate-hosting/references/connect-troubleshooting.md

@@ -25,6 +25,14 @@ The bootstrap prints a final `AWESOMATE CONNECT: SUCCESS account=<slug>` (or
 silence. `PARTIAL` means the token/pin are stored but a step (listed in
 `issues=`) needs the printed manual fix.
 
+`FAILED reason=profile-belongs-to-someone-else` means this computer is already
+connected to the same account as a different person (an owner and a team member
+sharing a computer). Nothing was saved. Ask the person at the computer which key
+should stay; re-run with `--replace` only on their clear yes, never on your own.
+Otherwise they connect from their own user account on the computer. The key made
+by the refused run is unused: they can remove it in the hub at Settings,
+Account, Your Claude Code.
+
 ## Sandboxed / ephemeral environments (cloud agent containers)
 
 - **Egress proxy**: if `HTTPS_PROXY`/`HTTP_PROXY` is set, the environment

package/skill/awesomate-hosting/scripts/bootstrap.mjs

@@ -11,7 +11,7 @@
  * access token itself is never printed.
  *
  * Usage (Claude runs this — the user doesn't touch a terminal):
- *   node bootstrap.mjs --code amt_bs_XXXX [--account <slug>] [--pin-dir <dir>]
+ *   node bootstrap.mjs --code amt_bs_XXXX [--account <slug>] [--pin-dir <dir>] [--replace]
  *   node bootstrap.mjs --pat amt_pat_XXXX [--account <slug>]   # resume: skip redeem
  *
  * --account asserts WHICH account this connect is for — mismatch aborts before
@@ -472,6 +472,7 @@ async function main() {
       shellAccess: Boolean(ctx.capabilities?.shell),
       cpanel: ctx.cpanel ?? null,
       expiresAt: ctx.patExpiresAt ?? null,
+      ...(ctx.key?.holder === 'person' ? { keyKind: 'person_device' } : {}),
     };
   } else {
     console.log(`Redeeming setup code against ${apiBase} …`);
@@ -514,6 +515,21 @@ async function main() {
     redeemed.email = redeemed.email ?? context?.email ?? null;
   }
 
+  // One computer, two people (per-person keys design §6.1): never silently swap whose key this
+  // account uses here. An owner and a team member on a shared computer each keep their own.
+  const saved = readJsonFile(credPath) ?? {};
+  const before = (saved.profiles ?? {})[slug] ?? (saved.slug === slug ? saved : null);
+  const beforeEmail = typeof before?.email === 'string' ? before.email.trim().toLowerCase() : null;
+  const newEmail = typeof redeemed.email === 'string' ? redeemed.email.trim().toLowerCase() : null;
+  const replacing = Boolean(beforeEmail && newEmail && beforeEmail !== newEmail);
+  if (replacing && !process.argv.includes('--replace')) {
+    console.error(`This computer is already connected to "${slug}" as ${beforeEmail}. Connecting as ${newEmail} would replace that key here.`);
+    console.error('Ask the person at this computer which key should stay. Only on their clear yes, run the same command again with --replace; otherwise connect from your own user account on this computer.');
+    console.error(`The new key for ${newEmail} was made but not saved here. If it will not be used, remove it in the hub: Settings, Account, Your Claude Code.`);
+    console.error('AWESOMATE CONNECT: FAILED reason=profile-belongs-to-someone-else');
+    process.exit(1);
+  }
+
   const profile = {
     apiBase,
     pat: redeemed.pat,
@@ -523,6 +539,8 @@ async function main() {
     plan: redeemed.plan,
     cpanel: redeemed.cpanel ?? null,
     expiresAt: redeemed.expiresAt ?? null,
+    // Someone else's SSH key never carries over to this person's profile.
+    ...(replacing ? { ssh: undefined } : {}),
   };
   mergeProfile(profile);
   console.log(`✓ Access token stored as profile "${slug}" in ${credPath} (chmod 600). Plan: ${redeemed.plan}.`);
@@ -571,6 +589,8 @@ async function main() {
         console.log('  Everything else is set up. This usually means hosting isn\'t fully provisioned — contact Awesomate support, then ask me to "retry SSH setup".');
       }
     }
+  } else if (redeemed.keyKind === 'person_device') {
+    console.log('• This is your own key: it does what you can do in the hub. SSH and deploys stay with the account owner.');
   } else {
     console.log('• Plan has no shell access — read/status mode. Upgrade to Support Plus for SSH + deploy.');
   }

package/skill/awesomate-knowledge/SKILL.md

@@ -164,6 +164,7 @@ confirm:true}`, both after the owner's yes.
 | Agent builder (what `awesomate_knowledge_agents` calls) | `GET\|POST /api/knowledge/agents` · `GET\|PATCH\|DELETE /api/knowledge/agents/:agent_id` · `POST /api/knowledge/agents/:agent_id/{publish,suspend,resume}` · `GET /api/knowledge/agents/{logs,answer-rates,where-used}` · `GET\|POST /api/knowledge/agents/policies` · `GET\|PATCH\|DELETE /api/knowledge/agents/policies/:policy_id` · `POST /api/knowledge/agents/policies/:policy_id/{suspend,resume}` |
 | **Test a DRAFT agent** (`action:'test'`) | `POST /api/knowledge/agents/:agent_id/chat` `{message, session_id?}`. There is **no** `/test` endpoint — guessing one returns 404. It ignores the agent's audience. |
 | **Ask the PUBLISHED agent as a visitor** (`action:'visitor_test'`) | `POST /api/knowledge/agents/:agent_id/visitor-chat` `{message (max 2000), session_id?}`. 403 `upgrade_required` below the public-widget plan; an unanswered question lands in the Questions inbox. |
+| **Website chat key** (`action:'website_key'`, `website_keys`, `revoke_website_key`; owner only, Support Plus and above) | `POST /api/knowledge/agents/keys` `{class:'p', agent_id, allowed_origins (https only, no path or wildcard), label?, request_id?, monthly_answer_cap?}` returns the key ONCE with its `monthly_answer_cap`; with no cap the hub sets half the account's monthly answers at that moment, and a key's cap cannot be changed later (a new limit is a new key). The tool refuses an agent that is not published, not public-audience, or paused. List with `GET /api/knowledge/agents/keys` (class `p`), revoke with `DELETE /api/knowledge/agents/keys/:key_id`. Every one only after the owner's yes. |
 | Entity layer probe (`available` false = not enabled yet, stop) | `GET /api/knowledge/entities` |
 | People list / detail | `GET /api/knowledge/people?status=named\|unknown\|hidden\|all` · `GET /api/knowledge/people/:id` — returns `{people, next_cursor}` and **no `counts` key**. |
 | Entity COUNTS + availability | `GET /api/knowledge/entities` → `{available, counts: {...}}` — counts are nested under `counts`. Reading `people.counts?.x ?? 0` prints a confident row of zeros next to data that plainly exists. |

package/skill/awesomate-onebrain/SKILL.md

@@ -260,8 +260,8 @@ while 1Brain is on.
   person's Task goes too), or move one on an older course to the role's
   current course (progress is read again from the new course). Each only on
   the owner's yes.
-- **`my_onboarding`**: the plans of the person this key belongs to, which
-  today is always the account owner.
+- **`my_onboarding`**: the plans of the person this key belongs to: the
+  account owner, or a team member on their own key.
 - Writing quizzes and acknowledgements, and sharing a course with a learner,
   are 1Brain's own connector's work (2d), owners and admins only.