@smartmemory/compose 0.1.1-beta → 0.1.2-beta

package/pipelines/bug-fix.stratum.yaml

@@ -69,6 +69,13 @@ contracts:
     discipline_score: {type: number}
     summary:          {type: string}
 
+  BisectResult:
+    skipped:          {type: boolean}
+    bisect_commit:    {type: string}  # nullable; empty string when skipped
+    estimate_minutes: {type: number}
+    log_path:         {type: string}  # nullable; empty string when skipped
+    summary:          {type: string}
+
 functions:
   reproduce:
     mode: compute
@@ -99,6 +106,30 @@ functions:
       - "result.scope_hint in ('single', 'cross-layer', 'unknown')"
     retries: 2
 
+  bisect:
+    mode: compute
+    intent: >
+      Decide whether the bug is a regression worth bisecting; if so,
+      classify → estimate cost → gate the human → run git bisect.
+      The runtime helper `lib/bug-bisect.js` does the work:
+        1. classifyRegression(): repro test exists in main AND files in
+           diagnosis.affected_layers were touched in the last 10 commits.
+        2. estimateBisectCost(): test_runs = ceil(log2(commits in range));
+           seconds_per_run sampled by running the test once.
+        3. Gate: "Looks like a regression. Run git bisect? Estimate:
+           <test_runs> runs × <seconds_per_run>s = ~<total_minutes> min.
+           approve / skip / kill"
+        4. On approve: runBisect() drives `git bisect start && bad HEAD
+           && good <baseline> && bisect run <testCmd>`, captures log to
+           docs/bugs/<bug-code>/bisect.log, always resets in finally.
+        5. On skip OR not-a-regression: return {skipped: true,
+           bisect_commit: null, estimate_minutes: 0} and continue.
+    input:
+      task: {type: string}
+      diagnosis: {type: object}
+    output: BisectResult
+    retries: 1
+
   scope_check:
     mode: compute
     intent: >
@@ -191,12 +222,19 @@ flows:
           task: "$.input.task"
         depends_on: [reproduce]
 
+      - id: bisect
+        function: bisect
+        inputs:
+          task: "$.input.task"
+          diagnosis: "$.steps.diagnose.output"
+        depends_on: [diagnose]
+
       - id: scope_check
         function: scope_check
         inputs:
           task: "$.input.task"
           diagnosis: "$.steps.diagnose.output"
-        depends_on: [diagnose]
+        depends_on: [bisect]
 
       - id: fix
         function: fix

package/pipelines/build.stratum.yaml

@@ -26,10 +26,16 @@ contracts:
     outcome:  {type: string, values: [complete, skipped, failed]}
     summary:  {type: string}
 
+  # Canonical review output — produced by both review_check (Codex) and parallel_review (Claude).
+  # Schema source: compose/contracts/review-result.json  (_roadmap: STRAT-CLAUDE-EFFORT-PARITY)
   ReviewResult:
-    clean:    {type: boolean}
-    summary:  {type: string}
-    findings: {type: array}
+    clean:      {type: boolean}
+    summary:    {type: string}
+    findings:   {type: array}
+    meta:       {type: object}
+    lenses_run: {type: array}
+    auto_fixes: {type: array}
+    asks:       {type: array}
 
   TestResult:
     passing:  {type: boolean}
@@ -39,14 +45,6 @@ contracts:
   TaskGraph:
     tasks: {type: array}
 
-  LensFinding:
-    lens:       {type: string}
-    file:       {type: string}
-    line:       {type: number}
-    severity:   {type: string, values: [must-fix, should-fix, nit]}
-    finding:    {type: string}
-    confidence: {type: number}
-
   LensTask:
     id:              {type: string}
     lens_name:       {type: string}
@@ -57,18 +55,6 @@ contracts:
   TriageResult:
     tasks:    {type: array}
 
-  LensResult:
-    clean:    {type: boolean}
-    findings: {type: array, items: LensFinding}
-
-  MergedReviewResult:
-    clean:      {type: boolean}
-    summary:    {type: string}
-    findings:   {type: array, items: LensFinding}
-    lenses_run: {type: array}
-    auto_fixes: {type: array, items: LensFinding}
-    asks:       {type: array, items: LensFinding}
-
 functions:
   design_gate:
     mode: gate
