@unlaxer/dve-toolkit 4.1.0

package/server/api.ts

@@ -0,0 +1,297 @@
+// DVE lightweight API server — annotation write + drift detection
+// Runs alongside vite preview, not a separate process
+
+import { createServer } from "node:http";
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, statSync } from "node:fs";
+import { execSync } from "node:child_process";
+import path from "node:path";
+import type { DVEGraph } from "../graph/schema.js";
+import { detectProjectState } from "../parser/state-detector.js";
+import { handleSlashCommand, handleEvent } from "./slack.js";
+
+interface APIConfig {
+  annotationsDir: string;
+  distDir: string;
+  projectDirs: { name: string; path: string; decisionsDir: string }[];
+}
+
+function parseBody(req: any): Promise<any> {
+  return new Promise((resolve) => {
+    let body = "";
+    req.on("data", (chunk: string) => (body += chunk));
+    req.on("end", () => {
+      try { resolve(JSON.parse(body)); }
+      catch { resolve({}); }
+    });
+  });
+}
+
+function cors(res: any) {
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+}
+
+function json(res: any, data: any, status = 200) {
+  cors(res);
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(data));
+}
+
+export function startAPIServer(config: APIConfig, port = 4174) {
+  const server = createServer(async (req, res) => {
+    cors(res);
+    if (req.method === "OPTIONS") { res.writeHead(204); res.end(); return; }
+
+    const url = new URL(req.url ?? "/", `http://localhost:${port}`);
+
+    // POST /api/annotations — create annotation
+    if (req.method === "POST" && url.pathname === "/api/annotations") {
+      const body = await parseBody(req);
+      const { target, action, author, body: text } = body;
+      if (!target || !text) {
+        return json(res, { error: "target and body required" }, 400);
+      }
+
+      mkdirSync(config.annotationsDir, { recursive: true });
+      const existing = existsSync(config.annotationsDir)
+        ? readdirSync(config.annotationsDir).filter((f) => f.endsWith(".md")).length
+        : 0;
+      const annNum = String(existing + 1).padStart(3, "0");
+      const slug = target.replace(/[^a-zA-Z0-9-]/g, "_");
+      const filename = `${annNum}-${slug}-${action ?? "comment"}.md`;
+      const filePath = path.join(config.annotationsDir, filename);
+
+      const content = `---
+target: ${target}
+action: ${action ?? "comment"}
+date: ${new Date().toISOString().split("T")[0]}
+author: ${author ?? ""}
+---
+
+${text}
+`;
+      writeFileSync(filePath, content);
+      return json(res, { ok: true, file: filename });
+    }
+
+    // GET /api/drift — detect decisions that may have drifted
+    if (req.method === "GET" && url.pathname === "/api/drift") {
+      const drifted: { dd: string; file: string; lastModified: string; ddDate: string }[] = [];
+
+      for (const proj of config.projectDirs) {
+        const graphPath = path.join(config.distDir, `graph-${proj.name}.json`);
+        const fallback = path.join(config.distDir, "graph.json");
+        const gp = existsSync(graphPath) ? graphPath : fallback;
+        if (!existsSync(gp)) continue;
+
+        const graph: DVEGraph = JSON.parse(readFileSync(gp, "utf-8"));
+        const ddNodes = graph.nodes.filter((n) => n.type === "decision");
+
+        for (const dd of ddNodes) {
+          const data = dd.data as any;
+          if (!data.file_path || data.status === "overturned") continue;
+
+          // Check git: files changed since DD date
+          try {
+            const since = data.date || "2020-01-01";
+            const log = execSync(
+              `git log --oneline --since="${since}" -- .`,
+              { cwd: proj.path, encoding: "utf-8", timeout: 5000 }
+            ).trim();
+            if (log.split("\n").length > 5) {
+              // Many commits since DD — potential drift
+              const ddFile = path.join(proj.path, data.file_path);
+              if (existsSync(ddFile)) {
+                const stat = statSync(ddFile);
+                drifted.push({
+                  dd: dd.id,
+                  file: data.file_path,
+                  lastModified: stat.mtime.toISOString(),
+                  ddDate: since,
+                });
+              }
+            }
+          } catch { /* git not available */ }
+        }
+      }
+
+      return json(res, { drifted });
+    }
+
+    // GET /api/coverage — character coverage analysis
+    if (req.method === "GET" && url.pathname === "/api/coverage") {
+      const graphPath = path.join(config.distDir, "graph.json");
+      if (!existsSync(graphPath)) return json(res, { error: "graph.json not found" }, 404);
+
+      const graph: DVEGraph = JSON.parse(readFileSync(graphPath, "utf-8"));
+      const charGaps: Record<string, { total: number; critical: number; high: number }> = {};
+
+      // Count gaps per session's characters
+      const sessions = graph.nodes.filter((n) => n.type === "session");
+      for (const session of sessions) {
+        const chars = (session.data as any).characters ?? [];
+        const sessionGaps = graph.edges
+          .filter((e) => e.source === session.id && e.type === "discovers")
+          .map((e) => graph.nodes.find((n) => n.id === e.target))
+          .filter(Boolean);
+
+        for (const char of chars) {
+          if (!charGaps[char]) charGaps[char] = { total: 0, critical: 0, high: 0 };
+          charGaps[char].total += sessionGaps.length;
+          charGaps[char].critical += sessionGaps.filter((g) => (g!.data as any).severity === "Critical").length;
+          charGaps[char].high += sessionGaps.filter((g) => (g!.data as any).severity === "High").length;
+        }
+      }
+
+      return json(res, { coverage: charGaps });
+    }
+
+    // POST /api/scan — scan directory for DxE projects
+    if (req.method === "POST" && url.pathname === "/api/scan") {
+      const body = await parseBody(req);
+      const scanDir = body.dir ?? path.resolve(config.distDir, "..", "..", "..");
+      const maxDepth = body.depth ?? 3;
+      const results: any[] = [];
+
+      function scanRec(dir: string, depth: number) {
+        if (depth > maxDepth) return;
+        let entries: string[];
+        try { entries = readdirSync(dir); } catch { return; }
+
+        const isProject = entries.includes(".git") || entries.includes("package.json");
+        if (isProject) {
+          const hasDGE = existsSync(path.join(dir, "dge")) || existsSync(path.join(dir, ".claude", "skills", "dge-session.md"));
+          const hasDRE = existsSync(path.join(dir, ".claude", ".dre-version")) || existsSync(path.join(dir, "dre"));
+          const hasDVE = existsSync(path.join(dir, "dve")) || existsSync(path.join(dir, ".claude", "skills", "dve-build.md"));
+          const hasDDE = existsSync(path.join(dir, "dde"));
+
+          let sessions = 0, decisions = 0;
+          const sd = path.join(dir, "dge", "sessions");
+          const dd = path.join(dir, "dge", "decisions");
+          if (existsSync(sd)) try { sessions = readdirSync(sd).filter((f: string) => f.endsWith(".md") && f !== "index.md").length; } catch {}
+          if (existsSync(dd)) try { decisions = readdirSync(dd).filter((f: string) => f.endsWith(".md") && f !== "index.md").length; } catch {}
+
+          if (hasDGE || hasDRE || hasDVE || hasDDE || sessions > 0) {
+            results.push({ name: path.basename(dir), path: dir, hasDGE, hasDRE, hasDVE, hasDDE, sessions, decisions });
+          }
+        }
+
+        const skip = new Set(["node_modules", ".git", "dist", "build", ".dre", ".claude", "dve", "dge", "dre", "dde"]);
+        for (const e of entries) {
+          if (skip.has(e) || e.startsWith(".")) continue;
+          const full = path.join(dir, e);
+          try { if (statSync(full).isDirectory()) scanRec(full, depth + 1); } catch {}
+        }
+      }
+
+      scanRec(scanDir, 0);
+      return json(res, { dir: scanDir, projects: results });
+    }
+
+    // POST /api/register — save scanned projects to dve.config.json
+    if (req.method === "POST" && url.pathname === "/api/register") {
+      const body = await parseBody(req);
+      const projects = body.projects ?? [];
+      const configPath = path.join(config.distDir, "..", "..", "dve.config.json");
+      const newConfig = {
+        outputDir: config.distDir,
+        projects: projects.map((p: any) => ({
+          name: p.name,
+          path: p.path,
+        })),
+      };
+      writeFileSync(configPath, JSON.stringify(newConfig, null, 2) + "\n");
+      return json(res, { ok: true, registered: projects.length, configPath });
+    }
+
+    // GET /api/status — project states (DRE + phase)
+    if (req.method === "GET" && url.pathname === "/api/status") {
+      const states = config.projectDirs.map((p) =>
+        detectProjectState(p.name, p.path)
+      );
+      return json(res, {
+        projects: states,
+        stateChart: {
+          phases: ["spec", "implementation", "stabilization", "maintenance"],
+          dreStates: ["FRESH", "INSTALLED", "CUSTOMIZED", "OUTDATED"],
+        },
+      });
+    }
+
+    // ─── Slack Integration ───
+
+    // POST /api/slack/command — slash command handler
+    if (req.method === "POST" && url.pathname === "/api/slack/command") {
+      // Slack sends x-www-form-urlencoded, not JSON
+      const rawBody = await new Promise<string>((resolve) => {
+        let b = ""; req.on("data", (c: string) => b += c); req.on("end", () => resolve(b));
+      });
+      const params = new URLSearchParams(rawBody);
+      const text = params.get("text") ?? "";
+      const response = handleSlashCommand(text, config.distDir, config.projectDirs);
+      return json(res, response);
+    }
+
+    // POST /api/slack/events — Events API handler
+    if (req.method === "POST" && url.pathname === "/api/slack/events") {
+      const body = await parseBody(req);
+
+      // URL verification challenge
+      if (body.type === "url_verification") {
+        return json(res, { challenge: body.challenge });
+      }
+
+      // Event callback
+      if (body.type === "event_callback" && body.event) {
+        const reply = handleEvent(body.event, config.distDir);
+        if (reply && body.event.channel) {
+          // Post reply via Slack API
+          const token = process.env.SLACK_BOT_TOKEN;
+          if (token) {
+            const fetch = globalThis.fetch ?? (await import("node:https")).request;
+            try {
+              await globalThis.fetch("https://slack.com/api/chat.postMessage", {
+                method: "POST",
+                headers: { "Authorization": `Bearer ${token}`, "Content-Type": "application/json" },
+                body: JSON.stringify({ channel: body.event.channel, text: reply }),
+              });
+            } catch { /* best effort */ }
+          }
+        }
+        return json(res, { ok: true });
+      }
+
+      return json(res, { ok: true });
+    }
+
+    // POST /api/slack/interactive — button clicks from Block Kit
+    if (req.method === "POST" && url.pathname === "/api/slack/interactive") {
+      const rawBody = await new Promise<string>((resolve) => {
+        let b = ""; req.on("data", (c: string) => b += c); req.on("end", () => resolve(b));
+      });
+      const params = new URLSearchParams(rawBody);
+      const payloadStr = params.get("payload") ?? "{}";
+      const payload = JSON.parse(payloadStr);
+
+      if (payload.type === "block_actions" && payload.actions?.[0]) {
+        const action = payload.actions[0];
+        const nodeId = action.value;
+        // Respond with trace/detail for the clicked node
+        const response = handleSlashCommand(`trace ${nodeId}`, config.distDir, config.projectDirs);
+        return json(res, response);
+      }
+
+      return json(res, { ok: true });
+    }
+
+    // 404
+    json(res, { error: "Not found" }, 404);
+  });
+
+  server.listen(port, "0.0.0.0", () => {
+    console.log(`  DVE API: http://0.0.0.0:${port}`);
+  });
+
+  return server;
+}

