@castlemilk/omega 0.2.0 → 0.4.0

package/dist/cli.js

@@ -12,8 +12,8 @@ function getApiUrl() {
   const opts = program.opts();
   return opts.api ?? "http://localhost:4000";
 }
-async function apiFetch(path3, init) {
-  const url = `${getApiUrl()}${path3}`;
+async function apiFetch(path4, init) {
+  const url = `${getApiUrl()}${path4}`;
   const res = await fetch(url, init);
   const data = await res.json().catch(() => ({}));
   if (!res.ok) {
@@ -48,8 +48,85 @@ projectCmd.command("remove").description("Remove a project").argument("<id>", "p
 });
 
 // ../../apps/cli/src/commands/task.ts
+import { Command as Command3 } from "commander";
+
+// ../../apps/cli/src/commands/task-feed.ts
 import { Command as Command2 } from "commander";
-var taskCmd = new Command2("task").description("Manage tasks");
+import * as grpc from "@grpc/grpc-js";
+import * as protoLoader from "@grpc/proto-loader";
+
+// ../../apps/cli/src/lib/proto-path.ts
+import { existsSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+function findProtoPath() {
+  const candidates = [
+    // Bundled / installed package layout: dist/proto/tasks.proto
+    path.join(__dirname, "proto/tasks.proto"),
+    // Development layout from apps/cli/src/lib: ../../../../proto/tasks.proto
+    path.resolve(__dirname, "../../../../proto/tasks.proto")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return candidates[0] ?? "proto/tasks.proto";
+}
+
+// ../../apps/cli/src/commands/task-feed.ts
+var GRPC_TARGET = process.env.HARNESS_GRPC_TARGET ?? "localhost:50051";
+var packageDefinition = protoLoader.loadSync(findProtoPath(), {
+  keepCase: true,
+  longs: String,
+  enums: String,
+  defaults: true,
+  oneofs: true
+});
+var proto = grpc.loadPackageDefinition(packageDefinition);
+var taskFeedCmd = new Command2("feed").description("Feed a task into the harness via gRPC").requiredOption("--project <id>", "project id").requiredOption("--title <title>", "task title").option("--description <text>", "task description").option("--complexity <level>", "simple | medium | complex", "simple").option("--tags <tags>", "comma-separated tags").option("--auto-run", "run the task immediately after submission", false).option("--stream", "stream task updates after submission", false).action(
+  (opts) => {
+    const client = new proto.omega.TaskIngestion(
+      GRPC_TARGET,
+      grpc.credentials.createInsecure()
+    );
+    const request = {
+      project_id: opts.project,
+      title: opts.title,
+      description: opts.description ?? "",
+      complexity: opts.complexity,
+      tags: opts.tags ? opts.tags.split(",").map((t) => t.trim()) : [],
+      auto_run: opts.autoRun
+    };
+    if (opts.stream) {
+      const call = client.streamTasks();
+      call.on("data", (event) => {
+        console.log(JSON.stringify(event, null, 2));
+      });
+      call.on("error", (err) => {
+        console.error("Stream error:", err.message);
+        process.exit(1);
+      });
+      call.on("end", () => {
+        process.exit(0);
+      });
+      call.write({ project_id: opts.project });
+    }
+    client.submitTask(request, (err, response) => {
+      if (err) {
+        console.error("gRPC error:", err.message);
+        process.exit(1);
+      }
+      console.log(JSON.stringify(response, null, 2));
+      if (!opts.stream) {
+        client.close();
+      }
+    });
+  }
+);
+
+// ../../apps/cli/src/commands/task.ts
+var taskCmd = new Command3("task").description("Manage tasks");
 taskCmd.command("create").description("Create a task").requiredOption("--project <id>", "project id").requiredOption("--title <title>", "task title").option("--description <text>", "task description").option("--complexity <level>", "simple | medium | complex", "simple").option("--tags <tags>", "comma-separated tags").action(async (opts) => {
   const task = await apiFetch("/tasks", {
     method: "POST",
@@ -73,13 +150,14 @@ taskCmd.command("run").description("Run a task through the router").argument("<i
   const result = await apiFetch(`/tasks/${id}/run`, { method: "POST" });
   console.log(JSON.stringify(result, null, 2));
 });
+taskCmd.addCommand(taskFeedCmd);
 
 // ../../apps/cli/src/commands/ui.ts
-import { Command as Command3 } from "commander";
+import { Command as Command4 } from "commander";
 import { spawn } from "child_process";
-import { existsSync } from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
+import { existsSync as existsSync2 } from "fs";
+import path2 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import open from "open";
 import { render } from "ink";
 import React2 from "react";
@@ -338,12 +416,12 @@ function TuiApp() {
 }
 
 // ../../apps/cli/src/commands/ui.ts
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = path.dirname(__filename);
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = path2.dirname(__filename2);
 var API2 = process.env.HARNESS_API_URL ?? "http://localhost:4000";
 function startBundledServer() {
-  const serverPath = path.resolve(__dirname, "server.js");
-  if (existsSync(serverPath)) {
+  const serverPath = path2.resolve(__dirname2, "server.js");
+  if (existsSync2(serverPath)) {
     return spawn(process.execPath, [serverPath], { stdio: "inherit" });
   }
   return void 0;
@@ -366,7 +444,7 @@ async function waitForApi(maxMs = 15e3) {
 }
 async function ensureProject() {
   const cwd = process.cwd();
-  const name = path.basename(cwd);
+  const name = path2.basename(cwd);
   try {
     const listRes = await fetch(`${API2}/projects`);
     const projects = await listRes.json();
@@ -389,7 +467,7 @@ async function ensureProject() {
     console.warn("Could not auto-detect project:", err);
   }
 }
-var uiCmd = new Command3("ui").description("Open the harness web UI").option("--no-tui", "Do not open the terminal console alongside the web UI").action(async (options) => {
+var uiCmd = new Command4("ui").description("Open the harness web UI").option("--no-tui", "Do not open the terminal console alongside the web UI").action(async (options) => {
   let server = void 0;
   const alreadyRunning = await isApiReady();
   const useTui = options.tui;
@@ -427,10 +505,10 @@ var uiCmd = new Command3("ui").description("Open the harness web UI").option("--
 });
 
 // ../../apps/cli/src/commands/console.ts
-import { Command as Command4 } from "commander";
+import { Command as Command5 } from "commander";
 import { render as render2 } from "ink";
 import React3 from "react";
-var consoleCmd = new Command4("console").description("Open the harness TUI console").action(() => {
+var consoleCmd = new Command5("console").description("Open the harness TUI console").action(() => {
   if (!process.stdin.isTTY) {
     console.error("The harness console requires an interactive terminal (TTY).");
     process.exit(1);
@@ -439,9 +517,9 @@ var consoleCmd = new Command4("console").description("Open the harness TUI conso
 });
 
 // ../../apps/cli/src/commands/skill.ts
-import { Command as Command5 } from "commander";
-import path2 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { Command as Command6 } from "commander";
+import path3 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 
 // ../skills/src/parse.ts
 import matter from "gray-matter";
@@ -542,22 +620,91 @@ async function registerSkill(sourcePath, outputDir) {
 // ../../apps/cli/src/commands/skill.ts
 function getOutputDir() {
   if (process.env.OMEGA_HARNESS_ROOT) {
-    return path2.join(path2.resolve(process.env.OMEGA_HARNESS_ROOT), "packages/skills/src");
+    return path3.join(path3.resolve(process.env.OMEGA_HARNESS_ROOT), "packages/skills/src");
   }
   try {
-    const __filename2 = fileURLToPath2(import.meta.url);
-    const __dirname2 = path2.dirname(__filename2);
-    return path2.join(path2.resolve(__dirname2, "../../../.."), "packages/skills/src");
+    const __filename3 = fileURLToPath3(import.meta.url);
+    const __dirname3 = path3.dirname(__filename3);
+    return path3.join(path3.resolve(__dirname3, "../../../.."), "packages/skills/src");
   } catch {
-    return path2.join(process.cwd(), "harness-skills");
+    return path3.join(process.cwd(), "harness-skills");
   }
 }
-var skillCmd = new Command5("skill").description("Manage skill artifacts");
+var skillCmd = new Command6("skill").description("Manage skill artifacts");
 skillCmd.command("generate").description("Generate a harness adapter from a SKILL.md file").argument("<source>", "path to SKILL.md").action(async (source) => {
   const outputDir = getOutputDir();
-  const manifest = await registerSkill(path2.resolve(source), outputDir);
+  const manifest = await registerSkill(path3.resolve(source), outputDir);
   console.log(`Generated adapter for skill: ${manifest.name}`);
-  console.log(`Output directory: ${path2.join(outputDir, "generated")}`);
+  console.log(`Output directory: ${path3.join(outputDir, "generated")}`);
+});
+
+// ../../apps/cli/src/commands/agent.ts
+import { Command as Command7 } from "commander";
+var agentCmd = new Command7("agent").description("Autonomous agent loop");
+agentCmd.command("run").description("Run a single agent task").requiredOption("--project <id>", "project id").requiredOption("--title <title>", "task title").option("--description <text>", "task description").option("--complexity <level>", "simple | medium | complex", "complex").option("--auto-publish", "publish if validation passes", false).action(
+  async (opts) => {
+    const tags = ["agent"];
+    if (opts.autoPublish) tags.push("publish");
+    const task = await apiFetch("/tasks", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        projectId: opts.project,
+        title: opts.title,
+        description: opts.description,
+        complexity: opts.complexity,
+        tags
+      })
+    });
+    console.log(JSON.stringify(task, null, 2));
+    const result = await apiFetch(`/tasks/${task.id}/run`, { method: "POST" });
+    console.log(JSON.stringify(result, null, 2));
+  }
+);
+agentCmd.command("loop").description("Continuously run agent tasks").requiredOption("--project <id>", "project id").option("--interval <min>", "minutes between loops", "30").option("--auto-publish", "publish if validation passes", false).option("--prompt <text>", "overriding self-improvement prompt").action(
+  async (opts) => {
+    const intervalMin = parseInt(opts.interval, 10);
+    const intervalMs = intervalMin * 60 * 1e3;
+    const runOnce = async () => {
+      const title = opts.prompt ?? "Improve the Omega harness: fix a TODO, add a test, refactor a function, or improve documentation";
+      const tags = ["agent", "self-improve"];
+      if (opts.autoPublish) tags.push("publish");
+      const task = await apiFetch("/tasks", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          projectId: opts.project,
+          title,
+          description: "Use the available tools to make a small, verifiable improvement to the codebase. Run lint and tests. Finish with a summary.",
+          complexity: "complex",
+          tags
+        })
+      });
+      console.log(`Created task ${task.id}`);
+      const result = await apiFetch(`/tasks/${task.id}/run`, { method: "POST" });
+      console.log(JSON.stringify(result, null, 2));
+      return result;
+    };
+    await runOnce();
+    if (intervalMs > 0) {
+      console.log(`Looping every ${opts.interval} minute(s). Press Ctrl+C to stop.`);
+      setInterval(() => {
+        void runOnce();
+      }, intervalMs);
+    }
+  }
+);
+agentCmd.command("steps").description("Show steps for a task").argument("<id>", "task id").action(async (id) => {
+  const steps = await apiFetch(`/tasks/${id}/steps`);
+  console.log(JSON.stringify(steps, null, 2));
+});
+agentCmd.command("traces").description("Show traces for a task").argument("<id>", "task id").action(async (id) => {
+  const traces = await apiFetch(`/tasks/${id}/traces`);
+  console.log(JSON.stringify(traces, null, 2));
+});
+agentCmd.command("diffs").description("Show diffs for a task").argument("<id>", "task id").action(async (id) => {
+  const diffs = await apiFetch(`/tasks/${id}/diffs`);
+  console.log(JSON.stringify(diffs, null, 2));
 });
 
 // ../../apps/cli/src/index.ts
@@ -567,4 +714,5 @@ program2.addCommand(taskCmd);
 program2.addCommand(uiCmd);
 program2.addCommand(consoleCmd);
 program2.addCommand(skillCmd);
+program2.addCommand(agentCmd);
 program2.parse();

package/dist/proto/tasks.proto

@@ -0,0 +1,37 @@
+syntax = "proto3";
+
+package omega;
+
+service TaskIngestion {
+  rpc SubmitTask (TaskRequest) returns (TaskResponse);
+  rpc StreamTasks (TaskStreamRequest) returns (stream TaskEvent);
+}
+
+message TaskRequest {
+  string project_id = 1;
+  string title = 2;
+  string description = 3;
+  string complexity = 4;
+  repeated string tags = 5;
+  bool auto_run = 6;
+}
+
+message TaskResponse {
+  string id = 1;
+  string status = 2;
+  string error = 3;
+}
+
+message TaskStreamRequest {
+  string project_id = 1;
+}
+
+message TaskEvent {
+  string id = 1;
+  string title = 2;
+  string status = 3;
+  string provider = 4;
+  string model = 5;
+  string result = 6;
+  string error = 7;
+}

package/dist/server.js

@@ -3,9 +3,10 @@
 // src/server.ts
 import express from "express";
 import cors from "cors";
-import path from "path";
 import { fileURLToPath } from "url";
 import { z } from "zod";
+import * as grpc from "@grpc/grpc-js";
+import * as protoLoader from "@grpc/proto-loader";
 
 // ../providers/src/openai.ts
 var DEFAULT_BASE_URL = "https://api.openai.com/v1";
@@ -47,6 +48,48 @@ var OpenAIProvider = class {
     const data = await res.json();
     return data.choices?.[0]?.message?.content ?? "";
   }
+  async sendWithTools(prompt, tools, opts) {
+    const res = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.authHeaders()
+      },
+      body: JSON.stringify({
+        model: opts?.model ?? this.config.defaultModel,
+        messages: [
+          ...opts?.system ? [{ role: "system", content: opts.system }] : [],
+          { role: "user", content: prompt }
+        ],
+        tools: tools.map((t) => ({
+          type: "function",
+          function: { name: t.name, description: t.description, parameters: t.parameters }
+        })),
+        temperature: opts?.temperature
+      })
+    });
+    if (!res.ok) {
+      throw new Error(`OpenAI tools request failed: ${res.status.toString()} ${res.statusText}`);
+    }
+    const data = await res.json();
+    const message = data.choices?.[0]?.message;
+    const toolCalls = message?.tool_calls;
+    if (toolCalls && toolCalls.length > 0) {
+      const normalized = toolCalls.map((tc) => ({
+        id: tc.id ?? "",
+        name: tc.function?.name ?? "",
+        arguments: (() => {
+          try {
+            return JSON.parse(tc.function?.arguments ?? "{}");
+          } catch {
+            return {};
+          }
+        })()
+      })).filter((tc) => tc.id && tc.name);
+      return JSON.stringify({ tool_calls: normalized });
+    }
+    return message?.content ?? "";
+  }
   authHeaders() {
     return this.config.apiKey ? { Authorization: `Bearer ${this.config.apiKey}` } : {};
   }
@@ -187,7 +230,7 @@ var KimiProvider = class extends OpenAIProvider {
   constructor(config) {
     super({
       ...config,
-      baseUrl: config.baseUrl ?? "https://api.moonshot.ai/v1"
+      baseUrl: config.baseUrl ?? "https://api.moonshot.cn/v1"
     });
     this.config = config;
   }
@@ -276,6 +319,11 @@ function selectProvider(configs, rules2, task) {
 }
 
 // src/server.ts
+import fs from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = path.dirname(__filename);
 function asyncHandler(fn) {
@@ -472,3 +520,256 @@ var PORT = Number(process.env.PORT ?? 4e3);
 app.listen(PORT, () => {
   console.log(`Omega harness server on http://localhost:${PORT.toString()}`);
 });
+var GRPC_PORT = Number(process.env.GRPC_PORT ?? 50051);
+var GRPC_PROTO_PATH = path.join(__dirname, "proto/tasks.proto");
+var grpcPackageDef = protoLoader.loadSync(GRPC_PROTO_PATH, {
+  keepCase: true,
+  longs: String,
+  enums: String,
+  defaults: true,
+  oneofs: true
+});
+var grpcProto = grpc.loadPackageDefinition(grpcPackageDef);
+function parseGrpcRequest(req) {
+  const r = req;
+  return {
+    project_id: typeof r.project_id === "string" ? r.project_id : "",
+    title: typeof r.title === "string" ? r.title : "",
+    description: typeof r.description === "string" ? r.description : void 0,
+    complexity: typeof r.complexity === "string" ? r.complexity : void 0,
+    tags: Array.isArray(r.tags) ? r.tags.filter((t) => typeof t === "string") : void 0,
+    auto_run: typeof r.auto_run === "boolean" ? r.auto_run : void 0
+  };
+}
+function isValidComplexity(value) {
+  return ["simple", "medium", "complex"].includes(value);
+}
+var AGENT_TOOLS = [
+  {
+    name: "read_file",
+    description: "Read a file relative to project root.",
+    parameters: { type: "object", properties: { path: { type: "string" } }, required: ["path"] }
+  },
+  {
+    name: "write_file",
+    description: "Write content to a file relative to project root.",
+    parameters: {
+      type: "object",
+      properties: { path: { type: "string" }, content: { type: "string" } },
+      required: ["path", "content"]
+    }
+  },
+  {
+    name: "run_command",
+    description: "Run a shell command in the project root.",
+    parameters: { type: "object", properties: { command: { type: "string" } }, required: ["command"] }
+  },
+  {
+    name: "finish",
+    description: "Mark the task complete.",
+    parameters: {
+      type: "object",
+      properties: { summary: { type: "string" }, success: { type: "boolean" } },
+      required: ["summary", "success"]
+    }
+  }
+];
+var AGENT_SYSTEM_PROMPT = `You are Omega, an autonomous software engineering agent. Respond with JSON: {"tool_calls":[{"id":"1","name":"tool_name","arguments":{}}]}. Available tools: read_file, write_file, run_command, finish. Work in small steps, run tests, and finish when done.`;
+function argString(value) {
+  if (value === void 0 || value === null) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return value.toString();
+  return JSON.stringify(value);
+}
+async function executeBundleTool(projectPath, name, args) {
+  const target = (file) => {
+    const resolved = path.resolve(projectPath, file);
+    if (!resolved.startsWith(path.resolve(projectPath))) throw new Error("Path traversal blocked");
+    return resolved;
+  };
+  try {
+    switch (name) {
+      case "read_file": {
+        const content = await fs.readFile(target(argString(args.path)), "utf-8");
+        return { success: true, output: content };
+      }
+      case "write_file": {
+        const p = target(argString(args.path));
+        await fs.mkdir(path.dirname(p), { recursive: true });
+        await fs.writeFile(p, argString(args.content), "utf-8");
+        return { success: true, output: `Wrote ${argString(args.path)}` };
+      }
+      case "run_command": {
+        const [cmd, ...cmdArgs] = argString(args.command).split(" ");
+        const { stdout, stderr } = await execFileAsync(cmd, cmdArgs, {
+          cwd: projectPath,
+          timeout: 12e4,
+          shell: false
+        });
+        return { success: true, output: stdout + stderr };
+      }
+      default:
+        return { success: false, output: `Unknown tool: ${name}` };
+    }
+  } catch (err) {
+    return { success: false, output: err instanceof Error ? err.message : String(err) };
+  }
+}
+function parseBundleToolCalls(raw) {
+  try {
+    const cleaned = raw.trim().replace(/^```[a-z]*\n?/, "").replace(/\n?```$/, "");
+    const parsed = JSON.parse(cleaned);
+    if (!Array.isArray(parsed.tool_calls)) return [];
+    const calls = parsed.tool_calls;
+    return calls.filter((t) => Boolean(t.id && t.name)).map((t) => ({ id: t.id, name: t.name, arguments: t.arguments }));
+  } catch {
+    return [];
+  }
+}
+async function executeAgentTask(task) {
+  task.status = "in_progress";
+  task.error = void 0;
+  task.result = void 0;
+  const project = projects.find((p) => p.id === task.projectId);
+  if (!project) {
+    task.status = "failed";
+    task.error = "Project not found for agent task";
+    return;
+  }
+  const selection = selectProvider(providerConfigs, rules, task);
+  if (!selection) {
+    task.status = "failed";
+    task.error = "No provider available for this task";
+    return;
+  }
+  try {
+    const provider = createProvider(selection.provider);
+    const prompt = [task.title, task.description].filter(Boolean).join("\n\n");
+    let response;
+    if ("sendWithTools" in provider && typeof provider.sendWithTools === "function") {
+      response = await provider.sendWithTools(prompt, AGENT_TOOLS, {
+        system: AGENT_SYSTEM_PROMPT,
+        model: selection.model
+      });
+    } else {
+      response = await provider.send(prompt, { system: AGENT_SYSTEM_PROMPT, model: selection.model });
+    }
+    const calls = parseBundleToolCalls(response);
+    const results = [];
+    for (const call of calls) {
+      if (call.name === "finish") {
+        task.status = call.arguments.success ? "done" : "failed";
+        const summaryArg = call.arguments.summary;
+        task.result = typeof summaryArg === "string" ? summaryArg : "";
+        break;
+      }
+      const result = await executeBundleTool(project.path, call.name, call.arguments);
+      results.push(`${call.name}: ${result.output}`);
+    }
+    if (calls.length > 0 && calls.every((c) => c.name !== "finish")) {
+      task.status = "done";
+      task.result = results.join("\n");
+    }
+    task.assignedModel = { provider: selection.provider.name, model: selection.model };
+  } catch (err) {
+    task.status = "failed";
+    task.error = err instanceof Error ? err.message : String(err);
+  }
+}
+async function executeTask(task) {
+  task.status = "in_progress";
+  task.error = void 0;
+  task.result = void 0;
+  if (task.tags.includes("agent") || task.tags.includes("self-improve")) {
+    return executeAgentTask(task);
+  }
+  const selection = selectProvider(providerConfigs, rules, task);
+  if (!selection) {
+    task.status = "failed";
+    task.error = "No provider available for this task";
+    return;
+  }
+  try {
+    const provider = createProvider(selection.provider);
+    const prompt = [task.title, task.description].filter(Boolean).join("\n\n");
+    const result = await provider.send(prompt, { model: selection.model });
+    task.status = "done";
+    task.result = result;
+    task.assignedModel = { provider: selection.provider.name, model: selection.model };
+  } catch (err) {
+    task.status = "failed";
+    task.error = err instanceof Error ? err.message : String(err);
+  }
+}
+var grpcServer = new grpc.Server();
+grpcServer.addService(grpcProto.omega.TaskIngestion.service, {
+  submitTask: (call, callback) => {
+    void (async () => {
+      try {
+        const req = parseGrpcRequest(call.request);
+        if (!req.project_id || !req.title) {
+          callback(
+            { code: grpc.status.INVALID_ARGUMENT, message: "project_id and title are required" },
+            null
+          );
+          return;
+        }
+        const complexity = isValidComplexity(req.complexity ?? "") ? req.complexity : "simple";
+        const task = {
+          id: newId(),
+          projectId: req.project_id,
+          title: req.title,
+          description: req.description ?? void 0,
+          status: "todo",
+          complexity,
+          tags: req.tags ?? [],
+          createdAt: now(),
+          updatedAt: now()
+        };
+        tasks.push(task);
+        if (req.auto_run) {
+          await executeTask(task);
+        }
+        callback(null, { id: task.id, status: task.status, error: task.error ?? "" });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        callback({ code: grpc.status.INTERNAL, message }, null);
+      }
+    })();
+  },
+  streamTasks: (call) => {
+    const req = call.request;
+    const projectId = req.project_id;
+    let cancelled = false;
+    const interval = setInterval(() => {
+      if (cancelled) return;
+      const filtered = projectId ? tasks.filter((t) => t.projectId === projectId) : tasks;
+      for (const task of filtered.slice(-20)) {
+        call.write({
+          id: task.id,
+          title: task.title,
+          status: task.status,
+          provider: task.assignedModel?.provider ?? "",
+          model: task.assignedModel?.model ?? "",
+          result: task.result ?? "",
+          error: task.error ?? ""
+        });
+      }
+    }, 1e3);
+    call.on("cancelled", () => {
+      cancelled = true;
+      clearInterval(interval);
+    });
+    call.on("error", () => {
+      cancelled = true;
+      clearInterval(interval);
+    });
+  }
+});
+grpcServer.bindAsync(`0.0.0.0:${GRPC_PORT.toString()}`, grpc.ServerCredentials.createInsecure(), (err) => {
+  if (err) {
+    console.error("gRPC server failed to start:", err);
+    return;
+  }
+  console.log(`gRPC task ingestion on 0.0.0.0:${GRPC_PORT.toString()}`);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@castlemilk/omega",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Omega Harness CLI - installable via npx",
   "type": "module",
   "main": "./dist/cli.js",
@@ -12,6 +12,8 @@
     "dist"
   ],
   "dependencies": {
+    "@grpc/grpc-js": "^1.14.4",
+    "@grpc/proto-loader": "^0.8.1",
     "commander": "^12.1.0",
     "cors": "^2.8.5",
     "express": "^4.19.2",
@@ -28,8 +30,8 @@
     "@types/node": "^20.14.0",
     "esbuild": "^0.23.0",
     "@omega/core": "0.1.0",
-    "@omega/providers": "0.1.0",
-    "@omega/router": "0.1.0"
+    "@omega/router": "0.1.0",
+    "@omega/providers": "0.1.0"
   },
   "publishConfig": {
     "access": "public"
@@ -40,9 +42,10 @@
     "url": "git+https://github.com/castlemilk/harness.git"
   },
   "scripts": {
-    "build:cli": "esbuild ../../apps/cli/src/index.ts --bundle --platform=node --format=esm --outfile=dist/cli.js --external:commander --external:open --external:gray-matter --external:yaml --external:ink --external:react --alias:@omega/core=../../packages/core/src/index.ts --alias:@omega/skills=../../packages/skills/src/index.ts",
-    "build:server": "esbuild src/server.ts --bundle --platform=node --format=esm --outfile=dist/server.js --external:express --external:cors --external:zod --alias:@omega/core=../../packages/core/src/index.ts --alias:@omega/providers=../../packages/providers/src/index.ts --alias:@omega/router=../../packages/router/src/index.ts",
+    "build:cli": "esbuild ../../apps/cli/src/index.ts --bundle --platform=node --format=esm --outfile=dist/cli.js --external:commander --external:open --external:gray-matter --external:yaml --external:ink --external:react --external:@grpc/grpc-js --external:@grpc/proto-loader --alias:@omega/core=../../packages/core/src/index.ts --alias:@omega/skills=../../packages/skills/src/index.ts",
+    "build:server": "esbuild src/server.ts --bundle --platform=node --format=esm --outfile=dist/server.js --external:express --external:cors --external:zod --external:@grpc/grpc-js --external:@grpc/proto-loader --alias:@omega/core=../../packages/core/src/index.ts --alias:@omega/providers=../../packages/providers/src/index.ts --alias:@omega/router=../../packages/router/src/index.ts",
     "copy:web": "cp -R ../../apps/web/dist dist/web",
-    "build": "pnpm build:cli && pnpm build:server && pnpm copy:web"
+    "copy:proto": "mkdir -p dist/proto && cp ../../proto/tasks.proto dist/proto/tasks.proto",
+    "build": "pnpm build:cli && pnpm build:server && pnpm copy:web && pnpm copy:proto"
   }
 }