pipe-kan 0.26.0 → 0.27.0

package/dist/pipe-kan.js

@@ -1,10 +1,143 @@
 #!/usr/bin/env node
 
 // src/server.ts
-import { readFileSync as readFileSync4, writeSync } from "node:fs";
+import { readFileSync as readFileSync6, writeSync } from "node:fs";
 import { createServer } from "node:http";
-import { tmpdir as tmpdir2 } from "node:os";
-import { join as join8 } from "node:path";
+import { tmpdir as tmpdir3 } from "node:os";
+import { join as join10 } from "node:path";
+
+// src/app.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import { availableParallelism as availableParallelism2, homedir as homedir2, tmpdir } from "node:os";
+import { join as join3 } from "node:path";
+
+// src/target-end.ts
+var EXACT_NAME = "Target End Date";
+var ALIAS_NAMES = new Set(["Target End", "Target end"]);
+var NAMED_FIELD_KEYS = [
+  "Target End Date",
+  "Target End",
+  "Target end",
+  "targetEndDate",
+  "targetenddate",
+  "targetEnd",
+  "targetend"
+];
+function isTargetStart(name) {
+  const folded = name.trim().toLowerCase();
+  return folded === "target start" || folded === "target start date";
+}
+function asNames(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return;
+  const names = {};
+  for (const [id, value] of Object.entries(raw)) {
+    if (typeof value === "string" && value.trim())
+      names[id] = value.trim();
+  }
+  return Object.keys(names).length ? names : undefined;
+}
+function resolveTargetEndFieldId(names) {
+  if (!names)
+    return;
+  let alias;
+  for (const [id, name] of Object.entries(names)) {
+    if (!id.startsWith("customfield_"))
+      continue;
+    if (isTargetStart(name))
+      continue;
+    if (name === EXACT_NAME)
+      return id;
+    if (ALIAS_NAMES.has(name) && !alias)
+      alias = id;
+  }
+  return alias;
+}
+function isoDay(value) {
+  if (typeof value === "string" && value.trim()) {
+    const text = value.trim();
+    const day = /^(\d{4})-(\d{2})-(\d{2})/.exec(text);
+    if (day)
+      return `${day[1]}-${day[2]}-${day[3]}`;
+    const parsed = Date.parse(text);
+    if (Number.isNaN(parsed))
+      return;
+    const date = new Date(parsed);
+    const y = date.getFullYear();
+    const m = String(date.getMonth() + 1).padStart(2, "0");
+    const d = String(date.getDate()).padStart(2, "0");
+    return `${y}-${m}-${d}`;
+  }
+  if (value && typeof value === "object") {
+    const item = value;
+    return isoDay(item.value) ?? isoDay(item.date);
+  }
+  return;
+}
+function issueTargetEnd(fields, opts = {}) {
+  if (!fields)
+    return;
+  for (const key of NAMED_FIELD_KEYS) {
+    const day = isoDay(fields[key]);
+    if (day)
+      return day;
+  }
+  const mapped = resolveTargetEndFieldId(opts.names) ?? opts.fieldId;
+  if (mapped && mapped.startsWith("customfield_")) {
+    const day = isoDay(fields[mapped]);
+    if (day)
+      return day;
+  }
+  return;
+}
+function mergeViewIntoIssue(listIssue, viewIssue) {
+  if (!viewIssue || typeof viewIssue !== "object")
+    return listIssue;
+  if (!listIssue || typeof listIssue !== "object")
+    return viewIssue;
+  const list = listIssue;
+  const view = viewIssue;
+  const names = { ...asNames(list.names), ...asNames(view.names) };
+  return {
+    ...list,
+    ...view,
+    ...Object.keys(names).length ? { names } : {},
+    fields: { ...list.fields, ...view.fields }
+  };
+}
+function unquoteYaml(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1).trim();
+  }
+  return trimmed;
+}
+function targetEndFieldIdFromJiraConfig(yaml) {
+  if (!yaml.trim())
+    return;
+  const names = {};
+  let name;
+  let key;
+  const flush = () => {
+    if (name && key)
+      names[key] = name;
+    name = undefined;
+    key = undefined;
+  };
+  for (const rawLine of yaml.split(/\r?\n/)) {
+    const line = rawLine.replace(/\t/g, "  ");
+    if (/^\s*-\s*$/.test(line) || /^\s*-\s+\S/.test(line))
+      flush();
+    const nameMatch = line.match(/^\s*-?\s*name:\s*(.+?)\s*$/);
+    if (nameMatch)
+      name = unquoteYaml(nameMatch[1] ?? "");
+    const keyMatch = line.match(/^\s*-?\s*key:\s*['"]?(customfield_\d+)['"]?/);
+    if (keyMatch)
+      key = keyMatch[1];
+  }
+  flush();
+  return resolveTargetEndFieldId(names);
+}
 
 // src/board.ts
 function formatDueDate(value) {
@@ -20,19 +153,6 @@ function formatDueDate(value) {
     year: "numeric"
   });
 }
-function formatTargetEnd(value) {
-  if (typeof value !== "string" || !value)
-    return;
-  const day = /^(\d{4})-(\d{2})-(\d{2})/.exec(value);
-  const date = day ? new Date(Number(day[1]), Number(day[2]) - 1, Number(day[3])) : new Date(value);
-  if (Number.isNaN(date.getTime()))
-    return;
-  return date.toLocaleDateString("en-US", {
-    month: "short",
-    day: "numeric",
-    year: "numeric"
-  });
-}
 function createdAt(fields) {
   return typeof fields?.created === "string" && fields.created ? fields.created : undefined;
 }
@@ -101,31 +221,6 @@ function issueAssignee(fields) {
   }
   return;
 }
