@smartmemory/compose 0.1.1-beta → 0.1.3-beta

package/lib/sections.js

@@ -0,0 +1,325 @@
+/**
+ * sections.js — per-task plan section files for COMP-PLAN-SECTIONS.
+ *
+ * Owned by compose. Invoked from build.js after the Phase 6 plan_gate is
+ * approved (emitSections) and after the feature-final ship step records a
+ * commit (appendTrailers). External skills (buddy:*, superpowers:*) are
+ * untouched.
+ *
+ * See docs/features/COMP-PLAN-SECTIONS/{design,blueprint,plan}.md.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+
+import { SECTIONS_DIR, getSectionsThreshold } from './constants.js';
+import { parsePlanItems } from './plan-parser.js';
+
+// ---------- Pure helpers ----------
+
+/**
+ * slugify(text) — stable URL-safe slug. Lowercase, runs of non-alphanumerics
+ * collapse to single dashes, leading/trailing dashes trimmed, capped at 40.
+ */
+export function slugify(text) {
+  if (!text || typeof text !== 'string') return '';
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 40)
+    .replace(/-+$/, ''); // trim trailing dash if cap landed on one
+}
+
+/**
+ * shouldEmitSections(taskCount) — true iff taskCount > threshold.
+ */
+export function shouldEmitSections(taskCount) {
+  if (!Number.isFinite(taskCount)) return false;
+  return taskCount > getSectionsThreshold();
+}
+
+/**
+ * parseTaskBlocks(planMarkdown) — split a plan into task blocks.
+ *
+ * Recognised heading shapes:
+ *   ## Task N <separator> <title>
+ *   ### Task N <separator> <title>
+ * where <separator> is optional and may be one of: '—', '-', ':', '.'.
+ *
+ * Returns [{ id: 'TN', title, headingLevel, body }] in order. Empty array
+ * if no task headings match.
+ */
+export function parseTaskBlocks(planMarkdown) {
+  if (!planMarkdown || typeof planMarkdown !== 'string') return [];
+
+  const lines = planMarkdown.split('\n');
+  const headingRe = /^(#{2,3})\s+Task\s+(\d+)\b\s*(?:[—\-:.]\s*)?(.*)$/i;
+
+  // Collect heading positions
+  const heads = [];
+  for (let i = 0; i < lines.length; i++) {
+    const m = lines[i].match(headingRe);
+    if (m) {
+      heads.push({
+        line: i,
+        headingLevel: m[1].length,
+        num: parseInt(m[2], 10),
+        title: (m[3] || '').trim(),
+      });
+    }
+  }
+  if (heads.length === 0) return [];
+
+  const blocks = [];
+  for (let i = 0; i < heads.length; i++) {
+    const start = heads[i].line + 1;
+    const end = i + 1 < heads.length ? heads[i + 1].line : lines.length;
+    const body = lines.slice(start, end).join('\n').replace(/^\n+|\n+$/g, '');
+    blocks.push({
+      id: `T${heads[i].num}`,
+      title: heads[i].title,
+      headingLevel: heads[i].headingLevel,
+      body,
+    });
+  }
+  return blocks;
+}
+
+/**
+ * extractSectionFiles(taskBody) — distinct file refs declared in checkboxes.
+ *
+ * Reuses plan-parser.parsePlanItems for `Files:` extraction. Returns deduped
+ * file paths in encounter order; empty array if none.
+ */
+export function extractSectionFiles(taskBody) {
+  const items = parsePlanItems(taskBody || '');
+  const seen = new Set();
+  const out = [];
+  for (const it of items) {
+    if (it.file && !seen.has(it.file)) {
+      seen.add(it.file);
+      out.push(it.file);
+    }
+  }
+  return out;
+}
+
+// ---------- Filesystem: emitSections ----------
+
+function readPlan(featureDir) {
+  const planPath = path.join(featureDir, 'plan.md');
+  if (!fs.existsSync(planPath)) return null;
+  return fs.readFileSync(planPath, 'utf8');
+}
+
+function pad2(n) {
+  return String(n).padStart(2, '0');
+}
+
+/**
+ * parseDependsOn(taskBody) — string-match a "Depends on:" or "Depends:" line
+ * from the task body. Returns the trimmed value, or null if none found.
+ */
+export function parseDependsOn(taskBody) {
+  if (!taskBody || typeof taskBody !== 'string') return null;
+  const m = taskBody.match(/^[ \t]*Depends(?:\s+on)?:\s*(.+?)\s*$/im);
+  if (!m) return null;
+  const v = m[1].trim();
+  return v || null;
+}
+
+function renderSectionFile({ block, idx, files }) {
+  const filesLine = files.length ? files.join(', ') : '—';
+  const title = block.title || `Task ${block.id.slice(1)}`;
+  const dependsRaw = parseDependsOn(block.body);
+  const dependsLine = dependsRaw || '—';
+  return [
+    `# Section ${pad2(idx)} — ${title}`,
+    ``,
+    `**Task ID:** ${block.id}`,
+    `**Depends on:** ${dependsLine}`,
+    `**Files:** ${filesLine}`,
+    ``,
+    `## Plan`,
+    ``,
+    block.body,
+    ``,
+  ].join('\n');
+}
+
+/**
+ * emitSections(featureDir) — idempotent emission of `<featureDir>/sections/`.
+ *
+ * Returns { created: string[], skipped: string[] } (relative paths within
+ * sections/). No-op if `plan.md` is missing or task count is sub-threshold.
+ * Existing section files are NEVER overwritten.
+ */
+export function emitSections(featureDir) {
+  const result = { created: [], skipped: [] };
+  if (!featureDir) return result;
+
+  const plan = readPlan(featureDir);
+  if (plan == null) return result;
+
+  const blocks = parseTaskBlocks(plan);
+  if (!shouldEmitSections(blocks.length)) return result;
+
+  const sectionsDir = path.join(featureDir, SECTIONS_DIR);
+  fs.mkdirSync(sectionsDir, { recursive: true });
+
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i];
+    const idx = i + 1;
+    const slug = slugify(block.title) || `task-${block.id.slice(1)}`;
+    const filename = `section-${pad2(idx)}-${slug}.md`;
+    const fullPath = path.join(sectionsDir, filename);
+    if (fs.existsSync(fullPath)) {
+      result.skipped.push(filename);
+      continue;
+    }
+    const files = extractSectionFiles(block.body);
+    const content = renderSectionFile({ block, idx, files });
+    fs.writeFileSync(fullPath, content);
+    result.created.push(filename);
+  }
+
+  return result;
+}
+
+// ---------- Filesystem: appendTrailers ----------
+
+const TRAILER_HEADING_RE = /^## What Was Built(?:\s*\(iteration\s+(\d+)\))?\s*$/gm;
+
+function readDeclaredFiles(sectionContent) {
+  const m = sectionContent.match(/^\*\*Files:\*\*\s+(.+)$/m);
+  if (!m) return [];
+  const raw = m[1].trim();
+  if (!raw || raw === '—' || raw === '-') return [];
+  return raw
+    .split(',')
+    .map(s => s.trim())
+    .filter(Boolean);
+}
+
+/**
+ * maxIteration(sectionContent) — scan all "What Was Built" headers and return
+ * the maximum iteration N (treating the unnumbered first one as N=1). Returns
+ * 0 if no trailer exists yet.
+ */
+function maxIteration(sectionContent) {
+  const re = /^## What Was Built(?:\s*\(iteration\s+(\d+)\))?\s*$/gm;
+  let max = 0;
+  let m;
+  while ((m = re.exec(sectionContent)) !== null) {
+    const n = m[1] ? parseInt(m[1], 10) : 1;
+    if (Number.isFinite(n) && n > max) max = n;
+  }
+  return max;
+}
+
+function nextTrailerHeading(maxIter) {
+  if (maxIter <= 0) return '## What Was Built';
+  return `## What Was Built (iteration ${maxIter + 1})`;
+}
+
+/**
+ * computeFilteredDiffStat(cwd, commit, declaredFiles) — best-effort per-section
+ * `git diff --stat <commit>~1..<commit> -- <files>`. Returns the trimmed string,
+ * or a sentinel:
+ *   - "(no declared files)" when declaredFiles is empty
+ *   - "(diff stat unavailable)" on any failure
+ */
+function computeFilteredDiffStat(cwd, commit, declaredFiles) {
+  if (!declaredFiles || declaredFiles.length === 0) return '(no declared files)';
+  if (!cwd || !commit) return '(diff stat unavailable)';
+  try {
+    // Use execFileSync with an argv array — no shell, no expansion, so file paths
+    // containing $(...), backticks, backslashes, spaces, etc. are passed verbatim
+    // to git as literal pathspecs.
+    const argv = ['diff', '--stat', `${commit}~1..${commit}`, '--', ...declaredFiles];
+    const out = execFileSync('git', argv, {
+      cwd,
+      encoding: 'utf-8',
+      timeout: 5000,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    }).trim();
+    return out || '(diff stat unavailable)';
+  } catch {
+    return '(diff stat unavailable)';
+  }
+}
+
+function renderTrailer({ heading, commit, diffStat, owned, deviated }) {
+  const ownedStr = owned.length ? owned.join(', ') : 'None';
+  const deviatedStr = deviated.length ? deviated.join(', ') : 'None';
+  const commitStr = commit ? `\`${commit}\`` : '`unknown`';
+  const diffStr = diffStat && String(diffStat).trim() ? String(diffStat).trim() : '(diff stat unavailable)';
+  return [
+    ``,
+    heading,
+    ``,
+    `- **Commit:** ${commitStr}`,
+    `- **Diff:** ${diffStr}`,
+    `- **Files this section owns that changed:** ${ownedStr}`,
+    `- **Files this section declared but did not change:** ${deviatedStr}`,
+    ``,
+  ].join('\n');
+}
+
+/**
+ * appendTrailers({ featureDir, commit, filesChanged, cwd, diffStat? }) — append
+ * a "What Was Built" block to every section file under `<featureDir>/sections/`.
+ *
+ * - No-op if sections/ is absent.
+ * - Auto-numbers re-runs as `iteration max(N)+1` (append-only; never overwrites).
+ * - Per-section partition: declared ∩ changed → owned; declared \ changed →
+ *   deviation. Changed-but-undeclared is deferred to COMP-PLAN-SECTIONS-REPORT.
+ * - Per-section diff stat: when `cwd` is provided, runs
+ *     `git diff --stat <commit>~1..<commit> -- <declared-files>`
+ *   filtered to that section's declared files. When `cwd` is omitted but a
+ *   `diffStat` string is provided (legacy callers), uses that string verbatim.
+ *
+ * Returns { trailed: string[] } — section filenames updated.
+ */
+export function appendTrailers({ featureDir, commit, filesChanged, cwd, diffStat } = {}) {
+  const result = { trailed: [] };
+  if (!featureDir) return result;
+  const sectionsDir = path.join(featureDir, SECTIONS_DIR);
+  if (!fs.existsSync(sectionsDir)) return result;
+
+  const changedSet = new Set(Array.isArray(filesChanged) ? filesChanged : []);
+  const files = fs
+    .readdirSync(sectionsDir)
+    .filter(f => /^section-\d+-.+\.md$/.test(f))
+    .sort();
+
+  for (const filename of files) {
+    const fullPath = path.join(sectionsDir, filename);
+    const existing = fs.readFileSync(fullPath, 'utf8');
+    const declared = readDeclaredFiles(existing);
+    const owned = declared.filter(f => changedSet.has(f));
+    const deviated = declared.filter(f => !changedSet.has(f));
+    const heading = nextTrailerHeading(maxIteration(existing));
+    // Prefer cwd-based per-section filtered diff. Fall back to legacy diffStat
+    // string only when cwd is not supplied. Wrapped in try/catch — failure
+    // substitutes "(diff stat unavailable)".
+    let perSectionDiff;
+    if (cwd) {
+      try {
+        perSectionDiff = computeFilteredDiffStat(cwd, commit, declared);
+      } catch {
+        perSectionDiff = '(diff stat unavailable)';
+      }
+    } else {
+      perSectionDiff = diffStat;
+    }
+    const trailer = renderTrailer({ heading, commit, diffStat: perSectionDiff, owned, deviated });
+    const sep = existing.endsWith('\n') ? '' : '\n';
+    fs.writeFileSync(fullPath, existing + sep + trailer);
+    result.trailed.push(filename);
+  }
+
+  return result;
+}

