@smartmemory/compose 0.3.6-beta → 0.3.8

package/scripts/cost-census.mjs

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { resolve, join } from 'node:path';
+
+const [runId, featureCode, projectArg] = process.argv.slice(2);
+if (!runId || !featureCode) {
+  console.error('Usage: node scripts/cost-census.mjs <runId> <featureCode> [projectCwd]');
+  process.exitCode = 2;
+} else {
+  const projectCwd = resolve(projectArg ?? process.cwd());
+  const flowPath = join(homedir(), '.stratum', 'ts', 'flows', `${runId}.json`);
+  const accumulatorPath = join(
+    projectCwd,
+    '.compose',
+    'data',
+    'build-accumulator',
+    `${featureCode}.json`,
+  );
+  const flow = JSON.parse(readFileSync(flowPath, 'utf8'));
+  // The live accumulator is cleared when a build completes or aborts
+  // (lib/build.js clearBuildAccumulator); after that the terminal totals live in
+  // build-history.jsonl. Prefer the live file, fall back to the last history row.
+  let accumulator;
+  let accumulatorSource;
+  if (existsSync(accumulatorPath)) {
+    accumulator = JSON.parse(readFileSync(accumulatorPath, 'utf8'));
+    accumulatorSource = 'build-accumulator (live)';
+  } else {
+    const historyPath = join(projectCwd, '.compose', 'data', 'build-history.jsonl');
+    const rows = existsSync(historyPath)
+      ? readFileSync(historyPath, 'utf8').split('\n').filter(Boolean).map((line) => JSON.parse(line))
+      : [];
+    const last = rows.filter((row) => row?.feature_code === featureCode).at(-1);
+    if (!last) {
+      console.error(`no build accumulator or build-history row for ${featureCode} under ${projectCwd}`);
+      process.exit(2);
+    }
+    accumulator = last;
+    accumulatorSource = 'build-history.jsonl (terminal)';
+  }
+  console.log(`accumulator.source=${accumulatorSource}`);
+  const receipts = Array.isArray(flow.receipts) ? flow.receipts : [];
+  const costReceipts = receipts.filter((receipt) => receipt?.source !== 'engine');
+  const clientReceipts = costReceipts.filter(
+    (receipt) => !receipt?.dispatchId?.startsWith('legacy:') && receipt?.source !== 'server_dispatch',
+  );
+  const sumTokens = (rows) => rows.reduce(
+    (sum, receipt) => sum + (Number(receipt?.amount?.tokens) || 0),
+    0,
+  );
+  const sourceCounts = costReceipts.reduce((counts, receipt) => {
+    const source = typeof receipt?.source === 'string' && receipt.source.length > 0
+      ? receipt.source
+      : 'unknown';
+    counts[source] = (counts[source] ?? 0) + 1;
+    return counts;
+  }, {});
+  const allHaveModel = receipts.every(
+    (receipt) => typeof receipt?.telemetry?.model === 'string' && receipt.telemetry.model.length > 0,
+  );
+
+  console.log(`receipts.tokens.client_sources=${sumTokens(clientReceipts)}`);
+  console.log(`receipts.tokens.all_sources=${sumTokens(costReceipts)}`);
+  console.log(`flowSpent.tokens=${Number(flow?.flowSpent?.tokens) || 0}`);
+  console.log(`accumulator.tokens_total=${Number(accumulator?.tokens_total) || 0}`);
+  console.log(`receipts.counts_by_source=${JSON.stringify(sourceCounts)}`);
+  console.log(`every_receipt_has_model=${allHaveModel}`);
+}

package/scripts/guard-sign/compose-guard-sign.sh

