@open-everywhere/create 0.2.1 → 0.3.0

package/README.md

@@ -27,7 +27,9 @@ npm create @open-everywhere my-agent
 This scaffolds the quickstart app into `./my-agent`, prints the next steps and exits. It never
 prompts. The directory must be new or empty. A fresh clone of an empty repository holds only `.git`,
 and it counts as empty: run `npx @open-everywhere/create .` inside it. The scaffold refuses a
-directory that holds anything else. The app depends on the eight `@open-everywhere/*` libraries at
+directory that holds anything else. Run inside an empty clone named `my-agent`,
+`npx @open-everywhere/create my-agent` would make `my-agent/my-agent/`, so it refuses and prints the
+`.` command instead. To nest on purpose, create the inner directory first. The app depends on the eight `@open-everywhere/*` libraries at
 this CLI's own version — plus this package itself, as a dev dependency, for its `check` script — and
 on `eve` at the pin core declares; its `postinstall` applies the eve patch. Its roster mounts the launch surfaces: Slack, Notion and GitHub. The app carries `AGENTS.md`,
 a `.mcp.json` for the `open-everywhere-ops` MCP server and the `quickstart-open-everywhere` skill,
@@ -42,7 +44,10 @@ npx @open-everywhere/create --check
 `--check` prompts for nothing, changes nothing, sends no telemetry and never scaffolds. It reports
 each setup step with what is missing and the next command for it. Add `--json` for the same report
 as one JSON object, which is what an agent-driven setup reads. `--route docker` judges against the
-Docker route (the default is `vercel`), and `--host https://<host>` probes a deployment.
+Docker route (the default is `vercel`), and `--host https://<host>` probes a deployment. With
+`--host`, the env step also reads the deployment's public status route (`/eve/v1/oe/status`), so a
+value set only on the deployment (in the Vercel dashboard, say) counts. Without it, the step reads
+only `.env.local` and the shell.
 
 Run it from inside an Open Everywhere app — a scaffolded one, or a clone of the repository. From a
 directory that is not an app, it reports an unsatisfied repo step and tells you to scaffold one.
