@arcbridge/core 0.1.3 → 0.1.4

package/dist/index.d.ts

@@ -1033,7 +1033,9 @@ interface GitRef {
  */
 declare function resolveRef(projectRoot: string, since: string, db?: Database): GitRef;
 /**
- * Get list of changed files between a ref and HEAD.
+ * Get list of changed files between a ref and HEAD, including uncommitted changes.
+ * Merges committed diffs with staged+unstaged working tree changes so that
+ * practice reviews and drift checks see all work, not just committed code.
  */
 declare function getChangedFiles(projectRoot: string, ref: string): ChangedFile[];
 /**

package/dist/index.js

@@ -1140,10 +1140,16 @@ ${input.template === "dotnet-webapi" ? `| Platform | Description | Notes |
 // src/templates/arc42/09-decisions.ts
 function firstAdrTemplate(input) {
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  if (input.template === "dotnet-webapi") {
-    return dotnetAdr(input, now);
+  switch (input.template) {
+    case "dotnet-webapi":
+      return dotnetAdr(input, now);
+    case "react-vite":
+      return reactViteAdr(input, now);
+    case "api-service":
+      return apiServiceAdr(input, now);
+    default:
+      return nextjsAdr(input, now);
   }
-  return nextjsAdr(input, now);
 }
 function nextjsAdr(input, date) {
   const { appPrefix } = detectProjectLayout(input.projectRoot, input.template);
@@ -1178,6 +1184,73 @@ Use Next.js with the App Router (introduced in Next.js 13+) as the application f
 `
   };
 }
+function reactViteAdr(input, date) {
+  const { srcPrefix } = detectProjectLayout(input.projectRoot, input.template);
+  return {
+    filename: "001-react-vite.md",
+    frontmatter: {
+      id: "001-react-vite",
+      title: "Use React with Vite",
+      status: "accepted",
+      date,
+      affected_blocks: ["app-shell"],
+      affected_files: [srcPrefix || "./"],
+      quality_scenarios: []
+    },
+    body: `# ADR-001: Use React with Vite
+
+## Context
+
+${input.name} needs a fast, modern frontend framework for building a single-page application (SPA) with TypeScript.
+
+## Decision
+
+Use React with Vite as the build tool and development server.
+
+## Consequences
+
+- **Positive:** Extremely fast dev server with hot module replacement (HMR)
+- **Positive:** Optimized production builds with tree shaking and code splitting
+- **Positive:** Simple configuration, no SSR complexity
+- **Positive:** Large React ecosystem of libraries and components
+- **Negative:** Client-side only \u2014 no built-in server-side rendering (add later if needed)
+- **Negative:** Requires separate backend service for API endpoints
+`
+  };
+}
+function apiServiceAdr(input, date) {
+  const { srcPrefix } = detectProjectLayout(input.projectRoot, input.template);
+  return {
+    filename: "001-api-service.md",
+    frontmatter: {
+      id: "001-api-service",
+      title: "Use Node.js API Service",
+      status: "accepted",
+      date,
+      affected_blocks: ["app-shell"],
+      affected_files: [srcPrefix || "./"],
+      quality_scenarios: []
+    },
+    body: `# ADR-001: Use Node.js API Service
+
+## Context
+
+${input.name} needs a backend API service with TypeScript support, good performance, and a simple architecture.
+
+## Decision
+
+Use a Node.js HTTP framework (Express, Fastify, or Hono) as the API service foundation.
+
+## Consequences
+
+- **Positive:** TypeScript-first with full type safety
+- **Positive:** Rich middleware ecosystem for auth, validation, logging
+- **Positive:** Easy to deploy to containers, serverless, or traditional hosts
+- **Negative:** Single-threaded \u2014 CPU-intensive operations need worker threads or external services
+- **Negative:** No built-in ORM \u2014 need to choose data access strategy
+`
+  };
+}
 function dotnetAdr(input, date) {
   return {
     filename: "001-aspnet-core-webapi.md",
@@ -1961,6 +2034,116 @@ function phaseTasksTemplate(_input, phaseId) {
           ]
         }
       ]
+    },
+    "phase-2-features": {
+      schema_version: 1,
+      phase_id: "phase-2-features",
+      tasks: [
+        {
+          id: "task-2.1-core-pages",
+          title: "Implement core application pages",
+          status: "todo",
+          quality_scenarios: ["PERF-01"],
+          acceptance_criteria: [
+            "Core pages created with proper data fetching",
+            "Server/client components properly separated",
+            "Loading and error states handled"
+          ]
+        },
+        {
+          id: "task-2.2-api-routes",
+          title: "Implement API routes",
+          status: "todo",
+          quality_scenarios: ["SEC-01", "PERF-02"],
+          acceptance_criteria: [
+            "API routes created for core operations",
+            "Input validation on all endpoints",
+            "Error responses standardized"
+          ]
+        },
+        {
+          id: "task-2.3-data-layer",
+          title: "Set up data access layer",
+          status: "todo",
+          quality_scenarios: ["MAINT-01"],
+          acceptance_criteria: [
+            "Data fetching patterns established",
+            "Caching strategy implemented",
+            "Type-safe data access"
+          ]
+        },
+        {
+          id: "task-2.4-integration-tests",
+          title: "Write integration tests for core flows",
+          status: "todo",
+          quality_scenarios: ["MAINT-02"],
+          acceptance_criteria: [
+            "Happy path tested for each core feature",
+            "API route tests written",
+            "Test coverage meets threshold"
+          ]
+        },
+        {
+          id: "task-2.5-document-decisions",
+          title: "Document Phase 2 architectural decisions",
+          status: "todo",
+          quality_scenarios: [],
+          acceptance_criteria: [
+            "ADRs for data fetching and API design choices",
+            "Building blocks updated with new code paths"
+          ]
+        }
+      ]
+    },
+    "phase-3-polish": {
+      schema_version: 1,
+      phase_id: "phase-3-polish",
+      tasks: [
+        {
+          id: "task-3.1-error-handling",
+          title: "Implement comprehensive error handling",
+          status: "todo",
+          quality_scenarios: ["SEC-01"],
+          acceptance_criteria: [
+            "Error boundaries at route level",
+            "Custom error.tsx and not-found.tsx pages",
+            "API error responses standardized"
+          ]
+        },
+        {
+          id: "task-3.2-accessibility",
+          title: "Accessibility audit and fixes",
+          status: "todo",
+          quality_scenarios: ["A11Y-01", "A11Y-02"],
+          acceptance_criteria: [
+            "Keyboard navigation works for all interactive elements",
+            "Screen reader compatible (ARIA labels, roles)",
+            "WCAG 2.1 AA compliance verified"
+          ]
+        },
+        {
+          id: "task-3.3-performance",
+          title: "Performance optimization",
+          status: "todo",
+          quality_scenarios: ["PERF-01"],
+          acceptance_criteria: [
+            "Bundle size optimized (dynamic imports, tree shaking)",
+            "Core Web Vitals meet thresholds (LCP < 2.5s)",
+            "Server-side rendering verified for SEO pages"
+          ]
+        },
+        {
+          id: "task-3.4-deployment",
+          title: "Configure production deployment",
+          status: "todo",
+          quality_scenarios: [],
+          acceptance_criteria: [
+            "Production build configuration verified",
+            "Environment variables documented",
+            "Deployment to Vercel/hosting configured"
+          ]
+        }
+      ]
     }
   };
   return tasksByPhase[phaseId] ?? null;
@@ -2128,6 +2311,105 @@ function phaseTasksTemplate2(_input, phaseId) {
           ]
         }
       ]
+    },
+    "phase-2-features": {
+      schema_version: 1,
+      phase_id: "phase-2-features",
+      tasks: [
+        {
+          id: "task-2.1-core-feature",
+          title: "Implement primary feature",
+          status: "todo",
+          quality_scenarios: ["PERF-01"],
+          acceptance_criteria: [
+            "Core user flow works end-to-end",
+            "Unit and component tests written",
+            "Meets performance budgets"
+          ]
+        },
+        {
+          id: "task-2.2-state-management",
+          title: "Set up state management for complex data",
+          status: "todo",
+          quality_scenarios: ["MAINT-01"],
+          acceptance_criteria: [
+            "State management pattern established",
+            "Data fetching/caching strategy implemented",
+            "Loading and error states handled"
+          ]
+        },
+        {
+          id: "task-2.3-integration-tests",
+          title: "Write integration tests for core flows",
+          status: "todo",
+          quality_scenarios: ["MAINT-02"],
+          acceptance_criteria: [
+            "Happy path tested for each core feature",
+            "Error scenarios tested",
+            "Test coverage meets threshold"
+          ]
+        },
+        {
+          id: "task-2.4-document-decisions",
+          title: "Document Phase 2 architectural decisions",
+          status: "todo",
+          quality_scenarios: [],
+          acceptance_criteria: [
+            "ADRs for state management and data fetching choices",
+            "Building blocks updated with new code paths"
+          ]
+        }
+      ]
+    },
+    "phase-3-polish": {
+      schema_version: 1,
+      phase_id: "phase-3-polish",
+      tasks: [
+        {
+          id: "task-3.1-error-handling",
+          title: "Implement comprehensive error handling",
+          status: "todo",
+          quality_scenarios: ["SEC-01"],
+          acceptance_criteria: [
+            "Error boundaries at route level",
+            "User-friendly error messages",
+            "Error logging configured"
+          ]
+        },
+        {
+          id: "task-3.2-accessibility",
+          title: "Accessibility audit and fixes",
+          status: "todo",
+          quality_scenarios: ["A11Y-01", "A11Y-02"],
+          acceptance_criteria: [
+            "Keyboard navigation works for all interactive elements",
+            "Screen reader compatible (ARIA labels, roles)",
+            "WCAG 2.1 AA compliance verified"
+          ]
+        },
+        {
+          id: "task-3.3-performance",
+          title: "Performance optimization",
+          status: "todo",
+          quality_scenarios: ["PERF-01"],
+          acceptance_criteria: [
+            "Bundle size optimized (code splitting, tree shaking)",
+            "Lighthouse performance score >= 90",
+            "No unnecessary re-renders in hot paths"
+          ]
+        },
+        {
+          id: "task-3.4-deployment",
+          title: "Configure production build and deployment",
+          status: "todo",
+          quality_scenarios: [],
+          acceptance_criteria: [
+            "Production build configuration verified",
+            "Deployment pipeline configured",
+            "Environment variables documented"
+          ]
+        }
+      ]
     }
   };
   return tasksByPhase[phaseId] ?? null;
@@ -2646,6 +2928,18 @@ You are responsible for maintaining these sections in \`.arcbridge/arc42/\`. Upd
 - All ADRs and their status
 - Building block \u2192 code mapping
 
+## Project Planning
+
+At the start of a project (after init), plan tasks across ALL phases:
+- **Phase 0-1 tasks are ready to use** \u2014 they cover setup and foundation for this template
+- **Phase 2+ tasks are examples** \u2014 replace them with real tasks derived from the project's requirements and specifications
+- Review the phase plan with \`arcbridge_get_phase_plan\` and replace example tasks with project-specific ones
+- Create tasks using \`arcbridge_create_task\` with the phase ID shown in the plan
+- Keep each phase reasonably scoped \u2014 3-6 tasks per phase is ideal
+- Map tasks to building blocks so drift detection tracks coverage
+- Link tasks to quality scenarios so gate checks are meaningful
+- Plan the full roadmap before diving into implementation \u2014 this prevents phases from becoming too large or unfocused
+
 ## Working Style
 
 Think at the system level. Before making changes, consider:
@@ -2883,13 +3177,25 @@ function phaseManagerTemplate() {
 - Tasks must be "done" before a phase can complete
 - Quality scenarios linked to phase tasks must be verified
 
+## Task Planning
+
+Before starting any phase, ensure proper task planning:
+- **Phase 0-1 tasks are concrete** \u2014 they cover project setup and foundation. Follow them as-is.
+- **Phase 2+ tasks are examples only** \u2014 they show the *shape* of later phases but must be replaced with real tasks derived from the project's actual requirements and specs.
+- **At project start, plan ALL phases** \u2014 review \`arcbridge_get_phase_plan\`, delete example tasks in Phase 2+, and create real tasks based on the product spec and building blocks.
+- **Keep phases small and focused** \u2014 if a phase has more than 6-8 tasks, split it into sub-phases
+- **Tasks should be concrete and verifiable** \u2014 each task needs clear acceptance criteria
+- **Link tasks to building blocks** \u2014 this enables drift detection and progress tracking
+- **Use \`arcbridge_create_task\` with the phase ID** shown in \`arcbridge_get_phase_plan\` output (e.g., \`phase-2-features\`)
+
 ## Phase Transition Process
 
 1. Verify all tasks in current phase are "done"
-2. Run drift detection (check_drift)
-3. Propose arc42 updates if drift is detected
-4. Check quality gate requirements
-5. Mark phase complete or report blockers`
+2. Review task coverage for the NEXT phase \u2014 create tasks if empty
+3. Run drift detection (\`arcbridge_check_drift\`)
+4. Propose arc42 updates if drift is detected
+5. Check quality gate requirements
+6. Mark phase complete or report blockers`
   };
 }
 
@@ -3353,6 +3659,7 @@ function refreshFromDocs(db, targetDir) {
   const scenarioStatusMap = new Map(
     existingScenarios.map((s) => [s.id, s.status])
   );
+  db.exec("PRAGMA foreign_keys = OFF");
   const refresh = () => transaction(db, () => {
     db.prepare("DELETE FROM tasks").run();
     db.prepare("DELETE FROM phases").run();
@@ -3365,6 +3672,16 @@ function refreshFromDocs(db, targetDir) {
     warnings.push(...populateQualityScenarios(db, targetDir));
     warnings.push(...populatePhases(db, targetDir));
     warnings.push(...populateAdrs(db, targetDir));
+    const orphaned = db.prepare(`
+      UPDATE tasks SET building_block = NULL
+      WHERE building_block IS NOT NULL
+        AND building_block NOT IN (SELECT id FROM building_blocks)
+    `).run();
+    if (orphaned.changes > 0) {
+      warnings.push(
+        `${orphaned.changes} task(s) referenced removed building blocks (references cleared)`
+      );
+    }
     const restoreTask = db.prepare(
       "UPDATE tasks SET status = ?, completed_at = ? WHERE id = ?"
     );
@@ -3390,7 +3707,11 @@ function refreshFromDocs(db, targetDir) {
       }
     }
   });
-  refresh();
+  try {
+    refresh();
+  } finally {
+    db.exec("PRAGMA foreign_keys = ON");
+  }
   return warnings;
 }
 function generateDatabase(targetDir, input) {
@@ -3437,7 +3758,7 @@ import YAML from "yaml";
 
 // src/indexer/program.ts
 import ts from "typescript";
-import { join as join7 } from "path";
+import { join as join7, dirname } from "path";
 function createTsProgram(options) {
   const projectRoot = options.projectRoot;
   const configPath = options.tsconfigPath ?? ts.findConfigFile(projectRoot, ts.sys.fileExists, "tsconfig.json");
@@ -3446,7 +3767,7 @@ function createTsProgram(options) {
       `No tsconfig.json found in ${projectRoot}. TypeScript indexing requires a tsconfig.json.`
     );
   }
-  const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+  let configFile = ts.readConfigFile(configPath, ts.sys.readFile);
   if (configFile.error) {
     const message = ts.flattenDiagnosticMessageText(
       configFile.error.messageText,
@@ -3454,12 +3775,45 @@ function createTsProgram(options) {
     );
     throw new Error(`Failed to read tsconfig.json: ${message}`);
   }
+  let resolvedConfigPath = configPath;
+  const config = configFile.config;
+  const hasOwnFiles = config.include && config.include.length > 0 || config.files && config.files.length > 0;
+  if (config.references && !hasOwnFiles) {
+    for (const ref of config.references) {
+      const refRelPath = typeof ref === "string" ? ref : ref.path;
+      if (!refRelPath) continue;
+      const refFullPath = join7(dirname(configPath), refRelPath);
+      const refConfigPath = refFullPath.endsWith(".json") ? refFullPath : join7(refFullPath, "tsconfig.json");
+      if (ts.sys.fileExists(refConfigPath)) {
+        const refConfig = ts.readConfigFile(refConfigPath, ts.sys.readFile);
+        const rc = refConfig.config;
+        if (!refConfig.error && (rc.include?.length > 0 || rc.files?.length > 0)) {
+          configFile = refConfig;
+          resolvedConfigPath = refConfigPath;
+          break;
+        }
+      }
+    }
+    if (resolvedConfigPath === configPath) {
+      for (const candidate of ["tsconfig.app.json", "tsconfig.src.json"]) {
+        const refPath = ts.findConfigFile(projectRoot, ts.sys.fileExists, candidate);
+        if (refPath) {
+          const refConfig = ts.readConfigFile(refPath, ts.sys.readFile);
+          if (!refConfig.error) {
+            configFile = refConfig;
+            resolvedConfigPath = refPath;
+            break;
+          }
+        }
+      }
+    }
+  }
   const parsed = ts.parseJsonConfigFileContent(
     configFile.config,
     ts.sys,
     join7(projectRoot),
     { noEmit: true },
-    configPath
+    resolvedConfigPath
   );
   const program = ts.createProgram({
     rootNames: parsed.fileNames,
@@ -4463,7 +4817,7 @@ function writeDependencies(db, dependencies) {
 
 // src/indexer/dotnet-indexer.ts
 import { execFileSync } from "child_process";
-import { resolve, join as join9, dirname, relative as relative4, basename } from "path";
+import { resolve, join as join9, dirname as dirname2, relative as relative4, basename } from "path";
 import { readdirSync as readdirSync3, readFileSync as readFileSync3, existsSync as existsSync4, accessSync, constants } from "fs";
 import { fileURLToPath } from "url";
 function findDotnetProject(projectRoot) {
@@ -4480,7 +4834,7 @@ function findDotnetProject(projectRoot) {
 }
 function parseSolutionProjects(slnPath) {
   const content = readFileSync3(slnPath, "utf-8");
-  const slnDir = dirname(slnPath);
+  const slnDir = dirname2(slnPath);
   const projects = [];
   const projectPattern = /Project\("\{[^}]+\}"\)\s*=\s*"([^"]+)",\s*"([^"]+\.csproj)"/g;
   let match;
@@ -4489,7 +4843,7 @@ function parseSolutionProjects(slnPath) {
     const relativeCsprojPath = match[2].replace(/\\/g, "/");
     const fullCsprojPath = resolve(join9(slnDir, relativeCsprojPath));
     if (!existsSync4(fullCsprojPath)) continue;
-    const projectDir = relative4(slnDir, dirname(fullCsprojPath)).replace(/\\/g, "/") || ".";
+    const projectDir = relative4(slnDir, dirname2(fullCsprojPath)).replace(/\\/g, "/") || ".";
     const isTestProject = /[.\x2d]tests?$/i.test(name) || /[.\x2d](unit|integration|functional|e2e)tests?$/i.test(name);
     projects.push({
       name,
@@ -4534,7 +4888,7 @@ function hasGlobalTool() {
   return false;
 }
 function resolveIndexerProject() {
-  const currentDir2 = dirname(fileURLToPath(import.meta.url));
+  const currentDir2 = dirname2(fileURLToPath(import.meta.url));
   const candidates = [
     resolve(currentDir2, "../../../../dotnet-indexer/ArcBridge.DotnetIndexer.csproj"),
     resolve(currentDir2, "../../../dotnet-indexer/ArcBridge.DotnetIndexer.csproj"),
@@ -4688,10 +5042,10 @@ import { globbySync } from "globby";
 
 // src/indexer/csharp/parser.ts
 import { accessSync as accessSync2, constants as constants2 } from "fs";
-import { dirname as dirname2, resolve as resolve2 } from "path";
+import { dirname as dirname3, resolve as resolve2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import "web-tree-sitter";
-var currentDir = dirname2(fileURLToPath2(import.meta.url));
+var currentDir = dirname3(fileURLToPath2(import.meta.url));
 var cachedParser = null;
 var initPromise = null;
 function resolveGrammarPath() {
@@ -6047,7 +6401,17 @@ function detectNewDependencies(db, entries) {
   const adrs = db.prepare("SELECT id, title, context, decision FROM adrs WHERE status != 'superseded'").all();
   const adrText = adrs.map((a) => `${a.title} ${a.context ?? ""} ${a.decision ?? ""}`.toLowerCase()).join(" ");
   const trivialPackages = /* @__PURE__ */ new Set([
-    // npm
+    // npm — frameworks (core deps that don't need ADRs)
+    "react",
+    "react-dom",
+    "next",
+    "vite",
+    "@vitejs/plugin-react",
+    "express",
+    "fastify",
+    "hono",
+    "koa",
+    // npm — dev tooling
     "typescript",
     "eslint",
     "prettier",
@@ -6055,15 +6419,28 @@ function detectNewDependencies(db, entries) {
     "jest",
     "@types/node",
     "@types/react",
+    "@types/react-dom",
     "tsup",
     "tsx",
-    // nuget
+    "ts-node",
+    "nodemon",
+    "@eslint/js",
+    "typescript-eslint",
+    // npm — build/bundler
+    "esbuild",
+    "rollup",
+    "webpack",
+    "postcss",
+    "tailwindcss",
+    "autoprefixer",
+    // nuget — test
     "microsoft.net.test.sdk",
     "xunit",
     "xunit.runner.visualstudio",
     "nunit",
     "nunit3testadapter",
     "coverlet.collector",
+    // nuget — framework
     "microsoft.aspnetcore.openapi",
     "swashbuckle.aspnetcore"
   ]);
@@ -6318,7 +6695,7 @@ function safeParseJson2(value, fallback) {
 
 // src/generators/sync-generator.ts
 import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync6 } from "fs";
-import { join as join15, dirname as dirname3 } from "path";
+import { join as join15, dirname as dirname4 } from "path";
 
 // src/templates/sync/claude-skill.ts
 function claudeSkillTemplate(config) {
@@ -6497,20 +6874,20 @@ function generateSyncFiles(targetDir, config) {
   const generated = [];
   const action = githubActionTemplate(config);
   const actionPath = join15(targetDir, action.relativePath);
-  mkdirSync6(dirname3(actionPath), { recursive: true });
+  mkdirSync6(dirname4(actionPath), { recursive: true });
   writeFileSync6(actionPath, action.content, "utf-8");
   generated.push(action.relativePath);
   if (config.platforms.includes("claude")) {
     const skill = claudeSkillTemplate(config);
     const skillPath = join15(targetDir, skill.relativePath);
-    mkdirSync6(dirname3(skillPath), { recursive: true });
+    mkdirSync6(dirname4(skillPath), { recursive: true });
     writeFileSync6(skillPath, skill.content, "utf-8");
     generated.push(skill.relativePath);
   }
   if (config.platforms.includes("copilot")) {
     const hook = copilotHookTemplate(config);
     const hookPath = join15(targetDir, hook.relativePath);
-    mkdirSync6(dirname3(hookPath), { recursive: true });
+    mkdirSync6(dirname4(hookPath), { recursive: true });
     writeFileSync6(hookPath, hook.content, "utf-8");
     generated.push(hook.relativePath);
   }
@@ -6866,6 +7243,7 @@ function resolveRef(projectRoot, since, db) {
   }
 }
 function getChangedFiles(projectRoot, ref) {
+  const byPath = /* @__PURE__ */ new Map();
   try {
     execFileSync3("git", ["rev-parse", "--verify", ref], {
       cwd: projectRoot,
@@ -6878,16 +7256,24 @@ function getChangedFiles(projectRoot, ref) {
       ["diff", "--name-status", "--no-renames", ref, "HEAD"],
       { cwd: projectRoot, encoding: "utf-8", timeout: 1e4 }
     ).trim();
-    if (!output) return [];
-    return output.split("\n").map((line) => {
-      const [statusCode, ...pathParts] = line.split("	");
-      const path = pathParts.join("	");
-      const status = parseStatusCode(statusCode ?? "M");
-      return { status, path };
-    });
+    if (output) {
+      for (const line of output.split("\n")) {
+        const [statusCode, ...pathParts] = line.split("	");
+        const path = pathParts.join("	");
+        byPath.set(path, { status: parseStatusCode(statusCode ?? "M"), path });
+      }
+    }
   } catch {
-    return getUncommittedChanges(projectRoot);
   }
+  for (const change of getUncommittedChanges(projectRoot)) {
+    const existing = byPath.get(change.path);
+    if (!existing) {
+      byPath.set(change.path, change);
+    } else if (change.status === "deleted") {
+      byPath.set(change.path, change);
+    }
+  }
+  return Array.from(byPath.values());
 }
 function getUncommittedChanges(projectRoot) {
   try {
@@ -6895,11 +7281,12 @@ function getUncommittedChanges(projectRoot) {
       "git",
       ["status", "--porcelain", "-uno"],
       { cwd: projectRoot, encoding: "utf-8", timeout: 5e3 }
-    ).trim();
-    if (!output) return [];
-    return output.split("\n").map((line) => {
+    );
+    const lines = output.split("\n").filter((l) => l.length >= 3);
+    if (lines.length === 0) return [];
+    return lines.map((line) => {
       const statusCode = line.slice(0, 2).trim();
-      const path = line.slice(3);
+      const path = line.slice(3).replace(/\r$/, "");
       const status = statusCode === "D" ? "deleted" : statusCode === "A" ? "added" : "modified";
       return { status, path };
     });