@simplysm/sd-cli 14.0.42 → 14.0.43

package/tests/esbuild/file-reference-tracker.spec.ts

@@ -0,0 +1,99 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { FileReferenceTracker } from "../../src/esbuild/file-reference-tracker.js";
+
+describe("FileReferenceTracker", () => {
+  let tracker: FileReferenceTracker;
+
+  beforeEach(() => {
+    tracker = new FileReferenceTracker();
+  });
+
+  //#region Acceptance Tests
+
+  describe("리소스 의존성 등록 및 조회", () => {
+    it("add로 등록된 참조 파일이 referencedFiles에 포함된다", () => {
+      tracker.add("comp.ts", ["style.scss", "template.html"]);
+
+      const refs = new Set(tracker.referencedFiles);
+      expect(refs.has("style.scss")).toBe(true);
+      expect(refs.has("template.html")).toBe(true);
+    });
+
+    it("자기 참조(containingFile)는 referencedFiles에 포함되지 않는다", () => {
+      tracker.add("comp.ts", ["comp.ts", "style.scss"]);
+
+      const refs = new Set(tracker.referencedFiles);
+      expect(refs.has("comp.ts")).toBe(false);
+      expect(refs.has("style.scss")).toBe(true);
+    });
+  });
+
+  describe("변경 파일에 대한 전이적 영향 파일 확장", () => {
+    it("참조 파일 변경 시 containingFile도 반환한다", () => {
+      tracker.add("comp.ts", ["style.scss"]);
+
+      const changed = new Set(["style.scss"]);
+      const result = tracker.update(changed);
+
+      expect(result.has("style.scss")).toBe(true);
+      expect(result.has("comp.ts")).toBe(true);
+    });
+
+    it("update 후 stale 레코드가 정리된다", () => {
+      tracker.add("comp.ts", ["style.scss"]);
+
+      tracker.update(new Set(["style.scss"]));
+
+      // stale 레코드 정리 확인: style.scss가 더 이상 referencedFiles에 없어야 함
+      const refs = new Set(tracker.referencedFiles);
+      expect(refs.has("style.scss")).toBe(false);
+    });
+  });
+
+  describe("변경되지 않은 파일은 원본 Set만 반환", () => {
+    it("의존성이 없는 파일 변경 시 원본 Set을 그대로 반환한다", () => {
+      tracker.add("comp.ts", ["style.scss"]);
+
+      const changed = new Set(["other.ts"]);
+      const result = tracker.update(changed);
+
+      // 원본 Set이 그대로 반환됨 (새 Set이 아님)
+      expect(result).toBe(changed);
+      expect(result.has("other.ts")).toBe(true);
+      expect(result.size).toBe(1);
+    });
+  });
+
+  //#endregion
+
+  //#region Unit Tests — Edge Cases
+
+  it("경로가 normalize되어 저장된다", () => {
+    tracker.add("src\\comp.ts", ["src\\style.scss"]);
+
+    const refs = new Set(tracker.referencedFiles);
+    // path.normalize가 적용되어야 함
+    expect(refs.size).toBe(1);
+  });
+
+  it("동일 참조 파일을 여러 containingFile에서 등록할 수 있다", () => {
+    tracker.add("comp-a.ts", ["shared.scss"]);
+    tracker.add("comp-b.ts", ["shared.scss"]);
+
+    const changed = new Set(["shared.scss"]);
+    const result = tracker.update(changed);
+
+    expect(result.has("comp-a.ts")).toBe(true);
+    expect(result.has("comp-b.ts")).toBe(true);
+    expect(result.has("shared.scss")).toBe(true);
+  });
+
+  it("빈 referencedFiles로 add 호출 시 아무 것도 등록되지 않는다", () => {
+    tracker.add("comp.ts", []);
+
+    const refs = new Set(tracker.referencedFiles);
+    expect(refs.size).toBe(0);
+  });
+
+  //#endregion
+});

