@getnoan/wizard 0.1.5 → 0.1.7

package/README.md

@@ -8,13 +8,14 @@ npx -y @getnoan/wizard@latest
 
 It takes your NOAN API key, points your coding assistants at the NOAN MCP server, installs the
 NOAN skill, checks whether your fact layer has anything in it, and, if you want, sets up the six
-open-source agents on your own GitHub account. Then it tells you what it did and what to do next.
+open-source agents on your own GitHub account and gets the two web agents — booking pages and a
+site chat — ready to deploy. Then it tells you what it did and what to do next.
 Run it again any time; every write is a merge, and nothing you have is overwritten.
 
 ## What it does
 
-1. **Your key.** Create one at app.getnoan.com → Settings → API → New key and paste it in (it is
-   not echoed). The wizard checks it with `GET /me`, writes it to `.env` as `NOAN_API_KEY` and
+1. **Your key.** Create your own at app.getnoan.com → Settings → API → New key and paste it in (it is
+   not echoed). This is *your* key, for you and your coding assistant. The wizard checks it with `GET /me`, writes it to `.env` as `NOAN_API_KEY` and
    `NOAN_PERSONAL_API_KEY`, and makes sure `.env` is gitignored. Already have `NOAN_API_KEY` in
    your environment? It uses that and never asks.
 2. **Your coding assistants.** Whatever is installed gets the MCP address `https://mcp.getnoan.com/mcp`
@@ -30,8 +31,18 @@ Run it again any time; every write is a merge, and nothing you have is overwritt
 4. **Your fact layer.** If the workspace holds fewer than ten facts, the wizard does not guess
    facts for you. It hands the seeding to your assistant, which has the procedure from the skill:
    read your website, repo and docs, propose a structure, and write only after you say yes.
