@smartmemory/compose 0.3.7 → 0.3.8

package/server/mcp-tool-policy.js

@@ -23,10 +23,41 @@ export const SETUP_TOOLS = new Set([
   'set_workspace', 'get_workspace', 'bind_session', 'get_current_session',
 ]);
 
-/** Management/approval/completion tools an implementer context must not wield. */
+/**
+ * Management/approval/completion tools an implementer context must not wield.
+ *
+ * COMP-COVERAGE-GATE (2026-08-24) added the last two, found by
+ * `checkAuthorizationCoverage`'s C4 check — mutating tools this list had never
+ * been asked about. Both postdate COMP-MCP-ENFORCE-1's charter ("cannot
+ * self-approve, self-complete, or mutate roadmap status") and no design ever
+ * ruled that an implementer may call them:
+ *
+ *  - `canon_override_grant` — the escape hatch FROM canon enforcement was
+ *    callable by the profile SUBJECT to it. COMP-CANON-OVERRIDE already reasoned
+ *    that the override must not be grantable for its own governance state
+ *    (`overrideEligible: false`); this is the same argument one level up, at the
+ *    caller instead of the target. An implementer that hits a canon block must
+ *    escalate, not self-authorise.
+ *  - `roadmap_xref_push` — writes EXTERNAL trackers (github issues, sibling
+ *    repos). An implementer session should not be reaching outside the repo.
+ *
+ * The eight `judgment_*` writers were the other eight C4 findings and are
+ * deliberately NOT here: COMP-JUDGMENT-WRITER/design.md:137 rules that they
+ * "stay implementer/orchestrator-only", so an implementer writing judgment is a
+ * recorded decision, not an omission. That ruling is now recorded machine-side
+ * in `C4_EXCEPTIONS` (lib/coverage-gate.js) so the gate stops re-raising it.
+ *
+ * Verified before adding the two: no pipeline spec, prompt template or server
+ * flow invokes either from an implementer-profile session.
+ */
 const IMPLEMENTER_DENY = [
   'approve_gate', 'complete_feature', 'kill_feature',
   'set_feature_status', 'add_roadmap_entry', 'record_completion', 'propose_followup',
+  // COMP-LIFECYCLE-BACKFILL: a completion is a management act, backfilled or not.
+  'backfill_completion',
+  // ── added by COMP-COVERAGE-GATE C4 ──
+  'canon_override_grant',
+  'roadmap_xref_push',
 ];
 
 /** Reviewer (read-only) may call only these. */