package/tests/esbuild/lmdb-cache-store.spec.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect, afterEach } from "vitest";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { LmdbCacheStore } from "../../src/esbuild/lmdb-cache-store.js";
+
+describe("LmdbCacheStore", () => {
+  let tmpDir: string;
+  let store: LmdbCacheStore;
+
+  function createStore(): LmdbCacheStore {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "lmdb-test-"));
+    store = new LmdbCacheStore(path.join(tmpDir, "test.db"));
+    return store;
+  }
+
+  afterEach(async () => {
+    await store.close();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  //#region Acceptance Tests
+
+  describe("값 저장 및 조회", () => {
+    it("set한 값을 get으로 조회할 수 있다", async () => {
+      createStore();
+
+      const value = new Uint8Array([1, 2, 3]);
+      await store.set("key1", value);
+
+      const result = store.get("key1");
+      // lmdb는 Uint8Array를 Buffer로 반환하므로 바이트 내용만 비교
+      expect(new Uint8Array(result as Uint8Array)).toEqual(value);
+    });
+  });
+
+  describe("close 후 리소스 해제", () => {
+    it("close 호출이 에러 없이 완료된다", async () => {
+      createStore();
+      await store.set("k", "v");
+
+      await expect(store.close()).resolves.toBeUndefined();
+    });
+  });
+
+  //#endregion
+
+  //#region Unit Tests — Edge Cases
+
+  it("존재하지 않는 키 조회 시 undefined를 반환한다", () => {
+    createStore();
+
+    const result = store.get("nonexistent");
+    expect(result).toBeUndefined();
+  });
+
+  //#endregion
+});

package/tests/esbuild/load-result-cache.acc.spec.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect, vi } from "vitest";
+import path from "path";
+import type { OnLoadResult } from "esbuild";
+
+const { MemoryLoadResultCache, createCachedLoad } = await import(
+  "../../src/esbuild/load-result-cache.js"
+);
+
+describe("MemoryLoadResultCache — Acceptance", () => {
+  it("put → get 조회 후, invalidate로 캐시 제거", () => {
+    const cache = new MemoryLoadResultCache();
+    const depPath = "/workspace/dep.js";
+    const utilPath = "/workspace/util.js";
+    const result: OnLoadResult = {
+      contents: "console.log('hello');",
+      loader: "js",
+      watchFiles: [depPath, utilPath],
+    };
+
+    // put 후 get으로 조회
+    cache.put("file:/workspace/app.js", result);
+    expect(cache.get("file:/workspace/app.js")).toBe(result);
+
+    // watchFiles에 의존 파일이 포함됨 (normalize된 경로)
+    expect(cache.watchFiles).toContain(path.normalize(depPath));
+    expect(cache.watchFiles).toContain(path.normalize(utilPath));
+
+    // 의존 파일 변경 → invalidate (normalize된 경로로 호출) → 캐시 제거
+    const found = cache.invalidate(path.normalize(depPath));
+    expect(found).toBe(true);
+    expect(cache.get("file:/workspace/app.js")).toBeUndefined();
+  });
+
+  it("createCachedLoad로 래핑된 콜백은 캐시 히트 시 원본을 호출하지 않는다", async () => {
+    const cache = new MemoryLoadResultCache();
+    const callback = vi.fn(() => ({
+      contents: "transformed",
+      loader: "js" as const,
+    }));
+
+    const cached = createCachedLoad(cache, callback) as (
+      args: { namespace: string; path: string },
+    ) => Promise<OnLoadResult | null | undefined>;
+
+    // 첫 호출 — 원본 실행
+    const result1 = await cached({ namespace: "file", path: "/workspace/vendor.js" });
+    expect(result1?.contents).toBe("transformed");
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    // 재호출 — 캐시 히트
+    const result2 = await cached({ namespace: "file", path: "/workspace/vendor.js" });
+    expect(result2?.contents).toBe("transformed");
+    expect(callback).toHaveBeenCalledTimes(1); // 추가 호출 없음
+  });
+});

package/tests/esbuild/load-result-cache.spec.ts

