@noir-ai/daemon 1.0.0-beta.1

package/dist/index.js

@@ -0,0 +1,759 @@
+// src/context-seam.ts
+import { ContextEngine } from "@noir-ai/context";
+function buildContextEngine(store, root, projectId, embedderCfg, storeDegraded) {
+  return new ContextEngine({ store, root, projectId, embedderCfg, storeDegraded });
+}
+
+// src/http.ts
+import { createServer } from "http";
+import {
+  localhostHostValidation,
+  localhostOriginValidation,
+  NodeStreamableHTTPServerTransport
+} from "@modelcontextprotocol/node";
+import { createEmbedFn, resolveEmbedderConfig } from "@noir-ai/context";
+import { resolveMemoryConfig } from "@noir-ai/memory";
+import { resolveModelConfig } from "@noir-ai/model";
+
+// src/lifecycle.ts
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function noirHome() {
+  return join(homedir(), ".noir");
+}
+function daemonJsonPath() {
+  return process.env.NOIR_DAEMON_JSON ?? join(noirHome(), "daemon.json");
+}
+function readDaemonRecord() {
+  try {
+    const raw = readFileSync(daemonJsonPath(), "utf8");
+    const rec = JSON.parse(raw);
+    if (typeof rec.pid === "number" && typeof rec.port === "number") return rec;
+    return null;
+  } catch {
+    return null;
+  }
+}
+function writeDaemonRecord(rec) {
+  mkdirSync(noirHome(), { recursive: true });
+  writeFileSync(daemonJsonPath(), `${JSON.stringify(rec)}
+`, "utf8");
+}
+function clearDaemonRecord() {
+  if (existsSync(daemonJsonPath())) rmSync(daemonJsonPath(), { force: true });
+}
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/memory-seam.ts
+import {
+  createMemoryEngine
+} from "@noir-ai/memory";
+import { complete } from "@noir-ai/model";
+function resolveMemoryConsolidation(modelCfg) {
+  if (!modelCfg) return null;
+  const providerKey = modelCfg.tiers.consolidate ?? modelCfg.defaultProvider;
+  if (!providerKey) return null;
+  const block = modelCfg.providers[providerKey];
+  if (!block || !block.model) return null;
+  return { provider: providerKey, model: block.model };
+}
+function resolveConsolidationCapability(resolvedMemory, modelCfg) {
+  const cons = resolvedMemory?.consolidation;
+  if (cons?.enabled !== true) return null;
+  if (cons.provider) {
+    return cons.model ? { provider: cons.provider, model: cons.model } : null;
+  }
+  return resolveMemoryConsolidation(modelCfg);
+}
+function bindMemoryModel(modelCfg) {
+  return {
+    async complete(req) {
+      const result = await complete(
+        {
+          system: req.system,
+          prompt: req.prompt,
+          provider: req.provider,
+          model: req.model,
+          ...req.maxTokens !== void 0 ? { maxTokens: req.maxTokens } : {},
+          ...req.tier !== void 0 ? { tier: req.tier } : {}
+        },
+        modelCfg
+      );
+      if (result === null) return null;
+      if (!result.ok) return { ok: false, reason: result.reason };
+      return { ok: true, text: result.text };
+    }
+  };
+}
+function buildMemoryEngine(store, root, projectId, embed, modelCfg, storeDegraded, resolvedMemory) {
+  const cons = resolveConsolidationCapability(resolvedMemory, modelCfg);
+  if (!cons) {
+    return createMemoryEngine({
+      store,
+      root,
+      projectId,
+      embed,
+      storeDegraded,
+      ...resolvedMemory ? { config: resolvedMemory } : {}
+    });
+  }
+  const model = modelCfg ? bindMemoryModel(modelCfg) : void 0;
+  const config = {
+    consolidation: { enabled: true, provider: cons.provider, model: cons.model }
+  };
+  return createMemoryEngine({
+    store,
+    root,
+    projectId,
+    embed,
+    ...model ? { model } : {},
+    config,
+    storeDegraded
+  });
+}
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/server";
+import { NOIR_VERSION as NOIR_VERSION2 } from "@noir-ai/core";
+import { PHASES } from "@noir-ai/workflow";
+import { z } from "zod";
+
+// src/status.ts
+import { NOIR_VERSION } from "@noir-ai/core";
+function buildStatus(project, ctx) {
+  const status = {
+    noir: NOIR_VERSION,
+    project: { id: project.id, name: project.name },
+    host: project.config.host,
+    transport: ctx.transport,
+    daemon: ctx.daemon
+  };
+  if (ctx.pid !== void 0) status.pid = ctx.pid;
+  if (ctx.startedAt !== void 0) {
+    status.uptimeSec = Math.max(0, Math.floor((Date.now() - ctx.startedAt) / 1e3));
+  }
+  return status;
+}
+
+// src/server.ts
+var GATE_PHASES = ["spec", "plan", "verify"];
+function buildStoreStatus(store, dbPath, degraded = false) {
+  return {
+    ok: true,
+    projectId: store.projectId,
+    docCount: store.countDocs(),
+    vecCount: store.countVecs(),
+    dbPath: dbPath ?? null,
+    degraded
+  };
+}
+function nextGateAfter(phase) {
+  const cur = PHASES.indexOf(phase);
+  for (const p of GATE_PHASES) {
+    if (PHASES.indexOf(p) > cur) return p;
+  }
+  return null;
+}
+function buildWorkflowStatus(engine, taskId, degraded = false) {
+  const task = engine.status(taskId);
+  if (!task) return null;
+  const stopped = task.state === "blocked" || task.state === "abandoned";
+  return {
+    ok: true,
+    taskId: task.taskId,
+    phase: task.phase,
+    state: task.state,
+    nextGate: stopped ? null : nextGateAfter(task.phase),
+    mode: task.mode,
+    history: task.history,
+    updatedAt: task.updatedAt,
+    degraded
+  };
+}
+function textResult(obj) {
+  return { content: [{ type: "text", text: JSON.stringify(obj, null, 2) }] };
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function createNoirServer(ctx) {
+  const server = new McpServer({ name: "noir", version: NOIR_VERSION2 });
+  server.registerTool(
+    "host_status",
+    {
+      description: "Report Noir's runtime status: project id/name, host CLI, transport, and daemon state.",
+      // Empty ZodRawShape => no input parameters (MCP SDK v2 registerTool overload 2).
+      inputSchema: {}
+    },
+    async () => {
+      const status = buildStatus(ctx.project, ctx);
+      return { content: [{ type: "text", text: JSON.stringify(status, null, 2) }] };
+    }
+  );
+  if (ctx.store) {
+    const store = ctx.store;
+    const dbPath = ctx.dbPath;
+    const degraded = ctx.storeDegraded === true;
+    server.registerTool(
+      "store_status",
+      {
+        description: "Report the Noir embedded store's health: project id, document and vector counts, DB path, and degraded state.",
+        inputSchema: {}
+      },
+      async () => {
+        const payload = buildStoreStatus(store, dbPath, degraded);
+        return {
+          content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
+        };
+      }
+    );
+  }
+  if (ctx.engine) {
+    const engine = ctx.engine;
+    const degraded = ctx.storeDegraded === true;
+    server.registerTool(
+      "workflow_status",
+      {
+        description: "Report the active Noir SDD task's phase, state, the next gate ahead, mode, and observable gate history. Omit taskId to read the active task.",
+        inputSchema: {
+          taskId: z.string().optional().describe("Task id; defaults to the active task (workflow:active).")
+        }
+      },
+      async ({ taskId }) => {
+        const id = taskId ?? engine.activeTaskId();
+        if (!id) return textResult({ ok: false, error: "no active task" });
+        const payload = buildWorkflowStatus(engine, id, degraded);
+        if (!payload) return textResult({ ok: false, taskId: id, error: "unknown task" });
+        return textResult(payload);
+      }
+    );
+    server.registerTool(
+      "checkpoint",
+      {
+        description: "Checkpoint a Noir SDD task: `save` flushes the in-flight state to the store KV; `restore` reads it back. Omit taskId to target the active task.",
+        inputSchema: {
+          action: z.enum(["save", "restore"]).describe("'save' flushes state; 'restore' returns the in-flight task state."),
+          taskId: z.string().optional().describe("Task id; defaults to the active task (workflow:active).")
+        }
+      },
+      async ({ action, taskId }) => {
+        const id = taskId ?? engine.activeTaskId();
+        if (!id) return textResult({ ok: false, error: "no active task" });
+        if (action === "save") {
+          try {
+            await engine.checkpoint(id);
+          } catch (err) {
+            return textResult({
+              ok: false,
+              action: "save",
+              taskId: id,
+              degraded: true,
+              error: errorMessage(err)
+            });
+          }
+        }
+        const payload = buildWorkflowStatus(engine, id, degraded);
+        if (!payload) return textResult({ ok: false, taskId: id, error: "unknown task" });
+        return textResult({ action, ...payload });
+      }
+    );
+    server.registerTool(
+      "workflow_start",
+      {
+        description: "Start a Noir SDD task at draft/intake and make it the active task (workflow:active). Re-starting an existing taskId overwrites it (the KV is the source of truth, not a journal). Defaults to full mode.",
+        inputSchema: {
+          taskId: z.string().min(1).describe("Stable task handle (re-starting overwrites)."),
+          slug: z.string().min(1).describe('Human-readable slug, e.g. "add-login".'),
+          mode: z.enum(["full", "quick"]).optional().describe("Mode: 'full' (default) or 'quick'.")
+        }
+      },
+      async ({ taskId, slug, mode }) => {
+        if (degraded) {
+          return textResult({
+            ok: false,
+            degraded: true,
+            error: "store is read-only (daemon down) \u2014 workflow_start is unavailable"
+          });
+        }
+        try {
+          const resolvedMode = mode ?? "full";
+          await engine.startTask(taskId, slug, resolvedMode);
+          const payload = buildWorkflowStatus(engine, taskId, degraded);
+          if (!payload) return textResult({ ok: false, taskId, error: "unknown task" });
+          return textResult(payload);
+        } catch (err) {
+          return textResult({ ok: false, degraded: true, error: errorMessage(err) });
+        }
+      }
+    );
+    server.registerTool(
+      "workflow_advance",
+      {
+        description: "Advance a Noir SDD task to its next phase, or jump with `to`. At a gate-landing state (entering specified/planned/done) a gate is recorded \u2014 approved by default, forced (with reason) via `force`, or skipped via `skip`. Omit taskId to target the active task. `force` and `skip` are mutually exclusive.",
+        inputSchema: {
+          taskId: z.string().optional().describe("Task id; defaults to the active task (workflow:active)."),
+          force: z.object({ reason: z.string().min(1) }).optional().describe(
+            "Pass the next gate without satisfying its criteria; requires a non-empty reason. Mutually exclusive with skip."
+          ),
+          to: z.enum(["intake", "clarify", "spec", "plan", "execute", "verify", "document"]).optional().describe("Jump directly to a phase, bypassing the FSM."),
+          skip: z.boolean().optional().describe(
+            "Quick-mode: record the landing gate as 'skipped' instead of 'approved'. Mutually exclusive with force."
+          )
+        }
+      },
+      async ({ taskId, force, to, skip }) => {
+        if (degraded) {
+          return textResult({
+            ok: false,
+            degraded: true,
+            error: "store is read-only (daemon down) \u2014 workflow_advance is unavailable"
+          });
+        }
+        try {
+          const id = taskId ?? engine.activeTaskId();
+          if (!id) return textResult({ ok: false, error: "no active task" });
+          const opts = {};
+          if (force) opts.force = { reason: force.reason };
+          if (to) opts.to = to;
+          if (skip) opts.skip = true;
+          await engine.advance(id, opts);
+          const payload = buildWorkflowStatus(engine, id, degraded);
+          if (!payload) return textResult({ ok: false, taskId: id, error: "unknown task" });
+          return textResult(payload);
+        } catch (err) {
+          return textResult({ ok: false, degraded: true, error: errorMessage(err) });
+        }
+      }
+    );
+  }
+  if (ctx.context) {
+    const context = ctx.context;
+    const storeDegraded = ctx.storeDegraded === true;
+    server.registerTool(
+      "context_search",
+      {
+        description: "Hybrid search over the Noir context index: BM25 \u222A cosine-kNN fused by Reciprocal Rank Fusion (k=60), packed into a token budget with window-extracted snippets (never truncated). Returns ranked hits with path, snippet, and score.",
+        inputSchema: {
+          query: z.string().describe('Natural-language or identifier query (e.g. "ContextEngine").'),
+          limit: z.number().int().positive().optional().describe("Max hits requested from each leg before fusion (default 10)."),
+          budgetTokens: z.number().int().positive().optional().describe("Token budget for the packed result set (default 4096)."),
+          // Singular `source` (not the spec's plural `sources`): both store
+          // primitives (SearchFtOpts.source / VecOpts.source) and the engine's
+          // SearchOptions.source take a single string, so a plural array is not
+          // honor-able here. Spec F9 source-filtering surfaces as one bucket.
+          source: z.string().optional().describe('Restrict both legs to a single source bucket (e.g. "docs", "codebase").')
+        }
+      },
+      async ({ query, limit, budgetTokens, source }) => {
+        try {
+          const result = await context.search(query, { limit, budgetTokens, source });
+          return textResult({ ok: true, ...result });
+        } catch (err) {
+          return textResult({ ok: false, degraded: true, error: errorMessage(err) });
+        }
+      }
+    );
+    server.registerTool(
+      "context_index",
+      {
+        description: "Incrementally index files/directories into the Noir context store (SHA-256 content-hash; unchanged files are skipped). Indexes docs + 384-dim vectors into the existing tables (no schema migration). Omit paths to index the project root.",
+        inputSchema: {
+          paths: z.array(z.string()).optional().describe('Files/directories to index (repo-relative or absolute); defaults to ["."].')
+        }
+      },
+      async ({ paths: paths2 }) => {
+        if (storeDegraded) {
+          return textResult({
+            ok: false,
+            degraded: true,
+            error: "store is read-only (daemon down) \u2014 context_index is unavailable"
+          });
+        }
+        try {
+          const result = await context.indexPaths(paths2 && paths2.length > 0 ? paths2 : ["."]);
+          return textResult({ ok: true, ...result });
+        } catch (err) {
+          return textResult({ ok: false, degraded: true, error: errorMessage(err) });
+        }
+      }
+    );
+    server.registerTool(
+      "context_status",
+      {
+        description: "Report the Noir context index's health: project id, document + vector counts, indexed file count, the active embedder (kind/model/dim), and degraded state.",
+        inputSchema: {}
+      },
+      async () => {
+        try {
+          return textResult(context.status());
+        } catch (err) {
+          return textResult({ ok: false, degraded: true, error: errorMessage(err) });
+        }
+      }
+    );
+  }
+  if (ctx.memory) {
+    const memory = ctx.memory;
+    const storeDegraded = ctx.storeDegraded === true;
+    server.registerTool(
+      "memory_save",
+      {
+        description: "Persist a cross-session memory observation (pattern / preference / architecture / bug / workflow / fact / decision). Stored locally on top of the Noir store (FTS5 + vectors + KV) \u2014 never truncated, never sent to an LLM. Returns the full saved observation.",
+        inputSchema: {
+          content: z.string().min(1).describe("The insight to remember (full text; never truncated)."),
+          // Open enum (DS-3): unknown types are accepted + stored, so this is a
+          // free-form string (with the known values described) rather than a
+          // closed zod enum that would reject forward-compatible types.
+          type: z.string().optional().describe(
+            "Observation type \u2014 pattern | preference | architecture | bug | workflow | fact | decision. Unknown values are accepted."
+          ),
+          concepts: z.array(z.string()).optional().describe("User tags (no auto-LLM tagging in v1 \u2014 explicit only)."),
+          files: z.array(z.string()).optional().describe("Repo-relative paths mentioned."),
+          importance: z.number().min(0).max(1).optional().describe("Salience 0..1 (defaults to 0.5)."),
+          sessionId: z.string().optional().describe("Host session id (recorded when known).")
+        }
+      },
+      async (input) => {
+        if (storeDegraded) {
+          return textResult({
+            ok: false,
+            degraded: true,
+            error: "store is read-only (daemon down) \u2014 memory_save is unavailable"
+          });
+        }
+        try {
+          const observation = await memory.save(input);
+          return textResult({ ok: true, id: observation.id, observation });
+        } catch (err) {
+          return textResult({ ok: false, degraded: true, error: errorMessage(err) });
+        }
+      }
+    );
+    server.registerTool(
+      "memory_recall",
+      {
+        description: 'Hybrid recall over cross-session memory: BM25 \u222A cosine-kNN fused by Reciprocal Rank Fusion (k=60) scoped to source:"memory", plus a cheap entity-boost. Returns ranked observations with FULL content (hydrated from the authoritative KV row \u2014 never the truncated FTS snippet). Degrades to BM25-only when the embedder is unavailable.',
+        inputSchema: {
+          query: z.string().describe("Natural-language or identifier query."),
+          limit: z.number().int().positive().optional().describe("Max results (default 10)."),
+          type: z.string().optional().describe("Filter to a single observation type."),
+          sessionId: z.string().optional().describe("Filter to a single host session.")
+        }
+      },
+      async ({ query, limit, type, sessionId }) => {
+        try {
+          const results = await memory.recall(query, { limit, type, sessionId });
+          return textResult({ ok: true, results });
+        } catch (err) {
+          return textResult({ ok: false, degraded: true, error: errorMessage(err) });
+        }
+      }
+    );
+    server.registerTool(
+      "memory_search",
+      {
+        description: 'Instant BM25-only lookup over cross-session memory (no embedding cost). Returns ranked observations with FULL content, scoped to source:"memory". Use memory_recall for the hybrid (vector + BM25) path.',
+        inputSchema: {
+          query: z.string().describe("Natural-language or identifier query."),
+          limit: z.number().int().positive().optional().describe("Max results (default 10).")
+        }
+      },
+      async ({ query, limit }) => {
+        try {
+          const hits = await memory.search(query, { limit });
+          return textResult({ ok: true, hits });
+        } catch (err) {
+          return textResult({ ok: false, degraded: true, error: errorMessage(err) });
+        }
+      }
+    );
+    server.registerTool(
+      "memory_sessions",
+      {
+        description: "List per-session memory rollups (session id, observation count, most-recent timestamp) for this project's cross-session memory.",
+        inputSchema: {}
+      },
+      async () => {
+        try {
+          return textResult({ ok: true, sessions: memory.sessions() });
+        } catch (err) {
+          return textResult({ ok: false, degraded: true, error: errorMessage(err) });
+        }
+      }
+    );
+    server.registerTool(
+      "memory_forget",
+      {
+        description: "Remove observations from cross-session memory: deletes the authoritative KV row + best-effort FTS/vector purge. Returns the count actually removed.",
+        inputSchema: {
+          ids: z.array(z.string()).min(1).describe("Observation ids to remove.")
+        }
+      },
+      async ({ ids }) => {
+        if (storeDegraded) {
+          return textResult({
+            ok: false,
+            degraded: true,
+            error: "store is read-only (daemon down) \u2014 memory_forget is unavailable"
+          });
+        }
+        try {
+          const result = memory.forget(ids);
+          return textResult({ ok: true, ...result });
+        } catch (err) {
+          return textResult({ ok: false, degraded: true, error: errorMessage(err) });
+        }
+      }
+    );
+    if (ctx.memoryConsolidation === true) {
+      server.registerTool(
+        "memory_consolidate",
+        {
+          description: 'Explicitly consolidate recent memory observations into ONE derived lesson (append-only; originals are never mutated). Provider-gated: refuses + logs if no provider is configured \u2014 NEVER a silent paid call. Emits a type:"lesson" observation with provenance.',
+          inputSchema: {
+            types: z.array(z.string()).optional().describe("Restrict candidates to these observation types."),
+            limit: z.number().int().positive().optional().describe("Cap on candidate observations.")
+          }
+        },
+        async ({ types, limit }) => {
+          try {
+            const result = await memory.consolidate?.({ types, limit });
+            if (result === void 0) {
+              return textResult({
+                ok: false,
+                degraded: true,
+                error: "consolidation is not wired on this engine"
+              });
+            }
+            return textResult(result);
+          } catch (err) {
+            return textResult({ ok: false, degraded: true, error: errorMessage(err) });
+          }
+        }
+      );
+    }
+  }
+  return server;
+}
+
+// src/store-seam.ts
+import { paths } from "@noir-ai/core";
+import { openStore } from "@noir-ai/store";
+async function openStoreForDaemon(projectId, root) {
+  const dbPath = paths.storeDb(root, projectId);
+  try {
+    const store = await openStore({ projectId, root });
+    return { store, dbPath, degraded: false };
+  } catch {
+    const store = await openStore({ projectId, root, readonly: true });
+    return { store, dbPath, degraded: true };
+  }
+}
+
+// src/workflow-seam.ts
+import { WorkflowEngine } from "@noir-ai/workflow";
+function buildWorkflowEngine(store, root, projectId) {
+  return new WorkflowEngine(store, root, projectId);
+}
+
+// src/http.ts
+async function startHttpServer(opts) {
+  const startedAt = Date.now();
+  const pid = process.pid;
+  const validateHost = localhostHostValidation();
+  const validateOrigin = localhostOriginValidation();
+  let lastActivity = Date.now();
+  let idleTimer = setInterval(() => {
+    if (Date.now() - lastActivity > opts.idleTimeoutSec * 1e3) void shutdown();
+  }, 1e4);
+  const daemonStore = await openStoreForDaemon(opts.project.id, opts.project.root).catch(
+    () => void 0
+  );
+  const engine = daemonStore ? buildWorkflowEngine(daemonStore.store, opts.project.root, opts.project.id) : void 0;
+  const embedderCfg = resolveEmbedderConfig(opts.project.config.context);
+  const embed = createEmbedFn(embedderCfg).embed;
+  const context = daemonStore ? buildContextEngine(
+    daemonStore.store,
+    opts.project.root,
+    opts.project.id,
+    embedderCfg,
+    daemonStore.degraded
+  ) : void 0;
+  const modelCfg = resolveModelConfig(opts.project.config.model);
+  const resolvedMemory = resolveMemoryConfig(opts.project.config.memory);
+  const memoryConsolidation = resolveConsolidationCapability(resolvedMemory, modelCfg) !== null;
+  const memory = daemonStore ? buildMemoryEngine(
+    daemonStore.store,
+    opts.project.root,
+    opts.project.id,
+    embed,
+    modelCfg,
+    daemonStore.degraded,
+    resolvedMemory
+  ) : void 0;
+  const httpServer = createServer(async (req, res) => {
+    lastActivity = Date.now();
+    if (req.method === "GET" && req.url === "/health") {
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end(
+        JSON.stringify({ ok: true, pid, uptimeSec: Math.floor((Date.now() - startedAt) / 1e3) })
+      );
+      return;
+    }
+    if (!validateHost(req, res) || !validateOrigin(req, res)) return;
+    if (req.url === "/mcp") {
+      const server = createNoirServer({
+        project: opts.project,
+        transport: "streamable-http",
+        daemon: true,
+        pid,
+        startedAt,
+        ...daemonStore ? {
+          store: daemonStore.store,
+          dbPath: daemonStore.dbPath,
+          storeDegraded: daemonStore.degraded
+        } : {},
+        ...engine ? { engine } : {},
+        ...context ? { context } : {},
+        ...memory ? { memory, memoryConsolidation } : {}
+      });
+      const transport = new NodeStreamableHTTPServerTransport({ sessionIdGenerator: void 0 });
+      await server.connect(transport);
+      await transport.handleRequest(req, res);
+      return;
+    }
+    res.writeHead(404).end("not found");
+  });
+  const port = await new Promise((resolve, reject) => {
+    httpServer.once("error", reject);
+    httpServer.listen(opts.port ?? 0, "127.0.0.1", () => {
+      const addr = httpServer.address();
+      httpServer.removeListener("error", reject);
+      resolve(typeof addr === "object" && addr ? addr.port : 0);
+    });
+  });
+  const rec = { pid, port, startedAt };
+  writeDaemonRecord(rec);
+  async function shutdown() {
+    if (idleTimer) {
+      clearInterval(idleTimer);
+      idleTimer = void 0;
+    }
+    await new Promise((r) => httpServer.close(() => r()));
+    await daemonStore?.store.close().catch(() => void 0);
+    clearDaemonRecord();
+  }
+  for (const sig of ["SIGTERM", "SIGINT"]) {
+    process.once(sig, () => void shutdown().then(() => process.exit(0)));
+  }
+  return { port, pid, startedAt, stop: shutdown };
+}
+
+// src/ensure.ts
+async function isHealthy(port) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/health`);
+    return res.status === 200;
+  } catch {
+    return false;
+  }
+}
+async function ensureDaemonRunning(opts) {
+  const rec = readDaemonRecord();
+  if (rec) {
+    if (pidAlive(rec.pid) && await isHealthy(rec.port)) {
+      return {
+        port: rec.port,
+        url: `http://127.0.0.1:${rec.port}/mcp`,
+        started: false,
+        stop: async () => {
+        }
+      };
+    }
+    clearDaemonRecord();
+  }
+  const running = await startHttpServer({
+    project: opts.project,
+    idleTimeoutSec: opts.idleTimeoutSec
+  });
+  return {
+    port: running.port,
+    url: `http://127.0.0.1:${running.port}/mcp`,
+    started: true,
+    stop: running.stop
+  };
+}
+
+// src/stdio.ts
+import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
+import { createEmbedFn as createEmbedFn2, resolveEmbedderConfig as resolveEmbedderConfig2 } from "@noir-ai/context";
+import { resolveMemoryConfig as resolveMemoryConfig2 } from "@noir-ai/memory";
+import { resolveModelConfig as resolveModelConfig2 } from "@noir-ai/model";
+async function startStdioServer(ctx) {
+  const daemonStore = await openStoreForDaemon(ctx.project.id, ctx.project.root).catch(
+    () => void 0
+  );
+  const engine = daemonStore ? buildWorkflowEngine(daemonStore.store, ctx.project.root, ctx.project.id) : void 0;
+  const embedderCfg = resolveEmbedderConfig2(ctx.project.config.context);
+  const embed = createEmbedFn2(embedderCfg).embed;
+  const context = daemonStore ? buildContextEngine(
+    daemonStore.store,
+    ctx.project.root,
+    ctx.project.id,
+    embedderCfg,
+    daemonStore.degraded
+  ) : void 0;
+  const modelCfg = resolveModelConfig2(ctx.project.config.model);
+  const resolvedMemory = resolveMemoryConfig2(ctx.project.config.memory);
+  const memoryConsolidation = resolveConsolidationCapability(resolvedMemory, modelCfg) !== null;
+  const memory = daemonStore ? buildMemoryEngine(
+    daemonStore.store,
+    ctx.project.root,
+    ctx.project.id,
+    embed,
+    modelCfg,
+    daemonStore.degraded,
+    resolvedMemory
+  ) : void 0;
+  const server = createNoirServer({
+    ...ctx,
+    ...daemonStore ? {
+      store: daemonStore.store,
+      dbPath: daemonStore.dbPath,
+      storeDegraded: daemonStore.degraded
+    } : {},
+    ...engine ? { engine } : {},
+    ...context ? { context } : {},
+    ...memory ? { memory, memoryConsolidation } : {}
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+export {
+  buildContextEngine,
+  buildMemoryEngine,
+  buildStatus,
+  buildWorkflowEngine,
+  clearDaemonRecord,
+  createNoirServer,
+  daemonJsonPath,
+  ensureDaemonRunning,
+  noirHome,
+  openStoreForDaemon,
+  pidAlive,
+  readDaemonRecord,
+  resolveConsolidationCapability,
+  resolveMemoryConsolidation,
+  startHttpServer,
+  startStdioServer,
+  writeDaemonRecord
+};
+//# sourceMappingURL=index.js.map