@askexenow/exe-os 0.9.227 → 0.9.229

package/dist/chunk-3JP3FY33.js

@@ -0,0 +1,258 @@
+// src/lib/message-queue.ts
+var DEFAULT_MAX_SIZE = 1e3;
+var DEFAULT_TTL_MS = 5 * 60 * 1e3;
+var MessageQueue = class {
+  queue = [];
+  maxSize;
+  ttlMs;
+  constructor(maxSize = DEFAULT_MAX_SIZE, ttlMs = DEFAULT_TTL_MS) {
+    this.maxSize = maxSize;
+    this.ttlMs = ttlMs;
+  }
+  /** Add a message to the queue. Drops oldest if at capacity. */
+  enqueue(data) {
+    this.pruneExpired();
+    if (this.queue.length >= this.maxSize) {
+      process.stderr.write(`[msg-queue] Dropping oldest message (queue at ${this.maxSize} cap)
+`);
+      this.queue.shift();
+    }
+    this.queue.push({ data, enqueuedAt: Date.now() });
+  }
+  /** Remove and return all queued messages (oldest first). Prunes expired entries. */
+  flush() {
+    this.pruneExpired();
+    const messages = this.queue.map((m) => m.data);
+    this.queue = [];
+    return messages;
+  }
+  /** Current number of queued (non-expired) messages. */
+  get size() {
+    this.pruneExpired();
+    return this.queue.length;
+  }
+  /** Remove all messages from the queue. */
+  clear() {
+    this.queue = [];
+  }
+  /** Remove messages whose TTL has expired. */
+  pruneExpired() {
+    const now = Date.now();
+    this.queue = this.queue.filter((m) => now - m.enqueuedAt < this.ttlMs);
+  }
+};
+
+// src/lib/gateway-client.ts
+var MIN_RECONNECT_MS = 1e3;
+var MAX_RECONNECT_MS = 3e4;
+var AUTH_RESPONSE_TIMEOUT_MS = 5e3;
+var DEFAULT_CHANNELS = ["all"];
+var GATEWAY_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "message_received",
+  "response_sent",
+  "agent_status",
+  "health",
+  "escalation"
+]);
+function createGatewayClient(config) {
+  assertSecureWsUrl(config.url);
+  let ws = null;
+  let currentStatus = "disconnected";
+  let closed = false;
+  let reconnectDelay = MIN_RECONNECT_MS;
+  let reconnectTimer = null;
+  let authTimer = null;
+  const eventHandlers = /* @__PURE__ */ new Set();
+  const statusHandlers = /* @__PURE__ */ new Set();
+  const channels = config.channels ?? DEFAULT_CHANNELS;
+  const outboundQueue = new MessageQueue();
+  function setStatus(next) {
+    if (next === currentStatus) return;
+    currentStatus = next;
+    for (const handler of statusHandlers) {
+      handler(next);
+    }
+  }
+  function connect() {
+    if (closed) return;
+    setStatus("connecting");
+    try {
+      ws = new WebSocket(config.url);
+      ws.onopen = () => {
+        setStatus("authenticating");
+        sendRaw({ type: "auth", token: config.authTokenHex });
+        authTimer = setTimeout(() => {
+          if (currentStatus === "authenticating") {
+            ws?.close();
+          }
+        }, AUTH_RESPONSE_TIMEOUT_MS);
+      };
+      ws.onmessage = (event) => {
+        const data = typeof event.data === "string" ? event.data : String(event.data);
+        handleMessage(data);
+      };
+      ws.onclose = () => {
+        clearAuthTimer();
+        if (!closed) {
+          setStatus("reconnecting");
+          scheduleReconnect();
+        } else {
+          setStatus("disconnected");
+        }
+      };
+      ws.onerror = () => {
+      };
+    } catch {
+      setStatus("reconnecting");
+      scheduleReconnect();
+    }
+  }
+  function handleMessage(raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (msg.type === "auth" && msg.status === "ok") {
+      clearAuthTimer();
+      reconnectDelay = MIN_RECONNECT_MS;
+      setStatus("connected");
+      if (channels.length > 0) {
+        sendRaw({ type: "subscribe", channels });
+      }
+      const queued = outboundQueue.flush();
+      for (const data of queued) {
+        try {
+          ws?.send(data);
+        } catch {
+        }
+      }
+      return;
+    }
+    if (msg.type === "error" && currentStatus === "authenticating") {
+      clearAuthTimer();
+      ws?.close();
+      return;
+    }
+    if (msg.type === "ping") {
+      sendRaw({ type: "pong" });
+      return;
+    }
+    if (currentStatus === "connected" && isGatewayEvent(msg)) {
+      for (const handler of eventHandlers) {
+        handler(msg);
+      }
+    }
+  }
+  function sendRaw(data) {
+    if (ws?.readyState === WebSocket.OPEN) {
+      try {
+        ws.send(JSON.stringify(data));
+      } catch {
+      }
+    }
+  }
+  function scheduleReconnect() {
+    if (closed || reconnectTimer) return;
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = null;
+      reconnectDelay = Math.min(reconnectDelay * 2, MAX_RECONNECT_MS);
+      connect();
+    }, reconnectDelay);
+  }
+  function clearAuthTimer() {
+    if (authTimer) {
+      clearTimeout(authTimer);
+      authTimer = null;
+    }
+  }
+  connect();
+  return {
+    get status() {
+      return currentStatus;
+    },
+    get queueSize() {
+      return outboundQueue.size;
+    },
+    send(data) {
+      const serialized = JSON.stringify(data);
+      if (currentStatus === "connected" && ws?.readyState === WebSocket.OPEN) {
+        try {
+          ws.send(serialized);
+        } catch {
+          outboundQueue.enqueue(serialized);
+        }
+      } else {
+        outboundQueue.enqueue(serialized);
+      }
+    },
+    onEvent(handler) {
+      eventHandlers.add(handler);
+      return () => {
+        eventHandlers.delete(handler);
+      };
+    },
+    onStatusChange(handler) {
+      statusHandlers.add(handler);
+      return () => {
+        statusHandlers.delete(handler);
+      };
+    },
+    close() {
+      closed = true;
+      clearAuthTimer();
+      outboundQueue.clear();
+      if (reconnectTimer) {
+        clearTimeout(reconnectTimer);
+        reconnectTimer = null;
+      }
+      if (ws) {
+        try {
+          ws.close();
+        } catch {
+        }
+        ws = null;
+      }
+      setStatus("disconnected");
+    }
+  };
+}
+async function connectGateway(url) {
+  const { getMasterKey } = await import("./lib/keychain.js");
+  const { deriveWsAuthToken } = await import("./lib/ws-auth.js");
+  const masterKey = await getMasterKey();
+  if (!masterKey) return null;
+  const token = deriveWsAuthToken(masterKey);
+  return createGatewayClient({
+    url,
+    authTokenHex: token.toString("hex")
+  });
+}
+var LOCALHOST_PATTERNS = /^(localhost|127\.0\.0\.1|\[::1\])$/i;
+function assertSecureWsUrl(url) {
+  if (url.startsWith("wss://")) return;
+  if (url.startsWith("ws://")) {
+    let parsed;
+    try {
+      parsed = new URL(url);
+    } catch {
+      throw new Error(
+        `Malformed WebSocket URL rejected: "${url}".`
+      );
+    }
+    if (LOCALHOST_PATTERNS.test(parsed.hostname)) return;
+    throw new Error(
+      `Insecure WebSocket URL rejected: "${url}". Use wss:// for remote hosts. Plain ws:// is only allowed for localhost.`
+    );
+  }
+}
+function isGatewayEvent(msg) {
+  return typeof msg.type === "string" && GATEWAY_EVENT_TYPES.has(msg.type);
+}
+
+export {
+  createGatewayClient,
+  connectGateway,
+  assertSecureWsUrl
+};

