nemoris 0.1.0 → 0.1.2

package/src/runtime/failure-ping.js

@@ -1,67 +1,67 @@
-/**
- * Sends a failure ping to the Telegram operator when a job fails,
- * and a user-friendly error message to the originating chat.
- * Never throws — all errors are caught and logged internally.
- */
-
-function isRetryableError(err) {
-  const msg = (err?.message || "").toLowerCase();
-  const status = err?.status || err?.statusCode || 0;
-  return status >= 500 || err?.code === "ETIMEDOUT" ||
-    msg.includes("etimedout") || msg.includes("timeout") || msg.includes("fetch failed");
-}
-
-/**
- * @param {object} job
- * @param {Error} error
- * @param {object} options
- * @param {string} options.botToken
- * @param {string} options.operatorChatId
- * @param {Function} [options.fetchImpl]
- */
-export async function sendFailurePing(job, error, options = {}) {
-  const { botToken, operatorChatId, fetchImpl } = options;
-
-  if (!botToken) return;
-  if (job.source === "completion_ping") return;
-
-  const fetchFn = fetchImpl || globalThis.fetch;
-
-  // Send user-friendly error to the originating chat
-  if (job.chat_id) {
-    const isTurnTimeout = error?.message === "turn_timeout";
-    let userMsg;
-    if (isTurnTimeout) {
-      userMsg = "⚠️ Turn timed out after 2 minutes. Try again or /stop to reset.";
-    } else if (isRetryableError(error)) {
-      userMsg = "⚠️ Provider hiccup — couldn't complete that. Try again in a moment.";
-    } else {
-      const snippet = (error?.message || "unknown error").slice(0, 120);
-      userMsg = `⚠️ Something went wrong: ${snippet}. Try again or /stop to reset.`;
-    }
-    try {
-      await fetchFn(`https://api.telegram.org/bot${botToken}/sendMessage`, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ chat_id: job.chat_id, text: userMsg }),
-      });
-    } catch (sendErr) {
-      console.error(JSON.stringify({ service: "error_delivery", event: "failed", error: sendErr.message, jobId: job.job_id }));
-    }
-  }
-
-  // Operator notification (detailed)
-  if (operatorChatId) {
-    const errorSnippet = (error?.message || String(error)).slice(0, 120);
-    const text = `⚠️ Job failed\nAgent: ${job.agent_id}\nJob: ${job.job_id}\nError: ${errorSnippet}\nSource: ${job.source}`;
-    try {
-      await fetchFn(`https://api.telegram.org/bot${botToken}/sendMessage`, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ chat_id: operatorChatId, text }),
-      });
-    } catch (sendErr) {
-      console.error(JSON.stringify({ service: "failure_ping", error: sendErr.message, jobId: job.job_id }));
-    }
-  }
-}
+/**
+ * Sends a failure ping to the Telegram operator when a job fails,
+ * and a user-friendly error message to the originating chat.
+ * Never throws — all errors are caught and logged internally.
+ */
+
+function isRetryableError(err) {
+  const msg = (err?.message || "").toLowerCase();
+  const status = err?.status || err?.statusCode || 0;
+  return status >= 500 || err?.code === "ETIMEDOUT" ||
+    msg.includes("etimedout") || msg.includes("timeout") || msg.includes("fetch failed");
+}
+
+/**
+ * @param {object} job
+ * @param {Error} error
+ * @param {object} options
+ * @param {string} options.botToken
+ * @param {string} options.operatorChatId
+ * @param {Function} [options.fetchImpl]
+ */
+export async function sendFailurePing(job, error, options = {}) {
+  const { botToken, operatorChatId, fetchImpl } = options;
+
+  if (!botToken) return;
+  if (job.source === "completion_ping") return;
+
+  const fetchFn = fetchImpl || globalThis.fetch;
+
+  // Send user-friendly error to the originating chat
+  if (job.chat_id) {
+    const isTurnTimeout = error?.message === "turn_timeout";
+    let userMsg;
+    if (isTurnTimeout) {
+      userMsg = "⚠️ Turn timed out after 2 minutes. Try again or /stop to reset.";
+    } else if (isRetryableError(error)) {
+      userMsg = "⚠️ Provider hiccup — couldn't complete that. Try again in a moment.";
+    } else {
+      const snippet = (error?.message || "unknown error").slice(0, 120);
+      userMsg = `⚠️ Something went wrong: ${snippet}. Try again or /stop to reset.`;
+    }
+    try {
+      await fetchFn(`https://api.telegram.org/bot${botToken}/sendMessage`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ chat_id: job.chat_id, text: userMsg }),
+      });
+    } catch (sendErr) {
+      console.error(JSON.stringify({ service: "error_delivery", event: "failed", error: sendErr.message, jobId: job.job_id }));
+    }
+  }
+
+  // Operator notification (detailed)
+  if (operatorChatId) {
+    const errorSnippet = (error?.message || String(error)).slice(0, 120);
+    const text = `⚠️ Job failed\nAgent: ${job.agent_id}\nJob: ${job.job_id}\nError: ${errorSnippet}\nSource: ${job.source}`;
+    try {
+      await fetchFn(`https://api.telegram.org/bot${botToken}/sendMessage`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ chat_id: operatorChatId, text }),
+      });
+    } catch (sendErr) {
+      console.error(JSON.stringify({ service: "failure_ping", error: sendErr.message, jobId: job.job_id }));
+    }
+  }
+}

