veefore 1.0.0 → 1.1.0

package/dist/veefore.mjs

@@ -236,29 +236,29 @@ var ApiClient = class {
   setToken(token) {
     this.token = token;
   }
-  async get(path11, query = {}) {
+  async get(path12, query = {}) {
     const search = new URLSearchParams();
     for (const [key, value] of Object.entries(query)) {
       if (value !== void 0) search.set(key, String(value));
     }
     const suffix = search.toString() === "" ? "" : `?${search.toString()}`;
-    return this.send("GET", `${path11}${suffix}`);
+    return this.send("GET", `${path12}${suffix}`);
   }
-  async post(path11, body) {
-    return this.send("POST", path11, body);
+  async post(path12, body) {
+    return this.send("POST", path12, body);
   }
-  async patch(path11, body) {
-    return this.send("PATCH", path11, body);
+  async patch(path12, body) {
+    return this.send("PATCH", path12, body);
   }
-  async delete(path11) {
-    return this.send("DELETE", path11);
+  async delete(path12) {
+    return this.send("DELETE", path12);
   }
   /** Raw request for endpoints that return a non-JSON body (exports). */
-  async raw(method, path11, body) {
-    return this.fetchWithTimeout(method, path11, body);
+  async raw(method, path12, body) {
+    return this.fetchWithTimeout(method, path12, body);
   }
-  async send(method, path11, body) {
-    const response = await this.fetchWithTimeout(method, path11, body);
+  async send(method, path12, body) {
+    const response = await this.fetchWithTimeout(method, path12, body);
     const text = await response.text();
     const parsed = parseJson(text);
     if (response.ok) {
@@ -266,14 +266,14 @@ var ApiClient = class {
       if (parsed && "data" in parsed) return parsed.data;
       throw new CliApiError(
         "UNEXPECTED_RESPONSE",
-        `The control plane returned an unexpected body for ${method} ${path11}.`,
+        `The control plane returned an unexpected body for ${method} ${path12}.`,
         response.status,
         response.headers.get("x-request-id")
       );
     }
     const error = new CliApiError(
       parsed?.error?.code ?? `HTTP_${response.status}`,
-      parsed?.error?.message ?? `${method} ${path11} failed with ${response.status} ${response.statusText}.`,
+      parsed?.error?.message ?? `${method} ${path12} failed with ${response.status} ${response.statusText}.`,
       response.status,
       parsed?.error?.request_id ?? response.headers.get("x-request-id"),
       parsed?.error?.details ?? {}
@@ -291,7 +291,7 @@ var ApiClient = class {
     }
     throw error;
   }
-  async fetchWithTimeout(method, path11, body) {
+  async fetchWithTimeout(method, path12, body) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), this.timeoutMs);
     const headers = { accept: "application/json" };
@@ -300,7 +300,7 @@ var ApiClient = class {
     if (this.workspaceId) headers["x-veefore-workspace"] = this.workspaceId;
     if (this.environmentId) headers["x-veefore-environment"] = this.environmentId;
     try {
-      return await fetch(`${this.controlPlaneUrl}${path11}`, {
+      return await fetch(`${this.controlPlaneUrl}${path12}`, {
         method,
         headers,
         body: body === void 0 ? void 0 : JSON.stringify(body),
@@ -566,6 +566,275 @@ function sleep(ms) {
 
 // src/terminal.ts
 import { createInterface } from "node:readline/promises";
+
+// src/tui.ts
+import { emitKeypressEvents } from "node:readline";
+
+// src/logo.ts
+var LOGO = [
+  "\u2580\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2584    \u2584\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2580",
+  " \u2588\u2588        \u2580\u2588    \u2588\u2580        \u2588\u2588",
+  "  \u2588\u2588   \u2588\u2588   \u2588\u2588  \u2588\u2588   \u2588\u2588   \u2588\u2588",
+  "   \u2588\u2588   \u2588\u2588     \u2588\u2588   \u2588\u2588   \u2588\u2588",
+  "    \u2588\u2588   \u2588\u2588   \u2588\u2588   \u2588\u2588   \u2588\u2588",
+  "    \u2580\u2588\u2584   \u2588\u2584 \u2584\u2588   \u2584\u2588   \u2584\u2588\u2580",
+  "     \u2580\u2588\u2584  \u2580\u2588\u2588\u2588\u2580  \u2584\u2588\u2580  \u2584\u2588\u2580",
+  "      \u2580\u2588\u2584  \u2580\u2588\u2580  \u2584\u2588\u2580  \u2584\u2588\u2580",
+  "       \u2580\u2588   \u2580   \u2588\u2580   \u2588\u2580",
+  "        \u2588\u2588     \u2588\u2588   \u2588\u2588",
+  "         \u2588\u2588\u2588\u2588\u2588\u2588\u2588   \u2588\u2588"
+];
+
+// src/tui.ts
+function isInteractive() {
+  return process.stdin.isTTY === true && process.stdout.isTTY === true && process.env.TERM !== "dumb" && process.env.CI === void 0;
+}
+var COLOR = process.env.NO_COLOR === void 0 && process.stdout.isTTY === true;
+function colorDepth() {
+  const colorterm = (process.env.COLORTERM ?? "").toLowerCase();
+  if (colorterm === "truecolor" || colorterm === "24bit") return 24;
+  if (process.env.TERM_PROGRAM === "vscode" || process.env.TERM_PROGRAM === "iTerm.app") return 24;
+  if ((process.env.TERM ?? "").includes("256")) return 8;
+  return 4;
+}
+function paint(rgb, text) {
+  if (!COLOR) return text;
+  const depth = colorDepth();
+  if (depth === 24) return `\x1B[38;2;${rgb[0]};${rgb[1]};${rgb[2]}m${text}\x1B[0m`;
+  if (depth === 8) {
+    const level = (value) => Math.round(value / 255 * 5);
+    const code = 16 + 36 * level(rgb[0]) + 6 * level(rgb[1]) + level(rgb[2]);
+    return `\x1B[38;5;${code}m${text}\x1B[0m`;
+  }
+  return `\x1B[94m${text}\x1B[0m`;
+}
+var BRAND_TOP = [150, 172, 236];
+var BRAND_BOTTOM = [84, 108, 186];
+var BRAND = [118, 140, 214];
+var brand = (text) => paint(BRAND, text);
+function gradient(row, rows) {
+  const t = rows <= 1 ? 0 : row / (rows - 1);
+  const mix = (a, b) => Math.round(a + (b - a) * t);
+  return [
+    mix(BRAND_TOP[0], BRAND_BOTTOM[0]),
+    mix(BRAND_TOP[1], BRAND_BOTTOM[1]),
+    mix(BRAND_TOP[2], BRAND_BOTTOM[2])
+  ];
+}
+var ANSI = /\u001B\[[0-9;?]*[A-Za-z]/g;
+function visibleLength(text) {
+  return [...text.replace(ANSI, "")].length;
+}
+function columns() {
+  return process.stdout.columns && process.stdout.columns > 0 ? process.stdout.columns : 80;
+}
+var sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var STARS = [
+  [0, -3, "*"],
+  [3, -2, "\xB7"],
+  [7, -3, "*"],
+  [10, -1, "\xB7"],
+  [1, 33, "\xB7"],
+  [5, 34, "*"],
+  [9, 32, "\xB7"]
+];
+async function showWelcome(context) {
+  if (!isInteractive()) return;
+  const width = Math.min(columns(), 100);
+  const logoWidth = Math.max(...LOGO.map((line) => [...line].length));
+  const indent = 5;
+  const gap = 6;
+  const panelWidth = Math.max(
+    24,
+    ...context.facts.map(([label, value]) => label.length + 2 + value.length)
+  );
+  const sideBySide = width >= indent + logoWidth + gap + panelWidth + 2;
+  const showLogo = width >= indent + logoWidth + 2;
+  const rule = style.grey("\xB7".repeat(Math.max(10, Math.min(width - 2, 72))));
+  const animate = process.env.VEEFORE_NO_ANIMATION === void 0;
+  out();
+  out(` ${brand(style.bold("Welcome to Veefore"))} ${style.grey(`v${context.version}`)}`);
+  out(` ${rule}`);
+  out();
+  const panel = renderPanel(context.facts);
+  if (showLogo) {
+    for (let row = 0; row < LOGO.length; row += 1) {
+      const line = LOGO[row] ?? "";
+      const left = starsFor(row, indent, (column) => column < 0, -indent);
+      const right = starsFor(row, 0, (column) => column >= logoWidth, logoWidth);
+      const art = paint(gradient(row, LOGO.length), line.padEnd(logoWidth));
+      let text = `${left}${art}`;
+      if (sideBySide) {
+        const top = Math.max(0, Math.floor((LOGO.length - panel.length) / 2));
+        const side = panel[row - top];
+        text += side === void 0 ? right : `${" ".repeat(gap)}${side}`;
+      } else {
+        text += right;
+      }
+      out(text.replace(/\s+$/, ""));
+      if (animate) await sleep2(14);
+    }
+  }
+  if (!sideBySide) {
+    out();
+    for (const line of panel) out(fit(`   ${line}`, width - 1));
+  }
+  out();
+  out(` ${rule}`);
+}
+function starsFor(row, width, inBand, offset) {
+  const cells = Array.from({ length: Math.max(width, 6) }, () => " ");
+  for (const [starRow, column, glyph] of STARS) {
+    if (starRow !== row || !inBand(column)) continue;
+    const index = column - offset;
+    if (index >= 0 && index < cells.length) cells[index] = style.grey(glyph);
+  }
+  return width === 0 ? cells.join("").replace(/\s+$/, "") : cells.slice(0, width).join("");
+}
+function renderPanel(facts) {
+  const lines = [
+    style.bold("Veefore"),
+    style.grey("Identity, authority and policy"),
+    style.grey("for AI agents"),
+    ""
+  ];
+  const labelWidth = Math.max(0, ...facts.map(([label]) => label.length));
+  for (const [label, value] of facts) {
+    lines.push(`${style.grey(label.padEnd(labelWidth))}  ${value}`);
+  }
+  return lines;
+}
+var MenuCancelled = class extends CliError {
+  constructor() {
+    super("Cancelled.", void 0, 130);
+    this.name = "MenuCancelled";
+  }
+};
+async function select(question, options, settings = {}) {
+  const enabled = options.map((option, index) => option.disabled ? -1 : index).filter((i) => i >= 0);
+  if (enabled.length === 0) throw new CliError(`Nothing can be chosen for "${question}".`);
+  const fallback = enabled.includes(settings.initial ?? -1) ? settings.initial : enabled[0];
+  if (!isInteractive()) return options[fallback].value;
+  let cursor = fallback;
+  let rendered = 0;
+  const stdin = process.stdin;
+  const stdout = process.stdout;
+  const labelWidth = Math.max(...options.map((option) => [...option.label].length));
+  const draw = () => {
+    const width = columns();
+    const lines = [];
+    lines.push(`${brand("?")} ${style.bold(question)}`);
+    if (settings.help) lines.push(`  ${style.grey(settings.help)}`);
+    options.forEach((option, index) => {
+      const active = index === cursor;
+      const pointer = active ? brand("\u276F") : " ";
+      const number = index < 9 ? `${index + 1}.` : "  ";
+      const text = option.hint ? option.label.padEnd(labelWidth) : option.label;
+      const hint = option.hint ? `  ${style.grey(option.hint)}` : "";
+      const label = option.disabled ? style.grey(`${number} ${text}`) : active ? brand(`${number} ${text}`) : `${number} ${text}`;
+      lines.push(fit(`${pointer} ${label}${hint}`, width - 1));
+    });
+    lines.push(style.grey("  \u2191\u2193 move \xB7 enter choose \xB7 esc cancel"));
+    if (rendered > 0) stdout.write(`\x1B[${rendered}A\r\x1B[J`);
+    stdout.write(`${lines.join("\n")}
+`);
+    rendered = lines.length;
+  };
+  const move = (direction) => {
+    const position = enabled.indexOf(cursor);
+    const next = (position + direction + enabled.length) % enabled.length;
+    cursor = enabled[next];
+  };
+  return new Promise((resolve, reject) => {
+    const wasRaw = stdin.isRaw;
+    const restoreCursor = () => {
+      stdout.write("\x1B[?25h");
+    };
+    const finish = (result) => {
+      stdin.off("keypress", onKey);
+      stdin.setRawMode(wasRaw);
+      stdin.pause();
+      process.off("exit", restoreCursor);
+      if (rendered > 0) stdout.write(`\x1B[${rendered}A\r\x1B[J`);
+      restoreCursor();
+      if (result) {
+        if (!settings.quiet) {
+          stdout.write(`${style.green("\u2713")} ${question} ${brand(result.label)}
+`);
+        }
+        resolve(result.value);
+      } else {
+        stdout.write(`${style.grey("\u2717")} ${question} ${style.grey("cancelled")}
+`);
+        reject(new MenuCancelled());
+      }
+    };
+    const choose = (index) => {
+      const option = options[index];
+      if (!option || option.disabled) return;
+      finish({ value: option.value, label: option.label });
+    };
+    const onKey = (input, key = {}) => {
+      if (key.ctrl && key.name === "c" || key.name === "escape") return finish(null);
+      if (key.name === "return" || key.name === "enter") return choose(cursor);
+      if (key.name === "up" || key.name === "k") move(-1);
+      else if (key.name === "down" || key.name === "j" || key.name === "tab") move(1);
+      else if (input && /^[1-9]$/.test(input)) {
+        const index = Number(input) - 1;
+        if (options[index] && !options[index]?.disabled) return choose(index);
+        return;
+      } else if (input) {
+        const match = options.findIndex(
+          (option) => !option.disabled && option.key?.toLowerCase() === input.toLowerCase()
+        );
+        if (match >= 0) return choose(match);
+        return;
+      } else {
+        return;
+      }
+      draw();
+    };
+    process.once("exit", restoreCursor);
+    emitKeypressEvents(stdin);
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdout.write("\x1B[?25l");
+    stdin.on("keypress", onKey);
+    draw();
+  });
+}
+async function selectYesNo(question, defaultYes = false) {
+  return select(
+    question,
+    [
+      { label: "Yes", value: true, key: "y" },
+      { label: "No", value: false, key: "n" }
+    ],
+    { initial: defaultYes ? 0 : 1 }
+  );
+}
+function fit(text, width) {
+  if (visibleLength(text) <= width) return text;
+  let shown = 0;
+  let result = "";
+  for (let index = 0; index < text.length; ) {
+    ANSI.lastIndex = index;
+    const escape = ANSI.exec(text);
+    if (escape && escape.index === index) {
+      result += escape[0];
+      index += escape[0].length;
+      continue;
+    }
+    if (shown >= width - 1) break;
+    const char = String.fromCodePoint(text.codePointAt(index));
+    result += char;
+    shown += 1;
+    index += char.length;
+  }
+  return `${result}\u2026\x1B[0m`;
+}
+
+// src/terminal.ts
 var COLOR_ENABLED = process.env.NO_COLOR === void 0 && process.env.TERM !== "dumb" && process.stdout.isTTY === true;
 function wrap(code, text) {
   return COLOR_ENABLED ? `\x1B[${code}m${text}\x1B[0m` : text;
@@ -599,12 +868,12 @@ function heading(text) {
   out(style.bold(text));
   out(style.grey("\u2500".repeat(Math.min(text.length, 72))));
 }
-function table(columns, rows) {
+function table(columns2, rows) {
   if (rows.length === 0) {
     out(style.grey("  (none)"));
     return;
   }
-  const widths = columns.map((column) => {
+  const widths = columns2.map((column) => {
     const longest = Math.max(
       column.header.length,
       ...rows.map((row) => (row[column.key] ?? "").length)
@@ -615,17 +884,17 @@ function table(columns, rows) {
     const parts = cells.map((cell, index) => {
       const width = widths[index] ?? cell.length;
       const text = cell.length > width ? `${cell.slice(0, Math.max(0, width - 1))}\u2026` : cell;
-      return columns[index]?.align === "right" ? text.padStart(width) : text.padEnd(width);
+      return columns2[index]?.align === "right" ? text.padStart(width) : text.padEnd(width);
     });
     out(`  ${decorate(parts.join("  "))}`);
   };
   renderRow(
-    columns.map((column) => column.header),
+    columns2.map((column) => column.header),
     style.grey
   );
   for (const row of rows) {
     renderRow(
-      columns.map((column) => row[column.key] ?? ""),
+      columns2.map((column) => row[column.key] ?? ""),
       (text) => text
     );
   }
@@ -696,6 +965,14 @@ async function confirm(question, options = {}) {
     out(`${question} ${style.grey("[y/N]")} ${style.amber("y (--yes)")}`);
     return true;
   }
+  if (isInteractive()) {
+    try {
+      return await selectYesNo(question);
+    } catch (error) {
+      if (error instanceof MenuCancelled) return false;
+      throw error;
+    }
+  }
   if (!process.stdin.isTTY) {
     err(
       "This command requires confirmation but the terminal is not interactive. Re-run with --yes to confirm explicitly."
@@ -1405,11 +1682,11 @@ function renderRevokeConfirmation(agent, environment, preview) {
   out(`  ${style.red("This action is irreversible for this identity.")}`);
   out();
 }
-async function lifecycle(args, flags, path11, resultingStatus) {
+async function lifecycle(args, flags, path12, resultingStatus) {
   const context = await resolveContext(flags);
   const agentId = positional(args) ?? context.config.agentId;
   const agent = await context.api.get(`/v1/agents/${agentId}`);
-  const reasonRequired = path11 === "suspend";
+  const reasonRequired = path12 === "suspend";
   const reason = valueFor(args, "--reason");
   if (reasonRequired && (!reason || reason.trim().length < 10)) {
     throw new CliError(
@@ -1419,24 +1696,24 @@ async function lifecycle(args, flags, path11, resultingStatus) {
   }
   out();
   out(
-    `${symbol.info} ${path11} ${style.bold(agent.name)} ${style.grey(`(${agent.status} \u2192 ${resultingStatus})`)}`
+    `${symbol.info} ${path12} ${style.bold(agent.name)} ${style.grey(`(${agent.status} \u2192 ${resultingStatus})`)}`
   );
-  if (path11 !== "resume") {
+  if (path12 !== "resume") {
     const confirmed = await confirm("Continue?", { yes: flags.yes });
     if (!confirmed) {
       out(style.grey("Cancelled."));
       return 1;
     }
   }
-  const actionSpinner = spinner(`Applying ${path11}`);
+  const actionSpinner = spinner(`Applying ${path12}`);
   try {
     await withStepUp(
       context.api,
-      () => context.api.post(`/v1/agents/${agentId}/${path11}`, reason ? { reason } : {})
+      () => context.api.post(`/v1/agents/${agentId}/${path12}`, reason ? { reason } : {})
     );
     actionSpinner.succeed(`${agent.name} is ${resultingStatus}`);
   } catch (error) {
-    actionSpinner.fail(`Could not ${path11} the agent`);
+    actionSpinner.fail(`Could not ${path12} the agent`);
     throw error;
   }
   out();
@@ -3556,32 +3833,30 @@ async function chooseMethod(items, options) {
     out(`    ${style.bold(item.key.padEnd(24))} ${style.grey(`${item.file}:${item.line}`)}`);
   }
   out();
-  out("How would you like to handle them?");
-  out(
-    `  ${style.bold("1")}  I will change them myself ${style.grey("(show me exactly what to change)")}`
-  );
-  out(
-    `  ${style.bold("2")}  Use AI with my own Anthropic or OpenAI key ${style.grey("(code goes only to that provider)")}`
-  );
-  out(
-    `  ${style.bold("3")}  Use Veefore AI ${style.grey(
-      options.hostedAvailable ? "(code is sent to Veefore, then to its model provider)" : "(not enabled on this deployment)"
-    )}`
-  );
-  out(`  ${style.bold("4")}  Skip for now`);
-  for (let attempt = 0; attempt < 3; attempt += 1) {
-    const answer = (await ask("Choice [1-4]:", "1")).trim();
-    if (answer === "1") return "manual";
-    if (answer === "2") return "own";
-    if (answer === "3") {
-      if (options.hostedAvailable) return "veefore";
-      out(style.amber("  Veefore AI is not enabled here. Choose 1, 2 or 4."));
-      continue;
-    }
-    if (answer === "4") return "skip";
-    out(style.amber("  Enter 1, 2, 3 or 4."));
+  try {
+    return await select("How would you like to handle them?", [
+      {
+        label: "I will change them myself",
+        hint: "show me exactly what to change",
+        value: "manual"
+      },
+      {
+        label: "Use AI with my own Anthropic or OpenAI key",
+        hint: "code goes only to that provider",
+        value: "own"
+      },
+      {
+        label: "Use Veefore AI",
+        hint: options.hostedAvailable ? "code is sent to Veefore, then to its model provider" : "not enabled on this deployment",
+        value: "veefore",
+        disabled: !options.hostedAvailable
+      },
+      { label: "Skip for now", value: "skip" }
+    ]);
+  } catch (error) {
+    if (error instanceof MenuCancelled) return "skip";
+    throw error;
   }
-  return "manual";
 }
 function printManualInstructions(items) {
   heading("Make these changes yourself");
@@ -3666,9 +3941,7 @@ function printDispatchInstructions(items, where) {
     out(`    ${style.cyan("import { guard } from '@veefore/sdk';")}`);
     out();
     out(`    ${style.grey("// before:  const result = await runTool(call);")}`);
-    out(
-      `    ${style.cyan("const result = await guard(call.name, (_args: typeof call.args) => runTool(call))(call.args);")}`
-    );
+    out(`    ${style.cyan("const result = await runTool(call);")}`);
   }
   out();
   out(
@@ -3793,16 +4066,21 @@ async function chooseModel(method, context) {
 async function pick(label, choices, preferred, interactive) {
   if (preferred && choices.includes(preferred)) return preferred;
   if (!interactive) return choices[0] ?? null;
-  const shown = choices.slice(0, 20);
+  const OTHER = "\0other";
   out();
-  out(`${label}:`);
-  shown.forEach(
-    (choice, index2) => out(`  ${style.bold(String(index2 + 1).padStart(2))}  ${choice}`)
-  );
-  const answer = (await ask(`Choice [1-${shown.length}]:`, "1")).trim();
-  const index = Number(answer) - 1;
-  if (Number.isInteger(index) && shown[index]) return shown[index];
-  return choices.includes(answer) ? answer : null;
+  let picked;
+  try {
+    picked = await select(label, [
+      ...choices.slice(0, 20).map((choice) => ({ label: choice, value: choice })),
+      ...choices.length > 20 ? [{ label: "Another\u2026", hint: `${choices.length - 20} more`, value: OTHER }] : []
+    ]);
+  } catch (error) {
+    if (error instanceof MenuCancelled) return null;
+    throw error;
+  }
+  if (picked !== OTHER) return picked;
+  const typed = (await ask(`${label} id:`)).trim();
+  return choices.includes(typed) ? typed : null;
 }
 async function runAssist(files, choice, context) {
   const accepted = [];
@@ -6551,1240 +6829,1430 @@ async function undoCommand(args, _flags) {
   return undoLatest(process.cwd(), { force: args.includes("--force") });
 }
 
-// src/setup.ts
-import { generateKeyPairSync } from "node:crypto";
-function buildPlan(scan, options = {}) {
-  return {
-    agentName: (options.agentName ?? scan.projectName ?? "my-agent").slice(0, 200),
-    tools: scan.tools.map(planTool),
-    agentHeldSecrets: scan.secrets.filter((s) => s.kind === "service").map((s) => s.name),
-    modelSecrets: scan.secrets.filter((s) => s.kind === "model").map((s) => s.name),
-    extraCapabilities: options.extraCapabilities ?? []
-  };
-}
-function planTool(tool) {
-  return {
-    key: tool.key,
-    name: tool.name,
-    description: tool.description ?? `Detected ${sourceLabel(tool.source)} tool.`,
-    // One capability per tool keeps authority explicit: granting the agent this
-    // tool grants nothing else. `tool.<key>` satisfies `resource.action`.
-    capability: `tool.${tool.key}`,
-    riskLevel: tool.riskLevel,
-    dangerous: tool.dangerous,
-    destinations: tool.hosts,
-    location: `${tool.location.file}:${tool.location.line}`,
-    money: tool.money ?? null
-  };
-}
-function printScan(scan) {
-  out(
-    `${symbol.pass} Scanned ${scan.filesScanned} file${scan.filesScanned === 1 ? "" : "s"}` + (scan.truncated ? style.amber(" (limit reached; findings may be incomplete)") : "") + style.grey(" \u2014 locally, nothing was uploaded")
-  );
-  if (scan.tools.length === 0) {
-    out(`${symbol.warn} No tools found, so there is nothing for Veefore to decide on yet.`);
-    out(style.grey("    Tools are found where they are declared for the model to call, not from"));
-    out(
-      style.grey(
-        scan.framework.language === "python" ? "    plain functions: @tool, @function_tool, @mcp.tool, Tool(name=\u2026), or a dict" : '    plain functions: tool({\u2026}), DynamicStructuredTool, { type: "function" },'
-      )
-    );
-    out(
-      style.grey(
-        scan.framework.language === "python" ? "    with name, description and an input schema." : "    server.tool(\u2026), or an object with name, description and parameters."
-      )
-    );
-    out(style.grey("    Register them in the console, or add them and run `veefore scan` again."));
-  } else {
-    out(`${symbol.pass} Found ${scan.tools.length} tool${scan.tools.length === 1 ? "" : "s"}:`);
-    for (const tool of scan.tools) {
-      const label = tool.riskLevel.padEnd(7);
-      const risk = tool.riskLevel === "HIGH" ? style.red(label) : tool.riskLevel === "MEDIUM" ? style.amber(label) : style.green(label);
-      out(
-        `    ${style.bold(tool.key.padEnd(24))} ${risk} ${style.grey(`${tool.location.file}:${tool.location.line}`)}`
-      );
-      if (tool.hosts.length > 0) out(style.grey(`      calls ${tool.hosts.join(", ")}`));
-    }
+// src/commands/logs.ts
+async function logsCommand(args, flags) {
+  const context = await resolveContext(flags);
+  const follow = args.includes("--follow") || args.includes("-f");
+  const limit = Number(valueFor(args, "--limit") ?? 25);
+  const decisionFilter = valueFor(args, "--decision");
+  const agentFilter = valueFor(args, "--agent") ?? (args.includes("--all") ? void 0 : context.config.agentId);
+  const initial = await fetchActions(context, {
+    limit,
+    decision: decisionFilter,
+    agentId: agentFilter
+  });
+  if (flags.json && !follow) {
+    printJson(initial);
+    return 0;
   }
-  const service = scan.secrets.filter((s) => s.kind === "service");
-  if (service.length > 0) {
-    out(
-      `${symbol.warn} Your code reads ${service.length} credential${service.length === 1 ? "" : "s"}: ${service.map((s) => s.name).join(", ")} ${style.grey("(names only; values were not read)")}`
-    );
+  heading(`Decisions \u2014 ${context.config.environmentName} (${context.config.environmentType})`);
+  renderActions(initial, flags.verbose);
+  if (!follow) {
+    out();
+    out(style.grey("  Use --follow to stream new decisions as they happen."));
+    out();
+    return 0;
   }
+  return streamActions(context, {
+    decision: decisionFilter,
+    agentId: agentFilter,
+    seen: new Set(initial.map((action) => action.id)),
+    verbose: flags.verbose,
+    json: flags.json
+  });
 }
-function printPlan2(plan, environment) {
+async function devCommand(args, flags) {
+  const context = await resolveContext(flags);
+  const environment = await context.api.get(`/v1/environments/${context.config.environmentId}`);
+  const gateway = await probeGateway(context.config.gatewayUrl);
+  const agent = await context.api.get(
+    `/v1/agents/${context.config.agentId}`
+  );
+  heading(`veefore dev \u2014 ${context.config.organizationName} \u203A ${environment.name}`);
   out();
-  out(style.bold("Veefore will set up"));
   out(
-    `  ${symbol.bullet} Agent ${style.bold(plan.agentName)} in ${environment.name} (${environment.type})`
+    `  ${gateway.reachable ? symbol.pass : symbol.fail} Gateway ${gateway.reachable ? style.green("connected") : style.red("unreachable")} ${style.grey(context.config.gatewayUrl)}`
   );
   out(
-    `    ${style.grey("with its own key pair, generated here. The private key never leaves this machine.")}`
+    `  ${agent.status === "ACTIVE" ? symbol.pass : symbol.warn} Agent ${style.bold(agent.name)} ${decisionStyle(agent.status)}`
   );
-  if (plan.tools.length > 0) {
+  out(
+    `  ${environment.gatewayMode === "ENFORCE" ? symbol.pass : symbol.warn} Mode ${decisionStyle(environment.status === "PAUSED" ? "PAUSED" : environment.gatewayMode)}`
+  );
+  if (!gateway.reachable) {
+    out();
     out(
-      `  ${symbol.bullet} ${plan.tools.length} tool${plan.tools.length === 1 ? "" : "s"}, each with its own capability, authorized for this agent only`
+      `  ${symbol.fail} ${style.red("The gateway is not reachable, so no action can be permitted.")}`
     );
-    const dangerous = plan.tools.filter((tool) => tool.dangerous).map((tool) => tool.key);
-    if (dangerous.length > 0) {
-      out(
-        `    ${style.grey(`flagged high impact (approval under the starter policy): ${dangerous.join(", ")}`)}`
-      );
-    }
+    out(style.grey("    Start it with `npm run dev:gateway`, then re-run `veefore dev`."));
+    out();
+    return 1;
   }
-  out(
-    `  ${symbol.bullet} A starter policy, in ${style.bold("OBSERVE")} mode: decisions are recorded, nothing is blocked yet`
-  );
-  if (plan.agentHeldSecrets.length > 0) {
+  if (environment.gatewayMode === "OBSERVE") {
     out();
     out(
-      style.grey(
-        `  Your agent keeps holding ${plan.agentHeldSecrets.join(", ")} for now. Veefore will decide every call
-  and record it, but a call that skips the SDK is not stopped until those keys move into
-  the Veefore credential broker. Setup does not read or move any secret.`
-      )
+      `  ${symbol.info} ${style.cyan("OBSERVE mode:")} every decision is evaluated and recorded, but nothing is blocked.`
     );
+    out(style.grey("    This is the safe way to learn what your agent actually does."));
   }
-}
-async function applyPlan(api, plan, scope, report = (line) => out(line), options = {}) {
-  const capabilityKeys = [
-    .../* @__PURE__ */ new Set([...plan.tools.map((t) => t.capability), ...plan.extraCapabilities])
-  ];
-  for (const tool of plan.tools) {
-    await createIfAbsent(
-      () => api.post("/v1/capabilities", {
-        key: tool.capability,
-        name: `Use ${tool.name}`.slice(0, 200),
-        description: tool.description.slice(0, 1e3),
-        dangerous: tool.dangerous
-      })
+  if (agent.isolated) {
+    out();
+    out(`  ${symbol.fail} ${style.red("This agent is isolated by an emergency control.")}`);
+  }
+  out();
+  out(style.grey("  Watching for decisions. Press Ctrl+C to stop."));
+  out();
+  const existing = await fetchActions(context, { limit: 5, agentId: context.config.agentId });
+  if (existing.length === 0) {
+    out(
+      `  ${symbol.info} No actions recorded yet. Call ${style.bold("agent.act({ tool: \u2026 })")} from your agent to see a decision here.`
     );
+    out();
+  } else {
+    renderActions(existing, flags.verbose);
   }
-  const keys = generateKeyPairSync("ed25519");
-  const publicKey = keys.publicKey.export({ type: "spki", format: "der" }).toString(
-    "base64"
-  );
-  const privateKey = keys.privateKey.export({ type: "pkcs8", format: "der" }).toString(
-    "base64"
-  );
-  const existing = options.newAgent ? null : await findExistingAgent(api, scope, plan.agentName);
-  let created;
-  if (existing) {
-    const rotated = await api.post(
-      `/v1/agents/${existing.id}/rotate-credentials`,
-      { public_key: publicKey, reason: "veefore setup re-run: new key generated on this machine" }
-    );
-    created = {
-      agent: { id: existing.id, name: existing.name },
-      identity: { key_id: rotated.key_id, fingerprint: rotated.fingerprint }
-    };
-    const held = new Set(
-      (await api.get(
-        `/v1/agents/${existing.id}/capabilities`
-      )).filter((grant) => !grant.revokedAt).map((grant) => grant.capabilityKey)
-    );
-    for (const key of capabilityKeys.filter((key2) => !held.has(key2))) {
-      await createIfAbsent(
-        () => api.post(`/v1/agents/${existing.id}/capabilities`, { capability_key: key })
-      );
-    }
-    report(
-      `${symbol.pass} Agent ${style.bold(existing.name)} reused ${style.grey(existing.id)}` + style.grey(
-        ` \u2014 new key issued; its delegations (${existing.delegations}) and grants stay in place`
-      )
-    );
-    if (existing.duplicates > 0) {
-      report(
-        `${symbol.warn} ${existing.duplicates} other agent${existing.duplicates === 1 ? "" : "s"} named "${existing.name}" exist${existing.duplicates === 1 ? "s" : ""} here. Suspend the ones you no longer use in the console (Agents).`
-      );
-    }
-  } else {
-    created = await api.post("/v1/agents", {
-      name: plan.agentName,
-      workspace_id: scope.workspaceId,
-      environment_id: scope.environmentId,
-      framework: scope.framework ?? void 0,
-      capabilities: capabilityKeys,
-      public_key: publicKey
-    });
-    report(
-      `${symbol.pass} Agent ${style.bold(created.agent.name)} created ${style.grey(created.agent.id)}`
+  return streamActions(context, {
+    agentId: args.includes("--all") ? void 0 : context.config.agentId,
+    seen: new Set(existing.map((action) => action.id)),
+    verbose: true,
+    json: false,
+    coach: true
+  });
+}
+async function fetchActions(context, options) {
+  const response = await context.api.get("/v1/actions", {
+    limit: options.limit ?? 25,
+    decision: options.decision,
+    agent_id: options.agentId,
+    environment_id: context.config.environmentId
+  });
+  return [...response.data].reverse();
+}
+function renderActions(actions, verbose) {
+  if (actions.length === 0) {
+    out(style.grey("  (no decisions yet)"));
+    return;
+  }
+  if (!verbose) {
+    table(
+      [
+        { header: "WHEN", key: "when", width: 12 },
+        { header: "TOOL", key: "tool", width: 24 },
+        { header: "DECISION", key: "decision", width: 20 },
+        { header: "OUTCOME", key: "outcome", width: 24 },
+        { header: "MS", key: "latency", width: 6, align: "right" }
+      ],
+      actions.map((action) => ({
+        when: formatWhen(action.startedAt),
+        tool: action.toolKey ?? action.action,
+        decision: decisionStyle(effectiveDecision(action)),
+        outcome: decisionStyle(action.outcome),
+        latency: String(Math.round(action.latencyMs))
+      }))
     );
-    if (options.newAgent) {
-      report(
-        `${symbol.warn} This is a new agent: delegations and amount limits set on any earlier "${created.agent.name}" do not apply to it. Requests with an amount wait for approval until you add a delegation.`
-      );
-    }
+    return;
   }
-  if (!created.identity) {
-    throw new Error("The agent was created without an identity.");
+  for (const action of actions) renderAction(action);
+}
+function effectiveDecision(action) {
+  return action.shadowDecision ?? action.decision ?? "UNKNOWN";
+}
+function renderAction(action, coach = false) {
+  const decision = effectiveDecision(action);
+  const icon = decision === "ALLOW" ? symbol.pass : decision === "BLOCK" ? symbol.fail : symbol.warn;
+  const amount = action.amount === null ? "" : style.grey(` ${formatAmount(action.amount, action.currency)}`);
+  out(
+    `${icon} ${style.grey(new Date(action.startedAt).toISOString().slice(11, 19))} ${style.bold(action.toolKey ?? action.action)}${amount} ${decisionStyle(decision)} ${style.grey(`(${action.outcome})`)}`
+  );
+  if (action.denyReason) out(`    ${action.denyReason}`);
+  const facts = [];
+  if (action.policyVersionNumber !== null) facts.push(`policy v${action.policyVersionNumber}`);
+  if (action.matchedRuleIds.length > 0)
+    facts.push(`${action.matchedRuleIds.length} rule(s) matched`);
+  if (action.riskLevel) facts.push(`risk ${action.riskLevel}`);
+  if (action.protocol !== "HTTP") facts.push(action.protocol);
+  if (action.gatewayMode !== "ENFORCE") facts.push(`mode ${action.gatewayMode}`);
+  facts.push(`${Math.round(action.latencyMs)}ms`);
+  out(`    ${style.grey(facts.join("  \xB7  "))}`);
+  if (coach) {
+    const hint = coachingFor(action);
+    if (hint) out(`    ${style.cyan("\u2192")} ${style.grey(hint)}`);
   }
-  const tools = [];
-  for (const tool of plan.tools) {
-    let toolId;
-    let reused = false;
+}
+function coachingFor(action) {
+  const decision = effectiveDecision(action);
+  if (action.gatewayMode === "OBSERVE" && decision !== "ALLOW") {
+    return `In ENFORCE mode this would have been ${decision}. Simulate before switching.`;
+  }
+  switch (decision) {
+    case "BLOCK":
+      return action.matchedRuleIds.length > 0 ? "Blocked by a policy rule. Adjust the rule, or grant the capability if this is legitimate." : "Blocked before policy evaluation. Check the tool is registered and the agent is authorized for it.";
+    case "REQUIRE_APPROVAL":
+      return "Call actWithApproval() so your agent waits for the reviewer instead of failing.";
+    case "LIMIT":
+      return "The amount was capped by policy. Read limits.appliedAmount from the decision.";
+    case "MASK":
+      return "Some fields were masked before reaching the tool. Check limits.maskedFields.";
+    case "STEP_UP_AUTH":
+      return "A human must re-authenticate. Agents cannot satisfy step-up on their own.";
+    default:
+      return null;
+  }
+}
+function formatAmount(minorUnits, currency) {
+  const major = (minorUnits / 100).toLocaleString("en-IN", {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2
+  });
+  return currency ? `${major} ${currency}` : major;
+}
+async function streamActions(context, options) {
+  let interval = 1e3;
+  let stopped = false;
+  const stop = () => {
+    stopped = true;
+  };
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
+  let blocked = 0;
+  let approvals = 0;
+  let allowed = 0;
+  while (!stopped) {
+    let fresh = [];
     try {
-      const registered = await api.post("/v1/tools", {
-        workspace_id: scope.workspaceId,
-        environment_id: scope.environmentId,
-        key: tool.key,
-        name: tool.name.slice(0, 200),
-        description: `${tool.description} (found at ${tool.location})`.slice(0, 2e3),
-        kind: "CLIENT",
-        required_capability: tool.capability,
-        destination_allowlist: tool.destinations,
-        risk_level: tool.riskLevel,
-        dangerous: tool.dangerous,
-        // Tells the gateway where the amount and currency are, so it neither
-        // guesses the unit nor assumes a currency.
-        ...tool.money?.amountParameter ? { amount_parameter: tool.money.amountParameter, amount_unit: tool.money.amountUnit } : {},
-        ...tool.money?.currencyParameter ? { currency_parameter: tool.money.currencyParameter } : {}
+      const recent = await fetchActions(context, {
+        limit: 50,
+        decision: options.decision,
+        agentId: options.agentId
       });
-      toolId = registered.id;
+      fresh = recent.filter((action) => !options.seen.has(action.id));
+      for (const action of fresh) options.seen.add(action.id);
     } catch (error) {
-      if (!(error instanceof CliApiError && error.code === "ALREADY_EXISTS")) throw error;
-      const existing2 = await findTool(api, scope, tool.key);
-      if (!existing2) throw error;
-      toolId = existing2;
-      reused = true;
+      out(
+        `${symbol.warn} ${style.amber("Lost contact with the control plane;")} ${style.grey(error instanceof Error ? error.message : String(error))}`
+      );
+      interval = Math.min(interval * 2, 15e3);
+      await delay(interval);
+      continue;
     }
-    await createIfAbsent(
-      () => api.post(`/v1/tools/${toolId}/agents`, { agent_id: created.agent.id })
-    );
-    tools.push({ key: tool.key, id: toolId, reused });
+    for (const action of fresh) {
+      if (options.json) {
+        out(JSON.stringify(action));
+      } else {
+        renderAction(action, options.coach);
+      }
+      const decision = effectiveDecision(action);
+      if (decision === "BLOCK") blocked += 1;
+      else if (decision === "REQUIRE_APPROVAL") approvals += 1;
+      else allowed += 1;
+    }
+    interval = fresh.length > 0 ? 1e3 : Math.min(interval * 1.5, 5e3);
+    await delay(interval);
   }
-  if (tools.length > 0) {
-    const reusedCount = tools.filter((tool) => tool.reused).length;
-    report(
-      `${symbol.pass} ${tools.length} tool${tools.length === 1 ? "" : "s"} authorized for this agent` + (reusedCount > 0 ? style.grey(` (${reusedCount} already registered, reused)`) : "")
+  if (!options.json) {
+    out();
+    out(
+      `  ${style.green(`${allowed} allowed`)}  ${style.amber(`${approvals} needing approval`)}  ${style.red(`${blocked} blocked`)}`
     );
+    out();
   }
-  return {
-    agentId: created.agent.id,
-    agentName: created.agent.name,
-    keyId: created.identity.key_id,
-    fingerprint: created.identity.fingerprint,
-    privateKey,
-    tools
-  };
+  return 0;
 }
-async function findExistingAgent(api, scope, name) {
-  const wanted = name.trim().toLowerCase();
-  const page2 = await api.get("/v1/agents", {
-    workspace_id: scope.workspaceId,
-    environment_id: scope.environmentId,
-    q: name.trim(),
-    limit: 100
-  });
-  const matches = page2.items.filter(
-    (agent) => agent.name.trim().toLowerCase() === wanted && agent.status !== "REVOKED"
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/commands/test.ts
+async function testCommand(args, flags) {
+  const context = await resolveContext(flags);
+  const toolFilter = valueFor(args, "--tool");
+  heading(
+    `Enforcement test \u2014 ${context.config.environmentName} (${context.config.environmentType})`
   );
-  if (matches.length === 0) return null;
-  const ranked = await Promise.all(
-    matches.map(async (agent) => {
-      const delegations = await api.get("/v1/delegations", {
-        subject_id: agent.id,
-        environment_id: scope.environmentId
-      }).then((result) => Array.isArray(result) ? result : result.items).catch(() => []);
-      return {
-        agent,
-        active: delegations.filter((delegation) => delegation.status === "ACTIVE").length
-      };
-    })
+  const results = [];
+  const record = (check, passed, detail) => {
+    results.push({ check, passed, detail });
+    out(`${passed ? symbol.pass : symbol.fail} ${check} ${style.grey(detail)}`);
+  };
+  const gateway = await probeGateway(context.config.gatewayUrl);
+  record(
+    "Gateway reachable",
+    gateway.reachable,
+    gateway.reachable ? `${context.config.gatewayUrl} \u2014 posture ${gateway.posture ?? "unknown"}` : gateway.error ?? "unreachable"
   );
-  ranked.sort(
-    (a, b) => b.active - a.active || (b.agent.createdAt ?? "").localeCompare(a.agent.createdAt ?? "")
+  const identities = await context.api.get(`/v1/agents/${context.config.agentId}/identities`).catch(() => []);
+  const activeIdentity = identities.find((identity) => identity.status === "ACTIVE");
+  record(
+    "Agent identity active",
+    Boolean(activeIdentity),
+    activeIdentity ? `generation ${activeIdentity.generation}, expires ${activeIdentity.expiresAt.slice(0, 10)}` : "no ACTIVE identity \u2014 the agent cannot authenticate"
   );
-  const best = ranked[0];
-  return {
-    id: best.agent.id,
-    name: best.agent.name,
-    delegations: best.active,
-    duplicates: matches.length - 1
-  };
-}
-async function createIfAbsent(call) {
-  try {
-    await call();
-  } catch (error) {
-    if (error instanceof CliApiError && (error.code === "ALREADY_EXISTS" || error.status === 409)) {
-      return;
+  const policies = await context.api.get("/v1/policies", { workspace_id: context.config.workspaceId });
+  const effective = policies.filter(
+    (policy) => policy.status === "ACTIVE" && policy.bindings.length > 0
+  );
+  record(
+    "Active, bound policy exists",
+    effective.length > 0,
+    effective.length > 0 ? effective.map((policy) => policy.name).join(", ") : "no active policy is bound to a scope, so no rule can match"
+  );
+  let caseTotal = 0;
+  let caseFailed = 0;
+  for (const policy of policies) {
+    const result = await context.api.post(`/v1/policies/${policy.id}/tests/run`, {}).catch(() => null);
+    if (!result) continue;
+    caseTotal += result.passed + result.failed;
+    caseFailed += result.failed;
+  }
+  record(
+    "Policy test cases",
+    caseFailed === 0,
+    caseTotal === 0 ? "no test cases recorded \u2014 add cases so rule changes are provable" : `${caseTotal - caseFailed}/${caseTotal} passing`
+  );
+  const tools = await resolveAuthorizedTools(context, toolFilter);
+  if (tools.length === 0) {
+    record(
+      "Authorized tools",
+      false,
+      "this agent is authorized for no tools, so it cannot do anything"
+    );
+  } else {
+    record("Authorized tools", true, tools.map((tool) => tool.key).join(", "));
+  }
+  heading("Decision probe (dry run \u2014 nothing is executed)");
+  const probes = [];
+  for (const tool of tools) {
+    const probeSpinner = spinner(`Evaluating ${tool.key}`);
+    try {
+      const outcome = await context.api.post("/v1/policies/simulate", {
+        agent_id: context.config.agentId,
+        tool: tool.key,
+        capability: tool.requiredCapability,
+        environment_id: context.config.environmentId,
+        parameters: {}
+      });
+      probeSpinner.succeed(`${tool.key} \u2192 ${outcome.decision}`);
+      probes.push({ tool, outcome });
+    } catch (error) {
+      probeSpinner.fail(`${tool.key} could not be evaluated`);
+      probes.push({
+        tool,
+        outcome: null,
+        error: error instanceof Error ? error.message : String(error)
+      });
     }
-    throw error;
   }
+  out();
+  table(
+    [
+      { header: "TOOL", key: "tool", width: 24 },
+      { header: "RISK", key: "risk", width: 18 },
+      { header: "DECISION", key: "decision", width: 20 },
+      { header: "MATCHED RULE", key: "rule", width: 32 }
+    ],
+    probes.map((probe) => ({
+      tool: probe.tool.dangerous ? `${probe.tool.key} ${style.red("(dangerous)")}` : probe.tool.key,
+      risk: decisionStyle(probe.tool.riskLevel),
+      decision: probe.outcome ? decisionStyle(probe.outcome.decision) : style.red("ERROR"),
+      rule: probe.outcome?.matchedRules[0]?.name ?? style.grey(probe.error ?? "default decision")
+    }))
+  );
+  const unguarded = probes.filter(
+    (probe) => probe.tool.dangerous && probe.outcome?.decision === "ALLOW" && probe.outcome.matchedRules.length === 0
+  );
+  out();
+  record(
+    "Dangerous tools are guarded",
+    unguarded.length === 0,
+    unguarded.length === 0 ? "every dangerous tool is either refused or matched by an explicit rule" : `${unguarded.map((probe) => probe.tool.key).join(", ")} allowed by the default decision with no rule`
+  );
+  const errored = probes.filter((probe) => probe.outcome === null);
+  record(
+    "All evaluations completed",
+    errored.length === 0,
+    errored.length === 0 ? `${probes.length} evaluated` : `${errored.length} failed to evaluate`
+  );
+  const impure = probes.filter((probe) => probe.outcome && probe.outcome.sideEffectFree !== true);
+  record(
+    "Simulation was side-effect free",
+    impure.length === 0,
+    impure.length === 0 ? "no action records were written" : "the server reported side effects"
+  );
+  const failed = results.filter((result) => !result.passed);
+  out();
+  out(
+    failed.length === 0 ? `  ${symbol.pass} ${style.green(`${results.length} check(s) passing.`)}` : `  ${symbol.fail} ${style.red(`${failed.length} of ${results.length} check(s) failing.`)}`
+  );
+  if (failed.length > 0) {
+    out();
+    for (const failure of failed) out(`    ${symbol.fail} ${failure.check}: ${failure.detail}`);
+  }
+  out();
+  if (flags.json) printJson({ results, probes });
+  return failed.length > 0 ? 1 : 0;
 }
-async function findTool(api, scope, key) {
-  const pageSize = 100;
-  for (let offset = 0; offset < 1e4; offset += pageSize) {
-    const page2 = await api.get("/v1/tools", {
-      workspace_id: scope.workspaceId,
-      environment_id: scope.environmentId,
-      limit: pageSize,
-      offset
-    });
-    const match = page2.items.find(
-      (tool) => tool.key === key && tool.environmentId === scope.environmentId
+async function resolveAuthorizedTools(context, filter) {
+  const tools = await context.api.get("/v1/tools", {
+    workspace_id: context.config.workspaceId,
+    agent_id: context.config.agentId,
+    limit: 100
+  });
+  const candidates = tools.items.filter(
+    (tool) => tool.status !== "DISABLED" && (tool.environmentId === null || tool.environmentId === context.config.environmentId)
+  );
+  if (!filter) return candidates;
+  const match = candidates.filter((tool) => tool.key === filter);
+  if (match.length === 0) {
+    throw new CliError(
+      `Tool "${filter}" is not available to this agent in ${context.config.environmentName}.`,
+      `Available: ${candidates.map((tool) => tool.key).join(", ") || "none"}`
     );
-    if (match) return match.id;
-    if (page2.items.length < pageSize || offset + pageSize >= page2.total) return null;
   }
-  return null;
+  return match;
 }
-function sourceLabel(source) {
-  switch (source) {
-    case "vercel-ai":
-      return "Vercel AI SDK";
-    case "langchain-js":
-    case "langchain-py":
-      return "LangChain";
-    case "openai-function":
-      return "OpenAI function";
-    case "openai-agents":
-    case "openai-agents-py":
-      return "OpenAI Agents SDK";
-    case "mcp":
-      return "MCP";
-    case "crewai":
-      return "CrewAI";
-    case "tool-schema":
-      return "tool definition";
+
+// src/report.ts
+function reportError(error, flags) {
+  if (error instanceof CliError) {
+    err();
+    err(`${style.red("\u2717")} ${error.message}`);
+    if (error.hint) err(style.grey(`  ${error.hint}`));
+    err();
+    return error.exitCode;
+  }
+  if (error instanceof CliApiError) {
+    err();
+    reportApiError(error);
+    err();
+    return 1;
   }
+  err();
+  err(`${style.red("\u2717")} ${error instanceof Error ? error.message : String(error)}`);
+  if (flags.verbose && error instanceof Error && error.stack) {
+    err(style.grey(error.stack));
+  } else {
+    err(style.grey("  Re-run with --verbose for the stack trace."));
+  }
+  err();
+  return 1;
 }
 
-// src/commands/init.ts
-var DEFAULT_GATEWAY = "http://localhost:4010";
-async function initCommand(args, flags) {
-  const options = parseInitArgs(args);
-  const existing = readProjectConfig();
-  if (existing && !options.force && process.stdin.isTTY && process.stdout.isTTY && !flags.json) {
-    return projectHome(existing, flags);
-  }
-  if (existing && !options.force) {
-    out();
-    out(`${symbol.warn} This project is already connected to Veefore.`);
-    details([
-      ["Agent", `${existing.agentName} (${existing.agentId})`],
-      ["Environment", `${existing.environmentName} (${existing.environmentType})`],
-      ["Control plane", existing.controlPlaneUrl]
-    ]);
-    out();
-    out(style.grey("Re-run with --force to replace the configuration, or use `veefore status`."));
-    return 0;
-  }
-  heading("Veefore init");
-  const framework = detectFramework();
+// src/setup.ts
+import { generateKeyPairSync } from "node:crypto";
+function buildPlan(scan, options = {}) {
+  return {
+    agentName: (options.agentName ?? scan.projectName ?? "my-agent").slice(0, 200),
+    tools: scan.tools.map(planTool),
+    agentHeldSecrets: scan.secrets.filter((s) => s.kind === "service").map((s) => s.name),
+    modelSecrets: scan.secrets.filter((s) => s.kind === "model").map((s) => s.name),
+    extraCapabilities: options.extraCapabilities ?? []
+  };
+}
+function planTool(tool) {
+  return {
+    key: tool.key,
+    name: tool.name,
+    description: tool.description ?? `Detected ${sourceLabel(tool.source)} tool.`,
+    // One capability per tool keeps authority explicit: granting the agent this
+    // tool grants nothing else. `tool.<key>` satisfies `resource.action`.
+    capability: `tool.${tool.key}`,
+    riskLevel: tool.riskLevel,
+    dangerous: tool.dangerous,
+    destinations: tool.hosts,
+    location: `${tool.location.file}:${tool.location.line}`,
+    money: tool.money ?? null
+  };
+}
+function printScan(scan) {
   out(
-    `${symbol.pass} Framework: ${style.bold(framework.name)} ${style.grey(`(${framework.language}, matched ${framework.evidence})`)}`
+    `${symbol.pass} Scanned ${scan.filesScanned} file${scan.filesScanned === 1 ? "" : "s"}` + (scan.truncated ? style.amber(" (limit reached; findings may be incomplete)") : "") + style.grey(" \u2014 locally, nothing was uploaded")
   );
-  if (framework.key === "unknown") {
+  if (scan.tools.length === 0) {
+    out(`${symbol.warn} No tools found, so there is nothing for Veefore to decide on yet.`);
+    out(style.grey("    Tools are found where they are declared for the model to call, not from"));
     out(
       style.grey(
-        "  No manifest was found. Veefore will still work; the integration snippet defaults to TypeScript."
+        scan.framework.language === "python" ? "    plain functions: @tool, @function_tool, @mcp.tool, Tool(name=\u2026), or a dict" : '    plain functions: tool({\u2026}), DynamicStructuredTool, { type: "function" },'
       )
     );
-  }
-  const found = await locateControlPlane(options.controlPlaneUrl ?? flags.controlPlaneUrl);
-  const controlPlaneUrl = found.controlPlaneUrl;
-  if (found.source !== "entered") {
     out(
-      `${symbol.pass} Veefore: ${style.bold(controlPlaneUrl)} ${style.grey(`(${found.source})`)}`
+      style.grey(
+        scan.framework.language === "python" ? "    with name, description and an input schema." : "    server.tool(\u2026), or an object with name, description and parameters."
+      )
     );
+    out(style.grey("    Register them in the console, or add them and run `veefore scan` again."));
+  } else {
+    out(`${symbol.pass} Found ${scan.tools.length} tool${scan.tools.length === 1 ? "" : "s"}:`);
+    for (const tool of scan.tools) {
+      const label = tool.riskLevel.padEnd(7);
+      const risk = tool.riskLevel === "HIGH" ? style.red(label) : tool.riskLevel === "MEDIUM" ? style.amber(label) : style.green(label);
+      out(
+        `    ${style.bold(tool.key.padEnd(24))} ${risk} ${style.grey(`${tool.location.file}:${tool.location.line}`)}`
+      );
+      if (tool.hosts.length > 0) out(style.grey(`      calls ${tool.hosts.join(", ")}`));
+    }
   }
-  let session = loadSession(controlPlaneUrl);
-  if (!session) {
-    await login(controlPlaneUrl);
-    session = loadSession(controlPlaneUrl);
-  }
-  if (!session) throw new CliError("Sign-in did not produce a usable session.");
-  const api = new ApiClient({ controlPlaneUrl, token: session.token });
-  const me = await api.get("/v1/auth/session");
-  const organization = await selectOrganization(api, me, options, flags);
-  const workspace = await selectWorkspace(api, me, options, flags);
-  const environment = await selectEnvironment(api, me, workspace.id, options, flags);
-  if (environment.type === "PRODUCTION" && !options.force) {
-    out();
+  const service = scan.secrets.filter((s) => s.kind === "service");
+  if (service.length > 0) {
     out(
-      `${symbol.warn} ${style.amber("You selected a PRODUCTION environment.")} A new agent here starts in ${style.bold("OBSERVE")} mode and performs no enforcement until you switch it.`
+      `${symbol.warn} Your code reads ${service.length} credential${service.length === 1 ? "" : "s"}: ${service.map((s) => s.name).join(", ")} ${style.grey("(names only; values were not read)")}`
     );
-    const proceed2 = await confirm("Continue with the production environment?", { yes: flags.yes });
-    if (!proceed2) {
-      out(style.grey("Cancelled. Re-run and choose a development environment."));
-      return 1;
-    }
-  }
-  heading("Looking at your project");
-  const scan = scanProject(process.cwd());
-  printScan(scan);
-  const plan = buildPlan(scan, {
-    agentName: options.agentName,
-    extraCapabilities: options.capabilities
-  });
-  if (!options.agentName && !flags.yes) {
-    plan.agentName = await ask(`Agent name ${style.grey(`[${plan.agentName}]`)}:`, plan.agentName);
   }
-  printPlan2(plan, environment);
+}
+function printPlan2(plan, environment) {
   out();
-  const proceed = await confirm("Set this up?", { yes: flags.yes });
-  if (!proceed) {
-    out(style.grey("Nothing was created. Run `veefore init` again when you are ready."));
-    return 1;
-  }
-  heading("Setting up");
-  let created;
-  try {
-    created = await applyPlan(
-      api,
-      plan,
-      {
-        workspaceId: workspace.id,
-        environmentId: environment.id,
-        framework: framework.key === "unknown" ? null : framework.key
-      },
-      void 0,
-      { newAgent: options.newAgent === true }
+  out(style.bold("Veefore will set up"));
+  out(
+    `  ${symbol.bullet} Agent ${style.bold(plan.agentName)} in ${environment.name} (${environment.type})`
+  );
+  out(
+    `    ${style.grey("with its own key pair, generated here. The private key never leaves this machine.")}`
+  );
+  if (plan.tools.length > 0) {
+    out(
+      `  ${symbol.bullet} ${plan.tools.length} tool${plan.tools.length === 1 ? "" : "s"}, each with its own capability, authorized for this agent only`
     );
-  } catch (error) {
-    if (error instanceof CliApiError && error.code === "PERMISSION_DENIED") {
-      throw new CliError(
-        "Your role cannot set up agents in this workspace.",
-        'Ask an owner or admin for the "agent:create" and "tool:create" permissions.'
-      );
-    }
-    throw error;
-  }
-  let gatewayUrl = options.gatewayUrl ?? flags.gatewayUrl ?? process.env.VEEFORE_GATEWAY_URL;
-  if (!gatewayUrl) {
-    const published = (await controlPlaneInfo(controlPlaneUrl)).gatewayUrl;
-    if (published && await gatewayReachable(published)) {
-      gatewayUrl = published;
-      out(
-        `${symbol.pass} Gateway: ${style.bold(published)} ${style.grey("(published by the control plane)")}`
-      );
-    } else {
-      const suggestion = published ?? DEFAULT_GATEWAY;
+    const dangerous = plan.tools.filter((tool) => tool.dangerous).map((tool) => tool.key);
+    if (dangerous.length > 0) {
       out(
-        `${symbol.warn} ${published ? `The gateway at ${published} is not answering.` : "The control plane did not publish a gateway address."}`
+        `    ${style.grey(`flagged high impact (approval under the starter policy): ${dangerous.join(", ")}`)}`
       );
-      gatewayUrl = await ask(`Gateway URL ${style.grey(`[${suggestion}]`)}:`, suggestion);
     }
   }
-  gatewayUrl = normalizeUrl(gatewayUrl);
-  const config = {
-    version: 1,
-    controlPlaneUrl,
-    gatewayUrl,
-    organizationId: organization.id,
-    organizationName: organization.name,
-    workspaceId: workspace.id,
-    workspaceName: workspace.name,
-    environmentId: environment.id,
-    environmentName: environment.name,
-    environmentType: environment.type,
-    agentId: created.agentId,
-    agentName: created.agentName,
-    keyId: created.keyId,
-    framework: framework.key === "unknown" ? null : framework.key,
-    declaredTools: created.tools.map((tool) => tool.key),
-    createdAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  const configFile = writeProjectConfig(config);
   out(
-    `${symbol.pass} Wrote ${style.bold("veefore.config.json")} ${style.grey("(safe to commit)")}`
+    `  ${symbol.bullet} A starter policy, in ${style.bold("OBSERVE")} mode: decisions are recorded, nothing is blocked yet`
   );
-  const audience = await discoverAudience(gatewayUrl);
-  ensureGitignore(process.cwd(), [".env.local", ".veefore/"]);
-  const approvalMode = options.approvalMode ?? previousApprovalMode() ?? "wait";
-  const envFile = writeLocalEnv({
-    VEEFORE_GATEWAY_URL: gatewayUrl,
-    VEEFORE_GATEWAY_AUDIENCE: audience,
-    VEEFORE_AGENT_ID: created.agentId,
-    VEEFORE_AGENT_KEY_ID: created.keyId,
-    VEEFORE_AGENT_PRIVATE_KEY: created.privateKey,
-    ...created.tools.length > 0 ? { VEEFORE_DECLARED_TOOLS: created.tools.map((tool) => tool.key).join(",") } : {},
-    // Written explicitly so the behaviour is visible and editable in one place.
-    VEEFORE_APPROVAL_MODE: approvalMode
-  });
-  if (audience !== gatewayUrl) {
+  if (plan.agentHeldSecrets.length > 0) {
+    out();
     out(
-      `${symbol.info} Gateway audience is ${style.bold(audience)} ${style.grey(
-        `(it reports this, rather than the ${gatewayUrl} you dialled)`
-      )}`
+      style.grey(
+        `  Your agent keeps holding ${plan.agentHeldSecrets.join(", ")} for now. Veefore will decide every call
+  and record it, but a call that skips the SDK is not stopped until those keys move into
+  the Veefore credential broker. Setup does not read or move any secret.`
+      )
     );
   }
-  out(
-    `${symbol.pass} Wrote agent credentials to ${style.bold(".env.local")} ${style.grey("(mode 0600, gitignored)")}`
-  );
-  out();
-  out(
-    `  ${style.amber("The private key was generated here and written to that file only.")} Veefore`
-  );
-  out(
-    `  never received it and cannot recover it. Move it into your secret manager before deploying.`
-  );
-  out(`  ${style.grey(`Fingerprint: ${created.fingerprint}`)}`);
-  await configureStarterPolicy(api, workspace.id, flags, options);
-  let integrated = false;
-  if (created.tools.length > 0 && !options.skipCode) {
-    const outcome = await integrate(
-      process.cwd(),
-      created.tools.map((tool) => tool.key),
-      { yes: flags.yes, quiet: flags.json, api }
+}
+async function applyPlan(api, plan, scope, report = (line) => out(line), options = {}) {
+  const capabilityKeys = [
+    .../* @__PURE__ */ new Set([...plan.tools.map((t) => t.capability), ...plan.extraCapabilities])
+  ];
+  for (const tool of plan.tools) {
+    await createIfAbsent(
+      () => api.post("/v1/capabilities", {
+        key: tool.capability,
+        name: `Use ${tool.name}`.slice(0, 200),
+        description: tool.description.slice(0, 1e3),
+        dangerous: tool.dangerous
+      })
     );
-    integrated = outcome.status === "applied" || outcome.status === "nothing-to-do";
-  }
-  heading("Validating the connection");
-  const checks = await validateConnection(api, gatewayUrl, created.agentId, environment.id);
-  for (const check of checks) {
-    const icon = check.status === "pass" ? symbol.pass : check.status === "warn" ? symbol.warn : symbol.fail;
-    out(`${icon} ${check.name}${check.message ? style.grey(` \u2014 ${check.message}`) : ""}`);
   }
-  const failed = checks.filter((check) => check.status === "fail");
-  if (!integrated) {
-    heading("Protect each tool");
-    out();
-    for (const line of integrationSnippet(framework).split("\n")) {
-      out(`  ${style.cyan(line)}`);
+  const keys = generateKeyPairSync("ed25519");
+  const publicKey = keys.publicKey.export({ type: "spki", format: "der" }).toString(
+    "base64"
+  );
+  const privateKey = keys.privateKey.export({ type: "pkcs8", format: "der" }).toString(
+    "base64"
+  );
+  const existing = options.newAgent ? null : await findExistingAgent(api, scope, plan.agentName);
+  let created;
+  if (existing) {
+    const rotated = await api.post(
+      `/v1/agents/${existing.id}/rotate-credentials`,
+      { public_key: publicKey, reason: "veefore setup re-run: new key generated on this machine" }
+    );
+    created = {
+      agent: { id: existing.id, name: existing.name },
+      identity: { key_id: rotated.key_id, fingerprint: rotated.fingerprint }
+    };
+    const held = new Set(
+      (await api.get(
+        `/v1/agents/${existing.id}/capabilities`
+      )).filter((grant) => !grant.revokedAt).map((grant) => grant.capabilityKey)
+    );
+    for (const key of capabilityKeys.filter((key2) => !held.has(key2))) {
+      await createIfAbsent(
+        () => api.post(`/v1/agents/${existing.id}/capabilities`, { capability_key: key })
+      );
     }
-    const entryPoints = findEntryPoints();
-    if (entryPoints.length > 0) {
-      out();
-      out(
-        style.grey(
-          `  Likely entry point${entryPoints.length > 1 ? "s" : ""}: ${entryPoints.join(", ")}`
-        )
+    report(
+      `${symbol.pass} Agent ${style.bold(existing.name)} reused ${style.grey(existing.id)}` + style.grey(
+        ` \u2014 new key issued; its delegations (${existing.delegations}) and grants stay in place`
+      )
+    );
+    if (existing.duplicates > 0) {
+      report(
+        `${symbol.warn} ${existing.duplicates} other agent${existing.duplicates === 1 ? "" : "s"} named "${existing.name}" exist${existing.duplicates === 1 ? "s" : ""} here. Suspend the ones you no longer use in the console (Agents).`
       );
     }
-    if (created.tools.length > 0) {
-      out(style.grey("  Or let Veefore wrap your tools for you: `veefore integrate`."));
+  } else {
+    created = await api.post("/v1/agents", {
+      name: plan.agentName,
+      workspace_id: scope.workspaceId,
+      environment_id: scope.environmentId,
+      framework: scope.framework ?? void 0,
+      capabilities: capabilityKeys,
+      public_key: publicKey
+    });
+    report(
+      `${symbol.pass} Agent ${style.bold(created.agent.name)} created ${style.grey(created.agent.id)}`
+    );
+    if (options.newAgent) {
+      report(
+        `${symbol.warn} This is a new agent: delegations and amount limits set on any earlier "${created.agent.name}" do not apply to it. Requests with an amount wait for approval until you add a delegation.`
+      );
     }
   }
-  heading("When a human must approve");
-  for (const line of approvalModeExplanation(approvalMode)) out(line);
-  heading("Next");
-  out(`  ${symbol.bullet} ${style.bold("veefore dev")}     watch decisions live while you build`);
-  out(
-    `  ${symbol.bullet} ${style.bold("veefore doctor")}  check the security posture of this setup`
-  );
-  out(`  ${symbol.bullet} ${style.bold("veefore status")}  see the current mode and agent health`);
-  out();
-  out(
-    style.grey(
-      `  This environment is in ${environment.gatewayMode ?? "OBSERVE"} mode. Nothing is blocked yet.`
-    )
-  );
-  out(style.grey("  Review the recommended policy, simulate it, then switch to ENFORCE."));
-  out();
-  if (flags.json) {
-    out(
-      JSON.stringify(
-        {
-          config_file: configFile,
-          env_file: envFile,
-          agent_id: created.agentId,
-          key_id: created.keyId,
-          fingerprint: created.fingerprint,
-          tools: created.tools,
-          checks
-        },
-        null,
-        2
-      )
+  if (!created.identity) {
+    throw new Error("The agent was created without an identity.");
+  }
+  const tools = [];
+  for (const tool of plan.tools) {
+    let toolId;
+    let reused = false;
+    try {
+      const registered = await api.post("/v1/tools", {
+        workspace_id: scope.workspaceId,
+        environment_id: scope.environmentId,
+        key: tool.key,
+        name: tool.name.slice(0, 200),
+        description: `${tool.description} (found at ${tool.location})`.slice(0, 2e3),
+        kind: "CLIENT",
+        required_capability: tool.capability,
+        destination_allowlist: tool.destinations,
+        risk_level: tool.riskLevel,
+        dangerous: tool.dangerous,
+        // Tells the gateway where the amount and currency are, so it neither
+        // guesses the unit nor assumes a currency.
+        ...tool.money?.amountParameter ? { amount_parameter: tool.money.amountParameter, amount_unit: tool.money.amountUnit } : {},
+        ...tool.money?.currencyParameter ? { currency_parameter: tool.money.currencyParameter } : {}
+      });
+      toolId = registered.id;
+    } catch (error) {
+      if (!(error instanceof CliApiError && error.code === "ALREADY_EXISTS")) throw error;
+      const existing2 = await findTool(api, scope, tool.key);
+      if (!existing2) throw error;
+      toolId = existing2;
+      reused = true;
+    }
+    await createIfAbsent(
+      () => api.post(`/v1/tools/${toolId}/agents`, { agent_id: created.agent.id })
     );
+    tools.push({ key: tool.key, id: toolId, reused });
   }
-  return failed.length > 0 ? 1 : 0;
+  if (tools.length > 0) {
+    const reusedCount = tools.filter((tool) => tool.reused).length;
+    report(
+      `${symbol.pass} ${tools.length} tool${tools.length === 1 ? "" : "s"} authorized for this agent` + (reusedCount > 0 ? style.grey(` (${reusedCount} already registered, reused)`) : "")
+    );
+  }
+  return {
+    agentId: created.agent.id,
+    agentName: created.agent.name,
+    keyId: created.identity.key_id,
+    fingerprint: created.identity.fingerprint,
+    privateKey,
+    tools
+  };
 }
-function previousApprovalMode(dir = process.cwd()) {
+async function findExistingAgent(api, scope, name) {
+  const wanted = name.trim().toLowerCase();
+  const page2 = await api.get("/v1/agents", {
+    workspace_id: scope.workspaceId,
+    environment_id: scope.environmentId,
+    q: name.trim(),
+    limit: 100
+  });
+  const matches = page2.items.filter(
+    (agent) => agent.name.trim().toLowerCase() === wanted && agent.status !== "REVOKED"
+  );
+  if (matches.length === 0) return null;
+  const ranked = await Promise.all(
+    matches.map(async (agent) => {
+      const delegations = await api.get("/v1/delegations", {
+        subject_id: agent.id,
+        environment_id: scope.environmentId
+      }).then((result) => Array.isArray(result) ? result : result.items).catch(() => []);
+      return {
+        agent,
+        active: delegations.filter((delegation) => delegation.status === "ACTIVE").length
+      };
+    })
+  );
+  ranked.sort(
+    (a, b) => b.active - a.active || (b.agent.createdAt ?? "").localeCompare(a.agent.createdAt ?? "")
+  );
+  const best = ranked[0];
+  return {
+    id: best.agent.id,
+    name: best.agent.name,
+    delegations: best.active,
+    duplicates: matches.length - 1
+  };
+}
+async function createIfAbsent(call) {
   try {
-    const text = readFileSync9(path10.join(dir, ".env.local"), "utf8");
-    const value = /^\s*VEEFORE_APPROVAL_MODE\s*=\s*['"]?(\w+)/m.exec(text)?.[1]?.toLowerCase();
-    return value === "wait" || value === "throw" ? value : null;
-  } catch {
-    return null;
+    await call();
+  } catch (error) {
+    if (error instanceof CliApiError && (error.code === "ALREADY_EXISTS" || error.status === 409)) {
+      return;
+    }
+    throw error;
   }
 }
-function approvalModeExplanation(mode) {
-  if (mode === "wait") {
-    return [
-      `  Guarded tools ${style.bold("wait")} for the reviewer's decision, then:`,
-      `    ${symbol.bullet} approved: the tool runs once and returns its real result`,
-      `    ${symbol.bullet} denied, cancelled or expired: it fails with that reason, and nothing runs`,
-      style.grey(
-        "  The agent process must stay running while it waits (up to the approval's expiry)."
-      ),
-      style.grey(
-        "  For chat agents that should hand the question back instead, set VEEFORE_APPROVAL_MODE=throw"
-      ),
-      style.grey("  in .env.local, or pass { waitForApproval: false } to a single guard().")
-    ];
+async function findTool(api, scope, key) {
+  const pageSize = 100;
+  for (let offset = 0; offset < 1e4; offset += pageSize) {
+    const page2 = await api.get("/v1/tools", {
+      workspace_id: scope.workspaceId,
+      environment_id: scope.environmentId,
+      limit: pageSize,
+      offset
+    });
+    const match = page2.items.find(
+      (tool) => tool.key === key && tool.environmentId === scope.environmentId
+    );
+    if (match) return match.id;
+    if (page2.items.length < pageSize || offset + pageSize >= page2.total) return null;
   }
-  return [
-    `  Guarded tools ${style.bold("return immediately")} with "approval required" (VeeforeApprovalRequiredError),`,
-    "  carrying the approval id. Your agent must resubmit the same call after a reviewer approves,",
-    "  or the action never happens.",
-    style.grey("  To wait for the decision instead, set VEEFORE_APPROVAL_MODE=wait in .env.local.")
-  ];
+  return null;
 }
-async function selectOrganization(api, me, options, flags) {
-  const organizations = me.organizations.length > 0 ? me.organizations : [
-    {
-      id: me.organization.id,
-      name: me.organization.name,
-      slug: me.organization.slug,
-      roleKey: me.roleKey
-    }
-  ];
-  if (options.organizationId) {
-    const match = organizations.find((org) => org.id === options.organizationId);
-    if (!match) {
-      throw new CliError(
-        `You are not a member of organization ${options.organizationId}.`,
-        `Available: ${organizations.map((org) => org.id).join(", ")}`
-      );
-    }
-    return match;
+function sourceLabel(source) {
+  switch (source) {
+    case "vercel-ai":
+      return "Vercel AI SDK";
+    case "langchain-js":
+    case "langchain-py":
+      return "LangChain";
+    case "openai-function":
+      return "OpenAI function";
+    case "openai-agents":
+    case "openai-agents-py":
+      return "OpenAI Agents SDK";
+    case "mcp":
+      return "MCP";
+    case "crewai":
+      return "CrewAI";
+    case "tool-schema":
+      return "tool definition";
   }
-  if (organizations.length === 1 || flags.yes) {
-    const chosen2 = organizations[0];
-    if (!chosen2) throw new CliError("Your account is not a member of any organization.");
-    out(`${symbol.pass} Organization: ${style.bold(chosen2.name)}`);
-    return chosen2;
+}
+
+// src/commands/init.ts
+var DEFAULT_GATEWAY = "http://localhost:4010";
+async function initCommand(args, flags) {
+  const options = parseInitArgs(args);
+  const existing = readProjectConfig();
+  if (existing && !options.force && process.stdin.isTTY && process.stdout.isTTY && !flags.json) {
+    return projectHome(existing, flags);
   }
-  out();
-  out(style.bold("Select an organization"));
-  table(
-    [
-      { header: "#", key: "index", align: "right" },
-      { header: "NAME", key: "name" },
-      { header: "ROLE", key: "role" },
-      { header: "ID", key: "id" }
-    ],
-    organizations.map((org, index) => ({
-      index: String(index + 1),
-      name: org.name,
-      role: org.roleKey,
-      id: org.id
-    }))
+  if (existing && !options.force) {
+    out();
+    out(`${symbol.warn} This project is already connected to Veefore.`);
+    details([
+      ["Agent", `${existing.agentName} (${existing.agentId})`],
+      ["Environment", `${existing.environmentName} (${existing.environmentType})`],
+      ["Control plane", existing.controlPlaneUrl]
+    ]);
+    out();
+    out(style.grey("Re-run with --force to replace the configuration, or use `veefore status`."));
+    return 0;
+  }
+  heading("Veefore init");
+  const framework = detectFramework();
+  out(
+    `${symbol.pass} Framework: ${style.bold(framework.name)} ${style.grey(`(${framework.language}, matched ${framework.evidence})`)}`
   );
-  const chosen = organizations[await pickIndex(organizations.length)];
-  if (!chosen) throw new CliError("No organization selected.");
-  await api.post("/v1/auth/scope", { organization_id: chosen.id });
-  out(`${symbol.pass} Organization: ${style.bold(chosen.name)}`);
-  return chosen;
-}
-async function selectWorkspace(api, me, options, flags) {
-  const workspaces = me.workspaces.length > 0 ? me.workspaces : await api.get("/v1/workspaces");
-  if (workspaces.length === 0) {
-    throw new CliError(
-      "This organization has no workspaces.",
-      "Create one in the console, or ask an admin to."
+  if (framework.key === "unknown") {
+    out(
+      style.grey(
+        "  No manifest was found. Veefore will still work; the integration snippet defaults to TypeScript."
+      )
     );
   }
-  if (options.workspaceId) {
-    const match = workspaces.find((workspace) => workspace.id === options.workspaceId);
-    if (!match) throw new CliError(`Workspace ${options.workspaceId} was not found.`);
-    return match;
+  const found = await locateControlPlane(options.controlPlaneUrl ?? flags.controlPlaneUrl);
+  const controlPlaneUrl = found.controlPlaneUrl;
+  if (found.source !== "entered") {
+    out(
+      `${symbol.pass} Veefore: ${style.bold(controlPlaneUrl)} ${style.grey(`(${found.source})`)}`
+    );
   }
-  if (workspaces.length === 1 || flags.yes) {
-    const chosen2 = workspaces[0];
-    out(`${symbol.pass} Workspace: ${style.bold(chosen2.name)}`);
-    return chosen2;
+  let session = loadSession(controlPlaneUrl);
+  if (!session) {
+    await login(controlPlaneUrl);
+    session = loadSession(controlPlaneUrl);
   }
-  out();
-  out(style.bold("Select a workspace"));
-  table(
-    [
-      { header: "#", key: "index", align: "right" },
-      { header: "NAME", key: "name" },
-      { header: "ID", key: "id" }
-    ],
-    workspaces.map((workspace, index) => ({
-      index: String(index + 1),
-      name: workspace.name,
-      id: workspace.id
-    }))
-  );
-  const chosen = workspaces[await pickIndex(workspaces.length)];
-  if (!chosen) throw new CliError("No workspace selected.");
-  out(`${symbol.pass} Workspace: ${style.bold(chosen.name)}`);
-  return chosen;
-}
-async function selectEnvironment(api, me, workspaceId, options, flags) {
-  const all = me.environments.length > 0 ? me.environments : await api.get("/v1/environments", { workspace_id: workspaceId });
-  const environments = all.filter((environment) => environment.workspaceId === workspaceId);
-  if (environments.length === 0) {
-    throw new CliError(
-      "That workspace has no environments.",
-      "Create one in the console, or ask an admin to."
+  if (!session) throw new CliError("Sign-in did not produce a usable session.");
+  const api = new ApiClient({ controlPlaneUrl, token: session.token });
+  const me = await api.get("/v1/auth/session");
+  const organization = await selectOrganization(api, me, options, flags);
+  const workspace = await selectWorkspace(api, me, options, flags);
+  const environment = await selectEnvironment(api, me, workspace.id, options, flags);
+  if (environment.type === "PRODUCTION" && !options.force) {
+    out();
+    out(
+      `${symbol.warn} ${style.amber("You selected a PRODUCTION environment.")} A new agent here starts in ${style.bold("OBSERVE")} mode and performs no enforcement until you switch it.`
     );
+    const proceed2 = await confirm("Continue with the production environment?", { yes: flags.yes });
+    if (!proceed2) {
+      out(style.grey("Cancelled. Re-run and choose a development environment."));
+      return 1;
+    }
   }
-  if (options.environmentId) {
-    const match = environments.find((environment) => environment.id === options.environmentId);
-    if (!match) throw new CliError(`Environment ${options.environmentId} was not found.`);
-    return match;
-  }
-  if (flags.yes) {
-    const chosen2 = environments.find((environment) => environment.type === "DEVELOPMENT") ?? environments[0];
-    out(`${symbol.pass} Environment: ${style.bold(chosen2.name)} (${chosen2.type})`);
-    return chosen2;
+  heading("Looking at your project");
+  const scan = scanProject(process.cwd());
+  printScan(scan);
+  const plan = buildPlan(scan, {
+    agentName: options.agentName,
+    extraCapabilities: options.capabilities
+  });
+  if (!options.agentName && !flags.yes) {
+    plan.agentName = await ask(`Agent name ${style.grey(`[${plan.agentName}]`)}:`, plan.agentName);
   }
+  printPlan2(plan, environment);
   out();
-  out(style.bold("Select an environment"));
-  table(
-    [
-      { header: "#", key: "index", align: "right" },
-      { header: "NAME", key: "name" },
-      { header: "TYPE", key: "type" },
-      { header: "MODE", key: "mode" },
-      { header: "ID", key: "id" }
-    ],
-    environments.map((environment, index) => ({
-      index: String(index + 1),
-      name: environment.name,
-      type: environment.type,
-      mode: environment.gatewayMode ?? "\u2014",
-      id: environment.id
-    }))
-  );
-  const chosen = environments[await pickIndex(environments.length)];
-  if (!chosen) throw new CliError("No environment selected.");
-  out(`${symbol.pass} Environment: ${style.bold(chosen.name)} (${chosen.type})`);
-  return chosen;
-}
-async function discoverAudience(gatewayUrl) {
-  try {
-    const response = await fetch(`${gatewayUrl}/.well-known/veefore-platform-key`, {
-      headers: { accept: "application/json" }
-    });
-    if (!response.ok) return gatewayUrl;
-    const body = await response.json();
-    const audience = body.data?.audience;
-    return typeof audience === "string" && audience !== "" ? audience : gatewayUrl;
-  } catch {
-    return gatewayUrl;
+  const proceed = await confirm("Set this up?", { yes: flags.yes });
+  if (!proceed) {
+    out(style.grey("Nothing was created. Run `veefore init` again when you are ready."));
+    return 1;
   }
-}
-async function pickIndex(count) {
-  for (let attempt = 0; attempt < 3; attempt += 1) {
-    const answer = await ask(`Choice [1-${count}]:`, "1");
-    const index = Number(answer) - 1;
-    if (Number.isInteger(index) && index >= 0 && index < count) return index;
-    out(style.amber(`  Enter a number between 1 and ${count}.`));
+  heading("Setting up");
+  let created;
+  try {
+    created = await applyPlan(
+      api,
+      plan,
+      {
+        workspaceId: workspace.id,
+        environmentId: environment.id,
+        framework: framework.key === "unknown" ? null : framework.key
+      },
+      void 0,
+      { newAgent: options.newAgent === true }
+    );
+  } catch (error) {
+    if (error instanceof CliApiError && error.code === "PERMISSION_DENIED") {
+      throw new CliError(
+        "Your role cannot set up agents in this workspace.",
+        'Ask an owner or admin for the "agent:create" and "tool:create" permissions.'
+      );
+    }
+    throw error;
   }
-  throw new CliError("No valid selection was made.");
-}
-async function configureStarterPolicy(api, workspaceId, flags, options) {
-  if (options.skipPolicy) {
-    out(`${symbol.info} Skipped starter policy (--skip-policy).`);
-    return;
+  let gatewayUrl = options.gatewayUrl ?? flags.gatewayUrl ?? process.env.VEEFORE_GATEWAY_URL;
+  if (!gatewayUrl) {
+    const published = (await controlPlaneInfo(controlPlaneUrl)).gatewayUrl;
+    if (published && await gatewayReachable(published)) {
+      gatewayUrl = published;
+      out(
+        `${symbol.pass} Gateway: ${style.bold(published)} ${style.grey("(published by the control plane)")}`
+      );
+    } else {
+      const suggestion = published ?? DEFAULT_GATEWAY;
+      out(
+        `${symbol.warn} ${published ? `The gateway at ${published} is not answering.` : "The control plane did not publish a gateway address."}`
+      );
+      gatewayUrl = await ask(`Gateway URL ${style.grey(`[${suggestion}]`)}:`, suggestion);
+    }
   }
-  const existing = await api.get(
-    "/v1/policies",
-    { workspace_id: workspaceId }
+  gatewayUrl = normalizeUrl(gatewayUrl);
+  const config = {
+    version: 1,
+    controlPlaneUrl,
+    gatewayUrl,
+    organizationId: organization.id,
+    organizationName: organization.name,
+    workspaceId: workspace.id,
+    workspaceName: workspace.name,
+    environmentId: environment.id,
+    environmentName: environment.name,
+    environmentType: environment.type,
+    agentId: created.agentId,
+    agentName: created.agentName,
+    keyId: created.keyId,
+    framework: framework.key === "unknown" ? null : framework.key,
+    declaredTools: created.tools.map((tool) => tool.key),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const configFile = writeProjectConfig(config);
+  out(
+    `${symbol.pass} Wrote ${style.bold("veefore.config.json")} ${style.grey("(safe to commit)")}`
   );
-  const count = Array.isArray(existing) ? existing.length : existing.items?.length ?? 0;
-  if (count > 0) {
-    out(`${symbol.pass} Workspace already has ${count} policy/policies. Leaving them alone.`);
-    return;
-  }
-  const create = flags.yes ? true : await confirm("Create a starter policy with safe defaults?", { yes: flags.yes });
-  if (!create) {
-    out(style.grey("  Skipped. Create one later from a template in the console."));
-    return;
-  }
-  const policySpinner = spinner("Creating starter policy from the safe-defaults template");
-  try {
-    const result = await api.post("/v1/policies", {
-      workspace_id: workspaceId,
-      name: "Starter \u2014 safe defaults",
-      template_key: "starter-observe-safe-defaults"
-    });
-    await api.post(`/v1/policies/${result.policy.id}/bindings`, {
-      scope: "WORKSPACE",
-      scope_id: workspaceId
-    });
-    policySpinner.succeed(
-      `Starter policy created as ${style.bold("DRAFT")} and bound to the workspace`
-    );
-    keyValue("Policy", `${result.policy.name} (${result.policy.id})`);
+  const audience = await discoverAudience(gatewayUrl);
+  ensureGitignore(process.cwd(), [".env.local", ".veefore/"]);
+  const approvalMode = options.approvalMode ?? previousApprovalMode() ?? "wait";
+  const envFile = writeLocalEnv({
+    VEEFORE_GATEWAY_URL: gatewayUrl,
+    VEEFORE_GATEWAY_AUDIENCE: audience,
+    VEEFORE_AGENT_ID: created.agentId,
+    VEEFORE_AGENT_KEY_ID: created.keyId,
+    VEEFORE_AGENT_PRIVATE_KEY: created.privateKey,
+    ...created.tools.length > 0 ? { VEEFORE_DECLARED_TOOLS: created.tools.map((tool) => tool.key).join(",") } : {},
+    // Written explicitly so the behaviour is visible and editable in one place.
+    VEEFORE_APPROVAL_MODE: approvalMode
+  });
+  if (audience !== gatewayUrl) {
     out(
-      style.grey(
-        "  Review it, run `veefore policies test`, then `veefore policies deploy` when you are ready."
-      )
+      `${symbol.info} Gateway audience is ${style.bold(audience)} ${style.grey(
+        `(it reports this, rather than the ${gatewayUrl} you dialled)`
+      )}`
     );
-  } catch (error) {
-    policySpinner.fail("Could not create the starter policy");
-    if (error instanceof CliApiError) {
-      out(style.grey(`  ${error.message}`));
-      out(style.grey("  You can create one from a template in the console instead."));
-      return;
-    }
-    throw error;
   }
-}
-async function validateConnection(api, gatewayUrl, agentId, environmentId) {
-  const checks = [];
-  try {
-    await api.get("/v1/auth/session");
-    checks.push({ name: "Control plane reachable", status: "pass", message: api.controlPlaneUrl });
-  } catch (error) {
-    checks.push({
-      name: "Control plane reachable",
-      status: "fail",
-      message: error instanceof Error ? error.message : String(error)
-    });
+  out(
+    `${symbol.pass} Wrote agent credentials to ${style.bold(".env.local")} ${style.grey("(mode 0600, gitignored)")}`
+  );
+  out();
+  out(
+    `  ${style.amber("The private key was generated here and written to that file only.")} Veefore`
+  );
+  out(
+    `  never received it and cannot recover it. Move it into your secret manager before deploying.`
+  );
+  out(`  ${style.grey(`Fingerprint: ${created.fingerprint}`)}`);
+  await configureStarterPolicy(api, workspace.id, flags, options);
+  let integrated = false;
+  if (created.tools.length > 0 && !options.skipCode) {
+    const outcome = await integrate(
+      process.cwd(),
+      created.tools.map((tool) => tool.key),
+      { yes: flags.yes, quiet: flags.json, api }
+    );
+    integrated = outcome.status === "applied" || outcome.status === "nothing-to-do";
   }
-  try {
-    const response = await fetch(`${gatewayUrl}/health`, {
-      signal: AbortSignal.timeout(5e3)
-    });
-    const body = await response.json();
-    checks.push({
-      name: "Gateway reachable",
-      status: response.ok ? "pass" : "fail",
-      message: `${gatewayUrl} \u2014 ${body.status ?? response.status} (${body.enforcement_posture ?? "unknown posture"})`
-    });
-  } catch (error) {
-    checks.push({
-      name: "Gateway reachable",
-      status: "fail",
-      message: `${gatewayUrl} \u2014 ${error instanceof Error ? error.message : String(error)}. Start it with \`npm run dev:gateway\`.`
-    });
+  heading("Validating the connection");
+  const checks = await validateConnection(api, gatewayUrl, created.agentId, environment.id);
+  for (const check of checks) {
+    const icon = check.status === "pass" ? symbol.pass : check.status === "warn" ? symbol.warn : symbol.fail;
+    out(`${icon} ${check.name}${check.message ? style.grey(` \u2014 ${check.message}`) : ""}`);
   }
-  try {
-    const identities = await api.get(
-      `/v1/agents/${agentId}/identities`
-    );
-    const active = identities.find((identity) => identity.status === "ACTIVE");
-    checks.push({
-      name: "Agent identity active",
-      status: active ? "pass" : "fail",
-      message: active ? `expires ${active.expiresAt.slice(0, 10)}` : "no ACTIVE identity"
-    });
-  } catch (error) {
-    checks.push({
-      name: "Agent identity active",
-      status: "warn",
-      message: error instanceof Error ? error.message : String(error)
-    });
+  const failed = checks.filter((check) => check.status === "fail");
+  if (!integrated) {
+    heading("Protect each tool");
+    out();
+    for (const line of integrationSnippet(framework).split("\n")) {
+      out(`  ${style.cyan(line)}`);
+    }
+    const entryPoints = findEntryPoints();
+    if (entryPoints.length > 0) {
+      out();
+      out(
+        style.grey(
+          `  Likely entry point${entryPoints.length > 1 ? "s" : ""}: ${entryPoints.join(", ")}`
+        )
+      );
+    }
+    if (created.tools.length > 0) {
+      out(style.grey("  Or let Veefore wrap your tools for you: `veefore integrate`."));
+    }
   }
-  try {
-    const passport = await api.get(
-      `/v1/passports/${agentId}`
+  heading("When a human must approve");
+  for (const line of approvalModeExplanation(approvalMode)) out(line);
+  heading("Next");
+  out(`  ${symbol.bullet} ${style.bold("veefore dev")}     watch decisions live while you build`);
+  out(
+    `  ${symbol.bullet} ${style.bold("veefore doctor")}  check the security posture of this setup`
+  );
+  out(`  ${symbol.bullet} ${style.bold("veefore status")}  see the current mode and agent health`);
+  out();
+  out(
+    style.grey(
+      `  This environment is in ${environment.gatewayMode ?? "OBSERVE"} mode. Nothing is blocked yet.`
+    )
+  );
+  out(style.grey("  Review the recommended policy, simulate it, then switch to ENFORCE."));
+  out();
+  if (flags.json) {
+    out(
+      JSON.stringify(
+        {
+          config_file: configFile,
+          env_file: envFile,
+          agent_id: created.agentId,
+          key_id: created.keyId,
+          fingerprint: created.fingerprint,
+          tools: created.tools,
+          checks
+        },
+        null,
+        2
+      )
     );
-    checks.push({
-      name: "Agent passport issued",
-      status: passport ? "pass" : "warn",
-      message: passport ? `version ${passport.version}` : "not issued yet"
-    });
-  } catch {
-    checks.push({ name: "Agent passport issued", status: "warn", message: "could not read" });
   }
+  return failed.length > 0 ? 1 : 0;
+}
+function previousApprovalMode(dir = process.cwd()) {
   try {
-    const environment = await api.get(
-      `/v1/environments/${environmentId}`
-    );
-    checks.push({
-      name: "Enforcement mode",
-      status: "pass",
-      message: environment.gatewayMode === "ENFORCE" ? "ENFORCE \u2014 decisions are enforced" : `${environment.gatewayMode} \u2014 decisions are recorded but not enforced`
-    });
+    const text = readFileSync9(path10.join(dir, ".env.local"), "utf8");
+    const value = /^\s*VEEFORE_APPROVAL_MODE\s*=\s*['"]?(\w+)/m.exec(text)?.[1]?.toLowerCase();
+    return value === "wait" || value === "throw" ? value : null;
   } catch {
-    checks.push({ name: "Enforcement mode", status: "warn", message: "could not read" });
-  }
-  return checks;
-}
-function parseInitArgs(args) {
-  const options = { force: false, skipPolicy: false, skipCode: false };
-  for (let index = 0; index < args.length; index += 1) {
-    const arg = args[index];
-    const next = () => {
-      const value = args[index + 1];
-      if (value === void 0 || value.startsWith("-")) {
-        throw new CliError(`Option ${String(arg)} requires a value.`);
-      }
-      index += 1;
-      return value;
-    };
-    switch (arg) {
-      case "--force":
-        options.force = true;
-        break;
-      case "--skip-policy":
-        options.skipPolicy = true;
-        break;
-      case "--skip-code":
-        options.skipCode = true;
-        break;
-      case "--new-agent":
-        options.newAgent = true;
-        break;
-      case "--control-plane":
-        options.controlPlaneUrl = next();
-        break;
-      case "--gateway":
-        options.gatewayUrl = next();
-        break;
-      case "--organization":
-        options.organizationId = next();
-        break;
-      case "--workspace":
-        options.workspaceId = next();
-        break;
-      case "--environment":
-        options.environmentId = next();
-        break;
-      case "--name":
-        options.agentName = next();
-        break;
-      case "--capability":
-        options.capabilities = [...options.capabilities ?? [], next()];
-        break;
-      case "--approval-mode": {
-        const value = next().toLowerCase();
-        if (value !== "wait" && value !== "throw") {
-          throw new CliError('--approval-mode must be "wait" or "throw".');
-        }
-        options.approvalMode = value;
-        break;
-      }
-      default:
-        if (arg?.startsWith("-")) {
-          throw new CliError(`Unknown option for \`veefore init\`: ${arg}`);
-        }
-    }
+    return null;
   }
-  return options;
 }
-async function projectHome(existing, flags) {
-  const state = await agentState(existing);
-  out();
-  out(`${style.bold("Veefore")} ${style.grey(existing.controlPlaneUrl)}`);
-  details([
-    ["Agent", `${existing.agentName} (${existing.agentId})`],
-    ["Environment", `${existing.environmentName} (${existing.environmentType})`],
-    [
-      "Status",
-      state.kind === "ok" ? state.status : state.kind === "signed-out" ? "not signed in" : state.kind === "session-ended" ? "signed out" : state.kind === "missing" ? "agent not found" : "Veefore not reachable"
-    ]
-  ]);
-  if (state.kind === "session-ended") {
-    out(`${symbol.warn} ${state.message}`);
-  }
-  const choices = [];
-  const ended = state.kind === "missing" || state.kind === "ok" && ENDED_STATUSES.includes(state.status);
-  if (ended) {
-    out();
-    out(
-      `${symbol.warn} ${style.amber(
-        state.kind === "missing" ? "This agent no longer exists in Veefore." : `This agent was ${state.kind === "ok" ? state.status.toLowerCase() : "removed"} in Veefore.`
-      )} Every tool call wrapped in guard() is now refused.`
-    );
-    choices.push(
-      {
-        label: "Remove Veefore from this project (take guard() out of the code, disconnect)",
-        run: () => removeCommand([], flags, state)
-      },
-      {
-        label: "Set it up again with a new agent (the guarded code keeps working)",
-        run: () => initCommand(["--force"], flags)
-      }
-    );
-  } else {
-    if (state.kind === "signed-out" || state.kind === "session-ended") {
-      choices.push({
-        label: "Sign in",
-        run: async () => {
-          await login(existing.controlPlaneUrl);
-          return 0;
-        }
-      });
+function approvalModeExplanation(mode) {
+  if (mode === "wait") {
+    return [
+      `  Guarded tools ${style.bold("wait")} for the reviewer's decision, then:`,
+      `    ${symbol.bullet} approved: the tool runs once and returns its real result`,
+      `    ${symbol.bullet} denied, cancelled or expired: it fails with that reason, and nothing runs`,
+      style.grey(
+        "  The agent process must stay running while it waits (up to the approval's expiry)."
+      ),
+      style.grey(
+        "  For chat agents that should hand the question back instead, set VEEFORE_APPROVAL_MODE=throw"
+      ),
+      style.grey("  in .env.local, or pass { waitForApproval: false } to a single guard().")
+    ];
+  }
+  return [
+    `  Guarded tools ${style.bold("return immediately")} with "approval required" (VeeforeApprovalRequiredError),`,
+    "  carrying the approval id. Your agent must resubmit the same call after a reviewer approves,",
+    "  or the action never happens.",
+    style.grey("  To wait for the decision instead, set VEEFORE_APPROVAL_MODE=wait in .env.local.")
+  ];
+}
+async function selectOrganization(api, me, options, flags) {
+  const organizations = me.organizations.length > 0 ? me.organizations : [
+    {
+      id: me.organization.id,
+      name: me.organization.name,
+      slug: me.organization.slug,
+      roleKey: me.roleKey
     }
-    choices.push(
-      { label: "Check status", run: () => statusCommand([], flags) },
-      {
-        label: "Protect tools in the code (veefore integrate)",
-        run: () => integrateCommand([], flags)
-      },
-      { label: "Re-run setup for this project", run: () => initCommand(["--force"], flags) },
-      {
-        label: "Remove Veefore from this project",
-        run: () => removeCommand([], flags, state)
-      }
-    );
-    if (state.kind === "ok" || state.kind === "unreachable") {
-      choices.push({
-        label: "Sign out",
-        run: async () => {
-          await logout(existing.controlPlaneUrl);
-          return 0;
-        }
-      });
+  ];
+  if (options.organizationId) {
+    const match = organizations.find((org) => org.id === options.organizationId);
+    if (!match) {
+      throw new CliError(
+        `You are not a member of organization ${options.organizationId}.`,
+        `Available: ${organizations.map((org) => org.id).join(", ")}`
+      );
     }
+    return match;
+  }
+  if (organizations.length === 1 || flags.yes) {
+    const chosen2 = organizations[0];
+    if (!chosen2) throw new CliError("Your account is not a member of any organization.");
+    out(`${symbol.pass} Organization: ${style.bold(chosen2.name)}`);
+    return chosen2;
   }
-  choices.push({ label: "Exit", run: async () => 0 });
   out();
-  out("What would you like to do?");
-  choices.forEach((choice, index) => out(`  ${style.bold(String(index + 1))}  ${choice.label}`));
-  const answer = Number(
-    (await ask(`Choice [1-${choices.length}]:`, String(choices.length))).trim()
+  const chosen = await select(
+    "Which organization?",
+    organizations.map((org) => ({
+      label: org.name,
+      hint: `${org.roleKey} \xB7 ${org.id}`,
+      value: org
+    })),
+    { quiet: true }
   );
-  const picked = choices[answer - 1];
-  if (!picked) {
-    out(style.grey("Nothing changed."));
-    return 0;
-  }
-  return picked.run();
+  await api.post("/v1/auth/scope", { organization_id: chosen.id });
+  out(`${symbol.pass} Organization: ${style.bold(chosen.name)}`);
+  return chosen;
 }
-
-// src/commands/scan.ts
-async function scanCommand(_args, flags) {
-  const scan = scanProject(process.cwd());
-  if (flags.json) {
-    out(JSON.stringify({ scan, plan: buildPlan(scan) }, null, 2));
-    return 0;
+async function selectWorkspace(api, me, options, flags) {
+  const workspaces = me.workspaces.length > 0 ? me.workspaces : await api.get("/v1/workspaces");
+  if (workspaces.length === 0) {
+    throw new CliError(
+      "This organization has no workspaces.",
+      "Create one in the console, or ask an admin to."
+    );
   }
-  heading("Veefore scan");
-  out(
-    `${symbol.pass} Framework: ${style.bold(scan.framework.name)} ${style.grey(`(${scan.framework.language}, ${scan.framework.evidence})`)}`
-  );
-  printScan(scan);
-  out();
-  out(style.grey("Nothing was changed. Run `veefore` to set this project up."));
-  return 0;
-}
-
-// src/commands/logs.ts
-async function logsCommand(args, flags) {
-  const context = await resolveContext(flags);
-  const follow = args.includes("--follow") || args.includes("-f");
-  const limit = Number(valueFor(args, "--limit") ?? 25);
-  const decisionFilter = valueFor(args, "--decision");
-  const agentFilter = valueFor(args, "--agent") ?? (args.includes("--all") ? void 0 : context.config.agentId);
-  const initial = await fetchActions(context, {
-    limit,
-    decision: decisionFilter,
-    agentId: agentFilter
-  });
-  if (flags.json && !follow) {
-    printJson(initial);
-    return 0;
+  if (options.workspaceId) {
+    const match = workspaces.find((workspace) => workspace.id === options.workspaceId);
+    if (!match) throw new CliError(`Workspace ${options.workspaceId} was not found.`);
+    return match;
   }
-  heading(`Decisions \u2014 ${context.config.environmentName} (${context.config.environmentType})`);
-  renderActions(initial, flags.verbose);
-  if (!follow) {
-    out();
-    out(style.grey("  Use --follow to stream new decisions as they happen."));
-    out();
-    return 0;
+  if (workspaces.length === 1 || flags.yes) {
+    const chosen2 = workspaces[0];
+    out(`${symbol.pass} Workspace: ${style.bold(chosen2.name)}`);
+    return chosen2;
   }
-  return streamActions(context, {
-    decision: decisionFilter,
-    agentId: agentFilter,
-    seen: new Set(initial.map((action) => action.id)),
-    verbose: flags.verbose,
-    json: flags.json
-  });
-}
-async function devCommand(args, flags) {
-  const context = await resolveContext(flags);
-  const environment = await context.api.get(`/v1/environments/${context.config.environmentId}`);
-  const gateway = await probeGateway(context.config.gatewayUrl);
-  const agent = await context.api.get(
-    `/v1/agents/${context.config.agentId}`
-  );
-  heading(`veefore dev \u2014 ${context.config.organizationName} \u203A ${environment.name}`);
   out();
-  out(
-    `  ${gateway.reachable ? symbol.pass : symbol.fail} Gateway ${gateway.reachable ? style.green("connected") : style.red("unreachable")} ${style.grey(context.config.gatewayUrl)}`
-  );
-  out(
-    `  ${agent.status === "ACTIVE" ? symbol.pass : symbol.warn} Agent ${style.bold(agent.name)} ${decisionStyle(agent.status)}`
+  const chosen = await select(
+    "Which workspace?",
+    workspaces.map((workspace) => ({
+      label: workspace.name,
+      hint: workspace.id,
+      value: workspace
+    })),
+    { quiet: true }
   );
-  out(
-    `  ${environment.gatewayMode === "ENFORCE" ? symbol.pass : symbol.warn} Mode ${decisionStyle(environment.status === "PAUSED" ? "PAUSED" : environment.gatewayMode)}`
-  );
-  if (!gateway.reachable) {
-    out();
-    out(
-      `  ${symbol.fail} ${style.red("The gateway is not reachable, so no action can be permitted.")}`
+  out(`${symbol.pass} Workspace: ${style.bold(chosen.name)}`);
+  return chosen;
+}
+async function selectEnvironment(api, me, workspaceId, options, flags) {
+  const all = me.environments.length > 0 ? me.environments : await api.get("/v1/environments", { workspace_id: workspaceId });
+  const environments = all.filter((environment) => environment.workspaceId === workspaceId);
+  if (environments.length === 0) {
+    throw new CliError(
+      "That workspace has no environments.",
+      "Create one in the console, or ask an admin to."
     );
-    out(style.grey("    Start it with `npm run dev:gateway`, then re-run `veefore dev`."));
-    out();
-    return 1;
   }
-  if (environment.gatewayMode === "OBSERVE") {
-    out();
-    out(
-      `  ${symbol.info} ${style.cyan("OBSERVE mode:")} every decision is evaluated and recorded, but nothing is blocked.`
-    );
-    out(style.grey("    This is the safe way to learn what your agent actually does."));
+  if (options.environmentId) {
+    const match = environments.find((environment) => environment.id === options.environmentId);
+    if (!match) throw new CliError(`Environment ${options.environmentId} was not found.`);
+    return match;
   }
-  if (agent.isolated) {
-    out();
-    out(`  ${symbol.fail} ${style.red("This agent is isolated by an emergency control.")}`);
+  if (flags.yes) {
+    const chosen2 = environments.find((environment) => environment.type === "DEVELOPMENT") ?? environments[0];
+    out(`${symbol.pass} Environment: ${style.bold(chosen2.name)} (${chosen2.type})`);
+    return chosen2;
   }
   out();
-  out(style.grey("  Watching for decisions. Press Ctrl+C to stop."));
-  out();
-  const existing = await fetchActions(context, { limit: 5, agentId: context.config.agentId });
-  if (existing.length === 0) {
-    out(
-      `  ${symbol.info} No actions recorded yet. Call ${style.bold("agent.act({ tool: \u2026 })")} from your agent to see a decision here.`
-    );
-    out();
-  } else {
-    renderActions(existing, flags.verbose);
-  }
-  return streamActions(context, {
-    agentId: args.includes("--all") ? void 0 : context.config.agentId,
-    seen: new Set(existing.map((action) => action.id)),
-    verbose: true,
-    json: false,
-    coach: true
-  });
+  const development = environments.findIndex((environment) => environment.type === "DEVELOPMENT");
+  const chosen = await select(
+    "Which environment?",
+    environments.map((environment) => ({
+      label: environment.name,
+      hint: `${environment.type} \xB7 ${environment.gatewayMode ?? "\u2014"} \xB7 ${environment.id}`,
+      value: environment
+    })),
+    { quiet: true, initial: development >= 0 ? development : 0 }
+  );
+  out(`${symbol.pass} Environment: ${style.bold(chosen.name)} (${chosen.type})`);
+  return chosen;
 }
-async function fetchActions(context, options) {
-  const response = await context.api.get("/v1/actions", {
-    limit: options.limit ?? 25,
-    decision: options.decision,
-    agent_id: options.agentId,
-    environment_id: context.config.environmentId
-  });
-  return [...response.data].reverse();
+async function discoverAudience(gatewayUrl) {
+  try {
+    const response = await fetch(`${gatewayUrl}/.well-known/veefore-platform-key`, {
+      headers: { accept: "application/json" }
+    });
+    if (!response.ok) return gatewayUrl;
+    const body = await response.json();
+    const audience = body.data?.audience;
+    return typeof audience === "string" && audience !== "" ? audience : gatewayUrl;
+  } catch {
+    return gatewayUrl;
+  }
 }
-function renderActions(actions, verbose) {
-  if (actions.length === 0) {
-    out(style.grey("  (no decisions yet)"));
+async function configureStarterPolicy(api, workspaceId, flags, options) {
+  if (options.skipPolicy) {
+    out(`${symbol.info} Skipped starter policy (--skip-policy).`);
     return;
   }
-  if (!verbose) {
-    table(
-      [
-        { header: "WHEN", key: "when", width: 12 },
-        { header: "TOOL", key: "tool", width: 24 },
-        { header: "DECISION", key: "decision", width: 20 },
-        { header: "OUTCOME", key: "outcome", width: 24 },
-        { header: "MS", key: "latency", width: 6, align: "right" }
-      ],
-      actions.map((action) => ({
-        when: formatWhen(action.startedAt),
-        tool: action.toolKey ?? action.action,
-        decision: decisionStyle(effectiveDecision(action)),
-        outcome: decisionStyle(action.outcome),
-        latency: String(Math.round(action.latencyMs))
-      }))
+  const existing = await api.get(
+    "/v1/policies",
+    { workspace_id: workspaceId }
+  );
+  const count = Array.isArray(existing) ? existing.length : existing.items?.length ?? 0;
+  if (count > 0) {
+    out(`${symbol.pass} Workspace already has ${count} policy/policies. Leaving them alone.`);
+    return;
+  }
+  const create = flags.yes ? true : await confirm("Create a starter policy with safe defaults?", { yes: flags.yes });
+  if (!create) {
+    out(style.grey("  Skipped. Create one later from a template in the console."));
+    return;
+  }
+  const policySpinner = spinner("Creating starter policy from the safe-defaults template");
+  try {
+    const result = await api.post("/v1/policies", {
+      workspace_id: workspaceId,
+      name: "Starter \u2014 safe defaults",
+      template_key: "starter-observe-safe-defaults"
+    });
+    await api.post(`/v1/policies/${result.policy.id}/bindings`, {
+      scope: "WORKSPACE",
+      scope_id: workspaceId
+    });
+    policySpinner.succeed(
+      `Starter policy created as ${style.bold("DRAFT")} and bound to the workspace`
     );
-    return;
+    keyValue("Policy", `${result.policy.name} (${result.policy.id})`);
+    out(
+      style.grey(
+        "  Review it, run `veefore policies test`, then `veefore policies deploy` when you are ready."
+      )
+    );
+  } catch (error) {
+    policySpinner.fail("Could not create the starter policy");
+    if (error instanceof CliApiError) {
+      out(style.grey(`  ${error.message}`));
+      out(style.grey("  You can create one from a template in the console instead."));
+      return;
+    }
+    throw error;
   }
-  for (const action of actions) renderAction(action);
-}
-function effectiveDecision(action) {
-  return action.shadowDecision ?? action.decision ?? "UNKNOWN";
 }
-function renderAction(action, coach = false) {
-  const decision = effectiveDecision(action);
-  const icon = decision === "ALLOW" ? symbol.pass : decision === "BLOCK" ? symbol.fail : symbol.warn;
-  const amount = action.amount === null ? "" : style.grey(` ${formatAmount(action.amount, action.currency)}`);
-  out(
-    `${icon} ${style.grey(new Date(action.startedAt).toISOString().slice(11, 19))} ${style.bold(action.toolKey ?? action.action)}${amount} ${decisionStyle(decision)} ${style.grey(`(${action.outcome})`)}`
-  );
-  if (action.denyReason) out(`    ${action.denyReason}`);
-  const facts = [];
-  if (action.policyVersionNumber !== null) facts.push(`policy v${action.policyVersionNumber}`);
-  if (action.matchedRuleIds.length > 0)
-    facts.push(`${action.matchedRuleIds.length} rule(s) matched`);
-  if (action.riskLevel) facts.push(`risk ${action.riskLevel}`);
-  if (action.protocol !== "HTTP") facts.push(action.protocol);
-  if (action.gatewayMode !== "ENFORCE") facts.push(`mode ${action.gatewayMode}`);
-  facts.push(`${Math.round(action.latencyMs)}ms`);
-  out(`    ${style.grey(facts.join("  \xB7  "))}`);
-  if (coach) {
-    const hint = coachingFor(action);
-    if (hint) out(`    ${style.cyan("\u2192")} ${style.grey(hint)}`);
+async function validateConnection(api, gatewayUrl, agentId, environmentId) {
+  const checks = [];
+  try {
+    await api.get("/v1/auth/session");
+    checks.push({ name: "Control plane reachable", status: "pass", message: api.controlPlaneUrl });
+  } catch (error) {
+    checks.push({
+      name: "Control plane reachable",
+      status: "fail",
+      message: error instanceof Error ? error.message : String(error)
+    });
   }
-}
-function coachingFor(action) {
-  const decision = effectiveDecision(action);
-  if (action.gatewayMode === "OBSERVE" && decision !== "ALLOW") {
-    return `In ENFORCE mode this would have been ${decision}. Simulate before switching.`;
+  try {
+    const response = await fetch(`${gatewayUrl}/health`, {
+      signal: AbortSignal.timeout(5e3)
+    });
+    const body = await response.json();
+    checks.push({
+      name: "Gateway reachable",
+      status: response.ok ? "pass" : "fail",
+      message: `${gatewayUrl} \u2014 ${body.status ?? response.status} (${body.enforcement_posture ?? "unknown posture"})`
+    });
+  } catch (error) {
+    checks.push({
+      name: "Gateway reachable",
+      status: "fail",
+      message: `${gatewayUrl} \u2014 ${error instanceof Error ? error.message : String(error)}. Start it with \`npm run dev:gateway\`.`
+    });
   }
-  switch (decision) {
-    case "BLOCK":
-      return action.matchedRuleIds.length > 0 ? "Blocked by a policy rule. Adjust the rule, or grant the capability if this is legitimate." : "Blocked before policy evaluation. Check the tool is registered and the agent is authorized for it.";
-    case "REQUIRE_APPROVAL":
-      return "Call actWithApproval() so your agent waits for the reviewer instead of failing.";
-    case "LIMIT":
-      return "The amount was capped by policy. Read limits.appliedAmount from the decision.";
-    case "MASK":
-      return "Some fields were masked before reaching the tool. Check limits.maskedFields.";
-    case "STEP_UP_AUTH":
-      return "A human must re-authenticate. Agents cannot satisfy step-up on their own.";
-    default:
-      return null;
+  try {
+    const identities = await api.get(
+      `/v1/agents/${agentId}/identities`
+    );
+    const active = identities.find((identity) => identity.status === "ACTIVE");
+    checks.push({
+      name: "Agent identity active",
+      status: active ? "pass" : "fail",
+      message: active ? `expires ${active.expiresAt.slice(0, 10)}` : "no ACTIVE identity"
+    });
+  } catch (error) {
+    checks.push({
+      name: "Agent identity active",
+      status: "warn",
+      message: error instanceof Error ? error.message : String(error)
+    });
+  }
+  try {
+    const passport = await api.get(
+      `/v1/passports/${agentId}`
+    );
+    checks.push({
+      name: "Agent passport issued",
+      status: passport ? "pass" : "warn",
+      message: passport ? `version ${passport.version}` : "not issued yet"
+    });
+  } catch {
+    checks.push({ name: "Agent passport issued", status: "warn", message: "could not read" });
+  }
+  try {
+    const environment = await api.get(
+      `/v1/environments/${environmentId}`
+    );
+    checks.push({
+      name: "Enforcement mode",
+      status: "pass",
+      message: environment.gatewayMode === "ENFORCE" ? "ENFORCE \u2014 decisions are enforced" : `${environment.gatewayMode} \u2014 decisions are recorded but not enforced`
+    });
+  } catch {
+    checks.push({ name: "Enforcement mode", status: "warn", message: "could not read" });
   }
+  return checks;
 }
-function formatAmount(minorUnits, currency) {
-  const major = (minorUnits / 100).toLocaleString("en-IN", {
-    minimumFractionDigits: 2,
-    maximumFractionDigits: 2
-  });
-  return currency ? `${major} ${currency}` : major;
+function parseInitArgs(args) {
+  const options = { force: false, skipPolicy: false, skipCode: false };
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    const next = () => {
+      const value = args[index + 1];
+      if (value === void 0 || value.startsWith("-")) {
+        throw new CliError(`Option ${String(arg)} requires a value.`);
+      }
+      index += 1;
+      return value;
+    };
+    switch (arg) {
+      case "--force":
+        options.force = true;
+        break;
+      case "--skip-policy":
+        options.skipPolicy = true;
+        break;
+      case "--skip-code":
+        options.skipCode = true;
+        break;
+      case "--new-agent":
+        options.newAgent = true;
+        break;
+      case "--control-plane":
+        options.controlPlaneUrl = next();
+        break;
+      case "--gateway":
+        options.gatewayUrl = next();
+        break;
+      case "--organization":
+        options.organizationId = next();
+        break;
+      case "--workspace":
+        options.workspaceId = next();
+        break;
+      case "--environment":
+        options.environmentId = next();
+        break;
+      case "--name":
+        options.agentName = next();
+        break;
+      case "--capability":
+        options.capabilities = [...options.capabilities ?? [], next()];
+        break;
+      case "--approval-mode": {
+        const value = next().toLowerCase();
+        if (value !== "wait" && value !== "throw") {
+          throw new CliError('--approval-mode must be "wait" or "throw".');
+        }
+        options.approvalMode = value;
+        break;
+      }
+      default:
+        if (arg?.startsWith("-")) {
+          throw new CliError(`Unknown option for \`veefore init\`: ${arg}`);
+        }
+    }
+  }
+  return options;
 }
-async function streamActions(context, options) {
-  let interval = 1e3;
-  let stopped = false;
-  const stop = () => {
-    stopped = true;
-  };
-  process.once("SIGINT", stop);
-  process.once("SIGTERM", stop);
-  let blocked = 0;
-  let approvals = 0;
-  let allowed = 0;
-  while (!stopped) {
-    let fresh = [];
+async function projectHome(existing, flags) {
+  let last = 0;
+  for (let round = 0; ; round += 1) {
+    const state = await agentState(existing);
+    if (round > 0) {
+      out();
+      out(style.grey("\u2500".repeat(Math.min(process.stdout.columns ?? 72, 72))));
+    }
+    printProjectSummary(existing, state);
+    const choices = homeChoices(existing, state, flags);
+    choices.push({ label: "Exit", hint: "esc", run: async () => last, leaves: true });
+    out();
+    let picked;
     try {
-      const recent = await fetchActions(context, {
-        limit: 50,
-        decision: options.decision,
-        agentId: options.agentId
-      });
-      fresh = recent.filter((action) => !options.seen.has(action.id));
-      for (const action of fresh) options.seen.add(action.id);
-    } catch (error) {
-      out(
-        `${symbol.warn} ${style.amber("Lost contact with the control plane;")} ${style.grey(error instanceof Error ? error.message : String(error))}`
+      picked = await select(
+        "What would you like to do?",
+        choices.map((choice) => ({ label: choice.label, hint: choice.hint, value: choice }))
       );
-      interval = Math.min(interval * 2, 15e3);
-      await delay(interval);
-      continue;
+    } catch (error) {
+      if (error instanceof MenuCancelled) return last;
+      throw error;
     }
-    for (const action of fresh) {
-      if (options.json) {
-        out(JSON.stringify(action));
-      } else {
-        renderAction(action, options.coach);
-      }
-      const decision = effectiveDecision(action);
-      if (decision === "BLOCK") blocked += 1;
-      else if (decision === "REQUIRE_APPROVAL") approvals += 1;
-      else allowed += 1;
+    out();
+    try {
+      last = await picked.run();
+    } catch (error) {
+      last = error instanceof MenuCancelled ? last : reportError(error, flags);
     }
-    interval = fresh.length > 0 ? 1e3 : Math.min(interval * 1.5, 5e3);
-    await delay(interval);
+    if (picked.leaves) return last;
   }
-  if (!options.json) {
+}
+function printProjectSummary(existing, state) {
+  out();
+  out(`${style.bold(existing.agentName)} ${style.grey(`\xB7 ${existing.controlPlaneUrl}`)}`);
+  details([
+    ["Agent", `${existing.agentName} (${existing.agentId})`],
+    ["Environment", `${existing.environmentName} (${existing.environmentType})`],
+    [
+      "Status",
+      state.kind === "ok" ? state.status : state.kind === "signed-out" ? "not signed in" : state.kind === "session-ended" ? "signed out" : state.kind === "missing" ? "agent not found" : "Veefore not reachable"
+    ]
+  ]);
+  if (state.kind === "session-ended") {
+    out(`${symbol.warn} ${state.message}`);
+  }
+}
+function homeChoices(existing, state, flags) {
+  const ended = state.kind === "missing" || state.kind === "ok" && ENDED_STATUSES.includes(state.status);
+  if (ended) {
     out();
     out(
-      `  ${style.green(`${allowed} allowed`)}  ${style.amber(`${approvals} needing approval`)}  ${style.red(`${blocked} blocked`)}`
+      `${symbol.warn} ${style.amber(
+        state.kind === "missing" ? "This agent no longer exists in Veefore." : `This agent was ${state.kind === "ok" ? state.status.toLowerCase() : "removed"} in Veefore.`
+      )} Every tool call wrapped in guard() is now refused.`
     );
-    out();
+    return [
+      {
+        label: "Remove Veefore from this project",
+        hint: "take guard() out of the code, disconnect",
+        run: () => removeCommand([], flags, state),
+        leaves: true
+      },
+      {
+        label: "Set it up again with a new agent",
+        hint: "the guarded code keeps working",
+        run: () => initCommand(["--force"], flags),
+        leaves: true
+      }
+    ];
   }
-  return 0;
+  const choices = [];
+  if (state.kind === "signed-out" || state.kind === "session-ended") {
+    choices.push({
+      label: "Sign in",
+      hint: "veefore login",
+      run: async () => {
+        await login(existing.controlPlaneUrl);
+        return 0;
+      }
+    });
+  }
+  choices.push(
+    { label: "Watch decisions live", hint: "veefore dev", run: () => devCommand([], flags) },
+    { label: "Check status", hint: "veefore status", run: () => statusCommand([], flags) },
+    {
+      label: "Protect tools in the code",
+      hint: "veefore integrate",
+      run: () => integrateCommand([], flags)
+    },
+    {
+      label: "Check every tool is guarded",
+      hint: "veefore integrate --check",
+      run: () => integrateCommand(["--check"], flags)
+    },
+    { label: "Test enforcement", hint: "veefore test", run: () => testCommand([], flags) },
+    {
+      label: "Audit the security posture",
+      hint: "veefore doctor",
+      run: () => doctorCommand([], flags)
+    },
+    { label: "Turn on enforcement", hint: "veefore deploy", run: () => deployCommand([], flags) },
+    {
+      label: "Re-run setup for this project",
+      hint: "veefore init --force",
+      run: () => initCommand(["--force"], flags),
+      leaves: true
+    },
+    {
+      label: "Remove Veefore from this project",
+      hint: "veefore remove",
+      run: () => removeCommand([], flags, state),
+      leaves: true
+    }
+  );
+  if (state.kind === "ok" || state.kind === "unreachable") {
+    choices.push({
+      label: "Sign out",
+      hint: "veefore logout",
+      run: async () => {
+        await logout(existing.controlPlaneUrl);
+        return 0;
+      },
+      leaves: true
+    });
+  }
+  return choices;
 }
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+
+// src/commands/scan.ts
+async function scanCommand(_args, flags) {
+  const scan = scanProject(process.cwd());
+  if (flags.json) {
+    out(JSON.stringify({ scan, plan: buildPlan(scan) }, null, 2));
+    return 0;
+  }
+  heading("Veefore scan");
+  out(
+    `${symbol.pass} Framework: ${style.bold(scan.framework.name)} ${style.grey(`(${scan.framework.language}, ${scan.framework.evidence})`)}`
+  );
+  printScan(scan);
+  out();
+  out(style.grey("Nothing was changed. Run `veefore` to set this project up."));
+  return 0;
 }
 
 // src/commands/policies.ts
@@ -8172,155 +8640,6 @@ async function diffPolicy(args, flags) {
   return 0;
 }
 
-// src/commands/test.ts
-async function testCommand(args, flags) {
-  const context = await resolveContext(flags);
-  const toolFilter = valueFor(args, "--tool");
-  heading(
-    `Enforcement test \u2014 ${context.config.environmentName} (${context.config.environmentType})`
-  );
-  const results = [];
-  const record = (check, passed, detail) => {
-    results.push({ check, passed, detail });
-    out(`${passed ? symbol.pass : symbol.fail} ${check} ${style.grey(detail)}`);
-  };
-  const gateway = await probeGateway(context.config.gatewayUrl);
-  record(
-    "Gateway reachable",
-    gateway.reachable,
-    gateway.reachable ? `${context.config.gatewayUrl} \u2014 posture ${gateway.posture ?? "unknown"}` : gateway.error ?? "unreachable"
-  );
-  const identities = await context.api.get(`/v1/agents/${context.config.agentId}/identities`).catch(() => []);
-  const activeIdentity = identities.find((identity) => identity.status === "ACTIVE");
-  record(
-    "Agent identity active",
-    Boolean(activeIdentity),
-    activeIdentity ? `generation ${activeIdentity.generation}, expires ${activeIdentity.expiresAt.slice(0, 10)}` : "no ACTIVE identity \u2014 the agent cannot authenticate"
-  );
-  const policies = await context.api.get("/v1/policies", { workspace_id: context.config.workspaceId });
-  const effective = policies.filter(
-    (policy) => policy.status === "ACTIVE" && policy.bindings.length > 0
-  );
-  record(
-    "Active, bound policy exists",
-    effective.length > 0,
-    effective.length > 0 ? effective.map((policy) => policy.name).join(", ") : "no active policy is bound to a scope, so no rule can match"
-  );
-  let caseTotal = 0;
-  let caseFailed = 0;
-  for (const policy of policies) {
-    const result = await context.api.post(`/v1/policies/${policy.id}/tests/run`, {}).catch(() => null);
-    if (!result) continue;
-    caseTotal += result.passed + result.failed;
-    caseFailed += result.failed;
-  }
-  record(
-    "Policy test cases",
-    caseFailed === 0,
-    caseTotal === 0 ? "no test cases recorded \u2014 add cases so rule changes are provable" : `${caseTotal - caseFailed}/${caseTotal} passing`
-  );
-  const tools = await resolveAuthorizedTools(context, toolFilter);
-  if (tools.length === 0) {
-    record(
-      "Authorized tools",
-      false,
-      "this agent is authorized for no tools, so it cannot do anything"
-    );
-  } else {
-    record("Authorized tools", true, tools.map((tool) => tool.key).join(", "));
-  }
-  heading("Decision probe (dry run \u2014 nothing is executed)");
-  const probes = [];
-  for (const tool of tools) {
-    const probeSpinner = spinner(`Evaluating ${tool.key}`);
-    try {
-      const outcome = await context.api.post("/v1/policies/simulate", {
-        agent_id: context.config.agentId,
-        tool: tool.key,
-        capability: tool.requiredCapability,
-        environment_id: context.config.environmentId,
-        parameters: {}
-      });
-      probeSpinner.succeed(`${tool.key} \u2192 ${outcome.decision}`);
-      probes.push({ tool, outcome });
-    } catch (error) {
-      probeSpinner.fail(`${tool.key} could not be evaluated`);
-      probes.push({
-        tool,
-        outcome: null,
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  out();
-  table(
-    [
-      { header: "TOOL", key: "tool", width: 24 },
-      { header: "RISK", key: "risk", width: 18 },
-      { header: "DECISION", key: "decision", width: 20 },
-      { header: "MATCHED RULE", key: "rule", width: 32 }
-    ],
-    probes.map((probe) => ({
-      tool: probe.tool.dangerous ? `${probe.tool.key} ${style.red("(dangerous)")}` : probe.tool.key,
-      risk: decisionStyle(probe.tool.riskLevel),
-      decision: probe.outcome ? decisionStyle(probe.outcome.decision) : style.red("ERROR"),
-      rule: probe.outcome?.matchedRules[0]?.name ?? style.grey(probe.error ?? "default decision")
-    }))
-  );
-  const unguarded = probes.filter(
-    (probe) => probe.tool.dangerous && probe.outcome?.decision === "ALLOW" && probe.outcome.matchedRules.length === 0
-  );
-  out();
-  record(
-    "Dangerous tools are guarded",
-    unguarded.length === 0,
-    unguarded.length === 0 ? "every dangerous tool is either refused or matched by an explicit rule" : `${unguarded.map((probe) => probe.tool.key).join(", ")} allowed by the default decision with no rule`
-  );
-  const errored = probes.filter((probe) => probe.outcome === null);
-  record(
-    "All evaluations completed",
-    errored.length === 0,
-    errored.length === 0 ? `${probes.length} evaluated` : `${errored.length} failed to evaluate`
-  );
-  const impure = probes.filter((probe) => probe.outcome && probe.outcome.sideEffectFree !== true);
-  record(
-    "Simulation was side-effect free",
-    impure.length === 0,
-    impure.length === 0 ? "no action records were written" : "the server reported side effects"
-  );
-  const failed = results.filter((result) => !result.passed);
-  out();
-  out(
-    failed.length === 0 ? `  ${symbol.pass} ${style.green(`${results.length} check(s) passing.`)}` : `  ${symbol.fail} ${style.red(`${failed.length} of ${results.length} check(s) failing.`)}`
-  );
-  if (failed.length > 0) {
-    out();
-    for (const failure of failed) out(`    ${symbol.fail} ${failure.check}: ${failure.detail}`);
-  }
-  out();
-  if (flags.json) printJson({ results, probes });
-  return failed.length > 0 ? 1 : 0;
-}
-async function resolveAuthorizedTools(context, filter) {
-  const tools = await context.api.get("/v1/tools", {
-    workspace_id: context.config.workspaceId,
-    agent_id: context.config.agentId,
-    limit: 100
-  });
-  const candidates = tools.items.filter(
-    (tool) => tool.status !== "DISABLED" && (tool.environmentId === null || tool.environmentId === context.config.environmentId)
-  );
-  if (!filter) return candidates;
-  const match = candidates.filter((tool) => tool.key === filter);
-  if (match.length === 0) {
-    throw new CliError(
-      `Tool "${filter}" is not available to this agent in ${context.config.environmentName}.`,
-      `Available: ${candidates.map((tool) => tool.key).join(", ") || "none"}`
-    );
-  }
-  return match;
-}
-
 // src/help.ts
 var COMMANDS = [
   {
@@ -8600,8 +8919,92 @@ function wrap2(text, width) {
   return lines;
 }
 
+// src/home.ts
+import { homedir as homedir2 } from "node:os";
+import path11 from "node:path";
+async function homeCommand(args, flags, version) {
+  await showWelcome(welcomeContext(flags, version));
+  if (readProjectConfig()) return initCommand(args, flags);
+  out();
+  out(style.bold("Let's get started."));
+  for (; ; ) {
+    out();
+    let action;
+    try {
+      action = await select("What would you like to do?", [
+        { label: "Set up this project", hint: "recommended \xB7 veefore init", value: "setup" },
+        {
+          label: "Preview what setup would find",
+          hint: "veefore scan \xB7 changes nothing",
+          value: "scan"
+        },
+        { label: "Sign in", hint: "veefore login", value: "login" },
+        { label: "Show every command", hint: "veefore help", value: "help" },
+        { label: "Exit", hint: "esc", value: "exit" }
+      ]);
+    } catch (error) {
+      if (error instanceof MenuCancelled) return 0;
+      throw error;
+    }
+    out();
+    try {
+      switch (action) {
+        case "setup":
+          return await initCommand(args, flags);
+        case "scan":
+          await scanCommand([], flags);
+          break;
+        case "login":
+          await login(resolveControlPlaneUrl(flags.controlPlaneUrl));
+          break;
+        case "help":
+          printRootHelp(version);
+          break;
+        case "exit":
+          return 0;
+      }
+    } catch (error) {
+      if (!(error instanceof MenuCancelled)) reportError(error, flags);
+    }
+  }
+}
+async function initWithWelcome(args, flags, version) {
+  await showWelcome(welcomeContext(flags, version));
+  return initCommand(args, flags);
+}
+function welcomeContext(flags, version) {
+  const project = readProjectConfig();
+  const controlPlaneUrl = project?.controlPlaneUrl ?? resolveControlPlaneUrl(flags.controlPlaneUrl);
+  const session = loadSession(controlPlaneUrl);
+  const home = homedir2();
+  const cwd = process.cwd();
+  const folder = cwd === home || cwd.startsWith(`${home}${path11.sep}`) ? `~${cwd.slice(home.length)}` : cwd;
+  return {
+    version,
+    facts: [
+      ["Folder", shorten(folder, 34)],
+      ["Signed in", session ? session.email : style.grey("not yet")],
+      [
+        "Project",
+        project ? `${project.agentName} \xB7 ${project.environmentName}` : style.grey("not set up here")
+      ],
+      ["Veefore", hostOf(controlPlaneUrl)]
+    ]
+  };
+}
+function hostOf(url) {
+  try {
+    return new URL(url).host;
+  } catch {
+    return url;
+  }
+}
+function shorten(text, width) {
+  return text.length <= width ? text : `\u2026${text.slice(text.length - width + 1)}`;
+}
+
 // src/index.ts
-var CLI_VERSION = "1.0.0";
+var CLI_VERSION = "1.1.0";
 async function run(argv) {
   const { flags, rest } = parseGlobalFlags(argv);
   if (rest.includes("--version") || rest.includes("-V")) {
@@ -8612,7 +9015,7 @@ async function run(argv) {
   const wantsHelp = rest.includes("--help") || rest.includes("-h");
   if (command === void 0 && !wantsHelp && process.stdin.isTTY && process.stdout.isTTY) {
     try {
-      return await initCommand(args, flags);
+      return flags.json ? await initCommand(args, flags) : await homeCommand(args, flags, CLI_VERSION);
     } catch (error) {
       return handleError(error, flags);
     }
@@ -8632,7 +9035,7 @@ async function run(argv) {
     switch (command) {
       case "init":
       case "setup":
-        return await initCommand(args, flags);
+        return flags.json || !isInteractive() ? await initCommand(args, flags) : await initWithWelcome(args, flags, CLI_VERSION);
       case "scan":
         return await scanCommand(args, flags);
       case "integrate":
@@ -8690,28 +9093,8 @@ async function run(argv) {
   }
 }
 function handleError(error, flags) {
-  if (error instanceof CliError) {
-    err();
-    err(`${style.red("\u2717")} ${error.message}`);
-    if (error.hint) err(style.grey(`  ${error.hint}`));
-    err();
-    return error.exitCode;
-  }
-  if (error instanceof CliApiError) {
-    err();
-    reportApiError(error);
-    err();
-    return 1;
-  }
-  err();
-  err(`${style.red("\u2717")} ${error instanceof Error ? error.message : String(error)}`);
-  if (flags.verbose && error instanceof Error && error.stack) {
-    err(style.grey(error.stack));
-  } else {
-    err(style.grey("  Re-run with --verbose for the stack trace."));
-  }
-  err();
-  return 1;
+  if (error instanceof MenuCancelled) return error.exitCode;
+  return reportError(error, flags);
 }
 function parseGlobalFlags(argv) {
   const flags = { json: false, yes: false, verbose: false };