@smartmemory/compose 0.1.27-beta → 0.1.29-beta

package/lib/gsd-decompose-enrich.js

@@ -0,0 +1,171 @@
+// lib/gsd-decompose-enrich.js
+//
+// COMP-GSD-2 T3: enrichTaskGraph(taskGraph, blueprintText) → TaskGraphGsd.
+//
+// Pure function. No filesystem I/O. Takes the bare TaskGraph emitted by
+// Stratum's decompose step (tasks have id/files_owned/files_read/depends_on/
+// description) and the blueprint text. Calls parseBoundaryMap (pure) to get
+// slices and parse violations. Maps each slice to exactly one task by
+// the slice's File Plan files ⊆ task.files_owned. Attaches produces/consumes
+// arrays to each task.
+//
+// Purity note: the blueprint says T6/runGsd should use validateBoundaryMap
+// (which does filesystem checks). T3 only uses parseBoundaryMap so it stays
+// pure and deterministic — runGsd separately calls validateBoundaryMap as
+// its lifecycle precondition.
+//
+// Throws on: parseBoundaryMap parseViolations, empty Boundary Map, orphaned
+// slice (slice's File Plan files not all owned by any single task), orphaned
+// task (no slice maps to it).
+
+import { parseBoundaryMap } from './boundary-map.js';
+
+// Match per-slice File Plan lines:
+//   File Plan: `path/a` (new), `path/b` (modify), ...
+//   File Plan: path/a, path/b
+const FILEPLAN_LINE_RE = /^File Plan\s*:\s*(.+)$/;
+const BACKTICK_PATH_RE = /`([^`]+)`/g;
+const BARE_PATH_RE = /([^\s,()`]+)/g;
+
+function extractSliceFilePlanFiles(blueprintText, sliceId) {
+  // Find the slice block: from `### {sliceId}` to the next `### S` heading or
+  // a `## ` heading or EOF.
+  const lines = blueprintText.split(/\r?\n/);
+  const headingRe = new RegExp(`^### ${sliceId}(?::|\\s|$)`);
+  let start = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (headingRe.test(lines[i])) { start = i + 1; break; }
+  }
+  if (start === -1) return [];
+  let end = lines.length;
+  for (let i = start; i < lines.length; i++) {
+    if (/^### S\d/.test(lines[i]) || /^## /.test(lines[i])) { end = i; break; }
+  }
+  // Find File Plan line within the slice block
+  for (let i = start; i < end; i++) {
+    const m = lines[i].match(FILEPLAN_LINE_RE);
+    if (!m) continue;
+    const tail = m[1];
+    // Prefer backtick-quoted paths; fall back to bare comma-separated if none.
+    const ticked = [...tail.matchAll(BACKTICK_PATH_RE)].map((mm) => mm[1].trim());
+    if (ticked.length > 0) return ticked;
+    // Strip parenthesized actions like " (new)" before bare-token matching.
+    const cleaned = tail.replace(/\([^)]*\)/g, '');
+    const bare = [...cleaned.matchAll(BARE_PATH_RE)].map((mm) => mm[1].trim()).filter(Boolean);
+    return bare;
+  }
+  return [];
+}
+
+export function enrichTaskGraph(taskGraph, blueprintText) {
+  if (!taskGraph || !Array.isArray(taskGraph.tasks)) {
+    throw new Error('enrichTaskGraph: taskGraph.tasks must be an array');
+  }
+  if (typeof blueprintText !== 'string') {
+    throw new Error('enrichTaskGraph: blueprintText must be a string');
+  }
+
+  const { slices, parseViolations } = parseBoundaryMap(blueprintText);
+  if (parseViolations.length > 0) {
+    const summary = parseViolations
+      .slice(0, 5)
+      .map((v) => `${v.kind}: ${v.message}`)
+      .join('; ');
+    throw new Error(`enrichTaskGraph: Boundary Map invalid (parse violations): ${summary}`);
+  }
+
+  const liveSlices = slices.filter((s) => !s._duplicate);
+  if (liveSlices.length === 0) {
+    throw new Error('enrichTaskGraph: Boundary Map empty (zero slices)');
+  }
+
+  // For each slice, extract its File Plan files and map to a task whose
+  // files_owned ⊇ those files. If the slice's File Plan files are split
+  // across multiple tasks → ambiguous → throw. If no task owns all of
+  // them → orphaned slice.
+  const sliceToTask = new Map();
+  const sliceFilePlanFiles = new Map(); // sliceId → string[]
+  for (const slice of liveSlices) {
+    const filePlanFiles = extractSliceFilePlanFiles(blueprintText, slice.id);
+    if (filePlanFiles.length === 0) {
+      throw new Error(
+        `enrichTaskGraph: slice ${slice.id} has no File Plan entries. ` +
+          `Each slice must declare its File Plan files for slice→task mapping.`,
+      );
+    }
+    sliceFilePlanFiles.set(slice.id, filePlanFiles);
+    const fpSet = new Set(filePlanFiles);
+    let matchedTaskId = null;
+    let partialMatchTaskIds = [];
+    for (const task of taskGraph.tasks) {
+      const owned = new Set(task.files_owned || []);
+      const allOwned = [...fpSet].every((f) => owned.has(f));
+      const someOwned = [...fpSet].some((f) => owned.has(f));
+      if (allOwned) {
+        if (matchedTaskId) {
+          throw new Error(
+            `enrichTaskGraph: slice ${slice.id} matches multiple tasks ` +
+              `(${matchedTaskId}, ${task.id}); decomposition has overlapping files_owned`,
+          );
+        }
+        matchedTaskId = task.id;
+      } else if (someOwned) {
+        partialMatchTaskIds.push(task.id);
+      }
+    }
+    if (!matchedTaskId) {
+      if (partialMatchTaskIds.length > 0) {
+        throw new Error(
+          `enrichTaskGraph: slice ${slice.id} File Plan files ` +
+            `[${[...fpSet].join(', ')}] are split across multiple tasks ` +
+            `(partial owners: ${partialMatchTaskIds.join(', ')}). ` +
+            `Each slice must map to exactly one task.`,
+        );
+      }
+      throw new Error(
+        `enrichTaskGraph: slice ${slice.id} is orphaned — no task owns its File Plan files [${[...fpSet].join(', ')}]`,
+      );
+    }
+    sliceToTask.set(slice.id, matchedTaskId);
+  }
+
+  // Reverse map: each task must have ≥1 matching slice.
+  const taskToSlices = new Map();
+  for (const [sliceId, taskId] of sliceToTask.entries()) {
+    if (!taskToSlices.has(taskId)) taskToSlices.set(taskId, []);
+    taskToSlices.get(taskId).push(sliceId);
+  }
+  const orphanedTasks = taskGraph.tasks
+    .filter((t) => !taskToSlices.has(t.id))
+    .map((t) => t.id);
+  if (orphanedTasks.length > 0) {
+    throw new Error(
+      `enrichTaskGraph: tasks have no matching Boundary Map slice (orphaned): ${orphanedTasks.join(', ')}`,
+    );
+  }
+
+  // Build the enriched TaskGraph. For each task, concatenate produces/consumes
+  // from all matching slices.
+  const slicesById = new Map(liveSlices.map((s) => [s.id, s]));
+  const enrichedTasks = taskGraph.tasks.map((task) => {
+    const matchedSliceIds = taskToSlices.get(task.id) || [];
+    const produces = [];
+    const consumes = [];
+    for (const sid of matchedSliceIds) {
+      const s = slicesById.get(sid);
+      for (const p of s.produces) {
+        produces.push({ file: p.file, symbols: p.symbols, kind: p.kind });
+      }
+      for (const c of s.consumes) {
+        consumes.push({ from: c.from, file: c.file, symbols: c.symbols });
+      }
+    }
+    return {
+      ...task,
+      produces,
+      consumes,
+    };
+  });
+
+  return { tasks: enrichedTasks };
+}

