fix: stop reporting the override difference as uncommitted work

Once per-machine overrides are in use the config file on disk is meant to
differ from the committed version — that is the entire mechanism. But status
asked git, so it reported one modified file forever: a warning the user could
never clear, and one that invites a pointless push.

The config is now compared with override-owned keys subtracted. Identical means
clean; anything else is still reported.

Fixing that surfaced a second bug. The porcelain parser sliced at a fixed
column offset, but the git wrapper trims its output, which eats the leading
column of an unstaged entry and shifts every field after it. ' M file' arrived
as 'M file' and the parser returned 'ile'. Paths are now matched by pattern,
which also handles quoted paths and renames.

Author: doomsday616

CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 3.0.1
+
+### Fixed
+- `status` no longer reports the config file as uncommitted work on machines
+  that use per-machine overrides. The file on disk is *supposed* to differ from
+  the committed version once overrides are in play, so plain `git status`
+  flagged it as modified forever — a warning the user could never clear. The
+  config is now compared with overrides subtracted, so only genuine edits count.
+- `git status --porcelain` output is parsed by pattern rather than at a fixed
+  column offset. Output is trimmed before parsing, which removed the leading
+  column of an unstaged entry and shifted every field after it, silently
+  yielding a truncated filename.
+
 ## 3.0.0
 
 Complete rewrite. The previous release was a set of shell-wrapped Node scripts;

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-github-sync",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Sync your OpenCode config, skills, and selected sessions across machines via a private GitHub repo — as a plugin or a CLI.",
   "type": "module",
   "license": "MIT",

package.json

@@ -134,6 +134,33 @@ export function toGitError(operation: string, result: GitResult): Error {
     : new GitError(operation, result);
 }
 
