nemoris 0.1.0

package/src/daemon/telegram-commands.js

@@ -0,0 +1,54 @@
+/**
+ * Handle /approve <id> — routes to repair_log (held updates) or rule_staging (rule approvals).
+ * Checks repair_log first, then rule_staging.
+ * Returns { found, table, type, needsNurseJob } so the caller can queue Nurse work.
+ */
+export function handleApproveCommand(id, repairLog, ruleStaging) {
+  const repairEntry = repairLog.getById(id);
+  if (repairEntry && repairEntry.result === "held") {
+    return { found: true, table: "repair_log", type: "held_update", entry: repairEntry, needsNurseJob: true };
+  }
+
+  const ruleEntry = ruleStaging.getById(id);
+  if (ruleEntry && ruleEntry.status === "pending" && ruleEntry.action_class === "approval_required") {
+    const approved = ruleStaging.approve(id);
+    return { found: true, table: "rule_staging", type: "rule_approval", approved, entry: ruleEntry, needsNurseJob: false };
+  }
+
+  return { found: false };
+}
+
+/**
+ * Handle /clear-repairs — marks unresolved repairs as acknowledged.
+ * Writes a "cleared" child row for each unresolved entry.
+ */
+export function handleClearRepairsCommand(repairLog) {
+  const unresolved = repairLog.getRecent(100).filter(
+    e => e.result === "unresolved" || (e.result === "escalated" && e.escalated === 1)
+  );
+  for (const entry of unresolved) {
+    repairLog.write({
+      source: "user", type: entry.type, action: "manual_clear",
+      result: "resolved", severity: "silent", parent_id: entry.id,
+      diagnosis: "Manually cleared by user via /clear-repairs"
+    });
+  }
+  return `${unresolved.length} unresolved repair(s) cleared.`;
+}
+
+/**
+ * Handle /health — return system health summary.
+ */
+export function handleHealthCommand(repairLog) {
+  const recent = repairLog.getRecent(50);
+  const resolved = recent.filter(e => e.result === "resolved").length;
+  const unresolved = recent.filter(e => e.result === "unresolved" || e.result === "escalated").length;
+  const held = recent.filter(e => e.result === "held").length;
+
+  const lines = [];
+  lines.push(`Last 50 repairs: ${resolved} resolved, ${unresolved} unresolved, ${held} held`);
+  if (unresolved > 0) lines.push(`⚠ ${unresolved} unresolved issue(s) need attention`);
+  if (held > 0) lines.push(`📦 ${held} update(s) awaiting /approve`);
+  if (unresolved === 0 && held === 0) lines.push("All systems healthy.");
+  return lines.join("\n");
+}

package/src/daemon/updater.js

@@ -0,0 +1,85 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export function detectInstallType(projectRoot) {
+  return fs.existsSync(path.join(projectRoot, ".git")) ? "git" : "npm";
+}
+
+export function classifySemver(current, next) {
+  const [cMajor, cMinor, cPatch] = current.split(".").map(Number);
+  const [nMajor, nMinor, nPatch] = next.split(".").map(Number);
+  if (nMajor > cMajor) return "major";
+  if (nMinor > cMinor) return "minor";
+  if (nPatch > cPatch) return "patch";
+  return "none";
+}
+
+export function shouldAutoApply(target, semverClass) {
+  if (semverClass === "none") return false;
+  if (target === "nemoris") {
+    return semverClass === "patch" || semverClass === "minor";
+  }
+  return semverClass === "patch";
+}
+
+export function snapshotConfig(projectRoot) {
+  const configDir = path.join(projectRoot, "config");
+  const snapshot = {};
+  if (!fs.existsSync(configDir)) return snapshot;
+  for (const file of fs.readdirSync(configDir)) {
+    if (file.endsWith(".toml") || file.endsWith(".json")) {
+      snapshot[`config/${file}`] = fs.readFileSync(path.join(configDir, file), "utf-8");
+    }
+  }
+  return snapshot;
+}
+
+export function restoreConfig(projectRoot, snapshot) {
+  for (const [relPath, content] of Object.entries(snapshot)) {
+    const absPath = path.join(projectRoot, relPath);
+    fs.writeFileSync(absPath, content);
+  }
+}
+
+export function parseNpmOutdated(stdout) {
+  try {
+    const data = JSON.parse(stdout);
+    return Object.entries(data).map(([name, info]) => ({
+      name,
+      current: info.current,
+      latest: info.latest,
+      wanted: info.wanted,
+      target: "npm",
+      semverClass: classifySemver(info.current, info.latest)
+    }));
+  } catch {
+    return [];
+  }
+}
+
+export function buildUpdatePlan(updates) {
+  const autoApply = [];
+  const hold = [];
+  for (const u of updates) {
+    if (shouldAutoApply(u.target, u.semverClass || classifySemver(u.current, u.latest))) {
+      autoApply.push(u);
+    } else {
+      hold.push(u);
+    }
+  }
+  return { autoApply, hold };
+}
+
+export async function runSmokeTest({ healthProbes, localModelAvailable, runTestJob }) {
+  const probeResults = await healthProbes();
+  const failures = probeResults.filter(r => r.status === "failure");
+  if (failures.length > 0) return { passed: false, reason: "probe_failure", failures };
+
+  // Only run per-lane test job if local model is available (never cloud)
+  if (localModelAvailable && runTestJob) {
+    const jobResult = await runTestJob({ model: "local" });
+    if (!jobResult.success) return { passed: false, reason: "test_job_failure" };
+  }
+
+  return { passed: true };
+}

