wireal-run 0.1.0

package/bin/mcp-stdio.mjs

@@ -0,0 +1,2567 @@
+// runner/mcp-stdio.ts
+import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
+
+// mcp/create-server.ts
+import { McpServer } from "@modelcontextprotocol/server";
+import * as z from "zod/v4";
+
+// src/orb-settings.ts
+function makeOrb(color) {
+  return { colors: [color, "#d6ecff", "#292139"], speed: 0.65, distortion: 0.75, swirl: 0.55, phase: 20 };
+}
+var defaultStatusOrbs = { proposed: makeOrb("#a78bfa"), todo: makeOrb("#9aacc4"), doing: makeOrb("#efb94b"), done: makeOrb("#45d797") };
+var wholeMapOrb = { colors: ["#000000", "#ffffff", "#ffffff"], speed: 0.18, distortion: 0.28, swirl: 0.2, phase: 0 };
+var orbPresets = [
+  { name: "Jade", orb: makeOrb("#45d797") },
+  { name: "Ocean", orb: { ...makeOrb("#408cff"), colors: ["#408cff", "#6bf1db", "#241a63"] } },
+  { name: "Amber", orb: { ...makeOrb("#ffb33e"), colors: ["#ffb33e", "#ffe8a2", "#bf4178"] } },
+  { name: "Rose", orb: { ...makeOrb("#ef6387"), colors: ["#ef6387", "#ffc8ad", "#673acc"] } }
+];
+function validOrb(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return Array.isArray(v.colors) && v.colors.length === 3 && v.colors.every((c) => /^#[a-f\d]{6}$/i.test(c)) && Number.isFinite(v.speed) && v.speed >= 0 && v.speed <= 2 && Number.isFinite(v.distortion) && v.distortion >= 0 && v.distortion <= 1 && Number.isFinite(v.swirl) && v.swirl >= 0 && v.swirl <= 1 && Number.isFinite(v.phase) && v.phase >= 0 && v.phase <= 100;
+}
+
+// src/domain.ts
+var statuses = {
+  proposed: "Proposed",
+  todo: "To do",
+  doing: "Doing",
+  done: "Done"
+};
+function normalizeProjectPath(input) {
+  let path = input.trim().replace(/\/{2,}/g, "/");
+  while (path.startsWith("./") || path.startsWith("/"))
+    path = path.startsWith("./") ? path.slice(2) : path.slice(1);
+  return path.replace(/\/+$/g, "");
+}
+function projectPaths(project) {
+  return [
+    ...new Set((project.paths ?? []).map(normalizeProjectPath).filter(Boolean))
+  ];
+}
+var activityKinds = [
+  "change",
+  "discovery",
+  "decision",
+  "verification",
+  "blocker"
+];
+var repositoryLayouts = ["monorepo", "multirepo"];
+function workspaceKind(state) {
+  return state.map.kind ?? "coding";
+}
+var uid = () => crypto.randomUUID();
+var taskReferenceId = (tasks = []) => {
+  const highest = tasks.reduce((top, task) => {
+    const value = Number(task.referenceId);
+    return Number.isSafeInteger(value) && value > top ? value : top;
+  }, 0);
+  return String(highest + 1);
+};
+var validReferenceId = (value) => typeof value === "string" && /^[1-9][0-9]{0,8}$/.test(value);
+var event = (text, author = {
+  author: "Wireal AI",
+  authorType: "ai"
+}) => ({
+  id: uid(),
+  text,
+  at: (/* @__PURE__ */ new Date()).toISOString(),
+  ...author
+});
+function canConnect(state, source, target) {
+  const a = state.tasks.find((t) => t.id === source), b = state.tasks.find((t) => t.id === target);
+  if (!a || !b || source === target) return false;
+  const edges = [
+    ...state.links,
+    ...state.tasks.filter((t) => t.parentId).map((t) => ({ source: t.parentId, target: t.id }))
+  ];
+  if (edges.some((e) => e.source === source && e.target === target))
+    return false;
+  const visited = /* @__PURE__ */ new Set();
+  const reaches = (id) => {
+    if (id === source) return true;
+    if (visited.has(id)) return false;
+    visited.add(id);
+    return edges.filter((e) => e.source === id).some((e) => reaches(e.target));
+  };
+  return !reaches(target);
+}
+function updateTask(state, id, patch, message, author) {
+  if (patch.name !== void 0 && !patch.name.trim())
+    throw new Error("A task needs a name.");
+  if (patch.projectIds && (!patch.projectIds.length || patch.projectIds.some((id2) => !state.projects.some((p) => p.id === id2))))
+    throw new Error("Choose at least one project.");
+  if (patch.commitUrls)
+    patch = {
+      ...patch,
+      commitUrls: [...new Set(patch.commitUrls.map(normalizeCommitUrl))]
+    };
+  return {
+    ...state,
+    tasks: state.tasks.map(
+      (t) => t.id === id ? {
+        ...t,
+        ...patch,
+        activity: message ? [event(message, author), ...t.activity] : t.activity
+      } : t
+    )
+  };
+}
+function removeTask(state, id) {
+  const removed = /* @__PURE__ */ new Set([id]);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const task of state.tasks)
+      if (task.parentId && removed.has(task.parentId) && !removed.has(task.id)) {
+        removed.add(task.id);
+        changed = true;
+      }
+  }
+  return {
+    ...state,
+    tasks: state.tasks.filter((t) => !removed.has(t.id)),
+    links: state.links.filter(
+      (e) => !removed.has(e.source) && !removed.has(e.target)
+    )
+  };
+}
+function launchOrder(state) {
+  const tasks = [...state.tasks];
+  const byPosition = (a, b) => a.position.x - b.position.x || a.position.y - b.position.y || Number(a.referenceId) - Number(b.referenceId);
+  const inbound = new Map(tasks.map((task) => [task.id, 0]));
+  const outgoing = new Map(tasks.map((task) => [task.id, []]));
+  const seen = /* @__PURE__ */ new Set();
+  const connections = [
+    ...state.links,
+    ...tasks.filter((task) => task.parentId).map((task) => ({ source: task.parentId, target: task.id }))
+  ];
+  for (const connection of connections) {
+    const key = `${connection.source}:${connection.target}`;
+    if (!inbound.has(connection.source) || !inbound.has(connection.target) || seen.has(key))
+      continue;
+    seen.add(key);
+    outgoing.get(connection.source).push(connection.target);
+    inbound.set(connection.target, inbound.get(connection.target) + 1);
+  }
+  const ready = tasks.filter((task) => inbound.get(task.id) === 0).sort(byPosition);
+  const order = /* @__PURE__ */ new Map();
+  while (ready.length) {
+    const task = ready.shift();
+    order.set(task.id, order.size + 1);
+    for (const target of outgoing.get(task.id) ?? []) {
+      const remaining = inbound.get(target) - 1;
+      inbound.set(target, remaining);
+      if (remaining === 0) {
+        ready.push(tasks.find((item) => item.id === target));
+        ready.sort(byPosition);
+      }
+    }
+  }
+  return order;
+}
+function normalizeUsage(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const raw = value;
+  const usage = {};
+  for (const key of [
+    "costUsd",
+    "inputTokens",
+    "outputTokens",
+    "durationMs"
+  ])
+    if (Number.isFinite(raw[key])) usage[key] = raw[key];
+  if (typeof raw.model === "string" && raw.model.trim())
+    usage.model = raw.model;
+  const windows = normalizeWindows(raw.windows);
+  if (windows) usage.windows = windows;
+  return Object.keys(usage).length ? usage : void 0;
+}
+function normalizeWindows(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const raw = value;
+  const windows = {};
+  for (const key of ["fiveHour", "sevenDay"]) {
+    const window = raw[key];
+    if (!window || typeof window !== "object") continue;
+    const clean = {};
+    for (const edge of ["start", "end"]) {
+      const percent = window[edge];
+      if (typeof percent === "number" && Number.isFinite(percent))
+        clean[edge] = percent;
+    }
+    if (Object.keys(clean).length) windows[key] = clean;
+  }
+  return Object.keys(windows).length ? windows : void 0;
+}
+function normalizeActivity(entry) {
+  const { id, text, at, author, authorType, authorId } = entry;
+  const clean = { id, text, at, author, authorType };
+  if (authorId !== void 0) clean.authorId = authorId;
+  if (entry.kind && activityKinds.includes(entry.kind)) clean.kind = entry.kind;
+  if (typeof entry.commit === "string" && /^[0-9a-f]{7,40}$/.test(entry.commit))
+    clean.commit = entry.commit;
+  const usage = normalizeUsage(entry.usage);
+  if (usage) clean.usage = usage;
+  return clean;
+}
+function parseWorkspace(raw) {
+  const parsed = JSON.parse(raw);
+  if (parsed?.version === 1 && Array.isArray(parsed.projects) && Array.isArray(parsed.tasks)) {
+    parsed.version = 2;
+    parsed.projects = parsed.projects.map((p) => ({
+      ...p,
+      repositoryUrl: ""
+    }));
+    parsed.tasks = parsed.tasks.map((t) => {
+      const { projectId, ...rest } = t;
+      return { ...rest, projectIds: [projectId], commitUrls: [] };
+    });
+  }
+  const value = parsed;
+  if (parsed?.version === 2 && Array.isArray(parsed.projects) && Array.isArray(parsed.tasks)) {
+    parsed.version = 3;
+    parsed.projects = parsed.projects.map(
+      (p) => {
+        const { category: _, ...project } = p;
+        return { ...project, orb: makeOrb(p.color) };
+      }
+    );
+    const names = [
+      .../* @__PURE__ */ new Set([
+        "Bug",
+        "Improvement",
+        "New feature",
+        ...parsed.tasks.flatMap((t) => t.labels)
+      ])
+    ];
+    parsed.labels = names.map((name, index) => ({
+      id: `label-${index}`,
+      name,
+      orb: makeOrb(["#ef6387", "#408cff", "#45d797", "#ffb33e"][index % 4])
+    }));
+    parsed.statusOrbs = structuredClone(defaultStatusOrbs);
+  }
+  if (parsed?.version === 3) {
+    parsed.version = 4;
+    parsed.map = { name: "Map", orb: structuredClone(wholeMapOrb) };
+  }
+  if (parsed?.version === 4 && Array.isArray(parsed.tasks)) {
+    parsed.version = 5;
+    parsed.tasks = parsed.tasks.map((task) => ({
+      ...task,
+      referenceId: task.referenceId
+    }));
+  }
+  if (parsed?.version === 5 && Array.isArray(parsed.tasks)) {
+    parsed.version = 6;
+    parsed.tasks = parsed.tasks.map((task) => ({
+      ...task,
+      objective: typeof task.objective === "string" ? task.objective : "",
+      activity: Array.isArray(task.activity) ? task.activity.map((item) => ({
+        ...item,
+        author: typeof item.author === "string" && item.author.trim() ? item.author : "Wireal AI",
+        authorType: item.authorType === "user" ? "user" : "ai"
+      })) : []
+    }));
+  }
+  if (parsed?.version === 6 && parsed.map) {
+    parsed.version = 7;
+    parsed.map = { ...parsed.map, repositoryUrl: "" };
+  }
+  if (parsed?.version === 7 && Array.isArray(parsed.tasks)) {
+    parsed.version = 8;
+    const ordered = [...parsed.tasks].sort(
+      (a, b) => a.position.x - b.position.x || a.position.y - b.position.y || String(a.referenceId).localeCompare(String(b.referenceId))
+    );
+    const numbers = new Map(
+      ordered.map((task, index) => [task.id, String(index + 1)])
+    );
+    parsed.tasks = parsed.tasks.map((task) => ({
+      ...task,
+      referenceId: numbers.get(task.id)
+    }));
+  }
+  if (parsed?.version === 8) {
+    parsed.version = 9;
+    parsed.statusOrbs = {
+      ...parsed.statusOrbs,
+      proposed: parsed.statusOrbs?.proposed ?? structuredClone(defaultStatusOrbs.proposed)
+    };
+  }
+  if (parsed?.statusOrbs && typeof parsed.statusOrbs === "object") {
+    for (const status of Object.keys(statuses))
+      parsed.statusOrbs[status] ??= structuredClone(defaultStatusOrbs[status]);
+  }
+  if (Array.isArray(parsed?.labels)) {
+    parsed.labels = parsed.labels.map((label) => ({
+      ...label,
+      color: typeof label.color === "string" && /^#[0-9a-f]{6}$/i.test(label.color) ? label.color : "#a1a1aa"
+    }));
+  }
+  const validString = (v) => typeof v === "string" && v.trim().length > 0;
+  if (value?.version !== 9 || !Array.isArray(value.projects) || !Array.isArray(value.tasks) || !Array.isArray(value.links))
+    throw new Error("Invalid Thread backup.");
+  if (!value.map || !validString(value.map.name) || typeof value.map.repositoryUrl !== "string" || value.map.kind !== void 0 && !["coding", "everyday"].includes(value.map.kind) || value.map.repositoryUrl && !isValidRepository(value.map.repositoryUrl) || value.map.repositoryLayout !== void 0 && !repositoryLayouts.includes(value.map.repositoryLayout) || !validOrb(value.map.orb))
+    throw new Error("Invalid workspace settings.");
+  if (!value.projects.every(
+    (p) => p && validString(p.id) && validString(p.name) && /^#[0-9a-f]{6}$/i.test(p.color) && typeof p.repositoryUrl === "string" && (p.paths === void 0 || Array.isArray(p.paths) && p.paths.length <= 50 && p.paths.every(
+      (path) => typeof path === "string" && path.trim().length >= 1 && path.trim().length <= 200 && !path.trim().split("/").includes("..")
+    )) && validOrb(p.orb) && (!p.repositoryUrl || isValidRepository(p.repositoryUrl))
+  ))
+    throw new Error("Invalid project data.");
+  if (!Array.isArray(value.labels) || !value.labels.every(
+    (l) => l && validString(l.id) && validString(l.name) && validOrb(l.orb) && typeof l.color === "string" && /^#[0-9a-f]{6}$/i.test(l.color)
+  ) || new Set(value.labels.map((l) => l.id)).size !== value.labels.length || new Set(value.labels.map((l) => l.name.toLowerCase())).size !== value.labels.length)
+    throw new Error("Invalid label data.");
+  if (!value.statusOrbs || !Object.keys(statuses).every((s) => validOrb(value.statusOrbs[s])))
+    throw new Error("Invalid status colors.");
+  const projects = new Set(value.projects.map((p) => p.id)), tasks = new Set(value.tasks.map((t) => t?.id));
+  if (projects.size !== value.projects.length || tasks.size !== value.tasks.length || new Set(value.tasks.map((task) => task.referenceId)).size !== value.tasks.length)
+    throw new Error("Duplicate IDs in backup.");
+  if (!value.tasks.every(
+    (t) => t && validString(t.id) && validReferenceId(t.referenceId) && validString(t.name) && typeof t.objective === "string" && Array.isArray(t.projectIds) && t.projectIds.length > 0 && new Set(t.projectIds).size === t.projectIds.length && t.projectIds.every((id) => projects.has(id)) && Array.isArray(t.commitUrls) && t.commitUrls.every(isValidCommit) && Object.hasOwn(statuses, t.status) && Array.isArray(t.labels) && t.labels.every(validString) && t.labels.every((name) => value.labels.some((l) => l.name === name)) && (t.parentId === null || tasks.has(t.parentId)) && Number.isFinite(t.position?.x) && Number.isFinite(t.position?.y) && Array.isArray(t.activity) && t.activity.every(
+      (a) => a && validString(a.id) && validString(a.text) && validString(a.author) && (a.authorType === "user" || a.authorType === "ai") && Number.isFinite(Date.parse(a.at))
+    )
+  ))
+    throw new Error("Invalid task data.");
+  value.tasks = value.tasks.map((task) => ({
+    ...task,
+    activity: task.activity.map(normalizeActivity)
+  }));
+  const graph = {
+    ...value,
+    links: [],
+    tasks: value.tasks.map((t) => ({ ...t, parentId: null }))
+  };
+  for (const t of value.tasks)
+    if (t.parentId) {
+      if (!canConnect(graph, t.parentId, t.id))
+        throw new Error("Invalid subtask hierarchy.");
+      graph.tasks = graph.tasks.map(
+        (n) => n.id === t.id ? { ...n, parentId: t.parentId } : n
+      );
+    }
+  const linkIds = /* @__PURE__ */ new Set();
+  for (const e of value.links) {
+    const legacy = e;
+    const legacyHandle = (handle) => handle === void 0 || typeof handle === "string" && ["left", "right", "top", "bottom"].includes(handle);
+    if (!e || !validString(e.id) || linkIds.has(e.id) || !legacyHandle(legacy.sourceHandle) || !legacyHandle(legacy.targetHandle) || !canConnect(graph, e.source, e.target))
+      throw new Error("Invalid task connections.");
+    linkIds.add(e.id);
+    const {
+      sourceHandle: _sourceHandle,
+      targetHandle: _targetHandle,
+      ...dependency
+    } = legacy;
+    graph.links.push(dependency);
+  }
+  value.links = graph.links;
+  value.projects = value.projects.map((project) => {
+    const legacy = project;
+    const { category: _category, ...clean } = legacy;
+    return clean;
+  });
+  return value;
+}
+function ensureLabels(state, names) {
+  const missing = [
+    ...new Set(names.map((n) => n.trim()).filter(Boolean))
+  ].filter(
+    (name) => !state.labels.some((l) => l.name.toLowerCase() === name.toLowerCase())
+  );
+  return {
+    ...state,
+    labels: [
+      ...state.labels,
+      ...missing.map((name) => ({
+        id: uid(),
+        name,
+        orb: makeOrb("#669df6"),
+        color: "#669df6"
+      }))
+    ]
+  };
+}
+function saveLabel(state, label) {
+  if (!label.name.trim() || state.labels.some(
+    (l) => l.id !== label.id && l.name.toLowerCase() === label.name.trim().toLowerCase()
+  ))
+    throw new Error("Use a unique label name.");
+  if (!validOrb(label.orb)) throw new Error("Invalid orb settings.");
+  if (label.color && !/^#[0-9a-f]{6}$/i.test(label.color))
+    throw new Error("Use a valid color.");
+  const previous = state.labels.find((l) => l.id === label.id);
+  const next = { ...label, name: label.name.trim() };
+  return {
+    ...state,
+    labels: previous ? state.labels.map((l) => l.id === label.id ? next : l) : [...state.labels, next],
+    tasks: previous ? state.tasks.map((t) => ({
+      ...t,
+      labels: t.labels.map(
+        (name) => name === previous.name ? next.name : name
+      )
+    })) : state.tasks
+  };
+}
+function deleteLabel(state, id) {
+  const label = state.labels.find((l) => l.id === id);
+  return {
+    ...state,
+    labels: state.labels.filter((l) => l.id !== id),
+    tasks: state.tasks.map((t) => ({
+      ...t,
+      labels: t.labels.filter((name) => name !== label?.name)
+    }))
+  };
+}
+function normalizeRepositoryUrl(input) {
+  if (!input.trim()) return "";
+  const url = new URL(input.trim());
+  const match = url.pathname.match(/^\/([a-zA-Z0-9-]+)\/([a-zA-Z0-9._-]+)\/?$/);
+  if (url.protocol !== "https:" || url.hostname !== "github.com" || url.port || url.username || url.password || !match || url.search || url.hash)
+    throw new Error(
+      "Use a GitHub repository URL: https://github.com/owner/repository"
+    );
+  return `https://github.com/${match[1]}/${match[2].replace(/\.git$/i, "")}`;
+}
+function repositoryLayout(state) {
+  return state.map.repositoryLayout ?? (state.map.repositoryUrl ? "monorepo" : "multirepo");
+}
+function projectRepository(state, project) {
+  if (workspaceKind(state) === "everyday") return "";
+  return repositoryLayout(state) === "monorepo" ? state.map.repositoryUrl || project.repositoryUrl : project.repositoryUrl;
+}
+function taskRepository(state, task) {
+  for (const id of task.projectIds) {
+    const project = state.projects.find((item) => item.id === id);
+    const repository = project ? projectRepository(state, project) : "";
+    if (repository) return repository;
+  }
+  return "";
+}
+function normalizeCommitUrl(input) {
+  const url = new URL(input.trim());
+  const match = url.pathname.match(
+    /^\/([a-zA-Z0-9-]+)\/([a-zA-Z0-9._-]+)\/commit\/([a-fA-F0-9]{40})\/?$/
+  );
+  if (url.protocol !== "https:" || url.hostname !== "github.com" || url.port || url.username || url.password || !match || url.search || url.hash)
+    throw new Error(
+      "Use an exact GitHub commit URL with the full 40-character SHA."
+    );
+  return `https://github.com/${match[1]}/${match[2]}/commit/${match[3].toLowerCase()}`;
+}
+function isValidRepository(input) {
+  try {
+    return typeof input === "string" && !!normalizeRepositoryUrl(input);
+  } catch {
+    return false;
+  }
+}
+function isValidCommit(input) {
+  try {
+    return typeof input === "string" && !!normalizeCommitUrl(input);
+  } catch {
+    return false;
+  }
+}
+function removeProject(state, id) {
+  const tasks = state.tasks.map((t) => ({ ...t, projectIds: t.projectIds.filter((p) => p !== id) })).filter((t) => t.projectIds.length);
+  const ids = new Set(tasks.map((t) => t.id));
+  return {
+    ...state,
+    projects: state.projects.filter((p) => p.id !== id),
+    tasks: tasks.map((t) => ({
+      ...t,
+      parentId: t.parentId && ids.has(t.parentId) ? t.parentId : null
+    })),
+    links: state.links.filter((e) => ids.has(e.source) && ids.has(e.target))
+  };
+}
+
+// src/agent-identity.ts
+function agentBrand(name) {
+  if (/\bcodex\b/i.test(name)) return "codex";
+  if (/\bchatgpt\b/i.test(name)) return "chatgpt";
+  if (/\b(claude|clode|anthropic)\b/i.test(name)) return "claude";
+  return null;
+}
+var brandNames = {
+  chatgpt: "ChatGPT",
+  codex: "Codex",
+  claude: "Claude"
+};
+function agentQualifier(name) {
+  const match = /^\s*(?:claude|codex|chatgpt)\s*·\s*(.+?)\s*$/i.exec(name);
+  return match ? match[1].slice(0, 60) : "";
+}
+function agentDisplayName(name) {
+  const brand = agentBrand(name);
+  if (!brand) return name.trim().slice(0, 80) || "Agent";
+  const qualifier = agentQualifier(name);
+  return qualifier ? `${brandNames[brand]} \xB7 ${qualifier}` : brandNames[brand];
+}
+
+// mcp/identity.ts
+var placeholders = /* @__PURE__ */ new Set([
+  "agent",
+  "mcp",
+  "mcp client",
+  "unknown",
+  "client"
+]);
+function realName(candidate) {
+  const name = candidate?.trim();
+  return name && !placeholders.has(name.toLowerCase()) ? name : void 0;
+}
+function agentHandle(value) {
+  return (value ?? "").replace(/[^\p{L}\p{N} ._-]+/gu, " ").replace(/\s+/g, " ").trim().slice(0, 24).trim();
+}
+function qualified(name, handle) {
+  if (!handle || agentQualifier(name)) return name;
+  return `${name} \xB7 ${handle}`;
+}
+function mcpCallerName(identity) {
+  const clientInfoName = identity.clientInfoName?.trim();
+  const registeredClientName = identity.registeredClientName?.trim();
+  const userAgent = identity.userAgent?.trim();
+  const handle = agentHandle(identity.handle);
+  for (const candidate of [registeredClientName, clientInfoName, userAgent]) {
+    if (candidate && agentBrand(candidate))
+      return qualified(agentDisplayName(candidate), handle);
+  }
+  for (const candidate of [clientInfoName, registeredClientName]) {
+    const name = realName(candidate);
+    if (name) return qualified(agentDisplayName(name), handle);
+  }
+  return qualified(agentDisplayName(identity.fallback), handle);
+}
+
+// mcp/views.ts
+function projectView(state, project) {
+  return {
+    ...project,
+    repositoryUrl: projectRepository(state, project),
+    folders: projectPaths(project)
+  };
+}
+function taskView(state, task, includeActivity = false, order = launchOrder(state)) {
+  const dependencyIds = state.links.filter((link) => link.target === task.id).map((link) => link.source);
+  const prerequisiteIds2 = /* @__PURE__ */ new Set([
+    ...dependencyIds,
+    ...task.parentId ? [task.parentId] : []
+  ]);
+  const unblockedIds = state.links.filter((link) => link.source === task.id).map((link) => link.target);
+  const view = {
+    id: task.id,
+    referenceId: task.referenceId,
+    name: task.name,
+    objective: task.objective,
+    status: task.status,
+    ...task.proposedBy ? { proposedBy: task.proposedBy } : {},
+    launchOrder: order.get(task.id) ?? null,
+    blocked: state.tasks.some(
+      (candidate) => prerequisiteIds2.has(candidate.id) && candidate.status !== "done"
+    ),
+    blockedBy: state.tasks.filter(
+      (candidate) => prerequisiteIds2.has(candidate.id) && candidate.status !== "done"
+    ).map((candidate) => ({
+      id: candidate.id,
+      referenceId: candidate.referenceId,
+      name: candidate.name,
+      status: candidate.status
+    })),
+    projects: state.projects.filter((project) => task.projectIds.includes(project.id)).map((project) => ({
+      id: project.id,
+      name: project.name,
+      repositoryUrl: projectRepository(state, project),
+      folders: projectPaths(project)
+    })),
+    labels: task.labels,
+    commitUrls: workspaceKind(state) === "everyday" ? [] : task.commitUrls,
+    parent: task.parentId ? state.tasks.find((candidate) => candidate.id === task.parentId)?.referenceId ?? task.parentId : null,
+    dependsOn: state.tasks.filter((candidate) => dependencyIds.includes(candidate.id)).map((candidate) => ({
+      id: candidate.id,
+      referenceId: candidate.referenceId,
+      name: candidate.name,
+      status: candidate.status
+    })),
+    unblocks: state.tasks.filter((candidate) => unblockedIds.includes(candidate.id)).map((candidate) => ({
+      id: candidate.id,
+      referenceId: candidate.referenceId,
+      name: candidate.name,
+      status: candidate.status
+    }))
+  };
+  return includeActivity ? { ...view, activity: task.activity.slice(0, 20) } : view;
+}
+function statusCounts(tasks) {
+  return {
+    proposed: tasks.filter((task) => task.status === "proposed").length,
+    todo: tasks.filter((task) => task.status === "todo").length,
+    doing: tasks.filter((task) => task.status === "doing").length,
+    done: tasks.filter((task) => task.status === "done").length
+  };
+}
+
+// mcp/workspace.ts
+function lookup(values, identifier, kind) {
+  const needle = identifier.trim().toLowerCase();
+  const exact = values.filter(
+    (value) => value.id.toLowerCase() === needle || value.name.toLowerCase() === needle
+  );
+  if (exact.length === 1) return exact[0];
+  if (exact.length > 1) throw new Error(`Ambiguous ${kind}: ${identifier}`);
+  throw new Error(`Unknown ${kind}: ${identifier}`);
+}
+function findProject(state, identifier) {
+  return lookup(state.projects, identifier, "project");
+}
+function findLabel(state, identifier) {
+  return lookup(state.labels, identifier, "label");
+}
+function findTask(state, identifier) {
+  const needle = identifier.trim().toLowerCase();
+  const matches = state.tasks.filter(
+    (task) => task.id.toLowerCase() === needle || task.referenceId.toLowerCase() === needle || task.name.toLowerCase() === needle
+  );
+  if (matches.length === 1) return matches[0];
+  if (matches.length > 1) throw new Error(`Ambiguous task: ${identifier}`);
+  throw new Error(`Unknown task: ${identifier}`);
+}
+function canonicalLabels(state, names) {
+  return [
+    ...new Set(
+      names.map((name) => {
+        const label = state.labels.find(
+          (candidate) => candidate.name.toLowerCase() === name.trim().toLowerCase()
+        );
+        if (!label) throw new Error(`Unknown label: ${name}`);
+        return label.name;
+      })
+    )
+  ];
+}
+function appendAudit(task, text, agentName2) {
+  return {
+    ...task,
+    activity: [
+      event(text, { author: agentName2, authorType: "ai" }),
+      ...task.activity
+    ]
+  };
+}
+var columnWidth = 380;
+var rowHeight = 300;
+var gridColumns = 6;
+function occupied(state, x, y) {
+  return state.tasks.some(
+    (task) => Math.abs(task.position.x - x) < columnWidth && Math.abs(task.position.y - y) < rowHeight
+  );
+}
+function placeTask(state, parent) {
+  if (parent) {
+    const x = parent.position.x + columnWidth;
+    let y = parent.position.y + rowHeight;
+    while (occupied(state, x, y)) y += rowHeight;
+    return { x, y };
+  }
+  if (!state.tasks.length) return { x: 0, y: 0 };
+  const originX = Math.min(...state.tasks.map((task) => task.position.x));
+  const originY = Math.min(...state.tasks.map((task) => task.position.y));
+  for (let row = 0; ; row++)
+    for (let column = 0; column < gridColumns; column++) {
+      const x = originX + column * columnWidth;
+      const y = originY + row * rowHeight;
+      if (!occupied(state, x, y)) return { x, y };
+    }
+}
+function createTask(state, input, agentName2) {
+  const name = input.name.trim();
+  if (!name) throw new Error("A task needs a name.");
+  if (!input.projects.length) throw new Error("Choose at least one project.");
+  const projectIds = [
+    ...new Set(input.projects.map((value) => findProject(state, value).id))
+  ];
+  const parent = input.parent ? findTask(state, input.parent) : void 0;
+  const labels = canonicalLabels(state, input.labels ?? []);
+  const position = placeTask(state, parent);
+  const task = {
+    id: uid(),
+    referenceId: taskReferenceId(state.tasks),
+    name,
+    projectIds,
+    commitUrls: [],
+    status: input.status ?? "todo",
+    objective: input.objective?.trim() ?? "",
+    labels,
+    parentId: parent?.id ?? null,
+    position,
+    activity: [
+      event("Task created through MCP", {
+        author: agentName2,
+        authorType: "ai"
+      })
+    ]
+  };
+  return { state: { ...state, tasks: [...state.tasks, task] }, task };
+}
+function patchTask(state, identifier, patch, agentName2) {
+  const task = findTask(state, identifier);
+  const resolved = Object.fromEntries(
+    Object.entries(patch).filter(([, value]) => value !== void 0)
+  );
+  if (patch.projectIds) {
+    resolved.projectIds = [
+      ...new Set(patch.projectIds.map((value) => findProject(state, value).id))
+    ];
+  }
+  if (patch.labels) resolved.labels = canonicalLabels(state, patch.labels);
+  let next = updateTask(state, task.id, resolved);
+  next = {
+    ...next,
+    tasks: next.tasks.map(
+      (candidate) => candidate.id === task.id ? appendAudit(candidate, "Task fields updated through MCP", agentName2) : candidate
+    )
+  };
+  return { state: next, task: findTask(next, task.id) };
+}
+function deleteTask(state, identifier) {
+  const task = findTask(state, identifier);
+  const next = removeTask(state, task.id);
+  const remaining = new Set(next.tasks.map((candidate) => candidate.id));
+  return {
+    state: next,
+    task,
+    removedTasks: state.tasks.filter(
+      (candidate) => !remaining.has(candidate.id)
+    )
+  };
+}
+function setTaskStatus(state, identifier, status, agentName2) {
+  const task = findTask(state, identifier);
+  if (task.status === status) return { state, task };
+  let next = updateTask(state, task.id, { status });
+  next = {
+    ...next,
+    tasks: next.tasks.map(
+      (candidate) => candidate.id === task.id ? appendAudit(
+        candidate,
+        `Status changed from ${task.status} to ${status}`,
+        agentName2
+      ) : candidate
+    )
+  };
+  return { state: next, task: findTask(next, task.id) };
+}
+function commitLinkFor(state, task, commit) {
+  if (!commit || !/^[0-9a-f]{40}$/i.test(commit)) return void 0;
+  if (workspaceKind(state) === "everyday") return void 0;
+  const project = state.projects.find(
+    (candidate) => task.projectIds.includes(candidate.id) && projectRepository(state, candidate)
+  );
+  if (!project) return void 0;
+  return normalizeCommitUrl(
+    `${projectRepository(state, project)}/commit/${commit.toLowerCase()}`
+  );
+}
+function withCommitLinked(task, commitUrl) {
+  if (!commitUrl || task.commitUrls.includes(commitUrl)) return task;
+  return { ...task, commitUrls: [...task.commitUrls, commitUrl] };
+}
+function addActivity(state, identifier, input, agentName2) {
+  const task = findTask(state, identifier);
+  const summary = input.summary.trim();
+  if (!summary) throw new Error("Activity summary is required.");
+  const entry = {
+    ...event(summary, { author: agentName2, authorType: "ai" }),
+    kind: input.kind,
+    ...input.commit !== void 0 ? { commit: input.commit } : {}
+  };
+  const commitUrl = commitLinkFor(state, task, input.commit);
+  const next = {
+    ...state,
+    tasks: state.tasks.map(
+      (candidate) => candidate.id === task.id ? withCommitLinked(
+        { ...candidate, activity: [entry, ...candidate.activity] },
+        commitUrl
+      ) : candidate
+    )
+  };
+  return {
+    state: next,
+    task: findTask(next, task.id),
+    ...commitUrl ? { commitUrl } : {}
+  };
+}
+function prerequisiteIds(state, task) {
+  return /* @__PURE__ */ new Set([
+    ...state.links.filter((link) => link.target === task.id).map((link) => link.source),
+    ...task.parentId ? [task.parentId] : []
+  ]);
+}
+function readyTasks(state) {
+  const order = launchOrder(state);
+  return state.tasks.filter(
+    (task) => task.status === "todo" && [...prerequisiteIds(state, task)].every(
+      (id) => state.tasks.find((candidate) => candidate.id === id)?.status === "done"
+    )
+  ).sort(
+    (left, right) => (order.get(left.id) ?? Number.MAX_SAFE_INTEGER) - (order.get(right.id) ?? Number.MAX_SAFE_INTEGER)
+  );
+}
+function taskBrief(state, identifier) {
+  const task = findTask(state, identifier);
+  const order = launchOrder(state);
+  const upstreamIds = prerequisiteIds(state, task);
+  return {
+    task: taskView(state, task, false, order),
+    repository: taskRepository(state, task),
+    projects: state.projects.filter((project) => task.projectIds.includes(project.id)).map((project) => ({
+      name: project.name,
+      repositoryUrl: projectRepository(state, project),
+      folders: projectPaths(project)
+    })),
+    upstream: state.tasks.filter((candidate) => upstreamIds.has(candidate.id)).sort(
+      (left, right) => (order.get(left.id) ?? Number.MAX_SAFE_INTEGER) - (order.get(right.id) ?? Number.MAX_SAFE_INTEGER)
+    ).map((candidate) => ({
+      referenceId: candidate.referenceId,
+      name: candidate.name,
+      status: candidate.status,
+      activity: candidate.activity.slice(0, 3).map((entry) => ({
+        text: entry.text,
+        author: entry.author,
+        kind: entry.kind,
+        commit: entry.commit
+      }))
+    }))
+  };
+}
+function proposeTask(state, input, agentName2) {
+  const source = findTask(state, input.from);
+  const name = input.name.trim();
+  if (!name) throw new Error("A task needs a name.");
+  const projectIdentifiers = input.projectIds ?? source.projectIds;
+  if (!projectIdentifiers.length)
+    throw new Error("Choose at least one project.");
+  const projectIds = [
+    ...new Set(
+      projectIdentifiers.map((identifier) => findProject(state, identifier).id)
+    )
+  ];
+  const proposedIds = new Set(
+    state.tasks.filter(
+      (task2) => task2.status === "proposed" && task2.proposedBy === agentName2
+    ).map((task2) => task2.id)
+  );
+  const proposalCount = state.links.filter(
+    (link) => link.source === source.id && proposedIds.has(link.target)
+  ).length;
+  if (proposalCount >= 3)
+    throw new Error(
+      "An agent can propose at most three tasks from one source."
+    );
+  const task = {
+    id: uid(),
+    referenceId: taskReferenceId(state.tasks),
+    name,
+    projectIds,
+    commitUrls: [],
+    status: "proposed",
+    proposedBy: agentName2,
+    objective: input.objective.trim(),
+    labels: [],
+    parentId: null,
+    position: { x: source.position.x, y: source.position.y + 270 },
+    activity: []
+  };
+  const next = {
+    ...state,
+    tasks: [
+      ...state.tasks.map(
+        (candidate) => candidate.id === source.id ? appendAudit(
+          candidate,
+          `Proposed ${task.referenceId} ${task.name}`,
+          agentName2
+        ) : candidate
+      ),
+      task
+    ],
+    links: [...state.links, { id: uid(), source: source.id, target: task.id }]
+  };
+  return { state: next, task };
+}
+function closeTask(state, input, agentName2) {
+  const task = findTask(state, input.task);
+  const summary = input.summary.trim();
+  if (!summary) throw new Error("A closing summary is required.");
+  const entry = {
+    ...event(summary, { author: agentName2, authorType: "ai" }),
+    ...input.outcome === "blocked" ? { kind: "blocker" } : {},
+    ...input.commit !== void 0 ? { commit: input.commit } : {},
+    ...input.usage !== void 0 ? { usage: input.usage } : {}
+  };
+  const status = input.outcome === "done" ? "done" : input.outcome === "abandoned" ? "todo" : task.status;
+  const commitUrl = commitLinkFor(state, task, input.commit);
+  const next = {
+    ...state,
+    tasks: state.tasks.map(
+      (candidate) => candidate.id === task.id ? withCommitLinked(
+        { ...candidate, status, activity: [entry, ...candidate.activity] },
+        commitUrl
+      ) : candidate
+    )
+  };
+  return {
+    state: next,
+    task: findTask(next, task.id),
+    ...commitUrl ? { commitUrl } : {}
+  };
+}
+function commitForProject(state, project, value) {
+  if (workspaceKind(state) === "everyday")
+    throw new Error("GitHub commits are only available in coding workspaces.");
+  const repositoryUrl = projectRepository(state, project);
+  if (!repositoryUrl) {
+    throw new Error(
+      `Project ${project.name} does not have a GitHub repository URL.`
+    );
+  }
+  const commitUrl = /^[a-fA-F0-9]{40}$/.test(value.trim()) ? normalizeCommitUrl(`${repositoryUrl}/commit/${value.trim()}`) : normalizeCommitUrl(value);
+  const expected = normalizeRepositoryUrl(repositoryUrl).toLowerCase();
+  const actual = commitUrl.slice(0, commitUrl.indexOf("/commit/")).toLowerCase();
+  if (actual !== expected) {
+    throw new Error(`Commit must belong to ${repositoryUrl}.`);
+  }
+  return commitUrl;
+}
+function linkCommit(state, taskIdentifier, projectIdentifier, commit, agentName2) {
+  const task = findTask(state, taskIdentifier);
+  const project = findProject(state, projectIdentifier);
+  if (!task.projectIds.includes(project.id)) {
+    throw new Error(`${task.name} does not belong to project ${project.name}.`);
+  }
+  const commitUrl = commitForProject(state, project, commit);
+  if (task.commitUrls.includes(commitUrl)) return { state, task, commitUrl };
+  let next = updateTask(state, task.id, {
+    commitUrls: [...task.commitUrls, commitUrl]
+  });
+  next = {
+    ...next,
+    tasks: next.tasks.map(
+      (candidate) => candidate.id === task.id ? appendAudit(
+        candidate,
+        `Linked GitHub commit ${commitUrl.split("/").at(-1)}`,
+        agentName2
+      ) : candidate
+    )
+  };
+  return { state: next, task: findTask(next, task.id), commitUrl };
+}
+function unlinkCommit(state, taskIdentifier, commit, agentName2) {
+  const task = findTask(state, taskIdentifier);
+  const needle = commit.trim().toLowerCase();
+  const commitUrl = task.commitUrls.find(
+    (url) => url.toLowerCase() === needle || url.split("/").at(-1)?.toLowerCase() === needle
+  );
+  if (!commitUrl) throw new Error("That commit is not linked to the task.");
+  let next = updateTask(state, task.id, {
+    commitUrls: task.commitUrls.filter((url) => url !== commitUrl)
+  });
+  next = {
+    ...next,
+    tasks: next.tasks.map(
+      (candidate) => candidate.id === task.id ? appendAudit(
+        candidate,
+        `Unlinked GitHub commit ${commitUrl.split("/").at(-1)}`,
+        agentName2
+      ) : candidate
+    )
+  };
+  return { state: next, task: findTask(next, task.id) };
+}
+function addDependency(state, taskIdentifier, dependencyIdentifier) {
+  const task = findTask(state, taskIdentifier);
+  const dependency = findTask(state, dependencyIdentifier);
+  if (!canConnect(state, dependency.id, task.id)) {
+    throw new Error(
+      "That dependency is duplicated, self-referential, or would create a cycle."
+    );
+  }
+  return {
+    state: {
+      ...state,
+      links: [
+        ...state.links,
+        { id: uid(), source: dependency.id, target: task.id }
+      ]
+    },
+    task,
+    dependency
+  };
+}
+function removeDependency(state, taskIdentifier, dependencyIdentifier) {
+  const task = findTask(state, taskIdentifier);
+  const dependency = findTask(state, dependencyIdentifier);
+  const matches = state.links.filter(
+    (link) => link.source === dependency.id && link.target === task.id
+  );
+  if (!matches.length) throw new Error("That dependency does not exist.");
+  const ids = new Set(matches.map((link) => link.id));
+  return {
+    state: { ...state, links: state.links.filter((link) => !ids.has(link.id)) },
+    task,
+    dependency
+  };
+}
+function createLabel(state, name) {
+  const trimmed = name.trim();
+  if (!trimmed) throw new Error("A label needs a name.");
+  if (state.labels.some(
+    (label) => label.name.toLowerCase() === trimmed.toLowerCase()
+  )) {
+    throw new Error(`Label already exists: ${trimmed}`);
+  }
+  return ensureLabels(state, [trimmed]);
+}
+function updateLabel(state, identifier, input) {
+  const previous = findLabel(state, identifier);
+  const name = input.name?.trim() ?? previous.name;
+  if (!name) throw new Error("A label needs a name.");
+  if (state.labels.some(
+    (label2) => label2.id !== previous.id && label2.name.toLowerCase() === name.toLowerCase()
+  )) {
+    throw new Error(`Label already exists: ${name}`);
+  }
+  if (input.color && !/^#[0-9a-f]{6}$/i.test(input.color))
+    throw new Error("Use a six-digit hex color.");
+  const label = {
+    ...previous,
+    name,
+    ...input.color ? { color: input.color, orb: makeOrb(input.color) } : {}
+  };
+  const next = saveLabel(state, label);
+  return { state: next, label: findLabel(next, label.id) };
+}
+function deleteLabel2(state, identifier) {
+  const label = findLabel(state, identifier);
+  return { state: deleteLabel(state, label.id), label };
+}
+function createProject(state, input) {
+  if (workspaceKind(state) === "everyday" && input.folders !== void 0)
+    throw new Error("Project folders are only available in coding workspaces.");
+  if (workspaceKind(state) === "everyday" && input.repositoryUrl)
+    throw new Error("Everyday projects do not connect a GitHub repository.");
+  const name = input.name.trim();
+  if (!name) throw new Error("A project needs a name.");
+  if (state.projects.some(
+    (project2) => project2.name.toLowerCase() === name.toLowerCase()
+  )) {
+    throw new Error(`Project already exists: ${name}`);
+  }
+  const color = input.color ?? "#669df6";
+  if (!/^#[0-9a-f]{6}$/i.test(color))
+    throw new Error("Use a six-digit hex color.");
+  const folders = normalizeProjectFolders(input.folders ?? []);
+  const project = setProjectFolders(
+    {
+      id: uid(),
+      name,
+      color,
+      orb: makeOrb(color),
+      repositoryUrl: input.repositoryUrl ? normalizeRepositoryUrl(input.repositoryUrl) : ""
+    },
+    folders
+  );
+  return {
+    state: { ...state, projects: [...state.projects, project] },
+    project
+  };
+}
+function updateProject(state, identifier, input) {
+  if (workspaceKind(state) === "everyday" && input.folders !== void 0)
+    throw new Error("Project folders are only available in coding workspaces.");
+  if (workspaceKind(state) === "everyday" && input.repositoryUrl)
+    throw new Error("Everyday projects do not connect a GitHub repository.");
+  const previous = findProject(state, identifier);
+  const name = input.name?.trim() ?? previous.name;
+  if (!name) throw new Error("A project needs a name.");
+  if (state.projects.some(
+    (project2) => project2.id !== previous.id && project2.name.toLowerCase() === name.toLowerCase()
+  )) {
+    throw new Error(`Project already exists: ${name}`);
+  }
+  if (input.color && !/^#[0-9a-f]{6}$/i.test(input.color))
+    throw new Error("Use a six-digit hex color.");
+  let project = {
+    ...previous,
+    name,
+    ...input.color ? { color: input.color, orb: makeOrb(input.color) } : {},
+    ...input.repositoryUrl !== void 0 ? { repositoryUrl: normalizeRepositoryUrl(input.repositoryUrl) } : {}
+  };
+  if (input.folders !== void 0)
+    project = setProjectFolders(
+      project,
+      normalizeProjectFolders(input.folders)
+    );
+  return {
+    state: {
+      ...state,
+      projects: state.projects.map(
+        (candidate) => candidate.id === project.id ? project : candidate
+      )
+    },
+    project
+  };
+}
+function deleteProject(state, identifier) {
+  const project = findProject(state, identifier);
+  const next = removeProject(state, project.id);
+  const remaining = new Set(next.tasks.map((task) => task.id));
+  return {
+    state: next,
+    project,
+    removedTasks: state.tasks.filter((task) => !remaining.has(task.id))
+  };
+}
+function configureProjectRepository(state, identifier, input) {
+  if (workspaceKind(state) === "everyday")
+    throw new Error(
+      "Repository configuration is only available in coding workspaces."
+    );
+  const previous = findProject(state, identifier);
+  const project = {
+    ...previous,
+    ...input.repositoryUrl !== void 0 ? { repositoryUrl: normalizeRepositoryUrl(input.repositoryUrl) } : {}
+  };
+  return {
+    state: {
+      ...state,
+      projects: state.projects.map((p) => p.id === project.id ? project : p)
+    },
+    project
+  };
+}
+function normalizeProjectFolders(values) {
+  const folders = [];
+  for (const value of values) {
+    const folder = normalizeProjectPath(value);
+    if (!folder) continue;
+    if (folder.length > 200 || folder.split("/").includes(".."))
+      throw new Error(
+        "Folders are repository-relative paths of up to 200 characters."
+      );
+    if (!folders.includes(folder)) folders.push(folder);
+  }
+  return folders;
+}
+function setProjectFolders(project, folders) {
+  if (folders.length > 50)
+    throw new Error("A project can own at most 50 folders.");
+  const { paths: _paths, ...withoutPaths } = project;
+  return folders.length ? { ...withoutPaths, paths: folders } : withoutPaths;
+}
+function configureProjectFolders(state, identifier, input) {
+  if (workspaceKind(state) === "everyday")
+    throw new Error("Project folders are only available in coding workspaces.");
+  const previous = findProject(state, identifier);
+  const folders = normalizeProjectFolders(
+    input.replace ?? previous.paths ?? []
+  );
+  for (const folder of normalizeProjectFolders(input.add ?? []))
+    if (!folders.includes(folder)) folders.push(folder);
+  const removed = new Set(normalizeProjectFolders(input.remove ?? []));
+  const project = setProjectFolders(
+    previous,
+    folders.filter((folder) => !removed.has(folder))
+  );
+  return {
+    state: {
+      ...state,
+      projects: state.projects.map(
+        (candidate) => candidate.id === project.id ? project : candidate
+      )
+    },
+    project
+  };
+}
+
+// mcp/create-server.ts
+var statusSchema = z.enum(["proposed", "todo", "doing", "done"]);
+var agentSchema = z.string().trim().max(200).optional().describe(
+  "A short handle for this session so several agents in one workspace stay apart in the record, such as the first seven characters of $CLAUDE_CODE_SESSION_ID or the name of the worktree folder you are working in. Send the same handle on every call of this session."
+);
+function response(value) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(value) }],
+    structuredContent: value && typeof value === "object" ? value : { value }
+  };
+}
+function failure(error) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: error instanceof Error ? error.message : String(error)
+      }
+    ],
+    isError: true
+  };
+}
+function run(handler, callerName) {
+  return async (input) => {
+    try {
+      const handle = typeof input.agent === "string" ? input.agent : void 0;
+      return await handler(input, callerName(handle));
+    } catch (error) {
+      return failure(error);
+    }
+  };
+}
+function createWirealServer(client) {
+  const server2 = new McpServer(
+    { name: "wireal", version: "0.2.0" },
+    {
+      instructions: "Wireal is the source of truth for tasks. Call set_active_workspace first when several workspaces exist. On every write pass agent with a short handle for this session, the first seven characters of $CLAUDE_CODE_SESSION_ID or the name of your worktree folder, and keep the same handle all session so several agents in one workspace stay apart. Before working on a task call get_recent_activity for it once. After a meaningful change, discovery, decision, verification or blocker call add_task_activity with a summary under 500 characters and the commit as the full 40-character SHA from git rev-parse HEAD, pushed or not. Check blocked and blockedBy before starting. In monorepos, project folders identify which repository paths belong to each project. When a runner started you for one task, do only that task. When you notice separate work, call propose_task instead of doing it. Finish with close_task."
+    }
+  );
+  const callerName = (handle) => mcpCallerName({
+    clientInfoName: server2.server.getClientVersion()?.name,
+    registeredClientName: client.registeredClientName,
+    userAgent: client.userAgent,
+    handle,
+    fallback: client.agentName
+  });
+  server2.registerTool(
+    "list_workspaces",
+    {
+      title: "List workspaces",
+      description: "List the signed-in user's Wireal workspaces and identify the active workspace.",
+      inputSchema: z.object({}),
+      annotations: { readOnlyHint: true }
+    },
+    run(async () => {
+      const workspaces = await client.listWorkspaces();
+      return response({
+        count: workspaces.length,
+        activeWorkspace: workspaces.find((workspace) => workspace.isActive) ?? null,
+        workspaces
+      });
+    }, callerName)
+  );
+  server2.registerTool(
+    "set_active_workspace",
+    {
+      title: "Set active workspace",
+      description: "Switch subsequent Wireal tool calls to a workspace selected by ID or exact name.",
+      inputSchema: z.object({
+        workspace: z.string().min(1).describe("Workspace ID or exact workspace name")
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true
+      }
+    },
+    run(async ({ workspace }) => {
+      const activeWorkspace = await client.setActiveWorkspace(workspace);
+      return response({ activeWorkspace });
+    }, callerName)
+  );
+  server2.registerTool(
+    "workspace_summary",
+    {
+      title: "Workspace summary",
+      description: "Summarize Wireal projects, labels, and task status counts.",
+      inputSchema: z.object({}),
+      annotations: { readOnlyHint: true }
+    },
+    run(async () => {
+      const { workspace, revision } = await client.read();
+      return response({
+        revision,
+        map: workspace.map.name,
+        kind: workspaceKind(workspace),
+        repositoryLayout: repositoryLayout(workspace),
+        taskCount: workspace.tasks.length,
+        launchOrderMeaning: "The sequence the board lays tasks out in: prerequisites first, then left to right and top to bottom. It says where a task sits, not what to pick up next \u2014 call ready_tasks for that.",
+        statuses: statusCounts(workspace.tasks),
+        projects: workspace.projects.map((project) => {
+          const tasks = workspace.tasks.filter(
+            (task) => task.projectIds.includes(project.id)
+          );
+          return {
+            id: project.id,
+            name: project.name,
+            repositoryUrl: projectRepository(workspace, project),
+            folders: projectPaths(project),
+            taskCount: tasks.length,
+            statuses: statusCounts(tasks)
+          };
+        }),
+        labels: workspace.labels.map((label) => label.name)
+      });
+    }, callerName)
+  );
+  server2.registerTool(
+    "list_projects",
+    {
+      title: "List projects",
+      description: "List Wireal projects with repositories and per-status task counts.",
+      inputSchema: z.object({}),
+      annotations: { readOnlyHint: true }
+    },
+    run(async () => {
+      const { workspace, revision } = await client.read();
+      return response({
+        revision,
+        projects: workspace.projects.map((project) => {
+          const tasks = workspace.tasks.filter(
+            (task) => task.projectIds.includes(project.id)
+          );
+          return {
+            ...projectView(workspace, project),
+            taskCount: tasks.length,
+            statuses: statusCounts(tasks)
+          };
+        })
+      });
+    }, callerName)
+  );
+  server2.registerTool(
+    "list_tasks",
+    {
+      title: "List tasks",
+      description: "List and search tasks in workspace launch order, optionally filtered by project and status.",
+      inputSchema: z.object({
+        project: z.string().min(1).optional().describe("Project ID or exact project name"),
+        statuses: z.array(statusSchema).min(1).optional(),
+        query: z.string().min(1).optional().describe("Case-insensitive name, reference, or objective search")
+      }),
+      annotations: { readOnlyHint: true }
+    },
+    run(async ({ project, statuses: statuses2, query }) => {
+      const { workspace, revision } = await client.read();
+      const selectedProject = project ? findProject(workspace, project) : void 0;
+      const needle = query?.trim().toLowerCase();
+      const order = launchOrder(workspace);
+      const tasks = workspace.tasks.filter(
+        (task) => (!selectedProject || task.projectIds.includes(selectedProject.id)) && (!statuses2 || statuses2.includes(task.status)) && (!needle || task.name.toLowerCase().includes(needle) || task.referenceId.toLowerCase().includes(needle) || task.objective.toLowerCase().includes(needle))
+      ).sort(
+        (left, right) => (order.get(left.id) ?? Number.MAX_SAFE_INTEGER) - (order.get(right.id) ?? Number.MAX_SAFE_INTEGER)
+      );
+      return response({
+        revision,
+        count: tasks.length,
+        statuses: statusCounts(tasks),
+        launchOrderMeaning: "The sequence the board lays tasks out in: prerequisites first, then left to right and top to bottom. It says where a task sits, not what to pick up next \u2014 call ready_tasks for that.",
+        tasks: tasks.map((task) => {
+          const view = taskView(workspace, task, false, order);
+          return view.objective.length > 160 ? {
+            ...view,
+            objective: `${view.objective.slice(0, 160).trimEnd()}\u2026`
+          } : view;
+        })
+      });
+    }, callerName)
+  );
+  server2.registerTool(
+    "get_task",
+    {
+      title: "Get task",
+      description: "Read one task, including its workspace launch order, blockers, activity, projects, commits, parent, and dependencies.",
+      inputSchema: z.object({
+        task: z.string().min(1).describe(
+          "Task ID, task number as shown in the app (for example 12), or exact task name"
+        )
+      }),
+      annotations: { readOnlyHint: true }
+    },
+    run(async ({ task }) => {
+      const { workspace, revision } = await client.read();
+      return response({
+        revision,
+        task: taskView(workspace, findTask(workspace, task), true)
+      });
+    }, callerName)
+  );
+  server2.registerTool(
+    "ready_tasks",
+    {
+      title: "Ready tasks",
+      description: "List todo tasks whose parent and dependency prerequisites are done, in launch order.",
+      inputSchema: z.object({}),
+      annotations: { readOnlyHint: true }
+    },
+    run(async () => {
+      const { workspace, revision } = await client.read();
+      const order = launchOrder(workspace);
+      const tasks = readyTasks(workspace);
+      return response({
+        revision,
+        count: tasks.length,
+        tasks: tasks.map((task) => taskView(workspace, task, false, order))
+      });
+    }, callerName)
+  );
+  server2.registerTool(
+    "task_brief",
+    {
+      title: "Task brief",
+      description: "Read one task with its repository, project folders, and token-lean upstream activity.",
+      inputSchema: z.object({
+        task: z.string().min(1).describe("Task ID, task number, or exact task name")
+      }),
+      annotations: { readOnlyHint: true }
+    },
+    run(async ({ task }) => {
+      const { workspace, revision } = await client.read();
+      return response({ revision, ...taskBrief(workspace, task) });
+    }, callerName)
+  );
+  server2.registerTool(
+    "propose_task",
+    {
+      title: "Propose task",
+      description: "Propose separate follow-up work from the current task for a person to accept.",
+      inputSchema: z.object({
+        from: z.string().min(1).describe("Source task ID, number, or name"),
+        name: z.string().trim().min(1),
+        objective: z.string(),
+        projectIds: z.array(z.string().min(1)).min(1).optional(),
+        agent: agentSchema
+      }),
+      annotations: { readOnlyHint: false, destructiveHint: false }
+    },
+    run(async (input, agentName2) => {
+      const result2 = await client.mutate((workspace2) => {
+        const proposed = proposeTask(workspace2, input, agentName2);
+        return { state: proposed.state, value: proposed.task.id };
+      });
+      const { workspace } = await client.read();
+      return response({
+        revision: result2.revision,
+        task: taskView(workspace, findTask(workspace, result2.value), true)
+      });
+    }, callerName)
+  );
+  server2.registerTool(
+    "create_task",
+    {
+      title: "Create task",
+      description: "Create a task in one or more existing Wireal projects.",
+      inputSchema: z.object({
+        name: z.string().min(1),
+        projects: z.array(z.string().min(1)).min(1).describe("Project IDs or exact names"),
+        objective: z.string().optional(),
+        status: statusSchema.optional(),
+        labels: z.array(z.string().min(1)).optional().describe("Existing label names"),
+        parent: z.string().min(1).optional().describe("Optional parent task"),
+        agent: agentSchema
+      }),
+      annotations: { readOnlyHint: false, destructiveHint: false }
+    },
+    run(async (input, agentName2) => {
+      const result2 = await client.mutate((workspace2) => {
+        const created = createTask(workspace2, input, agentName2);
+        return { state: created.state, value: created.task.id };
+      });
+      const { workspace } = await client.read();
+      return response({
+        revision: result2.revision,
+        task: taskView(workspace, findTask(workspace, result2.value), true)
+      });
+    }, callerName)
+  );
+  server2.registerTool(
+    "update_task",
+    {
+      title: "Update task",
+      description: "Edit a task's name, project membership, or labels, but not status (use set_task_status) or objective (edited only by a person in the app; report findings with add_task_activity instead). A locked task rejects edits to its name, objective and parent until the lock is lifted in the app.",
+      inputSchema: z.object({
+        task: z.string().min(1),
+        name: z.string().min(1).optional(),
+        projects: z.array(z.string().min(1)).min(1).optional(),
+        labels: z.array(z.string().min(1)).optional(),
+        agent: agentSchema
+      }).refine(
+        ({ name, projects, labels }) => name !== void 0 || projects !== void 0 || labels !== void 0,
+        { message: "Provide at least one field to update." }
+      ),
+      annotations: { readOnlyHint: false, destructiveHint: false }
+    },
+    run(async ({ task, name, projects, labels }, agentName2) => {
+      const result2 = await client.mutate((workspace2) => {
+        const changed = patchTask(
+          workspace2,
+          task,
+          { name, projectIds: projects, labels },
+          agentName2
+        );
+        return { state: changed.state, value: changed.task.id };
+      });
+      const { workspace } = await client.read();
+      return response({
+        revision: result2.revision,
+        task: taskView(workspace, findTask(workspace, result2.value), true)
+      });
+    }, callerName)
+  );
+  server2.registerTool(
+    "delete_task",
+    {
+      title: "Delete task",
+      description: "Delete a task and its subtasks, removing every attached dependency link. A locked task cannot be deleted until the lock is lifted in the app.",
+      inputSchema: z.object({
+        task: z.string().min(1).describe(
+          "Task ID, task number as shown in the app (for example 12), or exact task name"
+        )
+      }),
+      annotations: { readOnlyHint: false, destructiveHint: true }
+    },
+    run(async ({ task }) => {
+      const result2 = await client.mutate((workspace) => {
+        const removed = deleteTask(workspace, task);
+        return {
+          state: removed.state,
+          value: {
+            task: {
+              id: removed.task.id,
+              referenceId: removed.task.referenceId,
+              name: removed.task.name
+            },
+            removedTasks: removed.removedTasks.map((candidate) => ({
+              id: candidate.id,
+              referenceId: candidate.referenceId,
+              name: candidate.name
+            }))
+          }
+        };
+      });
+      return response({ revision: result2.revision, ...result2.value });
+    }, callerName)
+  );
+  server2.registerTool(
+    "set_task_status",
+    {
+      title: "Set task status",
+      description: "Set a task status to proposed, todo, doing, or done and append an attributed audit activity.",
+      inputSchema: z.object({
+        task: z.string().min(1),
+        status: statusSchema,
+        agent: agentSchema
+      }),
+      annotations: { readOnlyHint: false, destructiveHint: false }
+    },
+    run(async ({ task, status }, agentName2) => {
+      const result2 = await client.mutate((workspace2) => {
+        const changed = setTaskStatus(workspace2, task, status, agentName2);
+        return { state: changed.state, value: changed.task.id };
+      });
+      const { workspace } = await client.read();
+      return response({
+        revision: result2.revision,
+        task: taskView(workspace, findTask(workspace, result2.value), true)
+      });
+    }, callerName)
+  );
+  server2.registerTool(
+    "add_task_activity",
+    {
+      title: "Add task activity",
+      description: "Append an AI-attributed activity entry to a task with a kind, a summary, and optionally the commit. A commit given as a full SHA is also linked to the task, which is what puts it on the commits canvas.",
+      inputSchema: z.object({
+        task: z.string().min(1),
+        kind: z.enum(activityKinds),
+        summary: z.string().trim().min(1).max(500),
+        commit: z.string().regex(/^[0-9a-f]{40}$/).describe(
+          "The full 40-character SHA from git rev-parse HEAD. An abbreviated SHA is rejected because only the full one can be linked to the task. The commit does not have to be pushed yet."
+        ).optional(),
+        agent: agentSchema
+      }),
+      annotations: { readOnlyHint: false, destructiveHint: false }
+    },
+    run(async ({ task, kind, summary, commit }, agentName2) => {
+      const result2 = await client.mutate((workspace) => {
+        const changed = addActivity(
+          workspace,
+          task,
+          { kind, summary, commit },
+          agentName2
+        );
+        return {
+          state: changed.state,
+          value: {
+            taskId: changed.task.id,
+            activityId: changed.task.activity[0].id,
+            ...changed.commitUrl ? { commitUrl: changed.commitUrl } : {}
+          }
+        };
+      });
+      return response({ revision: result2.revision, ...result2.value });
+    }, callerName)
+  );
+  server2.registerTool(
+    "close_task",
+    {
+      title: "Close task",
+      description: "Finish an agent run as done, blocked, or abandoned with one closing activity.",
+      inputSchema: z.object({
+        task: z.string().min(1),
+        outcome: z.enum(["done", "blocked", "abandoned"]),
+        summary: z.string().trim().min(1).max(500),
+        commit: z.string().regex(/^[0-9a-f]{40}$/).describe(
+          "The full 40-character SHA from git rev-parse HEAD. An abbreviated SHA is rejected because only the full one can be linked to the task. The commit does not have to be pushed yet."
+        ).optional(),
+        usage: z.object({
+          costUsd: z.number().nonnegative().optional(),
+          inputTokens: z.number().int().nonnegative().optional(),
+          outputTokens: z.number().int().nonnegative().optional(),
+          model: z.string().trim().min(1).optional(),
+          durationMs: z.number().nonnegative().optional()
+        }).optional(),
+        agent: agentSchema
+      }),
+      annotations: { readOnlyHint: false, destructiveHint: false }
+    },
+    run(async (input, agentName2) => {
+      const result2 = await client.mutate((workspace2) => {
+        const closed = closeTask(workspace2, input, agentName2);
+        return { state: closed.state, value: closed.task.id };
+      });
+      const { workspace } = await client.read();
+      return response({
+        revision: result2.revision,
+        task: taskView(workspace, findTask(workspace, result2.value), true)
+      });
+    }, callerName)
+  );
+  server2.registerTool(
+    "get_recent_activity",
+    {
+      title: "Get recent activity",
+      description: "List the newest kind-tagged or user-written activity entries as plain text, grouped by task.",
+      inputSchema: z.object({
+        task: z.string().min(1).optional().describe(
+          "Task ID, task number as shown in the app, or exact task name"
+        ),
+        limit: z.number().int().min(1).max(30).default(10)
+      }),
+      annotations: { readOnlyHint: true }
+    },
+    run(async ({ task, limit }) => {
+      const { workspace } = await client.read();
+      const tasks = task ? [findTask(workspace, task)] : workspace.tasks;
+      const eligible = [];
+      for (const candidate of tasks)
+        for (const entry of candidate.activity)
+          if (entry.kind !== void 0 || entry.authorType === "user")
+            eligible.push({ task: candidate, entry });
+      eligible.sort((a, b) => Date.parse(b.entry.at) - Date.parse(a.entry.at));
+      const selected = eligible.slice(0, limit);
+      const order = [];
+      const groups = /* @__PURE__ */ new Map();
+      for (const { task: owner, entry } of selected) {
+        let group = groups.get(owner.id);
+        if (!group) {
+          group = { task: owner, entries: [] };
+          groups.set(owner.id, group);
+          order.push(owner.id);
+        }
+        group.entries.push(entry);
+      }
+      const blocks = order.map((taskId) => {
+        const group = groups.get(taskId);
+        const lines = task ? [] : [
+          `#${group.task.referenceId} ${group.task.name} \xB7 ${group.task.status}`
+        ];
+        for (const entry of group.entries) {
+          const at = new Date(entry.at).toISOString().slice(0, 16) + "Z";
+          lines.push(
+            `${entry.kind ?? "note"} \xB7 ${entry.author} \xB7 ${entry.commit ?? "uncommitted"} \xB7 ${at}`
+          );
+          lines.push(`  ${entry.text}`);
+        }
+        return lines.join("\n");
+      });
+      return {
+        content: [{ type: "text", text: blocks.join("\n\n") }]
+      };
+    }, callerName)
+  );
+  server2.registerTool(
+    "link_github_commit",
+    {
+      title: "Link GitHub commit",
+      description: "Link a full GitHub commit URL or 40-character SHA to a task, validating it against a project repository.",
+      inputSchema: z.object({
+        task: z.string().min(1),
+        project: z.string().min(1),
+        commit: z.string().min(1),
+        agent: agentSchema
+      }),
+      annotations: { readOnlyHint: false, destructiveHint: false }
+    },
+    run(async ({ task, project, commit }, agentName2) => {
+      const result2 = await client.mutate((workspace) => {
+        const changed = linkCommit(workspace, task, project, commit, agentName2);
+        return {
+          state: changed.state,
+          value: { taskId: changed.task.id, commitUrl: changed.commitUrl }
+        };
+      });
+      return response({ revision: result2.revision, ...result2.value });
+    }, callerName)
+  );
+  server2.registerTool(
+    "unlink_github_commit",
+    {
+      title: "Unlink GitHub commit",
+      description: "Remove a linked commit using its URL or full SHA.",
+      inputSchema: z.object({
+        task: z.string().min(1),
+        commit: z.string().min(1),
+        agent: agentSchema
+      }),
+      annotations: { readOnlyHint: false, destructiveHint: true }
+    },
+    run(async ({ task, commit }, agentName2) => {
+      const result2 = await client.mutate((workspace) => {
+        const changed = unlinkCommit(workspace, task, commit, agentName2);
+        return { state: changed.state, value: changed.task.id };
+      });
+      return response({ revision: result2.revision, taskId: result2.value });
+    }, callerName)
+  );
+  server2.registerTool(
+    "add_task_dependency",
+    {
+      title: "Add task dependency",
+      description: "Make a task depend on another task; duplicate links and cycles are rejected.",
+      inputSchema: z.object({
+        task: z.string().min(1).describe("The blocked task"),
+        dependsOn: z.string().min(1).describe("The prerequisite task")
+      }),
+      annotations: { readOnlyHint: false, destructiveHint: false }
+    },
+    run(async ({ task, dependsOn }) => {
+      const result2 = await client.mutate((workspace) => {
+        const changed = addDependency(workspace, task, dependsOn);
+        return {
+          state: changed.state,
+          value: {
+            taskId: changed.task.id,
+            dependencyId: changed.dependency.id
+          }
+        };
+      });
+      return response({ revision: result2.revision, ...result2.value });
+    }, callerName)
+  );
+  server2.registerTool(
+    "remove_task_dependency",
+    {
+      title: "Remove task dependency",
+      description: "Remove a dependency link between two tasks.",
+      inputSchema: z.object({
+        task: z.string().min(1),
+        dependsOn: z.string().min(1)
+      }),
+      annotations: { readOnlyHint: false, destructiveHint: true }
+    },
+    run(async ({ task, dependsOn }) => {
+      const result2 = await client.mutate((workspace) => {
+        const changed = removeDependency(workspace, task, dependsOn);
+        return {
+          state: changed.state,
+          value: {
+            taskId: changed.task.id,
+            dependencyId: changed.dependency.id
+          }
+        };
+      });
+      return response({ revision: result2.revision, ...result2.value });
+    }, callerName)
+  );
+  server2.registerTool(
+    "create_label",
+    {
+      title: "Create label",
+      description: "Create a reusable Wireal task label.",
+      inputSchema: z.object({ name: z.string().min(1) }),
+      annotations: { readOnlyHint: false, destructiveHint: false }
+    },
+    run(async ({ name }) => {
+      const result2 = await client.mutate((workspace) => {
+        const state = createLabel(workspace, name);
+        const label = state.labels.find(
+          (candidate) => candidate.name.toLowerCase() === name.trim().toLowerCase()
+        );
+        return { state, value: label };
+      });
+      return response({ revision: result2.revision, label: result2.value });
+    }, callerName)
+  );
+  server2.registerTool(
+    "update_label",
+    {
+      title: "Update label",
+      description: "Rename a label everywhere it is used or change its six-digit hex color.",
+      inputSchema: z.object({
+        label: z.string().min(1).describe("Label ID or exact label name"),
+        name: z.string().min(1).optional(),
+        color: z.string().regex(/^#[0-9a-fA-F]{6}$/).optional()
+      }).refine(
+        ({ name, color }) => name !== void 0 || color !== void 0,
+        {
+          message: "Provide a name or color to update."
+        }
+      ),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true
+      }
+    },
+    run(async ({ label, name, color }) => {
+      const result2 = await client.mutate((workspace) => {
+        const changed = updateLabel(workspace, label, { name, color });
+        return { state: changed.state, value: changed.label };
+      });
+      return response({ revision: result2.revision, label: result2.value });
+    }, callerName)
+  );
+  server2.registerTool(
+    "delete_label",
+    {
+      title: "Delete label",
+      description: "Delete a label and remove it from every task that uses it.",
+      inputSchema: z.object({
+        label: z.string().min(1).describe("Label ID or exact label name")
+      }),
+      annotations: { readOnlyHint: false, destructiveHint: true }
+    },
+    run(async ({ label }) => {
+      const result2 = await client.mutate((workspace) => {
+        const removed = deleteLabel2(workspace, label);
+        return { state: removed.state, value: removed.label };
+      });
+      return response({ revision: result2.revision, label: result2.value });
+    }, callerName)
+  );
+  server2.registerTool(
+    "create_project",
+    {
+      title: "Create project",
+      description: "Create a Wireal project, optionally connecting a GitHub repository and repository folders for coding projects.",
+      inputSchema: z.object({
+        name: z.string().min(1),
+        repositoryUrl: z.string().url().optional(),
+        folders: z.array(z.string()).optional(),
+        color: z.string().regex(/^#[0-9a-fA-F]{6}$/).optional()
+      }),
+      annotations: { readOnlyHint: false, destructiveHint: false }
+    },
+    run(async (input) => {
+      const result2 = await client.mutate((workspace) => {
+        const changed = createProject(workspace, input);
+        return {
+          state: changed.state,
+          value: projectView(changed.state, changed.project)
+        };
+      });
+      return response({ revision: result2.revision, project: result2.value });
+    }, callerName)
+  );
+  server2.registerTool(
+    "update_project",
+    {
+      title: "Update project",
+      description: "Update a project's name, color, GitHub repository, or repository folders.",
+      inputSchema: z.object({
+        project: z.string().min(1).describe("Project ID or exact name"),
+        name: z.string().min(1).optional(),
+        repositoryUrl: z.string().optional(),
+        folders: z.array(z.string()).optional(),
+        color: z.string().regex(/^#[0-9a-fA-F]{6}$/).optional()
+      }).refine(
+        ({ name, repositoryUrl, color, folders }) => name !== void 0 || repositoryUrl !== void 0 || color !== void 0 || folders !== void 0,
+        { message: "Provide at least one field to update." }
+      ),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true
+      }
+    },
+    run(async ({ project, name, repositoryUrl, color, folders }) => {
+      const result2 = await client.mutate((workspace) => {
+        const changed = updateProject(workspace, project, {
+          name,
+          repositoryUrl,
+          color,
+          folders
+        });
+        return {
+          state: changed.state,
+          value: projectView(changed.state, changed.project)
+        };
+      });
+      return response({ revision: result2.revision, project: result2.value });
+    }, callerName)
+  );
+  server2.registerTool(
+    "delete_project",
+    {
+      title: "Delete project",
+      description: "Delete a project, keeping shared tasks in their other projects and deleting tasks that belong only to it.",
+      inputSchema: z.object({
+        project: z.string().min(1).describe("Project ID or exact name")
+      }),
+      annotations: { readOnlyHint: false, destructiveHint: true }
+    },
+    run(async ({ project }) => {
+      const result2 = await client.mutate((workspace) => {
+        const removed = deleteProject(workspace, project);
+        return {
+          state: removed.state,
+          value: {
+            project: { id: removed.project.id, name: removed.project.name },
+            removedTasks: removed.removedTasks.map((task) => ({
+              id: task.id,
+              referenceId: task.referenceId,
+              name: task.name
+            }))
+          }
+        };
+      });
+      return response({ revision: result2.revision, ...result2.value });
+    }, callerName)
+  );
+  server2.registerTool(
+    "configure_project_folders",
+    {
+      title: "Configure project folders",
+      description: "Configure repository-relative folders such as apps/web or services/api. In a monorepo, folders say which part of the shared repository belongs to the project, and commits touching those folders are attributed to it.",
+      inputSchema: z.object({
+        project: z.string().min(1).describe("Project ID or exact name"),
+        add: z.array(z.string()).optional(),
+        remove: z.array(z.string()).optional(),
+        replace: z.array(z.string()).optional()
+      }).refine(
+        ({ add, remove, replace }) => add !== void 0 || remove !== void 0 || replace !== void 0,
+        { message: "Provide add, remove, or replace." }
+      ),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true
+      }
+    },
+    run(async ({ project, add, remove, replace }) => {
+      const result2 = await client.mutate((workspace) => {
+        const changed = configureProjectFolders(workspace, project, {
+          add,
+          remove,
+          replace
+        });
+        return {
+          state: changed.state,
+          value: projectView(changed.state, changed.project)
+        };
+      });
+      return response({ revision: result2.revision, project: result2.value });
+    }, callerName)
+  );
+  server2.registerTool(
+    "configure_project_repository",
+    {
+      description: "Set a project's GitHub repository.",
+      inputSchema: z.object({
+        project: z.string().min(1),
+        repositoryUrl: z.string()
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true
+      }
+    },
+    run(async ({ project, repositoryUrl }) => {
+      const result2 = await client.mutate((workspace) => {
+        const changed = configureProjectRepository(workspace, project, {
+          repositoryUrl
+        });
+        return {
+          state: changed.state,
+          value: projectView(changed.state, changed.project)
+        };
+      });
+      return response({ revision: result2.revision, project: result2.value });
+    }, callerName)
+  );
+  return server2;
+}
+
+// src/api-client.ts
+var ApiError = class extends Error {
+  constructor(message, status = 0, errorCode) {
+    super(message);
+    this.status = status;
+    this.errorCode = errorCode;
+    this.name = "ApiError";
+    this.code = String(status);
+  }
+  status;
+  errorCode;
+  code;
+};
+async function result(action) {
+  try {
+    return { data: await action(), error: null };
+  } catch (error) {
+    return {
+      data: null,
+      error: error instanceof ApiError ? error : new ApiError(
+        error instanceof Error ? error.message : String(error)
+      )
+    };
+  }
+}
+async function readResponse(response2) {
+  const body = response2.status === 204 ? null : await response2.json().catch(() => null);
+  if (!response2.ok)
+    throw new ApiError(
+      body?.error?.message ?? body?.error_description ?? body?.title ?? body?.message ?? `Request failed (${response2.status}).`,
+      response2.status,
+      typeof body?.error === "string" ? body.error : void 0
+    );
+  return body;
+}
+function jsonBody(value) {
+  return {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(value)
+  };
+}
+var DataClient = class {
+  constructor(request) {
+    this.request = request;
+  }
+  request;
+  from(table) {
+    return new DataQuery(this.request, table);
+  }
+  async rpc(name, args = {}) {
+    try {
+      return await this.request(
+        `/api/commands/${encodeURIComponent(name)}`,
+        jsonBody(args)
+      );
+    } catch (error) {
+      return result(() => Promise.reject(error));
+    }
+  }
+};
+var DataQuery = class {
+  constructor(request, table) {
+    this.request = request;
+    this.query = {
+      table,
+      operation: "select",
+      columns: "*",
+      filters: [],
+      any: [],
+      order: [],
+      offset: 0,
+      limit: 1e3
+    };
+  }
+  request;
+  query;
+  select(columns = "*", options) {
+    this.query.columns = columns;
+    this.query.count = options?.count === "exact";
+    this.query.head = options?.head;
+    return this;
+  }
+  update(values) {
+    this.query.operation = "update";
+    this.query.values = values;
+    return this;
+  }
+  insert(values) {
+    this.query.operation = "insert";
+    this.query.values = values;
+    return this;
+  }
+  delete() {
+    this.query.operation = "delete";
+    return this;
+  }
+  eq(field, value) {
+    this.query.filters.push({ field, op: "eq", value });
+    return this;
+  }
+  neq(field, value) {
+    this.query.filters.push({ field, op: "neq", value });
+    return this;
+  }
+  in(field, value) {
+    this.query.filters.push({ field, op: "in", value });
+    return this;
+  }
+  ilike(field, value) {
+    this.query.filters.push({ field, op: "ilike", value });
+    return this;
+  }
+  /** Converts the app's fixed OR patterns into structured filters, never SQL. */
+  or(pattern) {
+    const parts = pattern.match(/[^,]+\.in\.\([^)]*\)|[^,]+/g) ?? [];
+    this.query.any.push(
+      parts.map((part) => {
+        const match = part.match(/^(\w+)\.(in|ilike|eq)\.(.*)$/);
+        if (!match) throw new ApiError("Invalid query filter.");
+        return {
+          field: match[1],
+          op: match[2],
+          value: match[2] === "in" ? match[3].slice(1, -1).split(",") : match[3]
+        };
+      })
+    );
+    return this;
+  }
+  order(field, options) {
+    this.query.order.push({ field, ascending: options?.ascending !== false });
+    return this;
+  }
+  range(from, to) {
+    this.query.offset = from;
+    this.query.limit = to - from + 1;
+    return this;
+  }
+  limit(limit) {
+    this.query.limit = limit;
+    return this;
+  }
+  async maybeSingle() {
+    this.query.single = "optional";
+    return this.execute();
+  }
+  async single() {
+    this.query.single = "required";
+    return this.execute();
+  }
+  async execute() {
+    try {
+      return await this.request("/api/query", jsonBody(this.query));
+    } catch (error) {
+      return result(() => Promise.reject(error));
+    }
+  }
+  then(fulfilled, rejected) {
+    return this.execute().then(fulfilled, rejected);
+  }
+};
+
+// mcp/client.ts
+var WirealClient = class {
+  constructor(config) {
+    this.config = config;
+    if (!config.url)
+      throw new Error(
+        "Set WIREAL_API_URL or VITE_API_URL before starting MCP."
+      );
+    const url = new URL(config.url);
+    if (url.protocol !== "https:" || url.pathname !== "/" || url.search || url.hash || url.username || url.password)
+      throw new Error("The API URL must be an HTTPS origin.");
+    this.agentName = config.agentName;
+    this.workspaceId = config.workspaceId?.trim() || void 0;
+    this.registeredClientName = config.registeredClientName;
+    this.userAgent = config.userAgent;
+    this.accessToken = config.accessToken ?? "";
+    this.refreshToken = config.refreshToken ?? "";
+    this.dataClient = new DataClient(async (path, init) => {
+      await this.authenticate();
+      const send = () => fetch(config.url.replace(/\/$/, "") + path, {
+        ...init,
+        headers: {
+          ...Object.fromEntries(new Headers(init?.headers)),
+          Authorization: "Bearer " + this.accessToken
+        }
+      });
+      let response2 = await send();
+      for (let attempt = 0; attempt < 2; attempt++) {
+        if (response2.status !== 401 || !this.refreshToken) break;
+        await this.refresh();
+        response2 = await send();
+      }
+      return readResponse(response2);
+    });
+  }
+  config;
+  agentName;
+  registeredClientName;
+  userAgent;
+  workspaceId;
+  dataClient;
+  accessToken;
+  refreshToken;
+  refreshing;
+  async authenticate() {
+    if (!this.accessToken && this.refreshToken) await this.refresh();
+    if (!this.accessToken)
+      throw new Error(
+        "Wireal MCP is not authenticated. Reconnect your client to the hosted Wireal MCP endpoint."
+      );
+  }
+  refresh() {
+    this.refreshing ??= (async () => {
+      if (this.config.refreshSession) {
+        const session2 = await this.config.refreshSession();
+        this.accessToken = session2.accessToken;
+        this.refreshToken = session2.refreshToken;
+        return;
+      }
+      if (!this.config.clientId)
+        throw new Error(
+          "MCP client registration is missing. Reconnect your client to the hosted Wireal MCP endpoint."
+        );
+      const body = new URLSearchParams({
+        grant_type: "refresh_token",
+        refresh_token: this.refreshToken,
+        client_id: this.config.clientId,
+        resource: this.config.resource ?? "https://mcp.wireal.co"
+      });
+      const session = await readResponse(
+        await fetch(this.config.url.replace(/\/$/, "") + "/oauth/token", {
+          method: "POST",
+          body,
+          signal: AbortSignal.timeout(15e3)
+        })
+      );
+      this.accessToken = session.access_token;
+      this.refreshToken = session.refresh_token;
+      this.config.onSession?.(this.accessToken, this.refreshToken);
+    })().finally(() => {
+      this.refreshing = void 0;
+    });
+    return this.refreshing;
+  }
+  async readCurrent() {
+    await this.authenticate();
+    const rows = this.dataClient.from("workspaces").select("id,data,revision");
+    const { data, error } = await (this.workspaceId ? rows.eq("id", this.workspaceId) : rows.eq("is_active", true)).limit(1).maybeSingle();
+    if (error) throw error;
+    if (!data)
+      throw new Error(
+        this.workspaceId ? `Workspace ${this.workspaceId} is not available to this user.` : "No Wireal cloud workspace exists for this user."
+      );
+    return {
+      workspace: parseWorkspace(JSON.stringify(data.data)),
+      revision: Number(data.revision),
+      workspaceId: data.id
+    };
+  }
+  async command(name, args) {
+    await this.authenticate();
+    const { data, error } = await this.dataClient.rpc(name, args);
+    if (error) throw error;
+    return data;
+  }
+  async read() {
+    return this.readCurrent();
+  }
+  async listWorkspaces() {
+    await this.authenticate();
+    const { data, error } = await this.dataClient.from("workspaces").select("id,data,revision,is_active").order("created_at", { ascending: true });
+    if (error) throw error;
+    return (data ?? []).map((row) => {
+      const workspace = parseWorkspace(JSON.stringify(row.data));
+      return {
+        id: row.id,
+        name: workspace.map.name,
+        kind: workspaceKind(workspace),
+        repositoryUrl: workspaceKind(workspace) === "everyday" ? "" : workspace.map.repositoryUrl,
+        revision: Number(row.revision),
+        isActive: this.workspaceId ? row.id === this.workspaceId : row.is_active
+      };
+    });
+  }
+  async setActiveWorkspace(identifier) {
+    if (this.workspaceId) {
+      const pinned = await this.readCurrent();
+      throw new Error(
+        `This session is pinned to workspace ${pinned.workspace.map.name}.`
+      );
+    }
+    const workspaces = await this.listWorkspaces();
+    const needle = identifier.trim().toLowerCase();
+    const matches = workspaces.filter(
+      (workspace2) => workspace2.id.toLowerCase() === needle || workspace2.name.toLowerCase() === needle
+    );
+    if (matches.length > 1)
+      throw new Error(`Ambiguous workspace: ${identifier}. Use its ID.`);
+    const workspace = matches[0];
+    if (!workspace) throw new Error(`Unknown workspace: ${identifier}`);
+    if (workspace.isActive) return workspace;
+    const { data, error } = await this.dataClient.rpc("set_active_workspace", {
+      target_workspace_id: workspace.id
+    });
+    if (error) throw error;
+    if (!data)
+      throw new Error(`Workspace could not be activated: ${identifier}`);
+    return { ...workspace, isActive: true };
+  }
+  async mutate(change) {
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+      const current = await this.readCurrent();
+      const changed = change(current.workspace);
+      const validated = parseWorkspace(JSON.stringify(changed.state));
+      if (JSON.stringify(validated) === JSON.stringify(current.workspace)) {
+        return { value: changed.value, revision: current.revision };
+      }
+      const { data, error } = await this.dataClient.from("workspaces").update({ data: validated, updated_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", current.workspaceId).eq("revision", current.revision).select("revision").maybeSingle();
+      if (error) throw error;
+      if (data)
+        return { value: changed.value, revision: Number(data.revision) };
+    }
+    throw new Error("The workspace changed concurrently. Retry the operation.");
+  }
+};
+
+// runner/session.ts
+import {
+  chmodSync,
+  closeSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "node:fs";
+import { homedir, hostname } from "node:os";
+import { dirname, join, posix, resolve, win32 } from "node:path";
+import { createInterface } from "node:readline/promises";
+function apiUrl(env = process.env) {
+  return (env.WIREAL_API_URL || "https://api.wireal.co").replace(/\/$/, "");
+}
+function mcpResource(env = process.env) {
+  return env.WIREAL_MCP_RESOURCE || "https://mcp.wireal.co";
+}
+function configDirectory(platform = process.platform, env = process.env, home = homedir()) {
+  const under = platform === "win32" ? win32.join : posix.join;
+  if (platform === "darwin")
+    return under(home, "Library", "Application Support", "wireal");
+  if (platform === "win32")
+    return under(env.APPDATA || under(home, "AppData", "Roaming"), "wireal");
+  return under(env.XDG_CONFIG_HOME || under(home, ".config"), "wireal");
+}
+function sessionPath(platform = process.platform, env = process.env, home = homedir()) {
+  return (platform === "win32" ? win32.join : posix.join)(
+    configDirectory(platform, env, home),
+    "session.json"
+  );
+}
+function readSession(path = sessionPath()) {
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (!parsed.accessToken && !parsed.refreshToken) return null;
+    return {
+      apiUrl: parsed.apiUrl || apiUrl(),
+      clientId: parsed.clientId ?? "",
+      accessToken: parsed.accessToken ?? "",
+      refreshToken: parsed.refreshToken ?? "",
+      savedAt: parsed.savedAt ?? ""
+    };
+  } catch {
+    return null;
+  }
+}
+function writeSession(session, path = sessionPath()) {
+  mkdirSync(dirname(path), { recursive: true, mode: 448 });
+  writeFileSync(path, JSON.stringify(session, null, 2), { mode: 384 });
+  try {
+    chmodSync(path, 384);
+  } catch {
+    return;
+  }
+}
+var lockStaleMs = 3e4;
+var lockBusyNote = "Another wireal-run on this machine is refreshing the saved session.";
+async function withSessionLock(work, path = sessionPath(), waitMs = 6e4) {
+  const lock = `${path}.lock`;
+  mkdirSync(dirname(path), { recursive: true, mode: 448 });
+  const until = Date.now() + waitMs;
+  let held;
+  while (held === void 0 && Date.now() < until) {
+    try {
+      held = openSync(lock, "wx", 384);
+    } catch {
+      const stale = statSync(lock, { throwIfNoEntry: false });
+      if (stale && Date.now() - stale.mtimeMs > lockStaleMs) {
+        rmSync(lock, { force: true });
+        continue;
+      }
+      await new Promise((wake) => setTimeout(wake, 40));
+    }
+  }
+  if (held === void 0) throw new Error(lockBusyNote);
+  try {
+    return await work();
+  } finally {
+    closeSync(held);
+    rmSync(lock, { force: true });
+  }
+}
+
+// runner/api.ts
+var refreshBefore = 6e4;
+var signedOutNote = "This machine's Wireal session was revoked. Run `wireal-run login` again.";
+function revoked(error) {
+  return /expired or revoked|invalid_grant|invalid refresh token/i.test(
+    error instanceof Error ? error.message : String(error)
+  );
+}
+function tokenExpiry(token) {
+  const part = token.split(".")[1];
+  if (!part) return 0;
+  try {
+    const body = JSON.parse(
+      Buffer.from(part, "base64url").toString("utf8")
+    );
+    return typeof body.exp === "number" && Number.isFinite(body.exp) ? body.exp * 1e3 : 0;
+  } catch {
+    return 0;
+  }
+}
+var RunnerSession = class {
+  constructor(session, path = sessionPath()) {
+    this.session = session;
+    this.path = path;
+    this.origin = (session.apiUrl || apiUrl()).replace(/\/$/, "");
+    this.accessToken = session.accessToken;
+    this.refreshToken = session.refreshToken;
+    this.expiresAt = tokenExpiry(session.accessToken);
+    this.data = new DataClient(async (path2, init) => {
+      await this.tokens().catch(() => void 0);
+      const send = () => fetch(this.origin + path2, {
+        ...init,
+        headers: {
+          ...Object.fromEntries(new Headers(init?.headers)),
+          Authorization: "Bearer " + this.accessToken
+        }
+      });
+      let response2 = await send();
+      for (let attempt = 0; attempt < 2; attempt++) {
+        if (response2.status !== 401 || !this.refreshToken) break;
+        await this.refresh();
+        response2 = await send();
+      }
+      return readResponse(response2);
+    });
+  }
+  session;
+  path;
+  origin;
+  data;
+  accessToken;
+  refreshToken;
+  expiresAt;
+  rotating;
+  fresh(now = Date.now()) {
+    if (!this.accessToken) return false;
+    return this.expiresAt === 0 || this.expiresAt - now > refreshBefore;
+  }
+  tokens() {
+    if (this.fresh())
+      return Promise.resolve({
+        accessToken: this.accessToken,
+        refreshToken: this.refreshToken
+      });
+    return this.refresh();
+  }
+  adopt(stored, sent) {
+    if (!stored?.refreshToken || stored.refreshToken === sent) return void 0;
+    this.accessToken = stored.accessToken;
+    this.refreshToken = stored.refreshToken;
+    this.expiresAt = tokenExpiry(stored.accessToken);
+    return { accessToken: this.accessToken, refreshToken: this.refreshToken };
+  }
+  refresh() {
+    this.rotating ??= withSessionLock(async () => {
+      const sent = this.refreshToken;
+      const taken = this.adopt(readSession(this.path), sent);
+      if (taken) return taken;
+      let issued;
+      try {
+        issued = await readResponse(
+          await fetch(this.origin + "/oauth/token", {
+            method: "POST",
+            body: new URLSearchParams({
+              grant_type: "refresh_token",
+              refresh_token: sent,
+              client_id: this.session.clientId,
+              resource: mcpResource()
+            }),
+            signal: AbortSignal.timeout(15e3)
+          })
+        );
+      } catch (error) {
+        const rotated = this.adopt(readSession(this.path), sent);
+        if (rotated) return rotated;
+        throw revoked(error) ? new Error(signedOutNote) : error;
+      }
+      this.accessToken = issued.access_token;
+      this.refreshToken = issued.refresh_token;
+      this.expiresAt = tokenExpiry(issued.access_token);
+      writeSession(
+        {
+          ...this.session,
+          accessToken: this.accessToken,
+          refreshToken: this.refreshToken,
+          savedAt: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        this.path
+      );
+      return { accessToken: this.accessToken, refreshToken: this.refreshToken };
+    }, this.path).finally(() => {
+      this.rotating = void 0;
+    });
+    return this.rotating;
+  }
+  client(agentName2, workspaceId2) {
+    return new WirealClient({
+      url: this.origin,
+      agentName: agentName2,
+      registeredClientName: agentName2,
+      ...workspaceId2 ? { workspaceId: workspaceId2 } : {},
+      accessToken: this.accessToken,
+      refreshToken: this.refreshToken,
+      clientId: this.session.clientId,
+      resource: mcpResource(),
+      refreshSession: () => this.tokens()
+    });
+  }
+};
+function openSession(path = sessionPath()) {
+  const session = readSession(path);
+  if (!session)
+    throw new Error("Not signed in. Run `wireal-run login` on this machine.");
+  return new RunnerSession(session, path);
+}
+
+// runner/board.ts
+function sessionClient(agentName2 = "Wireal runner", workspaceId2) {
+  return openSession().client(agentName2, workspaceId2);
+}
+
+// runner/mcp-stdio.ts
+var agentName = process.env.WIREAL_AGENT_NAME?.trim() || "Agent";
+var workspaceId = process.env.WIREAL_WORKSPACE_ID?.trim() || void 0;
+var server = createWirealServer(sessionClient(agentName, workspaceId));
+await server.connect(new StdioServerTransport());