package/dist/chunk-3MK3R5E6.js

@@ -0,0 +1,85 @@
+import {
+  deactivateBehavior
+} from "./chunk-7DNX45WB.js";
+import {
+  getActiveAgent
+} from "./chunk-DLXTKVBO.js";
+import {
+  canCoordinate,
+  getClient
+} from "./chunk-UJOSFVWG.js";
+
+// src/mcp/tools/deactivate-behavior.ts
+import { z } from "zod";
+function registerDeactivateBehavior(server) {
+  server.registerTool(
+    "deactivate_behavior",
+    {
+      title: "Deactivate Behavior",
+      description: "Soft-delete a behavior by setting active = 0. RESTRICTED: only coordinator or founder sessions can use this. Use list_behaviors to find the behavior ID first.",
+      inputSchema: {
+        behavior_id: z.string().describe("UUID of the behavior to deactivate")
+      }
+    },
+    async ({ behavior_id }) => {
+      const caller = getActiveAgent();
+      try {
+        const { StewardGate } = await import("./steward-gate-6IKH335D.js");
+        const steward = new StewardGate();
+        const gateDecision = await steward.checkAuthority(caller.agentId || "unknown", "deactivate_behavior", behavior_id);
+        if (!gateDecision.allowed) {
+          return { content: [{ type: "text", text: `Steward gate denied: ${gateDecision.reason}` }], isError: true };
+        }
+      } catch {
+      }
+      const allowed = canCoordinate(caller.agentId, caller.agentRole);
+      if (!allowed) {
+        return {
+          content: [{
+            type: "text",
+            text: `Permission denied. Only the coordinator or founder sessions can deactivate behaviors. You are "${caller.agentId}".`
+          }],
+          isError: true
+        };
+      }
+      const client = getClient();
+      const result = await client.execute({
+        sql: `SELECT id, agent_id, content, domain, priority FROM behaviors WHERE id = ?`,
+        args: [behavior_id]
+      });
+      if (result.rows.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: `Behavior not found: ${behavior_id}`
+          }],
+          isError: true
+        };
+      }
+      const row = result.rows[0];
+      const wasActive = await deactivateBehavior(behavior_id);
+      if (!wasActive) {
+        return {
+          content: [{
+            type: "text",
+            text: `Behavior ${behavior_id} was already inactive.`
+          }]
+        };
+      }
+      return {
+        content: [{
+          type: "text",
+          text: `Deactivated behavior for ${row.agent_id}.
+ID: ${row.id}
+Domain: ${row.domain ?? "none"}
+Priority: ${row.priority}
+Content: ${row.content}`
+        }]
+      };
+    }
+  );
+}
+
+export {
+  registerDeactivateBehavior
+};