@@ -37,6 +68,7 @@ const REVIEWER_ALLOW = [
   'validate_feature', 'validate_project', 'roadmap_diff', 'get_roadmap', 'roadmap_graph_check', 'assess_feature_artifacts',
   'set_workspace', 'get_workspace', 'bind_session',
   'get_judgment_state', // COMP-JUDGMENT-WRITER: read-only; the eight judgment write tools stay reviewer-denied
+  'get_judgment_trace', // COMP-JUDGMENT-PRECEDENT: read-only ancestry walk
 ];
 
 export const PROFILE_POLICY = {
@@ -47,7 +79,7 @@ export const PROFILE_POLICY = {
 
 /** phase → management tools re-permitted for DENY-mode profiles in that phase. */
 export const PHASE_REFINEMENT = {
-  ship: new Set(['complete_feature', 'record_completion']),
+  ship: new Set(['complete_feature', 'record_completion', 'backfill_completion']),
 };
 
 // Strictness ordering — a bind hint may only NARROW (raise strictness), never widen.

package/server/model-tiers.js

@@ -1,7 +1,7 @@
 /**
  * model-tiers.js — Model tier routing for STRAT-TIER.
  *
- * Maps symbolic tier names to concrete Anthropic model IDs.
+ * Maps symbolic tier names to provider-specific model IDs.
  * Tiers let pipeline specs declare intent (critical / standard / fast)
  * without hard-coding model strings — the map here is the single source of truth.
  */
@@ -13,6 +13,21 @@ export const MODEL_TIERS = {
   fast: 'claude-haiku-4-5-20251001',
 };
 
+export const CODEX_MODEL_TIERS = {
+  critical: 'gpt-6-astra',
+  standard: 'gpt-5.6-terra',
+  fast: 'gpt-5.3-codex-spark',
+};
+
+// C12: codex efforts follow the routing convention — `low` is for trivial
+// mechanical work only, and the fast tier is a model choice, not a
+// reasoning-quality choice. Fast runs the cheap model at routine effort.
+const CODEX_TIER_THINKING = {
+  critical: { mode: null, effort: 'high' },
+  standard: { mode: null, effort: 'high' },
+  fast: { mode: null, effort: 'medium' },
+};
+
 /**
  * Default thinking config per tier.
  * - Opus 4.7 / Sonnet 4.6 support adaptive thinking and the effort parameter.
@@ -32,9 +47,10 @@ export const TIER_THINKING = {
  * @param {string|null|undefined} tier
  * @returns {string|null}  Model ID, or null if tier is unknown / not provided.
  */
-export function resolveTierModel(tier) {
+export function resolveTierModel(tier, provider = 'claude') {
   if (!tier) return null;
-  return MODEL_TIERS[tier] ?? null;
+  const models = provider === 'codex' ? CODEX_MODEL_TIERS : provider === 'claude' ? MODEL_TIERS : {};
+  return models[tier] ?? null;
 }
 
 /**
@@ -43,7 +59,8 @@ export function resolveTierModel(tier) {
  * @param {string|null|undefined} tier
  * @returns {{ mode: string, effort: string|null }|null}
  */
-export function resolveTierThinking(tier) {
+export function resolveTierThinking(tier, provider = 'claude') {
   if (!tier) return null;
-  return TIER_THINKING[tier] ?? null;
+  const thinking = provider === 'codex' ? CODEX_TIER_THINKING : provider === 'claude' ? TIER_THINKING : {};
+  return thinking[tier] ?? null;
 }

package/server/pipeline-routes.js

@@ -16,6 +16,7 @@ import { readdirSync, readFileSync, writeFileSync, unlinkSync, existsSync, mkdir
 import { join, basename, dirname } from 'node:path';
 import { randomUUID, createHash } from 'node:crypto';
 import YAML from 'yaml';
+import { tsCompatibilityOf } from '../lib/pipeline-compat.js';
 
 /** sha-256 hex of a string (COMP-PIPE-EDIT-6 conflict-detection baseline). */
 function sha256(text) {
@@ -139,7 +140,12 @@ function extractSteps(parsed) {
  * The shipped specs store `metadata` as a leading `#` comment (or omit it), so
  * the metadata-based `loadTemplates` never surfaces them. The editor discovers
  * by filename instead.
- * @returns {Array<{ file, version, flows: string[] }>}
+ * COMP-PIPELINE-QUARANTINE: each entry also carries `tsCompatible` — false for a
+ * spec left on the retired v0.3 dialect, which the engine cannot run at all. The
+ * editor lists specs it cannot execute, so the flag is what lets the surface say
+ * so instead of presenting them as ordinary choices.
+ *
+ * @returns {Array<{ file, version, flows: string[], tsCompatible: boolean, tsIncompatibleReason: string|null }>}
  */
 function listSpecFiles(pipelinesDir) {
   let files;
@@ -151,14 +157,24 @@ function listSpecFiles(pipelinesDir) {
   const out = [];
   for (const file of files) {
     try {
-      const parsed = YAML.parse(readFileSync(join(pipelinesDir, file), 'utf-8'));
+      const raw = readFileSync(join(pipelinesDir, file), 'utf-8');
+      const parsed = YAML.parse(raw);
+      const compat = tsCompatibilityOf(raw);
       out.push({
         file,
         version: parsed?.version ?? null,
         flows: flowNamesOf(parsed),
+        tsCompatible: compat.compatible,
+        tsIncompatibleReason: compat.reason,
       });
     } catch {
-      out.push({ file, version: null, flows: [] });
+      out.push({
+        file,
+        version: null,
+        flows: [],
+        tsCompatible: false,
+        tsIncompatibleReason: 'spec is not parseable YAML',
+      });
     }
   }
   return out;
@@ -603,33 +619,27 @@ function createNewFlowNode(doc, model, name) {
 }
 
 // ---------------------------------------------------------------------------
-// In-memory draft state (single draft at a time)
+// Workspace-local draft state (disk is authoritative)
 // ---------------------------------------------------------------------------
 
-let currentDraft = null;
-
 const DRAFT_FILE = 'pipeline-draft.json';
 
 function saveDraft(dataDir, draft) {
-  currentDraft = draft;
   mkdirSync(dataDir, { recursive: true });
   writeFileSync(join(dataDir, DRAFT_FILE), JSON.stringify(draft, null, 2));
 }
 
 function loadDraft(dataDir) {
-  if (currentDraft) return currentDraft;
   const p = join(dataDir, DRAFT_FILE);
   if (!existsSync(p)) return null;
   try {
-    currentDraft = JSON.parse(readFileSync(p, 'utf-8'));
-    return currentDraft;
+    return JSON.parse(readFileSync(p, 'utf-8'));
   } catch {
     return null;
   }
 }
 
 function clearDraft(dataDir) {
-  currentDraft = null;
   const p = join(dataDir, DRAFT_FILE);
   try { if (existsSync(p)) unlinkSync(p); } catch { /* ignore */ }
 }

package/server/project-root.js

@@ -12,6 +12,7 @@
  */
 
 import path from 'node:path';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import fs from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { findProjectRoot } from './find-root.js';
@@ -42,15 +43,40 @@ let _targetRoot = (() => {
 
 let _dataDir = path.join(_targetRoot, '.compose', 'data');
 let _configCache = null;
+const projectContext = new AsyncLocalStorage();
+
+/** Pin a request and all of its asynchronous descendants to one workspace. */
+export function withProjectContext(binding, fn) {
+  return projectContext.run(binding, fn);
+}
+
+/** Keep asynchronous work pinned even when its HTTP client disconnects. */
+export async function trackProjectWork(operation) {
+  const binding = projectContext.getStore();
+  if (!binding) return operation();
+  binding.activeWork = (binding.activeWork ?? 0) + 1;
+  try { return await operation(); }
+  finally { binding.activeWork--; }
+}
+
+/** Validate a destination before changing the process default or its services. */
+export function prepareProject(newRoot) {
+  const targetRoot = path.resolve(newRoot);
+  if (!fs.statSync(targetRoot).isDirectory()) throw new Error(`Project path is not a directory: ${targetRoot}`);
+  const dataDir = path.join(targetRoot, '.compose', 'data');
+  fs.mkdirSync(dataDir, { recursive: true });
+  const config = readProjectConfig(targetRoot, true);
+  return { targetRoot, dataDir, config };
+}
 
 /** The target project being developed. */
-export function getTargetRoot() { return _targetRoot; }
+export function getTargetRoot() { return projectContext.getStore()?.targetRoot ?? _targetRoot; }
 
 /** Data directory for Compose state. Lives in the target project. */
-export function getDataDir() { return _dataDir; }
+export function getDataDir() { return projectContext.getStore()?.dataDir ?? _dataDir; }
 
 let _currentWorkspaceId = null;
-export function getCurrentWorkspaceId() { return _currentWorkspaceId; }
+export function getCurrentWorkspaceId() { return projectContext.getStore()?.workspaceId ?? _currentWorkspaceId; }
 export function setCurrentWorkspaceId(id) { _currentWorkspaceId = id; }
 
 // ---------------------------------------------------------------------------
@@ -73,15 +99,12 @@ export function onProjectSwitch(fn) {
  * @returns {{ targetRoot: string, dataDir: string }}
  */
 export function switchProject(newRoot) {
-  const resolved = path.resolve(newRoot);
-  if (!fs.existsSync(resolved)) {
-    throw new Error(`Project path does not exist: ${resolved}`);
-  }
-  _targetRoot = resolved;
-  _dataDir = path.join(resolved, '.compose', 'data');
-  _configCache = null;
-  fs.mkdirSync(_dataDir, { recursive: true });
-  console.log(`[project-root] Switched to: ${resolved}`);
+  const prepared = prepareProject(newRoot);
+  _targetRoot = prepared.targetRoot;
+  _dataDir = prepared.dataDir;
+  _configCache = prepared.config;
+  _currentWorkspaceId = null;
+  console.error(`[project-root] Switched to: ${_targetRoot}`);
   for (const fn of _switchListeners) {
     try { fn(_targetRoot, _dataDir); } catch (e) { console.error('[project-root] Switch listener error:', e.message); }
   }
@@ -107,18 +130,34 @@ function cloneConfig(obj) {
   return JSON.parse(JSON.stringify(obj));
 }
 
-export function loadProjectConfig() {
-  if (_configCache) return cloneConfig(_configCache);
-  const configPath = path.join(getTargetRoot(), '.compose', 'compose.json');
+function readProjectConfig(root, strict = false) {
+  const file = path.join(root, '.compose', 'compose.json');
   try {
-    _configCache = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-    return cloneConfig(_configCache);
-  } catch {
-    _configCache = DEFAULT_CONFIG;
+    const config = JSON.parse(fs.readFileSync(file, 'utf-8'));
+    if (!config || typeof config !== 'object' || Array.isArray(config)) throw new Error('project config must be a JSON object');
+    return { ...config, capabilities: { ...DEFAULT_CONFIG.capabilities, ...config.capabilities } };
+  } catch (err) {
+    if (strict && err.code !== 'ENOENT') {
+      // C10: a malformed config is fatal on purpose — silently falling back to
+      // defaults switched the workspace into a configuration nobody wrote. Say
+      // which file is broken and what to do about it; a bare SyntaxError does
+      // neither. A MISSING file is still fine (defaults apply).
+      throw Object.assign(
+        new Error(`Invalid Compose config at ${file}: ${err.message}. Fix the file or delete it to fall back to defaults.`),
+        { code: 'InvalidProjectConfig', file, cause: err },
+      );
+    }
     return cloneConfig(DEFAULT_CONFIG);
   }
 }
 
+export function loadProjectConfig() {
+  const context = projectContext.getStore();
+  if (context) return cloneConfig(context.config ?? readProjectConfig(context.targetRoot));
+  _configCache ??= readProjectConfig(_targetRoot);
+  return cloneConfig(_configCache);
+}
+
 export function resolveProjectPath(key) {
   const config = loadProjectConfig();
   // resolvePathValue handles in-root / ../-escaping / absolute overrides.

package/server/remote-utils.js

@@ -15,7 +15,7 @@
  */
 
 import http from 'node:http';
-import { loadProjectConfig } from './project-root.js';
+import { loadProjectConfig, getTargetRoot } from './project-root.js';
 
 // ---------------------------------------------------------------------------
 // resolveComposeHost
@@ -83,6 +83,8 @@ export function attachAgentProxy(app, { agentPort }) {
       // Inject the server-side sensitive token; strip any client-sent credential
       delete headers['x-compose-token'];
       delete headers['authorization'];
+      // Only the resolved server workspace may choose the SDK cwd.
+      headers['x-compose-project-root'] = getTargetRoot();
       const apiToken = process.env.COMPOSE_API_TOKEN;
       if (apiToken) headers['x-compose-token'] = apiToken;
 

package/server/schema-validator.js

@@ -13,7 +13,13 @@ const cache = new Map();
 function load(schemaPath = DEFAULT_SCHEMA_PATH) {
   if (cache.has(schemaPath)) return cache.get(schemaPath);
   const schema = JSON.parse(readFileSync(schemaPath, 'utf8'));
-  const ajv = new Ajv({ strict: false, allErrors: true });
+  // `$data: true` lets a schema pin one field to another's value at validation
+  // time (`{"const": {"$data": "2/policy_checksum"}}` in
+  // contracts/lifecycle-backfill.schema.json). Without the option Ajv treats the
+  // `$data` object as a LITERAL to compare against, so such a schema rejects
+  // every document — including the valid ones. Additive: no other schema here
+  // uses `$data`, and enabling it changes nothing for them.
+  const ajv = new Ajv({ strict: false, allErrors: true, $data: true });
   addFormats(ajv);
   ajv.addSchema(schema);
   const entry = { schema, ajv };

package/server/session-manager.js

@@ -16,8 +16,6 @@ import { serializeSession, persistSession, readLastSession, readSessionsByFeatur
 
 import { getTargetRoot, getDataDir } from './project-root.js';
 
-const PROJECT_ROOT = getTargetRoot();
-const SESSIONS_FILE = path.join(getDataDir(), 'sessions.json');
 
 /** Tools whose events count toward the Haiku summary batch threshold */
 const SIGNIFICANT_TOOLS = new Set(['Write', 'Edit', 'Bash', 'NotebookEdit']);
@@ -26,7 +24,8 @@ const SIGNIFICANT_TOOLS = new Set(['Write', 'Edit', 'Bash', 'NotebookEdit']);
 const BATCH_SIZE = 4;
 
 export class SessionManager {
-  constructor({ getFeaturePhase, featureRoot, sessionsFile } = {}) {
+  constructor({ getFeaturePhase, featureRoot, sessionsFile, projectRoot = getTargetRoot() } = {}) {
+    this._projectRoot = projectRoot;
     /** @type {object|null} Current active session */
     this.currentSession = null;
 
@@ -37,7 +36,7 @@ export class SessionManager {
     this._featureRoot = featureRoot || 'docs/features';
 
     /** @type {string} Path to sessions.json — injectable for tests */
-    this._sessionsFile = sessionsFile || SESSIONS_FILE;
+    this._sessionsFile = sessionsFile || path.join(getDataDir(), 'sessions.json');
 
     /** @type {Array<{tool,filePath,input,itemIds,timestamp}>} Buffered significant events */
     this._pendingBatch = [];
@@ -332,8 +331,8 @@ export class SessionManager {
     const batch = this._pendingBatch.splice(0);
 
     try {
-      const prompt = buildSummaryPrompt(batch, PROJECT_ROOT);
-      const result = await summarize(prompt, { projectRoot: PROJECT_ROOT });
+      const prompt = buildSummaryPrompt(batch, this._projectRoot);
+      const result = await summarize(prompt, { projectRoot: this._projectRoot });
       if (result) {
         this._distributeSummary(result, batch);
         for (const fn of this._summaryListeners) {

package/server/session-routes.js

@@ -245,7 +245,9 @@ export function attachSessionRoutes(app, { sessionManager, scheduleBroadcast, br
       session: sessionData || recentSessions[0] || null,
       lifecycle: item?.lifecycle ? {
         currentPhase: item.lifecycle.currentPhase,
-        phaseHistory: (item.lifecycle.phaseHistory || []).map(h => ({ phase: h.phase, enteredAt: h.enteredAt, exitedAt: h.exitedAt })),
+        phaseHistory: (item.lifecycle.phaseHistory || []).map(h => ({
+          phase: h.phase, enteredAt: h.enteredAt, exitedAt: h.exitedAt, origin: h.origin,
+        })),
         artifacts: item.lifecycle.artifacts || {},
         pendingGate: item.lifecycle.pendingGate || null,
       } : null,

package/server/stratum-client.js

@@ -191,9 +191,12 @@ async function runMutation(args) {
  * @param {number}   timeoutMs
  * @returns {Promise<{ stdout: string, stderr: string, code: number }>}
  */
-function spawnStratumStdin(args, inputJson, timeoutMs, bin) {
+function spawnStratumStdin(args, inputJson, timeoutMs, bin, extraEnv) {
   return new Promise((resolve) => {
-    const proc = _execFile(bin, args, { timeout: timeoutMs }, (err, out, err2) => {
+    const proc = _execFile(bin, args, {
+      timeout: timeoutMs,
+      ...(extraEnv ? { env: { ...process.env, ...extraEnv } } : {}),
+    }, (err, out, err2) => {
       resolve(_spawnResult(bin, err, out, err2));
     });
     // Same both-paths-settle-identically contract as spawnStratum.
@@ -219,8 +222,8 @@ function spawnStratumStdin(args, inputJson, timeoutMs, bin) {
  *
  * @returns {Promise<any>} parsed JSON result or { error }
  */
-async function runGuard(action, kwargs, timeoutMs = MUTATION_TIMEOUT_MS) {
-  const result = await spawnStratumStdin(['guard', action], JSON.stringify(kwargs), timeoutMs, flowGateBin());
+async function runGuard(action, kwargs, timeoutMs = MUTATION_TIMEOUT_MS, extraEnv) {
+  const result = await spawnStratumStdin(['guard', action], JSON.stringify(kwargs), timeoutMs, flowGateBin(), extraEnv);
 
   if (result.code === -1) {
     return { error: { code: 'TIMEOUT', message: 'Stratum guard timed out', detail: '' } };
@@ -230,12 +233,16 @@ async function runGuard(action, kwargs, timeoutMs = MUTATION_TIMEOUT_MS) {
     return { error: { code: 'SPAWN', message: result.stderr, detail: '' } };
   }
   if (result.code !== 0) {
-    console.error('[stratum-client] guard error stderr:', result.stderr);
-    try {
-      return JSON.parse(result.stdout);   // canonical { status:"error", ... }
-    } catch {
-      return { error: { code: 'UNKNOWN', message: 'Stratum guard failed', detail: '' } };
+    let canonical = null;
+    try { canonical = JSON.parse(result.stdout); } catch { /* not canonical */ }
+    // guard_not_found is a normal answer to a policy/history query (every
+    // never-registered feature returns it); logging it as an error spammed
+    // 363 lines from one `compose guard status` on 2026-09-06.
+    if (canonical?.error_type !== 'guard_not_found') {
+      console.error('[stratum-client] guard error stderr:', result.stderr);
     }
+    if (canonical) return canonical;   // canonical { status:"error", ... }
+    return { error: { code: 'UNKNOWN', message: 'Stratum guard failed', detail: '' } };
   }
   try {
     return JSON.parse(result.stdout);
@@ -346,7 +353,7 @@ export async function guardRegister({ resourceId, graph, edgePredicates, initial
  * predicates verify server-side. A refusal is a normal result (status:"refused").
  * @returns {Promise<{status:string,verdict:object,ledger_ref:string,current_state:string}|ErrorResult>}
  */
-export async function guardTransition({ resourceId, fromState, toState, artifacts, modifiedFiles, idempotencyKey, resolvedBy }) {
+export async function guardTransition({ resourceId, fromState, toState, artifacts, modifiedFiles, idempotencyKey, expectedPolicyChecksum, resolvedBy }) {
   return runGuard('transition', _compact({
     resource_id: resourceId,
     from_state: fromState,
@@ -354,6 +361,7 @@ export async function guardTransition({ resourceId, fromState, toState, artifact
     artifacts,
     modified_files: modifiedFiles,
     idempotency_key: idempotencyKey,
+    expected_policy_checksum: expectedPolicyChecksum,
     resolved_by: resolvedBy,
   }));
 }
@@ -382,3 +390,42 @@ export async function guardOverride({ resourceId, fromState, toState, overrideTo
 export async function guardHistory(resourceId) {
   return runGuard('history', { resource_id: resourceId }, QUERY_TIMEOUT_MS);
 }
+
+/** Read an immutable guard policy for compatibility and upgrade decisions. */
+export async function guardPolicy(resourceId) {
+  return runGuard('policy', { resource_id: resourceId }, QUERY_TIMEOUT_MS);
+}
+
+/** List registered guard resources, optionally filtered by resource_id prefix. */
+export async function guardList({ prefix } = {}) {
+  return runGuard('list', prefix ? { prefix } : {}, QUERY_TIMEOUT_MS);
+}
+
+/** Apply a signed, server-owned guard upgrade descriptor. */
+export async function guardApplyUpgrade({ resourceId, descriptorId, descriptorsPath }) {
+  return runGuard('apply-upgrade', {
+    resource_id: resourceId,
+    descriptor_id: descriptorId,
+  }, MUTATION_TIMEOUT_MS, {
+    STRATUM_GUARD_UPGRADE_DESCRIPTORS: descriptorsPath,
+  });
+}
+
+/** Inspect + verify a descriptor file through stratum's verifier (read-only). */
+export async function guardDescriptors(descriptorsPath) {
+  return runGuard('descriptors', {}, MUTATION_TIMEOUT_MS, {
+    STRATUM_GUARD_UPGRADE_DESCRIPTORS: descriptorsPath,
+  });
+}
+
+/** Compute stratum's canonical transition payload digest without changing state. */
+export async function guardDigest({ fromState, toState, artifacts, modifiedFiles, resolvedBy, policyChecksum }) {
+  return runGuard('digest', {
+    from_state: fromState,
+    to_state: toState,
+    artifacts,
+    modified_files: modifiedFiles,
+    resolved_by: resolvedBy,
+    policy_checksum: policyChecksum,
+  }, QUERY_TIMEOUT_MS);
+}

package/server/stratum-sync.js

@@ -77,6 +77,8 @@ export class StratumSync {
   start() {
     this.#stopped = false;
     this.#lastTickAt = Date.now();
+    // Idempotent: a second start() must not orphan the armed timer.
+    if (this.#pollTimer) return;
     this.#scheduleNext();
   }
 
@@ -241,10 +243,11 @@ export function attachStratumRoutes(app, { store, scheduleBroadcast, broadcastMe
       // eslint-disable-next-line no-unused-vars
       const { stratumViolations: _v, violatedAt: _va, ...existingEvidence } = item.evidence || {};
       const evidence = { ...existingEvidence, stratumTrace: trace, tracedAt: new Date().toISOString() };
+      // COMP-COMPLETION-GATE slice 3 (AC-11, path 8): an audit trace is NOT
+      // completion evidence. A flow reporting `complete` used to flip the item
+      // to complete here with no commit, no test attestation and no ledger
+      // entry. The trace is still stored; the status is left to the gate.
       const updates = { evidence };
-      if (trace.status === 'complete' && item.status !== 'complete') {
-        updates.status = 'complete';
-      }
       const updatedItem = store.updateItem(req.params.itemId, updates);
       scheduleBroadcast();
 

package/server/summarizer.js

@@ -10,7 +10,6 @@ import path from 'node:path';
 
 import { getTargetRoot } from './project-root.js';
 
-const PROJECT_ROOT = getTargetRoot();
 
 const DEFAULT_MODEL = process.env.SUMMARIZER_MODEL || 'haiku';
 
@@ -25,7 +24,7 @@ const DEFAULT_MODEL = process.env.SUMMARIZER_MODEL || 'haiku';
  * @param {string} [projectRoot]
  * @returns {string}
  */
-export function buildSummaryPrompt(batch, projectRoot = PROJECT_ROOT) {
+export function buildSummaryPrompt(batch, projectRoot = getTargetRoot()) {
   const eventLines = batch.map(evt => {
     const itemLabel = evt.itemTitles.length > 0
       ? ` [${evt.itemTitles.join(', ')}]`
@@ -66,9 +65,9 @@ JSON schema:
  * @param {string} [opts.projectRoot]
  * @returns {Promise<object|null>}
  */
-export function summarize(prompt, { model = DEFAULT_MODEL, projectRoot = PROJECT_ROOT } = {}) {
+export function summarize(prompt, { model = DEFAULT_MODEL, projectRoot = getTargetRoot() } = {}) {
   return new Promise((resolve) => {
-    const cleanEnv = { ...process.env, NO_COLOR: '1' };
+    const cleanEnv = { ...process.env, COMPOSE_TARGET: projectRoot, NO_COLOR: '1' };
     delete cleanEnv.CLAUDECODE;
 
     const proc = spawn('claude', [

package/server/supervisor.js

@@ -59,7 +59,6 @@ function ensureComposeApiToken() {
   // Expose the same token to Vite client code.
   process.env.VITE_COMPOSE_API_TOKEN = process.env.COMPOSE_API_TOKEN;
   // Expose AGENT_PORT so AgentStream.jsx can reach the right port
-  process.env.VITE_AGENT_PORT = process.env.AGENT_PORT || '4002';
 }
 
 // --- Singleton enforcement ---