sanjang 0.3.4 → 0.3.5

package/dist/lib/engine/process.js

@@ -24,7 +24,10 @@ function detectPortFromStdout(logs, timeoutMs) {
                     const port = parseInt(match[1], 10);
                     // Wait briefly for the port to actually be ready
                     const sock = createConnection({ port, host: "localhost" });
-                    sock.once("connect", () => { sock.destroy(); resolve(port); });
+                    sock.once("connect", () => {
+                        sock.destroy();
+                        resolve(port);
+                    });
                     sock.once("error", () => {
                         sock.destroy();
                         // Port printed but not ready yet, retry

package/dist/lib/engine/self-heal.js

@@ -1,6 +1,6 @@
-import { existsSync, copyFileSync, mkdirSync } from "node:fs";
-import { join, dirname } from "node:path";
 import { execSync } from "node:child_process";
+import { copyFileSync, existsSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
 const PATTERNS = [
     {
         test: /Cannot find module|MODULE_NOT_FOUND/i,
@@ -64,7 +64,12 @@ export function executeHeal(action, campPath, projectRoot, setupCommand, copyFil
             if (!setupCommand)
                 return { action, success: false, detail: "설치 명령이 없습니다." };
             try {
-                execSync(setupCommand, { cwd: campPath, stdio: "pipe", timeout: 120_000, shell: true });
+                execSync(setupCommand, {
+                    cwd: campPath,
+                    stdio: "pipe",
+                    timeout: 120_000,
+                    shell: true,
+                });
                 return { action, success: true };
             }
             catch {
@@ -82,10 +87,16 @@ export function executeHeal(action, campPath, projectRoot, setupCommand, copyFil
                         copyFileSync(src, dst);
                         copied++;
                     }
-                    catch { /* skip */ }
+                    catch {
+                        /* skip */
+                    }
                 }
             }
-            return { action, success: copied > 0, detail: copied > 0 ? `${copied}개 파일 복사됨` : "복사할 파일이 없습니다." };
+            return {
+                action,
+                success: copied > 0,
+                detail: copied > 0 ? `${copied}개 파일 복사됨` : "복사할 파일이 없습니다.",
+            };
         }
         case "restart":
             // Restart is handled by the caller (stop + start)

package/dist/lib/engine/smart-init.js

@@ -32,7 +32,7 @@ export function deepFindEnvFiles(projectRoot, maxDepth = 4) {
 export function detectSetupIssues(projectRoot) {
     const issues = [];
     // 1. Check for env variable references without .env files
-    const hasEnvFile = ENV_PATTERNS.some(f => existsSync(join(projectRoot, f)));
+    const hasEnvFile = ENV_PATTERNS.some((f) => existsSync(join(projectRoot, f)));
     if (!hasEnvFile) {
         const envRefFound = scanForEnvReferences(projectRoot);
         if (envRefFound) {
@@ -52,7 +52,7 @@ export function detectSetupIssues(projectRoot) {
     }
     // 3. Check for missing lockfile
     const lockfiles = ["package-lock.json", "yarn.lock", "pnpm-lock.yaml", "bun.lockb", "bun.lock"];
-    if (!lockfiles.some(f => existsSync(join(projectRoot, f)))) {
+    if (!lockfiles.some((f) => existsSync(join(projectRoot, f)))) {
         issues.push({
             type: "missing-lockfile",
             message: "lockfile이 없습니다. 의존성 설치가 느릴 수 있습니다.",
@@ -97,7 +97,10 @@ function scanForEnvReferences(dir, depth = 0) {
                 continue;
             }
         }
-        if (entry.isDirectory() && !SKIP_DIRS.has(entry.name) && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+        if (entry.isDirectory() &&
+            !SKIP_DIRS.has(entry.name) &&
+            !entry.name.startsWith(".") &&
+            entry.name !== "node_modules") {
             if (scanForEnvReferences(join(dir, entry.name), depth + 1))
                 return true;
         }
@@ -129,9 +132,7 @@ function countTurboApps(root) {
                 if (scripts?.dev)
                     count++;
             }
-            catch {
-                continue;
-            }
+            catch { }
         }
     }
     return count;

package/dist/lib/engine/state.js

@@ -29,7 +29,7 @@ function read() {
 function write(records) {
     ensureDir();
     // Atomic write: write to temp file then rename to prevent corruption
-    const tmp = stateFile() + ".tmp";
+    const tmp = `${stateFile()}.tmp`;
     writeFileSync(tmp, JSON.stringify(records, null, 2), "utf8");
     renameSync(tmp, stateFile());
 }

package/dist/lib/engine/suggest.js

@@ -97,10 +97,7 @@ async function fetchRecentCommits(cwd) {
 export async function suggestTasks(projectRoot) {
     const results = [];
     // gh-dependent fetches — tolerate failure (gh not installed / no repo)
-    const [issues, prs] = await Promise.allSettled([
-        fetchIssues(projectRoot),
-        fetchMyPrs(projectRoot),
-    ]);
+    const [issues, prs] = await Promise.allSettled([fetchIssues(projectRoot), fetchMyPrs(projectRoot)]);
     // PRs first — most actionable ("이어하기")
     if (prs.status === "fulfilled") {
         results.push(...prs.value);

package/dist/lib/engine/warp.d.ts

@@ -15,7 +15,7 @@ export declare function detectWarp(): WarpDetectResult;
  * Opens as a new tab in the existing Warp window (not a new window).
  * The tab title naturally shows the directory name (= camp name).
  */
-export declare function openWarpTab(campName: string, worktreePath: string): WarpOpenResult;
+export declare function openWarpTab(_campName: string, worktreePath: string): WarpOpenResult;
 /**
  * No-op cleanup (launch config removed — using open -a instead).
  */

package/dist/lib/engine/warp.js

@@ -12,7 +12,7 @@ export function detectWarp() {
  * Opens as a new tab in the existing Warp window (not a new window).
  * The tab title naturally shows the directory name (= camp name).
  */
-export function openWarpTab(campName, worktreePath) {
+export function openWarpTab(_campName, worktreePath) {
     const { installed } = detectWarp();
     if (!installed) {
         return { opened: false, terminal: null, path: worktreePath };

package/dist/lib/server.js

@@ -7,20 +7,22 @@ import express from "express";
 import { WebSocket, WebSocketServer } from "ws";
 import { loadConfig } from "./config.js";
 import { applyCacheToWorktree, buildCache, isCacheValid } from "./engine/cache.js";
+import { buildChangeReport, generateReportSummary } from "./engine/change-report.js";
+import { applyConfigFix, suggestConfigFix } from "./engine/config-hotfix.js";
 import { buildConflictPrompt, parseConflictFiles } from "./engine/conflict.js";
 import { buildDiagnostics } from "./engine/diagnostics.js";
+import { getMainServerState, startMainServer, stopMainServer } from "./engine/main-server.js";
 import { aiSlugify, slugify } from "./engine/naming.js";
 import { allocate, scanPorts, setPortConfig } from "./engine/ports.js";
 import { buildClaudePrPrompt, buildFallbackPrBody } from "./engine/pr.js";
 import { getProcessInfo, setConfig, startCamp, stopAllCamps, stopCamp } from "./engine/process.js";
+import { diagnoseFromLogs, executeHeal } from "./engine/self-heal.js";
+import { generatePrDescription } from "./engine/smart-pr.js";
 import { listSnapshots, restoreSnapshot, saveSnapshot } from "./engine/snapshot.js";
 import { getAll, getOne, remove, setCampsDir, upsert } from "./engine/state.js";
+import { suggestTasks } from "./engine/suggest.js";
 import { detectWarp, openWarpTab, removeLaunchConfig } from "./engine/warp.js";
 import { CampWatcher } from "./engine/watcher.js";
-import { diagnoseFromLogs, executeHeal } from "./engine/self-heal.js";
-import { suggestTasks } from "./engine/suggest.js";
-import { generatePrDescription } from "./engine/smart-pr.js";
-import { suggestConfigFix, applyConfigFix } from "./engine/config-hotfix.js";
 import { addWorktree, campPath, getProjectRoot, listBranches, removeWorktree, setProjectRoot, } from "./engine/worktree.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 // ---------------------------------------------------------------------------
@@ -192,9 +194,15 @@ export async function createApp(projectRoot, options = {}) {
                 return;
             try {
                 // Reattach if detached
-                const headRef = spawnSync("git", ["-C", wtPath, "symbolic-ref", "--quiet", "HEAD"], { encoding: "utf8", stdio: "pipe" });
+                const headRef = spawnSync("git", ["-C", wtPath, "symbolic-ref", "--quiet", "HEAD"], {
+                    encoding: "utf8",
+                    stdio: "pipe",
+                });
                 if (headRef.status !== 0 && pg.branch) {
-                    const cur = spawnSync("git", ["-C", wtPath, "rev-parse", "HEAD"], { encoding: "utf8", stdio: "pipe" }).stdout?.trim();
+                    const cur = spawnSync("git", ["-C", wtPath, "rev-parse", "HEAD"], {
+                        encoding: "utf8",
+                        stdio: "pipe",
+                    }).stdout?.trim();
                     if (cur) {
                         spawnSync("git", ["-C", wtPath, "branch", "-f", pg.branch, cur], { stdio: "pipe" });
                         spawnSync("git", ["-C", wtPath, "checkout", pg.branch], { stdio: "pipe" });
@@ -202,10 +210,16 @@ export async function createApp(projectRoot, options = {}) {
                 }
                 runGit(["-C", wtPath, "add", "-A"], wtPath);
                 runGit(["-C", wtPath, "commit", "-m", `[auto] ${files.length}개 파일 자동 세이브`], wtPath);
-                broadcast({ type: "playground-saved", name, data: { message: `[auto] ${files.length}개 파일 자동 세이브`, auto: true } });
+                broadcast({
+                    type: "playground-saved",
+                    name,
+                    data: { message: `[auto] ${files.length}개 파일 자동 세이브`, auto: true },
+                });
                 broadcast({ type: "autosaved", name });
             }
-            catch { /* ignore */ }
+            catch {
+                /* ignore */
+            }
         }, AUTOSAVE_DELAY));
     }
     function startWatcher(name) {
@@ -224,7 +238,9 @@ export async function createApp(projectRoot, options = {}) {
                 if (autosaveEnabled.has(name))
                     resetAutosaveTimer(name);
             }
-            catch { /* ignore — worktree may be deleted */ }
+            catch {
+                /* ignore — worktree may be deleted */
+            }
         }, 800);
         watcher.start();
         watchers.set(name, watcher);
@@ -267,7 +283,9 @@ export async function createApp(projectRoot, options = {}) {
                     broadcast({ type: "browser-error", name: msg.name, data: msg.data });
                 }
             }
-            catch { /* ignore non-JSON */ }
+            catch {
+                /* ignore non-JSON */
+            }
         });
     });
     // -------------------------------------------------------------------------
@@ -306,13 +324,21 @@ export async function createApp(projectRoot, options = {}) {
         }
         // Only allow proxying to known camp ports (prevent SSRF to arbitrary local services)
         const camps = getAll();
-        const camp = camps.find(c => c.fePort === targetPort);
-        if (!camp) {
+        const camp = camps.find((c) => c.fePort === targetPort);
+        const mainState = getMainServerState();
+        const isMainPort = mainState.status === "running" && mainState.port === targetPort;
+        if (!camp && !isMainPort) {
             return res.status(403).send("이 포트는 활성 캠프가 아닙니다.");
         }
-        const campName = camp.name;
+        const campName = camp?.name ?? "__main__";
         const targetPath = req.url || "/";
-        const proxyReq = httpRequest({ hostname: "127.0.0.1", port: targetPort, path: targetPath, method: req.method, headers: { ...req.headers, host: `localhost:${targetPort}` } }, (proxyRes) => {
+        const proxyReq = httpRequest({
+            hostname: "127.0.0.1",
+            port: targetPort,
+            path: targetPath,
+            method: req.method,
+            headers: { ...req.headers, host: `localhost:${targetPort}` },
+        }, (proxyRes) => {
             const contentType = proxyRes.headers["content-type"] || "";
             const isHtml = contentType.includes("text/html");
             if (!isHtml) {
@@ -326,8 +352,7 @@ export async function createApp(projectRoot, options = {}) {
             proxyRes.on("data", (chunk) => chunks.push(chunk));
             proxyRes.on("end", () => {
                 let body = Buffer.concat(chunks).toString("utf8");
-                const script = INJECTED_SCRIPT
-                    .replace("data-camp'", `data-camp'`) // placeholder
+                const script = INJECTED_SCRIPT.replace("data-camp'", `data-camp'`) // placeholder
                     .replace("data-sanjang-injected>", `data-sanjang-injected data-camp="${campName}">`);
                 // Replace _sp port placeholder with actual sanjang server port
                 const finalScript = script.replace("new URLSearchParams(location.search.slice(1)||'').get('_sp')||location.port", `'${port}'`);
@@ -349,8 +374,7 @@ export async function createApp(projectRoot, options = {}) {
                 // Remove X-Frame-Options / frame-ancestors to allow iframe embedding
                 delete headers["x-frame-options"];
                 if (typeof headers["content-security-policy"] === "string") {
-                    headers["content-security-policy"] = headers["content-security-policy"]
-                        .replace(/frame-ancestors[^;]*(;|$)/gi, "");
+                    headers["content-security-policy"] = headers["content-security-policy"].replace(/frame-ancestors[^;]*(;|$)/gi, "");
                 }
                 res.writeHead(proxyRes.statusCode ?? 200, headers);
                 res.end(body);
@@ -408,8 +432,18 @@ export async function createApp(projectRoot, options = {}) {
             copyCampFiles(projectRoot, wtPath, freshConfig.copyFiles, (msg) => {
                 broadcast({ type: "log", name, source: "sanjang", data: msg });
             });
-            const baseCommit = spawnSync("git", ["-C", wtPath, "rev-parse", "HEAD"], { encoding: "utf8", stdio: "pipe" }).stdout?.trim() || undefined;
-            const record = { name, branch, slot, fePort: actualFePort, bePort, status: "setting-up", baseCommit, parentBranch: branch };
+            const baseCommit = spawnSync("git", ["-C", wtPath, "rev-parse", "HEAD"], { encoding: "utf8", stdio: "pipe" }).stdout?.trim() ||
+                undefined;
+            const record = {
+                name,
+                branch,
+                slot,
+                fePort: actualFePort,
+                bePort,
+                status: "setting-up",
+                baseCommit,
+                parentBranch: branch,
+            };
             upsert(record);
             broadcast({ type: "playground-created", name, data: record });
             res.status(201).json(record);
@@ -455,7 +489,7 @@ export async function createApp(projectRoot, options = {}) {
                 const processInfo = getProcessInfo(name) ?? { feLogs: [], feExitCode: null };
                 // Self-heal: try to auto-fix before giving up
                 const healActions = diagnoseFromLogs(processInfo.feLogs);
-                const autoFixable = healActions.filter(a => a.auto);
+                const autoFixable = healActions.filter((a) => a.auto);
                 if (autoFixable.length > 0) {
                     broadcast({ type: "log", name, source: "sanjang", data: "문제를 발견했습니다. 자동으로 고치는 중..." });
                     const freshConfig = await loadConfig(projectRoot);
@@ -583,10 +617,16 @@ export async function createApp(projectRoot, options = {}) {
             return res.json({ saved: false, reason: "변경사항이 없습니다." });
         try {
             // Reattach to branch if in detached HEAD state
-            const headRef = spawnSync("git", ["-C", wtPath, "symbolic-ref", "--quiet", "HEAD"], { encoding: "utf8", stdio: "pipe" });
+            const headRef = spawnSync("git", ["-C", wtPath, "symbolic-ref", "--quiet", "HEAD"], {
+                encoding: "utf8",
+                stdio: "pipe",
+            });
             if (headRef.status !== 0 && pg.branch) {
                 // Detached HEAD — move branch pointer to current commit and checkout
-                const currentCommit = spawnSync("git", ["-C", wtPath, "rev-parse", "HEAD"], { encoding: "utf8", stdio: "pipe" }).stdout?.trim();
+                const currentCommit = spawnSync("git", ["-C", wtPath, "rev-parse", "HEAD"], {
+                    encoding: "utf8",
+                    stdio: "pipe",
+                }).stdout?.trim();
                 if (currentCommit) {
                     spawnSync("git", ["-C", wtPath, "branch", "-f", pg.branch, currentCommit], { stdio: "pipe" });
                     spawnSync("git", ["-C", wtPath, "checkout", pg.branch], { stdio: "pipe" });
@@ -595,10 +635,16 @@ export async function createApp(projectRoot, options = {}) {
             // Stage all changes
             runGit(["-C", wtPath, "add", "-A"], wtPath);
             // Generate commit message with AI
-            const diff = spawnSync("git", ["-C", wtPath, "diff", "--cached", "--stat"], { encoding: "utf8", stdio: "pipe" }).stdout || "";
+            const diff = spawnSync("git", ["-C", wtPath, "diff", "--cached", "--stat"], { encoding: "utf8", stdio: "pipe" }).stdout ||
+                "";
             let message = `${files.length}개 파일 변경`;
             try {
-                const aiResult = spawnSync("claude", ["-p", "--model", "haiku", `이 git diff를 한국어 커밋 메시지로 작성해. 한 줄, 50자 이내, 설명 없이 메시지만:\n\n${diff.slice(0, 2000)}`], { encoding: "utf8", stdio: "pipe", timeout: 10_000 });
+                const aiResult = spawnSync("claude", [
+                    "-p",
+                    "--model",
+                    "haiku",
+                    `이 git diff를 한국어 커밋 메시지로 작성해. 한 줄, 50자 이내, 설명 없이 메시지만:\n\n${diff.slice(0, 2000)}`,
+                ], { encoding: "utf8", stdio: "pipe", timeout: 10_000 });
                 if (aiResult.status === 0 && aiResult.stdout?.trim()) {
                     message = aiResult.stdout.trim();
                 }
@@ -768,22 +814,95 @@ export async function createApp(projectRoot, options = {}) {
             res.status(500).json({ error: err.message });
         }
     });
-    // GET /api/playgrounds/:name/changes-summary — AI 한 줄 변경 요약
-    app.get("/api/playgrounds/:name/changes-summary", async (req, res) => {
+    // GET /api/playgrounds/:name/change-report — 구조화된 변경 리포트 (changes-summary 대체)
+    app.get("/api/playgrounds/:name/change-report", async (req, res) => {
         const { name } = req.params;
         if (!getOne(name))
             return res.status(404).json({ error: "not found" });
         try {
             const wtPath = campPath(name);
-            const diff = spawnSync("git", ["-C", wtPath, "diff", "--stat"], { encoding: "utf8", stdio: "pipe" }).stdout || "";
-            if (!diff.trim())
-                return res.json({ summary: null });
-            const result = spawnSync("claude", ["-p", "--model", "haiku", `이 git diff를 한국어 한 줄(20자 이내)로 요약해. 설명 없이 요약만:\n\n${diff.slice(0, 2000)}`], { encoding: "utf8", stdio: "pipe", timeout: 10_000 });
-            const summary = result.status === 0 ? (result.stdout ?? "").trim() : null;
-            res.json({ summary });
+            const files = getChangedFiles(wtPath);
+            if (files.length === 0) {
+                return res.json({
+                    files: [],
+                    totalCount: 0,
+                    byCategory: {},
+                    warnings: [],
+                    summary: null,
+                    humanDescription: null,
+                    categoryDetails: null,
+                });
+            }
+            const validStatuses = new Set(["수정", "추가", "삭제", "새 파일"]);
+            const reportFiles = files.map((f) => ({
+                path: f.path,
+                status: (validStatuses.has(f.status) ? f.status : "수정"),
+            }));
+            let report = buildChangeReport(reportFiles);
+            // AI 요약은 ?ai=true 일 때만 (비용 절약)
+            if (req.query.ai === "true") {
+                const diffStat = spawnSync("git", ["-C", wtPath, "diff", "--stat"], {
+                    encoding: "utf8",
+                    stdio: "pipe",
+                }).stdout || "";
+                const diff = spawnSync("git", ["-C", wtPath, "diff"], {
+                    encoding: "utf8",
+                    stdio: "pipe",
+                }).stdout || "";
+                report = generateReportSummary(diffStat, diff, report);
+            }
+            res.json(report);
         }
-        catch {
-            res.json({ summary: null });
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // GET /api/playgrounds/:name/commit-report/:hash — 특정 커밋의 변경 리포트
+    app.get("/api/playgrounds/:name/commit-report/:hash", async (req, res) => {
+        const { name, hash } = req.params;
+        if (!getOne(name))
+            return res.status(404).json({ error: "not found" });
+        try {
+            const wtPath = campPath(name);
+            // 해당 커밋의 diff (부모 대비)
+            const diffNames = spawnSync("git", ["-C", wtPath, "diff", "--name-status", `${hash}~1..${hash}`], {
+                encoding: "utf8",
+                stdio: "pipe",
+            }).stdout?.trim() || "";
+            if (!diffNames)
+                return res.json({
+                    files: [],
+                    totalCount: 0,
+                    byCategory: {},
+                    warnings: [],
+                    summary: null,
+                    humanDescription: null,
+                    categoryDetails: null,
+                });
+            const validStatuses = new Set(["수정", "추가", "삭제", "새 파일"]);
+            const statusMap = { M: "수정", A: "새 파일", D: "삭제" };
+            const parsedFiles = diffNames.split("\n").map((line) => {
+                const [st, ...pathParts] = line.split("\t");
+                const mapped = statusMap[st || ""] || "수정";
+                return {
+                    path: pathParts.join("\t"),
+                    status: (validStatuses.has(mapped) ? mapped : "수정"),
+                };
+            });
+            let report = buildChangeReport(parsedFiles);
+            if (req.query.ai === "true") {
+                const diffStat = spawnSync("git", ["-C", wtPath, "diff", "--stat", `${hash}~1..${hash}`], {
+                    encoding: "utf8",
+                    stdio: "pipe",
+                }).stdout || "";
+                const diff = spawnSync("git", ["-C", wtPath, "diff", `${hash}~1..${hash}`], { encoding: "utf8", stdio: "pipe" })
+                    .stdout || "";
+                report = generateReportSummary(diffStat, diff, report);
+            }
+            res.json(report);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
         }
     });
     app.post("/api/playgrounds/:name/ship", async (req, res) => {
@@ -797,9 +916,15 @@ export async function createApp(projectRoot, options = {}) {
         try {
             const wtPath = campPath(name);
             // 1. Reattach to branch if detached
-            const headRef = spawnSync("git", ["-C", wtPath, "symbolic-ref", "--quiet", "HEAD"], { encoding: "utf8", stdio: "pipe" });
+            const headRef = spawnSync("git", ["-C", wtPath, "symbolic-ref", "--quiet", "HEAD"], {
+                encoding: "utf8",
+                stdio: "pipe",
+            });
             if (headRef.status !== 0 && pg.branch) {
-                const cur = spawnSync("git", ["-C", wtPath, "rev-parse", "HEAD"], { encoding: "utf8", stdio: "pipe" }).stdout?.trim();
+                const cur = spawnSync("git", ["-C", wtPath, "rev-parse", "HEAD"], {
+                    encoding: "utf8",
+                    stdio: "pipe",
+                }).stdout?.trim();
                 if (cur) {
                     spawnSync("git", ["-C", wtPath, "branch", "-f", pg.branch, cur], { stdio: "pipe" });
                     spawnSync("git", ["-C", wtPath, "checkout", pg.branch], { stdio: "pipe" });
@@ -818,8 +943,14 @@ export async function createApp(projectRoot, options = {}) {
             // 3. Check there are commits to ship (vs base)
             const base = pg.baseCommit;
             const logCheck = base
-                ? spawnSync("git", ["-C", wtPath, "log", "--oneline", `${base}..HEAD`], { encoding: "utf8", stdio: "pipe" }).stdout?.trim()
-                : spawnSync("git", ["-C", wtPath, "log", "--oneline", "-1", "HEAD"], { encoding: "utf8", stdio: "pipe" }).stdout?.trim();
+                ? spawnSync("git", ["-C", wtPath, "log", "--oneline", `${base}..HEAD`], {
+                    encoding: "utf8",
+                    stdio: "pipe",
+                }).stdout?.trim()
+                : spawnSync("git", ["-C", wtPath, "log", "--oneline", "-1", "HEAD"], {
+                    encoding: "utf8",
+                    stdio: "pipe",
+                }).stdout?.trim();
             if (!logCheck) {
                 return res.status(400).json({ error: "보낼 변경사항이 없습니다." });
             }
@@ -851,6 +982,33 @@ export async function createApp(projectRoot, options = {}) {
                     const diffStat = spawnSync("git", ["-C", wtPath, "diff", "--stat", "HEAD~1"], { encoding: "utf8", stdio: "pipe" }).stdout ||
                         "";
                     const diff = spawnSync("git", ["-C", wtPath, "diff", "HEAD~1"], { encoding: "utf8", stdio: "pipe" }).stdout || "";
+                    // Change report warnings for PR body — based on full diff since camp creation
+                    let reportWarnings = "";
+                    try {
+                        const base = pg.baseCommit;
+                        if (base) {
+                            const diffFiles = spawnSync("git", ["-C", wtPath, "diff", "--name-status", `${base}..HEAD`], {
+                                encoding: "utf8",
+                                stdio: "pipe",
+                            }).stdout?.trim() || "";
+                            if (diffFiles) {
+                                const parsedFiles = diffFiles.split("\n").map((line) => {
+                                    const [st, ...pathParts] = line.split("\t");
+                                    return {
+                                        path: pathParts.join("\t"),
+                                        status: (st === "M" ? "수정" : st === "D" ? "삭제" : st === "A" ? "추가" : "수정"),
+                                    };
+                                });
+                                const shipReport = buildChangeReport(parsedFiles);
+                                if (shipReport.warnings.length > 0) {
+                                    reportWarnings = "\n\n### ⚠️ 주의사항\n" + shipReport.warnings.map((w) => `- ${w.message}`).join("\n");
+                                }
+                            }
+                        }
+                    }
+                    catch {
+                        /* non-critical */
+                    }
                     // Try Claude for rich PR body, fallback to simple
                     const claudeCheck = spawnSync("which", ["claude"], { stdio: "pipe" });
                     let prBody;
@@ -865,11 +1023,11 @@ export async function createApp(projectRoot, options = {}) {
                         });
                         prBody =
                             claudeResult.status === 0 && claudeResult.stdout?.trim()
-                                ? claudeResult.stdout.trim()
-                                : buildFallbackPrBody({ message, actions, diffStat });
+                                ? claudeResult.stdout.trim() + reportWarnings
+                                : buildFallbackPrBody({ message, actions, diffStat }) + reportWarnings;
                     }
                     else {
-                        prBody = buildFallbackPrBody({ message, actions, diffStat });
+                        prBody = buildFallbackPrBody({ message, actions, diffStat }) + reportWarnings;
                     }
                     const prResult = spawnSync("gh", ["pr", "create", "--title", message, "--body", prBody, "--head", branchName], { cwd: wtPath, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
                     if (prResult.status === 0) {
@@ -899,7 +1057,12 @@ export async function createApp(projectRoot, options = {}) {
             if (claudeCheck.status !== 0) {
                 return res.json({ passed: true, skipped: true, reason: "claude CLI 없음 — 테스트 생략" });
             }
-            const result = spawnSync("claude", ["-p", "--model", "haiku", `이 프로젝트에서 PR 전에 돌려야 할 테스트 명령어를 찾아서 실행해줘. .github/workflows/ 디렉토리, package.json scripts, Makefile 등을 확인해. typecheck과 test를 우선 실행하고 결과를 알려줘. 명령어와 결과만 간단히.`], { cwd: wtPath, encoding: "utf8", stdio: "pipe", timeout: 120_000 });
+            const result = spawnSync("claude", [
+                "-p",
+                "--model",
+                "haiku",
+                `이 프로젝트에서 PR 전에 돌려야 할 테스트 명령어를 찾아서 실행해줘. .github/workflows/ 디렉토리, package.json scripts, Makefile 등을 확인해. typecheck과 test를 우선 실행하고 결과를 알려줘. 명령어와 결과만 간단히.`,
+            ], { cwd: wtPath, encoding: "utf8", stdio: "pipe", timeout: 120_000 });
             const output = result.stdout?.trim() || "";
             const failed = result.status !== 0 || /fail|error|FAIL|ERROR/i.test(output);
             broadcast({ type: "log", name, source: "sanjang", data: failed ? "❌ 테스트 실패" : "✅ 테스트 통과" });
@@ -921,7 +1084,11 @@ export async function createApp(projectRoot, options = {}) {
             return res.status(400).json({ error: "되돌릴 파일을 선택해주세요." });
         // Validate file paths against traversal and shell injection
         for (const file of files) {
-            if (typeof file !== "string" || file.includes("..") || file.startsWith("/") || /[`$;"'\\|&]/.test(file)) {
+            if (typeof file !== "string" ||
+                file.includes("..") ||
+                file.startsWith("/") ||
+                file.startsWith("-") ||
+                /[`$;"'\\|&]/.test(file)) {
                 return res.status(400).json({ error: `invalid file path: ${file}` });
             }
         }
@@ -1131,7 +1298,7 @@ export async function createApp(projectRoot, options = {}) {
                 : ["-C", wtPath, "log", "--oneline", "--format=%h\t%s\t%cr", "--max-count=5", "HEAD"];
             const log = spawnSync("git", logArgs, { encoding: "utf8", stdio: "pipe" }).stdout?.trim() || "";
             if (log) {
-                commits = log.split("\n").map(line => {
+                commits = log.split("\n").map((line) => {
                     const [hash = "", message = "", date = ""] = line.split("\t");
                     return { hash, message, date };
                 });
@@ -1277,7 +1444,8 @@ export async function createApp(projectRoot, options = {}) {
             copyCampFiles(projectRoot, wtPath, freshConfig2.copyFiles, (msg) => {
                 broadcast({ type: "log", name, source: "sanjang", data: msg });
             });
-            const baseCommit2 = spawnSync("git", ["-C", wtPath, "rev-parse", "HEAD"], { encoding: "utf8", stdio: "pipe" }).stdout?.trim() || undefined;
+            const baseCommit2 = spawnSync("git", ["-C", wtPath, "rev-parse", "HEAD"], { encoding: "utf8", stdio: "pipe" }).stdout?.trim() ||
+                undefined;
             const record = {
                 name,
                 branch,
@@ -1353,7 +1521,7 @@ export async function createApp(projectRoot, options = {}) {
                     startWatcher(name);
                     return res.json({ fixed: true, description: fix.description });
                 }
-                catch (retryErr) {
+                catch (_retryErr) {
                     return res.json({ fixed: false, description: "설정을 고쳤지만 시작에 실패했습니다." });
                 }
             }
@@ -1362,6 +1530,31 @@ export async function createApp(projectRoot, options = {}) {
     });
     let activityCache = null;
     const ACTIVITY_CACHE_TTL = 5 * 60 * 1000; // 5 minutes
+    // GET /api/compare/status — main 서버 상태
+    app.get("/api/compare/status", (_req, res) => {
+        res.json(getMainServerState());
+    });
+    // POST /api/compare/start — main 서버 시작
+    app.post("/api/compare/start", async (_req, res) => {
+        const mainState = getMainServerState();
+        if (mainState.status === "running") {
+            return res.json(mainState);
+        }
+        try {
+            await startMainServer(projectRoot, config, (port) => {
+                broadcast({ type: "compare-ready", data: { port } });
+            });
+            res.json(getMainServerState());
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // POST /api/compare/stop — main 서버 중지
+    app.post("/api/compare/stop", (_req, res) => {
+        stopMainServer();
+        res.json({ ok: true });
+    });
     app.get("/api/activity", (_req, res) => {
         if (activityCache && Date.now() - activityCache.ts < ACTIVITY_CACHE_TTL) {
             return res.json(activityCache.data);
@@ -1413,8 +1606,6 @@ export async function createApp(projectRoot, options = {}) {
                 streak++;
             }
             else if (key === todayStr) {
-                // Today having 0 commits is ok — streak can start from yesterday
-                continue;
             }
             else {
                 break;
@@ -1456,6 +1647,7 @@ export async function startServer(projectRoot, options = {}) {
             w.stop();
         watchers.clear();
         stopAllCamps();
+        stopMainServer();
         server.close(() => process.exit(0));
         // Force exit after 10s if cleanup hangs
         setTimeout(() => process.exit(1), 10_000);