package/lib/step-prompt.js

@@ -5,6 +5,7 @@
 import { readdirSync, readFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { checkStaleness } from './staleness.js';
+import { readHypotheses, formatRejectedHypotheses } from './bug-ledger.js';
 
 // ---------------------------------------------------------------------------
 // Ambient context cache — loaded once per build, keyed by contextDir path.
@@ -165,7 +166,26 @@ export function buildRetryPrompt(stepDispatch, violations, context, conflicts) {
     sections.push(buildConflictSection(conflicts));
   }
 
-  return sections.join('\n\n');
+  let prompt = sections.join('\n\n');
+
+  // COMP-FIX-HARD T6: in bug-mode diagnose retries, prepend a digest of
+  // previously rejected hypotheses so the next attempt avoids dead ends.
+  // Guard: silent no-op if any precondition fails (regression-safe).
+  if (
+    context && context.mode === 'bug'
+    && stepDispatch && stepDispatch.step_id === 'diagnose'
+    && context.bug_code && context.cwd
+  ) {
+    try {
+      const entries = readHypotheses(context.cwd, context.bug_code);
+      const block = formatRejectedHypotheses(entries);
+      if (block) prompt = block + '\n' + prompt;
+    } catch {
+      // best-effort: never let ledger I/O break a retry
+    }
+  }
+
+  return prompt;
 }
 
 /**

package/lib/step-validator.js

@@ -15,10 +15,11 @@ import { runAndNormalize } from './result-normalizer.js';
  * @param {string}   opts.artifact  - File path to validate (relative to cwd)
  * @param {string[]} opts.criteria  - List of things to check
  * @param {string}   opts.stepId    - Step ID (for logging)
- * @param {object}   opts.connector - Agent connector to use
+ * @param {object}   opts.stratum   - StratumMcpClient for dispatching the validator agent
+ * @param {string}   [opts.cwd]     - Working directory
  * @returns {Promise<{ valid: boolean, issues: string[] }>}
  */
