genesis-compiler 1.9.3 → 1.10.1

package/README.md

@@ -36,7 +36,7 @@ genesis/
 .codex/hooks.json    project-local Codex lifecycle integration
 .claude/settings.json project-local Claude Code lifecycle integration
 .opencode/plugins/   project-local OpenCode lifecycle integration
-.genesis/
+.genesis/            local, git-ignored (`genesis init` adds the ignore lines)
   machine-city.json  derived detailed source and function map
   program-city.json  derived simple subsystem and operation map
 ```
@@ -73,7 +73,7 @@ completely or correctly explains the implementation.
 
 For ready-made applications and the shared new/existing-project workflow, see
 [Project opening and templates](docs/templates.md). Templates belong to Genesis
-and work through the CLI or Vibe64's Preview pane.
+and work through the CLI or any host that integrates Genesis.
 
 Genesis requires Node.js 22 or newer and Git.
 
@@ -459,7 +459,9 @@ extractor provenance. Program City is intentionally smaller: conceptual
 subsystems, Program operations, informational helper maps, and links to their
 implementing source files.
 Both are derived JSON, not receipts, authority, or correctness claims. An
-extractor warning does not stop ordinary work.
+extractor warning does not stop ordinary work. They are rebuilt from the
+working tree, so they are not committed: `genesis init` adds both paths to the
+project's `.gitignore`.
 
 Local package exports whose entry files are excluded from indexing retain their
 declared import paths with unavailable symbol coverage and a diagnostic. They do
@@ -590,8 +592,7 @@ Prompt generation remains available for other agents and explicit tasks:
 genesis prompt
 ```
 
-Give the printed prompt to Vibe64 or another coding agent with access to the
-project. Review ordinary edits through Git.
+Give the printed prompt to any coding agent with access to the project. Review ordinary edits through Git.
 
 An immediate improvement request can be included directly:
 
@@ -705,8 +706,8 @@ selection, ordinary commands resolve the recorded package without another
 flag, but later catalog releases never silently rewrite those contracts.
 Selecting no components is valid. `genesis-stack` currently contains C/C++,
 C#, Go, Java, Kotlin, Node.js, PHP, Python, Ruby, Rust, and Shell, plus Vue,
-MySQL, PostgreSQL, JSKIT, JSKIT database integrations, Laravel, and Laravel
-database integrations.
+MySQL, PostgreSQL, SQLite, the JSKIT, Laravel, Django, Rails, and Spring Boot
+frameworks with their database integrations, Express, and Next.js.
 
 ### Why `genesis/stack.md` is deliberately small
 
@@ -729,7 +730,9 @@ source remains the authority for what actually exists.
 Selection copies operation proposals once. From that point onward, the complete
 project sections in `genesis/stack.md` win: upgrading `genesis-stack` can improve
 guidance for future work but cannot silently change how this application is
-installed, checked, run, or deployed.
+installed, checked, run, or deployed. A section a newer component release
+proposes stays a pending proposal, reported by `genesis check`, until the
+project adopts it with `genesis stack add` or writes its own.
 
 Components may contribute:
 
@@ -771,7 +774,7 @@ add or replace complete project sections when its real scripts differ.
 
 | Project contract | Command or probe | Purpose | Executor |
 | --- | --- | --- | --- |
-| `Workspace setup` | `npm install` | Install development dependencies when `package.json` exists. | The operator or host preparing a workspace, such as Vibe64. |
+| `Workspace setup` | `npm install` | Install development dependencies when `package.json` exists. | The operator or host preparing a workspace. |
 | `Outputs` | `npm run develop` | Start the interactive development web application. | The operator or output host. |
 | `Outputs` readiness | `GET /api/health` → `200` | Decide when the development output is ready; preferred port is `3000`. | The output host. |
 | `Verification` | `npm run verify` | Run the application's finite declared checks. | `genesis verify` executes this one directly. |