package/server/slack.ts

@@ -0,0 +1,217 @@
+// DVE Slack Bot — slash commands + event handling
+// Endpoints: POST /api/slack/command, POST /api/slack/events
+
+import { readFileSync, existsSync } from "node:fs";
+import path from "node:path";
+import { traceDecision, impactOf, orphanGaps, search, overturned } from "../graph/query.js";
+import { detectProjectState } from "../parser/state-detector.js";
+import type { DVEGraph, Gap, Decision } from "../graph/schema.js";
+
+function loadGraph(distDir: string, project?: string): DVEGraph | null {
+  const file = project
+    ? path.join(distDir, `graph-${project}.json`)
+    : path.join(distDir, "graph.json");
+  if (!existsSync(file)) return null;
+  return JSON.parse(readFileSync(file, "utf-8"));
+}
+
+// ─── Slash Command Handler ───
+// /dve trace DD-003
+// /dve orphans
+// /dve status
+// /dve search JWT
+// /dve help
+
+export function handleSlashCommand(
+  text: string,
+  distDir: string,
+  projectDirs: { name: string; path: string }[]
+): { response_type: string; text: string; blocks?: any[] } {
+  const parts = text.trim().split(/\s+/);
+  const cmd = parts[0]?.toLowerCase() ?? "help";
+  const args = parts.slice(1);
+
+  const graph = loadGraph(distDir);
+  if (!graph && cmd !== "help" && cmd !== "status") {
+    return { response_type: "ephemeral", text: "❌ graph.json not found. Run `dve build` first." };
+  }
+
+  switch (cmd) {
+    case "trace": {
+      if (!args[0]) return { response_type: "ephemeral", text: "Usage: /dve trace DD-001" };
+      const chain = traceDecision(graph!, args[0]);
+      if (chain.length === 0) return { response_type: "ephemeral", text: `❌ ${args[0]} not found.` };
+
+      const lines = chain.map((n) => {
+        const d = n.data as any;
+        switch (n.type) {
+          case "decision": return `📋 *${n.id}*: ${d.title} (${d.date}) [${d.status}]`;
+          case "gap": return `  ← 🔴 ${n.id}: ${(d.summary ?? "").slice(0, 80)} (${d.severity})`;
+          case "session": return `  ← 📁 ${n.id} (${(d.characters ?? []).join(", ")})`;
+          default: return `  ← ${n.type}: ${n.id}`;
+        }
+      });
+      return { response_type: "in_channel", text: `*Trace: ${args[0]}*\n${lines.join("\n")}` };
+    }
+
+    case "orphans": {
+      const orphans = orphanGaps(graph!);
+      if (orphans.length === 0) return { response_type: "in_channel", text: "✅ No orphan gaps. All gaps linked to decisions." };
+
+      const lines = orphans.slice(0, 10).map((g) => {
+        const d = g.data as Gap;
+        return `• ${g.id}: ${(d.summary ?? "").slice(0, 60)} (${d.severity})`;
+      });
+      const more = orphans.length > 10 ? `\n_... and ${orphans.length - 10} more_` : "";
+      return { response_type: "in_channel", text: `*Orphan Gaps (${orphans.length})*\n${lines.join("\n")}${more}` };
+    }
+
+    case "search": {
+      if (!args[0]) return { response_type: "ephemeral", text: "Usage: /dve search <keyword>" };
+      const results = search(graph!, args.join(" "));
+      if (results.length === 0) return { response_type: "ephemeral", text: `No results for "${args.join(" ")}".` };
+
+      const lines = results.slice(0, 8).map((n) => {
+        const d = n.data as any;
+        const label = d.title ?? d.summary ?? d.theme ?? "";
+        return `• \`${n.type}\` ${n.id}: ${label.slice(0, 60)}`;
+      });
+      return { response_type: "in_channel", text: `*Search: "${args.join(" ")}"* (${results.length} results)\n${lines.join("\n")}` };
+    }
+
+    case "status": {
+      const statusLines = projectDirs.map((p) => {
+        const state = detectProjectState(p.name, p.path);
+        const wf = state.workflow;
+        const current = wf.currentPhase;
+        const sub = wf.subState ? ` > ${wf.subState}` : "";
+        return `• *${p.name}*: \`${current}${sub}\` | S:${state.dgeSessionCount} DD:${state.ddCount} | DRE: ${state.dre.installState}`;
+      });
+      return { response_type: "in_channel", text: `*DVE Status*\n${statusLines.join("\n")}` };
+    }
+
+    case "overturned": {
+      const ot = overturned(graph!);
+      if (ot.length === 0) return { response_type: "in_channel", text: "✅ No overturned decisions." };
+      const lines = ot.map(({ decision, impact }) => {
+        const d = decision.data as any;
+        return `• ❌ *${decision.id}*: ${d.title} → ${impact.length} affected nodes`;
+      });
+      return { response_type: "in_channel", text: `*Overturned Decisions*\n${lines.join("\n")}` };
+    }
+
+    case "list": {
+      const filter = args[0]?.toLowerCase() ?? "all"; // dd / gap / session / spec / all
+      const nodes = graph!.nodes.filter((n) => {
+        if (filter === "dd" || filter === "decisions") return n.type === "decision";
+        if (filter === "gap" || filter === "gaps") return n.type === "gap";
+        if (filter === "session" || filter === "sessions") return n.type === "session";
+        if (filter === "spec" || filter === "specs") return n.type === "spec";
+        return n.type === "decision" || n.type === "session" || n.type === "spec";
+      });
+
+      if (nodes.length === 0) return { response_type: "ephemeral", text: `No ${filter} found.` };
+
+      const blocks: any[] = [
+        { type: "section", text: { type: "mrkdwn", text: `*${filter === "all" ? "All Items" : filter.toUpperCase()}* (${nodes.length})` } },
+      ];
+
+      // Group by type
+      const grouped: Record<string, typeof nodes> = {};
+      for (const n of nodes) {
+        if (!grouped[n.type]) grouped[n.type] = [];
+        grouped[n.type].push(n);
+      }
+
+      for (const [type, items] of Object.entries(grouped)) {
+        const icon = type === "decision" ? "📋" : type === "session" ? "📁" : type === "spec" ? "📄" : type === "gap" ? "🔴" : "📎";
+        blocks.push({ type: "divider" });
+        blocks.push({ type: "section", text: { type: "mrkdwn", text: `*${icon} ${type}* (${items.length})` } });
+
+        for (const item of items.slice(0, 10)) {
+          const d = item.data as any;
+          const label = d.title ?? d.theme ?? d.summary?.slice(0, 50) ?? item.id;
+          const meta = type === "decision" ? `${d.date ?? ""} | ${d.status ?? ""}` :
+            type === "session" ? `${d.date ?? ""} | ${(d.characters ?? []).slice(0, 3).join(", ")}` :
+            type === "spec" ? `${d.type ?? ""} | ${d.status ?? ""}` :
+            `${(d as any).severity ?? ""}`;
+
+          blocks.push({
+            type: "section",
+            text: { type: "mrkdwn", text: `*${item.id}*\n${label}\n_${meta}_` },
+            accessory: {
+              type: "button",
+              text: { type: "plain_text", text: type === "decision" ? "Trace" : "Detail" },
+              action_id: `dve_detail_${item.id}`,
+              value: item.id,
+            },
+          });
+        }
+
+        if (items.length > 10) {
+          blocks.push({ type: "section", text: { type: "mrkdwn", text: `_... and ${items.length - 10} more_` } });
+        }
+      }
+
+      return { response_type: "in_channel", text: `List: ${filter}`, blocks };
+    }
+
+    case "summary": {
+      const s = graph!.stats;
+      const orphanCount = orphanGaps(graph!).length;
+      const otCount = overturned(graph!).length;
+      return {
+        response_type: "in_channel",
+        text: `*DVE Summary*\nSessions: ${s.sessions} | Gaps: ${s.gaps} | Decisions: ${s.decisions} | Specs: ${s.specs ?? 0} | Annotations: ${s.annotations}\nOrphan Gaps: ${orphanCount} | Overturned: ${otCount}`,
+      };
+    }
+
+    default:
+      return {
+        response_type: "ephemeral",
+        text: `*DVE Slack Commands*
+\`/dve list [dd|gap|session|spec]\` — 一覧（ボタン付き）
+\`/dve trace DD-001\` — 因果チェーン
+\`/dve orphans\` — 未解決 Gap
+\`/dve search <keyword>\` — 検索
+\`/dve status\` — 全プロジェクト状態
+\`/dve summary\` — 統計サマリー
+\`/dve overturned\` — 撤回された DD
+\`/dve help\` — このヘルプ`,
+      };
+  }
+}
+
+// ─── Events API Handler ───
+// @DVE メンション → 自然言語でクエリ
+
+export function handleEvent(event: any, distDir: string): string | null {
+  if (event.type !== "app_mention" && event.type !== "message") return null;
+
+  const text = (event.text ?? "").replace(/<@[^>]+>/g, "").trim().toLowerCase();
+
+  // Simple keyword routing
+  if (/trace|経緯|なぜ/.test(text)) {
+    const ddMatch = text.match(/DD-\d+/i);
+    if (ddMatch) {
+      const graph = loadGraph(distDir);
+      if (!graph) return "graph.json not found.";
+      const chain = traceDecision(graph, ddMatch[0]);
+      return chain.map((n) => `${n.type}: ${n.id}`).join(" ← ");
+    }
+    return "DD 番号を指定してください（例: DD-003 の経緯）";
+  }
+
+  if (/orphan|未解決|未決定/.test(text)) {
+    const graph = loadGraph(distDir);
+    if (!graph) return "graph.json not found.";
+    const orphans = orphanGaps(graph);
+    return `未解決 Gap: ${orphans.length} 件`;
+  }
+
+  if (/status|状態|フェーズ/.test(text)) {
+    return "Use `/dve status` for project status.";
+  }
+
+  return "🤖 `/dve help` でコマンド一覧を見れます。";
+}