-export async function validateStep({ artifact, criteria, stepId, connector }) {
+export async function validateStep({ artifact, criteria, stepId, stratum, cwd }) {
   const prompt =
     `You are a validator. Read the file "${artifact}" and check the following criteria:\n\n` +
     criteria.map((c, i) => `${i + 1}. ${c}`).join('\n') + '\n\n' +
@@ -31,13 +32,14 @@ export async function validateStep({ artifact, criteria, stepId, connector }) {
   // Minimal dispatch descriptor — only output_fields needed for JSON extraction
   const dispatch = {
     step_id: `validate_${stepId}`,
+    agent:   'claude',
     output_fields: {
       valid: 'boolean',
       issues: 'array',
     },
   };
 
-  const { result } = await runAndNormalize(connector, prompt, dispatch);
+  const { result } = await runAndNormalize(null, prompt, dispatch, { stratum, cwd });
 
   if (!result || typeof result.valid !== 'boolean') {
     // Extraction failed — assume valid (optimistic fallback)

package/lib/stratum-mcp-client.js

@@ -14,8 +14,10 @@
  */
 
 import { execFileSync } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { validateBuildStreamEvent } from './build-stream-schema.js';
 
 export class StratumError extends Error {
   constructor(code, message, detail) {
@@ -30,6 +32,86 @@ export class StratumMcpClient {
   #client = null;
   #transport = null;
   #connected = false;
+  // STRAT-PAR-STREAM: subscribers keyed by `${flowId}::${stepId}` → Set<handler>
+  #eventSubs = new Map();
+
+  /**
+   * Subscribe to BuildStreamEvent push notifications scoped to a (flowId, stepId).
+   * Handler receives a parsed BuildStreamEvent envelope. Returns an unsubscribe fn.
+   *
+   * Events arrive only while a tool call (parallelStart/parallelPoll/...) for that
+   * scope is in flight — the underlying transport is MCP progress notifications,
+   * which are tied to an active request. Subscribe BEFORE the poll loop, unsubscribe
+   * after `outcome` is observed.
+   *
+   * @param {string} flowId
+   * @param {string} stepId
+   * @param {(event: object) => void} handler
+   * @returns {() => void} unsubscribe
+   */
+  onEvent(flowId, stepId, handler) {
+    const key = `${flowId}::${stepId}`;
+    let set = this.#eventSubs.get(key);
+    if (!set) {
+      set = new Set();
+      this.#eventSubs.set(key, set);
+    }
+    set.add(handler);
+    return () => {
+      const s = this.#eventSubs.get(key);
+      if (!s) return;
+      s.delete(handler);
+      if (s.size === 0) this.#eventSubs.delete(key);
+    };
+  }
+
+  /**
+   * Internal: dispatch a parsed BuildStreamEvent to subscribers for its scope.
+   * Errors in handlers are logged and swallowed — push delivery is best-effort.
+   */
+  #dispatchEvent(event) {
+    if (!event || typeof event !== 'object') return;
+    const { flow_id, step_id } = event;
+    if (!flow_id || !step_id) return;
+    const set = this.#eventSubs.get(`${flow_id}::${step_id}`);
+    if (!set || set.size === 0) return;
+    for (const h of set) {
+      try { h(event); } catch (err) {
+        console.error('[stratum-mcp-client] onEvent handler threw:', err);
+      }
+    }
+  }
+
+  /**
+   * Build the onprogress callback for a tool call. Parses the
+   * notification.message field as JSON and dispatches if it looks like a
+   * BuildStreamEvent (schema_version + kind). Other progress payloads are
+   * ignored.
+   */
+  #makeProgressHandler() {
+    return (progress) => {
+      const msg = progress?.message;
+      if (typeof msg !== 'string' || msg.length === 0) return;
+      let parsed;
+      try { parsed = JSON.parse(msg); } catch { return; }
+      // Discriminator: BuildStreamEvent has schema_version + kind + flow_id + step_id
+      if (!parsed || typeof parsed !== 'object') return;
+      if (typeof parsed.kind !== 'string') return;
+      // STRAT-PAR-STREAM-CONSUMER-VALIDATE: validate envelope before forwarding.
+      // On failure: warn and drop — never throw. Consumer must remain robust to
+      // producer drift. Non-BuildStreamEvent payloads are silently ignored above.
+      const validation = validateBuildStreamEvent(parsed);
+      if (!validation.valid) {
+        console.warn(
+          `[stratum-mcp-client] dropping invalid BuildStreamEvent` +
+          ` kind=${parsed.kind} schema_version=${parsed.schema_version}:`,
+          validation.error
+        );
+        return;
+      }
+      this.#dispatchEvent(parsed);
+    };
+  }
 
   /**
    * Spawn stratum-mcp and establish MCP connection.
@@ -85,9 +167,11 @@ export class StratumMcpClient {
    * Call an MCP tool and return the parsed JSON result.
    * @param {string} toolName
    * @param {object} args
+   * @param {object} [opts]
+   * @param {boolean} [opts.subscribeProgress] - if true, attach onprogress to demux BuildStreamEvents
    * @returns {Promise<any>}
    */
-  async #callTool(toolName, args) {
+  async #callTool(toolName, args, opts = {}) {
     // Allow test-injected client to bypass real connection requirement.
     // Gated on NODE_ENV=test so production code cannot accidentally redirect calls.
     const client = (process.env.NODE_ENV === 'test' && this._testClient) || null;
@@ -95,10 +179,18 @@ export class StratumMcpClient {
       throw new Error('StratumMcpClient not connected. Call connect() first.');
     }
 
-    const result = await (client ?? this.#client).callTool({
-      name: toolName,
-      arguments: args,
-    });
+    const callArgs = { name: toolName, arguments: args };
+    const requestOpts = {};
+    if (opts.subscribeProgress) {
+      // Long-running tool calls may stream events for many minutes.
+      // Use generous timeouts and reset on each progress notification.
+      requestOpts.onprogress = this.#makeProgressHandler();
+      requestOpts.resetTimeoutOnProgress = true;
+      requestOpts.timeout = 600_000; // 10 min per heartbeat
+      requestOpts.maxTotalTimeout = 24 * 60 * 60 * 1000; // 24h hard cap
+    }
+
+    const result = await (client ?? this.#client).callTool(callArgs, undefined, requestOpts);
 
     // MCP tool results come back as content array; extract text content
     const textContent = result.content?.find(c => c.type === 'text');
@@ -325,7 +417,7 @@ export class StratumMcpClient {
     return this.#callTool('stratum_parallel_start', {
       flow_id: flowId,
       step_id: stepId,
-    });
+    }, { subscribeProgress: true });
   }
 
   /**
@@ -340,7 +432,7 @@ export class StratumMcpClient {
     return this.#callTool('stratum_parallel_poll', {
       flow_id: flowId,
       step_id: stepId,
-    });
+    }, { subscribeProgress: true });
   }
 
   /**
@@ -362,4 +454,77 @@ export class StratumMcpClient {
       merge_status: mergeStatus,
     });
   }
+
+  /**
+   * Run an agent (claude/codex) via the Python connector tier and stream
+   * BuildStreamEvent envelopes back via MCP progress notifications.
+   * Subscribe via `onEvent(correlationId, '_agent_run', handler)` BEFORE calling.
+   *
+   * @param {string} agentType    'claude' | 'codex'
+   * @param {string} prompt
+   * @param {object} [opts]
+   * @param {string}   [opts.correlationId]    Generated if absent.
+   * @param {string}   [opts.modelID]          Override model.
+   * @param {string[]} [opts.allowedTools]
+   * @param {string[]} [opts.disallowedTools]
+   * @param {object}   [opts.thinking]
+   * @param {string}   [opts.effort]
+   * @param {string}   [opts.cwd]
+   * @returns {Promise<{text: string, correlation_id: string}>}
+   *
+   * NOTE: Schema injection is the caller's responsibility — `runAndNormalize`
+   * runs `injectSchema(prompt, schema)` client-side. Forwarding `schema` to
+   * the server would cause double-injection (producer also calls
+   * inject_schema on its end). Schema is intentionally not forwarded here.
+   */
+  async agentRun(agentType, prompt, opts = {}) {
+    const correlationId = opts.correlationId ?? randomUUID();
+    const result = await this.#callTool('stratum_agent_run', {
+      type:              agentType,
+      prompt,
+      modelID:           opts.modelID ?? undefined,
+      allowed_tools:     opts.allowedTools ?? undefined,
+      disallowed_tools:  opts.disallowedTools ?? undefined,
+      thinking:          opts.thinking ?? undefined,
+      effort:            opts.effort ?? undefined,
+      cwd:               opts.cwd ?? undefined,
+      correlation_id:    correlationId,
+    }, { subscribeProgress: true });
+    if (result && typeof result === 'object' && !result.correlation_id) {
+      result.correlation_id = correlationId;
+    }
+    return result;
+  }
+
+  /**
+   * One-shot agent text call without progress streaming. Used for short Q&A
+   * (gate askAgent path) where cockpit visibility is not needed.
+   *
+   * @param {string} agentType
+   * @param {string} prompt
+   * @param {object} [opts]
+   * @param {string} [opts.cwd]
+   * @returns {Promise<string>}
+   */
+  async runAgentText(agentType, prompt, opts = {}) {
+    const result = await this.#callTool('stratum_agent_run', {
+      type:   agentType,
+      prompt,
+      cwd:    opts.cwd ?? undefined,
+    }, { subscribeProgress: false });
+    return result?.text ?? '';
+  }
+
+  /**
+   * Cancel an in-flight stratum_agent_run by correlation id. Returns
+   * `{status: 'cancelled' | 'not_found', correlation_id}` from the producer.
+   *
+   * @param {string} correlationId
+   * @returns {Promise<object>}
+   */
+  async cancelAgentRun(correlationId) {
+    return this.#callTool('stratum_cancel_agent_run', {
+      correlation_id: correlationId,
+    });
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartmemory/compose",
-  "version": "0.1.1-beta",
+  "version": "0.1.3-beta",
   "description": "Structured AI dev pipeline — goal-to-product orchestration with gates, iteration loops, and feature lifecycle management.",
   "author": "SmartMemory",
   "license": "MIT",
