@smartmemory/compose 0.2.58-beta → 0.3.1-beta

package/pipelines/gsd.stratum.yaml

@@ -1,149 +1,97 @@
 # metadata:
 #   id: gsd
 #   label: "GSD — Per-Task Fresh-Context Dispatch"
-#   description: "Long-run autonomous mode. Decompose blueprint+Boundary Map into tasks, dispatch each as a fresh-context worktree-isolated agent, sequential by default. Reads existing blueprint.md."
+#   description: "Decompose a blueprint and dispatch each task in a fresh worktree context"
 #   category: development
-#   steps: 3
+#   steps: 4
 #   estimated_minutes: 60
 
-version: "0.3"
-
-workflow:
-  name: gsd
-  description: "Per-task fresh-context dispatch from existing blueprint+Boundary Map (COMP-GSD-2)"
-  input:
-    featureCode:
-      type: string
-      required: true
-    gateCommands:
-      type: array
-      required: true   # injected by runGsd from loadProjectConfig() with default fallback
-    pre_merge_gate:
-      type: array
-      required: false  # COMP-PAR-MERGE-QUEUE: fast per-task enforced gate (lint+build); injected by runGsd
+version: 1
 
 contracts:
   PhaseResult:
-    phase:    {type: string}
-    artifact: {type: string}
-    outcome:  {type: string, values: [complete, skipped, failed]}
-    summary:  {type: string}
+    phase: string
+    artifact: string
+    outcome: complete|skipped|failed
+    summary: string
+    files_changed: string[]?
+    commit_hash: string?
+
+  TaskGraph:
+    tasks: object[]
 
-# TaskGraph is a v0.3 built-in contract — must NOT be redeclared.
-# The richer TaskGraphGsd shape (per-task produces/consumes) is enforced
-# post-decompose by lib/gsd-decompose-enrich.js + contracts/taskgraph-gsd.json
-# rather than via Stratum's contract layer.
+  TaskResult:
+    outcome: string
+    summary: string
+    files_changed: string[]?
 
 flows:
+  entry: gsd
   gsd:
     input:
-      featureCode: {type: string}
-      gateCommands: {type: array}
-      pre_merge_gate: {type: array}   # COMP-PAR-MERGE-QUEUE
-    output: PhaseResult
+      featureCode: string
+      gateCommands: string[]
+      pre_merge_gate: string[]?
+    output:
+      from: "${ship_gsd.output}"
+      contract: PhaseResult
     max_rounds: 10
     steps:
-      # Phase: Decompose blueprint + Boundary Map into TaskGraphGsd
       - id: decompose_gsd
-        type: decompose
         agent: claude
-        intent: >
-          Read docs/features/{input.featureCode}/blueprint.md including its
-          ## Boundary Map section. Decompose into independent tasks.
-
-          For each task emit: id, files_owned, files_read, depends_on, AND a
-          rich `description` string that bundles all the spec context Stratum's
-          parallel_dispatch interpolation cannot carry on its own.
-
-          Each task's `description` MUST include these labeled sections:
-            - "Symbols you must produce:" + the matching Boundary Map slice's
-              produces entries (file → symbols (kind))
-            - "Symbols you may consume from upstream tasks:" + the slice's
-              consumes entries
-            - "Boundary Map slice (the contract for this task):" + the verbatim
-              slice block from blueprint.md
-            - "Upstream tasks (spec-level summary; their code lands at end-of-step
-              merge):" + one line per upstream task listing its declared produces
-            - "GATES — you MUST run each command and they MUST pass before
-              declaring done:" + each command from the pre_merge_gate array
-            - "Fix and re-run within this invocation. Do NOT declare done while
-              gates are red."
-
-          Stratum's parallel_dispatch only interpolates {task.id},
-          {task.description}, {task.files_owned}, {task.files_read},
-          {task.depends_on}, {task.index}, {input.<field>}. Pack everything else
-          into description.
-
-          Each Boundary Map slice maps to exactly one task whose files_owned ⊇
-          the slice's File Plan files. The decomposition is invalid if a slice
-          has no matching task or its File Plan files are split across
-          multiple tasks.
-
-          pre_merge_gate commands to embed (the fast per-task gate; the full
-          test suite runs once at ship): {input.pre_merge_gate}
-        inputs:
-          featureCode:    "$.input.featureCode"
-          gateCommands:   "$.input.gateCommands"
-          pre_merge_gate: "$.input.pre_merge_gate"
-        output_contract: TaskGraph
+        do: >
+          Read docs/features/${input.featureCode}/blueprint.md including its Boundary
+          Map. Decompose it into independent tasks. Each task must contain id,
+          description, files_owned, files_read, and depends_on. Put the matching
+          produces/consumes entries, verbatim Boundary Map slice, upstream summaries,
+          and required pre-merge commands ${input.pre_merge_gate} into description.
+          Each slice maps to exactly one task and its File Plan is owned by that task.
+          Reject file ownership conflicts and return {tasks}.
+        out: TaskGraph
         ensure:
