@codacy/verity-cli 0.31.1-experimental.83a8619 → 0.31.1-experimental.b9b3862

package/CHANGELOG.md

@@ -5,6 +5,50 @@ All notable changes to Verity are documented here. This project follows
 
 ## [Unreleased]
 
+### 🤝 Joining a project that already has a Standard
+
+- **`verity init` now offers the Standard the service already holds** for this
+  repository, instead of asking a model to invent a second one. Everyone after the
+  first person on a project — a teammate cloning the repo, the same person on
+  another machine, a CI box — gets the team's actual configuration
+  (`standard.yaml`, the analysis config, `.verityignore`, `VERITY.md`) written
+  straight to disk, and the model phase is skipped entirely.
+- **This is a correctness fix as much as a speed one.** `verity standard push`
+  auto-versions, so a re-synthesis does not produce a private copy — it produces
+  v4, and v4 is what the team is held to from then on.
+- **Nothing about it can block a setup.** No token, offline, a 404, a service that
+  errors: every one of those falls through to the regular flow. An unreliable
+  answer is never reported as "no Standard stored" — that would offer a fresh
+  synthesis over one the team already agreed.
+- Unattended runs (`--yes`, CI) adopt without asking, for the same reason: a CI
+  box quietly authoring a new version of the team's Standard is not an outcome
+  anyone would choose on purpose.
+- **`--no-adopt` opts out**, for a script that wants a fresh synthesis on purpose.
+  It skips the request as well as the write: asking a question whose answer is
+  discarded is a network call the user declined, and in a locked-down CI it is one
+  that can fail loudly for no reason.
+- **Declining is remembered per VERSION, never as a mute.** Say no and init stops
+  asking about *that* Standard — and offers the next one, because a new version is
+  new information. A boolean "never again" would have been the familiar
+  silent-forever failure: decline on Monday meaning to synthesize later, forget,
+  and every later run stays quiet while the project has no local config at all.
+
+### 🔧 Fixed
+
+- **An upgrade no longer removes the gates you chose.** `.verity/setup.json` only
+  exists from this release, so every project configured before it had no recorded
+  answer — including everyone who picked commit/push gates through the old
+  `/verity-setup`. The first upgraded `verity init` fell back to the shipped
+  default and reconciled those gates away, turning Stop back on. What you chose is
+  still legible in `.claude/settings.json`, so init reads it.
+- `verity doctor` names the artifact that is actually missing instead of telling
+  you to run a phase that will decline: with a Standard adopted and no analysis
+  config, `/verity-setup` would have answered "already configured".
+- The setup skill learned the same case — Standard present, analysis config
+  missing — and writes only the config rather than re-synthesizing the Standard.
+
+## [Unreleased]
+
 **Setup is one command.** `verity init` and `/verity-setup` were two half-flows
 that overlapped — and the overlap was not harmless: init wired the Stop hook,
 then the skill reconciled the hooks to a selection it asked for afterwards,

package/README.md

@@ -12,8 +12,29 @@ verity init
 
 `verity init` is the whole setup. It asks how deeply to review and when
 (on stop / before commit / before push), wires everything, offers the optional
-GitHub login — then launches Claude Code to finish the half that needs a model:
-reading your codebase and synthesizing the Standard (`/verity-setup`).
+GitHub login — then either **adopts the Standard your team already has**, or
+launches Claude Code to synthesize one from your codebase (`/verity-setup`).
+
+### Joining a project that already uses Verity
+
+A Standard belongs to the project, not to your machine. So once you are signed in,
+init asks the service whether this repository already has one:
+
+```
+This repository already has a Standard on Verity: version 3, pushed by claude-code
+on 2026-08-12 · with analysis config and .verityignore
+Use the existing Standard? [Y/n]
+```
+
+Say yes and it writes `.verity/standard.yaml`, `.codacy/codacy.config.json`,
+`.verityignore` and `VERITY.md` straight from the service — no model phase, and no
+second version of your team's Standard (`verity standard push` auto-versions, so a
+fresh synthesis would become the version everyone is held to). Say no and it stops asking about
+that version — and offers the next one, since a new version is new information.
+With no Standard stored yet, the regular flow runs.
+`--no-adopt` opts out of the whole check, including the request. Offline, signed out, or a service
+that cannot answer: also the regular flow — setup has never needed the network and
+still doesn't.
 
 If Claude Code isn't on your PATH, or you're already inside a session, init prints
 the one command to run instead. `verity setup` is an alias for the same command.