@@ -15,8 +15,10 @@
     "dev:client": "vite",
     "build": "vite build",
     "preview": "vite preview",
-    "test": "node --test test/*.test.js",
+    "test": "node --test test/*.test.js test/comp-obs-branch/*.test.js && npm run test:ui",
+    "test:ui": "vitest run",
     "test:integration": "node --test test/integration/*.test.js",
+    "test:wave-6": "node --test test/wave-6-integration.test.js test/wave-6-contract-compliance.test.js",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -46,6 +48,8 @@
     "access": "public"
   },
   "files": [
+    ".compose-deps.json",
+    ".claude/skills/**",
     "bin/**",
     "server/**",
     "lib/**",
@@ -55,6 +59,7 @@
     "pipelines/**",
     "contracts/**",
     "scripts/**",
+    "skills/**",
     "README.md",
     "LICENSE"
   ],
@@ -75,6 +80,8 @@
     "@radix-ui/react-toggle-group": "^1.1.11",
     "@radix-ui/react-tooltip": "^1.2.8",
     "@tanstack/react-virtual": "^3.13.23",
+    "ajv": "^8.18.0",
+    "ajv-formats": "^3.0.1",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "cors": "^2.8.5",
@@ -99,11 +106,15 @@
     "zustand": "^5.0.11"
   },
   "devDependencies": {
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/react": "^16.3.2",
     "@vitejs/plugin-react": "^4.3.4",
     "autoprefixer": "^10.4.20",
+    "jsdom": "^29.0.2",
     "postcss": "^8.5.3",
     "tailwindcss": "^3.4.17",
-    "vite": "^6.1.0"
+    "vite": "^6.1.0",
+    "vitest": "^4.1.4"
   },
   "overrides": {
     "zod": "^4.0.0"