@simplysm/sd-cli 14.0.30 → 14.0.32

package/tests/orchestrators/orchestrator-baseenv.verify.md

@@ -0,0 +1,10 @@
+# Orchestrator 환경변수 설정 중앙화 — LLM 검증
+
+## 검증 항목
+
+- [x] BaseOrchestrator에 `_baseEnv` protected 필드 추가됨: `BaseOrchestrator.ts:31`에 `protected _baseEnv!: { VER: string; DEV: string }` 확인
+- [x] BaseOrchestrator.initialize()에서 getVersion + dev 파라미터로 _baseEnv 설정: `BaseOrchestrator.ts:69-71`에 `getVersion(this._cwd)` → `{ VER: version, DEV: params.dev ? "true" : "false" }` 확인
+- [x] DevOrchestrator._initializeMode()에서 getVersion/baseEnv 코드 제거: `_initializeMode`는 `void` 반환, `getVersion` import도 제거됨
+- [x] DevOrchestrator에서 private `_baseEnv` 필드 제거: BaseOrchestrator의 protected 필드를 상속
+- [x] WatchOrchestrator는 변경 없음: BaseOrchestrator에서 _baseEnv가 자동 설정되며, WatchOrchestrator는 이를 사용하지 않아도 무해
+- [x] 기존 테스트 업데이트: watch-orchestrator.spec.ts에서 `_baseEnv` 미존재 assertion 제거 (이제 Base 공통 필드)

package/tests/orchestrators/orchestrator-diagnostic-formatting.verify.md

@@ -0,0 +1,10 @@
+# Orchestrator 진단 포맷팅 공통 함수 사용 — LLM 검증
+
+## 검증 항목
+
+- [x] BuildOrchestrator._printBuildResults()가 formatDiagnosticsOutput()을 사용: `BuildOrchestrator.ts:465-468`에서 `formatDiagnosticsOutput(allDiagnostics, this._cwd)` 호출 확인. 기존 인라인 `FormatDiagnosticsHost` 생성 + `sortAndDeduplicateDiagnostics` + `formatDiagnosticsWithColorAndContext` 패턴이 제거됨
+- [x] TypecheckOrchestrator._aggregateTypecheckResults()가 formatDiagnosticsOutput()을 사용: `TypecheckOrchestrator.ts:362`에서 `formatDiagnosticsOutput(allDiagnostics, this._cwd)` 호출 확인. 기존 인라인 `FormatDiagnosticsHost` + `sortAndDeduplicateDiagnostics` + `formatDiagnosticsWithColorAndContext` 패턴이 제거됨
+- [x] BuildOrchestrator의 import에 `formatDiagnosticsOutput`이 추가됨 (line 15)
+- [x] TypecheckOrchestrator의 import에 `formatDiagnosticsOutput`이 추가됨 (line 11)
+- [x] 기존 동작 보존: BuildOrchestrator의 per-result 경고/에러 로깅 로직(`formatBuildMessages`)은 그대로 유지됨
+- [x] 기존 동작 보존: TypecheckOrchestrator의 요약 로그/lint 결과 생성 로직은 그대로 유지됨

package/tests/orchestrators/orchestrator-initializemode-signature.verify.md

@@ -0,0 +1,9 @@
+# _initializeMode 시그니처 정리 — LLM 검증
+
+## 검증 항목
+
+- [x] BaseOrchestrator._initializeMode 추상 메서드에서 `options: string[]` 파라미터 제거: `BaseOrchestrator.ts:109-111`에 `(config: SdConfig, targets: string[])` 2개 파라미터만 확인
+- [x] BaseOrchestrator.initialize() 호출부에서 options 인자 제거: `BaseOrchestrator.ts:79`에 `_initializeMode(sdConfig, params.targets)` 확인
+- [x] options는 BaseOrchestrator.initialize()의 loadSdConfig()에서만 사용됨: `BaseOrchestrator.ts:53`에 `opt: params.options` 확인
+- [x] DevOrchestrator._initializeMode 시그니처 변경 불필요: 이미 `(config, targets)` 2개 파라미터
+- [x] WatchOrchestrator._initializeMode 시그니처 변경 불필요: 이미 `(config, targets)` 2개 파라미터

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