@@ -96,12 +82,12 @@ flows:
       - id: review
         agent: codex
         intent: >
-          Review the implementation against the blueprint. Return structured JSON:
-          { "clean": boolean, "summary": string, "findings": string[] }.
-          Set clean=true only if no actionable findings with confidence >= 80 remain.
+          Review the implementation against the blueprint and task.
         inputs:
           task: "$.input.task"
           blueprint: "$.input.blueprint"
+          review_mode: "true"
+          confidence_gate: "7"
         output_contract: ReviewResult
         ensure:
           - "result.clean == True"
@@ -117,7 +103,7 @@ flows:
       blueprint:          {type: string}
       diff:               {type: string}
       prior_dirty_lenses: {type: array, optional: true}
-    output: MergedReviewResult
+    output: ReviewResult
     steps:
       - id: triage
         agent: "claude:orchestrator"
@@ -150,34 +136,31 @@ flows:
         source: "$.steps.triage.output.tasks"
         max_concurrent: 4
         isolation: none
+        output_contract: ReviewResult
         intent_template: >
-          You are a {lens_name} reviewer. Review ONLY through the {lens_name} lens.
-          Focus: {lens_focus}
-          Confidence gate: only report findings with confidence >= {confidence_gate}.
-          False-positive exclusions: {exclusions}
-          Return JSON: { "clean": boolean, "findings": LensFinding[] }
-          where each finding has: lens, file, line, severity (must-fix|should-fix|nit),
-          finding (description), confidence (1-10).
+          Lens: {lens_name}. Focus: {lens_focus}.
         require: all
 
       - id: merge
         agent: "claude:orchestrator"
         intent: >
-          Merge findings from all review lenses. The input contains the parallel
-          dispatch aggregate with tasks[].result for each lens.
-          1. Collect all findings arrays from completed task results.
-          2. Deduplicate: same file + same issue = one finding, keep highest confidence.
-          3. Assign severity: must-fix (blocks ship), should-fix (next iteration), nit (logged).
-          4. Classify: auto_fixes (mechanical: formatting, simple tests, obvious typos)
-             vs asks (requires judgment).
-          5. lenses_run = IDs of lenses that produced must-fix or should-fix findings.
-          Return JSON: MergedReviewResult with clean, summary, findings, lenses_run,
-          auto_fixes, asks. Set clean=true only if zero must-fix and zero should-fix findings.
+          Merge ReviewResult arrays from all lens runs into a single canonical ReviewResult.
+          The input contains the parallel dispatch aggregate with tasks[].result for each lens.
+          1. Concatenate all findings arrays from completed task results.
+             Deduplicate by file+line+lens: keep finding with highest confidence;
+             carry over its applied_gate.
+          2. Recompute clean: zero must-fix AND zero should-fix findings (post-dedupe, post-gate).
+          3. lenses_run = IDs of lenses that produced any must-fix or should-fix finding.
+          4. auto_fixes = mechanical fixes (formatting, typos, simple tests).
+          5. asks = findings requiring human judgment.
+          Return canonical ReviewResult with clean, summary, findings, lenses_run,
+          auto_fixes, asks, meta.
         inputs:
           results: "$.steps.review_lenses.output"
           task: "$.input.task"
           blueprint: "$.input.blueprint"
-        output_contract: MergedReviewResult
+          reduce_mode: "true"
+        output_contract: ReviewResult
         depends_on: [review_lenses]
 
   # --- Sub-flow: coverage ---

package/pipelines/review-fix.stratum.yaml

@@ -73,7 +73,7 @@ functions:
           - the task description
           - the execute_summary (what was implemented)
           - the blueprint content
-          - instruction: "List actionable findings with confidence >= 80.
+          - instruction: "List actionable findings with confidence >= 7.
             Set clean=true only if no actionable findings remain."
         Pass the schema to agent_run so it returns structured JSON.
 

package/presets/team-review.stratum.yaml

@@ -17,10 +17,15 @@ contracts:
       type: array
       values: [{type: object}]
     diff: {type: string}