@@ -949,7 +952,7 @@ Extra language parsers install on first use, outside the project's dependencies.
 The CLI can also prepare and verify parsers for an offline host; see
 [language parser management](docs/parsers.md).
 `migrate()` updates recognized older Genesis project-file formats and returns
-the resulting structural check for hosts such as Vibe64.
+the resulting structural check for hosts.
 `inspectProjectFormat({ projectRoot })` returns only the format marker's `path`,
 `status`, `projectVersion`, `supportedVersion`, `action`, and diagnostic when
 invalid. It retains Git repository discovery and trust checks, but does not
@@ -1030,7 +1033,7 @@ field: `genesis.collaboration.v1`, `genesis.engineering.v1`,
 `genesis.verification.v1`. A consumer defines any schema embedded inside the
 opaque section body.
 
-A host such as Vibe64 can send the generated prompt to its existing agent:
+A host can send the generated prompt to its existing agent:
 
 ```js
 const work = await generatePrompt({
@@ -1121,7 +1124,7 @@ Initialization creates an empty map without replacing one.
 ## Publishing this repository
 
 Genesis has no release command of its own. `genesis-compiler` and
-`genesis-stack` are released by the Vibe64 Online deploy, which runs the
+`genesis-stack` are released by an external operator workflow, which runs the
 published JSKIT release tool against a clean clone of this repository's `main`.
 Genesis does not depend on that tool.
 

package/docs/prompt-integration.md

@@ -158,7 +158,7 @@ component headings. Exact Program modules, sources, project contracts, indexed
 functions, verification commands, and skills are deferred to `genesis context
 <relevant-path...>`. A new technology request goes through `genesis stack list`
 before selection. For an existing uninitialized codebase it owns
-the adoption recommendation as part of the same portable prompt. A host such as Vibe64 sends this prompt on the
+the adoption recommendation as part of the same portable prompt. A host sends this prompt on the
 first chat turn; it does not recreate the questions or Stack catalog.
 `describe` creates or refreshes the complete Blueprint and useful Program in one
 agent task. The host owns the agent and its interaction. Genesis owns only

package/docs/stack-components.md

@@ -304,9 +304,10 @@ project sections remain authoritative; reconcile any proposed operation against
 the real source. Use the project's pinned compiler invocation when it declares
 `genesis-compiler`: `npm exec --no -- genesis stack add nodejs`.
 
-Before rolling out a catalog that adds operation proposals, operators should
-run read-only project inspection against representative existing projects with
-the candidate compiler and catalog. Arrange explicit reconciliation of affected
-projects before rollout. A format marker alone does not establish compatibility
-with new catalog proposals. Do not repair project contracts through opening,
-status reads or another lazy write path.
+A catalog release that adds an operation proposal does not break existing
+projects. Current-format reads leave a proposed section the project lacks
+pending and outside the effective Stack; `genesis check` and read-only project
+inspection report it as `STACK_SECTION_PROPOSALS_PENDING` with the adoption
+command. The project adopts it explicitly by re-running `genesis stack add` for
+a selected component, or authors its own section. Do not repair project
+contracts through opening, status reads or another lazy write path.

package/docs/templates.md

@@ -12,7 +12,7 @@ Initialization is a decision to use Genesis; it is not evidence that an existing
 application has been described or that an application has been created.
 
 `genesis inspect project --json` is a read-only opening inspection shared by
-the CLI, session guidance, and hosts such as Vibe64:
+the CLI, session guidance, and hosts:
 
 The diagnostics list reports each identical failure once, even when separate
 inspectors encounter it. Distinct failures remain available for repair.
@@ -35,7 +35,8 @@ the two derived Cities, Genesis's Codex/OpenCode integration files, its managed
 skills manifest, the relative Claude discovery link, and the SKILL.md/openai.yaml
 pair for each of the three Genesis workflow skills. Whole `.agents/`, `.codex/`, or `genesis/` directories are not
 exempt. A README, `.gitignore`, application manifest, unfamiliar source file, or
-custom agent tool counts as existing content. Ignored files also count, except
+custom agent tool counts as existing content, except a `.gitignore` containing
+only the two City lines `genesis init` writes. Ignored files also count, except
 installed `node_modules` dependencies. Source recognition does not depend on a
 language detector or an AI model.
 
@@ -64,7 +65,7 @@ genesis templates apply official:jskit/public
 ```
 
 The first-party JSKIT repository is
