@smartmemory/compose 0.2.36-beta → 0.2.38-beta

package/lib/resolve-workspace.js

@@ -5,7 +5,9 @@
  *   1. explicit hint.workspaceId  (cheap upward walk first; falls back to discovery)
  *   2. COMPOSE_TARGET env         (absolute path bypasses discovery; id routes through it)
  *   3. hint.getBinding() (MCP binding)
- *   4. discovery (auto-pick when exactly one candidate; throws otherwise)
+ *   4. discovery (auto-pick when exactly one candidate; throws otherwise) —
+ *      degrades to the nearest-enclosing workspace if the subtree is too broad
+ *      to enumerate within the visit bound.
  *
  * Throws structured errors with `.code`: WorkspaceUnknown, WorkspaceAmbiguous,
  * WorkspaceIdCollision, WorkspaceUnset. The CLI's dieOnWorkspaceError consumes them.
@@ -13,6 +15,14 @@
  * Design intent: explicit-flag path uses findWorkspaceById (cheap upward walk)
  * BEFORE invoking discoverWorkspaces — this lets users escape WorkspaceDiscoveryTooBroad
  * by passing --workspace=<ancestor-id>. A descendant id still routes through discovery.
+ *
+ * The no-hint path mirrors that instinct only when the descendant scan can't
+ * enumerate the subtree (WorkspaceDiscoveryTooBroad): rather than failing, it
+ * falls back to the nearest enclosing `.compose` ancestor (upward walk), so
+ * running from a large workspace root resolves instead of dying. A tractable
+ * tree is still enumerated in full — genuine nested-workspace ambiguity (a
+ * parent workspace with a child below it) deliberately surfaces and forces an
+ * explicit --workspace.
  */
 import path from 'node:path';
 import fs from 'node:fs';
@@ -96,8 +106,26 @@ export function resolveWorkspace(hint = {}) {
     }
   }
 
-  // 4. Discovery — collisions matter because we're auto-picking.
-  const { candidates } = discoverWorkspaces(cwd);
+  // 4. Discovery — fan out under the anchor; collisions/ambiguity matter
+  //    because we're auto-picking. A normal tree enumerates fine, so genuine
+  //    nested-workspace ambiguity (e.g. a parent workspace with a child below)
+  //    still surfaces as WorkspaceAmbiguous and forces an explicit --workspace.
+  let candidates;
+  try {
+    ({ candidates } = discoverWorkspaces(cwd));
+  } catch (err) {
+    // The subtree was too large to enumerate within the visit bound. That cap
+    // is a cost guard, not a verdict — if cwd is itself inside a workspace, the
+    // nearest enclosing `.compose` ancestor is the unambiguous answer, so we
+    // degrade to it instead of failing (best-effort, same philosophy as the
+    // scan silently skipping EACCES subtrees). Only when cwd is inside NO
+    // workspace must the caller disambiguate explicitly — then we rethrow.
+    if (err.code === 'WorkspaceDiscoveryTooBroad') {
+      const enclosing = findEnclosingWorkspace(cwd);
+      if (enclosing) return { ...deriveId({ root: enclosing }), source: 'discovery' };
+    }
+    throw err;
+  }
   detectCollisions(candidates);
   if (candidates.length === 0) throw new WorkspaceUnset();
   if (candidates.length === 1) return { ...candidates[0], source: 'discovery' };
@@ -124,6 +152,25 @@ function findWorkspaceById(startDir, targetId) {
   }
 }
 
+/**
+ * Cheap upward-only lookup: walk ancestors from startDir and return the first
+ * directory containing a `.compose/` marker, or null if none exists before the
+ * filesystem root. This is the no-hint "nearest enclosing workspace" resolver —
+ * identical walk to findWorkspaceById but id-agnostic (returns the closest
+ * workspace regardless of its derived id).
+ */
+function findEnclosingWorkspace(startDir) {
+  let dir = path.resolve(startDir);
+  const { root } = path.parse(dir);
+  while (true) {
+    if (fs.existsSync(path.join(dir, '.compose'))) return dir;
+    if (dir === root) return null;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
 function resolveByIdScopedCollisionCheck(id, candidates, source) {
   const matching = candidates.filter((c) => c.id === id);
   if (matching.length === 0) throw new WorkspaceUnknown(id);

package/package.json

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

package/server/build-routes.js

@@ -16,12 +16,26 @@
 import { runBuild as defaultRunBuild, abortBuild as defaultAbortBuild } from '../lib/build.js';
 import { requireSensitiveToken } from './security.js';
 import { getDataDir as defaultGetDataDir } from './project-root.js';
+import { readBuildHistory } from '../lib/build-history.js';
 
 export function attachBuildRoutes(app, deps = {}) {
   const runBuild = deps.runBuild || defaultRunBuild;
   const abortBuild = deps.abortBuild || defaultAbortBuild;
   const getDataDir = deps.getDataDir || defaultGetDataDir;
 
+  // COMP-COCKPIT-3: read-only past-builds history. No sensitive token —
+  // mirrors GET /api/build/state (read-only, no secrets in the records).
+  app.get('/api/builds', (req, res) => {
+    try {
+      const raw = parseInt(req.query.limit, 10);
+      const limit = Number.isFinite(raw) ? Math.min(Math.max(raw, 1), 200) : 50;
+      const builds = readBuildHistory(getDataDir(), { limit });
+      res.json({ builds });
+    } catch (err) {
+      res.status(500).json({ error: err.message || String(err) });
+    }
+  });
+
   app.post('/api/build/start', requireSensitiveToken, async (req, res) => {
     const body = req.body || {};
     const { featureCode, mode = 'feature', description = '' } = body;