package/dist/chunk-46SQTBQW.js

@@ -0,0 +1,207 @@
+// src/lib/graph-export.ts
+async function loadGraphData(client) {
+  const entityResult = await client.execute(`
+    SELECT e.id, e.name, e.type,
+      (SELECT COUNT(*) FROM relationships r WHERE r.source_entity_id = e.id OR r.target_entity_id = e.id) as degree
+    FROM entities e
+    ORDER BY degree DESC
+  `);
+  const nodes = entityResult.rows.map((row) => ({
+    id: String(row.id),
+    label: String(row.name),
+    type: String(row.type),
+    degree: Number(row.degree ?? 0)
+  }));
+  const relResult = await client.execute(`
+    SELECT source_entity_id, target_entity_id, type, weight,
+           COALESCE(confidence, 1.0) as confidence,
+           COALESCE(confidence_label, 'extracted') as confidence_label
+    FROM relationships
+  `);
+  const edges = relResult.rows.map((row) => ({
+    from: String(row.source_entity_id),
+    to: String(row.target_entity_id),
+    label: String(row.type),
+    weight: Number(row.weight),
+    confidence: Number(row.confidence),
+    confidenceLabel: String(row.confidence_label)
+  }));
+  return { nodes, edges };
+}
+function detectCommunities(nodes, edges) {
+  const communities = /* @__PURE__ */ new Map();
+  nodes.forEach((n, i) => communities.set(n.id, i));
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    if (!adjacency.has(e.from)) adjacency.set(e.from, []);
+    if (!adjacency.has(e.to)) adjacency.set(e.to, []);
+    adjacency.get(e.from).push(e.to);
+    adjacency.get(e.to).push(e.from);
+  }
+  for (let iter = 0; iter < 5; iter++) {
+    for (const node of nodes) {
+      const neighbors = adjacency.get(node.id) ?? [];
+      if (neighbors.length === 0) continue;
+      const counts = /* @__PURE__ */ new Map();
+      for (const n of neighbors) {
+        const c = communities.get(n) ?? 0;
+        counts.set(c, (counts.get(c) ?? 0) + 1);
+      }
+      let maxCount = 0;
+      let maxCommunity = communities.get(node.id) ?? 0;
+      for (const [c, count] of counts) {
+        if (count > maxCount) {
+          maxCount = count;
+          maxCommunity = c;
+        }
+      }
+      communities.set(node.id, maxCommunity);
+    }
+  }
+  return communities;
+}
+var TYPE_COLORS = {
+  person: "#F5D76E",
+  project: "#6B4C9A",
+  tool: "#22C55E",
+  decision: "#EF4444",
+  concept: "#3B82F6",
+  file: "#6B7280",
+  rationale: "#F97316"
+};
+async function exportGraphHTML(client, projectName) {
+  const { nodes, edges } = await loadGraphData(client);
+  if (nodes.length === 0) return "<html><body>No graph data.</body></html>";
+  const communities = detectCommunities(nodes, edges);
+  for (const node of nodes) {
+    node.community = communities.get(node.id) ?? 0;
+  }
+  const visNodes = nodes.map((n) => ({
+    id: n.id,
+    label: n.label,
+    size: Math.max(10, Math.min(50, n.degree * 5)),
+    color: TYPE_COLORS[n.type] ?? "#999",
+    title: `${n.label} (${n.type})
+Degree: ${n.degree}
+Community: ${n.community}`,
+    group: n.type
+  }));
+  const visEdges = edges.map((e, i) => ({
+    id: `e${i}`,
+    from: e.from,
+    to: e.to,
+    label: e.label,
+    width: Math.max(1, e.weight),
+    color: e.confidenceLabel === "ambiguous" ? "#EF4444" : e.confidenceLabel === "inferred" ? "#F59E0B" : "#6B7280",
+    title: `${e.label} (confidence: ${e.confidence.toFixed(1)}, ${e.confidenceLabel})`
+  }));
+  const title = projectName ? `${projectName} Knowledge Graph` : "exe-os Knowledge Graph";
+  return `<!DOCTYPE html>
+<html>
+<head>
+<title>${title}</title>
+<style>
+  body { margin: 0; background: #0F0E1A; color: #F0EDE8; font-family: 'Manrope', sans-serif; }
+  #graph { width: 100%; height: 80vh; border: 1px solid #3D3660; }
+  #sidebar { padding: 16px; background: #1A1830; }
+  #search { width: 300px; padding: 8px; background: #2A2840; color: #F0EDE8; border: 1px solid #3D3660; border-radius: 4px; margin: 8px; }
+  .stat { color: #6B4C9A; margin: 4px 8px; }
+  h1 { color: #F5D76E; margin: 8px; font-size: 1.5em; }
+  .legend { display: flex; gap: 12px; margin: 8px; flex-wrap: wrap; }
+  .legend-item { display: flex; align-items: center; gap: 4px; font-size: 0.85em; }
+  .legend-dot { width: 10px; height: 10px; border-radius: 50%; }
+</style>
+<script src="https://unpkg.com/vis-network@9.1.9/standalone/umd/vis-network.min.js"></script>
+</head>
+<body>
+<div id="sidebar">
+  <h1>${title}</h1>
+  <input id="search" placeholder="Search entities..." oninput="filterGraph(this.value)">
+  <div class="legend">
+    ${Object.entries(TYPE_COLORS).map(
+    ([type, color]) => `<span class="legend-item"><span class="legend-dot" style="background:${color}"></span>${type}</span>`
+  ).join("")}
+  </div>
+  <span class="stat">${nodes.length} nodes</span>
+  <span class="stat">${edges.length} edges</span>
+</div>
+<div id="graph"></div>
+<script>
+var nodes = new vis.DataSet(${JSON.stringify(visNodes)});
+var edges = new vis.DataSet(${JSON.stringify(visEdges)});
+var container = document.getElementById('graph');
+var network = new vis.Network(container, {nodes: nodes, edges: edges}, {
+  physics: { solver: 'forceAtlas2Based', forceAtlas2Based: { gravitationalConstant: -50 } },
+  edges: { arrows: 'to', font: { size: 9, color: '#6B4C9A' } },
+  nodes: { font: { color: '#F0EDE8' }, shape: 'dot' },
+  interaction: { hover: true, tooltipDelay: 100 }
+});
+function filterGraph(query) {
+  if (!query) { nodes.forEach(function(n) { nodes.update({id: n.id, hidden: false}); }); return; }
+  var q = query.toLowerCase();
+  nodes.forEach(function(n) { nodes.update({id: n.id, hidden: !n.label.toLowerCase().includes(q)}); });
+}
+</script>
+</body>
+</html>`;
+}
+async function generateGraphReport(client, projectName) {
+  const { nodes, edges } = await loadGraphData(client);
+  if (nodes.length === 0) return "# Graph Report\n\nNo graph data yet. Run graph extraction first.";
+  const communities = detectCommunities(nodes, edges);
+  for (const node of nodes) {
+    node.community = communities.get(node.id) ?? 0;
+  }
+  const godNodes = [...nodes].sort((a, b) => b.degree - a.degree).slice(0, 10);
+  const communityMap = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const c = node.community ?? 0;
+    if (!communityMap.has(c)) communityMap.set(c, []);
+    communityMap.get(c).push(node);
+  }
+  const topCommunities = [...communityMap.entries()].sort((a, b) => b[1].length - a[1].length).slice(0, 10);
+  const ambiguous = edges.filter((e) => e.confidenceLabel === "ambiguous");
+  const crossCommunity = edges.filter((e) => {
+    const fromC = communities.get(e.from);
+    const toC = communities.get(e.to);
+    return fromC !== void 0 && toC !== void 0 && fromC !== toC;
+  }).slice(0, 10);
+  let hyperedgeCount = 0;
+  try {
+    const result = await client.execute("SELECT COUNT(*) as cnt FROM hyperedges");
+    hyperedgeCount = Number(result.rows[0]?.cnt ?? 0);
+  } catch {
+  }
+  const nodeLabels = new Map(nodes.map((n) => [n.id, n.label]));
+  const lines = [
+    `# Knowledge Graph Report${projectName ? ` \u2014 ${projectName}` : ""}`,
+    "",
+    `Generated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`,
+    "",
+    "## Stats",
+    `- **Nodes:** ${nodes.length}`,
+    `- **Edges:** ${edges.length}`,
+    `- **Hyperedges:** ${hyperedgeCount}`,
+    `- **Communities:** ${communityMap.size}`,
+    "",
+    "## God Nodes (highest connectivity)",
+    ...godNodes.map((n) => `- **${n.label}** (${n.type}) \u2014 ${n.degree} connections`),
+    "",
+    "## Communities",
+    ...topCommunities.map(
+      ([id, members]) => `- **Community ${id}** (${members.length} nodes): ${members.slice(0, 8).map((m) => m.label).join(", ")}${members.length > 8 ? "\u2026" : ""}`
+    ),
+    "",
+    "## Cross-Community Connections",
+    crossCommunity.length > 0 ? crossCommunity.map((e) => `- ${nodeLabels.get(e.from) ?? e.from} \u2192[${e.label}]\u2192 ${nodeLabels.get(e.to) ?? e.to}`).join("\n") : "None detected",
+    "",
+    "## Open Questions (ambiguous edges)",
+    ambiguous.length > 0 ? ambiguous.map((e) => `- [${e.confidence.toFixed(1)}] ${nodeLabels.get(e.from) ?? e.from} \u2192[${e.label}]\u2192 ${nodeLabels.get(e.to) ?? e.to}`).join("\n") : "No ambiguous edges"
+  ];
+  return lines.join("\n");
+}
+
+export {
+  exportGraphHTML,
+  generateGraphReport
+};