package/skills/dve-annotate.md

@@ -0,0 +1,26 @@
+# Skill: DVE Annotate
+
+## Trigger
+「DD-005 にコメント」「この決定に異議」「drift を記録」「overturn」
+
+## Procedure
+
+1. 対象ノード (DD, Gap, or Session) を特定
+2. action を決定:
+   - `comment` — 単なるコメント
+   - `fork` — ここから DGE 分岐
+   - `overturn` — この決定を撤回
+   - `constrain` — 制約を追加
+   - `drift` — 現実と乖離している
+3. `node dve/kit/dist/cli/dve-tool.js annotate <id> --action <type> --body "text"` を実行
+4. `dve/annotations/` にファイルが生成される
+5. `dve build` でグラフに反映
+
+## Annotation の影響
+- `overturn` → DD の枠が赤に、取り消し線
+- `drift` → DD の枠が黄・点線
+- `constrain` → バッジ付き
+
+## Notes
+- Session は immutable。Annotation は別レイヤーで保存
+- Web UI からも作成可能（API server 経由）

package/skills/dve-build.md

@@ -0,0 +1,15 @@
+# Skill: DVE Build
+
+## Trigger
+「DVE ビルド」「決定マップを更新」「graph を更新」
+
+## Procedure
+
+1. kit をコンパイル: `npx tsc -p dve/kit/tsconfig.json`
+2. graph.json を生成: `node dve/kit/dist/cli/dve-tool.js build`
+3. app をビルド: `cd dve/app && npx vite build`
+4. 結果を報告（sessions / gaps / decisions / specs / annotations の件数）
+
+## Notes
+- graph.json に session/DD の全文 (content) が含まれる
+- changelog.json で前回ビルドとの差分を表示