package/src/runtime/flows.js

@@ -1,83 +1,83 @@
-/**
- * Cross-Pillar Flows — coordinates seams between pillars.
- */
-
-export async function flowTaskEscalationToOperator(task, deliveryAck, telegramSend, { chatId, retryDelays } = {}) {
-  const chain = JSON.parse(task.escalation_chain);
-  const target = chain[task.escalation_index] || "operator";
-  if (target !== "operator") {
-    throw new Error(`Flow 1 only handles operator escalation, got target: ${target}`);
-  }
-  const body = [
-    `${task.assigned_agent} timed out on: ${task.objective}`,
-    task.error_slot ? `Error: ${task.error_slot}` : null,
-    `Result so far: ${task.result_slot || "none"}`,
-    "Want me to intervene?",
-  ].filter(Boolean).join("\n");
-  return deliveryAck.sendWithGuarantee({
-    sourceAgent: task.owner_agent,
-    criticality: "decision_required",
-    payload: { text: body },
-    chatId,
-    correlationId: task.envelope_id,
-    sendFn: (payload) => telegramSend({ text: payload.text, chatId }),
-    retryDelays,
-  });
-}
-
-export async function flowTaskCompletionToMemory(task, writeBuffer) {
-  const summary = task.result_slot
-    ? (typeof task.result_slot === "string" ? task.result_slot : JSON.stringify(task.result_slot))
-    : "no result";
-  const content = `Task "${task.objective}" completed by ${task.assigned_agent}: ${summary.slice(0, 500)}`;
-  writeBuffer.add({
-    content,
-    confidence: 0.85,
-    sourceAgent: task.assigned_agent,
-    category: "task_result",
-    type: "fact",
-  });
-}
-
-export async function flowDecisionResponseToTask(envelope, operatorMessage, taskContract, { resolveAgent, callerAgent } = {}) {
-  const task = taskContract.db.prepare(
-    "SELECT * FROM tasks WHERE envelope_id = ?"
-  ).get(envelope.correlation_id);
-  if (!task) return { action: "unstructured", reason: "no linked task" };
-
-  const msg = operatorMessage.toLowerCase();
-
-  if (msg.includes("retry")) {
-    const newTask = taskContract.createTask({
-      ownerAgent: task.owner_agent,
-      assignedAgent: task.assigned_agent,
-      objective: task.objective,
-      deadlineMinutes: Math.max(10, Math.round((new Date(task.deadline_at) - new Date(task.created_at)) / 60000)),
-    });
-    return { action: "retry", newTaskId: newTask.task_id, originalTaskId: task.task_id };
-  }
-
-  if (msg.includes("cancel")) {
-    try {
-      taskContract.transition(task.task_id, "cancelled", task.owner_agent);
-    } catch { /* may not be in cancellable state */ }
-    return { action: "cancel", taskId: task.task_id };
-  }
-
-  if (msg.includes("reassign")) {
-    const match = operatorMessage.match(/reassign(?:\s+to)?\s+(\w+)/i);
-    const targetName = match?.[1];
-    if (targetName && resolveAgent && resolveAgent(targetName)) {
-      const newTask = taskContract.createTask({
-        ownerAgent: task.owner_agent,
-        assignedAgent: targetName,
-        objective: task.objective,
-        deadlineMinutes: Math.max(10, Math.round((new Date(task.deadline_at) - new Date(task.created_at)) / 60000)),
-      });
-      return { action: "reassign", newTaskId: newTask.task_id, assignedAgent: targetName };
-    }
-    return { action: "unstructured", reason: `Could not resolve agent: ${targetName}` };
-  }
-
-  return { action: "unstructured", message: operatorMessage };
-}
+/**
+ * Cross-Pillar Flows — coordinates seams between pillars.
+ */
+
+export async function flowTaskEscalationToOperator(task, deliveryAck, telegramSend, { chatId, retryDelays } = {}) {
+  const chain = JSON.parse(task.escalation_chain);
+  const target = chain[task.escalation_index] || "operator";
+  if (target !== "operator") {
+    throw new Error(`Flow 1 only handles operator escalation, got target: ${target}`);
+  }
+  const body = [
+    `${task.assigned_agent} timed out on: ${task.objective}`,
+    task.error_slot ? `Error: ${task.error_slot}` : null,
+    `Result so far: ${task.result_slot || "none"}`,
+    "Want me to intervene?",
+  ].filter(Boolean).join("\n");
+  return deliveryAck.sendWithGuarantee({
+    sourceAgent: task.owner_agent,
+    criticality: "decision_required",
+    payload: { text: body },
+    chatId,
+    correlationId: task.envelope_id,
+    sendFn: (payload) => telegramSend({ text: payload.text, chatId }),
+    retryDelays,
+  });
+}
+
+export async function flowTaskCompletionToMemory(task, writeBuffer) {
+  const summary = task.result_slot
+    ? (typeof task.result_slot === "string" ? task.result_slot : JSON.stringify(task.result_slot))
+    : "no result";
+  const content = `Task "${task.objective}" completed by ${task.assigned_agent}: ${summary.slice(0, 500)}`;
+  writeBuffer.add({
+    content,
+    confidence: 0.85,
+    sourceAgent: task.assigned_agent,
+    category: "task_result",
+    type: "fact",
+  });
+}
+
+export async function flowDecisionResponseToTask(envelope, operatorMessage, taskContract, { resolveAgent, callerAgent } = {}) {
+  const task = taskContract.db.prepare(
+    "SELECT * FROM tasks WHERE envelope_id = ?"
+  ).get(envelope.correlation_id);
+  if (!task) return { action: "unstructured", reason: "no linked task" };
+
+  const msg = operatorMessage.toLowerCase();
+
+  if (msg.includes("retry")) {
+    const newTask = taskContract.createTask({
+      ownerAgent: task.owner_agent,
+      assignedAgent: task.assigned_agent,
+      objective: task.objective,
+      deadlineMinutes: Math.max(10, Math.round((new Date(task.deadline_at) - new Date(task.created_at)) / 60000)),
+    });
+    return { action: "retry", newTaskId: newTask.task_id, originalTaskId: task.task_id };
+  }
+
+  if (msg.includes("cancel")) {
+    try {
+      taskContract.transition(task.task_id, "cancelled", task.owner_agent);
+    } catch { /* may not be in cancellable state */ }
+    return { action: "cancel", taskId: task.task_id };
+  }
+
+  if (msg.includes("reassign")) {
+    const match = operatorMessage.match(/reassign(?:\s+to)?\s+(\w+)/i);
+    const targetName = match?.[1];
+    if (targetName && resolveAgent && resolveAgent(targetName)) {
+      const newTask = taskContract.createTask({
+        ownerAgent: task.owner_agent,
+        assignedAgent: targetName,
+        objective: task.objective,
+        deadlineMinutes: Math.max(10, Math.round((new Date(task.deadline_at) - new Date(task.created_at)) / 60000)),
+      });
+      return { action: "reassign", newTaskId: newTask.task_id, assignedAgent: targetName };
+    }
+    return { action: "unstructured", reason: `Could not resolve agent: ${targetName}` };
+  }
+
+  return { action: "unstructured", message: operatorMessage };
+}

