nemoris 0.1.0 → 0.1.2

package/src/runtime/task-contract.js

@@ -1,140 +1,140 @@
-import { ulid } from "./ulid.js";
-
-const VALID_TRANSITIONS = {
-  created: ["accepted", "rejected"],
-  accepted: ["running", "rejected"],
-  running: ["completed", "failed", "cancelled", "timed_out"],
-  timed_out: ["escalated"],
-};
-
-export class TaskContract {
-  constructor(db, envelopeStore) {
-    this.db = db;
-    this.envelopes = envelopeStore;
-    this._ensureSchema();
-  }
-
-  _ensureSchema() {
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS tasks (
-        task_id           TEXT PRIMARY KEY,
-        envelope_id       TEXT NOT NULL,
-        owner_agent       TEXT NOT NULL,
-        assigned_agent    TEXT NOT NULL,
-        status            TEXT NOT NULL DEFAULT 'created',
-        objective         TEXT NOT NULL,
-        deadline_at       TEXT NOT NULL,
-        result_slot       TEXT,
-        error_slot        TEXT,
-        escalation_chain  TEXT NOT NULL,
-        escalation_index  INTEGER NOT NULL DEFAULT 0,
-        created_at        TEXT NOT NULL,
-        updated_at        TEXT NOT NULL,
-        FOREIGN KEY (envelope_id) REFERENCES envelopes(id)
-      );
-      CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
-      CREATE INDEX IF NOT EXISTS idx_tasks_assigned ON tasks(assigned_agent);
-      CREATE INDEX IF NOT EXISTS idx_tasks_deadline ON tasks(deadline_at);
-    `);
-  }
-
-  createTask({ ownerAgent, assignedAgent, objective, deadlineMinutes, escalationChain = ["assigned", "owner", "operator"] }) {
-    const taskId = ulid();
-    const now = new Date();
-    const deadlineAt = new Date(now.getTime() + deadlineMinutes * 60 * 1000).toISOString();
-    const envelope = this.envelopes.create({
-      sourceAgent: ownerAgent,
-      criticality: "result",
-      payloadType: "task",
-      payload: { objective, assignedAgent, deadlineMinutes },
-    });
-    this.db.prepare(`
-      INSERT INTO tasks (task_id, envelope_id, owner_agent, assigned_agent, status, objective, deadline_at, escalation_chain, escalation_index, created_at, updated_at)
-      VALUES (?, ?, ?, ?, 'created', ?, ?, ?, 0, ?, ?)
-    `).run(taskId, envelope.id, ownerAgent, assignedAgent, objective.slice(0, 500), deadlineAt, JSON.stringify(escalationChain), now.toISOString(), now.toISOString());
-    return this.get(taskId);
-  }
-
-  get(taskId) {
-    return this.db.prepare("SELECT * FROM tasks WHERE task_id = ?").get(taskId) || null;
-  }
-
-  transition(taskId, newStatus, callerAgent, { result, error } = {}) {
-    const task = this.get(taskId);
-    if (!task) throw new Error(`Task ${taskId} not found`);
-    const allowed = VALID_TRANSITIONS[task.status];
-    if (!allowed || !allowed.includes(newStatus)) {
-      throw new Error(`Invalid transition: ${task.status} → ${newStatus}`);
-    }
-    // Permission checks
-    if (newStatus === "cancelled" && callerAgent !== task.owner_agent) {
-      throw new Error("Only owner can cancel a task");
-    }
-    const assignedOnly = ["accepted", "running", "completed", "failed", "rejected"];
-    if (assignedOnly.includes(newStatus) && callerAgent !== task.assigned_agent) {
-      throw new Error(`Only assigned agent can transition to ${newStatus}`);
-    }
-    const now = new Date().toISOString();
-    const updates = { status: newStatus, updated_at: now };
-    if (result !== undefined) {
-      updates.result_slot = typeof result === "string" ? result : JSON.stringify(result);
-      if (updates.result_slot.length > 4000) {
-        updates.result_slot = JSON.stringify({
-          ledger_ref: `overflow-${taskId}`,
-          summary: updates.result_slot.slice(0, 200),
-        });
-      }
-    }
-    if (error !== undefined) {
-      updates.error_slot = typeof error === "string" ? error : JSON.stringify(error);
-    }
-    const setClauses = Object.keys(updates).map((k) => `${k} = ?`).join(", ");
-    const values = [...Object.values(updates), taskId];
-    this.db.prepare(`UPDATE tasks SET ${setClauses} WHERE task_id = ?`).run(...values);
-    return this.get(taskId);
-  }
-
-  listByStatus(status) {
-    return this.db.prepare("SELECT * FROM tasks WHERE status = ? ORDER BY created_at DESC").all(status);
-  }
-
-  listTimedOut() {
-    const now = new Date().toISOString();
-    return this.db.prepare("SELECT * FROM tasks WHERE status = 'running' AND deadline_at < ?").all(now);
-  }
-
-  sweepTimedOutTasks() {
-    const now = new Date().toISOString();
-    const overdue = this.db.prepare("SELECT * FROM tasks WHERE status = 'running' AND deadline_at < ?").all(now);
-    for (const task of overdue) {
-      this.db.prepare("UPDATE tasks SET status = 'timed_out', updated_at = ? WHERE task_id = ?").run(now, task.task_id);
-    }
-    return overdue;
-  }
-
-  advanceEscalation(taskId) {
-    const task = this.get(taskId);
-    if (!task) throw new Error(`Task ${taskId} not found`);
-    if (!["timed_out", "escalated"].includes(task.status)) {
-      throw new Error(`Cannot escalate task in status: ${task.status}`);
-    }
-    const chain = JSON.parse(task.escalation_chain);
-    const newIndex = task.escalation_index + 1;
-    this.db.prepare("UPDATE tasks SET escalation_index = ?, updated_at = ? WHERE task_id = ?")
-      .run(newIndex, new Date().toISOString(), taskId);
-    if (newIndex >= chain.length) {
-      this.db.prepare("UPDATE tasks SET status = 'escalated', updated_at = ? WHERE task_id = ?")
-        .run(new Date().toISOString(), taskId);
-    }
-    return { escalationIndex: newIndex, target: chain[newIndex] || null, exhausted: newIndex >= chain.length };
-  }
-
-  getInbox() {
-    return this.db.prepare(`
-      SELECT * FROM tasks
-      WHERE status IN ('timed_out', 'escalated')
-      AND escalation_index >= json_array_length(escalation_chain)
-      ORDER BY created_at DESC
-    `).all();
-  }
-}
+import { ulid } from "./ulid.js";
+
+const VALID_TRANSITIONS = {
+  created: ["accepted", "rejected"],
+  accepted: ["running", "rejected"],
+  running: ["completed", "failed", "cancelled", "timed_out"],
+  timed_out: ["escalated"],
+};
+
+export class TaskContract {
+  constructor(db, envelopeStore) {
+    this.db = db;
+    this.envelopes = envelopeStore;
+    this._ensureSchema();
+  }
+
+  _ensureSchema() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS tasks (
+        task_id           TEXT PRIMARY KEY,
+        envelope_id       TEXT NOT NULL,
+        owner_agent       TEXT NOT NULL,
+        assigned_agent    TEXT NOT NULL,
+        status            TEXT NOT NULL DEFAULT 'created',
+        objective         TEXT NOT NULL,
+        deadline_at       TEXT NOT NULL,
+        result_slot       TEXT,
+        error_slot        TEXT,
+        escalation_chain  TEXT NOT NULL,
+        escalation_index  INTEGER NOT NULL DEFAULT 0,
+        created_at        TEXT NOT NULL,
+        updated_at        TEXT NOT NULL,
+        FOREIGN KEY (envelope_id) REFERENCES envelopes(id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+      CREATE INDEX IF NOT EXISTS idx_tasks_assigned ON tasks(assigned_agent);
+      CREATE INDEX IF NOT EXISTS idx_tasks_deadline ON tasks(deadline_at);
+    `);
+  }
+
+  createTask({ ownerAgent, assignedAgent, objective, deadlineMinutes, escalationChain = ["assigned", "owner", "operator"] }) {
+    const taskId = ulid();
+    const now = new Date();
+    const deadlineAt = new Date(now.getTime() + deadlineMinutes * 60 * 1000).toISOString();
+    const envelope = this.envelopes.create({
+      sourceAgent: ownerAgent,
+      criticality: "result",
+      payloadType: "task",
+      payload: { objective, assignedAgent, deadlineMinutes },
+    });
+    this.db.prepare(`
+      INSERT INTO tasks (task_id, envelope_id, owner_agent, assigned_agent, status, objective, deadline_at, escalation_chain, escalation_index, created_at, updated_at)
+      VALUES (?, ?, ?, ?, 'created', ?, ?, ?, 0, ?, ?)
+    `).run(taskId, envelope.id, ownerAgent, assignedAgent, objective.slice(0, 500), deadlineAt, JSON.stringify(escalationChain), now.toISOString(), now.toISOString());
+    return this.get(taskId);
+  }
+
+  get(taskId) {
+    return this.db.prepare("SELECT * FROM tasks WHERE task_id = ?").get(taskId) || null;
+  }
+
+  transition(taskId, newStatus, callerAgent, { result, error } = {}) {
+    const task = this.get(taskId);
+    if (!task) throw new Error(`Task ${taskId} not found`);
+    const allowed = VALID_TRANSITIONS[task.status];
+    if (!allowed || !allowed.includes(newStatus)) {
+      throw new Error(`Invalid transition: ${task.status} → ${newStatus}`);
+    }
+    // Permission checks
+    if (newStatus === "cancelled" && callerAgent !== task.owner_agent) {
+      throw new Error("Only owner can cancel a task");
+    }
+    const assignedOnly = ["accepted", "running", "completed", "failed", "rejected"];
+    if (assignedOnly.includes(newStatus) && callerAgent !== task.assigned_agent) {
+      throw new Error(`Only assigned agent can transition to ${newStatus}`);
+    }
+    const now = new Date().toISOString();
+    const updates = { status: newStatus, updated_at: now };
+    if (result !== undefined) {
+      updates.result_slot = typeof result === "string" ? result : JSON.stringify(result);
+      if (updates.result_slot.length > 4000) {
+        updates.result_slot = JSON.stringify({
+          ledger_ref: `overflow-${taskId}`,
+          summary: updates.result_slot.slice(0, 200),
+        });
+      }
+    }
+    if (error !== undefined) {
+      updates.error_slot = typeof error === "string" ? error : JSON.stringify(error);
+    }
+    const setClauses = Object.keys(updates).map((k) => `${k} = ?`).join(", ");
+    const values = [...Object.values(updates), taskId];
+    this.db.prepare(`UPDATE tasks SET ${setClauses} WHERE task_id = ?`).run(...values);
+    return this.get(taskId);
+  }
+
+  listByStatus(status) {
+    return this.db.prepare("SELECT * FROM tasks WHERE status = ? ORDER BY created_at DESC").all(status);
+  }
+
+  listTimedOut() {
+    const now = new Date().toISOString();
+    return this.db.prepare("SELECT * FROM tasks WHERE status = 'running' AND deadline_at < ?").all(now);
+  }
+
+  sweepTimedOutTasks() {
+    const now = new Date().toISOString();
+    const overdue = this.db.prepare("SELECT * FROM tasks WHERE status = 'running' AND deadline_at < ?").all(now);
+    for (const task of overdue) {
+      this.db.prepare("UPDATE tasks SET status = 'timed_out', updated_at = ? WHERE task_id = ?").run(now, task.task_id);
+    }
+    return overdue;
+  }
+
+  advanceEscalation(taskId) {
+    const task = this.get(taskId);
+    if (!task) throw new Error(`Task ${taskId} not found`);
+    if (!["timed_out", "escalated"].includes(task.status)) {
+      throw new Error(`Cannot escalate task in status: ${task.status}`);
+    }
+    const chain = JSON.parse(task.escalation_chain);
+    const newIndex = task.escalation_index + 1;
+    this.db.prepare("UPDATE tasks SET escalation_index = ?, updated_at = ? WHERE task_id = ?")
+      .run(newIndex, new Date().toISOString(), taskId);
+    if (newIndex >= chain.length) {
+      this.db.prepare("UPDATE tasks SET status = 'escalated', updated_at = ? WHERE task_id = ?")
+        .run(new Date().toISOString(), taskId);
+    }
+    return { escalationIndex: newIndex, target: chain[newIndex] || null, exhausted: newIndex >= chain.length };
+  }
+
+  getInbox() {
+    return this.db.prepare(`
+      SELECT * FROM tasks
+      WHERE status IN ('timed_out', 'escalated')
+      AND escalation_index >= json_array_length(escalation_chain)
+      ORDER BY created_at DESC
+    `).all();
+  }
+}

