genesis-compiler 1.4.0 → 1.5.0

package/README.md

@@ -213,8 +213,23 @@ skill.
 
 `.agents/skills/.genesis-managed.json` records only copies Genesis owns.
 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.
+managed skills. `genesis check` and `genesis inspect skills` distinguish outdated
+managed copies from local customizations. After updating Genesis or a selected
+skill package, run `genesis skills sync` to refresh only those skill directories
+and their ownership manifest. Repeating it makes no changes. It does not install
+packages, initialize project files, migrate contracts, rebuild indexes, or run
+verification.
+
+Projects that declare `genesis-compiler` use the skills from that installed
+project dependency, including when a host embeds a different compiler. An
+unprepared declared dependency is reported instead of substituting the host's
+version. Other projects use the running compiler's packaged skills. Package
+upgrades remain explicit dependency changes.
+
+Inspection, context generation, and session hooks remain read-only and report
+skill maintenance diagnostics. An assistant that already loaded old skills
+needs its supported context refresh before using their replacement; changing
+files alone does not refresh its existing context.
 
 ## Commands at a glance
 
@@ -228,9 +243,11 @@ or use `genesis stack add`, to synchronize selected skills.
 | `genesis engineering set <profile>` | Records the selected engineering profile while preserving project-specific requirements. |
 | `genesis stack list` | Lists technology components from the installed Stack catalog. |
 | `genesis stack add <piece...>` | Resolves component dependencies/conflicts, records the selection, materializes missing project contracts, synchronizes declared skills, and prints the one-time preparation prompt. It does not install application packages or run an agent. |
+| `genesis skills sync` | Refreshes selected, unmodified managed skills while preserving customized and unmanaged copies. |
 | `genesis context <path...>` | Returns path-focused Program explanations, indexed functions, selected technology guidance, exact project contracts, and relevant skills. |
 | `genesis index [function-or-path...]` | Regenerates the derived code indexes and optionally searches the existing function/method inventory. |
 | `genesis inspect environment` | Reports declared resources, public defaults, missing input names, and environment-file paths without returning secret values. |
+| `genesis inspect skills` | Reports selected skill freshness and ownership without changing files. |
 | `genesis inspect section <name>` | Returns one exact consumer-owned Stack section without interpreting or executing it. |
 | `genesis prompt [request...]` | Generates the ordinary implementation prompt. Use `--task` for opening, adoption, Deslop, explanation, review, and other explicit prompt tasks. |
 | `genesis verify` | Executes only the ordered finite commands in `## Verification` and records exact evidence. |
@@ -281,6 +298,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
@@ -446,21 +468,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
@@ -473,8 +499,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.
@@ -486,10 +514,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`:
@@ -563,7 +593,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
@@ -590,9 +621,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
@@ -860,6 +892,7 @@ import {
   inspectCollaboration,
   inspectEngineering,
   inspectEnvironment,
+  inspectSkills,
   inspectStackSection,
   installCodex,
   listEngineeringProfiles,
@@ -869,6 +902,7 @@ import {
   projectTurnContext,
   setCollaboration,
   setEngineeringProfile,
+  syncSkills,
   verify,
   withTrustedGitRepository,
 } from 'genesis-compiler';
@@ -885,6 +919,12 @@ codebase. `installCodex()` installs the optional global discovery plugin.
 project selection used by the CLI and hosts.
 `inspectCollaboration()` and `setCollaboration()` expose the portable
 communication declaration and Genesis-owned choice expansions.
+`inspectSkills()` and `syncSkills()` expose the same inspection and narrow
+synchronization used by the CLI. Both accept `projectRoot` and `stackPackages`.
+Inspection returns aggregate status, per-skill status for valid installed copies,
+and diagnostics for missing, invalid, outdated, customized, or unmanaged skills.
+Synchronization returns changed paths, preservation diagnostics, and the resulting
+`inspection`. Hosts own source-write exclusion and assistant context lifecycle.
 `projectSessionContext()` composes stable project guidance with one explicitly
 supplied host-driver result. `projectTurnContext()` invokes that same optional
 driver for the separate untrusted turn lane without accepting user-message

package/package.json

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

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/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

@@ -15,6 +15,7 @@ import {
   inspectEnvironment,
   inspectStackSection,
   inspectProject,
+  inspectSkills,
   installCodex,
   listEngineeringProfiles,
   listStackPieces,
@@ -22,6 +23,7 @@ import {
   migrate,
   setCollaboration,
   setEngineeringProfile,
+  syncSkills,
   verify,
 } from './index.js';
 import {
@@ -54,6 +56,7 @@ const USAGE = `Usage:
   genesis engineering set <profile>
   genesis stack list
   genesis stack add <piece...>
