genesis-compiler 1.3.3 → 1.4.1

package/README.md

@@ -63,6 +63,10 @@ completely or correctly explains the implementation.
 
 ## Quick start
 
+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.
+
 Genesis requires Node.js 22 or newer and Git.
 
 Install the framework-neutral compiler and the optional first-party technology
@@ -277,6 +281,11 @@ genesis collaboration set direct balanced expert conclusions "Be candid."
 Genesis owns the supported choices and their concise expansions. Authored
 project requirements receive one fixed framing sentence and are otherwise
 preserved. They are omitted when the source says `- Nothing.`.
+The configured style applies to progress updates as well as final answers,
+with technical depth and terminology matched to the selected experience level.
+Updates should describe actual progress, findings, decisions, or blockers,
+rather than announce compliance with guidance or reassure the user about
+unrelated behavior staying unchanged.
 
 Persistent hosts should install `projectSessionContext()` once when a provider
 conversation is created or refreshed. They may then generate task prompts with
@@ -442,21 +451,25 @@ turn, and the project skill keeps intentional Blueprint and affected Program
 changes aligned there.
 
 Deslop runs only when explicitly requested. With no stated scope it reviews the
-latest commit; “the last N commits” reviews the net surviving first-parent
-range, and a named commit or range is honored exactly. It requires a clean
-worktree and leaves ordinary uncommitted cleanup for review rather than
-amending history. Genesis supplies the behavior-preserving boundary and Git
+agent's own changes for the current task across preceding turns, committed or
+uncommitted. An explicit commit, first-parent count, or range takes precedence
+regardless of authorship. The agent establishes ownership from task and edit
+history, preserves unrelated edits and existing staging, and asks for scope
+when ownership is unclear. A dirty worktree is allowed, and cleanup remains
+uncommitted for review. Genesis supplies the behavior-preserving boundary and
 scope rules. Selected Stack components add technology-specific Deslop guidance
 without weakening or broadening that contract.
 
-### Deslop committed work
+### Deslop your changes or specified commits
 
 Inside Codex, OpenCode, or another skill-aware coding agent, ask directly:
 
 ```text
 Deslop
+Deslop the last commit
 Deslop the last 5 commits
 Deslop commit a1b2c3d
+Deslop a1b2c3d..d4e5f6a
 ```
 
 The installed `genesis-deslop` skill generates the canonical project prompt
@@ -469,8 +482,10 @@ selection, generate the same complete prompt explicitly:
 
 ```bash
 genesis prompt --task deslop
+genesis prompt --task deslop "Deslop the last commit"
 genesis prompt --task deslop "Deslop the last 5 commits"
 genesis prompt --task deslop "Deslop commit a1b2c3d"
+genesis prompt --task deslop "Deslop a1b2c3d..d4e5f6a"
 ```
 
 Give the printed prompt to the coding agent that has access to the repository.
@@ -482,10 +497,12 @@ Stack component. Project additions or overrides from
 The main `genesis/stack.md` records component selection and durable project
 operations; it intentionally does not duplicate installed guidance bodies.
 
-Deslop refuses to mix cleanup with an existing dirty worktree. Its result is a
-normal uncommitted diff for review and a later commit. It never amends the
-selected commit, silently fixes newly discovered defects, or runs as an
-automatic completion phase.
+The whole dirty diff is not automatically the agent's work. Deslop preserves
+the user's and other agents' changes, including edits in the same files. With
+no changes of its own for the task, it reports that there is nothing to clean
+up; it does not silently select the latest commit. Its result is a normal
+uncommitted diff for review and a later commit. It never amends selected commits,
+silently fixes newly discovered defects, or runs as an automatic completion phase.
 
 Projects can customize a selected technology through its matching file, such
 as `genesis/stack/jskit.md`:
@@ -559,7 +576,8 @@ genesis prompt                                      # implementation work
 genesis prompt --task start                        # open a new or existing project conversation
 genesis prompt --task adopt                        # import an existing project's complete contract
 genesis prompt "Add filtering by note title"
