@sesamespace/hivemind 0.2.0 → 0.3.0

package/packages/runtime/src/sesame.ts

@@ -0,0 +1,174 @@
+import { SesameClient as SesameSDK } from "@sesamespace/sdk";
+import type { SesameConfig } from "./config.js";
+
+export interface SesameMessage {
+  id: string;
+  channelId: string;
+  channelKind: "dm" | "group" | "topic";
+  content: string;
+  author: {
+    id: string;
+    handle: string;
+  };
+  timestamp: string;
+}
+
+type MessageHandler = (message: SesameMessage) => void | Promise<void>;
+
+interface ChannelInfo {
+  kind: "dm" | "group" | "topic";
+  name?: string;
+}
+
+export class SesameClient {
+  private config: SesameConfig;
+  private sdk: SesameSDK;
+  private messageHandler: MessageHandler | null = null;
+  private agentId: string | null = null;
+  private channels: Map<string, ChannelInfo> = new Map();
+  private typingIntervals: Map<string, ReturnType<typeof setInterval>> = new Map();
+
+  constructor(config: SesameConfig) {
+    this.config = config;
+    this.sdk = new SesameSDK({
+      apiUrl: config.api_url.replace(/\/api\/v1$/, ""),
+      wsUrl: config.ws_url,
+      apiKey: config.api_key,
+    });
+  }
+
+  onMessage(handler: MessageHandler): void {
+    this.messageHandler = handler;
+  }
+
+  async connect(): Promise<void> {
+    const manifest = await this.sdk.getManifest();
+    this.agentId = manifest.agent.id;
+    console.log(`[sesame] Authenticated as ${manifest.agent.handle} (${this.agentId})`);
+
+    // Cache channel info
+    for (const ch of manifest.channels) {
+      this.channels.set(ch.id, { kind: ch.kind as ChannelInfo["kind"], name: ch.name ?? undefined });
+      const label = ch.name || ch.id.slice(0, 8);
+      console.log(`[sesame] Channel: ${label} (${ch.kind})`);
+    }
+
+    // Set presence to online
+    this.updatePresence("online", { emoji: "🟢" });
+
+    // Listen for message events
+    this.sdk.on("message", (event: any) => {
+      const msg = event.data || event.message || event;
+      const senderId = msg.senderId || msg.sender?.id;
+
+      // Ignore our own messages
+      if (senderId === this.agentId) return;
+
+      if (!this.messageHandler || !msg.content) return;
+
+      const channelInfo = this.channels.get(msg.channelId);
+
+      this.messageHandler({
+        id: msg.id || "unknown",
+        channelId: msg.channelId || "unknown",
+        channelKind: channelInfo?.kind || "dm",
+        content: msg.content,
+        author: {
+          id: senderId || "unknown",
+          handle: msg.senderHandle || msg.metadata?.senderHandle || "unknown",
+        },
+        timestamp: msg.createdAt || new Date().toISOString(),
+      });
+    });
+
+    await this.sdk.connect();
+    console.log("[sesame] WebSocket connected");
+  }
+
+  // ── Typing Indicators ──
+
+  /**
+   * Start sending typing indicators for a channel.
+   * Sends immediately, then every 2.5s until stopTyping() is called.
+   */
+  startTyping(channelId: string): void {
+    // Don't double-start
+    if (this.typingIntervals.has(channelId)) return;
+
+    this.sdk.sendTyping(channelId);
+    const interval = setInterval(() => {
+      this.sdk.sendTyping(channelId);
+    }, 2500);
+    this.typingIntervals.set(channelId, interval);
+  }
+
+  /**
+   * Stop sending typing indicators for a channel.
+   */
+  stopTyping(channelId: string): void {
+    const interval = this.typingIntervals.get(channelId);
+    if (interval) {
+      clearInterval(interval);
+      this.typingIntervals.delete(channelId);
+    }
+  }
+
+  /**
+   * Stop all active typing indicators.
+   */
+  stopAllTyping(): void {
+    for (const [channelId, interval] of this.typingIntervals) {
+      clearInterval(interval);
+    }
+    this.typingIntervals.clear();
+  }
+
+  // ── Presence ──
+
+  /**
+   * Update agent presence/status.
+   * @param status - "online" | "thinking" | "working" | "idle" | "offline"
+   * @param options - Optional detail text, progress (0-100), emoji
+   */
+  updatePresence(status: string, options?: { detail?: string; progress?: number; emoji?: string }): void {
+    // Use updatePresence if available (SDK >= 0.3), otherwise fall back to raw WS
+    if (typeof (this.sdk as any).updatePresence === "function") {
+      (this.sdk as any).updatePresence(status, options);
+    } else {
+      // Direct WS send for older SDK versions
+      const ws = (this.sdk as any).ws;
+      if (ws?.readyState === 1) {
+        ws.send(JSON.stringify({ type: "status", status, ...options }));
+      }
+    }
+  }
+
+  // ── Read Receipts ──
+
+  /**
+   * Mark a channel as read up to a given sequence number.
+   */
+  async markRead(channelId: string, seq: number): Promise<void> {
+    await this.sdk.markRead(channelId, seq);
+  }
+
+  // ── Messages ──
+
+  async sendMessage(channelId: string, content: string): Promise<void> {
+    await this.sdk.sendMessage(channelId, { content });
+  }
+
+  getAgentId(): string | null {
+    return this.agentId;
+  }
+
+  getChannelInfo(channelId: string): ChannelInfo | undefined {
+    return this.channels.get(channelId);
+  }
+
+  disconnect(): void {
+    this.stopAllTyping();
+    this.updatePresence("offline");
+    this.sdk.disconnect();
+  }
+}