package/lib/gsd-prompt.js

@@ -0,0 +1,82 @@
+// lib/gsd-prompt.js
+//
+// COMP-GSD-2 T4: buildTaskDescription — pure string assembly.
+//
+// Stratum's parallel_dispatch only interpolates {task.id|description|
+// files_owned|files_read|depends_on|index} and {input.<field>}. Every other
+// piece of context — the per-slice produces/consumes contract, the upstream
+// tasks summary, the gate commands — must be packed inside `task.description`.
+//
+// This module produces the rich `description` string. It is also used by
+// runGsd as a deterministic fallback when the decompose_gsd agent failed to
+// bake a description into a task.
+//
+// Pure function. No fs, no globals.
+
+const SECTION_DIVIDER = '---';
+
+function formatProduces(produces) {
+  if (!produces || produces.length === 0) return '(none)';
+  const lines = produces.map((p) => {
+    const syms = (p.symbols || []).join(', ');
+    return `  ${p.file} → ${syms} (${p.kind})`;
+  });
+  return lines.join('\n');
+}
+
+function formatConsumes(consumes) {
+  if (!consumes || consumes.length === 0) return '(none)';
+  const lines = consumes.map((c) => {
+    const syms = (c.symbols || []).join(', ');
+    return `  from ${c.from}: ${c.file} → ${syms}`;
+  });
+  return lines.join('\n');
+}
+
+function formatUpstream(task, upstreamTasks) {
+  const deps = new Set(task.depends_on || []);
+  const filtered = (upstreamTasks || []).filter((t) => deps.has(t.id));
+  if (filtered.length === 0) return '(none)';
+  return filtered
+    .map((t) => {
+      const producesStr = (t.produces || [])
+        .map((p) => `${p.file} → ${(p.symbols || []).join(', ')} (${p.kind})`)
+        .join('; ');
+      return `  ${t.id}: produces ${producesStr || '(none)'}`;
+    })
+    .join('\n');
+}
+
+function formatGates(gateCommands) {
+  if (!gateCommands || gateCommands.length === 0) return '(none)';
+  return gateCommands.map((c) => `  - ${c}`).join('\n');
+}
+
+export function buildTaskDescription({ task, slice, upstreamTasks, gateCommands }) {
+  if (!task || typeof task !== 'object') {
+    throw new Error('buildTaskDescription: task object required');
+  }
+
+  // The function PRODUCES task.description — it must not embed any preexisting
+  // description (which may itself be malformed; this is the repair path). The
+  // output is the fresh, canonical description.
+  const lines = [];
+  lines.push('Symbols you must produce:');
+  lines.push(formatProduces(task.produces));
+  lines.push('');
+  lines.push('Symbols you may consume from upstream tasks:');
+  lines.push(formatConsumes(task.consumes));
+  lines.push('');
+  lines.push('Boundary Map slice (the contract for this task):');
+  lines.push(typeof slice === 'string' ? slice : '(slice text not provided)');
+  lines.push('');
+  lines.push('Upstream tasks (spec-level summary; their code lands at end-of-step merge):');
+  lines.push(formatUpstream(task, upstreamTasks));
+  lines.push('');
+  lines.push('GATES — you MUST run each command and they MUST pass before declaring done:');
+  lines.push(formatGates(gateCommands));
+  lines.push('');
+  lines.push('Fix and re-run within this invocation. Do NOT declare done while gates are red.');
+
+  return lines.join('\n');
+}