package/skills/dve-context.md

@@ -0,0 +1,22 @@
+# Skill: DVE Context (DGE 再起動)
+
+## Trigger
+「DD-003 の経緯で DGE」「この決定を再検討」「制約を追加して DGE」
+
+## Procedure
+
+1. 対象ノード (DD or Gap) を特定
+2. `node dve/kit/dist/cli/dve-tool.js context <id> [--constraint="..."]` を実行
+3. ContextBundle (JSON) が `dve/contexts/` に保存される
+4. prompt_template が表示される — これを DGE に渡す
+5. そのまま DGE セッションを開始する（prompt_template をコンテキストとして使用）
+
+## ContextBundle の中身
+- origin: 起点ノード
+- summary: テーマ、前回の DD 一覧、Gap 一覧、キャラ
+- new_constraints: ユーザーが追加した制約
+- prompt_template: DGE に渡すテキスト（自動生成）
+
+## Notes
+- DVE → DGE の橋渡し。疎結合（プロンプトテキストだけが接点）
+- DGE の Phase 0 が context: パスを検出して自動読み込み

package/skills/dve-serve.md

@@ -0,0 +1,17 @@
+# Skill: DVE Serve
+
+## Trigger
+「DVE を開いて」「決定マップを見せて」「DVE serve」
+
+## Procedure
+
+1. graph.json が古ければ先にビルド: `node dve/kit/dist/cli/dve-tool.js build`
+2. サーバー起動: `node dve/kit/dist/cli/dve-tool.js serve`
+   - Web UI: http://localhost:4173
+   - API: http://localhost:4174
+3. `--watch` オプション付きならファイル監視も起��
+4. ユーザーに URL を案内
+
+## Notes
+- `serve --watch` で DGE session 保存時に自動リビルド
+- API は annotation 作成、ドリフト検出、キャラカバレッジを提供

