pipe-kan 0.33.1 → 0.34.0

package/dist/pipe-kan.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/server.ts
-import { readFileSync as readFileSync7, writeSync } from "node:fs";
+import { readFileSync as readFileSync8, writeSync } from "node:fs";
 import { createServer } from "node:http";
 import { tmpdir as tmpdir3 } from "node:os";
 import { join as join11 } from "node:path";
@@ -156,6 +156,9 @@ function formatDueDate(value) {
 function createdAt(fields) {
   return typeof fields?.created === "string" && fields.created ? fields.created : undefined;
 }
+function updatedAt(fields) {
+  return typeof fields?.updated === "string" && fields.updated ? fields.updated : undefined;
+}
 function issueType(fields) {
   const name = fields?.issuetype?.name ?? fields?.issueType?.name;
   return typeof name === "string" ? name : undefined;
@@ -247,6 +250,7 @@ function toCard(issue, key, fieldId) {
   const epic = epicKey(issue.fields);
   const labels = issueLabels(issue.fields);
   const created = createdAt(issue.fields);
+  const updated = updatedAt(issue.fields);
   return {
     key,
     summary,
@@ -257,7 +261,8 @@ function toCard(issue, key, fieldId) {
     ...type ? { type } : {},
     ...epic ? { epic } : {},
     ...labels ? { labels } : {},
-    ...created ? { created } : {}
+    ...created ? { created } : {},
+    ...updated ? { updated } : {}
   };
 }
 function issuesToBoard(raw, opts = {}) {
@@ -360,6 +365,8 @@ function parseFlags(flags) {
   let type = "";
   let raw = "";
   let projectsValue = "";
+  let workspacesValue = "";
+  let scopesValue = "";
   let plane = false;
   let workspace = "";
   const statusEq = [];
@@ -372,6 +379,28 @@ function parseFlags(flags) {
       plane = true;
       continue;
     }
+    if (token === "--workspaces" || token.startsWith("--workspaces=")) {
+      const parts = [];
+      if (token.startsWith("--workspaces="))
+        parts.push(token.slice("--workspaces=".length));
+      while (i + 1 < list.length && !list[i + 1].startsWith("-")) {
+        i++;
+        parts.push(list[i]);
+      }
+      workspacesValue = parts.join(",");
+      continue;
+    }
+    if (token === "--scopes" || token.startsWith("--scopes=")) {
+      const parts = [];
+      if (token.startsWith("--scopes="))
+        parts.push(token.slice("--scopes=".length));
+      while (i + 1 < list.length && !list[i + 1].startsWith("-")) {
+        i++;
+        parts.push(list[i]);
+      }
+      scopesValue = parts.join(",");
+      continue;
+    }
     if (token === "--workspace" || token.startsWith("--workspace=")) {
       const [value, next] = takeValue(list, i, "--workspace");
       workspace = value.startsWith("=") ? value.slice(1) : value;
@@ -420,9 +449,11 @@ function parseFlags(flags) {
     }
   }
   const projects = projectsValue.split(",").map((p) => p.trim().toUpperCase()).filter(Boolean);
+  const workspaces = uniqueSlugs(workspacesValue);
+  const scopes = parseScopes(scopesValue);
   const workspaceSlug = workspace.trim() || undefined;
   if (raw) {
-    return { jql: raw, projects, plane, workspace: workspaceSlug };
+    return { jql: raw, projects, plane, workspace: workspaceSlug, workspaces, scopes };
   }
   const projectClause = projects.length ? `project in (${projects.map((p) => `"${p}"`).join(", ")})` : "";
   const clauses = [];
@@ -438,7 +469,47 @@ function parseFlags(flags) {
     clauses.push(`status="${status}"`);
   for (const status of statusNeq)
     clauses.push(`status!="${status}"`);
-  return { jql: clauses.join(" AND "), projects, plane, workspace: workspaceSlug };
+  return { jql: clauses.join(" AND "), projects, plane, workspace: workspaceSlug, workspaces, scopes };
+}
+function uniqueSlugs(value) {
+  const seen = new Set;
+  const slugs = [];
+  for (const part of value.split(",")) {
+    const slug = part.trim().toLowerCase();
+    if (!slug || seen.has(slug))
+      continue;
+    seen.add(slug);
+    slugs.push(slug);
+  }
+  return slugs;
+}
+function parseScopes(value) {
+  const seen = new Set;
+  const scopes = [];
+  for (const part of value.split(",")) {
+    const trimmed = part.trim();
+    if (!trimmed)
+      continue;
+    const slash = trimmed.indexOf("/");
+    if (slash <= 0)
+      continue;
+    const workspace = trimmed.slice(0, slash).trim().toLowerCase();
+    const project = trimmed.slice(slash + 1).trim().toUpperCase();
+    if (!workspace || !project)
+      continue;
+    const key = `${workspace}/${project}`;
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    scopes.push({ workspace, project });
+  }
+  return scopes;
+}
+function setPlaneFlag(flags, on) {
+  const list = tokens(flags.trim()).filter((token) => token !== "--plane");
+  if (on)
+    list.unshift("--plane");
+  return list.join(" ");
 }
 function wantsPlane(flags) {
   return parseFlags(flags).plane;
@@ -621,6 +692,11 @@ Available states for issue ${key}: ${available}`
       issue.fields.description = input.description;
     if (input.labels !== undefined)
       issue.fields.labels = input.labels;
+    if (input.priority !== undefined)
+      issue.fields.priority = { name: input.priority };
+    if (input.assignee !== undefined) {
+      issue.fields.assignee = input.assignee ? { displayName: input.assignee } : undefined;
+    }
     return { ok: true };
   }
 }
@@ -972,6 +1048,10 @@ ${result.stderr}`);
         for (const label of input.labels)
           args.push("-l", label);
       }
+      if (input.assignee !== undefined)
+        args.push("-a", input.assignee);
+      if (input.priority !== undefined)
+        args.push("--priority", input.priority);
       const result = await runRetry(args);
       if (result.code !== 0) {
         return { ok: false, error: (result.stderr || result.stdout).trim() };
@@ -1518,11 +1598,246 @@ function createApp(opts) {
     },
     async listProjectIdentifiers(workspace) {
       return cli.listProjectIdentifiers?.(workspace) ?? [];
+    },
+    async listProjects(workspace) {
+      return cli.listProjects?.(workspace) ?? [];
+    },
+    async parity() {
+      return cli.parity?.() ?? { initiatives: [], projects: [], workspaces: [] };
     }
   };
   return app;
 }
 
+// src/plane-fixture.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+var STATES = [
+  { id: "st-backlog", name: "Backlog", group: "backlog", sequence: 1 },
+  { id: "st-todo", name: "Todo", group: "unstarted", sequence: 2 },
+  { id: "st-progress", name: "In Progress", group: "started", sequence: 3 },
+  { id: "st-done", name: "Done", group: "completed", sequence: 4 },
+  { id: "st-cancelled", name: "Cancelled", group: "cancelled", sequence: 5 }
+];
+function mod(id, name, status, extra = {}) {
+  return { id, name, status, created_at: "2026-01-04T00:00:00Z", updated_at: "2026-02-02T00:00:00Z", ...extra };
+}
+function issue(id, name, sequence, state, extra = {}) {
+  return { id, name, sequence_id: sequence, state, created_at: "2026-01-06T00:00:00Z", updated_at: "2026-03-03T00:00:00Z", ...extra };
+}
+var SYNTHETIC_PLANE = {
+  workspaces: [
+    { id: "ws-work", name: "Work", slug: "work" },
+    { id: "ws-personal", name: "Personal", slug: "personal" }
+  ],
+  projects: {
+    work: [
+      { id: "work-pulse", identifier: "PULSE", name: "Pulse" },
+      { id: "work-aph", identifier: "APH", name: "Aphrodite" }
+    ],
+    personal: [
+      { id: "personal-pulse", identifier: "PULSE", name: "Pulse" },
+      { id: "personal-pkan", identifier: "PKAN", name: "Pipe kan" }
+    ]
+  },
+  states: STATES,
+  labels: [
+    { id: "lbl-needs", name: "needs-input" },
+    { id: "lbl-roadmap", name: "roadmap" }
+  ],
+  members: [
+    { id: "user-ada", display_name: "Ada" },
+    { id: "user-grace", display_name: "Grace" }
+  ],
+  modules: {
+    "work-pulse": [
+      mod("mod-00000000000000000000000000000001", "Backlog objective", "backlog", { priority: "low" }),
+      mod("mod-00000000000000000000000000000002", "Planned objective", "todo", { priority: "medium", start_date: "2026-04-01", target_date: "2026-12-01" }),
+      mod("mod-00000000000000000000000000000003", "Slipped objective", "in_progress", { priority: "high", start_date: "2025-01-01", target_date: "2025-06-01" }),
+      mod("mod-00000000000000000000000000000004", "On track objective", "in_progress", { priority: "urgent", start_date: "2026-03-01", target_date: "2026-11-15" }),
+      mod("mod-00000000000000000000000000000005", "Shipped objective", "done", { priority: "medium", start_date: "2025-11-01", target_date: "2026-01-20" }),
+      mod("mod-00000000000000000000000000000006", "Dropped objective", "cancelled", { priority: "low", target_date: "2025-03-01" }),
+      mod("mod-00000000000000000000000000000007", "Undated objective", "in_progress", { priority: "low", start_date: "2026-05-01" })
+    ],
+    "personal-pulse": [
+      mod("mod-00000000000000000000000000000011", "Home objective", "in_progress", { priority: "medium", start_date: "2026-02-01", target_date: "2026-08-01" })
+    ],
+    "work-aph": [
+      mod("mod-00000000000000000000000000000021", "Aphrodite objective", "todo", { priority: "high", target_date: "2026-07-01" })
+    ],
+    "personal-pkan": []
+  },
+  issues: {
+    "work-pulse": [
+      issue("wi-work-1", "Work pulse story", 1, "st-progress", { priority: "high", module_ids: ["mod-00000000000000000000000000000004"], assignee: "Ada", labels: ["lbl-roadmap"], target_date: "2026-11-01" }),
+      issue("wi-work-2", "Work pulse done", 2, "st-done", { priority: "low", module_ids: ["mod-00000000000000000000000000000005"], assignee: "Grace" })
+    ],
+    "personal-pulse": [
+      issue("wi-home-1", "Personal pulse story", 1, "st-todo", { priority: "medium", module_ids: ["mod-00000000000000000000000000000011"], assignee: "Ada", labels: ["lbl-needs"], target_date: "2026-08-01" })
+    ],
+    "work-aph": [issue("wi-aph-1", "Aphrodite story", 4, "st-backlog", { priority: "medium" })],
+    "personal-pkan": [issue("wi-pkan-1", "Pipe kan story", 3, "st-todo", { priority: "low", assignee: "Grace" })]
+  }
+};
+function page(results) {
+  return { results, next_page_results: false, next_cursor: "" };
+}
+function planeFixtureFetch(fixture = SYNTHETIC_PLANE) {
+  const data = JSON.parse(JSON.stringify(fixture));
+  const stateById = new Map(data.states.map((state) => [state.id, state]));
+  const labelById = new Map(data.labels.map((label) => [label.id, label]));
+  return async (input, init) => {
+    const url = new URL(String(input), "https://plane.test");
+    const method = (init?.method ?? "GET").toUpperCase();
+    const path = url.pathname.replace(/\/+$/, "") || "/";
+    const parts = path.split("/").filter(Boolean);
+    let body;
+    if (init?.body)
+      body = JSON.parse(String(init.body));
+    if (method === "GET" && parts[2] === "users" && parts[4] === "workspaces") {
+      return Response.json(data.workspaces);
+    }
+    if (method === "GET" && parts[2] === "workspaces" && parts.length === 3) {
+      return Response.json(page(data.workspaces));
+    }
+    if (method === "GET" && /\/workspaces\/[^/]+\/projects$/.test(path)) {
+      return Response.json(page(data.projects[parts[3] ?? ""] ?? []));
+    }
+    if (method === "GET" && parts[4] === "members" && parts.length === 5)
+      return Response.json(page(data.members));
+    const projectId = parts[5] ?? "";
+    const collection = parts[6];
+    const itemId = parts[7];
+    const projectIssues = data.issues[projectId] ?? [];
+    const projectModules = data.modules[projectId] ?? [];
+    if (method === "GET" && collection === "states")
+      return Response.json(page(data.states));
+    if (method === "GET" && collection === "labels")
+      return Response.json(page(data.labels));
+    if (method === "GET" && collection === "modules" && !itemId)
+      return Response.json(page(projectModules));
+    if (method === "GET" && collection === "modules" && parts[8] === "module-issues") {
+      const ids = projectIssues.filter((row) => row.module_ids?.includes(itemId ?? "")).map((row) => row.id);
+      return Response.json(page(ids.map((id) => ({ issue: id, module: itemId }))));
+    }
+    if (method === "GET" && (collection === "work-items" || collection === "issues") && !itemId) {
+      return Response.json(page(projectIssues.map((row) => toWorkItem(row, stateById, labelById))));
+    }
+    if (method === "PATCH" && collection === "modules" && itemId) {
+      const module = projectModules.find((row) => row.id === itemId);
+      if (module && typeof body?.status === "string")
+        module.status = body.status;
+      return Response.json({ id: itemId, ...body });
+    }
+    if (method === "PATCH" && (collection === "work-items" || collection === "issues") && itemId) {
+      const issueRow = projectIssues.find((row) => row.id === itemId);
+      if (issueRow && typeof body?.state === "string")
+        issueRow.state = body.state;
+      if (issueRow && typeof body?.priority === "string")
+        issueRow.priority = body.priority;
+      if (issueRow && typeof body?.name === "string")
+        issueRow.name = body.name;
+      return Response.json({ id: itemId, ...body });
+    }
+    if (method === "POST" && (collection === "work-items" || collection === "issues") && !itemId) {
+      const sequence = 100 + projectIssues.length;
+      projectIssues.push(issue(`wi-new-${sequence}`, String(body?.name ?? "New"), sequence, "st-todo"));
+      return Response.json({ id: `wi-new-${sequence}`, sequence_id: sequence, name: body?.name }, { status: 201 });
+    }
+    return new Response(`unhandled ${method} ${path}`, { status: 404 });
+  };
+}
+function toWorkItem(row, states, labels) {
+  const state = states.get(row.state);
+  return {
+    id: row.id,
+    name: row.name,
+    sequence_id: row.sequence_id,
+    priority: row.priority,
+    state: state ? { id: state.id, name: state.name } : row.state,
+    labels: row.labels ?? [],
+    label_details: (row.labels ?? []).map((id) => labels.get(id)).filter(Boolean),
+    module_ids: row.module_ids ?? [],
+    assignees: row.assignee ? [{ display_name: row.assignee }] : [],
+    created_at: row.created_at,
+    updated_at: row.updated_at,
+    target_date: row.target_date,
+    start_date: row.start_date
+  };
+}
+function resolvePlaneFetch(env = process.env) {
+  const fixture = env.PLANE_FIXTURE?.trim();
+  if (!fixture)
+    return;
+  if (fixture === "synthetic")
+    return planeFixtureFetch(SYNTHETIC_PLANE);
+  const parsed = JSON.parse(readFileSync3(fixture, "utf8"));
+  return planeFixtureFetch(parsed);
+}
+
+// src/parity.ts
+function normalizeStatus(status) {
+  return status.trim().toLowerCase().replace(/[_-]+/g, " ").replace(/\s+/g, " ");
+}
+function parseDay(value) {
+  if (!value)
+    return;
+  const day = /^(\d{4})-(\d{2})-(\d{2})/.exec(value.trim());
+  if (day)
+    return new Date(Number(day[1]), Number(day[2]) - 1, Number(day[3]));
+  const parsed = new Date(value);
+  if (Number.isNaN(parsed.getTime()))
+    return;
+  return new Date(parsed.getFullYear(), parsed.getMonth(), parsed.getDate());
+}
+function startOfToday(now) {
+  return new Date(now.getFullYear(), now.getMonth(), now.getDate());
+}
+function computeHealth(status, targetDate, now = new Date) {
+  const key = normalizeStatus(status);
+  if (key === "done" || key === "completed" || key === "complete")
+    return "green";
+  if (key === "cancelled" || key === "canceled")
+    return "red";
+  if (key === "in progress" || key === "started" || key === "active" || key === "paused") {
+    const target = parseDay(targetDate);
+    if (key === "paused")
+      return "yellow";
+    if (target && target.getTime() < startOfToday(now).getTime())
+      return "yellow";
+    return "green";
+  }
+  if (key === "todo" || key === "to do" || key === "backlog" || key === "planned" || key === "unstarted" || key === "") {
+    return "gray";
+  }
+  return "gray";
+}
+function isCompletedStatus(status) {
+  const key = normalizeStatus(status);
+  return key === "done" || key === "completed" || key === "complete" || key === "cancelled" || key === "canceled";
+}
+function sourceOptions(input) {
+  return [
+    {
+      id: "plane",
+      label: "Plane",
+      enabled: input.planeKey,
+      ...input.planeKey ? {} : { reason: "Set PLANE_API_KEY to use Plane" }
+    },
+    {
+      id: "jira",
+      label: "Jira",
+      enabled: true,
+      ...input.jiraBin ? {} : { reason: "jira-cli is not on PATH; Fake Jira is used" }
+    },
+    {
+      id: "taskwarrior",
+      label: "Taskwarrior",
+      enabled: false,
+      reason: "Taskwarrior is not connected"
+    }
+  ];
+}
+
 // src/plane.ts
 var DEFAULT_PLANE_HOST = "https://plane.tail48fe8.ts.net";
 var DEFAULT_PLANE_WORKSPACE = "personal";
@@ -1692,12 +2007,14 @@ function workItemToIssue(item, project, opts) {
       ...opts.moduleKey ? { parent: { key: opts.moduleKey } } : {},
       ...labels.length ? { labels } : {},
       ...asString(item.created_at) ? { created: item.created_at } : {},
+      ...asString(item.updated_at) ? { updated: item.updated_at } : {},
       ...description ? { description } : {}
     }
   };
 }
 function moduleToIssue(module, project) {
   const target = asString(module.target_date);
+  const priority = titleCasePriority(module.priority);
   return {
     key: planeModuleKey(project.identifier, module.id),
     fields: {
@@ -1705,8 +2022,10 @@ function moduleToIssue(module, project) {
       status: { name: moduleStatusName(module.status) },
       issuetype: { name: "Epic" },
       issueType: { name: "Epic" },
+      ...priority ? { priority: { name: priority } } : {},
       ...target ? { duedate: target, "Target End Date": target } : {},
-      ...asString(module.created_at) ? { created: module.created_at } : {}
+      ...asString(module.created_at) ? { created: module.created_at } : {},
+      ...asString(module.updated_at) ? { updated: module.updated_at } : {}
     }
   };
 }
@@ -1936,25 +2255,76 @@ function createPlaneCli(opts) {
       status: asString(row?.status),
       created_at: asString(row?.created_at),
       target_date: asString(row?.target_date),
-      start_date: asString(row?.start_date)
+      start_date: asString(row?.start_date),
+      priority: asString(row?.priority),
+      updated_at: asString(row?.updated_at)
     };
   }
