@ondrej-svec/hog 1.1.1

package/dist/cli.js

@@ -0,0 +1,4988 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/api.ts
+var BASE_URL, TickTickClient;
+var init_api = __esm({
+  "src/api.ts"() {
+    "use strict";
+    BASE_URL = "https://api.ticktick.com/open/v1";
+    TickTickClient = class {
+      token;
+      constructor(token) {
+        this.token = token;
+      }
+      async request(method, path, body) {
+        const url = `${BASE_URL}${path}`;
+        const init = {
+          method,
+          headers: {
+            Authorization: `Bearer ${this.token}`,
+            "Content-Type": "application/json"
+          }
+        };
+        if (body !== void 0) {
+          init.body = JSON.stringify(body);
+        }
+        const res = await fetch(url, init);
+        if (!res.ok) {
+          const text2 = await res.text();
+          throw new Error(`TickTick API error ${res.status}: ${text2}`);
+        }
+        const text = await res.text();
+        if (!text) return void 0;
+        return JSON.parse(text);
+      }
+      async listProjects() {
+        return this.request("GET", "/project");
+      }
+      async getProject(projectId) {
+        return this.request("GET", `/project/${projectId}`);
+      }
+      async getProjectData(projectId) {
+        return this.request("GET", `/project/${projectId}/data`);
+      }
+      async listTasks(projectId) {
+        const data = await this.getProjectData(projectId);
+        return data.tasks ?? [];
+      }
+      async getTask(projectId, taskId) {
+        return this.request("GET", `/project/${projectId}/task/${taskId}`);
+      }
+      async createTask(input2) {
+        return this.request("POST", "/task", input2);
+      }
+      async updateTask(input2) {
+        return this.request("POST", `/task/${input2.id}`, input2);
+      }
+      async completeTask(projectId, taskId) {
+        await this.request("POST", `/project/${projectId}/task/${taskId}/complete`);
+      }
+      async deleteTask(projectId, taskId) {
+        await this.request("DELETE", `/project/${projectId}/task/${taskId}`);
+      }
+    };
+  }
+});
+
+// src/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { z } from "zod";
+function migrateConfig(raw) {
+  const version = typeof raw["version"] === "number" ? raw["version"] : 1;
+  if (version < 2) {
+    raw = {
+      ...raw,
+      version: 2,
+      repos: LEGACY_REPOS,
+      board: {
+        refreshInterval: 60,
+        backlogLimit: 20,
+        assignee: "unknown"
+      }
+    };
+  }
+  const currentVersion = typeof raw["version"] === "number" ? raw["version"] : 2;
+  if (currentVersion < 3) {
+    raw = {
+      ...raw,
+      version: 3,
+      ticktick: { enabled: existsSync(AUTH_FILE) }
+    };
+  }
+  return HOG_CONFIG_SCHEMA.parse(raw);
+}
+function loadFullConfig() {
+  const raw = loadRawConfig();
+  if (Object.keys(raw).length === 0) {
+    const config2 = migrateConfig({});
+    saveFullConfig(config2);
+    return config2;
+  }
+  const version = typeof raw["version"] === "number" ? raw["version"] : 1;
+  if (version < 3) {
+    const migrated = migrateConfig(raw);
+    saveFullConfig(migrated);
+    return migrated;
+  }
+  return HOG_CONFIG_SCHEMA.parse(raw);
+}
+function saveFullConfig(config2) {
+  ensureDir();
+  writeFileSync(CONFIG_FILE, `${JSON.stringify(config2, null, 2)}
+`, { mode: 384 });
+}
+function loadRawConfig() {
+  if (!existsSync(CONFIG_FILE)) return {};
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function resolveProfile(config2, profileName) {
+  const name = profileName ?? config2.defaultProfile;
+  if (!name) {
+    return { resolved: config2, activeProfile: null };
+  }
+  const profile = config2.profiles[name];
+  if (!profile) {
+    console.error(
+      `Profile "${name}" not found. Available: ${Object.keys(config2.profiles).join(", ") || "(none)"}`
+    );
+    process.exit(1);
+  }
+  return {
+    resolved: { ...config2, repos: profile.repos, board: profile.board, ticktick: profile.ticktick },
+    activeProfile: name
+  };
+}
+function findRepo(config2, shortNameOrFull) {
+  return config2.repos.find((r) => r.shortName === shortNameOrFull || r.name === shortNameOrFull);
+}
+function validateRepoName(name) {
+  return REPO_NAME_PATTERN.test(name);
+}
+function ensureDir() {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+}
+function getAuth() {
+  if (!existsSync(AUTH_FILE)) return null;
+  try {
+    return JSON.parse(readFileSync(AUTH_FILE, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveAuth(data) {
+  ensureDir();
+  writeFileSync(AUTH_FILE, `${JSON.stringify(data, null, 2)}
+`, {
+    mode: 384
+  });
+}
+function getConfig() {
+  if (!existsSync(CONFIG_FILE)) return {};
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveConfig(data) {
+  ensureDir();
+  const existing = getConfig();
+  writeFileSync(CONFIG_FILE, `${JSON.stringify({ ...existing, ...data }, null, 2)}
+`);
+}
+function requireAuth() {
+  const auth = getAuth();
+  if (!auth) {
+    console.error("Not authenticated. Run `hog init` first.");
+    process.exit(1);
+  }
+  return auth;
+}
+var CONFIG_DIR, AUTH_FILE, CONFIG_FILE, COMPLETION_ACTION_SCHEMA, REPO_NAME_PATTERN, REPO_CONFIG_SCHEMA, BOARD_CONFIG_SCHEMA, TICKTICK_CONFIG_SCHEMA, PROFILE_SCHEMA, HOG_CONFIG_SCHEMA, LEGACY_REPOS;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    CONFIG_DIR = join(homedir(), ".config", "hog");
+    AUTH_FILE = join(CONFIG_DIR, "auth.json");
+    CONFIG_FILE = join(CONFIG_DIR, "config.json");
+    COMPLETION_ACTION_SCHEMA = z.discriminatedUnion("type", [
+      z.object({ type: z.literal("updateProjectStatus"), optionId: z.string() }),
+      z.object({ type: z.literal("closeIssue") }),
+      z.object({ type: z.literal("addLabel"), label: z.string() })
+    ]);
+    REPO_NAME_PATTERN = /^[\w.-]+\/[\w.-]+$/;
+    REPO_CONFIG_SCHEMA = z.object({
+      name: z.string().regex(REPO_NAME_PATTERN, "Must be owner/repo format"),
+      shortName: z.string().min(1),
+      projectNumber: z.number().int().positive(),
+      statusFieldId: z.string().min(1),
+      completionAction: COMPLETION_ACTION_SCHEMA,
+      statusGroups: z.array(z.string()).optional()
+    });
+    BOARD_CONFIG_SCHEMA = z.object({
+      refreshInterval: z.number().int().min(10).default(60),
+      backlogLimit: z.number().int().min(1).default(20),
+      assignee: z.string().min(1),
+      focusDuration: z.number().int().min(60).default(1500)
+    });
+    TICKTICK_CONFIG_SCHEMA = z.object({
+      enabled: z.boolean().default(true)
+    });
+    PROFILE_SCHEMA = z.object({
+      repos: z.array(REPO_CONFIG_SCHEMA).default([]),
+      board: BOARD_CONFIG_SCHEMA,
+      ticktick: TICKTICK_CONFIG_SCHEMA.default({ enabled: true })
+    });
+    HOG_CONFIG_SCHEMA = z.object({
+      version: z.number().int().default(3),
+      defaultProjectId: z.string().optional(),
+      defaultProjectName: z.string().optional(),
+      repos: z.array(REPO_CONFIG_SCHEMA).default([]),
+      board: BOARD_CONFIG_SCHEMA,
+      ticktick: TICKTICK_CONFIG_SCHEMA.default({ enabled: true }),
+      profiles: z.record(z.string(), PROFILE_SCHEMA).default({}),
+      defaultProfile: z.string().optional()
+    });
+    LEGACY_REPOS = [];
+  }
+});
+
+// src/types.ts
+var init_types = __esm({
+  "src/types.ts"() {
+    "use strict";
+  }
+});
+
+// src/github.ts
+import { execFile, execFileSync as execFileSync2 } from "child_process";
+import { promisify } from "util";
+function runGh(args) {
+  return execFileSync2("gh", args, { encoding: "utf-8", timeout: 3e4 }).trim();
+}
+function runGhJson(args) {
+  const output = runGh(args);
+  return JSON.parse(output);
+}
+async function runGhAsync(args) {
+  const { stdout } = await execFileAsync("gh", args, { encoding: "utf-8", timeout: 3e4 });
+  return stdout.trim();
+}
+async function runGhJsonAsync(args) {
+  const output = await runGhAsync(args);
+  return JSON.parse(output);
+}
+function fetchAssignedIssues(repo, assignee) {
+  return runGhJson([
+    "issue",
+    "list",
+    "--repo",
+    repo,
+    "--assignee",
+    assignee,
+    "--state",
+    "open",
+    "--json",
+    "number,title,url,state,updatedAt,labels",
+    "--limit",
+    "100"
+  ]);
+}
+function fetchRepoIssues(repo, options = {}) {
+  const { state = "open", limit = 100 } = options;
+  const args = [
+    "issue",
+    "list",
+    "--repo",
+    repo,
+    "--state",
+    state,
+    "--json",
+    "number,title,url,state,updatedAt,labels,assignees,body",
+    "--limit",
+    String(limit)
+  ];
+  if (options.assignee) {
+    args.push("--assignee", options.assignee);
+  }
+  return runGhJson(args);
+}
+function assignIssue(repo, issueNumber) {
+  runGh(["issue", "edit", String(issueNumber), "--repo", repo, "--add-assignee", "@me"]);
+}
+async function assignIssueAsync(repo, issueNumber) {
+  await runGhAsync(["issue", "edit", String(issueNumber), "--repo", repo, "--add-assignee", "@me"]);
+}
+function fetchProjectFields(repo, issueNumber, projectNumber) {
+  const query = `
+    query($owner: String!, $repo: String!, $issueNumber: Int!) {
+      repository(owner: $owner, name: $repo) {
+        issue(number: $issueNumber) {
+          projectItems(first: 10) {
+            nodes {
+              project { number }
+              fieldValues(first: 20) {
+                nodes {
+                  ... on ProjectV2ItemFieldDateValue {
+                    field { ... on ProjectV2Field { name } }
+                    date
+                  }
+                  ... on ProjectV2ItemFieldSingleSelectValue {
+                    field { ... on ProjectV2SingleSelectField { name } }
+                    name
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  `;
+  const [owner, repoName] = repo.split("/");
+  try {
+    const result = runGhJson([
+      "api",
+      "graphql",
+      "-f",
+      `query=${query}`,
+      "-F",
+      `owner=${owner}`,
+      "-F",
+      `repo=${repoName}`,
+      "-F",
+      `issueNumber=${String(issueNumber)}`
+    ]);
+    const items = result?.data?.repository?.issue?.projectItems?.nodes ?? [];
+    const projectItem = items.find((item) => item?.project?.number === projectNumber);
+    if (!projectItem) return {};
+    const fields = {};
+    const fieldValues = projectItem.fieldValues?.nodes ?? [];
+    for (const fv of fieldValues) {
+      if (!fv) continue;
+      if ("date" in fv && fv.field?.name === "Target date") {
+        fields.targetDate = fv.date;
+      }
+      if ("name" in fv && fv.field?.name === "Status") {
+        fields.status = fv.name;
+      }
+    }
+    return fields;
+  } catch {
+    return {};
+  }
+}
+function fetchProjectEnrichment(repo, projectNumber) {
+  const [owner] = repo.split("/");
+  const query = `
+    query($owner: String!, $projectNumber: Int!) {
+      organization(login: $owner) {
+        projectV2(number: $projectNumber) {
+          items(first: 100) {
+            nodes {
+              content {
+                ... on Issue {
+                  number
+                }
+              }
+              fieldValues(first: 20) {
+                nodes {
+                  ... on ProjectV2ItemFieldDateValue {
+                    field { ... on ProjectV2Field { name } }
+                    date
+                  }
+                  ... on ProjectV2ItemFieldSingleSelectValue {
+                    field { ... on ProjectV2SingleSelectField { name } }
+                    name
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  `;
+  try {
+    const result = runGhJson([
+      "api",
+      "graphql",
+      "-f",
+      `query=${query}`,
+      "-F",
+      `owner=${owner}`,
+      "-F",
+      `projectNumber=${String(projectNumber)}`
+    ]);
+    const items = result?.data?.organization?.projectV2?.items?.nodes ?? [];
+    const enrichMap = /* @__PURE__ */ new Map();
+    for (const item of items) {
+      if (!item?.content?.number) continue;
+      const enrichment = {};
+      const fieldValues = item.fieldValues?.nodes ?? [];
+      for (const fv of fieldValues) {
+        if (!fv) continue;
+        if ("date" in fv && fv.field?.name === "Target date" && fv.date) {
+          enrichment.targetDate = fv.date;
+        }
+        if ("name" in fv && fv.field?.name === "Status" && fv.name) {
+          enrichment.projectStatus = fv.name;
+        }
+      }
+      enrichMap.set(item.content.number, enrichment);
+    }
+    return enrichMap;
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+function fetchProjectStatusOptions(repo, projectNumber, _statusFieldId) {
+  const [owner] = repo.split("/");
+  const query = `
+    query($owner: String!, $projectNumber: Int!) {
+      organization(login: $owner) {
+        projectV2(number: $projectNumber) {
+          field(name: "Status") {
+            ... on ProjectV2SingleSelectField {
+              options {
+                id
+                name
+              }
+            }
+          }
+        }
+      }
+    }
+  `;
+  try {
+    const result = runGhJson([
+      "api",
+      "graphql",
+      "-f",
+      `query=${query}`,
+      "-F",
+      `owner=${owner}`,
+      "-F",
+      `projectNumber=${String(projectNumber)}`
+    ]);
+    return result?.data?.organization?.projectV2?.field?.options ?? [];
+  } catch {
+    return [];
+  }
+}
+function addLabel(repo, issueNumber, label) {
+  runGh(["issue", "edit", String(issueNumber), "--repo", repo, "--add-label", label]);
+}
+function updateProjectItemStatus(repo, issueNumber, projectConfig) {
+  const [owner, repoName] = repo.split("/");
+  const findItemQuery = `
+    query($owner: String!, $repo: String!, $issueNumber: Int!) {
+      repository(owner: $owner, name: $repo) {
+        issue(number: $issueNumber) {
+          projectItems(first: 10) {
+            nodes {
+              id
+              project { number }
+            }
+          }
+        }
+      }
+    }
+  `;
+  const findResult = runGhJson([
+    "api",
+    "graphql",
+    "-f",
+    `query=${findItemQuery}`,
+    "-F",
+    `owner=${owner}`,
+    "-F",
+    `repo=${repoName}`,
+    "-F",
+    `issueNumber=${String(issueNumber)}`
+  ]);
+  const items = findResult?.data?.repository?.issue?.projectItems?.nodes ?? [];
+  const projectNumber = projectConfig.projectNumber;
+  const projectItem = items.find((item) => item?.project?.number === projectNumber);
+  if (!projectItem?.id) return;
+  const projectQuery = `
+    query($owner: String!) {
+      organization(login: $owner) {
+        projectV2(number: ${projectNumber}) {
+          id
+        }
+      }
+    }
+  `;
+  const projectResult = runGhJson([
+    "api",
+    "graphql",
+    "-f",
+    `query=${projectQuery}`,
+    "-F",
+    `owner=${owner}`
+  ]);
+  const projectId = projectResult?.data?.organization?.projectV2?.id;
+  if (!projectId) return;
+  const statusFieldId = projectConfig.statusFieldId;
+  const optionId = projectConfig.optionId;
+  const mutation = `
+    mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!, $optionId: String!) {
+      updateProjectV2ItemFieldValue(
+        input: {
+          projectId: $projectId
+          itemId: $itemId
+          fieldId: $fieldId
+          value: { singleSelectOptionId: $optionId }
+        }
+      ) {
+        projectV2Item { id }
+      }
+    }
+  `;
+  runGh([
+    "api",
+    "graphql",
+    "-f",
+    `query=${mutation}`,
+    "-F",
+    `projectId=${projectId}`,
+    "-F",
+    `itemId=${projectItem.id}`,
+    "-F",
+    `fieldId=${statusFieldId}`,
+    "-F",
+    `optionId=${optionId}`
+  ]);
+}
+async function updateProjectItemStatusAsync(repo, issueNumber, projectConfig) {
+  const [owner, repoName] = repo.split("/");
+  const findItemQuery = `
+    query($owner: String!, $repo: String!, $issueNumber: Int!) {
+      repository(owner: $owner, name: $repo) {
+        issue(number: $issueNumber) {
+          projectItems(first: 10) {
+            nodes {
+              id
+              project { number }
+            }
+          }
+        }
+      }
+    }
+  `;
+  const findResult = await runGhJsonAsync([
+    "api",
+    "graphql",
+    "-f",
+    `query=${findItemQuery}`,
+    "-F",
+    `owner=${owner}`,
+    "-F",
+    `repo=${repoName}`,
+    "-F",
+    `issueNumber=${String(issueNumber)}`
+  ]);
+  const items = findResult?.data?.repository?.issue?.projectItems?.nodes ?? [];
+  const projectNumber = projectConfig.projectNumber;
+  const projectItem = items.find((item) => item?.project?.number === projectNumber);
+  if (!projectItem?.id) return;
+  const projectQuery = `
+    query($owner: String!) {
+      organization(login: $owner) {
+        projectV2(number: ${projectNumber}) {
+          id
+        }
+      }
+    }
+  `;
+  const projectResult = await runGhJsonAsync([
+    "api",
+    "graphql",
+    "-f",
+    `query=${projectQuery}`,
+    "-F",
+    `owner=${owner}`
+  ]);
+  const projectId = projectResult?.data?.organization?.projectV2?.id;
+  if (!projectId) return;
+  const statusFieldId = projectConfig.statusFieldId;
+  const optionId = projectConfig.optionId;
+  const mutation = `
+    mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!, $optionId: String!) {
+      updateProjectV2ItemFieldValue(
+        input: {
+          projectId: $projectId
+          itemId: $itemId
+          fieldId: $fieldId
+          value: { singleSelectOptionId: $optionId }
+        }
+      ) {
+        projectV2Item { id }
+      }
+    }
+  `;
+  await runGhAsync([
+    "api",
+    "graphql",
+    "-f",
+    `query=${mutation}`,
+    "-F",
+    `projectId=${projectId}`,
+    "-F",
+    `itemId=${projectItem.id}`,
+    "-F",
+    `fieldId=${statusFieldId}`,
+    "-F",
+    `optionId=${optionId}`
+  ]);
+}
+var execFileAsync;
+var init_github = __esm({
+  "src/github.ts"() {
+    "use strict";
+    execFileAsync = promisify(execFile);
+  }
+});
+
+// src/sync-state.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+function loadSyncState() {
+  if (!existsSync3(STATE_FILE)) return { mappings: [] };
+  try {
+    return JSON.parse(readFileSync2(STATE_FILE, "utf-8"));
+  } catch {
+    return { mappings: [] };
+  }
+}
+function saveSyncState(state) {
+  writeFileSync2(STATE_FILE, `${JSON.stringify(state, null, 2)}
+`);
+}
+function findMapping(state, githubRepo, issueNumber) {
+  return state.mappings.find(
+    (m) => m.githubRepo === githubRepo && m.githubIssueNumber === issueNumber
+  );
+}
+function upsertMapping(state, mapping) {
+  const idx = state.mappings.findIndex(
+    (m) => m.githubRepo === mapping.githubRepo && m.githubIssueNumber === mapping.githubIssueNumber
+  );
+  if (idx >= 0) {
+    state.mappings[idx] = mapping;
+  } else {
+    state.mappings.push(mapping);
+  }
+}
+function removeMapping(state, githubRepo, issueNumber) {
+  state.mappings = state.mappings.filter(
+    (m) => !(m.githubRepo === githubRepo && m.githubIssueNumber === issueNumber)
+  );
+}
+var CONFIG_DIR2, STATE_FILE;
+var init_sync_state = __esm({
+  "src/sync-state.ts"() {
+    "use strict";
+    CONFIG_DIR2 = join2(homedir2(), ".config", "hog");
+    STATE_FILE = join2(CONFIG_DIR2, "sync-state.json");
+  }
+});
+
+// src/pick.ts
+var pick_exports = {};
+__export(pick_exports, {
+  parseIssueRef: () => parseIssueRef,
+  pickIssue: () => pickIssue
+});
+function parseIssueRef(input2, config2) {
+  const match = input2.match(ISSUE_REF_PATTERN);
+  if (!(match?.[1] && match[2])) {
+    throw new Error("Invalid format. Use: shortName/number (e.g., myrepo/145)");
+  }
+  const repoShortName2 = match[1];
+  const repo = findRepo(config2, repoShortName2);
+  if (!repo) {
+    throw new Error(`Unknown repo "${repoShortName2}". Run: hog config repos`);
+  }
+  const num = Number.parseInt(match[2], 10);
+  if (num < 1 || num > 999999) {
+    throw new Error("Invalid issue number");
+  }
+  return { repo, issueNumber: num };
+}
+function appendWarning(existing, addition) {
+  return existing ? `${existing}. ${addition}` : addition;
+}
+function mapPriority2(labels) {
+  for (const label of labels) {
+    if (label === "priority:critical" || label === "priority:high") return 5 /* High */;
+    if (label === "priority:medium") return 3 /* Medium */;
+    if (label === "priority:low") return 1 /* Low */;
+  }
+  return 0 /* None */;
+}
+function toBoardIssue(issue, repoName) {
+  return {
+    number: issue.number,
+    title: issue.title,
+    url: issue.url,
+    state: issue.state,
+    assignee: issue.assignees?.[0]?.login ?? null,
+    labels: issue.labels.map((l) => l.name),
+    updatedAt: issue.updatedAt,
+    repo: repoName
+  };
+}
+async function syncToTickTick(repo, issue, boardIssue) {
+  const state = loadSyncState();
+  const existing = findMapping(state, repo.name, issue.number);
+  if (existing) {
+    return { warning: "TickTick task already exists from sync." };
+  }
+  const auth = requireAuth();
+  const api = new TickTickClient(auth.accessToken);
+  const projectFields = fetchProjectFields(repo.name, issue.number, repo.projectNumber);
+  const input2 = {
+    title: issue.title,
+    content: `GitHub: ${issue.url}`,
+    priority: mapPriority2(boardIssue.labels),
+    tags: ["github", repo.shortName],
+    ...projectFields.targetDate ? { dueDate: projectFields.targetDate, isAllDay: true } : {}
+  };
+  const task2 = await api.createTask(input2);
+  upsertMapping(state, {
+    githubRepo: repo.name,
+    githubIssueNumber: issue.number,
+    githubUrl: issue.url,
+    ticktickTaskId: task2.id,
+    ticktickProjectId: task2.projectId,
+    githubUpdatedAt: issue.updatedAt,
+    lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  saveSyncState(state);
+  return { task: task2 };
+}
+async function pickIssue(config2, ref) {
+  const { repo, issueNumber } = ref;
+  const allIssues = fetchRepoIssues(repo.name, { state: "open", limit: 200 });
+  const issue = allIssues.find((i) => i.number === issueNumber);
+  if (!issue) {
+    throw new Error(`Issue #${issueNumber} not found in ${repo.name}. Is it open?`);
+  }
+  const boardIssue = toBoardIssue(issue, repo.name);
+  let warning;
+  if (boardIssue.assignee === config2.board.assignee) {
+    warning = "Issue is already assigned to you";
+  } else if (boardIssue.assignee) {
+    warning = `Issue is currently assigned to ${boardIssue.assignee}. Reassigning to you.`;
+  }
+  assignIssue(repo.name, issueNumber);
+  let ticktickTask;
+  try {
+    const result = await syncToTickTick(repo, issue, boardIssue);
+    ticktickTask = result.task;
+    if (result.warning) {
+      warning = appendWarning(warning, result.warning);
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    warning = appendWarning(warning, `TickTick sync failed: ${msg}. Run 'hog sync run' to retry.`);
+  }
+  return {
+    success: true,
+    issue: boardIssue,
+    ...ticktickTask ? { ticktickTask } : {},
+    ...warning ? { warning } : {}
+  };
+}
+var ISSUE_REF_PATTERN;
+var init_pick = __esm({
+  "src/pick.ts"() {
+    "use strict";
+    init_api();
+    init_config();
+    init_github();
+    init_sync_state();
+    init_types();
+    ISSUE_REF_PATTERN = /^([a-zA-Z0-9_.-]+)\/(\d+)$/;
+  }
+});
+
+// src/board/hooks/use-actions.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+import { useCallback, useRef } from "react";
+function findIssueContext(repos, selectedId, config2) {
+  if (!selectedId?.startsWith("gh:")) {
+    return { issue: null, repoName: null, repoConfig: null, statusOptions: [] };
+  }
+  for (const rd of repos) {
+    for (const issue of rd.issues) {
+      if (`gh:${rd.repo.name}:${issue.number}` === selectedId) {
+        const repoConfig = config2.repos.find((r) => r.name === rd.repo.name) ?? null;
+        return { issue, repoName: rd.repo.name, repoConfig, statusOptions: rd.statusOptions };
+      }
+    }
+  }
+  return { issue: null, repoName: null, repoConfig: null, statusOptions: [] };
+}
+async function triggerCompletionActionAsync(action, repoName, issueNumber) {
+  switch (action.type) {
+    case "closeIssue":
+      await execFileAsync2("gh", ["issue", "close", String(issueNumber), "--repo", repoName], {
+        encoding: "utf-8",
+        timeout: 3e4
+      });
+      break;
+    case "addLabel":
+      await execFileAsync2(
+        "gh",
+        ["issue", "edit", String(issueNumber), "--repo", repoName, "--add-label", action.label],
+        { encoding: "utf-8", timeout: 3e4 }
+      );
+      break;
+    case "updateProjectStatus":
+      break;
+  }
+}
+function optimisticSetStatus(data, repoName, issueNumber, statusOptions, optionId) {
+  const statusName = statusOptions.find((o) => o.id === optionId)?.name;
+  if (!statusName) return data;
+  return {
+    ...data,
+    repos: data.repos.map((rd) => {
+      if (rd.repo.name !== repoName) return rd;
+      return {
+        ...rd,
+        issues: rd.issues.map(
+          (issue) => issue.number === issueNumber ? { ...issue, projectStatus: statusName } : issue
+        )
+      };
+    })
+  };
+}
+function useActions({
+  config: config2,
+  repos,
+  selectedId,
+  toast,
+  refresh,
+  mutateData,
+  onOverlayDone
+}) {
+  const configRef = useRef(config2);
+  const reposRef = useRef(repos);
+  const selectedIdRef = useRef(selectedId);
+  configRef.current = config2;
+  reposRef.current = repos;
+  selectedIdRef.current = selectedId;
+  const handlePick = useCallback(() => {
+    const ctx = findIssueContext(reposRef.current, selectedIdRef.current, configRef.current);
+    if (!(ctx.issue && ctx.repoConfig)) return;
+    const { issue, repoConfig } = ctx;
+    const assignees = issue.assignees ?? [];
+    if (assignees.some((a) => a.login === configRef.current.board.assignee)) {
+      toast.info(`Already assigned to @${configRef.current.board.assignee}`);
+      return;
+    }
+    const firstAssignee = assignees[0];
+    if (firstAssignee) {
+      toast.info(`Already assigned to @${firstAssignee.login}`);
+      return;
+    }
+    const t = toast.loading(`Picking ${repoConfig.shortName}#${issue.number}...`);
+    pickIssue(configRef.current, { repo: repoConfig, issueNumber: issue.number }).then((result) => {
+      const msg = `Picked ${repoConfig.shortName}#${issue.number} \u2014 assigned + synced to TickTick`;
+      t.resolve(result.warning ? `${msg} (${result.warning})` : msg);
+      refresh();
+    }).catch((err) => {
+      t.reject(`Pick failed: ${err instanceof Error ? err.message : String(err)}`);
+    });
+  }, [toast, refresh]);
+  const handleComment = useCallback(
+    (body) => {
+      const ctx = findIssueContext(reposRef.current, selectedIdRef.current, configRef.current);
+      if (!(ctx.issue && ctx.repoName)) {
+        onOverlayDone();
+        return;
+      }
+      const { issue, repoName } = ctx;
+      const t = toast.loading("Commenting...");
+      execFileAsync2(
+        "gh",
+        ["issue", "comment", String(issue.number), "--repo", repoName, "--body", body],
+        { encoding: "utf-8", timeout: 3e4 }
+      ).then(() => {
+        t.resolve(`Comment posted on #${issue.number}`);
+        refresh();
+      }).catch((err) => {
+        t.reject(`Comment failed: ${err instanceof Error ? err.message : String(err)}`);
+      }).finally(() => {
+        onOverlayDone();
+      });
+    },
+    [toast, refresh, onOverlayDone]
+  );
+  const handleStatusChange = useCallback(
+    (optionId) => {
+      const ctx = findIssueContext(reposRef.current, selectedIdRef.current, configRef.current);
+      if (!(ctx.issue && ctx.repoName && ctx.repoConfig)) {
+        onOverlayDone();
+        return;
+      }
+      const { issue, repoName, repoConfig, statusOptions } = ctx;
+      mutateData(
+        (data) => optimisticSetStatus(data, repoName, issue.number, statusOptions, optionId)
+      );
+      const t = toast.loading("Moving...");
+      const projectConfig = {
+        projectNumber: repoConfig.projectNumber,
+        statusFieldId: repoConfig.statusFieldId,
+        optionId
+      };
+      updateProjectItemStatusAsync(repoName, issue.number, projectConfig).then(async () => {
+        const optionName = statusOptions.find((o) => o.id === optionId)?.name ?? optionId;
+        if (TERMINAL_STATUS_RE.test(optionName) && repoConfig.completionAction) {
+          try {
+            await triggerCompletionActionAsync(
+              repoConfig.completionAction,
+              repoName,
+              issue.number
+            );
+            t.resolve(
+              `#${issue.number} \u2192 ${optionName} (${repoConfig.completionAction.type})`
+            );
+          } catch {
+            toast.info(`#${issue.number} \u2192 ${optionName} (completion action failed)`);
+          }
+        } else {
+          t.resolve(`#${issue.number} \u2192 ${optionName}`);
+        }
+        refresh();
+      }).catch((err) => {
+        t.reject(`Status change failed: ${err instanceof Error ? err.message : String(err)}`);
+        refresh();
+      }).finally(() => {
+        onOverlayDone();
+      });
+    },
+    [toast, refresh, mutateData, onOverlayDone]
+  );
+  const handleAssign = useCallback(() => {
+    const ctx = findIssueContext(reposRef.current, selectedIdRef.current, configRef.current);
+    if (!(ctx.issue && ctx.repoName)) return;
+    const { issue, repoName } = ctx;
+    const assignees = issue.assignees ?? [];
+    if (assignees.some((a) => a.login === configRef.current.board.assignee)) {
+      toast.info(`Already assigned to @${configRef.current.board.assignee}`);
+      return;
+    }
+    const firstAssignee = assignees[0];
+    if (firstAssignee) {
+      toast.info(`Already assigned to @${firstAssignee.login}`);
+      return;
+    }
+    const t = toast.loading("Assigning...");
+    assignIssueAsync(repoName, issue.number).then(() => {
+      t.resolve(`Assigned #${issue.number} to @${configRef.current.board.assignee}`);
+      refresh();
+    }).catch((err) => {
+      t.reject(`Assign failed: ${err instanceof Error ? err.message : String(err)}`);
+    });
+  }, [toast, refresh]);
+  const handleUnassign = useCallback(() => {
+    const ctx = findIssueContext(reposRef.current, selectedIdRef.current, configRef.current);
+    if (!(ctx.issue && ctx.repoName)) return;
+    const { issue, repoName } = ctx;
+    const assignees = issue.assignees ?? [];
+    const selfAssigned = assignees.some((a) => a.login === configRef.current.board.assignee);
+    if (!selfAssigned) {
+      const firstAssignee = assignees[0];
+      if (firstAssignee) {
+        toast.info(`Assigned to @${firstAssignee.login} \u2014 can only unassign self`);
+      } else {
+        toast.info("Not assigned");
+      }
+      return;
+    }
+    const t = toast.loading("Unassigning...");
+    execFileAsync2(
+      "gh",
+      ["issue", "edit", String(issue.number), "--repo", repoName, "--remove-assignee", "@me"],
+      { encoding: "utf-8", timeout: 3e4 }
+    ).then(() => {
+      t.resolve(`Unassigned #${issue.number} from @${configRef.current.board.assignee}`);
+      refresh();
+    }).catch((err) => {
+      t.reject(`Unassign failed: ${err instanceof Error ? err.message : String(err)}`);
+    });
+  }, [toast, refresh]);
+  const handleCreateIssue = useCallback(
+    async (repo, title, labels) => {
+      const args = ["issue", "create", "--repo", repo, "--title", title];
+      if (labels && labels.length > 0) {
+        for (const label of labels) {
+          args.push("--label", label);
+        }
+      }
+      const t = toast.loading("Creating...");
+      try {
+        const { stdout } = await execFileAsync2("gh", args, { encoding: "utf-8", timeout: 3e4 });
+        const output = stdout.trim();
+        const match = output.match(/\/(\d+)$/);
+        const issueNumber = match?.[1] ? parseInt(match[1], 10) : 0;
+        const shortName = configRef.current.repos.find((r) => r.name === repo)?.shortName ?? repo;
+        t.resolve(`Created ${shortName}#${issueNumber}`);
+        refresh();
+        onOverlayDone();
+        return issueNumber > 0 ? { repo, issueNumber } : null;
+      } catch (err) {
+        t.reject(`Create failed: ${err instanceof Error ? err.message : String(err)}`);
+        onOverlayDone();
+        return null;
+      }
+    },
+    [toast, refresh, onOverlayDone]
+  );
+  const handleBulkAssign = useCallback(
+    async (ids) => {
+      const failed = [];
+      const t = toast.loading(`Assigning ${ids.size} issue${ids.size > 1 ? "s" : ""}...`);
+      for (const id of ids) {
+        const ctx = findIssueContext(reposRef.current, id, configRef.current);
+        if (!(ctx.issue && ctx.repoName)) {
+          failed.push(id);
+          continue;
+        }
+        const assignees = ctx.issue.assignees ?? [];
+        if (assignees.some((a) => a.login === configRef.current.board.assignee)) continue;
+        try {
+          await assignIssueAsync(ctx.repoName, ctx.issue.number);
+        } catch {
+          failed.push(id);
+        }
+      }
+      const total = ids.size;
+      const ok = total - failed.length;
+      if (failed.length === 0) {
+        t.resolve(
+          `Assigned ${total} issue${total > 1 ? "s" : ""} to @${configRef.current.board.assignee}`
+        );
+      } else {
+        t.reject(`${ok} assigned, ${failed.length} failed`);
+      }
+      refresh();
+      return failed;
+    },
+    [toast, refresh]
+  );
+  const handleBulkUnassign = useCallback(
+    async (ids) => {
+      const failed = [];
+      const t = toast.loading(`Unassigning ${ids.size} issue${ids.size > 1 ? "s" : ""}...`);
+      for (const id of ids) {
+        const ctx = findIssueContext(reposRef.current, id, configRef.current);
+        if (!(ctx.issue && ctx.repoName)) {
+          failed.push(id);
+          continue;
+        }
+        const assignees = ctx.issue.assignees ?? [];
+        if (!assignees.some((a) => a.login === configRef.current.board.assignee)) continue;
+        try {
+          await execFileAsync2(
+            "gh",
+            [
+              "issue",
+              "edit",
+              String(ctx.issue.number),
+              "--repo",
+              ctx.repoName,
+              "--remove-assignee",
+              "@me"
+            ],
+            { encoding: "utf-8", timeout: 3e4 }
+          );
+        } catch {
+          failed.push(id);
+        }
+      }
+      const total = ids.size;
+      const ok = total - failed.length;
+      if (failed.length === 0) {
+        t.resolve(`Unassigned ${total} issue${total > 1 ? "s" : ""}`);
+      } else {
+        t.reject(`${ok} unassigned, ${failed.length} failed`);
+      }
+      refresh();
+      return failed;
+    },
+    [toast, refresh]
+  );
+  const handleBulkStatusChange = useCallback(
+    async (ids, optionId) => {
+      for (const id of ids) {
+        const ctx = findIssueContext(reposRef.current, id, configRef.current);
+        if (ctx.issue && ctx.repoName) {
+          const { issue: ctxIssue, repoName: ctxRepo, statusOptions: ctxOpts } = ctx;
+          mutateData(
+            (data) => optimisticSetStatus(data, ctxRepo, ctxIssue.number, ctxOpts, optionId)
+          );
+        }
+      }
+      const t = toast.loading(`Moving ${ids.size} issue${ids.size > 1 ? "s" : ""}...`);
+      const failed = [];
+      for (const id of ids) {
+        const ctx = findIssueContext(reposRef.current, id, configRef.current);
+        if (!(ctx.issue && ctx.repoName && ctx.repoConfig)) {
+          failed.push(id);
+          continue;
+        }
+        try {
+          const projectConfig = {
+            projectNumber: ctx.repoConfig.projectNumber,
+            statusFieldId: ctx.repoConfig.statusFieldId,
+            optionId
+          };
+          await updateProjectItemStatusAsync(ctx.repoName, ctx.issue.number, projectConfig);
+        } catch {
+          failed.push(id);
+        }
+      }
+      const total = ids.size;
+      const ok = total - failed.length;
+      const optionName = (() => {
+        for (const id of ids) {
+          const ctx = findIssueContext(reposRef.current, id, configRef.current);
+          const name = ctx.statusOptions.find((o) => o.id === optionId)?.name;
+          if (name) return name;
+        }
+        return optionId;
+      })();
+      if (failed.length === 0) {
+        t.resolve(`Moved ${total} issue${total > 1 ? "s" : ""} to ${optionName}`);
+      } else {
+        t.reject(`${ok} moved to ${optionName}, ${failed.length} failed`);
+      }
+      refresh();
+      return failed;
+    },
+    [toast, refresh, mutateData]
+  );
+  return {
+    handlePick,
+    handleComment,
+    handleStatusChange,
+    handleAssign,
+    handleUnassign,
+    handleCreateIssue,
+    handleBulkAssign,
+    handleBulkUnassign,
+    handleBulkStatusChange
+  };
+}
+var execFileAsync2, TERMINAL_STATUS_RE;
+var init_use_actions = __esm({
+  "src/board/hooks/use-actions.ts"() {
+    "use strict";
+    init_github();
+    init_pick();
+    execFileAsync2 = promisify2(execFile2);
+    TERMINAL_STATUS_RE = /^(done|shipped|won't|wont|closed|complete|completed)$/i;
+  }
+});
+
+// src/board/hooks/use-data.ts
+import { Worker } from "worker_threads";
+import { useCallback as useCallback2, useEffect, useRef as useRef2, useState } from "react";
+function refreshAgeColor(lastRefresh) {
+  if (!lastRefresh) return "gray";
+  const age = Date.now() - lastRefresh.getTime();
+  if (age < STALE_THRESHOLDS.FRESH) return "green";
+  if (age < STALE_THRESHOLDS.AGING) return "yellow";
+  return "red";
+}
+function useData(config2, options, refreshIntervalMs) {
+  const [state, setState] = useState(INITIAL_STATE);
+  const activeRequestRef = useRef2(null);
+  const workerRef = useRef2(null);
+  const intervalRef = useRef2(null);
+  const configRef = useRef2(config2);
+  const optionsRef = useRef2(options);
+  configRef.current = config2;
+  optionsRef.current = options;
+  const refresh = useCallback2(() => {
+    if (activeRequestRef.current) {
+      activeRequestRef.current.canceled = true;
+    }
+    workerRef.current?.terminate();
+    const token = { canceled: false };
+    activeRequestRef.current = token;
+    setState((prev) => ({ ...prev, isRefreshing: true }));
+    const worker = new Worker(
+      new URL(
+        import.meta.url.endsWith(".ts") ? "../fetch-worker.ts" : "./fetch-worker.js",
+        // prod: tsup bundle in dist/
+        import.meta.url
+      ),
+      { workerData: { config: configRef.current, options: optionsRef.current } }
+    );
+    workerRef.current = worker;
+    worker.on("message", (msg) => {
+      if (token.canceled) {
+        worker.terminate();
+        return;
+      }
+      if (msg.type === "success" && msg.data) {
+        const data = msg.data;
+        data.fetchedAt = new Date(data.fetchedAt);
+        for (const ev of data.activity) {
+          ev.timestamp = new Date(ev.timestamp);
+        }
+        setState({
+          status: "success",
+          data,
+          error: null,
+          lastRefresh: /* @__PURE__ */ new Date(),
+          isRefreshing: false,
+          consecutiveFailures: 0,
+          autoRefreshPaused: false
+        });
+      } else {
+        setState((prev) => {
+          const failures = prev.consecutiveFailures + 1;
+          return {
+            ...prev,
+            status: prev.data ? "success" : "error",
+            error: msg.error ?? "Unknown error",
+            isRefreshing: false,
+            consecutiveFailures: failures,
+            autoRefreshPaused: failures >= MAX_REFRESH_FAILURES
+          };
+        });
+      }
+      worker.terminate();
+    });
+    worker.on("error", (err) => {
+      if (token.canceled) return;
+      setState((prev) => {
+        const failures = prev.consecutiveFailures + 1;
+        return {
+          ...prev,
+          status: prev.data ? "success" : "error",
+          error: err.message,
+          isRefreshing: false,
+          consecutiveFailures: failures,
+          autoRefreshPaused: failures >= MAX_REFRESH_FAILURES
+        };
+      });
+    });
+  }, []);
+  useEffect(() => {
+    refresh();
+  }, [refresh]);
+  const stateRef = useRef2(state);
+  stateRef.current = state;
+  useEffect(() => {
+    if (refreshIntervalMs <= 0) return;
+    intervalRef.current = setInterval(() => {
+      if (!stateRef.current.autoRefreshPaused) {
+        refresh();
+      }
+    }, refreshIntervalMs);
+    return () => {
+      if (intervalRef.current) {
+        clearInterval(intervalRef.current);
+      }
+    };
+  }, [refresh, refreshIntervalMs]);
+  useEffect(() => {
+    return () => {
+      if (activeRequestRef.current) {
+        activeRequestRef.current.canceled = true;
+      }
+      workerRef.current?.terminate();
+    };
+  }, []);
+  const mutateData = useCallback2((fn) => {
+    setState((prev) => {
+      if (!prev.data) return prev;
+      return { ...prev, data: fn(prev.data) };
+    });
+  }, []);
+  return { ...state, refresh, mutateData };
+}
+var INITIAL_STATE, STALE_THRESHOLDS, MAX_REFRESH_FAILURES;
+var init_use_data = __esm({
+  "src/board/hooks/use-data.ts"() {
+    "use strict";
+    INITIAL_STATE = {
+      status: "loading",
+      data: null,
+      error: null,
+      lastRefresh: null,
+      isRefreshing: false,
+      consecutiveFailures: 0,
+      autoRefreshPaused: false
+    };
+    STALE_THRESHOLDS = {
+      FRESH: 6e4,
+      // 0-60s → green
+      AGING: 3e5
+      // 60s-5m → yellow
+      // 5m+ → red
+    };
+    MAX_REFRESH_FAILURES = 3;
+  }
+});
+
+// src/board/hooks/use-multi-select.ts
+import { useCallback as useCallback3, useRef as useRef3, useState as useState2 } from "react";
+function useMultiSelect(getRepoForId) {
+  const [selected, setSelected] = useState2(/* @__PURE__ */ new Set());
+  const repoRef = useRef3(null);
+  const getRepoRef = useRef3(getRepoForId);
+  getRepoRef.current = getRepoForId;
+  const toggle = useCallback3((id) => {
+    setSelected((prev) => {
+      const repo = getRepoRef.current(id);
+      if (!repo) return prev;
+      const next = new Set(prev);
+      if (next.has(id)) {
+        next.delete(id);
+        if (next.size === 0) repoRef.current = null;
+      } else {
+        if (repoRef.current && repoRef.current !== repo) {
+          next.clear();
+        }
+        repoRef.current = repo;
+        next.add(id);
+      }
+      return next;
+    });
+  }, []);
+  const clear = useCallback3(() => {
+    setSelected(/* @__PURE__ */ new Set());
+    repoRef.current = null;
+  }, []);
+  const prune = useCallback3((validIds) => {
+    setSelected((prev) => {
+      const next = /* @__PURE__ */ new Set();
+      for (const id of prev) {
+        if (validIds.has(id)) next.add(id);
+      }
+      if (next.size === prev.size) return prev;
+      if (next.size === 0) repoRef.current = null;
+      return next;
+    });
+  }, []);
+  const isSelected = useCallback3((id) => selected.has(id), [selected]);
+  return {
+    selected,
+    count: selected.size,
+    isSelected,
+    toggle,
+    clear,
+    prune,
+    constrainedRepo: repoRef.current
+  };
+}
+var init_use_multi_select = __esm({
+  "src/board/hooks/use-multi-select.ts"() {
+    "use strict";
+  }
+});
+
+// src/board/hooks/use-navigation.ts
+import { useCallback as useCallback4, useMemo, useReducer, useRef as useRef4 } from "react";
+function arraysEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+function findFallback(items, oldSection) {
+  if (oldSection) {
+    const sectionItem = items.find((i) => i.section === oldSection && i.type === "item");
+    if (sectionItem) return sectionItem;
+    const sectionHeader = items.find((i) => i.section === oldSection && i.type === "header");
+    if (sectionHeader) return sectionHeader;
+  }
+  return items.find((i) => i.type === "header") ?? items[0];
+}
+function navReducer(state, action) {
+  switch (action.type) {
+    case "SET_ITEMS": {
+      const sections = [...new Set(action.items.map((i) => i.section))];
+      const isFirstLoad = state.sections.length === 0;
+      const collapsedSections = isFirstLoad ? new Set(sections) : state.collapsedSections;
+      const selectionValid = state.selectedId != null && action.items.some((i) => i.id === state.selectedId);
+      if (!isFirstLoad && selectionValid && arraysEqual(sections, state.sections)) {
+        return state;
+      }
+      if (selectionValid) {
+        const selected = action.items.find((i) => i.id === state.selectedId);
+        return {
+          ...state,
+          selectedSection: selected?.section ?? state.selectedSection,
+          sections,
+          collapsedSections
+        };
+      }
+      const fallback = findFallback(action.items, state.selectedSection);
+      return {
+        selectedId: fallback?.id ?? null,
+        selectedSection: fallback?.section ?? null,
+        sections,
+        collapsedSections
+      };
+    }
+    case "SELECT": {
+      return {
+        ...state,
+        selectedId: action.id,
+        selectedSection: action.section ?? state.selectedSection
+      };
+    }
+    case "TOGGLE_SECTION": {
+      const next = new Set(state.collapsedSections);
+      if (next.has(action.section)) {
+        next.delete(action.section);
+      } else {
+        next.add(action.section);
+      }
+      return { ...state, collapsedSections: next };
+    }
+    default:
+      return state;
+  }
+}
+function getVisibleItems(allItems, collapsedSections) {
+  return allItems.filter((item) => {
+    if (item.type === "header") return true;
+    if (collapsedSections.has(item.section)) return false;
+    if (item.type === "subHeader") return true;
+    if (item.subSection && collapsedSections.has(item.subSection)) return false;
+    return true;
+  });
+}
+function useNavigation(allItems) {
+  const [state, dispatch] = useReducer(navReducer, {
+    selectedId: null,
+    selectedSection: null,
+    sections: [],
+    collapsedSections: /* @__PURE__ */ new Set()
+  });
+  const prevItemsRef = useRef4(null);
+  if (allItems !== prevItemsRef.current) {
+    prevItemsRef.current = allItems;
+    dispatch({ type: "SET_ITEMS", items: allItems });
+  }
+  const visibleItems = useMemo(
+    () => getVisibleItems(allItems, state.collapsedSections),
+    [allItems, state.collapsedSections]
+  );
+  const selectedIndex = useMemo(() => {
+    if (!state.selectedId) return 0;
+    const idx = visibleItems.findIndex((i) => i.id === state.selectedId);
+    return idx >= 0 ? idx : 0;
+  }, [state.selectedId, visibleItems]);
+  const moveUp = useCallback4(() => {
+    const newIdx = Math.max(0, selectedIndex - 1);
+    const item = visibleItems[newIdx];
+    if (item) dispatch({ type: "SELECT", id: item.id, section: item.section });
+  }, [selectedIndex, visibleItems]);
+  const moveDown = useCallback4(() => {
+    const newIdx = Math.min(visibleItems.length - 1, selectedIndex + 1);
+    const item = visibleItems[newIdx];
+    if (item) dispatch({ type: "SELECT", id: item.id, section: item.section });
+  }, [selectedIndex, visibleItems]);
+  const nextSection = useCallback4(() => {
+    const currentItem = visibleItems[selectedIndex];
+    if (!currentItem) return;
+    const currentSectionIdx = state.sections.indexOf(currentItem.section);
+    const nextSectionId = state.sections[currentSectionIdx + 1];
+    if (!nextSectionId) return;
+    const header = visibleItems.find((i) => i.section === nextSectionId && i.type === "header");
+    if (header) dispatch({ type: "SELECT", id: header.id, section: header.section });
+  }, [selectedIndex, visibleItems, state.sections]);
+  const prevSection = useCallback4(() => {
+    const currentItem = visibleItems[selectedIndex];
+    if (!currentItem) return;
+    const currentSectionIdx = state.sections.indexOf(currentItem.section);
+    const prevSectionId = state.sections[currentSectionIdx - 1];
+    if (!prevSectionId) return;
+    const header = visibleItems.find((i) => i.section === prevSectionId && i.type === "header");
+    if (header) dispatch({ type: "SELECT", id: header.id, section: header.section });
+  }, [selectedIndex, visibleItems, state.sections]);
+  const toggleSection = useCallback4(() => {
+    const currentItem = visibleItems[selectedIndex];
+    if (!currentItem) return;
+    const key = currentItem.type === "subHeader" ? currentItem.id : currentItem.section;
+    dispatch({ type: "TOGGLE_SECTION", section: key });
+  }, [selectedIndex, visibleItems]);
+  const allItemsRef = useRef4(allItems);
+  allItemsRef.current = allItems;
+  const select2 = useCallback4((id) => {
+    const item = allItemsRef.current.find((i) => i.id === id);
+    dispatch({ type: "SELECT", id, section: item?.section });
+  }, []);
+  const isCollapsed = useCallback4(
+    (section) => state.collapsedSections.has(section),
+    [state.collapsedSections]
+  );
+  return {
+    selectedId: state.selectedId,
+    selectedIndex,
+    collapsedSections: state.collapsedSections,
+    moveUp,
+    moveDown,
+    nextSection,
+    prevSection,
+    toggleSection,
+    select: select2,
+    isCollapsed
+  };
+}
+var init_use_navigation = __esm({
+  "src/board/hooks/use-navigation.ts"() {
+    "use strict";
+  }
+});
+
+// src/board/hooks/use-toast.ts
+import { useCallback as useCallback5, useRef as useRef5, useState as useState3 } from "react";
+function useToast() {
+  const [toasts, setToasts] = useState3([]);
+  const timersRef = useRef5(/* @__PURE__ */ new Map());
+  const clearTimer = useCallback5((id) => {
+    const timer = timersRef.current.get(id);
+    if (timer) {
+      clearTimeout(timer);
+      timersRef.current.delete(id);
+    }
+  }, []);
+  const removeToast = useCallback5(
+    (id) => {
+      clearTimer(id);
+      setToasts((prev) => prev.filter((t) => t.id !== id));
+    },
+    [clearTimer]
+  );
+  const addToast = useCallback5(
+    (t) => {
+      const id = `toast-${++nextId}`;
+      const newToast = { ...t, id, createdAt: Date.now() };
+      setToasts((prev) => {
+        const next = [...prev, newToast];
+        while (next.length > MAX_VISIBLE) {
+          const evictIdx = next.findIndex((x) => x.type !== "error" && x.type !== "loading");
+          if (evictIdx >= 0) {
+            const evictToast = next[evictIdx];
+            if (evictToast) clearTimer(evictToast.id);
+            next.splice(evictIdx, 1);
+          } else {
+            const oldest = next[0];
+            if (oldest) clearTimer(oldest.id);
+            next.shift();
+          }
+        }
+        return next;
+      });
+      if (t.type === "info" || t.type === "success") {
+        const timer = setTimeout(() => removeToast(id), AUTO_DISMISS_MS);
+        timersRef.current.set(id, timer);
+      }
+      return id;
+    },
+    [removeToast, clearTimer]
+  );
+  const toast = {
+    info: useCallback5(
+      (message) => {
+        addToast({ type: "info", message });
+      },
+      [addToast]
+    ),
+    success: useCallback5(
+      (message) => {
+        addToast({ type: "success", message });
+      },
+      [addToast]
+    ),
+    error: useCallback5(
+      (message, retry) => {
+        addToast(retry ? { type: "error", message, retry } : { type: "error", message });
+      },
+      [addToast]
+    ),
+    loading: useCallback5(
+      (message) => {
+        const id = addToast({ type: "loading", message });
+        return {
+          resolve: (msg) => {
+            removeToast(id);
+            addToast({ type: "success", message: msg });
+          },
+          reject: (msg) => {
+            removeToast(id);
+            addToast({ type: "error", message: msg });
+          }
+        };
+      },
+      [addToast, removeToast]
+    )
+  };
+  const dismiss = useCallback5(
+    (id) => {
+      removeToast(id);
+    },
+    [removeToast]
+  );
+  const dismissAll = useCallback5(() => {
+    for (const timer of timersRef.current.values()) {
+      clearTimeout(timer);
+    }
+    timersRef.current.clear();
+    setToasts([]);
+  }, []);
+  const handleErrorAction = useCallback5(
+    (action) => {
+      const errorToast = toasts.find((t) => t.type === "error");
+      if (!errorToast) return false;
+      if (action === "retry" && errorToast.retry) {
+        removeToast(errorToast.id);
+        errorToast.retry();
+        return true;
+      }
+      if (action === "dismiss") {
+        removeToast(errorToast.id);
+        return true;
+      }
+      return false;
+    },
+    [toasts, removeToast]
+  );
+  return { toasts, toast, dismiss, dismissAll, handleErrorAction };
+}
+var MAX_VISIBLE, AUTO_DISMISS_MS, nextId;
+var init_use_toast = __esm({
+  "src/board/hooks/use-toast.ts"() {
+    "use strict";
+    MAX_VISIBLE = 3;
+    AUTO_DISMISS_MS = 3e3;
+    nextId = 0;
+  }
+});
+
+// src/board/hooks/use-ui-state.ts
+import { useCallback as useCallback6, useReducer as useReducer2 } from "react";
+function uiReducer(state, action) {
+  switch (action.type) {
+    case "ENTER_SEARCH":
+      if (state.mode !== "normal") return state;
+      return { ...state, mode: "search", previousMode: "normal" };
+    case "ENTER_COMMENT":
+      if (state.mode !== "normal") return state;
+      return { ...state, mode: "overlay:comment", previousMode: "normal" };
+    case "ENTER_STATUS":
+      if (state.mode !== "normal" && state.mode !== "overlay:bulkAction") return state;
+      return {
+        ...state,
+        mode: "overlay:status",
+        previousMode: state.mode === "overlay:bulkAction" ? "multiSelect" : "normal"
+      };
+    case "ENTER_CREATE":
+      if (state.mode !== "normal") return state;
+      return { ...state, mode: "overlay:create", previousMode: "normal" };
+    case "ENTER_MULTI_SELECT":
+      if (state.mode !== "normal" && state.mode !== "multiSelect") return state;
+      return { ...state, mode: "multiSelect", previousMode: "normal" };
+    case "ENTER_BULK_ACTION":
+      if (state.mode !== "multiSelect") return state;
+      return { ...state, mode: "overlay:bulkAction", previousMode: "multiSelect" };
+    case "ENTER_CONFIRM_PICK":
+      return { ...state, mode: "overlay:confirmPick", previousMode: "normal" };
+    case "ENTER_FOCUS":
+      if (state.mode !== "normal") return state;
+      return { ...state, mode: "focus", previousMode: "normal" };
+    case "TOGGLE_HELP":
+      return { ...state, helpVisible: !state.helpVisible };
+    case "EXIT_OVERLAY":
+      if (state.helpVisible) {
+        return { ...state, helpVisible: false };
+      }
+      return { ...state, mode: state.previousMode, previousMode: "normal" };
+    case "EXIT_TO_NORMAL":
+      return { ...state, mode: "normal", helpVisible: false, previousMode: "normal" };
+    case "CLEAR_MULTI_SELECT":
+      if (state.mode === "multiSelect") {
+        return { ...state, mode: "normal", previousMode: "normal" };
+      }
+      return state;
+    default:
+      return state;
+  }
+}
+function canNavigate(state) {
+  const { mode } = state;
+  return mode === "normal" || mode === "multiSelect" || mode === "focus";
+}
+function canAct(state) {
+  return state.mode === "normal";
+}
+function isOverlay(state) {
+  return state.mode.startsWith("overlay:") || state.mode === "search";
+}
+function useUIState() {
+  const [state, dispatch] = useReducer2(uiReducer, INITIAL_STATE2);
+  return {
+    state,
+    enterSearch: useCallback6(() => dispatch({ type: "ENTER_SEARCH" }), []),
+    enterComment: useCallback6(() => dispatch({ type: "ENTER_COMMENT" }), []),
+    enterStatus: useCallback6(() => dispatch({ type: "ENTER_STATUS" }), []),
+    enterCreate: useCallback6(() => dispatch({ type: "ENTER_CREATE" }), []),
+    enterMultiSelect: useCallback6(() => dispatch({ type: "ENTER_MULTI_SELECT" }), []),
+    enterBulkAction: useCallback6(() => dispatch({ type: "ENTER_BULK_ACTION" }), []),
+    enterConfirmPick: useCallback6(() => dispatch({ type: "ENTER_CONFIRM_PICK" }), []),
+    enterFocus: useCallback6(() => dispatch({ type: "ENTER_FOCUS" }), []),
+    toggleHelp: useCallback6(() => dispatch({ type: "TOGGLE_HELP" }), []),
+    exitOverlay: useCallback6(() => dispatch({ type: "EXIT_OVERLAY" }), []),
+    exitToNormal: useCallback6(() => dispatch({ type: "EXIT_TO_NORMAL" }), []),
+    clearMultiSelect: useCallback6(() => dispatch({ type: "CLEAR_MULTI_SELECT" }), []),
+    canNavigate: canNavigate(state),
+    canAct: canAct(state),
+    isOverlay: isOverlay(state)
+  };
+}
+var INITIAL_STATE2;
+var init_use_ui_state = __esm({
+  "src/board/hooks/use-ui-state.ts"() {
+    "use strict";
+    INITIAL_STATE2 = {
+      mode: "normal",
+      helpVisible: false,
+      previousMode: "normal"
+    };
+  }
+});
+
+// src/board/components/bulk-action-menu.tsx
+import { Box, Text, useInput } from "ink";
+import { useState as useState4 } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+function getMenuItems(selectionType) {
+  if (selectionType === "github") {
+    return [
+      { label: "Assign all to me", action: { type: "assign" } },
+      { label: "Unassign all from me", action: { type: "unassign" } },
+      { label: "Move status (all)", action: { type: "statusChange" } }
+    ];
+  }
+  if (selectionType === "ticktick") {
+    return [
+      { label: "Complete all", action: { type: "complete" } },
+      { label: "Delete all", action: { type: "delete" } }
+    ];
+  }
+  return [];
+}
+function BulkActionMenu({ count, selectionType, onSelect, onCancel }) {
+  const items = getMenuItems(selectionType);
+  const [selectedIdx, setSelectedIdx] = useState4(0);
+  useInput((input2, key) => {
+    if (key.escape) return onCancel();
+    if (key.return) {
+      const item = items[selectedIdx];
+      if (item) onSelect(item.action);
+      return;
+    }
+    if (input2 === "j" || key.downArrow) {
+      setSelectedIdx((i) => Math.min(i + 1, items.length - 1));
+    }
+    if (input2 === "k" || key.upArrow) {
+      setSelectedIdx((i) => Math.max(i - 1, 0));
+    }
+  });
+  if (items.length === 0) {
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Text, { color: "yellow", children: "No bulk actions for mixed selection types." }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Esc to cancel" })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs(Text, { color: "cyan", bold: true, children: [
+      "Bulk action (",
+      count,
+      " selected):"
+    ] }),
+    items.map((item, i) => {
+      const isSelected = i === selectedIdx;
+      const prefix = isSelected ? "> " : "  ";
+      return /* @__PURE__ */ jsxs(Text, { ...isSelected ? { color: "cyan" } : {}, children: [
+        prefix,
+        item.label
+      ] }, item.action.type);
+    }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: "j/k:navigate Enter:select Esc:cancel" })
+  ] });
+}
+var init_bulk_action_menu = __esm({
+  "src/board/components/bulk-action-menu.tsx"() {
+    "use strict";
+  }
+});
+
+// src/board/components/comment-input.tsx
+import { TextInput } from "@inkjs/ui";
+import { Box as Box2, Text as Text2, useInput as useInput2 } from "ink";
+import { useState as useState5 } from "react";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function CommentInput({ issueNumber, onSubmit, onCancel }) {
+  const [value, setValue] = useState5("");
+  useInput2((_input, key) => {
+    if (key.escape) onCancel();
+  });
+  return /* @__PURE__ */ jsxs2(Box2, { children: [
+    /* @__PURE__ */ jsxs2(Text2, { color: "cyan", children: [
+      "comment #",
+      issueNumber,
+      ": "
+    ] }),
+    /* @__PURE__ */ jsx2(
+      TextInput,
+      {
+        defaultValue: value,
+        placeholder: "type comment, Enter to post...",
+        onChange: setValue,
+        onSubmit: (text) => {
+          if (text.trim()) onSubmit(text.trim());
+          else onCancel();
+        }
+      }
+    )
+  ] });
+}
+var init_comment_input = __esm({
+  "src/board/components/comment-input.tsx"() {
+    "use strict";
+  }
+});
+
+// src/board/components/confirm-prompt.tsx
+import { Box as Box3, Text as Text3, useInput as useInput3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function ConfirmPrompt({ message, onConfirm, onCancel }) {
+  useInput3((input2, key) => {
+    if (input2 === "y" || input2 === "Y") return onConfirm();
+    if (input2 === "n" || input2 === "N" || key.escape) return onCancel();
+  });
+  return /* @__PURE__ */ jsxs3(Box3, { children: [
+    /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: message }),
+    /* @__PURE__ */ jsx3(Text3, { color: "gray", children: " (y/n)" })
+  ] });
+}
+var init_confirm_prompt = __esm({
+  "src/board/components/confirm-prompt.tsx"() {
+    "use strict";
+  }
+});
+
+// src/board/components/create-issue-form.tsx
+import { TextInput as TextInput2 } from "@inkjs/ui";
+import { Box as Box4, Text as Text4, useInput as useInput4 } from "ink";
+import { useState as useState6 } from "react";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function CreateIssueForm({ repos, defaultRepo, onSubmit, onCancel }) {
+  const defaultRepoIdx = defaultRepo ? Math.max(
+    0,
+    repos.findIndex((r) => r.name === defaultRepo)
+  ) : 0;
+  const [repoIdx, setRepoIdx] = useState6(defaultRepoIdx);
+  const [title, setTitle] = useState6("");
+  const [field, setField] = useState6("title");
+  useInput4((input2, key) => {
+    if (key.escape) return onCancel();
+    if (field === "repo") {
+      if (input2 === "j" || key.downArrow) {
+        setRepoIdx((i) => Math.min(i + 1, repos.length - 1));
+      }
+      if (input2 === "k" || key.upArrow) {
+        setRepoIdx((i) => Math.max(i - 1, 0));
+      }
+      if (key.tab) setField("title");
+      if (key.return) setField("title");
+    }
+  });
+  const selectedRepo = repos[repoIdx];
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx4(Text4, { color: "cyan", bold: true, children: "Create Issue" }),
+    /* @__PURE__ */ jsxs4(Box4, { children: [
+      /* @__PURE__ */ jsx4(Text4, { dimColor: field !== "repo", children: "Repo: " }),
+      repos.map((r, i) => /* @__PURE__ */ jsx4(
+        Text4,
+        {
+          ...i === repoIdx ? { color: "cyan", bold: true } : {},
+          dimColor: field !== "repo",
+          children: i === repoIdx ? `[${r.shortName}]` : ` ${r.shortName} `
+        },
+        r.name
+      )),
+      field === "repo" ? /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: " j/k:select Tab:next" }) : null
+    ] }),
+    /* @__PURE__ */ jsxs4(Box4, { children: [
+      /* @__PURE__ */ jsx4(Text4, { dimColor: field !== "title", children: "Title: " }),
+      field === "title" ? /* @__PURE__ */ jsx4(
+        TextInput2,
+        {
+          defaultValue: title,
+          placeholder: "issue title...",
+          onChange: setTitle,
+          onSubmit: (text) => {
+            if (text.trim() && selectedRepo) {
+              onSubmit(selectedRepo.name, text.trim());
+            }
+          }
+        }
+      ) : /* @__PURE__ */ jsx4(Text4, { children: title || "(empty)" })
+    ] }),
+    /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Tab:switch fields Enter:submit Esc:cancel" })
+  ] });
+}
+var init_create_issue_form = __esm({
+  "src/board/components/create-issue-form.tsx"() {
+    "use strict";
+  }
+});
+
+// src/board/components/detail-panel.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import { Fragment, jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function truncateLines(text, maxLines) {
+  const lines = text.split("\n").slice(0, maxLines);
+  return lines.join("\n");
+}
+function stripMarkdown(text) {
+  return text.replace(/^#{1,6}\s+/gm, "").replace(/\*\*(.+?)\*\*/g, "$1").replace(/\*(.+?)\*/g, "$1").replace(/__(.+?)__/g, "$1").replace(/_(.+?)_/g, "$1").replace(/~~(.+?)~~/g, "$1").replace(/`{1,3}[^`]*`{1,3}/g, (m) => m.replace(/`/g, "")).replace(/^\s*[-*+]\s+/gm, "  - ").replace(/^\s*\d+\.\s+/gm, "  ").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/!\[([^\]]*)\]\([^)]+\)/g, "[$1]").replace(/^>\s+/gm, "  ").replace(/---+/g, "").replace(/\n{3,}/g, "\n\n").trim();
+}
+function formatBody(body, maxLines) {
+  const plain = stripMarkdown(body);
+  const lines = plain.split("\n");
+  const truncated = lines.slice(0, maxLines).join("\n");
+  return { text: truncated, remaining: Math.max(0, lines.length - maxLines) };
+}
+function countSlackLinks(body) {
+  if (!body) return 0;
+  return (body.match(SLACK_URL_RE) ?? []).length;
+}
+function BodySection({
+  body,
+  issueNumber
+}) {
+  const { text, remaining } = formatBody(body, 15);
+  return /* @__PURE__ */ jsxs5(Fragment, { children: [
+    /* @__PURE__ */ jsx5(Text5, { children: "" }),
+    /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "--- Description ---" }),
+    /* @__PURE__ */ jsx5(Text5, { wrap: "wrap", children: text }),
+    remaining > 0 ? /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+      "... (",
+      remaining,
+      " more lines \u2014 gh issue view ",
+      issueNumber,
+      " for full)"
+    ] }) : null
+  ] });
+}
+function DetailPanel({ issue, task: task2, width }) {
+  if (!(issue || task2)) {
+    return /* @__PURE__ */ jsx5(
+      Box5,
+      {
+        width,
+        borderStyle: "single",
+        borderColor: "gray",
+        flexDirection: "column",
+        paddingX: 1,
+        children: /* @__PURE__ */ jsx5(Text5, { color: "gray", children: "No item selected" })
+      }
+    );
+  }
+  if (issue) {
+    return /* @__PURE__ */ jsxs5(
+      Box5,
+      {
+        width,
+        borderStyle: "single",
+        borderColor: "cyan",
+        flexDirection: "column",
+        paddingX: 1,
+        children: [
+          /* @__PURE__ */ jsxs5(Text5, { color: "cyan", bold: true, children: [
+            "#",
+            issue.number,
+            " ",
+            issue.title
+          ] }),
+          /* @__PURE__ */ jsx5(Text5, { children: "" }),
+          /* @__PURE__ */ jsxs5(Box5, { children: [
+            /* @__PURE__ */ jsx5(Text5, { color: "gray", children: "State: " }),
+            /* @__PURE__ */ jsx5(Text5, { color: issue.state === "open" ? "green" : "red", children: issue.state })
+          ] }),
+          (issue.assignees ?? []).length > 0 ? /* @__PURE__ */ jsxs5(Box5, { children: [
+            /* @__PURE__ */ jsx5(Text5, { color: "gray", children: "Assignees: " }),
+            /* @__PURE__ */ jsx5(Text5, { children: (issue.assignees ?? []).map((a) => a.login).join(", ") })
+          ] }) : null,
+          issue.labels.length > 0 ? /* @__PURE__ */ jsxs5(Box5, { children: [
+            /* @__PURE__ */ jsx5(Text5, { color: "gray", children: "Labels: " }),
+            /* @__PURE__ */ jsx5(Text5, { children: issue.labels.map((l) => l.name).join(", ") })
+          ] }) : null,
+          issue.projectStatus ? /* @__PURE__ */ jsxs5(Box5, { children: [
+            /* @__PURE__ */ jsx5(Text5, { color: "gray", children: "Status: " }),
+            /* @__PURE__ */ jsx5(Text5, { color: "magenta", children: issue.projectStatus })
+          ] }) : null,
+          issue.targetDate ? /* @__PURE__ */ jsxs5(Box5, { children: [
+            /* @__PURE__ */ jsx5(Text5, { color: "gray", children: "Target: " }),
+            /* @__PURE__ */ jsx5(Text5, { children: issue.targetDate })
+          ] }) : null,
+          /* @__PURE__ */ jsxs5(Box5, { children: [
+            /* @__PURE__ */ jsx5(Text5, { color: "gray", children: "Updated: " }),
+            /* @__PURE__ */ jsx5(Text5, { children: new Date(issue.updatedAt).toLocaleString() })
+          ] }),
+          issue.slackThreadUrl ? /* @__PURE__ */ jsxs5(Box5, { children: [
+            /* @__PURE__ */ jsx5(Text5, { color: "gray", children: "Slack: " }),
+            /* @__PURE__ */ jsx5(Text5, { color: "blue", children: countSlackLinks(issue.body) > 1 ? `${countSlackLinks(issue.body)} links (s opens first)` : "thread (s to open)" })
+          ] }) : null,
+          issue.body ? /* @__PURE__ */ jsx5(BodySection, { body: issue.body, issueNumber: issue.number }) : /* @__PURE__ */ jsxs5(Fragment, { children: [
+            /* @__PURE__ */ jsx5(Text5, { children: "" }),
+            /* @__PURE__ */ jsx5(Text5, { color: "gray", children: "(no description)" })
+          ] }),
+          /* @__PURE__ */ jsx5(Text5, { children: "" }),
+          /* @__PURE__ */ jsx5(Text5, { color: "gray", dimColor: true, children: issue.url })
+        ]
+      }
+    );
+  }
+  const t = task2;
+  return /* @__PURE__ */ jsxs5(
+    Box5,
+    {
+      width,
+      borderStyle: "single",
+      borderColor: "yellow",
+      flexDirection: "column",
+      paddingX: 1,
+      children: [
+        /* @__PURE__ */ jsx5(Text5, { color: "yellow", bold: true, children: t.title }),
+        /* @__PURE__ */ jsx5(Text5, { children: "" }),
+        /* @__PURE__ */ jsxs5(Box5, { children: [
+          /* @__PURE__ */ jsx5(Text5, { color: "gray", children: "Priority: " }),
+          /* @__PURE__ */ jsx5(Text5, { children: PRIORITY_LABELS2[t.priority] ?? "None" })
+        ] }),
+        t.dueDate ? /* @__PURE__ */ jsxs5(Box5, { children: [
+          /* @__PURE__ */ jsx5(Text5, { color: "gray", children: "Due: " }),
+          /* @__PURE__ */ jsx5(Text5, { children: new Date(t.dueDate).toLocaleDateString() })
+        ] }) : null,
+        (t.tags ?? []).length > 0 ? /* @__PURE__ */ jsxs5(Box5, { children: [
+          /* @__PURE__ */ jsx5(Text5, { color: "gray", children: "Tags: " }),
+          /* @__PURE__ */ jsx5(Text5, { children: t.tags.join(", ") })
+        ] }) : null,
+        t.content ? /* @__PURE__ */ jsxs5(Fragment, { children: [
+          /* @__PURE__ */ jsx5(Text5, { children: "" }),
+          /* @__PURE__ */ jsx5(Text5, { children: truncateLines(t.content, 8) })
+        ] }) : null,
+        (t.items ?? []).length > 0 ? /* @__PURE__ */ jsxs5(Fragment, { children: [
+          /* @__PURE__ */ jsx5(Text5, { children: "" }),
+          /* @__PURE__ */ jsx5(Text5, { color: "gray", children: "Checklist:" }),
+          t.items.slice(0, 5).map((item) => /* @__PURE__ */ jsxs5(Text5, { children: [
+            item.status === 2 ? "\u2611" : "\u2610",
+            " ",
+            item.title
+          ] }, item.id)),
+          t.items.length > 5 ? /* @__PURE__ */ jsxs5(Text5, { color: "gray", children: [
+            "...and ",
+            t.items.length - 5,
+            " more"
+          ] }) : null
+        ] }) : null
+      ]
+    }
+  );
+}
+var SLACK_URL_RE, PRIORITY_LABELS2;
+var init_detail_panel = __esm({
+  "src/board/components/detail-panel.tsx"() {
+    "use strict";
+    init_types();
+    SLACK_URL_RE = /https:\/\/[^/]+\.slack\.com\/archives\/[A-Z0-9]+\/p[0-9]+/gi;
+    PRIORITY_LABELS2 = {
+      [5 /* High */]: "High",
+      [3 /* Medium */]: "Medium",
+      [1 /* Low */]: "Low",
+      [0 /* None */]: "None"
+    };
+  }
+});
+
+// src/board/components/focus-mode.tsx
+import { Box as Box6, Text as Text6, useInput as useInput5 } from "ink";
+import { useCallback as useCallback7, useEffect as useEffect2, useRef as useRef6, useState as useState7 } from "react";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function formatTime(secs) {
+  const m = Math.floor(secs / 60);
+  const s = secs % 60;
+  return `${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}`;
+}
+function FocusMode({ label, durationSec, onExit, onEndAction }) {
+  const [remaining, setRemaining] = useState7(durationSec);
+  const [timerDone, setTimerDone] = useState7(false);
+  const bellSentRef = useRef6(false);
+  useEffect2(() => {
+    if (timerDone) return;
+    const interval = setInterval(() => {
+      setRemaining((prev) => {
+        if (prev <= 1) {
+          clearInterval(interval);
+          setTimerDone(true);
+          return 0;
+        }
+        return prev - 1;
+      });
+    }, 1e3);
+    return () => clearInterval(interval);
+  }, [timerDone]);
+  useEffect2(() => {
+    if (timerDone && !bellSentRef.current) {
+      bellSentRef.current = true;
+      process.stdout.write("\x07");
+    }
+  }, [timerDone]);
+  const handleInput = useCallback7(
+    (input2, key) => {
+      if (key.escape) {
+        if (timerDone) {
+          onEndAction("exit");
+        } else {
+          onExit();
+        }
+        return;
+      }
+      if (!timerDone) return;
+      switch (input2.toLowerCase()) {
+        case "c":
+          onEndAction("restart");
+          break;
+        case "b":
+          onEndAction("break");
+          break;
+        case "d":
+          onEndAction("done");
+          break;
+      }
+    },
+    [timerDone, onExit, onEndAction]
+  );
+  useInput5(handleInput);
+  if (timerDone) {
+    return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs6(Box6, { children: [
+        /* @__PURE__ */ jsx6(Text6, { color: "green", bold: true, children: "Focus complete!" }),
+        /* @__PURE__ */ jsxs6(Text6, { color: "gray", children: [
+          " ",
+          label
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs6(Box6, { marginTop: 1, children: [
+        /* @__PURE__ */ jsx6(Text6, { color: "cyan", children: "[c]" }),
+        /* @__PURE__ */ jsx6(Text6, { children: " Continue " }),
+        /* @__PURE__ */ jsx6(Text6, { color: "cyan", children: "[b]" }),
+        /* @__PURE__ */ jsx6(Text6, { children: " Break " }),
+        /* @__PURE__ */ jsx6(Text6, { color: "cyan", children: "[d]" }),
+        /* @__PURE__ */ jsx6(Text6, { children: " Done " }),
+        /* @__PURE__ */ jsx6(Text6, { color: "gray", children: "[Esc]" }),
+        /* @__PURE__ */ jsx6(Text6, { children: " Exit" })
+      ] })
+    ] });
+  }
+  const progress = 1 - remaining / durationSec;
+  const barWidth = 20;
+  const filled = Math.round(progress * barWidth);
+  const bar = "\u2588".repeat(filled) + "\u2591".repeat(barWidth - filled);
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs6(Box6, { children: [
+      /* @__PURE__ */ jsxs6(Text6, { color: "magenta", bold: true, children: [
+        "Focus:",
+        " "
+      ] }),
+      /* @__PURE__ */ jsx6(Text6, { children: label })
+    ] }),
+    /* @__PURE__ */ jsxs6(Box6, { children: [
+      /* @__PURE__ */ jsx6(Text6, { color: "magenta", children: bar }),
+      /* @__PURE__ */ jsx6(Text6, { children: " " }),
+      /* @__PURE__ */ jsx6(Text6, { bold: true, children: formatTime(remaining) }),
+      /* @__PURE__ */ jsx6(Text6, { color: "gray", children: " remaining" })
+    ] }),
+    /* @__PURE__ */ jsx6(Text6, { color: "gray", dimColor: true, children: "Esc to exit focus" })
+  ] });
+}
+var init_focus_mode = __esm({
+  "src/board/components/focus-mode.tsx"() {
+    "use strict";
+  }
+});
+
+// src/board/components/help-overlay.tsx
+import { Box as Box7, Text as Text7, useInput as useInput6 } from "ink";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+function HelpOverlay({ currentMode, onClose }) {
+  useInput6((_input, key) => {
+    if (key.escape) onClose();
+  });
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs7(Box7, { justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsx7(Text7, { color: "cyan", bold: true, children: "Keyboard Shortcuts" }),
+      /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+        "mode: ",
+        currentMode
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx7(Text7, { children: " " }),
+    SHORTCUTS.map((group) => /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx7(Text7, { color: "yellow", bold: true, children: group.category }),
+      group.items.map((item) => /* @__PURE__ */ jsxs7(Box7, { children: [
+        /* @__PURE__ */ jsx7(Box7, { width: 16, children: /* @__PURE__ */ jsx7(Text7, { color: "green", children: item.key }) }),
+        /* @__PURE__ */ jsx7(Text7, { children: item.desc })
+      ] }, item.key))
+    ] }, group.category)),
+    /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "Press ? or Esc to close" })
+  ] });
+}
+var SHORTCUTS;
+var init_help_overlay = __esm({
+  "src/board/components/help-overlay.tsx"() {
+    "use strict";
+    SHORTCUTS = [
+      {
+        category: "Navigation",
+        items: [
+          { key: "j / Down", desc: "Move down" },
+          { key: "k / Up", desc: "Move up" },
+          { key: "Tab", desc: "Next section" },
+          { key: "Shift+Tab", desc: "Previous section" }
+        ]
+      },
+      {
+        category: "View",
+        items: [
+          { key: "Enter", desc: "Toggle section / Open in browser" },
+          { key: "Space", desc: "Toggle section / Multi-select" },
+          { key: "/", desc: "Search" },
+          { key: "?", desc: "Toggle help" },
+          { key: "Esc", desc: "Close overlay / Back to normal" }
+        ]
+      },
+      {
+        category: "Actions",
+        items: [
+          { key: "p", desc: "Pick issue (assign + TickTick)" },
+          { key: "a", desc: "Assign to self" },
+          { key: "u", desc: "Unassign self" },
+          { key: "c", desc: "Comment on issue" },
+          { key: "m", desc: "Move status" },
+          { key: "s", desc: "Open Slack thread" },
+          { key: "n", desc: "Create new issue" }
+        ]
+      },
+      {
+        category: "Board",
+        items: [
+          { key: "r", desc: "Refresh data" },
+          { key: "q", desc: "Quit" }
+        ]
+      }
+    ];
+  }
+});
+
+// src/board/components/issue-row.tsx
+import { Box as Box8, Text as Text8 } from "ink";
+import { Fragment as Fragment2, jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+function truncate(s, max) {
+  return s.length > max ? `${s.slice(0, max - 1)}\u2026` : s;
+}
+function formatTargetDate(dateStr) {
+  if (!dateStr) return { text: "", color: "gray" };
+  const d = new Date(dateStr);
+  const days = Math.ceil((d.getTime() - Date.now()) / 864e5);
+  if (days < 0) return { text: `${Math.abs(days)}d overdue`, color: "red" };
+  if (days === 0) return { text: "today", color: "yellow" };
+  if (days === 1) return { text: "tomorrow", color: "white" };
+  if (days <= 7) return { text: `in ${days}d`, color: "white" };
+  return {
+    text: d.toLocaleDateString("en-US", { month: "short", day: "numeric" }),
+    color: "gray"
+  };
+}
+function timeAgo(dateStr) {
+  const seconds = Math.floor((Date.now() - new Date(dateStr).getTime()) / 1e3);
+  if (seconds < 60) return "now";
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h`;
+  const days = Math.floor(hours / 24);
+  if (days < 30) return `${days}d`;
+  const months = Math.floor(days / 30);
+  return `${months}mo`;
+}
+function labelColor(name) {
+  return LABEL_COLORS[name.toLowerCase()] ?? "cyan";
+}
+function IssueRow({ issue, selfLogin, isSelected }) {
+  const assignees = issue.assignees ?? [];
+  const isSelf = assignees.some((a) => a.login === selfLogin);
+  const isUnassigned = assignees.length === 0;
+  const assigneeColor = isSelf ? "green" : isUnassigned ? "gray" : "white";
+  const assigneeText = isUnassigned ? "unassigned" : truncate(assignees.map((a) => a.login).join(", "), 14);
+  const labels = (issue.labels ?? []).slice(0, 2);
+  const target = formatTargetDate(issue.targetDate);
+  const titleStr = truncate(issue.title, 42).padEnd(42);
+  return /* @__PURE__ */ jsxs8(Box8, { children: [
+    isSelected ? /* @__PURE__ */ jsx8(Text8, { color: "cyan", bold: true, children: "\u25B6 " }) : /* @__PURE__ */ jsx8(Text8, { children: "  " }),
+    /* @__PURE__ */ jsxs8(Text8, { color: "cyan", children: [
+      "#",
+      String(issue.number).padEnd(5)
+    ] }),
+    /* @__PURE__ */ jsx8(Text8, { children: " " }),
+    isSelected ? /* @__PURE__ */ jsx8(Text8, { color: "white", bold: true, children: titleStr }) : /* @__PURE__ */ jsx8(Text8, { children: titleStr }),
+    /* @__PURE__ */ jsx8(Text8, { children: " " }),
+    /* @__PURE__ */ jsx8(Box8, { width: LABEL_COL_WIDTH, children: labels.map((l, i) => /* @__PURE__ */ jsxs8(Text8, { children: [
+      i > 0 ? " " : "",
+      /* @__PURE__ */ jsxs8(Text8, { color: labelColor(l.name), children: [
+        "[",
+        truncate(l.name, 12),
+        "]"
+      ] })
+    ] }, l.name)) }),
+    /* @__PURE__ */ jsx8(Text8, { children: " " }),
+    /* @__PURE__ */ jsx8(Text8, { color: assigneeColor, children: assigneeText.padEnd(14) }),
+    /* @__PURE__ */ jsx8(Text8, { children: " " }),
+    /* @__PURE__ */ jsx8(Text8, { color: "gray", children: timeAgo(issue.updatedAt).padStart(4) }),
+    target.text ? /* @__PURE__ */ jsxs8(Fragment2, { children: [
+      /* @__PURE__ */ jsx8(Text8, { children: " " }),
+      /* @__PURE__ */ jsx8(Text8, { color: target.color, children: target.text })
+    ] }) : null
+  ] });
+}
+var LABEL_COLORS, LABEL_COL_WIDTH;
+var init_issue_row = __esm({
+  "src/board/components/issue-row.tsx"() {
+    "use strict";
+    LABEL_COLORS = {
+      bug: "red",
+      enhancement: "green",
+      feature: "green",
+      documentation: "blue",
+      "good first issue": "magenta",
+      help: "yellow",
+      question: "yellow",
+      urgent: "red",
+      wontfix: "gray"
+    };
+    LABEL_COL_WIDTH = 30;
+  }
+});
+
+// src/board/components/search-bar.tsx
+import { TextInput as TextInput3 } from "@inkjs/ui";
+import { Box as Box9, Text as Text9 } from "ink";
+import { jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
+function SearchBar({ defaultValue, onChange, onSubmit }) {
+  return /* @__PURE__ */ jsxs9(Box9, { children: [
+    /* @__PURE__ */ jsx9(Text9, { color: "yellow", children: "/" }),
+    /* @__PURE__ */ jsx9(
+      TextInput3,
+      {
+        defaultValue,
+        placeholder: "search...",
+        onChange,
+        onSubmit
+      }
+    )
+  ] });
+}
+var init_search_bar = __esm({
+  "src/board/components/search-bar.tsx"() {
+    "use strict";
+  }
+});
+
+// src/board/components/status-picker.tsx
+import { Box as Box10, Text as Text10, useInput as useInput7 } from "ink";
+import { useState as useState8 } from "react";
+import { jsx as jsx10, jsxs as jsxs10 } from "react/jsx-runtime";
+function StatusPicker({ options, currentStatus, onSelect, onCancel }) {
+  const [selectedIdx, setSelectedIdx] = useState8(() => {
+    const idx = options.findIndex((o) => o.name === currentStatus);
+    return idx >= 0 ? idx : 0;
+  });
+  useInput7((input2, key) => {
+    if (key.escape) return onCancel();
+    if (key.return) {
+      const opt = options[selectedIdx];
+      if (opt) onSelect(opt.id);
+      return;
+    }
+    if (input2 === "j" || key.downArrow) {
+      setSelectedIdx((i) => Math.min(i + 1, options.length - 1));
+    }
+    if (input2 === "k" || key.upArrow) {
+      setSelectedIdx((i) => Math.max(i - 1, 0));
+    }
+  });
+  return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx10(Text10, { color: "cyan", bold: true, children: "Move to status:" }),
+    options.map((opt, i) => {
+      const isCurrent = opt.name === currentStatus;
+      const isSelected = i === selectedIdx;
+      const prefix = isSelected ? "> " : "  ";
+      const suffix = isCurrent ? " (current)" : "";
+      return /* @__PURE__ */ jsxs10(
+        Text10,
+        {
+          ...isSelected ? { color: "cyan" } : {},
+          dimColor: isCurrent,
+          children: [
+            prefix,
+            opt.name,
+            suffix
+          ]
+        },
+        opt.id
+      );
+    }),
+    /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: "j/k:navigate Enter:select Esc:cancel" })
+  ] });
+}
+var init_status_picker = __esm({
+  "src/board/components/status-picker.tsx"() {
+    "use strict";
+  }
+});
+
+// src/board/components/task-row.tsx
+import { Box as Box11, Text as Text11 } from "ink";
+import { jsx as jsx11, jsxs as jsxs11 } from "react/jsx-runtime";
+function truncate2(s, max) {
+  return s.length > max ? `${s.slice(0, max - 1)}\u2026` : s;
+}
+function formatDue(dateStr) {
+  if (!dateStr) return { text: "", color: "gray" };
+  const d = new Date(dateStr);
+  const days = Math.ceil((d.getTime() - Date.now()) / 864e5);
+  if (days < 0) return { text: `${Math.abs(days)}d overdue`, color: "red" };
+  if (days === 0) return { text: "today", color: "yellow" };
+  if (days === 1) return { text: "tomorrow", color: "white" };
+  if (days <= 7) return { text: `in ${days}d`, color: "white" };
+  return {
+    text: d.toLocaleDateString("en-US", { month: "short", day: "numeric" }),
+    color: "gray"
+  };
+}
+function TaskRow({ task: task2, isSelected }) {
+  const pri = PRIORITY_INDICATORS[task2.priority] ?? DEFAULT_PRIORITY;
+  const due = formatDue(task2.dueDate);
+  const titleStr = truncate2(task2.title, 45).padEnd(45);
+  return /* @__PURE__ */ jsxs11(Box11, { children: [
+    isSelected ? /* @__PURE__ */ jsx11(Text11, { color: "cyan", bold: true, children: "\u25B6 " }) : /* @__PURE__ */ jsx11(Text11, { children: "  " }),
+    /* @__PURE__ */ jsx11(Text11, { color: pri.color, children: pri.text }),
+    /* @__PURE__ */ jsx11(Text11, { children: " " }),
+    isSelected ? /* @__PURE__ */ jsx11(Text11, { color: "white", bold: true, children: titleStr }) : /* @__PURE__ */ jsx11(Text11, { children: titleStr }),
+    /* @__PURE__ */ jsx11(Text11, { children: " " }),
+    /* @__PURE__ */ jsx11(Text11, { color: due.color, children: due.text })
+  ] });
+}
+var PRIORITY_INDICATORS, DEFAULT_PRIORITY;
+var init_task_row = __esm({
+  "src/board/components/task-row.tsx"() {
+    "use strict";
+    init_types();
+    PRIORITY_INDICATORS = {
+      [5 /* High */]: { text: "[!]", color: "red" },
+      [3 /* Medium */]: { text: "[~]", color: "yellow" },
+      [1 /* Low */]: { text: "[\u2193]", color: "blue" },
+      [0 /* None */]: { text: "   ", color: "gray" }
+    };
+    DEFAULT_PRIORITY = { text: "   ", color: "gray" };
+  }
+});
+
+// src/board/components/toast-container.tsx
+import { Spinner } from "@inkjs/ui";
+import { Box as Box12, Text as Text12 } from "ink";
+import { Fragment as Fragment3, jsx as jsx12, jsxs as jsxs12 } from "react/jsx-runtime";
+function ToastContainer({ toasts }) {
+  if (toasts.length === 0) return null;
+  return /* @__PURE__ */ jsx12(Box12, { flexDirection: "column", children: toasts.map((t) => /* @__PURE__ */ jsx12(Box12, { children: t.type === "loading" ? /* @__PURE__ */ jsxs12(Fragment3, { children: [
+    /* @__PURE__ */ jsx12(Spinner, { label: "" }),
+    /* @__PURE__ */ jsxs12(Text12, { color: "cyan", children: [
+      " ",
+      t.message
+    ] })
+  ] }) : /* @__PURE__ */ jsxs12(Text12, { color: TYPE_COLORS[t.type], children: [
+    TYPE_PREFIXES[t.type],
+    " ",
+    t.message,
+    t.type === "error" ? /* @__PURE__ */ jsx12(Text12, { color: "gray", children: t.retry ? " [r]etry [d]ismiss" : " [d]ismiss" }) : null
+  ] }) }, t.id)) });
+}
+var TYPE_COLORS, TYPE_PREFIXES;
+var init_toast_container = __esm({
+  "src/board/components/toast-container.tsx"() {
+    "use strict";
+    TYPE_COLORS = {
+      info: "cyan",
+      success: "green",
+      error: "red",
+      loading: "cyan"
+    };
+    TYPE_PREFIXES = {
+      info: "\u2139",
+      success: "\u2713",
+      error: "\u2717"
+    };
+  }
+});
+
+// src/board/components/dashboard.tsx
+import { execFileSync as execFileSync3 } from "child_process";
+import { Spinner as Spinner2 } from "@inkjs/ui";
+import { Box as Box13, Text as Text13, useApp, useInput as useInput8, useStdout } from "ink";
+import { useCallback as useCallback8, useEffect as useEffect3, useMemo as useMemo2, useRef as useRef7, useState as useState9 } from "react";
+import { Fragment as Fragment4, jsx as jsx13, jsxs as jsxs13 } from "react/jsx-runtime";
+function isTerminalStatus(status) {
+  return TERMINAL_STATUS_RE2.test(status);
+}
+function resolveStatusGroups(statusOptions, configuredGroups) {
+  if (configuredGroups && configuredGroups.length > 0) {
+    return configuredGroups.map((entry) => {
+      const statuses = entry.split(",").map((s) => s.trim()).filter(Boolean);
+      return { label: statuses[0] ?? entry, statuses };
+    });
+  }
+  const nonTerminal = statusOptions.map((o) => o.name).filter((s) => !isTerminalStatus(s));
+  if (nonTerminal.length > 0 && !nonTerminal.includes("Backlog")) {
+    nonTerminal.push("Backlog");
+  }
+  const order = nonTerminal.length > 0 ? nonTerminal : ["In Progress", "Backlog"];
+  return order.map((s) => ({ label: s, statuses: [s] }));
+}
+function issuePriorityRank(issue) {
+  for (const label of issue.labels ?? []) {
+    const rank = PRIORITY_RANK[label.name.toLowerCase()];
+    if (rank != null) return rank;
+  }
+  return 99;
+}
+function groupByStatus(issues) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    const status = issue.projectStatus ?? "Backlog";
+    const list = groups.get(status);
+    if (list) {
+      list.push(issue);
+    } else {
+      groups.set(status, [issue]);
+    }
+  }
+  for (const [, list] of groups) {
+    list.sort((a, b) => issuePriorityRank(a) - issuePriorityRank(b));
+  }
+  return groups;
+}
+function collectGroupIssues(statusGroup, byStatus) {
+  const issues = [];
+  for (const status of statusGroup.statuses) {
+    const list = byStatus.get(status);
+    if (list) issues.push(...list);
+  }
+  issues.sort((a, b) => issuePriorityRank(a) - issuePriorityRank(b));
+  return issues;
+}
+function buildNavItems(repos, tasks, activityCount) {
+  const items = [];
+  if (activityCount > 0) {
+    items.push({ id: "header:activity", section: "activity", type: "header" });
+  }
+  for (const rd of repos) {
+    items.push({ id: `header:${rd.repo.shortName}`, section: rd.repo.shortName, type: "header" });
+    const statusGroupDefs = resolveStatusGroups(rd.statusOptions, rd.repo.statusGroups);
+    const byStatus = groupByStatus(rd.issues);
+    const coveredStatuses = /* @__PURE__ */ new Set();
+    for (const sg of statusGroupDefs) {
+      const groupIssues = collectGroupIssues(sg, byStatus);
+      if (groupIssues.length === 0) continue;
+      const subId = `sub:${rd.repo.shortName}:${sg.label}`;
+      items.push({ id: subId, section: rd.repo.shortName, type: "subHeader" });
+      for (const issue of groupIssues) {
+        items.push({
+          id: `gh:${rd.repo.name}:${issue.number}`,
+          section: rd.repo.shortName,
+          type: "item",
+          subSection: subId
+        });
+      }
+      for (const s of sg.statuses) coveredStatuses.add(s);
+    }
+    for (const [status, issues] of byStatus) {
+      if (!(coveredStatuses.has(status) || isTerminalStatus(status)) && issues.length > 0) {
+        const subId = `sub:${rd.repo.shortName}:${status}`;
+        items.push({ id: subId, section: rd.repo.shortName, type: "subHeader" });
+        for (const issue of issues) {
+          items.push({
+            id: `gh:${rd.repo.name}:${issue.number}`,
+            section: rd.repo.shortName,
+            type: "item",
+            subSection: subId
+          });
+        }
+      }
+    }
+  }
+  if (tasks.length > 0) {
+    items.push({ id: "header:ticktick", section: "ticktick", type: "header" });
+    for (const task2 of tasks) {
+      items.push({ id: `tt:${task2.id}`, section: "ticktick", type: "item" });
+    }
+  }
+  return items;
+}
+function buildFlatRows(repos, tasks, activity, isCollapsed) {
+  const rows = [];
+  if (activity.length > 0) {
+    const collapsed = isCollapsed("activity");
+    rows.push({
+      type: "sectionHeader",
+      key: "header:activity",
+      navId: "header:activity",
+      label: "Recent Activity (24h)",
+      count: activity.length,
+      countLabel: "events",
+      isCollapsed: collapsed
+    });
+    if (!collapsed) {
+      for (const [i, event] of activity.entries()) {
+        rows.push({ type: "activity", key: `act:${i}`, navId: null, event });
+      }
+    }
+  }
+  for (const rd of repos) {
+    const { repo, issues, error: repoError } = rd;
+    const collapsed = isCollapsed(repo.shortName);
+    rows.push({
+      type: "sectionHeader",
+      key: `header:${repo.shortName}`,
+      navId: `header:${repo.shortName}`,
+      label: repo.shortName,
+      count: issues.length,
+      countLabel: "issues",
+      isCollapsed: collapsed
+    });
+    if (!collapsed) {
+      if (repoError) {
+        rows.push({ type: "error", key: `error:${repo.shortName}`, navId: null, text: repoError });
+      } else if (issues.length === 0) {
+        rows.push({
+          type: "subHeader",
+          key: `empty:${repo.shortName}`,
+          navId: null,
+          text: "No open issues"
+        });
+      } else {
+        const statusGroupDefs = resolveStatusGroups(rd.statusOptions, rd.repo.statusGroups);
+        const byStatus = groupByStatus(issues);
+        const coveredStatuses = /* @__PURE__ */ new Set();
+        let isFirstGroup = true;
+        for (const sg of statusGroupDefs) {
+          const groupIssues = collectGroupIssues(sg, byStatus);
+          if (groupIssues.length === 0) continue;
+          if (!isFirstGroup) {
+            rows.push({ type: "gap", key: `gap:${repo.shortName}:${sg.label}`, navId: null });
+          }
+          isFirstGroup = false;
+          const subId = `sub:${repo.shortName}:${sg.label}`;
+          const subCollapsed = isCollapsed(subId);
+          rows.push({
+            type: "subHeader",
+            key: subId,
+            navId: subId,
+            text: sg.label,
+            count: groupIssues.length,
+            isCollapsed: subCollapsed
+          });
+          if (!subCollapsed) {
+            for (const issue of groupIssues) {
+              rows.push({
+                type: "issue",
+                key: `gh:${repo.name}:${issue.number}`,
+                navId: `gh:${repo.name}:${issue.number}`,
+                issue,
+                repoName: repo.name
+              });
+            }
+          }
+          for (const s of sg.statuses) coveredStatuses.add(s);
+        }
+        for (const [status, groupIssues] of byStatus) {
+          if (!(coveredStatuses.has(status) || isTerminalStatus(status)) && groupIssues.length > 0) {
+            if (!isFirstGroup) {
+              rows.push({ type: "gap", key: `gap:${repo.shortName}:${status}`, navId: null });
+            }
+            isFirstGroup = false;
+            const subId = `sub:${repo.shortName}:${status}`;
+            const subCollapsed = isCollapsed(subId);
+            rows.push({
+              type: "subHeader",
+              key: subId,
+              navId: subId,
+              text: status,
+              count: groupIssues.length,
+              isCollapsed: subCollapsed
+            });
+            if (!subCollapsed) {
+              for (const issue of groupIssues) {
+                rows.push({
+                  type: "issue",
+                  key: `gh:${repo.name}:${issue.number}`,
+                  navId: `gh:${repo.name}:${issue.number}`,
+                  issue,
+                  repoName: repo.name
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if (tasks.length > 0) {
+    const collapsed = isCollapsed("ticktick");
+    rows.push({
+      type: "sectionHeader",
+      key: "header:ticktick",
+      navId: "header:ticktick",
+      label: "Personal (TickTick)",
+      count: tasks.length,
+      countLabel: "tasks",
+      isCollapsed: collapsed
+    });
+    if (!collapsed) {
+      for (const task2 of tasks) {
+        rows.push({ type: "task", key: `tt:${task2.id}`, navId: `tt:${task2.id}`, task: task2 });
+      }
+    }
+  }
+  return rows;
+}
+function timeAgo2(date) {
+  const seconds = Math.floor((Date.now() - date.getTime()) / 1e3);
+  if (seconds < 10) return "just now";
+  if (seconds < 60) return `${seconds}s ago`;
+  const minutes = Math.floor(seconds / 60);
+  return `${minutes}m ago`;
+}
+function openInBrowser(url) {
+  try {
+    execFileSync3("open", [url], { stdio: "ignore" });
+  } catch {
+  }
+}
+function findSelectedUrl(repos, selectedId) {
+  if (!selectedId?.startsWith("gh:")) return null;
+  for (const rd of repos) {
+    for (const issue of rd.issues) {
+      if (`gh:${rd.repo.name}:${issue.number}` === selectedId) return issue.url;
+    }
+  }
+  return null;
+}
+function findSelectedIssueWithRepo(repos, selectedId) {
+  if (!selectedId?.startsWith("gh:")) return null;
+  for (const rd of repos) {
+    for (const issue of rd.issues) {
+      if (`gh:${rd.repo.name}:${issue.number}` === selectedId)
+        return { issue, repoName: rd.repo.name };
+    }
+  }
+  return null;
+}
+function isHeaderId(id) {
+  return id != null && (id.startsWith("header:") || id.startsWith("sub:"));
+}
+function RowRenderer({ row, selectedId, selfLogin, isMultiSelected }) {
+  switch (row.type) {
+    case "sectionHeader": {
+      const arrow = row.isCollapsed ? "\u25B6" : "\u25BC";
+      const isSel = selectedId === row.navId;
+      return /* @__PURE__ */ jsxs13(Box13, { children: [
+        /* @__PURE__ */ jsxs13(Text13, { color: isSel ? "cyan" : "white", bold: true, children: [
+          arrow,
+          " ",
+          row.label
+        ] }),
+        /* @__PURE__ */ jsxs13(Text13, { color: "gray", children: [
+          " ",
+          "(",
+          row.count,
+          " ",
+          row.countLabel,
+          ")"
+        ] })
+      ] });
+    }
+    case "subHeader": {
+      if (row.navId) {
+        const arrow = row.isCollapsed ? "\u25B6" : "\u25BC";
+        const isSel = selectedId === row.navId;
+        return /* @__PURE__ */ jsxs13(Box13, { children: [
+          /* @__PURE__ */ jsxs13(Text13, { color: isSel ? "cyan" : "gray", children: [
+            "  ",
+            arrow,
+            " ",
+            row.text
+          ] }),
+          /* @__PURE__ */ jsxs13(Text13, { color: "gray", children: [
+            " (",
+            row.count,
+            ")"
+          ] })
+        ] });
+      }
+      return /* @__PURE__ */ jsxs13(Text13, { color: "gray", children: [
+        " ",
+        row.text
+      ] });
+    }
+    case "issue": {
+      const checkbox2 = isMultiSelected != null ? isMultiSelected ? "\u2611 " : "\u2610 " : "";
+      return /* @__PURE__ */ jsxs13(Box13, { children: [
+        checkbox2 ? /* @__PURE__ */ jsx13(Text13, { color: isMultiSelected ? "cyan" : "gray", children: checkbox2 }) : null,
+        /* @__PURE__ */ jsx13(IssueRow, { issue: row.issue, selfLogin, isSelected: selectedId === row.navId })
+      ] });
+    }
+    case "task": {
+      const checkbox2 = isMultiSelected != null ? isMultiSelected ? "\u2611 " : "\u2610 " : "";
+      return /* @__PURE__ */ jsxs13(Box13, { children: [
+        checkbox2 ? /* @__PURE__ */ jsx13(Text13, { color: isMultiSelected ? "cyan" : "gray", children: checkbox2 }) : null,
+        /* @__PURE__ */ jsx13(TaskRow, { task: row.task, isSelected: selectedId === row.navId })
+      ] });
+    }
+    case "activity": {
+      const ago = timeAgo2(row.event.timestamp);
+      return /* @__PURE__ */ jsxs13(Text13, { dimColor: true, children: [
+        "  ",
+        ago,
+        ": ",
+        /* @__PURE__ */ jsxs13(Text13, { color: "gray", children: [
+          "@",
+          row.event.actor
+        ] }),
+        " ",
+        row.event.summary,
+        " ",
+        /* @__PURE__ */ jsxs13(Text13, { dimColor: true, children: [
+          "(",
+          row.event.repoShortName,
+          ")"
+        ] })
+      ] });
+    }
+    case "error":
+      return /* @__PURE__ */ jsxs13(Text13, { color: "red", children: [
+        " Error: ",
+        row.text
+      ] });
+    case "gap":
+      return /* @__PURE__ */ jsx13(Text13, { children: "" });
+  }
+}
+function Dashboard({ config: config2, options, activeProfile }) {
+  const { exit } = useApp();
+  const refreshMs = config2.board.refreshInterval * 1e3;
+  const {
+    status,
+    data,
+    error,
+    lastRefresh,
+    isRefreshing,
+    consecutiveFailures,
+    autoRefreshPaused,
+    refresh,
+    mutateData
+  } = useData(config2, options, refreshMs);
+  const allRepos = useMemo2(() => data?.repos ?? [], [data?.repos]);
+  const allTasks = useMemo2(
+    () => config2.ticktick.enabled ? data?.ticktick ?? [] : [],
+    [data?.ticktick, config2.ticktick.enabled]
+  );
+  const allActivity = useMemo2(() => data?.activity ?? [], [data?.activity]);
+  const ui = useUIState();
+  const [searchQuery, setSearchQuery] = useState9("");
+  const { toasts, toast, handleErrorAction } = useToast();
+  const [, setTick] = useState9(0);
+  useEffect3(() => {
+    const id = setInterval(() => setTick((t) => t + 1), 1e4);
+    return () => clearInterval(id);
+  }, []);
+  const repos = useMemo2(() => {
+    if (!searchQuery) return allRepos;
+    const q = searchQuery.toLowerCase();
+    return allRepos.map((rd) => ({ ...rd, issues: rd.issues.filter((i) => i.title.toLowerCase().includes(q)) })).filter((rd) => rd.issues.length > 0);
+  }, [allRepos, searchQuery]);
+  const tasks = useMemo2(() => {
+    if (!searchQuery) return allTasks;
+    const q = searchQuery.toLowerCase();
+    return allTasks.filter((t) => t.title.toLowerCase().includes(q));
+  }, [allTasks, searchQuery]);
+  const navItems = useMemo2(
+    () => buildNavItems(repos, tasks, allActivity.length),
+    [repos, tasks, allActivity.length]
+  );
+  const nav = useNavigation(navItems);
+  const getRepoForId = useCallback8((id) => {
+    if (id.startsWith("gh:")) {
+      const parts = id.split(":");
+      return parts.length >= 3 ? `${parts[1]}` : null;
+    }
+    if (id.startsWith("tt:")) return "ticktick";
+    return null;
+  }, []);
+  const multiSelect = useMultiSelect(getRepoForId);
+  useEffect3(() => {
+    if (multiSelect.count === 0) return;
+    const validIds = new Set(navItems.map((i) => i.id));
+    multiSelect.prune(validIds);
+  }, [navItems, multiSelect]);
+  const actions = useActions({
+    config: config2,
+    repos,
+    selectedId: nav.selectedId,
+    toast,
+    refresh,
+    mutateData,
+    onOverlayDone: ui.exitOverlay
+  });
+  const pendingPickRef = useRef7(null);
+  const handleCreateIssueWithPrompt = useCallback8(
+    (repo, title, labels) => {
+      actions.handleCreateIssue(repo, title, labels).then((result) => {
+        if (result) {
+          pendingPickRef.current = result;
+          ui.enterConfirmPick();
+        }
+      });
+    },
+    [actions, ui]
+  );
+  const handleConfirmPick = useCallback8(() => {
+    const pending = pendingPickRef.current;
+    pendingPickRef.current = null;
+    ui.exitOverlay();
+    if (!pending) return;
+    const rc = config2.repos.find((r) => r.name === pending.repo);
+    if (!rc) return;
+    const t = toast.loading(`Picking ${rc.shortName}#${pending.issueNumber}...`);
+    Promise.resolve().then(() => (init_pick(), pick_exports)).then(
+      ({ pickIssue: pickIssue2 }) => pickIssue2(config2, { repo: rc, issueNumber: pending.issueNumber }).then((result) => {
+        const msg = `Picked ${rc.shortName}#${pending.issueNumber} \u2014 assigned + synced to TickTick`;
+        t.resolve(result.warning ? `${msg} (${result.warning})` : msg);
+        refresh();
+      }).catch((err) => {
+        t.reject(`Pick failed: ${err instanceof Error ? err.message : String(err)}`);
+      })
+    );
+  }, [config2, toast, refresh, ui]);
+  const handleCancelPick = useCallback8(() => {
+    pendingPickRef.current = null;
+    ui.exitOverlay();
+  }, [ui]);
+  const [focusLabel, setFocusLabel] = useState9(null);
+  const handleEnterFocus = useCallback8(() => {
+    const id = nav.selectedId;
+    if (!id || isHeaderId(id)) return;
+    let label = "";
+    if (id.startsWith("gh:")) {
+      const found = findSelectedIssueWithRepo(repos, id);
+      if (found) {
+        const rc = config2.repos.find((r) => r.name === found.repoName);
+        label = `${rc?.shortName ?? found.repoName}#${found.issue.number} \u2014 ${found.issue.title}`;
+      }
+    } else if (id.startsWith("tt:")) {
+      const taskId = id.slice(3);
+      const task2 = tasks.find((t) => t.id === taskId);
+      if (task2) label = task2.title;
+    }
+    if (!label) return;
+    setFocusLabel(label);
+    ui.enterFocus();
+  }, [nav.selectedId, repos, tasks, config2.repos, ui]);
+  const handleFocusExit = useCallback8(() => {
+    setFocusLabel(null);
+    ui.exitToNormal();
+  }, [ui]);
+  const handleFocusEndAction = useCallback8(
+    (action) => {
+      switch (action) {
+        case "restart":
+          toast.info("Focus restarted!");
+          setFocusLabel((prev) => prev);
+          setFocusKey((k) => k + 1);
+          break;
+        case "break":
+          toast.info("Break time! Step away for a few minutes.");
+          setFocusLabel(null);
+          ui.exitToNormal();
+          break;
+        case "done":
+          toast.success("Focus session complete!");
+          setFocusLabel(null);
+          ui.exitToNormal();
+          break;
+        case "exit":
+          setFocusLabel(null);
+          ui.exitToNormal();
+          break;
+      }
+    },
+    [toast, ui]
+  );
+  const [focusKey, setFocusKey] = useState9(0);
+  const { stdout } = useStdout();
+  const [termSize, setTermSize] = useState9({
+    cols: stdout?.columns ?? 80,
+    rows: stdout?.rows ?? 24
+  });
+  useEffect3(() => {
+    if (!stdout) return;
+    const onResize = () => setTermSize({ cols: stdout.columns, rows: stdout.rows });
+    stdout.on("resize", onResize);
+    return () => {
+      stdout.off("resize", onResize);
+    };
+  }, [stdout]);
+  const showDetailPanel = termSize.cols >= 120;
+  const detailPanelWidth = showDetailPanel ? Math.floor(termSize.cols * 0.35) : 0;
+  const overlayBarRows = ui.state.mode === "search" || ui.state.mode === "overlay:comment" ? 1 : 0;
+  const toastRows = toasts.length;
+  const viewportHeight = Math.max(5, termSize.rows - CHROME_ROWS - overlayBarRows - toastRows);
+  const flatRows = useMemo2(
+    () => buildFlatRows(repos, tasks, allActivity, nav.isCollapsed),
+    [repos, tasks, allActivity, nav.isCollapsed]
+  );
+  const scrollRef = useRef7(0);
+  const selectedRowIdx = flatRows.findIndex((r) => r.navId === nav.selectedId);
+  if (selectedRowIdx >= 0) {
+    if (selectedRowIdx < scrollRef.current) {
+      scrollRef.current = selectedRowIdx;
+    } else if (selectedRowIdx >= scrollRef.current + viewportHeight) {
+      scrollRef.current = selectedRowIdx - viewportHeight + 1;
+    }
+  }
+  const maxOffset = Math.max(0, flatRows.length - viewportHeight);
+  scrollRef.current = Math.max(0, Math.min(scrollRef.current, maxOffset));
+  const visibleRows = flatRows.slice(scrollRef.current, scrollRef.current + viewportHeight);
+  const hasMoreAbove = scrollRef.current > 0;
+  const hasMoreBelow = scrollRef.current + viewportHeight < flatRows.length;
+  const aboveCount = scrollRef.current;
+  const belowCount = flatRows.length - scrollRef.current - viewportHeight;
+  const selectedItem = useMemo2(() => {
+    const id = nav.selectedId;
+    if (!id || isHeaderId(id)) return { issue: null, task: null, repoName: null };
+    if (id.startsWith("gh:")) {
+      for (const rd of repos) {
+        for (const issue of rd.issues) {
+          if (`gh:${rd.repo.name}:${issue.number}` === id)
+            return { issue, task: null, repoName: rd.repo.name };
+        }
+      }
+    }
+    if (id.startsWith("tt:")) {
+      const taskId = id.slice(3);
+      const task2 = tasks.find((t) => t.id === taskId);
+      if (task2) return { issue: null, task: task2, repoName: null };
+    }
+    return { issue: null, task: null, repoName: null };
+  }, [nav.selectedId, repos, tasks]);
+  const selectedRepoStatusOptions = useMemo2(() => {
+    const repoName = multiSelect.count > 0 ? multiSelect.constrainedRepo : selectedItem.repoName;
+    if (!repoName || repoName === "ticktick") return [];
+    const rd = repos.find((r) => r.repo.name === repoName);
+    return rd?.statusOptions.filter((o) => !isTerminalStatus(o.name)) ?? [];
+  }, [selectedItem.repoName, repos, multiSelect.count, multiSelect.constrainedRepo]);
+  const handleOpen = useCallback8(() => {
+    const url = findSelectedUrl(repos, nav.selectedId);
+    if (url) openInBrowser(url);
+  }, [repos, nav.selectedId]);
+  const handleSlack = useCallback8(() => {
+    const found = findSelectedIssueWithRepo(repos, nav.selectedId);
+    if (!found?.issue.slackThreadUrl) return;
+    openInBrowser(found.issue.slackThreadUrl);
+  }, [repos, nav.selectedId]);
+  const multiSelectType = useMemo2(() => {
+    let hasGh = false;
+    let hasTt = false;
+    for (const id of multiSelect.selected) {
+      if (id.startsWith("gh:")) hasGh = true;
+      if (id.startsWith("tt:")) hasTt = true;
+    }
+    if (hasGh && hasTt) return "mixed";
+    if (hasTt) return "ticktick";
+    return "github";
+  }, [multiSelect.selected]);
+  const handleBulkAction = useCallback8(
+    (action) => {
+      const ids = multiSelect.selected;
+      switch (action.type) {
+        case "assign": {
+          ui.exitOverlay();
+          actions.handleBulkAssign(ids).then((failedIds) => {
+            if (failedIds.length > 0) {
+              multiSelect.clear();
+              for (const id of failedIds) multiSelect.toggle(id);
+            } else {
+              multiSelect.clear();
+              ui.clearMultiSelect();
+            }
+          });
+          return;
+        }
+        case "unassign": {
+          ui.exitOverlay();
+          actions.handleBulkUnassign(ids).then((failedIds) => {
+            if (failedIds.length > 0) {
+              multiSelect.clear();
+              for (const id of failedIds) multiSelect.toggle(id);
+            } else {
+              multiSelect.clear();
+              ui.clearMultiSelect();
+            }
+          });
+          return;
+        }
+        case "statusChange":
+          ui.enterStatus();
+          return;
+        // status picker will call handleBulkStatusSelect on select
+        case "complete":
+        case "delete":
+          toast.info(`Bulk ${action.type} not yet implemented for TickTick`);
+          ui.exitOverlay();
+          multiSelect.clear();
+          return;
+      }
+    },
+    [multiSelect, actions, ui, toast]
+  );
+  const handleBulkStatusSelect = useCallback8(
+    (optionId) => {
+      const ids = multiSelect.selected;
+      ui.exitOverlay();
+      actions.handleBulkStatusChange(ids, optionId).then((failedIds) => {
+        if (failedIds.length > 0) {
+          multiSelect.clear();
+          for (const id of failedIds) multiSelect.toggle(id);
+        } else {
+          multiSelect.clear();
+          ui.clearMultiSelect();
+        }
+      });
+    },
+    [multiSelect, actions, ui]
+  );
+  const handleInput = useCallback8(
+    (input2, key) => {
+      if (input2 === "?") {
+        ui.toggleHelp();
+        return;
+      }
+      if (key.escape && ui.state.mode !== "focus") {
+        if (ui.state.mode === "multiSelect") {
+          multiSelect.clear();
+        }
+        ui.exitOverlay();
+        return;
+      }
+      if (ui.canNavigate) {
+        if (input2 === "j" || key.downArrow) {
+          nav.moveDown();
+          return;
+        }
+        if (input2 === "k" || key.upArrow) {
+          nav.moveUp();
+          return;
+        }
+        if (key.tab) {
+          if (ui.state.mode === "multiSelect") {
+            multiSelect.clear();
+            ui.clearMultiSelect();
+          }
+          key.shift ? nav.prevSection() : nav.nextSection();
+          return;
+        }
+      }
+      if (ui.state.mode === "multiSelect") {
+        if (input2 === " ") {
+          const id = nav.selectedId;
+          if (id && !isHeaderId(id)) {
+            multiSelect.toggle(id);
+          }
+          return;
+        }
+        if (key.return) {
+          if (multiSelect.count > 0) {
+            ui.enterBulkAction();
+          }
+          return;
+        }
+        if (input2 === "m" && multiSelect.count > 0) {
+          ui.enterBulkAction();
+          return;
+        }
+        return;
+      }
+      if (input2 === "d") {
+        if (handleErrorAction("dismiss")) return;
+      }
+      if (input2 === "r" && handleErrorAction("retry")) return;
+      if (ui.canAct) {
+        if (input2 === "/") {
+          multiSelect.clear();
+          ui.enterSearch();
+          return;
+        }
+        if (input2 === "q") {
+          exit();
+          return;
+        }
+        if (input2 === "r" || input2 === "R") {
+          multiSelect.clear();
+          refresh();
+          return;
+        }
+        if (input2 === "s") {
+          handleSlack();
+          return;
+        }
+        if (input2 === "p") {
+          actions.handlePick();
+          return;
+        }
+        if (input2 === "a") {
+          actions.handleAssign();
+          return;
+        }
+        if (input2 === "u") {
+          actions.handleUnassign();
+          return;
+        }
+        if (input2 === "c") {
+          if (selectedItem.issue) {
+            multiSelect.clear();
+            ui.enterComment();
+          }
+          return;
+        }
+        if (input2 === "m") {
+          if (selectedItem.issue && selectedRepoStatusOptions.length > 0) {
+            multiSelect.clear();
+            ui.enterStatus();
+          } else if (selectedItem.issue) {
+            toast.info("Issue not in a project board");
+          }
+          return;
+        }
+        if (input2 === "n") {
+          multiSelect.clear();
+          ui.enterCreate();
+          return;
+        }
+        if (input2 === "f") {
+          handleEnterFocus();
+          return;
+        }
+        if (input2 === " ") {
+          const id = nav.selectedId;
+          if (id && !isHeaderId(id)) {
+            multiSelect.toggle(id);
+            ui.enterMultiSelect();
+          } else if (isHeaderId(nav.selectedId)) {
+            nav.toggleSection();
+          }
+          return;
+        }
+        if (key.return) {
+          if (isHeaderId(nav.selectedId)) {
+            nav.toggleSection();
+            return;
+          }
+          handleOpen();
+          return;
+        }
+      }
+    },
+    [
+      ui,
+      nav,
+      exit,
+      refresh,
+      handleSlack,
+      handleOpen,
+      actions,
+      selectedItem.issue,
+      selectedRepoStatusOptions.length,
+      toast,
+      nav.selectedId,
+      multiSelect,
+      handleEnterFocus,
+      handleErrorAction
+    ]
+  );
+  const inputActive = ui.state.mode === "normal" || ui.state.mode === "multiSelect" || ui.state.mode === "focus";
+  useInput8(handleInput, { isActive: inputActive });
+  const handleSearchEscape = useCallback8(
+    (_input, key) => {
+      if (key.escape) {
+        ui.exitOverlay();
+        setSearchQuery("");
+      }
+    },
+    [ui]
+  );
+  useInput8(handleSearchEscape, { isActive: ui.state.mode === "search" });
+  if (status === "loading" && !data) {
+    return /* @__PURE__ */ jsx13(Box13, { flexDirection: "column", padding: 1, children: /* @__PURE__ */ jsx13(Spinner2, { label: "Loading dashboard..." }) });
+  }
+  const now = data?.fetchedAt ?? /* @__PURE__ */ new Date();
+  const dateStr = now.toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric"
+  });
+  return /* @__PURE__ */ jsxs13(Box13, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs13(Box13, { children: [
+      /* @__PURE__ */ jsx13(Text13, { color: "cyan", bold: true, children: "HOG BOARD" }),
+      activeProfile ? /* @__PURE__ */ jsxs13(Text13, { color: "yellow", children: [
+        " [",
+        activeProfile,
+        "]"
+      ] }) : null,
+      /* @__PURE__ */ jsxs13(Text13, { color: "gray", children: [
+        " ",
+        "\u2014",
+        " ",
+        dateStr
+      ] }),
+      /* @__PURE__ */ jsx13(Text13, { children: " " }),
+      isRefreshing ? /* @__PURE__ */ jsxs13(Fragment4, { children: [
+        /* @__PURE__ */ jsx13(Spinner2, { label: "" }),
+        /* @__PURE__ */ jsx13(Text13, { color: "cyan", children: " Refreshing..." })
+      ] }) : lastRefresh ? /* @__PURE__ */ jsxs13(Fragment4, { children: [
+        /* @__PURE__ */ jsxs13(Text13, { color: refreshAgeColor(lastRefresh), children: [
+          "Updated ",
+          timeAgo2(lastRefresh)
+        ] }),
+        consecutiveFailures > 0 ? /* @__PURE__ */ jsx13(Text13, { color: "red", children: " (!)" }) : null
+      ] }) : null,
+      autoRefreshPaused ? /* @__PURE__ */ jsx13(Text13, { color: "yellow", children: " Auto-refresh paused \u2014 press r to retry" }) : null
+    ] }),
+    error ? /* @__PURE__ */ jsxs13(Text13, { color: "red", children: [
+      "Error: ",
+      error
+    ] }) : null,
+    ui.state.helpVisible ? /* @__PURE__ */ jsx13(HelpOverlay, { currentMode: ui.state.mode, onClose: ui.toggleHelp }) : null,
+    ui.state.mode === "overlay:status" && selectedRepoStatusOptions.length > 0 ? /* @__PURE__ */ jsx13(
+      StatusPicker,
+      {
+        options: selectedRepoStatusOptions,
+        currentStatus: multiSelect.count > 0 ? void 0 : selectedItem.issue?.projectStatus,
+        onSelect: multiSelect.count > 0 ? handleBulkStatusSelect : actions.handleStatusChange,
+        onCancel: ui.exitOverlay
+      }
+    ) : null,
+    ui.state.mode === "overlay:create" ? /* @__PURE__ */ jsx13(
+      CreateIssueForm,
+      {
+        repos: config2.repos,
+        defaultRepo: selectedItem.repoName,
+        onSubmit: handleCreateIssueWithPrompt,
+        onCancel: ui.exitOverlay
+      }
+    ) : null,
+    ui.state.mode === "overlay:confirmPick" ? /* @__PURE__ */ jsx13(
+      ConfirmPrompt,
+      {
+        message: "Pick this issue?",
+        onConfirm: handleConfirmPick,
+        onCancel: handleCancelPick
+      }
+    ) : null,
+    ui.state.mode === "overlay:bulkAction" ? /* @__PURE__ */ jsx13(
+      BulkActionMenu,
+      {
+        count: multiSelect.count,
+        selectionType: multiSelectType,
+        onSelect: handleBulkAction,
+        onCancel: ui.exitOverlay
+      }
+    ) : null,
+    ui.state.mode === "focus" && focusLabel ? /* @__PURE__ */ jsx13(
+      FocusMode,
+      {
+        label: focusLabel,
+        durationSec: config2.board.focusDuration ?? 1500,
+        onExit: handleFocusExit,
+        onEndAction: handleFocusEndAction
+      },
+      focusKey
+    ) : null,
+    !ui.state.helpVisible && ui.state.mode !== "overlay:status" && ui.state.mode !== "overlay:create" && ui.state.mode !== "overlay:bulkAction" && ui.state.mode !== "overlay:confirmPick" && ui.state.mode !== "focus" ? /* @__PURE__ */ jsxs13(Box13, { height: viewportHeight, children: [
+      /* @__PURE__ */ jsxs13(Box13, { flexDirection: "column", flexGrow: 1, children: [
+        hasMoreAbove ? /* @__PURE__ */ jsxs13(Text13, { color: "gray", dimColor: true, children: [
+          " ",
+          "\u25B2",
+          " ",
+          aboveCount,
+          " more above"
+        ] }) : null,
+        visibleRows.map((row) => /* @__PURE__ */ jsx13(
+          RowRenderer,
+          {
+            row,
+            selectedId: nav.selectedId,
+            selfLogin: config2.board.assignee,
+            isMultiSelected: ui.state.mode === "multiSelect" && row.navId ? multiSelect.isSelected(row.navId) : void 0
+          },
+          row.key
+        )),
+        hasMoreBelow ? /* @__PURE__ */ jsxs13(Text13, { color: "gray", dimColor: true, children: [
+          " ",
+          "\u25BC",
+          " ",
+          belowCount,
+          " more below"
+        ] }) : null
+      ] }),
+      showDetailPanel ? /* @__PURE__ */ jsx13(Box13, { marginLeft: 1, width: detailPanelWidth, children: /* @__PURE__ */ jsx13(
+        DetailPanel,
+        {
+          issue: selectedItem.issue,
+          task: selectedItem.task,
+          width: detailPanelWidth
+        }
+      ) }) : null
+    ] }) : null,
+    ui.state.mode === "search" ? /* @__PURE__ */ jsx13(SearchBar, { defaultValue: searchQuery, onChange: setSearchQuery, onSubmit: ui.exitOverlay }) : null,
+    ui.state.mode === "overlay:comment" && selectedItem.issue ? /* @__PURE__ */ jsx13(
+      CommentInput,
+      {
+        issueNumber: selectedItem.issue.number,
+        onSubmit: actions.handleComment,
+        onCancel: ui.exitOverlay
+      }
+    ) : null,
+    /* @__PURE__ */ jsx13(ToastContainer, { toasts }),
+    /* @__PURE__ */ jsx13(Box13, { children: ui.state.mode === "multiSelect" ? /* @__PURE__ */ jsxs13(Fragment4, { children: [
+      /* @__PURE__ */ jsxs13(Text13, { color: "cyan", bold: true, children: [
+        multiSelect.count,
+        " selected"
+      ] }),
+      /* @__PURE__ */ jsx13(Text13, { color: "gray", children: " Space:toggle Enter:actions Esc:cancel" })
+    ] }) : ui.state.mode === "focus" ? /* @__PURE__ */ jsx13(Text13, { color: "magenta", bold: true, children: "Focus mode \u2014 Esc to exit" }) : /* @__PURE__ */ jsxs13(Fragment4, { children: [
+      /* @__PURE__ */ jsx13(Text13, { color: "gray", children: "j/k:nav Tab:section Enter:open Space:select /:search p:pick c:comment m:status a/u:assign s:slack n:new f:focus ?:help q:quit" }),
+      searchQuery && ui.state.mode !== "search" ? /* @__PURE__ */ jsxs13(Text13, { color: "yellow", children: [
+        ' filter: "',
+        searchQuery,
+        '"'
+      ] }) : null
+    ] }) })
+  ] });
+}
+var TERMINAL_STATUS_RE2, PRIORITY_RANK, CHROME_ROWS;
+var init_dashboard = __esm({
+  "src/board/components/dashboard.tsx"() {
+    "use strict";
+    init_use_actions();
+    init_use_data();
+    init_use_multi_select();
+    init_use_navigation();
+    init_use_toast();
+    init_use_ui_state();
+    init_bulk_action_menu();
+    init_comment_input();
+    init_confirm_prompt();
+    init_create_issue_form();
+    init_detail_panel();
+    init_focus_mode();
+    init_help_overlay();
+    init_issue_row();
+    init_search_bar();
+    init_status_picker();
+    init_task_row();
+    init_toast_container();
+    TERMINAL_STATUS_RE2 = /^(done|shipped|won't|wont|closed|complete|completed)$/i;
+    PRIORITY_RANK = {
+      "priority:critical": 0,
+      "priority:high": 1,
+      "priority:medium": 2,
+      "priority:low": 3
+    };
+    CHROME_ROWS = 4;
+  }
+});
+
+// src/board/live.tsx
+var live_exports = {};
+__export(live_exports, {
+  runLiveDashboard: () => runLiveDashboard
+});
+import { render } from "ink";
+import { jsx as jsx14 } from "react/jsx-runtime";
+async function runLiveDashboard(config2, options, activeProfile) {
+  const { waitUntilExit } = render(
+    /* @__PURE__ */ jsx14(Dashboard, { config: config2, options, activeProfile: activeProfile ?? null })
+  );
+  await waitUntilExit();
+}
+var init_live = __esm({
+  "src/board/live.tsx"() {
+    "use strict";
+    init_dashboard();
+  }
+});
+
+// src/board/fetch.ts
+var fetch_exports = {};
+__export(fetch_exports, {
+  SLACK_URL_RE: () => SLACK_URL_RE2,
+  extractSlackUrl: () => extractSlackUrl,
+  fetchDashboard: () => fetchDashboard,
+  fetchRecentActivity: () => fetchRecentActivity
+});
+import { execFileSync as execFileSync4 } from "child_process";
+function extractSlackUrl(body) {
+  if (!body) return void 0;
+  const match = body.match(SLACK_URL_RE2);
+  return match?.[0];
+}
+function formatError2(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function fetchRecentActivity(repoName, shortName) {
+  try {
+    const output = execFileSync4(
+      "gh",
+      [
+        "api",
+        `repos/${repoName}/events`,
+        "--paginate",
+        "-q",
+        '.[] | select(.type == "IssuesEvent" or .type == "IssueCommentEvent" or .type == "PullRequestEvent") | {type: .type, actor: .actor.login, action: .payload.action, number: (.payload.issue.number // .payload.pull_request.number), title: (.payload.issue.title // .payload.pull_request.title), body: .payload.comment.body, created_at: .created_at}'
+      ],
+      { encoding: "utf-8", timeout: 15e3 }
+    );
+    const cutoff = Date.now() - 24 * 60 * 60 * 1e3;
+    const events = [];
+    for (const line of output.trim().split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const ev = JSON.parse(line);
+        const timestamp = new Date(ev.created_at);
+        if (timestamp.getTime() < cutoff) continue;
+        if (!ev.number) continue;
+        let eventType;
+        let summary;
+        if (ev.type === "IssueCommentEvent") {
+          eventType = "comment";
+          const preview = ev.body ? ev.body.slice(0, 60).replace(/\n/g, " ") : "";
+          summary = `commented on #${ev.number}${preview ? ` \u2014 "${preview}${(ev.body?.length ?? 0) > 60 ? "..." : ""}"` : ""}`;
+        } else if (ev.type === "IssuesEvent") {
+          switch (ev.action) {
+            case "opened":
+              eventType = "opened";
+              summary = `opened #${ev.number}: ${ev.title ?? ""}`;
+              break;
+            case "closed":
+              eventType = "closed";
+              summary = `closed #${ev.number}`;
+              break;
+            case "assigned":
+              eventType = "assignment";
+              summary = `assigned #${ev.number}`;
+              break;
+            case "labeled":
+              eventType = "labeled";
+              summary = `labeled #${ev.number}`;
+              break;
+            default:
+              continue;
+          }
+        } else {
+          continue;
+        }
+        events.push({
+          type: eventType,
+          repoShortName: shortName,
+          issueNumber: ev.number,
+          actor: ev.actor,
+          summary,
+          timestamp
+        });
+      } catch {
+      }
+    }
+    return events.slice(0, 15);
+  } catch {
+    return [];
+  }
+}
+async function fetchDashboard(config2, options = {}) {
+  const repos = options.repoFilter ? config2.repos.filter(
+    (r) => r.shortName === options.repoFilter || r.name === options.repoFilter
+  ) : config2.repos;
+  const repoData = repos.map((repo) => {
+    try {
+      const fetchOpts = {};
+      if (options.mineOnly) {
+        fetchOpts.assignee = config2.board.assignee;
+      }
+      const issues = fetchRepoIssues(repo.name, fetchOpts);
+      let statusOptions = [];
+      try {
+        const enrichMap = fetchProjectEnrichment(repo.name, repo.projectNumber);
+        for (const issue of issues) {
+          const e = enrichMap.get(issue.number);
+          if (e?.targetDate) issue.targetDate = e.targetDate;
+          if (e?.projectStatus) issue.projectStatus = e.projectStatus;
+        }
+        statusOptions = fetchProjectStatusOptions(
+          repo.name,
+          repo.projectNumber,
+          repo.statusFieldId
+        );
+      } catch {
+      }
+      for (const issue of issues) {
+        const slackUrl = extractSlackUrl(issue.body);
+        if (slackUrl) issue.slackThreadUrl = slackUrl;
+      }
+      return { repo, issues, statusOptions, error: null };
+    } catch (err) {
+      return { repo, issues: [], statusOptions: [], error: formatError2(err) };
+    }
+  });
+  let ticktick = [];
+  let ticktickError = null;
+  if (config2.ticktick.enabled) {
+    try {
+      const auth = requireAuth();
+      const api = new TickTickClient(auth.accessToken);
+      const cfg = getConfig();
+      if (cfg.defaultProjectId) {
+        const tasks = await api.listTasks(cfg.defaultProjectId);
+        ticktick = tasks.filter((t) => t.status !== 2 /* Completed */);
+      }
+    } catch (err) {
+      ticktickError = formatError2(err);
+    }
+  }
+  const activity = [];
+  for (const repo of repos) {
+    const events = fetchRecentActivity(repo.name, repo.shortName);
+    activity.push(...events);
+  }
+  activity.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+  return {
+    repos: repoData,
+    ticktick,
+    ticktickError,
+    activity: activity.slice(0, 15),
+    fetchedAt: /* @__PURE__ */ new Date()
+  };
+}
+var SLACK_URL_RE2;
+var init_fetch = __esm({
+  "src/board/fetch.ts"() {
+    "use strict";
+    init_api();
+    init_config();
+    init_github();
+    init_types();
+    SLACK_URL_RE2 = /https:\/\/[^/]+\.slack\.com\/archives\/[A-Z0-9]+\/p[0-9]+/i;
+  }
+});
+
+// src/board/theme.ts
+import chalk from "chalk";
+function getTheme() {
+  return darkTheme;
+}
+var darkTheme;
+var init_theme = __esm({
+  "src/board/theme.ts"() {
+    "use strict";
+    darkTheme = {
+      text: {
+        primary: chalk.white,
+        secondary: chalk.gray,
+        muted: chalk.dim,
+        success: chalk.green,
+        warning: chalk.yellow,
+        error: chalk.red,
+        accent: chalk.cyan
+      },
+      border: {
+        primary: chalk.gray,
+        muted: chalk.dim,
+        focus: chalk.cyan
+      },
+      priority: {
+        high: chalk.red,
+        medium: chalk.yellow,
+        low: chalk.blue,
+        none: chalk.gray
+      },
+      assignee: {
+        self: chalk.greenBright,
+        others: chalk.white,
+        unassigned: chalk.dim
+      }
+    };
+  }
+});
+
+// src/board/format-static.ts
+var format_static_exports = {};
+__export(format_static_exports, {
+  renderBoardJson: () => renderBoardJson,
+  renderStaticBoard: () => renderStaticBoard
+});
+function truncate3(s, max) {
+  return s.length > max ? `${s.slice(0, max - 1)}\u2026` : s;
+}
+function issueAssignee(issue, selfLogin) {
+  const assignees = issue.assignees ?? [];
+  if (assignees.length === 0) return theme.assignee.unassigned("unassigned");
+  const names = assignees.map((a) => a.login);
+  const isSelf = names.includes(selfLogin);
+  const display = names.join(", ");
+  return isSelf ? theme.assignee.self(display) : theme.assignee.others(display);
+}
+function formatIssueLine(issue, selfLogin, maxTitle) {
+  const num = theme.text.accent(`#${String(issue.number).padEnd(5)}`);
+  const title = truncate3(issue.title, maxTitle);
+  const assignee = issueAssignee(issue, selfLogin);
+  return `  ${num} ${title.padEnd(maxTitle)} ${assignee}`;
+}
+function formatTaskLine(task2, maxTitle) {
+  const pri = task2.priority === 5 /* High */ ? theme.priority.high("[!]") : task2.priority === 3 /* Medium */ ? theme.priority.medium("[~]") : "   ";
+  const title = truncate3(task2.title, maxTitle);
+  const due = task2.dueDate ? formatDueDate(task2.dueDate) : "";
+  return `  ${pri} ${title.padEnd(maxTitle)} ${theme.text.secondary(due)}`;
+}
+function formatDueDate(dateStr) {
+  const d = new Date(dateStr);
+  const now = /* @__PURE__ */ new Date();
+  const days = Math.ceil((d.getTime() - now.getTime()) / 864e5);
+  if (days < 0) return theme.text.error(`${Math.abs(days)}d overdue`);
+  if (days === 0) return theme.text.warning("today");
+  if (days === 1) return "tomorrow";
+  if (days <= 7) return `in ${days}d`;
+  return d.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+}
+function printSection2(title, content) {
+  const line = theme.border.primary("\u2500".repeat(Math.max(0, title.length + 4)));
+  console.log(`
+${theme.text.primary(title)}`);
+  console.log(line);
+  console.log(content);
+}
+function renderRepoSection(data, selfLogin, backlogOnly) {
+  if (data.error) {
+    return `  ${theme.text.error(`Error: ${data.error}`)}`;
+  }
+  if (data.issues.length === 0) {
+    return `  ${theme.text.muted("No open issues")}`;
+  }
+  const assigned = backlogOnly ? [] : data.issues.filter((i) => (i.assignees ?? []).length > 0);
+  const backlog = data.issues.filter((i) => (i.assignees ?? []).length === 0);
+  const lines = [];
+  const maxTitle = 45;
+  if (assigned.length > 0) {
+    lines.push(`  ${theme.text.secondary("In Progress")}`);
+    for (const issue of assigned) {
+      lines.push(formatIssueLine(issue, selfLogin, maxTitle));
+    }
+  }
+  if (backlog.length > 0) {
+    if (assigned.length > 0) lines.push("");
+    lines.push(`  ${theme.text.secondary("Backlog (unassigned)")}`);
+    for (const issue of backlog) {
+      lines.push(formatIssueLine(issue, selfLogin, maxTitle));
+    }
+  }
+  return lines.join("\n");
+}
+function renderTickTickSection(tasks, error) {
+  if (error) {
+    return `  ${theme.text.error(`Error: ${error}`)}`;
+  }
+  if (tasks.length === 0) {
+    return `  ${theme.text.muted("No active tasks")}`;
+  }
+  const maxTitle = 45;
+  const sorted = [...tasks].sort((a, b) => {
+    if (a.dueDate && !b.dueDate) return -1;
+    if (!a.dueDate && b.dueDate) return 1;
+    if (a.dueDate && b.dueDate) return a.dueDate.localeCompare(b.dueDate);
+    return b.priority - a.priority;
+  });
+  return sorted.map((t) => formatTaskLine(t, maxTitle)).join("\n");
+}
+function renderStaticBoard(data, selfLogin, backlogOnly) {
+  const now = data.fetchedAt.toLocaleTimeString("en-US", {
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+  const date = data.fetchedAt.toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric"
+  });
+  console.log(`
+${theme.text.accent("HOG BOARD")} ${theme.text.muted(`\u2014 ${date} ${now}`)}`);
+  for (const rd of data.repos) {
+    const issueCount = rd.issues.length;
+    const label = `${rd.repo.shortName} ${theme.text.muted(`(${issueCount} issues)`)}`;
+    printSection2(label, renderRepoSection(rd, selfLogin, backlogOnly));
+  }
+  if (!backlogOnly) {
+    const taskCount = data.ticktick.length;
+    const dueToday = data.ticktick.filter((t) => {
+      if (!t.dueDate) return false;
+      const days = Math.ceil((new Date(t.dueDate).getTime() - Date.now()) / 864e5);
+      return days <= 0;
+    }).length;
+    const label = dueToday > 0 ? `Personal (TickTick) ${theme.text.warning(`${dueToday} due today`)} / ${taskCount} total` : `Personal (TickTick) ${theme.text.muted(`${taskCount} tasks`)}`;
+    printSection2(label, renderTickTickSection(data.ticktick, data.ticktickError));
+  }
+  console.log("");
+}
+function renderBoardJson(data, selfLogin) {
+  return {
+    ok: true,
+    data: {
+      repos: data.repos.map((rd) => ({
+        name: rd.repo.name,
+        shortName: rd.repo.shortName,
+        error: rd.error,
+        issues: rd.issues.map((i) => ({
+          number: i.number,
+          title: i.title,
+          url: i.url,
+          state: i.state,
+          assignee: (i.assignees ?? [])[0]?.login ?? null,
+          assignees: (i.assignees ?? []).map((a) => a.login),
+          labels: i.labels.map((l) => l.name),
+          updatedAt: i.updatedAt,
+          isMine: (i.assignees ?? []).some((a) => a.login === selfLogin)
+        }))
+      })),
+      ticktick: {
+        error: data.ticktickError,
+        tasks: data.ticktick.map((t) => ({
+          id: t.id,
+          title: t.title,
+          priority: t.priority,
+          dueDate: t.dueDate,
+          tags: t.tags
+        }))
+      },
+      fetchedAt: data.fetchedAt.toISOString()
+    }
+  };
+}
+var theme;
+var init_format_static = __esm({
+  "src/board/format-static.ts"() {
+    "use strict";
+    init_types();
+    init_theme();
+    theme = getTheme();
+  }
+});
+
+// src/cli.ts
+init_api();
+init_config();
+import { Command } from "commander";
+
+// src/init.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import { checkbox, confirm, input, select } from "@inquirer/prompts";
+
+// src/auth.ts
+import { createServer } from "http";
+var AUTH_URL = "https://ticktick.com/oauth/authorize";
+var TOKEN_URL = "https://ticktick.com/oauth/token";
+var REDIRECT_URI = "http://localhost:8080";
+var SCOPE = "tasks:write tasks:read";
+function getAuthorizationUrl(clientId) {
+  const params = new URLSearchParams({
+    scope: SCOPE,
+    client_id: clientId,
+    state: "hog",
+    redirect_uri: REDIRECT_URI,
+    response_type: "code"
+  });
+  return `${AUTH_URL}?${params}`;
+}
+async function waitForAuthCode() {
+  return new Promise((resolve, reject) => {
+    const server = createServer((req, res) => {
+      const url = new URL(req.url ?? "", REDIRECT_URI);
+      const code = url.searchParams.get("code");
+      if (code) {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(
+          "<html><body><h1>Heart of Gold authenticated!</h1><p>You can close this window.</p></body></html>"
+        );
+        server.close();
+        resolve(code);
+      } else {
+        res.writeHead(400, { "Content-Type": "text/plain" });
+        res.end("Missing authorization code");
+        server.close();
+        reject(new Error("No authorization code received"));
+      }
+    });
+    server.listen(8080, () => {
+    });
+    server.on("error", reject);
+    setTimeout(() => {
+      server.close();
+      reject(new Error("Authorization timed out (2 min)"));
+    }, 12e4);
+  });
+}
+async function exchangeCodeForToken(clientId, clientSecret, code) {
+  const credentials = Buffer.from(`${clientId}:${clientSecret}`).toString("base64");
+  const res = await fetch(TOKEN_URL, {
+    method: "POST",
+    headers: {
+      Authorization: `Basic ${credentials}`,
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      code,
+      redirect_uri: REDIRECT_URI
+    })
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Token exchange failed: ${text}`);
+  }
+  const data = await res.json();
+  return data.access_token;
+}
+
+// src/init.ts
+init_config();
+function ghJson(args) {
+  const output = execFileSync("gh", args, { encoding: "utf-8", timeout: 3e4 }).trim();
+  return JSON.parse(output);
+}
+function isGhAuthenticated() {
+  try {
+    execFileSync("gh", ["auth", "status"], { encoding: "utf-8", timeout: 1e4 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getGitHubLogin() {
+  const user = ghJson(["api", "user"]);
+  return user.login;
+}
+function listRepos() {
+  return ghJson(["repo", "list", "--json", "nameWithOwner,name,owner", "--limit", "100"]);
+}
+function listOrgProjects(owner) {
+  try {
+    return ghJson(["project", "list", "--owner", owner, "--format", "json"]);
+  } catch {
+    return [];
+  }
+}
+function listProjectFields(owner, projectNumber) {
+  try {
+    return ghJson([
+      "project",
+      "field-list",
+      String(projectNumber),
+      "--owner",
+      owner,
+      "--format",
+      "json"
+    ]);
+  } catch {
+    return [];
+  }
+}
+function detectStatusFieldId(owner, projectNumber) {
+  const fields = listProjectFields(owner, projectNumber);
+  const statusField = fields.find(
+    (f) => f.name === "Status" && f.type === "ProjectV2SingleSelectField"
+  );
+  return statusField?.id ?? null;
+}
+async function runInit(opts = {}) {
+  try {
+    await runWizard(opts);
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("User force closed")) {
+      console.log("\nSetup cancelled. No changes were made.");
+      return;
+    }
+    throw error;
+  }
+}
+async function runWizard(opts) {
+  console.log("\n\u{1F417} hog init \u2014 Setup Wizard\n");
+  const configExists = existsSync2(`${CONFIG_DIR}/config.json`);
+  if (configExists && !opts.force) {
+    const overwrite = await confirm({
+      message: "Config already exists. Overwrite?",
+      default: false
+    });
+    if (!overwrite) {
+      console.log("Setup cancelled.");
+      return;
+    }
+  }
+  console.log("Checking GitHub CLI authentication...");
+  if (!isGhAuthenticated()) {
+    console.error(
+      "\nGitHub CLI is not authenticated. Run:\n\n  gh auth login\n\nThen re-run `hog init`."
+    );
+    process.exit(1);
+  }
+  console.log("  GitHub CLI authenticated.\n");
+  const login = getGitHubLogin();
+  console.log(`  Detected GitHub user: ${login}
+`);
+  const allRepos = listRepos();
+  if (allRepos.length === 0) {
+    console.error("No repositories found. Check your GitHub CLI access.");
+    process.exit(1);
+  }
+  const selectedRepoNames = await checkbox({
+    message: "Select repositories to track:",
+    choices: allRepos.map((r) => ({
+      name: r.nameWithOwner,
+      value: r.nameWithOwner
+    }))
+  });
+  if (selectedRepoNames.length === 0) {
+    console.log("No repos selected. You can add repos later with `hog config repos:add`.");
+  }
+  const repos = [];
+  for (const repoName of selectedRepoNames) {
+    console.log(`
+Configuring ${repoName}...`);
+    const [owner, name] = repoName.split("/");
+    const projects = listOrgProjects(owner);
+    let projectNumber;
+    if (projects.length === 0) {
+      console.log("  No GitHub Projects found. Enter project number manually.");
+      const num = await input({ message: `  Project number for ${repoName}:` });
+      projectNumber = Number.parseInt(num, 10);
+    } else {
+      projectNumber = await select({
+        message: `  Select project for ${repoName}:`,
+        choices: projects.map((p) => ({
+          name: `#${p.number} \u2014 ${p.title}`,
+          value: p.number
+        }))
+      });
+    }
+    console.log("  Detecting status field...");
+    let statusFieldId = detectStatusFieldId(owner, projectNumber);
+    if (statusFieldId) {
+      console.log(`  Found status field: ${statusFieldId}`);
+    } else {
+      console.log("  Could not auto-detect status field.");
+      statusFieldId = await input({
+        message: "  Enter status field ID manually:"
+      });
+    }
+    const completionType = await select({
+      message: `  When a task is completed in TickTick, what should happen on GitHub?`,
+      choices: [
+        { name: "Close the issue", value: "closeIssue" },
+        { name: "Add a label (e.g. review:pending)", value: "addLabel" },
+        { name: "Update project status column", value: "updateProjectStatus" }
+      ]
+    });
+    let completionAction;
+    if (completionType === "addLabel") {
+      const label = await input({
+        message: "  Label to add:",
+        default: "review:pending"
+      });
+      completionAction = { type: "addLabel", label };
+    } else if (completionType === "updateProjectStatus") {
+      const optionId = await input({
+        message: "  Status option ID to set:"
+      });
+      completionAction = { type: "updateProjectStatus", optionId };
+    } else {
+      completionAction = { type: "closeIssue" };
+    }
+    const shortName = await input({
+      message: `  Short name for ${repoName}:`,
+      default: name
+    });
+    repos.push({
+      name: repoName,
+      shortName,
+      projectNumber,
+      statusFieldId,
+      completionAction
+    });
+  }
+  const enableTickTick = await confirm({
+    message: "Enable TickTick integration?",
+    default: false
+  });
+  let ticktickAuth = false;
+  if (enableTickTick) {
+    const hasAuth = existsSync2(`${CONFIG_DIR}/auth.json`);
+    if (hasAuth) {
+      console.log("  TickTick auth already configured.");
+      ticktickAuth = true;
+    } else {
+      const setupNow = await confirm({
+        message: "  Set up TickTick OAuth now?",
+        default: true
+      });
+      if (setupNow) {
+        const clientId = await input({ message: "  TickTick OAuth client ID:" });
+        const clientSecret = await input({ message: "  TickTick OAuth client secret:" });
+        const url = getAuthorizationUrl(clientId);
+        console.log(`
+  Open this URL to authorize:
+
+    ${url}
+`);
+        try {
+          const { exec } = await import("child_process");
+          exec(`open "${url}"`);
+        } catch {
+        }
+        console.log("  Waiting for authorization...");
+        const code = await waitForAuthCode();
+        const accessToken = await exchangeCodeForToken(clientId, clientSecret, code);
+        saveAuth({ accessToken, clientId, clientSecret });
+        console.log("  TickTick authenticated successfully.");
+        ticktickAuth = true;
+      }
+    }
+  }
+  console.log("\nBoard settings:");
+  const refreshInterval = await input({
+    message: "  Refresh interval (seconds):",
+    default: "60"
+  });
+  const backlogLimit = await input({
+    message: "  Backlog limit (max issues per repo):",
+    default: "20"
+  });
+  const focusDuration = await input({
+    message: "  Focus timer duration (seconds):",
+    default: "1500"
+  });
+  const existingConfig = configExists ? loadFullConfig() : void 0;
+  const config2 = {
+    version: 3,
+    defaultProjectId: existingConfig?.defaultProjectId,
+    defaultProjectName: existingConfig?.defaultProjectName,
+    repos,
+    board: {
+      refreshInterval: Number.parseInt(refreshInterval, 10) || 60,
+      backlogLimit: Number.parseInt(backlogLimit, 10) || 20,
+      assignee: login,
+      focusDuration: Number.parseInt(focusDuration, 10) || 1500
+    },
+    ticktick: { enabled: enableTickTick && ticktickAuth },
+    profiles: existingConfig?.profiles ?? {}
+  };
+  saveFullConfig(config2);
+  console.log(`
+Config written to ${CONFIG_DIR}/config.json`);
+  console.log("\nSetup complete! Try:\n");
+  console.log("  hog board --live    # Interactive dashboard");
+  console.log("  hog task list       # List TickTick tasks");
+  console.log("  hog config show     # View configuration\n");
+}
+
+// src/output.ts
+init_types();
+var isTTY = process.stdout.isTTY ?? false;
+var forceFormat = null;
+function setFormat(format) {
+  forceFormat = format;
+}
+function useJson() {
+  if (forceFormat === "json") return true;
+  if (forceFormat === "human") return false;
+  return !isTTY;
+}
+function jsonOut(data) {
+  console.log(JSON.stringify(data));
+}
+var PRIORITY_LABELS = {
+  [0 /* None */]: "",
+  [1 /* Low */]: "[low]",
+  [3 /* Medium */]: "[med]",
+  [5 /* High */]: "[HIGH]"
+};
+function formatDate(dateStr) {
+  if (!dateStr) return "";
+  const d = new Date(dateStr);
+  const now = /* @__PURE__ */ new Date();
+  const days = Math.ceil((d.getTime() - now.getTime()) / 864e5);
+  if (days < 0) return `${Math.abs(days)}d ago`;
+  if (days === 0) return "today";
+  if (days === 1) return "tomorrow";
+  if (days <= 7) return `in ${days}d`;
+  return d.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+}
+function taskLine(t) {
+  const parts = [];
+  const pri = PRIORITY_LABELS[t.priority] ?? "";
+  if (pri) parts.push(pri);
+  parts.push(t.title);
+  if (t.dueDate) parts.push(`  ${formatDate(t.dueDate)}`);
+  if (t.tags.length > 0) parts.push(`  #${t.tags.join(" #")}`);
+  return `  ${t.id}  ${parts.join(" ")}`;
+}
+function printTasks(tasks) {
+  if (useJson()) {
+    jsonOut(tasks);
+    return;
+  }
+  if (tasks.length === 0) {
+    console.log("  No tasks.");
+    return;
+  }
+  for (const t of tasks) {
+    console.log(taskLine(t));
+  }
+}
+function printTask(task2) {
+  if (useJson()) {
+    jsonOut(task2);
+    return;
+  }
+  console.log(`  ID:       ${task2.id}`);
+  console.log(`  Title:    ${task2.title}`);
+  if (task2.content) console.log(`  Content:  ${task2.content}`);
+  console.log(`  Priority: ${PRIORITY_LABELS[task2.priority] ?? "none"}`);
+  if (task2.dueDate) console.log(`  Due:      ${formatDate(task2.dueDate)}`);
+  if (task2.startDate) console.log(`  Start:    ${formatDate(task2.startDate)}`);
+  if (task2.tags.length > 0) console.log(`  Tags:     ${task2.tags.join(", ")}`);
+  console.log(`  Project:  ${task2.projectId}`);
+  console.log(`  Status:   ${task2.status === 2 ? "completed" : "active"}`);
+}
+function printProjects(projects) {
+  if (useJson()) {
+    jsonOut(projects);
+    return;
+  }
+  if (projects.length === 0) {
+    console.log("  No projects.");
+    return;
+  }
+  for (const p of projects) {
+    const closed = p.closed ? " (closed)" : "";
+    console.log(`  ${p.id}  ${p.name}${closed}`);
+  }
+}
+function printSuccess(message, data) {
+  if (useJson()) {
+    jsonOut({ ok: true, message, ...data });
+    return;
+  }
+  console.log(message);
+}
+function printSection(prefix, label, icon, items) {
+  if (items.length === 0) return;
+  console.log(`${prefix}${label} ${items.length} task(s):`);
+  for (const key of items) console.log(`  ${icon} ${key}`);
+}
+function printSyncResult(result, dryRun) {
+  if (useJson()) {
+    jsonOut({ ok: true, dryRun, ...result });
+    return;
+  }
+  const prefix = dryRun ? "[dry-run] " : "";
+  printSection(prefix, "Created", "+", result.created);
+  printSection(prefix, "Updated", "~", result.updated);
+  printSection(prefix, "Completed", "\u2713", result.completed);
+  printSection(prefix, "GitHub updated", "\u2192", result.ghUpdated);
+  printSection("", "Errors", "\u2717", result.errors);
+  const total = result.created.length + result.updated.length + result.completed.length + result.ghUpdated.length;
+  if (total === 0 && result.errors.length === 0) {
+    console.log(`${prefix}Everything in sync.`);
+  }
+}
+function printSyncStatus(state, repos) {
+  if (useJson()) {
+    jsonOut({ repos, lastSyncAt: state.lastSyncAt ?? null, mappings: state.mappings });
+    return;
+  }
+  console.log(`  Repos: ${repos.join(", ")}`);
+  console.log(`  Last sync: ${state.lastSyncAt ?? "never"}`);
+  console.log(`  Active mappings: ${state.mappings.length}`);
+  if (state.mappings.length > 0) {
+    for (const m of state.mappings) {
+      console.log(`    ${m.githubRepo}#${m.githubIssueNumber} \u2192 ${m.ticktickTaskId}`);
+    }
+  }
+}
+
+// src/sync.ts
+init_api();
+init_config();
+init_github();
+init_sync_state();
+init_types();
+function emptySyncResult() {
+  return { created: [], updated: [], completed: [], ghUpdated: [], errors: [] };
+}
+function formatError(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function repoShortName(repo) {
+  return repo.split("/")[1] ?? repo;
+}
+function issueTaskTitle(issue) {
+  return issue.title;
+}
+function issueTaskContent(issue, projectFields) {
+  const lines = [`GitHub: ${issue.url}`];
+  if (projectFields.status) lines.push(`Status: ${projectFields.status}`);
+  return lines.join("\n");
+}
+function mapPriority(labels) {
+  for (const label of labels) {
+    if (label.name === "priority:critical" || label.name === "priority:high") return 5 /* High */;
+    if (label.name === "priority:medium") return 3 /* Medium */;
+    if (label.name === "priority:low") return 1 /* Low */;
+  }
+  return 0 /* None */;
+}
+function buildCreateInput(repo, issue, projectFields) {
+  const input2 = {
+    title: issueTaskTitle(issue),
+    content: issueTaskContent(issue, projectFields),
+    priority: mapPriority(issue.labels),
+    tags: ["github", repoShortName(repo)]
+  };
+  if (projectFields.targetDate) {
+    input2.dueDate = projectFields.targetDate;
+    input2.isAllDay = true;
+  }
+  return input2;
+}
+function buildUpdateInput(repo, issue, projectFields, mapping) {
+  const input2 = {
+    id: mapping.ticktickTaskId,
+    projectId: mapping.ticktickProjectId,
+    title: issueTaskTitle(issue),
+    content: issueTaskContent(issue, projectFields),
+    priority: mapPriority(issue.labels),
+    tags: ["github", repoShortName(repo)]
+  };
+  if (projectFields.targetDate) {
+    input2.dueDate = projectFields.targetDate;
+  }
+  return input2;
+}
+async function syncGitHubToTickTick(config2, state, api, result, dryRun) {
+  const openIssueKeys = /* @__PURE__ */ new Set();
+  const failedRepos = /* @__PURE__ */ new Set();
+  for (const repoConfig of config2.repos) {
+    let issues;
+    try {
+      issues = fetchAssignedIssues(repoConfig.name, config2.board.assignee);
+    } catch (err) {
+      result.errors.push(`Failed to fetch issues from ${repoConfig.name}: ${formatError(err)}`);
+      failedRepos.add(repoConfig.name);
+      continue;
+    }
+    for (const issue of issues) {
+      const key = `${repoConfig.name}#${issue.number}`;
+      openIssueKeys.add(key);
+      await syncSingleIssue(state, api, result, dryRun, repoConfig, issue, key);
+    }
+  }
+  return { openIssueKeys, failedRepos };
+}
+async function syncSingleIssue(state, api, result, dryRun, repoConfig, issue, key) {
+  try {
+    const existing = findMapping(state, repoConfig.name, issue.number);
+    if (existing && existing.githubUpdatedAt === issue.updatedAt) return;
+    const projectFields = fetchProjectFields(
+      repoConfig.name,
+      issue.number,
+      repoConfig.projectNumber
+    );
+    if (!existing) {
+      await createTickTickTask(
+        state,
+        api,
+        result,
+        dryRun,
+        repoConfig.name,
+        issue,
+        projectFields,
+        key
+      );
+    } else {
+      await updateTickTickTask(
+        state,
+        api,
+        result,
+        dryRun,
+        repoConfig.name,
+        issue,
+        projectFields,
+        existing,
+        key
+      );
+    }
+  } catch (err) {
+    result.errors.push(`${key}: ${formatError(err)}`);
+  }
+}
+async function createTickTickTask(state, api, result, dryRun, repo, issue, projectFields, key) {
+  if (dryRun) {
+    result.created.push(key);
+    return;
+  }
+  const input2 = buildCreateInput(repo, issue, projectFields);
+  const task2 = await api.createTask(input2);
+  upsertMapping(state, {
+    githubRepo: repo,
+    githubIssueNumber: issue.number,
+    githubUrl: issue.url,
+    ticktickTaskId: task2.id,
+    ticktickProjectId: task2.projectId,
+    githubUpdatedAt: issue.updatedAt,
+    lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  result.created.push(key);
+}
+async function updateTickTickTask(state, api, result, dryRun, repo, issue, projectFields, existing, key) {
+  if (dryRun) {
+    result.updated.push(key);
+    return;
+  }
+  const input2 = buildUpdateInput(repo, issue, projectFields, existing);
+  await api.updateTask(input2);
+  upsertMapping(state, {
+    ...existing,
+    githubUpdatedAt: issue.updatedAt,
+    lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  result.updated.push(key);
+}
+async function syncClosedIssues(state, api, result, dryRun, openIssueKeys, failedRepos) {
+  for (const mapping of [...state.mappings]) {
+    if (failedRepos.has(mapping.githubRepo)) continue;
+    const key = `${mapping.githubRepo}#${mapping.githubIssueNumber}`;
+    if (openIssueKeys.has(key)) continue;
+    try {
+      if (dryRun) {
+        result.completed.push(key);
+        continue;
+      }
+      await api.completeTask(mapping.ticktickProjectId, mapping.ticktickTaskId);
+      removeMapping(state, mapping.githubRepo, mapping.githubIssueNumber);
+      result.completed.push(key);
+    } catch (err) {
+      result.errors.push(`Complete ${key}: ${formatError(err)}`);
+    }
+  }
+}
+async function syncCompletedTasksToGitHub(config2, state, api, result, dryRun) {
+  for (const mapping of [...state.mappings]) {
+    const key = `${mapping.githubRepo}#${mapping.githubIssueNumber}`;
+    try {
+      await processCompletedMapping(config2, state, api, result, dryRun, mapping, key);
+    } catch (err) {
+      result.errors.push(`GH update ${key}: ${formatError(err)}`);
+    }
+  }
+}
+async function processCompletedMapping(config2, state, api, result, dryRun, mapping, key) {
+  let task2;
+  try {
+    task2 = await api.getTask(mapping.ticktickProjectId, mapping.ticktickTaskId);
+  } catch {
+    return;
+  }
+  if (task2.status !== 2 /* Completed */) return;
+  if (dryRun) {
+    result.ghUpdated.push(key);
+    return;
+  }
+  const repo = mapping.githubRepo;
+  const repoConfig = config2.repos.find((r) => r.name === repo);
+  if (repoConfig) {
+    const action = repoConfig.completionAction;
+    switch (action.type) {
+      case "addLabel":
+        addLabel(repo, mapping.githubIssueNumber, action.label);
+        break;
+      case "updateProjectStatus":
+        updateProjectItemStatus(repo, mapping.githubIssueNumber, {
+          projectNumber: repoConfig.projectNumber,
+          statusFieldId: repoConfig.statusFieldId,
+          optionId: action.optionId
+        });
+        break;
+      case "closeIssue":
+        break;
+    }
+  }
+  removeMapping(state, repo, mapping.githubIssueNumber);
+  result.ghUpdated.push(key);
+}
+async function runSync(options = {}) {
+  const { dryRun = false } = options;
+  const result = emptySyncResult();
+  const config2 = loadFullConfig();
+  const auth = requireAuth();
+  const api = new TickTickClient(auth.accessToken);
+  const state = loadSyncState();
+  const { openIssueKeys, failedRepos } = await syncGitHubToTickTick(
+    config2,
+    state,
+    api,
+    result,
+    dryRun
+  );
+  await syncClosedIssues(state, api, result, dryRun, openIssueKeys, failedRepos);
+  await syncCompletedTasksToGitHub(config2, state, api, result, dryRun);
+  if (!dryRun) {
+    state.lastSyncAt = (/* @__PURE__ */ new Date()).toISOString();
+    saveSyncState(state);
+  }
+  return result;
+}
+function getSyncStatus() {
+  const config2 = loadFullConfig();
+  return { state: loadSyncState(), repos: config2.repos.map((r) => r.name) };
+}
+
+// src/cli.ts
+init_types();
+var major = Number(process.versions.node.split(".")[0]);
+if (major < 22) {
+  console.error(
+    `hog requires Node.js >= 22 (current: ${process.version}). Install from https://nodejs.org/`
+  );
+  process.exit(1);
+}
+var PRIORITY_MAP = {
+  none: 0 /* None */,
+  low: 1 /* Low */,
+  medium: 3 /* Medium */,
+  med: 3 /* Medium */,
+  high: 5 /* High */
+};
+function parsePriority(value) {
+  const p = PRIORITY_MAP[value.toLowerCase()];
+  if (p === void 0) {
+    console.error(`Invalid priority: ${value}. Use: none, low, medium, high`);
+    process.exit(1);
+  }
+  return p;
+}
+function createClient() {
+  const auth = requireAuth();
+  return new TickTickClient(auth.accessToken);
+}
+function resolveProjectId(projectId) {
+  if (projectId) return projectId;
+  const config2 = getConfig();
+  if (config2.defaultProjectId) return config2.defaultProjectId;
+  console.error("No project selected. Run `hog task use-project <id>` or pass --project.");
+  process.exit(1);
+}
+var program = new Command();
+program.name("hog").description("Personal command deck \u2014 unified task dashboard for GitHub Projects + TickTick").version("1.1.1").option("--json", "Force JSON output").option("--human", "Force human-readable output").hook("preAction", (thisCommand) => {
+  const opts = thisCommand.opts();
+  if (opts.json) setFormat("json");
+  if (opts.human) setFormat("human");
+});
+program.command("init").description("Interactive setup wizard").option("--force", "Overwrite existing config without prompt").action(async (opts) => {
+  await runInit({ force: opts.force ?? false });
+});
+var task = program.command("task").description("Manage TickTick tasks");
+task.command("add <title>").description("Create a new task").option("-p, --priority <level>", "Priority: none, low, medium, high").option("-d, --date <date>", "Due date (ISO 8601)").option("--start <date>", "Start date (ISO 8601)").option("-c, --content <text>", "Task description/content").option("-t, --tags <tags>", "Comma-separated tags").option("--all-day", "Mark as all-day task").option("--project <id>", "Project ID (overrides default)").action(async (title, opts) => {
+  const api = createClient();
+  const input2 = {
+    title,
+    projectId: resolveProjectId(opts.project)
+  };
+  if (opts.priority) input2.priority = parsePriority(opts.priority);
+  if (opts.date) input2.dueDate = opts.date;
+  if (opts.start) input2.startDate = opts.start;
+  if (opts.content) input2.content = opts.content;
+  if (opts.tags) input2.tags = opts.tags.split(",").map((t) => t.trim());
+  if (opts.allDay) input2.isAllDay = true;
+  const created = await api.createTask(input2);
+  printSuccess(`Created: ${created.title}`, {
+    task: created
+  });
+});
+task.command("list").description("List tasks in a project").option("--project <id>", "Project ID (overrides default)").option("--all", "Include completed tasks").option("-p, --priority <level>", "Filter by minimum priority").option("-t, --tag <tag>", "Filter by tag").action(async (opts) => {
+  const api = createClient();
+  const projectId = resolveProjectId(opts.project);
+  let tasks = await api.listTasks(projectId);
+  if (!opts.all) {
+    tasks = tasks.filter((t) => t.status !== 2);
+  }
+  if (opts.priority) {
+    const minPri = parsePriority(opts.priority);
+    tasks = tasks.filter((t) => t.priority >= minPri);
+  }
+  if (opts.tag) {
+    const tag = opts.tag;
+    tasks = tasks.filter((t) => t.tags.includes(tag));
+  }
+  printTasks(tasks);
+});
+task.command("show <taskId>").description("Show task details").option("--project <id>", "Project ID (overrides default)").action(async (taskId, opts) => {
+  const api = createClient();
+  const projectId = resolveProjectId(opts.project);
+  const t = await api.getTask(projectId, taskId);
+  printTask(t);
+});
+task.command("complete <taskId>").description("Mark a task as completed").option("--project <id>", "Project ID (overrides default)").action(async (taskId, opts) => {
+  const api = createClient();
+  const projectId = resolveProjectId(opts.project);
+  await api.completeTask(projectId, taskId);
+  printSuccess(`Completed task ${taskId}`, { taskId });
+});
+task.command("update <taskId>").description("Update a task").option("--title <title>", "New title").option("-p, --priority <level>", "New priority").option("-d, --date <date>", "New due date (ISO 8601)").option("-c, --content <text>", "New content").option("-t, --tags <tags>", "New comma-separated tags").option("--project <id>", "Project ID (overrides default)").action(async (taskId, opts) => {
+  const api = createClient();
+  const projectId = resolveProjectId(opts.project);
+  const input2 = { id: taskId, projectId };
+  if (opts.title) input2.title = opts.title;
+  if (opts.priority) input2.priority = parsePriority(opts.priority);
+  if (opts.date) input2.dueDate = opts.date;
+  if (opts.content) input2.content = opts.content;
+  if (opts.tags) input2.tags = opts.tags.split(",").map((t) => t.trim());
+  const updated = await api.updateTask(input2);
+  printSuccess(`Updated: ${updated.title}`, {
+    task: updated
+  });
+});
+task.command("delete <taskId>").description("Delete a task").option("--project <id>", "Project ID (overrides default)").action(async (taskId, opts) => {
+  const api = createClient();
+  const projectId = resolveProjectId(opts.project);
+  await api.deleteTask(projectId, taskId);
+  printSuccess(`Deleted task ${taskId}`, { taskId });
+});
+task.command("projects").description("List all projects").action(async () => {
+  const api = createClient();
+  const projects = await api.listProjects();
+  printProjects(projects);
+});
+task.command("use-project <projectId>").description("Set the default project for task commands").action(async (projectId) => {
+  const api = createClient();
+  try {
+    const project = await api.getProject(projectId);
+    saveConfig({ defaultProjectId: project.id, defaultProjectName: project.name });
+    printSuccess(`Default project: ${project.name} (${project.id})`, {
+      projectId: project.id,
+      projectName: project.name
+    });
+  } catch {
+    saveConfig({ defaultProjectId: projectId });
+    printSuccess(`Default project: ${projectId}`, { projectId });
+  }
+});
+var sync = program.command("sync").description("Sync GitHub issues with TickTick");
+sync.command("run", { isDefault: true }).description("Run GitHub-TickTick sync").option("--dry-run", "Preview changes without applying them").action(async (opts) => {
+  const dryRun = opts.dryRun ?? false;
+  const result = await runSync({ dryRun });
+  printSyncResult(result, dryRun);
+});
+sync.command("status").description("Show sync status and mappings").action(() => {
+  const { state, repos } = getSyncStatus();
+  printSyncStatus(state, repos);
+});
+program.command("board").description("Show unified task dashboard").option("--repo <name>", "Filter by repo (short name or full)").option("--mine", "Show only my assigned issues and tasks").option("--backlog", "Show only unassigned issues").option("--live", "Persistent TUI with auto-refresh and keyboard navigation").option("--profile <name>", "Use a named board profile").action(async (opts) => {
+  const rawCfg = loadFullConfig();
+  const { resolved: cfg, activeProfile } = resolveProfile(rawCfg, opts.profile);
+  const jsonMode = useJson();
+  const fetchOptions = {
+    repoFilter: opts.repo,
+    mineOnly: opts.mine ?? false,
+    backlogOnly: opts.backlog ?? false
+  };
+  if (opts.live) {
+    const { runLiveDashboard: runLiveDashboard2 } = await Promise.resolve().then(() => (init_live(), live_exports));
+    await runLiveDashboard2(cfg, fetchOptions, activeProfile);
+    return;
+  }
+  const { fetchDashboard: fetchDashboard2 } = await Promise.resolve().then(() => (init_fetch(), fetch_exports));
+  const data = await fetchDashboard2(cfg, fetchOptions);
+  if (jsonMode) {
+    const { renderBoardJson: renderBoardJson2 } = await Promise.resolve().then(() => (init_format_static(), format_static_exports));
+    jsonOut(renderBoardJson2(data, cfg.board.assignee));
+  } else {
+    const { renderStaticBoard: renderStaticBoard2 } = await Promise.resolve().then(() => (init_format_static(), format_static_exports));
+    renderStaticBoard2(data, cfg.board.assignee, opts.backlog ?? false);
+  }
+});
+program.command("pick <issueRef>").description("Pick up an issue: assign to self + sync to TickTick (e.g., hog pick aibility/145)").action(async (issueRef) => {
+  const cfg = loadFullConfig();
+  const { parseIssueRef: parseIssueRef2, pickIssue: pickIssue2 } = await Promise.resolve().then(() => (init_pick(), pick_exports));
+  const ref = parseIssueRef2(issueRef, cfg);
+  const result = await pickIssue2(cfg, ref);
+  if (useJson()) {
+    jsonOut({
+      ok: result.success,
+      data: {
+        issue: result.issue,
+        ticktickTask: result.ticktickTask ?? null,
+        warning: result.warning ?? null
+      }
+    });
+  } else {
+    console.log(`Picked ${ref.repo.shortName}#${ref.issueNumber}: ${result.issue.title}`);
+    console.log(`  GitHub: assigned to @me`);
+    if (result.ticktickTask) {
+      console.log(`  TickTick: task created`);
+    }
+    if (result.warning) {
+      console.log(`  Warning: ${result.warning}`);
+    }
+  }
+});
+var config = program.command("config").description("Manage hog configuration");
+config.command("show").description("Show full configuration").action(() => {
+  const cfg = loadFullConfig();
+  if (useJson()) {
+    jsonOut({ ok: true, data: cfg });
+  } else {
+    console.log("Version:", cfg.version);
+    console.log("Default project:", cfg.defaultProjectId ?? "(none)");
+    console.log("Assignee:", cfg.board.assignee);
+    console.log("Refresh interval:", `${cfg.board.refreshInterval}s`);
+    console.log("Backlog limit:", cfg.board.backlogLimit);
+    console.log("TickTick:", cfg.ticktick.enabled ? "enabled" : "disabled");
+    console.log("\nRepos:");
+    for (const repo of cfg.repos) {
+      console.log(`  ${repo.shortName} \u2192 ${repo.name} (project #${repo.projectNumber})`);
+      console.log(`    completion: ${repo.completionAction.type}`);
+    }
+  }
+});
+config.command("repos").description("List configured repositories").action(() => {
+  const cfg = loadFullConfig();
+  if (useJson()) {
+    jsonOut({ ok: true, data: cfg.repos });
+  } else {
+    if (cfg.repos.length === 0) {
+      console.log("No repos configured. Run: hog config repos add <owner/repo>");
+      return;
+    }
+    for (const repo of cfg.repos) {
+      console.log(`  ${repo.shortName.padEnd(15)} ${repo.name}`);
+    }
+  }
+});
+config.command("repos:add <name>").description("Add a repository to track (owner/repo format)").requiredOption("--project-number <n>", "GitHub project number").requiredOption("--status-field-id <id>", "Project status field ID").requiredOption(
+  "--completion-type <type>",
+  "Completion action: addLabel, updateProjectStatus, closeIssue"
+).option("--completion-option-id <id>", "Option ID for updateProjectStatus").option("--completion-label <label>", "Label for addLabel").action((name, opts) => {
+  if (!validateRepoName(name)) {
+    console.error("Invalid repo name. Use owner/repo format (e.g., myorg/myrepo)");
+    process.exit(1);
+  }
+  const cfg = loadFullConfig();
+  if (findRepo(cfg, name)) {
+    console.error(`Repo "${name}" is already configured.`);
+    process.exit(1);
+  }
+  const shortName = name.split("/")[1] ?? name;
+  let completionAction;
+  switch (opts.completionType) {
+    case "addLabel":
+      if (!opts.completionLabel) {
+        console.error("--completion-label required for addLabel type");
+        process.exit(1);
+      }
+      completionAction = { type: "addLabel", label: opts.completionLabel };
+      break;
+    case "updateProjectStatus":
+      if (!opts.completionOptionId) {
+        console.error("--completion-option-id required for updateProjectStatus type");
+        process.exit(1);
+      }
+      completionAction = { type: "updateProjectStatus", optionId: opts.completionOptionId };
+      break;
+    case "closeIssue":
+      completionAction = { type: "closeIssue" };
+      break;
+    default:
+      console.error(
+        `Unknown completion type: ${opts.completionType}. Use: addLabel, updateProjectStatus, closeIssue`
+      );
+      process.exit(1);
+  }
+  const newRepo = {
+    name,
+    shortName,
+    projectNumber: Number.parseInt(opts.projectNumber, 10),
+    statusFieldId: opts.statusFieldId,
+    completionAction
+  };
+  cfg.repos.push(newRepo);
+  saveFullConfig(cfg);
+  if (useJson()) {
+    jsonOut({ ok: true, message: `Added ${name}`, data: newRepo });
+  } else {
+    console.log(`Added ${shortName} \u2192 ${name}`);
+  }
+});
+config.command("repos:rm <name>").description("Remove a repository from tracking").action((name) => {
+  const cfg = loadFullConfig();
+  const idx = cfg.repos.findIndex((r) => r.shortName === name || r.name === name);
+  if (idx === -1) {
+    console.error(`Repo "${name}" not found. Run: hog config repos`);
+    process.exit(1);
+  }
+  const [removed] = cfg.repos.splice(idx, 1);
+  if (!removed) {
+    process.exit(1);
+  }
+  saveFullConfig(cfg);
+  if (useJson()) {
+    jsonOut({ ok: true, message: `Removed ${removed.name}`, data: removed });
+  } else {
+    console.log(`Removed ${removed.shortName} \u2192 ${removed.name}`);
+    console.log("Note: Existing sync mappings for this repo remain in sync-state.json.");
+  }
+});
+config.command("ticktick:enable").description("Enable TickTick integration in the board").action(() => {
+  const cfg = loadFullConfig();
+  cfg.ticktick = { enabled: true };
+  saveFullConfig(cfg);
+  if (useJson()) {
+    jsonOut({ ok: true, message: "TickTick enabled" });
+  } else {
+    printSuccess("TickTick integration enabled.");
+  }
+});
+config.command("ticktick:disable").description("Disable TickTick integration in the board").action(() => {
+  const cfg = loadFullConfig();
+  cfg.ticktick = { enabled: false };
+  saveFullConfig(cfg);
+  if (useJson()) {
+    jsonOut({ ok: true, message: "TickTick disabled" });
+  } else {
+    printSuccess("TickTick integration disabled. Board will no longer show TickTick tasks.");
+  }
+});
+config.command("profile:create <name>").description("Create a board profile (copies current top-level config)").action((name) => {
+  const cfg = loadFullConfig();
+  if (cfg.profiles[name]) {
+    console.error(`Profile "${name}" already exists.`);
+    process.exit(1);
+  }
+  cfg.profiles[name] = {
+    repos: [...cfg.repos],
+    board: { ...cfg.board },
+    ticktick: { ...cfg.ticktick }
+  };
+  saveFullConfig(cfg);
+  if (useJson()) {
+    jsonOut({ ok: true, message: `Created profile "${name}"`, data: cfg.profiles[name] });
+  } else {
+    printSuccess(`Created profile "${name}" (copied from current config).`);
+  }
+});
+config.command("profile:delete <name>").description("Delete a board profile").action((name) => {
+  const cfg = loadFullConfig();
+  if (!cfg.profiles[name]) {
+    console.error(
+      `Profile "${name}" not found. Available: ${Object.keys(cfg.profiles).join(", ") || "(none)"}`
+    );
+    process.exit(1);
+  }
+  delete cfg.profiles[name];
+  if (cfg.defaultProfile === name) {
+    cfg.defaultProfile = void 0;
+  }
+  saveFullConfig(cfg);
+  if (useJson()) {
+    jsonOut({ ok: true, message: `Deleted profile "${name}"` });
+  } else {
+    printSuccess(`Deleted profile "${name}".`);
+  }
+});
+config.command("profile:default [name]").description("Set or show the default board profile").action((name) => {
+  const cfg = loadFullConfig();
+  if (!name) {
+    if (useJson()) {
+      jsonOut({
+        ok: true,
+        data: { defaultProfile: cfg.defaultProfile ?? null, profiles: Object.keys(cfg.profiles) }
+      });
+    } else {
+      console.log("Default profile:", cfg.defaultProfile ?? "(none)");
+      const names = Object.keys(cfg.profiles);
+      if (names.length > 0) {
+        console.log("Available profiles:", names.join(", "));
+      } else {
+        console.log("No profiles configured. Run: hog config profile:create <name>");
+      }
+    }
+    return;
+  }
+  if (!cfg.profiles[name]) {
+    console.error(
+      `Profile "${name}" not found. Available: ${Object.keys(cfg.profiles).join(", ") || "(none)"}`
+    );
+    process.exit(1);
+  }
+  cfg.defaultProfile = name;
+  saveFullConfig(cfg);
+  if (useJson()) {
+    jsonOut({ ok: true, message: `Default profile set to "${name}"` });
+  } else {
+    printSuccess(`Default profile set to "${name}".`);
+  }
+});
+program.parseAsync().catch((err) => {
+  const message = err instanceof Error ? err.message : String(err);
+  console.error(`Error: ${message}`);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map