genesis-compiler 1.2.29 → 1.3.1

package/README.md

@@ -24,6 +24,7 @@ The useful mental model is:
 genesis/
   version            project-file format version used for deterministic migrations
   blueprint.md       non-technical product intent
+  collaboration.md   project-wide communication choices and authored requirements
   engineering.md     selected engineering profile and project-specific requirements
   stack.md           selected components, resources, verification, and project-owned operation contracts
   stack/             optional per-component Description, Guidance, Adoption, Post-change, and Deslop customization
@@ -237,6 +238,60 @@ Project-scoped options follow the command, for example
 a host or script needs the normalized result. Run `genesis --help` for the
 compact CLI synopsis.
 
+## Collaboration approach
+
+Genesis keeps project-wide communication guidance in ordinary source rather
+than in a host-private policy or a repeated user-message prefix:
+
+```markdown
+# Collaboration approach
+
+## Tone
+
+- `encouraging`
+
+## Response length
+
+- `concise`
+
+## Assumed experience
+
+- `comfortable`
+
+## Explanation style
+
+- `concise`
+
+## Project requirements
+
+- Nothing.
+```
+
+Inspect or change it without parsing Markdown yourself:
+
+```bash
+genesis collaboration show
+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.`.
+
+Persistent hosts should install `projectSessionContext()` once when a provider
+conversation is created or refreshed. They may then generate task prompts with
+`sessionContextInstalled: true`, preventing the stable Collaboration and
+Engineering guidance from being repeated in each task. A host can supply one
+explicit session/turn driver; Genesis performs no driver discovery and labels
+turn output untrusted. If the project-local Codex or OpenCode adapter runs in a
+separate process, the host may set `GENESIS_HOST_CONTEXT_RESOLVER` to one
+executable and optionally supply opaque JSON in
+`GENESIS_HOST_CONTEXT_RESOLVER_DATA`. Session and turn hooks pass only the
+requested lane, native provider session id, and that configured data to the
+executable. Session output is composed into stable context; a nonempty turn
+result is capped at 512 bytes, labeled untrusted, and kept separate from the
+authored user message. This is a single process bridge, not a plugin registry.
+
 ## Engineering approach
 
 Every profile inherits one universal rule: implementation must remain easy to
@@ -780,7 +835,8 @@ genesis migrate
 
 Migration is deterministic and forward-only. The format 2 migration snapshots
 the previously effective Stack operations into project-owned sections before
-removing component-runtime fallback. Migration also synchronizes managed skills
+removing component-runtime fallback; format 3 adds the portable Collaboration
+declaration. Migration also synchronizes managed skills
 and hooks, regenerates derived indexes, and then returns a fresh `check`
 result. A newer project is never downgraded. Every project-scoped CLI
 invocation warns when the recorded format does not match the running CLI, and