-          - "no_file_conflicts(result.tasks)"
-          - "len(result.tasks) >= 1"
-        retries: 2
+          - expr: "len(result.tasks) >= 1"
+        attempts: 2
 
-      # Phase: Execute — sequential per-task fresh-context dispatch
+      # v0.3 parallel_dispatch -> TS v1 consumer fanout. Each item writes code,
+      # so Compose supplies an isolated worktree and retains its cumulative diff.
       - id: execute
-        type: parallel_dispatch
-        source: "$.steps.decompose_gsd.output.tasks"
-        agent: claude
-        max_concurrent: 1
-        isolation: worktree
-        capture_diff: true
-        defer_advance: true   # COMP-PAR-MERGE-QUEUE: consumer merges + reports status, enabling conflict-bounce
-        pre_merge_verify: "$.input.pre_merge_gate"   # COMP-PAR-MERGE-QUEUE: enforced fast gate per task worktree
-        require: all
-        merge: sequential_apply
-        retries: 2
-        intent_template: >
-          Implement task {task.id} using TDD.
-
-          Files you own (write): {task.files_owned}
-          Files you may read: {task.files_read}
-          Depends on: {task.depends_on}
-
-          {task.description}
+        after: [decompose_gsd]
+        attempts: 2
+        fanout:
+          over: "${decompose_gsd.output.tasks}"
+          dispatch: consumer
+          concurrency: 1
+          isolation: worktree
+          require: all
+          merge: sequential
+          pre_merge: "$.input.pre_merge_gate"
+          steps:
+            - agent: claude
+              do: >
+                Implement the task described by ${item} using TDD. Honor its id,
+                files_owned, files_read, depends_on, and description fields. Write the
+                TaskResult JSON under .compose/gsd/${input.featureCode}/results/ using
+                the task id as its filename, and include it in your diff. Return
+                {outcome, summary, files_changed}.
+              out: TaskResult
+
+      - id: execute_merge
+        after: [execute]
+        gate:
+          on_approve: ship_gsd
+          on_revise: execute
+          on_kill: null
+          max_rounds: 10
 
-          When done, write TaskResult JSON to
-          .compose/gsd/{input.featureCode}/results/{task.id}.json
-          (schema: contracts/task-result.json) and INCLUDE that file in your diff.
-        depends_on: [decompose_gsd]
-
-      # Phase: Ship — verify, update docs, commit, push
       - id: ship_gsd