package/dist/chunk-4JERP7NT.js

@@ -0,0 +1,132 @@
+// src/lib/typed-messages.ts
+function parseMessage(content) {
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed && typeof parsed === "object" && parsed.v === 1 && typeof parsed.type === "string") {
+      return parsed;
+    }
+  } catch {
+  }
+  return { type: "legacy", text: content };
+}
+function isTypedMessage(msg) {
+  return msg.type !== "legacy" && "v" in msg;
+}
+function buildTaskResult(opts) {
+  return {
+    v: 1,
+    type: "task_result",
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    from: opts.from,
+    payload: {
+      task_id: opts.task_id,
+      summary: opts.summary,
+      files_changed: opts.files_changed ?? [],
+      decisions: opts.decisions ?? [],
+      open_questions: opts.open_questions ?? [],
+      pr_number: opts.pr_number,
+      commits: opts.commits ?? [],
+      tests: opts.tests ?? "none",
+      build: opts.build ?? "skip"
+    }
+  };
+}
+function buildTypedMessage(opts) {
+  return {
+    v: 1,
+    type: opts.type,
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    from: opts.from,
+    payload: opts.payload
+  };
+}
+function serializeMessage(msg) {
+  return JSON.stringify(msg);
+}
+var TYPE_BADGES = {
+  task_result: "\u{1F4CB} TASK RESULT",
+  status_update: "\u{1F4CA} STATUS UPDATE",
+  question: "\u2753 QUESTION",
+  blocker: "\u{1F6AB} BLOCKER",
+  handoff: "\u{1F91D} HANDOFF",
+  review_request: "\u{1F4DD} REVIEW REQUEST"
+};
+function formatTypedMessage(msg) {
+  const badge = TYPE_BADGES[msg.type] ?? msg.type.toUpperCase();
+  const lines = [`[${badge}] from ${msg.from} at ${msg.ts}`];
+  switch (msg.type) {
+    case "task_result": {
+      const p = msg.payload;
+      lines.push(`Summary: ${p.summary}`);
+      if (p.files_changed.length > 0)
+        lines.push(`Files: ${p.files_changed.join(", ")}`);
+      if (p.decisions.length > 0)
+        lines.push(`Decisions: ${p.decisions.join("; ")}`);
+      if (p.commits.length > 0)
+        lines.push(`Commits: ${p.commits.join(", ")}`);
+      lines.push(`Tests: ${p.tests} | Build: ${p.build}`);
+      if (p.pr_number) lines.push(`PR: #${p.pr_number}`);
+      if (p.open_questions.length > 0)
+        lines.push(`Open questions: ${p.open_questions.join("; ")}`);
+      break;
+    }
+    case "status_update": {
+      const p = msg.payload;
+      lines.push(`Task: ${p.task_id} | Progress: ${p.progress_pct}%`);
+      lines.push(`Current step: ${p.current_step}`);
+      if (p.blockers.length > 0)
+        lines.push(`Blockers: ${p.blockers.join("; ")}`);
+      if (p.eta_minutes) lines.push(`ETA: ${p.eta_minutes}min`);
+      break;
+    }
+    case "question": {
+      const p = msg.payload;
+      lines.push(`Question: ${p.question}`);
+      lines.push(`Context: ${p.context}`);
+      if (p.options?.length) lines.push(`Options: ${p.options.join(" | ")}`);
+      break;
+    }
+    case "blocker": {
+      const p = msg.payload;
+      lines.push(`Task: ${p.task_id} | Severity: ${p.severity}`);
+      lines.push(`Blocker: ${p.blocker}`);
+      lines.push(`Needs action from: ${p.needs_action_from}`);
+      if (p.attempted.length > 0)
+        lines.push(`Attempted: ${p.attempted.join("; ")}`);
+      break;
+    }
+    case "handoff": {
+      const p = msg.payload;
+      lines.push(`From task: ${p.from_task_id}`);
+      if (p.to_task_id) lines.push(`To task: ${p.to_task_id}`);
+      lines.push(`Done: ${p.context.what_was_done}`);
+      lines.push(`Needs: ${p.context.what_needs_doing}`);
+      if (p.context.key_files.length > 0)
+        lines.push(`Key files: ${p.context.key_files.join(", ")}`);
+      if (p.context.pitfalls.length > 0)
+        lines.push(`Pitfalls: ${p.context.pitfalls.join("; ")}`);
+      break;
+    }
+    case "review_request": {
+      const p = msg.payload;
+      lines.push(`Summary: ${p.summary}`);
+      if (p.files_changed.length > 0)
+        lines.push(`Files: ${p.files_changed.join(", ")}`);
+      lines.push(`Tests: ${p.tests_status} | Build: ${p.build_status}`);
+      if (p.pr_number) lines.push(`PR: #${p.pr_number}`);
+      if (p.review_focus.length > 0)
+        lines.push(`Focus: ${p.review_focus.join("; ")}`);
+      break;
+    }
+  }
+  return lines.join("\n");
+}
+
+export {
+  parseMessage,
+  isTypedMessage,
+  buildTaskResult,
+  buildTypedMessage,
+  serializeMessage,
+  formatTypedMessage
+};