@@ -0,0 +1,62 @@
+#!/bin/sh
+# compose-guard-sign — COMP-GUARD-ONE-TAP root-owned signer.
+#
+# Installed by `compose guard enrol` to /Library/Compose/guard/sign, owner
+# root:wheel, mode 0755, and named by absolute path in
+# /etc/sudoers.d/compose-guard with `timestamp_timeout=0`. Compose invokes it as
+# `sudo -k /Library/Compose/guard/sign <namespace>` so every invocation
+# re-authenticates (Touch ID via pam_tid, or the account password) and leaves
+# no cached credential behind: one approval, exactly one signature.
+#
+# Usage:  sign <namespace>  < message  > armored-signature
+#
+# The private key lives at /Library/Compose/guard/private/signing-key (root,
+# 0600, in a root 0700 directory; the public half sits readable one level up at
+# /Library/Compose/guard/signing-key.pub) and is never readable by the
+# operator's user. This
+# script pins PATH, calls every binary by absolute path, stages stdin under a
+# root-private directory (never the caller's TMPDIR), signs with
+# `ssh-keygen -Y sign`, prints the armored signature, and removes the staging
+# directory on every exit path. The namespace is the only argument and is
+# validated so it cannot smuggle options into ssh-keygen.
+#
+# Test seam: when NOT running as root, COMPOSE_GUARD_SIGN_KEY may point at an
+# alternative key so the sshsig output can be verified in-suite without sudo,
+# and staging falls back to TMPDIR. As root both are ignored — root's
+# environment is not a caller input (and sudo's env_reset strips them anyway).
+
+set -eu
+umask 077
+PATH=/usr/bin:/bin
+export PATH
+
+GUARD_DIR=/Library/Compose/guard
+KEY="$GUARD_DIR/private/signing-key"
+STAGE_ROOT="$GUARD_DIR/private/tmp"
+
+NAMESPACE="${1:-}"
+case "$NAMESPACE" in
+  '' ) echo "compose-guard-sign: usage: sign <namespace>" >&2; exit 64 ;;
+  *[!a-z0-9-]* ) echo "compose-guard-sign: invalid namespace" >&2; exit 64 ;;
+esac
+case "$NAMESPACE" in
+  [a-z]* ) ;;
+  * ) echo "compose-guard-sign: invalid namespace" >&2; exit 64 ;;
+esac
+if [ "${#NAMESPACE}" -gt 64 ]; then echo "compose-guard-sign: invalid namespace" >&2; exit 64; fi
+
+if [ "$(/usr/bin/id -u)" -ne 0 ]; then
+  # Test seam only. Root ignores both.
+  if [ -n "${COMPOSE_GUARD_SIGN_KEY:-}" ]; then KEY="$COMPOSE_GUARD_SIGN_KEY"; fi
+  STAGE_ROOT="${TMPDIR:-/tmp}"
+fi
+[ -r "$KEY" ] || { echo "compose-guard-sign: signing key not readable: $KEY" >&2; exit 66; }
+[ -d "$STAGE_ROOT" ] || { echo "compose-guard-sign: staging directory missing: $STAGE_ROOT" >&2; exit 66; }
+
+WORK="$(/usr/bin/mktemp -d "$STAGE_ROOT/sign.XXXXXX")"
+trap '/bin/rm -rf "$WORK"' EXIT INT TERM HUP
+
+/bin/cat > "$WORK/message"
+# -q: no chatter on stderr; the signature is written next to the message.
+/usr/bin/ssh-keygen -Y sign -q -f "$KEY" -n "$NAMESPACE" "$WORK/message"
+/bin/cat "$WORK/message.sig"

package/server/agent-health.js

