septum 0.1.6 → 0.1.8

package/src/core/resources/work-queue.ts

@@ -0,0 +1,74 @@
+import { RESOURCE_LIMITS } from "./limits.ts";
+
+/** One mutation/parse lane per server; failures do not poison later work. */
+export class SerialWorkQueue {
+  private tail: Promise<void> = Promise.resolve();
+  private pending = 0;
+  private readonly maxPending: number;
+
+  constructor(maxPending = RESOURCE_LIMITS.maxQueuePending) {
+    this.maxPending = maxPending;
+  }
+
+  get pendingCount(): number {
+    return this.pending;
+  }
+
+  run<T>(work: () => Promise<T>, signal?: AbortSignal): Promise<T> {
+    if (signal?.aborted) {
+      return Promise.reject(signal.reason ?? new Error("Request was cancelled before queueing"));
+    }
+
+    if (this.pending >= this.maxPending) {
+      const busyError = new Error(`Server is busy: request admission limit (${this.maxPending}) exceeded. Retry after current tasks finish.`);
+      (busyError as any).code = "SERVER_BUSY";
+      return Promise.reject(busyError);
+    }
+
+    this.pending++;
+
+    return new Promise<T>((resolve, reject) => {
+      let cancelled = false;
+
+      const abortHandler = () => {
+        cancelled = true;
+        reject(signal?.reason ?? new Error("Request was cancelled while queued"));
+      };
+
+      if (signal) {
+        signal.addEventListener("abort", abortHandler, { once: true });
+      }
+
+      const execute = async () => {
+        if (signal) {
+          signal.removeEventListener("abort", abortHandler);
+        }
+        if (cancelled || signal?.aborted) {
+          if (!cancelled) {
+            reject(signal?.reason ?? new Error("Request was cancelled before execution"));
+          }
+          return;
+        }
+
+        try {
+          const res = await work();
+          resolve(res);
+        } catch (err) {
+          reject(err);
+        }
+      };
+
+      const next = this.tail.then(execute, execute);
+      this.tail = next.finally(() => {
+        this.pending--;
+        if (this.pending === 0) {
+          this.tail = Promise.resolve();
+        }
+      });
+    });
+  }
+
+  drain(): Promise<void> {
+    return this.tail;
+  }
+}

package/src/core/session/session-manager.ts

@@ -1,56 +1,85 @@
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import type { SeptumRepository } from "../database/repository.ts";
 import type { ActiveFeatureSession } from "../../types/index.ts";