package/src/runtime/task-packet.js

@@ -1,107 +1,107 @@
-import { activeRecall } from "../memory/active-recall.js";
-
-function compactCheckpoint(checkpoint) {
-  if (!checkpoint) return null;
-  return {
-    objective: checkpoint.objective,
-    status: checkpoint.status,
-    nextActions: checkpoint.nextActions || [],
-    blockers: checkpoint.blockers || []
-  };
-}
-
-export async function buildTaskPacket({
-  agentId,
-  objective,
-  memoryStore,
-  backendManager = null,
-  workspaceRoot = null,
-  backendOrder = null,
-  qmdSupplementLimit = 2,
-  retrievalQueries = null,
-  identity = null,
-  interactionContract = null,
-  outputContract = null,
-  reportGuidance = null,
-  allowedTools = [],
-  artifactRefs = [],
-  budget = {},
-  checkpointId = "latest",
-  memoryLimit = 8,
-  retrievalBlend = null,
-  conversationContext = undefined
-}) {
-  const checkpoint = compactCheckpoint(await memoryStore.loadCheckpoint(agentId, checkpointId));
-  let memory;
-  const useActiveRecall = memoryStore?.queryRetrievalCandidates;
-  if (useActiveRecall) {
-    const tokenBudget = budget.maxTokens ? Math.min(2000, Math.floor(budget.maxTokens * 0.08)) : 2000;
-    const recallResult = await activeRecall({
-      inboundMessage: objective,
-      memoryStore,
-      tokenBudget,
-      topicRelevanceFn: null,
-    });
-    const items = [
-      ...recallResult.facts.map((c) => ({ ...c, tier: "fact" })),
-      ...recallResult.asides.map((c) => ({ ...c, tier: "aside" })),
-    ];
-    memory = { items, backends: null, retrieval: null };
-  } else {
-    memory = backendManager
-      ? await backendManager.queryCombined(agentId, objective, {
-          workspaceRoot,
-          backendOrder,
-          qmdSupplementLimit,
-          fileQuery: retrievalQueries?.fileQuery || objective,
-          qmdQuery: retrievalQueries?.qmdQuery || objective,
-          limit: memoryLimit,
-          retrievalBlend
-        })
-      : await memoryStore.query(agentId, objective, { limit: memoryLimit, retrievalBlend });
-  }
-
-  return {
-    agentId,
-    objective,
-    conversationContext: conversationContext || null,
-    budget: {
-      maxTokens: budget.maxTokens ?? 8000,
-      maxRuntimeSeconds: budget.maxRuntimeSeconds ?? 60
-    },
-    layers: {
-      systemRules: [
-        "Transcript is not the system of record.",
-        "Use checkpoint and memory before requesting more history.",
-        "Do not write durable memory without policy approval."
-      ],
-      identity,
-      interactionContract,
-      outputContract,
-      reportGuidance,
-      checkpoint,
-      retrieval: memory.backends || null,
-      retrievalMeta: memory.retrieval || null,
-      retrievalQueries,
-      memory: memory.items.map((item) => ({
-        entryId: item.entryId || null,
-        type: item.type || "memory",
-        category: item.category || "general",
-        title: item.title || "",
-        content: item.content || "",
-        summary: item.summary || "",
-        reason: item.reason || "",
-        score: Number((item.score ?? 0).toFixed(4)),
-        tier: item.tier || null,
-        sourceBackend: item.sourceBackend || "file",
-        candidateSource: item.candidateSource || "indexed",
-        lexicalScore: Number((item.lexicalScore ?? 0).toFixed(4)),
-        embeddingSimilarity: Number((item.embeddingSimilarity ?? 0).toFixed(4)),
-        embeddingFreshness: item.embeddingFreshness || "missing",
-        retrievalSources: item.retrievalSources || ["lexical"]
-      })),
-      tools: allowedTools,
-      artifacts: artifactRefs
-    }
-  };
-}
+import { activeRecall } from "../memory/active-recall.js";
+
+function compactCheckpoint(checkpoint) {
+  if (!checkpoint) return null;
+  return {
+    objective: checkpoint.objective,
+    status: checkpoint.status,
+    nextActions: checkpoint.nextActions || [],
+    blockers: checkpoint.blockers || []
+  };
+}
+
+export async function buildTaskPacket({
+  agentId,
+  objective,
+  memoryStore,
+  backendManager = null,
+  workspaceRoot = null,
+  backendOrder = null,
+  qmdSupplementLimit = 2,
+  retrievalQueries = null,
+  identity = null,
+  interactionContract = null,
+  outputContract = null,
+  reportGuidance = null,
+  allowedTools = [],
+  artifactRefs = [],
+  budget = {},
+  checkpointId = "latest",
+  memoryLimit = 8,
+  retrievalBlend = null,
+  conversationContext = undefined
+}) {
+  const checkpoint = compactCheckpoint(await memoryStore.loadCheckpoint(agentId, checkpointId));
+  let memory;
+  const useActiveRecall = memoryStore?.queryRetrievalCandidates;
+  if (useActiveRecall) {
+    const tokenBudget = budget.maxTokens ? Math.min(2000, Math.floor(budget.maxTokens * 0.08)) : 2000;
+    const recallResult = await activeRecall({
+      inboundMessage: objective,
+      memoryStore,
+      tokenBudget,
+      topicRelevanceFn: null,
+    });
+    const items = [
+      ...recallResult.facts.map((c) => ({ ...c, tier: "fact" })),
+      ...recallResult.asides.map((c) => ({ ...c, tier: "aside" })),
+    ];
+    memory = { items, backends: null, retrieval: null };
+  } else {
+    memory = backendManager
+      ? await backendManager.queryCombined(agentId, objective, {
+          workspaceRoot,
+          backendOrder,
+          qmdSupplementLimit,
+          fileQuery: retrievalQueries?.fileQuery || objective,
+          qmdQuery: retrievalQueries?.qmdQuery || objective,
+          limit: memoryLimit,
+          retrievalBlend
+        })
+      : await memoryStore.query(agentId, objective, { limit: memoryLimit, retrievalBlend });
+  }
+
+  return {
+    agentId,
+    objective,
+    conversationContext: conversationContext || null,
+    budget: {
+      maxTokens: budget.maxTokens ?? 8000,
+      maxRuntimeSeconds: budget.maxRuntimeSeconds ?? 60
+    },
+    layers: {
+      systemRules: [
+        "Transcript is not the system of record.",
+        "Use checkpoint and memory before requesting more history.",
+        "Do not write durable memory without policy approval."
+      ],
+      identity,
+      interactionContract,
+      outputContract,
+      reportGuidance,
+      checkpoint,
+      retrieval: memory.backends || null,
+      retrievalMeta: memory.retrieval || null,
+      retrievalQueries,
+      memory: memory.items.map((item) => ({
+        entryId: item.entryId || null,
+        type: item.type || "memory",
+        category: item.category || "general",
+        title: item.title || "",
+        content: item.content || "",
+        summary: item.summary || "",
+        reason: item.reason || "",
+        score: Number((item.score ?? 0).toFixed(4)),
+        tier: item.tier || null,
+        sourceBackend: item.sourceBackend || "file",
+        candidateSource: item.candidateSource || "indexed",
+        lexicalScore: Number((item.lexicalScore ?? 0).toFixed(4)),
+        embeddingSimilarity: Number((item.embeddingSimilarity ?? 0).toFixed(4)),
+        embeddingFreshness: item.embeddingFreshness || "missing",
+        retrievalSources: item.retrievalSources || ["lexical"]
+      })),
+      tools: allowedTools,
+      artifacts: artifactRefs
+    }
+  };
+}