+  function catalogPlan(flags) {
+    const parsed = parseFlags(flags || defaultFlags);
+    if (parsed.scopes.length) {
+      return {
+        slugs: [...new Set(parsed.scopes.map((scope) => scope.workspace))],
+        pairs: parsed.scopes
+      };
+    }
+    if (parsed.workspaces.length)
+      return { slugs: parsed.workspaces, pairs: null };
+    return { slugs: [workspaceOf(flags)], pairs: null };
+  }
+  function exposeKey(slug, key, multi) {
+    return multi ? `${slug}/${key}` : key;
+  }
+  function prefixIssue(issue, slug, multi) {
+    if (!multi || typeof issue.key !== "string")
+      return issue;
+    const parent = asRecord(issue.fields?.parent);
+    const parentKey = asString(parent?.key);
+    return {
+      ...issue,
+      key: exposeKey(slug, issue.key, true),
+      fields: {
+        ...issue.fields,
+        ...parentKey ? { parent: { ...parent, key: exposeKey(slug, parentKey, true) } } : {}
+      }
+    };
+  }
+  const projectCache = new Map;
+  const cacheTtlMs = opts.cacheTtlMs ?? 30000;
+  async function projectsFor(slug) {
+    const hit = projectCache.get(slug);
+    const now = nowFn();
+    if (cacheTtlMs > 0 && hit && now - hit.at < cacheTtlMs)
+      return hit.rows;
+    const rows = (await paginate(`/workspaces/${slug}/projects/`)).map(parseProject).filter((row) => !!row).map((project) => ({ ...project, workspace: slug }));
+    projectCache.set(slug, { at: now, rows });
+    return rows;
+  }
   async function loadCatalog(flags) {
     lastFlags = flags || defaultFlags;
-    const workspace = workspaceOf(lastFlags);
-    if (catalog && catalog.flags === lastFlags && catalog.workspace === workspace)
+    const plan = catalogPlan(lastFlags);
+    const cacheKey = plan.slugs.join(",");
+    if (catalog && catalog.flags === lastFlags && catalog.cacheKey === cacheKey)
       return catalog;
-    const projects = scopedProjects((await paginate(`/workspaces/${workspace}/projects/`)).map(parseProject).filter((row) => !!row), lastFlags);
+    const multi = plan.slugs.length > 1;
+    const projects = [];
     const states = new Map;
     const labels = new Map;
     const works = new Map;
     const modules = new Map;
     const columnStates = [];
+    for (const slug of plan.slugs) {
+      const listed = await projectsFor(slug);
+      const chosen = plan.pairs ? listed.filter((project) => plan.pairs.some((pair) => pair.workspace === slug && pair.project === project.identifier.toUpperCase())) : scopedProjects(listed, lastFlags);
+      for (const project of chosen)
+        projects.push(project);
+    }
     for (const project of projects) {
-      const stateRows = await paginate(`/workspaces/${workspace}/projects/${project.id}/states/`);
-      const labelRows = await paginate(`/workspaces/${workspace}/projects/${project.id}/labels/`);
-      const moduleRows = await paginate(`/workspaces/${workspace}/projects/${project.id}/modules/`);
-      const workRows = await withResource((resource) => paginate(queryPath(`/workspaces/${workspace}/projects/${project.id}/${resource}/`, {
+      const slug = project.workspace || plan.slugs[0] || workspaceOf(lastFlags);
+      const stateRows = await paginate(`/workspaces/${slug}/projects/${project.id}/states/`);
+      const labelRows = await paginate(`/workspaces/${slug}/projects/${project.id}/labels/`);
+      const moduleRows = await paginate(`/workspaces/${slug}/projects/${project.id}/modules/`);
+      const workRows = await withResource((resource) => paginate(queryPath(`/workspaces/${slug}/projects/${project.id}/${resource}/`, {
         expand: "assignees,labels,state,module"
       })));
       const stateById = new Map;
@@ -1976,7 +2346,7 @@ function createPlaneCli(opts) {
         const module = parseModule(row);
         if (!module)
           continue;
-        const issue = moduleToIssue(module, project);
+        const issue = prefixIssue(moduleToIssue(module, project), slug, multi);
         const cached = { issue, module, project };
         moduleById.set(module.id, cached);
         modules.set(String(issue.key), cached);
@@ -1988,7 +2358,7 @@ function createPlaneCli(opts) {
       const issueByModule = new Map;
       if (missingModules && moduleById.size) {
         for (const moduleId of moduleById.keys()) {
-          const rows = await paginate(`/workspaces/${workspace}/projects/${project.id}/modules/${moduleId}/module-issues/`);
+          const rows = await paginate(`/workspaces/${slug}/projects/${project.id}/modules/${moduleId}/module-issues/`);
           const ids = rows.map((row) => asId(asRecord(row)?.issue) ?? asId(row)).filter((id) => !!id);
           issueByModule.set(moduleId, ids);
         }
@@ -1998,26 +2368,29 @@ function createPlaneCli(opts) {
         const fromItem = moduleIdsOf(item)[0];
         const fromJoin = [...issueByModule.entries()].find(([, ids]) => ids.includes(item.id))?.[0];
         const moduleId = fromItem ?? fromJoin;
-        const moduleKey = moduleId ? moduleById.get(moduleId)?.issue.key : undefined;
+        const bareModuleKey = moduleId ? planeModuleKey(project.identifier, moduleId) : undefined;
         const issue = workItemToIssue(item, project, {
           states: stateById,
           labels: labelById,
-          moduleKey: typeof moduleKey === "string" ? moduleKey : undefined
+          ...bareModuleKey ? { moduleKey: bareModuleKey } : {}
         });
-        const issueKey = typeof issue?.key === "string" ? issue.key : undefined;
-        if (!issue || !issueKey)
+        const stamped = issue ? prefixIssue(issue, slug, multi) : undefined;
+        const issueKey = typeof stamped?.key === "string" ? stamped.key : undefined;
+        if (!stamped || !issueKey)
           continue;
+        const linked = bareModuleKey ? exposeKey(slug, bareModuleKey, multi) : undefined;
         works.set(issueKey, {
-          issue,
+          issue: stamped,
           item,
           project,
-          ...typeof moduleKey === "string" ? { moduleKey } : {}
+          ...linked ? { moduleKey: linked } : {}
         });
       }
     }
     catalog = {
       flags: lastFlags,
-      workspace,
+      workspace: plan.slugs[0] || workspaceOf(lastFlags),
+      cacheKey,
       projects,
       states,
       labels,
@@ -2027,6 +2400,73 @@ function createPlaneCli(opts) {
     };
     return catalog;
   }
+  function projectSlug(project) {
+    return project.workspace || workspaceOf(lastFlags);
+  }
+  function buildParity(loaded) {
+    const projects = loaded.projects.map((project) => {
+      const issues = [...loaded.works.values()].filter((row) => row.project.id === project.id && row.project.workspace === project.workspace);
+      const modules = [...loaded.modules.values()].filter((row) => row.project.id === project.id && row.project.workspace === project.workspace);
+      const total = issues.length;
+      const completed = issues.filter((row) => {
+        const name = typeof row.issue.fields?.status?.name === "string" ? row.issue.fields.status.name : "";
+        const key = name.toLowerCase();
+        return key === "done" || key === "completed";
+      }).length;
+      const started = issues.some((row) => {
+        const name = typeof row.issue.fields?.status?.name === "string" ? row.issue.fields.status.name : "";
+        return name.toLowerCase() === "in progress";
+      });
+      const status = total > 0 && completed === total ? "done" : started ? "in_progress" : "backlog";
+      const dates = [
+        ...modules.map((row) => row.module.target_date),
+        ...issues.map((row) => row.item.target_date)
+      ].filter((value) => Boolean(value));
+      const starts = [
+        ...modules.map((row) => row.module.start_date),
+        ...issues.map((row) => row.item.start_date)
+      ].filter((value) => Boolean(value));
+      const targetDate = dates.sort().at(-1);
+      const startDate = starts.sort()[0];
+      return {
+        workspace: project.workspace || loaded.workspace,
+        id: project.id,
+        identifier: project.identifier,
+        name: project.name,
+        total,
+        completed,
+        status,
+        ...startDate ? { startDate } : {},
+        ...targetDate ? { targetDate } : {},
+        health: computeHealth(status, targetDate)
+      };
+    });
+    const active = new Map(projects.map((project) => [`${project.workspace}/${project.id}`, project.completed < project.total || project.total === 0]));
+    const initiatives = [...loaded.modules.values()].map((row) => {
+      const raw = row.module.status ?? "backlog";
+      const priority = titleCasePriority(row.module.priority);
+      const open = active.get(`${row.project.workspace}/${row.project.id}`) !== false;
+      return {
+        key: String(row.issue.key),
+        name: row.module.name,
+        workspace: row.project.workspace || loaded.workspace,
+        project: row.project.identifier,
+        status: moduleStatusName(raw),
+        rawStatus: raw,
+        ...priority ? { priority } : {},
+        ...row.module.start_date ? { startDate: row.module.start_date } : {},
+        ...row.module.target_date ? { targetDate: row.module.target_date } : {},
+        ...row.module.updated_at ? { updated: row.module.updated_at } : {},
+        health: computeHealth(raw, row.module.target_date),
+        activeProjects: isCompletedStatus(raw) || !open ? 0 : 1
+      };
+    });
+    return {
+      initiatives,
+      projects,
+      workspaces: [...new Set(loaded.projects.map((project) => project.workspace || loaded.workspace))]
+    };
+  }
   function filterWorks(flags, works) {
     const parsed = parseFlags(flags || defaultFlags);
     return works.filter(({ issue }) => {
@@ -2136,7 +2576,20 @@ function createPlaneCli(opts) {
       const slug = workspace.trim();
       if (!slug)
         return [];
-      return (await paginate(`/workspaces/${slug}/projects/`)).map(parseProject).filter((row) => !!row).map((row) => row.identifier);
+      return (await projectsFor(slug)).map((row) => row.identifier);
+    },
+    async listProjects(workspace) {
+      const slug = workspace.trim();
+      if (!slug)
+        return [];
+      return (await projectsFor(slug)).map((row) => ({
+        id: row.id,
+        identifier: row.identifier,
+        name: row.name
+      }));
+    },
+    async parity(flags) {
+      return buildParity(await loadCatalog(flags || lastFlags));
     },
     async move(key, status) {
       try {
@@ -2155,7 +2608,7 @@ function createPlaneCli(opts) {
           }).find(([name]) => name === status.toLowerCase())?.[1];
           if (!mapped)
             return { ok: false, error: `Unknown Plane module status "${status}"` };
-          await request(`/workspaces/${workspaceOf(lastFlags)}/projects/${module.project.id}/modules/${module.module.id}/`, { method: "PATCH", body: JSON.stringify({ status: mapped }) });
+          await request(`/workspaces/${projectSlug(module.project)}/projects/${module.project.id}/modules/${module.module.id}/`, { method: "PATCH", body: JSON.stringify({ status: mapped }) });
           catalog = undefined;
           return { ok: true };
         }
@@ -2165,7 +2618,7 @@ function createPlaneCli(opts) {
         const state = await resolveStateId(work.project, status, lastFlags);
         if (!state)
           return { ok: false, error: `Unknown Plane state "${status}" for ${key}` };
-        await withResource((resource) => request(`/workspaces/${workspaceOf(lastFlags)}/projects/${work.project.id}/${resource}/${work.item.id}/`, { method: "PATCH", body: JSON.stringify({ state }) }));
+        await withResource((resource) => request(`/workspaces/${projectSlug(work.project)}/projects/${work.project.id}/${resource}/${work.item.id}/`, { method: "PATCH", body: JSON.stringify({ state }) }));
         catalog = undefined;
         return { ok: true };
       } catch (err) {
@@ -2188,14 +2641,14 @@ function createPlaneCli(opts) {
           body.state = state;
         if (labels.length)
           body.labels = labels;
-        const created = asRecord(await withResource((resource) => requestJson(`/workspaces/${workspaceOf(lastFlags)}/projects/${project.id}/${resource}/`, {
+        const created = asRecord(await withResource((resource) => requestJson(`/workspaces/${projectSlug(project)}/projects/${project.id}/${resource}/`, {
           method: "POST",
           body: JSON.stringify(body)
         })));
         const sequence = Number(created?.sequence_id);
         const key = Number.isFinite(sequence) && sequence > 0 ? planeWorkItemKey(project.identifier, sequence) : undefined;
         if (parent && created?.id) {
-          await request(`/workspaces/${workspaceOf(lastFlags)}/projects/${project.id}/modules/${parent.module.id}/module-issues/`, { method: "POST", body: JSON.stringify({ issues: [created.id] }) });
+          await request(`/workspaces/${projectSlug(project)}/projects/${project.id}/modules/${parent.module.id}/module-issues/`, { method: "POST", body: JSON.stringify({ issues: [created.id] }) });
         }
         catalog = undefined;
         return key ? { ok: true, key } : { ok: true };
@@ -2205,6 +2658,24 @@ function createPlaneCli(opts) {
     },
     async edit(key, input) {
       try {
+        const loaded = await loadCatalog(lastFlags);
+        const module = loaded.modules.get(key);
+        if (module) {
+          if (input.assignee !== undefined)
+            return { ok: false, error: "Plane modules have no assignee field" };
+          if (input.labels)
+            return { ok: false, error: "Plane modules have no labels field" };
+          const body = {};
+          if (input.summary !== undefined)
+            body.name = input.summary;
+          if (input.priority !== undefined)
+            body.priority = input.priority.toLowerCase();
+          if (Object.keys(body).length) {
+            await request(`/workspaces/${projectSlug(module.project)}/projects/${module.project.id}/modules/${module.module.id}/`, { method: "PATCH", body: JSON.stringify(body) });
+          }
+          catalog = undefined;
+          return { ok: true };
+        }
         const work = await lookupByKey(key, lastFlags);
         if (!work)
           return { ok: false, error: `Work item ${key} not found` };
@@ -2215,7 +2686,19 @@ function createPlaneCli(opts) {
           body.description_html = htmlParagraph(input.description);
         if (input.labels)
           body.labels = await resolveLabelIds(work.project, input.labels, lastFlags);
-        await withResource((resource) => request(`/workspaces/${workspaceOf(lastFlags)}/projects/${work.project.id}/${resource}/${work.item.id}/`, { method: "PATCH", body: JSON.stringify(body) }));
+        if (input.priority !== undefined)
+          body.priority = input.priority.toLowerCase();
+        if (input.assignee !== undefined) {
+          const slug = projectSlug(work.project);
+          const members = (await paginate(`/workspaces/${slug}/members/`)).map((row) => asRecord(row));
+          const wanted = input.assignee.trim().toLowerCase();
+          const member = members.find((row) => asString(row?.display_name)?.toLowerCase() === wanted);
+          const memberId = asString(member?.id);
+          if (wanted && !memberId)
+            return { ok: false, error: `Plane member "${input.assignee}" was not found` };
+          body.assignees = memberId ? [memberId] : [];
+        }
+        await withResource((resource) => request(`/workspaces/${projectSlug(work.project)}/projects/${work.project.id}/${resource}/${work.item.id}/`, { method: "PATCH", body: JSON.stringify(body) }));
         catalog = undefined;
         return { ok: true };
       } catch (err) {
@@ -2223,7 +2706,12 @@ function createPlaneCli(opts) {
       }
     },
     async open(key) {
-      return `${host}/${workspaceOf(lastFlags)}/browse/${key}`;
+      const loaded = await loadCatalog(lastFlags);
+      const module = loaded.modules.get(key);
+      const work = loaded.works.get(key);
+      const slug = module?.project.workspace || work?.project.workspace || workspaceOf(lastFlags);
+      const bare = key.includes("/") ? key.slice(key.indexOf("/") + 1) : key;
+      return `${host}/${slug}/browse/${bare}`;
     },
     async view(key) {
       const loaded = await loadCatalog(lastFlags);
@@ -2245,13 +2733,15 @@ async function createBoardApp(opts) {
   const store = IssueStore.fromRaw(opts.raw);
   const plane = wantsPlane(flags);
   const bin = resolveJiraBin(env.JIRA_BIN ?? "jira", env.PATH ?? "");
+  const fixtureMode = Boolean(env.PLANE_FIXTURE?.trim());
+  const useJira = Boolean(bin) && !fixtureMode;
   const cli = plane ? createPlaneCli({
     host: planeHost(env),
     apiKey: env.PLANE_API_KEY ?? "",
     workspace: planeWorkspace(flags, env),
     flags,
-    fetch: opts.fetch
-  }) : bin ? createJiraCli({
+    fetch: opts.fetch ?? resolvePlaneFetch(env)
+  }) : useJira ? createJiraCli({
     bin,
     configPath: env.JIRA_CONFIG_FILE,
     token: env.JIRA_API_TOKEN,
@@ -2270,7 +2760,7 @@ async function createBoardApp(opts) {
     const local = createStoreCli(store, flags);
     app.hydrate(JSON.parse(await local.list(app.flags)), { fromStore: true });
   }
-  return { app, store, kind: plane ? "plane" : bin ? "jira" : "store" };
+  return { app, store, kind: plane ? "plane" : useJira ? "jira" : "store" };
 }
 async function refreshFromJira(app, kind, opts = {}) {
   if (opts.piped)
@@ -2281,7 +2771,7 @@ async function refreshFromJira(app, kind, opts = {}) {
 }
 
 // src/factory-ledger.ts
-import { existsSync as existsSync2, readFileSync as readFileSync3, statSync } from "node:fs";
+import { existsSync as existsSync2, readFileSync as readFileSync4, statSync } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 import { join as join4 } from "node:path";
 var DEFAULT_LEDGER_PATH = "~/code/software-factory/asf/runtime/factory-coordinator/jobs.jsonl";
@@ -2388,7 +2878,7 @@ function readLedger(env = process.env) {
     if (_cache && _cache.path === path && _cache.mtime === mtime) {
       return { jobs: _cache.jobs };
     }
-    const text = readFileSync3(path, "utf8");
+    const text = readFileSync4(path, "utf8");
     const jobs = classifyJobs(parseJobsJsonl(text));
     _cache = { path, mtime, jobs };
     return { jobs };
@@ -2456,7 +2946,9 @@ function handleAppApi(req, res, app, opts = {}) {
         return;
       }
       try {
-        json(res, 200, { projects: await app.listProjectIdentifiers?.(workspace) ?? [] });
+        const projects = await app.listProjectIdentifiers?.(workspace) ?? [];
+        const details = await app.listProjects?.(workspace) ?? [];
+        json(res, 200, { projects, ...details.length ? { details } : {} });
       } catch (err) {
         const message = err instanceof Error ? err.message : "catalog failed";
         json(res, 409, { error: message });
@@ -2464,6 +2956,38 @@ function handleAppApi(req, res, app, opts = {}) {
     });
     return true;
   }
+  if (url.pathname === "/api/parity" && method === "GET") {
+    reply(req, res, async () => {
+      json(res, 200, await app.parity?.() ?? { initiatives: [], projects: [], workspaces: [] });
+    });
+    return true;
+  }
+  if (url.pathname === "/api/sources" && method === "GET") {
+    reply(req, res, async () => {
+      const current = kind === "plane" ? "plane" : "jira";
+      json(res, 200, {
+        source: current,
+        kind,
+        sources: sourceOptions({
+          planeKey: Boolean(env.PLANE_API_KEY?.trim() || env.PLANE_FIXTURE?.trim()),
+          jiraBin: Boolean(resolveJiraBin(env.JIRA_BIN ?? "jira", env.PATH ?? ""))
+        })
+      });
+    });
+    return true;
+  }
+  if (url.pathname === "/api/source" && method === "POST") {
+    reply(req, res, async (text) => {
+      if (!opts.onSource) {
+        json(res, 404, { error: "source switch unavailable" });
+        return;
+      }
+      const body = text ? JSON.parse(text) : {};
+      const result = await opts.onSource(String(body.source ?? ""));
+      json(res, result.ok ? 200 : 409, result);
+    });
+    return true;
+  }
   if (url.pathname === "/api/refresh" && method === "POST") {
     reply(req, res, async (text) => {
       const body = text ? JSON.parse(text) : {};
@@ -2533,6 +3057,10 @@ function handleAppApi(req, res, app, opts = {}) {
         input.summary = String(body.summary);
       if (body.description !== undefined)
         input.description = String(body.description);
+      if (body.assignee !== undefined)
+        input.assignee = String(body.assignee);
+      if (body.priority !== undefined)
+        input.priority = String(body.priority);
       if (Array.isArray(body.labels)) {
         input.labels = body.labels.filter((item) => typeof item === "string");
       }
@@ -2650,7 +3178,7 @@ function formatCard(card) {
 }
 
 // src/server/agent/config.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
 import { delimiter as delimiter2, dirname as dirname2, join as join5 } from "node:path";
 var DEFAULT_CONFIG_PATH = join5(homedir4(), ".config", "pipe-kan", "agent.json");
@@ -2709,7 +3237,7 @@ function loadAgentConfig(path = agentConfigPath()) {
   if (!existsSync3(path))
     return structuredClone(DEFAULT_CONFIG);
   try {
-    const raw = JSON.parse(readFileSync4(path, "utf8"));
+    const raw = JSON.parse(readFileSync5(path, "utf8"));
     return mergeConfig(raw);
   } catch {
     return structuredClone(DEFAULT_CONFIG);
@@ -3236,7 +3764,7 @@ function parsedType(data) {
   }
   return t;
 }
-function issue(...args) {
+function issue2(...args) {
   const [iss, input, inst] = args;
   if (typeof iss === "string") {
     return {
@@ -5663,7 +6191,7 @@ function handleRefineResult(result, payload, input, inst) {
     };
     if (inst._zod.def.params)
       _iss.params = inst._zod.def.params;
-    payload.issues.push(issue(_iss));
+    payload.issues.push(issue2(_iss));
   }
 }
 // node_modules/zod/v4/core/memoizer.js
@@ -6489,11 +7017,11 @@ function _refine(Class, fn, _params) {
 }
 function _superRefine(fn, params) {
   const ch = _check((payload) => {
-    payload.addIssue = (issue2) => {
-      if (typeof issue2 === "string") {
-        payload.issues.push(issue(issue2, payload.value, ch._zod.def));
+    payload.addIssue = (issue) => {
+      if (typeof issue === "string") {
+        payload.issues.push(issue2(issue, payload.value, ch._zod.def));
       } else {
-        const _issue = issue2;
+        const _issue = issue;
         if (_issue.fatal)
           _issue.continue = false;
         _issue.code ?? (_issue.code = "custom");
@@ -6501,7 +7029,7 @@ function _superRefine(fn, params) {
           _issue.input = payload.value;
         _issue.inst ?? (_issue.inst = ch);
         _issue.continue ?? (_issue.continue = !ch._zod.def.abort);
-        payload.issues.push(issue(_issue));
+        payload.issues.push(issue2(_issue));
       }
     };
     return fn(payload.value, payload);
@@ -8243,18 +8771,18 @@ var ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
     if (_ctx.direction === "backward") {
       throw new $ZodEncodeError(inst.constructor.name);
     }
-    payload.addIssue = (issue2) => {
-      if (typeof issue2 === "string") {
-        payload.issues.push(issue(issue2, payload.value, def));
+    payload.addIssue = (issue) => {
+      if (typeof issue === "string") {
+        payload.issues.push(issue2(issue, payload.value, def));
       } else {
-        const _issue = issue2;
+        const _issue = issue;
         if (_issue.fatal)
           _issue.continue = false;
         _issue.code ?? (_issue.code = "custom");
         if (!("input" in _issue))
           _issue.input = payload.value;
         _issue.inst ?? (_issue.inst = inst);
-        payload.issues.push(issue(_issue));
+        payload.issues.push(issue2(_issue));
       }
     };
     const output = def.transform(payload.value, payload);
@@ -12791,7 +13319,7 @@ function permissionOptionForDecision(options, decision) {
 }
 
 // src/server/agent/skills.ts
-import { existsSync as existsSync4, readFileSync as readFileSync5, readdirSync } from "node:fs";
+import { existsSync as existsSync4, readFileSync as readFileSync6, readdirSync } from "node:fs";
 import { homedir as homedir5 } from "node:os";
 import { join as join7 } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -12840,7 +13368,7 @@ function skillPath(dir, id) {
 }
 function readSkill(path, id) {
   try {
-    const text = readFileSync5(path, "utf8");
+    const text = readFileSync6(path, "utf8");
     const front = parseFrontMatter(text);
     return {
       id,
@@ -12867,7 +13395,7 @@ function parseFrontMatter(text) {
 }
 
 // src/server/agent/tools.ts
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "node:fs";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "node:fs";
 import { join as join8 } from "node:path";
 var TOOLS = [
   {
@@ -13017,7 +13545,7 @@ var EXECUTORS = {
       return { ok: false, error: "Path traversal not allowed" };
     const repoRoot = process.cwd();
     try {
-      const text = readFileSync6(join8(repoRoot, relPath), "utf8");
+      const text = readFileSync7(join8(repoRoot, relPath), "utf8");
       return { ok: true, value: { path: relPath, text } };
     } catch (err) {
       return { ok: false, error: String(err) };
@@ -13641,7 +14169,7 @@ function handleFakeJira(req, res, store) {
 
 // src/http.ts
 function handleRequest(req, res, ctx) {
-  if (handleAppApi(req, res, ctx.app, { kind: ctx.kind }) || handleAgentApi(req, res, ctx.app)) {
+  if (handleAppApi(req, res, ctx.app, { kind: ctx.kind, env: ctx.env, onSource: ctx.switchSource }) || handleAgentApi(req, res, ctx.app)) {
     return true;
   }
   if (ctx.kind === "plane")
@@ -13757,15 +14285,51 @@ function announce(line) {
 }
 async function runServer(opts) {
   const piped = await readPipe();
-  const raw = piped ?? JSON.parse(readFileSync7(join11(opts.root, "fixtures/issues.json"), "utf8"));
+  const raw = piped ?? JSON.parse(readFileSync8(join11(opts.root, "fixtures/issues.json"), "utf8"));
   const flags = argvToFlags(process.argv);
-  const { app, store, kind } = await createBoardApp({
+  const booted = await createBoardApp({
     raw,
     piped: Boolean(piped),
     flags
   });
+  const live = {
+    app: booted.app,
+    store: booted.store,
+    kind: booted.kind,
+    raw
+  };
+  async function switchSource(source) {
+    if (source === "taskwarrior") {
+      return { ok: false, kind: live.kind, source, reason: "Taskwarrior is not connected" };
+    }
+    if (source !== "plane" && source !== "jira") {
+      return { ok: false, kind: live.kind, source, error: `Unknown source ${source}` };
+    }
+    if (source === "plane" && !process.env.PLANE_API_KEY?.trim()) {
+      return { ok: false, kind: live.kind, source, reason: "Set PLANE_API_KEY to use Plane" };
+    }
+    const nextFlags = setPlaneFlag(live.app.flags, source === "plane");
+    try {
+      const next = await createBoardApp({ raw: live.raw, piped: false, flags: nextFlags });
+      live.app = next.app;
+      live.store = next.store;
+      live.kind = next.kind;
+      if (next.kind === "plane" || next.kind === "jira") {
+        try {
+          await refreshFromJira(live.app, next.kind);
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return { ok: true, kind: live.kind, source, error: message };
+        }
+      }
+      return { ok: true, kind: live.kind, source };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { ok: false, kind: live.kind, source, error: message };
+    }
+  }
   const server = createServer((req, res) => {
-    if (handleRequest(req, res, { app, store, kind }))
+    if (handleRequest(req, res, { app: live.app, store: live.store, kind: live.kind, switchSource }))
       return;
     if (opts.fallback) {
       opts.fallback(req, res);
@@ -13776,34 +14340,34 @@ async function runServer(opts) {
       res.end("pipe-kan UI is missing. Run bun run build.");
     }
   });
-  if (kind === "plane") {
+  if (live.kind === "plane") {
     try {
-      await refreshFromJira(app, kind, { piped: Boolean(piped) });
+      await refreshFromJira(live.app, live.kind, { piped: Boolean(piped) });
     } catch (err) {
-      console.error(`${kind} Refresh failed`, err);
+      console.error(`${live.kind} Refresh failed`, err);
     }
-    const error = app.board().error;
+    const error = live.app.board().error;
     if (error)
-      console.error(`${kind} Refresh failed; keeping last live Board`, error);
+      console.error(`${live.kind} Refresh failed; keeping last live Board`, error);
   }
   const { host, port } = resolveListen();
   await bindListen(server, host, port);
   const origin = `http://127.0.0.1:${port}`;
   announce(`pipe-kan http://${host}:${port}`);
-  if (kind === "plane") {
+  if (live.kind === "plane") {
     announce(`cli plane ${planeHost()} ${planeWorkspace(flags)}`);
     announce(`Plane host default ${DEFAULT_PLANE_HOST}`);
   } else {
     const fakeConfig = writeJiraConfig(join11(tmpdir3(), "pipe-kan"), origin);
-    announce(`cli ${kind === "jira" ? resolveJiraBin() : "store"}`);
+    announce(`cli ${live.kind === "jira" ? resolveJiraBin() : "store"}`);
     announce(`Fake Jira ${origin}/rest/api/2/search`);
     announce(`Fake Jira config ${fakeConfig}`);
   }
-  if (kind === "jira") {
+  if (live.kind === "jira") {
     try {
-      await refreshFromJira(app, kind, { piped: Boolean(piped) });
+      await refreshFromJira(live.app, live.kind, { piped: Boolean(piped) });
     } catch (err) {
-      console.error(`${kind} Refresh failed; keeping Fixture Board`);
+      console.error(`${live.kind} Refresh failed; keeping Fixture Board`);
       console.error(err);
     }
   }