package/src/jobs/job-runner.js

@@ -0,0 +1,78 @@
+function nowIso() {
+  return new Date().toISOString();
+}
+
+export class JobRunner {
+  constructor({ memoryStore }) {
+    this.memoryStore = memoryStore;
+  }
+
+  async run(job, execute) {
+    const runId = `${job.id}:${Date.now()}`;
+    const agentId = job.agentId;
+
+    await this.memoryStore.appendEvent(agentId, {
+      title: `job:${job.id}:queued`,
+      content: `Run ${runId} queued`,
+      category: "job_state",
+      salience: 0.4
+    });
+
+    await this.memoryStore.saveCheckpoint(agentId, "latest", {
+      objective: job.taskType,
+      status: "running",
+      nextActions: [],
+      blockers: [],
+      runId
+    });
+
+    try {
+      const result = await execute({
+        runId,
+        budget: job.budget
+      });
+
+      await this.memoryStore.writeSummary(agentId, {
+        title: `job:${job.id}:summary`,
+        summary: result.summary,
+        content: result.output,
+        category: "job_summary",
+        salience: 0.72
+      });
+
+      await this.memoryStore.saveCheckpoint(agentId, "latest", {
+        objective: job.taskType,
+        status: "succeeded",
+        nextActions: result.nextActions || [],
+        blockers: []
+      });
+
+      return {
+        runId,
+        status: "succeeded",
+        result
+      };
+    } catch (error) {
+      await this.memoryStore.appendEvent(agentId, {
+        title: `job:${job.id}:failed`,
+        content: error.message,
+        category: "job_failure",
+        salience: 0.78
+      });
+
+      await this.memoryStore.saveCheckpoint(agentId, "latest", {
+        objective: job.taskType,
+        status: "failed",
+        nextActions: [],
+        blockers: [error.message],
+        failedAt: nowIso()
+      });
+
+      return {
+        runId,
+        status: "failed",
+        error: error.message
+      };
+    }
+  }
+}

package/src/mcp/consumer.js

