iriai-build 0.6.2 → 0.6.3

package/bin/cli.js

@@ -9,6 +9,7 @@ import { planCommand } from "../cli/commands/plan.js";
 import { implementationCommand } from "../cli/commands/implementation.js";
 import { launchCommand } from "../cli/commands/launch.js";
 import { slackCommand } from "../cli/commands/slack.js";
+import { desktopCommand } from "../cli/commands/desktop.js";
 import { setupCommand } from "../cli/commands/setup.js";
 import { transferToSlackCommand } from "../cli/commands/transfer.js";
 import { ensureReady } from "../cli/first-run.js";
@@ -67,6 +68,15 @@ program
     await withReadyCheck(() => slackCommand());
   });
 
+program
+  .command("desktop")
+  .description("Start the desktop companion bridge (WebSocket on port 9721).")
+  .option("--port <number>", "WebSocket server port (default: 9721)")
+  .option("--db <path>", "Database file path")
+  .action(async (opts) => {
+    await withReadyCheck(() => desktopCommand(opts));
+  });
+
 program
   .command("setup")
   .description("Configure Slack tokens, tool paths, and preferences.")

package/cli/commands/desktop.js

@@ -0,0 +1,19 @@
+// desktop.js — `iriai-build desktop` command.
+// Starts the desktop companion bridge (WebSocket-based, no Slack dependency).
+
+export async function desktopCommand(opts = {}) {
+  if (opts.port) {
+    const port = parseInt(opts.port, 10);
+    if (isNaN(port) || port < 1 || port > 65535) {
+      console.error(`Invalid port: ${opts.port}. Must be a number between 1 and 65535.`);
+      process.exit(1);
+    }
+    process.env.DESKTOP_WS_PORT = String(port);
+  }
+  if (opts.db) {
+    process.env.DB_PATH = opts.db;
+  }
+
+  // bridge-desktop.js is self-executing on import
+  await import("../../v3/bridge-desktop.js");
+}

package/lib/state-machines/feature-lead.js