-genesis prompt --task deslop                        # clean up the latest commit
+genesis prompt --task deslop                        # clean up the agent's own task changes
+genesis prompt --task deslop "Deslop the last commit"
 genesis prompt --task deslop "Deslop the last 5 commits"
 genesis prompt --task deslop "Deslop commit a1b2c3d"
 genesis prompt --task program                       # refresh explanation
@@ -586,9 +604,10 @@ The eight task types are deliberately explicit:
 - `work` implements the Blueprint and optional request using current code,
   Program, the selected engineering approach, selected Stack context, and
   progressively loaded Agent Skills.
-- `deslop` requests behavior-preserving cleanup of committed work explicitly.
-  It defaults to the latest commit, accepts a first-parent commit count or exact
-  commit/range, requires a clean worktree, and leaves its result uncommitted.
+- `deslop` explicitly requests behavior-preserving cleanup of the agent's own
+  task changes, committed or uncommitted. An explicit commit, first-parent
+  count, or range takes precedence. It preserves unrelated work and existing
+  staging, permits a dirty worktree, and leaves its result uncommitted.
 - `program` edits only `genesis/program/` to explain the code that exists, with
   selected Stack guidance available for technology-specific correctness.
 - `blueprint` edits only `genesis/blueprint.md` from explicit user intent. It

package/docs/templates.md

