@rashidee/co2 1.3.5 → 1.3.7

package/dist/index.js

@@ -1267,8 +1267,8 @@ var require_command = __commonJS({
        * @return {Command} `this` command for chaining
        */
       arguments(names) {
-        names.trim().split(/ +/).forEach((detail) => {
-          this.argument(detail);
+        names.trim().split(/ +/).forEach((detail2) => {
+          this.argument(detail2);
         });
         return this;
       }
@@ -6809,7 +6809,7 @@ var {
 // package.json
 var package_default = {
   name: "@rashidee/co2",
-  version: "1.3.5",
+  version: "1.3.7",
   description: "Compound Context Studio \u2014 self-hosted team context authoring for CO2 projects",
   type: "module",
   license: "MIT",
@@ -6937,9 +6937,9 @@ ${install.output}`));
 }
 
 // src/commands/start.ts
-import { existsSync as existsSync24 } from "fs";
+import { existsSync as existsSync25 } from "fs";
 import { networkInterfaces } from "os";
-import { dirname as dirname3, join as join28 } from "path";
+import { dirname as dirname3, join as join29 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // ../../node_modules/.pnpm/hono@4.12.27/node_modules/hono/dist/compose.js
@@ -10241,7 +10241,7 @@ function sql(strings, ...params) {
     return new SQL([new StringChunk(str)]);
   }
   sql2.raw = raw2;
-  function join29(chunks, separator) {
+  function join30(chunks, separator) {
     const result = [];
     for (const [i, chunk] of chunks.entries()) {
       if (i > 0 && separator !== void 0) {
@@ -10251,7 +10251,7 @@ function sql(strings, ...params) {
     }
     return new SQL(result);
   }
-  sql2.join = join29;
+  sql2.join = join30;
   function identifier(value) {
     return new Name(value);
   }
@@ -12760,7 +12760,7 @@ var SQLiteSelectQueryBuilderBase = class extends TypedQueryBuilder {
     return (table, on) => {
       const baseTableName = this.tableName;
       const tableName = getTableLikeName(table);
-      if (typeof tableName === "string" && this.config.joins?.some((join29) => join29.alias === tableName)) {
+      if (typeof tableName === "string" && this.config.joins?.some((join30) => join30.alias === tableName)) {
         throw new Error(`Alias "${tableName}" is already used in this query`);
       }
       if (!this.isPartialSelect) {
@@ -13563,7 +13563,7 @@ var SQLiteUpdateBase = class extends QueryPromise {
   createJoin(joinType) {
     return (table, on) => {
       const tableName = getTableLikeName(table);
-      if (typeof tableName === "string" && this.config.joins.some((join29) => join29.alias === tableName)) {
+      if (typeof tableName === "string" && this.config.joins.some((join30) => join30.alias === tableName)) {
         throw new Error(`Alias "${tableName}" is already used in this query`);
       }
       if (typeof on === "function") {
@@ -14490,6 +14490,17 @@ var projects = sqliteTable("projects", {
   // existing CO2 repo (no scaffolding, no brainstorm). importedBy is a soft ref → users.id.
   importedAt: text("imported_at"),
   importedBy: integer("imported_by"),
+  // [v2.2.0] Per-project git remote (push destination). Auto-seeded from an imported repo's
+  // origin; editable in project detail. Never carries an embedded credential.
+  gitRemoteUrl: text("git_remote_url"),
+  // [v2.3.0] Per-project default (trunk) branch — the branch release branches merge back into on
+  // a version cut (runVersionCutGit). Editable in the project detail Configuration tab; defaults
+  // to `main`. Existing rows backfill to `main`.
+  defaultBranch: text("default_branch").notNull().default("main"),
+  // [v2.3.0] Git hosting provider — drives the PAT auth-username convention (GitHub
+  // `x-access-token` vs GitLab `oauth2`) when the acting user has no configured Git name.
+  // Auto-seeded from an imported repo's origin host; defaults to `github`.
+  gitProvider: text("git_provider", { enum: ["github", "gitlab"] }).notNull().default("github"),
   createdBy: integer("created_by").notNull(),
   createdAt: text("created_at").notNull(),
   updatedAt: text("updated_at").notNull()
@@ -19079,6 +19090,68 @@ var documentSchema = external_exports.object({
 });
 var MAX_DOCUMENT_BYTES = 25 * 1024 * 1024;
 
+// ../core/src/schemas/git.ts
+var gitFileStatusSchema = external_exports.enum([
+  "modified",
+  "added",
+  "deleted",
+  "renamed",
+  "untracked",
+  "conflicted",
+  "typechange"
+]);
+var gitFileSchema = external_exports.object({
+  path: external_exports.string(),
+  status: gitFileStatusSchema,
+  staged: external_exports.boolean(),
+  unstaged: external_exports.boolean(),
+  conflicted: external_exports.boolean(),
+  /** Raw porcelain XY codes, retained for display / debugging. */
+  indexStatus: external_exports.string(),
+  worktreeStatus: external_exports.string()
+});
+var gitStatusResponseSchema = external_exports.object({
+  /** false when the project folder is missing or has no git repository. */
+  available: external_exports.boolean(),
+  branch: external_exports.string().nullable(),
+  upstream: external_exports.string().nullable(),
+  ahead: external_exports.number(),
+  behind: external_exports.number(),
+  clean: external_exports.boolean(),
+  hasConflicts: external_exports.boolean(),
+  files: external_exports.array(gitFileSchema),
+  /** Convenience: files.length (the dirty count the topbar indicator badges). */
+  changedCount: external_exports.number()
+});
+var gitDiffResponseSchema = external_exports.object({
+  path: external_exports.string(),
+  status: gitFileStatusSchema,
+  binary: external_exports.boolean(),
+  conflicted: external_exports.boolean(),
+  /** Non-conflicted compare — HEAD (before) vs working tree (after). null where absent. */
+  oldContent: external_exports.string().nullable(),
+  newContent: external_exports.string().nullable(),
+  /** Conflicted 3-way — base (merged ancestor), ours (local), theirs (remote). null where absent. */
+  base: external_exports.string().nullable(),
+  ours: external_exports.string().nullable(),
+  theirs: external_exports.string().nullable()
+});
+var gitCommitRequestSchema = external_exports.object({
+  message: external_exports.string().trim().min(1, "A commit message is required").max(500),
+  paths: external_exports.array(external_exports.string()).optional()
+});
+var gitDiscardRequestSchema = external_exports.object({
+  paths: external_exports.array(external_exports.string()).min(1, "Select at least one file to roll back")
+});
+var gitResolveRequestSchema = external_exports.object({
+  path: external_exports.string().min(1),
+  resolution: external_exports.enum(["ours", "theirs", "manual"]),
+  content: external_exports.string().optional()
+}).refine((v) => v.resolution !== "manual" || v.content !== void 0, {
+  message: "Manual resolution requires the merged content",
+  path: ["content"]
+});
+
 // ../core/src/schemas/import.ts
 var importCandidateSchema = external_exports.object({
   folderName: external_exports.string(),
@@ -19287,6 +19360,16 @@ var brainstormMdResponseSchema = external_exports.object({
 var updateBrainstormMdSchema = external_exports.object({
   content: external_exports.string().min(1, "Brainstorm content must not be empty")
 });
+var gitUrlOrEmpty = /^$|^https:\/\/[^@/\s]+(\/\S*)?$|^(git@|ssh:\/\/)\S+$/;
+var branchNameOrEmpty = /^$|^(?!.*\.\.)[A-Za-z0-9][A-Za-z0-9._/-]*$/;
+var updateProjectGitRemoteSchema = external_exports.object({
+  gitRemoteUrl: external_exports.string().trim().max(500).regex(gitUrlOrEmpty, "Must be empty or an https:// or ssh/git@ URL"),
+  // [v2.3.0] Default (trunk) branch releases merge back into on a version cut. Optional for
+  // backward compatibility; empty/omitted resolves to `main` server-side.
+  defaultBranch: external_exports.string().trim().max(255).regex(branchNameOrEmpty, "Must be a valid branch name").default("main"),
+  // [v2.3.0] Git hosting provider — drives the PAT auth-username convention. Defaults to `github`.
+  gitProvider: external_exports.enum(["github", "gitlab"]).default("github")
+});
 var projectSummarySchema = external_exports.object({
   id: external_exports.number(),
   name: external_exports.string(),
@@ -19304,6 +19387,12 @@ var projectDetailSchema = external_exports.object({
   workflowPhase: workflowPhaseSchema,
   creationStatus: creationStatusSchema.nullable(),
   isArchived: external_exports.boolean(),
+  // [v2.2.0] Push destination for Source Control (imported repos auto-seed it from origin).
+  gitRemoteUrl: external_exports.string().nullable(),
+  // [v2.3.0] Default (trunk) branch releases merge back into on a version cut (defaults to `main`).
+  defaultBranch: external_exports.string(),
+  // [v2.3.0] Git hosting provider (drives the PAT auth-username convention; defaults to `github`).
+  gitProvider: external_exports.enum(["github", "gitlab"]),
   applications: external_exports.array(
     external_exports.object({
       id: external_exports.number(),
@@ -19682,11 +19771,11 @@ process.once("SIGINT", () => {
 function resolveHub(db, workspacePath, projectId) {
   const project = db.select().from(projects).where(eq(projects.id, projectId)).limit(1).get();
   if (!project) throw svcError("PROJECT_NOT_FOUND", 404);
-  const projectDir = join2(workspacePath, project.workspaceFolderName);
-  const hubDir = [join2(projectDir, "mockup"), join2(projectDir, "source", "mockup")].find(
+  const projectDir2 = join2(workspacePath, project.workspaceFolderName);
+  const hubDir = [join2(projectDir2, "mockup"), join2(projectDir2, "source", "mockup")].find(
     (d) => existsSync2(join2(d, "server.js"))
   );
-  if (!hubDir) return { hubDir: join2(projectDir, "mockup"), present: false, port: 3e3 };
+  if (!hubDir) return { hubDir: join2(projectDir2, "mockup"), present: false, port: 3e3 };
   let port = 3e3;
   try {
     const config = JSON.parse(readFileSync2(join2(hubDir, "mockup.config.json"), "utf8"));
@@ -19782,17 +19871,17 @@ function registerArtifact(db, conductorRunId, applicationId, artifactType, fileP
     updatedAt: now
   }).returning({ id: artifacts.id }).get().id;
 }
-function resolveAppFolderName(projectDir, appName) {
+function resolveAppFolderName(projectDir2, appName) {
   const candidates = [appName, appName.replace(/-/g, "_"), appName.replace(/_/g, "-")];
   for (const candidate of candidates) {
-    if (existsSync3(join3(projectDir, candidate))) return candidate;
-    if (existsSync3(join3(projectDir, "source", candidate))) return `source/${candidate}`;
+    if (existsSync3(join3(projectDir2, candidate))) return candidate;
+    if (existsSync3(join3(projectDir2, "source", candidate))) return `source/${candidate}`;
   }
   const normalize2 = (s) => s.replace(/^\d+[_-]/, "").toLowerCase().replace(/[^a-z0-9]/g, "");
   const target = normalize2(appName);
   const prefixMatches = [];
   for (const base of ["", "source"]) {
-    const dir = base ? join3(projectDir, base) : projectDir;
+    const dir = base ? join3(projectDir2, base) : projectDir2;
     if (!existsSync3(dir)) continue;
     for (const entry of readdirSync(dir)) {
       try {
@@ -19847,9 +19936,9 @@ function registerConductorArtifacts(db, workspacePath, runId) {
   const project = db.select().from(projects).where(eq(projects.id, run.projectId)).get();
   const app = db.select().from(applications).where(eq(applications.id, run.applicationId)).get();
   if (!project || !app) return;
-  const projectDir = join3(workspacePath, project.workspaceFolderName);
-  const appRel = resolveAppFolderName(projectDir, app.name);
-  const contextDir = join3(projectDir, appRel, "context");
+  const projectDir2 = join3(workspacePath, project.workspaceFolderName);
+  const appRel = resolveAppFolderName(projectDir2, app.name);
+  const contextDir = join3(projectDir2, appRel, "context");
   const slugs = /* @__PURE__ */ new Set();
   for (const sub of ["model", "specification", "test"]) {
     const dir = join3(contextDir, sub);
@@ -19891,7 +19980,7 @@ function registerConductorArtifacts(db, workspacePath, runId) {
     }
   }
   if (run.conductorType !== "prepare") {
-    for (const srcRel of sweepSourceFiles(join3(projectDir, appRel))) {
+    for (const srcRel of sweepSourceFiles(join3(projectDir2, appRel))) {
       registerArtifact(db, runId, app.id, "source_code", `${appRel}/${srcRel}`, srcRel);
     }
   }
@@ -19949,9 +20038,9 @@ function getModuleModel(db, workspacePath, projectId, applicationId, moduleName)
   const app = db.select().from(applications).where(eq(applications.id, applicationId)).get();
   if (!app) throw svcError2("APP_NOT_FOUND", 404);
   const kebab = moduleName.toLowerCase().replace(/\s+/g, "-");
-  const projectDir = join3(workspacePath, project.workspaceFolderName);
-  const appRel = resolveAppFolderName(projectDir, app.name);
-  const modelPath = join3(projectDir, appRel, "context", "model", kebab, "model.md");
+  const projectDir2 = join3(workspacePath, project.workspaceFolderName);
+  const appRel = resolveAppFolderName(projectDir2, app.name);
+  const modelPath = join3(projectDir2, appRel, "context", "model", kebab, "model.md");
   if (!existsSync3(modelPath)) throw svcError2("MODEL_NOT_FOUND", 404);
   return { content: readFileSync3(modelPath, "utf8") };
 }
@@ -20777,17 +20866,101 @@ function writeSectionToDisk(db, workspacePath, projectId, applicationId, section
 import { execFileSync } from "child_process";
 import { existsSync as existsSync6 } from "fs";
 import { join as join6 } from "path";
-function git(cwd, args) {
-  return execFileSync("git", args, {
-    cwd,
-    stdio: "pipe",
-    timeout: 6e4,
-    env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
-  }).toString().trim();
+function defaultAuthUsername(provider) {
+  return provider === "gitlab" ? "oauth2" : "x-access-token";
+}
+function buildPushAuthArgs(auth) {
+  if (!auth) return [];
+  const b64 = Buffer.from(`${auth.username}:${auth.token}`).toString("base64");
+  return ["-c", `http.extraHeader=AUTHORIZATION: basic ${b64}`];
 }
-function deriveVersionBranch(semver) {
+function redactAuthHeaderFromError(e, b64) {
+  const err = e;
+  if (typeof err.message === "string") err.message = err.message.split(b64).join("***");
+  if (typeof err.cmd === "string") err.cmd = err.cmd.split(b64).join("***");
+  if (Array.isArray(err.spawnargs)) {
+    err.spawnargs = err.spawnargs.map((a) => typeof a === "string" ? a.split(b64).join("***") : a);
+  }
+}
+function git(cwd, args, auth) {
+  try {
+    return execFileSync("git", [...buildPushAuthArgs(auth), ...args], {
+      cwd,
+      stdio: "pipe",
+      timeout: 6e4,
+      env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+    }).toString().trim();
+  } catch (e) {
+    if (auth) {
+      const b64 = Buffer.from(`${auth.username}:${auth.token}`).toString("base64");
+      redactAuthHeaderFromError(e, b64);
+    }
+    throw e;
+  }
+}
+function readCurrentBranch(projectDir2) {
+  try {
+    return git(projectDir2, ["branch", "--show-current"]);
+  } catch {
+    return "";
+  }
+}
+function readOriginUrl(projectDir2) {
+  try {
+    const url = git(projectDir2, ["config", "--get", "remote.origin.url"]);
+    return url === "" ? void 0 : url;
+  } catch {
+    return void 0;
+  }
+}
+function stripHttpsCredentials(url) {
+  const scheme = url.startsWith("https://") ? "https://" : url.startsWith("http://") ? "http://" : null;
+  if (!scheme) return url;
+  const rest = url.slice(scheme.length);
+  const slash = rest.indexOf("/");
+  const authority = slash === -1 ? rest : rest.slice(0, slash);
+  const at = authority.indexOf("@");
+  if (at === -1) return url;
+  return scheme + rest.slice(at + 1);
+}
+function ensureOrigin(projectDir2, url) {
+  const remotes = git(projectDir2, ["remote"]).split("\n");
+  if (remotes.includes("origin")) git(projectDir2, ["remote", "set-url", "origin", url]);
+  else git(projectDir2, ["remote", "add", "origin", url]);
+}
+function resolveGitPushContext(db, projectId, userId) {
+  const project = db.select({
+    gitRemoteUrl: projects.gitRemoteUrl,
+    defaultBranch: projects.defaultBranch,
+    gitProvider: projects.gitProvider
+  }).from(projects).where(eq(projects.id, projectId)).get();
+  const remoteUrl = project?.gitRemoteUrl ?? void 0;
+  const defaultBranch = project?.defaultBranch ?? void 0;
+  const provider = project?.gitProvider ?? void 0;
+  if (!userId) return { remoteUrl, defaultBranch, provider };
+  const user = db.select({ gitName: users.gitName, gitPat: users.gitPat }).from(users).where(eq(users.id, userId)).get();
+  if (!user?.gitPat) return { remoteUrl, defaultBranch, provider };
+  return {
+    remoteUrl,
+    defaultBranch,
+    provider,
+    auth: { username: user.gitName || defaultAuthUsername(provider), token: user.gitPat }
+  };
+}
+function deriveVersionBranch(semver, trunk = "main") {
   const s = semver ?? "v1.0.0";
-  return s === "v1.0.0" ? "main" : `release-${s.replace(/^v/, "")}`;
+  return s === "v1.0.0" ? trunk : `release-${s.replace(/^v/, "")}`;
+}
+function detectTrunkBranch(projectDir2, startingBranch) {
+  try {
+    const ref = git(projectDir2, ["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"]);
+    const name = ref.startsWith("origin/") ? ref.slice("origin/".length) : "";
+    if (name) return name;
+  } catch {
+  }
+  if (branchExists(projectDir2, "main")) return "main";
+  if (branchExists(projectDir2, "master")) return "master";
+  return startingBranch || "main";
 }
 var GitCutError = class extends Error {
   code = "GIT_OPERATION_FAILED";
@@ -20795,117 +20968,120 @@ var GitCutError = class extends Error {
 };
 function gitErrorDetail(e) {
   const stderr = e.stderr?.toString().trim();
-  const detail = stderr || e.message || String(e);
-  return detail.replace(/(https?:\/\/)[^@/\s]+@/gi, "$1***@");
+  const detail2 = stderr || e.message || String(e);
+  return detail2.replace(/(https?:\/\/)[^@/\s]+@/gi, "$1***@").replace(/authorization:\s*basic\s+\S+/gi, "AUTHORIZATION: basic ***");
 }
-function branchExists(projectDir, branch) {
+function branchExists(projectDir2, branch) {
   try {
-    git(projectDir, ["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`]);
+    git(projectDir2, ["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`]);
     return true;
   } catch {
     return false;
   }
 }
-function runVersionCutGit(projectDir, prevSemver, newSemver) {
-  const previousBranch = deriveVersionBranch(prevSemver);
+function runVersionCutGit(projectDir2, prevSemver, newSemver, opts) {
   const newBranch = `release-${newSemver.replace(/^v/, "")}`;
-  if (!existsSync6(join6(projectDir, ".git"))) {
+  if (!existsSync6(join6(projectDir2, ".git"))) {
     throw new GitCutError(
-      `${projectDir} has no git repository \u2014 run "git init" in the project folder before adding a version`
+      `${projectDir2} has no git repository \u2014 run "git init" in the project folder before adding a version`
     );
   }
   const fail = (step, e) => {
     throw new GitCutError(`${step} failed: ${gitErrorDetail(e)}`);
   };
-  const startingBranch = git(projectDir, ["branch", "--show-current"]);
+  const startingBranch = git(projectDir2, ["branch", "--show-current"]);
   if (startingBranch === "") {
     throw new GitCutError(
       "the repository is in detached HEAD state \u2014 check out a branch before adding a version"
     );
   }
+  const trunk = opts?.defaultBranch?.trim() || detectTrunkBranch(projectDir2, startingBranch);
+  const previousBranch = deriveVersionBranch(prevSemver, trunk);
   try {
-    if (git(projectDir, ["status", "--porcelain"]) !== "") {
-      git(projectDir, ["add", "-A"]);
-      git(projectDir, ["commit", "-m", `chore(version): finalize ${prevSemver}`]);
+    if (git(projectDir2, ["status", "--porcelain"]) !== "") {
+      git(projectDir2, ["add", "-A"]);
+      git(projectDir2, ["commit", "-m", `chore(version): finalize ${prevSemver}`]);
     }
   } catch (e) {
     fail("committing pending changes", e);
   }
   try {
-    if (branchExists(projectDir, "main")) git(projectDir, ["checkout", "main"]);
-    else git(projectDir, ["checkout", "-b", "main"]);
+    if (branchExists(projectDir2, trunk)) git(projectDir2, ["checkout", trunk]);
+    else git(projectDir2, ["checkout", "-b", trunk]);
   } catch (e) {
-    fail("checking out main", e);
+    fail(`checking out ${trunk}`, e);
   }
-  const mergeSource = branchExists(projectDir, previousBranch) ? previousBranch : startingBranch;
-  if (mergeSource !== "main") {
+  const mergeSource = branchExists(projectDir2, previousBranch) ? previousBranch : startingBranch;
+  if (mergeSource !== trunk) {
     try {
-      git(projectDir, ["merge", mergeSource, "-X", "theirs", "--no-edit"]);
+      git(projectDir2, ["merge", mergeSource, "-X", "theirs", "--no-edit"]);
     } catch (e) {
       try {
-        git(projectDir, ["merge", "--abort"]);
+        git(projectDir2, ["merge", "--abort"]);
       } catch {
       }
       try {
-        git(projectDir, ["checkout", startingBranch]);
+        git(projectDir2, ["checkout", startingBranch]);
       } catch {
       }
-      fail(`merging ${mergeSource} into main`, e);
+      fail(`merging ${mergeSource} into ${trunk}`, e);
     }
   }
-  if (branchExists(projectDir, newBranch)) {
+  if (branchExists(projectDir2, newBranch)) {
     let newBranchMerged = true;
     try {
-      git(projectDir, ["merge-base", "--is-ancestor", newBranch, "main"]);
+      git(projectDir2, ["merge-base", "--is-ancestor", newBranch, trunk]);
     } catch {
       newBranchMerged = false;
     }
     if (!newBranchMerged) {
       try {
-        git(projectDir, ["merge", newBranch, "-X", "theirs", "--no-edit"]);
+        git(projectDir2, ["merge", newBranch, "-X", "theirs", "--no-edit"]);
       } catch (e) {
         try {
-          git(projectDir, ["merge", "--abort"]);
+          git(projectDir2, ["merge", "--abort"]);
         } catch {
         }
-        fail(`merging ${newBranch} into main`, e);
+        fail(`merging ${newBranch} into ${trunk}`, e);
       }
     }
   }
   let commitHash = "";
   try {
-    git(projectDir, ["checkout", "-B", newBranch]);
-    commitHash = git(projectDir, ["rev-parse", "--short", "HEAD"]);
+    git(projectDir2, ["checkout", "-B", newBranch]);
+    commitHash = git(projectDir2, ["rev-parse", "--short", "HEAD"]);
   } catch (e) {
     fail(`creating ${newBranch}`, e);
   }
   let pushed = false;
   try {
-    const remotes = git(projectDir, ["remote"]);
+    if (opts?.remoteUrl) ensureOrigin(projectDir2, opts.remoteUrl);
+    const remotes = git(projectDir2, ["remote"]);
     if (remotes.split("\n").includes("origin")) {
-      git(projectDir, ["push", "--set-upstream", "origin", "main", newBranch]);
+      git(projectDir2, ["push", "--set-upstream", "origin", trunk, newBranch], opts?.auth);
       pushed = true;
     }
   } catch (e) {
-    fail(`pushing main and ${newBranch}`, e);
+    fail(`pushing ${trunk} and ${newBranch}`, e);
   }
   return { previousBranch, newBranch, commitHash, pushed };
 }
-function runProjectGit(projectDir, message) {
-  if (!existsSync6(join6(projectDir, ".git"))) {
+function runProjectGit(projectDir2, message, opts) {
+  if (!existsSync6(join6(projectDir2, ".git"))) {
     return { branch: "", commitHash: "", status: "skipped" };
   }
   try {
-    git(projectDir, ["add", "-A"]);
+    git(projectDir2, ["add", "-A"]);
     try {
-      git(projectDir, ["commit", "-m", message]);
+      git(projectDir2, ["commit", "-m", message]);
     } catch {
     }
-    const branch = git(projectDir, ["branch", "--show-current"]);
-    const commitHash = git(projectDir, ["rev-parse", "--short", "HEAD"]);
-    const remotes = git(projectDir, ["remote"]);
+    const branch = git(projectDir2, ["branch", "--show-current"]);
+    const commitHash = git(projectDir2, ["rev-parse", "--short", "HEAD"]);
+    if (opts?.remoteUrl) ensureOrigin(projectDir2, opts.remoteUrl);
+    const remotes = git(projectDir2, ["remote"]);
     if (remotes.split("\n").includes("origin")) {
-      git(projectDir, ["push", "--set-upstream", "origin", "HEAD"]);
+      git(projectDir2, ["push", "--set-upstream", "origin", "HEAD"], opts?.auth);
     }
     return { branch, commitHash, status: "completed" };
   } catch {
@@ -20933,7 +21109,12 @@ function runPostConductorGit(db, workspacePath, workflowMarkdownId) {
   };
   const cwd = join6(workspacePath, project.workspaceFolderName);
   const semver = wfm.versionLabel ?? "latest";
-  const result = runProjectGit(cwd, `chore(${wfm.conductorType}): ${semver} conductor output`);
+  const pushCtx = resolveGitPushContext(db, project.id, wfm.createdBy);
+  const result = runProjectGit(
+    cwd,
+    `chore(${wfm.conductorType}): ${semver} conductor output`,
+    pushCtx
+  );
   finish(result.status, result.branch || null, result.commitHash || null);
   return result;
 }
@@ -21027,7 +21208,13 @@ function addVersion(db, projectId, versionType, createdBy, workspacePath) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const project = db.select().from(projects).where(eq(projects.id, projectId)).get();
   if (!project) throw svcError4("PROJECT_NOT_FOUND", 404);
-  runVersionCutGit(join7(workspacePath, project.workspaceFolderName), currentSemver, newSemver);
+  const pushCtx = resolveGitPushContext(db, projectId, createdBy);
+  runVersionCutGit(
+    join7(workspacePath, project.workspaceFolderName),
+    currentSemver,
+    newSemver,
+    pushCtx
+  );
   const apps = db.select({ id: applications.id }).from(applications).where(and(eq(applications.projectId, projectId), eq(applications.isDeleted, 0))).all();
   const snapshot = {};
   for (const app of apps) {
@@ -21174,7 +21361,8 @@ function syncFromDisk(db, workspacePath, projectFolder, session) {
     try {
       const result = runProjectGit(
         join8(workspacePath, projectFolder),
-        `chore(brainstorm): session "${session.title ?? session.id}" completed`
+        `chore(brainstorm): session "${session.title ?? session.id}" completed`,
+        resolveGitPushContext(db, session.projectId, session.createdBy)
       );
       if (session.createdBy) {
         createNotification(
@@ -21515,8 +21703,8 @@ function cicdGuardTokenValid(projectId, token) {
 function resolveCicdApp(db, workspacePath, projectId) {
   const project = db.select().from(projects).where(eq(projects.id, projectId)).get();
   if (!project) throw svcError6("PROJECT_NOT_FOUND", 404);
-  const projectDir = join9(workspacePath, project.workspaceFolderName);
-  const appDir = join9(projectDir, "cicd", "app");
+  const projectDir2 = join9(workspacePath, project.workspaceFolderName);
+  const appDir = join9(projectDir2, "cicd", "app");
   const present = existsSync8(join9(appDir, "server.js"));
   let port = DEFAULT_CICD_APP_PORT;
   try {
@@ -21524,7 +21712,7 @@ function resolveCicdApp(db, workspacePath, projectId) {
     if (typeof config.port === "number") port = config.port;
   } catch {
   }
-  return { appDir, projectDir, present, port };
+  return { appDir, projectDir: projectDir2, present, port };
 }
 function probeApp(port, timeoutMs = 1e3) {
   return new Promise((resolve5) => {
@@ -21703,7 +21891,8 @@ function generatePrdWizardMarkdown(db, workspacePath, requestId, targetModule) {
   try {
     const result = runProjectGit(
       join10(workspacePath, project.workspaceFolderName),
-      `chore(prd-wizard): ${filename} generated`
+      `chore(prd-wizard): ${filename} generated`,
+      resolveGitPushContext(db, project.id, req.createdBy)
     );
     createNotification(db, req.createdBy, "conductor_progress", "PRD Wizard markdown committed", {
       body: result.status === "completed" ? `git commit ${result.commitHash} on ${result.branch}` : `git ${result.status}`,
@@ -21721,12 +21910,12 @@ function snapshotPrdFiles(db, workspacePath, projectId) {
   const project = db.select().from(projects).where(eq(projects.id, projectId)).get();
   const snapshot = /* @__PURE__ */ new Map();
   if (!project) return snapshot;
-  const projectDir = join10(workspacePath, project.workspaceFolderName);
+  const projectDir2 = join10(workspacePath, project.workspaceFolderName);
   const apps = db.select({ name: applications.name }).from(applications).where(and(eq(applications.projectId, projectId), eq(applications.isDeleted, 0))).all();
   for (const app of apps) {
-    const appRel = resolveAppFolderName(projectDir, app.name);
+    const appRel = resolveAppFolderName(projectDir2, app.name);
     for (const rel of ["context/PRD.md", "CHANGELOG.md"]) {
-      const abs = join10(projectDir, appRel, ...rel.split("/"));
+      const abs = join10(projectDir2, appRel, ...rel.split("/"));
       if (!existsSync9(abs)) continue;
       const stat = statSync2(abs);
       snapshot.set(abs, `${stat.mtimeMs}:${stat.size}`);
@@ -21766,7 +21955,8 @@ function pollWizardApply(db, workspacePath, requestId, state, nowMs) {
       if (project) {
         const result = runProjectGit(
           join10(workspacePath, project.workspaceFolderName),
-          `chore(prd-wizard): applied PRD updates (request ${requestId})`
+          `chore(prd-wizard): applied PRD updates (request ${requestId})`,
+          resolveGitPushContext(db, project.id, req.createdBy)
         );
         createNotification(db, req.createdBy, "conductor_complete", "PRD updates applied", {
           body: result.status === "completed" ? `git commit ${result.commitHash} on ${result.branch}` : `git ${result.status}`,
@@ -21820,20 +22010,20 @@ function git2(cwd, args) {
     env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
   }).toString().trim();
 }
-function checkGitState(projectDir) {
-  if (!existsSync10(join11(projectDir, ".git"))) {
+function checkGitState(projectDir2) {
+  if (!existsSync10(join11(projectDir2, ".git"))) {
     return { hasRepo: false, clean: false, pushed: false, currentBranch: null };
   }
   let currentBranch = null;
   let clean = false;
   let pushed = true;
   try {
-    currentBranch = git2(projectDir, ["branch", "--show-current"]) || null;
-    clean = git2(projectDir, ["status", "--porcelain"]) === "";
-    const remotes = git2(projectDir, ["remote"]).split("\n").filter(Boolean);
+    currentBranch = git2(projectDir2, ["branch", "--show-current"]) || null;
+    clean = git2(projectDir2, ["status", "--porcelain"]) === "";
+    const remotes = git2(projectDir2, ["remote"]).split("\n").filter(Boolean);
     if (remotes.includes("origin")) {
       try {
-        pushed = git2(projectDir, ["rev-list", "--count", "@{u}..HEAD"]) === "0";
+        pushed = git2(projectDir2, ["rev-list", "--count", "@{u}..HEAD"]) === "0";
       } catch {
         pushed = false;
       }
@@ -21845,12 +22035,12 @@ function checkGitState(projectDir) {
 }
 var GIT_STATE_TTL_MS = 3e3;
 var gitStateCache = /* @__PURE__ */ new Map();
-function cachedCheckGitState(projectDir) {
-  const cached = gitStateCache.get(projectDir);
+function cachedCheckGitState(projectDir2) {
+  const cached = gitStateCache.get(projectDir2);
   const now = Date.now();
   if (cached && now - cached.at < GIT_STATE_TTL_MS) return cached.state;
-  const state = checkGitState(projectDir);
-  gitStateCache.set(projectDir, { state, at: now });
+  const state = checkGitState(projectDir2);
+  gitStateCache.set(projectDir2, { state, at: now });
   return state;
 }
 function evaluateBuildGuard(db, workspacePath, projectId, versionId) {
@@ -21875,8 +22065,8 @@ function evaluateBuildGuard(db, workspacePath, projectId, versionId) {
     const applying = db.select({ id: prdWizardRequests.id }).from(prdWizardRequests).where(and(eq(prdWizardRequests.projectId, projectId), inArray(prdWizardRequests.id, applyIds))).limit(1).get();
     if (applying) reasons.push("a PRD Wizard update is being applied");
   }
-  const projectDir = join11(workspacePath, project.workspaceFolderName);
-  const gitState = cachedCheckGitState(projectDir);
+  const projectDir2 = join11(workspacePath, project.workspaceFolderName);
+  const gitState = cachedCheckGitState(projectDir2);
   if (!gitState.hasRepo) reasons.push("the project folder has no git repository");
   else {
     if (!gitState.clean) reasons.push("uncommitted changes in the working tree");
@@ -22061,15 +22251,19 @@ function requestPlan(db, workspacePath, projectId, userId) {
   stopCicdWatcher(setup.id, "generation");
   const project = requireProject(db, projectId);
   const apps = db.select({ name: applications.name }).from(applications).where(and(eq(applications.projectId, projectId), eq(applications.isDeleted, 0))).all();
-  const projectDir = join13(workspacePath, project.workspaceFolderName);
-  const executionDir = join13(projectDir, "execution");
+  const projectDir2 = join13(workspacePath, project.workspaceFolderName);
+  const executionDir = join13(projectDir2, "execution");
   mkdirSync4(executionDir, { recursive: true });
   const filename = `cicd-plan-${setup.id}-${Date.now()}.md`;
   const filePath = join13(executionDir, filename);
   const relative3 = `execution/${filename}`;
   writeFileSync5(
     filePath,
-    buildPlanRequestMarkdown(project.name, apps.map((a) => a.name), relative3),
+    buildPlanRequestMarkdown(
+      project.name,
+      apps.map((a) => a.name),
+      relative3
+    ),
     "utf8"
   );
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -22080,7 +22274,11 @@ function requestPlan(db, workspacePath, projectId, userId) {
     relatedEntityId: setup.id
   });
   try {
-    runProjectGit(projectDir, `chore(cicd): plan request ${filename}`);
+    runProjectGit(
+      projectDir2,
+      `chore(cicd): plan request ${filename}`,
+      resolveGitPushContext(db, projectId, userId)
+    );
   } catch {
   }
   startCicdWatcher(db, workspacePath, setup.id, "plan", userId);
@@ -22104,9 +22302,9 @@ function pollCicdTracking(db, workspacePath, setupId, kind, notifyUserId) {
   if (setup.status !== expected) return "stopped";
   const project = db.select().from(projects).where(eq(projects.id, setup.projectId)).get();
   if (!project) return "stopped";
-  const projectDir = join13(workspacePath, project.workspaceFolderName);
+  const projectDir2 = join13(workspacePath, project.workspaceFolderName);
   const trackingPath = join13(
-    projectDir,
+    projectDir2,
     ...(kind === "plan" ? CICD_PLAN_RELATIVE : CICD_GENERATION_RELATIVE).split("/")
   );
   const requestedAt = kind === "plan" ? setup.planRequestedAt : setup.generateRequestedAt;
@@ -22136,7 +22334,11 @@ function pollCicdTracking(db, workspacePath, setupId, kind, notifyUserId) {
       relatedEntityId: setupId
     });
     try {
-      runProjectGit(projectDir, "chore(cicd): CI/CD app generated");
+      runProjectGit(
+        projectDir2,
+        "chore(cicd): CI/CD app generated",
+        resolveGitPushContext(db, setup.projectId, notifyUserId)
+      );
     } catch {
     }
   }
@@ -22172,8 +22374,8 @@ function approvePlan(db, workspacePath, projectId, userId) {
   const setup = getOrCreateSetup(db, projectId, userId);
   if (setup.status !== "planned") throw svcError8("CICD_INVALID_STATE", 409);
   const project = requireProject(db, projectId);
-  const projectDir = join13(workspacePath, project.workspaceFolderName);
-  const planPath = join13(projectDir, ...CICD_PLAN_RELATIVE.split("/"));
+  const projectDir2 = join13(workspacePath, project.workspaceFolderName);
+  const planPath = join13(projectDir2, ...CICD_PLAN_RELATIVE.split("/"));
   if (parseTrackingStatus(planPath) !== "COMPLETED") throw svcError8("CICD_PLAN_NOT_READY", 409);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   appendFileSync(planPath, `
@@ -22181,7 +22383,11 @@ function approvePlan(db, workspacePath, projectId, userId) {
 `);
   db.update(cicdSetups).set({ status: "approved", approvedBy: userId, approvedAt: now, updatedAt: now }).where(eq(cicdSetups.id, setup.id)).run();
   try {
-    runProjectGit(projectDir, "chore(cicd): deployment plan approved");
+    runProjectGit(
+      projectDir2,
+      "chore(cicd): deployment plan approved",
+      resolveGitPushContext(db, projectId, userId)
+    );
   } catch {
   }
 }
@@ -22490,12 +22696,12 @@ function createProject(db, workspacePath, name, code, baseIdea, createdBy) {
   return projectId;
 }
 function scaffoldProjectFolder(workspacePath, folderName, name, baseIdea) {
-  const projectDir = join16(workspacePath, folderName);
-  mkdirSync6(projectDir, { recursive: true });
-  mkdirSync6(join16(projectDir, "execution"), { recursive: true });
-  mkdirSync6(join16(projectDir, "context"), { recursive: true });
-  mkdirSync6(join16(projectDir, "context", "references"), { recursive: true });
-  mkdirSync6(join16(projectDir, "shared_context"), { recursive: true });
+  const projectDir2 = join16(workspacePath, folderName);
+  mkdirSync6(projectDir2, { recursive: true });
+  mkdirSync6(join16(projectDir2, "execution"), { recursive: true });
+  mkdirSync6(join16(projectDir2, "context"), { recursive: true });
+  mkdirSync6(join16(projectDir2, "context", "references"), { recursive: true });
+  mkdirSync6(join16(projectDir2, "shared_context"), { recursive: true });
   const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   const template = [
     "---",
@@ -22535,9 +22741,9 @@ function scaffoldProjectFolder(workspacePath, folderName, name, baseIdea) {
     "# Feedback",
     "<!-- Human answers appear here -->"
   ].join("\n");
-  writeFileSync7(join16(projectDir, `${folderName}.brainstorm.md`), template, "utf8");
+  writeFileSync7(join16(projectDir2, `${folderName}.brainstorm.md`), template, "utf8");
   writeFileSync7(
-    join16(projectDir, "context", "references", "brainstorm-protocol.md"),
+    join16(projectDir2, "context", "references", "brainstorm-protocol.md"),
     "# Brainstorm Protocol\n\n[Installed by the co2 plugin]\n",
     "utf8"
   );
@@ -22636,6 +22842,9 @@ function getProjectDetail(db, workspacePath, projectId) {
     workflowPhase: project.workflowPhase,
     creationStatus,
     isArchived: project.isArchived,
+    gitRemoteUrl: project.gitRemoteUrl ?? null,
+    defaultBranch: project.defaultBranch ?? "main",
+    gitProvider: project.gitProvider ?? "github",
     applications: apps,
     createdAt: project.createdAt
   };
@@ -22691,11 +22900,11 @@ function getProjectDetailSummary(db, projectId) {
 function regenerateCO2Files(db, workspacePath, projectId) {
   const project = db.select().from(projects).where(eq(projects.id, projectId)).limit(1).get();
   if (!project) throw svcError10("NOT_FOUND", 404);
-  const projectDir = join16(workspacePath, project.workspaceFolderName);
-  mkdirSync6(projectDir, { recursive: true });
+  const projectDir2 = join16(workspacePath, project.workspaceFolderName);
+  mkdirSync6(projectDir2, { recursive: true });
   const apps = db.select().from(applications).where(and(eq(applications.projectId, projectId), eq(applications.isDeleted, 0))).all();
   writeFileSync7(
-    join16(projectDir, "CLAUDE.md"),
+    join16(projectDir2, "CLAUDE.md"),
     project.rawClaudeMd ?? buildClaudeMd(project.name, apps),
     "utf8"
   );
@@ -22708,8 +22917,8 @@ function regenerateCO2Files(db, workspacePath, projectId) {
   }
   for (const app of apps) {
     const mods = db.select().from(projectModules).where(and(eq(projectModules.applicationId, app.id), eq(projectModules.isDeleted, 0))).all();
-    const appRel = resolveAppFolderName(projectDir, app.name);
-    const appDir = join16(projectDir, appRel, "context");
+    const appRel = resolveAppFolderName(projectDir2, app.name);
+    const appDir = join16(projectDir2, appRel, "context");
     mkdirSync6(appDir, { recursive: true });
     writeFileSync7(
       join16(appDir, "PRD.md"),
@@ -22766,10 +22975,10 @@ function toKebabCase(name) {
 function rescanClaudeMd(db, workspacePath, projectId) {
   const project = db.select().from(projects).where(eq(projects.id, projectId)).limit(1).get();
   if (!project) throw svcError10("NOT_FOUND", 404);
-  const projectDir = join16(workspacePath, project.workspaceFolderName);
+  const projectDir2 = join16(workspacePath, project.workspaceFolderName);
   const claudeMdPath = [
-    join16(projectDir, "CLAUDE.md"),
-    join16(projectDir, "source", "CLAUDE.md")
+    join16(projectDir2, "CLAUDE.md"),
+    join16(projectDir2, "source", "CLAUDE.md")
   ].find((p) => existsSync14(p));
   if (!claudeMdPath) throw svcError10("CLAUDE_MD_MISSING", 404);
   const content = readFileSync9(claudeMdPath, "utf8");
@@ -22860,6 +23069,18 @@ function deriveAppCode(name) {
   const initials = name.split(/[\s_-]+/).filter(Boolean).map((w) => w[0].toUpperCase()).join("");
   return (initials || name.slice(0, 2)).slice(0, 4);
 }
+function updateProjectGitRemote(db, projectId, gitRemoteUrl, opts = {}) {
+  const project = db.select({ id: projects.id }).from(projects).where(eq(projects.id, projectId)).limit(1).get();
+  if (!project) throw svcError10("NOT_FOUND", 404);
+  const trimmed = gitRemoteUrl.trim();
+  const set = { gitRemoteUrl: trimmed === "" ? null : trimmed, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  if (opts.defaultBranch !== void 0) {
+    const b = opts.defaultBranch.trim();
+    set.defaultBranch = b === "" ? "main" : b;
+  }
+  if (opts.gitProvider !== void 0) set.gitProvider = opts.gitProvider;
+  db.update(projects).set(set).where(eq(projects.id, projectId)).run();
+}
 function archiveProject(db, projectId, archivedBy) {
   const project = db.select({ id: projects.id }).from(projects).where(eq(projects.id, projectId)).limit(1).get();
   if (!project) throw svcError10("NOT_FOUND", 404);
@@ -23520,9 +23741,9 @@ function writeBugMdFile(db, workspacePath, app, projectFolderName) {
     db.select({ id: prdVersions.id, semver: prdVersions.semver }).from(prdVersions).where(eq(prdVersions.projectId, app.projectId)).all().map((v) => [v.id, v.semver])
   );
   const content = buildBugMd(modules, bugs, semverByVersionId);
-  const projectDir = join17(workspacePath, projectFolderName);
-  const appRel = resolveAppFolderName(projectDir, app.name);
-  const appContextDir = join17(projectDir, appRel, "context");
+  const projectDir2 = join17(workspacePath, projectFolderName);
+  const appRel = resolveAppFolderName(projectDir2, app.name);
+  const appContextDir = join17(projectDir2, appRel, "context");
   mkdirSync7(appContextDir, { recursive: true });
   writeFileSync8(join17(appContextDir, "BUG.md"), content, "utf8");
   return { content, bugCount: bugs.length };
@@ -23557,8 +23778,8 @@ function syncBugMdToDisk(db, workspacePath, applicationId, bugId, mode = "replac
     const project = db.select({ workspaceFolderName: projects.workspaceFolderName }).from(projects).where(eq(projects.id, app.projectId)).get();
     if (!project) return;
     if (bugId !== void 0) {
-      const projectDir = join17(workspacePath, project.workspaceFolderName);
-      const file = join17(projectDir, resolveAppFolderName(projectDir, app.name), "context", "BUG.md");
+      const projectDir2 = join17(workspacePath, project.workspaceFolderName);
+      const file = join17(projectDir2, resolveAppFolderName(projectDir2, app.name), "context", "BUG.md");
       if (existsSync15(file)) {
         const bug = db.select().from(bugReports).where(and(eq(bugReports.id, bugId), eq(bugReports.isDeleted, 0))).get();
         if (bug) {
@@ -23800,6 +24021,332 @@ function documentRoutes(db, dataDir) {
   return app;
 }
 
+// ../server/src/features/git/service.ts
+import { execFileSync as execFileSync3 } from "child_process";
+import { existsSync as existsSync17, readFileSync as readFileSync12, rmSync, writeFileSync as writeFileSync10 } from "fs";
+import { join as join19 } from "path";
+var GitServiceError = class extends Error {
+  code;
+  status;
+  constructor(code, status, message) {
+    super(message ?? code);
+    this.code = code;
+    this.status = status;
+  }
+};
+function git3(cwd, args) {
+  return execFileSync3("git", args, {
+    cwd,
+    stdio: "pipe",
+    timeout: 3e4,
+    maxBuffer: 64 * 1024 * 1024,
+    env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+  }).toString().trim();
+}
+function gitOrNull(cwd, args) {
+  try {
+    return execFileSync3("git", args, {
+      cwd,
+      stdio: "pipe",
+      timeout: 3e4,
+      maxBuffer: 64 * 1024 * 1024,
+      env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+    }).toString();
+  } catch {
+    return null;
+  }
+}
+function projectDir(db, workspacePath, projectId) {
+  const project = db.select({ folder: projects.workspaceFolderName }).from(projects).where(eq(projects.id, projectId)).get();
+  if (!project) throw new GitServiceError("PROJECT_NOT_FOUND", 404);
+  return join19(workspacePath, project.folder);
+}
+function isGitRepo(dir) {
+  return existsSync17(join19(dir, ".git"));
+}
+function classifyStatus(x, y) {
+  const conflictPairs = /* @__PURE__ */ new Set(["DD", "AU", "UD", "UA", "DU", "AA", "UU"]);
+  const xy = `${x}${y}`;
+  if (conflictPairs.has(xy)) {
+    return { status: "conflicted", staged: false, unstaged: true, conflicted: true };
+  }
+  if (x === "?" && y === "?") {
+    return { status: "untracked", staged: false, unstaged: true, conflicted: false };
+  }
+  const staged = x !== " " && x !== "?";
+  const unstaged = y !== " " && y !== "?";
+  const code = x !== " " && x !== "?" ? x : y;
+  const status = code === "A" ? "added" : code === "D" ? "deleted" : code === "R" ? "renamed" : code === "T" ? "typechange" : "modified";
+  return { status, staged, unstaged, conflicted: false };
+}
+function parseStatus2(raw2) {
+  const parsed = { branch: null, upstream: null, ahead: 0, behind: 0, files: [] };
+  const records = raw2.split("\0");
+  for (let i = 0; i < records.length; i++) {
+    const rec = records[i];
+    if (rec === "" || rec === void 0) continue;
+    if (rec.startsWith("## ")) {
+      const info = rec.slice(3);
+      const noCommits = info.match(/^No commits yet on (.+)$/);
+      const head = info.split(" ")[0] ?? "";
+      const dots = head.indexOf("...");
+      parsed.branch = noCommits ? noCommits[1] ?? null : dots === -1 ? head : head.slice(0, dots);
+      if (dots !== -1) parsed.upstream = head.slice(dots + 3);
+      parsed.ahead = Number(info.match(/ahead (\d+)/)?.[1] ?? 0);
+      parsed.behind = Number(info.match(/behind (\d+)/)?.[1] ?? 0);
+      continue;
+    }
+    const x = rec[0] ?? " ";
+    const y = rec[1] ?? " ";
+    const path = rec.slice(3);
+    if (x === "R" || x === "C" || y === "R" || y === "C") i++;
+    const cls = classifyStatus(x, y);
+    parsed.files.push({
+      path,
+      status: cls.status,
+      staged: cls.staged,
+      unstaged: cls.unstaged,
+      conflicted: cls.conflicted,
+      indexStatus: x,
+      worktreeStatus: y
+    });
+  }
+  return parsed;
+}
+function getGitStatus(db, workspacePath, projectId) {
+  const dir = projectDir(db, workspacePath, projectId);
+  const empty = {
+    available: false,
+    branch: null,
+    upstream: null,
+    ahead: 0,
+    behind: 0,
+    clean: true,
+    hasConflicts: false,
+    files: [],
+    changedCount: 0
+  };
+  if (!existsSync17(dir) || !isGitRepo(dir)) return empty;
+  let raw2;
+  try {
+    raw2 = execFileSync3("git", ["status", "--porcelain=v1", "-b", "-z"], {
+      cwd: dir,
+      stdio: "pipe",
+      timeout: 3e4,
+      maxBuffer: 64 * 1024 * 1024,
+      env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+    }).toString();
+  } catch {
+    return empty;
+  }
+  const p = parseStatus2(raw2);
+  return {
+    available: true,
+    branch: p.branch,
+    upstream: p.upstream,
+    ahead: p.ahead,
+    behind: p.behind,
+    clean: p.files.length === 0,
+    hasConflicts: p.files.some((f) => f.conflicted),
+    files: p.files,
+    changedCount: p.files.length
+  };
+}
+function looksBinary(s) {
+  return s?.includes("\0") ?? false;
+}
+function getFileDiff(db, workspacePath, projectId, path) {
+  const dir = projectDir(db, workspacePath, projectId);
+  if (!existsSync17(dir) || !isGitRepo(dir)) {
+    throw new GitServiceError("NO_GIT_REPO", 404, "No git repository for this project");
+  }
+  const status = getGitStatus(db, workspacePath, projectId);
+  const file = status.files.find((f) => f.path === path);
+  const cls = file?.status ?? "modified";
+  const conflicted = file?.conflicted ?? false;
+  if (conflicted) {
+    const base = gitOrNull(dir, ["show", `:1:${path}`]);
+    const ours = gitOrNull(dir, ["show", `:2:${path}`]);
+    const theirs = gitOrNull(dir, ["show", `:3:${path}`]);
+    const working = readWorking(dir, path);
+    const binary2 = looksBinary(base) || looksBinary(ours) || looksBinary(theirs);
+    return {
+      path,
+      status: cls,
+      binary: binary2,
+      conflicted: true,
+      oldContent: ours,
+      // pre-populate the merge editor with our side by default
+      newContent: working,
+      base,
+      ours,
+      theirs
+    };
+  }
+  const oldContent = gitOrNull(dir, ["show", `HEAD:${path}`]);
+  const newContent = cls === "deleted" ? null : readWorking(dir, path);
+  const binary = looksBinary(oldContent) || looksBinary(newContent);
+  return {
+    path,
+    status: cls,
+    binary,
+    conflicted: false,
+    oldContent: cls === "added" || cls === "untracked" ? null : oldContent,
+    newContent,
+    base: null,
+    ours: null,
+    theirs: null
+  };
+}
+function readWorking(dir, path) {
+  const abs = join19(dir, path);
+  if (!existsSync17(abs)) return null;
+  try {
+    return readFileSync12(abs, "utf8");
+  } catch {
+    return null;
+  }
+}
+function commitChanges(db, workspacePath, projectId, input) {
+  const dir = projectDir(db, workspacePath, projectId);
+  if (!existsSync17(dir) || !isGitRepo(dir)) {
+    throw new GitServiceError("NO_GIT_REPO", 404, "No git repository for this project");
+  }
+  try {
+    if (input.paths && input.paths.length > 0) git3(dir, ["add", "--", ...input.paths]);
+    else git3(dir, ["add", "-A"]);
+  } catch (e) {
+    throw new GitServiceError("GIT_ADD_FAILED", 409, detail(e));
+  }
+  try {
+    git3(dir, ["diff", "--cached", "--quiet"]);
+    throw new GitServiceError("NOTHING_TO_COMMIT", 400, "No staged changes to commit");
+  } catch (e) {
+    if (e instanceof GitServiceError) throw e;
+  }
+  try {
+    git3(dir, ["commit", "-m", input.message]);
+  } catch (e) {
+    throw new GitServiceError("GIT_COMMIT_FAILED", 409, detail(e));
+  }
+  const branch = safe(() => git3(dir, ["branch", "--show-current"])) ?? "";
+  const commitHash = safe(() => git3(dir, ["rev-parse", "--short", "HEAD"])) ?? "";
+  return { committed: true, branch, commitHash };
+}
+function discardChanges(db, workspacePath, projectId, paths) {
+  const dir = projectDir(db, workspacePath, projectId);
+  if (!existsSync17(dir) || !isGitRepo(dir)) {
+    throw new GitServiceError("NO_GIT_REPO", 404, "No git repository for this project");
+  }
+  for (const path of paths) {
+    safe(() => git3(dir, ["reset", "-q", "HEAD", "--", path]));
+    const inHead = safe(() => git3(dir, ["cat-file", "-e", `HEAD:${path}`])) !== null;
+    if (inHead) {
+      try {
+        git3(dir, ["checkout", "--", path]);
+      } catch (e) {
+        throw new GitServiceError("GIT_DISCARD_FAILED", 409, detail(e));
+      }
+    } else {
+      const abs = join19(dir, path);
+      if (existsSync17(abs)) rmSync(abs, { force: true });
+    }
+  }
+}
+function resolveConflict(db, workspacePath, projectId, input) {
+  const dir = projectDir(db, workspacePath, projectId);
+  if (!existsSync17(dir) || !isGitRepo(dir)) {
+    throw new GitServiceError("NO_GIT_REPO", 404, "No git repository for this project");
+  }
+  try {
+    if (input.resolution === "manual") {
+      if (input.content === void 0) {
+        throw new GitServiceError("CONTENT_REQUIRED", 400, "Manual resolution requires content");
+      }
+      writeFileSync10(join19(dir, input.path), input.content, "utf8");
+    } else {
+      git3(dir, ["checkout", `--${input.resolution}`, "--", input.path]);
+    }
+    git3(dir, ["add", "--", input.path]);
+  } catch (e) {
+    if (e instanceof GitServiceError) throw e;
+    throw new GitServiceError("GIT_RESOLVE_FAILED", 409, detail(e));
+  }
+}
+function detail(e) {
+  const stderr = e.stderr?.toString().trim();
+  return stderr || e.message || String(e);
+}
+function safe(fn) {
+  try {
+    return fn();
+  } catch {
+    return null;
+  }
+}
+
+// ../server/src/features/git/routes.ts
+function errorResponse7(c, e) {
+  const err = e;
+  const status = err.status ?? 500;
+  return c.json({ code: err.code ?? "INTERNAL_ERROR" }, status);
+}
+function gitRoutes(db, workspacePath) {
+  const app = new Hono2();
+  app.get("/status/:projectId", (c) => {
+    const projectId = Number(c.req.param("projectId"));
+    if (Number.isNaN(projectId)) return c.json({ code: "INVALID_ID" }, 400);
+    try {
+      return c.json(getGitStatus(db, workspacePath, projectId));
+    } catch (e) {
+      return errorResponse7(c, e);
+    }
+  });
+  app.get("/diff/:projectId", (c) => {
+    const projectId = Number(c.req.param("projectId"));
+    if (Number.isNaN(projectId)) return c.json({ code: "INVALID_ID" }, 400);
+    const path = c.req.query("path");
+    if (!path) return c.json({ code: "PATH_REQUIRED" }, 400);
+    try {
+      return c.json(getFileDiff(db, workspacePath, projectId, path));
+    } catch (e) {
+      return errorResponse7(c, e);
+    }
+  });
+  app.post("/commit/:projectId", zValidator("json", gitCommitRequestSchema), (c) => {
+    const projectId = Number(c.req.param("projectId"));
+    if (Number.isNaN(projectId)) return c.json({ code: "INVALID_ID" }, 400);
+    try {
+      const body = c.req.valid("json");
+      return c.json(commitChanges(db, workspacePath, projectId, body));
+    } catch (e) {
+      return errorResponse7(c, e);
+    }
+  });
+  app.post("/discard/:projectId", zValidator("json", gitDiscardRequestSchema), (c) => {
+    const projectId = Number(c.req.param("projectId"));
+    if (Number.isNaN(projectId)) return c.json({ code: "INVALID_ID" }, 400);
+    try {
+      discardChanges(db, workspacePath, projectId, c.req.valid("json").paths);
+      return c.json({ ok: true });
+    } catch (e) {
+      return errorResponse7(c, e);
+    }
+  });
+  app.post("/resolve/:projectId", zValidator("json", gitResolveRequestSchema), (c) => {
+    const projectId = Number(c.req.param("projectId"));
+    if (Number.isNaN(projectId)) return c.json({ code: "INVALID_ID" }, 400);
+    try {
+      resolveConflict(db, workspacePath, projectId, c.req.valid("json"));
+      return c.json({ ok: true });
+    } catch (e) {
+      if (e instanceof GitServiceError) return errorResponse7(c, e);
+      return errorResponse7(c, e);
+    }
+  });
+  return app;
+}
+
 // ../server/src/features/notification/routes.ts
 function notificationRoutes(db) {
   const app = new Hono2();
@@ -23830,7 +24377,7 @@ function notificationRoutes(db) {
 }
 
 // ../server/src/features/prd-wizard/routes.ts
-function errorResponse7(c, e) {
+function errorResponse8(c, e) {
   const err = e;
   const status = err.status ?? 500;
   return c.json({ code: err.code ?? "INTERNAL_ERROR" }, status);
@@ -23859,7 +24406,7 @@ function prdWizardRoutes(db, workspacePath) {
       startWizardApplyWatcher(db, workspacePath, requestId);
       return c.json({ requestId, filePath, status: "generated" }, 201);
     } catch (e) {
-      return errorResponse7(c, e);
+      return errorResponse8(c, e);
     }
   });
   app.get("/:projectId", (c) => {
@@ -23871,14 +24418,14 @@ function prdWizardRoutes(db, workspacePath) {
     try {
       return c.json(listPrdWizardRequests(db, projectId, prdVersionId));
     } catch (e) {
-      return errorResponse7(c, e);
+      return errorResponse8(c, e);
     }
   });
   return app;
 }
 
 // ../server/src/features/project-config/routes.ts
-function errorResponse8(c, e) {
+function errorResponse9(c, e) {
   const err = e;
   const status = err.status ?? 500;
   return c.json({ code: err.code ?? "INTERNAL_ERROR" }, status);
@@ -23895,7 +24442,7 @@ function projectConfigRoutes(db, workspacePath) {
     try {
       return c.json(getProjectEnvironment(db, projectId));
     } catch (e) {
-      return errorResponse8(c, e);
+      return errorResponse9(c, e);
     }
   });
   app.patch("/:projectId/environment", zValidator("json", saveWorkspaceConfigSchema), (c) => {
@@ -23906,7 +24453,7 @@ function projectConfigRoutes(db, workspacePath) {
         saveProjectEnvironment(db, workspacePath, projectId, c.req.valid("json").content)
       );
     } catch (e) {
-      return errorResponse8(c, e);
+      return errorResponse9(c, e);
     }
   });
   app.post(
@@ -23929,7 +24476,7 @@ function projectConfigRoutes(db, workspacePath) {
           )
         );
       } catch (e) {
-        return errorResponse8(c, e);
+        return errorResponse9(c, e);
       }
     }
   );
@@ -23939,7 +24486,7 @@ function projectConfigRoutes(db, workspacePath) {
     try {
       return c.json(getProjectDevtool(db, projectId));
     } catch (e) {
-      return errorResponse8(c, e);
+      return errorResponse9(c, e);
     }
   });
   app.patch("/:projectId/devtool", zValidator("json", saveWorkspaceConfigSchema), (c) => {
@@ -23948,7 +24495,7 @@ function projectConfigRoutes(db, workspacePath) {
     try {
       return c.json(saveProjectDevtool(db, workspacePath, projectId, c.req.valid("json").content));
     } catch (e) {
-      return errorResponse8(c, e);
+      return errorResponse9(c, e);
     }
   });
   app.post(
@@ -23965,7 +24512,7 @@ function projectConfigRoutes(db, workspacePath) {
           importProjectDevtool(db, workspacePath, projectId, c.req.valid("json").content, user.id)
         );
       } catch (e) {
-        return errorResponse8(c, e);
+        return errorResponse9(c, e);
       }
     }
   );
@@ -23973,8 +24520,8 @@ function projectConfigRoutes(db, workspacePath) {
 }
 
 // ../server/src/features/project-import/scanner.ts
-import { existsSync as existsSync17, readFileSync as readFileSync12, readdirSync as readdirSync3, statSync as statSync5 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync13, readdirSync as readdirSync3, statSync as statSync5 } from "fs";
+import { join as join20 } from "path";
 
 // ../server/src/features/project-import/changelog-md.ts
 var VERSION_HEADING = /^##\s+v?(\d+\.\d+\.\d+)\b/;
@@ -24122,64 +24669,64 @@ function svcError13(code, status) {
   return Object.assign(new Error(code), { code, status });
 }
 function readIfExists(path) {
-  return existsSync17(path) ? readFileSync12(path, "utf8") : null;
+  return existsSync18(path) ? readFileSync13(path, "utf8") : null;
 }
 function emptyArtifactCounts() {
   return { erd: 0, data_model: 0, mockup: 0, technical_spec: 0, test_spec: 0, source_code: 0 };
 }
 function countArtifacts(appDir) {
   const counts = emptyArtifactCounts();
-  const contextDir = join19(appDir, "context");
-  const modelDir = join19(contextDir, "model");
-  if (existsSync17(modelDir)) {
+  const contextDir = join20(appDir, "context");
+  const modelDir = join20(contextDir, "model");
+  if (existsSync18(modelDir)) {
     for (const slug of readdirSync3(modelDir)) {
       try {
-        if (!statSync5(join19(modelDir, slug)).isDirectory()) continue;
+        if (!statSync5(join20(modelDir, slug)).isDirectory()) continue;
       } catch {
         continue;
       }
-      if (existsSync17(join19(modelDir, slug, "erd.mermaid")) || existsSync17(join19(modelDir, slug, "document-model.mermaid")))
+      if (existsSync18(join20(modelDir, slug, "erd.mermaid")) || existsSync18(join20(modelDir, slug, "document-model.mermaid")))
         counts.erd++;
-      if (existsSync17(join19(modelDir, slug, "model.md"))) counts.data_model++;
-      if (existsSync17(join19(contextDir, "specification", slug, "SPEC.md"))) counts.technical_spec++;
-      if (existsSync17(join19(contextDir, "test", slug, "TEST_SPEC.md"))) counts.test_spec++;
+      if (existsSync18(join20(modelDir, slug, "model.md"))) counts.data_model++;
+      if (existsSync18(join20(contextDir, "specification", slug, "SPEC.md"))) counts.technical_spec++;
+      if (existsSync18(join20(contextDir, "test", slug, "TEST_SPEC.md"))) counts.test_spec++;
     }
   }
   for (const [sub, key, file] of [
     ["specification", "technical_spec", "SPEC.md"],
     ["test", "test_spec", "TEST_SPEC.md"]
   ]) {
-    const dir = join19(contextDir, sub);
-    if (!existsSync17(dir)) continue;
+    const dir = join20(contextDir, sub);
+    if (!existsSync18(dir)) continue;
     let total = 0;
     for (const slug of readdirSync3(dir)) {
       try {
-        if (statSync5(join19(dir, slug)).isDirectory() && existsSync17(join19(dir, slug, file))) total++;
+        if (statSync5(join20(dir, slug)).isDirectory() && existsSync18(join20(dir, slug, file))) total++;
       } catch {
       }
     }
     counts[key] = Math.max(counts[key], total);
   }
-  if (existsSync17(join19(contextDir, "mockup", "MOCKUP.html")) || existsSync17(join19(contextDir, "mockup", "index.html")))
+  if (existsSync18(join20(contextDir, "mockup", "MOCKUP.html")) || existsSync18(join20(contextDir, "mockup", "index.html")))
     counts.mockup = 1;
   counts.source_code = sweepSourceFiles(appDir).length;
   return counts;
 }
 function findClaudeMd(folderDir) {
-  if (existsSync17(join19(folderDir, "CLAUDE.md"))) return { relPath: "CLAUDE.md", prefix: "" };
-  if (existsSync17(join19(folderDir, "source", "CLAUDE.md")))
+  if (existsSync18(join20(folderDir, "CLAUDE.md"))) return { relPath: "CLAUDE.md", prefix: "" };
+  if (existsSync18(join20(folderDir, "source", "CLAUDE.md")))
     return { relPath: "source/CLAUDE.md", prefix: "source" };
   return null;
 }
 function listImportCandidates(db, workspacePath) {
-  if (!existsSync17(workspacePath)) return [];
+  if (!existsSync18(workspacePath)) return [];
   const registered = new Set(
     db.select({ folder: projects.workspaceFolderName }).from(projects).all().map((r) => r.folder)
   );
   const candidates = [];
   for (const entry of readdirSync3(workspacePath)) {
     if (entry.startsWith(".") || registered.has(entry)) continue;
-    const dir = join19(workspacePath, entry);
+    const dir = join20(workspacePath, entry);
     try {
       if (!statSync5(dir).isDirectory()) continue;
     } catch {
@@ -24187,14 +24734,14 @@ function listImportCandidates(db, workspacePath) {
     }
     const found = findClaudeMd(dir);
     if (!found) continue;
-    const detail = parseProjectDetail(
-      readFileSync12(join19(workspacePath, entry, found.relPath), "utf8")
+    const detail2 = parseProjectDetail(
+      readFileSync13(join20(workspacePath, entry, found.relPath), "utf8")
     );
     candidates.push({
       folderName: entry,
       claudeMdPath: `${entry}/${found.relPath}`,
-      projectName: detail.projectName,
-      projectCode: detail.projectCode
+      projectName: detail2.projectName,
+      projectCode: detail2.projectCode
     });
   }
   return candidates.sort((a, b) => a.folderName.localeCompare(b.folderName));
@@ -24202,22 +24749,22 @@ function listImportCandidates(db, workspacePath) {
 function scanRepo(db, workspacePath, folderName) {
   const registered = db.select({ id: projects.id }).from(projects).where(eq(projects.workspaceFolderName, folderName)).limit(1).get();
   if (registered) throw svcError13("FOLDER_ALREADY_IMPORTED", 409);
-  const folderDir = join19(workspacePath, folderName);
-  const found = existsSync17(folderDir) ? findClaudeMd(folderDir) : null;
+  const folderDir = join20(workspacePath, folderName);
+  const found = existsSync18(folderDir) ? findClaudeMd(folderDir) : null;
   if (!found) throw svcError13("CLAUDE_MD_MISSING", 404);
-  const repoRoot = found.prefix ? join19(folderDir, found.prefix) : folderDir;
-  const claudeMdRaw = readFileSync12(join19(folderDir, found.relPath), "utf8");
-  const detail = parseProjectDetail(claudeMdRaw);
+  const repoRoot = found.prefix ? join20(folderDir, found.prefix) : folderDir;
+  const claudeMdRaw = readFileSync13(join20(folderDir, found.relPath), "utf8");
+  const detail2 = parseProjectDetail(claudeMdRaw);
   const claudeApps = parseClaudeMdApplications(claudeMdRaw);
   const claudeModules = new Set(parseModuleNames(claudeMdRaw).map((m) => m.name));
   const warnings = [];
-  if (detail.projectName) {
-    const nameTaken = db.select({ id: projects.id }).from(projects).where(eq(projects.name, detail.projectName)).limit(1).get();
+  if (detail2.projectName) {
+    const nameTaken = db.select({ id: projects.id }).from(projects).where(eq(projects.name, detail2.projectName)).limit(1).get();
     if (nameTaken) {
       warnings.push({
         level: "warning",
         code: "DUPLICATE_PROJECT_NAME",
-        message: `A project named "${detail.projectName}" already exists \u2014 rename before importing.`
+        message: `A project named "${detail2.projectName}" already exists \u2014 rename before importing.`
       });
     }
   }
@@ -24229,10 +24776,10 @@ function scanRepo(db, workspacePath, folderName) {
   for (const claude of claudeApps) {
     const name = toKebabCase(claude.heading);
     const resolvedInRoot = resolveAppFolderName(repoRoot, name);
-    const folderExists = existsSync17(join19(repoRoot, resolvedInRoot));
+    const folderExists = existsSync18(join20(repoRoot, resolvedInRoot));
     const folderRel = folderExists ? found.prefix ? `${found.prefix}/${resolvedInRoot}` : resolvedInRoot : null;
-    const appDir = folderRel ? join19(folderDir, folderRel) : null;
-    const prdRaw = appDir ? readIfExists(join19(appDir, "context", "PRD.md")) : null;
+    const appDir = folderRel ? join20(folderDir, folderRel) : null;
+    const prdRaw = appDir ? readIfExists(join20(appDir, "context", "PRD.md")) : null;
     const prdModules = prdRaw ? parsePrdMarkdown(prdRaw) : [];
     const versions = /* @__PURE__ */ new Set();
     for (const m of prdModules) {
@@ -24243,19 +24790,19 @@ function scanRepo(db, workspacePath, folderName) {
     for (const v of versions) semverUnion.add(v);
     const derived = prdRaw ? deriveRequirementIdAppCode(prdRaw, name) : { code: appCodeFromInitials(name), derivedFromIds: false };
     const requirementIdAppCode = claude.requirementIdAppCode ?? derived.code;
-    const bugMdRaw = appDir ? readIfExists(join19(appDir, "context", "BUG.md")) : null;
+    const bugMdRaw = appDir ? readIfExists(join20(appDir, "context", "BUG.md")) : null;
     const bugItems = bugMdRaw ? parseBugMd(bugMdRaw) : [];
-    const bugMasterRaw = appDir ? readIfExists(join19(appDir, "context", "bug", "BUG_MASTER.md")) : null;
+    const bugMasterRaw = appDir ? readIfExists(join20(appDir, "context", "bug", "BUG_MASTER.md")) : null;
     const bugMaster = bugMasterRaw ? parseBugMaster(bugMasterRaw) : /* @__PURE__ */ new Map();
     for (const item of bugItems) if (item.semver) semverUnion.add(item.semver);
     for (const [, m] of bugMaster) if (m.semver) semverUnion.add(m.semver);
-    const preparePath = appDir ? join19(appDir, "context", "prepare", "PREPARE_MASTER.md") : "";
-    const developPath = appDir ? join19(appDir, "context", "develop", "IMPLEMENTATION_MASTER.md") : "";
-    const prepareMasterExists = !!appDir && existsSync17(preparePath);
-    const developMasterExists = !!appDir && existsSync17(developPath);
+    const preparePath = appDir ? join20(appDir, "context", "prepare", "PREPARE_MASTER.md") : "";
+    const developPath = appDir ? join20(appDir, "context", "develop", "IMPLEMENTATION_MASTER.md") : "";
+    const prepareMasterExists = !!appDir && existsSync18(preparePath);
+    const developMasterExists = !!appDir && existsSync18(developPath);
     const prepareCompleted = prepareMasterExists && parseTrackingStatus(preparePath) === "COMPLETED";
     const developCompleted = developMasterExists && parseTrackingStatus(developPath) === "COMPLETED";
-    const changelogRaw = appDir ? readIfExists(join19(appDir, "CHANGELOG.md")) : null;
+    const changelogRaw = appDir ? readIfExists(join20(appDir, "CHANGELOG.md")) : null;
     const changelogEntries = changelogRaw ? parseChangelogConductorEntries(changelogRaw) : [];
     if (!folderRel) {
       warnings.push({
@@ -24337,21 +24884,28 @@ function scanRepo(db, workspacePath, folderName) {
   }
   const versionUnion = [...semverUnion].sort(compareSemver);
   const workflowPhase = anyBugs ? "qa" : anyDevelopCompleted ? "developed" : anyPrepareMaster ? "prepared" : "brainstorm";
-  const environmentMd = readIfExists(join19(repoRoot, "ENVIRONMENT.md")) ?? readIfExists(join19(folderDir, "ENVIRONMENT.md"));
-  const devtoolMd = readIfExists(join19(repoRoot, "DEVTOOL.md")) ?? readIfExists(join19(folderDir, "DEVTOOL.md"));
+  const environmentMd = readIfExists(join20(repoRoot, "ENVIRONMENT.md")) ?? readIfExists(join20(folderDir, "ENVIRONMENT.md"));
+  const devtoolMd = readIfExists(join20(repoRoot, "DEVTOOL.md")) ?? readIfExists(join20(folderDir, "DEVTOOL.md"));
+  const origin = readOriginUrl(folderDir);
+  const gitRemoteUrl = origin ? stripHttpsCredentials(origin) : origin;
+  const defaultBranch = existsSync18(join20(folderDir, ".git")) ? detectTrunkBranch(folderDir, readCurrentBranch(folderDir)) : "main";
+  const gitProvider = /gitlab/i.test(gitRemoteUrl ?? "") ? "gitlab" : "github";
   return {
     folderName,
     sourcePrefix: found.prefix,
     claudeMdRelPath: found.relPath,
     claudeMdRaw,
-    projectName: detail.projectName,
-    projectCode: detail.projectCode,
+    projectName: detail2.projectName,
+    projectCode: detail2.projectCode,
     apps,
     versionUnion,
     currentVersion: versionUnion.at(-1) ?? null,
     workflowPhase,
     environmentMd,
     devtoolMd,
+    gitRemoteUrl,
+    defaultBranch,
+    gitProvider,
     warnings
   };
 }
@@ -24390,11 +24944,11 @@ function scanProject(db, workspacePath, folderName) {
 }
 
 // ../server/src/features/project-import/service.ts
-import { join as join21, relative as relative2 } from "path";
+import { join as join22, relative as relative2 } from "path";
 
 // ../server/src/features/workflow/service.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync9, readFileSync as readFileSync13, writeFileSync as writeFileSync10 } from "fs";
-import { join as join20, relative, resolve as resolve2, sep } from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync9, readFileSync as readFileSync14, writeFileSync as writeFileSync11 } from "fs";
+import { join as join21, relative, resolve as resolve2, sep } from "path";
 var ACTIVE_RUN_STATUSES = ["pending", "in_progress"];
 function svcError14(code, status) {
   return Object.assign(new Error(code), { code, status });
@@ -24536,9 +25090,9 @@ function validateAllAppsPending(db, projectId, applicationIds, conductorType, pr
   const notPending = applicationIds.filter((id) => !pending.has(id));
   if (notPending.length > 0) throw svcError14("APPS_NOT_PENDING", 422);
 }
-function resolveRunTrackingFilePath(projectDir, appName, conductorType) {
+function resolveRunTrackingFilePath(projectDir2, appName, conductorType) {
   const master = TRACKING_FILE_MAP[conductorType] ?? "";
-  return join20(projectDir, resolveAppFolderName(projectDir, appName), master);
+  return join21(projectDir2, resolveAppFolderName(projectDir2, appName), master);
 }
 function buildWorkflowPath(username) {
   const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").replace(/\..+$/, "").replace("T", "-");
@@ -24611,7 +25165,7 @@ function generateWorkflowMarkdown(db, workspacePath, input, creatingUser, watche
   const ver = db.select({ semver: prdVersions.semver }).from(prdVersions).where(eq(prdVersions.id, prdVersionId)).get();
   const semver = ver?.semver ?? "latest";
   const relPath = buildWorkflowPath(creatingUser.username);
-  const projectDir = join20(workspacePath, project.workspaceFolderName);
+  const projectDir2 = join21(workspacePath, project.workspaceFolderName);
   const content = buildWorkflowMarkdown(
     input.conductorType,
     apps.map((a) => a.name),
@@ -24619,8 +25173,8 @@ function generateWorkflowMarkdown(db, workspacePath, input, creatingUser, watche
     project.workspaceFolderName,
     relPath
   );
-  mkdirSync9(join20(projectDir, "workflow", creatingUser.username), { recursive: true });
-  writeFileSync10(join20(projectDir, relPath), content, "utf8");
+  mkdirSync9(join21(projectDir2, "workflow", creatingUser.username), { recursive: true });
+  writeFileSync11(join21(projectDir2, relPath), content, "utf8");
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const wfm = db.insert(workflowMarkdowns).values({
     projectId: input.projectId,
@@ -24636,7 +25190,7 @@ function generateWorkflowMarkdown(db, workspacePath, input, creatingUser, watche
   const runApps = [];
   for (const appId of input.applicationIds) {
     const appName = apps.find((a) => a.id === appId)?.name ?? "";
-    const trackingFilePath = resolveRunTrackingFilePath(projectDir, appName, input.conductorType);
+    const trackingFilePath = resolveRunTrackingFilePath(projectDir2, appName, input.conductorType);
     const run = db.insert(conductorRuns).values({
       projectId: input.projectId,
       applicationId: appId,
@@ -24660,7 +25214,7 @@ function generateWorkflowMarkdown(db, workspacePath, input, creatingUser, watche
     startWatcher(
       db,
       runId,
-      () => resolveRunTrackingFilePath(projectDir, appName, input.conductorType),
+      () => resolveRunTrackingFilePath(projectDir2, appName, input.conductorType),
       creatingUser.id,
       watcherIntervalMs,
       (id, status) => {
@@ -24699,13 +25253,13 @@ function backfillWorkflowHistoryFromChangelogs(db, workspacePath, projectId) {
   if (!project) return 0;
   const apps = db.select({ id: applications.id, name: applications.name }).from(applications).where(and(eq(applications.projectId, projectId), eq(applications.isDeleted, 0))).all();
   if (apps.length === 0) return 0;
-  const projectDir = join20(workspacePath, project.workspaceFolderName);
+  const projectDir2 = join21(workspacePath, project.workspaceFolderName);
   const collected = [];
   for (const app of apps) {
-    const appRel = resolveAppFolderName(projectDir, app.name);
-    const changelogPath = join20(projectDir, appRel, "CHANGELOG.md");
-    if (!existsSync18(changelogPath)) continue;
-    for (const entry of parseChangelogConductorEntries(readFileSync13(changelogPath, "utf8"))) {
+    const appRel = resolveAppFolderName(projectDir2, app.name);
+    const changelogPath = join21(projectDir2, appRel, "CHANGELOG.md");
+    if (!existsSync19(changelogPath)) continue;
+    for (const entry of parseChangelogConductorEntries(readFileSync14(changelogPath, "utf8"))) {
       collected.push({ appName: app.name, appRel, entry });
     }
   }
@@ -24751,7 +25305,7 @@ function getActiveRun(db, projectId, workspacePath) {
 function resumeWatchers(db, workspacePath, projectId, watcherIntervalMs) {
   const project = db.select().from(projects).where(eq(projects.id, projectId)).get();
   if (!project) return;
-  const projectDir = join20(workspacePath, project.workspaceFolderName);
+  const projectDir2 = join21(workspacePath, project.workspaceFolderName);
   const stale = db.select({ run: conductorRuns, appName: applications.name }).from(conductorRuns).innerJoin(applications, eq(applications.id, conductorRuns.applicationId)).where(
     and(
       eq(conductorRuns.projectId, projectId),
@@ -24766,7 +25320,7 @@ function resumeWatchers(db, workspacePath, projectId, watcherIntervalMs) {
       db,
       run.id,
       // [BUG-027] Re-resolve per poll — heals rows persisted with a stale/project-level path.
-      () => resolveRunTrackingFilePath(projectDir, appName, conductorType),
+      () => resolveRunTrackingFilePath(projectDir2, appName, conductorType),
       run.startedBy ?? 1,
       watcherIntervalMs,
       (id, status) => {
@@ -24801,7 +25355,7 @@ function rescanWorkflowRun(db, workspacePath, workflowMarkdownId, watcherInterva
   if (!wfm) throw svcError14("RUN_NOT_FOUND", 404);
   const project = db.select().from(projects).where(eq(projects.id, wfm.projectId)).get();
   if (!project) throw svcError14("PROJECT_NOT_FOUND", 404);
-  const projectDir = join20(workspacePath, project.workspaceFolderName);
+  const projectDir2 = join21(workspacePath, project.workspaceFolderName);
   const runs = db.select({ run: conductorRuns, appName: applications.name }).from(conductorRuns).innerJoin(applications, eq(applications.id, conductorRuns.applicationId)).where(
     and(
       eq(conductorRuns.workflowMarkdownId, workflowMarkdownId),
@@ -24810,7 +25364,7 @@ function rescanWorkflowRun(db, workspacePath, workflowMarkdownId, watcherInterva
   ).all();
   for (const { run, appName } of runs) {
     const conductorType = run.conductorType;
-    const freshPath = resolveRunTrackingFilePath(projectDir, appName, conductorType);
+    const freshPath = resolveRunTrackingFilePath(projectDir2, appName, conductorType);
     if (freshPath !== run.trackingFilePath) {
       db.update(conductorRuns).set({ trackingFilePath: freshPath }).where(eq(conductorRuns.id, run.id)).run();
     }
@@ -24830,7 +25384,7 @@ function rescanWorkflowRun(db, workspacePath, workflowMarkdownId, watcherInterva
       startWatcher(
         db,
         run.id,
-        () => resolveRunTrackingFilePath(projectDir, appName, conductorType),
+        () => resolveRunTrackingFilePath(projectDir2, appName, conductorType),
         run.startedBy ?? 1,
         watcherIntervalMs,
         (id, terminalStatus) => {
@@ -24862,12 +25416,12 @@ function getWorkflowRunFileContent(db, workspacePath, workflowMarkdownId) {
   if (!wfm) throw svcError14("RUN_NOT_FOUND", 404);
   const project = db.select().from(projects).where(eq(projects.id, wfm.projectId)).get();
   if (!project) throw svcError14("PROJECT_NOT_FOUND", 404);
-  const projectDir = resolve2(workspacePath, project.workspaceFolderName);
-  const absolute = resolve2(projectDir, wfm.filePath);
-  if (absolute !== projectDir && !absolute.startsWith(projectDir + sep))
+  const projectDir2 = resolve2(workspacePath, project.workspaceFolderName);
+  const absolute = resolve2(projectDir2, wfm.filePath);
+  if (absolute !== projectDir2 && !absolute.startsWith(projectDir2 + sep))
     throw svcError14("INVALID_PATH", 400);
-  if (!existsSync18(absolute)) throw svcError14("FILE_NOT_FOUND", 404);
-  return { filePath: wfm.filePath, content: readFileSync13(absolute, "utf-8") };
+  if (!existsSync19(absolute)) throw svcError14("FILE_NOT_FOUND", 404);
+  return { filePath: wfm.filePath, content: readFileSync14(absolute, "utf-8") };
 }
 function getRunApplicationChangelog(db, workspacePath, workflowMarkdownId, appName) {
   const wfm = db.select().from(workflowMarkdowns).where(eq(workflowMarkdowns.id, workflowMarkdownId)).get();
@@ -24882,16 +25436,16 @@ function getRunApplicationChangelog(db, workspacePath, workflowMarkdownId, appNa
     runAppNames = appIds.length > 0 ? db.select({ name: applications.name }).from(applications).where(inArray(applications.id, appIds)).all().map((a) => a.name) : [];
   }
   if (!runAppNames.includes(appName)) throw svcError14("APP_NOT_IN_RUN", 404);
-  const projectDir = resolve2(workspacePath, project.workspaceFolderName);
-  const appFolder = resolveAppFolderName(projectDir, appName);
-  const absolute = resolve2(projectDir, appFolder, "CHANGELOG.md");
-  if (absolute !== projectDir && !absolute.startsWith(projectDir + sep))
+  const projectDir2 = resolve2(workspacePath, project.workspaceFolderName);
+  const appFolder = resolveAppFolderName(projectDir2, appName);
+  const absolute = resolve2(projectDir2, appFolder, "CHANGELOG.md");
+  if (absolute !== projectDir2 && !absolute.startsWith(projectDir2 + sep))
     throw svcError14("INVALID_PATH", 400);
-  if (!existsSync18(absolute)) throw svcError14("CHANGELOG_NOT_FOUND", 404);
+  if (!existsSync19(absolute)) throw svcError14("CHANGELOG_NOT_FOUND", 404);
   return {
     applicationName: appName,
     filePath: relative(workspacePath, absolute).replace(/\\/g, "/"),
-    content: readFileSync13(absolute, "utf-8")
+    content: readFileSync14(absolute, "utf-8")
   };
 }
 function toDetail(db, projectFolder, wfm, workspacePath) {
@@ -24926,20 +25480,20 @@ function toDetail(db, projectFolder, wfm, workspacePath) {
   const appNames = appRows.map((a) => a.name);
   let appBreakdown;
   if (workspacePath) {
-    const projectDir = join20(workspacePath, projectFolder);
+    const projectDir2 = join21(workspacePath, projectFolder);
     appBreakdown = runs.map((r) => {
       const appName = nameOf.get(r.applicationId) ?? `app #${r.applicationId}`;
-      const trackingPath = resolveRunTrackingFilePath(projectDir, appName, r.conductorType);
+      const trackingPath = resolveRunTrackingFilePath(projectDir2, appName, r.conductorType);
       return {
         applicationName: appName,
         status: r.status,
-        trackingFileExists: existsSync18(trackingPath),
+        trackingFileExists: existsSync19(trackingPath),
         trackingFilePath: relative(workspacePath, trackingPath).replace(/\\/g, "/")
       };
     });
   }
   const completedAt = runs.every((r) => r.completedAt) ? runs.map((r) => r.completedAt).sort().at(-1) ?? null : null;
-  const git3 = runs.find((r) => r.gitOperationStatus && r.gitOperationStatus !== "not_started");
+  const git4 = runs.find((r) => r.gitOperationStatus && r.gitOperationStatus !== "not_started");
   return {
     id: wfm.id,
     conductorType: wfm.conductorType,
@@ -24949,9 +25503,9 @@ function toDetail(db, projectFolder, wfm, workspacePath) {
     filePath: wfm.filePath,
     executeCommand: buildExecuteCommand(projectFolder, wfm.filePath),
     versionLabel: wfm.versionLabel,
-    gitOperationStatus: git3?.gitOperationStatus ?? "not_started",
-    gitBranchCreated: git3?.gitBranchCreated ?? null,
-    gitCommitHash: git3?.gitCommitHash ?? null,
+    gitOperationStatus: git4?.gitOperationStatus ?? "not_started",
+    gitBranchCreated: git4?.gitBranchCreated ?? null,
+    gitCommitHash: git4?.gitCommitHash ?? null,
     completedAt,
     createdAt: wfm.createdAt
   };
@@ -24972,7 +25526,7 @@ function importProject(db, workspacePath, input, userId) {
   const nameTaken = db.select({ id: projects.id }).from(projects).where(eq(projects.name, name)).limit(1).get();
   if (nameTaken) throw svcError15("PROJECT_EXISTS", 409);
   const items = [];
-  const report = (entity, action, label, detail) => items.push({ entity, action, label, ...detail ? { detail } : {} });
+  const report = (entity, action, label, detail2) => items.push({ entity, action, label, ...detail2 ? { detail: detail2 } : {} });
   const projectId = db.transaction((rawTx) => {
     const tx = rawTx;
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -24985,6 +25539,9 @@ function importProject(db, workspacePath, input, userId) {
       // bypasses the lazy brainstorm-rescan path
       workflowPhase: scan.workflowPhase,
       rawClaudeMd: scan.claudeMdRaw,
+      gitRemoteUrl: scan.gitRemoteUrl ?? null,
+      defaultBranch: scan.defaultBranch,
+      gitProvider: scan.gitProvider,
       importedAt: now,
       importedBy: userId,
       createdBy: userId,
@@ -25068,7 +25625,7 @@ function importProject(db, workspacePath, input, userId) {
       snapshotPrdContent: JSON.stringify(prdSnapshot),
       snapshotBugContent: JSON.stringify(bugSnapshot)
     }).where(eq(prdVersions.id, current.id)).run();
-    const projectDir = join21(workspacePath, input.folderName);
+    const projectDir2 = join22(workspacePath, input.folderName);
     for (const app of scan.apps) {
       const appId = appIdByName.get(app.name);
       const hasContextArtifacts = app.artifactCounts.erd + app.artifactCounts.data_model + app.artifactCounts.mockup + app.artifactCounts.technical_spec + app.artifactCounts.test_spec > 0;
@@ -25085,8 +25642,8 @@ function importProject(db, workspacePath, input, userId) {
       const trackingPathFor = (type) => toPosix(
         relative2(
           workspacePath,
-          join21(
-            projectDir,
+          join22(
+            projectDir2,
             app.folderRel,
             type === "prepare" ? "context/prepare/PREPARE_MASTER.md" : type === "develop" ? "context/develop/IMPLEMENTATION_MASTER.md" : "context/bug/BUG_MASTER.md"
           )
@@ -25311,7 +25868,7 @@ ${item.body}`.match(REQUIREMENT_ID)?.[0] ?? null;
 }
 
 // ../server/src/features/project-import/routes.ts
-function errorResponse9(c, e) {
+function errorResponse10(c, e) {
   const err = e;
   const status = err.status ?? 500;
   return c.json({ code: err.code ?? "INTERNAL_ERROR" }, status);
@@ -25322,14 +25879,14 @@ function projectImportRoutes(db, workspacePath) {
     try {
       return c.json(listImportCandidates(db, workspacePath));
     } catch (e) {
-      return errorResponse9(c, e);
+      return errorResponse10(c, e);
     }
   });
   app.post("/scan", requireRole("admin"), zValidator("json", scanImportRequestSchema), (c) => {
     try {
       return c.json(scanProject(db, workspacePath, c.req.valid("json").folderName));
     } catch (e) {
-      return errorResponse9(c, e);
+      return errorResponse10(c, e);
     }
   });
   app.post("/", requireRole("admin"), zValidator("json", runImportRequestSchema), (c) => {
@@ -25337,14 +25894,14 @@ function projectImportRoutes(db, workspacePath) {
     try {
       return c.json(importProject(db, workspacePath, c.req.valid("json"), user.id), 201);
     } catch (e) {
-      return errorResponse9(c, e);
+      return errorResponse10(c, e);
     }
   });
   return app;
 }
 
 // ../server/src/features/project/routes.ts
-function errorResponse10(c, e) {
+function errorResponse11(c, e) {
   const err = e;
   const status = err.status ?? 500;
   return c.json({ code: err.code ?? "INTERNAL_ERROR" }, status);
@@ -25362,7 +25919,7 @@ function projectRoutes(db, workspacePath) {
       const id = createProject(db, workspacePath, name, code, baseIdea, user.id);
       return c.json({ id }, 201);
     } catch (e) {
-      return errorResponse10(c, e);
+      return errorResponse11(c, e);
     }
   });
   app.get("/:id/detail", (c) => {
@@ -25371,7 +25928,7 @@ function projectRoutes(db, workspacePath) {
     try {
       return c.json(getProjectDetailSummary(db, id));
     } catch (e) {
-      return errorResponse10(c, e);
+      return errorResponse11(c, e);
     }
   });
   app.post("/:id/scaffold", requireRole("admin"), (c) => {
@@ -25381,7 +25938,7 @@ function projectRoutes(db, workspacePath) {
       scaffoldProject(db, workspacePath, id);
       return c.json({ ok: true });
     } catch (e) {
-      return errorResponse10(c, e);
+      return errorResponse11(c, e);
     }
   });
   app.get("/:id/brainstorm-md", (c) => {
@@ -25390,7 +25947,7 @@ function projectRoutes(db, workspacePath) {
     try {
       return c.json(getBrainstormMd(db, workspacePath, id));
     } catch (e) {
-      return errorResponse10(c, e);
+      return errorResponse11(c, e);
     }
   });
   app.patch("/:id/brainstorm-md", zValidator("json", updateBrainstormMdSchema), (c) => {
@@ -25400,7 +25957,7 @@ function projectRoutes(db, workspacePath) {
       updateBrainstormMd(db, workspacePath, id, c.req.valid("json").content);
       return c.json({ ok: true });
     } catch (e) {
-      return errorResponse10(c, e);
+      return errorResponse11(c, e);
     }
   });
   app.get("/:id", (c) => {
@@ -25409,7 +25966,7 @@ function projectRoutes(db, workspacePath) {
     try {
       return c.json(getProjectDetail(db, workspacePath, id));
     } catch (e) {
-      return errorResponse10(c, e);
+      return errorResponse11(c, e);
     }
   });
   app.post("/:id/regenerate", (c) => {
@@ -25419,7 +25976,7 @@ function projectRoutes(db, workspacePath) {
       regenerateCO2Files(db, workspacePath, id);
       return c.json({ ok: true });
     } catch (e) {
-      return errorResponse10(c, e);
+      return errorResponse11(c, e);
     }
   });
   app.post("/:id/rescan-claude-md", (c) => {
@@ -25429,7 +25986,7 @@ function projectRoutes(db, workspacePath) {
       const imported = rescanClaudeMd(db, workspacePath, id);
       return c.json({ ok: true, imported });
     } catch (e) {
-      return errorResponse10(c, e);
+      return errorResponse11(c, e);
     }
   });
   app.patch("/:id/archive", requireRole("admin"), (c) => {
@@ -25440,15 +25997,29 @@ function projectRoutes(db, workspacePath) {
       archiveProject(db, id, user.id);
       return c.json({ ok: true });
     } catch (e) {
-      return errorResponse10(c, e);
+      return errorResponse11(c, e);
+    }
+  });
+  app.patch("/:id", zValidator("json", updateProjectGitRemoteSchema), (c) => {
+    const id = Number(c.req.param("id"));
+    if (Number.isNaN(id)) return c.json({ code: "INVALID_ID" }, 400);
+    try {
+      const body = c.req.valid("json");
+      updateProjectGitRemote(db, id, body.gitRemoteUrl, {
+        defaultBranch: body.defaultBranch,
+        gitProvider: body.gitProvider
+      });
+      return c.json({ ok: true });
+    } catch (e) {
+      return errorResponse11(c, e);
     }
   });
   return app;
 }
 
 // ../server/src/features/shared-context/service.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync10, readFileSync as readFileSync14, readdirSync as readdirSync4, statSync as statSync6, writeFileSync as writeFileSync11 } from "fs";
-import { join as join22, resolve as resolve3, sep as sep2 } from "path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync10, readFileSync as readFileSync15, readdirSync as readdirSync4, statSync as statSync6, writeFileSync as writeFileSync12 } from "fs";
+import { join as join23, resolve as resolve3, sep as sep2 } from "path";
 function svcError16(code, status) {
   return Object.assign(new Error(code), { code, status });
 }
@@ -25474,7 +26045,7 @@ function mimeForName(name) {
 function resolveSharedRoot(db, workspacePath, projectId) {
   const project = db.select().from(projects).where(eq(projects.id, projectId)).limit(1).get();
   if (!project) throw svcError16("NOT_FOUND", 404);
-  const root = join22(workspacePath, project.workspaceFolderName, "shared_context");
+  const root = join23(workspacePath, project.workspaceFolderName, "shared_context");
   mkdirSync10(root, { recursive: true });
   return root;
 }
@@ -25488,9 +26059,9 @@ function safeResolve(root, relPath) {
   return full;
 }
 function sanitizeSegment(name) {
-  const safe = name.replace(/[^a-zA-Z0-9._-]/g, "_");
-  if (!safe || safe === "." || safe === "..") throw svcError16("INVALID_NAME", 400);
-  return safe;
+  const safe2 = name.replace(/[^a-zA-Z0-9._-]/g, "_");
+  if (!safe2 || safe2 === "." || safe2 === "..") throw svcError16("INVALID_NAME", 400);
+  return safe2;
 }
 function walk(dir, relBase) {
   const entries = readdirSync4(dir, { withFileTypes: true });
@@ -25502,10 +26073,10 @@ function walk(dir, relBase) {
         name: entry.name,
         path: rel,
         type: "folder",
-        children: walk(join22(dir, entry.name), rel)
+        children: walk(join23(dir, entry.name), rel)
       });
     } else if (entry.isFile()) {
-      const stat = statSync6(join22(dir, entry.name));
+      const stat = statSync6(join23(dir, entry.name));
       nodes.push({
         name: entry.name,
         path: rel,
@@ -25536,28 +26107,28 @@ function uploadFile(db, workspacePath, projectId, folder, file) {
   if (file.bytes.length > MAX_DOCUMENT_BYTES) throw svcError16("FILE_TOO_LARGE", 413);
   const root = resolveSharedRoot(db, workspacePath, projectId);
   const dir = folder ? safeResolve(root, folder) : root;
-  if (folder && !existsSync19(dir)) throw svcError16("FOLDER_NOT_FOUND", 404);
+  if (folder && !existsSync20(dir)) throw svcError16("FOLDER_NOT_FOUND", 404);
   const safeName = sanitizeSegment(file.name);
-  writeFileSync11(join22(dir, safeName), file.bytes);
+  writeFileSync12(join23(dir, safeName), file.bytes);
   return { path: folder ? `${folder}/${safeName}` : safeName };
 }
 function getFileContent(db, workspacePath, projectId, relPath) {
   const root = resolveSharedRoot(db, workspacePath, projectId);
   const full = safeResolve(root, relPath);
-  if (!existsSync19(full) || !statSync6(full).isFile()) throw svcError16("NOT_FOUND", 404);
+  if (!existsSync20(full) || !statSync6(full).isFile()) throw svcError16("NOT_FOUND", 404);
   const name = relPath.split("/").pop() ?? relPath;
-  return { mimeType: mimeForName(name), bytes: readFileSync14(full), name };
+  return { mimeType: mimeForName(name), bytes: readFileSync15(full), name };
 }
 function saveMarkdown(db, workspacePath, projectId, relPath, content) {
   if (mimeForName(relPath) !== "text/markdown") throw svcError16("NOT_MARKDOWN", 400);
   const root = resolveSharedRoot(db, workspacePath, projectId);
   const full = safeResolve(root, relPath);
-  if (!existsSync19(full) || !statSync6(full).isFile()) throw svcError16("NOT_FOUND", 404);
-  writeFileSync11(full, content, "utf8");
+  if (!existsSync20(full) || !statSync6(full).isFile()) throw svcError16("NOT_FOUND", 404);
+  writeFileSync12(full, content, "utf8");
 }
 
 // ../server/src/features/shared-context/routes.ts
-function errorResponse11(c, e) {
+function errorResponse12(c, e) {
   const err = e;
   const status = err.status ?? 500;
   return c.json({ code: err.code ?? "INTERNAL_ERROR" }, status);
@@ -25573,7 +26144,7 @@ function sharedContextRoutes(db, workspacePath) {
     try {
       return c.json({ tree: listTree(db, workspacePath, projectId) });
     } catch (e) {
-      return errorResponse11(c, e);
+      return errorResponse12(c, e);
     }
   });
   app.post("/:projectId/folders", async (c) => {
@@ -25584,7 +26155,7 @@ function sharedContextRoutes(db, workspacePath) {
     try {
       return c.json({ path: createFolder(db, workspacePath, projectId, body.path) });
     } catch (e) {
-      return errorResponse11(c, e);
+      return errorResponse12(c, e);
     }
   });
   app.post("/:projectId/upload", async (c) => {
@@ -25599,7 +26170,7 @@ function sharedContextRoutes(db, workspacePath) {
       const { path } = uploadFile(db, workspacePath, projectId, folder, { name: file.name, bytes });
       return c.json({ path });
     } catch (e) {
-      return errorResponse11(c, e);
+      return errorResponse12(c, e);
     }
   });
   app.get("/:projectId/content", (c) => {
@@ -25618,7 +26189,7 @@ function sharedContextRoutes(db, workspacePath) {
         }
       });
     } catch (e) {
-      return errorResponse11(c, e);
+      return errorResponse12(c, e);
     }
   });
   app.put("/:projectId/content", async (c) => {
@@ -25632,7 +26203,7 @@ function sharedContextRoutes(db, workspacePath) {
       saveMarkdown(db, workspacePath, projectId, body.path, body.content);
       return c.json({ ok: true });
     } catch (e) {
-      return errorResponse11(c, e);
+      return errorResponse12(c, e);
     }
   });
   return app;
@@ -25697,8 +26268,8 @@ function svcError17(code, status) {
   return Object.assign(new Error(code), { code, status });
 }
 function toSafe(user) {
-  const { passwordHash: _omit, ...safe } = user;
-  return safe;
+  const { passwordHash: _omit, ...safe2 } = user;
+  return safe2;
 }
 function loginUser(db, input, clientIp) {
   const rateLimitKey = `${input.username}:${clientIp}`;
@@ -25775,8 +26346,8 @@ function getUserDetail(db, id) {
     const admin = db.select({ displayName: users.displayName }).from(users).where(eq(users.id, user.reactivatedBy)).limit(1).get();
     reactivatedByName = admin?.displayName ?? null;
   }
-  const { passwordHash: _omit, ...safe } = user;
-  return { ...safe, reactivatedByName };
+  const { passwordHash: _omit, ...safe2 } = user;
+  return { ...safe2, reactivatedByName };
 }
 function adminUpdateUser(db, targetId, input) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -25837,7 +26408,7 @@ function listAssignments(db, userId) {
 
 // ../server/src/features/user/auth-routes.ts
 var SESSION_MAX_AGE = 30 * 24 * 60 * 60;
-function errorResponse12(c, e) {
+function errorResponse13(c, e) {
   const err = e;
   const status = err.status ?? 500;
   return c.json({ code: err.code ?? "INTERNAL_ERROR" }, status);
@@ -25858,7 +26429,7 @@ function authRoutes(db) {
       });
       return c.json({ mustChangePassword });
     } catch (e) {
-      return errorResponse12(c, e);
+      return errorResponse13(c, e);
     }
   });
   app.post("/logout", (c) => {
@@ -25882,14 +26453,14 @@ function authRoutes(db) {
       });
       return c.json({ ok: true });
     } catch (e) {
-      return errorResponse12(c, e);
+      return errorResponse13(c, e);
     }
   });
   app.get("/me", (c) => {
     const user = c.get("user");
     if (!user) return c.json({ code: "UNAUTHORIZED" }, 401);
-    const { passwordHash: _omit, ...safe } = user;
-    return c.json(safe);
+    const { passwordHash: _omit, ...safe2 } = user;
+    return c.json(safe2);
   });
   app.patch("/me", zValidator("json", updateProfileSchema), (c) => {
     const user = c.get("user");
@@ -25901,7 +26472,7 @@ function authRoutes(db) {
 }
 
 // ../server/src/features/user/routes.ts
-function errorResponse13(c, e) {
+function errorResponse14(c, e) {
   const err = e;
   const status = err.status ?? 500;
   return c.json({ code: err.code ?? "INTERNAL_ERROR" }, status);
@@ -25915,7 +26486,7 @@ function userRoutes(db) {
       const id = createUser(db, c.req.valid("json"));
       return c.json({ id }, 201);
     } catch (e) {
-      return errorResponse13(c, e);
+      return errorResponse14(c, e);
     }
   });
   app.get("/:id", requireRole("admin"), (c) => {
@@ -25939,7 +26510,7 @@ function userRoutes(db) {
       deactivateUser(db, id, admin.id);
       return c.json({ ok: true });
     } catch (e) {
-      return errorResponse13(c, e);
+      return errorResponse14(c, e);
     }
   });
   app.patch(
@@ -25961,7 +26532,7 @@ function userRoutes(db) {
       reactivateUser(db, id, admin.id);
       return c.json({ ok: true });
     } catch (e) {
-      return errorResponse13(c, e);
+      return errorResponse14(c, e);
     }
   });
   app.get("/:id/project-assignments", requireRole("admin"), (c) => {
@@ -25981,7 +26552,7 @@ function userRoutes(db) {
         const assignmentId = assignProject(db, id, c.req.valid("json").projectId, admin.id);
         return c.json({ id: assignmentId }, 201);
       } catch (e) {
-        return errorResponse13(c, e);
+        return errorResponse14(c, e);
       }
     }
   );
@@ -25996,7 +26567,7 @@ function userRoutes(db) {
 }
 
 // ../server/src/features/version/routes.ts
-function errorResponse14(c, e) {
+function errorResponse15(c, e) {
   const err = e;
   const status = err.status ?? 500;
   const message = e instanceof Error && err.code ? e.message : void 0;
@@ -26011,7 +26582,7 @@ function versionRoutes(db, workspacePath) {
     try {
       return c.json(listVersions(db, projectId, user.id));
     } catch (e) {
-      return errorResponse14(c, e);
+      return errorResponse15(c, e);
     }
   });
   app.get("/:projectId/current", (c) => {
@@ -26021,7 +26592,7 @@ function versionRoutes(db, workspacePath) {
     try {
       return c.json(getCurrentVersion(db, projectId, user.id));
     } catch (e) {
-      return errorResponse14(c, e);
+      return errorResponse15(c, e);
     }
   });
   app.get("/:projectId/can-add", (c) => {
@@ -26037,14 +26608,14 @@ function versionRoutes(db, workspacePath) {
       const result = addVersion(db, projectId, c.req.valid("json").versionType, user.id, workspacePath);
       return c.json(result);
     } catch (e) {
-      return errorResponse14(c, e);
+      return errorResponse15(c, e);
     }
   });
   return app;
 }
 
 // ../server/src/features/workflow/routes.ts
-function errorResponse15(c, e) {
+function errorResponse16(c, e) {
   const err = e;
   const status = err.status ?? 500;
   return c.json({ code: err.code ?? "INTERNAL_ERROR" }, status);
@@ -26056,7 +26627,7 @@ function workflowRoutes(db, workspacePath) {
     try {
       return c.json(getPendingApps(db, projectId, conductorType, versionId));
     } catch (e) {
-      return errorResponse15(c, e);
+      return errorResponse16(c, e);
     }
   });
   app.get("/phase-completion", zValidator("query", pendingAppsQuerySchema), (c) => {
@@ -26064,7 +26635,7 @@ function workflowRoutes(db, workspacePath) {
     try {
       return c.json(getPhaseCompletion(db, projectId, conductorType, versionId));
     } catch (e) {
-      return errorResponse15(c, e);
+      return errorResponse16(c, e);
     }
   });
   app.get("/runs", (c) => {
@@ -26075,7 +26646,7 @@ function workflowRoutes(db, workspacePath) {
       resumeWatchers(db, workspacePath, projectId);
       return c.json(listWorkflowRuns(db, projectId));
     } catch (e) {
-      return errorResponse15(c, e);
+      return errorResponse16(c, e);
     }
   });
   app.get("/active-run", (c) => {
@@ -26085,7 +26656,7 @@ function workflowRoutes(db, workspacePath) {
       resumeWatchers(db, workspacePath, projectId);
       return c.json(getActiveRun(db, projectId, workspacePath));
     } catch (e) {
-      return errorResponse15(c, e);
+      return errorResponse16(c, e);
     }
   });
   app.get("/runs/:id", (c) => {
@@ -26094,7 +26665,7 @@ function workflowRoutes(db, workspacePath) {
     try {
       return c.json(getWorkflowRun(db, id, workspacePath));
     } catch (e) {
-      return errorResponse15(c, e);
+      return errorResponse16(c, e);
     }
   });
   app.get("/runs/:id/file-content", (c) => {
@@ -26103,7 +26674,7 @@ function workflowRoutes(db, workspacePath) {
     try {
       return c.json(getWorkflowRunFileContent(db, workspacePath, id));
     } catch (e) {
-      return errorResponse15(c, e);
+      return errorResponse16(c, e);
     }
   });
   app.get("/runs/:id/changelog", (c) => {
@@ -26114,7 +26685,7 @@ function workflowRoutes(db, workspacePath) {
     try {
       return c.json(getRunApplicationChangelog(db, workspacePath, id, appName));
     } catch (e) {
-      return errorResponse15(c, e);
+      return errorResponse16(c, e);
     }
   });
   app.post("/runs/:id/force-stop", (c) => {
@@ -26124,7 +26695,7 @@ function workflowRoutes(db, workspacePath) {
       forceStopWorkflowRun(db, id);
       return c.json({ ok: true });
     } catch (e) {
-      return errorResponse15(c, e);
+      return errorResponse16(c, e);
     }
   });
   app.post("/runs/:id/rescan", (c) => {
@@ -26133,7 +26704,7 @@ function workflowRoutes(db, workspacePath) {
     try {
       return c.json(rescanWorkflowRun(db, workspacePath, id));
     } catch (e) {
-      return errorResponse15(c, e);
+      return errorResponse16(c, e);
     }
   });
   app.post("/runs", zValidator("json", createWorkflowSchema), (c) => {
@@ -26145,7 +26716,7 @@ function workflowRoutes(db, workspacePath) {
       });
       return c.json(result, 201);
     } catch (e) {
-      return errorResponse15(c, e);
+      return errorResponse16(c, e);
     }
   });
   return app;
@@ -26285,11 +26856,11 @@ function closeTerminalSessions(projectId, reason) {
 }
 function buildPtyLaunch(workspacePath, folderName) {
   const isWindows = process.platform === "win32";
-  const join29 = (a, b) => `${a.replace(/[\\/]+$/, "")}/${b}`;
+  const join30 = (a, b) => `${a.replace(/[\\/]+$/, "")}/${b}`;
   return {
     shell: isWindows ? "powershell.exe" : process.env["SHELL"] ?? "bash",
     args: [],
-    cwd: join29(workspacePath, folderName),
+    cwd: join30(workspacePath, folderName),
     autoCommand: `${CLAUDE_COMMAND}\r`
   };
 }
@@ -26466,16 +27037,16 @@ function terminalRoutes(db) {
 import { execSync } from "child_process";
 
 // ../server/src/lib/claude-plugin.ts
-import { existsSync as existsSync20, readFileSync as readFileSync15, readdirSync as readdirSync5 } from "fs";
+import { existsSync as existsSync21, readFileSync as readFileSync16, readdirSync as readdirSync5 } from "fs";
 import { homedir } from "os";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 var PLUGIN_NAME = "co2-skills";
-function detectCo2SkillsPlugin(claudeDir = join23(homedir(), ".claude")) {
+function detectCo2SkillsPlugin(claudeDir = join24(homedir(), ".claude")) {
   return readRegistry(claudeDir) ?? readCacheDir(claudeDir);
 }
 function readRegistry(claudeDir) {
   try {
-    const raw2 = readFileSync15(join23(claudeDir, "plugins", "installed_plugins.json"), "utf8");
+    const raw2 = readFileSync16(join24(claudeDir, "plugins", "installed_plugins.json"), "utf8");
     const json = JSON.parse(raw2);
     for (const [key, entries] of Object.entries(json.plugins ?? {})) {
       if (!key.startsWith(`${PLUGIN_NAME}@`)) continue;
@@ -26488,8 +27059,8 @@ function readRegistry(claudeDir) {
   }
 }
 function readCacheDir(claudeDir) {
-  const base = join23(claudeDir, "plugins", "cache", "co2", PLUGIN_NAME);
-  if (!existsSync20(base)) return { installed: false };
+  const base = join24(claudeDir, "plugins", "cache", "co2", PLUGIN_NAME);
+  if (!existsSync21(base)) return { installed: false };
   try {
     const versions = readdirSync5(base).filter((d) => /^\d+\.\d+/.test(d)).sort();
     return { installed: true, version: versions.at(-1) };
@@ -26543,8 +27114,8 @@ function workspaceRoutes(_db, config, port, host, workspacePath) {
 }
 
 // ../server/src/lib/config.ts
-import { existsSync as existsSync21, readFileSync as readFileSync16, writeFileSync as writeFileSync12 } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync22, readFileSync as readFileSync17, writeFileSync as writeFileSync13 } from "fs";
+import { join as join25 } from "path";
 var configSchema = external_exports.object({
   port: external_exports.number().int().min(1).max(65535).optional(),
   host: external_exports.string().optional(),
@@ -26552,16 +27123,16 @@ var configSchema = external_exports.object({
   provisioningState: external_exports.enum(["pending", "complete"]).optional()
 });
 function loadConfig(dataDir) {
-  const file = join24(dataDir, "config.json");
-  if (!existsSync21(file)) return {};
+  const file = join25(dataDir, "config.json");
+  if (!existsSync22(file)) return {};
   try {
-    return configSchema.parse(JSON.parse(readFileSync16(file, "utf8")));
+    return configSchema.parse(JSON.parse(readFileSync17(file, "utf8")));
   } catch {
     return {};
   }
 }
 function saveConfig(dataDir, config) {
-  writeFileSync12(join24(dataDir, "config.json"), JSON.stringify(config, null, 2));
+  writeFileSync13(join25(dataDir, "config.json"), JSON.stringify(config, null, 2));
 }
 
 // ../server/src/lib/logger.ts
@@ -26589,8 +27160,8 @@ function loggerMiddleware() {
 }
 
 // ../server/src/lib/static.ts
-import { existsSync as existsSync22, readFileSync as readFileSync17, statSync as statSync7 } from "fs";
-import { extname, join as join25, normalize, resolve as resolve4, sep as sep3 } from "path";
+import { existsSync as existsSync23, readFileSync as readFileSync18, statSync as statSync7 } from "fs";
+import { extname, join as join26, normalize, resolve as resolve4, sep as sep3 } from "path";
 var MIME = {
   ".html": "text/html; charset=utf-8",
   ".js": "text/javascript; charset=utf-8",
@@ -26614,7 +27185,7 @@ function safeResolve2(rootDir, relPath) {
   return target;
 }
 function serveSpa(staticDir) {
-  const indexPath = join25(staticDir, "index.html");
+  const indexPath = join26(staticDir, "index.html");
   return async (c, next) => {
     if (c.req.method !== "GET" && c.req.method !== "HEAD") {
       await next();
@@ -26627,14 +27198,14 @@ function serveSpa(staticDir) {
     }
     const rel = path === "/" ? "/index.html" : decodeURIComponent(path);
     const filePath = safeResolve2(staticDir, rel);
-    if (filePath && existsSync22(filePath) && statSync7(filePath).isFile()) {
-      const body = readFileSync17(filePath);
+    if (filePath && existsSync23(filePath) && statSync7(filePath).isFile()) {
+      const body = readFileSync18(filePath);
       return c.body(body, 200, {
         "Content-Type": MIME[extname(filePath)] ?? "application/octet-stream"
       });
     }
-    if (existsSync22(indexPath)) {
-      return c.body(readFileSync17(indexPath), 200, { "Content-Type": "text/html; charset=utf-8" });
+    if (existsSync23(indexPath)) {
+      return c.body(readFileSync18(indexPath), 200, { "Content-Type": "text/html; charset=utf-8" });
     }
     await next();
   };
@@ -26678,6 +27249,7 @@ function createApp(db, opts) {
   api.route("/defects", defects);
   api.route("/quality", defects);
   api.route("/dashboard", dashboardRoutes(db));
+  api.route("/git", gitRoutes(db, opts.workspacePath));
   app.route("/api", api);
   if (opts.staticDir) {
     app.use("*", serveSpa(opts.staticDir));
@@ -26686,8 +27258,8 @@ function createApp(db, opts) {
 }
 
 // ../server/src/db/index.ts
-import { existsSync as existsSync23 } from "fs";
-import { dirname as dirname2, join as join26 } from "path";
+import { existsSync as existsSync24 } from "fs";
+import { dirname as dirname2, join as join27 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import Database from "better-sqlite3";
 
@@ -26891,16 +27463,16 @@ function resolveMigrationsFolder() {
   const here = dirname2(fileURLToPath2(import.meta.url));
   const candidates = [
     process.env["CO2_CLI_MIGRATIONS_DIR"],
-    join26(here, "../../drizzle"),
+    join27(here, "../../drizzle"),
     // source: src/db -> packages/server/drizzle
-    join26(here, "../drizzle"),
+    join27(here, "../drizzle"),
     // bundled: cli/dist -> cli/drizzle
-    join26(here, "drizzle")
+    join27(here, "drizzle")
   ].filter((c) => Boolean(c));
   for (const c of candidates) {
-    if (existsSync23(join26(c, "meta", "_journal.json"))) return c;
+    if (existsSync24(join27(c, "meta", "_journal.json"))) return c;
   }
-  return join26(here, "../../drizzle");
+  return join27(here, "../../drizzle");
 }
 function openDb(dbPath, migrationsFolder = resolveMigrationsFolder()) {
   const sqlite = new Database(dbPath);
@@ -26934,7 +27506,7 @@ function bootstrap(db) {
 // ../server/src/lib/data-dir.ts
 import { mkdirSync as mkdirSync11 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 function resolveDataDir(override) {
   const dir = override ?? defaultDataDir();
   mkdirSync11(dir, { recursive: true, mode: 448 });
@@ -26943,11 +27515,11 @@ function resolveDataDir(override) {
 function defaultDataDir() {
   switch (process.platform) {
     case "darwin":
-      return join27(homedir2(), "Library", "Application Support", "co2-cli");
+      return join28(homedir2(), "Library", "Application Support", "co2-cli");
     case "win32":
-      return join27(process.env["LOCALAPPDATA"] ?? join27(homedir2(), "AppData", "Local"), "co2-cli");
+      return join28(process.env["LOCALAPPDATA"] ?? join28(homedir2(), "AppData", "Local"), "co2-cli");
     default:
-      return join27(process.env["XDG_DATA_HOME"] ?? join27(homedir2(), ".local", "share"), "co2-cli");
+      return join28(process.env["XDG_DATA_HOME"] ?? join28(homedir2(), ".local", "share"), "co2-cli");
   }
 }
 
@@ -27601,8 +28173,8 @@ var startOptionsSchema = external_exports.object({
   workspacePath: external_exports.string().optional()
 });
 function resolveStaticDir() {
-  const dir = join28(dirname3(fileURLToPath3(import.meta.url)), "../static");
-  return existsSync24(join28(dir, "index.html")) ? dir : void 0;
+  const dir = join29(dirname3(fileURLToPath3(import.meta.url)), "../static");
+  return existsSync25(join29(dir, "index.html")) ? dir : void 0;
 }
 function registerStart(program3, version2) {
   program3.command("start").description("Start the co2-cli web application (foreground)").option("-p, --port <n>", "Listen port (default: 3001)").option("-H, --host <addr>", "Listen host (default: 0.0.0.0 for LAN access)").option("-d, --data-dir <path>", "Override the data directory").option("-w, --workspace-path <path>", "Override the Workspace root folder").action(async (rawOpts) => {
@@ -27611,11 +28183,11 @@ function registerStart(program3, version2) {
     const config = loadConfig(dataDir);
     const port = opts.port ?? (process.env["APP_PORT"] ? Number(process.env["APP_PORT"]) : void 0) ?? config.port ?? 3001;
     const host = opts.host ?? process.env["APP_HOST"] ?? config.host ?? "0.0.0.0";
-    const workspacePath = opts.workspacePath ?? process.env["APP_WORKSPACE_PATH"] ?? config.workspacePath ?? join28(process.env["HOME"] ?? process.env["USERPROFILE"] ?? ".", "workspace");
+    const workspacePath = opts.workspacePath ?? process.env["APP_WORKSPACE_PATH"] ?? config.workspacePath ?? join29(process.env["HOME"] ?? process.env["USERPROFILE"] ?? ".", "workspace");
     if (opts.port !== void 0 || opts.workspacePath !== void 0) {
       saveConfig(dataDir, { ...config, port, workspacePath });
     }
-    const db = openDb(join28(dataDir, "app.db"));
+    const db = openDb(join29(dataDir, "app.db"));
     const credentials = bootstrap(db);
     const app = createApp(db, {
       dataDir,