genesis-compiler 1.10.10 → 1.10.12

package/src/index/project-inspection.js

@@ -34,6 +34,7 @@ export const GENESIS_BOOTSTRAP_PATHS = Object.freeze([
     `.agents/skills/${name}/SKILL.md`,
     `.agents/skills/${name}/agents/openai.yaml`,
   ]),
+  '.agents/skills/genesis-project/references/sanity-checks.md',
 ]);
 const bootstrapPaths = new Set(GENESIS_BOOTSTRAP_PATHS);
 // Genesis creates .gitignore only to ignore its Cities; any other content is the project's.
@@ -50,22 +51,39 @@ async function isBootstrapGitignore(projectRoot, paths) {
   }
 }
 
-export async function inspectProjectContent(projectRoot) {
+async function listFiles(projectRoot, options) {
   // Exclude dependency paths in Git before collecting and sorting its output.
-  const sourcePaths = ['--', '.', ':(exclude,glob)**/node_modules/**'];
+  const { stdout } = await runGit(projectRoot, ['ls-files', '-z', ...options, '--', '.', ':(exclude,glob)**/node_modules/**']);
+  return stdout.toString('utf8').split('\0').filter(Boolean);
+}
+
+/**
+ * With kindOnly, only `kind` is returned. Listing ignored files walks ignored dependency trees such as node_modules
+ * despite the exclusion, which dominates the inspection of an installed application, so it is skipped when Git's
+ * visible files already include project content: ignored files can add existing content, never remove it.
+ */
+export async function inspectProjectContent(projectRoot, { kindOnly = false } = {}) {
+  const listIgnored = () => listFiles(projectRoot, ['--others', '--ignored', '--exclude-standard']);
   const [visible, deleted, ignored] = await Promise.all([
-    runGit(projectRoot, ['ls-files', '-z', '--cached', '--others', '--exclude-standard', ...sourcePaths]),
-    runGit(projectRoot, ['ls-files', '-z', '--deleted', ...sourcePaths]),
-    runGit(projectRoot, ['ls-files', '-z', '--others', '--ignored', '--exclude-standard', ...sourcePaths]),
+    listFiles(projectRoot, ['--cached', '--others', '--exclude-standard']),
+    listFiles(projectRoot, ['--deleted']),
+    kindOnly ? [] : listIgnored(),
   ]);
-  const absent = new Set(deleted.stdout.toString('utf8').split('\0').filter(Boolean));
-  const paths = [...new Set([visible, ignored].flatMap(({ stdout }) => stdout.toString('utf8').split('\0').filter(Boolean)))]
+  if (!kindOnly) return classifyContent(projectRoot, visible, deleted, ignored);
+  const { kind } = await classifyContent(projectRoot, visible, deleted, []);
+  if (kind === 'existing') return { kind };
+  return { kind: (await classifyContent(projectRoot, visible, deleted, await listIgnored())).kind };
+}
+
+async function classifyContent(projectRoot, visible, deleted, ignored) {
+  const absent = new Set(deleted);
+  const paths = [...new Set([...visible, ...ignored])]
     .filter((file) => !absent.has(file) && file !== '.git' && !file.startsWith('.git/'))
     .sort();
   // OpenCode installs its plugin dependency beside the generated guidance plugin.
   // Recognize only its exact ignored scaffolding, never an authored config tree.
   const opencodePaths = ['.opencode/.gitignore', '.opencode/package.json', '.opencode/package-lock.json'];
-  const ignoredPaths = new Set(ignored.stdout.toString('utf8').split('\0').filter(Boolean));
+  const ignoredPaths = new Set(ignored);
   let opencodeBootstrap = [];
   if (opencodePaths.every((file) => ignoredPaths.has(file))) {
     try {
@@ -99,15 +117,19 @@ export async function inspectProjectContent(projectRoot) {
 
 /** Read-only opening inspection: no index generation, verification, or application execution. */
 export async function inspectProject({ projectRoot, stackPackages = [] } = {}) {
-  const root = (await gitContext(projectRoot)).repositoryRoot;
+  return inspectProjectAtRoot((await gitContext(projectRoot)).repositoryRoot, { stackPackages });
+}
+
+/** The same inspection of a resolved repository root; without `count`, content reports only its kind. */
+export async function inspectProjectAtRoot(root, { stackPackages = [], count = true } = {}) {
   const [content, format] = await Promise.all([
-    inspectProjectContent(root),
+    inspectProjectContent(root, { kindOnly: !count }),
     inspectProjectFormatAtRoot(root),
   ]);
   const result = {
     contract: GENESIS_CONTRACTS.projectInspection,
     state: 'attention',
-    content: { kind: content.kind, count: content.existingPaths.length },
+    content: count ? { kind: content.kind, count: content.existingPaths.length } : { kind: content.kind },
     projectFormat: format,
     templateEligible: false,
     stackComponents: [],

package/src/index/session-context.js

@@ -2,17 +2,12 @@ import { readCollaboration } from './collaboration.js';
 import { inspectProjectSkills, renderAgentSkillCatalog } from './agent-skills.js';
 import { GENESIS_CONTRACTS } from './contracts.js';
 import { readEngineering, readEngineeringBaseline } from './engineering.js';
-import { asDiagnostic, GenesisError } from './errors.js';
+import { asDiagnostic } from './errors.js';
 import { gitContext } from './git.js';
-import { inspectProject } from './project-inspection.js';
+import { inspectProjectAtRoot } from './project-inspection.js';
 import { readStack } from './stack.js';
 import { listStackCatalogPieces } from './stack-catalog.js';
-import { normalizeSource, sha256, stableJson } from './utils.js';
-
-const HOST_CONTEXT_MAX_BYTES = Object.freeze({
-  session: 24 * 1024,
-  turn: 512,
-});
+import { composedContext, hostContextContribution } from './host-context.js';
 
 async function optionalStack(projectRoot, stackPackages) {
   try { return await readStack(projectRoot, { stackPackages }); } catch { return null; }
@@ -47,53 +42,6 @@ async function optionalCollaboration(projectRoot) {
   }
 }
 
-async function hostContextContribution({ hostDriver, hostDriverInput, scope }) {
-  if (hostDriver === undefined || hostDriver === null) {
-    if (hostDriverInput !== undefined) {
-      throw new GenesisError(
-        'HOST_CONTEXT_INVALID',
-        'Host context input requires an explicitly registered host driver.',
-      );
-    }
-    return '';
-  }
-  if (typeof hostDriver !== 'function') {
-    throw new GenesisError('HOST_CONTEXT_INVALID', 'The registered host driver must be a function.');
-  }
-  if (
-    !hostDriverInput
-    || typeof hostDriverInput !== 'object'
-    || Array.isArray(hostDriverInput)
-    || hostDriverInput.scope !== scope
-  ) {
-    throw new GenesisError(
-      'HOST_CONTEXT_INVALID',
-      `The ${scope} context lane requires host input with scope \`${scope}\`.`,
-    );
-  }
-  const value = await hostDriver(hostDriverInput);
-  if (typeof value !== 'string') {
-    throw new GenesisError('HOST_CONTEXT_INVALID', 'The registered host driver must return plain text.');
-  }
-  const output = normalizeSource(value).trim();
-  if (Buffer.byteLength(output, 'utf8') > HOST_CONTEXT_MAX_BYTES[scope]) {
-    throw new GenesisError(
-      'HOST_CONTEXT_INVALID',
-      `The registered host driver's ${scope} contribution exceeds ${HOST_CONTEXT_MAX_BYTES[scope]} bytes.`,
-    );
-  }
-  return output;
-}
-
-function composedContext(contract, output) {
-  return {
-    contract,
-    status: 'ready',
-    output,
-    identity: sha256(stableJson({ contract, output })),
-  };
-}
-
 async function optionalStackComponentIds(projectRoot, stack, stackPackages) {
   try {
     const packages = [...new Set([...(stack?.stackPackages || []), ...stackPackages])];
@@ -116,7 +64,8 @@ export async function projectSessionContext({
     optionalCollaboration(root),
     optionalEngineering(root),
     hostContextContribution({ hostDriver, hostDriverInput, scope: 'session' }),
-    inspectProject({ projectRoot: root, stackPackages }),
+    // The opening state needs only the content kind, not a count of every ignored file.
+    inspectProjectAtRoot(root, { stackPackages, count: false }),
   ]);
   const availableComponents = await optionalStackComponentIds(root, stack, stackPackages);
   const skills = stack && inspection.projectFormat.status === 'current'
@@ -172,14 +121,4 @@ export async function projectSessionContext({
   return { ...composedContext(GENESIS_CONTRACTS.sessionContext, output), warnings: skills.diagnostics };
 }
 
-export async function projectTurnContext({ hostDriver, hostDriverInput } = {}) {
-  const output = await hostContextContribution({
-    hostDriver,
-    hostDriverInput,
-    scope: 'turn',
-  });
-  return {
-    ...composedContext(GENESIS_CONTRACTS.turnContext, output),
-    trust: 'untrusted',
-  };
-}
+export { projectTurnContext } from './host-context.js';

package/src/index/stack-catalog.js

@@ -7,11 +7,39 @@ import {
   normalizeStackPieceId,
   parseStackPieceSource,
 } from './stack-piece.js';
+import { sha256 } from './utils.js';
 
 const require = createRequire(import.meta.url);
 const PACKAGE_NAME = /^(?:@[a-z0-9._-]+\/)?[a-z0-9._-]+$/u;
 const FIRST_PARTY_STACK_PACKAGE = 'genesis-stack';
 
+// Parsed catalogue pieces by source text. One operation reads the catalogue several times (the Stack, then the code
+// index, context and prompts each read it again), and every read parsed every piece. A parse depends only on the text,
+// the expected id and the path its errors name, so each distinct piece is parsed once per process; the result is
+// frozen so no reader can change what another reads. Every read still reads each file, so an edited piece is parsed
+// again, and a piece that fails to parse is never kept.
+const MAX_PARSED_PIECES = 512;
+const parsedPieces = new Map();
+
+function deepFreeze(value) {
+  if (value && typeof value === 'object' && !Object.isFrozen(value)) {
+    Object.freeze(value);
+    for (const child of Object.values(value)) deepFreeze(child);
+  }
+  return value;
+}
+
+function parsedStackPiece(source, expectedId, piecePath) {
+  const key = `${sha256(source)}\0${expectedId}\0${piecePath}`;
+  let piece = parsedPieces.get(key);
+  if (!piece) {
+    piece = deepFreeze(parseStackPieceSource(source, { expectedId, path: piecePath }));
+    if (parsedPieces.size >= MAX_PARSED_PIECES) parsedPieces.delete(parsedPieces.keys().next().value);
+    parsedPieces.set(key, piece);
+  }
+  return piece;
+}
+
 export function normalizeStackPackageName(value) {
   const name = String(value ?? '').trim();
   if (!PACKAGE_NAME.test(name)) {
@@ -94,7 +122,7 @@ async function readPieceDirectory(
   return Promise.all(files.map(async (file) => {
     const id = normalizeStackPieceId(file.slice(0, -3));
     const source = await readFile(path.join(directory, file), 'utf8');
-    const piece = parseStackPieceSource(source, { expectedId: id, path: `${sourcePrefix}:${id}` });
+    const piece = parsedStackPiece(source, id, `${sourcePrefix}:${id}`);
     return {
       ...piece,
       skill: piece.skill === null ? null : { ...piece.skill, resolveFrom: stackPackageRoot },

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

@@ -1,8 +1,5 @@
-import { realpath, stat } from 'node:fs/promises';
-import path from 'node:path';
-
 import { GENESIS_CONTRACTS } from './contracts.js';
-import { gitContext } from './git.js';
+import { inspectionRoot } from './git.js';
 import { readStack } from './stack.js';
 import { normalizeStackSectionName } from './stack-section.js';
 import { sha256, stableJson } from './utils.js';
@@ -29,18 +26,7 @@ export async function inspectProjectStackSections({
   if (new Set(sectionNames).size !== sectionNames.length) {
     throw new TypeError('Stack section inspection requires distinct names.');
   }
-  let root;
-  if (rootMode === 'repository') {
-    root = (await gitContext(projectRoot)).repositoryRoot;
-  } else if (rootMode === 'directory') {
-    if (typeof projectRoot !== 'string' || !path.isAbsolute(projectRoot)) {
-      throw new TypeError('Directory inspection requires an explicit absolute projectRoot.');
-    }
-    root = await realpath(projectRoot);
-    if (!(await stat(root)).isDirectory()) throw new TypeError('Directory inspection requires a directory.');
-  } else {
-    throw new TypeError('Stack section rootMode must be repository or directory.');
-  }
+  const root = await inspectionRoot({ projectRoot, rootMode, subject: 'Stack section' });
   const stack = await readStack(root, { stackPackages });
   return sectionNames.map((sectionName) => {
     const section = stack.extensions.find((candidate) => candidate.name === sectionName);

package/src/index/template-source.js

@@ -17,6 +17,29 @@ function validateRepository(repository) {
   }
 }
 
+/** Read every listed blob through one `git cat-file --batch` process, in listing order. */
+async function readBlobs(root, entries) {
+  if (entries.length === 0) return [];
+  const { stdout } = await runGit(root, ['cat-file', '--batch'], {
+    input: `${entries.map(({ object }) => object).join('\n')}\n`,
+    // Each blob is preceded by "<object> blob <size>\n" and followed by "\n".
+    maxBytes: entries.reduce((total, { size }) => total + size + 128, 0),
+  });
+  const blobs = [];
+  let offset = 0;
+  for (const { object, size } of entries) {
+    const headerEnd = stdout.indexOf(0x0a, offset);
+    const header = headerEnd === -1 ? '' : stdout.subarray(offset, headerEnd).toString('utf8');
+    const start = headerEnd + 1;
+    if (header !== `${object} blob ${size}` || stdout.length < start + size + 1) {
+      throw new GenesisError('TEMPLATE_SOURCE_INVALID', `Git did not return template blob ${object}.`);
+    }
+    blobs.push(stdout.subarray(start, start + size));
+    offset = start + size + 1;
+  }
+  return blobs;
+}
+
 /**
  * Fetch a branch once and read ordinary blobs; never execute or check out remote hooks/filters.
  * The scratch repository is created below scratchRoot (the system temporary directory by default).
@@ -32,31 +55,43 @@ export async function readGitSnapshot({ repository, branch, scratchRoot = os.tmp
     await runGit(temporaryRoot, ['check-ref-format', `refs/heads/${branch}`]);
     await runGit(temporaryRoot, ['fetch', '--quiet', '--depth=1', '--no-tags', '--', repository, `refs/heads/${branch}`], { timeoutMs: 120_000 });
     const revision = await runGitText(temporaryRoot, ['rev-parse', 'FETCH_HEAD^{commit}']);
-    const tree = await runGit(temporaryRoot, ['ls-tree', '-rz', '--full-tree', revision]);
-    const files = [];
+    // The long listing carries each blob's size, so the limits hold before any content is read.
+    const tree = await runGit(temporaryRoot, ['ls-tree', '-rlz', '--full-tree', revision]);
+    const entries = [];
     let bytes = 0;
+    let fileCount = 0;
     for (const item of tree.stdout.toString('utf8').split('\0').filter(Boolean)) {
       const separator = item.indexOf('\t');
-      const [mode, type, object] = item.slice(0, separator).split(' ');
+      const [mode, type, object, size] = item.slice(0, separator).split(/ +/u);
       const name = item.slice(separator + 1);
       if (!['100644', '100755', '120000'].includes(mode) || type !== 'blob' || path.isAbsolute(name)
         || name.includes('\\') || name.split('/').some((part) => !part || ['.', '..', '.git'].includes(part.toLowerCase()))) {
         throw new GenesisError('TEMPLATE_TREE_INVALID', `Template contains an unsupported path or file: ${name}.`);
       }
-      const blob = await runGit(temporaryRoot, ['cat-file', 'blob', object]);
+      if (mode === '120000') {
+        // Only short Claude skill links are accepted; never read a large one.
+        if (Number(size) > 1024) throw new GenesisError('TEMPLATE_TREE_INVALID', `Template contains an unsupported link: ${name}.`);
+      } else {
+        bytes += Number(size);
+        fileCount += 1;
+        if (bytes > 64 * 1024 * 1024 || fileCount > 10_000) {
+          throw new GenesisError('TEMPLATE_TREE_TOO_LARGE', 'Template exceeds the source size limit.');
+        }
+      }
+      entries.push({ mode, object, name, size: Number(size) });
+    }
+    const blobs = await readBlobs(temporaryRoot, entries);
+    const files = [];
+    for (const [index, { mode, name }] of entries.entries()) {
       if (mode === '120000') {
         const target = claudeSkillLinkTarget(name);
-        if (!target || !blob.stdout.equals(Buffer.from(target))) {
+        if (!target || !blobs[index].equals(Buffer.from(target))) {
           throw new GenesisError('TEMPLATE_TREE_INVALID', `Template contains an unsupported link: ${name}.`);
         }
         // Regenerate these through initialization from the canonical skill files.
         continue;
       }
-      bytes += blob.stdout.length;
-      if (bytes > 64 * 1024 * 1024 || files.length >= 10_000) {
-        throw new GenesisError('TEMPLATE_TREE_TOO_LARGE', 'Template exceeds the source size limit.');
-      }
-      files.push({ path: name, contents: blob.stdout, mode: mode === '100755' ? 0o777 : 0o666 });
+      files.push({ path: name, contents: blobs[index], mode: mode === '100755' ? 0o777 : 0o666 });
     }
     return { repository, branch, revision, files };
   } finally { await rm(temporaryRoot, { recursive: true, force: true }); }