package/lib/gsd.js

@@ -0,0 +1,364 @@
+// lib/gsd.js
+//
+// COMP-GSD-2 T6: runGsd lifecycle entry — `compose gsd <featureCode>`.
+//
+// Self-contained status loop. Does NOT modify lib/build.js. Reuses primitives:
+//   - StratumMcpClient (lib/stratum-mcp-client.js) for plan/stepDone/runAgentText
+//   - executeParallelDispatchServer (lib/build.js) for the execute step
+//   - validateBoundaryMap (lib/boundary-map.js) for precondition check
+//   - enrichTaskGraph (lib/gsd-decompose-enrich.js) for decompose validation
+//   - buildTaskDescription (lib/gsd-prompt.js) for description repair fallback
+//   - gsd-blackboard.writeAll for post-step finalization
+//
+// V1 limitation: runtime task-to-task handoff is not implemented; tasks see
+// only spec-level upstream context (Boundary Map declarations) per blueprint.
+
+import { readFileSync, existsSync, readdirSync } from 'node:fs';
+import { join, resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { execSync } from 'node:child_process';
+
+import { StratumMcpClient } from './stratum-mcp-client.js';
+import { validateBoundaryMap } from './boundary-map.js';
+import { enrichTaskGraph } from './gsd-decompose-enrich.js';
+import { buildTaskDescription } from './gsd-prompt.js';
+import { writeAll, validate as validateTaskResult } from './gsd-blackboard.js';
+import { executeParallelDispatchServer, executeShipStep } from './build.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PACKAGE_ROOT = resolve(__dirname, '..');
+
+const DEFAULT_GATE_COMMANDS = ['pnpm lint', 'pnpm build', 'pnpm test'];
+
+// ---------- Public API ----------
+
+export async function runGsd(featureCode, opts = {}) {
+  if (!featureCode || typeof featureCode !== 'string') {
+    throw new Error('runGsd: featureCode required');
+  }
+  const cwd = opts.cwd ?? process.cwd();
+
+  // 1. Validate preconditions: blueprint exists + Boundary Map ok
+  const blueprintPath = join(cwd, 'docs', 'features', featureCode, 'blueprint.md');
+  if (!existsSync(blueprintPath)) {
+    throw new Error(
+      `runGsd: blueprint missing at ${blueprintPath}. ` +
+        `Run \`compose build ${featureCode}\` to generate it, or author it by hand.`,
+    );
+  }
+  const blueprintText = readFileSync(blueprintPath, 'utf-8');
+  const bmResult = validateBoundaryMap({
+    blueprintText,
+    blueprintPath,
+    repoRoot: cwd,
+  });
+  if (!bmResult.ok) {
+    const summary = bmResult.violations
+      .slice(0, 5)
+      .map((v) => `${v.kind}: ${v.message}`)
+      .join('\n  - ');
+    throw new Error(
+      `runGsd: Boundary Map invalid in ${blueprintPath}:\n  - ${summary}`,
+    );
+  }
+
+  // 2. Refuse to start in a dirty workspace BEFORE any Stratum side effects.
+  // v1 rationale: alternatives (baseline subtract + post-execute delta) drop
+  // legitimate edits to pre-existing dirty files. Refuse-if-dirty makes
+  // post-execute dirty set unambiguous: every entry is GSD-produced.
+  if (!opts.allowDirtyWorkspace) {
+    const startingDirty = collectChangedFiles(cwd);
+    if (startingDirty.length > 0) {
+      throw new Error(
+        `runGsd: working tree must be clean to ensure ship_gsd stages only GSD-produced changes. ` +
+          `Dirty files: ${startingDirty.slice(0, 5).join(', ')}${startingDirty.length > 5 ? `, +${startingDirty.length - 5} more` : ''}. ` +
+          `Commit or stash and re-run, or pass {allowDirtyWorkspace: true} (advanced; risks staging unrelated edits).`,
+      );
+    }
+  }
+
+  // 3. Resolve gateCommands. loadProjectConfig() does not merge defaults, so
+  // explicit fallback here.
+  const gateCommands = resolveGateCommands(cwd, opts.gateCommands);
+
+  // 4. Load pipeline spec
+  const specPath = join(PACKAGE_ROOT, 'pipelines', 'gsd.stratum.yaml');
+  const specYaml = readFileSync(specPath, 'utf-8');
+
+  // 5. Connect Stratum + plan (only after preconditions pass)
+  const stratum = opts.stratum ?? new StratumMcpClient();
+  const ownsStratum = !opts.stratum;
+  if (ownsStratum) await stratum.connect();
+  try {
+    let response = await stratum.plan(specYaml, 'gsd', {
+      featureCode,
+      gateCommands,
+    });
+    const flowId = response.flow_id;
+
+    // Track files merged into the base cwd by the execute step so ship_gsd
+    // can stage them. executeShipStep's default filter only stages feature
+    // docs unless context.filesChanged is provided.
+    const stepCtx = {
+      stratum, cwd, featureCode, blueprintText, gateCommands,
+      filesChanged: [],
+    };
+
+    // 5. Status loop
+    while (response.status !== 'complete' && response.status !== 'killed') {
+      response = await runOneStep(response, stepCtx);
+    }
+
+    // 6. Post-step blackboard finalization — read each task's TaskResult JSON
+    // and write the consolidated blackboard.
+    const blackboard = collectBlackboard(cwd, featureCode);
+    if (Object.keys(blackboard).length > 0) {
+      await writeAll(featureCode, blackboard, { cwd });
+    }
+
+    return {
+      status: response.status,
+      flowId,
+      blackboardEntries: Object.keys(blackboard).length,
+    };
+  } finally {
+    if (ownsStratum) {
+      try { await stratum.disconnect?.(); } catch { /* best-effort */ }
+    }
+  }
+}
+
+// ---------- Internals ----------
+
+export function resolveGateCommands(cwd, override) {
+  if (Array.isArray(override) && override.length > 0) return override;
+  // loadProjectConfig() returns raw .compose/compose.json — does NOT merge
+  // defaults — so we must do our own fallback.
+  const configPath = join(cwd, '.compose', 'compose.json');
+  if (existsSync(configPath)) {
+    try {
+      const cfg = JSON.parse(readFileSync(configPath, 'utf-8'));
+      if (Array.isArray(cfg.gateCommands) && cfg.gateCommands.length > 0) {
+        return cfg.gateCommands;
+      }
+    } catch {
+      /* fall through to default */
+    }
+  }
+  return [...DEFAULT_GATE_COMMANDS];
+}
+
+async function runOneStep(response, ctx) {
+  const { stratum, cwd, featureCode, blueprintText, gateCommands } = ctx;
+  const flowId = response.flow_id;
+  const stepId = response.step_id;
+  const stepType = response.type ?? response.step_type;
+
+  if (response.status === 'execute_step') {
+    // parallel_dispatch step (the `execute` step)
+    if (stepType === 'parallel_dispatch' || response.tasks) {
+      const outcome = await executeParallelDispatchServer(
+        response,
+        stratum,
+        { cwd, featureCode },
+        null, // progress
+        { write: () => {} }, // streamWriter — no-op for v1
+        cwd,
+      );
+      // After diffs are merged, capture the touched files for ship_gsd
+      // staging. The clean-workspace precondition above guarantees every
+      // file in the post-execute dirty set is genuinely a GSD-produced change.
+      ctx.filesChanged = collectChangedFiles(cwd);
+      // executeParallelDispatchServer returns the next-step dispatch envelope
+      return outcome;
+    }
+
+    // ship_gsd: delegate to executeShipStep with filesChanged from execute step
+    // so source files are staged. Agent sandbox blocks git, so commit must
+    // run in-process (mirrors runBuild's special case at lib/build.js:963-981).
+    if (stepId === 'ship_gsd') {
+      const shipResult = await executeShipStep(
+        featureCode,
+        cwd,
+        cwd,
+        { cwd, featureCode, mode: 'feature', filesChanged: ctx.filesChanged ?? [] },
+        '',
+        null,
+      );
+      // executeShipStep stages + commits but does NOT push. Push is a
+      // user-facing operation deferred to the user in v1; runBuild's ship
+      // step doesn't auto-push either. Document via ship intent later.
+      return await stratum.stepDone(flowId, stepId, shipResult);
+    }
+
+    // Single-agent step: dispatch via runAgentText. The agent returns text;
+    // we expect JSON matching the step's output_contract.
+    const prompt = response.intent ?? '';
+    const text = await stratum.runAgentText(response.agent ?? 'claude', prompt, { cwd });
+    let result;
+    try {
+      result = parseJsonFromText(text);
+    } catch (err) {
+      throw new Error(
+        `runGsd: step ${stepId} agent did not return parseable JSON: ${err.message}`,
+      );
+    }
+
+    // T6 step 7: validate decompose_gsd output and repair missing descriptions.
+    if (stepId === 'decompose_gsd') {
+      result = validateAndRepairTaskGraph(result, blueprintText, gateCommands);
+    }
+
+    return await stratum.stepDone(flowId, stepId, result);
+  }
+
+  if (response.status === 'await_gate') {
+    // GSD has no gates in v1. If we hit one, surface it.
+    throw new Error(
+      `runGsd: unexpected gate at step ${stepId}. v1 has no gates in the gsd flow.`,
+    );
+  }
+
+  throw new Error(`runGsd: unknown response status: ${response.status}`);
+}
+
+export function validateAndRepairTaskGraph(taskGraph, blueprintText, gateCommands) {
+  // Structural check via enrichTaskGraph. Throws on orphan slice/task —
+  // that's a "fail loudly" case (no reliable repair path).
+  const enriched = enrichTaskGraph(taskGraph, blueprintText);
+
+  // Per-task description check. The agent must produce a description with
+  // all six required sections (per T4 prompt contract). If ANY section
+  // marker is missing, repair via buildTaskDescription. Length-only would
+  // miss long-but-malformed strings.
+  const enrichedById = new Map(enriched.tasks.map((t) => [t.id, t]));
+  const repairedTasks = enriched.tasks.map((task) => {
+    if (typeof task.description === 'string' && hasAllRequiredSections(task.description)) {
+      return task;
+    }
+    // Repair: synthesize a fresh description.
+    const sliceText = extractSliceTextForTask(blueprintText, task);
+    const upstream = (task.depends_on || [])
+      .map((dep) => enrichedById.get(dep))
+      .filter(Boolean);
+    const fresh = buildTaskDescription({
+      task,
+      slice: sliceText,
+      upstreamTasks: upstream,
+      gateCommands,
+    });
+    return { ...task, description: fresh };
+  });
+
+  return { tasks: repairedTasks };
+}
+
+const REQUIRED_DESCRIPTION_SECTIONS = [
+  'Symbols you must produce',
+  'Symbols you may consume from upstream tasks',
+  'Boundary Map slice',
+  'Upstream tasks',
+  'GATES',
+];
+
+function hasAllRequiredSections(description) {
+  for (const marker of REQUIRED_DESCRIPTION_SECTIONS) {
+    if (!description.includes(marker)) return false;
+  }
+  return true;
+}
+
+function extractSliceTextForTask(blueprintText, task) {
+  // Find any Boundary Map slice whose File Plan files match the task's
+  // files_owned. We don't have a sliceId here, so we scan slice blocks for
+  // the first one whose File Plan ⊆ task.files_owned. Best-effort — only
+  // used in the description-repair path.
+  const lines = blueprintText.split(/\r?\n/);
+  const owned = new Set(task.files_owned || []);
+  const blocks = [];
+  let cur = null;
+  for (let i = 0; i < lines.length; i++) {
+    const m = lines[i].match(/^### (S\d{2,})/);
+    if (m) {
+      if (cur) blocks.push(cur);
+      cur = { id: m[1], start: i, end: lines.length };
+    } else if (cur && /^### S\d/.test(lines[i])) {
+      cur.end = i;
+      blocks.push(cur);
+      cur = null;
+    } else if (cur && /^## /.test(lines[i])) {
+      cur.end = i;
+      blocks.push(cur);
+      cur = null;
+    }
+  }
+  if (cur) blocks.push(cur);
+  for (const b of blocks) {
+    const block = lines.slice(b.start, b.end).join('\n');
+    const fpMatch = block.match(/^File Plan\s*:\s*(.+)$/m);
+    if (!fpMatch) continue;
+    const files = [...fpMatch[1].matchAll(/`([^`]+)`/g)].map((mm) => mm[1].trim());
+    if (files.length > 0 && files.every((f) => owned.has(f))) {
+      return block;
+    }
+  }
+  return '';
+}
+
+function parseJsonFromText(text) {
+  // Strip code fences if present.
+  const trimmed = text.trim();
+  const fenced = trimmed.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+  const body = fenced ? fenced[1] : trimmed;
+  return JSON.parse(body);
+}
+
+function collectChangedFiles(cwd) {
+  try {
+    const tracked = execSync('git diff --name-only HEAD', {
+      cwd, encoding: 'utf-8', timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+    const untracked = execSync('git ls-files --others --exclude-standard', {
+      cwd, encoding: 'utf-8', timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+    const all = [
+      ...tracked.split('\n').filter(Boolean),
+      ...untracked.split('\n').filter(Boolean),
+    ];
+    return [...new Set(all)];
+  } catch {
+    return [];
+  }
+}
+
+function collectBlackboard(cwd, featureCode) {
+  const dir = join(cwd, '.compose', 'gsd', featureCode, 'results');
+  if (!existsSync(dir)) return {};
+  const files = readdirSync(dir).filter((f) => f.endsWith('.json'));
+  const out = {};
+  const failures = [];
+  for (const f of files) {
+    const taskId = f.replace(/\.json$/, '');
+    let parsed;
+    try {
+      parsed = JSON.parse(readFileSync(join(dir, f), 'utf-8'));
+    } catch (err) {
+      failures.push(`${f}: unreadable JSON (${err.message})`);
+      continue;
+    }
+    const v = validateTaskResult(parsed);
+    if (v.ok) {
+      out[taskId] = parsed;
+    } else {
+      failures.push(`${f}: ${v.errors.join('; ')}`);
+    }
+  }
+  if (failures.length > 0) {
+    // Plan T6 acceptance: blackboard must contain one VALIDATED entry per task.
+    // A partial blackboard is worse than no blackboard — fail loudly.
+    throw new Error(
+      `runGsd: ${failures.length} TaskResult file(s) failed validation; refusing to write partial blackboard:\n  - ${failures.join('\n  - ')}`,
+    );
+  }
+  return out;
+}

package/package.json

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

package/pipelines/build.stratum.yaml

@@ -278,8 +278,13 @@ flows:
         agent: claude
         intent: >
           Verify every file:line reference in the blueprint against the actual codebase.
-          Flag stale or incorrect references. Return { verified: true } only if all
-          references are valid. Return { verified: false, staleRefs: [...] } otherwise.
+          Flag stale or incorrect references. If the blueprint contains a `## Boundary Map`
+          section, additionally invoke `validateBoundaryMap` from `lib/boundary-map.js` and
+          treat its violations as stale references; treat its warnings as informational.
+          Summarize Boundary Map results (counts of violations and warnings, plus any
+          must-fix detail) inside the existing `summary` string field of the PhaseResult —
+          do not add new top-level fields. The phase outcome is `complete` only when every
+          file:line reference is valid AND the Boundary Map (if present) has zero violations.
         inputs:
           featureCode: "$.input.featureCode"
           description: "$.input.description"