genesis-compiler 1.2.12 → 1.2.13

package/prompts/adopt.txt

@@ -28,20 +28,11 @@ relevant existing-application migration reference. Apply all SELECTED STACK
 ADOPTION GUIDANCE. Component defaults describe current foundations and are
 hypotheses until they match this source. They do not upgrade an older project.
 
-Build one evidence-backed import inventory covering, where applicable:
-
-- package manager, install/build commands, runtimes, workdirs, and generated
-  prerequisites;
-- environment files, public defaults, required resources, and alternative
-  environment names, without reading or returning secret values;
-- database engine, migration ownership and ledger, preparation command,
-  idempotent seed behavior, and fresh versus existing-database safety;
-- every long-running target's exact argv, host/port placeholders, URL path,
-  readiness predicate, and shutdown ownership;
-- application-owned Preview identity helper, protocol, supported selectors,
-  environment names, runtime, and timeout when authenticated preview exists;
-- concrete verification commands, browser-test assumptions, and deployment
-  preparation/build/migration/serve/readiness declarations.
+Build one evidence-backed import inventory covering the selected technologies,
+public environment/resource declarations, concrete Verification commands, and
+every consumer-owned Stack section supported by direct source evidence. Use the
+selected technology skill and the section's declared schema for any
+consumer-specific detail; do not invent a generic operational grammar.
 
 Translate observed contracts into exact project-owned Stack sections whenever
 the selected components' defaults differ. A project section replaces the
@@ -51,18 +42,18 @@ Genesis; never add a permanent legacy reader or shim. Do not delete an old
 manifest until all of its live facts have been accounted for.
 
 The resulting project contract may therefore own complete `## Resources`,
-`## Environment defaults`, `## Environment files`, `## Workspace setup`,
-`## Commands`, `## Launch`, and `## Deployment` sections. Treat these as one
-operational inventory: do not preserve setup while silently dropping its
-resource, launch, readiness, identity, verification, or deployment counterpart.
+`## Environment defaults`, `## Environment files`, `## Verification`, and any
+evidence-backed consumer-owned opaque sections. Treat these as one inventory:
+preserve every observed contract without asking Genesis to infer or validate a
+consumer's private semantics.
 
 Create the non-technical Blueprint and useful subsystem-oriented Program from
 current source and tests. Do not cite archive internals or Git object storage as
 implementation source; Program sources must be current Git-visible files.
 
-Run `genesis check` only for structural validation. Missing environment values,
-workspace markers, commands, helpers, seeds, or readiness evidence are honest
-import findings, not permission to invent or execute them. Finish with a clear
-inventory of what was imported, what remains unconfigured or blocked, and what
-would require a separately approved implementation port. Never claim the
+Run `genesis check` only for structural validation. Missing environment inputs,
+Verification commands, or evidence required by a consumer-owned contract are
+honest import findings, not permission to invent or execute them. Finish with a
+clear inventory of what was imported, what remains unconfigured or blocked, and
+what would require a separately approved implementation port. Never claim the
 project is ready merely because Stack components were selected.

package/prompts/start.txt

@@ -14,10 +14,9 @@ If the product direction becomes clear while Stack is still empty, do not end
 the turn after only writing or summarizing the Blueprint: present the relevant
 Stack choices in that same turn and ask the user to select one explicitly.
 This opening turn owns product direction and Stack selection, not final
-verification. Do not run `genesis verify` before implementation has created
-the selected technology's workspace substrate. If structural validation is
-useful, run `genesis check`; treat missing workspace markers as unconfigured,
-not as an implementation failure.
+verification. Do not run `genesis verify` before implementation exists. If
+structural validation is useful, run `genesis check`; consumer-owned operations
+remain governed by their own tools and must not be inferred here.
 
 When `projectKind` is `existing`, ask what the user wants to understand or
 change. Use the current Blueprint, Stack, Program, and code index when present.