-5. **The agent pack** (optional, `--agents`). Asks what to call your agent — Verity by default, the
-   name she answers to in NOAN — then forks [getnoan/agent-pack](https://github.com/getnoan/agent-pack)
+5. **The agent pack** (optional, `--agents`). The agents should run as **NOAN's agent identity**,
+   not as you: an Owner creates it once under Settings → Team → Agent, and mints its keys under
+   Settings → API → Agent API Keys. The wizard asks for that agent key (or takes `--agent-key` /
+   `NOAN_AGENT_API_KEY`) and checks it is the agent's. The agents then run on it, answer to the
+   agent's id (`AGENT_IDENTITY_IDS`), and take direction from you (`COMMANDERS`). Work they hand
+   back to a person (the weekly fact review, parked tasks, support follow-ups) goes to you: the
+   `PARK_ASSIGNEES_*`, `FACT_ALIGNMENT_REVIEW_ASSIGNEES`, `REPLY_HUMAN_ASSIGNEES` and
+   `HUMAN_IDENTITIES` variables, which a re-run keeps if you have since changed them. Your own key stays
+   for seeding and your assistant. Skip it and the agents run as you; the wizard warns that your own
+   task comments will then read as the agent's, so steer them by email.
+
+   It asks what to call your agent — Verity by default — then forks [getnoan/agent-pack](https://github.com/getnoan/agent-pack)
    to your account, verifies and stores your model and Resend keys (and optionally a Postgres URL
    and a Firecrawl key) as repository secrets, runs the pack's seed scripts so each agent's starting
    instructions are in your workspace, records the name and the block slugs as repository variables,
@@ -41,7 +52,21 @@ Run it again any time; every write is a merge, and nothing you have is overwritt
    running — `https://openrouter.ai/api`, say, or your own gateway — and the wizard verifies your key
    against *that* endpoint, stores it as `LLM_API_KEY`, and records the endpoint as a repository
    variable so the fork actually uses it. Unset, nothing changes: it asks for an Anthropic key.
-6. **The report.** What happened, and the one thing to do next.
+6. **The web agents** (optional, `--meetings`, `--chat`). Two agents run as always-on services on
+   your own domain rather than as scheduled jobs, so they live in their own repos:
+   [Verity Meetings](https://github.com/getnoan/verity-meetings) (booking pages) and
+   [Verity Chat](https://github.com/getnoan/verity-chat) (a chat widget for your website). For each
+   one you pick, the wizard forks the repo to your account, runs its seed scripts so its starting
+   instructions are in your workspace (in a stack of their own, apart from any other agent's), boots
+   it locally with no keys to prove it works, and writes a gitignored `.env` in the clone with the
+   block slugs. Deploying needs accounts only you can create — a host, a Supabase project, and for
+   Meetings, Google Calendar credentials — so the report hands your assistant the rest of the repo's
+   `INSTALL.md` and a one-click Render deploy link.
+
+   Your personal NOAN key is **not** written into either service's `.env`: these answer the open
+   internet, so each gets a NOAN key made for it alone, minted under your NOAN agent
+   (Settings → API → Agent API Keys). The report says so.
+7. **The report.** What happened, and the one thing to do next.
 
 ## For a coding assistant
 
@@ -55,7 +80,9 @@ NOAN_API_KEY=npak_… npx -y @getnoan/wizard@latest --yes --json
 (progress goes to stderr) with a `next` list an agent can act on, including the first-connect
 hand-off when the workspace is empty. `--agents` adds the pack step; it reads `ANTHROPIC_API_KEY`,
 `RESEND_API_KEY`, `DATABASE_URL`, `FIRECRAWL_API_KEY`, `MAIL_FROM`, `REPLY_TO` and `ESCALATE_TO`
-from the environment and skips what is missing, saying so.
+from the environment and skips what is missing, saying so. `--meetings` and `--chat` add the web
+agents; the chat reads its model key from the same variables as the pack (or reuses the pack
+step's in the same run), and a `next` item per service carries the deploy hand-off.
 
 Exit codes: 0 done, 2 the key did not work, 3 cancelled, 1 anything else.
 
@@ -66,9 +93,12 @@ Exit codes: 0 done, 2 the key did not work, 3 cancelled, 1 anything else.
 | `-y`, `--yes` | non-interactive |
 | `--json` | machine-readable report (implies `--yes`) |
 | `--api-key <key>` | the NOAN key (else `NOAN_API_KEY`, else a prompt) |
+| `--agent-key <key>` | an agent-owned NOAN key the agent pack runs on (else `NOAN_AGENT_API_KEY`, else a prompt) |
 | `--global` | user-scope client config instead of project scope |
 | `--dir <path>` | the project directory (default: current) |
 | `--agents` / `--no-agents` | include or skip the agent pack step |
+| `--meetings` / `--no-meetings` | include or skip Verity Meetings (booking pages) |
+| `--chat` / `--no-chat` | include or skip Verity Chat (a chat widget for your site) |
 | `--no-mcp`, `--no-skill` | skip a step |
 | `--dry-run` | show every write without making it |
 | `--no-telemetry` | send nothing about this run (also `NOAN_WIZARD_NO_TELEMETRY`, `DO_NOT_TRACK`, or any `CI`) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getnoan/wizard",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "One command from nothing to a grounded agent: sign in to NOAN, wire your coding assistant, install the skill, and set up the agent pack.",
   "license": "MIT",
   "type": "module",

package/src/agents.mjs

@@ -35,7 +35,8 @@ export function parseSeedOutput(text) {
  *  name for the model key and one of the two is required. It is listed so a caller enumerating
  *  the pack's secrets knows the name exists, not so anyone sets both. */
 export const PACK_SECRETS = ["NOAN_PERSONAL_API_KEY", "RESEND_API_KEY", "ANTHROPIC_API_KEY", "LLM_API_KEY", "DATABASE_URL", "FIRECRAWL_API_KEY", "NEWSLETTER_UNSUB_SECRET"];
-export const PACK_VARS = ["MAIL_FROM", "REPLY_TO", "ESCALATE_TO", "STATE_BACKEND", "ANTHROPIC_BASE_URL", "AGENT_NAME", "COMPANY_NAME", "AGENT_IDENTITY_IDS", "COMMANDERS", "REPORT_RECIPIENT_TAG"];
+export const PACK_VARS = ["MAIL_FROM", "REPLY_TO", "ESCALATE_TO", "STATE_BACKEND", "ANTHROPIC_BASE_URL", "AGENT_NAME", "COMPANY_NAME", "AGENT_IDENTITY_IDS", "COMMANDERS", "REPORT_RECIPIENT_TAG",
+                          "FACT_ALIGNMENT_REVIEW_ASSIGNEES", "PARK_ASSIGNEES_CS", "PARK_ASSIGNEES_SALES", "PARK_ASSIGNEES_ENG", "REPLY_HUMAN_ASSIGNEES", "HUMAN_IDENTITIES"];
 
 /** The pack's model endpoint, from the same variable the pack itself reads. Bare base, no
  *  trailing slash; empty string means the default vendor.
@@ -122,6 +123,13 @@ export function setSecret(dest, name, value, dryRun) {
   const r = spawnSync("gh", ["secret", "set", name], { cwd: dest, input: value, encoding: "utf8" });
   return { name, action: r.status === 0 ? "set" : "failed", error: r.status === 0 ? undefined : (r.stderr || "").trim().split("\n")[0] };
 }
+/** The repository variables already set on the fork, by name. A list that cannot be read is
+ *  empty: the defaults are then written, and the gh failure shows on the set that follows. */
+export function existingVariables(dest, dryRun) {
+  if (dryRun) return new Set();
+  const r = spawnSync("gh", ["variable", "list", "--json", "name", "-q", ".[].name"], { cwd: dest, encoding: "utf8" });
+  return new Set(r.status === 0 ? r.stdout.split("\n").map(s => s.trim()).filter(Boolean) : []);
+}
 export function setVariable(dest, name, value, dryRun) {
   if (dryRun) return { name, action: "would set" };
   const r = spawnSync("gh", ["variable", "set", name, "--body", value], { cwd: dest, encoding: "utf8" });

package/src/args.mjs

@@ -11,16 +11,22 @@ What it does, in order:
   4. Workspace checks whether your fact layer has anything in it; if not, hands the
                seeding to your assistant (it has the procedure) rather than guessing
   5. Agents    optionally sets up the open-source agent pack on your GitHub account
-  6. Report    says what it did, and what to do next
+  6. Web       optionally forks Verity Meetings (booking pages) and Verity Chat (a chat
+               widget for your site), seeds their facts, proves each boots locally, and
+               hands the deploy to your assistant
+  7. Report    says what it did, and what to do next
 
 Options:
   -y, --yes            non-interactive: take every default, never prompt (for an agent mid-session)
   --json               machine-readable report on stdout (implies --yes)
   --api-key <key>      the NOAN key (else NOAN_API_KEY / NOAN_PERSONAL_API_KEY, else a prompt)
+  --agent-key <key>    an agent-owned NOAN key the agent pack runs on (else NOAN_AGENT_API_KEY, else a prompt)
   --global             write user-scope client config (~/.claude.json, ~/.cursor/mcp.json, ...)
                        instead of project scope (.mcp.json, .cursor/mcp.json, .vscode/mcp.json)
   --dir <path>         the project directory (default: the current directory)
   --agents             also set up the agent pack (default: ask; with --yes: skip unless given)
+  --meetings           also set up Verity Meetings, booking pages on your own domain (same default)
+  --chat               also set up Verity Chat, a chat widget for your website (same default)
   --no-mcp             skip the client wiring
   --no-skill           skip the skill install
   --dry-run            show every write without making it
@@ -32,7 +38,7 @@ Exit codes: 0 done · 2 the key did not work · 3 cancelled · 1 anything else
 `;
 
 export function parseArgs(argv) {
-  const a = { yes: false, json: false, apiKey: null, global: false, dir: process.cwd(), agents: null,
+  const a = { yes: false, json: false, apiKey: null, agentKey: null, global: false, dir: process.cwd(), agents: null, meetings: null, chat: null,
               mcp: true, skill: true, dryRun: false, telemetry: true, help: false, version: false, unknown: [] };
   for (let i = 0; i < argv.length; i++) {
     const t = argv[i];
@@ -41,11 +47,17 @@ export function parseArgs(argv) {
     else if (t === "--json") { a.json = true; a.yes = true; }
     else if (t === "--api-key") a.apiKey = next();
     else if (t.startsWith("--api-key=")) a.apiKey = t.slice(10);
+    else if (t === "--agent-key") a.agentKey = next();
+    else if (t.startsWith("--agent-key=")) a.agentKey = t.slice(12);
     else if (t === "--global") a.global = true;
     else if (t === "--dir") a.dir = next();
     else if (t.startsWith("--dir=")) a.dir = t.slice(6);
     else if (t === "--agents") a.agents = true;
     else if (t === "--no-agents") a.agents = false;
+    else if (t === "--meetings") a.meetings = true;
+    else if (t === "--no-meetings") a.meetings = false;
+    else if (t === "--chat") a.chat = true;
+    else if (t === "--no-chat") a.chat = false;
     else if (t === "--no-mcp") a.mcp = false;
     else if (t === "--no-skill") a.skill = false;
     else if (t === "--dry-run") a.dryRun = true;

package/src/clients.mjs

@@ -29,7 +29,10 @@ export function mergeJsonServer(existing, container, entry) {
 export function mergeToml(text, table, lines) {
   const block = `[${table}]\n${lines.join("\n")}\n`;
   const src = text || "";
-  const rx = new RegExp(`^\\[${table.replace(/\./g, "\\.")}\\]\\n(?:(?!\\[)[^\\n]*\\n?)*`, "m");
+  // Escape every regex metacharacter, not only the dot: the table name is ours today, but a
+  // partial escape is exactly what CodeQL js/incomplete-sanitization flags, and it is one line.
+  const esc = table.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const rx = new RegExp(`^\\[${esc}\\]\\n(?:(?!\\[)[^\\n]*\\n?)*`, "m");
   if (rx.test(src)) {
     const cur = src.match(rx)[0];
     if (cur.trim() === block.trim()) return { text: src, action: "unchanged" };

package/src/noan.mjs

@@ -3,6 +3,8 @@ export const API = "https://api.getnoan.com/v1";
 export const MCP_URL = "https://mcp.getnoan.com/mcp";
 export const APP_URL = "https://app.getnoan.com";
 export const KEY_PAGE_HINT = "app.getnoan.com → Settings → API → New key";
+/** Where an AGENT-owned key is minted: NOAN's agent identity (role bot), created by an Owner. */
+export const AGENT_KEY_PAGE_HINT = "app.getnoan.com → Settings → API → Agent API Keys";
 
 export function looksLikeKey(k) { return typeof k === "string" && /^npak_[A-Za-z0-9_-]{16,}$/.test(k.trim()); }
 
@@ -20,6 +22,72 @@ export async function whoAmI(key) {
   return { ok: true, project: body.project, identity: body.identity };
 }
 
+/** The pack's variables naming who gets work an agent hands back: identity ids, comma-separated.
+ *  HUMAN_IDENTITIES (email=id pairs) is the sixth, set alongside these. */
+export const HAND_BACK_ASSIGNEE_VARS = ["FACT_ALIGNMENT_REVIEW_ASSIGNEES", "PARK_ASSIGNEES_CS", "PARK_ASSIGNEES_SALES", "PARK_ASSIGNEES_ENG", "REPLY_HUMAN_ASSIGNEES"];
+
+/** Is this /me identity NOAN's agent? Its role is "bot" (and the API gives it no email). */
+export function isAgentIdentity(identity) {
+  return identity?.role === "bot";
+}
+
+/**
+ * Who the agents run as, and who steers them, from GET /me on the keys the user gave.
+ *
+ * NOAN has an agent role: one agent identity per workspace (role bot, no login), which an Owner
+ * creates under Settings → Team → Agent; its keys are minted under Settings → API → Agent API Keys. Its id is what the agents answer to
+ * (AGENT_IDENTITY_IDS: tasks assigned to it trigger them, comments by it are the agent's own).
+ * The people who steer and approve (COMMANDERS) are humans, never the agent.
+ *
+ * Deriving both from one key's /me was wrong either way: a person's key made the person "the
+ * agent", so every comment they wrote was classed as the agent's own and ignored; an agent key
+ * made the agent the only commander, and the agent has no email to be one.
+ *
+ *   person  GET /me of the user's own key (step 1), when it is a person
+ *   agent   GET /me of an agent-owned key, when one was given (or step 1's, if that was the agent)
+ *   commanders  extra addresses (COMMANDERS env or a prompt), comma-separated
+ *
+ * Returns the ids/addresses to configure, which key the agents should run on ("agent" or
+ * "person"), who gets the work the agents hand back (handBack), and the warnings to say out loud.
+ *
+ * handBack matters only under the agent role. On a person's key the pack falls back to that
+ * person (fact alignment's review) or to nobody (parks never read GET /me); on the agent's key
+ * every fallback is deliberately refused, because handing work to the key's owner would hand it
+ * to the agent. So with no hand-back settings an agent-key install files its weekly review, its
+ * parked tasks and its support follow-ups with no person on them, and nothing errors. The person
+ * who ran the wizard is the default owner of all of it. On a person's key handBack stays empty:
+ * that person IS the agent there (AGENT_IDENTITY_IDS), so assigning them would hand the work
+ * straight back to the agents.
+ */
+export function agentRoles({ person = null, agent = null, commanders = "" } = {}) {
+  const warnings = [];
+  const agentId = agent && isAgentIdentity(agent) ? agent.id : null;
+  const humans = new Set(String(commanders || "").split(",").map(s => s.trim().toLowerCase()).filter(Boolean));
+  if (person && !isAgentIdentity(person) && person.email) humans.add(String(person.email).toLowerCase());
+  const out = { agentIds: agentId, commanders: [...humans].join(","), runAs: agentId ? "agent" : "person", warnings };
+  if (!agentId) {
+    // No agent identity: keep the old single-account setup, but say what it costs.
+    out.agentIds = person?.id || null;
+    warnings.push(
+      "No agent key, so the agents run as you and answer to your own account. Every comment you write on a task " +
+      "will read as the agent's own, so steer and approve by email, not task comments. To fix it, create the agent " +
+      `(${AGENT_KEY_PAGE_HINT}) and re-run with --agent-key.`);
+  }
+  if (!out.commanders) warnings.push("No commander: nobody can steer or approve the agents until COMMANDERS lists a person's email.");
+  out.handBack = {};
+  if (out.runAs === "agent") {
+    const human = person && !isAgentIdentity(person) && person.id ? person : null;
+    if (human) {
+      for (const n of HAND_BACK_ASSIGNEE_VARS) out.handBack[n] = human.id;
+      if (human.email) out.handBack.HUMAN_IDENTITIES = `${String(human.email).toLowerCase()}=${human.id}`;
+    } else warnings.push(
+      "No person's key, so the work the agents hand back (the weekly fact review, parked tasks, support follow-ups) " +
+      `has nobody to go to. Set ${HAND_BACK_ASSIGNEE_VARS.join(", ")} on the fork to a person's NOAN identity id ` +
+      "(GET /me with their key), or re-run with your own key first and the agent key as --agent-key.");
+  }
+  return out;
+}
+
 /** How many facts the workspace holds — the signal for "empty, hand the seeding over". */
 export async function factCount(key) {
   const { status, body } = await get("/facts?per_page=1", key);

package/src/report.mjs

@@ -15,6 +15,13 @@ export function renderReport(report, { json = false } = {}) {
   if (s.skill?.rows) L.push(`skill: ${s.skill.rows.map(r => `${r.id} (${r.written} written)`).join(" · ")}; pointers: ${s.skill.pointers.map(p => p.action).join(", ")}`);
   if (s.workspace) L.push(`facts: ${s.workspace.count ?? "?"} (${s.workspace.state})`);
   if (s.agents && !s.agents.skipped) L.push(s.agents.ok ? `agents: ${s.agents.repo || s.agents.dest} — ${s.agents.agentName || "your agent"}, ${s.agents.secrets.length} secrets, ${s.agents.variables.length} variables, safe mode on` : `agents: not set up (${s.agents.reason})`);
+  if (s.web && !s.web.skipped) for (const [id, w] of Object.entries(s.web)) {
+    if (!w.ok) { L.push(`${id}: not set up (${w.reason})`); continue; }
+    if (report.dryRun) { L.push(`${id}: would fork to ${w.dest}, run ${w.seeds.length} seed(s), boot it locally and write its .env${w.missing?.length ? ` (still needs ${w.missing.join(", ")})` : ""}`); continue; }
+    const seeded = w.seeds.filter(r => r.action === "ran").length;
+    const local = w.local?.ok ? "boots locally" : w.local?.ok === false ? `local boot failed (${w.local.reason})` : "local boot not tried";
+    L.push(`${id}: ${w.repo || w.dest} — ${seeded}/${w.seeds.length} seeds ran, ${local}, .env written${w.missing?.length ? ` (still needs ${w.missing.join(", ")})` : ""}${w.deployUrl ? `, deploy: ${w.deployUrl}` : ""}`);
+  }
   if (report.next?.length) { L.push("", "──────── next ────────"); for (const n of report.next) L.push(`• ${n.say}${n.why ? `  (${n.why})` : ""}`); }
   L.push("");
   return L.join("\n");

package/src/run.mjs

@@ -2,11 +2,12 @@
 import { existsSync } from "node:fs";
 import path from "node:path";
 import { makeUI } from "./ui.mjs";
-import { whoAmI, factCount, classifyWorkspace, looksLikeKey, APP_URL, KEY_PAGE_HINT, MCP_URL } from "./noan.mjs";
+import { whoAmI, factCount, classifyWorkspace, looksLikeKey, APP_URL, KEY_PAGE_HINT, MCP_URL, isAgentIdentity, agentRoles, AGENT_KEY_PAGE_HINT } from "./noan.mjs";
 import { writeEnv, ensureGitignored } from "./env-file.mjs";
 import { wireClients, MANUAL_CLIENTS } from "./clients.mjs";
 import { fetchSkillFiles, skillTargets, installSkill, writePointers } from "./skill.mjs";
 import * as pack from "./agents.mjs";
+import * as web from "./web.mjs";
 import { capture } from "./telemetry.mjs";
 import { renderReport } from "./report.mjs";
 
@@ -37,7 +38,10 @@ export async function run(args) {
   if (!looksLikeKey(key)) ui.warn("that does not look like a NOAN key (they start with npak_) — checking anyway");
   const me = await whoAmI(key);
   if (!me.ok) { ui.warn(me.reason); report.steps.auth = { ok: false, reason: me.reason }; return finish(2, "cancelled"); }
-  ui.ok(`key accepted: ${me.identity?.email || "?"} in workspace "${me.project?.name || "?"}"`);
+  if (isAgentIdentity(me.identity)) {
+    ui.ok(`key accepted: your NOAN agent "${me.identity?.name || "?"}" (role bot) in workspace "${me.project?.name || "?"}"`);
+    ui.warn("this key belongs to the agent, not to you: your coding assistant will write as the agent too. For your own use, a personal key (" + KEY_PAGE_HINT + ") is the better fit.");
+  } else ui.ok(`key accepted: ${me.identity?.email || "?"} in workspace "${me.project?.name || "?"}"`);
   const env = writeEnv(dir, { NOAN_API_KEY: key, NOAN_PERSONAL_API_KEY: key }, { dryRun: args.dryRun });
   const gi = ensureGitignored(dir, { dryRun: args.dryRun });
   ui.ok(`${env.created ? "wrote" : env.changed ? "updated" : "kept"} ${env.path} (NOAN_API_KEY, NOAN_PERSONAL_API_KEY); .gitignore: ${gi.action}`);
@@ -86,17 +90,36 @@ export async function run(args) {
   ui.step(5, "The agent pack");
   let wantAgents = args.agents;
   if (wantAgents == null) wantAgents = ui.interactive ? await ui.confirm("Set up the six open-source agents on your GitHub account too?", false) : false;
-  if (wantAgents) report.steps.agents = await setupAgents({ args, ui, dir, key, me, report });
+  // Carries the model key and the agent's name from the pack step to the web step, so a run that
+  // does both asks once. Never put in the report: the report is printed, and --json is parsed.
+  const shared = {};
+  if (wantAgents) report.steps.agents = await setupAgents({ args, ui, dir, key, me, report, shared });
   else { ui.info("skipped" + (args.yes && args.agents == null ? " (pass --agents to include it)" : "")); report.steps.agents = { skipped: true }; }
 
-  /* 6. report */
+  /* 6. web agents */
+  ui.step(6, "The web agents");
+  const wantWeb = [];
+  for (const [id, agent] of Object.entries(web.WEB_AGENTS)) {
+    let want = args[id];
+    if (want == null) want = ui.interactive ? await ui.confirm(`Set up ${agent.label} — ${agent.what}?`, false) : false;
+    if (want) wantWeb.push(id);
+  }
+  if (!wantWeb.length) {
+    ui.info("skipped" + (args.yes && args.meetings == null && args.chat == null ? " (pass --meetings and/or --chat to include them)" : ""));
+    report.steps.web = { skipped: true };
+  } else {
+    report.steps.web = {};
+    for (const id of wantWeb) report.steps.web[id] = await setupWeb({ id, args, ui, dir, key, me, report, shared });
+  }
+
+  /* 7. report */
   report.next.push({ id: "open", say: `Open ${APP_URL} to see the workspace your assistant is grounded in.` });
   return finish(0);
 }
 
 async function ask(ui, q, o) { return ui.ask(q, o); }
 
-async function setupAgents({ args, ui, dir, key, me, report }) {
+async function setupAgents({ args, ui, dir, key, me, report, shared = {} }) {
   const ready = pack.ghReady();
   if (!ready.ok) { ui.warn(ready.reason); return { ok: false, reason: ready.reason }; }
   const fork = pack.forkAndClone(dir, { dryRun: args.dryRun });
@@ -155,7 +178,32 @@ async function setupAgents({ args, ui, dir, key, me, report }) {
         ? await ui.ask(`Pronouns for ${askedName}, in ${askedName}'s own prose (blank for they/them)`)
         : "") });
 
-  const secrets = { NOAN_PERSONAL_API_KEY: key, ...(anthropic && { [mName]: anthropic }), ...(resend && { RESEND_API_KEY: resend }),
+  /* Who the agents run as, and who steers them (NOAN's agent role). The agents should run on an
+   * AGENT-owned key, so what they write is the agent's and its id is what they answer to; the
+   * people who steer them are humans. Step 1's key is normally the user's own, which stays for
+   * seeding and the coding assistant. See agentRoles in noan.mjs. */
+  let agentKey = null, agentMe = null;
+  if (isAgentIdentity(me.identity)) { agentKey = key; agentMe = me.identity; }
+  else {
+    const given = (args.agentKey || process.env.NOAN_AGENT_API_KEY || "").trim()
+      || (ui.interactive ? await ui.ask(`Agent key, so the agents run as your NOAN agent rather than as you (${AGENT_KEY_PAGE_HINT}; blank to skip)`, { secret: true }) : "");
+    if (given) {
+      const am = await whoAmI(given);
+      if (!am.ok) ui.warn(`agent key not accepted (${am.reason}); continuing without one`);
+      else if (am.project?.id && me.project?.id && am.project.id !== me.project.id) ui.warn(`that agent key is for workspace "${am.project?.name}", not "${me.project?.name}"; continuing without one`);
+      else if (!isAgentIdentity(am.identity)) ui.warn(`that key belongs to ${am.identity?.email || "a person"}, not the agent; continuing without one`);
+      else { agentKey = given; agentMe = am.identity; ui.ok(`agent key accepted: "${am.identity?.name || "agent"}" (role bot)`); }
+    }
+  }
+  const commandersIn = (process.env.COMMANDERS || "").trim()
+    || (isAgentIdentity(me.identity) && ui.interactive ? await ui.ask("Email(s) of the people who steer and approve the agents, comma-separated") : "");
+  const roles = agentRoles({ person: isAgentIdentity(me.identity) ? null : me.identity, agent: agentMe, commanders: commandersIn });
+  for (const w of roles.warnings) ui.warn(w);
+  out.identity = { runAs: roles.runAs, agentIds: roles.agentIds, commanders: roles.commanders };
+  // The pack reads its NOAN key from this secret name; under the agent role it holds the agent's key.
+  const runKey = roles.runAs === "agent" ? agentKey : key;
+
+  const secrets = { NOAN_PERSONAL_API_KEY: runKey, ...(anthropic && { [mName]: anthropic }), ...(resend && { RESEND_API_KEY: resend }),
                     ...(db && { DATABASE_URL: db }), ...(firecrawl && { FIRECRAWL_API_KEY: firecrawl }), NEWSLETTER_UNSUB_SECRET: pack.randomSecret() };
   for (const [n, v] of Object.entries(secrets)) { const r = pack.setSecret(fork.dest, n, v, args.dryRun); out.secrets.push(r); ui.ok(`secret ${n}: ${r.action}${r.error ? ` — ${r.error}` : ""}`); }
   // The endpoint is a repository VARIABLE, not a secret: without it the fork holds a gateway key
@@ -163,7 +211,7 @@ async function setupAgents({ args, ui, dir, key, me, report }) {
   // pack's own workflows had.
   const vars = { DRY_RUN: "1", STATE_BACKEND: db ? "postgres" : "local", ...(mBase && { ANTHROPIC_BASE_URL: mBase }), ...(mailFrom && { MAIL_FROM: mailFrom }), ...(replyTo && { REPLY_TO: replyTo }), ...(escalateTo && { ESCALATE_TO: escalateTo }),
                  ...identity,
-                 COMPANY_NAME: me.project?.name || "", ...(me.identity?.id && { AGENT_IDENTITY_IDS: me.identity.id }), ...(me.identity?.email && { COMMANDERS: me.identity.email }) };
+                 COMPANY_NAME: me.project?.name || "", ...(roles.agentIds && { AGENT_IDENTITY_IDS: roles.agentIds }), ...(roles.commanders && { COMMANDERS: roles.commanders }) };
   // The seeds need the key in the clone's .env; the pack's own .env.example documents the rest.
   pack.writePackEnv(fork.dest, { NOAN_PERSONAL_API_KEY: key, ...(anthropic && { [mName]: anthropic }), ...(mBase && { ANTHROPIC_BASE_URL: mBase }), ...(resend && { RESEND_API_KEY: resend }) }, args.dryRun);
   const seeds = pack.runSeeds(fork.dest, { NOAN_PERSONAL_API_KEY: key }, { dryRun: args.dryRun });
@@ -181,7 +229,20 @@ async function setupAgents({ args, ui, dir, key, me, report }) {
       report.next.push({ id: "grounding", say: `Fill the ${grounding.gaps.length} block(s) the agents read (tasks are on your NOAN board): ${grounding.gaps.map(g => g.title).join(", ")}.`, why: "an agent grounded in an empty block fails quietly" });
     } else ui.ok("every block the agents read holds a fact");
   }
+  // Who gets work handed back (agent role only, see agentRoles). An env value wins; one already
+  // set on the fork is kept, since it is a list a person may have extended with teammates.
+  const have = pack.existingVariables(fork.dest, args.dryRun);
+  const handBackKept = [], handBackToYou = [];
+  for (const [n, v] of Object.entries(roles.handBack)) {
+    const given = (process.env[n] || "").trim();
+    if (given) vars[n] = given;
+    else if (have.has(n)) handBackKept.push(n);
+    else { vars[n] = v; handBackToYou.push(n); }
+  }
+  out.handBack = { toYou: handBackToYou, kept: handBackKept };
   for (const [n, v] of Object.entries(vars)) { if (!v) continue; const r = pack.setVariable(fork.dest, n, v, args.dryRun); out.variables.push(r); }
+  if (handBackToYou.length) ui.ok(`work the agents hand back goes to ${me.identity?.email || "you"} (fact review, parked tasks, support follow-ups)`);
+  if (handBackKept.length) ui.ok(`kept the fork's own ${handBackKept.join(", ")}`);
   ui.ok(`${out.variables.length} repository variable(s) ${args.dryRun ? "to set" : "set"} (DRY_RUN=1: every agent stays in safe mode)`);
   // No point dispatching a run that will only fail for a missing key: say what is missing instead.
   if (!anthropic || !resend) {
@@ -196,5 +257,63 @@ async function setupAgents({ args, ui, dir, key, me, report }) {
   }
   out.repo = pack.repoSlug(fork.dest);
   out.agentName = identity.AGENT_NAME;
+  Object.assign(shared, { modelKey: anthropic, modelKeyName: mName, modelBase: mBase, agentName: identity.AGENT_NAME });
+  return out;
+}
+
+/** One web agent: fork, seed, prove it boots, write its .env, hand the deploy to the assistant.
+ *  What it returns goes in the report, so it carries names and outcomes — never a key. */
+async function setupWeb({ id, args, ui, dir, key, me, report, shared }) {
+  const agent = web.WEB_AGENTS[id];
+  ui.info(`${agent.label}:`);
+  const ready = pack.ghReady();
+  if (!ready.ok) { ui.warn(ready.reason); return { ok: false, reason: ready.reason }; }
+  const fork = web.forkAndCloneWeb(dir, agent, { dryRun: args.dryRun });
+  ui.ok(`${fork.action}: ${fork.dest}${fork.error ? ` — ${fork.error}` : ""}`);
+  if (fork.error) return { ok: false, reason: fork.error };
+  const out = { ok: true, dest: fork.dest, seeds: [], skipped: [] };
+
+  // Seeds run under the person's own key: setting up their workspace is theirs to do.
+  const seeds = web.runWebSeeds(fork.dest, agent, { NOAN_PERSONAL_API_KEY: key }, { dryRun: args.dryRun });
+  out.seeds = seeds.rows;
+  for (const r of seeds.rows) (r.action === "failed" || r.action === "missing" ? ui.warn : ui.ok)(`${r.seed}: ${r.action}${r.slugs != null ? ` (${r.slugs} slug(s))` : ""}${r.error ? ` — ${r.error}` : ""}`);
+
+  // INSTALL.md step 0, for them: the service boots with no keys at all.
+  if (args.dryRun) out.local = { ok: null, reason: "dry run" };
+  else if (existsSync(fork.dest)) {
+    out.local = await web.proveLocally(fork.dest, agent);
+    if (out.local.ok) ui.ok(`boots locally with no keys (${out.local.probes.join(", ")} answered)`);
+    else ui.warn(`did not boot locally: ${out.local.reason} — INSTALL.md step 0 runs the same thing by hand`);
+  }
+
+  // The chat needs a model key; reuse the pack step's if this run had one, else env, else ask.
+  let modelKey = null, modelKeyName = "ANTHROPIC_API_KEY", modelBase = "";
+  if (agent.needsModelKey) {
+    if (shared.modelKey) ({ modelKey, modelKeyName, modelBase } = shared);
+    else {
+      try { modelBase = pack.modelBase(); } catch (e) { ui.warn(e.message); out.skipped.push({ name: "model key", why: e.message }); modelBase = null; }
+      if (modelBase !== null) {
+        modelKeyName = pack.modelKeyName();
+        modelKey = (process.env[modelKeyName] || process.env[modelKeyName === "LLM_API_KEY" ? "ANTHROPIC_API_KEY" : "LLM_API_KEY"] || "").trim()
+          || (ui.interactive ? await ui.ask(`API key for ${modelBase ? new URL(modelBase).host : "Anthropic"} (the chat's model; blank to add it later)`, { secret: true }) : "");
+        if (modelKey) {
+          const verdict = await pack.verifyModelKey(modelKey, modelBase);
+          if (verdict === false) { ui.warn(`${modelKeyName} was not accepted by its service; not written`); out.skipped.push({ name: modelKeyName, why: "rejected" }); modelKey = null; }
+        } else out.skipped.push({ name: modelKeyName, why: "not provided" });
+      }
+    }
+  }
+
+  const agentName = shared.agentName || pack.agentIdentity({ name: process.env.AGENT_NAME }).AGENT_NAME;
+  const pairs = web.webEnv(agent, { slugs: seeds.slugs, company: me.project?.name || "", agentName, modelKey, modelKeyName, modelBase: modelBase || "" });
+  const env = web.writeWebEnv(fork.dest, pairs, { dryRun: args.dryRun });
+  ui.ok(`${args.dryRun ? "would write" : env.created ? "wrote" : env.changed ? "updated" : "kept"} ${env.path} (${env.keys.join(", ") || "nothing new"}); .gitignore: ${env.gitignore}`);
+  out.env = { path: env.path, keys: env.keys, gitignore: env.gitignore };
+  const missingModelKey = agent.needsModelKey && !modelKey ? modelKeyName : null;
+  if (missingModelKey) { ui.warn(`no ${missingModelKey} written: the chat cannot answer until it has one`); out.missing = [missingModelKey]; }
+
+  out.repo = args.dryRun ? null : pack.repoSlug(fork.dest);
+  out.deployUrl = web.renderDeployUrl(out.repo);
+  report.next.push(web.webNext(agent, { dest: fork.dest, deployUrl: out.deployUrl, missingModelKey }));
   return out;
 }

package/src/web.mjs

@@ -0,0 +1,169 @@
+/**
+ * The web-facing agents: getnoan/verity-meetings (booking pages) and getnoan/verity-chat (a chat
+ * widget for your site). They are always-on services on the user's own domain, not scheduled
+ * jobs, so they live in their own repos and deploy to a host (Render by default), not to Actions.
+ *
+ * The wizard does the part that needs no account the user has not already given it:
+ *   fork and clone → seed the service's facts (under the user's own key, a human action) →
+ *   prove the service boots locally with NO keys → write a gitignored .env in the clone with what
+ *   is known → hand the rest to the coding assistant, INSTALL.md's remaining steps plus a Render
+ *   deploy link.
+ * The rest — a host account, a Supabase project, Google calendar credentials, DNS, the embed tag on
+ * their site — needs the person, and INSTALL.md marks each of those HUMAN.
+ *
+ * The personal NOAN key is NOT written into the service's .env. That key reaches the whole
+ * workspace, and these services answer the open internet; each gets a key made for it, and the
+ * hand-off says so. The seeds are different: seeding is a person setting up their own workspace.
+ */
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { createServer } from "node:net";
+import path from "node:path";
+import { gh, parseSeedOutput, randomSecret } from "./agents.mjs";
+import { writeEnv, ensureGitignored } from "./env-file.mjs";
+
+/** One entry per web agent. `boot` is INSTALL.md step 0 — the no-keys local run — and `probe` is
+ *  what proves it came up; both are the repos' own CI checks, so a green CI there means this works. */
+export const WEB_AGENTS = {
+  meetings: {
+    label: "Verity Meetings",
+    repo: "getnoan/verity-meetings",
+    dirName: "verity-meetings",
+    what: "booking pages on your own domain",
+    seeds: ["agents/seed-scheduling.mjs", "agents/seed-booking.mjs"],
+    boot: (port) => ({
+      args: ["booking/server.mjs"],
+      env: { BOOKING_ENABLED: "1", BOOKING_STORE: "memory", BOOKING_DRY_RUN: "1",
+             BOOKING_HOSTS: "founder@example.com,teammate@example.com",
+             BOOKING_PUBLIC_URL: `http://127.0.0.1:${port}`, PORT: String(port) },
+    }),
+    probe: ["/healthz", "/alex"],
+    needsModelKey: false,
+    // INSTALL.md steps left after the wizard: it has seeded (step 1's second half).
+    remaining: "step 2 (Google calendar credentials), step 3 (Supabase + schema.sql), step 4 (deploy), step 5 (DNS)",
+    after: "Then edit the Booking Types fact in NOAN: the starters use placeholder hosts, and a type whose host is not in BOOKING_HOSTS is not served.",
+  },
+  chat: {
+    label: "Verity Chat",
+    repo: "getnoan/verity-chat",
+    dirName: "verity-chat",
+    what: "a grounded chat widget for your website",
+    seeds: ["agents/seed-site-chat.mjs"],
+    boot: (port) => ({
+      args: ["--input-type=module", "-e", `const { server } = await import("./site-web/server.mjs"); server.listen(${port}, "127.0.0.1");`],
+      env: { NODE_ENV: "test" },
+    }),
+    probe: ["/healthz", "/widget.js"],
+    needsModelKey: true,
+    remaining: "step 3 (Supabase + schema.sql — the daily budget refuses every chat until it can meter), step 4 (deploy), step 5 (the embed tag on your site)",
+    after: "Set SITE_ALLOWED_ORIGINS to your site's origins and SITE_CHAT_GROUNDING_SLUGS to the blocks it may answer from.",
+  },
+};
+
+/** Fork (or reuse) and clone a web agent's repo into dir/<dirName>. */
+export function forkAndCloneWeb(dir, agent, { dryRun = false } = {}) {
+  const dest = path.join(dir, agent.dirName);
+  if (existsSync(path.join(dest, ".git"))) return { dest, action: "reused existing clone" };
+  if (dryRun) return { dest, action: "would fork and clone" };
+  const r = gh(["repo", "fork", agent.repo, "--clone", "--remote=false", dest]);
+  if (!r.ok) return { dest, action: "fork failed", error: r.err.split("\n")[0] };
+  return { dest, action: "forked and cloned" };
+}
+
+/** Run a web agent's seed scripts from the repo root; collect the block slugs they print. */
+export function runWebSeeds(dest, agent, env, { dryRun = false } = {}) {
+  const slugs = {}; const rows = [];
+  for (const s of agent.seeds) {
+    const p = path.join(dest, s);
+    // A dry run has no clone yet, so "missing" there would be a false alarm.
+    if (dryRun && !existsSync(dest)) { rows.push({ seed: s, action: "would run" }); continue; }
+    if (!existsSync(p)) { rows.push({ seed: s, action: "missing" }); continue; }
+    if (dryRun) { rows.push({ seed: s, action: "would run" }); continue; }
+    const r = spawnSync(process.execPath, [p], { cwd: dest, encoding: "utf8", env: { ...process.env, ...env } });
+    const found = parseSeedOutput((r.stdout || "") + "\n" + (r.stderr || ""));
+    Object.assign(slugs, found);
+    rows.push({ seed: s, action: r.status === 0 ? "ran" : "failed", slugs: Object.keys(found).length,
+      error: r.status === 0 ? undefined : (r.stderr || r.stdout || "").trim().split("\n").slice(-1)[0] });
+  }
+  return { slugs, rows };
+}
+
+export function freePort() {
+  return new Promise((res, rej) => {
+    const s = createServer(); s.unref(); s.on("error", rej);
+    s.listen(0, "127.0.0.1", () => { const { port } = s.address(); s.close(() => res(port)); });
+  });
+}
+
+/** INSTALL.md step 0, run for the user: boot the service with no keys, hit its probes, stop it.
+ *  The child gets PATH and HOME only — never the wizard's environment — so no key it holds can
+ *  reach the service, and a block slug in the shell cannot switch booking out of its local mode. */
+export async function proveLocally(dest, agent, { timeoutMs = 15000, fetchImpl = fetch } = {}) {
+  const port = await freePort();
+  const { args, env } = agent.boot(port);
+  const child = spawn(process.execPath, args, { cwd: dest, stdio: ["ignore", "ignore", "pipe"],
+    env: { PATH: process.env.PATH || "", HOME: process.env.HOME || "", ...env } });
+  let stderr = ""; child.stderr.on("data", d => { stderr = (stderr + d).slice(-2000); });
+  const exited = new Promise(r => child.on("exit", code => r(code)));
+  const base = `http://127.0.0.1:${port}`;
+  try {
+    const deadline = Date.now() + timeoutMs;
+    let up = false;
+    while (Date.now() < deadline && !up) {
+      if (child.exitCode !== null) break;
+      try { up = (await fetchImpl(`${base}${agent.probe[0]}`, { signal: AbortSignal.timeout(1000) })).ok; } catch {}
+      if (!up) await new Promise(r => setTimeout(r, 300));
+    }
+    if (!up) return { ok: false, reason: child.exitCode !== null ? `exited (${child.exitCode}): ${stderr.trim().split("\n").slice(-1)[0] || "no output"}` : "did not answer in time" };
+    for (const p of agent.probe.slice(1)) {
+      const r = await fetchImpl(`${base}${p}`, { signal: AbortSignal.timeout(3000) }).catch(() => null);
+      if (!r?.ok) return { ok: false, reason: `${p} answered ${r ? r.status : "nothing"}` };
+    }
+    return { ok: true, probes: agent.probe };
+  } finally {
+    if (child.exitCode === null) { child.kill(); await Promise.race([exited, new Promise(r => setTimeout(r, 2000))]); }
+  }
+}
+
+/** Render's one-click deploy for a repo that carries a render.yaml. */
+export const renderDeployUrl = (slug) => (slug ? `https://render.com/deploy?repo=https://github.com/${slug}` : null);
+
+/** What goes in the clone's .env. Never the personal NOAN key (see the header). The model key goes
+ *  under the name the service reads for the chosen endpoint (the pack's rule: ANTHROPIC_API_KEY for
+ *  the default vendor, LLM_API_KEY plus ANTHROPIC_BASE_URL for anything else). */
+export function webEnv(agent, { slugs = {}, company = "", agentName = "", modelKey = null, modelKeyName = "ANTHROPIC_API_KEY", modelBase = "" } = {}) {
+  return {
+    ...slugs,
+    ...(company && { COMPANY_NAME: company }),
+    ...(agentName && { AGENT_NAME: agentName }),
+    ...(agent === WEB_AGENTS.chat && { SESSION_SECRET: randomSecret() }),
+    ...(agent.needsModelKey && modelKey && { [modelKeyName]: modelKey }),
+    ...(agent.needsModelKey && modelKey && modelBase && { ANTHROPIC_BASE_URL: modelBase }),
+  };
+}
+
+/** Write the clone's .env: gitignored FIRST (the exported repos ship no .gitignore, and this file
+ *  can hold a model key), and a SESSION_SECRET that is already there is kept — rotating it would
+ *  sign out every visitor of a chat already deployed from it. */
+export function writeWebEnv(dest, pairs, { dryRun = false } = {}) {
+  const gitignore = ensureGitignored(dest, { dryRun });
+  const envPath = path.join(dest, ".env");
+  const existing = existsSync(envPath) ? readFileSync(envPath, "utf8") : "";
+  const keep = { ...pairs };
+  if (/^\s*(?:export\s+)?SESSION_SECRET\s*=\s*\S/m.test(existing)) delete keep.SESSION_SECRET;
+  const env = writeEnv(dest, keep, { dryRun });
+  return { ...env, gitignore: gitignore.action, keys: Object.keys(keep) };
+}
+
+/** The hand-off line for the report's `next` list: what is left, and where to read how. */
+export function webNext(agent, { dest, deployUrl, missingModelKey = null }) {
+  return {
+    id: `web-${agent.dirName}`,
+    say: `Finish ${agent.label} (${agent.what}): in ${dest}, follow INSTALL.md ${agent.remaining}.`
+      + (missingModelKey ? ` It needs ${missingModelKey} too — the wizard had none to write.` : "")
+      + (deployUrl ? ` One-click deploy: ${deployUrl}.` : "")
+      + ` Mint a NOAN key for this service alone under your NOAN agent (Settings → API → Agent API Keys) and set it as NOAN_AGENT_API_KEY in the deploy env — not your personal key.`
+      + ` ${agent.after}`,
+    why: "the rest needs accounts only you can create; INSTALL.md marks those steps HUMAN",
+  };
+}