-[vibe64-dev/seed-jskit](https://github.com/vibe64-dev/seed-jskit). `public` supplies
+the [JSKIT seed repository](https://github.com/vibe64-dev/seed-jskit). `public` supplies
 an adaptive public app; `accounts` adds local accounts, private Home and MySQL.
 Each branch is a complete, current Genesis project with actual application
 source, dependency lockfile, setup/run contracts and focused checks.
@@ -94,12 +95,12 @@ Template Stack components/packages are combined with existing selections;
 existing complete operation sections take precedence. No dependency command,
 database command, agent, or Git commit runs during import. The result reports
 the resolved source repository, branch and commit; no provenance ledger is
-written to the project. Review the ordinary diff and commit or use Vibe64 Save.
+written to the project. Review the ordinary diff and commit it, or save it through the host.
 
 The application declares its actual operations in `genesis/stack.md`. CLI users
 provide the declared runtimes and resources and execute those commands themselves
-or with their agent. Vibe64 can provide runtimes, resource bindings, workspace
-preparation and preview routing through its existing host facilities.
+or with their agent. A host can provide runtimes, resource bindings, workspace
+preparation and preview routing through its own facilities.
 
 ## Supply catalogues
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genesis-compiler",
-  "version": "1.9.3",
+  "version": "1.10.1",
   "type": "module",
   "description": "An agent-independent prompt, multi-language code-index, cleanup, and verification companion with project agent guidance.",
   "repository": {

package/plugins/genesis/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "genesis",
-  "version": "1.9.3",
+  "version": "1.10.1",
   "description": "Makes Codex aware of optional Genesis adoption for existing projects.",
   "author": {
     "name": "Mobily Enterprises"

package/skills/genesis-project/SKILL.md

@@ -105,8 +105,8 @@ tests, and runtime behavior.
 
 `.genesis/machine-city.json` is a derived detailed file/function map.
 `.genesis/program-city.json` is a derived simpler subsystem/operation map.
-Neither is authority or proof; both may be regenerated with the Genesis
-`index` operation.
+Neither is authority or proof; both are git-ignored and may be regenerated
+with the Genesis `index` operation.
 
 ## Implement ordinary local work
 

package/src/index/check.js

@@ -1,7 +1,7 @@
 import { readBlueprint } from './blueprint.js';
 import { readCollaboration } from './collaboration.js';
 import { inspectProjectSkills } from './agent-skills.js';
-import { readStack } from './stack.js';
+import { readStack, stackPendingDiagnostics } from './stack.js';
 import { asDiagnostic } from './errors.js';
 import { gitContext } from './git.js';
 import { inspectProgram } from './program.js';
@@ -124,7 +124,9 @@ export async function checkProject({
     projectRoot: root,
     stackPackages,
   });
+  const pendingStack = stackPendingDiagnostics(stack);
   const diagnostics = [
+    ...pendingStack,
     ...(program.diagnostic ? [program.diagnostic] : []),
     ...skills.diagnostics,
     ...missingResources,
@@ -134,7 +136,7 @@ export async function checkProject({
     }] : []),
   ];
 
-  const guidance = [];
+  const guidance = pendingStack.map(({ message }) => message);
   if (program.status === 'missing') guidance.push('Generate an explanatory Program prompt with genesis prompt --task program.');
   if (engineering.status === 'defaulted') guidance.push('Run genesis init or genesis engineering set focused.v1 to record the default engineering approach.');
   if (program.status === 'invalid') guidance.push('Repair the Program with genesis prompt --task program.');
@@ -147,7 +149,8 @@ export async function checkProject({
   if (verification.status === 'unconfigured') guidance.push('Add project verification commands to genesis/stack.md.');
   guidance.push('Use genesis prompt --task review for a semantic, evidence-based comparison.');
 
-  const needsAttention = program.status === 'missing'
+  const needsAttention = pendingStack.length > 0
+    || program.status === 'missing'
     || engineering.status === 'defaulted'
     || ['missing', 'outdated'].includes(skills.status)
     || missingResources.length > 0

package/src/index/code-index.js

@@ -31,6 +31,11 @@ export const GENESIS_DERIVED_ARTIFACTS = Object.freeze([
   }),
 ]);
 
+// Both Cities are rebuilt from the working tree, so projects ignore them.
+export const GENESIS_DERIVED_ARTIFACTS_GITIGNORE_LINES = Object.freeze(
+  GENESIS_DERIVED_ARTIFACTS.map(({ path: artifactPath }) => `/${artifactPath}`),
+);
+
 function directoryId(value) {
   return `directory:${value || '.'}`;
 }

package/src/index/init.js

@@ -1,10 +1,11 @@
 import { SUBSYSTEMS_PATH, EMPTY_SUBSYSTEMS_SOURCE } from './subsystems.js';
-import { mkdir, writeFile } from 'node:fs/promises';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 
 import { syncProjectSkills } from './agent-skills.js';
 import { BLUEPRINT_SKELETON_SOURCE } from './blueprint.js';
 import { syncAgentIntegrations } from './agent-integrations.js';
+import { GENESIS_DERIVED_ARTIFACTS_GITIGNORE_LINES } from './code-index.js';
 import { COLLABORATION_SKELETON_SOURCE } from './collaboration.js';
 import { ENGINEERING_SKELETON_SOURCE } from './engineering.js';
 import { gitContext } from './git.js';
@@ -35,6 +36,24 @@ async function createIfMissing(projectRoot, relativePath, source) {
   }
 }
 
+/** Append the derived City ignore lines a project's .gitignore lacks. */
+async function ignoreDerivedArtifacts(projectRoot) {
+  const location = path.join(projectRoot, '.gitignore');
+  let source = '';
+  try {
+    source = await readFile(location, 'utf8');
+  } catch (error) {
+    if (!['ENOENT', 'ENOTDIR'].includes(error?.code)) throw error;
+  }
+  const present = new Set(source.split(/\r?\n/u).map((line) => line.trim().replace(/^\//u, '')));
+  const missing = GENESIS_DERIVED_ARTIFACTS_GITIGNORE_LINES
+    .filter((line) => !present.has(line.replace(/^\//u, '')));
+  if (missing.length === 0) return null;
+  const separator = source && !source.endsWith('\n') ? '\n' : '';
+  await writeFile(location, `${source}${separator}${missing.join('\n')}\n`, { mode: 0o666 });
+  return '.gitignore';
+}
+
 export async function initializeProject({
   allowUnresolvedSections = false,
   projectRoot,
@@ -49,6 +68,7 @@ export async function initializeProject({
     createIfMissing(root, COLLABORATION_PATH, COLLABORATION_SKELETON_SOURCE),
     createIfMissing(root, ENGINEERING_PATH, ENGINEERING_SKELETON_SOURCE),
     createIfMissing(root, STACK_PATH, EMPTY_STACK_SOURCE),
+    ignoreDerivedArtifacts(root),
   ])).filter(Boolean);
   await mkdir(path.join(root, PROGRAM_ROOT), { recursive: true });
   const stack = await readStack(root, { allowUnresolvedSections, stackPackages });

package/src/index/project-inspection.js

@@ -4,6 +4,7 @@ import { isDeepStrictEqual } from 'node:util';
 
 import { readBlueprint } from './blueprint.js';
 import { readCollaboration } from './collaboration.js';
+import { GENESIS_DERIVED_ARTIFACTS_GITIGNORE_LINES } from './code-index.js';
 import { GENESIS_CONTRACTS } from './contracts.js';
 import { readEngineering } from './engineering.js';
 import { asDiagnostic } from './errors.js';
@@ -11,7 +12,7 @@ import { gitContext } from './git.js';
 import { inspectProjectFormatAtRoot, projectFormatDiagnostic } from './project-format.js';
 import { inspectProgram } from './program.js';
 import { runGit } from './process.js';
-import { readStack } from './stack.js';
+import { readStack, stackPendingDiagnostics } from './stack.js';
 
 // These are initialization outputs, not whole directories that may contain user code.
 export const GENESIS_BOOTSTRAP_PATHS = Object.freeze([
@@ -34,6 +35,17 @@ export const GENESIS_BOOTSTRAP_PATHS = Object.freeze([
   ]),
 ]);
 const bootstrapPaths = new Set(GENESIS_BOOTSTRAP_PATHS);
+// Genesis creates .gitignore only to ignore its Cities; any other content is the project's.
+async function isBootstrapGitignore(projectRoot, paths) {
+  if (!paths.includes('.gitignore')) return false;
+  try {
+    return await readFile(path.join(projectRoot, '.gitignore'), 'utf8')
+      === `${GENESIS_DERIVED_ARTIFACTS_GITIGNORE_LINES.join('\n')}\n`;
+  } catch (error) {
+    if (['ENOENT', 'ENOTDIR', 'EISDIR'].includes(error?.code)) return false;
+    throw error;
+  }
+}
 
 export async function inspectProjectContent(projectRoot) {
   // Exclude dependency paths in Git before collecting and sorting its output.
@@ -71,7 +83,9 @@ export async function inspectProjectContent(projectRoot) {
       if (!(error instanceof SyntaxError) && !['ENOENT', 'ENOTDIR'].includes(error.code)) throw error;
     }
   }
+  const gitignoreBootstrap = await isBootstrapGitignore(projectRoot, paths);
   const existingPaths = paths.filter((file) => !bootstrapPaths.has(file) &&
+    !(gitignoreBootstrap && file === '.gitignore') &&
     !opencodeBootstrap.includes(file) && !file.split('/').includes('node_modules'));
   return {
     kind: existingPaths.length ? 'existing' : paths.length ? 'bootstrap' : 'empty',
@@ -121,6 +135,9 @@ export async function inspectProject({ projectRoot, stackPackages = [] } = {}) {
     await readFile(path.join(root, 'genesis/stack.md'), 'utf8');
     stack = await readStack(root, { stackPackages });
     result.stackComponents = stack.components.map(({ id }) => id);
+    // Unadopted component proposals are offered, never a reason to repair.
+    const pending = stackPendingDiagnostics(stack);
+    if (pending.length) result.warnings = pending;
   } catch (error) { result.diagnostics.push(asDiagnostic(error)); }
   for (const read of [readCollaboration, readEngineering]) {
     try { await read(root); } catch (error) { result.diagnostics.push(asDiagnostic(error)); }

package/src/index/stack-project-contracts.js

@@ -94,17 +94,25 @@ export function stackPieceContractNames(piece) {
   ];
 }
 
-function contractSections({ components, knownSectionNames, sections }) {
+function contractSections({ adoptProposals, components, knownSectionNames, sections }) {
   const genesisContracts = componentGenesisContracts(components, sections);
   const materializedSections = [];
+  const pendingSections = [];
   const projectLines = new Map();
+  const propose = (name, lines) => {
+    if (!adoptProposals) {
+      pendingSections.push({ name, lines });
+      return;
+    }
+    projectLines.set(name, lines);
+    materializedSections.push(name);
+  };
 
   for (const name of PROJECT_CONTRACT_NAMES) {
     if (sections.has(name)) {
       projectLines.set(name, trimStackSectionLines(sections.get(name)));
     } else if (genesisContracts.has(name)) {
-      projectLines.set(name, genesisContracts.get(name));
-      materializedSections.push(name);
+      propose(name, genesisContracts.get(name));
     }
   }
 
@@ -119,8 +127,9 @@ function contractSections({ components, knownSectionNames, sections }) {
       unresolvedSections.push({ name: extension.name, diagnostic });
       continue;
     }
-    projectLines.set(extension.name, trimStackSectionLines(extension.lines));
-    if (!sections.has(extension.name)) materializedSections.push(extension.name);
+    const lines = trimStackSectionLines(extension.lines);
+    if (sections.has(extension.name)) projectLines.set(extension.name, lines);
+    else propose(extension.name, lines);
   }
 
   return {
@@ -130,6 +139,7 @@ function contractSections({ components, knownSectionNames, sections }) {
       .filter(([name]) => !PROJECT_CONTRACT_NAMES.includes(name))
       .map(([name, lines]) => ({ name, lines })),
     materializedSections,
+    pendingSections,
     projectContracts: [...projectLines].map(([name, lines]) => ({ name, lines })),
     resourceLines: projectLines.get('Resources') ?? null,
     unresolvedSections,
@@ -149,34 +159,40 @@ function unresolvedSectionsError(unresolvedSections) {
   );
 }
 
+/** Adopt every selected proposal missing from the project (add and migration). */
 export function materializeStackProjectContracts(options) {
-  return contractSections(options);
+  return contractSections({ ...options, adoptProposals: true });
 }
 
 /**
- * Require every selected proposal to be project-owned. A competing proposal
- * is a project decision; only the add operation that reports it may continue
- * without it.
+ * Read only project-owned contracts. A proposal the project has not adopted,
+ * such as a section a newer component release introduced, stays pending and
+ * outside the effective Stack. A competing proposal is a project decision; only
+ * the operations that report it may continue without it.
  */
-export function requireMaterializedStackProjectContracts({
+export function projectOwnedStackContracts({
   allowUnresolvedSections = false,
   ...options
 }) {
-  const result = contractSections(options);
-  if (result.materializedSections.length > 0) {
-    const headings = result.materializedSections.map((name) => `\`## ${name}\``);
-    throw new GenesisError(
-      'STACK_PROJECT_CONTRACTS_INCOMPLETE',
-      `Selected Stack components require project-owned contracts missing from genesis/stack.md: ${headings.join(', ')}. Run \`genesis migrate\` for an older project or re-run the confirmed \`genesis stack add\` operation for a current project.`,
-      { sections: result.materializedSections },
-    );
-  }
+  const result = contractSections({ ...options, adoptProposals: false });
   if (!allowUnresolvedSections && result.unresolvedSections.length > 0) {
     throw unresolvedSectionsError(result.unresolvedSections);
   }
   return result;
 }
 
+/** One warning naming the proposals a project has not adopted yet. */
+export function pendingStackSectionsDiagnostic(pendingSections, components) {
+  if (pendingSections.length === 0) return null;
+  const headings = pendingSections.map(({ name }) => `\`## ${name}\``).join(', ');
+  const ids = components.map(({ id }) => id).join(' ');
+  return {
+    code: 'STACK_SECTION_PROPOSALS_PENDING',
+    message: `Selected Stack components propose sections missing from genesis/stack.md: ${headings}. They are not part of the project Stack until adopted. Review them against the application, then adopt them with \`genesis stack add ${ids}\` or author the sections yourself.`,
+    details: { sections: pendingSections.map(({ name, lines }) => ({ name, lines })) },
+  };
+}
+
 function contractBlocks(projectContracts, hasDecisions) {
   if (projectContracts.length === 0) {
     if (hasDecisions) return ['No other operation contract was proposed by these components.'];

package/src/index/stack.js

@@ -24,7 +24,8 @@ import {
 import {
   materializeStackProjectContracts,
   renderStackPreparationPrompt,
-  requireMaterializedStackProjectContracts,
+  pendingStackSectionsDiagnostic,
+  projectOwnedStackContracts,
   stackPieceContractNames,
 } from './stack-project-contracts.js';
 import { parseStackVerificationLines } from './stack-verification.js';
@@ -332,7 +333,7 @@ async function readStackWithContractMode(projectRoot, {
   })).map((piece) => customizePiece(projectRoot, piece)));
   const projectContracts = (allowComponentContracts
     ? materializeStackProjectContracts
-    : requireMaterializedStackProjectContracts)({
+    : projectOwnedStackContracts)({
     allowUnresolvedSections,
     components,
     knownSectionNames: STACK_SECTIONS,
@@ -396,6 +397,7 @@ async function readStackWithContractMode(projectRoot, {
     environmentFiles,
     extensions,
     projectContracts: projectContracts.projectContracts,
+    pendingSections: projectContracts.pendingSections,
     ...(allowUnresolvedSections ? { unresolvedSections: projectContracts.unresolvedSections } : {}),
     resources,
     guidance: composedProse(components, 'guidance'),
@@ -422,7 +424,10 @@ export function readStack(projectRoot, { allowUnresolvedSections = false, stackP
 export function stackDecisionResult(stack) {
   const unresolvedSections = stack.unresolvedSections || [];
   return {
-    diagnostics: unresolvedSections.map(({ diagnostic }) => diagnostic),
+    diagnostics: [
+      ...unresolvedSections.map(({ diagnostic }) => diagnostic),
+      ...stackPendingDiagnostics(stack),
+    ],
     prompt: renderStackPreparationPrompt({
       components: stack.components,
       projectContracts: stack.projectContracts,
@@ -431,6 +436,12 @@ export function stackDecisionResult(stack) {
   };
 }
 
+/** Warnings for component proposals the project has not adopted. */
+export function stackPendingDiagnostics(stack) {
+  const diagnostic = pendingStackSectionsDiagnostic(stack.pendingSections || [], stack.components);
+  return diagnostic ? [diagnostic] : [];
+}
+
 export function readLegacyStack(projectRoot, { stackPackages = [] } = {}) {
   return readStackWithContractMode(projectRoot, {
     allowComponentContracts: true,

package/src/index/template-project.js

@@ -91,7 +91,8 @@ export async function applyTemplate({ projectRoot, templateId, stackPackages = [
     const { templates } = await listTemplates({ projectRoot: root, stackPackages, templateSources });
     const template = resolveTemplate(templates, String(templateId || ''));
     const preserved = new Map();
-    for (const name of GENESIS_BOOTSTRAP_PATHS) preserved.set(name, await existingFile(root, name));
+    // A seedable project's .gitignore can only be the one init wrote for the Cities.
+    for (const name of [...GENESIS_BOOTSTRAP_PATHS, '.gitignore']) preserved.set(name, await existingFile(root, name));
     const snapshot = await readGitSnapshot(template);
     stagingRoot = await mkdtemp(path.join(os.tmpdir(), 'genesis-template-project-'));
     await runGit(stagingRoot, ['init', '--quiet']);
@@ -109,7 +110,8 @@ export async function applyTemplate({ projectRoot, templateId, stackPackages = [
       throw new GenesisError('TEMPLATE_STACK_MISMATCH', 'The template Stack does not contain its advertised technology.');
     }
     for (const [name, previous] of preserved) {
-      if (previous === null || name.startsWith('.genesis/')) continue;
+      // Initialization below re-adds the City ignore lines to the template's own .gitignore.
+      if (previous === null || name.startsWith('.genesis/') || name === '.gitignore') continue;
       const { contents, linkTarget } = previous;
       if (name === 'genesis/blueprint.md' && !parseBlueprintSource(contents.toString('utf8')).description) continue;
       if (name === 'genesis/subsystems.md' && (await inspectSubsystems({ projectRoot: root })).status === 'empty') continue;