@@ -25,14 +24,13 @@ If the existing implementation is not yet explained, recommend the Genesis
 description/adoption path instead of pretending its intent is known.
 When an existing implementation has no selected Stack yet, inspect its actual
 package scripts, build files, setup commands, server entrypoint, and readiness
-route before recording the user's technology choice. Component Workspace setup
-and Launch declarations describe that component's current foundation; selecting
-the component does not port an older implementation to it. If the existing
-commands differ, add exact project-owned `## Workspace setup` and `## Launch`
-sections that replace the component defaults and match the code that exists.
-Never report the inherited setup or Launch as usable merely because the
-component was selected, and never add compatibility implementation without the
-user asking for a port.
+route before recording the user's technology choice. Consumer-owned sections
+declared by a component describe that component's current operational
+foundation; selecting the component does not port an older implementation to
+it. If the existing facts differ, add exact project-owned replacements using
+the consumer's current schema and the code that exists. Never report an
+inherited operation as usable merely because the component was selected, and
+never add compatibility implementation without the user asking for a port.
 
 When `projectKind` is `existing-uninitialized`, ask what the user wants to
 understand or change and strongly recommend preparing the existing project for

package/prompts/work.txt

@@ -8,14 +8,13 @@ Before adding a helper or public operation, query `genesis index <name-or-path>`
 and reuse an existing function when it already owns the behavior.
 
 This is the implementation turn. Do not edit the Blueprint, Program, or
-`.genesis/`; the separate reconciliation turn owns explanatory changes. Keep an
-exact Stack `## Launch` declaration aligned when the implementation establishes
-or intentionally changes how the project is started or how a preview host may request
-an application preview identity. Declare only command paths, protocol, supported
-identity types, environment variable names, runtimes, and timeout policy; never
-put an environment value or secret in Stack. Never invent missing external-resource
-values. Preserve useful work and report a genuinely missing resource instead of
-constructing a parallel fallback.
+`.genesis/`; the separate reconciliation turn owns explanatory changes. Keep
+applicable consumer-owned Stack sections aligned when the implementation changes
+facts governed by those contracts. Follow the selected technology skill and the
+section's own schema; Genesis only transports the section and does not interpret
+or execute it. Never put an environment value or secret in Stack. Never invent
+missing external-resource values. Preserve useful work and report a genuinely
+missing resource instead of constructing a parallel fallback.
 
 Run focused checks when useful. Summarize files changed, checks actually run,
 and anything still requiring attention.
@@ -24,5 +23,5 @@ If no Stack components are selected, continue the project-opening
 conversation instead of guessing a technology. Use `genesis stack list` for
 the current catalog, present relevant choices, wait for an explicit decision,
 and add the selection with `genesis stack add <piece...>` before relying on
-technology-specific setup or launch behavior. Do not end after only updating
+technology-specific operations. Do not end after only updating
 or summarizing the Blueprint while the Stack remains empty.

package/src/cli.js

