async function track() {
  if (Instance.project.vcs !== "git")
    return;
  const cfg = await Config.get();
  if (cfg.snapshot === false)
    return;
  const git = gitdir();  // Returns: ~/.local/share/opencode/snapshot/<hash>
  
  // Initialize git repo if needed
  if (await fs8.mkdir(git, { recursive: true })) {
    await $6`git init`.env({
      ...process.env,
      GIT_DIR: git,
      GIT_WORK_TREE: Instance.worktree
    }).quiet().nothrow();
  }
  
  // ⚠️ THE LEAK SOURCE - No timeout, silent failures
  await $6`git --git-dir ${git} --work-tree ${Instance.worktree} add .`
    .quiet()              // Suppress output
    .cwd(Instance.directory)
    .nothrow();           // Silent failure - CRITICAL ISSUE
  
  const hash2 = await $6`git --git-dir ${git} --work-tree ${Instance.worktree} write-tree`
    .quiet()
    .cwd(Instance.directory)
    .nothrow().text();
  
  log3.info("tracking", { hash: hash2, cwd: Instance.directory, git });
  return hash2.trim();
}

// Runs every 1 hour
Scheduler.register({
  id: "snapshot.cleanup",
  interval: 3600000,  // 1 hour
  run: cleanup,
  scope: "instance"
});

async function cleanup() {
  // ⚠️ ONLY runs git gc - doesn't remove tmp_pack files!
  const result = await $6`git --git-dir ${git} --work-tree ${Instance.worktree} gc --prune=${prune}`
    .quiet()
    .cwd(Instance.directory)
    .nothrow();
  
  if (result.exitCode !== 0) {
    log3.warn("cleanup failed", { exitCode, stderr, stdout });
    return;  // Silent failure
  }
  log3.info("cleanup", { prune: "7.days" });
}

// BEFORE (current code):
await $6`git --git-dir ${git} --work-tree ${Instance.worktree} add .`
  .quiet()
  .cwd(Instance.directory)
  .nothrow();

// AFTER (with fix):
const addResult = await $6`git --git-dir ${git} --work-tree ${Instance.worktree} add .`
  .quiet()
  .cwd(Instance.directory)
  .timeout(30000)  // 30 second timeout
  .nothrow();

// Check result and cleanup on failure
if (addResult.exitCode !== 0) {
  log3.warn("git add failed or timed out", {
    exitCode: addResult.exitCode,
    stderr: addResult.stderr.toString()
  });
  await cleanupTmpPacks(git);
  return null;
}

async function cleanup() {
  if (Instance.project.vcs !== "git")
    return;
  const cfg = await Config.get();
  if (cfg.snapshot === false)
    return;
  const git = gitdir();
  const exists = await fs8.stat(git).then(() => true).catch(() => false);
  if (!exists)
    return;

  // ========== ADD THIS: Clean tmp_pack files ==========
  try {
    const packDir = path.join(git, "objects", "pack");
    const files = await fs8.readdir(packDir).catch(() => []);
    const tmpPacks = files.filter(f => f.startsWith("tmp_pack_"));
    
    if (tmpPacks.length > 0) {
      log3.info("removing tmp_pack files", { count: tmpPacks.length });
      
      await Promise.all(
        tmpPacks.map(file => 
          fs8.unlink(path.join(packDir, file))
            .catch(err => log3.warn("failed to remove tmp_pack", { file, error: err.message }))
        )
      );
      
      log3.info("tmp_pack cleanup complete", { removed: tmpPacks.length });
    }
  } catch (err) {
    log3.warn("tmp_pack cleanup error", { error: err.message });
  }
  // ====================================================

  // Existing git gc cleanup
  const result = await $6`git --git-dir ${git} --work-tree ${Instance.worktree} gc --prune=${prune}`
    .quiet()
    .cwd(Instance.directory)
    .nothrow();
  
  if (result.exitCode !== 0) {
    log3.warn("cleanup failed", {
      exitCode: result.exitCode,
      stderr: result.stderr.toString(),
      stdout: result.stdout.toString()
    });
    return;
  }
  log3.info("cleanup", { prune });
}

// Helper function for immediate cleanup after failures
async function cleanupTmpPacks(git) {
  try {
    const packDir = path.join(git, "objects", "pack");
    const files = await fs8.readdir(packDir).catch(() => []);
    const tmpPacks = files.filter(f => f.startsWith("tmp_pack_"));
    
    await Promise.all(
      tmpPacks.map(file => fs8.unlink(path.join(packDir, file)).catch(() => {}))
    );
    
    if (tmpPacks.length > 0) {
      log3.info("cleaned tmp_pack after failure", { count: tmpPacks.length });
    }
  } catch (err) {
    log3.warn("tmp_pack cleanup error", { error: err.message });
  }
}

let lastSnapshot = null;
let lastSnapshotTime = 0;
const SNAPSHOT_THROTTLE = 5000; // 5 seconds

async function track() {
  const now = Date.now();
  if (now - lastSnapshotTime < SNAPSHOT_THROTTLE) {
    log3.debug("throttled snapshot", { lastSnapshot });
    return lastSnapshot;
  }
  
  // ... existing track() code ...
  
  lastSnapshot = hash2.trim();
  lastSnapshotTime = now;
  return lastSnapshot;
}

// User-configurable in ~/.opencode/config
{
  "snapshot": {
    "enabled": true,
    "timeout": 30000,          // NEW: Timeout in ms
    "strategy": "every-step",  // NEW: "on-demand" | "every-step" | "minimal"
    "cleanup": {
      "interval": 3600000,
      "prune": "7.days",
      "removeTmpPack": true    // NEW: Remove tmp_pack files
    }
  }
}