@@ -0,0 +1,133 @@
+import { describe, it, expect, vi } from "vitest";
+import path from "path";
+import type { OnLoadResult } from "esbuild";
+
+const { MemoryLoadResultCache, createCachedLoad } = await import(
+  "../../src/esbuild/load-result-cache.js"
+);
+
+describe("MemoryLoadResultCache", () => {
+  it("put 후 get으로 동일한 결과를 반환한다", () => {
+    const cache = new MemoryLoadResultCache();
+    const result: OnLoadResult = { contents: "x", loader: "js" };
+
+    cache.put("key1", result);
+    expect(cache.get("key1")).toBe(result);
+  });
+
+  it("존재하지 않는 키에 대해 undefined를 반환한다", () => {
+    const cache = new MemoryLoadResultCache();
+    expect(cache.get("nonexistent")).toBeUndefined();
+  });
+
+  it("watchFiles가 있는 결과를 put하면 fileDependencies가 추적된다", () => {
+    const cache = new MemoryLoadResultCache();
+    const depPath = "/workspace/dep.js";
+    cache.put("file:app.js", {
+      contents: "x",
+      loader: "js",
+      watchFiles: [depPath],
+    });
+
+    expect(cache.watchFiles).toContain(path.normalize(depPath));
+  });
+
+  it("invalidate는 의존 파일에 연결된 캐시 항목을 제거한다", () => {
+    const cache = new MemoryLoadResultCache();
+    const depPath = "/workspace/dep.js";
+    cache.put("file:app.js", {
+      contents: "x",
+      loader: "js",
+      watchFiles: [depPath],
+    });
+
+    const found = cache.invalidate(path.normalize(depPath));
+    expect(found).toBe(true);
+    expect(cache.get("file:app.js")).toBeUndefined();
+  });
+
+  it("invalidate는 의존성이 없는 파일에 대해 false를 반환한다", () => {
+    const cache = new MemoryLoadResultCache();
+    expect(cache.invalidate("/unknown.js")).toBe(false);
+  });
+
+  it("여러 항목이 같은 watchFile을 공유하면 모두 무효화된다", () => {
+    const cache = new MemoryLoadResultCache();
+    const sharedPath = "/workspace/shared.js";
+    const normalizedShared = path.normalize(sharedPath);
+    cache.put("file:a.js", { contents: "a", watchFiles: [sharedPath] });
+    cache.put("file:b.js", { contents: "b", watchFiles: [sharedPath] });
+
+    // invalidate는 normalize된 경로로 호출해야 한다 (호출자 책임, 원본 패턴)
+    cache.invalidate(normalizedShared);
+    expect(cache.get("file:a.js")).toBeUndefined();
+    expect(cache.get("file:b.js")).toBeUndefined();
+  });
+
+  it("watchFiles는 경로를 정규화하여 추적한다", () => {
+    const cache = new MemoryLoadResultCache();
+    cache.put("file:app.js", {
+      contents: "x",
+      watchFiles: ["/workspace\\dep.js"],
+    });
+
+    // path.normalize 적용 결과에 따라 경로가 정규화됨
+    const watchFiles = cache.watchFiles;
+    expect(watchFiles.length).toBe(1);
+  });
+});
+
+describe("createCachedLoad", () => {
+  it("cache가 undefined이면 원본 콜백을 그대로 반환한다", () => {
+    const callback = vi.fn();
+    const result = createCachedLoad(undefined, callback);
+    expect(result).toBe(callback);
+  });
+
+  it("캐시 미스 시 콜백을 호출하고 결과를 캐싱한다", async () => {
+    const cache = new MemoryLoadResultCache();
+    const callback = vi.fn(() => ({
+      contents: "result",
+      loader: "js" as const,
+    }));
+
+    const cached = createCachedLoad(cache, callback) as (
+      args: { namespace: string; path: string },
+    ) => Promise<OnLoadResult | null | undefined>;
+
+    await cached({ namespace: "file", path: "/app.js" });
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    // 캐시에 저장됨
+    expect(cache.get("file:/app.js")).toBeDefined();
+  });
+
+  it("콜백이 null을 반환하면 캐싱하지 않는다", async () => {
+    const cache = new MemoryLoadResultCache();
+    const callback = vi.fn(() => null);
+
+    const cached = createCachedLoad(cache, callback) as (
+      args: { namespace: string; path: string },
+    ) => Promise<OnLoadResult | null | undefined>;
+
+    const result = await cached({ namespace: "file", path: "/skip.js" });
+    expect(result).toBeNull();
+    expect(cache.get("file:/skip.js")).toBeUndefined();
+  });
+
+  it("file namespace일 때 watchFiles에 args.path가 자동 추가된다", async () => {
+    const cache = new MemoryLoadResultCache();
+    const callback = vi.fn(() => ({
+      contents: "result",
+      loader: "js" as const,
+    }));
+
+    const cached = createCachedLoad(cache, callback) as (
+      args: { namespace: string; path: string },
+    ) => Promise<OnLoadResult | null | undefined>;
+
+    await cached({ namespace: "file", path: "/app.js" });
+    const stored = cache.get("file:/app.js");
+    expect(stored?.watchFiles).toContain("/app.js");
+  });
+});

