nemoris 0.1.0

package/src/runtime/handoff.js

@@ -0,0 +1,51 @@
+const VALID_STATUSES = ["succeeded", "failed", "halted", "escalated"];
+const REQUIRED_HANDOFF_FIELDS = ["fromAgent", "toAgent", "jobId", "routingReason", "parentRunId"];
+const REQUIRED_RESULT_FIELDS = ["status", "agentId", "runId", "parentRunId"];
+
+export function buildHandoffPacket({ fromAgent, toAgent, jobId, skill, routingReason, parentRunId, budget = {}, artifacts = [] }) {
+  const packet = {
+    handoff: Object.freeze({
+      fromAgent,
+      toAgent,
+      jobId,
+      skill: skill || null,
+      routingReason,
+      parentRunId,
+      budget: Object.freeze({ ...budget }),
+      artifacts: Object.freeze([...artifacts]),
+    }),
+  };
+  Object.freeze(packet);
+  return packet;
+}
+
+export function buildResultPacket({ status, agentId, runId, parentRunId, result = {}, toolsUsed = [], tokenUsage = {}, evalScore = null, concerns = [] }) {
+  const packet = Object.freeze({
+    status,
+    agentId,
+    runId,
+    parentRunId,
+    result: Object.freeze({ ...result }),
+    toolsUsed: Object.freeze([...toolsUsed]),
+    tokenUsage: Object.freeze({ ...tokenUsage }),
+    evalScore,
+    concerns: Object.freeze([...concerns]),
+  });
+  return packet;
+}
+
+export function validateHandoffPacket(packet) {
+  if (!packet?.handoff) throw new Error("Handoff packet missing 'handoff' field");
+  for (const field of REQUIRED_HANDOFF_FIELDS) {
+    if (!packet.handoff[field]) throw new Error(`Handoff packet missing required field: ${field}`);
+  }
+}
+
+export function validateResultPacket(packet) {
+  for (const field of REQUIRED_RESULT_FIELDS) {
+    if (!packet[field]) throw new Error(`Result packet missing required field: ${field}`);
+  }
+  if (!VALID_STATUSES.includes(packet.status)) {
+    throw new Error(`Invalid result status: ${packet.status}. Must be one of: ${VALID_STATUSES.join(", ")}`);
+  }
+}

package/src/runtime/identity-cache.js

@@ -0,0 +1,28 @@
+const CACHE = new Map(); // key → { value, expiresAt }
+const DEFAULT_TTL_MS = Number(process.env.NEMORIS_IDENTITY_CACHE_TTL_MS) || 5 * 60 * 1000; // 5 minutes
+
+export function getCached(key) {
+  const entry = CACHE.get(key);
+  if (!entry) return null;
+  if (Date.now() > entry.expiresAt) {
+    CACHE.delete(key);
+    return null;
+  }
+  return entry.value;
+}
+
+export function setCached(key, value, ttlMs = DEFAULT_TTL_MS) {
+  CACHE.set(key, { value, expiresAt: Date.now() + ttlMs });
+}
+
+export function invalidateCache(key) {
+  CACHE.delete(key);
+}
+
+export function clearCache() {
+  CACHE.clear();
+}
+
+export function cacheSize() {
+  return CACHE.size;
+}

package/src/runtime/improvement-engine.js

@@ -0,0 +1,109 @@
+import { writeFile, readFile, readdir, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+
+const DEFAULT_THRESHOLDS = {
+  scoreDrop: 0.20,
+  maxRetunesPerDay: 3,
+  budgetIncreaseRatio: 0.15,
+  budgetMaxMultiplier: 2,
+};
+
+export class ImprovementEngine {
+  #stateRoot;
+  #thresholds;
+
+  constructor({ stateRoot, ...overrides } = {}) {
+    this.#stateRoot = stateRoot;
+    this.#thresholds = { ...DEFAULT_THRESHOLDS, ...overrides };
+  }
+
+  async check(jobId, { evalScore, rollingAverage, runArtifact, toolFailures = [], budgetExceeded = false, contractFailures = [] }) {
+    const actions = [];
+
+    const todayCount = await this.#countTodaysTunings(jobId);
+    if (todayCount >= this.#thresholds.maxRetunesPerDay) return actions;
+
+    if (rollingAverage > 0 && (rollingAverage - evalScore) > this.#thresholds.scoreDrop) {
+      actions.push({ trigger: "eval_score_drop", evalDelta: evalScore - rollingAverage, targetJob: jobId });
+    }
+
+    if (toolFailures.length > 0) {
+      actions.push({ trigger: "tool_failure", tools: toolFailures, targetJob: jobId });
+    }
+
+    if (budgetExceeded) {
+      actions.push({ trigger: "budget_exceeded", targetJob: jobId });
+    }
+
+    if (contractFailures.length > 0) {
+      actions.push({ trigger: "contract_failure", fields: contractFailures, targetJob: jobId });
+    }
+
+    for (const action of actions) {
+      await this.#createImprovementJob(jobId, action, runArtifact);
+    }
+
+    return actions;
+  }
+
+  async #createImprovementJob(jobId, action, runArtifact) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const id = `improve-${jobId}-${timestamp}`;
+    const jobsDir = join(this.#stateRoot, "improvement-jobs");
+    await mkdir(jobsDir, { recursive: true });
+
+    const manifest = [
+      `[job]`,
+      `id = "${id}"`,
+      `agent_id = "ops"`,
+      `skill = "self_improvement"`,
+      `model_lane = "local_cheap"`,
+      `schedule = "once"`,
+      `priority = "low"`,
+      ``,
+      `[job.context]`,
+      `trigger = "${action.trigger}"`,
+      `target_job = "${jobId}"`,
+      `eval_delta = ${action.evalDelta || 0}`,
+      `run_artifact = "${runArtifact || ""}"`,
+      `current_tunings = "state/tunings/${jobId}/"`,
+    ].join("\n");
+
+    await writeFile(join(jobsDir, `${id}.toml`), manifest);
+  }
+
+  async #countTodaysTunings(jobId) {
+    const tuningsDir = join(this.#stateRoot, "tunings", jobId);
+    try {
+      const files = await readdir(tuningsDir);
+      const today = new Date().toISOString().slice(0, 10);
+      let count = 0;
+      for (const file of files) {
+        try {
+          const content = JSON.parse(await readFile(join(tuningsDir, file), "utf8"));
+          if (content.timestamp && content.timestamp.startsWith(today)) count++;
+        } catch { /* skip non-JSON */ }
+      }
+      return count;
+    } catch {
+      return 0;
+    }
+  }
+
+  async loadTunings(jobId) {
+    const tuningsDir = join(this.#stateRoot, "tunings", jobId);
+    try {
+      const files = await readdir(tuningsDir);
+      const tunings = [];
+      for (const file of files) {
+        if (!file.endsWith(".json")) continue;
+        try {
+          tunings.push(JSON.parse(await readFile(join(tuningsDir, file), "utf8")));
+        } catch { /* skip */ }
+      }
+      return tunings;
+    } catch {
+      return [];
+    }
+  }
+}