@@ -0,0 +1,129 @@
+// src/mcp/consumer.js
+import { expandEnvRefs } from "../config/loader.js";
+import { McpClient } from "../tools/mcp-client.js";
+
+export class McpConsumer {
+  #clients = new Map();
+  #schemaCache = new Map();
+  #config;
+  #clientFactory;
+
+  constructor({ config, clientFactory }) {
+    this.#config = config;
+    this.#clientFactory = clientFactory || ((serverConfig) => new McpClient(serverConfig));
+  }
+
+  async ensureRunning(serverId) {
+    const existing = this.#clients.get(serverId);
+    if (existing && existing.isAlive()) return existing;
+
+    if (existing) {
+      this.#schemaCache.delete(serverId);
+    }
+
+    const serverConfig = this.#config.servers[serverId];
+    if (!serverConfig) throw new Error(`MCP server '${serverId}' not found in config`);
+
+    const resolvedEnv = {};
+    for (const [key, val] of Object.entries(serverConfig.env || {})) {
+      const raw = String(val);
+      const resolved = expandEnvRefs(raw);
+      const varMatch = raw.match(/\$\{([^}]+)\}/);
+      if (varMatch && !process.env[varMatch[1]]) {
+        console.warn(`[mcp:${serverId}] env var ${varMatch[1]} is not set`);
+      }
+      resolvedEnv[key] = resolved;
+    }
+
+    const client = this.#clientFactory({
+      command: serverConfig.command,
+      args: serverConfig.args || [],
+      env: resolvedEnv,
+      timeout: serverConfig.timeout || 30000,
+    });
+
+    await client.spawn();
+    this.#clients.set(serverId, client);
+    return client;
+  }
+
+  async callTool(serverId, toolName, args) {
+    let client;
+    try {
+      client = await this.ensureRunning(serverId);
+      return await client.callTool(toolName, args);
+    } catch (err) {
+      if (client && !client.isAlive()) {
+        this.#clients.delete(serverId);
+        const retryClient = await this.ensureRunning(serverId);
+        return await retryClient.callTool(toolName, args);
+      }
+      throw err;
+    }
+  }
+
+  async allSchemas() {
+    const schemas = [];
+    for (const serverId of Object.keys(this.#config.servers)) {
+      try {
+        const tools = await this.#getServerTools(serverId);
+        for (const tool of tools) {
+          schemas.push({
+            server: serverId,
+            name: `mcp:${serverId}.${tool.name}`,
+            description: tool.description || "",
+            inputSchema: tool.inputSchema || {},
+          });
+        }
+      } catch (err) {
+        console.warn(`[mcp:${serverId}] failed to start: ${err.message}`);
+      }
+    }
+    return schemas;
+  }
+
+  cachedSchemas() {
+    const schemas = [];
+    for (const [serverId, tools] of this.#schemaCache) {
+      for (const tool of tools) {
+        schemas.push({
+          server: serverId,
+          name: `mcp:${serverId}.${tool.name}`,
+          description: tool.description || "",
+          inputSchema: tool.inputSchema || {},
+        });
+      }
+    }
+    return schemas;
+  }
+
+  async shutdown() {
+    for (const [, client] of this.#clients) {
+      try {
+        client.kill();
+      } catch {
+        // Best-effort kill
+      }
+    }
+    this.#clients.clear();
+  }
+
+  healthSummary() {
+    const summary = [];
+    for (const serverId of Object.keys(this.#config.servers)) {
+      const client = this.#clients.get(serverId);
+      summary.push({ id: serverId, alive: Boolean(client?.isAlive()) });
+    }
+    return summary;
+  }
+
+  async #getServerTools(serverId) {
+    const cached = this.#schemaCache.get(serverId);
+    if (cached) return cached;
+
+    const client = await this.ensureRunning(serverId);
+    const tools = await client.listTools();
+    this.#schemaCache.set(serverId, tools);
+    return tools;
+  }
+}

package/src/memory/active-recall.js

