@simplysm/sd-cli 14.0.19 → 14.0.22

package/tests/commands/lint.spec.ts

@@ -1,189 +1,16 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 
-// Hoisted mock references — available inside vi.mock factories
-const mocks = vi.hoisted(() => ({
-  fsxExists: vi.fn<(path: string) => Promise<boolean>>(),
-  fsxGlob: vi.fn<(...args: unknown[]) => Promise<string[]>>(),
-  filterByTargets: vi.fn(
-    (files: string[], _targets: string[], _cwd: string) => files,
-  ),
-  lintFiles: vi.fn<() => Promise<Array<{ errorCount: number; warningCount: number }>>>(),
-  loadFormatter: vi.fn(),
-  outputFixes: vi.fn(),
-  jitiImport: vi.fn(),
-  eslintCtor: vi.fn(),
-}));
+//#region Mocks
 
-vi.mock("@simplysm/core-node", () => ({
-  fsx: { exists: mocks.fsxExists, glob: mocks.fsxGlob },
-  pathx: { filterByTargets: mocks.filterByTargets },
-}));
-
-vi.mock("eslint", () => ({
-  ESLint: class MockESLint {
-    constructor(options: unknown) { mocks.eslintCtor(options); }
-    lintFiles = mocks.lintFiles;
-    loadFormatter = mocks.loadFormatter;
-    static outputFixes = mocks.outputFixes;
-  },
+const mocks = vi.hoisted(() => ({
+  executeLint: vi.fn(),
 }));
 
-vi.mock("jiti", () => ({
-  createJiti: vi.fn(() => ({ import: mocks.jitiImport })),
+vi.mock("../../src/utils/lint-core", () => ({
+  executeLint: mocks.executeLint,
 }));
 
-vi.mock("consola", () => {
-  const fns = (): Record<string, unknown> => ({
-    debug: vi.fn(), start: vi.fn(), success: vi.fn(),
-    info: vi.fn(), error: vi.fn(), warn: vi.fn(), log: vi.fn(),
-    withTag: vi.fn(() => fns()),
-    level: 0,
-  });
-  const c = fns();
-  return { consola: c, default: c, LogLevels: {} };
-});
-
-const { loadIgnorePatterns, executeLint, runLint } = await import("../../src/commands/lint");
-
-//#region loadIgnorePatterns
-
-describe("loadIgnorePatterns", () => {
-  beforeEach(() => vi.clearAllMocks());
-
-  it("extracts globalIgnores patterns from eslint config", async () => {
-    mocks.fsxExists.mockImplementation((p) =>
-      Promise.resolve(typeof p === "string" && p.endsWith("eslint.config.ts")),
-    );
-    mocks.jitiImport.mockResolvedValue({
-      default: [
-        { ignores: ["dist/**", "node_modules/**"] },
-        { files: ["*.ts"], rules: {} }, // not globalIgnores — has files key
-        { ignores: [".cache/**"] },
-      ],
-    });
-
-    const result = await loadIgnorePatterns("/project");
-    expect(result).toEqual(["dist/**", "node_modules/**", ".cache/**"]);
-  });
-
-  it("ignores config objects that have files key", async () => {
-    mocks.fsxExists.mockImplementation((p) =>
-      Promise.resolve(typeof p === "string" && p.endsWith("eslint.config.ts")),
-    );
-    mocks.jitiImport.mockResolvedValue({
-      default: [{ files: ["*.ts"], ignores: ["dist/**"] }],
-    });
-
-    const result = await loadIgnorePatterns("/project");
-    expect(result).toEqual([]);
-  });
-
-  it("throws when no eslint config file found", async () => {
-    mocks.fsxExists.mockResolvedValue(false);
-
-    await expect(loadIgnorePatterns("/project")).rejects.toThrow(
-      "ESLint 설정 파일",
-    );
-  });
-});
-
-//#endregion
-
-//#region executeLint
-
-describe("executeLint", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    // Default: eslint config exists with no ignores
-    mocks.fsxExists.mockImplementation((p) =>
-      Promise.resolve(typeof p === "string" && p.endsWith("eslint.config.ts")),
-    );
-    mocks.jitiImport.mockResolvedValue({ default: [] });
-    mocks.fsxGlob.mockResolvedValue(["/project/src/a.ts", "/project/src/b.ts"]);
-    mocks.filterByTargets.mockImplementation((files) => files);
-    mocks.lintFiles.mockResolvedValue([{ errorCount: 0, warningCount: 0 }]);
-    mocks.loadFormatter.mockResolvedValue({
-      format: vi.fn().mockResolvedValue(""),
-    });
-  });
-
-  it("lints all collected files and returns success when no errors", async () => {
-    const result = await executeLint({ targets: [], fix: false, timing: false });
-
-    expect(result.success).toBe(true);
-    expect(result.errorCount).toBe(0);
-    expect(result.warningCount).toBe(0);
-    expect(mocks.lintFiles).toHaveBeenCalled();
-  });
-
-  it("filters files by targets via pathx.filterByTargets", async () => {
-    const filteredFiles = ["/project/packages/core-common/src/a.ts"];
-    mocks.filterByTargets.mockReturnValue(filteredFiles);
-
-    await executeLint({ targets: ["packages/core-common"], fix: false, timing: false });
-
-    expect(mocks.filterByTargets).toHaveBeenCalledWith(
-      expect.any(Array),
-      ["packages/core-common"],
-      expect.any(String),
-    );
-  });
-
-  it("applies auto-fix when fix option is true", async () => {
-    await executeLint({ targets: [], fix: true, timing: false });
-
-    expect(mocks.outputFixes).toHaveBeenCalled();
-  });
-
-  it("sets TIMING env variable when timing option is true", async () => {
-    const origTiming = process.env["TIMING"];
-
-    await executeLint({ targets: [], fix: false, timing: true });
-
-    expect(process.env["TIMING"]).toBe("1");
-
-    // Cleanup
-    if (origTiming == null) delete process.env["TIMING"];
-    else process.env["TIMING"] = origTiming;
-  });
-
-  it("creates ESLint with cache enabled and correct cache location", async () => {
-    await executeLint({ targets: [], fix: false, timing: false });
-
-    expect(mocks.eslintCtor).toHaveBeenCalledWith(
-      expect.objectContaining({
-        cache: true,
-        cacheLocation: expect.stringContaining("eslint.cache"),
-      }),
-    );
-  });
-
-  it("returns error count and formatted output when lint errors found", async () => {
-    mocks.lintFiles.mockResolvedValue([
-      { errorCount: 3, warningCount: 1 },
-      { errorCount: 1, warningCount: 2 },
-    ]);
-    mocks.loadFormatter.mockResolvedValue({
-      format: vi.fn().mockResolvedValue("error details"),
-    });
-
-    const result = await executeLint({ targets: [], fix: false, timing: false });
-
-    expect(result.success).toBe(false);
-    expect(result.errorCount).toBe(4);
-    expect(result.warningCount).toBe(3);
-    expect(result.formattedOutput).toBe("error details");
-  });
-
-  it("returns success when no files to lint", async () => {
-    mocks.fsxGlob.mockResolvedValue([]);
-
-    const result = await executeLint({ targets: [], fix: false, timing: false });
-
-    expect(result.success).toBe(true);
-    expect(mocks.lintFiles).not.toHaveBeenCalled();
-  });
-});
+const { runLint } = await import("../../src/commands/lint");
 
 //#endregion
 
@@ -200,15 +27,11 @@ describe("runLint", () => {
     writeSpy = vi.spyOn(process.stdout, "write").mockReturnValue(true);
 
     // Default: successful lint
-    mocks.fsxExists.mockImplementation((p) =>
-      Promise.resolve(typeof p === "string" && p.endsWith("eslint.config.ts")),
-    );
-    mocks.jitiImport.mockResolvedValue({ default: [] });
-    mocks.fsxGlob.mockResolvedValue(["/project/src/a.ts"]);
-    mocks.filterByTargets.mockImplementation((files) => files);
-    mocks.lintFiles.mockResolvedValue([{ errorCount: 0, warningCount: 0 }]);
-    mocks.loadFormatter.mockResolvedValue({
-      format: vi.fn().mockResolvedValue(""),
+    mocks.executeLint.mockResolvedValue({
+      success: true,
+      errorCount: 0,
+      warningCount: 0,
+      formattedOutput: "",
     });
   });
 
@@ -218,9 +41,11 @@ describe("runLint", () => {
   });
 
   it("writes formatted output to stdout when there are results", async () => {
-    mocks.lintFiles.mockResolvedValue([{ errorCount: 1, warningCount: 0 }]);
-    mocks.loadFormatter.mockResolvedValue({
-      format: vi.fn().mockResolvedValue("lint output here"),
+    mocks.executeLint.mockResolvedValue({
+      success: false,
+      errorCount: 1,
+      warningCount: 0,
+      formattedOutput: "lint output here",
     });
 
     await runLint({ targets: [], fix: false, timing: false });
@@ -229,15 +54,29 @@ describe("runLint", () => {
   });
 
   it("sets exitCode to 1 when lint errors are found", async () => {
-    mocks.lintFiles.mockResolvedValue([{ errorCount: 1, warningCount: 0 }]);
-    mocks.loadFormatter.mockResolvedValue({
-      format: vi.fn().mockResolvedValue("errors"),
+    mocks.executeLint.mockResolvedValue({
+      success: false,
+      errorCount: 1,
+      warningCount: 0,
+      formattedOutput: "errors",
     });
 
     await runLint({ targets: [], fix: false, timing: false });
 
     expect(process.exitCode).toBe(1);
   });
+
+  it("does not set exitCode when lint passes", async () => {
+    await runLint({ targets: [], fix: false, timing: false });
+
+    expect(process.exitCode).toBeUndefined();
+  });
+
+  it("does not write to stdout when formattedOutput is empty", async () => {
+    await runLint({ targets: [], fix: false, timing: false });
+
+    expect(writeSpy).not.toHaveBeenCalled();
+  });
 });
 
 //#endregion

package/tests/commands/publish-set.verify.md

@@ -0,0 +1,7 @@
+# 배포 실패 패키지 ���색 Set 사용 -- LLM 검증
+
+## 검증 항목
+
+- [x] Set 생성: `publish.ts:773` — `const publishedSet = new Set(publishedPackages)` 확인
+- [x] Set.has() 사용: `publish.ts:774` — `allPkgNames.filter(n => !publishedSet.has(n))` 확인
+- [x] 동작 동등성: `Array.includes()` → `Set.has()` 변환은 동일한 boolean 결과를 반환하���로 기능 동등

package/tests/electron/electron-symlink-cleanup.verify.md

@@ -0,0 +1,8 @@
+# symlink 테스트 임시 파일 정리 -- LLM 검증
+
+## 검증 항목
+
+- [x] try-catch-finally 구조 적용: `electron.ts:348-358` — try 블록에서 writeFile/symlink/lstat 수행, finally에서 정리
+- [x] finally에서 testLink, testTarget 각각 unlink: `finally { try { fs.unlinkSync(testLink); } catch {} try { fs.unlinkSync(testTarget); } catch {} }` 확인
+- [x] 성공 시에도 파일 정리: try 블록 return 후 finally가 실행되므로 정리 보장
+- [x] 실패 시에도 파일 정리: catch 블록 return 후 finally가 실행되므로 정리 보장

package/tests/engines/vite-engine.spec.ts

@@ -492,6 +492,35 @@ describe("ViteEngine", () => {
       await engine.stop();
     });
 
+    // Unit: ViteEngine uses same workerKey pattern as BaseEngine (CONSIST-001)
+    it("registers with RebuildManager using '{name}:build' key pattern", async () => {
+      const mockRebuildManager = { registerBuild: vi.fn(() => vi.fn()) };
+
+      mockWorker.startWatch.mockImplementation(() => {
+        return Promise.resolve({ success: true });
+      });
+
+      const engine = new ViteEngine({
+        cwd: "/root",
+        pkg: createMockPkg({ name: "my-client" }),
+        rebuildManager: mockRebuildManager as any,
+      });
+
+      await engine.startWatch({ js: true, dts: false });
+
+      const buildStartHandler = mockWorker.on.mock.calls.find(
+        (call: any[]) => call[0] === "buildStart",
+      )?.[1];
+      buildStartHandler?.({});
+
+      expect(mockRebuildManager.registerBuild).toHaveBeenCalledWith(
+        "my-client:build",
+        expect.any(String),
+      );
+
+      await engine.stop();
+    });
+
     // Acceptance: Scenario "build 이벤트로 ResultCollector 갱신 + resolver 호출" (Feature 3.3)
     it("resolves rebuild when build event arrives after buildStart", async () => {
       const mockResolver = vi.fn();

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

@@ -43,4 +43,15 @@ describe("ResultCollector", () => {
     expect(collector.get("storage:server")).toBeDefined();
     expect(collector.get("storage:build")).toBeUndefined();
   });
+
+  it("toMap returns a map that does not allow external mutation of internal state (DESIGN-004)", () => {
+    const collector = new ResultCollector();
+    collector.add({ name: "core", target: "node", type: "build", status: "success" });
+
+    const map = collector.toMap();
+    // ReadonlyMap at compile time; at runtime, verify internal state isolation
+    expect(map.size).toBe(1);
+    // Internal state should still have the result regardless of external map reference
+    expect(collector.get("core:build")!.status).toBe("success");
+  });
 });

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

@@ -1471,6 +1471,76 @@ describe("DevWatchOrchestrator", () => {
 
   //#region Slice 4: watch/dev lint 활성화 (Feature 3.2)
 
+  describe("resource safety (DESIGN-001, DESIGN-002)", () => {
+    // --- Acceptance: shutdown 시 타이머 정리 + replaceDepWatcher 해제 ---
+
+    it("clears pending timers on shutdown so no delayed restart fires", async () => {
+      vi.useFakeTimers();
+      try {
+        setupDefaults(createConfig({
+          packages: { "demo-server": { target: "server" } },
+        }));
+        // Engine adds "success" result to trigger restart timer via batchComplete
+        vi.mocked(createBuildEngine).mockImplementation((pkg: any, options: any) => {
+          const engine = {
+            run: vi.fn(),
+            startWatch: vi.fn().mockImplementation(() => {
+              options.resultCollector?.add({
+                name: pkg.name, target: "server", type: "build", status: "success",
+              });
+            }),
+            stop: vi.fn().mockResolvedValue(undefined),
+            _pkgName: pkg.name,
+          };
+          mockBuildEngines.push(engine);
+          return engine as any;
+        });
+
+        const orchestrator = new DevWatchOrchestrator({ mode: "dev", targets: [], options: [] });
+        await orchestrator.initialize();
+        await orchestrator.start();
+
+        // Trigger batchComplete with a server build key → sets _serverRestartTimer
+        const rebuildInstance = vi.mocked(RebuildManager).mock.instances[0];
+        const onCall = vi.mocked(rebuildInstance.on).mock.calls.find((c) => c[0] === "batchComplete");
+        const batchHandler = onCall?.[1] as ((keys: string[]) => void) | undefined;
+        const runtimeCountBefore = mockRuntimeProxies.length;
+        batchHandler?.(["demo-server:build"]);
+
+        // shutdown before timer fires
+        await orchestrator.shutdown();
+
+        // Advance past timer (100ms restart + 300ms print)
+        vi.advanceTimersByTime(500);
+
+        // No new runtime workers created after shutdown
+        expect(mockRuntimeProxies.length).toBe(runtimeCountBefore);
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+
+    it("disposes replaceDepWatcher even when initialize fails after watchReplaceDeps", async () => {
+      const mockDispose = vi.fn();
+      vi.mocked(watchReplaceDeps).mockResolvedValue({ entries: [], dispose: mockDispose } as any);
+
+      setupDefaults(createConfig({
+        packages: { "demo-server": { target: "server" } },
+        replaceDeps: { "@simplysm/*": "packages/*/src" },
+      }));
+      vi.mocked(watchReplaceDeps).mockResolvedValue({ entries: [], dispose: mockDispose } as any);
+      // Make getVersion throw to simulate partial init failure after watchReplaceDeps
+      vi.mocked(getVersion).mockRejectedValue(new Error("version fetch failed"));
+
+      const orchestrator = new DevWatchOrchestrator({ mode: "dev", targets: [], options: [] });
+      await expect(orchestrator.initialize()).rejects.toThrow("version fetch failed");
+
+      await orchestrator.shutdown();
+
+      expect(mockDispose).toHaveBeenCalledOnce();
+    });
+  });
+
   describe("lint activation", () => {
     // Scenario: watch 초기 빌드에서 lint 비활성화 (별도 실행으로 분리됨)
     it("passes lint:false to startWatch for library engines in watch mode", async () => {

package/tests/orchestrators/dist-delete-watcher.verify.md

@@ -0,0 +1,10 @@
+# dist 삭제 감지 watcher 일반화 -- LLM 검증
+
+## 검증 항목
+
+- [x] 디버그 하드코딩 제거: `DevWatchOrchestrator.ts:281` — `angular` 하드코딩 블록이 제거됨
+- [x] 모든 라이브러리 패키지 감시: `_startWatchMode()`에서 `this._libraryPackages`를 순회하며 각 `pkg.dir/dist`를 감시
+- [x] 클래스 필드 저장: `_distDeleteWatchers: FsWatcher[]` 필드에 push
+- [x] shutdown() 정리: `shutdown()`에서 `this._distDeleteWatchers.map(w => w.close())` 호출 확인
+- [x] 정리 후 초기화: `this._distDeleteWatchers = []`로 참조 해제 확인
+- [x] 로그 형식: `[dist-delete:{패키지명}]` 형식으로 어떤 패키지의 dist가 삭제되었는지 식별 가능

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

@@ -0,0 +1,180 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+//#region Mocks
+
+const mocks = vi.hoisted(() => ({
+  loadSdConfig: vi.fn(),
+  deserializeDiagnostic: vi.fn((d: any) => d),
+  typecheckNonPackageFiles: vi.fn(),
+  createBuildEngine: vi.fn(),
+  discoverWorkspacePackages: vi.fn(),
+  mergeTestsPackagesIntoConfig: vi.fn(),
+}));
+
+const mockEngines: Array<{
+  run: ReturnType<typeof vi.fn>;
+  stop: ReturnType<typeof vi.fn>;
+}> = [];
+
+vi.mock("../../src/utils/sd-config", () => ({
+  loadSdConfig: mocks.loadSdConfig,
+}));
+
+vi.mock("../../src/utils/typecheck-serialization", () => ({
+  deserializeDiagnostic: mocks.deserializeDiagnostic,
+}));
+
+vi.mock("../../src/utils/typecheck-non-package", () => ({
+  typecheckNonPackageFiles: mocks.typecheckNonPackageFiles,
+}));
+
+vi.mock("../../src/engines/index", () => ({
+  createBuildEngine: mocks.createBuildEngine,
+}));
+
+vi.mock("../../src/utils/package-utils", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../../src/utils/package-utils")>();
+  return {
+    ...actual,
+    discoverWorkspacePackages: mocks.discoverWorkspacePackages,
+    mergeTestsPackagesIntoConfig: mocks.mergeTestsPackagesIntoConfig,
+  };
+});
+
+vi.mock("typescript", async (importOriginal) => {
+  const orig = await importOriginal<Record<string, unknown>>();
+  const origDefault = (orig["default"] ?? orig) as Record<string, unknown>;
+  return {
+    ...orig,
+    default: {
+      ...origDefault,
+      sortAndDeduplicateDiagnostics: vi.fn((d: unknown[]) => d),
+      formatDiagnosticsWithColorAndContext: vi.fn((diags: Array<{ messageText: string }>) =>
+        diags.map((d) => `formatted: ${d.messageText}`).join("\n"),
+      ),
+    },
+  };
+});
+
+vi.mock("consola", () => {
+  const fns = (): Record<string, unknown> => ({
+    debug: vi.fn(), start: vi.fn(), success: vi.fn(),
+    info: vi.fn(), error: vi.fn(), warn: vi.fn(), log: vi.fn(),
+    withTag: vi.fn(() => fns()),
+    level: 0,
+  });
+  const c = fns();
+  return { consola: c, default: c, LogLevels: {} };
+});
+
+const { TypecheckOrchestrator } = await import(
+  "../../src/orchestrators/TypecheckOrchestrator"
+);
+
+//#endregion
+
+//#region Helpers
+
+function createMockEngine() {
+  const engine = {
+    run: vi.fn().mockResolvedValue({
+      build: { success: true, errors: [], warnings: [], diagnostics: [] },
+    }),
+    startWatch: vi.fn(),
+    stop: vi.fn().mockResolvedValue(undefined),
+  };
+  mockEngines.push(engine);
+  return engine;
+}
+
+function setupDefaults(packages: Record<string, any> = {}) {
+  mocks.loadSdConfig.mockResolvedValue({ packages });
+  mocks.createBuildEngine.mockImplementation(() => createMockEngine() as any);
+  mocks.typecheckNonPackageFiles.mockReturnValue({
+    success: true, errorCount: 0, warningCount: 0, diagnostics: [],
+  });
+
+  mocks.discoverWorkspacePackages.mockReturnValue(new Map<string, string>());
+  const pathMap = new Map<string, string>();
+  for (const name of Object.keys(packages)) {
+    pathMap.set(name, `packages/${name}`);
+  }
+  mocks.mergeTestsPackagesIntoConfig.mockReturnValue({
+    merged: packages,
+    pathMap,
+  });
+}
+
+//#endregion
+
+//#region Tests
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mockEngines.length = 0;
+});
+
+describe("TypecheckOrchestrator", () => {
+  // Acceptance: Scenario "TypecheckOrchestrator 정상 실행"
+  it("produces correct TypecheckResult through init → start → shutdown lifecycle", async () => {
+    setupDefaults({
+      "core-common": { target: "neutral" },
+      "core-node": { target: "node" },
+    });
+
+    const orchestrator = new TypecheckOrchestrator({ targets: [], options: [] });
+    await orchestrator.initialize();
+    const result = await orchestrator.start();
+    await orchestrator.shutdown();
+
+    expect(result.success).toBe(true);
+    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);
+    for (const engine of mockEngines) {
+      expect(engine.run).toHaveBeenCalledWith(
+        expect.objectContaining({ js: false, dts: false }),
+      );
+    }
+  });
+
+  // Acceptance: Scenario "엔진 성공 시 리소스 정리"
+  it("calls engine.stop() after successful run", async () => {
+    setupDefaults({ "core-node": { target: "node" } });
+
+    const orchestrator = new TypecheckOrchestrator({ targets: [], options: [] });
+    await orchestrator.initialize();
+    await orchestrator.start();
+    await orchestrator.shutdown();
+
+    expect(mockEngines[0].stop).toHaveBeenCalled();
+  });
+
+  // Acceptance: Scenario "엔진 실패 시 리소스 정리"
+  it("calls engine.stop() even when run fails", async () => {
+    setupDefaults({ "core-node": { target: "node" } });
+    mocks.createBuildEngine.mockImplementation(() => {
+      const engine = {
+        run: vi.fn().mockRejectedValue(new Error("build error")),
+        startWatch: vi.fn(),
+        stop: vi.fn().mockResolvedValue(undefined),
+      };
+      mockEngines.push(engine);
+      return engine as any;
+    });
+
+    const orchestrator = new TypecheckOrchestrator({ targets: [], options: [] });
+    await orchestrator.initialize();
+    const result = await orchestrator.start();
+    await orchestrator.shutdown();
+
+    expect(result.success).toBe(false);
+    expect(mockEngines[0].stop).toHaveBeenCalled();
+  });
+});
+
+// executeTypecheck 편의 함수 테스트는 tests/commands/typecheck.spec.ts에서
+// 동일한 코드 경로를 통해 검증되므로 중복 삭제함
+
+//#endregion

package/tests/sd-cli-catch-all.verify.md

@@ -0,0 +1,7 @@
+# replaceDeps catch-all 에러 필터링 -- LLM 검증
+
+## 검증 항목
+
+- [x] catch 블록이 에러 코드를 확인하여 MODULE_NOT_FOUND/ERR_MODULE_NOT_FOUND만 무시: `sd-cli.ts:37-41` 확인 완료. `code` 프로퍼티를 체크하고 해당 코드가 아닌 경우 `console.warn`으로 경고 출력
+- [x] 예상 외 에러(SyntaxError 등)에 경고 로그 출력: `console.warn("[sd-cli] replaceDeps 사전 설정 실패:", ...)` 확인
+- [x] Phase 2로 정상 진행: catch 후 코드 흐름이 Phase 2(line 44~)로 계속됨 확인

package/tests/utils/lint-core-import-paths.verify.md

@@ -0,0 +1,10 @@
+# lint.worker/lint-utils/check.ts import 경로 검증 -- LLM 검증
+
+## 검증 항목
+
+- [x] lint.worker.ts가 `../utils/lint-core`에서 import: `import { executeLint, type LintOptions, type LintResult } from "../utils/lint-core";` (line 2) 확인
+- [x] lint-utils.ts가 `./lint-core`에서 import: `import type { LintOptions, LintResult } from "./lint-core";` (line 2) 확인
+- [x] check.ts가 `../utils/lint-core`에서 import: `import { executeLint, type LintResult } from "../utils/lint-core";` (line 4) 확인
+- [x] commands/lint.ts�� `../commands/lint` import가 없음: `import { executeLint, type LintOptions } from "../utils/lint-core";` (line 1)만 존재
+- [x] lint-core.ts에 runLint가 없음: `executeLint`, `loadIgnorePatterns`, `LintOptions`, `LintResult`만 export
+- [x] commands/lint.ts에 runLint만 존재: 13줄의 thin wrapper