+  genesis skills sync
   genesis templates list
   genesis templates apply <catalogue:technology/variant>
   genesis context <path...>
@@ -61,6 +64,7 @@ const USAGE = `Usage:
   genesis migrate
   genesis inspect environment
   genesis inspect project
+  genesis inspect skills
   genesis inspect section <name>
   genesis prompt [request...]
   genesis prompt --task <start|adopt|work|deslop|program|blueprint|describe|review> [request...]
@@ -80,7 +84,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', 'templates', 'verify']);
+const COMMANDS = new Set(['adopt', 'check', 'codex', 'collaboration', 'context', 'engineering', 'hook', 'index', 'init', 'inspect', 'migrate', 'prompt', 'skills', 'stack', 'templates', 'verify']);
 
 function parseCommand(argv) {
   if (argv.length === 0 || argv.includes('--help') || argv.includes('-h') || argv[0] === 'help') {
@@ -167,6 +171,10 @@ function parseCommand(argv) {
     if (action === 'set' && operands.length !== 2) {
       fail('CLI_ENGINEERING_PROFILE_REQUIRED', 'Command engineering set requires exactly one profile.');
     }
+  } else if (command === 'skills') {
+    if (operands.length !== 1 || operands[0] !== 'sync') {
+      fail('CLI_SKILLS_ACTION_REQUIRED', 'Command skills requires exactly: sync.');
+    }
   } else if (command === 'codex') {
     if (operands.length !== 1 || operands[0] !== 'install') {
       fail('CLI_CODEX_ACTION_REQUIRED', 'Command codex requires exactly: install.');
@@ -174,12 +182,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 && ['environment', 'project'].includes(operands[0]);
+    const ordinaryInspection = operands.length === 1 && ['environment', 'project', 'skills'].includes(operands[0]);
     const sectionInspection = operands.length >= 2 && operands[0] === 'section';
     if (!ordinaryInspection && !sectionInspection) {
       fail(
         'CLI_INSPECT_TARGET_REQUIRED',
-        'Command inspect requires project, environment, or section <name>.',
+        'Command inspect requires project, environment, skills, or section <name>.',
       );
     }
   } else if (command === 'hook' && (operands.length !== 1 || !['discover', 'session', 'turn'].includes(operands[0]))) {
@@ -278,6 +286,12 @@ function writeInspection(result) {
 }
 
 function writeResult(command, result) {
+  if (command === 'inspect' && result.inspection === 'skills') {
+    line(process.stdout, `Agent Skills: ${result.status}`);
+    for (const skill of result.skills) line(process.stdout, `  - ${skill.name}: ${skill.status}`);
+    for (const diagnostic of result.diagnostics) line(process.stdout, `${diagnostic.code}: ${diagnostic.message}`);
+    return;
+  }
   if (command === 'templates') {
     if (result.templates) for (const entry of result.templates) line(process.stdout, `${entry.id}: ${entry.name} — ${entry.description}`);
     else {
@@ -419,6 +433,7 @@ async function execute({ command, operands, options }, { signal } = {}) {
     return operands[0] === 'list' ? listTemplates(templateOptions) : applyTemplate({ ...templateOptions, templateId: operands[1] });
   }
   if (command === 'migrate') return migrate({ projectRoot, stackPackages });
+  if (command === 'skills') return syncSkills({ projectRoot, stackPackages });
   if (command === 'adopt') {
     return adoptProject({ projectRoot, request: operands.join(' '), stackPackages });
   }
@@ -496,7 +511,7 @@ async function execute({ command, operands, options }, { signal } = {}) {
         }),
       };
     }
-    const inspections = { environment: inspectEnvironment, project: inspectProject };
+    const inspections = { environment: inspectEnvironment, project: inspectProject, skills: inspectSkills };
     return {
       inspection: operands[0],
       ...await inspections[operands[0]]({ projectRoot, stackPackages }),
@@ -611,7 +626,12 @@ export async function runCli(argv = process.argv.slice(2)) {
       formatDiagnostic,
     );
     if (options.json) line(process.stdout, JSON.stringify(result));
-    else writeResult(parsed.command, result);
+    else {
+      writeResult(parsed.command, result);
+      for (const warning of result.warnings || []) {
+        if (warning.code !== formatDiagnostic?.code) line(process.stderr, `WARNING: ${warning.code}: ${warning.message}`);
+      }
+    }
     return ['blocked', 'failed', 'invalid'].includes(result?.status) ? 2 : 0;
   } catch (error) {
     const diagnostic = asDiagnostic(error);

package/src/index/agent-skills.js

@@ -242,12 +242,12 @@ async function describeSkill(directory, source) {
   };
 }
 
-async function packageDirectory(packageName, resolveFrom = null) {
+async function packageDirectory(packageName, resolveFrom = null, { projectOnly = false } = {}) {
   const roots = [
     ...(resolveFrom
       ? createRequire(path.join(resolveFrom, 'package.json')).resolve.paths(packageName) || []
       : []),
-    ...(require.resolve.paths(packageName) || []),
+    ...(projectOnly ? [] : require.resolve.paths(packageName) || []),
   ];
   for (const modulesRoot of [...new Set(roots)]) {
     const manifest = path.join(modulesRoot, packageName, 'package.json');
@@ -274,7 +274,7 @@ async function packageDirectory(packageName, resolveFrom = null) {
 async function resolveLocator(locator) {
   const root = locator.package
     ? await packageDirectory(locator.package, locator.resolveFrom)
-    : packageRoot;
+    : locator.root || packageRoot;
   const directory = path.join(root, locator.path);
   const source = locator.source || (
     locator.package
@@ -287,9 +287,23 @@ async function resolveLocator(locator) {
 }
 
 /** Resolves the three Genesis workflow skills plus authoritative selected Stack skills. */
-export async function projectSkillPlan(stack) {
+export async function projectSkillPlan(stack, { projectRoot } = {}) {
+  let coreRoot = packageRoot;
+  if (projectRoot) {
+    let manifest;
+    try { manifest = JSON.parse(await readFile(path.join(projectRoot, 'package.json'), 'utf8')); } catch (error) {
+      if (!['ENOENT', 'ENOTDIR'].includes(error?.code)) throw error;
+    }
+    if (manifest?.name === 'genesis-compiler') {
+      coreRoot = projectRoot;
+    } else if (['dependencies', 'devDependencies', 'optionalDependencies'].some((field) => (
+      Object.hasOwn(manifest?.[field] || {}, 'genesis-compiler')
+    ))) {
+      coreRoot = await packageDirectory('genesis-compiler', projectRoot, { projectOnly: true });
+    }
+  }
   const locators = [
-    ...CORE_SKILLS,
+    ...CORE_SKILLS.map((skill) => ({ ...skill, root: coreRoot })),
     ...(stack?.components || []).flatMap((component) => (
       component.skill ? [{ ...component.skill, component: component.id }] : []
     )),
@@ -386,9 +400,19 @@ function targetFiles(skill) {
   return skill.files.map(({ path: file }) => `${SKILLS_ROOT}/${skill.name}/${file}`);
 }
 
+function skillStatus(installed, managed, expected) {
+  if (!installed) return 'missing';
+  if (!managed) return 'unmanaged';
+  if (installed.hash !== managed.hash && installed.hash !== expected.hash) return 'customized';
+  if (installed.hash !== expected.hash || managed.hash !== expected.hash || managed.source !== expected.source) {
+    return 'outdated';
+  }
+  return 'current';
+}
+
 /** Installs only Genesis-owned or authoritative Stack-declared skills. */
 export async function syncProjectSkills({ projectRoot, stack } = {}) {
-  const desired = await projectSkillPlan(stack);
+  const desired = await projectSkillPlan(stack, { projectRoot });
   const desiredNames = new Set(desired.map(({ name }) => name));
   const manifest = await readManifest(projectRoot);
   const changedFiles = [];
@@ -400,13 +424,14 @@ export async function syncProjectSkills({ projectRoot, stack } = {}) {
     const managed = Object.hasOwn(manifest.value.skills, skill.name)
       ? manifest.value.skills[skill.name]
       : null;
-    if (!installed) {
+    const status = skillStatus(installed, managed, skill);
+    if (status === 'missing') {
       await replaceSkill(skill.directory, target);
       manifest.value.skills[skill.name] = { hash: skill.hash, source: skill.source };
       changedFiles.push(...targetFiles(skill));
       continue;
     }
-    if (!managed) {
+    if (status === 'unmanaged') {
       diagnostics.push({
         code: 'AGENT_SKILL_EXTERNAL',
         message: `Preserved existing project Agent Skill ${skill.name}; Genesis does not own it.`,
@@ -414,11 +439,7 @@ export async function syncProjectSkills({ projectRoot, stack } = {}) {
       });
       continue;
     }
-    if (installed.hash !== managed.hash) {
-      if (installed.hash === skill.hash) {
-        manifest.value.skills[skill.name] = { hash: skill.hash, source: skill.source };
-        continue;
-      }
+    if (status === 'customized') {
       diagnostics.push({
         code: 'AGENT_SKILL_CUSTOMIZED',
         message: `Preserved locally modified Agent Skill ${skill.name}.`,
@@ -426,10 +447,12 @@ export async function syncProjectSkills({ projectRoot, stack } = {}) {
       });
       continue;
     }
-    if (installed.hash !== skill.hash || managed.source !== skill.source) {
-      await replaceSkill(skill.directory, target);
+    if (status === 'outdated') {
+      if (installed.hash !== skill.hash) {
+        await replaceSkill(skill.directory, target);
+        changedFiles.push(...targetFiles(installed), ...targetFiles(skill));
+      }
       manifest.value.skills[skill.name] = { hash: skill.hash, source: skill.source };
-      changedFiles.push(...new Set([...targetFiles(installed), ...targetFiles(skill)]));
     }
   }
 
@@ -469,13 +492,14 @@ export async function syncProjectSkills({ projectRoot, stack } = {}) {
 
 /** Inspects the exact project copies without changing them. */
 export async function inspectProjectSkills({ projectRoot, stack } = {}) {
-  const desired = await projectSkillPlan(stack);
+  const desired = await projectSkillPlan(stack, { projectRoot });
   const manifest = await readManifest(projectRoot);
   const diagnostics = [];
   const skills = [];
   let customized = false;
   let invalid = false;
   let missing = false;
+  let outdated = false;
   for (const expected of desired) {
     const target = path.join(projectRoot, SKILLS_ROOT, expected.name);
     let installed;
@@ -488,7 +512,7 @@ export async function inspectProjectSkills({ projectRoot, stack } = {}) {
       missing = true;
       diagnostics.push({
         code: 'AGENT_SKILL_MISSING',
-        message: `Project Agent Skill is missing: ${SKILLS_ROOT}/${expected.name}/SKILL.md.`,
+        message: `Project Agent Skill is missing: ${SKILLS_ROOT}/${expected.name}/SKILL.md. Run \`genesis skills sync\` to install selected skills.`,
         details: { name: expected.name },
       });
       continue;