@@ -266,6 +266,14 @@ export default class FeatureLead extends EventEmitter {
       onPhaseDone: () => {
         this._mainCrashCount = 0;
         this.emit("lifecycle", { key: this.key, event: "refresh-complete" });
+        // If gate evidence was already posted, don't chain — wait for user decision.
+        const currentGateTs = this._featureState?.gate_evidence_ts || null;
+        if (currentGateTs) {
+          this._state = "monitoring";
+          this.emit("lifecycle", { key: this.key, event: "gate-evidence-awaiting-decision" });
+          this._startTriggerDetection();
+          return;
+        }
         // Chain to a fresh session to dispatch the next gate — same as
         // _spawnTrigger("gate-ready") does. Without this, the FL drops
         // into monitoring with no process and no trigger detection,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iriai-build",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "description": "Iriai Build tool — AI agent orchestration CLI",
   "type": "module",
   "bin": {
@@ -22,6 +22,7 @@
     "@slack/web-api": "^7.8.0",
     "chokidar": "^4.0.3",
     "commander": "^14.0.3",
-    "iriai-feedback": "^0.1.0"
+    "iriai-feedback": "^0.1.0",
+    "ws": "^8.19.0"
   }
 }

package/v3/adapters/desktop-adapter.js

@@ -1,78 +1,348 @@
 // desktop-adapter.js — DesktopAdapter implementing InterfaceAdapter.
-// For iriai-command Tauri desktop app.
-// Stub — implementation deferred to Phase 7.
-// Will use WebSocket or stdin/stdout JSON protocol as Tauri sidecar.
+// WebSocket server for iriai-command Tauri desktop app.
 
+import { WebSocketServer, WebSocket } from "ws";
+import fs from "node:fs";
+import path from "node:path";
+import * as queries from "../queries.js";
+import * as db from "../db.js";
+import { slugify } from "../helpers.js";
 import { InterfaceAdapter } from "./interface.js";
 
 export class DesktopAdapter extends InterfaceAdapter {
-  constructor({ port } = {}) {
+  constructor({ port = 9721, db: dbRef, cityCatalogPath } = {}) {
     super();
-    this.port = port || 9721;
-    this._connections = new Set();
-    // TODO: Start WebSocket server or stdin/stdout JSON protocol
+    this.port = port;
+    this.db = dbRef;
+    this.wss = null;
+    this.orchestrator = null;
+    this.assignedCities = new Set();
+
+    // Load city catalog
+    this.cityCatalog = [];
+    if (cityCatalogPath) {
+      try {
+        const raw = fs.readFileSync(cityCatalogPath, "utf-8");
+        this.cityCatalog = JSON.parse(raw);
+      } catch (err) {
+        if (err.code === 'ENOENT') {
+          console.warn(`[desktop] City catalog not found at ${cityCatalogPath}. Set CITY_CATALOG_PATH env var or place file at the expected location.`);
+        } else {
+          console.warn(`[desktop] Failed to parse city catalog at ${cityCatalogPath}: ${err.message}`);
+        }
+      }
+    }
+    this._cityIndex = 0;
+  }
+
+  setOrchestrator(orch) {
+    this.orchestrator = orch;
+  }
+
+  async start() {
+    return new Promise((resolve, reject) => {
+      this.wss = new WebSocketServer({ port: this.port });
+
+      this.wss.on("error", (err) => {
+        if (err.code === "EADDRINUSE") {
+          console.error(`[desktop] Port ${this.port} is already in use. Set DESKTOP_WS_PORT to use a different port.`);
+        }
+        reject(err);
+      });
+
+      this.wss.on("listening", () => {
+        this.wss.on("connection", (ws) => {
+          ws.send(JSON.stringify({ type: "welcome", version: "1.0" }));
+          ws.on("message", (raw) => this._handleMessage(ws, raw));
+        });
+        console.log(`Desktop adapter ready on ws://localhost:${this.port}`);
+        resolve();
+      });
+    });
+  }
+
+  async stop() {
+    if (this.wss) {
+      for (const client of this.wss.clients) {
+        client.close();
+      }
+      await new Promise((resolve) => this.wss.close(resolve));
+      this.wss = null;
+    }
+  }
+
+  // ─── Client Message Handler ─────────────────────────────────────────────────
+
+  async _handleMessage(ws, raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw.toString());
+    } catch {
+      ws.send(JSON.stringify({ type: "error", message: "Invalid JSON" }));
+      return;
+    }
+
+    try {
+      switch (msg.type) {
+        case "sync-request":
+          await this._handleSyncRequest(ws);
+          break;
+        case "create-feature":
+          await this._handleCreateFeature(ws, msg.payload || {});
+          break;
+        case "user-message":
+          await this._handleUserMessage(ws, msg.payload || {});
+          break;
+        case "resolve-decision":
+          await this._handleResolveDecision(ws, msg.payload || {});
+          break;
+        default:
+          ws.send(JSON.stringify({ type: "error", message: `Unknown message type: ${msg.type}` }));
+      }
+    } catch (err) {
+      console.error(`[desktop] Error handling ${msg.type}:`, err);
+      ws.send(JSON.stringify({ type: "error", message: err.message }));
+    }
+  }
+
+  async _handleSyncRequest(ws) {
+    const d = db.get();
+    if (!d) {
+      ws.send(JSON.stringify({ type: "error", message: "Database not ready" }));
+      return;
+    }
+    const features = queries.getAllFeatures();
+    const agents = d.prepare("SELECT * FROM agents ORDER BY updated_at DESC").all();
+    const decisions = d.prepare("SELECT * FROM decisions ORDER BY created_at DESC").all();
+    const events = d.prepare("SELECT * FROM events ORDER BY created_at DESC LIMIT 200").all();
+
+    ws.send(JSON.stringify({
+      type: "sync-response",
+      payload: { features, agents, decisions, events },
+      ts: Date.now(),
+    }));
+  }
+
+  async _handleCreateFeature(ws, payload) {
+    const slug = slugify(payload.description || "untitled");
+    const city = this._assignNextCity();
+
+    let feature = null;
+    if (this.orchestrator) {
+      feature = await this.orchestrator.initializeFeature(slug);
+    }
+
+    // Store city_id in feature metadata if we have a feature
+    if (feature && city) {
+      const metadata = queries.getFeatureMetadata(feature.id);
+      metadata.city_id = city.id;
+      metadata.city_name = city.name;
+      queries.updateFeatureMetadata(feature.id, metadata);
+    }
+
+    ws.send(JSON.stringify({
+      type: "feature-created",
+      payload: { feature, cityId: city ? city.id : null },
+      ts: Date.now(),
+    }));
+  }
+
+  async _handleUserMessage(ws, payload) {
+    if (!this.orchestrator) {
+      ws.send(JSON.stringify({ type: "error", message: "No orchestrator configured" }));
+      return;
+    }
+    if (!payload.featureId || !payload.text) {
+      ws.send(JSON.stringify({ type: "error", message: "Missing required fields: featureId, text" }));
+      return;
+    }
+    await this.orchestrator.routeUserMessage(payload.featureId, payload.text, "desktop");
+  }
+
+  async _handleResolveDecision(ws, payload) {
+    if (!this.orchestrator) {
+      ws.send(JSON.stringify({ type: "error", message: "No orchestrator configured" }));
+      return;
+    }
+    if (!payload.decisionId) {
+      ws.send(JSON.stringify({ type: "error", message: "Missing required field: decisionId" }));
+      return;
+    }
+    await this.orchestrator.handleDecisionClick(
+      payload.decisionId,
+      payload.optionId,
+      payload.feedback,
+    );
+  }
+
+  // ─── City Assignment ────────────────────────────────────────────────────────
+
+  _assignNextCity() {
+    if (this.cityCatalog.length === 0) return null;
+
+    // Find next unassigned city, wrapping around if all assigned
+    let city = null;
+
+    for (let i = 0; i < this.cityCatalog.length; i++) {
+      const candidate = this.cityCatalog[this._cityIndex % this.cityCatalog.length];
+      this._cityIndex = (this._cityIndex + 1) % this.cityCatalog.length;
+
+      if (!this.assignedCities.has(candidate.id)) {
+        city = candidate;
+        this.assignedCities.add(candidate.id);
+        return city;
+      }
+    }
+
+    // All cities assigned — wrap around, reset tracking, assign first
+    this.assignedCities.clear();
+    city = this.cityCatalog[this._cityIndex % this.cityCatalog.length];
+    this._cityIndex = (this._cityIndex + 1) % this.cityCatalog.length;
+    this.assignedCities.add(city.id);
+    return city;
   }
 
+  // ─── Broadcast Helper ──────────────────────────────────────────────────────
+
+  _broadcast(message) {
+    if (!this.wss) return;
+    const data = JSON.stringify(message);
+    for (const client of this.wss.clients) {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(data);
+      }
+    }
+  }
+
+  // ─── InterfaceAdapter Implementation ────────────────────────────────────────
+
   async createFeatureChannel(featureId, slug) {
-    this._emit("feature:created", { featureId, slug });
+    const city = this._assignNextCity();
+
+    // Store city in feature metadata
+    if (city) {
+      const metadata = queries.getFeatureMetadata(featureId);
+      metadata.city_id = city.id;
+      metadata.city_name = city.name;
+      queries.updateFeatureMetadata(featureId, metadata);
+    }
+
+    this._broadcast({
+      type: "feature-created",
+      payload: { featureId, slug, city },
+      ts: Date.now(),
+    });
+
     return `desktop-${slug}`;
   }
 
   async postMessage(featureId, text) {
     const ref = Date.now().toString();
-    this._emit("message", { featureId, text, ref });
+    this._broadcast({
+      type: "message",
+      payload: { featureId, text, ref },
+      ts: Date.now(),
+    });
     return { ref };
   }
 
   async postThreadMessage(featureId, text) {
-    this._emit("thread-message", { featureId, text });
+    this._broadcast({
+      type: "thread-message",
+      payload: { featureId, text },
+      ts: Date.now(),
+    });
   }
 
   async postPipelineMessage(featureId, text) {
     const ref = Date.now().toString();
-    this._emit("pipeline-message", { featureId, text, ref });
+    this._broadcast({
+      type: "pipeline-status",
+      payload: { featureId, text, ref },
+      ts: Date.now(),
+    });
     return { ref };
   }
 
   async postAgentResponse(featureId, agentLabel, content) {
     const ref = Date.now().toString();
-    this._emit("agent-response", { featureId, agentLabel, content, ref });
+    this._broadcast({
+      type: "agent-response",
+      payload: { featureId, agentLabel, content, ref },
+      ts: Date.now(),
+    });
     return { ref };
   }
 
   async uploadArtifact(featureId, filePath, title) {
-    this._emit("artifact", { featureId, filePath, title });
+    this._broadcast({
+      type: "artifact-uploaded",
+      payload: { featureId, filePath, title },
+      ts: Date.now(),
+    });
   }
 
   async postDecision(featureId, decision) {
     const ref = Date.now().toString();
-    this._emit("decision", { featureId, decision, ref });
-    // TODO: Wait for response event from Tauri client
+    this._broadcast({
+      type: "decision-posted",
+      payload: { featureId, decision, ref },
+      ts: Date.now(),
+    });
     return { ref };
   }
 
   async resolveDecisionMessage(featureId, messageRef, decisionId, selectedOption, selectedLabel, resolvedBy, feedback) {
-    this._emit("decision-resolved", { featureId, decisionId, selectedOption, selectedLabel, resolvedBy, feedback });
+    this._broadcast({
+      type: "decision-resolved",
+      payload: { featureId, messageRef, decisionId, selectedOption, selectedLabel, resolvedBy, feedback },
+      ts: Date.now(),
+    });
   }
 
   async postPlanForApproval(featureId, planDir) {
-    return this.postDecision(featureId, {
-      id: "plan-approval",
-      title: "Plan ready for approval",
-      context: "All planning phases complete.",
-      options: [
-        { id: "approve", label: "Approve Plan", style: "primary" },
-        { id: "reject", label: "Reject Plan", style: "danger" },
-      ],
+    // List artifact files in the plan directory
+    let artifacts = [];
+    try {
+      artifacts = fs.readdirSync(planDir).filter((f) => !f.startsWith("."));
+    } catch {
+      // planDir may not exist yet
+    }
+
+    const ref = Date.now().toString();
+    this._broadcast({
+      type: "plan-approval",
+      payload: { featureId, planDir, artifacts, ref },
+      ts: Date.now(),
     });
+    return { ref };
   }
 
   async postFeatureComplete(featureId) {
-    this._emit("feature-complete", { featureId });
+    this._broadcast({
+      type: "feature-complete",
+      payload: { featureId },
+      ts: Date.now(),
+    });
+  }
+
+  async pinMessage(_featureId, _messageTs) {
+    // No-op — desktop app doesn't need pinning
   }
 
-  _emit(event, data) {
-    // TODO: Send over WebSocket / stdout
-    console.log(`[desktop] ${event}:`, JSON.stringify(data).slice(0, 200));
+  async markProcessing(featureId, messageRef) {
+    this._broadcast({
+      type: "processing-start",
+      payload: { featureId, messageRef },
+      ts: Date.now(),
+    });
+  }
+
+  async clearProcessing(featureId, messageRef) {
+    this._broadcast({
+      type: "processing-end",
+      payload: { featureId, messageRef },
+      ts: Date.now(),
+    });
   }
 }

package/v3/artifact-portal.js

@@ -308,11 +308,10 @@ export class ArtifactPortal {
   }
 
   _getReviewSessionsForFeature(featureId) {
-    try {
-      return queries.getReviewSessionsByFeature(featureId);
-    } catch {
-      return [];
-    }
+    if (!this._reviewSessions) return [];
+    // Derive from in-memory sessions — no DB query needed
+    return this._reviewSessions.getAllSessions()
+      .filter(s => s.decisionId.includes(queries.getFeatureById(featureId)?.slug || "~~none~~"));
   }
 
   // ─── Shared CSS ────────────────────────────────────────────────────

package/v3/bridge-desktop.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+// bridge-desktop.js — Desktop companion app bridge.
+//
+// Mirrors bridge-v3.js (Slack bridge) but uses DesktopAdapter (WebSocket)
+// instead of SlackAdapter. No Slack tokens required.
+//
+// Usage: node v3/bridge-desktop.js
+
+import path from "node:path";
+import * as db from "./db.js";
+import { DesktopAdapter } from "./adapters/desktop-adapter.js";
+import { Orchestrator } from "./orchestrator.js";
+import { Recovery } from "./recovery.js";
+import { ReviewSessionManager } from "./review-sessions.js";
+import { DB_PATH, PORTAL_PORT } from "./constants.js";
+import { ArtifactPortal } from "./artifact-portal.js";
+
+let _orchestrator = null;
+let _portal = null;
+let _adapter = null;
+
+// ─── Config ──────────────────────────────────────────────────────────────────
+
+const WS_PORT = process.env.DESKTOP_WS_PORT
+  ? parseInt(process.env.DESKTOP_WS_PORT, 10)
+  : 9721;
+
+const ARTIFACT_PORT = process.env.ARTIFACT_PORT
+  ? parseInt(process.env.ARTIFACT_PORT, 10)
+  : PORTAL_PORT;
+
+const CITY_CATALOG_PATH =
+  process.env.CITY_CATALOG_PATH ||
+  path.resolve(import.meta.dirname, "../data/city-catalog.json");
+
+// ─── Startup ─────────────────────────────────────────────────────────────────
+
+async function start() {
+  console.log("Starting Iriai Desktop Bridge (SQLite-backed)...");
+
+  // 1. Open database
+  try {
+    db.open(DB_PATH);
+  } catch (err) {
+    console.error(`[desktop-bridge] Failed to open database at ${DB_PATH}:`, err.message);
+    process.exit(1);
+  }
+  console.log(`Database opened: ${DB_PATH}`);
+
+  // 2. Create DesktopAdapter
+  const adapter = new DesktopAdapter({
+    port: WS_PORT,
+    db: null,
+    cityCatalogPath: CITY_CATALOG_PATH,
+  });
+  _adapter = adapter;
+
+  // 3. Create orchestrator with review session support
+  const reviewSessions = new ReviewSessionManager();
+  const orchestrator = new Orchestrator({ adapter, reviewSessions });
+  _orchestrator = orchestrator;
+  adapter.setOrchestrator(orchestrator);
+
+  // 4. Start artifact portal
+  const portal = new ArtifactPortal({ reviewSessions });
+  _portal = portal;
+  await portal.start(ARTIFACT_PORT);
+
+  // 5. Run recovery (process stale signals, reattach running agents)
+  const recovery = new Recovery({ orchestrator, adapter });
+  await recovery.run();
+
+  // 6. Start stale signal safety net
+  orchestrator.startStaleScan();
+
+  // 7. Start WebSocket server
+  await adapter.start();
+
+  console.log(`Desktop bridge ready on ws://localhost:${WS_PORT}`);
+}
+
+// ─── Graceful Shutdown ───────────────────────────────────────────────────────
+
+async function shutdown(signal) {
+  console.log(`\n[desktop-bridge] ${signal} received — shutting down gracefully`);
+
+  if (_adapter) {
+    await _adapter.stop();
+  }
+
+  if (_portal) {
+    await _portal.stop();
+  }
+
+  if (_orchestrator) {
+    await _orchestrator.shutdown();
+  }
+
+  db.close();
+  console.log("[desktop-bridge] Database closed. Exiting.");
+  process.exit(0);
+}
+
+process.on("SIGINT", () => shutdown("SIGINT"));
+process.on("SIGTERM", () => shutdown("SIGTERM"));
+
+process.on("unhandledRejection", (err) => {
+  console.error("[desktop-bridge] Unhandled rejection (non-fatal):", err?.message || err);
+});
+
+start().catch((err) => {
+  console.error("[desktop-bridge] Fatal:", err);
+  process.exit(1);
+});

package/v3/operator.js

@@ -30,6 +30,7 @@ export async function invokeOperator({ feature, operatorDir, flDir, featureDir,
   const history = await assembleHistory(feature.id);
   const activeAgents = assembleActiveAgents(feature.id);
   const pendingDecision = assemblePendingDecision(feature.id);
+  const routingTable = assembleRoutingTable(feature.id);
 
   const projectRoot = process.env.PROJECT_ROOT || process.cwd();
   const directoryMap = path.join(projectRoot, "DIRECTORY_MAP.MD");
@@ -47,6 +48,7 @@ export async function invokeOperator({ feature, operatorDir, flDir, featureDir,
     planDir,
     activePlanningRole,
     directoryMap,
+    routingTable,
   });
 
   // 3. Spawn claude via supervisor — default to --continue for session context,
@@ -232,6 +234,20 @@ export function assembleActiveAgents(featureId) {
   }).join("\n");
 }
 
+/**
+ * Assemble a routing table of all agent keys for this feature.
+ * Gives the Operator exact keys to use in [ROUTE:] blocks.
+ */
+export function assembleRoutingTable(featureId) {
+  const agents = queries.getAgentsByFeature(featureId);
+  if (!agents.length) return "(no agents registered)";
+
+  return agents
+    .filter(a => a.agent_type !== "operator") // exclude self
+    .map(a => `- [ROUTE:${a.agent_key}] → ${a.role_name || a.agent_type}${a.team_num ? ` (team ${a.team_num})` : ""} — ${a.status}`)
+    .join("\n");
+}
+
 /**
  * Assemble pending decision info.
  */