+/**
+ * Extract the file paths from `git status --porcelain` output.
+ *
+ * The format is fixed-width — two status columns, a space, then the path — but
+ * this deliberately does not slice at a fixed offset. Output here is trimmed
+ * before parsing, which eats the leading space of an unstaged entry (` M file`)
+ * and shifts every subsequent column. Matching the status field by pattern
+ * instead survives that, as well as the quoting git applies to paths with
+ * unusual characters.
+ *
+ * Renames appear as `old -> new`; the destination is reported, since that is
+ * what exists afterwards.
+ */
+export function parsePorcelainPaths(output: string): string[] {
+  const paths: string[] = [];
+  for (const line of String(output ?? "").split("\n")) {
+    if (!line.trim()) continue;
+    const withoutStatus = line.replace(/^\s*[MADRCU?!]{1,2}\s+/, "");
+    if (withoutStatus === line.trim() && !/^\s*[MADRCU?!]/.test(line)) continue;
+    const arrow = withoutStatus.lastIndexOf(" -> ");
+    const raw = arrow === -1 ? withoutStatus : withoutStatus.slice(arrow + 4);
+    const unquoted = raw.trim().replace(/^"(.*)"$/, "$1");
+    if (unquoted) paths.push(unquoted);
+  }
+  return paths;
+}
+
 export interface NameStatusEntry {
   kind: "added" | "modified" | "deleted" | "renamed";
   path: string;

src/core/git.ts

@@ -114,6 +114,48 @@ function isPlainObject(value: unknown): value is Record<string, any> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+/** Serialise with sorted keys, so comparisons ignore key order. */
+function canonical(value: unknown): string {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  if (isPlainObject(value)) {
+    const entries = Object.keys(value)
+      .sort()
+      .map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`);
+    return `{${entries.join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+
+/**
+ * True when the config on disk is, apart from override-owned keys, exactly what
+ * the repository already holds.
+ *
+ * Once overrides are in use the file on disk permanently differs from the
+ * committed version — that is the whole point. Plain `git status` therefore
+ * reports it as modified forever, which looks like pending work that never goes
+ * away. This lets the status command tell a real edit apart from the expected
+ * override difference.
+ *
+ * Returns `false` when there are no overrides, so callers fall back to git.
+ */
+export function configMatchesRepo(configRoot: string, previousText: string | undefined): boolean {
+  const overrides = loadOverrides(configRoot);
+  if (Object.keys(overrides).length === 0) return false;
+  if (!previousText) return false;
+
+  const configFile = findConfigFile(configRoot);
+  if (!configFile) return false;
+
+  try {
+    const effective = parseJsonc<Record<string, any>>(fs.readFileSync(configFile, "utf8"));
+    const previous = parseJsonc<Record<string, any>>(previousText);
+    return canonical(stripOverrides(effective, overrides, previous)) === canonical(previous);
+  } catch {
+    // Unparseable on either side: treat it as a genuine difference.
+    return false;
+  }
+}
+
 /**
  * Produce the text that should be committed for the config file.
  *

src/core/overrides.ts

@@ -1,8 +1,15 @@
 import fs from "node:fs";
 import path from "node:path";
-import { type GitResult, git, isGitRepo, parseNameStatus, toGitError } from "./git.js";
+import {
+  type GitResult,
+  git,
+  isGitRepo,
+  parseNameStatus,
+  parsePorcelainPaths,
+  toGitError,
+} from "./git.js";
 import { commitMessage, hostAlias } from "./host.js";
-import { applyOverrides } from "./overrides.js";
+import { applyOverrides, configMatchesRepo, findConfigFile } from "./overrides.js";
 import { type Roots, getDatabasePath, getRoots } from "./paths.js";
 import {
   LOCAL_RUNTIME_PATHS,
@@ -493,7 +500,7 @@ export function status(options: SyncOptions = {}): StatusResult {
   base.behind = countCommits(root, `HEAD..origin/${branch}`);
 
   const dirty = git(["status", "--porcelain", "--", ".", ...excludePathspecs()], { cwd: root });
-  base.dirty = dirty.ok ? dirty.stdout.split("\n").filter(Boolean).length : 0;
+  base.dirty = dirty.ok ? countRealChanges(root, dirty.stdout) : 0;
 
   const log = git(["log", "-1", "--format=%s%n%cI"], { cwd: root });
   if (log.ok) {
@@ -510,6 +517,27 @@ function countShards(root: string): number {
   return fs.readdirSync(dir).filter((f) => f.endsWith(".json.gz")).length;
 }
 
+/**
+ * Count genuinely uncommitted files.
+ *
+ * With overrides in use the config file always differs from the committed
+ * version, so a raw `git status` would report one modified file forever. That
+ * entry is dropped when the only difference is the overrides themselves.
+ */
+function countRealChanges(root: string, porcelain: string): number {
+  const paths = parsePorcelainPaths(porcelain);
+  if (paths.length === 0) return 0;
+
+  const configFile = findConfigFile(root);
+  if (!configFile) return paths.length;
+
+  const relative = path.relative(root, configFile).split(path.sep).join("/");
+  const head = git(["show", `HEAD:${relative}`], { cwd: root });
+  if (!configMatchesRepo(root, head.ok ? head.stdout : undefined)) return paths.length;
+
+  return paths.filter((file) => file !== relative).length;
+}
+
 // ── Helpers ─────────────────────────────────────────────────────────────────
 
 function countCommits(root: string, range: string): number {

src/core/sync.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { parseNameStatus } from "../src/core/git.js";
+import { parseNameStatus, parsePorcelainPaths } from "../src/core/git.js";
 import { commitMessage, hostAlias, sanitizeAlias } from "../src/core/host.js";
 import { deepMerge, parseJsonc } from "../src/core/jsonc.js";
 import { stripOverrides } from "../src/core/overrides.js";
@@ -156,6 +156,47 @@ describe("isLocalRuntimePath", () => {
   });
 });
 
+describe("parsePorcelainPaths", () => {
+  it("reads a staged entry", () => {
+    expect(parsePorcelainPaths("M  opencode.jsonc")).toEqual(["opencode.jsonc"]);
+  });
+
+  it("reads an unstaged entry that still has its leading space", () => {
+    expect(parsePorcelainPaths(" M opencode.jsonc")).toEqual(["opencode.jsonc"]);
+  });
+
+  it("reads an unstaged entry whose leading space was trimmed away", () => {
+    // The git wrapper trims its output, which eats the leading column of the
+    // first line. Slicing at a fixed offset silently returned "pencode.jsonc"
+    // here and made the caller miscount.
+    expect(parsePorcelainPaths("M opencode.jsonc")).toEqual(["opencode.jsonc"]);
+  });
+
+  it("reads untracked entries", () => {
+    expect(parsePorcelainPaths("?? command/new.md")).toEqual(["command/new.md"]);
+  });
+
+  it("reports the destination of a rename", () => {
+    expect(parsePorcelainPaths('R  "old name.md" -> "new name.md"')).toEqual(["new name.md"]);
+  });
+
+  it("unquotes a path containing spaces", () => {
+    // git always reports forward slashes, and quotes a path only when it holds
+    // unusual characters.
+    expect(parsePorcelainPaths('A  "skills/my skill/SKILL.md"')).toEqual([
+      "skills/my skill/SKILL.md",
+    ]);
+  });
+
+  it("handles several entries and ignores blank lines", () => {
+    expect(parsePorcelainPaths("M  a.md\n\n?? b.md\n D c.md\n")).toEqual(["a.md", "b.md", "c.md"]);
+  });
+
+  it("returns nothing for empty input", () => {
+    expect(parsePorcelainPaths("")).toEqual([]);
+  });
+});
+
 describe("parseNameStatus", () => {
   it("maps status characters to change kinds", () => {
     const entries = parseNameStatus("A\tnew.txt\nM\tmod.txt\nD\tgone.txt");

tests/config.test.ts

@@ -349,6 +349,47 @@ describe("status", () => {
     expect(result.configured).toBe(false);
   });
 
+  it("does not report the override difference as uncommitted work", async () => {
+    // The config on disk always differs from the committed version once
+    // overrides are in use. Reporting that as pending work would show a warning
+    // that the user can never clear.
+    const a = makeMachine("a");
+    useMachine(a);
+    write(path.join(a.config, "opencode.jsonc"), '{ "model": "shared", "theme": "dark" }\n');
+    await push({ settings: settings(), roots: getRoots() });
+
+    const b = makeMachine("b");
+    useMachine(b);
+    write(path.join(b.config, "opencode-sync.overrides.jsonc"), '{ "model": "mine" }\n');
+    await pull({ settings: settings(), roots: getRoots() });
+
+    // git itself still sees a modified file — that is expected.
+    const porcelain = execFileSync("git", ["status", "--porcelain"], {
+      cwd: b.config,
+      encoding: "utf8",
+    });
+    expect(porcelain).toMatch(/opencode\.jsonc/);
+
+    // But the reported state is clean, because nothing is actually pending.
+    expect(status({ settings: settings(), roots: getRoots() }).dirty).toBe(0);
+  });
+
+  it("still reports a real edit made alongside an override", async () => {
+    const a = makeMachine("a");
+    useMachine(a);
+    write(path.join(a.config, "opencode.jsonc"), '{ "model": "shared", "theme": "dark" }\n');
+    await push({ settings: settings(), roots: getRoots() });
+
+    const b = makeMachine("b");
+    useMachine(b);
+    write(path.join(b.config, "opencode-sync.overrides.jsonc"), '{ "model": "mine" }\n');
+    await pull({ settings: settings(), roots: getRoots() });
+
+    // A change to a key the overrides do not claim is genuine pending work.
+    write(path.join(b.config, "opencode.jsonc"), '{ "model": "mine", "theme": "light" }\n');
+    expect(status({ settings: settings(), roots: getRoots() }).dirty).toBeGreaterThan(0);
+  });
+
   it("reports pending incoming commits", async () => {
     const a = makeMachine("a");
     useMachine(a);