fix(sync): Use commit SHA to verify push status before closing issues

Replace gitignore-based storage checking with commit SHA verification.
GitHub issues are now only closed when the task's associated commit
exists on origin/HEAD, ensuring issues stay open until work is actually
pushed. Auto-archive also respects this - tasks with unpushed commits
won't be archived.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: dcramer

src/core/auto-archive.test.ts

@@ -14,6 +14,11 @@ vi.mock("node:fs", async () => {
   };
 });
 
+// Mock git-utils for commit checking
+vi.mock("./git-utils.js", () => ({
+  isCommitOnRemote: vi.fn(() => true), // Default: commits are on remote
+}));
+
 const createTask = (overrides: Partial<Task> = {}): Task => ({
   id: "test-id",
   parent_id: null,
@@ -375,4 +380,91 @@ describe("performAutoArchive", () => {
     // With default keep_recent of 50, this task won't be archived
     expect(result.archivedCount).toBe(0);
   });
+
+  describe("commit-based archive filtering", () => {
+    it("does not archive tasks with unpushed commits", async () => {
+      const { isCommitOnRemote } = await import("./git-utils.js");
+      vi.mocked(isCommitOnRemote).mockReturnValue(false); // Commit not pushed
+
+      const store: TaskStore = {
+        tasks: [
+          createTask({
+            id: "unpushed-task",
+            completed: true,
+            completed_at: "2024-01-01T00:00:00.000Z",
+            metadata: {
+              commit: {
+                sha: "abc123",
+                message: "Fix bug",
+              },
+            },
+          }),
+        ],
+      };
+
+      const result = performAutoArchive(store, testStoragePath, {
+        auto: true,
+        age_days: 90,
+        keep_recent: 0,
+      });
+
+      expect(result.archivedCount).toBe(0);
+      expect(store.tasks).toHaveLength(1);
+    });
+
+    it("archives tasks with pushed commits", async () => {
+      const { isCommitOnRemote } = await import("./git-utils.js");
+      vi.mocked(isCommitOnRemote).mockReturnValue(true); // Commit is pushed
+
+      const store: TaskStore = {
+        tasks: [
+          createTask({
+            id: "pushed-task",
+            completed: true,
+            completed_at: "2024-01-01T00:00:00.000Z",
+            metadata: {
+              commit: {
+                sha: "abc123",
+                message: "Fix bug",
+              },
+            },
+          }),
+        ],
+      };
+
+      const result = performAutoArchive(store, testStoragePath, {
+        auto: true,
+        age_days: 90,
+        keep_recent: 0,
+      });
+
+      expect(result.archivedCount).toBe(1);
+      expect(store.tasks).toHaveLength(0);
+    });
+
+    it("archives tasks without commit metadata (uses local status)", async () => {
+      const { isCommitOnRemote } = await import("./git-utils.js");
+      vi.mocked(isCommitOnRemote).mockReturnValue(true); // No commit = assume pushed
+
+      const store: TaskStore = {
+        tasks: [
+          createTask({
+            id: "no-commit-task",
+            completed: true,
+            completed_at: "2024-01-01T00:00:00.000Z",
+            // No commit metadata
+          }),
+        ],
+      };
+
+      const result = performAutoArchive(store, testStoragePath, {
+        auto: true,
+        age_days: 90,
+        keep_recent: 0,
+      });
+
+      expect(result.archivedCount).toBe(1);
+      expect(store.tasks).toHaveLength(0);
+    });
+  });
 });

src/core/auto-archive.ts

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { ArchivedTask, TaskStore } from "../types.js";
+import { ArchivedTask, Task, TaskStore } from "../types.js";
 import { ArchiveConfig } from "./config.js";
 import {
   findAutoArchivableTasks,
@@ -10,6 +10,7 @@ import {
 } from "./archive-compactor.js";
 import { ArchiveStorage } from "./storage/archive-storage.js";
 import { cleanupTaskReferences } from "./task-relationships.js";
+import { isCommitOnRemote } from "./git-utils.js";
 
 /**
  * Default auto-archive configuration.
@@ -41,6 +42,16 @@ function toAutoArchiveConfig(config: ArchiveConfig): AutoArchiveConfig {
   };
 }
 
+/**
+ * Check if a task's commit has been pushed to origin.
+ * Only tasks with pushed commits (or no commit SHA) can be auto-archived.
+ */
+function isTaskPushed(task: Task): boolean {
+  const sha = task.metadata?.commit?.sha;
+  // No commit SHA means we can't verify - allow archiving
+  return !sha || isCommitOnRemote(sha);
+}
+
 /**
  * Log an auto-archive event to the archive log file.
  */
@@ -100,7 +111,11 @@ export function performAutoArchive(
   // Find eligible tasks (root-level only)
   const eligibleTasks = findAutoArchivableTasks(store.tasks, autoArchiveConfig);
 
-  if (eligibleTasks.length === 0) {
+  // Filter to only tasks whose commits have been pushed to origin
+  // This ensures we don't archive work that hasn't been published yet
+  const pushedTasks = eligibleTasks.filter(isTaskPushed);
+
+  if (pushedTasks.length === 0) {
     return { archivedCount: 0, archivedIds: [] };
   }
 
@@ -111,7 +126,7 @@ export function performAutoArchive(
   const tasksToArchive: ArchivedTask[] = [];
 
   // Process each eligible task
-  for (const rootTask of eligibleTasks) {
+  for (const rootTask of pushedTasks) {
     const collected = collectArchivableTasks(rootTask.id, store.tasks);
     if (!collected) continue;
 

src/core/git-utils.ts

@@ -0,0 +1,18 @@
+import { execSync } from "node:child_process";
+
+/**
+ * Check if a commit SHA exists on origin/HEAD (has been pushed).
+ * Returns true if the commit is an ancestor of origin/HEAD.
+ */
+export function isCommitOnRemote(sha: string): boolean {
+  try {
+    // git merge-base --is-ancestor returns 0 if sha is ancestor of origin/HEAD
+    execSync(`git merge-base --is-ancestor ${sha} origin/HEAD`, {
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    return true;
+  } catch {
+    // Not an ancestor, or git command failed
+    return false;
+  }
+}