@@ -0,0 +1,171 @@
+/**
+ * Active Recall — turn-aware memory scoring and tiered injection.
+ *
+ * Spec: docs/superpowers/specs/2026-03-16-interaction-layer-design.md § Pillar 1
+ */
+
+// ── Scoring ─────────────────────────────────────────────────────
+
+export function computeRecency(lastAccessedOrCreated, now = new Date()) {
+  const ts = new Date(lastAccessedOrCreated);
+  const daysSince = (now.getTime() - ts.getTime()) / (24 * 60 * 60 * 1000);
+  return 1 / (1 + daysSince * 0.1);
+}
+
+export function scoreCandidate({ similarity, topicRelevance, recency, confidence }) {
+  const hasTopicRelevance = topicRelevance > 0;
+  if (hasTopicRelevance) {
+    return (similarity * 0.5) + (topicRelevance * 0.3) + (recency * confidence * 0.2);
+  }
+  return (similarity * 0.7) + (recency * confidence * 0.3);
+}
+
+// ── Tier classification ─────────────────────────────────────────
+
+const FACT_THRESHOLD = 0.85;
+export const ASIDE_THRESHOLD = 0.70;
+
+export function classifyTier(score) {
+  if (score > FACT_THRESHOLD) return "fact";
+  if (score >= ASIDE_THRESHOLD) return "aside";
+  return "silent";
+}
+
+// ── Injection builder ───────────────────────────────────────────
+
+const CHARS_PER_TOKEN = 4;
+
+export function buildInjection(candidates, { tokenBudget = 2000 } = {}) {
+  let remainingChars = tokenBudget * CHARS_PER_TOKEN;
+  const facts = [];
+  const asides = [];
+  const silent = [];
+
+  const sorted = [...candidates].sort((a, b) => b.score - a.score);
+
+  for (const c of sorted) {
+    if (c.tier === "silent") { silent.push(c); continue; }
+    if (c.tier === "fact") {
+      const len = c.content.length;
+      if (len <= remainingChars) {
+        facts.push(c);
+        remainingChars -= len;
+      }
+    }
+  }
+
+  for (const c of sorted) {
+    if (c.tier === "aside") {
+      const len = c.content.length;
+      if (len <= remainingChars) {
+        asides.push(c);
+        remainingChars -= len;
+      }
+    }
+  }
+
+  return { facts, asides, silent };
+}
+
+// ── Orchestrator ────────────────────────────────────────────────
+
+export async function activeRecall({ inboundMessage, memoryStore, tokenBudget = 2000, topicRelevanceFn = null, contextWindow = 0 }) {
+  const budget = contextWindow > 0 ? Math.min(tokenBudget, Math.floor(contextWindow * 0.08)) : tokenBudget;
+
+  // Stage 1: Candidate retrieval (top 20)
+  // queryRetrievalCandidates(query, options) — positional args
+  const raw = memoryStore.queryRetrievalCandidates
+    ? memoryStore.queryRetrievalCandidates(inboundMessage, { limit: 20 })
+    : [];
+
+  // Unwrap nested shape: real store returns { item: { entry_id, content, ... }, embeddingSimilarity }
+  const candidates = raw.map((r) => ({
+    entryId: r.item?.entry_id || r.entryId,
+    content: r.item?.content || r.content,
+    summary: r.item?.summary || r.summary,
+    salience: r.item?.salience ?? r.salience ?? 0.5,
+    embeddingSimilarity: r.embeddingSimilarity ?? 0,
+    last_accessed: r.item?.last_accessed || r.last_accessed || null,
+    created_at: r.item?.timestamp || r.created_at,
+  }));
+
+  // Stage 2: Turn-aware scoring
+  const now = new Date();
+  const scored = candidates.map((c) => {
+    const similarity = c.embeddingSimilarity || c.salience || 0.5;
+    const topicRelevance = topicRelevanceFn ? topicRelevanceFn(inboundMessage, c) : 0;
+    const recency = computeRecency(c.last_accessed || c.created_at || now.toISOString(), now);
+    const confidence = 0.75; // Default — declared memory (MEMORY.md) injected separately at 1.0
+    const score = scoreCandidate({ similarity, topicRelevance, recency, confidence });
+    const tier = classifyTier(score);
+    return { ...c, score, tier };
+  });
+
+  // Stage 3: Tiered injection
+  const injection = buildInjection(scored, { tokenBudget: budget });
+
+  // Stage 4: Access tracking (score >= 0.70)
+  const accessedIds = scored.filter((c) => c.score >= ASIDE_THRESHOLD).map((c) => c.entryId);
+  if (accessedIds.length && memoryStore.updateAccessTime) {
+    memoryStore.updateAccessTime(accessedIds);
+  }
+
+  return injection;
+}
+
+// ── Write discipline ────────────────────────────────────────────
+
+const DEDUP_THRESHOLD = 0.95;
+const CONTRADICTION_LOW = 0.85;
+
+export class WriteBuffer {
+  constructor({ commitFn, similarityFn, updateFn, existingEntries = [] }) {
+    this._pending = [];
+    this._commitFn = commitFn;
+    this._similarityFn = similarityFn;
+    this._updateFn = updateFn || (() => {});
+    this._existingEntries = existingEntries;
+  }
+
+  add(entry) {
+    this._pending.push(entry);
+  }
+
+  flush() {
+    let committed = 0;
+    let deduped = 0;
+    const contradictions = [];
+
+    for (const entry of this._pending) {
+      let dominated = false;
+      for (const existing of this._existingEntries) {
+        const sim = this._similarityFn(entry.content, existing.content);
+        if (sim > DEDUP_THRESHOLD) {
+          this._updateFn(existing.entryId, entry.content);
+          deduped++;
+          dominated = true;
+          break;
+        }
+        if (sim >= CONTRADICTION_LOW && sim <= DEDUP_THRESHOLD) {
+          contradictions.push({
+            existingId: existing.entryId,
+            existingContent: existing.content,
+            newContent: entry.content,
+            similarity: sim,
+          });
+          dominated = true;
+          break;
+        }
+      }
+      if (!dominated) {
+        this._commitFn(entry);
+        committed++;
+      }
+    }
+
+    this._pending = [];
+    return { committed, deduped, contradictions };
+  }
+
+  get pending() { return this._pending; }
+}

