@ogygie/generate 0.0.0-stage → 0.19.0

package/dist/cli/run.js

@@ -0,0 +1,1127 @@
+import {
+  DEFAULT_FILL_MODELS,
+  EMPTY_GUARD_REGISTRY,
+  FeatureNameSchema,
+  GENERATOR_VERSION,
+  MANIFEST_FILE,
+  PREVIEWS_FILE_SUFFIX,
+  acceptExamplesOf,
+  applyGeneratedContracts,
+  applyManifestEntry,
+  applySpecContracts,
+  boundBehaviorsOf,
+  boundScreenBehaviorsOf,
+  buildFeaturePlan,
+  buildScreenPlan,
+  checkSpec,
+  contractViolationCodeOf,
+  createMessagesClient,
+  emitScreenSpecContracts,
+  entryStatusForSpec,
+  featureTargetOf,
+  formatProblem,
+  generateFeature,
+  generateScreen,
+  importProductModule,
+  intentForManifest,
+  intentOfSpec,
+  loadConsumedFeatures,
+  loadGenerateProject,
+  loadHolesLibrary,
+  migrationFileNameFor,
+  modelsOfModule,
+  ogygieError,
+  pascalCaseOf,
+  runFillCommand,
+  schemaModelsLoader,
+  screenBodyDefault,
+  screenBodyPath,
+  screenTargetOf,
+  scrubbedEnvironment,
+  serializeManifest,
+  tableNameOf,
+  targetKindOf,
+  throwOgygieError,
+  verifyGeneration
+} from "../chunk-WVFHAPGC.js";
+
+// src/cli/check-command.ts
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+var SPEC_FILE_NAME = /^(?!_)[^/]+\.spec\.md$/u;
+async function checkOne(project, specPath, out) {
+  const markdown = readFileSync(join(project.root, specPath), "utf8");
+  const guards = project.generation?.guards ?? EMPTY_GUARD_REGISTRY;
+  const first = checkSpec({ markdown, specPath, guards, generation: project.generation });
+  if (first.kind === "screen" && first.screen !== null) {
+    const consumed = await loadConsumedFeatures(project, first.screen);
+    return checkSpec({ markdown, specPath, guards, generation: project.generation, consumed });
+  }
+  const owner = project.owners.find((candidate) => candidate.specPath === specPath);
+  if (first.block === null || owner === void 0) return first;
+  const modulePath = `${owner.folder}/${first.block.contracts.module.replace(/^\.\//u, "")}`;
+  const schemas = await schemaModelsLoader(project.root)(modulePath);
+  if (schemas === null) {
+    out.error(`ogygie generate check \u2014 ${modulePath} n'existe pas : le bloc est v\xE9rifi\xE9 sans son module (D19 : schemas.ts est le premier geste humain).`);
+    return first;
+  }
+  return checkSpec({ markdown, specPath, guards, generation: project.generation, schemas });
+}
+function printReport(specPath, report, out) {
+  for (const problem of report.problems) out.error(formatProblem(problem));
+  const { derivable, hole, unbound } = report.tally;
+  const verdict = report.ok ? "OK" : `${report.problems.length} probl\xE8me(s)`;
+  out.log(
+    report.generated ? `  ${specPath} \u2014 ${verdict} ; ${derivable} ligne(s) li\xE9e(s), ${hole} port\xE9e(s) par un trou, ${unbound} hors vocabulaire` : `  ${specPath} \u2014 sans section # G\xE9n\xE9ration, rien \xE0 v\xE9rifier`
+  );
+}
+async function runCheckCommand(project, featureId, out) {
+  const specPaths = [];
+  if (featureId !== void 0) {
+    const target = targetKindOf(project, featureId) === "screen" ? screenTargetOf(project, featureId) : featureTargetOf(project, featureId);
+    if (!target.ok) {
+      out.error(formatProblem(target.problem));
+      return 1;
+    }
+    specPaths.push(target.target.specPath);
+  } else {
+    const folder = project.specsFolder.replace(/\/+$/u, "");
+    const absolute = join(project.root, folder);
+    const names = existsSync(absolute) ? readdirSync(absolute).filter((name) => SPEC_FILE_NAME.test(name)).sort() : [];
+    specPaths.push(...names.map((name) => `${folder}/${name}`));
+  }
+  let problems = 0;
+  let generated = 0;
+  for (const specPath of specPaths) {
+    const report = await checkOne(project, specPath, out);
+    printReport(specPath, report, out);
+    problems += report.problems.length;
+    if (report.generated) generated += 1;
+  }
+  if (problems > 0) {
+    out.error(`ogygie generate check \u2014 ${problems} probl\xE8me(s) sur ${specPaths.length} spec(s).`);
+    return 1;
+  }
+  out.log(`ogygie generate check \u2014 OK, ${specPaths.length} spec(s) lue(s) dont ${generated} avec une section # G\xE9n\xE9ration.`);
+  return 0;
+}
+
+// src/cli/generate-command.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, readdirSync as readdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join3 } from "node:path";
+import { performance as performance2 } from "node:perf_hooks";
+
+// ../ogygie-core/src/spec.schema.ts
+import { z } from "zod";
+var DeferredBehaviorSchema = z.string().regex(
+  /^.+ blockedBy:[a-z][a-z0-9]*(-[a-z0-9]+)*$/,
+  'Expected "<behavior> blockedBy:<feature-name>" (feature name in kebab-case)'
+);
+var SpecFrontmatterSchema = z.object({
+  id: FeatureNameSchema.describe("Identical to the feature name in the manifest"),
+  status: z.enum(["draft", "validated", "implemented"]),
+  depends_on: z.array(FeatureNameSchema),
+  priority: z.enum(["P0", "P1", "P2"]),
+  refs: z.array(z.string()).default([]).describe("References to the domain model, e.g. 'modele-gally \xA74.2'"),
+  deferred: z.array(DeferredBehaviorSchema).default([]).describe("Behaviors deferred to a later feature, blocked by name")
+});
+function splitInlineArrayElements(inner) {
+  const elements = [];
+  let current = "";
+  let openQuote = null;
+  for (const character of inner) {
+    if (openQuote === null && (character === '"' || character === "'")) {
+      openQuote = character;
+      current += character;
+    } else if (character === openQuote) {
+      openQuote = null;
+      current += character;
+    } else if (openQuote === null && character === ",") {
+      elements.push(current);
+      current = "";
+    } else {
+      current += character;
+    }
+  }
+  elements.push(current);
+  return { elements, unbalancedQuote: openQuote !== null };
+}
+function unquote(raw, location, problems) {
+  const trimmed = raw.trim();
+  const first = trimmed[0];
+  if (first === '"' || first === "'") {
+    if (trimmed.length < 2 || !trimmed.endsWith(first)) {
+      problems.push(`${location}: unbalanced quotes in ${JSON.stringify(trimmed)}`);
+      return null;
+    }
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function parseSpecFrontmatter(text) {
+  const value = {};
+  const problems = [];
+  const lines = text.split("\n");
+  for (let index = 0; index < lines.length; index += 1) {
+    const trimmed = (lines[index] ?? "").trim();
+    if (trimmed === "" || trimmed.startsWith("#")) continue;
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex === -1 || trimmed.startsWith('"') || trimmed.startsWith("'")) {
+      problems.push(
+        `unparseable line ${JSON.stringify(trimmed)}: expected \`key: value\` \u2014 a spilled array element outside any array? (scalars and arrays of scalars only)`
+      );
+      continue;
+    }
+    const key = trimmed.slice(0, colonIndex).trim();
+    let rawValue = trimmed.slice(colonIndex + 1).trim();
+    if (rawValue.startsWith("[")) {
+      let closed = rawValue.endsWith("]");
+      while (!closed && index + 1 < lines.length) {
+        index += 1;
+        rawValue = `${rawValue} ${(lines[index] ?? "").trim()}`;
+        closed = rawValue.endsWith("]");
+      }
+      if (!closed) {
+        problems.push(
+          `key "${key}": array opened with "[" and never closed with "]" before the end of the frontmatter \u2014 a truncated array would be silently read as empty, hence refused`
+        );
+        continue;
+      }
+      const { elements, unbalancedQuote } = splitInlineArrayElements(
+        rawValue.slice(1, -1)
+      );
+      if (unbalancedQuote) {
+        problems.push(`key "${key}": unbalanced quotes inside the array`);
+        continue;
+      }
+      const parsedElements = [];
+      let broken = false;
+      for (const element of elements) {
+        if (element.trim() === "") continue;
+        const unquoted = unquote(element, `key "${key}"`, problems);
+        if (unquoted === null) broken = true;
+        else parsedElements.push(unquoted);
+      }
+      if (!broken) value[key] = parsedElements;
+    } else {
+      const unquoted = unquote(rawValue, `key "${key}"`, problems);
+      if (unquoted !== null) value[key] = unquoted;
+    }
+  }
+  return { value, problems };
+}
+var FRONTMATTER_BLOCK = /^---\n([\s\S]*?)\n---/;
+function parseSpecDocument(content) {
+  const match = FRONTMATTER_BLOCK.exec(content);
+  if (match === null || match[1] === void 0) {
+    return {
+      frontmatter: null,
+      problems: ["file does not start with a --- ... --- frontmatter block"],
+      body: content
+    };
+  }
+  const body = content.slice(match[0].length);
+  const parsed = parseSpecFrontmatter(match[1]);
+  if (parsed.problems.length > 0) {
+    return { frontmatter: null, problems: parsed.problems, body };
+  }
+  const checked = SpecFrontmatterSchema.safeParse(parsed.value);
+  if (!checked.success) {
+    return {
+      frontmatter: null,
+      problems: checked.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`),
+      body
+    };
+  }
+  return { frontmatter: checked.data, problems: [], body };
+}
+var DESIGN_SECTION_TITLE = "Design";
+var COMPOSITION_LINE = /^\s*(?:[-*]\s*)?[Cc]omposition\s*:\s*`?([a-z][a-z0-9]*(?:-[a-z0-9]+)*)`?(?![A-Za-z0-9])/mu;
+function compositionOfSpec(content) {
+  const heading = new RegExp(`^# ${DESIGN_SECTION_TITLE}\\s*$`, "mu").exec(content);
+  if (heading === null) return null;
+  const rest = content.slice(heading.index + heading[0].length);
+  const next = /^# /mu.exec(rest);
+  const section = next === null ? rest : rest.slice(0, next.index);
+  return COMPOSITION_LINE.exec(section)?.[1] ?? null;
+}
+
+// src/cli/generate-screen-command.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { dirname, join as join2 } from "node:path";
+import { performance } from "node:perf_hooks";
+function consumedInputsOf(loaded) {
+  const inputs = [];
+  for (const feature of loaded.values()) {
+    if (feature.schemas === null) continue;
+    inputs.push({ featureId: feature.featureId, block: feature.block, schemas: feature.schemas, routes: feature.routes });
+  }
+  return inputs;
+}
+async function runGenerateScreenCommand(project, featureId, out) {
+  const lookup = screenTargetOf(project, featureId);
+  if (!lookup.ok) {
+    out.error(formatProblem(lookup.problem));
+    return 1;
+  }
+  const { target } = lookup;
+  const markdown = readFileSync2(join2(project.root, target.specPath), "utf8");
+  const first = checkSpec({ markdown, specPath: target.specPath, generation: target.generation });
+  if (first.kind !== "screen" || first.screen === null) {
+    for (const problem of first.problems) out.error(formatProblem(problem));
+    out.error(`ogygie generate \u2014 ${target.specPath} n'a pas de bloc # G\xE9n\xE9ration d'\xE9cran lisible (consumes, views, holes).`);
+    return 1;
+  }
+  const loaded = await loadConsumedFeatures(project, first.screen);
+  const report = checkSpec({ markdown, specPath: target.specPath, generation: target.generation, consumed: loaded });
+  if (!report.ok || report.screen === null) {
+    for (const problem of report.problems) out.error(formatProblem(problem));
+    out.error(`ogygie generate \u2014 ${report.problems.length} probl\xE8me(s), rien n'est \xE9crit.`);
+    return 1;
+  }
+  const started = performance.now();
+  const plan = buildScreenPlan({
+    featureId,
+    folder: target.folder,
+    appPath: target.appPath,
+    specPath: target.specPath,
+    block: report.screen,
+    consumed: consumedInputsOf(loaded),
+    front: target.front,
+    guards: target.generation.guards,
+    contractViolationCode: contractViolationCodeOf(target.generation.target),
+    generatorVersion: GENERATOR_VERSION,
+    behaviors: boundScreenBehaviorsOf(report.behaviors)
+  });
+  const existingCustomViews = /* @__PURE__ */ new Map();
+  for (const view of plan.views) {
+    if (view.kind !== "custom") continue;
+    const path = join2(project.root, plan.folder, "views", `${view.componentName}.tsx`);
+    existingCustomViews.set(view.id, existsSync2(path) ? readFileSync2(path, "utf8") : null);
+  }
+  const files = generateScreen(plan, { existingCustomViews });
+  const specContracts = applyGeneratedContracts(markdown, emitScreenSpecContracts(plan), GENERATOR_VERSION);
+  const elapsedMs = Math.round(performance.now() - started);
+  let written = 0;
+  let emitted = 0;
+  for (const file of files) {
+    const absolute = join2(project.root, file.path);
+    const exists = existsSync2(absolute);
+    emitted += file.content.split("\n").length - 1;
+    if (exists && readFileSync2(absolute, "utf8") === file.content) {
+      out.log(`  identique ${file.path}`);
+      continue;
+    }
+    mkdirSync(dirname(absolute), { recursive: true });
+    writeFileSync(absolute, file.content, "utf8");
+    written += 1;
+    out.log(`  ${exists ? "r\xE9\xE9crit  " : "\xE9crit    "} ${file.path}`);
+  }
+  const bodyPath = screenBodyPath(plan);
+  const bodyAbsolute = join2(project.root, bodyPath);
+  if (existsSync2(bodyAbsolute)) {
+    out.log(`  conserv\xE9  ${bodyPath} (corps \xE9crit, jamais compar\xE9 \u2014 D40)`);
+  } else {
+    mkdirSync(dirname(bodyAbsolute), { recursive: true });
+    writeFileSync(bodyAbsolute, screenBodyDefault(plan), "utf8");
+    written += 1;
+    out.log(`  \xE9crit     ${bodyPath} (corps par d\xE9faut, une fois : le v\xF4tre d\xE9sormais \u2014 D40)`);
+  }
+  if (specContracts.outcome === "section-missing") {
+    out.error(`ogygie generate \u2014 ${target.specPath} n'a pas de section # Contrats de donn\xE9es, le bloc g\xE9n\xE9r\xE9 n'a nulle part o\xF9 aller (section obligatoire, verify-specs).`);
+    return 1;
+  }
+  if (specContracts.outcome === "unchanged") {
+    out.log(`  identique ${target.specPath} \u203A bloc @generated de # Contrats de donn\xE9es`);
+  } else {
+    writeFileSync(join2(project.root, target.specPath), specContracts.markdown, "utf8");
+    out.log(`  ${specContracts.outcome === "inserted" ? "ins\xE9r\xE9   " : "r\xE9\xE9crit  "} ${target.specPath} \u203A bloc @generated de # Contrats de donn\xE9es`);
+  }
+  out.log(
+    `ogygie generate \u2014 ${featureId} (\xE9cran) : ${files.length} fichier(s) \xE9mis en ${elapsedMs} ms (${emitted} lignes \xE9mises, bloc de la spec compris), ${written} \xE9crit(s), ${report.tally.derivable} ligne(s) li\xE9e(s), ${report.tally.hole} port\xE9e(s) par un trou ; ${plan.views.filter((view) => view.kind === "custom").length} vue(s) custom sur ${plan.views.length}.`
+  );
+  return 0;
+}
+
+// src/cli/generate-command.ts
+function generatedFeatureIdsOf(project) {
+  const kinds = [];
+  for (const feature of project.manifest.features) {
+    if (feature.spec === null) continue;
+    const kind = targetKindOf(project, feature.name);
+    if (kind === null) continue;
+    const specPath = join3(project.root, feature.spec);
+    if (!existsSync3(specPath)) continue;
+    const first = checkSpec({ markdown: readFileSync3(specPath, "utf8"), specPath: feature.spec, generation: project.generation });
+    if (kind === "feature" ? first.block !== null : first.screen !== null) kinds.push({ id: feature.name, kind });
+  }
+  return [...kinds.filter((entry) => entry.kind === "feature"), ...kinds.filter((entry) => entry.kind === "screen")].map((entry) => entry.id);
+}
+async function runGenerateAllCommand(project, out) {
+  const ids = generatedFeatureIdsOf(project);
+  if (ids.length === 0) {
+    out.log("ogygie generate --all \u2014 aucune spec de la carte ne porte de bloc # G\xE9n\xE9ration, rien \xE0 r\xE9g\xE9n\xE9rer.");
+    return 0;
+  }
+  const refused = [];
+  let current = project;
+  for (const [index, id] of ids.entries()) {
+    if (index > 0) {
+      const reloaded = loadGenerateProject(project.root);
+      if (!reloaded.ok) {
+        for (const problem of reloaded.problems) out.error(formatProblem(problem));
+        out.error(`ogygie generate --all \u2014 le projet ne se relit plus apr\xE8s ${ids[index - 1]}, arr\xEAt.`);
+        return 1;
+      }
+      current = reloaded.project;
+    }
+    const code = await runGenerateFeatureCommand(current, id, out);
+    if (code !== 0) refused.push(id);
+  }
+  out.log(`ogygie generate --all \u2014 ${ids.length} spec(s) g\xE9n\xE9r\xE9e(s) de la carte : ${ids.length - refused.length} r\xE9g\xE9n\xE9r\xE9e(s)${refused.length === 0 ? "" : `, ${refused.length} refus\xE9e(s) (${refused.join(", ")})`}.`);
+  return refused.length === 0 ? 0 : 1;
+}
+async function runGenerateFeatureCommand(project, featureId, out) {
+  if (featureId === void 0 || featureId === "") {
+    out.error("usage: ogygie generate generate <feature-id> | --all");
+    return 1;
+  }
+  if (targetKindOf(project, featureId) === "screen") return runGenerateScreenCommand(project, featureId, out);
+  const lookup = featureTargetOf(project, featureId);
+  if (!lookup.ok) {
+    out.error(formatProblem(lookup.problem));
+    return 1;
+  }
+  const { target } = lookup;
+  const markdown = readFileSync3(join3(project.root, target.specPath), "utf8");
+  const firstPass = checkSpec({ markdown, specPath: target.specPath, generation: target.generation });
+  if (firstPass.block === null) {
+    for (const problem of firstPass.problems) out.error(formatProblem(problem));
+    out.error(`ogygie generate \u2014 ${target.specPath} n'a pas de bloc # G\xE9n\xE9ration lisible.`);
+    return 1;
+  }
+  const modulePath = `${target.folder}/${firstPass.block.contracts.module.replace(/^\.\//u, "")}`;
+  const schemas = await schemaModelsLoader(project.root)(modulePath);
+  if (schemas === null) {
+    out.error(`ogygie generate \u2014 ${modulePath} n'existe pas (D19 : schemas.ts est le premier geste humain).`);
+    return 1;
+  }
+  const report = checkSpec({ markdown, specPath: target.specPath, generation: target.generation, schemas });
+  if (!report.ok || report.block === null) {
+    for (const problem of report.problems) out.error(formatProblem(problem));
+    out.error(`ogygie generate \u2014 ${report.problems.length} probl\xE8me(s), rien n'est \xE9crit.`);
+    return 1;
+  }
+  const started = performance2.now();
+  const migrationsDir = join3(project.root, target.appPath, target.generation.target.migrations);
+  const existingMigrations = existsSync3(migrationsDir) ? readdirSync2(migrationsDir) : [];
+  const plan = buildFeaturePlan({
+    featureId,
+    folder: target.folder,
+    appPath: target.appPath,
+    specPath: target.specPath,
+    block: report.block,
+    schemas,
+    generation: target.generation,
+    ...target.tenantColumn === void 0 ? {} : { tenantColumn: target.tenantColumn },
+    migrationFileName: migrationFileNameFor(existingMigrations, report.block.contracts.table === void 0 ? featureId : tableNameOf(report.block.contracts.table)),
+    generatorVersion: GENERATOR_VERSION,
+    behaviors: boundBehaviorsOf(report.behaviors)
+  });
+  const logicPath = join3(project.root, target.folder, "logic.ts");
+  const existingLogic = existsSync3(logicPath) ? readFileSync3(logicPath, "utf8") : null;
+  const migrationPath = join3(project.root, plan.migrationPath);
+  const existingMigration = existsSync3(migrationPath) ? readFileSync3(migrationPath, "utf8") : null;
+  const files = generateFeature(plan, { existingLogic, existingMigration, library: loadHolesLibrary() });
+  const manifestEntry = applyManifestEntry(project.rawManifest, plan, intentOfSpec(markdown), entryStatusForSpec(parseSpecDocument(markdown).frontmatter?.status));
+  const specContracts = applySpecContracts(markdown, plan);
+  const elapsedMs = Math.round(performance2.now() - started);
+  let written = 0;
+  let emitted = 0;
+  for (const file of files) {
+    const absolute = join3(project.root, file.path);
+    const exists = existsSync3(absolute);
+    emitted += file.content.split("\n").length - 1;
+    if (exists && readFileSync3(absolute, "utf8") === file.content) {
+      out.log(`  identique ${file.path}`);
+      continue;
+    }
+    mkdirSync2(dirname2(absolute), { recursive: true });
+    writeFileSync2(absolute, file.content, "utf8");
+    written += 1;
+    out.log(`  ${exists ? "r\xE9\xE9crit  " : "\xE9crit    "} ${file.path}`);
+  }
+  if (manifestEntry.outcome === "unchanged") {
+    out.log(`  identique ${MANIFEST_FILE} \u203A features[${featureId}].routes, dbTables`);
+  } else {
+    writeFileSync2(join3(project.root, MANIFEST_FILE), serializeManifest(manifestEntry.manifest), "utf8");
+    out.log(
+      `  ${manifestEntry.outcome === "created" ? "ajout\xE9e  " : "r\xE9\xE9crite "} ${MANIFEST_FILE} \u203A features[${featureId}] (${plan.operations.length} route(s), ${1 + plan.slots.length + plan.references.filter((reference) => reference.table !== null).length} table(s)${manifestEntry.outcome === "created" ? `, status ${entryStatusForSpec(parseSpecDocument(markdown).frontmatter?.status)} : \xE0 vous de dire delivered` : ""})`
+    );
+  }
+  if (specContracts.outcome === "section-missing") {
+    out.error(`ogygie generate \u2014 ${target.specPath} n'a pas de section # Contrats de donn\xE9es, le bloc g\xE9n\xE9r\xE9 n'a nulle part o\xF9 aller (section obligatoire, verify-specs).`);
+    return 1;
+  }
+  if (specContracts.outcome === "unchanged") {
+    out.log(`  identique ${target.specPath} \u203A bloc @generated de # Contrats de donn\xE9es`);
+  } else {
+    const addedLines = specContracts.markdown.split("\n").length - markdown.split("\n").length;
+    writeFileSync2(join3(project.root, target.specPath), specContracts.markdown, "utf8");
+    out.log(
+      `  ${specContracts.outcome === "inserted" ? "ins\xE9r\xE9   " : "r\xE9\xE9crit  "} ${target.specPath} \u203A bloc @generated de # Contrats de donn\xE9es${specContracts.outcome === "inserted" ? ` (+${addedLines} lignes)` : ""}`
+    );
+  }
+  out.log(
+    `ogygie generate \u2014 ${featureId} : ${files.length} fichier(s) \xE9mis en ${elapsedMs} ms (${emitted} lignes \xE9mises, entr\xE9e du manifeste et bloc de la spec compris dans le temps), ${written} \xE9crit(s), ${report.tally.derivable} ligne(s) li\xE9e(s), ${report.tally.hole} port\xE9e(s) par un trou.`
+  );
+  return 0;
+}
+
+// src/cli/preview-command.ts
+import { spawnSync } from "node:child_process";
+import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync3 } from "node:fs";
+import { join as join4 } from "node:path";
+var PREVIEWS_ROOT = "previews";
+function previewsDirOf(featureId, composition) {
+  return composition === null ? `${PREVIEWS_ROOT}/${featureId}` : `${PREVIEWS_ROOT}/${featureId}/${composition}`;
+}
+var vitestPreviewRunner = ({ projectRoot, testPath, outDir }) => {
+  const result = spawnSync("pnpm", ["exec", "vitest", "run", testPath], {
+    cwd: projectRoot,
+    env: { ...process.env, OGYGIE_PREVIEW_OUT: outDir, CI: "1" },
+    encoding: "utf8"
+  });
+  const lines = `${result.stdout ?? ""}
+${result.stderr ?? ""}`.split("\n").filter((line) => line.trim() !== "");
+  return { code: result.status ?? 1, lines };
+};
+async function runPreviewCommand(project, featureId, out, runner = vitestPreviewRunner) {
+  if (featureId === void 0) {
+    out.error("usage: ogygie generate preview <screen-id>");
+    return 1;
+  }
+  const lookup = screenTargetOf(project, featureId);
+  if (!lookup.ok) {
+    out.log(`ogygie generate preview \u2014 ${featureId} n'est pas un \xE9cran de la carte : rien \xE0 rendre (${lookup.problem.cause}).`);
+    return 0;
+  }
+  const { target } = lookup;
+  if (target.front.tests !== "static-render") {
+    out.log(`ogygie generate preview \u2014 la cible front est ${target.front.tests} : les aper\xE7us demandent static-render (D43), rien \xE0 rendre.`);
+    return 0;
+  }
+  const testPath = `${target.folder}/${pascalCaseOf(featureId)}Screen${PREVIEWS_FILE_SUFFIX}`;
+  if (!existsSync4(join4(project.root, testPath))) {
+    out.error(`ogygie generate preview \u2014 ${testPath} n'existe pas : lancez \`ogygie generate generate ${featureId}\` d'abord, le test des aper\xE7us est \xE9mis avec l'\xE9cran.`);
+    return 1;
+  }
+  const specAbsolute = join4(project.root, target.specPath);
+  const composition = existsSync4(specAbsolute) ? compositionOfSpec(readFileSync4(specAbsolute, "utf8")) : null;
+  const relativeDir = previewsDirOf(featureId, composition);
+  const outDir = join4(project.root, relativeDir);
+  const run = runner({ projectRoot: project.root, testPath, outDir });
+  for (const line of run.lines) out.log(`  ${line}`);
+  if (run.code !== 0) {
+    out.error(`ogygie generate preview \u2014 le rendu des aper\xE7us de ${featureId} a \xE9chou\xE9 (code ${run.code}) : rien n'est publi\xE9 tant qu'un \xE9tat ne rend pas.`);
+    return run.code;
+  }
+  const pages = existsSync4(outDir) ? readdirSync3(outDir).filter((name) => name.endsWith(".html")).sort() : [];
+  out.log(`ogygie generate preview \u2014 ${featureId} : ${pages.length} page(s) dans ${relativeDir}/ (${pages.map((name) => name.replace(/\.html$/u, "")).join(", ")})${composition === null ? "" : ` \u2014 composition ${composition}`}.`);
+  return pages.length === 0 ? 1 : 0;
+}
+
+// src/cli/schemas-command.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { appendFileSync, existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync5, rmSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname3, join as join5 } from "node:path";
+import { pathToFileURL } from "node:url";
+
+// src/schemas/draft.ts
+var SCHEMAS_NEEDS_OPERATOR = "OGYGIE_SCHEMAS_NEEDS_OPERATOR";
+var SCHEMAS_ATTEMPTS = 2;
+var SCHEMAS_SYSTEM_PROMPT = [
+  "You write the FIRST `schemas.ts` of a feature generated by the Ogygie framework: the Zod v4 data contracts its `# G\xE9n\xE9ration` block cites. You receive the spec \u2014 its block, its behaviours, its prose \u2014 and nothing else. The schemas are the source of truth the generator introspects: columns, factories and output mappings derive from them.",
+  "",
+  "Answer with the COMPLETE TypeScript module only, in one fenced block or bare: no prose before or after.",
+  "",
+  "Rules of the module:",
+  '- `import { z } from "zod";` is the only import (a sibling feature\'s contracts may be imported by a relative path ending in `schemas.js`); no runtime value but schemas; never `process`, `fetch`, `require`, a clock;',
+  "- every schema the block cites (`input`, `output`, `resource`, `rowSchema`, slot and reference `schema`, `orderBy`) is `export const <Name>Schema = z.\u2026` with its `export type <Name> = z.infer<typeof <Name>Schema>`; names end in `Schema`, identifiers and comments are English;",
+  "- the resource schema is one `z.object` whose fields are the table's columns, camelCase: `id: z.uuid()`, dates `z.iso.date()` or `z.iso.datetime()`, money and measures `z.number()`, closed lists `z.enum([...])`; a motif `signedWrite: { by, at }` means the resource carries those two fields; an `appendOnlySupersedes` resource carries `supersedes` and `supersededBy` (nullable uuids);",
+  "- a read's output wraps a collection: `{ <field>: z.array(<Element>Schema) }`, the element COVERING the resource (`ResourceSchema.extend({...})` for slot arrays, reference counts, view or project fields the block declares); a create's input carries the resource fields the client sends (never `id`, never the signature, never a derived field); an update's input is the partial body and REFUSES an empty body (`.partial().refine((body) => Object.values(body).some((value) => value !== undefined), { message: \"at least one field must be sent\" })`); a setOrClear's input is `{ <value field> }` nullable; a delete's input is `z.object({})`; an import's input is `z.object({ csv: z.string() })`, its row schema the create's input;",
+  '- a field the structure alone cannot populate \u2014 a regex, a `.refine`, a `.trim()`, a `.transform` \u2014 carries its example: `.meta({ examples: ["\u2026"] })`, and the example passes the schema;',
+  '- the examples of the `holes` block parse against the fields they read: when an accept or reject example gives `valuationDate: "2026-02-28"`, the input\'s `valuationDate` accepts that string;',
+  // Assembled from fragments: the repo's lint reads source text and would refuse the spelled-out words.
+  `- no \`any\`, no \`@ts-${"ignore"}\`, no \`as unknown ${"as"}\`, no default export; two-space indentation; a short JSDoc on each exported schema.`
+].join("\n");
+async function draftSchemas(deps, attempts = SCHEMAS_ATTEMPTS) {
+  const usage = [];
+  let previous;
+  let model = null;
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    const candidate = await deps.draw(previous);
+    usage.push({ ...candidate.usage, model: candidate.model });
+    model = candidate.model;
+    const bans = forbiddenInSchemas(candidate.source);
+    const problems = bans.length > 0 ? bans : (await deps.judge(candidate.source, attempt)).problems;
+    deps.log(JSON.stringify({ action: "schemas", attempt, model: candidate.model, outcome: problems.length === 0 ? "green" : bans.length > 0 ? "banned" : "red", problems: problems.length }));
+    if (problems.length === 0) return { outcome: "written", attempts: attempt, problems: [], model, usage };
+    await deps.discard();
+    previous = { source: candidate.source, problems };
+  }
+  return { outcome: "needs-operator", attempts, problems: previous?.problems ?? [], model, usage };
+}
+function extractModuleSource(answer) {
+  const fenced = /```(?:ts|tsx|typescript)?\s*\n([\s\S]*?)\n```/u.exec(answer);
+  return `${(fenced?.[1] ?? answer).replace(/\r\n/gu, "\n").trim()}
+`;
+}
+var banned = (...fragments) => new RegExp(fragments.join(""), "u");
+var IMPORT = /^\s*import\s+(?:type\s+)?[^;]*?\sfrom\s+["']([^"']+)["']/gmu;
+var ALLOWED_IMPORT = /^(?:zod|zod\/v4|\.{1,2}\/[^"']*schemas(?:\.js|\.ts)?)$/u;
+function forbiddenInSchemas(source) {
+  const code = source.replace(/\/\*[\s\S]*?\*\//gu, "").replace(/(^|[^:])\/\/.*$/gmu, "$1");
+  const rules = [];
+  for (const match of code.matchAll(IMPORT)) {
+    const specifier = match[1] ?? "";
+    if (!ALLOWED_IMPORT.test(specifier)) rules.push(`import de ${JSON.stringify(specifier)} : un schemas.ts n'importe que zod et les contrats d'une feature voisine (puret\xE9 des contrats)`);
+  }
+  const checks = [
+    [banned("(:\\s*a", "ny\\b)|(<a", "ny[,>])|(\\bas a", "ny\\b)|(\\ba", "ny\\[\\])"), "type any interdit"],
+    [banned("@ts-", "ignore"), "ts-ignore interdit"],
+    [banned("\\bas unknown ", "as\\b"), ["as unknown ", "as interdit"].join("")],
+    [/\brequire\s*\(/u, "require interdit"],
+    [/\bprocess\.(env|exit|argv)\b/u, "process hors de port\xE9e d'un contrat"],
+    [/\bfetch\s*\(/u, "aucun r\xE9seau dans un contrat"],
+    [/\beval\s*\(|\bnew Function\s*\(/u, "aucune \xE9valuation dynamique"],
+    [/\bnew Date\s*\(\s*\)|\bDate\.now\s*\(/u, "aucune horloge dans un contrat"],
+    [/^\s*export\s+default\b/mu, "pas d'export par d\xE9faut : chaque contrat est un export nomm\xE9"]
+  ];
+  for (const [pattern, rule] of checks) if (pattern.test(code)) rules.push(rule);
+  if (!/^\s*export\s+const\s+[A-Z][A-Za-z0-9]*Schema\s*=/mu.test(code)) rules.push("aucun `export const <Nom>Schema` : le module n'exporte aucun contrat");
+  return rules;
+}
+function citedSchemaNamesOf(block) {
+  const cited = /* @__PURE__ */ new Map();
+  const cite = (name, role) => {
+    if (name !== void 0 && !cited.has(name)) cited.set(name, role);
+  };
+  cite(block.contracts.resource, "contracts.resource \u2014 la ressource, une ligne de la table");
+  for (const [slot, declaration] of Object.entries(block.contracts.slots ?? {})) cite(declaration.schema, `contracts.slots.${slot}.schema \u2014 une case de la ressource`);
+  for (const [reference, declaration] of Object.entries(block.contracts.references ?? {})) cite(declaration.schema, `contracts.references.${reference}.schema \u2014 une ligne qui pointe la ressource`);
+  for (const operation of block.operations) {
+    cite(operation.input, `operations.${operation.id}.input (${operation.kind})`);
+    cite(operation.output, `operations.${operation.id}.output (${operation.kind})`);
+    if (operation.kind === "read" && typeof operation.orderBy === "string") cite(operation.orderBy, `operations.${operation.id}.orderBy`);
+  }
+  cite(block.motifs.allOrNothingImport?.rowSchema, "motifs.allOrNothingImport.rowSchema \u2014 une ligne du fichier import\xE9");
+  return [...cited.entries()].map(([name, role]) => ({ name, role }));
+}
+function fieldParserOf(moduleExports, schemaName, field) {
+  const schema = moduleExports[schemaName];
+  if (typeof schema !== "object" || schema === null || !("shape" in schema)) return null;
+  const shape = schema.shape;
+  if (typeof shape !== "object" || shape === null) return null;
+  const candidate = shape[field];
+  return typeof candidate === "object" && candidate !== null && "safeParse" in candidate ? candidate : null;
+}
+function holeExampleProblems(block, moduleExports) {
+  const problems = [];
+  const schemasReadBy = (holeId) => {
+    const names = /* @__PURE__ */ new Set();
+    for (const operation of block.operations) {
+      if (operation.kind === "command" || !(operation.holes ?? []).includes(holeId)) continue;
+      const rowSchema = operation.kind === "import" ? block.motifs.allOrNothingImport?.rowSchema : void 0;
+      names.add(rowSchema ?? operation.input);
+    }
+    return [...names];
+  };
+  const parseExample = (holeId, label, schemaName, example, fields) => {
+    for (const field of fields) {
+      if (!(field in example)) continue;
+      const parser = fieldParserOf(moduleExports, schemaName, field);
+      if (parser === null) continue;
+      const parsed = parser.safeParse(example[field]);
+      if (!parsed.success) {
+        const why = (parsed.error?.issues ?? []).map((issue) => issue.message).join(" ; ");
+        problems.push(`holes.${holeId}.examples.${label}.${field}: ${schemaName}.${field} refuse ${JSON.stringify(example[field])} (${why})`);
+      }
+    }
+  };
+  for (const hole of block.holes) {
+    if (hole.kind !== "validate" && hole.kind !== "derive") continue;
+    for (const schemaName of schemasReadBy(hole.id)) {
+      if (hole.kind === "validate") {
+        acceptExamplesOf(hole).forEach((example, index) => parseExample(hole.id, `accept${index === 0 ? "" : `.${index}`}`, schemaName, example, hole.reads));
+        parseExample(hole.id, "reject", schemaName, hole.examples.reject, hole.reads);
+      } else {
+        hole.examples.accept.forEach((example, index) => parseExample(hole.id, `accept.${index}.input`, schemaName, example.input, hole.reads));
+        if (hole.examples.reject !== void 0) parseExample(hole.id, "reject.input", schemaName, hole.examples.reject.input, hole.reads);
+      }
+    }
+  }
+  return problems;
+}
+function writeInputProblems(block, moduleExports) {
+  const problems = [];
+  for (const operation of block.operations) {
+    if (operation.kind !== "update") continue;
+    const schema = moduleExports[operation.input];
+    if (typeof schema !== "object" || schema === null || !("safeParse" in schema)) continue;
+    if (schema.safeParse({}).success) {
+      problems.push(`operations.${operation.id}.input: ${operation.input} accepte un corps vide {} \u2014 une mise \xE0 jour partielle refuse le corps sans aucun champ (.refine)`);
+    }
+  }
+  return problems;
+}
+function fieldsOf(moduleExports, schemaName) {
+  if (schemaName === void 0) return null;
+  const schema = moduleExports[schemaName];
+  return schema !== void 0 && typeof schema === "object" && schema !== null && typeof schema.shape === "object" && schema.shape !== null ? Object.keys(schema.shape) : null;
+}
+function resourceCoverageProblems(block, moduleExports) {
+  const resourceFields = fieldsOf(moduleExports, block.contracts.resource);
+  if (resourceFields === null) return [];
+  const problems = [];
+  const signed = block.motifs.signedWrite;
+  const derived = new Set(block.holes.flatMap((hole) => hole.kind === "derive" ? [hole.writes] : []));
+  for (const operation of block.operations) {
+    if (operation.kind !== "create") continue;
+    const inputFields = fieldsOf(moduleExports, operation.input);
+    if (inputFields === null) continue;
+    const covered = /* @__PURE__ */ new Set(["id", ...inputFields, ...derived, ...signed === void 0 ? [] : [signed.by, signed.at]]);
+    for (const field of resourceFields) {
+      if (covered.has(field)) continue;
+      problems.push(`${block.contracts.resource ?? "resource"}.${field}: ni envoy\xE9 par ${operation.input}, ni d\xE9riv\xE9 par un trou, ni sign\xE9 \u2014 l'insertion g\xE9n\xE9r\xE9e ne saurait pas le remplir (retirer le champ, l'ajouter \xE0 l'entr\xE9e, ou le d\xE9river)`);
+    }
+  }
+  return problems;
+}
+function missingExportsOf(block, exportedNames) {
+  const exported = new Set(exportedNames);
+  return citedSchemaNamesOf(block).filter(({ name }) => !exported.has(name)).map(({ name, role }) => `${name} n'est pas export\xE9 par le module (${role})`);
+}
+function buildSchemasPrompt(input) {
+  const cited = citedSchemaNamesOf(input.block).map(({ name, role }) => `- \`${name}\` \u2014 ${role}`);
+  const sections = [
+    `# Feature \`${input.featureId}\` \u2014 write \`${input.modulePath}\``,
+    "",
+    `## The spec (\`${input.specPath}\`)`,
+    "",
+    input.specMarkdown.trim(),
+    "",
+    "## Schemas the block cites \u2014 each one an export of the module",
+    "",
+    ...cited
+  ];
+  if (input.previous !== void 0) {
+    sections.push(
+      "",
+      "## Your previous module was refused \u2014 correct it, keep what was right",
+      "",
+      "```ts",
+      input.previous.source.trim(),
+      "```",
+      "",
+      "Problems:",
+      ...input.previous.problems.map((problem) => `- ${problem}`)
+    );
+  }
+  return `${sections.join("\n")}
+`;
+}
+
+// src/cli/schemas-command.ts
+function parseSchemasFlags(argv) {
+  const index = argv.indexOf("--model");
+  const value = argv[index + 1];
+  return { model: index !== -1 && value !== void 0 ? value : DEFAULT_FILL_MODELS.spec };
+}
+var SCHEMAS_GATE_SCRIPTS = ["typecheck", "ogygie:verify-contracts"];
+var pnpmGateRunner = ({ projectRoot, script }) => {
+  const result = spawnSync2("pnpm", ["run", script], { cwd: projectRoot, env: scrubbedEnvironment(process.env), encoding: "utf8" });
+  const lines = `${result.stdout ?? ""}
+${result.stderr ?? ""}`.split("\n").filter((line) => line.trim() !== "");
+  return { green: result.status === 0, lines };
+};
+function featureFolderFor(project, featureId) {
+  const parents = project.manifest.features.filter((feature) => feature.app === void 0 || feature.app === project.apiApp?.name).map((feature) => feature.folder.split("/").slice(0, -1).join("/")).filter((parent) => parent !== "");
+  const counts = /* @__PURE__ */ new Map();
+  for (const parent of parents) counts.set(parent, (counts.get(parent) ?? 0) + 1);
+  const common = [...counts.entries()].sort((left, right) => right[1] - left[1])[0]?.[0] ?? "src/features";
+  return `${common}/${featureId}`;
+}
+function availableGateScripts(projectRoot) {
+  const path = join5(projectRoot, "package.json");
+  if (!existsSync5(path)) return [];
+  const scripts = JSON.parse(readFileSync5(path, "utf8")).scripts ?? {};
+  return SCHEMAS_GATE_SCRIPTS.filter((script) => script in scripts);
+}
+async function runSchemasCommand(project, featureId, argv, out, deps = {}) {
+  if (featureId === void 0 || featureId === "") {
+    out.error("usage: ogygie generate schemas <feature-id> [--model <model>]");
+    return 1;
+  }
+  const onMap = project.manifest.features.find((feature) => feature.name === featureId);
+  const specPath = onMap?.spec ?? `${project.specsFolder.replace(/\/+$/u, "")}/${featureId}.spec.md`;
+  const specAbsolute = join5(project.root, specPath);
+  if (!existsSync5(specAbsolute)) {
+    out.error(formatProblem(ogygieError({ code: "OGYGIE_GENERATE_PROJECT_INVALID", message: `No spec carries the feature "${featureId}".`, file: specPath, cause: `${specPath} does not exist`, suggestedFix: "Write the spec first: a schemas module derives from a spec, never the reverse." })));
+    return 1;
+  }
+  if (project.apiApp === void 0 || project.generation === null) {
+    out.error(formatProblem(ogygieError({ code: "OGYGIE_GENERATE_PROJECT_INVALID", message: `The feature "${featureId}" cannot be generated from this map.`, file: MANIFEST_FILE, cause: project.apiApp === void 0 ? "apps[] has no entry with type=api" : "the manifest declares no generation block", suggestedFix: "Declare the api app and the `generation` block in the manifest." })));
+    return 1;
+  }
+  const markdown = readFileSync5(specAbsolute, "utf8");
+  const first = checkSpec({ markdown, specPath, generation: project.generation });
+  if (first.kind !== "feature" || first.block === null) {
+    out.log(`ogygie generate schemas \u2014 ${specPath} ${first.kind === "screen" ? "est un \xE9cran : ses contrats sont ceux des features qu'il consomme" : "n'a pas de bloc # G\xE9n\xE9ration de feature"}, rien \xE0 \xE9crire.`);
+    return 0;
+  }
+  const block = first.block;
+  const folder = onMap === void 0 ? `${project.apiApp.path}/${featureFolderFor(project, featureId)}` : `${project.apiApp.path}/${onMap.folder}`;
+  const modulePath = `${folder}/${block.contracts.module.replace(/^\.\//u, "")}`;
+  const moduleAbsolute = join5(project.root, modulePath);
+  if (existsSync5(moduleAbsolute)) {
+    out.log(`ogygie generate schemas \u2014 ${modulePath} existe : il appartient au repo, jamais r\xE9g\xE9n\xE9r\xE9 (D52).`);
+    return 0;
+  }
+  const modelApiKey = deps.modelApiKey ?? process.env["OGYGIE_MODEL_API_KEY"];
+  if (deps.client === void 0 && modelApiKey === void 0) {
+    out.error(formatProblem(ogygieError({ code: SCHEMAS_NEEDS_OPERATOR, message: `The first schemas module of "${featureId}" cannot be drawn: no model key.`, file: modulePath, cause: "OGYGIE_MODEL_API_KEY is absent", suggestedFix: "Give the job the client's workspace key (repo secret), or write the module by hand: it is the operator's gesture then." })));
+    return 2;
+  }
+  const flags = parseSchemasFlags(argv);
+  const client = deps.client ?? createMessagesClient({ apiKey: modelApiKey ?? "", fetchImpl: deps.fetchImpl ?? fetch, credentialHint: "OGYGIE_MODEL_API_KEY" });
+  const gateRunner = deps.gateRunner ?? pnpmGateRunner;
+  const gateScripts = availableGateScripts(project.root);
+  for (const script of SCHEMAS_GATE_SCRIPTS) if (!gateScripts.includes(script)) out.log(`ogygie generate schemas \u2014 le projet n'a pas de script \`${script}\` : ce gate ne juge pas le module ici, la CI le fera.`);
+  const draftDeps = {
+    async draw(previous) {
+      const answer = await client.complete({
+        model: flags.model,
+        system: SCHEMAS_SYSTEM_PROMPT,
+        messages: [{ role: "user", content: buildSchemasPrompt({ featureId, specPath, modulePath, specMarkdown: markdown, block, previous }) }],
+        maxTokens: 16e3,
+        effort: "high"
+      });
+      return { source: extractModuleSource(answer.text), model: answer.model, usage: answer.usage };
+    },
+    async judge(source, attempt) {
+      mkdirSync3(dirname3(moduleAbsolute), { recursive: true });
+      writeFileSync3(moduleAbsolute, source, "utf8");
+      let moduleExports;
+      try {
+        moduleExports = await importProductModule(`${pathToFileURL(moduleAbsolute).href}?attempt=${attempt}`);
+      } catch (thrown) {
+        return { problems: [`le module ne se charge pas : ${thrown instanceof Error ? thrown.message : String(thrown)}`] };
+      }
+      const missing = missingExportsOf(block, Object.keys(moduleExports));
+      if (missing.length > 0) return { problems: missing };
+      const report = checkSpec({ markdown, specPath, generation: project.generation, schemas: modelsOfModule(moduleExports) });
+      const problems = report.problems.map((problem) => `${problem.code} ${String(problem.details?.["path"] ?? "")}: ${problem.cause}`);
+      problems.push(...holeExampleProblems(block, moduleExports), ...writeInputProblems(block, moduleExports), ...resourceCoverageProblems(block, moduleExports));
+      if (problems.length > 0) return { problems };
+      for (const script of gateScripts) {
+        const run = gateRunner({ projectRoot: project.root, script });
+        if (!run.green) return { problems: [`\`pnpm run ${script}\` est rouge :`, ...run.lines.slice(-20)] };
+      }
+      return { problems: [] };
+    },
+    async discard() {
+      rmSync(moduleAbsolute, { force: true });
+    },
+    log: (line) => out.log(`  ${line}`)
+  };
+  const result = await draftSchemas(draftDeps);
+  const summaryPath = deps.summaryPath ?? process.env["GITHUB_STEP_SUMMARY"];
+  if (summaryPath !== void 0 && result.usage.length > 0) {
+    const rows = result.usage.map((usage, index) => `| ${index + 1} | ${result.outcome} | ${usage.model} | ${usage.inputTokens} | ${usage.outputTokens} |`);
+    appendFileSync(summaryPath, `
+### ogygie generate schemas \u2014 ${featureId}
+
+| tentative | issue | mod\xE8le | entr\xE9e | sortie |
+|---|---|---|---|---|
+${rows.join("\n")}
+`, "utf8");
+  }
+  const totalInput = result.usage.reduce((sum, usage) => sum + usage.inputTokens, 0);
+  const totalOutput = result.usage.reduce((sum, usage) => sum + usage.outputTokens, 0);
+  if (result.outcome === "needs-operator") {
+    out.error(
+      formatProblem(
+        ogygieError({
+          code: SCHEMAS_NEEDS_OPERATOR,
+          message: `The first schemas module of "${featureId}" still fails the gates after ${result.attempts} attempts; nothing was written.`,
+          file: modulePath,
+          cause: result.problems.join(" ; "),
+          suggestedFix: "Write the module by hand from the spec (the operator's gesture, D19), or split the block: the listed problems say what the model could not reconcile.",
+          details: { problems: result.problems, attempts: result.attempts, model: result.model }
+        })
+      )
+    );
+    out.error(`ogygie generate schemas \u2014 ${featureId} : l'op\xE9rateur reprend la main (needs-operator) ; ${result.usage.length} appel(s) de mod\xE8le (${totalInput} jetons d'entr\xE9e, ${totalOutput} de sortie).`);
+    return 2;
+  }
+  out.log(`  \xE9crit    ${modulePath}`);
+  if (onMap === void 0) {
+    const raw = structuredClone(project.rawManifest);
+    const features = Array.isArray(raw["features"]) ? raw["features"] : [];
+    raw["features"] = features;
+    const status = entryStatusForSpec(parseSpecDocument(markdown).frontmatter?.status);
+    features.push({ name: featureId, intent: intentForManifest(intentOfSpec(markdown), specPath), folder: featureFolderFor(project, featureId), spec: specPath, routes: [], dbTables: [], dependsOn: [], status });
+    writeFileSync3(join5(project.root, MANIFEST_FILE), serializeManifest(raw), "utf8");
+    out.log(`  ajout\xE9e  ${MANIFEST_FILE} \u203A features[${featureId}] (routes et tables viendront de \`generate\`, status ${status}${status === "skeleton" ? " tant que la spec est draft" : ""})`);
+  }
+  out.log(`ogygie generate schemas \u2014 ${featureId} : module \xE9crit en ${result.attempts} tentative(s) par ${result.model ?? "?"}, ${result.usage.length} appel(s) de mod\xE8le (${totalInput} jetons d'entr\xE9e, ${totalOutput} de sortie) ; commit\xE9 une fois, jamais r\xE9g\xE9n\xE9r\xE9 (D52).`);
+  return 0;
+}
+
+// src/cli/verify-command.ts
+import { performance as performance3 } from "node:perf_hooks";
+
+// ../ogygie-core/src/repo-adapter.ts
+import { readFile as readFileFromDisk, readdir, realpath, stat } from "node:fs/promises";
+import { isAbsolute, join as join6, resolve, sep } from "node:path";
+import { z as z2 } from "zod";
+var RepoFileEntrySchema = z2.object({
+  /** Path relative to the LISTED directory, "/" separated, never absolute. */
+  path: z2.string(),
+  sizeBytes: z2.number().int().nonnegative()
+});
+var NEVER_LISTED = /* @__PURE__ */ new Set(["node_modules"]);
+function isSkippedDirectory(name) {
+  return name.startsWith(".") || NEVER_LISTED.has(name);
+}
+function refusePathOutsideRepo(relativePath, cause) {
+  return throwOgygieError(
+    {
+      code: "PATH_OUTSIDE_REPO",
+      message: "The requested path resolves outside the repo root.",
+      file: relativePath,
+      cause,
+      suggestedFix: "Address a path INSIDE the repo, written relative to its root and without `..`."
+    },
+    400
+  );
+}
+function resolveInsideRoot(rootDir, relativePath) {
+  if (isAbsolute(relativePath)) {
+    refusePathOutsideRepo(relativePath, `"${relativePath}" is an absolute path`);
+  }
+  const root = resolve(rootDir);
+  const absolute = resolve(root, relativePath);
+  if (absolute !== root && !absolute.startsWith(root + sep)) {
+    refusePathOutsideRepo(relativePath, `"${relativePath}" resolves to "${absolute}", outside "${root}"`);
+  }
+  return absolute;
+}
+async function assertRealPathInsideRoot(rootDir, absolute, relativePath) {
+  let realRoot;
+  let realTarget;
+  try {
+    realRoot = await realpath(rootDir);
+    realTarget = await realpath(absolute);
+  } catch {
+    return;
+  }
+  if (realTarget !== realRoot && !realTarget.startsWith(realRoot + sep)) {
+    refusePathOutsideRepo(
+      relativePath,
+      `"${relativePath}" is a symbolic link leading to "${realTarget}", outside "${realRoot}"`
+    );
+  }
+}
+async function listFilesRecursively(absoluteDir, prefix) {
+  let entries;
+  try {
+    entries = await readdir(absoluteDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const entry of entries) {
+    const relativePath = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
+    if (entry.isDirectory()) {
+      if (isSkippedDirectory(entry.name)) continue;
+      files.push(...await listFilesRecursively(join6(absoluteDir, entry.name), relativePath));
+    } else if (entry.isFile()) {
+      const stats = await stat(join6(absoluteDir, entry.name));
+      files.push({ path: relativePath, sizeBytes: stats.size });
+    }
+  }
+  return files.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+}
+async function resolveGitDirs(rootDir) {
+  const dotGit = join6(rootDir, ".git");
+  let gitDir;
+  try {
+    const stats = await stat(dotGit);
+    if (stats.isDirectory()) {
+      gitDir = dotGit;
+    } else {
+      const pointer = (await readFileFromDisk(dotGit, "utf8")).trim();
+      const target = pointer.startsWith("gitdir:") ? pointer.slice("gitdir:".length).trim() : "";
+      if (target === "") return null;
+      gitDir = isAbsolute(target) ? target : resolve(rootDir, target);
+    }
+  } catch {
+    return null;
+  }
+  try {
+    const commonPointer = (await readFileFromDisk(join6(gitDir, "commondir"), "utf8")).trim();
+    return { gitDir, commonDir: isAbsolute(commonPointer) ? commonPointer : resolve(gitDir, commonPointer) };
+  } catch {
+    return { gitDir, commonDir: gitDir };
+  }
+}
+async function readRefSha(dirs, refName) {
+  for (const base of [dirs.gitDir, dirs.commonDir]) {
+    try {
+      const sha = (await readFileFromDisk(join6(base, refName), "utf8")).trim();
+      if (sha !== "") return sha;
+    } catch {
+    }
+  }
+  try {
+    const packed = await readFileFromDisk(join6(dirs.commonDir, "packed-refs"), "utf8");
+    for (const line of packed.split("\n")) {
+      if (line.startsWith("#") || line.startsWith("^")) continue;
+      const [sha, name] = line.trim().split(" ");
+      if (name === refName && sha !== void 0 && sha !== "") return sha;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function createFilesystemRepoAdapter(rootDir) {
+  return {
+    async readFile(relativePath) {
+      const absolute = resolveInsideRoot(rootDir, relativePath);
+      await assertRealPathInsideRoot(rootDir, absolute, relativePath);
+      try {
+        return await readFileFromDisk(absolute, "utf8");
+      } catch (thrown) {
+        return throwOgygieError({
+          code: "REPO_FILE_NOT_FOUND",
+          message: "The requested file cannot be read from the repo.",
+          file: relativePath,
+          cause: `reading "${absolute}" failed: ${thrown instanceof Error ? thrown.message : String(thrown)}`,
+          suggestedFix: "Check the path against what the map declares \u2014 the manifest is the only chart of a repo."
+        });
+      }
+    },
+    async listDirectory(relativePath) {
+      const absolute = resolveInsideRoot(rootDir, relativePath);
+      await assertRealPathInsideRoot(rootDir, absolute, relativePath);
+      return listFilesRecursively(absolute, "");
+    },
+    async exists(relativePath) {
+      const absolute = resolveInsideRoot(rootDir, relativePath);
+      await assertRealPathInsideRoot(rootDir, absolute, relativePath);
+      try {
+        await stat(absolute);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async currentRef() {
+      const dirs = await resolveGitDirs(rootDir);
+      if (dirs === null) return null;
+      let head;
+      try {
+        head = (await readFileFromDisk(join6(dirs.gitDir, "HEAD"), "utf8")).trim();
+      } catch {
+        return null;
+      }
+      if (!head.startsWith("ref:")) return head === "" ? null : head;
+      return readRefSha(dirs, head.slice("ref:".length).trim());
+    }
+  };
+}
+
+// src/cli/verify-command.ts
+async function runVerifyCommand(project, out) {
+  const started = performance3.now();
+  const report = await verifyGeneration({
+    repo: createFilesystemRepoAdapter(project.root),
+    specsFolder: project.specsFolder,
+    scanDirs: project.scanDirs,
+    generation: project.generation,
+    features: project.owners,
+    loadSchemaModels: schemaModelsLoader(project.root),
+    ...project.apiApp === void 0 ? {} : { apiAppPath: project.apiApp.path },
+    ...project.manifest.tenancy === void 0 ? {} : { tenantColumn: project.manifest.tenancy.column },
+    library: loadHolesLibrary(),
+    loadConsumed: (block) => loadConsumedFeatures(project, block)
+  });
+  const elapsedMs = Math.round(performance3.now() - started);
+  if (!report.ok) {
+    for (const problem of report.problems) out.error(formatProblem(problem));
+    out.error(`
+ogygie generate verify \u2014 ${report.problems.length} probl\xE8me(s).`);
+    return 1;
+  }
+  const generatedSpecs = report.specs.filter((spec) => spec.generated);
+  const derivable = generatedSpecs.reduce((sum, spec) => sum + spec.tally.derivable, 0);
+  const holes = generatedSpecs.reduce((sum, spec) => sum + spec.tally.hole, 0);
+  out.log(
+    `ogygie generate verify \u2014 OK en ${elapsedMs} ms, ${report.specs.length} spec(s) v\xE9rifi\xE9es dont ${generatedSpecs.length} g\xE9n\xE9r\xE9e(s) (${derivable} ligne(s) li\xE9e(s), ${holes} port\xE9e(s) par un trou), ${report.generatedFiles.length} fichier(s) g\xE9n\xE9r\xE9(s) dans ${report.perimeter.scanDirs.join(", ")}.`
+  );
+  out.log(`  hors p\xE9rim\xE8tre : ${report.perimeter.outOfScope.join(" ; ")}.`);
+  return 0;
+}
+
+// src/cli/run.ts
+var GENERATE_COMMANDS = ["check", "generate", "verify", "preview", "fill", "schemas"];
+var GENERATE_USAGE = "OGYGIE_GENERATE_USAGE";
+function isCommandName(word) {
+  return word !== void 0 && GENERATE_COMMANDS.includes(word);
+}
+async function runGenerateCommand(input) {
+  const out = { log: input.log, error: input.error };
+  const [command, featureId] = input.argv.filter((argument) => !argument.startsWith("--"));
+  if (!isCommandName(command)) {
+    out.error(
+      formatProblem(
+        ogygieError({
+          code: GENERATE_USAGE,
+          message: `Unknown generate command ${JSON.stringify(command ?? "")}.`,
+          file: null,
+          cause: `expected one of: ${GENERATE_COMMANDS.join(", ")}`,
+          suggestedFix: "Run `ogygie generate check [feature-id]`, `ogygie generate generate <feature-id|--all>`, `ogygie generate verify`, `ogygie generate preview <screen-id>`, `ogygie generate fill <feature-id>` or `ogygie generate schemas <feature-id>`."
+        })
+      )
+    );
+    return 1;
+  }
+  const loaded = loadGenerateProject(input.projectRoot);
+  if (!loaded.ok) {
+    for (const problem of loaded.problems) out.error(formatProblem(problem));
+    out.error(`ogygie generate ${command} \u2014 ${loaded.problems.length} probl\xE8me(s) dans le projet, rien n'est fait.`);
+    return 1;
+  }
+  switch (command) {
+    case "check":
+      return runCheckCommand(loaded.project, featureId, out);
+    case "generate":
+      return input.argv.includes("--all") ? runGenerateAllCommand(loaded.project, out) : runGenerateFeatureCommand(loaded.project, featureId, out);
+    case "verify":
+      return runVerifyCommand(loaded.project, out);
+    case "preview":
+      return runPreviewCommand(loaded.project, featureId, out);
+    case "fill":
+      return runFillCommand(loaded.project, featureId, input.argv, out);
+    case "schemas":
+      return runSchemasCommand(loaded.project, featureId, input.argv, out);
+  }
+}
+export {
+  GENERATE_COMMANDS,
+  GENERATE_USAGE,
+  runGenerateCommand
+};