@@ -36,6 +36,7 @@ export class HealthMonitor {
   #silenceKillMs;
   #defaultTimeoutMs;
   #memoryLimitMB;
+  #suspended = false;
 
   /** @type {Map<string, TrackedAgent>} */
   #agents = new Map();
@@ -91,6 +92,7 @@ export class HealthMonitor {
     // Start silence timers
     this._resetSilenceTimers(agentId);
 
+    if (this.#suspended) return;
     // Wall-clock timeout
     entry.wallClockTimer = setTimeout(() => this._kill(agentId, 'wall_clock_timeout'), this.#defaultTimeoutMs);
 
@@ -117,6 +119,8 @@ export class HealthMonitor {
     return this.#agents.has(agentId);
   }
 
+  get hasActiveProcesses() { return this.#agents.size > 0; }
+
   getTerminalReason(agentId) {
     return this.#agents.get(agentId)?.terminalReason ?? null;
   }
@@ -126,6 +130,23 @@ export class HealthMonitor {
     if (entry) entry.terminalReason = reason;
   }
 
+  suspend() {
+    this.#suspended = true;
+    for (const entry of this.#agents.values()) this._clearTimers(entry);
+  }
+
+  resume() {
+    if (!this.#suspended) return;
+    this.#suspended = false;
+    for (const [id, entry] of this.#agents) {
+      if (entry.terminalReason) continue;
+      this._resetSilenceTimers(id);
+      entry.wallClockTimer = setTimeout(() => this._kill(id, 'wall_clock_timeout'),
+        Math.max(0, this.#defaultTimeoutMs - (Date.now() - entry.startedAt)));
+      if (this.#memoryLimitMB > 0) entry.memoryPollTimer = setInterval(() => this._checkMemory(id), MEMORY_POLL_INTERVAL_MS);
+    }
+  }
+
   /** Clean up all tracked agents and timers. */
   destroy() {
     for (const agentId of [...this.#agents.keys()]) {
@@ -136,6 +157,7 @@ export class HealthMonitor {
   // ── Internal ────────────────────────────────────────────────────────────
 
   _resetSilenceTimers(agentId) {
+    if (this.#suspended) return;
     const entry = this.#agents.get(agentId);
     if (!entry) return;
 

package/server/agent-hooks.js

@@ -9,6 +9,8 @@
  * Terminal.jsx and vision-server.js).
  */
 
+import { getTargetRoot, withProjectContext } from './project-root.js';
+import { deriveId } from '../lib/discover-workspaces.js';
 import { resolvePort } from '../lib/resolve-port.js';
 
 const API_SERVER = `http://127.0.0.1:${resolvePort()}`;
@@ -26,7 +28,11 @@ async function post(path, body) {
   try {
     const res = await fetch(`${API_SERVER}${path}`, {
       method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
+      headers: {
+        'Content-Type': 'application/json',
+        'x-compose-workspace-id': deriveId({ root: getTargetRoot() }).id,
+        ...(process.env.COMPOSE_API_TOKEN ? { 'x-compose-token': process.env.COMPOSE_API_TOKEN } : {}),
+      },
       body: JSON.stringify(body),
       signal: AbortSignal.timeout(5000),
     });
@@ -102,3 +108,10 @@ export const HOOK_OPTIONS = {
   SessionStart: [{ hooks: [sessionStartHook] }],
   SessionEnd: [{ hooks: [sessionEndHook] }],
 };
+
+/** SDK callbacks can be invoked outside the HTTP async context. Pin explicitly. */
+export function hooksForProject(binding) {
+  return Object.fromEntries(Object.entries(HOOK_OPTIONS).map(([event, groups]) => [event,
+    groups.map(group => ({ ...group, hooks: group.hooks.map(hook => (...args) => withProjectContext(binding, () => hook(...args))) })),
+  ]));
+}

package/server/agent-server.js

@@ -1,249 +1,15 @@
-/**
- * Agent Server (Tier 1 — immortal, port 3003 during migration, then 3002)
- *
- * Replaces terminal-server.js. Uses @anthropic-ai/claude-agent-sdk instead of
- * node-pty + tmux. Streams typed SDK messages via SSE to the browser.
- * User input arrives via POST — SSE is the right transport for a unidirectional
- * async iterator.
- *
- * Process isolation: this server only talks to api-server (4001) via SDK hooks.
- * SessionManager and VisionServer require zero changes.
- */
-
+/** Immortal SDK server. Workspace sessions remain pinned across UI switches. */
 import http from 'node:http';
-import { readFileSync } from 'node:fs';
-import path from 'node:path';
 import express from 'express';
 import cors from 'cors';
 import { query } from '@anthropic-ai/claude-agent-sdk';
-import { requireSensitiveToken } from './security.js';
-import { HOOK_OPTIONS } from './agent-hooks.js';
-import { getTargetRoot, getDataDir } from './project-root.js';
-import { BuildStreamBridge } from './build-stream-bridge.js';
-import { CoalescingBuffer } from './coalescing-buffer.js';
-
-const _agentBuffer = new CoalescingBuffer((flushed) => {
-  if (flushed.agentMessage) {
-    for (const msg of flushed.agentMessage) {
-      _trackMessage(msg);
-      broadcast(msg);
-    }
-  }
-}, { intervalMs: 16 });
-_agentBuffer.register('agentMessage', 'append');
-
-const _recentMessages = [];
-const HYDRATE_LIMIT = 50;
-
-function _trackMessage(msg) {
-  _recentMessages.push(msg);
-  if (_recentMessages.length > HYDRATE_LIMIT) _recentMessages.shift();
-}
-
-export function getAgentSnapshot() {
-  return _recentMessages.length > 0 ? [..._recentMessages] : null;
-}
+import { createAgentApp } from './agent-workspace.js';
 
 const PORT = process.env.AGENT_PORT || 4002;
-const SETTINGS_FILE = path.join(getDataDir(), 'settings.json');
-
-function _readModelSetting() {
-  try {
-    const raw = readFileSync(SETTINGS_FILE, 'utf-8');
-    return JSON.parse(raw)?.models?.interactive || null;
-  } catch {
-    return null;
-  }
-}
-
+const workspaceServer = createAgentApp({ query });
 const app = express();
 app.use(cors({ origin: /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/ }));
-app.use(express.json());
-
-app.get('/api/health', (_req, res) => res.json({ ok: true }));
-
-// ---------------------------------------------------------------------------
-// Session state — one active SDK session at a time
-// ---------------------------------------------------------------------------
-
-/**
- * Active session state:
- *   id: string|null        — SDK session_id captured from init message
- *   queryIter: Query|null  — SDK async iterator, has .interrupt() method
- */
-let _session = { id: null, queryIter: null };
-
-/** SSE clients waiting for messages */
-const _sseClients = new Set();
-
-function broadcast(msg) {
-  const line = `data: ${JSON.stringify(msg)}\n\n`;
-  for (const client of _sseClients) {
-    try {
-      client.write(line);
-    } catch {
-      _sseClients.delete(client);
-    }
-  }
-}
-
-// ---------------------------------------------------------------------------
-// GET /api/agent/stream — SSE subscription
-// ---------------------------------------------------------------------------
-
-app.get('/api/agent/stream', (req, res) => {
-  res.setHeader('Content-Type', 'text/event-stream');
-  res.setHeader('Cache-Control', 'no-cache');
-  res.setHeader('Connection', 'keep-alive');
-  res.setHeader('X-Accel-Buffering', 'no'); // disable nginx buffering if proxied
-  res.flushHeaders();
-
-  _sseClients.add(res);
-
-  const snapshot = getAgentSnapshot();
-  if (snapshot) {
-    res.write(`event: hydrate\ndata: ${JSON.stringify(snapshot)}\n\n`);
-  }
-
-  // Immediately tell the new client whether a session exists
-  if (_session.id) {
-    res.write(`data: ${JSON.stringify({
-      type: 'system', subtype: 'connected', sessionId: _session.id,
-    })}\n\n`);
-  }
-
-  req.on('close', () => _sseClients.delete(res));
-});
-
-// ---------------------------------------------------------------------------
-// POST /api/agent/session — create a fresh session
-// ---------------------------------------------------------------------------
-
-app.post('/api/agent/session', requireSensitiveToken, (req, res) => {
-  const { prompt = '' } = req.body || {};
-  if (!prompt.trim()) return res.status(400).json({ error: 'prompt is required' });
-
-  _killCurrentSession();
-
-  try {
-    const q = _startQuery(prompt, null);
-    _session = { id: null, queryIter: q };
-    _consumeStream(q);
-    res.json({ ok: true });
-  } catch (err) {
-    res.status(500).json({ error: err.message });
-  }
-});
-
-// ---------------------------------------------------------------------------
-// POST /api/agent/message — send a follow-up message (resumes session)
-// ---------------------------------------------------------------------------
-
-app.post('/api/agent/message', requireSensitiveToken, (req, res) => {
-  const { prompt } = req.body || {};
-  if (!prompt?.trim()) return res.status(400).json({ error: 'prompt is required' });
-
-  const resumeId = _session.id;
-  _killCurrentSession();
-
-  try {
-    const q = _startQuery(prompt, resumeId);
-    _session = { id: resumeId, queryIter: q };
-    _consumeStream(q);
-    res.json({ ok: true, resumeSessionId: resumeId });
-  } catch (err) {
-    res.status(500).json({ error: err.message });
-  }
-});
-
-// ---------------------------------------------------------------------------
-// POST /api/agent/interrupt — interrupt current query
-// ---------------------------------------------------------------------------
-
-app.post('/api/agent/interrupt', requireSensitiveToken, (req, res) => {
-  if (!_session.queryIter) {
-    return res.status(404).json({ error: 'No active query' });
-  }
-  try {
-    _session.queryIter.interrupt();
-
-    // COMP-AGT-1: Escalation — if not resolved within 5s, force-kill the session
-    const capturedIter = _session.queryIter;
-    setTimeout(() => {
-      if (_session.queryIter === capturedIter) {
-        console.log('[agent-server] Interrupt escalation: killing session after 5s timeout');
-        _killCurrentSession();
-      }
-    }, 5000);
-
-    res.json({ ok: true });
-  } catch (err) {
-    res.status(500).json({ error: err.message });
-  }
-});
-
-// ---------------------------------------------------------------------------
-// GET /api/agent/session/status
-// ---------------------------------------------------------------------------
-
-app.get('/api/agent/session/status', (_req, res) => {
-  res.json({
-    active: !!_session.queryIter,
-    sessionId: _session.id || null,
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Internals
-// ---------------------------------------------------------------------------
-
-function _buildOptions(prompt, resumeId) {
-  return {
-    cwd: getTargetRoot(),
-    model: _readModelSetting() || 'claude-sonnet-4-6',
-    permissionMode: 'acceptEdits',
-    settingSources: ['project'],
-    tools: { type: 'preset', preset: 'claude_code' },
-    hooks: HOOK_OPTIONS,
-    ...(resumeId ? { resume: resumeId } : {}),
-  };
-}
-
-function _startQuery(prompt, resumeId) {
-  return query({ prompt, options: _buildOptions(prompt, resumeId) });
-}
-
-function _killCurrentSession() {
-  if (_session.queryIter) {
-    try { _session.queryIter.return(); } catch { /* ignore */ }
-  }
-  _session = { id: null, queryIter: null };
-  _recentMessages.length = 0;
-}
-
-async function _consumeStream(q) {
-  try {
-    for await (const msg of q) {
-      // Capture session_id from the init message so we can resume
-      if (msg.type === 'system' && msg.subtype === 'init') {
-        _session.id = msg.session_id;
-      }
-      _agentBuffer.put('agentMessage', msg);
-    }
-  } catch (err) {
-    if (err?.name !== 'AbortError') {
-      broadcast({ type: 'error', message: err.message || String(err) });
-    }
-  } finally {
-    // Signal completion to clients regardless of success/error
-    if (_session.queryIter === q) {
-      _session.queryIter = null;
-    }
-    // Keep _recentMessages populated after natural session end so clients
-    // reloading the tab post-turn can still hydrate recent history.
-    // Ring is cleared only on force-kill / new-session start in _killCurrentSession.
-  }
-}
+app.use(workspaceServer.app);
 
 // ---------------------------------------------------------------------------
 // Server startup
@@ -252,23 +18,14 @@ async function _consumeStream(q) {
 let serverListening = false;
 const server = http.createServer(app);
 
-// Build stream bridge — tails JSONL from CLI build, rebroadcasts via SSE
-const _bridge = new BuildStreamBridge(
-  path.join(getTargetRoot(), '.compose'),
-  broadcast
-);
-
 server.listen(PORT, '127.0.0.1', () => {
   serverListening = true;
-  _bridge.start();
   console.log(`Agent server running on http://127.0.0.1:${PORT}`);
 });
 
 function shutdown(sig) {
   console.log(`[agent-server] ${sig}, shutting down`);
-  _agentBuffer.stop();
-  _bridge.stop();
-  _killCurrentSession();
+  workspaceServer.close();
   server.close();
   setTimeout(() => process.exit(0), 1000);
 }

package/server/agent-spawn.js

@@ -11,7 +11,6 @@ import { getTargetRoot } from './project-root.js';
 import { gracefulKill } from './agent-health.js';
 import { resolveSpawnProfile } from './mcp-tool-policy.js';
 
-const PROJECT_ROOT = getTargetRoot();
 
 // ---------------------------------------------------------------------------
 // Route registration
@@ -35,7 +34,7 @@ function deriveAgentType(prompt) {
   return 'claude';
 }
 
-export function attachAgentSpawnRoutes(app, { projectRoot = PROJECT_ROOT, broadcastMessage, requireSensitiveToken, registry, sessionManager, healthMonitor, worktreeGC }) {
+export function attachAgentSpawnRoutes(app, { projectRoot = getTargetRoot(), broadcastMessage, requireSensitiveToken, registry, sessionManager, healthMonitor, worktreeGC }) {
   const _agents = new Map();
   // POST /api/agent/spawn — spawn a hidden Claude subagent
   app.post('/api/agent/spawn', requireSensitiveToken, (req, res) => {
@@ -48,7 +47,7 @@ export function attachAgentSpawnRoutes(app, { projectRoot = PROJECT_ROOT, broadc
       return res.status(409).json({ error: `Agent ${agentId} already running` });
     }
 
-    const cleanEnv = { ...process.env, NO_COLOR: '1' };
+    const cleanEnv = { ...process.env, COMPOSE_TARGET: projectRoot, NO_COLOR: '1' };
     delete cleanEnv.CLAUDECODE;
     // COMP-MCP-ENFORCE-1: inject a TRUSTED, spawn-time MCP profile the subagent
     // cannot rewrite (its compose-mcp child inherits this env). Only restrictive
@@ -217,7 +216,7 @@ export function attachAgentSpawnRoutes(app, { projectRoot = PROJECT_ROOT, broadc
     const currentSessionId = sessionManager?.currentSession?.id ?? null;
     if (agentId === currentSessionId) {
       const agentPort = process.env.AGENT_PORT || 4002;
-      const headers = { 'Content-Type': 'application/json' };
+      const headers = { 'Content-Type': 'application/json', 'x-compose-project-root': projectRoot };
       if (process.env.COMPOSE_API_TOKEN) headers['x-compose-token'] = process.env.COMPOSE_API_TOKEN;
       fetch(`http://127.0.0.1:${agentPort}/api/agent/interrupt`, {
         method: 'POST',