@@ -496,30 +520,39 @@ export async function inspectProjectSkills({ projectRoot, stack } = {}) {
     const managed = Object.hasOwn(manifest.value.skills, expected.name)
       ? manifest.value.skills[expected.name]
       : null;
-    if (!managed) {
+    const status = skillStatus(installed, managed, expected);
+    if (status === 'unmanaged') {
       customized = true;
       diagnostics.push({
         code: 'AGENT_SKILL_EXTERNAL',
         message: `Project Agent Skill ${expected.name} is externally managed; Genesis preserved it.`,
         details: { name: expected.name, path: `${SKILLS_ROOT}/${expected.name}/SKILL.md` },
       });
-    } else if (installed.hash !== managed.hash && installed.hash !== expected.hash) {
+    } else if (status === 'customized') {
       customized = true;
       diagnostics.push({
         code: 'AGENT_SKILL_CUSTOMIZED',
         message: `Project Agent Skill ${expected.name} differs from its Genesis-managed source.`,
         details: { name: expected.name, path: `${SKILLS_ROOT}/${expected.name}/SKILL.md` },
       });
+    } else if (status === 'outdated') {
+      outdated = true;
+      diagnostics.push({
+        code: 'AGENT_SKILL_OUTDATED',
+        message: `Project Agent Skill ${expected.name} is outdated relative to the installed source. Run \`genesis skills sync\` to update unmodified managed skills.`,
+        details: { name: expected.name, path: `${SKILLS_ROOT}/${expected.name}/SKILL.md` },
+      });
     }
     skills.push({
       name: installed.name,
       description: installed.description,
       path: `${SKILLS_ROOT}/${installed.name}/SKILL.md`,
       component: expected.component,
+      status,
     });
   }
   return {
-    status: invalid ? 'invalid' : missing ? 'missing' : customized ? 'customized' : 'current',
+    status: invalid ? 'invalid' : missing ? 'missing' : outdated ? 'outdated' : customized ? 'customized' : 'current',
     diagnostics,
     skills,
   };

package/src/index/check.js

@@ -140,7 +140,7 @@ export async function checkProject({
   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 (['missing', 'outdated'].includes(skills.status)) guidance.push('Run genesis skills sync to refresh selected project Agent Skills.');
   if (skills.status === 'invalid') guidance.push('Repair the reported Agent Skill or managed-skill manifest.');
   if (missingResources.length > 0) {
     guidance.push(`${missingResources.map(({ message }) => message).join(' ')} Prompt generation remains available.`);
@@ -152,7 +152,7 @@ export async function checkProject({
 
   const needsAttention = program.status === 'missing'
     || engineering.status === 'defaulted'
-    || skills.status === 'missing'
+    || ['missing', 'outdated'].includes(skills.status)
     || missingResources.length > 0
     || extensionDiagnostics.length > 0
     || ['missing', 'stale', 'unconfigured'].includes(verification.status);

package/src/index/collaboration.js

@@ -198,6 +198,10 @@ function collaborationCatalog() {
 
 function collaborationGuidance(value) {
   return [
+    'Apply the configured tone, response length, assumed experience, and explanation style to every user-facing message, including progress updates and final responses.',
+    'Match technical depth and terminology to the configured experience level. Report concrete changes, findings, decisions, or blockers at that level of detail.',
+    'Do not announce that you are following project, UI, Stack, or Agent Skill guidance, or add unsolicited assurances about unrelated behavior staying unchanged. Explain process or scope when the user asks or it matters to a decision or blocker, using the configured style.',
+    '',
     '## Tone',
     '',
     DIMENSIONS.tone[value.tone].guidance,

package/src/index/prompt.js

@@ -27,7 +27,7 @@ const DEFAULT_REQUEST = {
   start: 'Start a conversation about this project.',
   adopt: 'Import the existing project into a truthful Genesis project contract.',
   work: 'Implement the product intent expressed by the current Blueprint.',
-  deslop: 'Deslop the latest commit.',
+  deslop: 'Deslop your own changes for the current task.',
   program: 'Refresh the complete useful Program for the code that exists now.',
   describe: 'Create or refresh the complete Blueprint and useful Program for the codebase that exists now.',
   review: 'Review the complete useful relationship between Blueprint, code, Program, and tests.',

package/src/index/session-context.js

@@ -1,7 +1,8 @@
 import { readCollaboration } from './collaboration.js';
+import { inspectProjectSkills } from './agent-skills.js';
 import { GENESIS_CONTRACTS } from './contracts.js';
 import { readEngineering, readEngineeringBaseline } from './engineering.js';
-import { GenesisError } from './errors.js';
+import { asDiagnostic, GenesisError } from './errors.js';
 import { gitContext } from './git.js';
 import { inspectProject } from './project-inspection.js';
 import { readStack } from './stack.js';
@@ -118,6 +119,11 @@ export async function projectSessionContext({
     inspectProject({ projectRoot: root, stackPackages }),
   ]);
   const availableComponents = await optionalStackComponentIds(root, stack, stackPackages);
+  const skills = stack && inspection.projectFormat.status === 'current'
+    ? await inspectProjectSkills({ projectRoot: root, stack }).catch((error) => ({
+        diagnostics: [asDiagnostic(error)],
+      }))
+    : { diagnostics: [] };
   const selected = stack?.components.map(({ id }) => id) || [];
   const stackStatus = stack
     ? (selected.length > 0 ? selected.join(', ') : 'none')
@@ -140,11 +146,13 @@ export async function projectSessionContext({
     '- When the user names an unselected technology that exactly matches this catalog, run `genesis stack list`, ask whether to add and prepare it, and wait for confirmation. If confirmed, run `genesis stack add <piece...>` and follow its returned preparation prompt in the same task; then use `genesis context` and any installed technology skill. Never infer dependency commands from a component id. If declined or unmatched, continue through authoritative technology documentation without inventing a component.',
     '- Project-owned operation sections in `genesis/stack.md` are the durable application contract. Make the implementation satisfy them or update a complete section to match evidenced reality; Genesis executes only Verification.',
     '- Use the relevant project Agent Skills below `.agents/skills/`.',
+    ...skills.diagnostics.map(({ message }) => `- Agent Skill maintenance: ${message}`),
+    ...(skills.diagnostics.length > 0 ? ['- Skill inspection is read-only. Synchronization is an explicit source change; follow the current task authorization and host write boundary before running it.'] : []),
     '- After locating source, run `genesis context <path...>`; before adding a helper or public operation, run `genesis index <name-or-path...>` and reuse an existing owner.',
     '- Program is fallible explanation; code, tests, and runtime behavior remain evidence.',
     '- Keep Blueprint and affected Program explanations aligned with intentional observable product behavior in the same implementation turn. Private restructuring may need only source citations or no explanatory change.',
     '- Before reporting completion, compare the requested observable behavior, required inputs and resources, declared project operations, and focused evidence with what actually exists. State anything not proven.',
-    '- Deslop only when explicitly requested. Genesis defines its behavior-preserving committed scope; selected Stack components may add technology-specific cleanup guidance.',
+    '- Deslop only when explicitly requested. By default, clean up your own changes for the current task, committed or uncommitted; explicit commits or ranges take precedence. Preserve behavior, unrelated work, and existing staging; a dirty worktree is allowed. Selected Stack components may add technology-specific cleanup guidance.',
     '- This guidance is loaded for a new session and refreshed after compaction. Continue the active request without restarting completed work.',
     `Engineering profile: ${engineering.profile?.id || 'invalid; run the Genesis `check` operation'}.`,
     `Selected Stack components: ${stackStatus}.`,
@@ -158,7 +166,7 @@ export async function projectSessionContext({
     collaboration.guidance,
     ...(hostContext ? ['', 'HOST CONTEXT', '', hostContext] : []),
   ].join('\n');
-  return composedContext(GENESIS_CONTRACTS.sessionContext, output);
+  return { ...composedContext(GENESIS_CONTRACTS.sessionContext, output), warnings: skills.diagnostics };
 }
 
 export async function projectTurnContext({ hostDriver, hostDriverInput } = {}) {

package/src/index.js

@@ -1,6 +1,9 @@
 import path from 'node:path';
 
 import { checkProject } from './index/check.js';
+import { inspectProjectSkills, syncProjectSkills } from './index/agent-skills.js';
+import { gitContext } from './index/git.js';
+import { inspectProjectFormatAtRoot, requireCurrentProjectFormat } from './index/project-format.js';
 import { buildProjectIndex, GENESIS_DERIVED_ARTIFACTS } from './index/code-index.js';
 import {
   inspectProjectCollaboration,
@@ -200,3 +203,23 @@ export function verify(options) {
 export function check(options) {
   return checkProject(options);
 }
+
+async function projectSkillContext({ projectRoot = process.cwd(), stackPackages = [] } = {}) {
+  const root = (await gitContext(projectRoot)).repositoryRoot;
+  requireCurrentProjectFormat(await inspectProjectFormatAtRoot(root), { allowUninitialized: true });
+  return { projectRoot: root, stack: await readStack(root, { stackPackages }) };
+}
+
+export async function inspectSkills(options) {
+  return inspectProjectSkills(await projectSkillContext(options));
+}
+
+export async function syncSkills(options) {
+  const context = await projectSkillContext(options);
+  const result = await syncProjectSkills(context);
+  return {
+    ...result,
+    inspection: await inspectProjectSkills(context),
+    guidance: 'Review changed skills in the ordinary Git diff. An assistant that already loaded them needs its supported context refresh before using the new guidance.',
+  };
+}