-function issueTargetEnd(fields) {
-  if (!fields)
-    return;
-  const candidates = [
-    fields.targetEnd,
-    fields.targetend,
-    fields.targetEndDate,
-    fields.targetenddate,
-    fields["Target End"],
-    fields["Target End Date"]
-  ];
-  const direct = candidates.find((value) => typeof value === "string" && value.trim());
-  if (direct)
-    return formatTargetEnd(direct);
-  for (const [key, value] of Object.entries(fields)) {
-    if (!key.startsWith("customfield_"))
-      continue;
-    if (typeof value === "string" && value.trim()) {
-      const formatted = formatTargetEnd(value.trim());
-      if (formatted)
-        return formatted;
-    }
-  }
-  return;
-}
 function toEpic(face) {
   return {
     key: face.key,
@@ -135,15 +230,19 @@ function toEpic(face) {
     ...face.assignee ? { assignee: face.assignee } : {},
     ...face.dueDate ? { dueDate: face.dueDate } : {},
     ...face.targetEnd ? { targetEnd: face.targetEnd } : {},
-    ...face.labels ? { labels: face.labels } : {}
+    ...face.labels ? { labels: face.labels } : {},
+    ...face.created ? { created: face.created } : {}
   };
 }
-function toCard(issue, key) {
+function toCard(issue, key, fieldId) {
   const summary = typeof issue.fields?.summary === "string" ? issue.fields.summary : "";
   const priority = typeof issue.fields?.priority?.name === "string" ? issue.fields.priority.name : undefined;
   const assignee = issueAssignee(issue.fields);
   const dueDate = formatDueDate(issue.fields?.duedate);
-  const targetEnd = issueTargetEnd(issue.fields);
+  const targetEnd = issueTargetEnd(issue.fields, {
+    names: asNames(issue.names),
+    fieldId
+  });
   const type = issueType(issue.fields);
   const epic = epicKey(issue.fields);
   const labels = issueLabels(issue.fields);
@@ -161,7 +260,7 @@ function toCard(issue, key) {
     ...created ? { created } : {}
   };
 }
-function issuesToBoard(raw) {
+function issuesToBoard(raw, opts = {}) {
   if (!Array.isArray(raw)) {
     throw new Error("jira-cli --raw payload must be a JSON array");
   }
@@ -185,7 +284,7 @@ function issuesToBoard(raw) {
     const status = typeof issue?.fields?.status?.name === "string" ? issue.fields.status.name : "";
     if (!key || !status)
       continue;
-    const card = toCard(issue, key);
+    const card = toCard(issue, key, opts.targetEndFieldId);
     if ((card.type ?? "").toLowerCase() === "epic") {
       rememberEpic(toEpic({ ...card, status: issueStatus(issue.fields) }));
       continue;
@@ -217,6 +316,8 @@ function mergeEpics(listed, fromBoard) {
       Object.assign(existing, epic);
     if (!existing.targetEnd && epic.targetEnd)
       existing.targetEnd = epic.targetEnd;
+    if (!existing.created && epic.created)
+      existing.created = epic.created;
   }
   return [...byKey.values()];
 }
@@ -1001,9 +1102,40 @@ function flattenIssue(raw, url) {
   return [...rows, ...rest];
 }
 
+// src/field-map.ts
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join as join2 } from "node:path";
+function jiraCliConfigPath(env = process.env) {
+  const explicit = env.JIRA_CONFIG_FILE?.trim();
+  if (explicit)
+    return explicit;
+  const xdg = env.XDG_CONFIG_HOME?.trim();
+  if (xdg)
+    return join2(xdg, ".jira", ".config.yml");
+  return join2(homedir(), ".config", ".jira", ".config.yml");
+}
+function readTargetEndFieldMap(path) {
+  try {
+    const raw = JSON.parse(readFileSync(path, "utf8"));
+    const targetEnd = typeof raw.targetEnd === "string" && raw.targetEnd.startsWith("customfield_") ? raw.targetEnd : undefined;
+    return targetEnd ? { targetEnd } : {};
+  } catch {
+    return {};
+  }
+}
+function writeTargetEndFieldMap(path, map) {
+  const targetEnd = typeof map.targetEnd === "string" && map.targetEnd.startsWith("customfield_") ? map.targetEnd : undefined;
+  if (!targetEnd)
+    return;
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify({ targetEnd }, null, 2)}
+`);
+}
+
 // src/app.ts
-function columnsOf(raw) {
-  return Object.fromEntries(issuesToBoard(raw).columns.map((column) => [column.title, column.cards]));
+function columnsOf(raw, fieldId) {
+  return Object.fromEntries(issuesToBoard(raw, { targetEndFieldId: fieldId }).columns.map((column) => [column.title, column.cards]));
 }
 function stampMissingEpic(board, epic) {
   for (const column of board.columns) {
@@ -1014,21 +1146,76 @@ function stampMissingEpic(board, epic) {
   }
   return board;
 }
-function cardsOf(raw) {
+function cardsOf(raw, fieldId) {
   if (!Array.isArray(raw))
     return [];
-  return issuesToBoard(raw).columns.flatMap((column) => column.cards);
+  return issuesToBoard(raw, { targetEndFieldId: fieldId }).columns.flatMap((column) => column.cards);
+}
+function issueKeyOf(issue) {
+  if (!issue || typeof issue !== "object" || !("key" in issue))
+    return;
+  return typeof issue.key === "string" ? issue.key : undefined;
+}
+function viewConcurrency() {
+  const env = Number(process.env.PIPE_KAN_CHILDREN_CONCURRENCY);
+  if (!Number.isNaN(env) && env > 0)
+    return env;
+  return Math.max(3, Math.min(10, availableParallelism2()));
+}
+function defaultFieldMapPath() {
+  if (process.env.PIPE_KAN_FIELD_MAP)
+    return process.env.PIPE_KAN_FIELD_MAP;
+  if (process.env.VITEST) {
+    return join3(tmpdir(), `pipe-kan-field-map-${process.pid}-${Math.random().toString(16).slice(2)}.json`);
+  }
+  return join3(homedir2(), ".pipe-kan", "field-map.json");
+}
+function defaultJiraConfigPath() {
+  if (process.env.JIRA_CONFIG_FILE)
+    return process.env.JIRA_CONFIG_FILE;
+  return join3(process.env.XDG_CONFIG_HOME || join3(homedir2(), ".config"), ".jira", ".config.yml");
+}
+function safeRead(path) {
+  if (!path)
+    return;
+  try {
+    return readFileSync2(path, "utf8");
+  } catch {
+    return;
+  }
+}
+async function poolMap(items, concurrency, worker) {
+  const results = new Array(items.length);
+  let next = 0;
+  async function run() {
+    while (next < items.length) {
+      const index = next++;
+      results[index] = await worker(items[index]);
+    }
+  }
+  const workers = Math.min(Math.max(1, concurrency), Math.max(1, items.length));
+  await Promise.all(Array.from({ length: workers }, run));
+  return results;
 }
 function createApp(opts) {
   const cli = opts.cli ?? createStoreCli(opts.store);
+  const fieldMapPath = opts.fieldMapPath ?? defaultFieldMapPath();
+  const jiraConfigPath = opts.jiraConfigPath ?? defaultJiraConfigPath();
   let flags = opts.flags ?? DEFAULT_FLAGS;
   let payload = [];
   let epicsPayload = [];
   let childrenRaw = [];
   let hasChildrenCache = false;
   let childrenError;
+  let targetEndFieldId = readTargetEndFieldMap(fieldMapPath).targetEnd ?? targetEndFieldIdFromJiraConfig(safeRead(jiraConfigPath) ?? "");
+  function boardOpts() {
+    return { targetEndFieldId };
+  }
+  function toBoard(raw) {
+    return issuesToBoard(raw, boardOpts());
+  }
   function listedEpicKeys() {
-    return issuesToBoard(epicsPayload).epics.map((epic) => epic.key);
+    return toBoard(epicsPayload).epics.map((epic) => epic.key);
   }
   function cacheFromStore() {
     epicsPayload = opts.store.list(flagsToJql("-tEpic"));
@@ -1038,7 +1225,56 @@ function createApp(opts) {
   }
   function currentStatus(key) {
     const fromPayload = payload.find((issue) => issue.key === key)?.fields?.status?.name;
-    return fromPayload ?? issuesToBoard(epicsPayload).epics.find((epic) => epic.key === key)?.status ?? app.board().epics.find((epic) => epic.key === key)?.status;
+    return fromPayload ?? toBoard(epicsPayload).epics.find((epic) => epic.key === key)?.status ?? app.board().epics.find((epic) => epic.key === key)?.status;
+  }
+  function rememberTargetEndId(issues) {
+    for (const issue of issues) {
+      if (!issue || typeof issue !== "object")
+        continue;
+      const row = issue;
+      const id = resolveTargetEndFieldId(asNames(row.names));
+      if (id) {
+        targetEndFieldId = id;
+        writeTargetEndFieldMap(fieldMapPath, { targetEnd: id });
+        return;
+      }
+    }
+    const fromConfig = targetEndFieldIdFromJiraConfig(safeRead(jiraConfigPath) ?? "");
+    if (!fromConfig)
+      return;
+    targetEndFieldId = fromConfig;
+    writeTargetEndFieldMap(fieldMapPath, { targetEnd: fromConfig });
+  }
+  async function hydrateRaw(raw) {
+    if (!Array.isArray(raw) || raw.length === 0)
+      return Array.isArray(raw) ? raw : [];
+    const keys = [...new Set(raw.map(issueKeyOf).filter((key) => Boolean(key)))];
+    if (!keys.length)
+      return raw;
+    const concurrency = viewConcurrency();
+    console.log(`Refresh view-raw ${keys.length} issues; concurrency ${concurrency}`);
+    const views = await poolMap(keys, concurrency, async (key) => {
+      try {
+        return JSON.parse(await cli.view(key));
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.log(`Refresh view ${key} failed; ${message}`);
+        return null;
+      }
+    });
+    const byKey = new Map;
+    for (const view of views) {
+      const key = issueKeyOf(view);
+      if (key)
+        byKey.set(key, view);
+    }
+    const merged = raw.map((issue) => {
+      const key = issueKeyOf(issue);
+      const view = key ? byKey.get(key) : undefined;
+      return view ? mergeViewIntoIssue(issue, view) : issue;
+    });
+    rememberTargetEndId(merged);
+    return merged;
   }
   async function tryMove(key, status) {
     const current = currentStatus(key);
@@ -1053,11 +1289,11 @@ function createApp(opts) {
       return flags;
     },
     board() {
-      const board = issuesToBoard(payload);
+      const board = toBoard(payload);
       return {
         columns: board.columns,
-        epics: mergeEpics(issuesToBoard(epicsPayload).epics, board.epics),
-        ...hasChildrenCache ? { children: columnsOf(childrenRaw) } : {},
+        epics: mergeEpics(toBoard(epicsPayload).epics, board.epics),
+        ...hasChildrenCache ? { children: columnsOf(childrenRaw, targetEndFieldId) } : {},
         ...childrenError ? { error: childrenError } : {}
       };
     },
@@ -1069,6 +1305,7 @@ function createApp(opts) {
       childrenError = undefined;
       if (hydrateOpts?.fromStore)
         cacheFromStore();
+      rememberTargetEndId([...payload, ...epicsPayload, ...childrenRaw]);
       return app.board();
     },
     async refresh(next) {
@@ -1078,17 +1315,17 @@ function createApp(opts) {
       try {
         const issues = await cli.list(flags);
         const epics = await cli.listEpics(flags);
-        const nextPayload = JSON.parse(issues);
-        const nextEpics = JSON.parse(epics);
-        const keys = issuesToBoard(nextEpics).epics.map((epic) => epic.key);
-        const issueCount = Array.isArray(nextPayload) ? nextPayload.length : 0;
+        const listedPayload = JSON.parse(issues);
+        const listedEpics = JSON.parse(epics);
+        const keys = toBoard(listedEpics).epics.map((epic) => epic.key);
+        const issueCount = Array.isArray(listedPayload) ? listedPayload.length : 0;
         console.log(`Refresh listed ${issueCount} issues, ${keys.length} epics`);
         let nextChildren = [];
         let nextHasCache = false;
         let nextError;
         try {
           nextChildren = JSON.parse(await cli.listChildren(keys));
-          const cards = cardsOf(nextChildren);
+          const cards = cardsOf(nextChildren, targetEndFieldId);
           if (cards.length > 0 && !cards.some((card) => card.epic)) {
             console.log(`Refresh children missing Epic keys; skip ${keys.length} per-Epic lists`);
             nextChildren = [];
@@ -1103,9 +1340,9 @@ function createApp(opts) {
           nextError = err instanceof Error ? err.message : "Epic children list failed";
           console.log("Refresh children failed; keeping existing children", nextError);
         }
-        payload = nextPayload;
-        epicsPayload = nextEpics;
-        childrenRaw = nextChildren;
+        payload = await hydrateRaw(listedPayload);
+        epicsPayload = await hydrateRaw(listedEpics);
+        childrenRaw = nextHasCache ? await hydrateRaw(nextChildren) : nextChildren;
         hasChildrenCache = nextHasCache;
         childrenError = nextError;
         return app.board();
@@ -1116,12 +1353,12 @@ function createApp(opts) {
       }
     },
     async children(epic) {
-      const listed = issuesToBoard(epicsPayload).epics;
+      const listed = toBoard(epicsPayload).epics;
       if (!listed.some((e) => e.key === epic)) {
         return { columns: [], epics: [] };
       }
       if (hasChildrenCache) {
-        const cards = Object.fromEntries(Object.entries(columnsOf(childrenRaw)).map(([title, list]) => [
+        const cards = Object.fromEntries(Object.entries(columnsOf(childrenRaw, targetEndFieldId)).map(([title, list]) => [
           title,
           list.filter((card) => card.epic === epic).map((card) => ({
             ...card,
@@ -1132,7 +1369,7 @@ function createApp(opts) {
         if (columns.length)
           return { columns, epics: [] };
       }
-      return stampMissingEpic(issuesToBoard(JSON.parse(await cli.listEpic(epic, flags))), epic);
+      return stampMissingEpic(toBoard(JSON.parse(await cli.listEpic(epic, flags))), epic);
     },
     async move(key, status) {
       const result = await tryMove(key, status);
@@ -1194,7 +1431,12 @@ async function createBoardApp(opts) {
     token: env.JIRA_API_TOKEN,
     flags
   }) : createStoreCli(store, flags);
-  const app = createApp({ store, cli, flags });
+  const app = createApp({
+    store,
+    cli,
+    flags,
+    jiraConfigPath: jiraCliConfigPath(env)
+  });
   if (opts.piped) {
     app.hydrate(opts.raw);
   } else {
@@ -1398,10 +1640,10 @@ function formatCard(card) {
 }
 
 // src/server/agent/config.ts
-import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { delimiter as delimiter2, dirname, join as join2 } from "node:path";
-var DEFAULT_CONFIG_PATH = join2(homedir(), ".config", "pipe-kan", "agent.json");
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { delimiter as delimiter2, dirname as dirname2, join as join4 } from "node:path";
+var DEFAULT_CONFIG_PATH = join4(homedir3(), ".config", "pipe-kan", "agent.json");
 var FALLBACK_MODELS = {
   cursor: [
     { id: "composer-2", name: "Composer 2" },
@@ -1448,7 +1690,7 @@ function commandOnPath(command, env = process.env) {
   for (const dir of pathVar.split(delimiter2)) {
     if (!dir)
       continue;
-    if (existsSync2(join2(dir, command)))
+    if (existsSync2(join4(dir, command)))
       return true;
   }
   return false;
@@ -1457,7 +1699,7 @@ function loadAgentConfig(path = agentConfigPath()) {
   if (!existsSync2(path))
     return structuredClone(DEFAULT_CONFIG);
   try {
-    const raw = JSON.parse(readFileSync(path, "utf8"));
+    const raw = JSON.parse(readFileSync3(path, "utf8"));
     return mergeConfig(raw);
   } catch {
     return structuredClone(DEFAULT_CONFIG);
@@ -1476,7 +1718,7 @@ function saveAgentConfig(patch, path = agentConfigPath()) {
     }
   }
   ensureAgentConfigDir(path);
-  writeFileSync(path, `${JSON.stringify(next, null, 2)}
+  writeFileSync2(path, `${JSON.stringify(next, null, 2)}
 `);
   return next;
 }
@@ -1492,16 +1734,16 @@ function mergeConfig(raw) {
   };
 }
 function ensureAgentConfigDir(path = agentConfigPath()) {
-  const dir = dirname(path);
+  const dir = dirname2(path);
   if (!existsSync2(dir))
-    mkdirSync(dir, { recursive: true });
+    mkdirSync2(dir, { recursive: true });
 }
 
 // src/server/agent/session.ts
 import { spawn as spawn2 } from "node:child_process";
 import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join as join3 } from "node:path";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join5 } from "node:path";
 import { Readable } from "node:stream";
 
 // node_modules/@agentclientprotocol/sdk/dist/schema/index.js