@@ -9,13 +9,10 @@ import {
   getContext,
   indexCodebase,
   initialize,
-  inspectDeployment,
   inspectEnvironment,
-  inspectLaunch,
-  inspectWorkspaceSetup,
+  inspectStackSection,
   installCodex,
   listStackPieces,
-  prepareWorkspace,
   verify,
 } from './index.js';
 import {
@@ -35,8 +32,8 @@ const USAGE = `Usage:
   genesis stack add <piece...>
   genesis context <path...>
   genesis index [function-or-path...]
-  genesis inspect <workspace|environment|launch|deployment>
-  genesis prepare
+  genesis inspect environment
+  genesis inspect section <name>
   genesis prompt [request...]
   genesis prompt --task <start|adopt|work|deslop|program|blueprint|describe|review> [request...]
   genesis verify
@@ -54,7 +51,7 @@ prompt to the agent you already use. Review all edits through the ordinary Git
 diff, then run genesis verify for the Stack's concrete checks.
 `;
 
-const COMMANDS = new Set(['adopt', 'check', 'codex', 'context', 'hook', 'index', 'init', 'inspect', 'prepare', 'prompt', 'stack', 'verify']);
+const COMMANDS = new Set(['adopt', 'check', 'codex', 'context', 'hook', 'index', 'init', 'inspect', 'prompt', 'stack', 'verify']);
 
 function parseCommand(argv) {
   if (argv.length === 0 || argv.includes('--help') || argv.includes('-h') || argv[0] === 'help') {
@@ -105,10 +102,12 @@ function parseCommand(argv) {
   } else if (command === 'context' && operands.length === 0) {
     fail('CONTEXT_PATH_REQUIRED', 'Command context requires at least one project path.');
   } else if (command === 'inspect') {
-    if (operands.length !== 1 || !['workspace', 'environment', 'launch', 'deployment'].includes(operands[0])) {
+    const ordinaryInspection = operands.length === 1 && operands[0] === 'environment';
+    const sectionInspection = operands.length >= 2 && operands[0] === 'section';
+    if (!ordinaryInspection && !sectionInspection) {
       fail(
         'CLI_INSPECT_TARGET_REQUIRED',
-        'Command inspect requires exactly one of: workspace, environment, launch, deployment.',
+        'Command inspect requires environment or section <name>.',
       );
     }
   } else if (command === 'hook' && (operands.length !== 1 || !['begin', 'discover', 'end', 'session', 'stop'].includes(operands[0]))) {
@@ -134,10 +133,8 @@ function writeCheck(result) {
   line(process.stdout, `Stack: ${result.stack}`);
   line(process.stdout, `Agent Skills: ${result.skills}`);
   line(process.stdout, `Program: ${result.program}`);
-  line(process.stdout, `Workspace setup: ${result.workspaceSetup}`);
   line(process.stdout, `Environment: ${result.environment}`);
-  line(process.stdout, `Launch: ${result.launch}`);
-  line(process.stdout, `Deployment: ${result.deployment}`);
+  line(process.stdout, `Stack extensions: ${result.extensions}`);
   line(process.stdout, `Resource inputs: ${result.resources}`);
   line(process.stdout, `Verification: ${result.verification}`);
   namedItems('Program files', result.programFiles);
@@ -152,21 +149,14 @@ function writeInspection(result) {
   line(process.stdout, `${title}: ${result.status}`);
   namedItems('Components', result.components);
   namedItems('Runtimes', result.runtimeRequirements);
-  if (result.inspection === 'workspace') {
-    namedItems('Preparation steps', result.steps.map(({ label, argv, workdir }) => (
-      `${label} in ${workdir}: ${argv.join(' ')}`
-    )));
-  } else if (result.inspection === 'environment') {
+  if (result.inspection === 'environment') {
     namedItems('Public defaults', result.environmentDefaults.map(({ name, value }) => `${name}=${value}`));
     namedItems('Environment files', result.files.map(({ format, path: filePath }) => `${format}: ${filePath}`));
-  } else if (result.inspection === 'launch') {
-    namedItems('Targets', result.targets.map(({ id, label, urlPath, steps }) => (
-      `${id} (${label}) ${urlPath}: ${steps.map(({ argv }) => argv.join(' ')).join(' -> ')}`
-    )));
-  } else {
-    namedItems('Deployment steps', result.steps.map(({ label, argv }) => `${label}: ${argv.join(' ')}`));
+  } else if (result.inspection === 'section') {
+    if (result.source) line(process.stdout, `Source: ${result.source}`);
+    if (result.content) process.stdout.write(`${result.content}\n`);
   }
-  namedItems('Resources', result.resources.map(({ component, resource }) => (
+  namedItems('Resources', result.resources?.map(({ component, resource }) => (
     `${resource.id} (${resource.kind}, ${component})`
   )));
   for (const item of result.diagnostics || []) line(process.stdout, `${item.code}: ${item.message}`);
@@ -215,19 +205,6 @@ function writeResult(command, result) {
     writeInspection(result);
     return;
   }
-  if (command === 'prepare') {
-    if (result.summary) line(process.stdout, result.summary);
-    namedItems('Commands', result.commands?.map(({ label, argv }) => `${label}: ${argv.join(' ')}`));
-    for (const item of result.diagnostics || []) {
-      line(process.stdout, `${item.code}: ${item.message}`);
-      for (const field of ['stdout', 'stderr']) {
-        const output = item.details?.[field]?.trim();
-        if (output) line(process.stdout, output);
-      }
-    }
-    line(process.stdout, `prepare: ${result.status}`);
-    return;
-  }
   if (command === 'hook') {
     if (['discover', 'session'].includes(result.kind) && result.output) line(process.stdout, result.output);
     else if (result.kind === 'stop') line(process.stdout, JSON.stringify(result.output));
@@ -243,7 +220,7 @@ function writeResult(command, result) {
   }
   if (result.summary) line(process.stdout, result.summary);
   namedItems('Changed files', result.changedFiles);
-  namedItems('Commands', result.commands?.map(({ label, argv }) => `${label}: ${argv.join(' ')}`));
+  namedItems('Verification commands', result.commands?.map(({ label, argv }) => `${label}: ${argv.join(' ')}`));
   for (const item of result.diagnostics || []) {
     line(process.stdout, `${item.code}: ${item.message}`);
     for (const field of ['stdout', 'stderr']) {
@@ -294,27 +271,22 @@ async function execute({ command, operands, options }, { signal } = {}) {
   if (command === 'context') return getContext({ paths: operands, projectRoot, stackPackages });
   if (command === 'index') return indexCodebase({ projectRoot, queries: operands, stackPackages });
   if (command === 'inspect') {
-    const inspections = {
-      workspace: inspectWorkspaceSetup,
-      environment: inspectEnvironment,
-      launch: inspectLaunch,
-      deployment: inspectDeployment,
-    };
+    if (operands[0] === 'section') {
+      return {
+        inspection: 'section',
+        ...await inspectStackSection({
+          name: operands.slice(1).join(' '),
+          projectRoot,
+          stackPackages,
+        }),
+      };
+    }
+    const inspections = { environment: inspectEnvironment };
     return {
       inspection: operands[0],
       ...await inspections[operands[0]]({ projectRoot, stackPackages }),
     };
   }
-  if (command === 'prepare') {
-    return prepareWorkspace({
-      projectRoot,
-      signal,
-      stackPackages,
-      onEvent: (event) => {
-        if (!options.json) line(process.stderr, event.message);
-      },
-    });
-  }
   if (command === 'hook') {
     if (operands[0] === 'discover') {
       return { kind: 'discover', ...await codexAdoptionRecommendation({ projectRoot }) };
@@ -356,7 +328,7 @@ export async function runCli(argv = process.argv.slice(2)) {
       return 0;
     }
     options = parsed.options;
-    const finiteCommand = ['prepare', 'verify'].includes(parsed.command);
+    const finiteCommand = parsed.command === 'verify';
     if (finiteCommand) {
       process.once('SIGINT', abort);
       process.once('SIGTERM', abort);

package/src/index/check.js

@@ -8,9 +8,6 @@ import { inspectVerification } from './project-state.js';
 import { missingStackResources } from './stack-preflight.js';
 import { withStackEnvironmentDefaults } from './stack-environment-defaults.js';
 import { inspectProjectEnvironment } from './environment-files.js';
-import { inspectProjectLaunch } from './launch.js';
-import { inspectProjectDeployment } from './deployment.js';
-import { inspectWorkspaceSetupForStack } from './workspace-setup.js';
 
 function invalidResult(area, error) {
   return {
@@ -19,10 +16,8 @@ function invalidResult(area, error) {
     stack: area === 'stack' ? 'invalid' : 'unknown',
     skills: area === 'skills' ? 'invalid' : 'unknown',
     program: 'unknown',
-    workspaceSetup: 'unknown',
     environment: 'unknown',
-    launch: 'unknown',
-    deployment: 'unknown',
+    extensions: 'unknown',
     resources: 'unknown',
     verification: 'unknown',
     programFiles: [],
@@ -73,18 +68,17 @@ export async function checkProject({
     resources: stack.resources,
   });
   const verification = await inspectVerification({ projectRoot: root, stack });
-  const [workspaceSetup, projectEnvironment, launch, deployment] = await Promise.all([
-    inspectWorkspaceSetupForStack({ projectRoot: root, stack }),
-    inspectProjectEnvironment({ environment, projectRoot: root, stackPackages }),
-    inspectProjectLaunch({ environment, projectRoot: root, stackPackages }),
-    inspectProjectDeployment({ projectRoot: root, stackPackages }),
-  ]);
+  const projectEnvironment = await inspectProjectEnvironment({
+    environment,
+    projectRoot: root,
+    stackPackages,
+  });
+  const extensionDiagnostics = stack.extensions.flatMap(({ diagnostics }) => diagnostics);
   const diagnostics = [
     ...(program.diagnostic ? [program.diagnostic] : []),
     ...skills.diagnostics,
     ...missingResources,
-    ...workspaceSetup.diagnostics.filter(({ code }) => code !== 'STACK_WORKSPACE_SETUP_WAITING'),
-    ...deployment.diagnostics,
+    ...extensionDiagnostics,
     ...(verification.status === 'invalid' ? [{
       code: 'VERIFICATION_EVIDENCE_INVALID',
       message: 'Saved verification evidence is malformed.',
@@ -99,8 +93,7 @@ export async function checkProject({
   if (missingResources.length > 0) {
     guidance.push(`${missingResources.map(({ message }) => message).join(' ')} Prompt generation remains available.`);
   }
-  if (workspaceSetup.status === 'blocked') guidance.push('Repair the project Workspace setup declaration.');
-  if (deployment.status === 'blocked') guidance.push('Repair the project Deployment declaration.');
+  if (extensionDiagnostics.length > 0) guidance.push('Resolve the competing consumer-owned Stack sections.');
   if (['missing', 'stale'].includes(verification.status)) guidance.push('Run genesis verify to refresh concrete evidence.');
   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.');
@@ -108,8 +101,7 @@ export async function checkProject({
   const needsAttention = program.status === 'missing'
     || skills.status === 'missing'
     || missingResources.length > 0
-    || workspaceSetup.status === 'blocked'
-    || deployment.status === 'blocked'
+    || extensionDiagnostics.length > 0
     || ['missing', 'stale', 'unconfigured'].includes(verification.status);
 
   return {
@@ -120,10 +112,10 @@ export async function checkProject({
     stack: 'valid',
     skills: skills.status,
     program: program.status,
-    workspaceSetup: workspaceSetup.status,
     environment: projectEnvironment.status,
-    launch: launch.status,
-    deployment: deployment.status,
+    extensions: extensionDiagnostics.length > 0
+      ? 'blocked'
+      : stack.extensions.length > 0 ? 'ready' : 'unconfigured',
     resources: missingResources.length > 0 ? 'missing' : 'inputs-present',
     verification: verification.status,
     programFiles: program.files,

package/src/index/context.js

@@ -115,9 +115,9 @@ export async function contextForProjectPaths({ paths, projectRoot, stackPackages
     '',
     '## Verification',
     '',
-    ...(stack.commands.length === 0
+    ...(stack.verificationCommands.length === 0
       ? ['No verification commands are configured.']
-      : stack.commands.map(({ label, argv }) => `- ${label}: ${argv.map((value) => `\`${value}\``).join(' ')}`)),
+      : stack.verificationCommands.map(({ label, argv }) => `- ${label}: ${argv.map((value) => `\`${value}\``).join(' ')}`)),
     '',
   ].join('\n');
   return {
@@ -125,7 +125,7 @@ export async function contextForProjectPaths({ paths, projectRoot, stackPackages
     paths: targets,
     modules: moduleSources.map(({ source: _source, ...module }) => module),
     components: stack.components.map(({ id }) => id),
-    verificationCommands: stack.commands.map(({ label, argv }) => ({ label, argv })),
+    verificationCommands: stack.verificationCommands.map(({ label, argv }) => ({ label, argv })),
     warnings: [
       ...(program.diagnostic ? [program.diagnostic] : []),
       ...projectSkills.diagnostics,

package/src/index/contracts.js

@@ -1,8 +1,6 @@
 export const GENESIS_CONTRACTS = Object.freeze({
-  deployment: 'genesis.deployment.v2',
   derivedArtifacts: 'genesis.derived-artifacts.v1',
   environment: 'genesis.environment.v1',
-  launch: 'genesis.launch.v1',
+  stackSection: 'genesis.stack-section.v1',
   verification: 'genesis.verification.v1',
-  workspaceSetup: 'genesis.workspace-setup.v1',
 });

package/src/index/project-state.js

@@ -9,7 +9,7 @@ const SCHEMA_VERSION = 1;
 const HASH = /^sha256:[0-9a-f]{64}$/u;
 
 function commandRecords(stack) {
-  return stack.commands.map(({ label, argv }) => ({ label, argv }));
+  return stack.verificationCommands.map(({ label, argv }) => ({ label, argv }));
 }
 
 async function codebaseHash(projectRoot) {
@@ -52,7 +52,7 @@ async function readEvidence(projectRoot) {
 }
 
 export async function inspectVerification({ projectRoot, stack }) {
-  if (stack.commands.length === 0) return { status: 'unconfigured', evidence: null };
+  if (stack.verificationCommands.length === 0) return { status: 'unconfigured', evidence: null };
   const saved = await readEvidence(projectRoot);
   if (saved.status !== 'recorded') return saved;
   const expected = {

package/src/index/prompt.js

@@ -390,7 +390,7 @@ export async function generateProjectPrompt({
     resourceInputs: missing.length > 0
       ? { status: 'missing', diagnostics: missing }
       : { status: 'present' },
-    verificationCommands: stack.commands.map(({ label, argv }) => ({ label, argv })),
+    verificationCommands: stack.verificationCommands.map(({ label, argv }) => ({ label, argv })),
     agentSkills: { status: projectSkills.status },
     codeIndex: codeIndexContext(index),
   };

package/src/index/stack-catalog.js

@@ -152,8 +152,7 @@ export async function listStackCatalogPieces(options = {}) {
       cityRegions: piece.cityRegions,
       indexers: piece.indexers,
       environmentDefaults: piece.environmentDefaults,
-      launchTargets: piece.launchTargets.map(({ id }) => id),
-      workspaceSetup: piece.workspaceSetupSteps,
+      extensions: piece.extensions.map(({ name }) => name),
       skill: piece.skill === null ? null : piece.skill.path,
       stackPackage: piece.stackPackage,
       resources: piece.resources.map(({ id }) => id),

package/src/index/stack-piece.js

@@ -1,16 +1,29 @@
 import { GenesisError } from './errors.js';
-import { parseStackCommandLines } from './stack-command.js';
 import { parseStackCityPresentationLines } from './stack-city-presentation.js';
-import { parseStackDeploymentLines } from './stack-deployment.js';
 import { parseStackEnvironmentDefaultLines } from './stack-environment-defaults.js';
 import { parseStackEnvironmentFileLines } from './stack-environment-files.js';
-import { parseStackLaunchLines } from './stack-launch.js';
-import { parseStackWorkspaceSetupLines } from './stack-workspace-setup.js';
+import { opaqueStackSections } from './stack-section.js';
+import { parseStackVerificationLines } from './stack-verification.js';
 import { normalizeSource } from './utils.js';
 
 const STACK_PIECE_ID_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
 const STACK_CUSTOMIZATION_TITLE = /^# Stack customization: ([a-z0-9]+(?:-[a-z0-9]+)*)\s*$/u;
 const STACK_CUSTOMIZATION_FIELDS = new Set(['Description', 'Guidance', 'Adoption', 'Deslop']);
+const STACK_PIECE_SECTIONS = new Set([
+  'Adoption',
+  'City regions',
+  'Conflicts',
+  'Description',
+  'Deslop',
+  'Environment defaults',
+  'Environment files',
+  'Guidance',
+  'Indexers',
+  'Requires',
+  'Resources',
+  'Skill',
+  'Verification',
+]);
 
 export function normalizeStackPieceId(value, {
   code = 'STACK_PIECE_INVALID',
@@ -214,7 +227,8 @@ function resources(all, piecePath) {
 
 /**
  * Stack pieces are guidance, not a second programming language. Genesis reads
- * only the few sections it uses and deliberately ignores explanatory sections.
+ * only its own small grammar and preserves every other section as opaque data
+ * for the consumer that named it.
  */
 export function parseStackPieceSource(value, {
   expectedId,
@@ -231,7 +245,10 @@ export function parseStackPieceSource(value, {
   const adoption = textSection(all, 'Adoption');
   const deslop = textSection(all, 'Deslop');
   if (!description) invalid(piecePath, 'Stack piece needs Description.');
-  const commands = parseStackCommandLines(all.get('Commands') || [], { path: piecePath });
+  const verificationCommands = parseStackVerificationLines(
+    all.get('Verification') || [],
+    { path: piecePath },
+  );
   const cityPresentation = parseStackCityPresentationLines(
     all.has('City regions') ? all.get('City regions') : undefined,
     { path: piecePath },
@@ -244,17 +261,6 @@ export function parseStackPieceSource(value, {
     all.has('Environment files') ? all.get('Environment files') : undefined,
     { path: piecePath },
   );
-  const launch = parseStackLaunchLines(all.has('Launch') ? all.get('Launch') : undefined, {
-    path: piecePath,
-  });
-  const deployment = parseStackDeploymentLines(
-    all.has('Deployment') ? all.get('Deployment') : undefined,
-    { path: piecePath },
-  );
-  const workspaceSetup = parseStackWorkspaceSetupLines(
-    all.has('Workspace setup') ? all.get('Workspace setup') : undefined,
-    { path: piecePath },
-  );
   return {
     id,
     description,
@@ -265,14 +271,12 @@ export function parseStackPieceSource(value, {
     indexers: idList(all, 'Indexers', piecePath),
     skill: skill(all, piecePath),
     resources: resources(all, piecePath),
-    commands: commands.map(({ line: _line, ...command }) => command),
+    verificationCommands: verificationCommands.map(({ line: _line, ...command }) => command),
     cityExclusions: cityPresentation.exclusions,
     cityRegions: cityPresentation.regions,
     environmentDefaults,
     environmentFiles: environmentFiles || [],
-    launchTargets: launch?.targets || [],
-    deployment,
-    workspaceSetupSteps: workspaceSetup || [],
+    extensions: opaqueStackSections(all, STACK_PIECE_SECTIONS),
     deslop,
   };
 }

package/src/index/stack-section-inspection.js

@@ -0,0 +1,33 @@
+import { GENESIS_CONTRACTS } from './contracts.js';
+import { gitContext } from './git.js';
+import { readStack } from './stack.js';
+import { normalizeStackSectionName } from './stack-section.js';
+import { sha256, stableJson } from './utils.js';
+
+/** Inspect one consumer-owned Stack section without interpreting its contents. */
+export async function inspectProjectStackSection({
+  name,
+  projectRoot,
+  stackPackages = [],
+} = {}) {
+  const sectionName = normalizeStackSectionName(name);
+  const root = (await gitContext(projectRoot)).repositoryRoot;
+  const stack = await readStack(root, { stackPackages });
+  const section = stack.extensions.find((candidate) => candidate.name === sectionName);
+  const diagnostics = [...(section?.diagnostics || [])];
+  const status = diagnostics.length > 0 ? 'blocked' : section ? 'ready' : 'unconfigured';
+  const lines = section ? [...section.lines] : [];
+  return {
+    contract: GENESIS_CONTRACTS.stackSection,
+    status,
+    stackHash: stack.identityHash,
+    sectionHash: status === 'ready' ? sha256(stableJson({ name: sectionName, lines })) : '',
+    components: stack.components.map(({ id }) => id),
+    name: sectionName,
+    source: section?.source || null,
+    content: lines.join('\n'),
+    lines,
+    diagnostics,
+  };
+}
+

package/src/index/stack-section.js

@@ -0,0 +1,82 @@
+import { GenesisError } from './errors.js';
+
+export function trimStackSectionLines(lines = []) {
+  const result = [...lines];
+  while (result[0]?.trim() === '') result.shift();
+  while (result.at(-1)?.trim() === '') result.pop();
+  return result;
+}
+
+export function normalizeStackSectionName(value, {
+  code = 'STACK_SECTION_INVALID',
+  field = 'section',
+} = {}) {
+  const name = String(value ?? '').trim();
+  if (!name || /[\0\r\n]/u.test(name) || /^#/u.test(name)) {
+    throw new GenesisError(code, 'Stack section names must be non-empty single lines.', {
+      [field]: value,
+    });
+  }
+  return name;
+}
+
+export function opaqueStackSections(sections, knownNames) {
+  return [...sections.entries()]
+    .filter(([name]) => !knownNames.has(name))
+    .map(([name, lines]) => ({
+      name: normalizeStackSectionName(name),
+      lines: trimStackSectionLines(lines),
+    }));
+}
+
+/**
+ * Compose consumer-owned Stack sections without interpreting their contents.
+ * A project declaration replaces component defaults; otherwise exactly one
+ * selected component may provide a section with a given name.
+ */
+export function composeStackSections(components = [], projectSections = []) {
+  const projectByName = new Map(projectSections.map((section) => [section.name, section]));
+  const componentByName = new Map();
+  for (const component of components) {
+    for (const section of component.extensions || []) {
+      const declarations = componentByName.get(section.name) || [];
+      declarations.push({
+        ...section,
+        source: `component:${component.id}`,
+      });
+      componentByName.set(section.name, declarations);
+    }
+  }
+  const names = [...new Set([...projectByName.keys(), ...componentByName.keys()])].sort();
+  return names.map((name) => {
+    const project = projectByName.get(name);
+    if (project) {
+      return {
+        name,
+        lines: [...project.lines],
+        source: 'project',
+        diagnostics: [],
+      };
+    }
+    const declarations = componentByName.get(name) || [];
+    if (declarations.length === 1) {
+      return {
+        name,
+        lines: [...declarations[0].lines],
+        source: declarations[0].source,
+        diagnostics: [],
+      };
+    }
+    const sources = declarations.map(({ source }) => source).sort();
+    return {
+      name,
+      lines: [],
+      source: null,
+      diagnostics: [{
+        code: 'STACK_SECTION_AMBIGUOUS',
+        message: `Selected Stack components provide competing \`${name}\` sections: ${sources.join(', ')}. Add one project \`## ${name}\` section to select the exact declaration.`,
+        details: { name, sources },
+      }],
+    };
+  });
+}