+import { SeptumDatabase } from "../database/client.ts";
 
 export class SessionManager {
   private static readonly SESSION_FILE = ".septum/session.json";
 
-  /**
-   * Save the active feature session to .septum/session.json
-   */
-  public static saveActiveSession(workspaceRoot: string, session: ActiveFeatureSession): void {
-    const septumDir = join(workspaceRoot, ".septum");
-    if (!existsSync(septumDir)) {
-      mkdirSync(septumDir, { recursive: true });
+  public static getOwnerId(): string {
+    return process.env.SEPTUM_SESSION_ID || `process:${process.pid}`;
+  }
+
+  private static mutate<T>(workspaceRoot: string, fn: () => T, repo?: SeptumRepository): T {
+    if (repo) return repo.runInTransaction(fn, true);
+    const db = new SeptumDatabase(join(workspaceRoot, ".septum/septum.db"));
+    try {
+      // Serialize ownership checks with writes across CLI and MCP processes.
+      return db.raw.transaction(fn).immediate();
+    } finally {
+      db.close();
     }
-    const sessionPath = join(workspaceRoot, SessionManager.SESSION_FILE);
-    writeFileSync(sessionPath, JSON.stringify(session, null, 2), "utf-8");
   }
 
-  /**
-   * Get the active feature session, or null if no session exists or file is invalid
-   */
+  public static saveActiveSession(
+    workspaceRoot: string,
+    session: ActiveFeatureSession,
+    ownerId: string = SessionManager.getOwnerId(),
+    persistence?: { repo: SeptumRepository; save: () => void }
+  ): void {
+    SessionManager.mutate(workspaceRoot, () => {
+      const current = SessionManager.getActiveSession(workspaceRoot);
+      if (current && current.owner_id !== ownerId) {
+        throw new Error(`Workspace already has an active feature session owned by '${current.owner_id || "legacy-session"}'. Release it with its owner, or explicitly run 'septum feature clear --force'.`);
+      }
+      const septumDir = join(workspaceRoot, ".septum");
+      mkdirSync(septumDir, { recursive: true });
+      const sessionPath = join(workspaceRoot, SessionManager.SESSION_FILE);
+      const temporaryPath = `${sessionPath}.${randomUUID()}.tmp`;
+      try {
+        writeFileSync(temporaryPath, JSON.stringify({ ...session, owner_id: ownerId }, null, 2), "utf-8");
+        // Metadata and ownership use one write lock; a failed rename rolls back SQLite.
+        persistence?.save();
+        renameSync(temporaryPath, sessionPath);
+      } finally {
+        rmSync(temporaryPath, { force: true });
+      }
+    }, persistence?.repo);
+  }
+
   public static getActiveSession(workspaceRoot: string): ActiveFeatureSession | null {
     const sessionPath = join(workspaceRoot, SessionManager.SESSION_FILE);
-    if (!existsSync(sessionPath)) {
-      return null;
-    }
-
+    if (!existsSync(sessionPath)) return null;
+    let parsed: any;
     try {
-      const raw = readFileSync(sessionPath, "utf-8");
-      const parsed = JSON.parse(raw) as ActiveFeatureSession;
-      if (parsed && typeof parsed.feature_key === "string" && Array.isArray(parsed.touchpoints)) {
-        return parsed;
-      }
-      return null;
-    } catch {
-      return null;
+      parsed = JSON.parse(readFileSync(sessionPath, "utf-8")) as ActiveFeatureSession;
+    } catch (e: any) {
+      throw new Error(`Corrupted active feature session JSON in '${sessionPath}': ${e.message}. Release it explicitly with 'septum feature clear --force' or 'septum_feature({action: "release", force: true})'.`);
     }
+    if (parsed && typeof parsed.feature_key === "string" && parsed.feature_key.trim() &&
+        typeof parsed.domain === "string" && parsed.domain.trim() &&
+        Array.isArray(parsed.touchpoints) && parsed.touchpoints.every((tp: unknown) => typeof tp === "string") &&
+        (parsed.owner_id === undefined || typeof parsed.owner_id === "string")) return parsed;
+    throw new Error(`Invalid active feature session in '${sessionPath}'. Release it explicitly with 'septum feature clear --force'.`);
   }
 
-  /**
-   * Clear the active feature session
-   */
-  public static clearActiveSession(workspaceRoot: string): boolean {
-    const sessionPath = join(workspaceRoot, SessionManager.SESSION_FILE);
-    if (existsSync(sessionPath)) {
-      try {
-        rmSync(sessionPath, { force: true });
-        return true;
-      } catch {
-        return false;
+  public static clearActiveSession(
+    workspaceRoot: string,
+    ownerId: string = SessionManager.getOwnerId(),
+    force: boolean = false
+  ): boolean {
+    if (!existsSync(join(workspaceRoot, SessionManager.SESSION_FILE))) return false;
+    return SessionManager.mutate(workspaceRoot, () => {
+      const sessionPath = join(workspaceRoot, SessionManager.SESSION_FILE);
+      if (!existsSync(sessionPath)) return false;
+      if (!force) {
+        const current = SessionManager.getActiveSession(workspaceRoot);
+        if (current?.owner_id !== ownerId) throw new Error("Only the active session owner can release it. Use 'septum feature clear --force' for explicit recovery.");
       }
-    }
-    return false;
+      rmSync(sessionPath, { force: true });
+      return true;
+    });
   }
 }

package/src/core/telemetry/telemetry.ts

@@ -56,13 +56,24 @@ export class SeptumTelemetry {
       console.error(`[Septum Telemetry SLOW_WARN] ${jsonLine}`);
     }
 
+    this.appendLog(jsonLine, workspaceRoot);
+  }
+
+  public static recordMemorySample(metrics: Record<string, number>, workspaceRoot: string = process.cwd()): void {
+    const jsonLine = JSON.stringify({timestamp: new Date().toISOString(), event: "memory_sample", metrics});
+    console.error(`[Septum Memory] ${jsonLine}`);
+    this.appendLog(jsonLine, workspaceRoot);
+  }
+
+  private static appendLog(jsonLine: string, workspaceRoot: string): void {
     // Sink 2: Append-only persistent file recorder in .septum/septum.log
     try {
       const logPath = this.getLogPath(workspaceRoot);
       const logDir = dirname(logPath);
 
+      // SV-03: Do not auto-scaffold .septum directory for telemetry if workspace has not been initialized
       if (!existsSync(logDir)) {
-        mkdirSync(logDir, { recursive: true });
+        return;
       }
 
       // Check for rotation if file exceeds 2MB

package/src/core/topology/environment-detector.ts

@@ -18,8 +18,8 @@ export class EnvironmentDetector {
   ): EnvironmentTopology {
     // 1. Fetch any previously verified layers and nodes from SQLite SSOT
     const savedLayers: Partial<Record<EnvironmentLayer, EnvironmentLayerInfo>> =
-      repo && !forceRefresh ? repo.environment.getAllLayers() : {};
-    const savedNodes = repo && !forceRefresh ? repo.environment.getAllNodes() : [];
+      repo ? repo.environment.getAllLayers() : {};
+    const savedNodes = repo ? repo.environment.getAllNodes() : [];
     const savedNodeMap = new Map(savedNodes.map((n) => [n.id, n]));
 
     // 2. Perform root file-based heuristic inspection for each of the 6 layers
@@ -31,19 +31,28 @@ export class EnvironmentDetector {
     const detectedTelemetry = this.inspectTelemetryLayer(workspaceRoot);
 
     // 3. Merge layers: Database verified layers take precedence
+    const resolveLayer = (layerKey: EnvironmentLayer, detected: EnvironmentLayerInfo): EnvironmentLayerInfo => {
+      const saved = savedLayers[layerKey];
+      if (saved && saved.status === "VERIFIED") {
+        return saved;
+      }
+      return detected;
+    };
+
     const layers: Record<EnvironmentLayer, EnvironmentLayerInfo> = {
-      edge: savedLayers.edge?.status === "VERIFIED" ? savedLayers.edge : detectedEdge,
-      gateway: savedLayers.gateway?.status === "VERIFIED" ? savedLayers.gateway : detectedGateway,
-      host: savedLayers.host?.status === "VERIFIED" ? savedLayers.host : detectedHost,
-      runtime: savedLayers.runtime?.status === "VERIFIED" ? savedLayers.runtime : detectedRuntime,
-      storage: savedLayers.storage?.status === "VERIFIED" ? savedLayers.storage : detectedStorage,
-      telemetry: savedLayers.telemetry?.status === "VERIFIED" ? savedLayers.telemetry : detectedTelemetry,
+      edge: resolveLayer("edge", detectedEdge),
+      gateway: resolveLayer("gateway", detectedGateway),
+      host: resolveLayer("host", detectedHost),
+      runtime: resolveLayer("runtime", detectedRuntime),
+      storage: resolveLayer("storage", detectedStorage),
+      telemetry: resolveLayer("telemetry", detectedTelemetry),
     };
 
-    // 4. Save layers to SQLite if not already stored
+    // 4. Save layers to SQLite if not already stored (refresh only non-VERIFIED layers)
     if (repo) {
       for (const layerKey of Object.keys(layers) as EnvironmentLayer[]) {
-        if (!savedLayers[layerKey] || forceRefresh) {
+        const saved = savedLayers[layerKey];
+        if (!saved || (forceRefresh && saved.status !== "VERIFIED")) {
           repo.environment.saveLayer(layers[layerKey]);
         }
       }
@@ -231,7 +240,8 @@ export class EnvironmentDetector {
     // 7. Save detected nodes to SQLite SSOT
     if (repo) {
       for (const node of finalNodes) {
-        if (!savedNodeMap.has(node.id) || forceRefresh) {
+        const saved = savedNodeMap.get(node.id);
+        if (!saved || (forceRefresh && saved.status !== "VERIFIED")) {
           repo.environment.saveNode(node);
         }
       }