@@ -0,0 +1,122 @@
+# Project opening and templates
+
+`genesis init` installs the portable Genesis documents, workflow skills, and
+agent integration in an ordinary Git repository. It preserves existing source.
+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:
+
+| State | Evidence | Next step |
+| --- | --- | --- |
+| `new` | No content beyond known bootstrap files | Choose a template or create through conversation |
+| `adoption` | Existing content with no Genesis, or initialized documents that still lack product/Stack description | Ask what the project does and what should run; work backwards from existing code into its documents |
+| `ready` | Current format, valid core declarations and any present Program, existing source, product and Stack description | Continue ordinary work |
+| `attention` | Unversioned/old/invalid/newer Genesis, malformed declarations, or broken Program source references | Use the specific diagnostic and `nextAction` for migration, repair, or a compiler update |
+
+`genesis/version` is the format sentinel. Existing Genesis documents without it
+are an unversioned migration case, never an empty project. The supported format
+is independent of the npm package version. A Stack description can use selected
+components or authored project contracts when no catalogue technology matches.
+
+The exact bootstrap allowlist is `GENESIS_BOOTSTRAP_PATHS` in
+`src/index/project-inspection.js`: the four core Markdown documents and version,
+the two derived Cities, Genesis's Codex/OpenCode integration files, its managed
+skills manifest, 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
+installed `node_modules` dependencies. Source recognition does not depend on a
+language detector or an AI model.
+
+Opening a session does not run verification, rebuild the source index, install
+dependencies, prepare a database, or start the application. The inspection is
+repeated as a small read when opening/resuming a session and when a host refreshes
+its setup view. There is no persistent “ready” flag that can misclassify a later
+Git import. Program source references are structural evidence; prose accuracy
+still requires review against the implementation during relevant work.
+
+## Choose a starter
+
+Install the optional catalogue alongside the compiler:
+
+```sh
+npm install --global genesis-compiler genesis-stack
+git init
+genesis init
+genesis templates list
+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
+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.
+
+Applying fetches the explicitly named branch once, resolves its commit and reads
+its ordinary Git blobs into a temporary project. Genesis rejects links,
+submodules, unsafe paths, dependencies and private dotenv files in the template.
+It validates the prepared project before changing the destination. A project
+lock serializes competing imports; the source and authored bootstrap files are
+checked again immediately before the copy. An ordinary copy failure rolls back
+written files. If a process is forcibly killed, inspect any partial work and the
+Git-local `genesis-template.lock` before removing the abandoned lock and retrying;
+Genesis never treats partial application code as an empty destination.
+
+The destination keeps its Git history, remotes, branch, meaningful Blueprint,
+collaboration/engineering choices, and authored Stack operation sections.
+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.
+
+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.
+
+## Supply catalogues
+
+A catalogue repository has `genesis.templates.json` at its branch root:
+
+```json
+{
+  "schemaVersion": 1,
+  "templates": [{
+    "id": "jskit/public",
+    "technology": "jskit",
+    "name": "Company JSKIT app",
+    "description": "The company's public application starter.",
+    "repository": "https://github.com/example/seed-jskit.git",
+    "branch": "public"
+  }]
+}
+```
+
+Add explicit sources to either command, repeating the option for more sources:
+
+```sh
+genesis templates list --template-source company=https://github.com/example/starters.git#main
+genesis templates apply company:jskit/public --template-source company=https://github.com/example/starters.git#main
+```
+
+Repositories use HTTPS; explicit local absolute paths are also accepted for
+offline use and testing. The catalogue's technology matches a selected Stack
+component in its template. Skills do not trigger template selection: one complete
+template may select several components such as JSKIT, Node and MySQL.
+
+An installed Stack package may ship the same file and declare
+`"genesis": { "templates": { "namespace": "company", "path": "genesis.templates.json" } }`
+in its package.json, alongside `stackPieces`. Project-recorded Stack packages
+and explicit `--stack-package` packages contribute their catalogue data.
+Namespaces must be unique. Competing providers remain separate choices, such as
+`official:jskit/public` and `company:jskit/public`. An ambiguous unqualified ID
+is rejected; source order never chooses a winner.
+
+The JavaScript API exposes `inspectProject`, `listTemplates`, and `applyTemplate`.
+Catalogue options accept `stackPackages` and `templateSources`; explicit source
+records contain `namespace`, `repository`, and `branch`. Hosts configure those
+sources themselves and accept only a selected template ID from their browser.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genesis-compiler",
-  "version": "1.3.3",
+  "version": "1.4.1",
   "type": "module",
   "description": "An agent-independent prompt, multi-language code-index, cleanup, and verification companion with project agent guidance.",
   "repository": {
@@ -26,6 +26,7 @@
     "bin",
     "docs/assurance-model.md",
     "docs/stack-components.md",
+    "docs/templates.md",
     "docs/prompt-integration.md",
     "prompts/blueprint.txt",
     "prompts/adopt.txt",

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

@@ -1,6 +1,6 @@
 {
   "name": "genesis",
-  "version": "1.3.2",
+  "version": "1.4.0",
   "description": "Makes Codex aware of optional Genesis adoption for existing projects.",
   "author": {
     "name": "Mobily Enterprises"
@@ -11,7 +11,9 @@
     "longDescription": "Recommends the optional Genesis explanatory layer when Codex opens an existing project that has not adopted it.",
     "developerName": "Mobily Enterprises",
     "category": "Productivity",
-    "capabilities": ["Read"],
+    "capabilities": [
+      "Read"
+    ],
     "defaultPrompt": [
       "Adopt Genesis in this existing project"
     ]

package/prompts/deslop.txt

@@ -2,15 +2,19 @@ This Deslop task has already been rendered by Genesis. Do not generate another
 Deslop prompt. Read and follow `.agents/skills/genesis-deslop/SKILL.md`
 completely.
 
-This is an explicitly requested behavior-preserving cleanup of committed work.
-Resolve the commit or first-parent commit range from USER REQUEST exactly; when
-no scope is stated, use the latest commit. Require a clean worktree before
-editing and leave the cleanup as ordinary uncommitted work for review.
+This is an explicitly requested behavior-preserving cleanup. With no stated
+scope, select your own changes for the current task across preceding turns,
+committed or uncommitted. An explicit commit, first-parent count, or range in
+USER REQUEST takes precedence regardless of who authored those changes.
+Establish ownership from task and edit history; the entire dirty diff is not
+automatically yours. If ownership is unclear, ask for scope. A dirty worktree
+is allowed: preserve unrelated edits and existing staging, and leave the
+cleanup as ordinary uncommitted work for review.
 
 Apply the selected Stack cleanup guidance and applicable technology skills in
 addition to the Genesis Deslop contract. Stack guidance may improve
-technology-specific cleanup, but it cannot broaden the resolved Git scope,
+technology-specific cleanup, but it cannot broaden the resolved scope,
 weaken behavior preservation, or turn this into another implementation pass.
 
-Report the resolved range, what became simpler, files changed, checks actually
+Report the resolved scope, what became simpler, files changed, checks actually
 run, and any defect or gap deliberately left for follow-up.

package/prompts/start-existing-uninitialized.txt

@@ -1,8 +1,17 @@
-This is an existing project without Genesis project context. Do not ask
-new-project product-discovery questions. Ask what the person wants to understand
-or change and strongly recommend preparing the project for guided editing before
+This is an existing application that has not yet been described and configured
+in Genesis. It may already have initialized but empty Genesis documents. Never
+offer a template or replace its source. Ask what this project does and which
+application, command, or output the person wants to run. Use answers already
+given, and accept "inspect it for me" without requiring a technology choice.
+Ask about ambiguity such as multiple applications only after inspecting evidence.
+Recommend preparing the project for guided editing before
 substantial work. Explain in product language that preparation preserves the
 implementation while importing its current product, setup, run, data, preview,
 and verification facts. Do not require the person to know Genesis terminology or
-type a command. If they approve, run the Genesis `adopt` operation and follow its
-prompt. If they decline, continue normally and do not repeat the recommendation.
+type a command. When genesis.initialized is true, they have already opted into
+Genesis; run the Genesis `adopt` operation and follow its prompt without requesting
+that approval again. Otherwise, run it when they approve (including an explicit
+request to set up this existing project). If they decline, continue normally and
+do not repeat the recommendation.
+Opening a session never requires tests, builds, dependency installation, database
+preparation, or application verification.

package/prompts/start-new.txt

@@ -3,6 +3,13 @@ what is being built, who or what will use or invoke it, and the first observable
 useful outcome. Ask at most three concise questions at a time, and do not repeat
 facts already supplied by the user. A Stack choice is not product intent.
 
+Offer a ready-made starting point through `genesis templates list` when helpful.
+On an explicit choice, use `genesis templates apply <catalogue:technology/variant>`.
+Each choice is one complete repository branch, not a template per selected Skill.
+If multiple catalogues match, ask the user to choose a qualified identifier; never
+guess a source. Applying a template preserves authored project intent and Git
+history. Existing application source must go through adoption, never templates.
+
 Use `availableStackPieces` to offer only relevant technology choices in product
 language. Never silently select one. If the user names an unselected technology,
 run the Genesis `stack list` operation first. For one exact match, ask whether to

package/skills/genesis-deslop/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: genesis-deslop
-description: Deslop committed work through an explicit behavior-preserving cleanup pass. Use when asked to Deslop a commit or recent commits, simplify completed work, remove repeated helpers, clarify ownership, or align changed code with established project and technology patterns.
+description: Deslop the agent's own task changes or explicitly selected commits through a behavior-preserving cleanup pass. Use when asked to Deslop, simplify current work, remove repeated helpers, clarify ownership, or align changed code with established project and technology patterns.
 ---
 
 # Genesis Deslop
 
-Review and simplify committed work without changing product behavior. Deslop is
+Review and simplify selected changes without changing product behavior. Deslop is
 explicit: never run it merely because implementation finished.
 
 Resolve the invocation before running the first Genesis operation. Do not use a
@@ -29,8 +29,11 @@ Genesis operation or `genesis --version` as an availability probe.
 Successful invocation resolution is routine. Do not narrate whether Genesis is
 project-pinned or on `PATH`, and never describe direct `PATH` use as a fallback.
 Mention how the invocation was selected only when resolution fails or the user
-explicitly asks. This does not suppress an otherwise-required work update about
-using Genesis; keep that update about the project work, not executable selection.
+explicitly asks.
+
+Follow the configured Collaboration approach for user-facing updates, including
+its technical depth and response length. Report concrete progress,
+findings, or blockers; do not announce that you are following guidance.
 
 ## Load the effective project instructions once
 
@@ -49,25 +52,41 @@ to another agent and do not generate it again. This step composes the selected
 Stack's technology-specific Deslop guidance and any project customization with
 the portable contract below.
 
-## Resolve the committed scope
+## Resolve the cleanup scope
 
-Before reading or editing the selected change, require a clean worktree and
-index with `git status --short`. Stop and report the existing paths when it is
-not clean; do not stash, commit, discard, or mix them into Deslop.
+Inspect `git status --short` and the staged and unstaged diffs before editing.
+A dirty worktree is allowed; a prior commit is not required. Preserve the
+existing index and unrelated work. Do not stage, stash, commit, or discard
+changes as a prerequisite or as part of cleanup.
 
 Resolve the user's scope as follows:
 
-- With no stated scope, use the latest commit.
+- With no stated scope, select only your own changes for the current task,
+  including preceding turns. This can include staged and unstaged edits,
+  new untracked files, and already-committed task changes. Identify ownership
+  from task and edit history, then confirm those changes against the current
+  source and Git diffs. Neither the entire
+  dirty diff, the latest commit, nor a Git author identity proves ownership.
+- Preserve changes made by the user or other agents, including edits in the
+  same files. If ownership cannot be established, ask which changes to deslop. If there
+  are no changes of your own for this task, report that there is nothing to
+  deslop; do not silently select the latest commit or somebody else's work.
+- An explicit commit, first-parent count, or range takes precedence over the
+  default, regardless of who authored those changes.
+- “The last commit” means `HEAD` against its first parent.
 - “The last N commits” means the net surviving change from the first parent
   before those N commits through `HEAD`.
 - A named commit means that commit against its first parent.
 - An explicit commit range means exactly that range.
 - A root commit uses Git's root-diff form because it has no parent.
 
-Inspect the resolved commit identities and changed paths before editing. Review
-the committed diff, current source, direct call sites, relevant tests, and the
-affected Program and Stack context. Do not substitute the ordinary working-tree
-diff for the selected committed scope.
+Inspect the resolved changes and paths, plus commit identities when applicable.
+Review their diff, current source, direct call sites, relevant tests, and the
+affected Program and Stack context. For an explicit committed scope, do not
+substitute the ordinary working-tree diff for the selected committed diff.
+Apply cleanup to the current source while preserving edits outside the scope.
+If overlapping edits cannot be separated safely, ask about that overlap rather
+than blocking solely because the repository is dirty.
 
 ## Apply the cleanup contract
 
@@ -81,7 +100,7 @@ operation to find existing public and internal functions before introducing or
 consolidating an abstraction. Confirm every apparent duplicate in source and
 its call sites.
 
-Within the selected commits' intended behavior and scope, leave no
+Within the selected changes' intended behavior and scope, leave no
 repeated helpers, no code that is unclear or hard to reason about, and no code
 that goes against established patterns in the codebase. Remove unnecessary
 wrappers, abandoned scaffolding, parallel framework plumbing, and speculative
@@ -89,9 +108,10 @@ abstractions. Consolidate ownership where one clear module is enough. Do not
 optimize for tiny files or indirection; optimize for a small, obvious design
 that a junior programmer can follow.
 
-Cleanup is not a second implementation pass. A committed path limits where cleanup
-may occur; it does not authorize different behavior in that file. Deslop may
-reorganize behavior already present; it may not complete, correct, or extend
+Cleanup is not a second implementation pass. The selected changes limit where
+cleanup may occur; sharing a file does not bring unrelated edits into scope or
+authorize different behavior in that file. Deslop may reorganize behavior
+already present; it may not complete, correct, or extend
 behavior. If review reveals a defect, missing behavior, contract mismatch, or
 test gap, report it as a follow-up finding and leave it unchanged, even when it
 is inside a changed path or appears related to the preceding implementation. Do
@@ -100,7 +120,7 @@ not implement the finding or alter tests to accommodate it during Deslop.
 Apply every technology-specific Deslop instruction supplied by the selected
 Stack and load applicable official technology skills for framework and language
 context. Stack guidance enriches this contract; it cannot weaken the
-behavior-preserving boundary, change the selected Git scope, or authorize
+behavior-preserving boundary, change the selected scope, or authorize
 unrelated implementation.
 
 You may edit or delete implementation and test files when that is the clearest
@@ -115,5 +135,6 @@ create a second architecture or perform unrelated rewrites.
 Leave the cleanup as ordinary uncommitted work for review and a later normal
 commit. Never amend or rewrite the selected commits. Run focused checks when
 useful. Final declared checks remain available through the Genesis `verify`
-operation. Summarize the resolved commit range, what became simpler, files
-changed, checks actually run, and follow-up findings left unchanged.
+operation. Summarize the resolved scope and any selected commit identities,
+what became simpler, files changed, checks actually run, and follow-up findings
+left unchanged.

package/skills/genesis-deslop/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
   display_name: "Genesis Deslop"
-  short_description: "Clean up committed work without behavior drift"
-  default_prompt: "Use $genesis-deslop to Deslop the latest commit."
+  short_description: "Clean up your task changes or specified commits"
+  default_prompt: "Use $genesis-deslop to Deslop your own changes for the current task."

package/skills/genesis-project/SKILL.md

@@ -46,8 +46,11 @@ Genesis operation or `genesis --version` as an availability probe.
 Successful invocation resolution is routine. Do not narrate whether Genesis is
 project-pinned or on `PATH`, and never describe direct `PATH` use as a fallback.
 Mention how the invocation was selected only when resolution fails or the user
-explicitly asks. This does not suppress an otherwise-required work update about
-using Genesis; keep that update about the project work, not executable selection.
+explicitly asks.
+
+Follow the configured Collaboration approach for user-facing updates, including
+its technical depth and response length. Report concrete progress,
+findings, or blockers; do not announce that you are following guidance.
 
 ## Resolve explicit technology choices
 

package/src/cli.js

@@ -4,6 +4,7 @@ import { parseArgs } from 'node:util';
 import {
   addStack,
   adoptProject,
+  applyTemplate,
   check,
   generatePrompt,
   getContext,
@@ -13,9 +14,11 @@ import {
   inspectEngineering,
   inspectEnvironment,
   inspectStackSection,
+  inspectProject,
   installCodex,
   listEngineeringProfiles,
   listStackPieces,
+  listTemplates,
   migrate,
   setCollaboration,
   setEngineeringProfile,
@@ -51,10 +54,13 @@ const USAGE = `Usage:
   genesis engineering set <profile>
   genesis stack list
   genesis stack add <piece...>
