@smartmemory/compose 0.2.10-beta → 0.2.12-beta

package/lib/build.js

@@ -8,7 +8,7 @@
  * Gates resolved via CLI readline prompt.
  */
 
-import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync, renameSync, mkdtempSync, rmSync } from 'node:fs';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync, renameSync, mkdtempSync, rmSync, symlinkSync } from 'node:fs';
 import { join, resolve, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { homedir, tmpdir } from 'node:os';
@@ -3323,6 +3323,67 @@ export function buildMergeConflictBounce(taskId, error, files) {
   };
 }
 
+/**
+ * COMP-PAR-MERGE-QUEUE-CONSUMER: best-effort list of files changed in a worktree
+ * (tracked + untracked), for a gate_failed bounce's `files`. Never throws.
+ */
+function gateChangedFiles(cwd) {
+  const out = [];
+  const seen = new Set();
+  for (const cmd of [
+    'git -c core.hooksPath=/dev/null diff --name-only HEAD',
+    'git -c core.hooksPath=/dev/null ls-files --others --exclude-standard',
+  ]) {
+    try {
+      const res = execSync(cmd, { cwd, encoding: 'utf-8', timeout: 30000, stdio: 'pipe' });
+      for (const line of res.split('\n')) {
+        const f = line.trim();
+        if (f && !seen.has(f)) { seen.add(f); out.push(f); }
+      }
+    } catch { /* best-effort */ }
+  }
+  return out;
+}
+
+/**
+ * COMP-PAR-MERGE-QUEUE-CONSUMER: run a per-task pre-merge gate inside a Compose-run
+ * task worktree (the consumer-dispatch mirror of Stratum's worktree.run_pre_merge_gate).
+ * Best-effort symlinks node_modules from base (the worktree is bare). Each command
+ * runs in `cwd` with `timeoutMs`; the first non-zero exit (or launch failure) returns a
+ * structured gate_failed bounce record (caller stamps task_id). All-pass ⇒ null.
+ */
+export function runPreMergeGateLocal(cwd, commands, baseCwd, timeoutMs) {
+  if (!Array.isArray(commands) || commands.length === 0) return null;
+  // Best-effort node_modules symlink (bare worktree lacks gitignored deps).
+  if (baseCwd) {
+    try {
+      const baseNm = join(baseCwd, 'node_modules');
+      const wtNm = join(cwd, 'node_modules');
+      if (existsSync(baseNm) && !existsSync(wtNm)) symlinkSync(baseNm, wtNm, 'dir');
+    } catch { /* non-fatal */ }
+  }
+  for (const cmd of commands) {
+    try {
+      execSync(cmd, { cwd, encoding: 'utf-8', timeout: timeoutMs, stdio: 'pipe' });
+    } catch (err) {
+      // execSync throws on non-zero exit, ENOENT, or timeout.
+      const exitCode = (typeof err.status === 'number') ? err.status : null;
+      const out = (err.stdout != null ? String(err.stdout) : '');
+      const errOut = (err.stderr != null ? String(err.stderr) : '');
+      const sep = (out && errOut) ? '\n' : '';
+      const excerpt = (out + sep + errOut + (out || errOut ? '' : (err.message ?? ''))).slice(-2048);
+      return {
+        reason: 'gate_failed',
+        command: cmd,
+        exit_code: exitCode,
+        files: gateChangedFiles(cwd),
+        excerpt,
+      };
+    }
+  }
+  return null;
+}
+
 function applyTaskDiffsToBaseCwd(tasks, diffMap, baseCwd, streamWriter, stepId, patchDir) {
   if (diffMap.size === 0) {
     return { mergeStatus: 'clean', appliedFiles: [], conflictedTaskId: null, conflictError: null, conflictFiles: [] };
@@ -3681,6 +3742,26 @@ async function executeParallelDispatch(
         });
 
         if (worktreeIsolation && worktreePaths.has(taskId)) {
+          // COMP-PAR-MERGE-QUEUE-CONSUMER: run the per-task pre-merge gate in the
+          // worktree BEFORE capturing the diff. A gate failure fails the task,
+          // records a gate_failed bounce, and skips diff capture so the bad work
+          // never merges. No-op when no gate is configured (byte-identical).
+          const gateCmds = dispatchResponse.pre_merge_verify ?? [];
+          if (gateCmds.length > 0) {
+            const gateTimeout = STEP_TIMEOUT_MS[dispStepId] ?? DEFAULT_TIMEOUT_MS;
+            const bounce = runPreMergeGateLocal(wtPath, gateCmds, baseCwd, gateTimeout);
+            if (bounce) {
+              bounce.task_id = taskId;
+              if (streamWriter) {
+                streamWriter.write({
+                  type: 'build_error', stepId: taskId,
+                  message: `pre-merge gate failed for ${taskId}: ${bounce.command} (exit ${bounce.exit_code ?? '?'}). Diff NOT merged.`,
+                });
+              }
+              return { taskId, status: 'failed', error: `pre_merge_verify failed: ${bounce.command}`, gateBounce: bounce };
+            }
+          }
+
           const diskQuotaMB = dispatchResponse.diskQuotaMB ?? 500;
           try {
             const duOut = execSync(`du -sk "${wtPath}"`, { encoding: 'utf-8', timeout: 10000, stdio: 'pipe' }).trim();
@@ -3734,11 +3815,15 @@ async function executeParallelDispatch(
     })
   );
 
+  // COMP-PAR-MERGE-QUEUE-CONSUMER: collect structured bounce records (gate-failed
+  // here, merge-conflict below) to surface on the parallelDone envelope.
+  const bouncedTasks = [];
   const taskResults = settled.map(outcome => {
     if (outcome.status === 'rejected') {
       return { task_id: 'unknown', status: 'failed', error: String(outcome.reason) };
     }
-    const { taskId, status, result, error } = outcome.value;
+    const { taskId, status, result, error, gateBounce } = outcome.value;
+    if (gateBounce) bouncedTasks.push(gateBounce);
     return status === 'complete'
       ? { task_id: taskId, status: 'complete', result }
       : { task_id: taskId, status: 'failed', error };
@@ -3765,6 +3850,10 @@ async function executeParallelDispatch(
         taskResults[idx].status = 'failed';
         taskResults[idx].error = `merge conflict: ${result.conflictError}`;
       }
+      // COMP-PAR-MERGE-QUEUE-CONSUMER: structured merge-conflict bounce.
+      bouncedTasks.push(
+        buildMergeConflictBounce(result.conflictedTaskId, result.conflictError, result.conflictFiles),
+      );
     }
   }
 
@@ -3784,7 +3873,13 @@ async function executeParallelDispatch(
     });
   }
 
