@smartmemory/compose 0.2.49-beta → 0.2.50-beta

package/server/stratum-sync.js

@@ -2,7 +2,19 @@
  * stratum-sync.js — Stratum flow poller + route registration.
  *
  * Polls stratum flow state via stratum-client (not direct file reads) and syncs
- * into the vision store every 15 seconds.
+ * into the vision store on a self-scheduling, sleep-aware loop.
+ *
+ * Sleep behavior: each poll cold-starts a `stratum-mcp` subprocess (Python
+ * interpreter spin-up — the expensive part, not the query itself). Doing that
+ * every few seconds generated enough periodic activity to keep the host from
+ * sleeping. Two mitigations:
+ *   1. Cadence widened to 60s (override with COMPOSE_STRATUM_POLL_MS).
+ *   2. The spawn is skipped entirely when no bound flow can still change state
+ *      (`hasLiveFlows`), so an idle/finished Forge does zero periodic spawning
+ *      and the host is free to sleep. The cheap in-memory scan that gates this
+ *      holds no power assertion.
+ * On wake, a tick that fired far later than scheduled is treated as a
+ * post-sleep resync rather than business as usual.
  *
  * Routes: POST /api/stratum/bind, POST /api/stratum/audit/:itemId
  * (Flow/gate query routes are now in stratum-api.js)
@@ -10,6 +22,38 @@
 
 import { queryFlows } from './stratum-client.js';
 
+// Poll cadence. 60s is plenty for a flow list (slower than any build step) and
+// keeps periodic process-spawn activity low enough not to fight host sleep.
+const DEFAULT_POLL_MS = 60_000;
+const MIN_POLL_MS = 1_000;
+const POLL_MS = (() => {
+  const raw = parseInt(process.env.COMPOSE_STRATUM_POLL_MS ?? '', 10);
+  return Number.isFinite(raw) && raw >= MIN_POLL_MS ? raw : DEFAULT_POLL_MS;
+})();
+// A tick that fires later than POLL_MS * this factor means the host slept
+// through scheduled ticks — log it and treat the next sync as a wake resync.
+const WAKE_GAP_FACTOR = 1.5;
+
+/**
+ * Sleep-aware poll gate: true only when some bound vision item could still
+ * change state (i.e. is bound to a flow and not settled-`complete`). When this
+ * is false the poller skips the stratum-mcp spawn so an idle host can sleep.
+ *
+ * A bound `complete` item is steady-state (status only advances to `complete`
+ * via the audit route, never back), so polling it changes nothing. Anything
+ * else bound — `in_progress`, `blocked`, or mid-flight — can still transition
+ * and is worth a poll.
+ *
+ * @param {Iterable<{stratumFlowId?: string, status?: string}>} items
+ * @returns {boolean}
+ */
+export function hasLiveFlows(items) {
+  for (const item of items) {
+    if (item.stratumFlowId && item.status !== 'complete') return true;
+  }
+  return false;
+}
+
 // ---------------------------------------------------------------------------
 // StratumSync class
 // ---------------------------------------------------------------------------
@@ -18,6 +62,8 @@ export class StratumSync {
   #store;
   #scheduleBroadcast;
   #pollTimer = null;
+  #stopped = true;
+  #lastTickAt = 0;
 
   /**
    * @param {object} store — VisionStore instance
@@ -28,23 +74,53 @@ export class StratumSync {
     this.#scheduleBroadcast = scheduleBroadcast;
   }
 
-  /** Start the 15s polling interval. */
+  /** Start the self-scheduling, sleep-aware poll loop (default 60s). */
   start() {
-    this.#pollTimer = setInterval(() => {
-      this.#syncFlows().catch(err => {
-        console.error('[vision] Stratum poll error:', err.message);
-      });
-    }, 15_000);
+    this.#stopped = false;
+    this.#lastTickAt = Date.now();
+    this.#scheduleNext();
   }
 