@@ -51,7 +56,13 @@ The same step list written out for a human is
 [Setup steps](https://github.com/open-everywhere/open-everywhere/blob/main/docs/deploy/setup-steps.md).
 That page is generated from the step list this command reports, so the two cannot drift.
 
-This CLI starts on Node 18 or newer. The app it scaffolds needs Node 24.
+This CLI starts on Node 18 or newer, so `--check` can report an old Node. The app it scaffolds needs
+Node 24, so a scaffold on an older Node exits non-zero and writes nothing.
+
+The scaffolded app sends anonymous usage telemetry when it runs, ON by default. Its `README.md`
+says how to turn it off (`OE_TELEMETRY=off` on the deployment), and the full disclosure is
+[Telemetry](https://github.com/open-everywhere/open-everywhere/blob/main/docs/deploy/telemetry.md).
+This CLI itself sends none.
 
 ## Docs
 
@@ -61,8 +72,8 @@ This CLI starts on Node 18 or newer. The app it scaffolds needs Node 24.
 
 ## Status
 
-The 0.1 line is the first public release. It is pre-1.0: the API surface is expected to
-change, and a minor release may break you. Pin an exact version.
+This package is pre-1.0: the API surface is expected to change, and a minor release may
+break you. Pin an exact version.
 
 ## Licence
 

package/bin/create-open-everywhere.js

@@ -11,6 +11,10 @@
 // and `npm create @open-everywhere` resolves it there. The bin keeps the command name a scaffolded
 // app's `check` script already runs. One bin is declared, so `npm exec` picks it either way.
 //
+// THE NODE GATE IS NOT HERE. The scaffold refuses a Node below core's range (src/cli.ts
+// `scaffoldNodeRefusal`, OPE-2399), and `--check` must still run on that Node to report it. Both
+// need the parsed argv, so the gate lives in the TS entry, which tsx runs on any Node it supports.
+//
 // WHAT IT WRITES. With a `<dir>` argument it SCAFFOLDS, and that is the only write: it copies the
 // quickstart app (`template/`) into a new or empty `<dir>` (`src/scaffold.ts`) and prints the next
 // steps. With `--check` it only REPORTS on the current directory — every step is a pure `check()`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-everywhere/create",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "license": "Apache-2.0",
   "type": "module",
   "description": "npx scaffold and setup check for Open Everywhere — one step engine, reported by --check for an agent-led setup.",
@@ -46,8 +46,8 @@
     "test:env-pipe": "tsx scripts/env-pipe-test.ts"
   },
   "dependencies": {
-    "@open-everywhere/core": "0.2.1",
-    "@open-everywhere/provider-slack": "0.2.1",
+    "@open-everywhere/core": "0.3.0",
+    "@open-everywhere/provider-slack": "0.3.0",
     "tsx": "^4.23.9"
   },
   "devDependencies": {

package/src/cli.ts

@@ -5,7 +5,8 @@
 // TWO JOBS, AND NOTHING ELSE (OPE-2233):
 //   1. `<dir>` SCAFFOLDS the quickstart app (scaffold.ts) and prints what to do next.
 //   2. `--check [--json]` REPORTS the setup steps for the current directory. Pure `check()` calls:
-//      no prompts, no writes, no network except the `--host` deploy probe, and no telemetry.
+//      no prompts, no writes, no network except the two `--host` reads (the deploy probe and the
+//      status route), and no telemetry. A scaffold on a Node below core's range is refused (OPE-2399).
 //
 // 🔴 THERE IS NO INTERACTIVE WIZARD, AND THIS CLI SENDS NO TELEMETRY. The TTY wizard is retired:
 // setup is AGENT-LED (open the app in a coding agent, which reads AGENTS.md and drives the
@@ -17,8 +18,9 @@
 import { checkAll, isSetupRoute, SETUP_ROUTES, type SetupRoute, type StepContext } from "./engine.js";
 import { SETUP_STEPS } from "./steps/index.js";
 import { CLI_VERSION } from "./version.js";
-import { initGitRepo, scaffoldApp, ScaffoldRefusal } from "./scaffold.js";
+import { initGitRepo, nestedNameRefusal, scaffoldApp, ScaffoldRefusal } from "./scaffold.js";
 import { resolve } from "node:path";
+import { coreNodeRange, nodeRangeSatisfied } from "@open-everywhere/core/agent/ops/package-info.js";
 import { pathToFileURL } from "node:url";
 import { slackAppNameProblem } from "@open-everywhere/provider-slack/agent/app-manifest.js";
 import { readAppNaming } from "./app-naming.js";
@@ -39,7 +41,8 @@ const USAGE = `create-open-everywhere [<dir>] [--check [--json]] [--route vercel
                  two supported routes. A local run is the development loop
                  after a deploy, never a route.
   --host <url>   The deployment's public origin. The build + deploy step
-                 probes its Slack route.
+                 probes its Slack route, and the env step reads the env
+                 verdicts its status route (/eve/v1/oe/status) reports.
   --app-name <name>
                  The Slack app's name in the manifest the Slack step prints.
                  Default: the app's identity.name setting, else "Open
@@ -181,6 +184,26 @@ function runScaffold(target: string): string | undefined {
   }
 }
 
+/**
+ * The scaffold's Node gate (OPE-2399). The app needs the Node range `@open-everywhere/core` declares,
+ * and a scaffold on an older Node used to succeed with only npm's EBADENGINE warnings, so the person
+ * met the failure later and further from its cause. The gate refuses BEFORE a byte is written.
+ *
+ * It gates the scaffold only. `--check` still runs on an old Node, because its prerequisites step is
+ * the report that says which Node to install. An unreadable range does not block: the
+ * prerequisites step reports that case as "cannot tell".
+ */
+export function scaffoldNodeRefusal(version: string, range: string | undefined): string | undefined {
+  if (range === undefined || nodeRangeSatisfied(range, version) !== false) return undefined;
+  return `refusing to scaffold: Open Everywhere needs Node ${range} (found ${version}). Run \`nvm install 24 && nvm use 24\`, then run this command again.`;
+}
+
+/** What `main` reads from the process, injectable so a test can drive any Node version. */
+export interface MainOptions {
+  readonly nodeVersion?: string;
+  readonly nodeRange?: string;
+}
+
 /** What to do after a scaffold. The scaffold never prompts, so this is always printed. */
 function nextSteps(target: string): string {
   return [
@@ -197,7 +220,7 @@ function nextSteps(target: string): string {
   ].join("\n");
 }
 
-export async function main(argv: readonly string[]): Promise<number> {
+export async function main(argv: readonly string[], options: MainOptions = {}): Promise<number> {
   if (argv.includes("--help") || argv.includes("-h")) {
     console.log(USAGE);
     return 0;
@@ -226,6 +249,16 @@ export async function main(argv: readonly string[]): Promise<number> {
     console.error("--check changes nothing, so it cannot scaffold. Scaffold first, then run --check from inside the app.");
     return 2;
   }
+  const nodeRefusal = scaffoldNodeRefusal(options.nodeVersion ?? process.versions.node, "nodeRange" in options ? options.nodeRange : coreNodeRange());
+  if (nodeRefusal !== undefined) {
+    console.error(nodeRefusal);
+    return 1;
+  }
+  const nested = nestedNameRefusal(target, process.cwd());
+  if (nested !== undefined) {
+    console.error(nested);
+    return 1;
+  }
   const dir = runScaffold(target);
   if (dir === undefined) return 1;
   console.log(nextSteps(target));

package/src/deploy-status.ts

@@ -0,0 +1,84 @@
+// The deployment's own env verdicts — `GET <host>/eve/v1/oe/status` (OPE-2399).
+//
+// `--check` reads `.env.local` and this shell. A Vercel app whose values were set in the dashboard
+// holds them only on the deployment, so the env step read it as all-missing. With `--host`, the env
+// step also reads the deployment's public status route and reports the verdicts the deployment gives
+// for its own environment. The route is unauthenticated by design and carries only closed-vocabulary
+// verdicts plus prose core wrote (packages/core/agent/ops/status.ts), so no secret crosses here.
+//
+// This module imports nothing from core. The route path is a copy of core's `OE_STATUS_PATH`, and
+// scripts/engine-test.ts fails when the two differ: importing `ops/status.ts` would pull the
+// access, sandbox and store resolvers into a CLI that must start before anything is configured.
+
+/** The status route. A COPY of core's `OE_STATUS_PATH` — engine-test.ts pins the two equal. */
+export const DEPLOY_STATUS_PATH = "/eve/v1/oe/status";
+
+/**
+ * The status rows that judge the deployment's ENVIRONMENT, in the order the env step reports them.
+ * `secrets` is the root-of-trust pair (DATABASE_URL and the credential key), `postgres` is the
+ * store selection that DATABASE_URL drives, and `model-route` is the gateway. The other rows (Node,
+ * sandbox, egress, workflow storage, public URL) judge the host, not the env checklist.
+ */
+export const DEPLOYED_ENV_REQUIREMENTS = ["secrets", "postgres", "model-route"] as const;
+
+export type Verdict = "yes" | "no" | "unknown";
+
+export interface DeployedRequirement {
+  readonly id: string;
+  readonly met: Verdict;
+  readonly detail: string;
+}
+
+export type DeployedStatusRead =
+  | { readonly ok: true; readonly url: string; readonly requirements: readonly DeployedRequirement[] }
+  | { readonly ok: false; readonly url: string; readonly detail: string };
+
+const VERDICTS: readonly string[] = ["yes", "no", "unknown"];
+
+/** The rows of a status document, or `undefined` when the body is not one. */
+export function parseStatusRequirements(body: unknown): DeployedRequirement[] | undefined {
+  if (typeof body !== "object" || body === null) return undefined;
+  const rows = (body as { requirements?: unknown }).requirements;
+  if (!Array.isArray(rows)) return undefined;
+  const out: DeployedRequirement[] = [];
+  for (const row of rows) {
+    if (typeof row !== "object" || row === null) return undefined;
+    const { id, met, detail } = row as Record<string, unknown>;
+    if (typeof id !== "string" || typeof met !== "string" || !VERDICTS.includes(met)) return undefined;
+    out.push({ id, met: met as Verdict, detail: typeof detail === "string" ? detail : "" });
+  }
+  return out;
+}
+
+/** Read the deployment's status document. One GET, no retry: the deploy probe owns cold starts. */
+export async function readDeployedStatus(origin: string, fetchImpl: typeof fetch = fetch, timeoutMs = 15_000): Promise<DeployedStatusRead> {
+  const url = `${origin}${DEPLOY_STATUS_PATH}`;
+  let res: Response;
+  try {
+    res = await fetchImpl(url, { method: "GET", signal: AbortSignal.timeout(timeoutMs), redirect: "manual" });
+  } catch (err) {
+    return { ok: false, url, detail: `${url} did not answer (${err instanceof Error ? err.message : String(err)})` };
+  }
+  if (res.status !== 200) return { ok: false, url, detail: `${url} answered ${res.status}, not the status document` };
+  let body: unknown;
+  try {
+    body = JSON.parse(await res.text());
+  } catch {
+    return { ok: false, url, detail: `${url} answered 200, but the body is not JSON` };
+  }
+  const requirements = parseStatusRequirements(body);
+  if (requirements === undefined) return { ok: false, url, detail: `${url} answered 200, but the body is not a status document` };
+  return { ok: true, url, requirements };
+}
+
+/**
+ * The env step's verdict from a status document. Satisfied when the deployment reports `secrets`
+ * as "yes" and no env row as "no". An "unknown" row does not fail the step: the route uses it for
+ * "not measured" (no probe registered), never for "probably not". An absent row counts as unknown.
+ */
+export function deployedEnvVerdict(requirements: readonly DeployedRequirement[]): { satisfied: boolean; summary: string } {
+  const byId = new Map(requirements.map((r) => [r.id, r]));
+  const rows = DEPLOYED_ENV_REQUIREMENTS.map((id) => byId.get(id) ?? { id, met: "unknown" as const, detail: "not in the document" });
+  const satisfied = byId.get("secrets")?.met === "yes" && rows.every((r) => r.met !== "no");
+  return { satisfied, summary: rows.map((r) => `${r.id}=${r.met} (${r.detail})`).join("; ") };
+}

package/src/engine.ts

@@ -6,8 +6,9 @@
 //
 // 🔴 THERE IS NO INTERACTIVE WIZARD (OPE-2233). The TTY wizard, its `WizardIO` prompt surface and
 // every step's `automate()` are retired: setup is AGENT-LED. The agent reads this engine's report
-// and runs the commands with the user's consent, and the ops MCP server's `scaffold_env` /
-// `scaffold_credential_key` tools do the writes a step's `automate()` used to do. So this engine
+// and runs the commands with the user's consent. The ops MCP server's `scaffold_env` /
+// `scaffold_credential_key` tools and the person's own `oe env set <NAME>` (every secret value,
+// OPE-2396) do the writes a step's `automate()` used to do. So this engine
 // is READ-ONLY by construction: `check()` inspects, `guide()` describes, and nothing writes.
 //
 // Resumability is structural, not a bookkeeping flag: `check()` inspects the REAL WORLD (env vars,
@@ -39,7 +40,7 @@ export interface StepContext {
   readonly env: NodeJS.ProcessEnv;
   /** The route the steps judge against. Absent means `vercel`. */
   readonly route?: SetupRoute;
-  /** The deployment's public origin (`--host`), for the deploy probe. */
+  /** The deployment's public origin (`--host`), for the deploy probe and the env step's status read. */
   readonly host?: string;
   /** The chat app's name (`--app-name`), for the Slack manifest. It wins over {@link agentName}. */
   readonly appName?: string;

package/src/env-file.ts

@@ -1,10 +1,11 @@
 // Thin .env.local helpers for the setup steps' `check()`s.
 //
 // 🔴 READ-ONLY SINCE OPE-2233. This module used to carry `writeEnvLocal`, which the wizard's
-// `automate()` steps called. Setup is agent-led now, and the ONE door that writes `.env.local` is
-// the ops MCP server's `scaffold_env` tool — which gates the target filename, so a value can never
-// land in a tracked file (agent/ops/server.ts § envTargetRefusal). A second writer here would be a
-// second gate to keep right.
+// `automate()` steps called. Setup is agent-led now, and two doors write `.env.local`: the ops MCP
+// server's `scaffold_env` tool (non-secret config) and `oe env set <NAME>` (a secret, typed in the
+// person's own terminal — OPE-2396). Both pass one gate on the target filename, so a value can never
+// land in a tracked file (core agent/ops/quickstart.ts § envFileTargetRefusal). A third writer here
+// would be a second gate to keep right.
 //
 // SECURITY: nothing here ever returns a secret VALUE to a caller for printing — `mergedEnv` and
 // `isSet` are presence checks only. See AGENTS.md's "never log secrets" rule.
@@ -41,13 +42,14 @@ export function isSet(v: string | undefined): boolean {
 }
 
 /**
- * What a "missing" detail adds (OPE-2222). `--check` reads `.env.local` and the shell, and NEVER
- * the deployment's own environment. Setting a value on the deployment instead is a normal thing to
- * do, so a miss here can be a value the deployment already holds. The check does not call a vendor
- * CLI to find out: that needs a login and a network round trip.
+ * What a "missing" detail adds (OPE-2222). Without `--host`, `--check` reads `.env.local` and the
+ * shell, and NEVER the deployment's own environment. Setting a value on the deployment instead is a
+ * normal thing to do, so a miss here can be a value the deployment already holds. The check does
+ * not call a vendor CLI to find out: that needs a login. It names `--host` instead, which reads the
+ * deployment's public status route (OPE-2399, deploy-status.ts).
  */
 export function missNote(route: SetupRoute): string {
   const where = route === "docker" ? "the container's environment" : "the Vercel project";
   const list = route === "docker" ? "`docker inspect` lists the names there" : "`npx vercel env ls production` lists the names there";
-  return `Did you set these on ${where} instead? Then ignore this miss: the check reads only .env.local and this shell, never the deployment's own env (${list})`;
+  return `Did you set these on ${where} instead? Re-run with --host https://<host>: the env step then also reads the deployment's own verdicts from its status route. Without --host it reads only .env.local and this shell (${list})`;
 }

package/src/scaffold.ts

@@ -99,6 +99,27 @@ export function isScaffoldableDir(dir: string): boolean {
   return readdirSync(dir).every((name) => name === ".git");
 }
 
+/**
+ * The nested-name case (OPE-2399). A person who clones an empty repository named `my-agent`, enters
+ * it, and runs `npx @open-everywhere/create my-agent` gets `my-agent/my-agent/`. The scaffold is
+ * correct, but it is almost never what the person wanted. So when the target is a direct child of
+ * `cwd` with the same name, and `cwd` counts as empty (see {@link isScaffoldableDir}), this returns
+ * a refusal that names the `.` command. A person who does want the nested directory creates it
+ * first: `cwd` then holds it, is no longer empty, and the refusal does not apply.
+ */
+export function nestedNameRefusal(target: string, cwd: string): string | undefined {
+  const dir = resolve(cwd, target);
+  const here = resolve(cwd);
+  if (resolve(dir, "..") !== here || basename(dir) !== basename(here)) return undefined;
+  if (!isScaffoldableDir(here)) return undefined;
+  return [
+    `refusing to scaffold: you are inside an empty directory named "${basename(here)}", so this would create ${basename(here)}/${basename(dir)}/.`,
+    "To scaffold into this directory, run:",
+    "  npx @open-everywhere/create .",
+    `To nest the app on purpose, create the directory first (\`mkdir ${basename(dir)}\`), then run this command again.`,
+  ].join("\n");
+}
+
 /**
  * Copy the template into `targetDir`. Creates the directory when it is absent. Throws a
  * {@link ScaffoldRefusal} when it exists and is not an empty directory. A directory that holds only

package/src/steps/database.ts

@@ -30,7 +30,8 @@ function postgresResolution(env: NodeJS.ProcessEnv): { operational: boolean; mem
 
 /** The next action for an unsatisfied database step, per route. */
 function nextFor(route: SetupRoute): string {
-  const write = 'write it with the ops MCP tool `scaffold_env { values: { DATABASE_URL: "<the connection string>" } }` — it selects postgres for both stores on its own';
+  const write =
+    "ask the person to run `npx oe env set DATABASE_URL` in their own terminal and paste the connection string at its hidden prompt — it selects postgres for both stores on its own";
   return route === "vercel"
     ? `add Neon from the Vercel Marketplace (\`npx vercel install neon\`, or the project's Storage → Neon → Connect; either sets DATABASE_URL on the project), then ${write}`
     : `provision a Postgres the container can reach (the deployment contract names it), then ${write}`;
@@ -72,9 +73,9 @@ export const databaseStep: SetupStep = {
       summary: "Both routes need Postgres: an ephemeral disk (Vercel) or a replaced container (Docker) loses every local store.",
       instructions: [
         vercel
-          ? "`npx vercel install neon` provisions Neon and connects it to the linked project, which sets DATABASE_URL there. The project's Storage → Neon → Connect does the same thing."
+          ? "`npx vercel install neon` provisions Neon and connects it to the linked project, which sets DATABASE_URL there. The project's Storage → Neon → Connect does the same thing. The integration can also enable Neon Auth (NEON_AUTH_BASE_URL, VITE_NEON_AUTH_URL): Open Everywhere does not use it, so leave it off, or ignore those two variables."
           : "Provision a Postgres the container can reach (Neon, RDS, or your own server). The deployment contract states what it must satisfy.",
-        "Write the same connection string into .env.local with the ops tool `scaffold_env`. It selects postgres for the operational store and the memory backing on its own — no provider selector needed. Never paste a connection string into the chat.",
+        "Write the same connection string into .env.local with `npx oe env set DATABASE_URL`, run in your own terminal: it reads the value from a hidden prompt. It selects postgres for the operational store and the memory backing on its own — no provider selector needed. Never paste a connection string into the chat, and never pass it to an ops tool.",
         vercel
           ? "The deployment needs it too: the Neon integration already set DATABASE_URL on the Vercel project."
           : "The deployment needs it too: DATABASE_URL is part of the container's environment.",

package/src/steps/env-checklist.ts

@@ -12,22 +12,40 @@
 import { preflight } from "@open-everywhere/core/agent/ops/quickstart.js";
 import { routeOf, type SetupStep, type StepContext } from "../engine.js";
 import { mergedEnv, missNote } from "../env-file.js";
+import { normalizeHost } from "../deploy-probe.js";
+import { deployedEnvVerdict, readDeployedStatus } from "../deploy-status.js";
 
 export const envChecklistStep: SetupStep = {
   id: "env-checklist",
   title: "Env var checklist",
-  check(ctx: StepContext) {
+  // WITH `--host`, THE DEPLOYMENT'S OWN VERDICT COUNTS TOO (OPE-2399). A Vercel app configured in
+  // the dashboard holds its values only on the deployment, so the local reading alone said
+  // "all missing". The step then reads the public status route (deploy-status.ts). Either reading
+  // can satisfy the step, and the detail names which one did. A status route that cannot be read
+  // leaves the local verdict as it was and says why.
+  async check(ctx: StepContext) {
     const env = mergedEnv(ctx.cwd, ctx.env) as NodeJS.ProcessEnv;
     const route = routeOf(ctx);
     const { checks, ready } = preflight(env, { target: route });
+    if (ready) return { satisfied: true, detail: `all required env vars present for the ${route} route` };
     const missing = checks.filter((c) => c.status === "missing");
-    return {
-      satisfied: ready,
-      detail: ready
-        ? `all required env vars present for the ${route} route`
-        : `missing from .env.local and this shell: ${missing.map((c) => c.name).join(", ")}. ${missNote(route)}`,
-      next: ready ? undefined : missing.map((c) => c.fix).filter((f): f is string => Boolean(f)).join(" · "),
-    };
+    const localMiss = `missing from .env.local and this shell: ${missing.map((c) => c.name).join(", ")}`;
+    const localNext = missing.map((c) => c.fix).filter((f): f is string => Boolean(f)).join(" · ");
+    const origin = ctx.host === undefined ? undefined : normalizeHost(ctx.host);
+    if (origin === undefined) return { satisfied: false, detail: `${localMiss}. ${missNote(route)}`, next: localNext };
+    const read = await readDeployedStatus(origin);
+    if (!read.ok) return { satisfied: false, detail: `${localMiss}. The deployment's own verdicts could not be read: ${read.detail}`, next: localNext };
+    const deployed = deployedEnvVerdict(read.requirements);
+    return deployed.satisfied
+      ? {
+          satisfied: true,
+          detail: `the deployment reports its env as set (${read.url}): ${deployed.summary}. The local reading differs (${localMiss}); that is expected when the values live only on the deployment`,
+        }
+      : {
+          satisfied: false,
+          detail: `the deployment reports its env as NOT set (${read.url}): ${deployed.summary}. Locally, ${localMiss}`,
+          next: localNext,
+        };
   },
   // 🔴 `guide()` IS STATIC, AND THAT IS DELIBERATE (OPE-2233). It used to dump the live preflight
   // rows, which read `process.versions.node` and the operator's `.env.local`. `guide()` is now read
@@ -48,7 +66,8 @@ export const envChecklistStep: SetupStep = {
           : "The Vercel route needs NO AI_GATEWAY_API_KEY: a deployed project authenticates to the AI Gateway with OIDC.",
         "Each chat surface adds its own names — Slack reads SLACK_BOT_TOKEN and SLACK_SIGNING_SECRET from the environment.",
         "Not needed on a deployment: OE_PUBLIC_BASE_URL (only for a custom domain) and OE_INTAKE_PAGE_SIGNING_KEY (the deployment mints it into the credential store).",
-        "Run `npx @open-everywhere/create --check --json`, or the ops tool `preflight`, for the live verdict per name.",
+        "Run `npx @open-everywhere/create --check --json`, or the ops tool `preflight`, for the live verdict per name. Both read .env.local and the shell only.",
+        "Set the values on the deployment instead (the Vercel dashboard, say)? Add `--host https://<host>`: the step then also reads the deployment's own verdicts from its public `/eve/v1/oe/status` route.",
       ],
     };
   },

package/src/steps/slack.ts

@@ -51,7 +51,7 @@ export const slackStep: SetupStep = {
       next:
         'open https://<host>/setup once the deployment is up (it creates and installs the Slack app from one pasted configuration ' +
         'token, with no env var to set), or create the app from the manifest the ops tool `surface_manifest { surface: "slack" }` ' +
-        "returns and write each pasted value with `scaffold_env`",
+        "returns, then have the person run `npx oe env set SLACK_BOT_TOKEN` and `npx oe env set SLACK_SIGNING_SECRET` in their own terminal",
     };
   },
   guide(ctx: StepContext) {
@@ -76,7 +76,7 @@ export const slackStep: SetupStep = {
         }). A second install in one workspace needs its own name: re-run with --app-name "<name>".`,
         "Install to Workspace, then OAuth & Permissions → copy the Bot User OAuth Token (xoxb-…) = SLACK_BOT_TOKEN.",
         "Basic Information → App Credentials → copy the Signing Secret = SLACK_SIGNING_SECRET.",
-        "Write both with the ops tool `scaffold_env`. Never paste a secret into the chat: the person pastes it where the tool reads it.",
+        "Write both with `npx oe env set SLACK_BOT_TOKEN` and `npx oe env set SLACK_SIGNING_SECRET`, run in your own terminal: each reads the value from a hidden prompt. Never paste a secret into the chat, and never pass one to an ops tool.",
         "THE SHORT WAY, once the deployment is up: open https://<host>/setup. It creates the Slack app from this same manifest with one pasted Slack app configuration token, installs it, and keeps every credential in the deployment's own encrypted store — no env var to set. This check cannot see that store, so it still reports this step unsatisfied afterwards; the status endpoint can.",
         "The manifest's URLs say YOUR-DEPLOY-URL until you deploy. Slack cannot verify Event Subscriptions before a deploy that holds SLACK_SIGNING_SECRET is up. After the deploy, paste the manifest again with your host (App Manifest → Save Changes), then retry the verification under Event Subscriptions.",
         "Note two ids for the trust edits: the workspace (team) id T… (the segment after /client/ in the workspace URL at https://app.slack.com), and your own member id U… (your Slack profile → ⋮ More → Copy member ID).",

package/template/.env.example

@@ -18,7 +18,7 @@ AI_GATEWAY_API_KEY=
 # replaced Docker container starts from an empty volume, so without it core throws at the first
 # store or DM-memory use. On the Vercel route add Neon from the Marketplace
 # (`npx vercel install neon`, or project -> Storage -> Neon -> Connect): it sets DATABASE_URL on the
-# project. Copy the same value here so the operator tools (`npx oe secret`, the ops server's
+# project. Copy the same value here (`npx oe env set DATABASE_URL`, in your own terminal) so the operator tools (`npx oe secret`, the ops server's
 # `secret_set`) write the store the deployment reads. A local run needs nothing: it uses an embedded
 # database under .open-everywhere-data/.
 DATABASE_URL=
@@ -38,6 +38,15 @@ DATABASE_URL=
 # whose credential names `broker: "db"` in the encrypted store. The Slack variables and
 # GITHUB_WEBHOOK_SECRET below are read from the ENVIRONMENT only, so they stay environment variables.
 
+# --- Telemetry (https://github.com/open-everywhere/open-everywhere/blob/main/docs/deploy/telemetry.md) ---
+# The deployed app sends ANONYMOUS USAGE TELEMETRY, ON BY DEFAULT: event names, enums, coarse
+# buckets, public model ids and the app version, with a random per-install id (service.instance.id).
+# Never message or memory content, org names, workspace, channel, user or session ids, or env
+# values. The page above lists every event. To turn it
+# off, set this ON THE DEPLOYMENT (the Vercel project or the container's environment): a value here
+# only reaches a local run, because .env.local never ships. DO_NOT_TRACK=1 does the same.
+# OE_TELEMETRY=off
+
 # --- Slack (https://github.com/open-everywhere/open-everywhere/blob/main/docs/deploy/surfaces/slack.md) ---
 # Slack app -> OAuth & Permissions -> Bot User OAuth Token (xoxb-…).
 SLACK_BOT_TOKEN=

package/template/AGENTS.md

@@ -17,17 +17,31 @@ Setup is yours to drive, with the user's consent at every command. Use the
 - **Never propose a local run as a setup step.** `npm run dev` is the development loop after the
   deploy — changing tools and skills, evals, debugging a turn. A local run has no public HTTPS URL
   for Slack to reach and a different store, so it proves little about the deployment.
-- **Never ask the user to paste a secret into the chat.** They paste it where a tool reads it; you
-  write it with `scaffold_env`, or mint it with `scaffold_credential_key`, which never prints it.
+- **Never ask the user to paste a secret into the chat, and never pass one to a tool.** The user
+  types each secret into their own terminal with `npx oe env set <NAME>` (a hidden prompt into
+  `.env.local`). You handle names only: `scaffold_env { secretNames }` gives the command per name,
+  and `scaffold_credential_key` mints the store key without printing it.
+- **Tell the user about telemetry before the first deploy.** The deployed app sends anonymous usage
+  telemetry, and it is ON by default: event names, enums, coarse buckets, public model ids and the
+  app version, with a random per-install id (`service.instance.id`). It never sends message or
+  memory content, org names, workspace, channel, user or session ids, or env values. To turn it off, they set `OE_TELEMETRY=off` (or
+  `DO_NOT_TRACK=1`) on the deployment itself. The full list of events is
+  `https://github.com/open-everywhere/open-everywhere/blob/main/docs/deploy/telemetry.md`. Ask which
+  they want, and do not decide for them.
 - `npx @open-everywhere/create --check --json` is the status report: every step, with `satisfied`,
   `detail` and a `next` command. Add `--route docker` for the Docker route and
-  `--host https://<host>` to probe a deployment. The human-readable version of the same step list is
+  `--host https://<host>` to probe a deployment and read the env verdicts it reports for itself. The human-readable version of the same step list is
   `https://github.com/open-everywhere/open-everywhere/blob/main/docs/deploy/setup-steps.md`.
 
 ## Where things live
 
 - `roster.config.ts` — what the agent can do. `roster.lock.json` is the reviewed roll-call of every
   contribution. Both are committed.
+- `scripts/goldens/roster-plan.txt` — the roster review surface: one line per slot file `oe build`
+  writes, with the package that mounts it. The slot tree is not committed, so this file is how a
+  pull request shows what the agent gains or loses. `oe build` keeps it current, and
+  `npx oe build --check` fails when it differs from the plan. Commit it, and read its diff with the
+  lock's. Never edit it by hand.
 - `agent/agent.ts` — the eve agent definition.
 - `agent/` — the config: access bundles, identity and trust, memory domains, models, settings, spend
   caps, webhooks. Each file's header says what it controls.

package/template/README.md

@@ -28,7 +28,19 @@ It is generated from the same step list the status check reports, so it cannot d
 
 `npx @open-everywhere/create --check` reports every setup step and the next command for each
 unsatisfied one. It changes nothing. Add `--json` for the report as data, `--route docker` to judge
-against the Docker route, and `--host https://<host>` to probe a deployment.
+against the Docker route, and `--host https://<host>` to probe a deployment. With `--host`, the env
+step also reads the deployment's own verdicts, so values set only in the Vercel dashboard count.
+
+## Telemetry
+
+The deployed app sends **anonymous usage telemetry, ON by default**: event names, enums, coarse
+buckets, public model ids and the app version. Each event carries a random per-install id
+(`service.instance.id`). It never sends message or memory content, org names, workspace, channel,
+user or session ids, or env values. **To turn it off, set `OE_TELEMETRY=off`** (or `DO_NOT_TRACK=1`) on the deployment:
+the Vercel project's environment or the container's. `.env.local` alone does not do it, because it
+never ships. Every event and attribute is listed in the
+[telemetry disclosure](https://github.com/open-everywhere/open-everywhere/blob/main/docs/deploy/telemetry.md).
+The `@open-everywhere/create` CLI sends none.
 
 ## Develop locally
 
@@ -44,6 +56,7 @@ without a public tunnel.
 | --- | --- |
 | `roster.config.ts` | What the agent can do: which packages contribute, and which eve built-ins it takes away. |
 | `roster.lock.json` | The reviewed roll-call of every contribution. `npx oe build --accept` updates it. Review its diff. |
+| `scripts/goldens/roster-plan.txt` | The roster review surface: one line per slot file `oe build` writes, with the package that mounts it. `oe build` keeps it current and `npx oe build --check` fails when it drifts. Commit it, and review its diff with the lock's. |
 | `agent/agent.ts` | The eve agent definition. |
 | `agent/access/` | Bundles and bindings (what the agent may reach, and where), connector credentials, browser hosts, and the pre-approval rules (what runs with no approval card). |
 | `agent/identity/` | Trusted surfaces, principals and groups. |

package/template/claude/skills/quickstart-open-everywhere/SKILL.md

@@ -22,9 +22,13 @@ that repository ships no `env:pipe` script. Everything else is the same.
 - The ops MCP tools check and scaffold. **You** run install, build and deploy commands in the
   user's shell: show the command, get a yes, then run it. Never run a deploy, create a cloud
   resource, or write a secret without explicit confirmation.
-- **Never ask the user to paste a secret into the chat, and never echo or commit one.** They paste
-  it where a tool reads it; you write it to the gitignored `.env.local` with `scaffold_env`, then
-  forget it. Mint the credential-store key with `scaffold_credential_key`, which never prints it.
+- **Never ask the user to paste a secret into the chat, never pass one to a tool, and never echo or
+  commit one.** A tool call is part of your transcript. The user types each secret into their OWN
+  terminal with `npx oe env set <NAME>`: it reads the value from a hidden prompt and writes it to the
+  gitignored `.env.local`. You only ever handle the NAME: `scaffold_env { secretNames: [...] }`
+  returns the command per name and whether the file holds a value yet. `scaffold_env { values }`
+  takes non-secret config only, and its schema refuses a secret name. Mint the credential-store key
+  with `scaffold_credential_key`, which never prints it.
 - **Never propose a local run as a setup step.** `npm run dev` is the development loop AFTER the
   deploy. A local run has no public HTTPS URL for Slack to reach and keeps its state in a different
   store, so it proves little about the deployment. See "Develop locally" below.
@@ -32,9 +36,17 @@ that repository ships no `env:pipe` script. Everything else is the same.
   `OE_CREDENTIAL_ENCRYPTION_KEY`, `SLACK_BOT_TOKEN`, `SLACK_SIGNING_SECRET` and
   `GITHUB_WEBHOOK_SECRET` from its **environment**: the Slack bundle and the GitHub webhook check
   never read the credential store. So these go in `.env.local`, and then into the deployment's own
-  environment. `secret_set` is for a credential whose `broker` is `"db"` (and
-  `NOTION_WEBHOOK_SECRET`). It needs `DATABASE_URL` and the key in `.env.local` first. Nothing
-  reads a stored secret back out (`secret_list` returns names only).
+  environment. `secret_set { names: [...] }` is for a credential whose `broker` is `"db"` (and
+  `NOTION_WEBHOOK_SECRET`): it moves each named value from `.env.local` into the store, so the user
+  runs `npx oe env set <NAME>` first. It needs `DATABASE_URL` and the key in `.env.local` too.
+  Nothing reads a stored secret back out (`secret_list` returns names only).
+- **If an ops tool answers "the app now runs @open-everywhere/core X; this ops server runs Y"**, the
+  server predates an upgrade. Ask the user to restart it (`/mcp`, then reconnect
+  `open-everywhere-ops`) and call again. Never work around it: a stale server serves old code. A
+  server whose core predates this check cannot refuse: after an upgrade, an input-validation error
+  that names `values` or `secrets`, a `scaffold_env` reply with no `secrets` list for the
+  `secretNames` you sent, or "Tool … not found", means the same thing. Restart it. Never fall back
+  to passing a value.
 - Every command runs from the app root.
 
 ## Step 1 — ask which route
@@ -53,11 +65,26 @@ that repository ships no `env:pipe` script. Everything else is the same.
 Nothing beyond these two is supported. For any other host, read the contract and follow the Docker
 route; do not invent a recipe.
 
+## Tell the user about telemetry, before the first deploy
+
+**The deployed app sends anonymous usage telemetry, and it is ON by default.** Tell the user that
+before the first deploy, and ask whether they want it. Do not decide for them. It sends event names,
+enums, coarse buckets, public model ids and the app version, with a random per-install id
+(`service.instance.id`). It never sends message or memory content, org names, workspace, channel,
+user or session ids, or env values. The full list
+of events is `https://github.com/open-everywhere/open-everywhere/blob/main/docs/deploy/telemetry.md`.
+
+To turn it off, `OE_TELEMETRY=off` (or `DO_NOT_TRACK=1`) must be set on the DEPLOYMENT: a value in
+`.env.local` reaches only a local run. On the Vercel route, at step 9:
+`printf off | npx vercel env add OE_TELEMETRY production`. On the Docker route, put it in the
+container's environment. Every boot prints a line that says whether telemetry is on.
+
 ## Status, at every step
 
 - `npx @open-everywhere/create --check --json` — the step list as data: `satisfied`, `detail`, and a
   `next` command per unsatisfied step. It changes nothing. Pass `--route docker` on the Docker
-  route, and `--host https://<host>` once a deployment exists. In a clone of the repository, run
+  route, and `--host https://<host>` once a deployment exists: the env step then also reads the
+  deployment's own verdicts from its public status route. In a clone of the repository, run
   `node packages/create/bin/create-open-everywhere.js --check --json` instead.
 - The `preflight` tool — the env verdict per name. Pass `target: "vercel"` or `target: "docker"`.
 
@@ -74,18 +101,21 @@ tool. The same step list, written for a human, is
 3. **Database.** `npx vercel install neon` provisions a Neon database and connects it to the linked
    project, which sets `DATABASE_URL` there. (`vercel install` is an alias of
    `vercel integration add`; the Marketplace slug is `neon`.) The dashboard path — project →
-   **Storage → Neon → Connect** — does the same thing. Then get the same value into `.env.local`
+   **Storage → Neon → Connect** — does the same thing. The integration can also enable **Neon
+   Auth** (`NEON_AUTH_BASE_URL`, `VITE_NEON_AUTH_URL`). Open Everywhere does not use it: leave it
+   off, or ignore those two variables. Then get the same value into `.env.local`
    for the operator tools, either with `npx vercel env pull` (it writes the project's environment
    into `.env.local`, overwriting it, so pull before you add anything local) or by asking the user
-   for the connection string and writing it with `scaffold_env`. **That one value is the whole
+   to run `npx oe env set DATABASE_URL` and paste the connection string at its prompt. **That one value is the whole
    step:** it resolves both the operational store and the memory backing to postgres on its own, so
    set no provider selector. A selector pointing AWAY from postgres is the only thing that breaks
    it.
 4. **Key.** `scaffold_credential_key`.
 5. **Slack app.** Call `surface_manifest { surface: "slack" }` and hand the user the manifest and
    the steps it returns. Before the first deploy the manifest keeps `YOUR-DEPLOY-URL`. The user
-   creates and installs the app, then pastes `SLACK_BOT_TOKEN` and `SLACK_SIGNING_SECRET`: write
-   both with `scaffold_env`.
+   creates and installs the app, then runs `npx oe env set SLACK_BOT_TOKEN` and
+   `npx oe env set SLACK_SIGNING_SECRET` in their own terminal. Confirm with
+   `scaffold_env { secretNames: ["SLACK_BOT_TOKEN", "SLACK_SIGNING_SECRET"] }`: both read `present: true`.
 6. **Vouch the workspace.** Ask for the team id (`T…`: the segment after `/client/` in the
    workspace URL at app.slack.com). In `agent/identity/surfaces.ts` add
    `defineSurface({ key: "slack/<team-id>", trust: "internal" })`.
@@ -96,7 +126,8 @@ tool. The same step list, written for a human, is
 9. **Deployment env.** `.env.local` never ships, so the deployment reads only what you set ON it.
    The names are `OE_CREDENTIAL_ENCRYPTION_KEY`, `SLACK_BOT_TOKEN` and `SLACK_SIGNING_SECRET`. The
    Neon integration already set `DATABASE_URL` there, and that one value resolves both stores — so
-   there is no `OE_OPERATIONAL_PROVIDER` or `OE_MEMORY_PROVIDER` to push.
+   there is no `OE_OPERATIONAL_PROVIDER` or `OE_MEMORY_PROVIDER` to push. Add `OE_TELEMETRY` (value
+   `off`) only when the user chose to turn telemetry off (see the telemetry section above).
    Confirm each command first, and **never let a value reach your own output.**
    - **In a scaffolded app:** `npm run -s env:pipe -- <NAME> | npx vercel env add <NAME> production`.
      Always pipe `env:pipe` straight into `vercel env add`, as written. Never run it bare: your
@@ -127,11 +158,12 @@ public HTTPS URL, Postgres, a sandbox backend, egress control, a model route, an
 Then:
 
 1. **Install and build.** `npm install`, then `npm run build`.
-2. **Postgres.** Provision one the container can reach, and `scaffold_env` its `DATABASE_URL`. That
-   one value resolves both stores to postgres; set no provider selector.
+2. **Postgres.** Provision one the container can reach. The user runs `npx oe env set DATABASE_URL`
+   and pastes its connection string at the prompt. That one value resolves both stores to postgres;
+   set no provider selector.
 3. **Key.** `scaffold_credential_key`.
 4. **Model route.** There is no OIDC off Vercel, so the user supplies `AI_GATEWAY_API_KEY` (Vercel
-   → AI Gateway → API Keys issues one for any host). Running a different model backend instead is
+   → AI Gateway → API Keys issues one for any host) with `npx oe env set AI_GATEWAY_API_KEY`. Running a different model backend instead is
    an **adapter swap in app code**
    (`https://github.com/open-everywhere/open-everywhere/blob/main/docs/extending/adapter-model.md`),
    which `--check` cannot see: that step stays `missing` on the Docker route either way, so read it
@@ -147,9 +179,9 @@ Then:
 
 ## Develop locally
 
-Only when the user asks to change or debug the agent — never as a setup step. Write
-`AI_GATEWAY_API_KEY` with `scaffold_env` (the user creates it: Vercel → AI Gateway → API Keys),
-then `npm run dev`. A local run keeps its state in an embedded database under
+Only when the user asks to change or debug the agent — never as a setup step. The user creates
+`AI_GATEWAY_API_KEY` (Vercel → AI Gateway → API Keys) and writes it with
+`npx oe env set AI_GATEWAY_API_KEY`, then `npm run dev`. A local run keeps its state in an embedded database under
 `.open-everywhere-data/`, and Slack cannot reach it without a public tunnel.
 
 ## Notes
@@ -161,7 +193,12 @@ then `npm run dev`. A local run keeps its state in an embedded database under
 - The deployment's own identity (`deploymentIdentity`) is code in `agent/identity/surfaces.ts`, not
   env.
 - `@open-everywhere/create` has no interactive wizard and sends no telemetry. It scaffolds
-  (`npx @open-everywhere/create <dir>`) and reports status (`--check`). Nothing else.
-- 🔴 **`--check` reads `.env.local` and your shell, never the deployment's own environment.** A
-  "9/9 satisfied" is not proof that the deployment holds the credential key or the Slack secrets:
-  step 9 is the only thing that puts them there, and nothing can observe it from here.
+  (`npx @open-everywhere/create <dir>`) and reports status (`--check`). Nothing else. The deployed
+  app is a different matter: its telemetry is on by default (see the telemetry section above).
+- 🔴 **Without `--host`, `--check` reads `.env.local` and your shell, never the deployment's own
+  environment.** With `--host`, the env step also reads the deployment's status route, which reports
+  `DATABASE_URL` and the credential key (its `secrets` row), the store selection and the model route.
+  The env step does not judge the Slack secrets, so even a "9/9 satisfied" is not proof that the
+  deployment holds `SLACK_BOT_TOKEN` and `SLACK_SIGNING_SECRET`. The same status document's
+  `surfaces.slack.credentials` reports whether both are present: read it with
+  `curl -s https://<host>/eve/v1/oe/status`. Slack's **Verified** is what proves the signing secret.

package/template/claude/skills/upgrade-open-everywhere/SKILL.md

@@ -66,7 +66,8 @@ Those are decisions, not steps.
 
 `--plan` also prints a **template drift** report. It compares every file the scaffold copied into
 this app with the TARGET release's `@open-everywhere/create` template, and lists each one that
-differs, with a one-line size of its diff. An upgrade changes only `package.json`, so a scaffolded
+differs, with a one-line size of its diff. An upgrade changes only `package.json` and
+`package-lock.json`, so a scaffolded
 file stays as the old template wrote it. A stale copy can typecheck and build and still break the
 deployment: the 0.1.2 `agent/lib/register-adapters.ts` registers no Postgres client on a bare
 `DATABASE_URL`, so a Vercel+Neon deployment of 0.1.4 fails at its first write.
@@ -82,6 +83,14 @@ the adapters by hand to the one-call copy: move any adapter the user registered
 | --- | --- |
 | SYNC | a template-owned file — wiring, a script, `AGENTS.md`, `README.md`, `.env.example`, a skill. Plan to copy the target's file over this one, after you read the diff. |
 | config | the app's own config-as-code. A difference is normal once the app is configured. Merge the template's change by hand only if the user wants it. |
+| DELETE | a release up to the target removed this file from the template, and the app still has it. Plan to delete it. eve 0.69 and later refuse `agent/instrumentation.ts` at build. |
+| app-owned | `.oe-template-ignore` names the file, so the app owns it. Nothing to do. |
+
+`.oe-template-ignore` at the app root lists the template files the app removed or owns on purpose:
+one app-relative path per line, a trailing `/` for a directory, `#` for a comment. The report prints
+nothing for an ignored file the app does not have, and one `app-owned` line for one it has. Add a
+path only when the user says the app owns that file. Never add one to silence a SYNC line you have
+not read.
 
 The report never writes a file. If it says the drift check did not run, compare the files with the
 target's template by hand. An installed core without the report prints none: `oe upgrade` runs the
@@ -99,7 +108,11 @@ In order, and it stops at the first step that fails:
 1. bump every `@open-everywhere/*` package to the target, renaming a dependency on the retired
    unscoped `create-open-everywhere` to `@open-everywhere/create` as it goes;
 2. pin `eve` to the version the target core declares as its peer;
-3. `npm install` — its `postinstall` runs `oe-eve-patch`, which the app refuses to boot without;
+3. `npm install` — its `postinstall` runs `oe-eve-patch`, which the app refuses to boot without.
+   Before it, the run drops the `package-lock.json` entries of `eve`, of every
+   `@open-everywhere/*` package and of every package that peers on one of them, so npm resolves
+   that set again. If the install still stops with ERESOLVE (a core at 0.2.1 or earlier does not
+   drop them), run `rm package-lock.json && npm install`, then run `oe upgrade` again;
 4. run the config codemods the target's notes name, and print the migrations that are yours;
 5. `oe build --accept` — this rewrites `roster.lock.json`;
 6. `npm run typecheck`;
@@ -136,7 +149,7 @@ codemod. Do not delete the marker to get past this refusal.
 
 ```
 git diff roster.lock.json
-git diff package.json
+git diff package.json package-lock.json
 git status
 ```
 
@@ -149,7 +162,8 @@ Then run the app's own checks once more if anything above was fixed by hand:
 
 Then act on the template drift report. A core that carries it prints it again after the install;
 if this run printed no "Template drift" heading, run `npx oe upgrade --to <target> --plan` now to get it. For
-each SYNC line, read the diff against the installed template, for example
+each DELETE line, delete the file. If the user says the app owns it, keep it and name it in
+`.oe-template-ignore`. For each SYNC line, read the diff against the installed template, for example
 `diff node_modules/@open-everywhere/create/template/agent/lib/register-adapters.ts agent/lib/register-adapters.ts`.
 Keep any edit the user made on purpose, and copy the template's file otherwise. For
 `agent/lib/register-adapters.ts`, the user's edits belong in the `customAdapters` hook of the
@@ -171,7 +185,7 @@ Commit on a branch, never on the default branch. The body carries:
 - what changed in `roster.lock.json`, in your own words;
 - **the env names the deployment needs before this merges**, names only;
 - the manual steps, and who does each one.
-- the template files you synced, and each SYNC line you left as it is, with the reason.
+- the template files you synced or deleted, and each SYNC or DELETE line you left as it is, with the reason.
 
 Then stop. The admin reviews the lock diff and merges. The merge deploys.
 
@@ -179,21 +193,23 @@ Then stop. The admin reviews the lock diff and merges. The merge deploys.
 
 A green build is not a working deployment.
 
-**The status endpoint is not built yet.** OPE-2230 adds one: an unauthenticated, non-sensitive
-JSON route that reports the deployment's version, whether the database is reachable and which
-provider it uses, the sandbox backend, whether egress is enforced, whether the model route
-answers, and the Slack posture. That ticket proposes `GET /eve/v1/oe/status`. Do not assume the
-route exists, and never read some other route as if it were this one. Check the deployment's own
-routes first; when the endpoint is there, read it and report each field, in this order:
+**Read the status route, `GET /eve/v1/oe/status`.** It ships from core 0.1.4. It is an
+unauthenticated, non-sensitive JSON route that reports the deployment's version, whether the
+database is reachable, the sandbox backend, whether egress is enforced, whether the model route
+answers, and the Slack posture. A deployment can hide it on purpose, with a roster exclusion or an
+edge rule (`docs/deploy/contract.md` § Hiding the status route). A 404 or a 403 there can be that
+choice, not a fault: ask the operator before you call it broken. Never read some other route as if
+it were this one. When the route answers, report each field, in this order:
 
 1. **version** — it reads the target. If it still reads the old version, the deploy has not
    finished, or it failed. Nothing below is meaningful until this matches.
-2. **database reachable**, and the provider it names.
+2. **database reachable** (the `postgres` verdict).
 3. **sandbox backend**, and **egress enforced**.
 4. **model route answers.**
 5. **Slack** — credentials present, workspace installed, events verified.
 
-**Until that endpoint ships**, confirm what you can and say plainly what you could not:
+**When the route does not answer**, on a core older than 0.1.4 or on a deployment that hides it,
+confirm what you can and say plainly what you could not:
 
 - the deploy finished, from the host's own deployment log;
 - `npx @open-everywhere/create --check --json --host https://<host>` — its `build-deploy` step

package/template/scripts/goldens/roster-plan.txt

@@ -0,0 +1,156 @@
+agent/channels/aws-sso-callback.ts	mounted @open-everywhere/core
+agent/channels/control-mcp.ts	mounted @open-everywhere/core
+agent/channels/control-read.ts	mounted @open-everywhere/core
+agent/channels/credential-intake-page.ts	mounted @open-everywhere/core
+agent/channels/github.ts	mounted @open-everywhere/provider-github
+agent/channels/notion.ts	mounted @open-everywhere/provider-notion
+agent/channels/oe-oauth-callback.ts	mounted @open-everywhere/core
+agent/channels/oe-status.ts	mounted @open-everywhere/core
+agent/channels/policy-pages.ts	mounted @open-everywhere/core
+agent/channels/slack-commands.ts	mounted @open-everywhere/provider-slack
+agent/channels/slack-setup-page.ts	mounted @open-everywhere/provider-slack
+agent/channels/slack.ts	mounted @open-everywhere/provider-slack
+agent/channels/test-wake.ts	mounted @open-everywhere/core
+agent/channels/transcript-relay.ts	mounted @open-everywhere/core
+agent/channels/unified.ts	mounted @open-everywhere/core
+agent/channels/webhook-reveal-page.ts	mounted @open-everywhere/core
+agent/channels/webhooks.ts	mounted @open-everywhere/core
+agent/connections/notion.ts	mounted @open-everywhere/core
+agent/hooks/approval-raised.ts	mounted @open-everywhere/core
+agent/hooks/approval-settlement.ts	mounted @open-everywhere/core
+agent/hooks/binding-bridge.ts	mounted @open-everywhere/core
+agent/hooks/connector-audit.ts	mounted @open-everywhere/core
+agent/hooks/egress.ts	mounted @open-everywhere/core
+agent/hooks/eve-patch-gate.ts	mounted @open-everywhere/core
+agent/hooks/fire-carriage.ts	mounted @open-everywhere/core
+agent/hooks/fire-toolset.ts	mounted @open-everywhere/core
+agent/hooks/held-question.ts	mounted @open-everywhere/core
+agent/hooks/job-posture.ts	mounted @open-everywhere/core
+agent/hooks/lean-seat.ts	mounted @open-everywhere/core
+agent/hooks/learn.ts	mounted @open-everywhere/core
+agent/hooks/link-claim.ts	mounted @open-everywhere/core
+agent/hooks/log-flush.ts	mounted @open-everywhere/core
+agent/hooks/loop-breaker.ts	mounted @open-everywhere/core
+agent/hooks/memory.ts	mounted @open-everywhere/core
+agent/hooks/native-input-audit.ts	mounted @open-everywhere/core
+agent/hooks/own-account-ask.ts	mounted @open-everywhere/core
+agent/hooks/requester-identity.ts	mounted @open-everywhere/core
+agent/hooks/requester-messages.ts	mounted @open-everywhere/core
+agent/hooks/routine-outcome.ts	mounted @open-everywhere/core
+agent/hooks/routine-silence.ts	mounted @open-everywhere/core
+agent/hooks/sandbox-lifecycle.ts	mounted @open-everywhere/adapters
+agent/hooks/session-park.ts	mounted @open-everywhere/core
+agent/hooks/spawn-taint.ts	mounted @open-everywhere/core
+agent/hooks/spend.ts	mounted @open-everywhere/core
+agent/hooks/stall-guard.ts	mounted @open-everywhere/core
+agent/hooks/telemetry.ts	mounted @open-everywhere/core
+agent/hooks/turn-anchor.ts	mounted @open-everywhere/core
+agent/hooks/wake-accounting-turn.ts	mounted @open-everywhere/core
+agent/hooks/wake-turn-start.ts	mounted @open-everywhere/core
+agent/hooks/window-routing.ts	mounted @open-everywhere/core
+agent/lib/providers.generated.ts	providers slack,notion,github
+agent/schedules/directory-sync.ts	mounted @open-everywhere/core
+agent/schedules/dispatch.ts	mounted @open-everywhere/core
+agent/schedules/dream-mode3.ts	mounted @open-everywhere/core
+agent/schedules/notion-ingress.ts	mounted @open-everywhere/provider-notion
+agent/schedules/tidy.ts	mounted @open-everywhere/core
+agent/skills/scoped.ts	mounted @open-everywhere/core
+agent/tools/add_label.ts	mounted @open-everywhere/core
+agent/tools/add_routine_rule.ts	mounted @open-everywhere/core
+agent/tools/agent_version.ts	mounted @open-everywhere/core
+agent/tools/ask_question.ts	mounted @open-everywhere/core
+agent/tools/ask_room.ts	mounted @open-everywhere/core
+agent/tools/assign.ts	mounted @open-everywhere/core
+agent/tools/aws.ts	mounted @open-everywhere/core
+agent/tools/bash.ts	framework-disabled
+agent/tools/browser_tools.ts	mounted @open-everywhere/core
+agent/tools/cancel_routine.ts	mounted @open-everywhere/core
+agent/tools/cancel_work.ts	mounted @open-everywhere/core
+agent/tools/capture_events.ts	mounted @open-everywhere/core
+agent/tools/check_pr_status.ts	mounted @open-everywhere/core
+agent/tools/checkout_repo.ts	mounted @open-everywhere/core
+agent/tools/clear_connector_override.ts	mounted @open-everywhere/core
+agent/tools/clear_spend_limit.ts	mounted @open-everywhere/core
+agent/tools/complete_job.ts	mounted @open-everywhere/core
+agent/tools/complete_thread.ts	mounted @open-everywhere/core
+agent/tools/confirm_link.ts	mounted @open-everywhere/core
+agent/tools/connector.ts	mounted @open-everywhere/core
+agent/tools/create_agent.ts	mounted @open-everywhere/core
+agent/tools/create_routine.ts	mounted @open-everywhere/core
+agent/tools/create_skill.ts	mounted @open-everywhere/core
+agent/tools/create_ticket.ts	mounted @open-everywhere/core
+agent/tools/declare_webhook.ts	mounted @open-everywhere/core
+agent/tools/delete_skill.ts	mounted @open-everywhere/core
+agent/tools/describe_image.ts	mounted @open-everywhere/core
+agent/tools/dm_person.ts	mounted @open-everywhere/core
+agent/tools/edit_reply.ts	mounted @open-everywhere/core
+agent/tools/edit_routine.ts	mounted @open-everywhere/core
+agent/tools/enable_routine.ts	mounted @open-everywhere/core
+agent/tools/explain_permission.ts	mounted @open-everywhere/core
+agent/tools/extend_workspace_time.ts	mounted @open-everywhere/adapters
+agent/tools/get_pr_feedback.ts	mounted @open-everywhere/core
+agent/tools/grant_tools.ts	mounted @open-everywhere/core
+agent/tools/halt.ts	mounted @open-everywhere/core
+agent/tools/link_identity.ts	mounted @open-everywhere/core
+agent/tools/list_recent_events.ts	mounted @open-everywhere/core
+agent/tools/list_repos.ts	mounted @open-everywhere/core
+agent/tools/list_routines.ts	mounted @open-everywhere/core
+agent/tools/list_skills.ts	mounted @open-everywhere/core
+agent/tools/list_webhooks.ts	mounted @open-everywhere/core
+agent/tools/memory_admin_list.ts	mounted @open-everywhere/core
+agent/tools/memory_admin_read.ts	mounted @open-everywhere/core
+agent/tools/message_thread_seat.ts	mounted @open-everywhere/core
+agent/tools/no_reply.ts	mounted @open-everywhere/core
+agent/tools/notion_search.ts	mounted @open-everywhere/provider-notion
+agent/tools/open_pull_request.ts	mounted @open-everywhere/core
+agent/tools/permission_fit_report.ts	mounted @open-everywhere/core
+agent/tools/post_file.ts	mounted @open-everywhere/core
+agent/tools/post_message.ts	mounted @open-everywhere/core
+agent/tools/post_pr_walkthrough.ts	mounted @open-everywhere/core
+agent/tools/purge_memory.ts	mounted @open-everywhere/core
+agent/tools/query_analytics.ts	mounted @open-everywhere/core
+agent/tools/react.ts	mounted @open-everywhere/core
+agent/tools/read_channel.ts	mounted @open-everywhere/core
+agent/tools/read_docs.ts	mounted @open-everywhere/core
+agent/tools/read_file_upload.ts	mounted @open-everywhere/core
+agent/tools/read_file.ts	framework-disabled
+agent/tools/read_github_issue.ts	mounted @open-everywhere/core
+agent/tools/read_notion_comments.ts	mounted @open-everywhere/provider-notion
+agent/tools/read_notion_page.ts	mounted @open-everywhere/provider-notion
+agent/tools/read_routine_transcript.ts	mounted @open-everywhere/core
+agent/tools/read_thread_seat.ts	mounted @open-everywhere/core
+agent/tools/read_thread.ts	mounted @open-everywhere/core
+agent/tools/read_webhook_history.ts	mounted @open-everywhere/core
+agent/tools/read_work_channel.ts	mounted @open-everywhere/core
+agent/tools/read_work_thread.ts	mounted @open-everywhere/core
+agent/tools/record_follow_up.ts	mounted @open-everywhere/core
+agent/tools/record_job_state.ts	mounted @open-everywhere/core
+agent/tools/record_watch_state.ts	mounted @open-everywhere/core
+agent/tools/remove_routine_rule.ts	mounted @open-everywhere/core
+agent/tools/reply.ts	mounted @open-everywhere/core
+agent/tools/report_run_failed.ts	mounted @open-everywhere/core
+agent/tools/request_access.ts	mounted @open-everywhere/core
+agent/tools/request_credential_grant.ts	mounted @open-everywhere/core
+agent/tools/resume.ts	mounted @open-everywhere/core
+agent/tools/revoke_connector.ts	mounted @open-everywhere/core
+agent/tools/revoke_credential_grant.ts	mounted @open-everywhere/core
+agent/tools/revoke_routine_permissions.ts	mounted @open-everywhere/core
+agent/tools/rotate_webhook.ts	mounted @open-everywhere/core
+agent/tools/run_routine_now.ts	mounted @open-everywhere/core
+agent/tools/sandbox_tools.ts	mounted @open-everywhere/core
+agent/tools/search.ts	mounted @open-everywhere/core
+agent/tools/session_cost.ts	mounted @open-everywhere/core
+agent/tools/set_dm_delivery.ts	mounted @open-everywhere/core
+agent/tools/set_spend_limit.ts	mounted @open-everywhere/core
+agent/tools/set_state.ts	mounted @open-everywhere/core
+agent/tools/spawn_thread_session.ts	mounted @open-everywhere/core
+agent/tools/spend_report.ts	mounted @open-everywhere/core
+agent/tools/stand_down.ts	mounted @open-everywhere/core
+agent/tools/subscribe_pr.ts	mounted @open-everywhere/core
+agent/tools/unlink_identity.ts	mounted @open-everywhere/core
+agent/tools/update_status.ts	mounted @open-everywhere/core
+agent/tools/usage_report.ts	mounted @open-everywhere/core
+agent/tools/walk_pr.ts	mounted @open-everywhere/core
+agent/tools/web_fetch.ts	framework-disabled
+agent/tools/work.ts	mounted @open-everywhere/core
+agent/tools/write_file.ts	framework-disabled