package/src/runtime/guards.js

@@ -1,45 +1,45 @@
-const DEFAULT_PROVIDER_MODE = {
-  allowProviderExecution: false,
-  allowRemoteProviders: false,
-  allowedJobIds: ["heartbeat-check", "workspace-health", "memory-rollup"],
-  allowedLanes: ["local_cheap", "local_report", "report_fallback_lowcost"],
-  requireHealthyProvider: true
-};
-
-function readFlag(name) {
-  const raw = process.env[name];
-  return raw === "1" || raw === "true";
-}
-
-export function getProviderModePolicy() {
-  return {
-    ...DEFAULT_PROVIDER_MODE,
-    allowProviderExecution: readFlag("NEMORIS_ALLOW_PROVIDER_MODE"),
-    allowRemoteProviders: readFlag("NEMORIS_ALLOW_REMOTE_PROVIDER_MODE")
-  };
-}
-
-export function assertProviderExecutionAllowed({ jobId, modelLane, providerId, interactive = false }) {
-  const policy = getProviderModePolicy();
-
-  if (!policy.allowProviderExecution) {
-    throw new Error("Provider mode disabled. Set NEMORIS_ALLOW_PROVIDER_MODE=1 to enable guarded shadow execution.");
-  }
-
-  // Interactive jobs (Telegram, agent dispatch) bypass job-id and lane allowlists
-  if (!interactive) {
-    if (!policy.allowedJobIds.includes(jobId)) {
-      throw new Error(`Provider mode not allowed for job ${jobId}.`);
-    }
-
-    if (!policy.allowedLanes.includes(modelLane)) {
-      throw new Error(`Provider mode not allowed for lane ${modelLane}.`);
-    }
-  }
-
-  if (providerId !== "ollama" && !policy.allowRemoteProviders) {
-    throw new Error(`Remote provider execution blocked for ${providerId}. Set NEMORIS_ALLOW_REMOTE_PROVIDER_MODE=1 to override.`);
-  }
-
-  return policy;
-}
+const DEFAULT_PROVIDER_MODE = {
+  allowProviderExecution: false,
+  allowRemoteProviders: false,
+  allowedJobIds: ["heartbeat-check", "workspace-health", "memory-rollup"],
+  allowedLanes: ["local_cheap", "local_report", "report_fallback_lowcost"],
+  requireHealthyProvider: true
+};
+
+function readFlag(name) {
+  const raw = process.env[name];
+  return raw === "1" || raw === "true";
+}
+
+export function getProviderModePolicy() {
+  return {
+    ...DEFAULT_PROVIDER_MODE,
+    allowProviderExecution: readFlag("NEMORIS_ALLOW_PROVIDER_MODE"),
+    allowRemoteProviders: readFlag("NEMORIS_ALLOW_REMOTE_PROVIDER_MODE")
+  };
+}
+
+export function assertProviderExecutionAllowed({ jobId, modelLane, providerId, interactive = false }) {
+  const policy = getProviderModePolicy();
+
+  if (!policy.allowProviderExecution) {
+    throw new Error("Provider mode disabled. Set NEMORIS_ALLOW_PROVIDER_MODE=1 to enable guarded shadow execution.");
+  }
+
+  // Interactive jobs (Telegram, agent dispatch) bypass job-id and lane allowlists
+  if (!interactive) {
+    if (!policy.allowedJobIds.includes(jobId)) {
+      throw new Error(`Provider mode not allowed for job ${jobId}.`);
+    }
+
+    if (!policy.allowedLanes.includes(modelLane)) {
+      throw new Error(`Provider mode not allowed for lane ${modelLane}.`);
+    }
+  }
+
+  if (providerId !== "ollama" && !policy.allowRemoteProviders) {
+    throw new Error(`Remote provider execution blocked for ${providerId}. Set NEMORIS_ALLOW_REMOTE_PROVIDER_MODE=1 to override.`);
+  }
+
+  return policy;
+}

package/src/runtime/handoff.js

@@ -1,51 +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(", ")}`);
-  }
-}
+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

@@ -1,28 +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;
-}
+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;
+}