package/{dist/start.js → packages/runtime/src/start.ts}

@@ -1,13 +1,12 @@
 #!/usr/bin/env node
-import {
-  loadConfig,
-  startPipeline,
-  startWorker
-} from "./chunk-2I2O6X5D.js";
+import { loadConfig } from "./config.js";
+import { startPipeline } from "./pipeline.js";
+import { startWorker } from "./worker.js";
 
-// packages/runtime/src/start.ts
-var configPath = process.argv[2] || "config/default.toml";
-var config = loadConfig(configPath);
+const configPath = process.argv[2] || "config/default.toml";
+const config = loadConfig(configPath);
+
+// If worker mode is enabled, start as a fleet worker
 if (config.worker?.enabled) {
   startWorker(config).catch((err) => {
     console.error("[hivemind] Worker fatal:", err);
@@ -19,4 +18,3 @@ if (config.worker?.enabled) {
     process.exit(1);
   });
 }
-//# sourceMappingURL=start.js.map

package/packages/runtime/src/task-engine.ts

@@ -0,0 +1,113 @@
+import type { MemoryClient, TaskRecord, TaskInput } from "./memory-client.js";
+
+export type TaskStatus = "planned" | "active" | "complete" | "archived";
+
+export interface TaskEngineOptions {
+  contextName: string;
+  memory: MemoryClient;
+}
+
+export class TaskEngine {
+  private contextName: string;
+  private memory: MemoryClient;
+
+  constructor(options: TaskEngineOptions) {
+    this.contextName = options.contextName;
+    this.memory = options.memory;
+  }
+
+  async addTask(title: string, description: string, blockedBy: string[] = []): Promise<TaskRecord> {
+    return this.memory.createTask({
+      context_name: this.contextName,
+      title,
+      description,
+      status: "planned",
+      blocked_by: blockedBy,
+    });
+  }
+
+  async listTasks(status?: TaskStatus): Promise<TaskRecord[]> {
+    return this.memory.listTasks(this.contextName, status);
+  }
+
+  async startTask(taskId: string): Promise<TaskRecord | null> {
+    return this.memory.updateTask(taskId, { status: "active" });
+  }
+
+  async completeTask(taskId: string): Promise<TaskRecord | null> {
+    return this.memory.updateTask(taskId, { status: "complete" });
+  }
+
+  async archiveTask(taskId: string): Promise<TaskRecord | null> {
+    return this.memory.updateTask(taskId, { status: "archived" });
+  }
+
+  async getNextTask(): Promise<TaskRecord | null> {
+    return this.memory.getNextTask(this.contextName);
+  }
+
+  async pickAndStartNextTask(): Promise<TaskRecord | null> {
+    const next = await this.getNextTask();
+    if (next) {
+      return this.startTask(next.id);
+    }
+    return null;
+  }
+
+  setContext(contextName: string): void {
+    this.contextName = contextName;
+  }
+
+  /**
+   * Parse a task command from a chat message.
+   * Returns the action and parsed parameters, or null if not a task command.
+   */
+  static parseTaskCommand(message: string): TaskCommand | null {
+    const lower = message.trim().toLowerCase();
+
+    // "add task: <title>"
+    const addMatch = message.match(/^(?:add|create)\s+task[:\s]+(.+)/i);
+    if (addMatch) {
+      return { action: "add", title: addMatch[1].trim() };
+    }
+
+    // "list tasks"
+    if (/^list\s+tasks/i.test(lower)) {
+      const statusMatch = lower.match(/list\s+tasks\s+(\w+)/);
+      return { action: "list", statusFilter: statusMatch?.[1] as TaskStatus | undefined };
+    }
+
+    // "complete task <id>"
+    const completeMatch = message.match(/^complete\s+task\s+(\S+)/i);
+    if (completeMatch) {
+      return { action: "complete", taskId: completeMatch[1] };
+    }
+
+    // "start task <id>"
+    const startMatch = message.match(/^start\s+task\s+(\S+)/i);
+    if (startMatch) {
+      return { action: "start", taskId: startMatch[1] };
+    }
+
+    // "next task"
+    if (/^next\s+task/i.test(lower)) {
+      return { action: "next" };
+    }
+
+    // "archive task <id>"
+    const archiveMatch = message.match(/^archive\s+task\s+(\S+)/i);
+    if (archiveMatch) {
+      return { action: "archive", taskId: archiveMatch[1] };
+    }
+
+    return null;
+  }
+}
+
+export interface TaskCommand {
+  action: "add" | "list" | "complete" | "start" | "next" | "archive";
+  title?: string;
+  description?: string;
+  taskId?: string;
+  statusFilter?: TaskStatus;
+}

package/packages/runtime/src/worker.ts

@@ -0,0 +1,339 @@
+/**
+ * Worker mode entry point — distributed context execution.
+ *
+ * A worker runs autonomously on a separate machine:
+ *   1. Starts its HTTP server (for Primary to manage it)
+ *   2. Registers with the Primary node
+ *   3. Connects to the local memory daemon
+ *   4. Picks up tasks from assigned context queues
+ *   5. Executes tasks using the agent loop (query memory, call LLM, store episodes)
+ *   6. Reports status back to Primary via HTTP
+ */
+
+import type { HivemindConfig, WorkerModeConfig } from "./config.js";
+import type { WorkerRegistrationRequest, WorkerRegistrationResponse, WorkerStatusReport } from "./fleet/worker-protocol.js";
+import { PRIMARY_ROUTES } from "./fleet/worker-protocol.js";
+import { WorkerServer } from "./fleet/worker-server.js";
+import { Agent } from "./agent.js";
+import { MemoryClient } from "./memory-client.js";
+import { TaskEngine } from "./task-engine.js";
+
+export interface WorkerRuntimeOptions {
+  config: HivemindConfig;
+  workerConfig: WorkerModeConfig;
+}
+
+export class WorkerRuntime {
+  private config: HivemindConfig;
+  private workerConfig: WorkerModeConfig;
+  private server: WorkerServer;
+  private memory: MemoryClient;
+  private agent: Agent;
+  private taskPollTimer: ReturnType<typeof setInterval> | null = null;
+  private statusReportTimer: ReturnType<typeof setInterval> | null = null;
+  private registeredWorkerId: string | null = null;
+  private running = false;
+  private executing = false;
+
+  constructor(opts: WorkerRuntimeOptions) {
+    this.config = opts.config;
+    this.workerConfig = opts.workerConfig;
+
+    this.server = new WorkerServer({
+      workerId: this.workerConfig.worker_id,
+      port: this.workerConfig.worker_port,
+      maxContexts: this.workerConfig.max_contexts,
+      memoryDaemonUrl: this.config.memory.daemon_url,
+      ollamaUrl: this.config.ollama.base_url,
+    });
+
+    this.memory = new MemoryClient(this.config.memory);
+    this.agent = new Agent(this.config);
+  }
+
+  /**
+   * Start the worker: HTTP server, register with Primary, begin task loop.
+   */
+  async start(): Promise<void> {
+    this.running = true;
+
+    // 1. Start the worker HTTP server
+    this.server.onContextAssigned((contextName, description) => {
+      console.log(`[worker] Context assigned: "${contextName}" — ${description || "(no description)"}`);
+      // Create the context in the local memory daemon
+      this.memory.createContext(contextName, description).catch((err) => {
+        console.warn(`[worker] Failed to create context "${contextName}" in daemon:`, (err as Error).message);
+      });
+    });
+    await this.server.start();
+    console.log(`[worker] HTTP server listening on port ${this.workerConfig.worker_port}`);
+
+    // 2. Verify local memory daemon is reachable
+    const memoryOk = await this.memory.healthCheck();
+    if (memoryOk) {
+      console.log("[worker] Local memory daemon connected");
+    } else {
+      console.warn("[worker] Memory daemon unreachable at", this.config.memory.daemon_url);
+      console.warn("[worker] Continuing — episodes will not be stored until daemon is available");
+    }
+
+    // 3. Register with Primary
+    await this.registerWithPrimary();
+
+    // 4. Start the task execution loop
+    this.startTaskLoop();
+
+    // 5. Start periodic status reporting
+    this.startStatusReporting();
+
+    console.log("[worker] Ready — waiting for context assignments");
+  }
+
+  /**
+   * Stop the worker gracefully.
+   */
+  async stop(): Promise<void> {
+    this.running = false;
+
+    if (this.taskPollTimer) {
+      clearInterval(this.taskPollTimer);
+      this.taskPollTimer = null;
+    }
+
+    if (this.statusReportTimer) {
+      clearInterval(this.statusReportTimer);
+      this.statusReportTimer = null;
+    }
+
+    await this.server.stop();
+    console.log("[worker] Stopped");
+  }
+
+  /**
+   * Register this worker with the Primary node.
+   */
+  async registerWithPrimary(): Promise<WorkerRegistrationResponse | null> {
+    const workerUrl = `http://localhost:${this.workerConfig.worker_port}`;
+
+    const registration: WorkerRegistrationRequest = {
+      url: workerUrl,
+      capabilities: {
+        max_contexts: this.workerConfig.max_contexts,
+        has_ollama: true,
+        has_memory_daemon: true,
+        available_models: [this.config.memory.embedding_model],
+      },
+    };
+
+    try {
+      const resp = await fetch(
+        `${this.workerConfig.primary_url}${PRIMARY_ROUTES.register}`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(registration),
+        },
+      );
+
+      if (!resp.ok) {
+        console.error(`[worker] Registration failed: ${resp.status} ${await resp.text()}`);
+        return null;
+      }
+
+      const result = (await resp.json()) as WorkerRegistrationResponse;
+      this.registeredWorkerId = result.worker_id;
+      console.log(`[worker] Registered with Primary as ${result.worker_id}`);
+      return result;
+    } catch (err) {
+      console.error("[worker] Could not reach Primary at", this.workerConfig.primary_url);
+      console.error("[worker] Will continue in standalone mode — retry registration manually");
+      return null;
+    }
+  }
+
+  /**
+   * Start the task execution polling loop.
+   * Iterates assigned contexts and picks up tasks from each queue.
+   */
+  startTaskLoop(): void {
+    this.taskPollTimer = setInterval(() => {
+      if (!this.running || this.executing) return;
+      this.executeNextTask().catch((err) => {
+        console.error("[worker] Task execution error:", (err as Error).message);
+      });
+    }, this.workerConfig.task_poll_interval_ms);
+  }
+
+  /**
+   * Find and execute the next available task across all assigned contexts.
+   */
+  async executeNextTask(): Promise<void> {
+    const contexts = this.server.getAssignedContexts();
+    if (contexts.length === 0) return;
+
+    for (const contextName of contexts) {
+      const engine = new TaskEngine({ contextName, memory: this.memory });
+      const task = await engine.getNextTask();
+
+      if (task) {
+        this.executing = true;
+
+        try {
+          // Update worker status
+          this.server.setActiveContext(contextName);
+          this.server.setCurrentTask(task.id);
+
+          console.log(`[worker] Executing task [${task.id.slice(0, 8)}] "${task.title}" in context "${contextName}"`);
+
+          // Mark task as active
+          await engine.startTask(task.id);
+
+          // Switch agent to the correct context
+          this.agent.setContext(contextName);
+
+          // Ensure context exists in memory daemon
+          try {
+            await this.memory.createContext(contextName);
+          } catch {
+            // Context may already exist
+          }
+
+          // Execute the task via the agent loop:
+          //   - Agent queries memory for relevant episodes
+          //   - Builds prompt with context + memories
+          //   - Calls LLM for a response
+          //   - Stores episodes (write-through to L2)
+          //   - Triggers promotion if needed
+          const taskPrompt = buildTaskPrompt(task.title, task.description);
+          const response = await this.agent.processMessage(taskPrompt);
+
+          console.log(`[worker] Task [${task.id.slice(0, 8)}] completed. Response: ${response.content.slice(0, 100)}...`);
+
+          // Mark task as complete
+          await engine.completeTask(task.id);
+
+          // Report status to Primary
+          await this.reportStatus("working", contextName, task.id);
+        } catch (err) {
+          console.error(`[worker] Task [${task.id.slice(0, 8)}] failed:`, (err as Error).message);
+          await this.reportStatus("error", contextName, task.id, (err as Error).message);
+        } finally {
+          this.executing = false;
+          this.server.setCurrentTask(null);
+        }
+
+        // Execute one task per poll cycle to stay responsive
+        return;
+      }
+    }
+
+    // No tasks found in any context — go idle
+    if (this.server.getAssignedContexts().length > 0) {
+      this.server.setActiveContext(null);
+      this.server.setCurrentTask(null);
+    }
+  }
+
+  /**
+   * Periodically report status back to Primary.
+   */
+  startStatusReporting(): void {
+    this.statusReportTimer = setInterval(() => {
+      if (!this.running || !this.registeredWorkerId) return;
+
+      const contexts = this.server.getAssignedContexts();
+      if (contexts.length === 0) return;
+
+      this.reportStatus(
+        this.executing ? "working" : "idle",
+        this.executing ? contexts[0] : null,
+        null,
+      ).catch(() => {});
+    }, this.workerConfig.status_report_interval_ms);
+  }
+
+  /**
+   * Send a status report to the Primary.
+   */
+  async reportStatus(
+    activity: "idle" | "working" | "error",
+    currentContext: string | null,
+    currentTask: string | null,
+    error?: string,
+  ): Promise<void> {
+    if (!this.registeredWorkerId) return;
+
+    const report: WorkerStatusReport = {
+      activity,
+      current_context: currentContext,
+      current_task: currentTask,
+      error,
+    };
+
+    try {
+      const statusUrl = `${this.workerConfig.primary_url}${PRIMARY_ROUTES.status(this.registeredWorkerId)}`;
+      await fetch(statusUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(report),
+      });
+    } catch {
+      // Primary unreachable — non-fatal, will retry next interval
+    }
+  }
+
+  // --- Accessors for testing ---
+
+  getServer(): WorkerServer {
+    return this.server;
+  }
+
+  getAgent(): Agent {
+    return this.agent;
+  }
+
+  getMemoryClient(): MemoryClient {
+    return this.memory;
+  }
+
+  isRunning(): boolean {
+    return this.running;
+  }
+
+  isExecuting(): boolean {
+    return this.executing;
+  }
+
+  getRegisteredWorkerId(): string | null {
+    return this.registeredWorkerId;
+  }
+}
+
+/**
+ * Build a prompt for executing a task via the agent.
+ */
+function buildTaskPrompt(title: string, description: string): string {
+  let prompt = `[TASK] ${title}`;
+  if (description) {
+    prompt += `\n\n${description}`;
+  }
+  prompt += "\n\nPlease work on this task. Use your memory and knowledge to provide a thorough response.";
+  return prompt;
+}
+
+/**
+ * Start a worker from a config file path (convenience entry point).
+ */
+export async function startWorker(config: HivemindConfig): Promise<WorkerRuntime> {
+  if (!config.worker || !config.worker.enabled) {
+    throw new Error("Worker mode is not enabled in config. Set [worker] enabled = true.");
+  }
+
+  const runtime = new WorkerRuntime({
+    config,
+    workerConfig: config.worker,
+  });
+
+  await runtime.start();
+  return runtime;
+}

package/packages/runtime/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"]
+}

package/pnpm-workspace.yaml

@@ -0,0 +1,2 @@
+packages:
+  - "packages/*"

package/run-aidan.sh

@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+set -euo pipefail
+cd /tmp/hivemind
+
+# Load secrets
+export SESAME_API_KEY="sk_sesame_KggHivRwUPVK-zEyUrD45UAWLAD8Sj6J8lIaH0xc"
+export LLM_API_KEY="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"
+
+# Ensure memory daemon is running
+if ! curl -s http://localhost:3434/health &>/dev/null; then
+  echo "[hivemind] Starting memory daemon..."
+  nohup ./packages/memory/target/release/hivemind-memory > /tmp/hivemind-memory.log 2>&1 &
+  sleep 2
+fi
+
+# Auto-restart loop
+while true; do
+  echo "[hivemind] Starting Aidan at $(date)"
+  node packages/cli/dist/main.js start --config config/default.toml 2>&1 | tee -a /tmp/hivemind-aidan.log
+  EXIT_CODE=$?
+  echo "[hivemind] Aidan exited with code $EXIT_CODE at $(date) — restarting in 5s..."
+  sleep 5
+done