package/tests/orchestrators/build-orchestrator.spec.ts

@@ -229,6 +229,7 @@ describe("BuildOrchestrator.initialize", () => {
     const hasError = await orchestrator.start();
 
     expect(hasError).toBe(false);
+    expect(mockLogger.info).toHaveBeenCalledWith("빌드할 패키지가 없습니다.");
   });
 });
 
@@ -266,7 +267,7 @@ describe("BuildOrchestrator.start", () => {
 
     // BuildEngine should be created and run() called
     expect(createBuildEngine).toHaveBeenCalledOnce();
-    expect(mockEngines[0].run).toHaveBeenCalledWith({ js: true, dts: true, lint: false });
+    expect(mockEngines[0].run).toHaveBeenCalledWith({ js: true, dts: true, lint: false, includeTests: false });
     expect(mockEngines[0].stop).toHaveBeenCalled();
   });
 
@@ -617,7 +618,7 @@ describe("BuildOrchestrator client build", () => {
       expect.any(Object),
     );
     const engineMock = vi.mocked(createBuildEngine).mock.results[0].value;
-    expect(engineMock.run).toHaveBeenCalledWith({ js: true, dts: false, lint: false });
+    expect(engineMock.run).toHaveBeenCalledWith({ js: true, dts: false, lint: false, includeTests: false });
     expect(engineMock.stop).toHaveBeenCalled();
   });
 