+  genesis templates list
+  genesis templates apply <catalogue:technology/variant>
   genesis context <path...>
   genesis index [function-or-path...]
   genesis migrate
   genesis inspect environment
+  genesis inspect project
   genesis inspect section <name>
   genesis prompt [request...]
   genesis prompt --task <start|adopt|work|deslop|program|blueprint|describe|review> [request...]
@@ -64,6 +70,7 @@ const USAGE = `Usage:
 Options:
   --project-root <path>  Set the project root (default: current directory)
   --stack-package <name> Add an installed external Stack package (repeatable)
+  --template-source <namespace=repository[#branch]> Add a template catalogue (repeatable)
   --task <task>          Select the prompt task (default: work)
   --json                 Emit one machine-readable result
   -h, --help             Show this help
@@ -73,7 +80,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', 'collaboration', 'context', 'engineering', 'hook', 'index', 'init', 'inspect', 'migrate', 'prompt', 'stack', 'verify']);
+const COMMANDS = new Set(['adopt', 'check', 'codex', 'collaboration', 'context', 'engineering', 'hook', 'index', 'init', 'inspect', 'migrate', 'prompt', 'stack', 'templates', 'verify']);
 
 function parseCommand(argv) {
   if (argv.length === 0 || argv.includes('--help') || argv.includes('-h') || argv[0] === 'help') {
@@ -91,6 +98,7 @@ function parseCommand(argv) {
         json: { type: 'boolean', default: false },
         'project-root': { type: 'string' },
         'stack-package': { type: 'string', multiple: true, default: [] },
+        'template-source': { type: 'string', multiple: true, default: [] },
         task: { type: 'string' },
       },
     });
@@ -101,13 +109,27 @@ function parseCommand(argv) {
     json: parsed.values.json,
     projectRoot: parsed.values['project-root'],
     stackPackages: parsed.values['stack-package'],
+    templateSources: parsed.values['template-source'].map((source) => {
+      const separator = source.indexOf('=');
+      if (separator < 1) fail('CLI_TEMPLATE_SOURCE_INVALID', 'Use --template-source namespace=repository[#branch].');
+      const repositoryRef = source.slice(separator + 1);
+      const hash = repositoryRef.lastIndexOf('#');
+      return { namespace: source.slice(0, separator), repository: hash < 0 ? repositoryRef : repositoryRef.slice(0, hash), branch: hash < 0 ? 'main' : repositoryRef.slice(hash + 1) };
+    }),
     task: parsed.values.task,
   };
   const operands = parsed.positionals;
+  if (options.templateSources.length && command !== 'templates') {
+    fail('CLI_OPTION_NOT_APPLICABLE', `Option --template-source is not applicable to ${command}.`);
+  }
   if (options.task !== undefined && command !== 'prompt') {
     fail('CLI_OPTION_NOT_APPLICABLE', `Option --task is not applicable to ${command}.`);
   }
-  if (command === 'collaboration') {
+  if (command === 'templates') {
+    if (!(operands[0] === 'list' && operands.length === 1) && !(operands[0] === 'apply' && operands.length === 2)) {
+      fail('CLI_TEMPLATE_ACTION_REQUIRED', 'Use templates list or templates apply <catalogue:technology/variant>.');
+    }
+  } else if (command === 'collaboration') {
     const [action] = operands;
     if (!['show', 'set'].includes(action)) {
       fail('CLI_COLLABORATION_ACTION_REQUIRED', 'Command collaboration requires show or set.');
@@ -152,12 +174,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') {
-    const ordinaryInspection = operands.length === 1 && operands[0] === 'environment';
+    const ordinaryInspection = operands.length === 1 && ['environment', 'project'].includes(operands[0]);
     const sectionInspection = operands.length >= 2 && operands[0] === 'section';
     if (!ordinaryInspection && !sectionInspection) {
       fail(
         'CLI_INSPECT_TARGET_REQUIRED',
-        'Command inspect requires environment or section <name>.',
+        'Command inspect requires project, environment, or section <name>.',
       );
     }
   } else if (command === 'hook' && (operands.length !== 1 || !['discover', 'session', 'turn'].includes(operands[0]))) {
@@ -256,6 +278,21 @@ function writeInspection(result) {
 }
 
 function writeResult(command, result) {
+  if (command === 'templates') {
+    if (result.templates) for (const entry of result.templates) line(process.stdout, `${entry.id}: ${entry.name} — ${entry.description}`);
+    else {
+      line(process.stdout, `Applied ${result.template.id} from ${result.source.repository} (${result.source.branch} at ${result.source.revision}).`);
+      namedItems('Changed files', result.changedFiles);
+      line(process.stdout, result.guidance);
+    }
+    return;
+  }
+  if (command === 'inspect' && result.inspection === 'project') {
+    line(process.stdout, `Project: ${result.state}; source: ${result.content.kind}; Genesis: ${result.projectFormat.status}`);
+    line(process.stdout, `Next action: ${result.nextAction}. Templates: ${result.templateEligible ? 'available' : 'not applicable'}.`);
+    for (const diagnostic of result.diagnostics) line(process.stdout, `${diagnostic.code}: ${diagnostic.message}`);
+    return;
+  }
   if (command === 'prompt') {
     process.stdout.write(result.prompt.endsWith('\n') ? result.prompt : `${result.prompt}\n`);
     return;
@@ -377,6 +414,10 @@ async function execute({ command, operands, options }, { signal } = {}) {
   const projectRoot = options.projectRoot || process.cwd();
   const stackPackages = await cliStackPackages(projectRoot, options.stackPackages || []);
   if (command === 'init') return initialize({ projectRoot, stackPackages });
+  if (command === 'templates') {
+    const templateOptions = { projectRoot, stackPackages, templateSources: options.templateSources };
+    return operands[0] === 'list' ? listTemplates(templateOptions) : applyTemplate({ ...templateOptions, templateId: operands[1] });
+  }
   if (command === 'migrate') return migrate({ projectRoot, stackPackages });
   if (command === 'adopt') {
     return adoptProject({ projectRoot, request: operands.join(' '), stackPackages });
@@ -455,7 +496,7 @@ async function execute({ command, operands, options }, { signal } = {}) {
         }),
       };
     }
-    const inspections = { environment: inspectEnvironment };
+    const inspections = { environment: inspectEnvironment, project: inspectProject };
     return {
       inspection: operands[0],
       ...await inspections[operands[0]]({ projectRoot, stackPackages }),