@@ -11227,7 +11469,7 @@ class AcpSession {
   executeTool = null;
   stderr = "";
   selectedModelId = null;
-  workspace = mkdtempSync(join3(tmpdir(), "pipe-kan-agent-"));
+  workspace = mkdtempSync(join5(tmpdir2(), "pipe-kan-agent-"));
   constructor(config) {
     this.config = config;
     this.id = crypto.randomUUID();
@@ -11539,11 +11781,11 @@ function permissionOptionForDecision(options, decision) {
 }
 
 // src/server/agent/skills.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2, readdirSync } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { join as join4 } from "node:path";
-function createSkillRegistry(bundledDir = join4(import.meta.dirname, "..", "..", "..", ".agents", "skills")) {
-  const userDir = join4(homedir2(), ".pi", "agent", "skills");
+import { existsSync as existsSync3, readFileSync as readFileSync4, readdirSync } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { join as join6 } from "node:path";
+function createSkillRegistry(bundledDir = join6(import.meta.dirname, "..", "..", "..", ".agents", "skills")) {
+  const userDir = join6(homedir4(), ".pi", "agent", "skills");
   return {
     list() {
       const bundled = listSkills(bundledDir);
@@ -11582,11 +11824,11 @@ function listSkills(dir) {
   return readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => readSkill(skillPath(dir, entry.name), entry.name)).filter((skill) => skill !== undefined);
 }
 function skillPath(dir, id) {
-  return join4(dir, id, "SKILL.md");
+  return join6(dir, id, "SKILL.md");
 }
 function readSkill(path, id) {
   try {
-    const text = readFileSync2(path, "utf8");
+    const text = readFileSync4(path, "utf8");
     const front = parseFrontMatter(text);
     return {
       id,
@@ -11613,8 +11855,8 @@ function parseFrontMatter(text) {
 }
 
 // src/server/agent/tools.ts
-import { readFileSync as readFileSync3 } from "node:fs";
-import { join as join5 } from "node:path";
+import { readFileSync as readFileSync5 } from "node:fs";
+import { join as join7 } from "node:path";
 var TOOLS = [
   {
     name: "board_state",
@@ -11731,7 +11973,7 @@ var EXECUTORS = {
       return { ok: false, error: "Path traversal not allowed" };
     const repoRoot = process.cwd();
     try {
-      const text = readFileSync3(join5(repoRoot, relPath), "utf8");
+      const text = readFileSync5(join7(repoRoot, relPath), "utf8");
       return { ok: true, value: { path: relPath, text } };
     } catch (err) {
       return { ok: false, error: String(err) };
@@ -12264,12 +12506,12 @@ function handleRequest(req, res, ctx) {
 }
 
 // src/jira-config.ts
-import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join6 } from "node:path";
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join8 } from "node:path";
 function writeJiraConfig(dir, server) {
-  mkdirSync2(dir, { recursive: true });
-  const path = join6(dir, "jira.config.yml");
-  writeFileSync2(path, [
+  mkdirSync3(dir, { recursive: true });
+  const path = join8(dir, "jira.config.yml");
+  writeFileSync3(path, [
     "installation: Cloud",
     `server: ${server}`,
     `login: ${ME.emailAddress}`,
@@ -12324,7 +12566,7 @@ function stdinStat() {
 
 // src/ui.ts
 import { createReadStream, existsSync as existsSync4, statSync } from "node:fs";
-import { dirname as dirname2, extname, join as join7, resolve as resolve2, sep } from "node:path";
+import { dirname as dirname3, extname, join as join9, resolve as resolve2, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 var types = {
   ".css": "text/css; charset=utf-8",
@@ -12338,10 +12580,10 @@ var types = {
   ".woff2": "font/woff2"
 };
 function packageRoot(from = import.meta.url) {
-  return resolve2(dirname2(fileURLToPath(from)), "..");
+  return resolve2(dirname3(fileURLToPath(from)), "..");
 }
 function uiDir(root) {
-  return join7(root, "dist", "ui");
+  return join9(root, "dist", "ui");
 }
 function inside(root, file) {
   const base = resolve2(root);
@@ -12350,7 +12592,7 @@ function inside(root, file) {
 }
 function sendUi(root, req, res) {
   const ui = uiDir(root);
-  const index = join7(ui, "index.html");
+  const index = join9(ui, "index.html");
   if (!existsSync4(index))
     return false;
   const path = new URL(req.url ?? "/", "http://127.0.0.1").pathname;
@@ -12371,7 +12613,7 @@ function announce(line) {
 }
 async function runServer(opts) {
   const piped = await readPipe();
-  const raw = piped ?? JSON.parse(readFileSync4(join8(opts.root, "fixtures/issues.json"), "utf8"));
+  const raw = piped ?? JSON.parse(readFileSync6(join10(opts.root, "fixtures/issues.json"), "utf8"));
   const flags = argvToFlags(process.argv);
   const { app, store, kind } = await createBoardApp({
     raw,
@@ -12393,7 +12635,7 @@ async function runServer(opts) {
   const { host, port } = resolveListen();
   await bindListen(server, host, port);
   const origin = `http://127.0.0.1:${port}`;
-  const fakeConfig = writeJiraConfig(join8(tmpdir2(), "pipe-kan"), origin);
+  const fakeConfig = writeJiraConfig(join10(tmpdir3(), "pipe-kan"), origin);
   announce(`pipe-kan http://${host}:${port}`);
   announce(`cli ${kind === "jira" ? resolveJiraBin() : "store"}`);
   announce(`Fake Jira ${origin}/rest/api/2/search`);