create-interview-cockpit 0.20.0 → 0.22.0

package/template/server/src/index.ts

@@ -162,6 +162,103 @@ function makeCodeReferenceFileEntry(
   return { label, originalName: label, reader };
 }
 
+interface GitDiffContextPayload {
+  baseRef?: string;
+  headRef?: string;
+  mode?: string;
+  selectedFiles?: string[];
+}
+
+// Register lazily-fetched git diff entries on the model's file registry and
+// append a short manifest line to the system prompt. Full patches / blobs are
+// only pulled when the model calls readFile with a gitdiff:* id.
+async function registerGitDiffContext(
+  fileRegistry: Map<string, ReferenceFileEntry>,
+  ctx: GitDiffContextPayload,
+): Promise<string> {
+  if (!GIT_DIFF_DIR) return "";
+  const base = (ctx.baseRef || "").trim();
+  if (!base || !isValidRef(base)) return "";
+  const mode = parseDiffMode(ctx.mode);
+  const headRaw = (ctx.headRef || "").trim();
+  const head = mode === "working-tree" ? WORKING_TREE_SENTINEL : headRaw;
+  if (mode !== "working-tree" && (!head || !isValidRef(head))) return "";
+
+  const selected = Array.isArray(ctx.selectedFiles)
+    ? ctx.selectedFiles.filter(
+        (p) => typeof p === "string" && p && !p.includes("\0"),
+      )
+    : [];
+  if (selected.length === 0) return "";
+
+  let changedFiles: GitDiffFileEntry[];
+  try {
+    changedFiles = await getChangedFiles(base, head, mode);
+  } catch {
+    return "";
+  }
+  const byPath = new Map(changedFiles.map((f) => [f.path, f]));
+  const validSelected = selected.filter((p) => byPath.has(p));
+  if (validSelected.length === 0) return "";
+
+  const headLabel = mode === "working-tree" ? "working tree" : head;
+  const rangeLabel =
+    mode === "working-tree"
+      ? `${base} → working tree`
+      : `${base} ${mode === "two-dot" ? ".." : "..."} ${headLabel}`;
+
+  let manifest = `\n\n--- Available Git Diff Context (${rangeLabel}) ---
+You can pull lazy git diff context with the readFile tool. Three views are available per file:
+  • gitdiff:patch:<path>   — unified diff hunks (recommended starting point)
+  • gitdiff:before:<path>  — full file contents at the base ref
+  • gitdiff:after:<path>   — full file contents at the head ref (or working tree)
+Only read what you need; each file can be expensive.
+
+`;
+  for (const filePath of validSelected) {
+    const entry = byPath.get(filePath)!;
+    const sign = entry.binary
+      ? "binary"
+      : `+${entry.additions}/-${entry.deletions}`;
+    const renamed = entry.oldPath ? `  (renamed from ${entry.oldPath})` : "";
+    manifest += `• [${entry.status}] ${entry.path}  ${sign}${renamed}\n`;
+    manifest += `    patch id: "gitdiff:patch:${entry.path}"\n`;
+    if (entry.status !== "A" && entry.status !== "?") {
+      manifest += `    before id: "gitdiff:before:${entry.path}"\n`;
+    }
+    if (entry.status !== "D") {
+      manifest += `    after id:  "gitdiff:after:${entry.path}"\n`;
+    }
+
+    const safePath = filePath; // already validated to be in diff
+    fileRegistry.set(
+      `gitdiff:patch:${safePath}`,
+      makeCodeReferenceFileEntry(`[git diff] ${safePath}`, () =>
+        getDiffPatch(base, head, mode, safePath),
+      ),
+    );
+    if (entry.status !== "A" && entry.status !== "?") {
+      const refPath = entry.oldPath ?? safePath;
+      fileRegistry.set(
+        `gitdiff:before:${safePath}`,
+        makeCodeReferenceFileEntry(`[git before ${base}] ${safePath}`, () =>
+          getFileAtRef(base, refPath),
+        ),
+      );
+    }
+    if (entry.status !== "D") {
+      const ref = mode === "working-tree" ? WORKING_TREE_SENTINEL : head;
+      fileRegistry.set(
+        `gitdiff:after:${safePath}`,
+        makeCodeReferenceFileEntry(`[git after ${headLabel}] ${safePath}`, () =>
+          getFileAtRef(ref, safePath),
+        ),
+      );
+    }
+  }
+  return manifest;
+}
+
 function createReadFileTool(fileRegistry: Map<string, ReferenceFileEntry>) {
   return tool({
     description:
@@ -895,6 +992,26 @@ app.patch("/api/questions/:id", async (req, res) => {
   if (!q) return res.status(404).json({ error: "Not found" });
   if (req.body.codeContextFiles !== undefined)
     q.codeContextFiles = req.body.codeContextFiles;
+  if (req.body.gitDiffContext !== undefined) {
+    const gdc = req.body.gitDiffContext;
+    if (gdc === null) {
+      delete q.gitDiffContext;
+    } else if (gdc && typeof gdc === "object") {
+      q.gitDiffContext = {
+        baseRef: String(gdc.baseRef || ""),
+        headRef: String(gdc.headRef || ""),
+        mode:
+          gdc.mode === "two-dot" ||
+          gdc.mode === "three-dot" ||
+          gdc.mode === "working-tree"
+            ? gdc.mode
+            : "three-dot",
+        selectedFiles: Array.isArray(gdc.selectedFiles)
+          ? gdc.selectedFiles.filter((p: unknown) => typeof p === "string")
+          : [],
+      };
+    }
+  }
   if (req.body.systemContext !== undefined)
     q.systemContext = req.body.systemContext;
   if (req.body.title !== undefined) q.title = req.body.title;
@@ -1759,6 +1876,7 @@ app.post("/api/chat", async (req, res) => {
     systemContext,
     responseLength,
     linkedConversationIds,
+    gitDiffContext,
   } = req.body;
 
   const aiSettings = await storage.getAiSettings();
@@ -1881,6 +1999,12 @@ app.post("/api/chat", async (req, res) => {
     }
   }
 
+  // Git diff context (lazy patches / before / after blobs)
+  const gitDiffManifest = await registerGitDiffContext(
+    fileRegistry,
+    gitDiffContext || {},
+  );
+
   // Tell the model what files are available
   if (fileRegistry.size > 0) {
     // collect just the code-context file paths for linking instructions
@@ -1895,9 +2019,14 @@ For image files, readFile returns visual image data so you can inspect what is v
 
 `;
     for (const [id, { label }] of fileRegistry) {
+      if (id.startsWith("gitdiff:")) continue;
       system += `• ${label}  (id: "${id}")\n`;
     }
 
+    if (gitDiffManifest) {
+      system += gitDiffManifest;
+    }
+
     if (codeFilePaths.length > 0) {
       system += `
 --- Linking Code Files in Your Response ---
@@ -2281,6 +2410,490 @@ app.get("/api/code-context/file", async (req, res) => {
   }
 });
 
+// ─── Git Diff Context ────────────────────────────────────
+//
+// Lets the user pick a base/head ref (or working tree) and a list of changed
+// files. The LLM only sees a short manifest in the system prompt; full patches
+// or before/after blobs are pulled lazily via the readFile tool using ids of
+// the form  gitdiff:patch:<path> / gitdiff:before:<path> / gitdiff:after:<path>.
+
+const GIT_DIFF_DIR = process.env.GIT_DIFF_DIR || CODE_CONTEXT_DIR;
+
+// Hard caps so a runaway repo can never blow up the response or the model's context.
+const MAX_DIFF_FILES = 500;
+const MAX_DIFF_FILE_BYTES = 256 * 1024; // 256 KB per patch / blob
+const MAX_BRANCHES = 200;
+const REF_PATTERN = /^[A-Za-z0-9._\/\-]{1,200}$/;
+const WORKING_TREE_SENTINEL = "WORKING_TREE";
+
+type GitDiffMode = "two-dot" | "three-dot" | "working-tree";
+type GitDiffStatus = "A" | "M" | "D" | "R" | "C" | "T" | "U" | "?";
+
+interface GitDiffFileEntry {
+  path: string;
+  oldPath?: string;
+  status: GitDiffStatus;
+  additions: number;
+  deletions: number;
+  binary: boolean;
+}
+
+function runGit(
+  args: string[],
+  opts: {
+    cwd: string;
+    maxBuffer?: number;
+    allowFail?: boolean;
+    timeoutMs?: number;
+  } = {
+    cwd: GIT_DIFF_DIR,
+  },
+): Promise<{ stdout: string; stderr: string; code: number }> {
+  return new Promise((resolve, reject) => {
+    const child = spawn("git", args, {
+      cwd: opts.cwd,
+      env: {
+        ...process.env,
+        GIT_OPTIONAL_LOCKS: "0",
+        GIT_TERMINAL_PROMPT: "0",
+        GCM_INTERACTIVE: "Never",
+      },
+      shell: false,
+    });
+    const maxBuffer = opts.maxBuffer ?? 16 * 1024 * 1024;
+    const outChunks: Buffer[] = [];
+    const errChunks: Buffer[] = [];
+    let outLen = 0;
+    let killed = false;
+    const timer = opts.timeoutMs
+      ? setTimeout(() => {
+          killed = true;
+          child.kill("SIGKILL");
+        }, opts.timeoutMs)
+      : null;
+    child.stdout.on("data", (b: Buffer) => {
+      outLen += b.length;
+      if (outLen > maxBuffer) {
+        killed = true;
+        child.kill("SIGKILL");
+        return;
+      }
+      outChunks.push(b);
+    });
+    child.stderr.on("data", (b: Buffer) => errChunks.push(b));
+    child.on("error", (err) => reject(err));
+    child.on("close", (code) => {
+      if (timer) clearTimeout(timer);
+      const stdout = Buffer.concat(outChunks).toString("utf-8");
+      const stderr = Buffer.concat(errChunks).toString("utf-8");
+      if (killed)
+        return reject(
+          new Error("git command timed out or exceeded buffer cap"),
+        );
+      if (code !== 0 && !opts.allowFail) {
+        return reject(new Error(stderr.trim() || `git exited with ${code}`));
+      }
+      resolve({ stdout, stderr, code: code ?? 0 });
+    });
+  });
+}
+
+function uniqueStrings(values: string[]): string[] {
+  return Array.from(new Set(values.filter(Boolean)));
+}
+
+function chooseDefaultBaseBranch(head: string, branches: string[]): string {
+  const candidates = [
+    "origin/main",
+    "main",
+    "origin/master",
+    "master",
+    "origin/develop",
+    "develop",
+    "origin/dev",
+    "dev",
+  ];
+  return (
+    candidates.find((b) => branches.includes(b) && b !== head) ??
+    branches.find((b) => b !== head && !b.endsWith("/HEAD")) ??
+    head
+  );
+}
+
+function isValidRef(ref: string): boolean {
+  return REF_PATTERN.test(ref);
+}
+
+async function resolveRef(ref: string): Promise<string | null> {
+  if (!isValidRef(ref)) return null;
+  try {
+    const { stdout } = await runGit(
+      ["rev-parse", "--verify", `${ref}^{commit}`],
+      {
+        cwd: GIT_DIFF_DIR,
+      },
+    );
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+function parseDiffMode(value: unknown): GitDiffMode {
+  if (
+    value === "three-dot" ||
+    value === "two-dot" ||
+    value === "working-tree"
+  ) {
+    return value;
+  }
+  return "three-dot";
+}
+
+function buildDiffRange(
+  base: string,
+  head: string,
+  mode: GitDiffMode,
+): string[] {
+  if (mode === "working-tree") return [base];
+  if (mode === "two-dot") return [`${base}..${head}`];
+  return [`${base}...${head}`];
+}
+
+async function getChangedFiles(
+  base: string,
+  head: string,
+  mode: GitDiffMode,
+): Promise<GitDiffFileEntry[]> {
+  const range = buildDiffRange(base, head, mode);
+  const baseArgs = ["diff", "--find-renames", "--no-color"];
+
+  const nameStatus = await runGit(
+    [...baseArgs, "--name-status", "-z", ...range],
+    { cwd: GIT_DIFF_DIR },
+  );
+  const numStat = await runGit([...baseArgs, "--numstat", "-z", ...range], {
+    cwd: GIT_DIFF_DIR,
+  });
+
+  // numstat with -z uses NUL between records AND between additions/deletions/path,
+  // and for renames emits an extra leading NUL before the two paths. Simpler: parse with newlines fallback.
+  const numMap = new Map<
+    string,
+    { add: number; del: number; binary: boolean }
+  >();
+  for (const line of numStat.stdout.split(/\0|\n/).filter(Boolean)) {
+    const parts = line.split("\t");
+    if (parts.length < 3) continue;
+    const [a, d, ...rest] = parts;
+    const filePath = rest.join("\t");
+    const additions = a === "-" ? 0 : Number(a) || 0;
+    const deletions = d === "-" ? 0 : Number(d) || 0;
+    const binary = a === "-" && d === "-";
+    numMap.set(filePath, { add: additions, del: deletions, binary });
+  }
+
+  // Parse --name-status -z. Renames take 3 tokens: "R<score>", old, new. Others take 2.
+  const tokens = nameStatus.stdout.split("\0").filter((t) => t.length > 0);
+  const entries: GitDiffFileEntry[] = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const statusToken = tokens[i];
+    const letter = statusToken[0] as GitDiffStatus;
+    if (letter === "R" || letter === "C") {
+      const oldPath = tokens[++i];
+      const newPath = tokens[++i];
+      if (!newPath) continue;
+      const num = numMap.get(newPath) ?? numMap.get(`${oldPath} => ${newPath}`);
+      entries.push({
+        path: newPath,
+        oldPath,
+        status: letter,
+        additions: num?.add ?? 0,
+        deletions: num?.del ?? 0,
+        binary: num?.binary ?? false,
+      });
+    } else {
+      const filePath = tokens[++i];
+      if (!filePath) continue;
+      const num = numMap.get(filePath);
+      entries.push({
+        path: filePath,
+        status: letter,
+        additions: num?.add ?? 0,
+        deletions: num?.del ?? 0,
+        binary: num?.binary ?? false,
+      });
+    }
+  }
+
+  // Working tree mode: also surface untracked files so the user can include them.
+  if (mode === "working-tree") {
+    try {
+      const untracked = await runGit(
+        ["ls-files", "--others", "--exclude-standard", "-z"],
+        { cwd: GIT_DIFF_DIR },
+      );
+      for (const filePath of untracked.stdout
+        .split("\0")
+        .filter((t) => t.length > 0)) {
+        entries.push({
+          path: filePath,
+          status: "?",
+          additions: 0,
+          deletions: 0,
+          binary: false,
+        });
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  return entries.slice(0, MAX_DIFF_FILES);
+}
+
+async function getDiffPatch(
+  base: string,
+  head: string,
+  mode: GitDiffMode,
+  filePath: string,
+): Promise<string> {
+  const range = buildDiffRange(base, head, mode);
+  const { stdout } = await runGit(
+    [
+      "diff",
+      "--no-color",
+      "--find-renames",
+      "--unified=3",
+      ...range,
+      "--",
+      filePath,
+    ],
+    { cwd: GIT_DIFF_DIR, maxBuffer: MAX_DIFF_FILE_BYTES * 4 },
+  );
+  if (stdout.length > MAX_DIFF_FILE_BYTES) {
+    return (
+      stdout.slice(0, MAX_DIFF_FILE_BYTES) +
+      `\n\n[diff truncated after ${MAX_DIFF_FILE_BYTES} bytes]`
+    );
+  }
+  return stdout;
+}
+
+async function getFileAtRef(ref: string, filePath: string): Promise<string> {
+  if (ref === WORKING_TREE_SENTINEL) {
+    const resolved = path.resolve(path.join(GIT_DIFF_DIR, filePath));
+    if (!resolved.startsWith(path.resolve(GIT_DIFF_DIR))) {
+      throw new Error("Access denied");
+    }
+    const buf = await fs.readFile(resolved);
+    if (buf.byteLength > MAX_DIFF_FILE_BYTES) {
+      return (
+        buf.slice(0, MAX_DIFF_FILE_BYTES).toString("utf-8") +
+        `\n\n[file truncated after ${MAX_DIFF_FILE_BYTES} bytes]`
+      );
+    }
+    return buf.toString("utf-8");
+  }
+  const { stdout } = await runGit(["show", `${ref}:${filePath}`], {
+    cwd: GIT_DIFF_DIR,
+    maxBuffer: MAX_DIFF_FILE_BYTES * 4,
+  });
+  if (stdout.length > MAX_DIFF_FILE_BYTES) {
+    return (
+      stdout.slice(0, MAX_DIFF_FILE_BYTES) +
+      `\n\n[file truncated after ${MAX_DIFF_FILE_BYTES} bytes]`
+    );
+  }
+  return stdout;
+}
+
+app.get("/api/code-context/git/branches", async (_req, res) => {
+  if (!GIT_DIFF_DIR) return res.json({ enabled: false, branches: [] });
+  try {
+    // Refresh remote-tracking refs first. This is intentionally non-interactive
+    // and time-capped so private/offline repos fall back to already-local refs.
+    await runGit(["fetch", "--all", "--prune", "--quiet"], {
+      cwd: GIT_DIFF_DIR,
+      allowFail: true,
+      timeoutMs: 8000,
+    });
+
+    const [head, branches, tags, remotes] = await Promise.all([
+      runGit(["rev-parse", "--abbrev-ref", "HEAD"], { cwd: GIT_DIFF_DIR }),
+      runGit(
+        [
+          "for-each-ref",
+          "--sort=-committerdate",
+          `--count=${MAX_BRANCHES}`,
+          "--format=%(refname:short)",
+          "refs/heads/",
+          "refs/remotes/",
+        ],
+        { cwd: GIT_DIFF_DIR },
+      ),
+      runGit(
+        [
+          "for-each-ref",
+          "--sort=-creatordate",
+          "--count=50",
+          "--format=%(refname:short)",
+          "refs/tags/",
+        ],
+        { cwd: GIT_DIFF_DIR, allowFail: true },
+      ),
+      runGit(["remote"], { cwd: GIT_DIFF_DIR, allowFail: true }),
+    ]);
+    const remoteNames = remotes.stdout
+      .split("\n")
+      .map((s) => s.trim())
+      .filter(Boolean);
+    const lsRemoteResults = await Promise.all(
+      remoteNames.slice(0, 5).map((remote) =>
+        runGit(["ls-remote", "--heads", remote], {
+          cwd: GIT_DIFF_DIR,
+          allowFail: true,
+          timeoutMs: 5000,
+          maxBuffer: 1024 * 1024,
+        }).then((result) =>
+          result.stdout
+            .split("\n")
+            .map((line) => line.trim().split("\t")[1] || "")
+            .filter((ref) => ref.startsWith("refs/heads/"))
+            .map((ref) => `${remote}/${ref.replace("refs/heads/", "")}`),
+        ),
+      ),
+    );
+    const branchList = uniqueStrings([
+      ...branches.stdout
+        .split("\n")
+        .map((s) => s.trim())
+        .filter(Boolean),
+      ...lsRemoteResults.flat(),
+    ]).filter((b) => !b.endsWith("/HEAD"));
+    const tagList = tags.stdout
+      .split("\n")
+      .map((s) => s.trim())
+      .filter(Boolean);
+    const currentHead = head.stdout.trim();
+    res.json({
+      enabled: true,
+      head: currentHead,
+      defaultBranch: chooseDefaultBaseBranch(currentHead, branchList),
+      branches: branchList,
+      tags: tagList,
+    });
+  } catch (err: any) {
+    res.status(500).json({
+      enabled: false,
+      branches: [],
+      error: err?.message || "git not available",
+    });
+  }
+});
+
+app.get("/api/code-context/git/diff-tree", async (req, res) => {
+  if (!GIT_DIFF_DIR) return res.status(400).json({ error: "No git directory" });
+
+  const base = String(req.query.base || "").trim();
+  const headRaw = String(req.query.head || "").trim();
+  const mode = parseDiffMode(req.query.mode);
+
+  if (!isValidRef(base))
+    return res.status(400).json({ error: "Invalid base ref" });
+
+  const baseSha = await resolveRef(base);
+  if (!baseSha) return res.status(404).json({ error: "Base ref not found" });
+
+  let head = headRaw;
+  let headSha: string | null = WORKING_TREE_SENTINEL;
+  if (mode === "working-tree") {
+    head = WORKING_TREE_SENTINEL;
+  } else {
+    if (!isValidRef(head))
+      return res.status(400).json({ error: "Invalid head ref" });
+    headSha = await resolveRef(head);
+    if (!headSha) return res.status(404).json({ error: "Head ref not found" });
+  }
+
+  try {
+    const files = await getChangedFiles(base, head, mode);
+    res.json({
+      base,
+      baseSha,
+      head: mode === "working-tree" ? WORKING_TREE_SENTINEL : head,
+      headSha,
+      mode,
+      truncated: files.length >= MAX_DIFF_FILES,
+      files,
+    });
+  } catch (err: any) {
+    res.status(500).json({ error: err?.message || "git diff failed" });
+  }
+});
+
+app.get("/api/code-context/git/diff-file", async (req, res) => {
+  if (!GIT_DIFF_DIR) return res.status(400).json({ error: "No git directory" });
+
+  const base = String(req.query.base || "").trim();
+  const headRaw = String(req.query.head || "").trim();
+  const mode = parseDiffMode(req.query.mode);
+  const filePath = String(req.query.path || "").trim();
+  const view = (req.query.view as string) || "patch";
+
+  if (!isValidRef(base))
+    return res.status(400).json({ error: "Invalid base ref" });
+  if (!filePath || filePath.includes("\0"))
+    return res.status(400).json({ error: "Invalid path" });
+
+  const baseSha = await resolveRef(base);
+  if (!baseSha) return res.status(404).json({ error: "Base ref not found" });
+
+  let head = headRaw;
+  if (mode === "working-tree") {
+    head = WORKING_TREE_SENTINEL;
+  } else {
+    if (!isValidRef(head))
+      return res.status(400).json({ error: "Invalid head ref" });
+    const headSha = await resolveRef(head);
+    if (!headSha) return res.status(404).json({ error: "Head ref not found" });
+  }
+
+  // Verify the path is actually part of the diff so callers cannot read arbitrary repo files.
+  let entry: GitDiffFileEntry | undefined;
+  try {
+    const files = await getChangedFiles(base, head, mode);
+    entry = files.find((f) => f.path === filePath || f.oldPath === filePath);
+  } catch (err: any) {
+    return res.status(500).json({ error: err?.message || "git diff failed" });
+  }
+  if (!entry) return res.status(404).json({ error: "File not in diff" });
+
+  try {
+    if (view === "before") {
+      if (entry.status === "A" || entry.status === "?") {
+        return res.json({ path: filePath, view, content: "" });
+      }
+      const refPath = entry.oldPath ?? filePath;
+      const content = await getFileAtRef(base, refPath);
+      return res.json({ path: filePath, view, content });
+    }
+    if (view === "after") {
+      if (entry.status === "D") {
+        return res.json({ path: filePath, view, content: "" });
+      }
+      const ref = mode === "working-tree" ? WORKING_TREE_SENTINEL : head;
+      const content = await getFileAtRef(ref, filePath);
+      return res.json({ path: filePath, view, content });
+    }
+    // default: patch
+    const patch = await getDiffPatch(base, head, mode, filePath);
+    return res.json({ path: filePath, view: "patch", content: patch });
+  } catch (err: any) {
+    res.status(500).json({ error: err?.message || "git read failed" });
+  }
+});
+
 // ─── Code Line Ask ──────────────────────────────────────
 
 app.post("/api/code-line-ask", async (req, res) => {
@@ -2293,6 +2906,7 @@ app.post("/api/code-line-ask", async (req, res) => {
     codeContextFiles,
     codeSnippets,
     preferenceSuffix,
+    gitDiffContext,
   } = req.body;
   if (typeof prompt !== "string" || !prompt.trim()) {
     return res.status(400).json({ error: "prompt is required" });
@@ -2372,6 +2986,11 @@ app.post("/api/code-line-ask", async (req, res) => {
       }
     }
 
+    const gitDiffManifestCla = await registerGitDiffContext(
+      fileRegistry,
+      gitDiffContext || {},
+    );
+
     let system =
       "You are a senior software engineer and interview coach. Answer questions about the highlighted code lines. Be concise, accurate, and practical. Use markdown formatting for code references.";
 
@@ -2393,9 +3012,14 @@ app.post("/api/code-line-ask", async (req, res) => {
 
       system += `\n\n--- Available Reference Files ---\nThe following files are available to you. Use the readFile tool to retrieve a file's content when it would help answer the question. Only read files that are relevant. For image files, readFile returns visual image data so you can inspect what is visible.\n\n`;
       for (const [id, { label }] of fileRegistry) {
+        if (id.startsWith("gitdiff:")) continue;
         system += `• ${label}  (id: "${id}")\n`;
       }
 
+      if (gitDiffManifestCla) {
+        system += gitDiffManifestCla;
+      }
+
       if (codeFilePaths.length > 0) {
         system += `\n--- Linking Code Files in Your Response ---\nWhen you mention a [code] file, format it as a clickable link:\n  [DisplayText](coderef://relative/path/to/file)\nOnly use coderef:// for [code] files.`;
       }