@@ -797,6 +853,7 @@ import {
   getContext,
   indexCodebase,
   initialize,
+  inspectCollaboration,
   inspectEngineering,
   inspectEnvironment,
   inspectStackSection,
@@ -804,6 +861,9 @@ import {
   listEngineeringProfiles,
   listStackPieces,
   migrate,
+  projectSessionContext,
+  projectTurnContext,
+  setCollaboration,
   setEngineeringProfile,
   verify,
 } from 'genesis-compiler';
@@ -818,6 +878,12 @@ codebase. `installCodex()` installs the optional global discovery plugin.
 `listEngineeringProfiles()`, `inspectEngineering()`, and
 `setEngineeringProfile()` expose the same built-in catalog and portable
 project selection used by the CLI and hosts.
+`inspectCollaboration()` and `setCollaboration()` expose the portable
+communication declaration and Genesis-owned choice expansions.
+`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
+text.
 `getContext()` resolves source paths to the Program modules that cite them,
 the functions already declared there, selected Stack guidance, available Agent
 Skills, and verification commands. `indexCodebase()` regenerates or returns the
@@ -829,8 +895,9 @@ projection paths without returning any supplied environment value.
 interpreting or executing its contents.
 
 Normalized results identify their stable public contract in the `contract`
-field: `genesis.engineering.v1`, `genesis.environment.v2`,
-`genesis.stack-section.v1`, or
+field: `genesis.collaboration.v1`, `genesis.engineering.v1`,
+`genesis.environment.v2`, `genesis.session-context.v1`,
+`genesis.stack-section.v1`, `genesis.turn-context.v1`, or
 `genesis.verification.v1`. A consumer defines any schema embedded inside the
 opaque section body.
 

package/docs/prompt-integration.md

@@ -15,6 +15,81 @@ const work = await generatePrompt({
 await currentAgent.send(work.prompt);
 ```
 
+A persistent host installs stable context separately and keeps ordinary user
+text unchanged:
+
+```js
+import {
+  generatePrompt,
+  projectSessionContext,
+  projectTurnContext,
+} from 'genesis-compiler';
+
+const sessionContext = await projectSessionContext({
+  projectRoot,
+  hostDriver,
+  hostDriverInput: {
+    scope: 'session',
+    conversationKind: 'main',
+    session: { managedPreview: true },
+  },
+});
+await provider.installTrustedSessionContext(sessionContext.output);
+
+const task = await generatePrompt({
+  projectRoot,
+  task: 'work',
+  request: userMessage,
+  sessionContextInstalled: true,
+});
+const turnContext = await projectTurnContext({
+  hostDriver,
+  hostDriverInput: {
+    scope: 'turn',
+    actor: { preferredAddressName: 'Merc' },
+  },
+});
+await provider.sendUserTurn({
+  text: task.prompt,
+  untrustedContext: turnContext.output,
+});
+```
+
+The provider method names above are illustrative. Genesis supplies semantic
+session and untrusted-turn results; the host's provider adapter owns their
+native placement. The driver never receives or rewrites `userMessage`, and
+Genesis supports only the one explicitly supplied driver—there is no discovery
+or plugin registry.
+
+When the project-local Codex or OpenCode adapter runs in a separate process,
+the host can configure that same one-driver boundary without adding another
+prompt compositor:
+
+```text
+GENESIS_HOST_CONTEXT_RESOLVER=/path/to/host-context-resolver
+GENESIS_HOST_CONTEXT_RESOLVER_DATA={"registry":"/runtime/host-sessions.json"}
+```
+
+For `genesis hook session`, Genesis invokes that one executable with bounded
+JSON on stdin:
+
+```json
+{
+  "scope": "session",
+  "providerSessionId": "native-session-id",
+  "data": { "registry": "/runtime/host-sessions.json" }
+}
+```
+
+For `genesis hook turn`, the input has the same shape with `scope: "turn"`.
+The executable returns only the requested host contribution as text. Codex's
+hook input and OpenCode's transform callbacks supply the native session id;
+Genesis extracts that id but does not understand the host registry or the
+provider's prompt-placement rules. The Codex prompt hook and OpenCode message
+transform place a nonempty turn result separately from authored user text. If
+no resolver is configured, both turn paths are empty and the adapters render
+ordinary Genesis session context exactly as before.
+
 Tasks are `start`, `adopt`, `work`, `deslop`, `program`, `blueprint`, `describe`, and `review`.
 `start` is the host-independent first conversation: it classifies an initialized
 project from its selected Stack and Git-visible project paths without building
@@ -48,6 +123,9 @@ Genesis keeps each instruction at one useful level:
   structural Indexers, and an optional authoritative Agent Skill source.
 - `genesis/blueprint.md`, `genesis/program/`, and `genesis/stack.md` are the
   project's own intent, explanation, and selected technical composition.
+- `genesis/collaboration.md` selects Genesis-owned tone, response-length,
+  assumed-experience, and explanation-style instructions plus optional authored
+  project requirements.
 - `profiles/engineering/*.md` owns the installed versioned engineering
   profiles. `genesis/engineering.md` selects one profile and records explicit
   project requirements. A universal complexity gate is composed ahead of the
@@ -97,6 +175,21 @@ requests another model turn. Selected `Post-change` contributions are included
 in the original implementation prompt, whose project skill also keeps
 intentional Blueprint and affected Program changes aligned.
 
+An out-of-process host may configure the single resolver described above. Each
+adapter passes only its native session id to Genesis; Genesis sends that id,
+the requested lane, and explicitly configured opaque data to the resolver.
+Session output is composed with the stable guide; turn output remains a small
+untrusted item beside a selected real user turn. This is one process bridge,
+not a driver or plugin registry.
+
+Hosts that own a persistent provider conversation can call
+`projectSessionContext()` directly and pass at most one explicit host driver.
+The complete result includes Genesis Collaboration and Engineering guidance and
+has a stable identity. `projectTurnContext()` calls that driver only for a real
+turn selected by the host and labels its separate result untrusted. Hosts use
+`sessionContextInstalled: true` for task prompts only after installing the
+session result; the default command-line prompt remains self-contained.
+
 The operating guide dynamically lists only the component ids in the currently
 available Stack catalogs. The naked CLI uses an explicitly installed
 first-party `genesis-stack` package as its initial catalog without exposing the

package/package.json

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

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

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

package/plugins/opencode/project-guidance.js

@@ -5,12 +5,18 @@ import { promisify } from "node:util";
 
 const execute = promisify(execFile);
 
-async function renderProjectContext(projectRoot) {
+const HOST_CONTEXT_INPUT_ENV = "GENESIS_HOST_CONTEXT_INPUT";
+
+async function renderContext(projectRoot, sessionId, scope) {
   const { stdout } = await execute(
     "genesis",
-    ["hook", "session", "--project-root", projectRoot],
+    ["hook", scope, "--project-root", projectRoot],
     {
       cwd: projectRoot,
+      env: {
+        ...process.env,
+        [HOST_CONTEXT_INPUT_ENV]: JSON.stringify({ sessionId })
+      },
       maxBuffer: 256 * 1024,
       timeout: 5_000
     }
@@ -25,13 +31,13 @@ function eventSessionId(event = {}) {
 }
 
 export const GenesisProjectGuidance = async ({ directory, worktree } = {}) => {
-  const projectRoot = path.resolve(worktree || directory || process.cwd());
+  const projectRoot = path.resolve(directory || worktree || process.cwd());
   const contexts = new Map();
 
   function contextForSession(sessionId) {
     let context = contexts.get(sessionId);
     if (!context) {
-      context = renderProjectContext(projectRoot);
+      context = renderContext(projectRoot, sessionId, "session");
       contexts.set(sessionId, context);
       context.catch(() => {
         if (contexts.get(sessionId) === context) contexts.delete(sessionId);
@@ -50,7 +56,37 @@ export const GenesisProjectGuidance = async ({ directory, worktree } = {}) => {
       const sessionId = String(input.sessionID || input.sessionId || "").trim();
       if (!sessionId) return;
       const context = await contextForSession(sessionId);
-      if (!output.system.includes(context)) output.system.push(context);
+      if (context && !output.system.includes(context)) output.system.push(context);
+    },
+    "experimental.chat.messages.transform": async (...hookArguments) => {
+      const output = hookArguments[1] || {};
+      const messages = Array.isArray(output.messages) ? output.messages : [];
+      const messageIndex = messages.findLastIndex((message) => message?.info?.role === "user");
+      if (messageIndex < 0) return;
+      const message = messages[messageIndex];
+      const sessionId = String(message.info?.sessionID || "").trim();
+      const messageId = String(message.info?.id || "").trim();
+      if (!sessionId || !messageId || !Array.isArray(message.parts)) return;
+      const context = await renderContext(projectRoot, sessionId, "turn");
+      if (!context || message.parts.some((part) => part?.synthetic === true && part?.text === context)) {
+        return;
+      }
+      output.messages = messages.map((candidate, index) => index === messageIndex
+        ? {
+            ...candidate,
+            parts: [
+              ...candidate.parts,
+              {
+                id: `${messageId}_genesis_turn_context`,
+                messageID: messageId,
+                sessionID: sessionId,
+                synthetic: true,
+                text: context,
+                type: "text"
+              }
+            ]
+          }
+        : candidate);
     }
   };
 };

package/skills/genesis-deslop/SKILL.md

@@ -8,12 +8,23 @@ description: Deslop committed work through an explicit behavior-preserving clean
 Review and simplify committed work without changing product behavior. Deslop is
 explicit: never run it merely because implementation finished.
 
-When this repository is Genesis itself or has `genesis-compiler` installed
-locally, invoke every Genesis CLI operation through the project-pinned package:
-`npm exec --no -- genesis <arguments>`. This runs without fetching another
-package. Otherwise use `genesis <arguments>` only when that executable is
-already available on `PATH`. Never install or update Genesis merely to satisfy
-a workflow instruction.
+Resolve the invocation before running the first Genesis operation. Do not use a
+Genesis operation or `genesis --version` as an availability probe.
+
+1. Read the repository-root `package.json`. Treat Genesis as project-pinned only
+   when that manifest's `name` is `genesis-compiler`, or its `dependencies`,
+   `devDependencies`, or `optionalDependencies` contain the exact
+   `genesis-compiler` key.
+2. For a project-pinned repository, invoke every Genesis CLI operation with
+   `npm exec --no -- genesis <arguments>`. This runs without fetching another
+   package. If the declared package is not installed, report that the project's
+   dependencies are not prepared; do not fall back to another Genesis version.
+3. Otherwise, do not try `npm exec`. Run `command -v genesis` (or the current
+   shell's equivalent `PATH` lookup). When it resolves an executable, invoke
+   `genesis <arguments>` directly.
+4. When neither source is available, stop and report that Genesis is
+   unavailable. Never install or update Genesis merely to satisfy a workflow
+   instruction.
 
 ## Load the effective project instructions once
 

package/skills/genesis-project/SKILL.md

@@ -25,12 +25,23 @@ one exact investigation.
 
 ## Run Genesis commands
 
-When this repository is Genesis itself or has `genesis-compiler` installed
-locally, invoke every Genesis CLI operation through the project-pinned package:
-`npm exec --no -- genesis <arguments>`. This runs without fetching another
-package. Otherwise use `genesis <arguments>` only when that executable is
-already available on `PATH`. Never install or update Genesis merely to satisfy
-a workflow instruction.
+Resolve the invocation before running the first Genesis operation. Do not use a
+Genesis operation or `genesis --version` as an availability probe.
+
+1. Read the repository-root `package.json`. Treat Genesis as project-pinned only
+   when that manifest's `name` is `genesis-compiler`, or its `dependencies`,
+   `devDependencies`, or `optionalDependencies` contain the exact
+   `genesis-compiler` key.
+2. For a project-pinned repository, invoke every Genesis CLI operation with
+   `npm exec --no -- genesis <arguments>`. This runs without fetching another
+   package. If the declared package is not installed, report that the project's
+   dependencies are not prepared; do not fall back to another Genesis version.
+3. Otherwise, do not try `npm exec`. Run `command -v genesis` (or the current
+   shell's equivalent `PATH` lookup). When it resolves an executable, invoke
+   `genesis <arguments>` directly.
+4. When neither source is available, stop and report that Genesis is
+   unavailable. Never install or update Genesis merely to satisfy a workflow
+   instruction.
 
 ## Resolve explicit technology choices
 

package/src/cli.js

@@ -9,6 +9,7 @@ import {
   getContext,
   indexCodebase,
   initialize,
+  inspectCollaboration,
   inspectEngineering,
   inspectEnvironment,
   inspectStackSection,
@@ -16,6 +17,7 @@ import {
   listEngineeringProfiles,
   listStackPieces,
   migrate,
+  setCollaboration,
   setEngineeringProfile,
   verify,
 } from './index.js';
@@ -24,11 +26,17 @@ import {
 } from './index/codex-hooks.js';
 import { engineeringProfile, readEngineeringBaseline } from './index/engineering.js';
 import { asDiagnostic, fail } from './index/errors.js';
+import {
+  HOST_CONTEXT_INPUT_ENV,
+  HOST_CONTEXT_RESOLVER_ENV,
+  SESSION_CONTEXT_INSTALLED_ENV,
+  resolveConfiguredHostContext,
+} from './index/host-context-resolver.js';
 import {
   inspectProjectFormat,
   projectFormatDiagnostic,
 } from './index/project-format.js';
-import { projectSessionContext } from './index/session-context.js';
+import { projectSessionContext, projectTurnContext } from './index/session-context.js';
 import { installedFirstPartyStackPackages } from './index/stack-catalog.js';
 import { readStack } from './index/stack.js';
 
@@ -36,6 +44,8 @@ const USAGE = `Usage:
   genesis init
   genesis adopt [product guidance...]
   genesis codex install
+  genesis collaboration show
+  genesis collaboration set <tone> <response-length> <experience> <explanation-style> [project requirements...]
   genesis engineering list
   genesis engineering show [profile]
   genesis engineering set <profile>
@@ -63,7 +73,7 @@ prompt to the agent you already use. Review all edits through the ordinary Git
 diff, then run genesis verify for the Stack's concrete checks.
 `;
 
-const COMMANDS = new Set(['adopt', 'check', 'codex', 'context', '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', 'verify']);
 
 function parseCommand(argv) {
   if (argv.length === 0 || argv.includes('--help') || argv.includes('-h') || argv[0] === 'help') {
@@ -97,7 +107,21 @@ function parseCommand(argv) {
   if (options.task !== undefined && command !== 'prompt') {
     fail('CLI_OPTION_NOT_APPLICABLE', `Option --task is not applicable to ${command}.`);
   }
-  if (command === 'stack') {
+  if (command === 'collaboration') {
+    const [action] = operands;
+    if (!['show', 'set'].includes(action)) {
+      fail('CLI_COLLABORATION_ACTION_REQUIRED', 'Command collaboration requires show or set.');
+    }
+    if (action === 'show' && operands.length !== 1) {
+      fail('CLI_EXTRA_ARGUMENT', 'Command collaboration show accepts no extra arguments.');
+    }
+    if (action === 'set' && operands.length < 5) {
+      fail(
+        'CLI_COLLABORATION_VALUES_REQUIRED',
+        'Command collaboration set requires tone, response length, experience, and explanation style.',
+      );
+    }
+  } else if (command === 'stack') {
     if (!['list', 'add'].includes(operands[0])) {
       fail('CLI_STACK_ACTION_REQUIRED', 'Command stack requires list or add.');
     }
@@ -136,8 +160,8 @@ function parseCommand(argv) {
         'Command inspect requires environment or section <name>.',
       );
     }
-  } else if (command === 'hook' && (operands.length !== 1 || !['discover', 'session'].includes(operands[0]))) {
-    fail('CLI_HOOK_ACTION_REQUIRED', 'Command hook requires exactly one of: discover, session.');
+  } else if (command === 'hook' && (operands.length !== 1 || !['discover', 'session', 'turn'].includes(operands[0]))) {
+    fail('CLI_HOOK_ACTION_REQUIRED', 'Command hook requires exactly one of: discover, session, turn.');
   } else if (!['adopt', 'context', 'hook', 'index', 'inspect', 'prompt'].includes(command) && operands.length > 0) {
     fail('CLI_EXTRA_ARGUMENT', `Command ${command} accepts no arguments.`);
   }
@@ -159,6 +183,7 @@ function writeCheck(result) {
   const version = format.projectVersion === null ? format.status : format.projectVersion;
   line(process.stdout, `Project format: ${version} (${format.status}; CLI supports ${format.supportedVersion})`);
   line(process.stdout, `Blueprint: ${result.blueprint}`);
+  line(process.stdout, `Collaboration approach: ${result.collaboration}`);
   line(process.stdout, `Engineering approach: ${result.engineering}`);
   line(process.stdout, `Stack: ${result.stack}`);
   line(process.stdout, `Agent Skills: ${result.skills}`);
@@ -174,6 +199,21 @@ function writeCheck(result) {
   line(process.stdout, `Check: ${result.status}`);
 }
 
+function writeCollaboration(result) {
+  line(process.stdout, `Tone: ${result.tone}`);
+  line(process.stdout, `Response length: ${result.responseLength}`);
+  line(process.stdout, `Assumed experience: ${result.experience}`);
+  line(process.stdout, `Explanation style: ${result.explanationStyle}`);
+  if (result.requirements) {
+    line(process.stdout, 'Project requirements:');
+    line(process.stdout, result.requirements);
+  }
+  if (result.action === 'set') {
+    namedItems('Changed files', result.changedFiles);
+    line(process.stdout, `collaboration: ${result.status}`);
+  }
+}
+
 function writeEngineering(result) {
   if (result.action === 'list') {
     for (const profile of result.profiles) {
@@ -236,6 +276,10 @@ function writeResult(command, result) {
     writeEngineering(result);
     return;
   }
+  if (command === 'collaboration') {
+    writeCollaboration(result);
+    return;
+  }
   if (command === 'context') {
     process.stdout.write(result.context.endsWith('\n') ? result.context : `${result.context}\n`);
     return;
@@ -263,7 +307,7 @@ function writeResult(command, result) {
     return;
   }
   if (command === 'hook') {
-    if (['discover', 'session'].includes(result.kind) && result.output) line(process.stdout, result.output);
+    if (['discover', 'session', 'turn'].includes(result.kind) && result.output) line(process.stdout, result.output);
     return;
   }
   if (command === 'stack' && Array.isArray(result.pieces)) {
@@ -292,6 +336,32 @@ function writeResult(command, result) {
   line(process.stdout, `${command}: ${result.status}`);
 }
 
+async function hookSessionId(environment = process.env) {
+  if (!environment[HOST_CONTEXT_RESOLVER_ENV]) return null;
+  let source = environment[HOST_CONTEXT_INPUT_ENV];
+  if (source === undefined && !process.stdin.isTTY) {
+    const chunks = [];
+    let bytes = 0;
+    for await (const chunk of process.stdin) {
+      bytes += Buffer.byteLength(chunk);
+      if (bytes > 16 * 1024) {
+        fail('HOST_CONTEXT_INPUT_INVALID', 'The host hook input exceeds 16 KiB.');
+      }
+      chunks.push(chunk);
+    }
+    source = Buffer.concat(chunks).toString('utf8');
+  }
+  if (!String(source || '').trim()) return null;
+  let input;
+  try {
+    input = JSON.parse(source);
+  } catch {
+    fail('HOST_CONTEXT_INPUT_INVALID', 'The host hook input must contain JSON.');
+  }
+  const sessionId = input?.sessionId ?? input?.session_id;
+  return typeof sessionId === 'string' && sessionId.trim() ? sessionId.trim() : null;
+}
+
 async function cliStackPackages(projectRoot, supplied) {
   if (supplied.length > 0) return supplied;
   try {
@@ -312,6 +382,22 @@ async function execute({ command, operands, options }, { signal } = {}) {
     return adoptProject({ projectRoot, request: operands.join(' '), stackPackages });
   }
   if (command === 'codex') return installCodex();
+  if (command === 'collaboration') {
+    if (operands[0] === 'show') {
+      return { action: 'show', ...await inspectCollaboration({ projectRoot }) };
+    }
+    return {
+      action: 'set',
+      ...await setCollaboration({
+        projectRoot,
+        tone: operands[1],
+        responseLength: operands[2],
+        experience: operands[3],
+        explanationStyle: operands[4],
+        ...(operands.length > 5 ? { requirements: operands.slice(5).join(' ') } : {}),
+      }),
+    };
+  }
   if (command === 'engineering') {
     if (operands[0] === 'list') {
       return { action: 'list', status: 'ok', profiles: await listEngineeringProfiles() };
@@ -379,7 +465,38 @@ async function execute({ command, operands, options }, { signal } = {}) {
     if (operands[0] === 'discover') {
       return { kind: 'discover', ...await codexAdoptionRecommendation({ projectRoot }) };
     }
-    return { kind: 'session', ...await projectSessionContext({ projectRoot, stackPackages }) };
+    const scope = operands[0];
+    if (scope === 'session' && process.env[SESSION_CONTEXT_INSTALLED_ENV] === '1') {
+      return { kind: 'session', status: 'ready', output: '' };
+    }
+    const providerSessionId = await hookSessionId();
+    const hostContext = await resolveConfiguredHostContext({
+      projectRoot,
+      providerSessionId,
+      scope,
+    });
+    if (scope === 'turn') {
+      return hostContext === null
+        ? { kind: 'turn', status: 'ready', output: '' }
+        : {
+            kind: 'turn',
+            ...await projectTurnContext({
+              hostDriver: () => hostContext,
+              hostDriverInput: { scope: 'turn' },
+            }),
+          };
+    }
+    return {
+      kind: 'session',
+      ...await projectSessionContext({
+        ...(hostContext === null ? {} : {
+          hostDriver: () => hostContext,
+          hostDriverInput: { scope: 'session' },
+        }),
+        projectRoot,
+        stackPackages,
+      }),
+    };
   }
   if (command === 'verify') {
     return verify({

package/src/index/check.js

@@ -1,4 +1,5 @@
 import { readBlueprint } from './blueprint.js';
+import { readCollaboration } from './collaboration.js';
 import { inspectProjectSkills } from './agent-skills.js';
 import { readStack } from './stack.js';
 import { asDiagnostic } from './errors.js';
@@ -19,6 +20,7 @@ function invalidResult(area, error, projectFormat) {
     status: 'invalid',
     projectFormat,
     blueprint: area === 'blueprint' ? 'invalid' : 'valid',
+    collaboration: area === 'collaboration' ? 'invalid' : 'unknown',
     engineering: area === 'engineering' ? 'invalid' : 'unknown',
     stack: area === 'stack' ? 'invalid' : 'unknown',
     skills: area === 'skills' ? 'invalid' : 'unknown',
@@ -43,6 +45,7 @@ function formatMismatchResult(projectFormat) {
     status,
     projectFormat,
     blueprint: 'unknown',
+    collaboration: 'unknown',
     engineering: 'unknown',
     stack: 'unknown',
     skills: 'unknown',
@@ -75,7 +78,13 @@ export async function checkProject({
   }
 
   let stack;
+  let collaboration;
   let engineering;
+  try {
+    collaboration = await readCollaboration(root);
+  } catch (error) {
+    return invalidResult('collaboration', error, projectFormat);
+  }
   try {
     engineering = await readEngineering(root);
   } catch (error) {
@@ -154,6 +163,7 @@ export async function checkProject({
       : needsAttention ? 'attention' : 'ok',
     projectFormat,
     blueprint: 'valid',
+    collaboration: collaboration.status,
     engineering: engineering.status,
     stack: 'valid',
     skills: skills.status,