-  return stratum.parallelDone(dispFlowId, dispStepId, taskResults, mergeStatus);
+  // COMP-PAR-MERGE-QUEUE-CONSUMER: when there are bounce records, send a structured
+  // merge_status {status, bounced_tasks} so Stratum threads them onto the failure
+  // envelope (and derives readable violations). Bare string otherwise — byte-identical.
+  const mergeArg = bouncedTasks.length > 0
+    ? { status: mergeStatus, bounced_tasks: bouncedTasks }
+    : mergeStatus;
+  return stratum.parallelDone(dispFlowId, dispStepId, taskResults, mergeArg);
 }
 
 async function startFresh(stratum, specYaml, featureCode, description, dataDir, templateName, mode = 'feature') {

package/lib/stratum-mcp-client.js

@@ -394,7 +394,9 @@ export class StratumMcpClient {
    * @param {string} flowId
    * @param {string} stepId
    * @param {Array<{task_id: string, status: string, result?: object, error?: string}>} taskResults
-   * @param {'clean'|'conflict'|'fallback'|'manual_required'} mergeStatus
+   * @param {'clean'|'conflict'|'fallback'|'manual_required'|{status:string,bounced_tasks?:object[]}} mergeStatus
+   *   COMP-PAR-MERGE-QUEUE-CONSUMER: either a bare status string (back-compat) or a
+   *   structured object carrying gate/conflict bounce records. Serializes as-is.
    * @returns {Promise<object>} Next dispatch response
    */
   async parallelDone(flowId, stepId, taskResults, mergeStatus) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartmemory/compose",
-  "version": "0.2.10-beta",
+  "version": "0.2.12-beta",
   "description": "Structured AI dev pipeline — goal-to-product orchestration with gates, iteration loops, and feature lifecycle management.",
   "author": "SmartMemory",
   "license": "MIT",