@smartmemory/compose 0.3.7 → 0.4.0

package/server/vision-store.js

@@ -124,7 +124,10 @@ export class VisionStore {
     }
   }
 
-  /** Save state to disk atomically (temp file + rename) */
+  /** Save state to disk atomically (temp file + rename).
+   *  Returns true when the state reached disk, false when it did not. Existing
+   *  callers ignore the return and keep their prior log-and-continue behavior;
+   *  callers that must not report success on a failed write check it. */
   _save() {
     try {
       fs.mkdirSync(this._dataDir, { recursive: true });
@@ -132,8 +135,10 @@ export class VisionStore {
       const tmp = path.join(this._dataDir, `vision-state.json.tmp.${Date.now()}`);
       fs.writeFileSync(tmp, data, 'utf-8');
       fs.renameSync(tmp, this._dataFile);
+      return true;
     } catch (err) {
       console.error('[vision] Failed to save state:', err.message);
+      return false;
     }
   }
 
@@ -200,7 +205,7 @@ export class VisionStore {
       throw new Error(`Invalid phase: ${updates.phase}`);
     }
 
-    const allowed = ['type', 'title', 'description', 'confidence', 'status', 'phase', 'position', 'parentId', 'summary', 'files', 'featureCode', 'stratumFlowId', 'evidence', 'group', 'priority'];
+    const allowed = ['type', 'title', 'description', 'confidence', 'status', 'phase', 'position', 'parentId', 'summary', 'files', 'featureCode', 'stratumFlowId', 'evidence', 'group', 'priority', 'completion_projection'];
     for (const key of allowed) {
       if (updates[key] !== undefined) {
         item[key] = updates[key];
@@ -221,7 +226,7 @@ export class VisionStore {
     item.updatedAt = new Date().toISOString();
 
     this.items.set(id, item);
-    this._save();
+    this.lastSaveOk = this._save();
     return item;
   }
 
@@ -243,7 +248,7 @@ export class VisionStore {
     }
     item.updatedAt = new Date().toISOString();
     this.items.set(id, item);
-    this._save();
+    this.lastSaveOk = this._save();
     return item;
   }
 
@@ -262,14 +267,54 @@ export class VisionStore {
     return item;
   }
 
-  /** Delete an item and all its connections and gates */
+  /** Set the additive `fluid_ext` namespace on an item — bypasses the generic
+   *  updateItem allowlist, exactly as updateLifecycle/updateLifecycleExt do for
+   *  the lifecycle namespace.
+   *
+   *  The fluid-store provider seam (lib/fluid/, PROVIDER-SEAM ruling) is the only
+   *  caller. It exists because a fluid record carries fields the vision store has
+   *  no generic slot for (handle, cluster, tags, source, links) and the ruling
+   *  forbids a second store — so the record rides in one additive namespace on
+   *  the item rather than leaking record-specific fields into the allowlist.
+   *
+   *  `touch: false` preserves updatedAt, which the provider uses when writing the
+   *  namespace as part of record CREATION so created_at and updated_at agree. */
+  setFluidExt(id, ext, { touch = true } = {}) {
+    const item = this.items.get(id);
+    if (!item) throw new Error(`Item not found: ${id}`);
+    const priorExt = item.fluid_ext;
+    const priorUpdatedAt = item.updatedAt;
+    item.fluid_ext = ext;
+    if (touch) item.updatedAt = new Date().toISOString();
+    this.items.set(id, item);
+    if (!this._save()) {
+      // Roll the in-memory change back and fail. Reporting success here would
+      // let the provider append a lifecycle event asserting a change that
+      // vanishes on restart — a log that disagrees with the store is worse than
+      // a write that visibly failed.
+      item.fluid_ext = priorExt;
+      item.updatedAt = priorUpdatedAt;
+      this.items.set(id, item);
+      throw new Error(`[vision] failed to persist fluid_ext for item ${id}`);
+    }
+    return item;
+  }
+
+  /** Delete an item and all its connections and gates.
+   *  Throws when the deletion does not reach disk — reporting success on a
+   *  failed save would let a caller believe a record is gone while it is still
+   *  on disk to reappear at the next load. */
   deleteItem(id) {
     if (!this.items.has(id)) throw new Error(`Item not found: ${id}`);
+    const removedItem = this.items.get(id);
+    const removedConnections = [];
+    const removedGates = [];
     this.items.delete(id);
 
     // Remove connections referencing this item
     for (const [connId, conn] of this.connections) {
       if (conn.fromId === id || conn.toId === id) {
+        removedConnections.push([connId, conn]);
         this.connections.delete(connId);
       }
     }
@@ -277,11 +322,20 @@ export class VisionStore {
     // Remove gates associated with this item
     for (const [gateId, gate] of this.gates) {
       if (gate.itemId === id) {
+        removedGates.push([gateId, gate]);
         this.gates.delete(gateId);
       }
     }
 
-    this._save();
+    if (!this._save()) {
+      // Restore everything the delete removed, then fail. The alternative is an
+      // in-memory state that disagrees with disk and a caller told the record
+      // is gone when the next load will bring it back.
+      this.items.set(id, removedItem);
+      for (const [connId, conn] of removedConnections) this.connections.set(connId, conn);
+      for (const [gateId, gate] of removedGates) this.gates.set(gateId, gate);
+      throw new Error(`[vision] failed to persist deletion of item ${id}`);
+    }
     return { ok: true };
   }
 

package/server/vision-utils.js

@@ -13,7 +13,6 @@ import { fileURLToPath } from 'node:url';
 import { getTargetRoot } from './project-root.js';
 import { resolveJournalPathFromConfig, relForDisplay } from '../lib/project-paths.js';
 
-const PROJECT_ROOT = getTargetRoot();
 
 /**
  * Read the compose.json config for an ARBITRARY workspace root (not the bound
@@ -83,9 +82,9 @@ export function detectError(tool, input, responseText) {
  *
  * @param {object} session — serialized session object
  * @param {string} transcriptPath
- * @param {string} [projectRoot] — defaults to PROJECT_ROOT
+ * @param {string} [projectRoot] — defaults to the current request workspace
  */
-export function spawnJournalAgent(session, transcriptPath, projectRoot = PROJECT_ROOT) {
+export function spawnJournalAgent(session, transcriptPath, projectRoot = getTargetRoot()) {
   // Resolve the journal path against the PASSED projectRoot's own config — not
   // the process-global cached config of the bound target (COMP-PATHS-EXTERNAL).
   const journalAbs = resolveJournalPathFromConfig(projectRoot, loadComposeConfig(projectRoot));
@@ -126,7 +125,7 @@ Session data:
 After writing the entry, update ${journalRel}/README.md with the new entry row.
 Then commit both files.`;
 
-  const cleanEnv = { ...process.env, NO_COLOR: '1' };
+  const cleanEnv = { ...process.env, COMPOSE_TARGET: projectRoot, NO_COLOR: '1' };
   delete cleanEnv.CLAUDECODE;
   const proc = spawn('claude', ['-p', prompt, '--dangerously-skip-permissions'], {
     cwd: projectRoot,

package/server/workspace-activity.js

@@ -0,0 +1,18 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+
+/** Persisted work is shared by CLI, vision and SDK processes. Missing is idle;
+ * unreadable state is uncertain and must never authorize eviction. */
+export function hasPersistedWork(dataDir) {
+  const read = file => {
+    try { return JSON.parse(readFileSync(path.join(dataDir, file), 'utf8')); }
+    catch (error) { if (error.code === 'ENOENT') return null; throw error; }
+  };
+  try {
+    const build = read('active-build.json');
+    if (build && !['complete', 'completed', 'failed', 'aborted', 'cancelled'].includes(build.status)) return true;
+    const agents = read('agents.json');
+    const records = Array.isArray(agents) ? agents : Object.values(agents ?? {});
+    return records.some(agent => agent?.status === 'running');
+  } catch { return true; }
+}

package/server/workspace-middleware.js

@@ -41,7 +41,7 @@ const EXEMPT_PATHS = new Set([
  *   the workspace header soft-fallback to the target root with a hint header.
  *   When false, missing header surfaces as a WorkspaceUnknown(null) → 400.
  */
-export function createWorkspaceMiddleware({ allowGetFallback = true } = {}) {
+export function createWorkspaceMiddleware({ allowGetFallback = true, resolveKnownWorkspace = () => null } = {}) {
   return function workspaceMiddleware(req, res, next) {
     if (EXEMPT_PATHS.has(req.path)) {
       req.workspace = { id: null, root: getTargetRoot(), source: 'exempt' };
@@ -60,7 +60,7 @@ export function createWorkspaceMiddleware({ allowGetFallback = true } = {}) {
         // Hard-fail mode: missing header is treated as an unknown id.
         throw new WorkspaceUnknown(null);
       }
-      const resolved = resolveWorkspace({
+      const resolved = resolveKnownWorkspace(headerId) || resolveWorkspace({
         workspaceId: headerId,
         cwd: getTargetRoot(),
       });

package/server/workspace-runtime.js

@@ -0,0 +1,243 @@
+/** A workspace owns its stores, routes and background services for its lifetime.
+ * Requests and async work keep their binding even when the UI switches projects.
+ */
+import express from 'express';
+import path from 'node:path';
+import { realpathSync } from 'node:fs';
+import { hasPersistedWork } from './workspace-activity.js';
+import { hasDesignWork, closeDesignStratum } from './design-routes.js';
+import { FileWatcherServer } from './file-watcher.js';
+import { VisionStore } from './vision-store.js';
+import { VisionServer } from './vision-server.js';
+import { SessionManager } from './session-manager.js';
+import { attachGraphLayoutRoutes } from './graph-layout-routes.js';
+import { attachAgentProxy } from './remote-utils.js';
+import { scanFeatures, seedFeatures, scanSubPackages, seedSubPackages } from './feature-scan.js';
+import { prepareProject, withProjectContext, resolveProjectPath, switchProject } from './project-root.js';
+import { deriveId } from '../lib/discover-workspaces.js';
+import { probeStratumBin, resolveStratumBin } from '../lib/stratum-engine.js';
+
+export class WorkspaceRuntime {
+  constructor(httpServer, { agentPort = 4002, maxWorkspaces = 8 } = {}) {
+    this.server = httpServer;
+    this.agentPort = agentPort;
+    if (!Number.isInteger(maxWorkspaces) || maxWorkspaces < 1) throw new Error("maxWorkspaces must be a positive integer");
+    this.maxWorkspaces = maxWorkspaces;
+    this.contexts = new Map();
+    this.active = null;
+    // Monotonic stamp for LRU ordering; Date.now() ties within a millisecond.
+    this._tick = 0;
+  }
+
+  /** Record a workspace as most-recently-used. */
+  touch(context) { if (context) context.usedAt = ++this._tick; return context; }
+
+  /**
+   * Whether a retained workspace still has work that eviction would destroy.
+   * The active workspace is never evictable. Everything else is judged on
+   * signals the runtime can see: live vision/file sockets, an open session, a
+   * running build (`active-build.json`) and running spawned agents
+   * (`agents.json`). `isBusy` lets the host add its own signal.
+   */
+  busy(context) {
+    if (context === this.active) return true;
+    if (context.visionServer?.clients?.size) return true;
+    if (context.fileWatcher?.clients?.size) return true;
+    if (context.sessionManager?.currentSession) return true;
+    if (context.requests || context.binding.activeWork) return true;
+    if (context.visionServer?._healthMonitor?.hasActiveProcesses) return true;
+    if (hasDesignWork(context.binding.targetRoot)) return true;
+    if (hasPersistedWork(context.binding.dataDir)) return true;
+    return Boolean(this.isBusy?.(context));
+  }
+
+  /**
+   * Close the least-recently-used idle workspace to make room for another.
+   * Retention is an LRU cache, not a hard wall: refusing at the cap stranded
+   * users behind "restart to release retained sessions" while every retained
+   * workspace sat idle. The cap still refuses when nothing is evictable.
+   * @returns {boolean} whether a workspace was evicted
+   */
+  evictIdle() {
+    let victimKey = null; let victim = null;
+    for (const [key, context] of this.contexts) {
+      if (this.busy(context)) continue;
+      if (!victim || (context.usedAt ?? 0) < (victim.usedAt ?? 0)) { victimKey = key; victim = context; }
+    }
+    if (!victim) return false;
+    victim.fileWatcher.close();
+    victim.visionServer.close();
+    void closeDesignStratum(victim.binding.targetRoot);
+    this.contexts.delete(victimKey);
+    console.error(`[workspace] Evicted idle workspace ${victim.binding.targetRoot} (cap ${this.maxWorkspaces})`);
+    return true;
+  }
+
+  /**
+   * Context-map key. The agent server (`createAgentApp`) realpaths its target
+   * root, so keying on `path.resolve` alone made `/var/...` and
+   * `/private/var/...` two entries for ONE directory — the two capacity counts
+   * then disagreed. Both sides now key on the real path.
+   */
+  key(root) {
+    const resolved = path.resolve(root);
+    try { return realpathSync(resolved); } catch { return resolved; }
+  }
+
+  /** The retained context for a root, keyed on its real path. */
+  get(root) { return this.contexts.get(this.key(root)); }
+
+  prepare(root, config) {
+    const existing = this.get(root);
+    // Validate the destination before evicting any retained state.
+    const binding = prepareProject(root);
+    if (!existing && this.contexts.size >= this.maxWorkspaces && !this.evictIdle()) {
+      throw Object.assign(new Error(`Workspace capacity reached (${this.maxWorkspaces}); every retained workspace is busy (open sockets, a live session, a running build or agent)`), { code: 'WorkspaceCapacityExceeded' });
+    }
+    if (config) binding.config = config;
+    else if (binding.config.capabilities?.stratum) {
+      const probe = probeStratumBin(resolveStratumBin('cli', binding.targetRoot));
+      if (!probe.ok) binding.config.capabilities.stratum = false;
+    }
+    if (existing) {
+      withProjectContext(existing.binding, () => existing.visionServer.refreshConfig(binding.config));
+      // One holder, two references: the binding and the vision server must not
+      // drift apart, or a request resolved through the binding reads a config
+      // the routes no longer use.
+      existing.binding.config = existing.visionServer.config;
+      return this.touch(existing);
+    }
+    return withProjectContext(binding, () => {
+      const router = express.Router();
+      const fileWatcher = new FileWatcherServer({ projectRoot: binding.targetRoot });
+      const store = new VisionStore(binding.dataDir);
+      const sessionManager = new SessionManager({
+        projectRoot: binding.targetRoot,
+        sessionsFile: path.join(binding.dataDir, 'sessions.json'),
+        featureRoot: resolveProjectPath('features'),
+        getFeaturePhase: (code) => store.getItemByFeatureCode(code)?.lifecycle?.currentPhase || null,
+      });
+      const visionServer = new VisionServer(store, sessionManager, { config: binding.config });
+      const context = { binding, router, fileWatcher, store, sessionManager, visionServer };
+      try {
+        attachGraphLayoutRoutes(router);
+        attachAgentProxy(router, { agentPort: this.agentPort });
+        fileWatcher.attach(this.server, router);
+        visionServer.attach(this.server, router);
+        const reseed = () => {
+          seedFeatures(scanFeatures(), store);
+          seedSubPackages(scanSubPackages(), store);
+        };
+        reseed();
+        fileWatcher.onFeatureChanged = () => {
+          try { reseed(); visionServer.scheduleBroadcast(); }
+          catch (err) { console.error('[compose] Feature reseed error:', err.message); }
+        };
+        fileWatcher.onBuildStateChanged = (state) => {
+          if (state) visionServer.broadcastMessage({ type: 'buildState', ...state });
+        };
+        fileWatcher.onSpecChanged = fileWatcher.onIdeaboxChanged = (msg) => visionServer.broadcastMessage(msg);
+        return context;
+      } catch (err) {
+        fileWatcher.close();
+        visionServer.close();
+        throw err;
+      }
+    });
+  }
+
+  switch(root, config) {
+    // Preparation may fail. Never mutate the current root/services until it succeeds.
+    const next = this.prepare(root, config);
+    if (next === this.active) {
+      // C8: switching to the workspace already active is a config refresh, not
+      // a workspace change. suspend() closes every vision WebSocket with 1000,
+      // so the old suspend/resume pair dropped the whole cockpit on a no-op
+      // switch. prepare() has already refreshed the config in place; restart
+      // only the OS watchers (paths may have moved) and re-arm the background
+      // services that a config refresh stopped. Neither closes a socket.
+      withProjectContext(next.binding, () => {
+        next.fileWatcher.stopWatching(); next.fileWatcher.startWatching();
+        next.visionServer.resume(); switchProject(next.binding.targetRoot);
+      });
+      return next;
+    }
+    const retained = this.get(next.binding.targetRoot) !== undefined;
+    try {
+      if (retained) withProjectContext(next.binding, () => {
+        next.fileWatcher.startWatching();
+        next.visionServer.resume();
+      });
+      switchProject(next.binding.targetRoot);
+    } catch (err) {
+      if (retained) {
+        next.fileWatcher.stopWatching(); next.visionServer.suspend();
+      } else {
+        next.fileWatcher.close(); next.visionServer.close();
+      }
+      throw err;
+    }
+    if (this.active) {
+      this.active.fileWatcher.stopWatching();
+      for (const client of this.active.fileWatcher.clients) client.close(1000, 'Workspace changed');
+      this.active.fileWatcher.clients.clear();
+      this.active.visionServer.suspend();
+    }
+    this.contexts.set(this.key(next.binding.targetRoot), next);
+    this.active = this.touch(next);
+    return next;
+  }
+
+  resolveKnownWorkspace(id) {
+    const matches = [...this.contexts.values()].filter(c => deriveId({ root: c.binding.targetRoot }).id === id);
+    if (matches.length > 1) {
+      const err = new Error(`Workspace id collision: ${id}`);
+      Object.assign(err, { code: 'WorkspaceIdCollision', id, roots: matches.map(c => c.binding.targetRoot) });
+      throw err;
+    }
+    return matches.length ? { id, root: matches[0].binding.targetRoot, source: 'explicit-header' } : null;
+  }
+
+  handle(req, res, next) {
+    let context = req.workspace?.root ? this.get(req.workspace.root) : this.active;
+    // C6: ONLY workspace preparation is translated into a workspace error. A
+    // route that throws is a route bug, not an unavailable workspace, and
+    // reporting it as `400 {error: <internal text>}` both mislabels it and
+    // leaks internals past the error handler.
+    try {
+      if (!context && req.workspace?.root) {
+        context = this.prepare(req.workspace.root);
+        context.fileWatcher.stopWatching(); context.visionServer.suspend();
+        this.contexts.set(this.key(context.binding.targetRoot), context);
+      }
+    } catch (error) {
+      return res.status(error.code === 'WorkspaceCapacityExceeded' ? 409 : 400).json({ error: error.message, code: error.code ?? 'WorkspaceUnavailable' });
+    }
+    if (!context) return res.status(409).json({ error: 'No workspace selected', code: 'WorkspaceUnset', root: null });
+    this.touch(context);
+    context.requests = (context.requests ?? 0) + 1;
+    let released = false;
+    const release = () => {
+      if (released) return;
+      released = true;
+      context.requests--;
+      res.off('finish', release); res.off('close', release);
+    };
+    res.once('finish', release); res.once('close', release);
+    try {
+      return withProjectContext(context.binding, () => context.router(req, res, error => { release(); next(error); }));
+    } catch (error) {
+      release();
+      return next(error);
+    }
+  }
+
+  close() {
+    for (const context of this.contexts.values()) {
+      context.fileWatcher.close(); context.visionServer.close();
+      void closeDesignStratum(context.binding.targetRoot);
+    }
+    this.contexts.clear();
+    this.active = null;
+  }
+}

package/server/worktree-gc.js

@@ -37,6 +37,7 @@ export class WorktreeGC {
 
   /** Start periodic scanning. Also runs an initial scan. */
   start() {
+    if (this.#timer) return;
     this.runNow().catch(() => {}); // fire-and-forget initial scan
     this.#timer = setInterval(() => {
       this.runNow().catch(() => {});