@@ -22,6 +43,7 @@ the one command to run instead. `verity setup` is an alias for the same command.
 |------|-----|
 | `--yes` | Take the recommended answer for every question — no prompts at all (CI, scripts, agents). Includes the GitHub login, whose unattended answer is **skip**: the project stays local-only until you run `verity login`. |
 | `--no-setup` | Stop after the deterministic phase; don't launch Claude Code |
+| `--no-adopt` | Don't offer the Standard the service already holds for this repo — synthesize a fresh one. Skips the request entirely |
 | `--force` | Overwrite the installed skills even when they differ |
 
 Run `verity doctor` any time to see prerequisites, which phase is done, the hook

package/bin/verity.js

@@ -675,8 +675,8 @@ var require_option = __commonJS({
        * @param {(string | string[])} names
        * @return {Option}
        */
-      conflicts(names) {
-        this.conflictsWith = this.conflictsWith.concat(names);
+      conflicts(names2) {
+        this.conflictsWith = this.conflictsWith.concat(names2);
         return this;
       }
       /**
@@ -1249,8 +1249,8 @@ var require_command = __commonJS({
        * @param {string} names
        * @return {Command} `this` command for chaining
        */
-      arguments(names) {
-        names.trim().split(/ +/).forEach((detail) => {
+      arguments(names2) {
+        names2.trim().split(/ +/).forEach((detail) => {
           this.argument(detail);
         });
         return this;
@@ -19364,7 +19364,7 @@ function channelSilence(input) {
 // src/lib/cli-version.ts
 function cliVersion() {
   try {
-    return true ? "0.31.1-experimental.83a8619" : "dev";
+    return true ? "0.31.1-experimental.b9b3862" : "dev";
   } catch {
     return "dev";
   }
@@ -23288,9 +23288,9 @@ function registerWaiveCommand(program2) {
 }
 
 // src/commands/init.ts
-var import_node_fs44 = require("node:fs");
-var import_promises14 = require("node:fs/promises");
-var import_node_path29 = require("node:path");
+var import_node_fs45 = require("node:fs");
+var import_promises15 = require("node:fs/promises");
+var import_node_path30 = require("node:path");
 var import_node_child_process14 = require("node:child_process");
 
 // src/lib/banner.ts
@@ -23701,8 +23701,19 @@ async function buildReport() {
     if (c.status !== "ok" && c.remedy) next.push(c.remedy);
   }
   if (!state?.init) next.push('Run "verity init" \u2014 the deterministic setup phase has not completed here.');
-  if (!artifacts.standard || !artifacts.analysisConfig || !artifacts.verityMd) {
-    next.push("Run /verity-setup in Claude Code \u2014 the Standard, analysis config, and VERITY.md are synthesized there.");
+  const missing = [
+    !artifacts.standard && ".verity/standard.yaml",
+    !artifacts.analysisConfig && ".codacy/codacy.config.json",
+    !artifacts.verityMd && "VERITY.md"
+  ].filter((x) => !!x);
+  if (missing.length === 3) {
+    next.push("Run /verity-setup in Claude Code \u2014 it synthesizes the Standard, the analysis config, and VERITY.md.");
+  } else if (missing.length === 1 && !artifacts.analysisConfig) {
+    next.push(
+      'No analysis config, so static analysis runs nothing. Run /verity-setup in Claude Code to write one (it keeps the Standard you already have), or have a teammate run "verity config push".'
+    );
+  } else if (missing.length > 0) {
+    next.push(`Missing ${missing.join(" and ")}. Run "/verity-setup --force" in Claude Code to regenerate.`);
   }
   const noAnalysisMoment = !hooks.stop && hooks.guardOn.length === 0;
   if (noAnalysisMoment) {
@@ -24152,6 +24163,146 @@ async function promptMultiSelect(question, choices, fallback) {
   return parsed.ids;
 }
 
+// src/lib/remote-config.ts
+var import_node_fs44 = require("node:fs");
+var import_promises14 = require("node:fs/promises");
+var import_node_path29 = require("node:path");
+var import_yaml3 = __toESM(require_dist());
+var IGNORE_RIDER = "verityignore";
+async function fetchRemoteSetup(opts) {
+  const standard = await apiRequest({
+    method: "GET",
+    path: "/standards/latest",
+    serviceUrl: opts.serviceUrl,
+    token: opts.token,
+    verbose: opts.verbose
+  });
+  if (!standard.ok) {
+    const missing = /STANDARD_NOT_FOUND|not found|404/i.test(standard.error);
+    return missing ? { status: "none" } : { status: "unavailable", reason: standard.error };
+  }
+  const config = await apiRequest({
+    method: "GET",
+    path: "/analysis-configs",
+    serviceUrl: opts.serviceUrl,
+    token: opts.token,
+    verbose: opts.verbose
+  });
+  return {
+    status: "found",
+    standard: {
+      version: standard.data.version,
+      content: standard.data.content ?? {},
+      createdBy: standard.data.created_by,
+      createdAt: standard.data.created_at
+    },
+    // Absent is normal and not an error: the two are stored independently, and a
+    // project can have a Standard with no analysis config.
+    analysisConfig: config.ok ? config.data.content ?? null : null
+  };
+}
+async function adoptRemoteSetup(found, opts) {
+  const written = [];
+  const notes = [];
+  const content = { ...found.standard.content };
+  const rider = typeof content[IGNORE_RIDER] === "string" ? content[IGNORE_RIDER] : null;
+  delete content[IGNORE_RIDER];
+  await writeOut(STANDARD_FILE, (0, import_yaml3.stringify)(content));
+  written.push(STANDARD_FILE);
+  if (rider !== null) {
+    const localIgnore = projectPath(VERITYIGNORE_FILE);
+    if (!(0, import_node_fs44.existsSync)(localIgnore)) {
+      await writeOut(VERITYIGNORE_FILE, rider);
+      written.push(VERITYIGNORE_FILE);
+    } else {
+      const local = await (0, import_promises14.readFile)(localIgnore, "utf-8").catch(() => null);
+      if (local !== null && local !== rider) {
+        notes.push(`${VERITYIGNORE_FILE} already exists here and differs from the pushed copy \u2014 kept yours.`);
+      }
+    }
+  }
+  if (found.analysisConfig) {
+    await writeOut(CODACY_CONFIG_FILE, JSON.stringify(found.analysisConfig, null, 2) + "\n");
+    written.push(CODACY_CONFIG_FILE);
+  } else {
+    notes.push(
+      "No analysis config is stored for this repository, so static analysis has nothing to run. Run /verity-setup in Claude Code to generate one."
+    );
+  }
+  await writeOut(VERITY_MD_FILE, renderVerityMd(found.standard, opts));
+  written.push(VERITY_MD_FILE);
+  return { written, notes };
+}
+async function writeOut(relative, body) {
+  const target = projectPath(relative);
+  await (0, import_promises14.mkdir)((0, import_node_path29.dirname)(target), { recursive: true });
+  await (0, import_promises14.writeFile)(target, body);
+}
+function names(content, key) {
+  const raw = content[key];
+  if (!Array.isArray(raw)) return [];
+  return raw.map((entry) => {
+    if (typeof entry === "string") return entry;
+    if (entry && typeof entry === "object") {
+      const rec = entry;
+      const label2 = rec.name ?? rec.id ?? rec.dimension ?? rec.pattern;
+      return typeof label2 === "string" ? label2 : null;
+    }
+    return null;
+  }).filter((x) => !!x);
+}
+function renderVerityMd(standard, opts) {
+  const dimensions = names(standard.content, "quality_dimensions");
+  const patterns = names(standard.content, "security_patterns");
+  const custom = names(standard.content, "custom_patterns");
+  const list2 = (items, fallback) => (items.length > 0 ? items : fallback).map((i) => `- ${i}`).join("\n");
+  return `# VERITY.md \u2014 Quality Gate
+
+> This project uses [Verity](https://verity.md) to enforce quality and security standards on AI-generated code.
+
+**URL:** ${opts.serviceUrl}
+**Project:** ${opts.projectId ?? "this repository"}
+**Standard:** v${standard.version} (adopted from the service${standard.createdBy ? `, created by ${standard.createdBy}` : ""})
+
+## Quality Dimensions
+${list2(dimensions, ["comprehensibility", "modularity", "type_safety", "test_adequacy"])}
+
+## Security Patterns
+${list2(patterns, [
+    "No hardcoded secrets (CWE-798)",
+    "Input sanitization (CWE-20)",
+    "Parameterized queries (CWE-89)",
+    "Dependency verification (CWE-1395)",
+    "No unsafe deserialization (CWE-502)",
+    "Access control checks (CWE-639)",
+    "Config file integrity (CWE-15)"
+  ])}
+${custom.length > 0 ? `
+## Project Patterns
+${list2(custom, [])}
+` : ""}
+## How It Works
+Every time the coding agent stops, the Verity hook:
+1. Runs static analysis via @codacy/analysis-cli
+2. Sends results + code to the Verity service
+3. An independent model reviews the code
+4. Returns PASS / WARN / FAIL with actionable findings
+
+_This Standard came from the service \u2014 the team's shared version. To change it,
+edit \`.verity/standard.yaml\` and run \`verity standard push\`, or re-synthesize
+from the codebase with \`/verity-setup --force\`._
+`;
+}
+function describeRemote(found) {
+  const when = found.standard.createdAt.slice(0, 10);
+  const who = found.standard.createdBy ? ` by ${found.standard.createdBy}` : "";
+  const extras = [];
+  if (found.analysisConfig) extras.push("analysis config");
+  if (typeof found.standard.content[IGNORE_RIDER] === "string") extras.push(".verityignore");
+  const also = extras.length > 0 ? ` \xB7 with ${extras.join(" and ")}` : "";
+  return `version ${found.standard.version}, pushed${who} on ${when}${also}`;
+}
+
 // src/commands/init.ts
 async function confirmExistingLogin(serviceUrl, remote, opts) {
   const existing = await resolveToken(opts.token);
@@ -24256,15 +24407,15 @@ async function runOptionalAuth(resolution, opts = {}) {
 }
 function resolveDataDir() {
   const candidates = [
-    (0, import_node_path29.join)(__dirname, "..", "data"),
+    (0, import_node_path30.join)(__dirname, "..", "data"),
     // installed: node_modules/@codacy/verity-cli/data
-    (0, import_node_path29.join)(__dirname, "..", "..", "data"),
+    (0, import_node_path30.join)(__dirname, "..", "..", "data"),
     // edge case: nested resolution
-    (0, import_node_path29.join)(process.cwd(), "cli", "data")
+    (0, import_node_path30.join)(process.cwd(), "cli", "data")
     // local dev: running from repo root
   ];
   for (const candidate of candidates) {
-    if ((0, import_node_fs44.existsSync)((0, import_node_path29.join)(candidate, "skills"))) {
+    if ((0, import_node_fs45.existsSync)((0, import_node_path30.join)(candidate, "skills"))) {
       return candidate;
     }
   }
@@ -24273,16 +24424,16 @@ function resolveDataDir() {
   );
 }
 async function copyDir(src, dest) {
-  await (0, import_promises14.mkdir)(dest, { recursive: true });
-  await (0, import_promises14.cp)(src, dest, { recursive: true, force: true });
+  await (0, import_promises15.mkdir)(dest, { recursive: true });
+  await (0, import_promises15.cp)(src, dest, { recursive: true, force: true });
 }
 async function skillIsCurrent(src, dest) {
   const list2 = (dir) => {
     const out = [];
     const walk = (d, prefix) => {
-      for (const e of (0, import_node_fs44.readdirSync)(d, { withFileTypes: true })) {
+      for (const e of (0, import_node_fs45.readdirSync)(d, { withFileTypes: true })) {
         const rel = prefix ? `${prefix}/${e.name}` : e.name;
-        if (e.isDirectory()) walk((0, import_node_path29.join)(d, e.name), rel);
+        if (e.isDirectory()) walk((0, import_node_path30.join)(d, e.name), rel);
         else if (e.isFile()) out.push(rel);
       }
     };
@@ -24293,8 +24444,8 @@ async function skillIsCurrent(src, dest) {
     const shipped = list2(src);
     if (JSON.stringify(shipped) !== JSON.stringify(list2(dest))) return false;
     for (const rel of shipped) {
-      const a = await (0, import_promises14.readFile)((0, import_node_path29.join)(src, rel), "utf-8");
-      const b = await (0, import_promises14.readFile)((0, import_node_path29.join)(dest, rel), "utf-8");
+      const a = await (0, import_promises15.readFile)((0, import_node_path30.join)(src, rel), "utf-8");
+      const b = await (0, import_promises15.readFile)((0, import_node_path30.join)(dest, rel), "utf-8");
       if (a !== b) return false;
     }
     return true;
@@ -24323,9 +24474,17 @@ var MOMENT_CHOICES = [
   { id: "pre-push", label: "Before push / PR", hint: "reviews the to-be-pushed commits, blocks on FAIL" }
 ];
 var DEFAULT_MOMENTS = ["stop"];
+async function momentsFromInstalledHooks() {
+  const status = await checkAllVerityHooks();
+  const wired = [];
+  if (status.stop) wired.push("stop");
+  if (status.guardOn.includes("commit")) wired.push("pre-commit");
+  if (status.guardOn.includes("push")) wired.push("pre-push");
+  return wired.length > 0 ? wired : DEFAULT_MOMENTS;
+}
 async function askSetupQuestions(defaultsOnly, previous) {
   const intensityDefault = previous?.intensity ?? "balanced";
-  const momentsDefault = previous?.moments?.length ? previous.moments : DEFAULT_MOMENTS;
+  const momentsDefault = previous?.moments?.length ? previous.moments : await momentsFromInstalledHooks();
   if (defaultsOnly) {
     return { intensity: intensityDefault, moments: momentsDefault, telemetry: "not-asked" };
   }
@@ -24362,6 +24521,73 @@ function insideClaudeCode() {
 function resumeDeferredPending(previous) {
   return previous?.telemetry === "deferred";
 }
+async function maybeAdoptRemoteSetup(opts) {
+  if (!opts.adopt) {
+    printInfo("  Skipped (--no-adopt) \u2014 the setup below runs from this codebase.");
+    return false;
+  }
+  const token = await resolveToken(opts.globals.token);
+  const url = await resolveServiceUrl(opts.globals.serviceUrl);
+  if (!token.ok || !url.ok) {
+    printInfo("  Not signed in, so there is nothing to fetch \u2014 the setup below runs from your codebase.");
+    return false;
+  }
+  const found = await fetchRemoteSetup({
+    token: token.data.token,
+    serviceUrl: url.data,
+    verbose: opts.globals.verbose
+  });
+  if (found.status === "unavailable") {
+    printWarn(`  Could not ask the service (${found.reason}) \u2014 continuing with the regular setup.`);
+    return false;
+  }
+  if (found.status === "none") {
+    printInfo("  No Standard stored for this repository yet \u2014 this setup will create the first one.");
+    return false;
+  }
+  if (opts.previous?.declinedStandardVersion === found.standard.version) {
+    printInfo(`  Standard v${found.standard.version} is available; you declined this version before \u2014 not asking again.`);
+    printInfo("    A newer version will be offered. To take it now: verity standard get, or /verity-setup.");
+    return false;
+  }
+  console.log("");
+  console.log(`  This repository already has a Standard on Verity: ${describeRemote(found)}`);
+  console.log("    Using it keeps you consistent with everyone else on the project.");
+  console.log("    Synthesizing a new one from this codebase would push a competing version.");
+  console.log("");
+  const use = opts.defaultsOnly ? true : await promptYes("  Use the existing Standard? [Y/n] ", { nonInteractive: true });
+  if (!use) {
+    printInfo("  Keeping the existing version untouched; /verity-setup will synthesize a new one.");
+    await writeSetupState({ declinedStandardVersion: found.standard.version }).catch(() => {
+    });
+    return false;
+  }
+  try {
+    const outcome = await adoptRemoteSetup(found, {
+      serviceUrl: url.data,
+      projectId: await projectLabel(token.data.token, url.data, opts.globals.verbose)
+    });
+    for (const path of outcome.written) printInfo(`  ${path} \u2713`);
+    for (const note of outcome.notes) printWarn(`  ${note}`);
+    if (opts.previous?.declinedStandardVersion != null) {
+      await writeSetupState({ declinedStandardVersion: void 0 }).catch(() => {
+      });
+    }
+    return true;
+  } catch (err) {
+    printWarn(`  Could not write the fetched configuration: ${err.message}`);
+    printInfo("  Falling back to the regular setup.");
+    return false;
+  }
+}
+async function projectLabel(token, serviceUrl, verbose) {
+  try {
+    const who = await whoami(token, serviceUrl, verbose);
+    return who.ok ? who.data.project_id : null;
+  } catch {
+    return null;
+  }
+}
 var PHASE_TWO_ARTIFACTS = [
   {
     path: ".verity/standard.yaml",
@@ -24438,12 +24664,13 @@ async function handoffToSetup(enabled, claudeInstalled) {
   await reportPhaseTwo(startedAt);
 }
 function registerInitCommand(program2) {
-  program2.command("init").alias("setup").description("Set up Verity in the current project (asks the setup questions, then hands off to /verity-setup)").option("--force", "Reinstall the skills even when they are already up to date (hooks are always reconciled)").option("-y, --yes", "Take the recommended answer for every question (no prompts)").option("--no-setup", "Skip the /verity-setup handoff at the end").action(async (opts) => {
+  program2.command("init").alias("setup").description("Set up Verity in the current project (asks the setup questions, then hands off to /verity-setup)").option("--force", "Reinstall the skills even when they are already up to date (hooks are always reconciled)").option("-y, --yes", "Take the recommended answer for every question (no prompts)").option("--no-setup", "Skip the /verity-setup handoff at the end").option("--no-adopt", "Don't offer this repository's existing Standard from the service; synthesize a new one").action(async (opts) => {
     const force = opts.force ?? false;
     const wantsHandoff = opts.setup !== false;
+    const wantsAdopt = opts.adopt !== false;
     const defaultsOnly = (opts.yes ?? false) || !interactive();
     const projectMarkers = [".git", "package.json", "pyproject.toml", "go.mod", "Cargo.toml", "Gemfile", "pom.xml", "build.gradle"];
-    const isProject = projectMarkers.some((m) => (0, import_node_fs44.existsSync)(m));
+    const isProject = projectMarkers.some((m) => (0, import_node_fs45.existsSync)(m));
     if (!isProject) {
       printError("No project detected in the current directory.");
       printInfo('Run "verity init" from your project root.');
@@ -24458,7 +24685,7 @@ function registerInitCommand(program2) {
     } else {
       printPhase(1, 2, "this machine", "prerequisites \xB7 skills \xB7 hooks \xB7 sign-in");
     }
-    const TOTAL_STEPS = 8;
+    const TOTAL_STEPS = 9;
     let stepNo = 0;
     const step = (label2) => {
       stepNo++;
@@ -24493,17 +24720,17 @@ function registerInitCommand(program2) {
     console.log("");
     step("Installing skills");
     const dataDir = resolveDataDir();
-    const skillsSource = (0, import_node_path29.join)(dataDir, "skills");
+    const skillsSource = (0, import_node_path30.join)(dataDir, "skills");
     const skillsDest = ".claude/skills";
     let skillsInstalled = 0;
     for (const skill of SKILLS) {
-      const src = (0, import_node_path29.join)(skillsSource, skill);
-      const dest = (0, import_node_path29.join)(skillsDest, skill);
-      if (!(0, import_node_fs44.existsSync)(src)) {
+      const src = (0, import_node_path30.join)(skillsSource, skill);
+      const dest = (0, import_node_path30.join)(skillsDest, skill);
+      if (!(0, import_node_fs45.existsSync)(src)) {
         printWarn(`  Skill data not found: ${skill}`);
         continue;
       }
-      if ((0, import_node_fs44.existsSync)(dest) && !force && await skillIsCurrent(src, dest)) {
+      if ((0, import_node_fs45.existsSync)(dest) && !force && await skillIsCurrent(src, dest)) {
         skillsInstalled++;
         continue;
       }
@@ -24519,7 +24746,7 @@ function registerInitCommand(program2) {
       printInfo(`  intensity: ${intensity} \xB7 moments: ${moments.join(", ") || "none"} (no questions asked)`);
     }
     step("Knowledge base, .gitignore and CLAUDE.md");
-    await (0, import_promises14.mkdir)(VERITY_DIR, { recursive: true });
+    await (0, import_promises15.mkdir)(VERITY_DIR, { recursive: true });
     await ensureMemoryDir();
     const ignoreResult = ensureVerityGitignore();
     if (ignoreResult === "failed") {
@@ -24553,8 +24780,8 @@ function registerInitCommand(program2) {
     } catch (err) {
       printWarn(`  Could not update CLAUDE.md: ${err.message}`);
     }
-    const globalVerityDir = (0, import_node_path29.join)(process.env.HOME ?? "", ".verity");
-    await (0, import_promises14.mkdir)(globalVerityDir, { recursive: true });
+    const globalVerityDir = (0, import_node_path30.join)(process.env.HOME ?? "", ".verity");
+    await (0, import_promises15.mkdir)(globalVerityDir, { recursive: true });
     console.log("");
     step("Wiring Claude Code hooks");
     await applyMomentSelection(moments);
@@ -24606,6 +24833,18 @@ function registerInitCommand(program2) {
         printWarn('Telemetry needs a Verity token \u2014 run "verity login", then "verity telemetry install".');
       }
     }
+    step("Checking Verity for an existing setup");
+    let adopted = false;
+    if ((0, import_node_fs45.existsSync)(projectPath(STANDARD_FILE))) {
+      printInfo("  This project already has .verity/standard.yaml \u2014 keeping it.");
+    } else {
+      adopted = await maybeAdoptRemoteSetup({
+        globals: program2.opts(),
+        defaultsOnly,
+        previous,
+        adopt: wantsAdopt
+      });
+    }
     step("Recording your answers");
     try {
       await writeSetupState({
@@ -24614,7 +24853,7 @@ function registerInitCommand(program2) {
         ...telemetryChoice ? { telemetry: telemetryChoice } : {},
         init: {
           completed_at: (/* @__PURE__ */ new Date()).toISOString(),
-          cli_version: true ? "0.31.1-experimental.83a8619" : "dev"
+          cli_version: true ? "0.31.1-experimental.b9b3862" : "dev"
         }
       });
     } catch (err) {
@@ -24632,14 +24871,20 @@ function registerInitCommand(program2) {
     console.log("    CLAUDE.md                      memory pointer, waive policy, reflection");
     console.log("");
     console.log(`  Intensity: ${intensity}    Moments: ${moments.join(", ") || "none"}`);
-    await handoffToSetup(wantsHandoff, claudeInstalled);
+    if (adopted) {
+      console.log("");
+      printInfo("Setup complete \u2014 this project uses your team's Standard.");
+      printInfo("  Re-synthesize from this codebase instead: /verity-setup --force");
+    } else {
+      await handoffToSetup(wantsHandoff, claudeInstalled);
+    }
     console.log("");
   });
 }
 
 // src/commands/uninstall.ts
-var import_node_fs45 = require("node:fs");
-var import_node_path30 = require("node:path");
+var import_node_fs46 = require("node:fs");
+var import_node_path31 = require("node:path");
 var SKILL_NAMES = [
   "verity-setup",
   "verity-analyze",
@@ -24658,11 +24903,11 @@ function registerUninstallCommand(program2) {
     const actions = [];
     const skillsRoot = projectPath(".claude/skills");
     for (const name of SKILL_NAMES) {
-      const dir = (0, import_node_path30.join)(skillsRoot, name);
-      if ((0, import_node_fs45.existsSync)(dir)) {
+      const dir = (0, import_node_path31.join)(skillsRoot, name);
+      if ((0, import_node_fs46.existsSync)(dir)) {
         actions.push({
           label: `Remove .claude/skills/${name}/`,
-          apply: () => (0, import_node_fs45.rmSync)(dir, { recursive: true, force: true })
+          apply: () => (0, import_node_fs46.rmSync)(dir, { recursive: true, force: true })
         });
       }
     }
@@ -24676,24 +24921,24 @@ function registerUninstallCommand(program2) {
       });
     }
     const verityDir = projectPath(VERITY_DIR);
-    if ((0, import_node_fs45.existsSync)(verityDir)) {
+    if ((0, import_node_fs46.existsSync)(verityDir)) {
       actions.push({
         label: `Remove ${VERITY_DIR}/`,
-        apply: () => (0, import_node_fs45.rmSync)(verityDir, { recursive: true, force: true })
+        apply: () => (0, import_node_fs46.rmSync)(verityDir, { recursive: true, force: true })
       });
     }
     if (!keepVerityMd) {
       const verityMd = projectPath(VERITY_MD_FILE);
-      if ((0, import_node_fs45.existsSync)(verityMd)) {
+      if ((0, import_node_fs46.existsSync)(verityMd)) {
         actions.push({
           label: `Remove ${VERITY_MD_FILE}`,
-          apply: () => (0, import_node_fs45.rmSync)(verityMd, { force: true })
+          apply: () => (0, import_node_fs46.rmSync)(verityMd, { force: true })
         });
       }
     }
     const cleanupEmptyDir = (path) => {
-      if ((0, import_node_fs45.existsSync)(path) && (0, import_node_fs45.statSync)(path).isDirectory() && (0, import_node_fs45.readdirSync)(path).length === 0) {
-        (0, import_node_fs45.rmdirSync)(path);
+      if ((0, import_node_fs46.existsSync)(path) && (0, import_node_fs46.statSync)(path).isDirectory() && (0, import_node_fs46.readdirSync)(path).length === 0) {
+        (0, import_node_fs46.rmdirSync)(path);
       }
     };
     actions.push({
@@ -24704,11 +24949,11 @@ function registerUninstallCommand(program2) {
       }
     });
     const home = process.env.HOME ?? "";
-    const globalVerityDir = (0, import_node_path30.join)(home, ".verity");
-    if (purgeGlobal && (0, import_node_fs45.existsSync)(globalVerityDir)) {
+    const globalVerityDir = (0, import_node_path31.join)(home, ".verity");
+    if (purgeGlobal && (0, import_node_fs46.existsSync)(globalVerityDir)) {
       actions.push({
         label: `Remove ~/.verity/ (global credentials \u2014 reconnect requires re-registration)`,
-        apply: () => (0, import_node_fs45.rmSync)(globalVerityDir, { recursive: true, force: true })
+        apply: () => (0, import_node_fs46.rmSync)(globalVerityDir, { recursive: true, force: true })
       });
     }
     if (actions.length === 0) {
@@ -24902,8 +25147,8 @@ function registerTaskCommands(program2) {
 }
 
 // src/commands/reset.ts
-var import_node_fs46 = require("node:fs");
-var import_node_path31 = require("node:path");
+var import_node_fs47 = require("node:fs");
+var import_node_path32 = require("node:path");
 function registerResetCommand(program2) {
   program2.command("reset").description("Close the current task and clear transient state").option("--keep-task", "Only purge caches; leave the current task open").option("--all", "Also purge diagnostic logs (.verity/.logs/)").action(async (opts) => {
     const globals = program2.opts();
@@ -24940,11 +25185,11 @@ function registerResetCommand(program2) {
     }
     const cacheDir = projectPath(CACHE_DIR);
     let purged = 0;
-    if ((0, import_node_fs46.existsSync)(cacheDir)) {
-      for (const entry of (0, import_node_fs46.readdirSync)(cacheDir)) {
+    if ((0, import_node_fs47.existsSync)(cacheDir)) {
+      for (const entry of (0, import_node_fs47.readdirSync)(cacheDir)) {
         if (entry.startsWith("pending-")) {
           try {
-            (0, import_node_fs46.unlinkSync)((0, import_node_path31.join)(cacheDir, entry));
+            (0, import_node_fs47.unlinkSync)((0, import_node_path32.join)(cacheDir, entry));
             purged++;
           } catch {
           }
@@ -24959,19 +25204,19 @@ function registerResetCommand(program2) {
       projectPath(`${VERITY_DIR}/.last-analysis`)
     ];
     for (const file of filesToClear) {
-      if ((0, import_node_fs46.existsSync)(file)) {
+      if ((0, import_node_fs47.existsSync)(file)) {
         try {
-          (0, import_node_fs46.writeFileSync)(file, "");
+          (0, import_node_fs47.writeFileSync)(file, "");
         } catch {
         }
       }
     }
     if (opts.all) {
       const logsDir = projectPath(`${VERITY_DIR}/.logs`);
-      if ((0, import_node_fs46.existsSync)(logsDir)) {
-        for (const entry of (0, import_node_fs46.readdirSync)(logsDir)) {
+      if ((0, import_node_fs47.existsSync)(logsDir)) {
+        for (const entry of (0, import_node_fs47.readdirSync)(logsDir)) {
           try {
-            (0, import_node_fs46.unlinkSync)((0, import_node_path31.join)(logsDir, entry));
+            (0, import_node_fs47.unlinkSync)((0, import_node_path32.join)(logsDir, entry));
           } catch {
           }
         }
@@ -25279,8 +25524,8 @@ function registerTelemetryCommands(program2) {
 }
 
 // src/cli.ts
-program.name("verity").description("CLI for Verity quality gate service").version("0.31.1-experimental.83a8619").option("--token <token>", "Override authentication token").option("--service-url <url>", "Override service URL").option("--verbose", "Log HTTP requests/responses to stderr").hook("preAction", async (_thisCommand, actionCommand) => {
-  installStderrLog(actionCommand.name(), process.argv.slice(2), "0.31.1-experimental.83a8619");
+program.name("verity").description("CLI for Verity quality gate service").version("0.31.1-experimental.b9b3862").option("--token <token>", "Override authentication token").option("--service-url <url>", "Override service URL").option("--verbose", "Log HTTP requests/responses to stderr").hook("preAction", async (_thisCommand, actionCommand) => {
+  installStderrLog(actionCommand.name(), process.argv.slice(2), "0.31.1-experimental.b9b3862");
   setUserNamedServiceUrl(program.opts().serviceUrl);
   try {
     await foldLegacyLocalCredential();

package/data/skills/verity-setup/SKILL.md

@@ -46,6 +46,13 @@ answers, the hook wiring, and a `next` list. Branch on it:
   to launch a second Claude Code session on top of this one.
 - **`blocked` is true** → a required prerequisite is missing. Show the
   `prerequisites[].remedy` lines and stop; nothing below can work.
+- **`artifacts.standard` is true but `artifacts.analysisConfig` is false** → this
+  project adopted a Standard rather than synthesizing one (`verity init` can pull
+  the team's Standard straight from the service), and the only missing piece is
+  the analysis config. **Do Step 2 and Step 5 only**, then `verity config push`,
+  then stop. Do NOT re-synthesize the Standard: the team already agreed one, and
+  `verity standard push` auto-versions, so writing a new one lands as the version
+  everybody is then held to.
 - **`artifacts.verityMd` is true and the user did not pass `--force`** → already
   configured. Say "Already configured. Run `/verity-setup --force` to
   reconfigure." and stop.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codacy/verity-cli",
-  "version": "0.31.1-experimental.83a8619",
+  "version": "0.31.1-experimental.b9b3862",
   "description": "CLI for Verity quality gate service",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://verity.md",