genesis-compiler 1.2.16 → 1.2.18

package/README.md

@@ -13,6 +13,7 @@ interaction.
 ```text
 genesis/
   blueprint.md       non-technical product intent
+  engineering.md     selected engineering profile and project-specific requirements
   stack.md           selected technology guidance, verification, declarations, and opaque extensions
   stack/             optional per-component Description, Guidance, Adoption, Post-change, and Deslop customization
   program/           concise explanations grouped into conceptual subsystems
@@ -104,8 +105,8 @@ assistant runs `genesis adopt`; the person need not know Genesis terminology or
 type a command. It never runs adoption without approval and does nothing in an
 empty or already-adopted project.
 
-`genesis init` creates an empty Blueprint, an empty optional Stack, three
-project Agent Skills, and project-local Codex hooks. The skills are ordinary
+`genesis init` creates an empty Blueprint, a focused engineering approach, an
+empty optional Stack, three project Agent Skills, and project-local Codex hooks. The skills are ordinary
 [Agent Skills](https://agentskills.io): `genesis-project`, `genesis-program`,
 and `genesis-deslop`, each with standard `SKILL.md` and `agents/openai.yaml`
 metadata. Open `/hooks` once in Codex to review and trust the hooks. After
@@ -136,6 +137,54 @@ Genesis never overwrites an unmanaged skill and preserves locally modified
 managed skills. Run `genesis init` after manually editing `genesis/stack.md`,
 or use `genesis stack add`, to synchronize selected skills.
 
+## Engineering approach
+
+Every profile inherits one universal rule: implementation must remain easy to
+reason about and be the smallest targeted change that satisfies current
+requirements. Speculative abstractions, infrastructure, compatibility paths,
+distributed patterns, cryptography, and similarly advanced machinery are not
+allowed. When a concrete requirement makes material complexity necessary, the
+agent must explain why a direct design is insufficient and ask before writing
+that complexity.
+
+The installed, versioned profile descriptions live in
+`profiles/engineering/*.md`. Straight Genesis users can inspect and select them
+without editing Markdown grammar:
+
+```bash
+genesis engineering list
+genesis engineering show focused.v1
+genesis engineering set durable.v1
+```
+
+`focused.v1` is the default for small direct product work. `durable.v1` adds
+explicit compatibility and operational care for long-lived products.
+`high-assurance.v1` adds risk-driven security and reliability discipline. None
+of them mandates complexity without a concrete need.
+
+The selection and any explicit project overrides are portable source:
+
+```markdown
+# Engineering approach
+
+## Profile
+
+- `focused.v1`
+
+## Project requirements
+
+- Nothing.
+```
+
+People may edit `## Project requirements` to name obligations the presets do
+not capture, including a specific organizational, compliance, cryptographic,
+or scale constraint. `genesis engineering set` changes only the profile and
+preserves those requirements. Generated prompts, path-focused context, Codex
+session guidance, Post-change work, and Deslop all receive the effective
+approach. A project upgraded from an older Genesis release safely uses
+`focused.v1` until `genesis init` or `genesis engineering set focused.v1`
+records the file.
+
 Hosts that manage project environments can call `inspectEnvironment()`.
 Concrete Stack integrations may declare public, non-secret Environment
 defaults such as the database driver selected by that integration. Explicit
@@ -323,7 +372,8 @@ The eight task types are deliberately explicit:
   contracts into Genesis metadata. It composes technology-specific Adoption
   requirements from the selected Stack and does not change application code.
 - `work` implements the Blueprint and optional request using current code,
-  Program, selected Stack context, and progressively loaded Agent Skills.
+  Program, the selected engineering approach, selected Stack context, and
+  progressively loaded Agent Skills.
 - `deslop` requests cleanup explicitly. Codex projects also receive a bounded
   automatic Deslop turn after their separate explanatory reconciliation turn.
 - `program` edits only `genesis/program/` to explain the code that exists, with
@@ -422,7 +472,7 @@ genesis check
 
 `check` is read-only. It reports only structural or recorded facts:
 
-- Blueprint and Stack validity;
+- Blueprint, engineering approach, and Stack validity;
 - selected Agent Skill presence and structural validity;
 - Program presence and structural validity;
 - environment declarations and consumer-owned Stack extensions as `ready`,
@@ -451,10 +501,13 @@ import {
   getContext,
   indexCodebase,
   initialize,
+  inspectEngineering,
   inspectEnvironment,
   inspectStackSection,
   installCodex,
+  listEngineeringProfiles,
   listStackPieces,
+  setEngineeringProfile,
   verify,
 } from 'genesis-compiler';
 ```
@@ -463,6 +516,9 @@ import {
 Stack skills, and local Codex hooks.
 `adoptProject()` also returns the initial `adopt` prompt for an existing
 codebase. `installCodex()` installs the optional global discovery plugin.
+`listEngineeringProfiles()`, `inspectEngineering()`, and
+`setEngineeringProfile()` expose the same built-in catalog and portable
+project selection used by the CLI and hosts.
 `getContext()` resolves source paths to the Program modules that cite them,
 the functions already declared there, selected Stack guidance, available Agent
 Skills, and verification commands. `indexCodebase()` regenerates or returns the
@@ -474,7 +530,8 @@ projection paths without returning any supplied environment value.
 interpreting or executing its contents.
 
 Normalized results identify their stable public contract in the `contract`
-field: `genesis.environment.v1`, `genesis.stack-section.v1`, or
+field: `genesis.engineering.v1`, `genesis.environment.v2`,
+`genesis.stack-section.v1`, or
 `genesis.verification.v1`. A consumer defines any schema embedded inside the
 opaque section body.
 

package/docs/assurance-model.md

@@ -2,7 +2,9 @@
 
 Genesis reports only facts it can establish mechanically:
 
-1. Blueprint, Stack, and Program files satisfy their small structural formats.
+1. Blueprint, Engineering approach, Stack, and Program files satisfy their
+   small structural formats, and the selected engineering profile exists in
+   the installed versioned catalog.
 2. Program operations live in conceptual subsystem directories and cite real
    source files. Optional helper maps are not mechanically certified.
 3. Stack-declared environment inputs are present and non-placeholder. This does
@@ -17,8 +19,8 @@ Genesis reports only facts it can establish mechanically:
    City projects the Program modules and source citations that exist. Neither
    proves semantic equivalence, complete dynamic dispatch, or true duplication.
 
-Prompt text, Stack Description/Guidance/Adoption/Post-change/Deslop prose, Program prose, Agent Skill
-content, and agent output are not assurance evidence. Genesis does not claim
+Prompt text, engineering guidance, Stack Description/Guidance/Adoption/Post-change/Deslop prose,
+Program prose, Agent Skill content, and agent output are not assurance evidence. Genesis does not claim
 that product intent and code have converged, that Program is complete or
 semantically current, or that passing checks prove the whole product correct.
 

package/docs/prompt-integration.md

@@ -40,6 +40,10 @@ Genesis keeps each instruction at one useful level:
   commands, opaque consumer sections, and an optional authoritative Agent Skill source.
 - `genesis/blueprint.md`, `genesis/program/`, and `genesis/stack.md` are the
   project's own intent, explanation, and selected technical composition.
+- `profiles/engineering/*.md` owns the installed versioned engineering
+  profiles. `genesis/engineering.md` selects one profile and records explicit
+  project requirements. A universal complexity gate is composed ahead of the
+  selected profile in every implementation and cleanup path.
 - The generated JSON block contains current structural facts and warnings.
 
 Detailed technology manuals belong in the technology skill's `references/`
@@ -89,7 +93,8 @@ then refreshes them again after Deslop in case cleanup changed the
 implementation map.
 
 Once Codex identifies relevant source, `genesis context <path...>` returns only
-Program modules citing those paths plus concise selected Stack context, the
+Program modules citing those paths plus the effective engineering approach and
+concise selected Stack context, the
 functions structurally indexed in those paths, available Agent Skill catalog,
 and verification commands. `genesis index <name-or-path>` searches the complete
 current function inventory and refreshes `.genesis/machine-city.json` and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genesis-compiler",
-  "version": "1.2.16",
+  "version": "1.2.18",
   "type": "module",
   "description": "An agent-independent prompt, multi-language code-index, cleanup, and verification companion with optional Codex hooks.",
   "repository": {
@@ -38,6 +38,7 @@
     "prompts/start.txt",
     "prompts/work.txt",
     "plugins/genesis",
+    "profiles",
     "skills",
     "src"
   ],

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

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

package/profiles/engineering/baseline.md

@@ -0,0 +1,6 @@
+# Engineering baseline
+
+- Every implementation must be easy to reason about and be the smallest targeted change that fully satisfies the known requirements.
+- Prefer direct control flow, existing ownership boundaries, and established project or technology seams.
+- Do not overengineer or overcomplicate the solution. Do not add speculative abstractions, layers, dependencies, infrastructure, compatibility paths, distributed patterns, cryptography, enterprise patterns, or other advanced machinery unless an explicit requirement or a concrete constraint makes it necessary.
+- If good software requires material complexity beyond these rules, stop before writing it. Explain the requirement, why the direct design is insufficient, and the smallest added complexity proposed, then ask the user to approve or clarify the tradeoff.

package/profiles/engineering/durable.v1.md

@@ -0,0 +1,11 @@
+# Durable product
+
+## Description
+
+Long-lived product work with explicit compatibility and operational care.
+
+## Guidance
+
+- Treat affected public contracts, stored data, migrations, recovery, and operability as first-class requirements.
+- Make ownership and failure handling explicit enough for multiple contributors to maintain safely.
+- Add boundaries or supporting machinery only where a current longevity or operational requirement needs them; keep unaffected work as direct as the focused profile.

package/profiles/engineering/focused.v1.md

@@ -0,0 +1,11 @@
+# Focused
+
+## Description
+
+Small, direct changes for ordinary product work.
+
+## Guidance
+
+- Optimize for the clearest complete implementation with the fewest moving parts.
+- Keep single-use logic close to its caller and introduce a shared abstraction only when one real shared operation already exists.
+- Do not pre-build extensibility, scale, migration, or organizational machinery for hypothetical future needs.

package/profiles/engineering/high-assurance.v1.md

@@ -0,0 +1,11 @@
+# High assurance
+
+## Description
+
+Security- or reliability-critical work backed by explicit risks and evidence.
+
+## Guidance
+
+- Establish the relevant threat model, trust boundaries, data sensitivity, availability, compliance, and recovery requirements before making a design they could materially change.
+- Use established, audited primitives; make critical failure paths and ownership explicit; verify the properties on which safety depends.
+- Cryptography, distributed coordination, redundant controls, and similarly advanced machinery still require a concrete risk or obligation. Ask for missing constraints instead of inventing them.

package/prompts/start.txt

@@ -13,6 +13,14 @@ the non-technical Blueprint from the user's answers before implementation.
 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.
+The default `focused.v1` engineering profile is already suitable for ordinary
+work, so do not force a separate profile question. When the user asks for a
+different engineering approach, or the product clearly has long-lived
+compatibility, operational, security, reliability, or compliance constraints,
+use `availableEngineeringProfiles` to explain only the relevant choices in
+product language. After an explicit choice, run `genesis engineering set
+<profile>`; do not invent or duplicate a built-in profile. Record additional
+explicit obligations in `genesis/engineering.md` under Project requirements.
 This opening turn owns product direction and Stack selection, not final
 verification. Do not run `genesis verify` before implementation exists. If
 structural validation is useful, run `genesis check`; consumer-owned operations

package/skills/genesis-deslop/SKILL.md

@@ -9,6 +9,11 @@ Review and simplify the current local codebase without changing product
 behavior. Start with the requested scope, or otherwise the ordinary Git diff
 and the code immediately around it.
 
+Apply the engineering approach supplied with the task. If this skill is invoked
+directly, read `genesis/engineering.md` as well as the relevant project context.
+Cleanup must reduce or preserve complexity, never introduce unapproved
+machinery that the selected profile or a concrete requirement does not need.
+
 Consult `.genesis/machine-city.json` or run `genesis index <name-or-path>` to
 find existing public and internal functions before introducing or consolidating
 an abstraction. Confirm every apparent duplicate in source and its call sites.

package/skills/genesis-project/SKILL.md

@@ -11,23 +11,26 @@ codebase, tests, Git review, or the coding agent.
 ## Establish context
 
 1. Read `genesis/blueprint.md` for non-technical product intent.
-2. Read `genesis/stack.md` for the selected technical composition, resources,
+2. Read `genesis/engineering.md` for the selected engineering profile and any
+   project-specific requirements.
+3. Read `genesis/stack.md` for the selected technical composition, resources,
    and verification commands.
-3. Locate the source involved in the request.
-4. Run `genesis index <name-or-path>` before adding a helper or public operation.
+4. Locate the source involved in the request.
+5. Run `genesis index <name-or-path>` before adding a helper or public operation.
    Reuse an existing function when it already owns the behavior.
-5. Run `genesis context <path...>` for the relevant Program explanations and
+6. Run `genesis context <path...>` for the relevant Program explanations and
    selected Stack context.
-6. Load applicable technology skills from `.agents/skills/` or from the
+7. Load applicable technology skills from `.agents/skills/` or from the
    agent's own installed skill catalog.
 
 For an existing application's first Stack selection, inspect its real setup,
-build, and launch commands before relying on component defaults. A selected
+build, and output commands before relying on component defaults. A selected
 component describes its current foundation; it does not silently port older
 source. When the existing commands differ, keep the implementation unchanged
-and declare exact project-owned `## Workspace setup` and `## Launch` overrides.
-Do not claim the inherited component recipe is usable until it matches the
-source.
+and declare exact project-owned consumer-operation overrides (for Vibe64,
+`## Workspace setup` and `## Outputs`). Genesis composes those sections as
+opaque text; the named consumer alone owns their meaning and execution. Do not
+claim the inherited component recipe is usable until it matches the source.
 
 Program is concise, fallible explanation. Its Sources and optional
 Implementation maps aid navigation but never substitute for reading code,
@@ -39,14 +42,25 @@ Neither is authority or proof; both may be regenerated with `genesis index`.
 
 ## Implement ordinary local work
 
+- Apply the effective engineering approach supplied by Genesis. Every change
+  must be easy to reason about and be the smallest targeted implementation that
+  fully meets known requirements. Do not overengineer or overcomplicate it, and
+  do not add speculative abstractions, layers,
+  dependencies, infrastructure, compatibility paths, distributed patterns,
+  cryptography, or other advanced machinery.
+- When a concrete requirement makes material complexity necessary, stop before
+  writing it. Explain why the direct design is insufficient and the smallest
+  added complexity proposed, then ask the user to approve or clarify the
+  tradeoff. Never silently override the engineering approach.
 - Work directly in the current Git tree and leave useful edits visible in the
   ordinary diff.
 - Do not edit the Blueprint, Program, or `.genesis/` during implementation; the
-  separate reconciliation turn owns explanatory updates. 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. Record only capability metadata and
-  environment variable names there, never environment values or secrets.
+  separate reconciliation turn owns explanatory updates. Keep exact
+  consumer-owned operation declarations, such as Vibe64 `## Outputs`, aligned
+  when implementation intentionally changes the corresponding commands or
+  capabilities. Record only capability metadata and environment-variable names
+  there, never values or secrets; do not infer or execute the section as
+  Genesis behavior.
 - Follow established project and technology seams instead of creating parallel
   frameworks, persistence layers, transports, validators, or UI systems.
 - Never invent unavailable external-resource values or pass literal

package/src/cli.js

@@ -9,10 +9,13 @@ import {
   getContext,
   indexCodebase,
   initialize,
+  inspectEngineering,
   inspectEnvironment,
   inspectStackSection,
   installCodex,
+  listEngineeringProfiles,
   listStackPieces,
+  setEngineeringProfile,
   verify,
 } from './index.js';
 import {
@@ -22,12 +25,16 @@ import {
   discardCodexTurn,
   recordCodexTurn,
 } from './index/codex-hooks.js';
+import { engineeringProfile, readEngineeringBaseline } from './index/engineering.js';
 import { asDiagnostic, fail } from './index/errors.js';
 
 const USAGE = `Usage:
   genesis init
   genesis adopt [product guidance...]
   genesis codex install
+  genesis engineering list
+  genesis engineering show [profile]
+  genesis engineering set <profile>
   genesis stack list
   genesis stack add <piece...>
   genesis context <path...>
@@ -51,7 +58,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', 'prompt', 'stack', 'verify']);
+const COMMANDS = new Set(['adopt', 'check', 'codex', 'context', 'engineering', 'hook', 'index', 'init', 'inspect', 'prompt', 'stack', 'verify']);
 
 function parseCommand(argv) {
   if (argv.length === 0 || argv.includes('--help') || argv.includes('-h') || argv[0] === 'help') {
@@ -95,6 +102,20 @@ function parseCommand(argv) {
     if (operands[0] === 'list' && operands.length !== 1) {
       fail('CLI_EXTRA_ARGUMENT', 'Command stack list accepts no extra arguments.');
     }
+  } else if (command === 'engineering') {
+    const [action] = operands;
+    if (!['list', 'show', 'set'].includes(action)) {
+      fail('CLI_ENGINEERING_ACTION_REQUIRED', 'Command engineering requires list, show, or set.');
+    }
+    if (action === 'list' && operands.length !== 1) {
+      fail('CLI_EXTRA_ARGUMENT', 'Command engineering list accepts no extra arguments.');
+    }
+    if (action === 'show' && operands.length > 2) {
+      fail('CLI_EXTRA_ARGUMENT', 'Command engineering show accepts at most one profile.');
+    }
+    if (action === 'set' && operands.length !== 2) {
+      fail('CLI_ENGINEERING_PROFILE_REQUIRED', 'Command engineering set requires exactly one profile.');
+    }
   } else if (command === 'codex') {
     if (operands.length !== 1 || operands[0] !== 'install') {
       fail('CLI_CODEX_ACTION_REQUIRED', 'Command codex requires exactly: install.');
@@ -130,6 +151,7 @@ function namedItems(label, values) {
 
 function writeCheck(result) {
   line(process.stdout, `Blueprint: ${result.blueprint}`);
+  line(process.stdout, `Engineering approach: ${result.engineering}`);
   line(process.stdout, `Stack: ${result.stack}`);
   line(process.stdout, `Agent Skills: ${result.skills}`);
   line(process.stdout, `Program: ${result.program}`);
@@ -144,6 +166,29 @@ function writeCheck(result) {
   line(process.stdout, `Check: ${result.status}`);
 }
 
+function writeEngineering(result) {
+  if (result.action === 'list') {
+    for (const profile of result.profiles) {
+      line(process.stdout, `${profile.id}: ${profile.name} — ${profile.description}`);
+    }
+    return;
+  }
+  if (result.profile) {
+    line(process.stdout, `${result.profile.name} (${result.profile.id})`);
+    line(process.stdout, result.profile.description);
+  }
+  if (result.guidance) {
+    line(process.stdout, '');
+    line(process.stdout, result.guidance);
+  }
+  if (result.action === 'set') {
+    namedItems('Changed files', result.changedFiles);
+    line(process.stdout, `engineering: ${result.status}`);
+  } else if (result.status) {
+    line(process.stdout, `Engineering approach: ${result.status}`);
+  }
+}
+
 function writeInspection(result) {
   const title = result.inspection[0].toUpperCase() + result.inspection.slice(1);
   line(process.stdout, `${title}: ${result.status}`);
@@ -179,6 +224,10 @@ function writeResult(command, result) {
     writeCheck(result);
     return;
   }
+  if (command === 'engineering') {
+    writeEngineering(result);
+    return;
+  }
   if (command === 'context') {
     process.stdout.write(result.context.endsWith('\n') ? result.context : `${result.context}\n`);
     return;
@@ -254,6 +303,36 @@ async function execute({ command, operands, options }, { signal } = {}) {
     return adoptProject({ projectRoot, request: operands.join(' '), stackPackages });
   }
   if (command === 'codex') return installCodex();
+  if (command === 'engineering') {
+    if (operands[0] === 'list') {
+      return { action: 'list', status: 'ok', profiles: await listEngineeringProfiles() };
+    }
+    if (operands[0] === 'show') {
+      if (!operands[1]) return { action: 'show', ...await inspectEngineering({ projectRoot }) };
+      const [baseline, profile] = await Promise.all([
+        readEngineeringBaseline(),
+        engineeringProfile(operands[1]),
+      ]);
+      return {
+        action: 'show',
+        status: 'ready',
+        profile,
+        guidance: [
+          '## Universal complexity gate',
+          '',
+          baseline,
+          '',
+          '## Profile guidance',
+          '',
+          profile.guidance,
+        ].join('\n'),
+      };
+    }
+    return {
+      action: 'set',
+      ...await setEngineeringProfile({ profile: operands[1], projectRoot }),
+    };
+  }
   if (command === 'stack') {
     if (operands[0] === 'list') {
       return { status: 'ok', pieces: await listStackPieces({ projectRoot, stackPackages }) };

package/src/index/check.js

@@ -8,11 +8,13 @@ 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 { readEngineering } from './engineering.js';
 
 function invalidResult(area, error) {
   return {
     status: 'invalid',
     blueprint: area === 'blueprint' ? 'invalid' : 'valid',
+    engineering: area === 'engineering' ? 'invalid' : 'unknown',
     stack: area === 'stack' ? 'invalid' : 'unknown',
     skills: area === 'skills' ? 'invalid' : 'unknown',
     program: 'unknown',
@@ -40,6 +42,13 @@ export async function checkProject({
   }
 
   let stack;
+  let engineering;
+  try {
+    engineering = await readEngineering(root);
+  } catch (error) {
+    return invalidResult('engineering', error);
+  }
+
   try {
     stack = await readStack(root, { stackPackages });
   } catch (error) {
@@ -87,6 +96,7 @@ export async function checkProject({
 
   const guidance = [];
   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.');
   if (skills.status === 'missing') guidance.push('Run genesis init to install selected project Agent Skills.');
   if (skills.status === 'invalid') guidance.push('Repair the reported Agent Skill or managed-skill manifest.');
@@ -99,6 +109,7 @@ export async function checkProject({
   guidance.push('Use genesis prompt --task review for a semantic, evidence-based comparison.');
 
   const needsAttention = program.status === 'missing'
+    || engineering.status === 'defaulted'
     || skills.status === 'missing'
     || missingResources.length > 0
     || extensionDiagnostics.length > 0
@@ -109,6 +120,7 @@ export async function checkProject({
       ? 'invalid'
       : needsAttention ? 'attention' : 'ok',
     blueprint: 'valid',
+    engineering: engineering.status,
     stack: 'valid',
     skills: skills.status,
     program: program.status,

package/src/index/codex-hooks.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 
 import { readInstalledAsset } from './assets.js';
 import { buildProjectIndex } from './code-index.js';
+import { readEngineering, readEngineeringBaseline } from './engineering.js';
 import { GenesisError } from './errors.js';
 import { gitContext } from './git.js';
 import { isProjectContentPath } from './paths.js';
@@ -115,9 +116,30 @@ async function optionalStack(projectRoot) {
   try { return await readStack(projectRoot); } catch { return null; }
 }
 
+async function optionalEngineering(projectRoot) {
+  try {
+    return await readEngineering(projectRoot);
+  } catch {
+    return {
+      guidance: [
+        '## Universal complexity gate',
+        '',
+        await readEngineeringBaseline(),
+        '',
+        'The project engineering profile is invalid. Do not infer a replacement; run `genesis check` and ask the user before implementation if the selected approach matters.',
+      ].join('\n'),
+      profile: null,
+      status: 'invalid',
+    };
+  }
+}
+
 export async function codexSessionContext({ projectRoot } = {}) {
   const root = (await gitContext(projectRoot)).repositoryRoot;
-  const stack = await optionalStack(root);
+  const [stack, engineering] = await Promise.all([
+    optionalStack(root),
+    optionalEngineering(root),
+  ]);
   const selected = stack?.components.map(({ id }) => id) || [];
   const stackStatus = stack
     ? (selected.length > 0 ? selected.join(', ') : 'none')
@@ -127,6 +149,7 @@ export async function codexSessionContext({ projectRoot } = {}) {
     output: [
       'This is a Genesis-enriched project.',
       '- `genesis/blueprint.md` describes non-technical product intent.',
+      '- `genesis/engineering.md` selects the project engineering approach and any project-specific requirements.',
       '- `genesis/stack.md` selects optional technology guidance and verification.',
       '- `genesis/program/<subsystem>/` explains public operations and useful internal seams.',
       '- Project Agent Skills live in `.agents/skills/`; load applicable skills progressively.',
@@ -134,9 +157,14 @@ export async function codexSessionContext({ projectRoot } = {}) {
       '- Before creating a helper or public operation, run `genesis index <name-or-path>` and reuse an existing function when it already owns the behavior.',
       '- `.genesis/machine-city.json` is the detailed code/function map; `.genesis/program-city.json` is the simpler subsystem/operation map.',
       '- Program is fallible explanation; code, tests, and runtime behavior remain evidence.',
-      '- Keep implementation focused; the Stop hook owns optional Stack Post-change work, Blueprint/Program reconciliation, and Deslop turns.',
+      '- Apply the engineering approach below to implementation and cleanup; the Stop hook owns optional Stack Post-change work, Blueprint/Program reconciliation, and Deslop turns.',
       '- After a code-changing turn, Genesis may request separate post-change, explanation, cleanup, and final-summary turns.',
+      `Engineering profile: ${engineering.profile?.id || 'invalid; run \`genesis check\`'}.`,
       `Selected Stack components: ${stackStatus}.`,
+      '',
+      'ENGINEERING APPROACH',
+      '',
+      engineering.guidance,
     ].join('\n'),
   };
 }
@@ -279,9 +307,10 @@ function changedPathLines(changedPaths) {
 }
 
 async function reconciliationContinuation(projectRoot, changedPaths) {
-  const [instructions, stack] = await Promise.all([
+  const [instructions, stack, engineering] = await Promise.all([
     readInstalledAsset('reconcile'),
     optionalStack(projectRoot),
+    optionalEngineering(projectRoot),
   ]);
   return [
     'This is the automatic Genesis explanation turn for the preceding implementation turn.',
@@ -292,11 +321,15 @@ async function reconciliationContinuation(projectRoot, changedPaths) {
     ...changedPathLines(changedPaths),
     '',
     instructions.trim(),
+    '',
+    'ENGINEERING APPROACH',
+    '',
+    engineering.guidance,
     ...(stack?.guidance ? ['', 'SELECTED STACK GUIDANCE', '', stack.guidance] : []),
   ].join('\n');
 }
 
-function postChangeContinuation(changedPaths, stack) {
+function postChangeContinuation(changedPaths, stack, engineering) {
   return [
     'This is the one automatic Stack Post-change turn for the preceding implementation.',
     'Use the same conversation context and the Git-visible changes below.',
@@ -310,14 +343,19 @@ function postChangeContinuation(changedPaths, stack) {
     'COMPOSED STACK POST-CHANGE WORK',
     '',
     stack.postChange,
+    '',
+    'ENGINEERING APPROACH',
+    '',
+    engineering.guidance,
     ...(stack.guidance ? ['', 'SELECTED STACK GUIDANCE', '', stack.guidance] : []),
   ].join('\n');
 }
 
 async function deslopContinuation(projectRoot, changedPaths) {
-  const [instructions, stack] = await Promise.all([
+  const [instructions, stack, engineering] = await Promise.all([
     readInstalledAsset('deslop'),
     optionalStack(projectRoot),
+    optionalEngineering(projectRoot),
   ]);
   return [
     'This is the final automatic Genesis Deslop turn for the preceding implementation.',
@@ -328,6 +366,10 @@ async function deslopContinuation(projectRoot, changedPaths) {
     ...changedPathLines(changedPaths),
     '',
     instructions.trim(),
+    '',
+    'ENGINEERING APPROACH',
+    '',
+    engineering.guidance,
     ...(stack?.guidance ? ['', 'SELECTED STACK GUIDANCE', '', stack.guidance] : []),
     ...(stack?.deslop ? ['', 'SELECTED STACK CLEANUP GUIDANCE', '', stack.deslop] : []),
     '',
@@ -360,7 +402,10 @@ export async function completeCodexTurn({ input, projectRoot } = {}) {
       await rm(statePath, { force: true });
       return {};
     }
-    const stack = await optionalStack(root);
+    const [stack, engineering] = await Promise.all([
+      optionalStack(root),
+      optionalEngineering(root),
+    ]);
     const postChange = Boolean(stack?.postChange?.trim());
     await writeTurnState(statePath, {
       ...state,
@@ -370,7 +415,7 @@ export async function completeCodexTurn({ input, projectRoot } = {}) {
     return {
       decision: 'block',
       reason: postChange
-        ? postChangeContinuation(changedPaths, stack)
+        ? postChangeContinuation(changedPaths, stack, engineering)
         : await reconciliationContinuation(root, changedPaths),
     };
   }

package/src/index/context.js

@@ -4,6 +4,7 @@ import path from 'node:path';
 import { inspectProjectSkills, renderAgentSkillCatalog } from './agent-skills.js';
 import { buildProjectIndex } from './code-index.js';
 import { asDiagnostic, GenesisError } from './errors.js';
+import { readEngineering } from './engineering.js';
 import { gitContext } from './git.js';
 import { inspectProgram } from './program.js';
 import { readStack } from './stack.js';
@@ -56,13 +57,14 @@ export async function contextForProjectPaths({ paths, projectRoot, stackPackages
   const location = await gitContext(projectRoot);
   const root = location.repositoryRoot;
   const targets = [...new Set(paths.map((value) => projectPath(root, location.workingDirectory, value)))];
-  const [program, stack] = await Promise.all([
+  const [program, stack, engineering] = await Promise.all([
     inspectProgram(root).catch((error) => ({
       status: 'invalid',
       modules: [],
       diagnostic: asDiagnostic(error),
     })),
     readStack(root, { stackPackages }),
+    readEngineering(root),
   ]);
   const modules = program.modules.filter((module) => targets.some((target) => citesTarget(module, target)));
   const moduleSources = await Promise.all(modules.map(async (module) => ({
@@ -98,6 +100,12 @@ export async function contextForProjectPaths({ paths, projectRoot, stackPackages
     '## Relevant Program',
     '',
     ...programDetails,
+    '## Engineering approach',
+    '',
+    `Profile: \`${engineering.profile.id}\` — ${engineering.profile.description}`,
+    '',
+    engineering.guidance,
+    '',
     ...stackSummary(stack),
     ...stackGuidance(stack),
     '',
@@ -125,6 +133,7 @@ export async function contextForProjectPaths({ paths, projectRoot, stackPackages
     paths: targets,
     modules: moduleSources.map(({ source: _source, ...module }) => module),
     components: stack.components.map(({ id }) => id),
+    engineeringProfile: engineering.profile.id,
     verificationCommands: stack.verificationCommands.map(({ label, argv }) => ({ label, argv })),
     warnings: [
       ...(program.diagnostic ? [program.diagnostic] : []),

package/src/index/contracts.js

@@ -1,5 +1,6 @@
 export const GENESIS_CONTRACTS = Object.freeze({
   derivedArtifacts: 'genesis.derived-artifacts.v1',
+  engineering: 'genesis.engineering.v1',
   environment: 'genesis.environment.v2',
   stackSection: 'genesis.stack-section.v1',
   verification: 'genesis.verification.v1',

package/src/index/engineering.js

@@ -0,0 +1,274 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+
+import { GENESIS_CONTRACTS } from './contracts.js';
+import { GenesisError } from './errors.js';
+import { gitContext } from './git.js';
+import { ENGINEERING_PATH } from './paths.js';
+import { normalizeSource, writeFileAtomic } from './utils.js';
+
+const PROFILE_ID_PATTERN = /^[a-z][a-z0-9-]*\.v[1-9][0-9]*$/u;
+const PROFILE_IDS = Object.freeze(['focused.v1', 'durable.v1', 'high-assurance.v1']);
+const PROFILE_ASSETS = new Map(PROFILE_IDS.map((id) => [
+  id,
+  new URL(`../../profiles/engineering/${id}.md`, import.meta.url),
+]));
+const BASELINE_ASSET = new URL('../../profiles/engineering/baseline.md', import.meta.url);
+
+export const DEFAULT_ENGINEERING_PROFILE_ID = 'focused.v1';
+export const ENGINEERING_SKELETON_SOURCE = `# Engineering approach
+
+## Profile
+
+- \`${DEFAULT_ENGINEERING_PROFILE_ID}\`
+
+## Project requirements
+
+- Nothing.
+`;
+
+function normalizeProfileId(value) {
+  const id = String(value ?? '').trim();
+  if (!PROFILE_ID_PATTERN.test(id)) {
+    throw new GenesisError(
+      'ENGINEERING_PROFILE_INVALID',
+      'Engineering profile ids use a lowercase name followed by a version, such as `focused.v1`.',
+      { profile: value },
+    );
+  }
+  return id;
+}
+
+function sections(source, { title, sourcePath }) {
+  const lines = normalizeSource(source).split('\n');
+  if (lines.filter((line) => line.trim() === title).length !== 1) {
+    throw new GenesisError('ENGINEERING_INVALID', `${sourcePath} needs exactly one \`${title}\` title.`);
+  }
+  const result = new Map();
+  let current = null;
+  for (const line of lines) {
+    const heading = line.match(/^##\s+(.+?)\s*$/u);
+    if (heading) {
+      if (result.has(heading[1])) {
+        throw new GenesisError('ENGINEERING_INVALID', `Duplicate engineering section: ${heading[1]}.`, {
+          path: sourcePath,
+        });
+      }
+      current = [];
+      result.set(heading[1], current);
+    } else if (current) {
+      current.push(line);
+    } else if (line.trim() && line.trim() !== title) {
+      throw new GenesisError('ENGINEERING_INVALID', `${sourcePath} contains content outside an engineering section.`);
+    }
+  }
+  return result;
+}
+
+function sectionText(all, name) {
+  return (all.get(name) || []).join('\n').trim();
+}
+
+function parseProfileSource(source, { id }) {
+  const normalized = normalizeSource(source);
+  const titleMatch = normalized.match(/^# ([^\r\n]+)[ \t]*$/mu);
+  if (!titleMatch || normalized.match(/^# [^\r\n]+[ \t]*$/gmu)?.length !== 1) {
+    throw new GenesisError('ENGINEERING_PROFILE_INVALID', `Engineering profile ${id} needs one title.`);
+  }
+  const all = sections(normalized, {
+    sourcePath: `profiles/engineering/${id}.md`,
+    title: titleMatch[0].trim(),
+  });
+  const unknown = [...all.keys()].filter((name) => !['Description', 'Guidance'].includes(name));
+  const description = sectionText(all, 'Description');
+  const guidance = sectionText(all, 'Guidance');
+  if (unknown.length > 0 || !description || !guidance) {
+    throw new GenesisError(
+      'ENGINEERING_PROFILE_INVALID',
+      `Engineering profile ${id} needs only non-empty Description and Guidance sections.`,
+      { profile: id },
+    );
+  }
+  return Object.freeze({ id, name: titleMatch[1].trim(), description, guidance });
+}
+
+export async function engineeringProfile(value) {
+  const id = normalizeProfileId(value);
+  const location = PROFILE_ASSETS.get(id);
+  if (!location) {
+    throw new GenesisError(
+      'ENGINEERING_PROFILE_UNKNOWN',
+      `No installed engineering profile exists for ${id}.`,
+      { profile: id },
+    );
+  }
+  return parseProfileSource(await readFile(location, 'utf8'), { id });
+}
+
+export async function readEngineeringBaseline() {
+  const source = normalizeSource(await readFile(BASELINE_ASSET, 'utf8')).trim();
+  if (!/^# Engineering baseline[ \t]*$/mu.test(source)) {
+    throw new GenesisError('ENGINEERING_PROFILE_INVALID', 'The installed engineering baseline is invalid.');
+  }
+  return source.replace(/^# Engineering baseline[ \t]*\n?/mu, '').trim();
+}
+
+export function parseEngineeringSource(source) {
+  const normalized = normalizeSource(source);
+  const all = sections(normalized, {
+    sourcePath: ENGINEERING_PATH,
+    title: '# Engineering approach',
+  });
+  const unknown = [...all.keys()].filter((name) => !['Profile', 'Project requirements'].includes(name));
+  if (unknown.length > 0 || !all.has('Profile') || !all.has('Project requirements')) {
+    throw new GenesisError(
+      'ENGINEERING_INVALID',
+      `${ENGINEERING_PATH} needs only Profile and Project requirements sections.`,
+      { path: ENGINEERING_PATH },
+    );
+  }
+  const profileLines = (all.get('Profile') || []).filter((line) => line.trim());
+  const match = profileLines.length === 1
+    ? profileLines[0].trim().match(/^- `([^`]+)`$/u)
+    : null;
+  if (!match) {
+    throw new GenesisError(
+      'ENGINEERING_INVALID',
+      'The engineering Profile must be exactly one bullet containing a backticked profile id.',
+      { path: ENGINEERING_PATH },
+    );
+  }
+  const requirementsSource = sectionText(all, 'Project requirements');
+  if (!requirementsSource) {
+    throw new GenesisError(
+      'ENGINEERING_INVALID',
+      'Project requirements must contain requirements or `- Nothing.`.',
+      { path: ENGINEERING_PATH },
+    );
+  }
+  if (Buffer.byteLength(requirementsSource, 'utf8') > 64 * 1024) {
+    throw new GenesisError('ENGINEERING_INVALID', 'Project engineering requirements exceed 64 KiB.', {
+      path: ENGINEERING_PATH,
+    });
+  }
+  return {
+    path: ENGINEERING_PATH,
+    profileId: normalizeProfileId(match[1]),
+    requirements: requirementsSource === '- Nothing.' ? '' : requirementsSource,
+    source: normalized,
+  };
+}
+
+function renderEngineering({ profileId, requirements = '' }) {
+  return [
+    '# Engineering approach',
+    '',
+    '## Profile',
+    '',
+    `- \`${profileId}\``,
+    '',
+    '## Project requirements',
+    '',
+    requirements.trim() || '- Nothing.',
+    '',
+  ].join('\n');
+}
+
+function effectiveGuidance({ baseline, profile, requirements }) {
+  return [
+    '## Universal complexity gate',
+    '',
+    baseline,
+    '',
+    `## Selected profile: ${profile.name} (\`${profile.id}\`)`,
+    '',
+    profile.guidance,
+    ...(requirements ? [
+      '',
+      '## Project requirements',
+      '',
+      requirements,
+    ] : []),
+  ].join('\n');
+}
+
+export async function readEngineering(projectRoot) {
+  const location = path.join(projectRoot, ENGINEERING_PATH);
+  let parsed;
+  let status = 'configured';
+  try {
+    parsed = parseEngineeringSource(await readFile(location, 'utf8'));
+  } catch (error) {
+    if (!['ENOENT', 'ENOTDIR'].includes(error?.code)) throw error;
+    parsed = parseEngineeringSource(ENGINEERING_SKELETON_SOURCE);
+    status = 'defaulted';
+  }
+  const [baseline, profile] = await Promise.all([
+    readEngineeringBaseline(),
+    engineeringProfile(parsed.profileId),
+  ]);
+  return {
+    contract: GENESIS_CONTRACTS.engineering,
+    path: ENGINEERING_PATH,
+    status,
+    profile,
+    requirements: parsed.requirements,
+    source: status === 'configured' ? parsed.source : null,
+    guidance: effectiveGuidance({ baseline, profile, requirements: parsed.requirements }),
+  };
+}
+
+export function engineeringPromptContext(engineering) {
+  return {
+    path: engineering.path,
+    status: engineering.status,
+    profile: {
+      id: engineering.profile.id,
+      name: engineering.profile.name,
+      description: engineering.profile.description,
+    },
+    requirements: engineering.requirements || 'Nothing.',
+  };
+}
+
+export function listEngineeringProfileCatalog() {
+  return Promise.all(PROFILE_IDS.map(engineeringProfile));
+}
+
+export async function inspectProjectEngineering({ projectRoot } = {}) {
+  const root = (await gitContext(projectRoot)).repositoryRoot;
+  const [engineering, profiles] = await Promise.all([
+    readEngineering(root),
+    listEngineeringProfileCatalog(),
+  ]);
+  return {
+    contract: engineering.contract,
+    path: engineering.path,
+    status: engineering.status,
+    profile: engineering.profile,
+    profiles,
+    requirements: engineering.requirements,
+    guidance: engineering.guidance,
+  };
+}
+
+export async function selectEngineeringProfile({ profile, projectRoot } = {}) {
+  const root = (await gitContext(projectRoot)).repositoryRoot;
+  const selected = await engineeringProfile(profile);
+  const current = await readEngineering(root);
+  const rendered = renderEngineering({
+    profileId: selected.id,
+    requirements: current.requirements,
+  });
+  const changed = current.source !== rendered;
+  if (changed) await writeFileAtomic(path.join(root, ENGINEERING_PATH), rendered);
+  return {
+    contract: GENESIS_CONTRACTS.engineering,
+    status: changed ? 'updated' : 'unchanged',
+    summary: changed
+      ? `Selected engineering profile: ${selected.id}.`
+      : `Engineering profile ${selected.id} is already selected.`,
+    profile: selected,
+    changedFiles: changed ? [ENGINEERING_PATH] : [],
+  };
+}

package/src/index/init.js

@@ -4,8 +4,9 @@ import path from 'node:path';
 import { syncProjectSkills } from './agent-skills.js';
 import { BLUEPRINT_SKELETON_SOURCE } from './blueprint.js';
 import { installCodexHooks } from './codex-hooks.js';
+import { ENGINEERING_SKELETON_SOURCE } from './engineering.js';
 import { gitContext } from './git.js';
-import { BLUEPRINT_PATH, PROGRAM_ROOT, STACK_PATH } from './paths.js';
+import { BLUEPRINT_PATH, ENGINEERING_PATH, PROGRAM_ROOT, STACK_PATH } from './paths.js';
 import { EMPTY_STACK_SOURCE, readStack } from './stack.js';
 
 async function createIfMissing(projectRoot, relativePath, source) {
@@ -24,6 +25,7 @@ export async function initializeProject({ projectRoot, stackPackages = [] } = {}
   const root = (await gitContext(projectRoot)).repositoryRoot;
   const created = (await Promise.all([
     createIfMissing(root, BLUEPRINT_PATH, BLUEPRINT_SKELETON_SOURCE),
+    createIfMissing(root, ENGINEERING_PATH, ENGINEERING_SKELETON_SOURCE),
     createIfMissing(root, STACK_PATH, EMPTY_STACK_SOURCE),
   ])).filter(Boolean);
   await mkdir(path.join(root, PROGRAM_ROOT), { recursive: true });
@@ -42,6 +44,7 @@ export async function initializeProject({ projectRoot, stackPackages = [] } = {}
       'Open Codex and use /hooks to review and trust the project hooks.',
       'Genesis workflow skills are available in .agents/skills/.',
       'Describe product intent in genesis/blueprint.md.',
+      'Choose the project engineering approach with genesis engineering set <profile>.',
       'Stack components are optional; add them with genesis stack add <piece...>.',
     ].join(' '),
   };

package/src/index/paths.js

@@ -1,4 +1,5 @@
 export const BLUEPRINT_PATH = 'genesis/blueprint.md';
+export const ENGINEERING_PATH = 'genesis/engineering.md';
 export const STACK_PATH = 'genesis/stack.md';
 export const PROGRAM_ROOT = 'genesis/program';
 export const VERIFICATION_PATH = '.genesis/verification.json';

package/src/index/prompt.js

@@ -2,6 +2,11 @@ import { readInstalledAsset } from './assets.js';
 import { inspectProjectSkills, renderAgentSkillCatalog } from './agent-skills.js';
 import { buildProjectIndex, MACHINE_CITY_PATH, PROGRAM_CITY_PATH } from './code-index.js';
 import { BLUEPRINT_SKELETON_SOURCE, readBlueprint } from './blueprint.js';
+import {
+  engineeringPromptContext,
+  listEngineeringProfileCatalog,
+  readEngineering,
+} from './engineering.js';
 import { readStack, stackPromptContext } from './stack.js';
 import { listStackCatalogPieces } from './stack-catalog.js';
 import { normalizeStackPieceId } from './stack-piece.js';
@@ -103,6 +108,7 @@ function renderPrompt({
   guidance = '',
   cleanup = '',
   adoption = '',
+  engineeringGuidance = '',
 }) {
   return [
     instructions.trim(),
@@ -116,6 +122,7 @@ function renderPrompt({
     '```json',
     stableJson(context).trimEnd(),
     '```',
+    ...(engineeringGuidance ? ['', 'ENGINEERING APPROACH', '', engineeringGuidance] : []),
     ...(guidance ? ['', 'SELECTED STACK GUIDANCE', '', guidance] : []),
     ...(adoption ? ['', 'SELECTED STACK ADOPTION GUIDANCE', '', adoption] : []),
     ...(skills ? ['', 'AVAILABLE AGENT SKILLS', '', skills] : []),
@@ -124,7 +131,7 @@ function renderPrompt({
   ].join('\n');
 }
 
-async function generateAdoptionPrompt({ environment, instructions, program, request, root, stackPackages }) {
+async function generateAdoptionPrompt({ engineering, environment, instructions, program, request, root, stackPackages }) {
   const blueprint = await readBlueprint(root, { required: true });
   const stack = await readStack(root, { stackPackages });
   const availableStackPackages = [...new Set([...stack.stackPackages, ...stackPackages])];
@@ -148,6 +155,7 @@ async function generateAdoptionPrompt({ environment, instructions, program, requ
         projectRoot: root,
         projectKind: 'existing',
         blueprint: { path: blueprint.path, source: blueprint.source },
+        engineering: engineeringPromptContext(engineering),
         stack: stackPromptContext(stack),
         availableStackPieces: stackCatalogContext(catalog),
         program: programContext(program),
@@ -156,6 +164,7 @@ async function generateAdoptionPrompt({ environment, instructions, program, requ
           : { status: 'present' },
         codeIndex: codeIndexContext(index),
       },
+      engineeringGuidance: engineering.guidance,
       guidance: stack.guidance,
       adoption: stack.adoption,
       skills: renderAgentSkillCatalog(projectSkills.skills),
@@ -170,7 +179,7 @@ async function generateAdoptionPrompt({ environment, instructions, program, requ
   };
 }
 
-async function generateExplanationPrompt({ instructions, program, request, root, stackPackages, task }) {
+async function generateExplanationPrompt({ engineering, instructions, program, request, root, stackPackages, task }) {
   const blueprint = await readBlueprint(root, {
     required: true,
     requireDescription: task === 'program',
@@ -193,10 +202,12 @@ async function generateExplanationPrompt({ instructions, program, request, root,
         task,
         projectRoot: root,
         blueprint: blueprintContext,
+        engineering: engineeringPromptContext(engineering),
         stack: stackPromptContext(stack),
         program: programContext(program),
         codeIndex: codeIndexContext(index),
       },
+      engineeringGuidance: engineering.guidance,
       guidance: stack.guidance,
       skills: renderAgentSkillCatalog(projectSkills.skills),
     }),
@@ -211,12 +222,15 @@ async function generateExplanationPrompt({ instructions, program, request, root,
 
 async function generateStartPrompt({
   hiddenStackPieces,
+  engineering,
   instructions,
   program,
   request,
   root,
   stackPackages,
 }) {
+  const availableEngineeringProfiles = (await listEngineeringProfileCatalog())
+    .map(({ id, name, description }) => ({ id, name, description }));
   let blueprint;
   try {
     blueprint = await readBlueprint(root, { required: true });
@@ -236,8 +250,11 @@ async function generateStartPrompt({
           projectRoot: root,
           projectKind: 'existing-uninitialized',
           genesis: { initialized: false },
+          engineering: engineeringPromptContext(engineering),
+          availableEngineeringProfiles,
           program: programContext(program),
         },
+        engineeringGuidance: engineering.guidance,
       }),
       warnings: program.diagnostic ? [program.diagnostic] : [],
       verificationCommands: [],
@@ -265,11 +282,14 @@ async function generateStartPrompt({
           path: blueprint.path,
           description: blueprint.description,
         },
+        engineering: engineeringPromptContext(engineering),
+        availableEngineeringProfiles,
         stack: stackPromptContext(stack),
         availableStackPieces: stackCatalogContext(catalog, hiddenStackPieces),
         program: programContext(program),
         codeIndex: codeIndexContext(index),
       },
+      engineeringGuidance: engineering.guidance,
       guidance: stack.guidance,
       skills: renderAgentSkillCatalog(projectSkills.skills),
     }),
@@ -295,7 +315,10 @@ export async function generateProjectPrompt({
   }
   const root = (await gitContext(projectRoot)).repositoryRoot;
   const userRequest = requestText(request, task);
-  const instructions = await readInstalledAsset(task);
+  const [instructions, engineering] = await Promise.all([
+    readInstalledAsset(task),
+    readEngineering(root),
+  ]);
 
   if (task === 'blueprint') {
     const blueprint = await readBlueprint(root);
@@ -310,7 +333,9 @@ export async function generateProjectPrompt({
           path: 'genesis/blueprint.md',
           source: blueprint?.source || BLUEPRINT_SKELETON_SOURCE,
         },
+        engineering: engineeringPromptContext(engineering),
       },
+      engineeringGuidance: engineering.guidance,
       skills: renderAgentSkillCatalog(projectSkills.skills),
     });
     return {
@@ -327,6 +352,7 @@ export async function generateProjectPrompt({
     return generateStartPrompt({
       instructions,
       hiddenStackPieces,
+      engineering,
       program,
       request: userRequest,
       root,
@@ -336,6 +362,7 @@ export async function generateProjectPrompt({
   if (task === 'adopt') {
     return generateAdoptionPrompt({
       environment,
+      engineering,
       instructions,
       program,
       request: userRequest,
@@ -352,6 +379,7 @@ export async function generateProjectPrompt({
       return generateStartPrompt({
         instructions: await readInstalledAsset('start'),
         hiddenStackPieces,
+        engineering,
         program,
         request: userRequest,
         root,
@@ -362,6 +390,7 @@ export async function generateProjectPrompt({
       return generateStartPrompt({
         instructions: await readInstalledAsset('start'),
         hiddenStackPieces,
+        engineering,
         program,
         request: userRequest,
         root,
@@ -372,6 +401,7 @@ export async function generateProjectPrompt({
   if (['describe', 'program'].includes(task)) {
     return generateExplanationPrompt({
       instructions,
+      engineering,
       program,
       request: userRequest,
       root,
@@ -400,6 +430,7 @@ export async function generateProjectPrompt({
     task,
     projectRoot: root,
     blueprint: { path: blueprint.path, description: blueprint.description },
+    engineering: engineeringPromptContext(engineering),
     stack: stackPromptContext(stack),
     program: programContext(program),
     resourceInputs: missing.length > 0
@@ -417,6 +448,7 @@ export async function generateProjectPrompt({
     instructions,
     request: userRequest,
     context,
+    engineeringGuidance: engineering.guidance,
     guidance: stack.guidance,
     skills: renderAgentSkillCatalog(projectSkills.skills),
     cleanup: task === 'deslop' ? stack.deslop : '',

package/src/index.js

@@ -5,6 +5,11 @@ import { buildProjectIndex, GENESIS_DERIVED_ARTIFACTS } from './index/code-index
 import { GENESIS_CONTRACTS } from './index/contracts.js';
 import { contextForProjectPaths } from './index/context.js';
 import { generateProjectPrompt } from './index/prompt.js';
+import {
+  inspectProjectEngineering,
+  listEngineeringProfileCatalog,
+  selectEngineeringProfile,
+} from './index/engineering.js';
 import { initializeProject } from './index/init.js';
 import { installCodexPlugin } from './index/codex-plugin.js';
 import { inspectProjectEnvironment } from './index/environment-files.js';
@@ -98,6 +103,18 @@ export function inspectStackSection(options) {
   return inspectProjectStackSection(options);
 }
 
+export function listEngineeringProfiles() {
+  return listEngineeringProfileCatalog();
+}
+
+export function inspectEngineering(options) {
+  return inspectProjectEngineering(options);
+}
+
+export function setEngineeringProfile(options) {
+  return selectEngineeringProfile(options);
+}
+
 export function generatePrompt(options) {
   return generateProjectPrompt(options);
 }