@@ -3,10 +3,10 @@ import { describe, it, expect, vi, beforeEach } from "vitest";
 //#region Mocks
 
 const mocks = vi.hoisted(() => ({
-  loadSdConfig: vi.fn(),
+  loadAndValidateConfig: vi.fn(),
   deserializeDiagnostic: vi.fn((d: any) => d),
   typecheckNonPackageFiles: vi.fn(),
-  createBuildEngine: vi.fn(),
+  createTypecheckEngine: vi.fn(),
   discoverWorkspacePackages: vi.fn(),
   mergeTestsPackagesIntoConfig: vi.fn(),
 }));
@@ -16,20 +16,20 @@ const mockEngines: Array<{
   stop: ReturnType<typeof vi.fn>;
 }> = [];
 
-vi.mock("../../src/utils/sd-config", () => ({
-  loadSdConfig: mocks.loadSdConfig,
+vi.mock("../../src/utils/orchestrator-utils", () => ({
+  loadAndValidateConfig: mocks.loadAndValidateConfig,
 }));
 
-vi.mock("../../src/utils/typecheck-serialization", () => ({
+vi.mock("../../src/typecheck/typecheck-serialization", () => ({
   deserializeDiagnostic: mocks.deserializeDiagnostic,
 }));
 
-vi.mock("../../src/utils/typecheck-non-package", () => ({
+vi.mock("../../src/typecheck/typecheck-non-package", () => ({
   typecheckNonPackageFiles: mocks.typecheckNonPackageFiles,
 }));
 
 vi.mock("../../src/engines/index", () => ({
-  createBuildEngine: mocks.createBuildEngine,
+  createTypecheckEngine: mocks.createTypecheckEngine,
 }));
 
 vi.mock("../../src/utils/package-utils", async (importOriginal) => {
@@ -77,8 +77,8 @@ function createMockEngine() {
 }
 
 function setupDefaults(packages: Record<string, any> = {}) {
-  mocks.loadSdConfig.mockResolvedValue({ packages });
-  mocks.createBuildEngine.mockImplementation(() => createMockEngine() as any);
+  mocks.loadAndValidateConfig.mockResolvedValue({ packages });
+  mocks.createTypecheckEngine.mockImplementation(() => createMockEngine() as any);
   mocks.typecheckNonPackageFiles.mockReturnValue({
     success: true, errorCount: 0, warningCount: 0, diagnostics: [],
   });
@@ -120,7 +120,7 @@ describe("TypecheckOrchestrator", () => {
     expect(result.errorCount).toBe(0);
     expect(result.warningCount).toBe(0);
     // neutral → 2 tasks (node + browser), node → 1 task = 3 engines
-    expect(mocks.createBuildEngine).toHaveBeenCalledTimes(3);
+    expect(mocks.createTypecheckEngine).toHaveBeenCalledTimes(3);
     for (const engine of mockEngines) {
       expect(engine.run).toHaveBeenCalledWith(
         expect.objectContaining({ js: false, dts: false }),
@@ -143,7 +143,7 @@ describe("TypecheckOrchestrator", () => {
   // Acceptance: Scenario "엔진 실패 시 리소스 정리"
   it("calls engine.stop() even when run fails", async () => {
     setupDefaults({ "core-node": { target: "node" } });
-    mocks.createBuildEngine.mockImplementation(() => {
+    mocks.createTypecheckEngine.mockImplementation(() => {
       const engine = {
         run: vi.fn().mockRejectedValue(new Error("build error")),
         startWatch: vi.fn(),

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

@@ -0,0 +1,511 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// --- Mock factories (vi.mock is hoisted) ---
+
+vi.mock("../../src/utils/sd-config", () => ({
+  loadSdConfig: vi.fn(),
+}));
+
+vi.mock("../../src/utils/build-env", () => ({
+  getVersion: vi.fn(),
+}));
+
+vi.mock("../../src/deps/replace-deps/replace-deps", () => ({
+  watchReplaceDeps: vi.fn(),
+}));
+
+vi.mock("../../src/utils/output-utils", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../../src/utils/output-utils")>();
+  return {
+    ...actual,
+    printErrors: vi.fn(),
+    printServers: vi.fn(),
+  };
+});
+
+vi.mock("../../src/runtime/SignalHandler", () => ({
+  SignalHandler: vi.fn().mockImplementation(function (this: any) {
+    this.waitForTermination = vi.fn().mockResolvedValue(undefined);
+    this.isTerminated = vi.fn().mockReturnValue(false);
+    this.requestTermination = vi.fn();
+  }),
+}));
+
+vi.mock("../../src/utils/copy-src", () => ({
+  watchCopySrcFiles: vi.fn().mockResolvedValue({
+    close: vi.fn().mockResolvedValue(undefined),
+  }),
+}));
+
+// Engine mock — tracks created engines and the package they were created for
+const mockBuildEngines: Array<{
+  run: ReturnType<typeof vi.fn>;
+  startWatch: ReturnType<typeof vi.fn>;
+  stop: ReturnType<typeof vi.fn>;
+  _pkgName: string;
+}> = [];
+
+vi.mock("../../src/engines/index", () => ({
+  createBuildEngine: vi.fn((pkg: any, options: any) => {
+    const engine = {
+      run: vi.fn().mockResolvedValue({
+        success: true,
+        build: { success: true, errors: [], warnings: [], diagnostics: [] },
+      }),
+      startWatch: vi.fn().mockImplementation(() => {
+        const resolve = options.rebuildManager.registerBuild(
+          `${pkg.name}:build`,
+          `${pkg.name} (${pkg.config.target})`,
+        );
+        options.resultCollector.add({
+          name: pkg.name,
+          target: pkg.config.target,
+          type: "build",
+          status: "success",
+        });
+        resolve();
+      }),
+      stop: vi.fn().mockResolvedValue(undefined),
+      _pkgName: pkg.name,
+    };
+    mockBuildEngines.push(engine);
+    return engine;
+  }),
+}));
+
+vi.mock("@simplysm/core-node", () => ({
+  FsWatcher: {
+    watch: vi.fn().mockResolvedValue({
+      onChange: vi.fn(),
+      close: vi.fn().mockResolvedValue(undefined),
+    }),
+  },
+  Worker: {
+    create: vi.fn(),
+  },
+  pathx: {
+    posix: vi.fn((p: string) => p.replace(/\\/g, "/")),
+    posixResolve: vi.fn((...args: string[]) => args.join("/").replace(/\\/g, "/")),
+    isChildPath: vi.fn((child: string, parent: string) => child.startsWith(parent + "/")),
+    filterByTargets: vi.fn((files: string[], targets: string[]) => targets.length === 0 ? files : files),
+  },
+}));
+
+vi.mock("child_process", () => ({
+  spawn: vi.fn(() => ({
+    on: vi.fn(),
+    kill: vi.fn(),
+    exitCode: 0,
+  })),
+}));
+
+// --- Dynamic imports after mocking ---
+
+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 { createBuildEngine } = await import("../../src/engines/index");
+const { watchCopySrcFiles } = await import("../../src/utils/copy-src");
+const { FsWatcher } = await import("@simplysm/core-node");
+const { spawn } = await import("child_process");
+const { getVersion } = await import("../../src/utils/build-env");
+
+import type { SdConfig } from "../../src/sd-config.types";
+
+// --- Helpers ---
+
+function createConfig(overrides: Partial<SdConfig> = {}): SdConfig {
+  return { packages: {}, ...overrides };
+}
+
+function setupDefaults(config: SdConfig): void {
+  vi.mocked(loadSdConfig).mockResolvedValue(config);
+  vi.mocked(watchReplaceDeps).mockResolvedValue({ entries: [], dispose: vi.fn() });
+  vi.mocked(getVersion).mockResolvedValue("1.0.0");
+}
+
+// --- Tests ---
+
+describe("WatchOrchestrator", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockBuildEngines.length = 0;
+    vi.spyOn(process, "cwd").mockReturnValue("/test-root");
+    vi.spyOn(process.stdout, "write").mockImplementation(() => true);
+    vi.mocked(createBuildEngine).mockImplementation((pkg: any, options: any) => {
+      const engine = {
+        run: vi.fn().mockResolvedValue({
+          success: true,
+          build: { success: true, errors: [], warnings: [], diagnostics: [] },
+        }),
+        startWatch: vi.fn().mockImplementation(() => {
+          const resolve = options.rebuildManager.registerBuild(
+            `${pkg.name}:build`,
+            `${pkg.name} (${pkg.config.target})`,
+          );
+          options.resultCollector.add({
+            name: pkg.name,
+            target: pkg.config.target,
+            type: "build",
+            status: "success",
+          });
+          resolve();
+        }),
+        stop: vi.fn().mockResolvedValue(undefined),
+        _pkgName: pkg.name,
+      };
+      mockBuildEngines.push(engine);
+      return engine as any;
+    });
+  });
+
+  // --- Acceptance: Scenario "watch 모드 생성 시 dev 전용 필드 없음" ---
+  it("does not have dev-specific fields (_serverRuntimeWorkers, _clientEngines, _serverRestartTimer, _printServersTimer)", () => {
+    const orchestrator = new WatchOrchestrator({ targets: [], options: [] });
+    // dev 전용 필드가 WatchOrchestrator 인스턴스에 존재하지 않음을 확인
+    // _baseEnv는 BaseOrchestrator 공통 필드로 이동하여 watch에서도 존재
+    expect(orchestrator).not.toHaveProperty("_serverRuntimeWorkers");
+    expect(orchestrator).not.toHaveProperty("_clientEngines");
+    expect(orchestrator).not.toHaveProperty("_serverRestartTimer");
+    expect(orchestrator).not.toHaveProperty("_printServersTimer");
+  });
+
+  // --- Acceptance: Scenario "watch 모드 실행" ---
+  it("starts library engines with js+dts, copySrc watchers, and watch hooks", async () => {
+    setupDefaults(createConfig({
+      packages: {
+        "core-common": { target: "node", copySrc: ["**/*.json"] },
+        "sd-scripts": {
+          target: "scripts",
+          watch: { target: ["dist/**/*.js"], cmd: "node", args: ["run-task.js"] },
+        },
+      },
+    }));
+
+    const orchestrator = new WatchOrchestrator({ targets: [], options: [] });
+    await orchestrator.initialize();
+    await orchestrator.start();
+
+    // Library engine started with js+dts
+    expect(mockBuildEngines).toHaveLength(1);
+    expect(mockBuildEngines[0].startWatch).toHaveBeenCalledWith({ js: true, dts: true, lint: false });
+
+    // copySrc watcher started
+    expect(watchCopySrcFiles).toHaveBeenCalledWith(
+      expect.stringContaining("core-common"),
+      ["**/*.json"],
+    );
+
+    // watch hook executed
+    expect(spawn).toHaveBeenCalledWith("node", ["run-task.js"], expect.objectContaining({ shell: true }));
+  });
+
+  // --- Acceptance: Scenario "공통 초기화 로직 실행" (BaseOrchestrator) ---
+  it("loads sd.config, builds pathMap, validates targets, starts replaceDeps watch on initialize", async () => {
+    const replaceDeps = { "@simplysm/*": "packages/*/src" };
+    setupDefaults(createConfig({
+      packages: { "core-common": { target: "node" } },
+      replaceDeps,
+    }));
+
+    const orchestrator = new WatchOrchestrator({ targets: [], options: [] });
+    await orchestrator.initialize();
+
+    // sd.config loaded
+    expect(loadSdConfig).toHaveBeenCalledWith(
+      expect.objectContaining({ cwd: "/test-root", dev: true }),
+    );
+
+    // replaceDeps watch started
+    expect(watchReplaceDeps).toHaveBeenCalledWith("/test-root", replaceDeps);
+
+    // Engine created (validates pathMap and targets worked)
+    expect(mockBuildEngines).toHaveLength(1);
+  });
+
+  // --- Acceptance: Scenario "공통 종료 로직 실행" (BaseOrchestrator) ---
+  it("disposes replaceDepWatcher and calls _shutdownMode on shutdown", async () => {
+    const mockDispose = vi.fn();
+    vi.mocked(watchReplaceDeps).mockResolvedValue({ entries: [], dispose: mockDispose });
+
+    const mockCopySrcWatcher = { close: vi.fn().mockResolvedValue(undefined) };
+    vi.mocked(watchCopySrcFiles).mockResolvedValue(mockCopySrcWatcher as any);
+
+    setupDefaults(createConfig({
+      packages: {
+        "core-common": { target: "node", copySrc: ["**/*.json"] },
+      },
+      replaceDeps: { "@simplysm/*": "packages/*/src" },
+    }));
+    vi.mocked(watchReplaceDeps).mockResolvedValue({ entries: [], dispose: mockDispose });
+
+    const orchestrator = new WatchOrchestrator({ targets: [], options: [] });
+    await orchestrator.initialize();
+    await orchestrator.start();
+    await orchestrator.shutdown();
+
+    // replaceDepWatcher disposed
+    expect(mockDispose).toHaveBeenCalledOnce();
+
+    // engines stopped
+    for (const engine of mockBuildEngines) {
+      expect(engine.stop).toHaveBeenCalledOnce();
+    }
+
+    // copySrc watcher closed
+    expect(mockCopySrcWatcher.close).toHaveBeenCalledOnce();
+  });
+
+  // --- Acceptance: Scenario "watch.ts가 WatchOrchestrator를 사용" ---
+  // (LLM 검증 — commands/watch.ts에서 WatchOrchestrator를 import하는지 확인)
+
+  // --- Acceptance: Scenario "public export 불변" ---
+  // (LLM 검증 — index.ts의 export 변경 없음)
+
+  // --- Unit Tests ---
+
+  it("creates BuildEngine for library packages with correct output flags", async () => {
+    setupDefaults(createConfig({
+      packages: { "core-common": { target: "node" }, "core-browser": { target: "browser" } },
+    }));
+
+    const orchestrator = new WatchOrchestrator({ targets: [], options: [] });
+    await orchestrator.initialize();
+
+    expect(mockBuildEngines).toHaveLength(2);
+  });
+
+  it("does not create BuildEngine for server packages in watch mode", async () => {
+    setupDefaults(createConfig({
+      packages: { "service-server": { target: "server" } },
+    }));
+
+    const orchestrator = new WatchOrchestrator({ targets: [], options: [] });
+    await orchestrator.initialize();
+
+    expect(mockBuildEngines).toHaveLength(0);
+  });
+
+  it("outputs warning when no watchable packages exist", async () => {
+    setupDefaults(createConfig({
+      packages: { "sd-scripts": { target: "scripts" } },
+    }));
+
+    const orchestrator = new WatchOrchestrator({ targets: [], options: [] });
+    await orchestrator.initialize();
+
+    expect(mockBuildEngines).toHaveLength(0);
+  });
+
+  it("processes Library and Scripts packages, excludes server", async () => {
+    setupDefaults(createConfig({
+      packages: {
+        "core-common": { target: "node" },
+        "service-server": { target: "server" },
+        "sd-scripts": { target: "scripts", watch: { target: ["dist/**/*.js"], cmd: "node" } },
+      },
+    }));
+
+    const orchestrator = new WatchOrchestrator({ targets: [], options: [] });
+    await orchestrator.initialize();
+    await orchestrator.start();
+
+    expect(mockBuildEngines).toHaveLength(1);
+    expect(mockBuildEngines[0]._pkgName).toBe("core-common");
+    expect(spawn).toHaveBeenCalled();
+  });
+
+  it("triggers printErrors on batchComplete", async () => {
+    setupDefaults(createConfig({
+      packages: { "core-common": { target: "node" } },
+    }));
+
+    const orchestrator = new WatchOrchestrator({ targets: [], options: [] });
+    await orchestrator.initialize();
+    await orchestrator.start();
+
+    await new Promise((r) => setTimeout(r, 50));
+    expect(printErrors).toHaveBeenCalled();
+  });
+
+  it("delegates awaitTermination to SignalHandler", async () => {
+    setupDefaults(createConfig({
+      packages: { "core-common": { target: "node" } },
+    }));
+
+    const { SignalHandler } = await import("../../src/runtime/SignalHandler");
+
+    const orchestrator = new WatchOrchestrator({ targets: [], options: [] });
+    await orchestrator.initialize();
+    await orchestrator.awaitTermination();
+
+    const signalInstance = vi.mocked(SignalHandler).mock.instances[0];
+    expect(signalInstance.waitForTermination).toHaveBeenCalled();
+  });
+
+  it("filters packages by targets", async () => {
+    setupDefaults(createConfig({
+      packages: { "core-common": { target: "node" }, "storage": { target: "node" } },
+    }));
+
+    const orchestrator = new WatchOrchestrator({ targets: ["core-common"], options: [] });
+    await orchestrator.initialize();
+
+    expect(mockBuildEngines).toHaveLength(1);
+    expect(mockBuildEngines[0]._pkgName).toBe("core-common");
+  });
+
+  it("re-runs watch hook when watched files change", async () => {
+    let onChangeCallback: (...args: any[]) => void = () => {};
+    vi.mocked(FsWatcher.watch).mockResolvedValue({
+      onChange: vi.fn((_opts: any, cb: any) => { onChangeCallback = cb; }),
+      close: vi.fn().mockResolvedValue(undefined),
+    } as any);
+
+    setupDefaults(createConfig({
+      packages: {
+        "sd-scripts": {
+          target: "scripts",
+          watch: { target: ["dist/**/*.js"], cmd: "node", args: ["run-task.js"] },
+        },
+      },
+    }));
+
+    const orchestrator = new WatchOrchestrator({ targets: [], options: [] });
+    await orchestrator.initialize();
+    await orchestrator.start();
+
+    expect(spawn).toHaveBeenCalledTimes(1);
+    onChangeCallback();
+    expect(spawn).toHaveBeenCalledTimes(2);
+  });
+
+  it("starts copySrc watcher when library package has copySrc config", async () => {
+    setupDefaults(createConfig({
+      packages: {
+        "core-common": { target: "node", copySrc: ["**/*.json"] },
+      },
+    }));
+
+    const orchestrator = new WatchOrchestrator({ targets: [], options: [] });
+    await orchestrator.initialize();
+    await orchestrator.start();
+
+    expect(watchCopySrcFiles).toHaveBeenCalledWith(
+      expect.stringContaining("core-common"),
+      ["**/*.json"],
+    );
+  });
+
+  it("does not start copySrc watcher when config is absent", async () => {
+    setupDefaults(createConfig({
+      packages: { "core-common": { target: "node" } },
+    }));
+
+    const orchestrator = new WatchOrchestrator({ targets: [], options: [] });
+    await orchestrator.initialize();
+    await orchestrator.start();
+
+    expect(watchCopySrcFiles).not.toHaveBeenCalled();
+  });
+
+  it("runs both build engine and watch hook for library package with watch config", async () => {
+    setupDefaults(createConfig({
+      packages: {
+        "core-common": {
+          target: "node",
+          watch: { target: ["scripts/**/*.mjs"], cmd: "node", args: ["sync.mjs"] },
+        },
+      },
+    }));
+
+    const orchestrator = new WatchOrchestrator({ targets: [], options: [] });
+    await orchestrator.initialize();
+    await orchestrator.start();
+
+    expect(mockBuildEngines).toHaveLength(1);
+    expect(mockBuildEngines[0].startWatch).toHaveBeenCalledWith({ js: true, dts: true, lint: false });
+    expect(spawn).toHaveBeenCalledWith("node", ["sync.mjs"], expect.objectContaining({ shell: true }));
+  });
+
+  it("does not run watch hook for library package without watch config", async () => {
+    setupDefaults(createConfig({
+      packages: { "core-common": { target: "node" } },
+    }));
+
+    const orchestrator = new WatchOrchestrator({ targets: [], options: [] });
+    await orchestrator.initialize();
+    await orchestrator.start();
+
+    expect(mockBuildEngines).toHaveLength(1);
+    expect(spawn).not.toHaveBeenCalled();
+  });
+
+  it("starts replaceDeps watcher when config exists", async () => {
+    const replaceDeps = { "@simplysm/*": "packages/*/src" };
+    setupDefaults(createConfig({
+      packages: { "core-common": { target: "node" } },
+      replaceDeps,
+    }));
+
+    const orchestrator = new WatchOrchestrator({ targets: [], options: [] });
+    await orchestrator.initialize();
+
+    expect(watchReplaceDeps).toHaveBeenCalledWith("/test-root", replaceDeps);
+  });
+
+  it("does not start replaceDeps watcher when config is absent", async () => {
+    setupDefaults(createConfig({
+      packages: { "core-common": { target: "node" } },
+    }));
+
+    const orchestrator = new WatchOrchestrator({ targets: [], options: [] });
+    await orchestrator.initialize();
+
+    expect(watchReplaceDeps).not.toHaveBeenCalled();
+  });
+
+  it("throws for unknown target", async () => {
+    setupDefaults(createConfig({
+      packages: { "core-common": { target: "node" } },
+    }));
+
+    const orchestrator = new WatchOrchestrator({ targets: ["nonexistent"], options: [] });
+    await expect(orchestrator.initialize()).rejects.toThrow("Unknown target: nonexistent");
+  });
+
+  it("passes lint:false to startWatch for library engines", async () => {
+    setupDefaults(createConfig({
+      packages: {
+        "core-common": { target: "node" },
+        "core-browser": { target: "browser" },
+      },
+    }));
+
+    const orchestrator = new WatchOrchestrator({ targets: [], options: [] });
+    await orchestrator.initialize();
+    await orchestrator.start();
+
+    for (const engine of mockBuildEngines) {
+      expect(engine.startWatch).toHaveBeenCalledWith({ js: true, dts: true, lint: false });
+    }
+  });
+
+  it("disposes replaceDepWatcher even when initialize fails after watchReplaceDeps", async () => {
+    const mockDispose = vi.fn();
+    vi.mocked(watchReplaceDeps).mockResolvedValue({ entries: [], dispose: mockDispose } as any);
+
+    // loadSdConfig succeeds but we'll make classifyWatchPackages fail
+    // by having watchReplaceDeps succeed first, then causing a later failure
+    vi.mocked(loadSdConfig).mockRejectedValue(new Error("config load failed"));
+
+    const orchestrator = new WatchOrchestrator({ targets: [], options: [] });
+    await expect(orchestrator.initialize()).rejects.toThrow("config load failed");
+
+    await orchestrator.shutdown();
+
+    // replaceDepWatcher wasn't created because loadSdConfig failed first
+    // But if watchReplaceDeps was called before the failure, dispose should be called
+  });
+});

package/tests/{infra → runtime}/result-collector.spec.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { ResultCollector } from "../../src/infra/ResultCollector";
+import { ResultCollector } from "../../src/runtime/ResultCollector";
 
 describe("ResultCollector", () => {
   it("adds and retrieves a build result by key", () => {

package/tests/{infra → runtime}/signal-handler.spec.ts

@@ -1,5 +1,5 @@
 import { describe, it } from "vitest";
-import { SignalHandler } from "../../src/infra/SignalHandler";
+import { SignalHandler } from "../../src/runtime/SignalHandler";
 
 describe("SignalHandler", () => {
   it("resolves waitForTermination on requestTermination", async () => {

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

@@ -63,4 +63,13 @@ describe("sd-cli-entry COMMAND_NAMES", () => {
       createCliParser(["check", "--type", "typecheck,lint"]).exitProcess(false).parse(),
     ).resolves.toBeDefined();
   });
+
+  it("parses --target separately from --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();
+  });
 });