opencode-skills-deck 0.2.0-rc.0 → 0.3.0

package/dist/index.js

@@ -5,8 +5,13 @@ var __export = (target, all) => {
 };
 
 // packages/plugin/src/index.ts
+import { fileURLToPath } from "node:url";
 import { Plugin } from "@opencode/plugin";
 
+// packages/core/src/config.ts
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
 // node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/classic/external.js
 var external_exports = {};
 __export(external_exports, {
@@ -3621,8 +3626,8 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
   const _normalized = cached(() => normalizeDef(def));
   const memo2 = globalConfig.memoizer;
   const generateFastpass = (shape) => {
-    const normalized = _normalized.value;
-    const syms = normalized.symbolKeys;
+    const normalized2 = _normalized.value;
+    const syms = normalized2.symbolKeys;
     const doc = new Doc(["payload", "ctx"], { shape, inst, memo: memo2, syms });
     const parseStr = (k) => `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
     const prefixStr = (id, k) => `
@@ -3640,11 +3645,11 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
     doc.write(`const input = payload.value;`);
     const ids = /* @__PURE__ */ Object.create(null);
     let counter = 0;
-    for (const key of normalized.allKeys) {
+    for (const key of normalized2.allKeys) {
       ids[key] = `key_${counter++}`;
     }
     doc.write(memo2 ? `const newResult = memo.alloc(inst, payload, {}, ctx);` : `const newResult = {};`);
-    for (const key of normalized.allKeys) {
+    for (const key of normalized2.allKeys) {
       if (key === "__proto__")
         continue;
       const id = ids[key];
@@ -5074,7 +5079,7 @@ var recursive = /* @__PURE__ */ new WeakMap();
 var NONE = 0;
 var ASSUMED = 1;
 var PROVEN = 2;
-function isRecursive(inst, stack, resolve) {
+function isRecursive(inst, stack, resolve3) {
   const cached2 = recursive.get(inst);
   if (cached2 !== void 0)
     return cached2 ? PROVEN : NONE;
@@ -5084,7 +5089,7 @@ function isRecursive(inst, stack, resolve) {
   let result = NONE;
   const check2 = (child) => {
     if (result !== PROVEN && child?._zod) {
-      const answer = isRecursive(child, stack, resolve);
+      const answer = isRecursive(child, stack, resolve3);
       if (answer > result)
         result = answer;
     }
@@ -5095,7 +5100,7 @@ function isRecursive(inst, stack, resolve) {
       const desc = Object.getOwnPropertyDescriptor(sh, key);
       if (spread && !desc.enumerable)
         continue;
-      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve) : NONE;
+      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve3) : NONE;
       if (child > answer)
         answer = child;
     }
@@ -5159,7 +5164,7 @@ function isRecursive(inst, stack, resolve) {
       break;
     // `$ZodLazy` caches its inner on the def, so a resolved edge is followed exactly
     case "lazy": {
-      const inner = def._cachedInner ?? (resolve ? inst._zod.innerType : void 0);
+      const inner = def._cachedInner ?? (resolve3 ? inst._zod.innerType : void 0);
       merge2(inner ? isRecursive(inner, stack, false) : ASSUMED);
       break;
     }
@@ -19483,23 +19488,23 @@ function fromJSONSchema(schema, params) {
   if (typeof schema === "boolean") {
     return schema ? z.any() : z.never();
   }
-  let normalized;
+  let normalized2;
   try {
-    normalized = JSON.parse(JSON.stringify(schema));
+    normalized2 = JSON.parse(JSON.stringify(schema));
   } catch {
     throw new Error("fromJSONSchema input is not valid JSON (possibly cyclic); use $defs/$ref for recursive schemas");
   }
-  const version2 = detectVersion(normalized, params?.defaultTarget);
-  const defs = normalized.$defs || normalized.definitions || {};
+  const version2 = detectVersion(normalized2, params?.defaultTarget);
+  const defs = normalized2.$defs || normalized2.definitions || {};
   const ctx = {
     version: version2,
     defs,
     refs: /* @__PURE__ */ new Map(),
     processing: /* @__PURE__ */ new Set(),
-    rootSchema: normalized,
+    rootSchema: normalized2,
     registry: params?.registry ?? globalRegistry
   };
-  return convertSchema(normalized, ctx);
+  return convertSchema(normalized2, ctx);
 }
 
 // node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/visit.js
@@ -19745,25 +19750,121 @@ var configSchema = external_exports.object({
   repos: external_exports.array(repoSchema).default([])
 });
 var defaultConfig = configSchema.parse({});
+function configFilePath(paths) {
+  return join(paths.configDir, "config.json");
+}
+function parseConfig(raw) {
+  return configSchema.parse(raw);
+}
+function loadConfig(paths) {
+  try {
+    const text = readFileSync(configFilePath(paths), "utf8");
+    return parseConfig(JSON.parse(text));
+  } catch {
+    return defaultConfig;
+  }
+}
+function fillTemplate(template, values) {
+  return template.replace(/\{(\w+)\}/g, (match, key) => {
+    const value = values[key];
+    return value === void 0 ? match : String(value);
+  });
+}
 
 // packages/core/src/exec.ts
+import { spawn } from "node:child_process";
 var MAX_BUFFER = 16 * 1024 * 1024;
+var DEFAULT_TIMEOUT_MS = 3e4;
+function createRunner(options = {}) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  return (command, args, options2) => new Promise((resolve3, reject) => {
+    const child = spawn(command, args, {
+      cwd: options2?.cwd,
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let overflow = false;
+    let settled = false;
+    const fail = (error62) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(error62);
+    };
+    const succeed = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve3(result);
+    };
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      fail(new Error(`${command} ${args.join(" ")} timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    timer.unref?.();
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+      if (overflow) return;
+      stdout += chunk;
+      if (stdout.length > MAX_BUFFER) {
+        overflow = true;
+        child.kill();
+      }
+    });
+    child.stderr?.on("data", (chunk) => {
+      if (overflow) return;
+      stderr += chunk;
+      if (stderr.length > MAX_BUFFER) {
+        overflow = true;
+        child.kill();
+      }
+    });
+    child.on("error", (error62) => {
+      fail(new Error(`${command} ${args.join(" ")} failed: ${error62.message}`));
+    });
+    child.on("close", (code) => {
+      if (settled) return;
+      if (overflow) {
+        fail(new Error(`${command} ${args.join(" ")} failed: \u51FA\u529B\u304C\u5927\u304D\u3059\u304E\u307E\u3059`));
+        return;
+      }
+      if (code === 0) {
+        succeed({ stdout, stderr });
+        return;
+      }
+      const detail = stderr.trim() || `exit code ${code ?? "unknown"}`;
+      fail(new Error(`${command} ${args.join(" ")} failed: ${detail}`));
+    });
+  });
+}
 
 // packages/core/src/paths.ts
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { join as join2 } from "node:path";
 var APP_DIR = "opencode-skills-deck";
 function configRootOf(platform, env, home) {
-  return env.XDG_CONFIG_HOME ?? (platform === "win32" ? env.APPDATA ?? join(home, "AppData", "Roaming") : join(home, ".config"));
+  return env.XDG_CONFIG_HOME ?? (platform === "win32" ? env.APPDATA ?? join2(home, "AppData", "Roaming") : join2(home, ".config"));
 }
 function stateRootOf(platform, env, home) {
-  return env.XDG_STATE_HOME ?? (platform === "win32" ? env.LOCALAPPDATA ?? join(home, "AppData", "Local") : join(home, ".local", "state"));
+  return env.XDG_STATE_HOME ?? (platform === "win32" ? env.LOCALAPPDATA ?? join2(home, "AppData", "Local") : join2(home, ".local", "state"));
+}
+function opencodeConfigDir(options = {}) {
+  const platform = options.platform ?? process.platform;
+  const env = options.env ?? process.env;
+  const home = options.home ?? homedir();
+  return join2(configRootOf(platform, env, home), "opencode");
+}
+function opencodeSkillsDir(options = {}) {
+  return join2(opencodeConfigDir(options), "skills");
 }
 function repoSessionSlug(repo) {
   return repo.replace(/[^a-zA-Z0-9._-]+/g, "__");
 }
 function sessionsDirFor(paths, repo) {
-  return repo ? join(paths.sessionsDir, repoSessionSlug(repo)) : paths.sessionsDir;
+  return repo ? join2(paths.sessionsDir, repoSessionSlug(repo)) : paths.sessionsDir;
 }
 function resolvePaths(options = {}) {
   const platform = options.platform ?? process.platform;
@@ -19771,34 +19872,155 @@ function resolvePaths(options = {}) {
   const home = options.home ?? homedir();
   const configRoot = configRootOf(platform, env, home);
   const stateRoot = stateRootOf(platform, env, home);
-  const configDir = join(configRoot, APP_DIR);
-  const stateDir = join(stateRoot, APP_DIR);
+  const configDir = join2(configRoot, APP_DIR);
+  const stateDir = join2(stateRoot, APP_DIR);
   return {
     configDir,
     stateDir,
-    sessionsDir: join(stateDir, "sessions"),
-    issueCacheDir: join(stateDir, "issues")
+    sessionsDir: join2(stateDir, "sessions"),
+    issueCacheDir: join2(stateDir, "issues")
   };
 }
 
+// packages/core/src/repo.ts
+import { dirname, join as join3, resolve } from "node:path";
+var REMOTE_PATTERNS = [
+  /^git@[^:]+:(?<owner>[^/]+)\/(?<name>[^/]+?)(?:\.git)?$/,
+  /^(?:ssh|git|https?):\/\/(?:[^@/]+@)?[^/]+\/(?<owner>[^/]+)\/(?<name>[^/]+?)(?:\.git)?\/?$/
+];
+function parseRemoteUrl(url2) {
+  const trimmed = url2.trim();
+  for (const pattern of REMOTE_PATTERNS) {
+    const match = pattern.exec(trimmed);
+    const owner = match?.groups?.owner;
+    const name = match?.groups?.name;
+    if (owner && name) return { owner, name };
+  }
+  return null;
+}
+function slugify2(input2, maxLength = 40) {
+  const base = input2.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  if (!base) return "";
+  return base.slice(0, maxLength).replace(/-+$/g, "");
+}
+function branchName(issueNumber, title) {
+  const slug = slugify2(title);
+  return slug ? `issue/${issueNumber}-${slug}` : `issue/${issueNumber}`;
+}
+function issueWorktreePath(repoRoot, issueNumber) {
+  return join3(repoRoot, ".worktrees", `issue-${issueNumber}`);
+}
+async function resolveRepoRoot(directory, runner) {
+  let worktreeRoot;
+  try {
+    const { stdout } = await runner("git", ["rev-parse", "--show-toplevel"], { cwd: directory });
+    worktreeRoot = stdout.trim();
+    if (!worktreeRoot) return null;
+  } catch {
+    return null;
+  }
+  try {
+    const { stdout } = await runner("git", ["rev-parse", "--path-format=absolute", "--git-common-dir"], {
+      cwd: worktreeRoot
+    });
+    const common = stdout.trim();
+    if (common.endsWith(".git")) return dirname(common);
+  } catch {
+    try {
+      const { stdout } = await runner("git", ["rev-parse", "--git-common-dir"], {
+        cwd: worktreeRoot
+      });
+      const common = resolve(worktreeRoot, stdout.trim());
+      if (common.endsWith(".git")) return dirname(common);
+    } catch {
+    }
+  }
+  return worktreeRoot;
+}
+async function readRepoInfo(directory, runner) {
+  const root = await resolveRepoRoot(directory, runner);
+  if (!root) return null;
+  let remote;
+  try {
+    const { stdout } = await runner("git", ["remote", "get-url", "origin"], { cwd: root });
+    remote = stdout.trim();
+  } catch {
+    return null;
+  }
+  const ref = parseRemoteUrl(remote);
+  if (!ref) return null;
+  let defaultBranch2 = "main";
+  try {
+    const { stdout } = await runner("git", ["symbolic-ref", "--quiet", "refs/remotes/origin/HEAD"], {
+      cwd: root
+    });
+    const value = stdout.trim().replace(/^refs\/remotes\/origin\//, "");
+    if (value) defaultBranch2 = value;
+  } catch {
+  }
+  let branch = defaultBranch2;
+  try {
+    const { stdout } = await runner("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: root });
+    const current = stdout.trim();
+    if (current) branch = current;
+  } catch {
+  }
+  return { root, ref, defaultBranch: defaultBranch2, branch };
+}
+async function resolveRepoContexts(input2) {
+  const contexts = [];
+  if (input2.config.repos.length === 0) {
+    const info = await readRepoInfo(input2.directory, input2.runner);
+    if (info) {
+      contexts.push({
+        repo: `${info.ref.owner}/${info.ref.name}`,
+        root: info.root,
+        info,
+        configured: false
+      });
+    }
+    return contexts;
+  }
+  for (const entry of input2.config.repos) {
+    const root = entry.root ?? input2.directory;
+    const info = await readRepoInfo(root, input2.runner);
+    if (info) {
+      contexts.push({
+        repo: `${info.ref.owner}/${info.ref.name}`,
+        root: info.root,
+        info,
+        configured: true
+      });
+      continue;
+    }
+    contexts.push({ repo: entry.repo, root, info: null, configured: true });
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return contexts.filter((context) => {
+    if (seen.has(context.repo)) return false;
+    seen.add(context.repo);
+    return true;
+  });
+}
+
 // packages/core/src/state.ts
 import {
   existsSync,
   mkdirSync,
   readdirSync,
-  readFileSync,
+  readFileSync as readFileSync2,
   renameSync,
   rmSync,
   watch,
   writeFileSync
 } from "node:fs";
-import { join as join2 } from "node:path";
+import { join as join4 } from "node:path";
 function sessionFilePath(dir, key) {
-  return join2(dir, `${key}.json`);
+  return join4(dir, `${key}.json`);
 }
 function readSession(dir, key) {
   try {
-    const parsed = JSON.parse(readFileSync(sessionFilePath(dir, key), "utf8"));
+    const parsed = JSON.parse(readFileSync2(sessionFilePath(dir, key), "utf8"));
     return typeof parsed?.key === "string" && typeof parsed?.status === "string" ? parsed : null;
   } catch {
     return null;
@@ -19815,9 +20037,9 @@ function writeSession(dir, record2) {
 var PREVIEW_MAX_LINES = 3;
 var PREVIEW_MAX_CHARS = 500;
 function truncatePreview(text, lines = PREVIEW_MAX_LINES, chars = PREVIEW_MAX_CHARS) {
-  const normalized = text.replace(/\r\n?/g, "\n").split(String.fromCharCode(0)).join("").trimEnd();
-  if (!normalized) return "";
-  const tail = normalized.split("\n").slice(-lines).join("\n");
+  const normalized2 = text.replace(/\r\n?/g, "\n").split(String.fromCharCode(0)).join("").trimEnd();
+  if (!normalized2) return "";
+  const tail = normalized2.split("\n").slice(-lines).join("\n");
   return tail.length > chars ? tail.slice(tail.length - chars) : tail;
 }
 function appendPreview(current, chunk) {
@@ -19825,10 +20047,1077 @@ function appendPreview(current, chunk) {
 }
 var SESSION_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
 
+// packages/core/src/worktree.ts
+import { existsSync as existsSync2, readFileSync as readFileSync3, realpathSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join5, resolve as resolve2, sep } from "node:path";
+async function defaultBranch(input2) {
+  if (input2.configured) return input2.configured;
+  try {
+    const { stdout } = await input2.runner("git", ["symbolic-ref", "--quiet", "refs/remotes/origin/HEAD"], {
+      cwd: input2.repoRoot
+    });
+    const value = stdout.trim().replace(/^refs\/remotes\/origin\//, "");
+    if (value) return value;
+  } catch {
+  }
+  return "main";
+}
+async function ensureWorktreesExcluded(input2) {
+  const { stdout } = await input2.runner("git", ["rev-parse", "--git-path", "info/exclude"], {
+    cwd: input2.repoRoot
+  });
+  const path = join5(input2.repoRoot, stdout.trim());
+  const existing = existsSync2(path) ? readFileSync3(path, "utf8") : "";
+  if (existing.split("\n").some((line) => line.trim() === ".worktrees/")) return;
+  const suffix = existing.endsWith("\n") || existing === "" ? "" : "\n";
+  writeFileSync2(path, `${existing}${suffix}.worktrees/
+`);
+}
+async function readWorktreeEntries(input2) {
+  const { stdout } = await input2.runner("git", ["worktree", "list", "--porcelain"], {
+    cwd: input2.repoRoot
+  });
+  const entries = [];
+  let current = null;
+  for (const line of stdout.split("\n")) {
+    if (line.startsWith("worktree ")) {
+      if (current) entries.push(current);
+      current = {
+        directory: line.slice("worktree ".length).trim(),
+        branch: null,
+        detached: false,
+        bare: false
+      };
+      continue;
+    }
+    if (!current) continue;
+    if (line.startsWith("branch ")) {
+      current.branch = line.slice("branch ".length).replace(/^refs\/heads\//, "").trim();
+    } else if (line === "detached") {
+      current.detached = true;
+    } else if (line === "bare") {
+      current.bare = true;
+    }
+  }
+  if (current) entries.push(current);
+  return entries;
+}
+async function registeredWorktrees(input2) {
+  return (await readWorktreeEntries(input2)).map((entry) => entry.directory);
+}
+function normalized(path) {
+  try {
+    return realpathSync(path).replace(/\/+$/, "");
+  } catch {
+    return resolve2(path).replace(/\/+$/, "");
+  }
+}
+async function branchExists(input2) {
+  try {
+    await input2.runner("git", ["show-ref", "--verify", "--quiet", `refs/heads/${input2.branch}`], {
+      cwd: input2.repoRoot
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureWorktree(input2) {
+  const directory = issueWorktreePath(input2.repoRoot, input2.issueNumber);
+  const branch = branchName(input2.issueNumber, input2.title);
+  const base = await defaultBranch({
+    repoRoot: input2.repoRoot,
+    runner: input2.runner,
+    configured: input2.baseBranch
+  });
+  await ensureWorktreesExcluded({ repoRoot: input2.repoRoot, runner: input2.runner });
+  const registered = await registeredWorktrees({ repoRoot: input2.repoRoot, runner: input2.runner });
+  if (registered.includes(directory)) return { directory, branch, base, created: false };
+  if (await branchExists({ repoRoot: input2.repoRoot, runner: input2.runner, branch })) {
+    await input2.runner("git", ["worktree", "add", directory, branch], { cwd: input2.repoRoot });
+    return { directory, branch, base, created: true };
+  }
+  try {
+    await input2.runner("git", ["fetch", "--quiet", "origin", base], { cwd: input2.repoRoot });
+  } catch {
+  }
+  try {
+    await input2.runner("git", ["worktree", "add", "-b", branch, directory, `origin/${base}`], {
+      cwd: input2.repoRoot
+    });
+  } catch {
+    await input2.runner("git", ["worktree", "add", "-b", branch, directory, base], { cwd: input2.repoRoot });
+  }
+  return { directory, branch, base, created: true };
+}
+async function removeWorktree(input2) {
+  const registered = await registeredWorktrees({ repoRoot: input2.repoRoot, runner: input2.runner });
+  if (!registered.includes(input2.directory)) return { removed: false, reason: "missing" };
+  const { stdout } = await input2.runner("git", ["status", "--porcelain"], { cwd: input2.directory });
+  if (stdout.trim() !== "") return { removed: false, reason: "dirty" };
+  await input2.runner("git", ["worktree", "remove", input2.directory], { cwd: input2.repoRoot });
+  return { removed: true };
+}
+function worktreeIssueNumber(directory) {
+  const name = normalized(directory).split("/").at(-1) ?? "";
+  const match = /^issue-(\d+)$/.exec(name);
+  if (!match) return null;
+  const value = Number(match[1]);
+  return Number.isSafeInteger(value) && value > 0 ? value : null;
+}
+function isInsideWorktrees(repoRoot, directory) {
+  const root = normalized(join5(repoRoot, ".worktrees"));
+  return normalized(directory).startsWith(`${root}${sep}`);
+}
+async function readWorktreeStatus(input2) {
+  const entries = await readWorktreeEntries(input2);
+  const entry = entries.find((candidate) => normalized(candidate.directory) === normalized(input2.directory));
+  const exists = existsSync2(input2.directory);
+  let dirty = false;
+  if (exists) {
+    try {
+      const { stdout } = await input2.runner("git", ["status", "--porcelain"], {
+        cwd: input2.directory
+      });
+      dirty = stdout.trim() !== "";
+    } catch {
+      dirty = true;
+    }
+  }
+  return {
+    directory: input2.directory,
+    branch: entry?.branch ?? null,
+    registered: Boolean(entry),
+    exists,
+    dirty,
+    issueNumber: worktreeIssueNumber(input2.directory)
+  };
+}
+async function listIssueWorktrees(input2) {
+  const entries = await readWorktreeEntries(input2);
+  const result = [];
+  for (const entry of entries) {
+    if (!isInsideWorktrees(input2.repoRoot, entry.directory)) continue;
+    const issueNumber = worktreeIssueNumber(entry.directory);
+    if (issueNumber === null) continue;
+    let dirty = false;
+    try {
+      const { stdout } = await input2.runner("git", ["status", "--porcelain"], {
+        cwd: entry.directory
+      });
+      dirty = stdout.trim() !== "";
+    } catch {
+      dirty = true;
+    }
+    result.push({
+      directory: entry.directory,
+      branch: entry.branch,
+      registered: true,
+      exists: existsSync2(entry.directory),
+      dirty,
+      issueNumber
+    });
+  }
+  return result;
+}
+function selectOrphanWorktrees(worktrees, openIssueNumbers) {
+  return worktrees.filter(
+    (worktree) => worktree.issueNumber === null || !openIssueNumbers.has(worktree.issueNumber)
+  );
+}
+
+// packages/core/src/issue.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync4, renameSync as renameSync2, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname2, join as join6 } from "node:path";
+var SUMMARY_HEADING = /summary|要約|概要/i;
+var CRITERIA_HEADING = /acceptance criteria|受け入れ基準|完了条件|acceptance/i;
+var BULLET = /^\s*(?:[-*+]|\d+\.)\s+(?:\[[ xX]\]\s*)?(.+)$/;
+function parseIssueBody(body) {
+  const sections = [{ title: "", lines: [] }];
+  for (const line of body.replace(/\r\n?/g, "\n").split("\n")) {
+    const heading = /^##\s+(.+?)\s*$/.exec(line);
+    if (heading) {
+      sections.push({ title: heading[1] ?? "", lines: [] });
+      continue;
+    }
+    sections[sections.length - 1]?.lines.push(line);
+  }
+  const criteriaSection = sections.find((section) => CRITERIA_HEADING.test(section.title));
+  const summarySection = sections.find((section) => SUMMARY_HEADING.test(section.title));
+  const fallback = sections.find(
+    (section) => section !== criteriaSection && section.lines.some((line) => line.trim() !== "")
+  );
+  const summarySource = summarySection ?? fallback;
+  const summary = collapse((summarySource?.lines ?? []).join("\n"));
+  const criteria = (criteriaSection?.lines ?? []).map((line) => BULLET.exec(line)?.[1]?.trim()).filter((line) => Boolean(line));
+  return { summary, criteria };
+}
+function collapse(text) {
+  return text.split("\n").map((line) => line.trim()).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+function toIssue(raw) {
+  const parsed = parseIssueBody(raw.body ?? "");
+  return {
+    number: raw.number,
+    title: raw.title,
+    labels: (raw.labels ?? []).map((label) => label.name),
+    state: raw.state ?? "OPEN",
+    updatedAt: raw.updatedAt ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+    summary: parsed.summary,
+    criteria: parsed.criteria
+  };
+}
+async function fetchIssues(input2) {
+  const args = [
+    "issue",
+    "list",
+    "--repo",
+    `${input2.repo.owner}/${input2.repo.name}`,
+    "--state",
+    "open",
+    "--limit",
+    String(input2.config.issueLimit),
+    "--json",
+    "number,title,labels,body,state,updatedAt"
+  ];
+  if (input2.config.issueLabelFilter) args.push("--label", input2.config.issueLabelFilter);
+  const { stdout } = await input2.runner("gh", args, { cwd: input2.cwd });
+  const rows = JSON.parse(stdout || "[]");
+  return rows.map(toIssue).sort((left, right) => left.number - right.number);
+}
+function issueCachePath(paths, repo) {
+  return join6(paths.issueCacheDir, `${repo.owner}__${repo.name}.json`);
+}
+function normalizeCachedIssue(value) {
+  if (!value || typeof value !== "object") return null;
+  const issue2 = value;
+  if (typeof issue2.number !== "number" || typeof issue2.title !== "string") return null;
+  return {
+    number: issue2.number,
+    title: issue2.title,
+    labels: Array.isArray(issue2.labels) ? issue2.labels.filter((label) => typeof label === "string") : [],
+    state: typeof issue2.state === "string" ? issue2.state : "OPEN",
+    updatedAt: typeof issue2.updatedAt === "string" ? issue2.updatedAt : (/* @__PURE__ */ new Date(0)).toISOString(),
+    summary: typeof issue2.summary === "string" ? issue2.summary : "",
+    criteria: Array.isArray(issue2.criteria) ? issue2.criteria.filter((criterion) => typeof criterion === "string") : []
+  };
+}
+function readIssueCache(path) {
+  try {
+    const parsed = JSON.parse(readFileSync4(path, "utf8"));
+    if (!Array.isArray(parsed.issues) || typeof parsed.fetchedAt !== "number") {
+      rmSync2(path, { force: true });
+      return null;
+    }
+    const issues = parsed.issues.map(normalizeCachedIssue);
+    if (issues.some((issue2) => issue2 === null)) {
+      rmSync2(path, { force: true });
+      return null;
+    }
+    return { fetchedAt: parsed.fetchedAt, issues };
+  } catch {
+    try {
+      rmSync2(path, { force: true });
+    } catch {
+    }
+    return null;
+  }
+}
+function writeIssueCache(path, cache) {
+  mkdirSync2(dirname2(path), { recursive: true });
+  const temporary = `${path}.${process.pid}.${Date.now()}.tmp`;
+  writeFileSync3(temporary, `${JSON.stringify(cache, null, 2)}
+`);
+  renameSync2(temporary, path);
+}
+var CACHE_TTL_MS = 6e4;
+function classifyGhError(error62) {
+  const message = error62 instanceof Error ? error62.message : String(error62);
+  if (/not authenticated|authentication|401|gh auth login/i.test(message)) {
+    return { code: "auth", message };
+  }
+  if (/rate limit|secondary rate|403/i.test(message)) {
+    return { code: "rate_limit", message };
+  }
+  if (/ENOTFOUND|ECONNREFUSED|ETIMEDOUT|fetch failed|network/i.test(message)) {
+    return { code: "network", message };
+  }
+  if (/^gh\b|gh issue/i.test(message)) return { code: "gh", message };
+  return { code: "unknown", message };
+}
+async function fetchIssue(input2) {
+  const { stdout } = await input2.runner(
+    "gh",
+    [
+      "issue",
+      "view",
+      String(input2.number),
+      "--repo",
+      `${input2.repo.owner}/${input2.repo.name}`,
+      "--json",
+      "number,title,labels,body,state,updatedAt"
+    ],
+    { cwd: input2.cwd }
+  );
+  return toIssue(JSON.parse(stdout));
+}
+function availableLabels(issues) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const issue2 of issues) {
+    for (const label of issue2.labels) {
+      const key = label.toLocaleLowerCase();
+      if (!seen.has(key)) seen.set(key, label);
+    }
+  }
+  return [...seen.values()].sort((left, right) => left.localeCompare(right));
+}
+async function loadIssuesResult(input2) {
+  const path = issueCachePath(input2.paths, input2.repo);
+  const now = input2.now ?? Date.now();
+  const cache = readIssueCache(path);
+  if (!input2.force && cache && now - cache.fetchedAt < CACHE_TTL_MS) {
+    return { issues: cache.issues, cached: true, stale: false, fetchedAt: cache.fetchedAt, error: null };
+  }
+  try {
+    const issues = await fetchIssues({
+      repo: input2.repo,
+      config: input2.config,
+      runner: input2.runner,
+      cwd: input2.cwd
+    });
+    writeIssueCache(path, { fetchedAt: now, issues });
+    return { issues, cached: false, stale: false, fetchedAt: now, error: null };
+  } catch (error62) {
+    const failure3 = classifyGhError(error62);
+    if (cache) {
+      return {
+        issues: cache.issues,
+        cached: true,
+        stale: true,
+        fetchedAt: cache.fetchedAt,
+        error: failure3
+      };
+    }
+    return { issues: [], cached: false, stale: false, fetchedAt: null, error: failure3 };
+  }
+}
+
+// packages/core/src/skills.ts
+import { createHash } from "node:crypto";
+import { cpSync, existsSync as existsSync3, mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync5, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join7, relative, sep as sep2 } from "node:path";
+var MANIFEST_NAME = ".skills-deck.json";
+function hashSkillDir(dir) {
+  const hash2 = createHash("sha256");
+  const walk = (current) => {
+    const entries = readdirSync2(current, { withFileTypes: true }).sort(
+      (left, right) => left.name.localeCompare(right.name)
+    );
+    for (const entry of entries) {
+      const absolute = join7(current, entry.name);
+      const key = relative(dir, absolute).split(sep2).join("/");
+      if (entry.isDirectory()) {
+        hash2.update(`d:${key}
+`);
+        walk(absolute);
+      } else if (entry.isFile()) {
+        hash2.update(`f:${key}
+`);
+        hash2.update(readFileSync5(absolute));
+        hash2.update("\n");
+      }
+    }
+  };
+  walk(dir);
+  return hash2.digest("hex");
+}
+function readManifest(targetDir) {
+  try {
+    const parsed = JSON.parse(readFileSync5(join7(targetDir, MANIFEST_NAME), "utf8"));
+    if (!parsed || typeof parsed.version !== "string" || typeof parsed.skills !== "object") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function writeManifest(targetDir, manifest) {
+  writeFileSync4(join7(targetDir, MANIFEST_NAME), `${JSON.stringify(manifest, null, 2)}
+`);
+}
+function readBundledVersion(sourceDir) {
+  try {
+    return readFileSync5(join7(sourceDir, "VERSION"), "utf8").trim() || "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function skillNames(sourceDir) {
+  if (!existsSync3(sourceDir)) return [];
+  return readdirSync2(sourceDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => existsSync3(join7(sourceDir, name, "SKILL.md"))).sort();
+}
+function bundledSkillNames(sourceDir) {
+  return skillNames(sourceDir);
+}
+function installBundledSkills(input2) {
+  const result = { installed: [], updated: [], skipped: [], unchanged: [] };
+  if (!existsSync3(input2.sourceDir)) return result;
+  mkdirSync3(input2.targetDir, { recursive: true });
+  const version2 = readBundledVersion(input2.sourceDir);
+  const manifest = readManifest(input2.targetDir) ?? { version: version2, skills: {} };
+  const now = new Date(input2.now ?? Date.now()).toISOString();
+  for (const name of skillNames(input2.sourceDir)) {
+    const source = join7(input2.sourceDir, name);
+    const target = join7(input2.targetDir, name);
+    const sourceHash = hashSkillDir(source);
+    if (!existsSync3(target)) {
+      cpSync(source, target, { recursive: true });
+      manifest.skills[name] = { hash: sourceHash, updatedAt: now };
+      result.installed.push(name);
+      continue;
+    }
+    const recorded = manifest.skills[name];
+    const targetHash = hashSkillDir(target);
+    if (!recorded) {
+      if (targetHash === sourceHash) {
+        manifest.skills[name] = { hash: targetHash, updatedAt: now };
+        result.unchanged.push(name);
+      } else {
+        result.skipped.push(name);
+      }
+      continue;
+    }
+    if (recorded.hash !== targetHash) {
+      result.skipped.push(name);
+      continue;
+    }
+    if (sourceHash === targetHash) {
+      result.unchanged.push(name);
+      continue;
+    }
+    rmSync3(target, { recursive: true, force: true });
+    cpSync(source, target, { recursive: true });
+    manifest.skills[name] = { hash: sourceHash, updatedAt: now };
+    result.updated.push(name);
+  }
+  manifest.version = version2;
+  writeManifest(input2.targetDir, manifest);
+  return result;
+}
+
 // packages/core/src/version.ts
 var SUPPORTED_OPENCODE_MIN = "2.3.0";
 var SUPPORTED_OPENCODE_MAX_EXCLUSIVE = "3.0.0";
 var SUPPORTED_OPENCODE_RANGE = `>=${SUPPORTED_OPENCODE_MIN} <${SUPPORTED_OPENCODE_MAX_EXCLUSIVE}`;
+var VERSION = /(\d+)\.(\d+)\.(\d+)/;
+function parseVersion(input2) {
+  if (!input2) return null;
+  const match = VERSION.exec(input2);
+  if (!match) return null;
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  const patch = Number(match[3]);
+  if (!Number.isInteger(major) || !Number.isInteger(minor) || !Number.isInteger(patch)) return null;
+  return [major, minor, patch];
+}
+function compareVersions(left, right) {
+  for (let index = 0; index < 3; index += 1) {
+    const a = left[index] ?? 0;
+    const b = right[index] ?? 0;
+    if (a !== b) return a < b ? -1 : 1;
+  }
+  return 0;
+}
+function isSupportedVersion(input2) {
+  const parsed = parseVersion(input2);
+  if (!parsed) return false;
+  return compareVersions(parsed, [2, 3, 0]) >= 0 && compareVersions(parsed, [3, 0, 0]) < 0;
+}
+function checkOpencodeVersion(input2) {
+  const parsed = parseVersion(input2);
+  if (!parsed) {
+    return {
+      ok: false,
+      version: null,
+      message: `OpenCode \u306E\u30D0\u30FC\u30B8\u30E7\u30F3\u3092\u78BA\u8A8D\u3067\u304D\u307E\u305B\u3093\uFF08\u5BFE\u5FDC: ${SUPPORTED_OPENCODE_RANGE}\uFF09`
+    };
+  }
+  const version2 = parsed.join(".");
+  if (isSupportedVersion(version2)) return { ok: true, version: version2, message: "" };
+  return {
+    ok: false,
+    version: version2,
+    message: `OpenCode ${version2} \u306F\u672A\u5BFE\u5FDC\u3067\u3059\uFF08\u5BFE\u5FDC: ${SUPPORTED_OPENCODE_RANGE}\uFF09\u3002\u52D5\u4F5C\u306F\u4FDD\u8A3C\u3055\u308C\u307E\u305B\u3093`
+  };
+}
+
+// packages/plugin/src/contract.ts
+import { Rpc } from "@opencode/plugin/rpc";
+var repoViewSchema = external_exports.object({
+  /** `owner/name`。 */
+  repo: external_exports.string(),
+  /** メインの作業ツリー（リンクされた worktree から解決してもここに戻す）。 */
+  root: external_exports.string(),
+  branch: external_exports.string(),
+  defaultBranch: external_exports.string(),
+  /** `config.json` の `repos` から来たか。 */
+  configured: external_exports.boolean()
+});
+var issueViewSchema = external_exports.object({
+  number: external_exports.number().int(),
+  title: external_exports.string(),
+  labels: external_exports.array(external_exports.string()),
+  state: external_exports.string(),
+  updatedAt: external_exports.string(),
+  summary: external_exports.string(),
+  criteria: external_exports.array(external_exports.string())
+});
+var worktreeViewSchema = external_exports.object({
+  directory: external_exports.string(),
+  branch: external_exports.string().nullable(),
+  issueNumber: external_exports.number().int().nullable(),
+  registered: external_exports.boolean(),
+  exists: external_exports.boolean(),
+  dirty: external_exports.boolean(),
+  /** そのディレクトリを使っているアプリ内セッションの数。 */
+  sessions: external_exports.number().int()
+});
+var syncViewSchema = external_exports.object({
+  state: external_exports.enum(["fresh", "cached", "stale", "error"]),
+  fetchedAt: external_exports.number().nullable(),
+  message: external_exports.string().nullable(),
+  code: external_exports.enum(["auth", "rate_limit", "network", "gh", "unknown"]).nullable()
+});
+var versionViewSchema = external_exports.object({
+  app: external_exports.string().nullable(),
+  supported: external_exports.boolean(),
+  message: external_exports.string()
+});
+var promptsSchema = external_exports.object({
+  /** `draftPromptIssue`。`{number}` を置換して使う。 */
+  issue: external_exports.string(),
+  /** `draftPromptSkill`。`{skill}` を置換して使う。 */
+  skill: external_exports.string()
+});
+var skillsViewSchema = external_exports.object({
+  /** 同梱スキルの名前。 */
+  available: external_exports.array(external_exports.string()),
+  /** 実際に配置した（または配置済みだった）スキルの名前。 */
+  installed: external_exports.array(external_exports.string())
+});
+var boardSnapshotSchema = external_exports.object({
+  /** 表示中の Repo。解決できなければ null。 */
+  repo: repoViewSchema.nullable(),
+  repos: external_exports.array(repoViewSchema),
+  issues: external_exports.array(issueViewSchema),
+  worktrees: external_exports.array(worktreeViewSchema),
+  /** 検索・ラベル絞り込みのデータ面。 */
+  labels: external_exports.array(external_exports.string()),
+  sync: syncViewSchema,
+  prompts: promptsSchema,
+  version: versionViewSchema,
+  skills: skillsViewSchema,
+  /** Repo が無い・設定が壊れているなど、snapshot 全体の失敗。 */
+  error: external_exports.string().nullable()
+});
+var failureSchema = external_exports.object({
+  code: external_exports.enum(["repo", "issue", "gh", "git", "worktree", "session", "unknown"]),
+  message: external_exports.string()
+});
+var ControlTower = Rpc.define({
+  id: "opencode-skills-deck.control-tower",
+  methods: {
+    boardSnapshot: {
+      input: external_exports.object({
+        /** `owner/name`。省略時はセッションのディレクトリから解決した Repo。 */
+        repo: external_exports.string().optional(),
+        /** gh を呼び直す。 */
+        force: external_exports.boolean().optional()
+      }).optional(),
+      output: boardSnapshotSchema
+    },
+    issueDetail: {
+      input: external_exports.object({
+        repo: external_exports.string().optional(),
+        number: external_exports.number().int()
+      }),
+      output: external_exports.object({
+        issue: issueViewSchema.nullable(),
+        worktree: worktreeViewSchema.nullable(),
+        error: failureSchema.nullable()
+      })
+    },
+    repoList: {
+      input: external_exports.object({ repo: external_exports.string().optional() }).optional(),
+      output: external_exports.object({
+        repos: external_exports.array(repoViewSchema),
+        active: repoViewSchema.nullable()
+      })
+    },
+    repoSwitch: {
+      input: external_exports.object({ repo: external_exports.string() }),
+      output: boardSnapshotSchema
+    },
+    dispatchPrepare: {
+      input: external_exports.object({
+        repo: external_exports.string().optional(),
+        number: external_exports.number().int()
+      }),
+      output: external_exports.discriminatedUnion("ok", [
+        external_exports.object({
+          ok: external_exports.literal(true),
+          issue: issueViewSchema,
+          worktree: worktreeViewSchema,
+          base: external_exports.string(),
+          created: external_exports.boolean(),
+          draft: external_exports.string()
+        }),
+        external_exports.object({ ok: external_exports.literal(false), error: failureSchema })
+      ])
+    },
+    /**
+     * New session 用に、worktree を用意して**その worktree で動くセッション**を作る（#40）。
+     * アプリ 2.3 の `layout.draft` は directory を実行先に使わないため、セッションは server 側で作る。
+     * 送信はしない。プロンプトは GUI が新しいセッションの composer に入れる。
+     */
+    sessionStart: {
+      input: external_exports.object({
+        repo: external_exports.string().optional(),
+        number: external_exports.number().int()
+      }),
+      output: external_exports.discriminatedUnion("ok", [
+        external_exports.object({
+          ok: external_exports.literal(true),
+          sessionID: external_exports.string(),
+          directory: external_exports.string(),
+          worktree: worktreeViewSchema,
+          draft: external_exports.string()
+        }),
+        external_exports.object({ ok: external_exports.literal(false), error: failureSchema })
+      ])
+    },
+    worktreeCleanup: {
+      input: external_exports.object({
+        repo: external_exports.string().optional(),
+        number: external_exports.number().int().optional(),
+        directory: external_exports.string().optional(),
+        /** GUI 上でその worktree のタブが開いているか。 */
+        inUse: external_exports.boolean().optional()
+      }),
+      output: external_exports.object({
+        removed: external_exports.boolean(),
+        reason: external_exports.enum(["removed", "missing", "dirty", "in_use", "outside", "unknown"]),
+        message: external_exports.string().nullable()
+      })
+    },
+    worktreeOrphans: {
+      input: external_exports.object({ repo: external_exports.string().optional() }).optional(),
+      output: external_exports.object({
+        orphans: external_exports.array(worktreeViewSchema),
+        error: failureSchema.nullable()
+      })
+    },
+    sessionResume: {
+      input: external_exports.object({
+        repo: external_exports.string().optional(),
+        number: external_exports.number().int()
+      }),
+      output: external_exports.discriminatedUnion("ok", [
+        external_exports.object({
+          ok: external_exports.literal(true),
+          worktree: worktreeViewSchema.nullable(),
+          draft: external_exports.string(),
+          existing: external_exports.boolean()
+        }),
+        external_exports.object({ ok: external_exports.literal(false), error: failureSchema })
+      ])
+    }
+  },
+  events: {
+    boardChanged: {
+      schema: external_exports.object({
+        repo: external_exports.string(),
+        fetchedAt: external_exports.number()
+      })
+    }
+  }
+});
+
+// packages/plugin/src/rpc-handlers.ts
+function toRepoView(context) {
+  return {
+    repo: context.repo,
+    root: context.root,
+    branch: context.info?.branch ?? "?",
+    defaultBranch: context.info?.defaultBranch ?? "main",
+    configured: context.configured
+  };
+}
+function toIssueView(issue2) {
+  return {
+    number: issue2.number,
+    title: issue2.title,
+    labels: issue2.labels,
+    state: issue2.state,
+    updatedAt: issue2.updatedAt,
+    summary: issue2.summary,
+    criteria: issue2.criteria
+  };
+}
+function toSyncView(result) {
+  let state;
+  if (result.error) state = result.cached ? "stale" : "error";
+  else state = result.cached ? "cached" : "fresh";
+  return {
+    state,
+    fetchedAt: result.fetchedAt,
+    message: result.error?.message ?? null,
+    code: result.error?.code ?? null
+  };
+}
+function versionView(appVersion) {
+  const check2 = checkOpencodeVersion(appVersion);
+  return { app: check2.version, supported: check2.ok, message: check2.message };
+}
+function failure2(code, error62) {
+  return { code, message: error62 instanceof Error ? error62.message : String(error62) };
+}
+async function resolveActive(input2) {
+  const contexts = await resolveRepoContexts({
+    config: input2.ctx.config,
+    directory: input2.ctx.directory,
+    runner: input2.ctx.runner
+  });
+  const active = input2.repo ? contexts.find((context) => context.repo === input2.repo) ?? null : contexts[0] ?? null;
+  return { repos: contexts.map(toRepoView), active, contexts };
+}
+async function toWorktreeView(ctx, status) {
+  const sessions = ctx.sessionsIn ? await ctx.sessionsIn(status.directory) : 0;
+  return {
+    directory: status.directory,
+    branch: status.branch,
+    issueNumber: status.issueNumber,
+    registered: status.registered,
+    exists: status.exists,
+    dirty: status.dirty,
+    sessions
+  };
+}
+async function worktreeForIssue(ctx, repoRoot, issueNumber) {
+  const directory = issueWorktreePath(repoRoot, issueNumber);
+  const status = await readWorktreeStatus({
+    repoRoot,
+    directory,
+    runner: ctx.runner
+  });
+  return toWorktreeView(ctx, status);
+}
+async function snapshot(input2) {
+  const { repos, active } = await resolveActive(input2);
+  const base = {
+    repo: active ? toRepoView(active) : null,
+    repos,
+    issues: [],
+    worktrees: [],
+    labels: [],
+    sync: { state: "error", fetchedAt: null, message: null, code: null },
+    prompts: {
+      issue: input2.ctx.config.draftPromptIssue,
+      skill: input2.ctx.config.draftPromptSkill
+    },
+    version: versionView(input2.ctx.appVersion),
+    skills: input2.ctx.skills,
+    error: null
+  };
+  if (!active) {
+    return {
+      ...base,
+      error: repos.length === 0 ? "Could not resolve a repo context. Open a git repository or set repos in config.json." : `Repo ${input2.repo ?? ""} was not found.`
+    };
+  }
+  const result = await loadIssuesResult({
+    paths: input2.ctx.paths,
+    repo: repoRef(active),
+    config: input2.ctx.config,
+    runner: input2.ctx.runner,
+    cwd: active.root,
+    force: input2.force,
+    now: input2.ctx.now
+  });
+  const worktrees = await listIssueWorktrees({
+    repoRoot: active.root,
+    runner: input2.ctx.runner
+  });
+  const views = [];
+  for (const worktree of worktrees) views.push(await toWorktreeView(input2.ctx, worktree));
+  return {
+    ...base,
+    issues: [...result.issues].sort((left, right) => left.number - right.number).map(toIssueView),
+    worktrees: views,
+    labels: availableLabels(result.issues),
+    sync: toSyncView(result)
+  };
+}
+function emitChanged(ctx, repo) {
+  ctx.emit?.("boardChanged", { repo, fetchedAt: ctx.now });
+}
+function createControlTowerHandlers(getContext) {
+  return {
+    async boardSnapshot(input2) {
+      return snapshot({ ctx: await getContext(), repo: input2?.repo, force: input2?.force });
+    },
+    async issueDetail(input2) {
+      const ctx = await getContext();
+      const { active } = await resolveActive({ ctx, repo: input2.repo });
+      if (!active) return { issue: null, worktree: null, error: failure2("repo", "Repo was not found.") };
+      const result = await loadIssuesResult({
+        paths: ctx.paths,
+        repo: repoRef(active),
+        config: ctx.config,
+        runner: ctx.runner,
+        cwd: active.root,
+        now: ctx.now
+      });
+      let issue2 = result.issues.find((candidate) => candidate.number === input2.number);
+      if (!issue2) {
+        try {
+          issue2 = await fetchIssue({
+            repo: repoRef(active),
+            number: input2.number,
+            runner: ctx.runner,
+            cwd: active.root
+          });
+        } catch (error62) {
+          return {
+            issue: null,
+            worktree: null,
+            error: failure2("issue", classifyGhError(error62).message)
+          };
+        }
+      }
+      return {
+        issue: toIssueView(issue2),
+        worktree: await worktreeForIssue(ctx, active.root, input2.number),
+        error: null
+      };
+    },
+    async repoList(input2) {
+      const ctx = await getContext();
+      const { repos, active } = await resolveActive({ ctx, repo: input2?.repo });
+      return { repos, active: active ? toRepoView(active) : null };
+    },
+    async repoSwitch(input2) {
+      return snapshot({ ctx: await getContext(), repo: input2.repo });
+    },
+    async dispatchPrepare(input2) {
+      const ctx = await getContext();
+      const { active } = await resolveActive({ ctx, repo: input2.repo });
+      if (!active) return { ok: false, error: failure2("repo", "Repo was not found.") };
+      let issue2;
+      try {
+        const result = await loadIssuesResult({
+          paths: ctx.paths,
+          repo: repoRef(active),
+          config: ctx.config,
+          runner: ctx.runner,
+          cwd: active.root,
+          now: ctx.now
+        });
+        issue2 = result.issues.find((candidate) => candidate.number === input2.number);
+      } catch (error62) {
+        return { ok: false, error: failure2("gh", classifyGhError(error62).message) };
+      }
+      if (!issue2) {
+        try {
+          issue2 = await fetchIssue({
+            repo: repoRef(active),
+            number: input2.number,
+            runner: ctx.runner,
+            cwd: active.root
+          });
+        } catch (error62) {
+          return { ok: false, error: failure2("issue", classifyGhError(error62).message) };
+        }
+      }
+      try {
+        const plan = await ensureWorktree({
+          repoRoot: active.root,
+          issueNumber: issue2.number,
+          title: issue2.title,
+          baseBranch: ctx.config.baseBranch,
+          runner: ctx.runner
+        });
+        emitChanged(ctx, active.repo);
+        return {
+          ok: true,
+          issue: toIssueView(issue2),
+          worktree: await worktreeForIssue(ctx, active.root, issue2.number),
+          base: plan.base,
+          created: plan.created,
+          draft: fillTemplate(ctx.config.draftPromptIssue, { number: issue2.number })
+        };
+      } catch (error62) {
+        return { ok: false, error: failure2("git", error62) };
+      }
+    },
+    async sessionStart(input2) {
+      const ctx = await getContext();
+      const { active } = await resolveActive({ ctx, repo: input2.repo });
+      if (!active) return { ok: false, error: failure2("repo", "Repo was not found.") };
+      let issue2;
+      try {
+        const result = await loadIssuesResult({
+          paths: ctx.paths,
+          repo: repoRef(active),
+          config: ctx.config,
+          runner: ctx.runner,
+          cwd: active.root,
+          now: ctx.now
+        });
+        issue2 = result.issues.find((candidate) => candidate.number === input2.number);
+      } catch (error62) {
+        return { ok: false, error: failure2("gh", classifyGhError(error62).message) };
+      }
+      if (!issue2) {
+        try {
+          issue2 = await fetchIssue({
+            repo: repoRef(active),
+            number: input2.number,
+            runner: ctx.runner,
+            cwd: active.root
+          });
+        } catch (error62) {
+          return { ok: false, error: failure2("issue", classifyGhError(error62).message) };
+        }
+      }
+      try {
+        const plan = await ensureWorktree({
+          repoRoot: active.root,
+          issueNumber: issue2.number,
+          title: issue2.title,
+          baseBranch: ctx.config.baseBranch,
+          runner: ctx.runner
+        });
+        if (!ctx.createSession) {
+          return { ok: false, error: failure2("session", "Sessions cannot be created here.") };
+        }
+        const sessionID = await ctx.createSession(plan.directory);
+        emitChanged(ctx, active.repo);
+        return {
+          ok: true,
+          sessionID,
+          directory: plan.directory,
+          worktree: await worktreeForIssue(ctx, active.root, issue2.number),
+          draft: fillTemplate(ctx.config.draftPromptIssue, { number: issue2.number })
+        };
+      } catch (error62) {
+        return { ok: false, error: failure2("session", error62) };
+      }
+    },
+    async worktreeCleanup(input2) {
+      const ctx = await getContext();
+      const { active } = await resolveActive({ ctx, repo: input2.repo });
+      if (!active) {
+        return { removed: false, reason: "unknown", message: "Repo was not found." };
+      }
+      const directory = input2.directory ?? (input2.number !== void 0 ? issueWorktreePath(active.root, input2.number) : null);
+      if (!directory) {
+        return {
+          removed: false,
+          reason: "unknown",
+          message: "Pass number or directory."
+        };
+      }
+      if (!isInsideWorktrees(active.root, directory)) {
+        return {
+          removed: false,
+          reason: "outside",
+          message: "Only worktrees under .worktrees/ can be cleaned."
+        };
+      }
+      if (input2.inUse) {
+        return { removed: false, reason: "in_use", message: "A tab for this worktree is open." };
+      }
+      const result = await removeWorktree({
+        repoRoot: active.root,
+        directory,
+        runner: ctx.runner
+      });
+      if (result.removed) emitChanged(ctx, active.repo);
+      return {
+        removed: result.removed,
+        reason: result.removed ? "removed" : result.reason ?? "unknown",
+        message: result.reason === "dirty" ? "Uncommitted changes; the worktree cannot be cleaned." : result.reason === "missing" ? "The worktree was not found." : null
+      };
+    },
+    async worktreeOrphans(input2) {
+      const ctx = await getContext();
+      const { active } = await resolveActive({ ctx, repo: input2?.repo });
+      if (!active) {
+        return { orphans: [], error: failure2("repo", "Repo was not found.") };
+      }
+      const result = await loadIssuesResult({
+        paths: ctx.paths,
+        repo: repoRef(active),
+        config: ctx.config,
+        runner: ctx.runner,
+        cwd: active.root,
+        now: ctx.now
+      });
+      if (result.error && !result.cached) {
+        return { orphans: [], error: failure2("gh", result.error.message) };
+      }
+      const worktrees = await listIssueWorktrees({
+        repoRoot: active.root,
+        runner: ctx.runner
+      });
+      const orphans = selectOrphanWorktrees(worktrees, new Set(result.issues.map((issue2) => issue2.number)));
+      const views = [];
+      for (const orphan of orphans) views.push(await toWorktreeView(ctx, orphan));
+      return {
+        orphans: views,
+        error: result.error ? failure2("gh", result.error.message) : null
+      };
+    },
+    async sessionResume(input2) {
+      const ctx = await getContext();
+      const { active } = await resolveActive({ ctx, repo: input2.repo });
+      if (!active) return { ok: false, error: failure2("repo", "Repo was not found.") };
+      let issue2;
+      try {
+        const result = await loadIssuesResult({
+          paths: ctx.paths,
+          repo: repoRef(active),
+          config: ctx.config,
+          runner: ctx.runner,
+          cwd: active.root,
+          now: ctx.now
+        });
+        issue2 = result.issues.find((candidate) => candidate.number === input2.number);
+      } catch {
+        issue2 = void 0;
+      }
+      const draft = fillTemplate(ctx.config.draftPromptIssue, { number: input2.number });
+      if (!issue2) {
+        return {
+          ok: false,
+          error: failure2("issue", `Issue #${input2.number} was not found.`)
+        };
+      }
+      const worktree = await worktreeForIssue(ctx, active.root, input2.number);
+      return {
+        ok: true,
+        worktree,
+        draft,
+        existing: worktree.registered && worktree.exists
+      };
+    }
+  };
+}
+function repoRef(context) {
+  if (context.info) return context.info.ref;
+  const [owner = "unknown", name = context.repo] = context.repo.split("/");
+  return { owner, name };
+}
 
 // packages/plugin/src/status.ts
 function sessionIDOf(event) {
@@ -19909,103 +21198,151 @@ var KEY = process.env.SKILLS_DECK_KEY;
 var REPO = process.env.SKILLS_DECK_REPO ?? "";
 var KIND = process.env.SKILLS_DECK_KIND === "dialogue" ? "dialogue" : "issue";
 var PREVIEW_FLUSH_MS = 400;
+function setupChildSession(ctx) {
+  const paths = resolvePaths();
+  const sessionsDir = sessionsDirFor(paths, REPO || null);
+  const stamp = () => (/* @__PURE__ */ new Date()).toISOString();
+  const patch = (update) => {
+    const current = readSession(sessionsDir, KEY);
+    if (!current) return;
+    writeSession(sessionsDir, mergeRecord(current, update, process.pid, stamp()));
+  };
+  const initial = readSession(sessionsDir, KEY);
+  const record2 = initial ?? {
+    key: KEY,
+    kind: KIND,
+    repo: REPO,
+    label: KEY,
+    pid: process.pid,
+    status: "input_wait",
+    reason: "idle",
+    createdAt: stamp(),
+    updatedAt: stamp()
+  };
+  writeSession(sessionsDir, {
+    ...record2,
+    pid: process.pid,
+    status: "input_wait",
+    reason: "idle",
+    updatedAt: stamp()
+  });
+  let boundSessionID = record2.opencodeSessionID;
+  let preview = record2.preview ?? "";
+  let previewDirty = false;
+  let flushTimer;
+  const flushPreview = () => {
+    if (!previewDirty) return;
+    previewDirty = false;
+    patch({ preview });
+  };
+  const scheduleFlush = () => {
+    if (flushTimer) return;
+    flushTimer = setTimeout(() => {
+      flushTimer = void 0;
+      flushPreview();
+    }, PREVIEW_FLUSH_MS);
+    flushTimer.unref?.();
+  };
+  const controller = new AbortController();
+  const onExit = () => {
+    try {
+      flushPreview();
+      patch({ status: "exited", exitedAt: stamp() });
+    } catch {
+    }
+  };
+  process.once("exit", onExit);
+  void (async () => {
+    try {
+      for await (const event of ctx.event.subscribe({ signal: controller.signal })) {
+        const typed = event;
+        const sessionID = sessionIDOf(typed);
+        if (!boundSessionID && sessionID) {
+          boundSessionID = sessionID;
+          patch({ opencodeSessionID: sessionID });
+        } else if (boundSessionID && sessionID && sessionID !== boundSessionID) {
+          continue;
+        }
+        const update = mapEvent(typed);
+        if (update) {
+          if (update.status === "exited") {
+            preview = "";
+            previewDirty = false;
+            if (flushTimer) clearTimeout(flushTimer);
+            flushTimer = void 0;
+            patch({ ...update, preview: "" });
+          } else if (typed.type === "session.execution.started") {
+            preview = "";
+            previewDirty = false;
+            patch({ ...update, preview: "" });
+          } else {
+            patch(update);
+          }
+        }
+        const delta = textDeltaOf(typed);
+        if (delta) {
+          preview = appendPreview(preview, delta);
+          previewDirty = true;
+          scheduleFlush();
+        }
+      }
+    } catch {
+    }
+  })();
+  return () => {
+    controller.abort();
+    process.off("exit", onExit);
+  };
+}
 var index_default = Plugin.define({
   id: "opencode-skills-deck",
   async setup(ctx) {
-    if (!KEY) return;
     const paths = resolvePaths();
-    const sessionsDir = sessionsDirFor(paths, REPO || null);
-    const stamp = () => (/* @__PURE__ */ new Date()).toISOString();
-    const patch = (update) => {
-      const current = readSession(sessionsDir, KEY);
-      if (!current) return;
-      writeSession(sessionsDir, mergeRecord(current, update, process.pid, stamp()));
-    };
-    const initial = readSession(sessionsDir, KEY);
-    const record2 = initial ?? {
-      key: KEY,
-      kind: KIND,
-      repo: REPO,
-      label: KEY,
-      pid: process.pid,
-      status: "input_wait",
-      reason: "idle",
-      createdAt: stamp(),
-      updatedAt: stamp()
-    };
-    writeSession(sessionsDir, {
-      ...record2,
-      pid: process.pid,
-      status: "input_wait",
-      reason: "idle",
-      updatedAt: stamp()
-    });
-    let boundSessionID = record2.opencodeSessionID;
-    let preview = record2.preview ?? "";
-    let previewDirty = false;
-    let flushTimer;
-    const flushPreview = () => {
-      if (!previewDirty) return;
-      previewDirty = false;
-      patch({ preview });
-    };
-    const scheduleFlush = () => {
-      if (flushTimer) return;
-      flushTimer = setTimeout(() => {
-        flushTimer = void 0;
-        flushPreview();
-      }, PREVIEW_FLUSH_MS);
-      flushTimer.unref?.();
-    };
-    const controller = new AbortController();
-    const onExit = () => {
+    const config2 = loadConfig(paths);
+    const sourceDir = fileURLToPath(new URL("../resources/skills", import.meta.url));
+    const available = bundledSkillNames(sourceDir);
+    let installed = available;
+    if (config2.installSkillsOnStart) {
       try {
-        flushPreview();
-        patch({ status: "exited", exitedAt: stamp() });
+        const result = installBundledSkills({
+          sourceDir,
+          targetDir: opencodeSkillsDir()
+        });
+        installed = [
+          .../* @__PURE__ */ new Set([...result.installed, ...result.updated, ...result.unchanged, ...result.skipped])
+        ];
       } catch {
-      }
-    };
-    process.once("exit", onExit);
-    void (async () => {
-      try {
-        for await (const event of ctx.event.subscribe({ signal: controller.signal })) {
-          const typed = event;
-          const sessionID = sessionIDOf(typed);
-          if (!boundSessionID && sessionID) {
-            boundSessionID = sessionID;
-            patch({ opencodeSessionID: sessionID });
-          } else if (boundSessionID && sessionID && sessionID !== boundSessionID) {
-            continue;
-          }
-          const update = mapEvent(typed);
-          if (update) {
-            if (update.status === "exited") {
-              preview = "";
-              previewDirty = false;
-              if (flushTimer) clearTimeout(flushTimer);
-              flushTimer = void 0;
-              patch({ ...update, preview: "" });
-            } else if (typed.type === "session.execution.started") {
-              preview = "";
-              previewDirty = false;
-              patch({ ...update, preview: "" });
-            } else {
-              patch(update);
-            }
-          }
-          const delta = textDeltaOf(typed);
-          if (delta) {
-            preview = appendPreview(preview, delta);
-            previewDirty = true;
-            scheduleFlush();
-          }
+        installed = [];
+      }
+    }
+    let registration;
+    registration = await ctx.rpc.register(
+      ControlTower,
+      createControlTowerHandlers(async () => ({
+        directory: ctx.location.directory,
+        config: config2,
+        paths,
+        runner: createRunner(),
+        now: Date.now(),
+        appVersion: ctx.app.version ?? null,
+        skills: { available, installed },
+        sessionsIn: async (directory) => {
+          const response = await ctx.session.list({ directory });
+          return response.data.length;
+        },
+        createSession: async (directory) => {
+          const info = await ctx.session.create({ location: { directory } });
+          return info.id;
+        },
+        emit: (event, data) => {
+          void registration?.events.emit(event, data);
         }
-      } catch {
-      }
-    })();
+      }))
+    );
+    const childCleanup = KEY ? setupChildSession(ctx) : void 0;
     return () => {
-      controller.abort();
-      process.off("exit", onExit);
+      childCleanup?.();
+      void registration?.dispose();
     };
   }
 });