-  MergedReviewResult:
-    findings: {type: string}
-    has_critical: {type: string}
-    summary: {type: string}
+  # Canonical schema — STRAT-CLAUDE-EFFORT-PARITY. Local MergedReviewResult removed.
+  ReviewResult:
+    clean:      {type: boolean}
+    summary:    {type: string}
+    findings:   {type: array}
+    meta:       {type: object}
+    lenses_run: {type: array}
+    auto_fixes: {type: array}
+    asks:       {type: array}
 
 workflow:
   name: team-review
@@ -38,7 +43,7 @@ flows:
     input:
       featureCode: {type: string}
       description: {type: string}
-    output: MergedReviewResult
+    output: ReviewResult
     steps:
       - id: triage
         agent: "claude:orchestrator"
@@ -76,9 +81,9 @@ flows:
           Confidence gate: only report findings with confidence >= {confidence_gate}/10.
           Exclusions: do NOT flag {exclusions}.
 
-          Return JSON: { "clean": boolean, "findings": LensFinding[] }
+          Return JSON: { "clean": boolean, "findings": <ReviewResult finding items> }
           where each finding has: lens, file, line, severity (must-fix|should-fix|nit),
-          finding (description), confidence (1-10).
+          finding (description), confidence (1-10), applied_gate (integer).
 
           If no issues found, return { "clean": true, "findings": [] }.
         output_fields:
@@ -92,15 +97,17 @@ flows:
         agent: "claude:orchestrator"
         depends_on: [review_lenses]
         intent: >
-          Consolidate findings from all review lenses. Deduplicate findings
-          that appear in multiple passes (same file:line, same issue). Rank
-          by severity (must-fix first, then should-fix, then nit).
-          Set has_critical to "true" if any finding has severity "must-fix",
-          "false" otherwise. Write a one-sentence summary.
+          Consolidate ReviewResult arrays from all review lenses into a single
+          canonical ReviewResult. Deduplicate findings (same file:line+lens,
+          keep highest confidence; carry over its applied_gate). Rank by
+          severity (must-fix first, then should-fix, then nit). Set clean=true
+          only if zero must-fix AND zero should-fix findings remain. Write a
+          one-sentence summary.
         inputs:
           review_results: "$.steps.review_lenses.output"
-        output_contract: MergedReviewResult
+          reduce_mode: "true"
+        output_contract: ReviewResult
         ensure:
-          - "result.has_critical == 'false'"
+          - "result.clean == True"
           - "result.summary != ''"
         retries: 2

package/server/build-stream-bridge.js

@@ -455,6 +455,22 @@ export class BuildStreamBridge {
           _source: 'build',
         };
 
+      // STRAT-PAR-STREAM: typed BuildStreamEvent envelope (schema v0.2.5+) wrapped
+      // by build.js as { type: 'build_stream_event', event: {...} }. Pass the
+      // inner envelope through to the cockpit unchanged so renderers can
+      // discriminate by `kind`.
+      case 'build_stream_event': {
+        const inner = event.event;
+        if (!inner || typeof inner !== 'object' || typeof inner.kind !== 'string') {
+          return null;
+        }
+        return {
+          type: 'buildStreamEvent',
+          event: inner,
+          _source: 'build',
+        };
+      }
+
       // COMP-HEALTH item 118: health score after build completion
       case 'health_score':
         return {
@@ -465,6 +481,18 @@ export class BuildStreamBridge {
           _source: 'build',
         };
 
+      // COMP-AGENT-CAPS-5: capability violation audit events
+      case 'capability_violation':
+        return {
+          type: 'system', subtype: 'capability_violation',
+          stepId: event.stepId,
+          agent: event.agent,
+          template: event.template,
+          detail: event.detail,
+          severity: event.severity ?? 'violation',
+          _source: 'build',
+        };
+
       default:
         return null; // unknown event type — skip
     }

package/server/cc-session-feature-resolver.js