package/src/memory/backend-manager.js

@@ -0,0 +1,97 @@
+import { FileMemoryBackend } from "./backends/file-backend.js";
+import { QmdMemoryBackend } from "./backends/qmd-backend.js";
+
+export class MemoryBackendManager {
+  constructor({ memoryStore, embeddingIndex, liveRoot }) {
+    this.fileBackend = new FileMemoryBackend({ memoryStore, embeddingIndex });
+    this.qmdBackend = new QmdMemoryBackend({ liveRoot });
+  }
+
+  defaultBackend() {
+    return this.fileBackend;
+  }
+
+  async queryCombined(agentId, query, options = {}) {
+    const limit = options.limit ?? 8;
+    const workspaceRoot = options.workspaceRoot || null;
+    const backendOrder = options.backendOrder || ["file"];
+    const qmdSupplementLimit = options.qmdSupplementLimit ?? 2;
+    const fileQuery = options.fileQuery || query;
+    const qmdQuery = options.qmdQuery || query;
+
+    const fileResult = await this.fileBackend.query(agentId, fileQuery, {
+      limit,
+      now: options.now,
+      retrievalBlend: options.retrievalBlend
+    });
+
+    let merged = [...fileResult.items];
+    let qmdResult = {
+      backend: "qmd",
+      available: false,
+      items: []
+    };
+
+    if (backendOrder.includes("qmd")) {
+      qmdResult = await this.qmdBackend.query(agentId, qmdQuery, {
+        workspaceRoot,
+        limit: qmdSupplementLimit
+      });
+
+      const qmdItems = qmdResult.items.map((item, index) => ({
+        type: "external",
+        category: "qmd_match",
+        title: item.title,
+        content: item.snippet,
+        summary: item.filepath,
+        reason: "Matched through local QMD FTS retrieval.",
+        score: Number((0.35 - index * 0.03).toFixed(4)),
+        sourceBackend: "qmd",
+        candidateSource: "qmd",
+        lexicalScore: 0,
+        embeddingSimilarity: 0,
+        embeddingFreshness: "not_applicable",
+        retrievalSources: ["qmd"]
+      }));
+
+      merged = [...merged, ...qmdItems];
+    }
+
+    return {
+      items: merged.slice(0, limit),
+      backends: {
+        file: {
+          available: fileResult.available,
+          totalCandidates: fileResult.totalCandidates ?? fileResult.items.length,
+          query: fileQuery
+        },
+        qmd: {
+          available: qmdResult.available,
+          totalCandidates: qmdResult.items.length,
+          stats: qmdResult.stats || null,
+          query: qmdQuery
+        }
+      },
+      retrieval: fileResult.retrieval || null
+    };
+  }
+
+  async inspect(agentId, workspaceRoot = null) {
+    const [file, qmd] = await Promise.all([
+      this.fileBackend.inspect(agentId),
+      this.qmdBackend.inspect(agentId, workspaceRoot)
+    ]);
+
+    return {
+      defaultBackend: file.kind,
+      backends: [file, qmd]
+    };
+  }
+
+  async queryQmd(agentId, query, workspaceRoot = null, limit = 5) {
+    return this.qmdBackend.query(agentId, query, {
+      workspaceRoot,
+      limit
+    });
+  }
+}

package/src/memory/backends/file-backend.js

@@ -0,0 +1,38 @@
+export class FileMemoryBackend {
+  constructor({ memoryStore, embeddingIndex = null } = {}) {
+    this.kind = "file";
+    this.memoryStore = memoryStore;
+    this.embeddingIndex = embeddingIndex;
+  }
+
+  async query(agentId, query, options = {}) {
+    const result = await this.memoryStore.query(agentId, query, {
+      ...options,
+      embeddingIndex: this.embeddingIndex
+    });
+    return {
+      backend: this.kind,
+      available: true,
+      items: result.items.map((item) => ({
+        ...item,
+        sourceBackend: this.kind
+      })),
+      totalCandidates: result.totalCandidates,
+      retrieval: result.retrieval || null
+    };
+  }
+
+  async listAll(agentId) {
+    return this.memoryStore.listAll(agentId);
+  }
+
+  async inspect(agentId) {
+    const items = await this.memoryStore.listAll(agentId);
+    return {
+      kind: this.kind,
+      available: true,
+      itemCount: items.length,
+      embeddingIndexConfigured: Boolean(this.embeddingIndex)
+    };
+  }
+}