-        agent: "claude::critical"
-        intent: >
-          Final verification and ship for feature {input.featureCode}.
-
-          You MUST:
-            1. Run the project test suite. If tests fail, fix them.
-            2. Run the project build. Must pass.
-            3. Update ROADMAP.md — find COMP-GSD-2's row and mark it COMPLETE.
-               If this completes a parent feature, update the parent header.
-            4. Update CHANGELOG.md — add an entry under today's date with
-               COMP-GSD-2 and a bullet list of what was built. Read the
-               existing format first.
-            5. Update CLAUDE.md ONLY if a new convention/command/architecture
-               surface emerged. Skip otherwise.
-            6. Stage changed files explicitly (no worktrees, pycache, build
-               artifacts). Commit with message:
-               "feat(COMP-GSD-2): per-task fresh-context dispatch"
-               (Note: push is deferred to the user — `compose gsd` does not
-                auto-push, mirroring `compose build`'s ship behavior.)
-            7. Report commit hash and files_changed in result JSON.
-        inputs:
-          featureCode: "$.input.featureCode"
-        output_contract: PhaseResult
+        agent: claude
+        do: >
+          Final verification and ship for ${input.featureCode}. Run all gate commands
+          ${input.gateCommands}; fix failures. Update ROADMAP.md and CHANGELOG.md, update
+          CLAUDE.md only for a new convention, stage only GSD-produced files, and commit
+          with message "feat(COMP-GSD-2): per-task fresh-context dispatch". Do not push.
+          Return PhaseResult with files_changed and commit_hash.
+        out: PhaseResult
         ensure:
-          - "result.outcome == 'complete'"
-        retries: 2
-        depends_on: [execute]
+          - expr: "result.outcome == 'complete'"
+        attempts: 2

package/pipelines/new.stratum.yaml

@@ -1,182 +1,101 @@
-version: "0.2"
-
-workflow:
-  name: new
-  description: "Product kickoff — research, brainstorm, and scaffold a new project from intent"
-  input:
-    projectName:
-      type: string
-      required: true
-    intent:
-      type: string
-      required: true
+version: 1
 
 contracts:
   ResearchResult:
-    priorArt:    {type: array}
-    patterns:    {type: array}
-    risks:       {type: array}
-    summary:     {type: string}
+    priorArt: array
+    patterns: array
+    risks: array
+    summary: string
 
   BrainstormResult:
-    features:    {type: array}
-    userStories: {type: array}
-    archOptions: {type: array}
-    summary:     {type: string}
+    features: array
+    userStories: array
+    archOptions: array
+    summary: string
 
   RoadmapResult:
-    phases:      {type: array}
-    features:    {type: array}
-    summary:     {type: string}
-    artifact:    {type: string}
+    phases: array
+    features: array
+    summary: string
+    artifact: string
 
   ScaffoldResult:
-    created:     {type: array}
-    summary:     {type: string}
-
-functions:
-  review_gate:
-    mode: gate
-    timeout: 7200
-
-  roadmap_gate:
-    mode: gate
-    timeout: 3600
+    created: array
+    summary: string
 
 flows:
+  entry: new
+
   new:
     input:
-      projectName: {type: string}
-      intent: {type: string}
-    output: ScaffoldResult
+      projectName: string
+      intent: string
+    output:
+      from: "${scaffold.output}"
+      contract: ScaffoldResult
+    max_rounds: 10
     steps:
-      # Phase: Research prior art
       - id: research
         agent: claude
-        intent: >
-          Research prior art for this product idea. Search the web for:
-          1. Existing tools that solve the same or similar problems
-          2. Common architectural patterns used in this domain
-          3. Known pitfalls and risks
-
-          Write your findings to docs/discovery/research.md.
-          If docs/discovery/research.md already exists, read it and build on it
-          rather than starting from scratch.
-        inputs:
-          intent: "$.input.intent"
-        output_contract: ResearchResult
+        do: >
+          Research prior art for ${input.intent}. Find existing tools, common
+          architectural patterns, known pitfalls, and risks. Write the findings
+          to docs/discovery/research.md, building on that file if it exists.
+          Return ResearchResult.
+        out: ResearchResult
         ensure:
-          - "file_exists('docs/discovery/research.md')"
-        validate:
-          artifact: docs/discovery/research.md
-          criteria:
-            - "Contains at least 2 existing tools or prior art entries"
-            - "Mentions architectural patterns or common approaches"
-            - "Lists risks or pitfalls"
-        retries: 3
+          - expr: "file_exists('docs/discovery/research.md')"
+        attempts: 3
 
-      # Phase: Brainstorm features
       - id: brainstorm
+        after: [research]
         agent: claude
-        intent: >
-          Given the product intent (and any available research findings),
-          brainstorm the product. Generate:
-          1. A feature list — discrete capabilities the product should have,
-             each with a short code (e.g. LOG-1, LOG-2) and description.
-             Order features by dependency: foundational first, advanced later.
-          2. User stories — "As a <user>, I want <goal>, so that <benefit>"
-          3. Architecture options — 2-3 high-level approaches with trade-offs
-
-          If docs/discovery/research.md exists, read it first for prior-art
-          context. Otherwise proceed from the product intent alone — research
-          is an optional input, not a hard requirement (the questionnaire can
-          skip it).
-
-          Write the full brainstorm to docs/discovery/brainstorm.md.
-          If docs/discovery/brainstorm.md already exists, read it and refine it
-          rather than starting from scratch.
-        inputs:
-          intent: "$.input.intent"
-          research: "$.steps.research.output.summary"  # may be null when research is skipped
-        output_contract: BrainstormResult
+        do: >
+          Brainstorm features, dependency-ordered feature codes, user stories,
+          and 2-3 architecture options with trade-offs for ${input.intent}.
+          Read docs/discovery/research.md first if it exists. Write the complete
+          result to docs/discovery/brainstorm.md and return BrainstormResult.
+        out: BrainstormResult
         ensure:
-          - "file_exists('docs/discovery/brainstorm.md')"
-        validate:
-          artifact: docs/discovery/brainstorm.md
-          criteria:
-            - "Contains at least 3 features with short codes (e.g. LOG-1, LOG-2)"
-            - "Contains user stories in 'As a... I want... so that...' format"
-            - "Contains at least 2 architecture options with trade-offs"
-        retries: 3
-        depends_on: [research]
+          - expr: "file_exists('docs/discovery/brainstorm.md')"
+        attempts: 3
 
-      # Gate: Human reviews brainstorm
       - id: review_gate
-        function: review_gate
-        on_approve: roadmap
-        on_revise: brainstorm
-        on_kill: null
-        depends_on: [brainstorm]
+        after: [brainstorm]
+        gate:
+          on_approve: roadmap
+          on_revise: brainstorm
+          on_kill: null
 
-      # Phase: Structure the roadmap
       - id: roadmap
+        after: [review_gate]
         agent: claude
-        intent: >
-          Take the approved brainstorm and structure it into a phased ROADMAP.
-
-          First read docs/discovery/brainstorm.md for the full brainstorm.
-          If ROADMAP.md already exists, read it and update it rather than overwriting.
-
-          Write ROADMAP.md in the project root with:
-          1. Project name and description
-          2. Roadmap conventions (status values, numbering rules)
-          3. Phases grouping features by dependency order
-          4. Each feature as a numbered row with its code, description, and PLANNED status
-
-          Follow this table format for each phase:
-          | # | Feature | Item | Status |
-          |---|---------|------|--------|
-          | 1 | CODE-1  | Description | PLANNED |
-        inputs:
-          intent: "$.input.intent"
-          brainstorm: "$.steps.brainstorm.output.summary"
-        output_contract: RoadmapResult
+        do: >
+          Read the approved docs/discovery/brainstorm.md and write a phased
+          ROADMAP.md for ${input.projectName}. Include project conventions and
+          dependency-ordered feature tables with PLANNED status. Return
+          RoadmapResult with artifact set to ROADMAP.md.
+        out: RoadmapResult
         ensure:
-          - "file_exists('ROADMAP.md')"
-        validate:
-          artifact: ROADMAP.md
-          criteria:
-            - "Contains a markdown table with feature codes and status columns"
-            - "Features are organized into phases"
-            - "All features have PLANNED status"
-        retries: 3
-        depends_on: [review_gate]
+          - expr: "file_exists('ROADMAP.md')"
+        attempts: 3
 
-      # Gate: Human approves the roadmap
       - id: roadmap_gate
-        function: roadmap_gate
-        on_approve: scaffold
-        on_revise: roadmap
-        on_kill: null
-        depends_on: [roadmap]
+        after: [roadmap]
+        gate:
+          on_approve: scaffold
+          on_revise: roadmap
+          on_kill: null
 
-      # Phase: Scaffold feature folders
       - id: scaffold
+        after: [roadmap_gate]
         agent: claude
-        intent: >
-          Read the approved ROADMAP.md and create a feature folder for each
-          feature listed. For each feature:
-          1. Create docs/features/<CODE>/design.md with a seed design doc containing:
-             - Title: "<CODE>: <description>"
-             - Status: PLANNED
-             - Created date
-             - Intent section with the feature description
-             - Notes section explaining this is a seed for compose build
-        inputs:
-          intent: "$.input.intent"
-          roadmap: "$.steps.roadmap.output.summary"
-        output_contract: ScaffoldResult
+        do: >
+          Read the approved ROADMAP.md and create docs/features/CODE/design.md
+          seed documents for every feature. Include title, PLANNED status,
+          created date, intent, and a note that compose build will refine it.
+          Return ScaffoldResult listing every created file.
+        out: ScaffoldResult
         ensure:
-          - "len(result.created) > 0"
-        retries: 2
-        depends_on: [roadmap_gate]
+          - expr: "len(result.created) > 0"
+        attempts: 2

package/server/build-routes.js

@@ -144,7 +144,10 @@ export function attachBuildRoutes(app, deps = {}) {
       return res.status(400).json({ error: 'featureCode required' });
     }
     try {
-      const result = await abortBuild(getDataDir(), featureCode);
+      // C2: thread the ACTIVE PROJECT ROOT so abortBuild resolves the stratum
+      // engine from the project's capabilities (the route may have switched
+      // projects at runtime; process.cwd() is not the project root).
+      const result = await abortBuild(getDataDir(), featureCode, getTargetRoot());
       res.json(result ?? { ok: true });
     } catch (err) {
       res.status(500).json({ error: err.message || String(err) });

package/server/design-routes.js

@@ -17,29 +17,45 @@ import { parseDecisionBlocks } from '../src/components/vision/designSessionState
 import { StratumMcpClient } from '../lib/stratum-mcp-client.js';
 import { KNOWN_VERSIONS } from '../lib/build-stream-schema.js';
 import { getTargetRoot, resolveProjectPath } from './project-root.js';
+import { resolveStratumMcpConnection } from '../lib/stratum-engine.js';
 import { relForDisplay } from '../lib/project-paths.js';
 
-// Lazy singleton — design conversations share one stratum-mcp connection
-// across the server process lifetime. Concurrent runs are correlation-id scoped.
-let _stratumClient = null;
-let _stratumConnectPromise = null;
-async function _getStratum() {
-  if (_stratumClient) return _stratumClient;
-  if (!_stratumConnectPromise) {
-    const c = new StratumMcpClient();
-    _stratumConnectPromise = c.connect()
-      .then(() => { _stratumClient = c; return c; })
-      .catch((err) => { _stratumConnectPromise = null; throw err; });
+// Lazy per-project-root singletons — design conversations share one Stratum TS
+// MCP connection PER target project root. H2: keying on root (and threading the
+// root into the connection) is load-bearing. `resolveStratumMcpConnection(root)`
+// reads the project's `.compose/compose.json` engine pin and THROWS the
+// python-legacy error for a python-pinned project; connecting without a cwd (the
+// old behaviour) resolved the process cwd and silently handed a python project a
+// TS engine, and the single cached client leaked across project switches. Keying
+// the cache on root re-resolves the engine on every project switch.
+const _stratumClients = new Map();         // root key -> connected client
+const _stratumConnectPromises = new Map(); // root key -> in-flight connect promise
+
+async function _getStratum(root = getTargetRoot(), { factory } = {}) {
+  const key = root || '';
+  if (_stratumClients.has(key)) return _stratumClients.get(key);
+  if (!_stratumConnectPromises.has(key)) {
+    // Throws synchronously for a python-pinned (or otherwise invalid) root, before
+    // any subprocess is spawned — the caller sees a rejected promise.
+    const connection = resolveStratumMcpConnection(root);
+    const c = factory ? factory() : new StratumMcpClient();
+    const p = c.connect(connection)
+      .then(() => { _stratumClients.set(key, c); return c; })
+      .catch((err) => { _stratumConnectPromises.delete(key); throw err; });
+    _stratumConnectPromises.set(key, p);
   }
-  return _stratumConnectPromise;
+  return _stratumConnectPromises.get(key);
 }
 
-/** Tear down the cached stratum-mcp connection. Tests should call this in after(). */
+// Test-only export: exercise the root-keyed connect/cache without a live server.
+export { _getStratum as _getDesignStratumForTest };
+
+/** Tear down every cached Stratum connection. Tests should call this in after(). */
 export async function closeDesignStratum() {
-  const c = _stratumClient;
-  _stratumClient = null;
-  _stratumConnectPromise = null;
-  if (c) {
+  const clients = [..._stratumClients.values()];
+  _stratumClients.clear();
+  _stratumConnectPromises.clear();
+  for (const c of clients) {
     try { await c.close(); } catch { /* ignore */ }
   }
 }
@@ -95,7 +111,7 @@ async function dispatchDesignAgent(sessionManager, projectRoot, scope, featureCo
   const key = sessionKey(scope, featureCode, projectRoot);
   if (_inFlight.has(key)) return; // already running
   // Tests assert on the HTTP response only — skip the LLM round-trip to avoid
-  // keeping a stratum-mcp subprocess alive past the test lifetime.
+  // keeping a Stratum subprocess alive past the test lifetime.
   if (process.env.NODE_ENV === 'test' || process.env.COMPOSE_DESIGN_DISPATCH === '0') return;
   _inFlight.add(key);
   // Snapshot message count so we can detect new messages arriving during the run
@@ -142,7 +158,7 @@ ${formattedMessages}`;
     let fullContent = '';
     let toolUseCounter = 0;
 
-    const stratum = await _getStratum();
+    const stratum = await _getStratum(projectRoot);
     const correlationId = randomUUID();
     const subStepId = '_agent_run';
 
@@ -432,11 +448,11 @@ Write the design document in Markdown format. Include:
 
 Output ONLY the Markdown content, no code fences.`;
 
-      // Generate the design doc via the persistent stratum-mcp client.
+      // Generate the design doc via the persistent Stratum TS client.
       // No streaming needed for the one-shot doc generation.
       let docContent = '';
       try {
-        const stratum = await _getStratum();
+        const stratum = await _getStratum(projectRoot);
         const result = await stratum.runAgentText('claude', docPrompt, { cwd: projectRoot });
         docContent = result || '';
       } catch (err) {

package/server/index.js

@@ -2,8 +2,7 @@ import express from 'express';
 import cors from 'cors';
 import http from 'node:http';
 import path from 'node:path';
-import { execFileSync } from 'node:child_process';
-import { existsSync, statSync, readFileSync, accessSync, constants as fsConstants } from 'node:fs';
+import { existsSync, statSync, readFileSync } from 'node:fs';
 import { FileWatcherServer } from './file-watcher.js';
 import { VisionStore } from './vision-store.js';
 import { VisionServer } from './vision-server.js';
@@ -15,6 +14,7 @@ import { attachGraphLayoutRoutes } from './graph-layout-routes.js';
 import { createWorkspaceMiddleware } from './workspace-middleware.js';
 import { getTargetRoot, getDataDir, ensureDataDir, loadProjectConfig, resolveProjectPath, switchProject, COMPOSE_HOME } from './project-root.js';
 import { resolveStratumEngine } from './stratum-client.js';
+import { probeStratumBin, resolveStratumBin } from '../lib/stratum-engine.js';
 import { createAuthStore } from './auth-store.js';
 import { createAuthGate, wsUpgradeTokenOk } from './auth-middleware.js';
 import { attachAuthRoutes } from './auth-routes.js';
@@ -39,34 +39,26 @@ if (remoteMode && process.env.COMPOSE_REMOTE_AUTH !== 'enabled') {
 }
 
 // Load project config and verify stratum capability matches reality.
-// The probe targets the SELECTED engine's binary (COMP-STRATUM-TS): under
-// engine=ts the flow/gate seam runs without any Python install.
+// The probe targets the TS engine binary (COMP-STRATUM-TS).
 const projectConfig = loadProjectConfig();
 if (projectConfig.capabilities.stratum) {
   let stratumEngine;
+  let stratumBin;
   try {
     stratumEngine = resolveStratumEngine();
+    stratumBin = resolveStratumBin('cli', getTargetRoot());
   } catch (err) {
     console.error(`[compose] ${err.message}`);
     process.exit(1);
   }
-  const stratumBin = stratumEngine === 'ts'
-    ? (process.env.COMPOSE_STRATUM_TS_BIN || 'stratum')
-    : 'stratum-mcp';
-  try {
-    if (stratumBin.includes('/')) {
-      // A configured path must be an executable regular file — a directory or
-      // mode-644 file would pass a bare stat and fail later at spawn time.
-      if (!statSync(stratumBin).isFile()) throw new Error('not a regular file');
-      accessSync(stratumBin, fsConstants.X_OK);
-    } else {
-      execFileSync('which', [stratumBin], { stdio: 'ignore' });
-    }
-  } catch {
-    console.error(`[compose] ${stratumBin} (engine=${stratumEngine}) not found but capabilities.stratum=true`);
-    console.error(stratumEngine === 'ts'
-      ? '[compose] Install @smartmemory/stratum or set COMPOSE_STRATUM_TS_BIN'
-      : '[compose] Run: compose init (will auto-install) or compose init --no-stratum');
+  // C1: existence alone is not enough — a bare `stratum` on $PATH can EXIST yet
+  // not speak the query contract (miniconda's CLI answers "Unknown command" and
+  // even exits 0), which used to half-enable the adapter with every call broken.
+  // The probe now verifies the binary actually returns the flows projection.
+  const probe = probeStratumBin(stratumBin);
+  if (!probe.ok) {
+    console.error(`[compose] stratum ${stratumEngine} binary is unusable but capabilities.stratum=true: ${probe.reason}`);
+    console.error('[compose] Install @smartmemory/stratum or set COMPOSE_STRATUM_TS_CLI_BIN to the live query/gate CLI');
     projectConfig.capabilities.stratum = false;
   }
 }