@@ -0,0 +1,111 @@
+/**
+ * CC-session → feature_code resolver — COMP-OBS-BRANCH T2.
+ *
+ * Forge session ids (`session-<ts>-<hex>` from SessionManager) and Claude Code
+ * session uuids live in different namespaces. The only join key is
+ * `sessions.json[i].transcriptPath` — its basename is `<cc_session_id>.jsonl`.
+ *
+ * Resolution tiers (per blueprint §5):
+ *   1. Primary  — sessions.json scan, match basename(transcriptPath)
+ *   2. Fallback — probe <featureRoot>/<CODE>/sessions/<cc_session_id>.*
+ *   3. Unbound  — null (caller skips emission)
+ *
+ * Results cache per cc_session_id; invalidated on mtime bump of either
+ * sessions.json or the matched feature's sessions/ directory.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+function statMtime(p) {
+  try { return fs.statSync(p).mtimeMs; } catch { return null; }
+}
+
+function loadSessionsJson(sessionsFile) {
+  try {
+    const raw = fs.readFileSync(sessionsFile, 'utf8');
+    const arr = JSON.parse(raw);
+    return Array.isArray(arr) ? arr : [];
+  } catch {
+    return [];
+  }
+}
+
+export class CCSessionFeatureResolver {
+  constructor({ sessionsFile, featureRoot }) {
+    if (!sessionsFile) throw new Error('sessionsFile required');
+    if (!featureRoot) throw new Error('featureRoot required');
+    this.sessionsFile = sessionsFile;
+    this.featureRoot = featureRoot;
+    this._cache = new Map(); // cc_session_id → { feature_code, sessionsMtime, featureDirMtime }
+    this._sessionsIndex = null;
+    this._sessionsMtime = null;
+    this.stats = { unbound_count: 0 };
+  }
+
+  _refreshIndex() {
+    const mtime = statMtime(this.sessionsFile);
+    if (mtime === this._sessionsMtime && this._sessionsIndex) return;
+    this._sessionsMtime = mtime;
+    const sessions = loadSessionsJson(this.sessionsFile);
+    const idx = new Map();
+    for (const s of sessions) {
+      const tp = s?.transcriptPath;
+      if (!tp || !s?.featureCode) continue;
+      const base = path.basename(tp);
+      const ccId = base.replace(/\.jsonl$/, '');
+      if (!idx.has(ccId)) idx.set(ccId, s.featureCode);
+    }
+    this._sessionsIndex = idx;
+    this._cache.clear();
+  }
+
+  _fallbackProbe(cc_session_id) {
+    let entries;
+    try { entries = fs.readdirSync(this.featureRoot, { withFileTypes: true }); }
+    catch { return null; }
+    for (const ent of entries) {
+      if (!ent.isDirectory()) continue;
+      const sessionsDir = path.join(this.featureRoot, ent.name, 'sessions');
+      let files;
+      try { files = fs.readdirSync(sessionsDir); } catch { continue; }
+      if (files.some(f => f.startsWith(cc_session_id + '.'))) {
+        return ent.name;
+      }
+    }
+    return null;
+  }
+
+  resolve(cc_session_id) {
+    if (!cc_session_id) return null;
+    this._refreshIndex();
+
+    const cached = this._cache.get(cc_session_id);
+    if (cached && cached.sessionsMtime === this._sessionsMtime) {
+      if (cached.feature_code == null) return null;
+      const curDirMtime = statMtime(path.join(this.featureRoot, cached.feature_code, 'sessions'));
+      if (curDirMtime === cached.featureDirMtime) return cached.feature_code;
+    }
+
+    let fc = this._sessionsIndex.get(cc_session_id);
+    if (!fc) fc = this._fallbackProbe(cc_session_id);
+
+    if (fc) {
+      const dirMtime = statMtime(path.join(this.featureRoot, fc, 'sessions'));
+      this._cache.set(cc_session_id, {
+        feature_code: fc,
+        sessionsMtime: this._sessionsMtime,
+        featureDirMtime: dirMtime,
+      });
+      return fc;
+    }
+
+    this._cache.set(cc_session_id, {
+      feature_code: null,
+      sessionsMtime: this._sessionsMtime,
+      featureDirMtime: null,
+    });
+    this.stats.unbound_count++;
+    return null;
+  }
+}