package/skills/dve-status.md

@@ -0,0 +1,18 @@
+# Skill: DVE Status
+
+## Trigger
+「DVE ステータス」「プロジェクトの状態は」「今どのフェーズ？」
+
+## Procedure
+
+1. `node dve/kit/dist/cli/dve-tool.js status` を実行
+2. 表示内容:
+   - DRE install 状態 (FRESH / INSTALLED / CUSTOMIZED / OUTDATED)
+   - Workflow state machine (backlog → spec → {gap_extraction} → impl → review → release)
+   - 現在フェーズ + サブステート
+   - インストール済み plugin 一覧
+3. 複数プ���ジェクト対応: `dve.config.json` があれば全プロジェクトを表示
+
+## Notes
+- 現在フェーズの検出優先度: .dre/context.json > CLAUDE.md active_phase > git log 推定
+- サブステートは plugin の内部 SM (e.g. DGE: flow_detection → dialogue_generation → ...)

package/skills/dve-trace.md

@@ -0,0 +1,16 @@
+# Skill: DVE Trace
+
+## Trigger
+「DD-005 の経緯」「この決定はなぜ？」「因果チェーンを見せて」「trace DD-003」
+
+## Procedure
+
+1. DD 番号を特定（ユーザー入力 or 文脈から推定）
+2. `node dve/kit/dist/cli/dve-tool.js trace <DD-id>` を実行
+3. 因果チェーンを表示:
+   - DD → Gap (severity) → Session (characters, date)
+4. 「この文脈で DGE しますか？」と提案
+
+## Notes
+- graph.json が必要。なければ先に `dve build` を実行
+- DD が見つからない場合は `dve search` で検索を提案

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "outDir": "./dist",
+    "rootDir": ".",
+    "strict": true,
+    "esModuleInterop": true,
+    "declaration": true,
+    "skipLibCheck": true
+  },
+  "include": ["parser/**/*.ts", "graph/**/*.ts", "context/**/*.ts", "cli/**/*.ts", "server/**/*.ts", "config.ts"],
+  "exclude": ["node_modules", "dist", "test"]
+}