-  /** Stop the polling interval. */
+  /** Stop the poll loop. */
   stop() {
+    this.#stopped = true;
     if (this.#pollTimer) {
-      clearInterval(this.#pollTimer);
+      clearTimeout(this.#pollTimer);
       this.#pollTimer = null;
     }
   }
 
+  /** Arm the next tick. No-op once stopped so stop() is final. */
+  #scheduleNext() {
+    if (this.#stopped) return;
+    this.#pollTimer = setTimeout(() => this.#tick(), POLL_MS);
+  }
+
+  /**
+   * One poll tick. Skips the stratum-mcp spawn when nothing is live (lets the
+   * host sleep); on a tick that fired far later than scheduled, notes the
+   * sleep gap before resyncing.
+   */
+  async #tick() {
+    if (this.#stopped) return;
+    const now = Date.now();
+    const gap = now - this.#lastTickAt;
+    this.#lastTickAt = now;
+
+    if (hasLiveFlows(this.#store.items.values())) {
+      if (gap > POLL_MS * WAKE_GAP_FACTOR) {
+        console.log(`[vision] Stratum sync resuming after ${Math.round(gap / 1000)}s gap (host likely slept) — resyncing`);
+      }
+      try {
+        await this.#syncFlows();
+      } catch (err) {
+        console.error('[vision] Stratum poll error:', err.message);
+      }
+    }
+
+    this.#scheduleNext();
+  }
+
   /**
    * Fetch flow summaries via stratum-client (stable contract, not direct file reads).
    * Maps stratum's query output to the shape the sync logic expects.

package/server/vision-routes.js

@@ -42,7 +42,8 @@ function getSchemaValidator() {
 }
 
 import { randomUUID } from 'node:crypto';
-import { getTargetRoot, resolveProjectPath, loadProjectConfig } from './project-root.js';
+import { getTargetRoot, resolveProjectPath } from './project-root.js';
+import { resolveFeaturesPathFromConfig } from '../lib/project-paths.js';
 import { anchorBoundary } from '../lib/checkpoint/checkpoint-writer.js';
 import { appendGateLogEntry, readGateLog, mapResolveOutcomeToSchema } from './gate-log-store.js';
 import { addOpenLoop, resolveOpenLoop, listOpenLoops } from './open-loops-store.js';
@@ -55,6 +56,20 @@ import { requireSensitiveOrPaired as requireSensitiveToken } from './security.js
 
 const PROJECT_ROOT = getTargetRoot();
 
+/**
+ * Read the compose.json config for an ARBITRARY workspace root (not the bound
+ * target). The alternate-root lifecycle branch must resolve `paths.features`
+ * against that root's own config, not the process-global cache
+ * (COMP-PATHS-EXTERNAL, Decision 1 / Codex finding 3).
+ */
+function loadComposeConfig(root) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(root, '.compose', 'compose.json'), 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
 /**
  * Attach vision CRUD and lifecycle REST routes to an Express app.
  *
@@ -167,7 +182,7 @@ export function attachVisionRoutes(app, { store, scheduleBroadcast, broadcastMes
 
   // ── Lifecycle endpoints (simplified — no state machine) ──────────────
   const featuresPath = projectRoot !== PROJECT_ROOT
-    ? path.join(projectRoot, loadProjectConfig().paths?.features || 'docs/features')
+    ? resolveFeaturesPathFromConfig(projectRoot, loadComposeConfig(projectRoot))
     : resolveProjectPath('features');
 
   // Phase graph + SKIPPABLE + TERMINAL are owned by lifecycle-guard.js (single

package/server/vision-server.js

@@ -55,7 +55,8 @@ const SETTINGS_DEFAULTS = {
   policyModes: ['gate', 'flag', 'skip'],
 };
 
-import { getTargetRoot, getDataDir } from './project-root.js';
+import { getTargetRoot, getDataDir, resolveProjectPath } from './project-root.js';
+import { relForDisplay } from '../lib/project-paths.js';
 
 export class VisionServer {
   constructor(store, sessionManager = null, { config } = {}) {
@@ -264,7 +265,7 @@ export class VisionServer {
         const projectsRoot = process.env.CC_PROJECTS_ROOT ||
           path.join(process.env.HOME || process.env.USERPROFILE || '', '.claude', 'projects');
         const sessionsFile = this.sessionManager?.sessionsFile || path.join(getDataDir(), 'sessions.json');
-        const featureRoot = path.join(getTargetRoot(), 'docs', 'features');
+        const featureRoot = resolveProjectPath('features');
 
         const findItemIdByFeatureCode = (fc) => {
           for (const it of this.store.items.values()) {
@@ -457,7 +458,7 @@ export class VisionServer {
   /** Resolve a file path to matching tracker items */
   resolveItems(filePath) {
     const rel = filePath.startsWith(getTargetRoot())
-      ? filePath.slice(getTargetRoot().length + 1)
+      ? relForDisplay(getTargetRoot(), filePath)
       : filePath.replace(/^\.\//, '');
     const matches = [];
     const matchType = new Map();

package/server/vision-utils.js

@@ -10,10 +10,25 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
-import { getTargetRoot, loadProjectConfig } from './project-root.js';
+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
+ * target). Routes/agents that serve an alternate `projectRoot` must resolve
+ * artifact paths against that root's own config, not the process-global cache
+ * (COMP-PATHS-EXTERNAL, Decision 1 / Codex finding 3).
+ */
+function loadComposeConfig(root) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(root, '.compose', 'compose.json'), 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Error detection
 // ---------------------------------------------------------------------------
@@ -71,8 +86,12 @@ export function detectError(tool, input, responseText) {
  * @param {string} [projectRoot] — defaults to PROJECT_ROOT
  */
 export function spawnJournalAgent(session, transcriptPath, projectRoot = PROJECT_ROOT) {
-  const config = loadProjectConfig();
-  const journalRel = config.paths?.journal || 'docs/journal';
+  // 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));
+  // Display path for the agent prompt: clean relative when in-root (the agent
+  // runs with cwd: projectRoot), absolute when the journal escapes the root.
+  const journalRel = relForDisplay(projectRoot, journalAbs);
 
   const itemSummaries = Object.entries(session.items || {})
     .map(([_id, data]) => `- ${data.title}: ${data.writes} writes, ${data.reads} reads. ${(data.summaries || []).map(s => s.summary || '').filter(Boolean).join('. ')}`)
@@ -88,7 +107,7 @@ export function spawnJournalAgent(session, transcriptPath, projectRoot = PROJECT
   const today = new Date().toISOString().slice(0, 10);
   let sessionNum = 0;
   try {
-    const entries = fs.readdirSync(path.join(projectRoot, journalRel));
+    const entries = fs.readdirSync(journalAbs);
     for (const f of entries) {
       const m = f.match(new RegExp(`^${today}-session-(\\d+)`));
       if (m) sessionNum = Math.max(sessionNum, parseInt(m[1]) + 1);

package/dist/assets/channel-KsY1x-7s.js

@@ -1 +0,0 @@
-import{ai as o,aj as n}from"./App-DOerhoDp.js";const t=(a,r)=>o.lang.round(n.parse(a)[r]);export{t as c};

package/dist/assets/classDiagram-4FO5ZUOK-zDEDoVPk.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-727SXJPM-CeKpXDif.js";import{_ as i}from"./App-DOerhoDp.js";import"./chunk-FMBD7UC4-C1Z5m8DP.js";import"./chunk-ND2GUHAM-DmqZMEQe.js";import"./chunk-55IACEB6-D7VauOmU.js";import"./chunk-2J33WTMH-6HKDSnOw.js";import"./mobile-DwmxS_O4.js";import"./index-DlgxA8dX.js";import"./graph-BBXaecIU.js";var b={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{b as diagram};

package/dist/assets/classDiagram-v2-Q7XG4LA2-zDEDoVPk.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-727SXJPM-CeKpXDif.js";import{_ as i}from"./App-DOerhoDp.js";import"./chunk-FMBD7UC4-C1Z5m8DP.js";import"./chunk-ND2GUHAM-DmqZMEQe.js";import"./chunk-55IACEB6-D7VauOmU.js";import"./chunk-2J33WTMH-6HKDSnOw.js";import"./mobile-DwmxS_O4.js";import"./index-DlgxA8dX.js";import"./graph-BBXaecIU.js";var b={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{b as diagram};