@@ -844,7 +845,7 @@ describe("BuildOrchestrator native build integration (Slice 1)", () => {
     // ViteEngine should have been called
     expect(createBuildEngine).toHaveBeenCalled();
     const engineMock = vi.mocked(createBuildEngine).mock.results[0].value;
-    expect(engineMock.run).toHaveBeenCalledWith({ js: true, dts: false, lint: false });
+    expect(engineMock.run).toHaveBeenCalledWith({ js: true, dts: false, lint: false, includeTests: false });
 
     // Capacitor should have been created, initialized, and built
     expect(Capacitor.create).toHaveBeenCalledWith(

package/tests/orchestrators/dev-orchestrator.spec.ts

@@ -18,7 +18,7 @@ vi.mock("../../src/utils/output-utils", async (importOriginal) => {
   const actual = await importOriginal<typeof import("../../src/utils/output-utils")>();
   return {
     ...actual,
-    printErrors: vi.fn(),
+    printDiagnostics: vi.fn(),
     printServers: vi.fn(),
   };
 });
@@ -117,7 +117,7 @@ vi.mock("../../src/electron/electron", () => ({
 const { DevOrchestrator } = await import("../../src/orchestrators/DevOrchestrator");
 const { loadSdConfig } = await import("../../src/utils/sd-config");
 const { watchReplaceDeps } = await import("../../src/deps/replace-deps/replace-deps");
-const { printErrors, printServers: _printServers } = await import("../../src/utils/output-utils");
+const { printDiagnostics, printServers: _printServers } = await import("../../src/utils/output-utils");
 const { createBuildEngine } = await import("../../src/engines/engine-factory");
 const { Worker } = await import("@simplysm/core-node");
 const { getVersion } = await import("../../src/utils/build-env");
@@ -302,7 +302,7 @@ describe("DevOrchestrator", () => {
 
     expect(mockBuildEngines).toHaveLength(1);
     expect(mockBuildEngines[0]._pkgName).toBe("service-server");
-    expect(mockBuildEngines[0].startWatch).toHaveBeenCalledWith({ js: true, dts: false, lint: false });
+    expect(mockBuildEngines[0].startWatch).toHaveBeenCalledWith({ js: true, dts: false, lint: false, includeTests: false });
     expect(Worker.create).toHaveBeenCalled();
     expect(mockRuntimeProxies[0].start).toHaveBeenCalled();
   });
@@ -397,7 +397,7 @@ describe("DevOrchestrator", () => {
     await orchestrator.start();
 
     expect(Worker.create).not.toHaveBeenCalled();
-    expect(printErrors).toHaveBeenCalled();
+    expect(printDiagnostics).toHaveBeenCalled();
   });
 
   // --- Unit: excludes library packages ---
@@ -504,7 +504,7 @@ describe("DevOrchestrator", () => {
     await orchestrator.start();
 
     const clientEngine = mockBuildEngines.find((e) => e._pkgName === "my-client")!;
-    expect(clientEngine.startWatch).toHaveBeenCalledWith({ js: true, dts: false, lint: false });
+    expect(clientEngine.startWatch).toHaveBeenCalledWith({ js: true, dts: false, lint: false, includeTests: false });
   });
 
   it("passes clientPorts to server runtime for connected clients", async () => {

package/tests/orchestrators/slice1-stdout-to-consola.verify.md

@@ -0,0 +1,10 @@
+# Slice 1: process.stdout.write → consola 전환 — LLM 검증
+
+## 검증 항목
+
+- [x] BaseOrchestrator.ts:105 — `this._logger.start("종료 중...")` 사용 확인: `process.stdout.write("⏳ 종료 중...\n")` → `this._logger.start("종료 중...")` 변경 완료. 수동 아이콘 ⏳ 제거됨
+- [x] BaseOrchestrator.ts:107 — `this._logger.success("종료 완료")` 사용 확인: `process.stdout.write("✔ 종료 완료\n")` → `this._logger.success("종료 완료")` 변경 완료. 수동 아이콘 ✔ 제거됨
+- [x] BuildOrchestrator.ts:173 — `this._logger.info("빌드할 패키지가 없습니다.")` 사용 확인: `process.stdout.write("✔ 빌드할 패키지가 없습니다.\n")` → `this._logger.info(...)` 변경 완료. 자동 테스트에서도 검증됨
+- [x] WatchOrchestrator.ts:69 — `this._logger.warn("워치 대상 패키지가 없습니다.")` 사용 확인: `process.stdout.write("⚠ 워치 대상 패키지가 없습니다.\n")` → `this._logger.warn(...)` 변경 완료. 수동 아이콘 ⚠ 제거됨
+- [x] publish-command.ts:121 — `logger.info("배포할 패키지가 없습니다.")` 사용 확인: `process.stdout.write("✔ 배포할 패키지가 없습니다.\n")` → `logger.info(...)` 변경 완료. 수동 아이콘 ✔ 제거됨
+- [x] 모든 대상 파일에서 process.stdout.write가 더 이상 사용되지 않음 확인 (output-utils.ts의 printServers 내 `"\n"` 출력은 Feature 1.2 범위 외)

package/tests/orchestrators/typecheck-orchestrator.spec.ts

@@ -123,7 +123,7 @@ describe("TypecheckOrchestrator", () => {
     expect(mocks.createTypecheckEngine).toHaveBeenCalledTimes(3);
     for (const engine of mockEngines) {
       expect(engine.run).toHaveBeenCalledWith(
-        expect.objectContaining({ js: false, dts: false }),
+        expect.objectContaining({ js: false, dts: false, includeTests: true }),
       );
     }
   });

package/tests/orchestrators/watch-orchestrator.spec.ts

@@ -18,7 +18,7 @@ vi.mock("../../src/utils/output-utils", async (importOriginal) => {
   const actual = await importOriginal<typeof import("../../src/utils/output-utils")>();
   return {
     ...actual,
-    printErrors: vi.fn(),
+    printDiagnostics: vi.fn(),
     printServers: vi.fn(),
   };
 });
@@ -104,7 +104,7 @@ vi.mock("child_process", () => ({
 const { WatchOrchestrator } = await import("../../src/orchestrators/WatchOrchestrator");
 const { loadSdConfig } = await import("../../src/utils/sd-config");
 const { watchReplaceDeps } = await import("../../src/deps/replace-deps/replace-deps");
-const { printErrors } = await import("../../src/utils/output-utils");
+const { printDiagnostics } = await import("../../src/utils/output-utils");
 const { createBuildEngine } = await import("../../src/engines/engine-factory");
 const { watchCopySrcFiles } = await import("../../src/utils/copy-src");
 const { FsWatcher } = await import("@simplysm/core-node");
@@ -189,7 +189,7 @@ describe("WatchOrchestrator", () => {
 
     // Library engine started with js+dts
     expect(mockBuildEngines).toHaveLength(1);
-    expect(mockBuildEngines[0].startWatch).toHaveBeenCalledWith({ js: true, dts: true, lint: false });
+    expect(mockBuildEngines[0].startWatch).toHaveBeenCalledWith({ js: true, dts: true, lint: false, includeTests: false });
 
     // copySrc watcher started
     expect(watchCopySrcFiles).toHaveBeenCalledWith(
@@ -316,7 +316,7 @@ describe("WatchOrchestrator", () => {
     expect(spawn).toHaveBeenCalled();
   });
 
-  it("triggers printErrors on batchComplete", async () => {
+  it("triggers printDiagnostics on batchComplete", async () => {
     setupDefaults(createConfig({
       packages: { "core-common": { target: "node" } },
     }));
@@ -326,7 +326,7 @@ describe("WatchOrchestrator", () => {
     await orchestrator.start();
 
     await new Promise((r) => setTimeout(r, 50));
-    expect(printErrors).toHaveBeenCalled();
+    expect(printDiagnostics).toHaveBeenCalled();
   });
 
   it("delegates awaitTermination to SignalHandler", async () => {
@@ -425,7 +425,7 @@ describe("WatchOrchestrator", () => {
     await orchestrator.start();
 
     expect(mockBuildEngines).toHaveLength(1);
-    expect(mockBuildEngines[0].startWatch).toHaveBeenCalledWith({ js: true, dts: true, lint: false });
+    expect(mockBuildEngines[0].startWatch).toHaveBeenCalledWith({ js: true, dts: true, lint: false, includeTests: false });
     expect(spawn).toHaveBeenCalledWith("node", ["sync.mjs"], expect.objectContaining({ shell: true }));
   });
 
@@ -488,7 +488,7 @@ describe("WatchOrchestrator", () => {
     await orchestrator.start();
 
     for (const engine of mockBuildEngines) {
-      expect(engine.startWatch).toHaveBeenCalledWith({ js: true, dts: true, lint: false });
+      expect(engine.startWatch).toHaveBeenCalledWith({ js: true, dts: true, lint: false, includeTests: false });
     }
   });
 

package/tests/runtime/result-collector.spec.ts

@@ -52,4 +52,68 @@ describe("ResultCollector", () => {
     expect(map.size).toBe(1);
     expect(map.get("core:build")!.status).toBe("success");
   });
+
+  //#region Feature 1.1 Slice 1: BuildResult warnings 필드
+
+  it("stores warnings alongside error message", () => {
+    const collector = new ResultCollector();
+    collector.add({
+      name: "client-pda",
+      target: "client",
+      type: "build",
+      status: "error",
+      message: "타입 에러",
+      warnings: "사용되지 않는 변수",
+    });
+
+    const result = collector.get("client-pda:build");
+    expect(result!.status).toBe("error");
+    expect(result!.message).toBe("타입 에러");
+    expect(result!.warnings).toBe("사용되지 않는 변수");
+  });
+
+  it("stores warnings on success result", () => {
+    const collector = new ResultCollector();
+    collector.add({
+      name: "core",
+      target: "node",
+      type: "build",
+      status: "success",
+      warnings: "경고1\n경고2",
+    });
+
+    const result = collector.get("core:build");
+    expect(result!.status).toBe("success");
+    expect(result!.warnings).toBe("경고1\n경고2");
+  });
+
+  it("warnings is undefined when not provided", () => {
+    const collector = new ResultCollector();
+    collector.add({ name: "core", target: "node", type: "build", status: "success" });
+
+    const result = collector.get("core:build");
+    expect(result!.warnings).toBeUndefined();
+  });
+
+  it("overwrites warnings on re-add", () => {
+    const collector = new ResultCollector();
+    collector.add({
+      name: "core",
+      target: "node",
+      type: "build",
+      status: "success",
+      warnings: "old warning",
+    });
+    collector.add({
+      name: "core",
+      target: "node",
+      type: "build",
+      status: "success",
+    });
+
+    // 새 결과에 warnings가 없으면 이전 값은 덮어씌워짐
+    expect(collector.get("core:build")!.warnings).toBeUndefined();
+  });
+
+  //#endregion
 });

package/tests/sd-cli-entry.spec.ts

@@ -64,12 +64,11 @@ describe("sd-cli-entry COMMAND_NAMES", () => {
     ).resolves.toBeDefined();
   });
 
-  it("parses --target separately from --type", async () => {
+  it("throws on --type test (removed type)", async () => {
     const { createCliParser } = await import("../src/sd-cli-entry");
 
-    // --type test 뒤의 --target angular가 type으로 먹히지 않아야 한다
     await expect(
-      createCliParser(["check", "--type", "test", "--target", "angular"]).exitProcess(false).parse(),
-    ).resolves.toBeDefined();
+      createCliParser(["check", "--type", "test"]).exitProcess(false).parse(),
+    ).rejects.toThrow("Invalid check type(s): test");
   });
 });

package/tests/sd-cli-log-tag.verify.md

@@ -0,0 +1,11 @@
+# CLI 진입점 태그 로거 — LLM 검증
+
+## 검증 항목
+
+- [x] sd-cli.ts에 `consola.withTag("sd:cli")` 모듈-레벨 로거가 생성됨: `src/sd-cli.ts:18` — `const logger = consola.withTag("sd:cli");`
+- [x] sd-cli.ts replaceDeps 경고에서 수동 `[sd-cli]` prefix가 제거됨: `src/sd-cli.ts:43` — `logger.warn("replaceDeps 사전 설정 실패:", ...)` (이전: `consola.warn("[sd-cli] replaceDeps ..."`)
+- [x] sd-cli.ts CPU affinity 경고가 consola로 전환됨: `src/sd-cli.ts:104-108` — `logger.warn("CPU affinity/priority 설정 실패:", ...)` (이전: `console.warn("Failed to configure ..."`)
+- [x] sd-cli.ts에서 `eslint-disable-next-line no-console` 주석이 제거됨: `src/sd-cli.ts:104` 부근에 해당 주석 없음
+- [x] sd-cli-entry.ts에 `consola.withTag("sd:cli:entry")` 모듈-레벨 로거가 생성됨: `src/sd-cli-entry.ts:20` — `const logger = consola.withTag("sd:cli:entry");`
+- [x] sd-cli-entry.ts .fail() 핸들러가 태그 로거를 사용함: `src/sd-cli-entry.ts:329` — `logger.error(msg);` (이전: `consola.error(msg)`)
+- [x] sd-cli-entry.ts의 `/* eslint-disable no-console */`이 유지됨: `src/sd-cli-entry.ts:1` — `collectYargsHelp`의 `console.log` 사용 때문에 필요

package/tests/ts-compiler/SdTsCompiler-affected-files.verify.md

@@ -0,0 +1,8 @@
+# affected files 추적 — LLM 검증
+
+## 검증 항목
+
+- [x] Non-Angular 전역 변경 시 affectedFiles=undefined: `_findAffectedFilesForTsc`에서 `result.affected`가 `ts.SourceFile`이 아닌 경우(`"fileName" in result.affected` 실패) `return undefined`를 반환. (`SdTsCompiler.ts:272-275`)
+- [x] Angular TypeScript 5.9 크래시 방어: `_findAffectedFilesForAngular`에서 `getSemanticDiagnosticsOfNextAffectedFile`를 try-catch로 감싸고, catch 시 전체 소스를 affected로 처리 (`SdTsCompiler.ts:290-298`)
+- [x] Angular 리소스 의존성 기반 추가 affected: `_findAffectedFilesForAngular`에서 `sourceFileCache.modifiedFiles`와 `angularCompiler.getResourceDependencies(sourceFile)`를 비교하여 매칭 시 `_diagnosticCache.delete(sourceFile)` + `affectedSourceFiles.add(sourceFile)` (`SdTsCompiler.ts:317-334`)
+- [x] Angular .ngtypecheck.ts → 원본 .ts 매핑: `getSemanticDiagnosticsOfNextAffectedFile`의 두 번째 인자 콜백에서 `.ngtypecheck.ts` 파일을 원본 `.ts`로 매핑하여 affected에 추가 (`SdTsCompiler.ts:284-295`)

package/tests/ts-compiler/SdTsCompiler-diagnostics.verify.md

@@ -0,0 +1,12 @@
+# 진단 수집 — LLM 검증
+
+## 검증 항목
+
+- [x] Angular TS 5.9 getSemanticDiagnostics 크래시 방어: `_collectDiagnosticsForAngular`에서 `builderProgram.getSemanticDiagnostics(sourceFile)`를 try-catch로 감싸고, catch 시 빈 배열로 처리 (`SdTsCompiler.ts` `_collectDiagnosticsForAngular` 메서드 내 per-file 루프)
+- [x] Angular diagnosticCache 갱신: affected 파일이면 `getDiagnosticsForFile` 호출 후 `this._diagnosticCache.set(sourceFile, angularDiagnostics)` 수행 (`SdTsCompiler.ts` `_collectDiagnosticsForAngular` 메서드)
+- [x] Angular diagnosticCache 반환: 비-affected 파일이면 `this._diagnosticCache.get(sourceFile)` 캐시 결과 반환 (`SdTsCompiler.ts` `_collectDiagnosticsForAngular` 메서드)
+- [x] Angular ignoreForDiagnostics 건너뜀: per-file 루프에서 `angularCompiler.ignoreForDiagnostics.has(sourceFile)` 체크 후 continue
+- [x] Non-Angular 7종 진단 수집: `_collectDiagnosticsForTsc`에서 config + syntactic + options + global + semantic + declaration 진단 수집 (declaration은 `!output.dts` 조건)
+- [x] isWorkspaceDiagnostic 필터링: `_finalizeDiagnostics`에서 `rawDiagnostics.filter(d => isWorkspaceDiagnostic(d, this._options.cwd))` 적용
+- [x] serializeDiagnostic 직렬화: `_finalizeDiagnostics`에서 `filtered.map(serializeDiagnostic)` 적용
+- [x] formatDiagnosticError 포맷: `_finalizeDiagnostics`에서 Error 카테고리 진단을 `formatDiagnosticError`로 포맷하여 `errors` 배열 생성

package/tests/ts-compiler/SdTsCompiler-emit.verify.md

@@ -0,0 +1,9 @@
+# emit 처리 — LLM 검증
+
+## 검증 항목
+
+- [x] Angular emit — additionalTransformers 병합: `_emitAngular`에서 `emitOptions?.additionalTransformers`의 before/after를 `angularCompiler.prepareEmit().transformers`에 push 병합 (`SdTsCompiler.ts` `_emitAngular` 메서드)
+- [x] Angular emit — tsbuildinfo 영속화 크래시 방어: `builderProgram.emit(undefined, () => {})` 호출이 try-catch로 감싸져 있음 (`SdTsCompiler.ts` `_emitAngular` 메서드 하단)
+- [x] Angular emit — sourceFilter 적용: emitResults를 `emitOptions.sourceFilter`로 필터링하여 반환 (`SdTsCompiler.ts` `_emitAngular` 메서드 마지막)
+- [x] Angular emit — incrementalCompilation.recordSuccessfulEmit 호출: writeFileCallback에서 각 sourceFile에 대해 호출됨
+- [x] Angular emit — ignoreForEmit/isDeclarationFile/safeToSkipEmit 건너뜀: per-file emit 루프에서 세 조건 모두 continue 처리