fix(push): clear timeout timer after push settles to avoid event-loop hang

[hobostay]

Problem

reportUsageToTeam (run from pull() on every teamai pull that has usage events to report — i.e. on most session-start hook fires) and contribute() both guarded their git push with a plain Promise.race:

const pushPromise = pushRepoDirectly(repoPath, commitMsg, filesToPush);
const timeoutPromise = new Promise<never>((__, reject) =>
  setTimeout(() => reject(new Error('Auto-report timeout (5s)')), 5000),
);
await Promise.race([pushPromise, timeoutPromise]);

When the push resolves quickly — the normal case — the losing setTimeout is never cleared. It stays pending on the Node event loop, so the process hangs at the terminal for the full 5000 ms (pull) / 10_000 ms (contribute) after all real work has finished.

Because teamai pull runs from session-start hooks, this hang recurred on nearly every session and was very visible. clearTimeout never appears in either file; by contrast clone.ts already implements the correct pattern (clearTimeout(timer) in both the close and error handlers).

Fix

Replace both sites with a shared withTimeout() helper (src/utils/async.ts) that clears its timer in a finally once the guarded promise settles:

export async function withTimeout<T>(promise: Promise<T>, timeoutMs: number, message: string): Promise<T> {
  let timer: ReturnType<typeof setTimeout> | undefined;
  const timeoutPromise = new Promise<never>((_, reject) => {
    timer = setTimeout(() => reject(new Error(message)), timeoutMs);
  });
  try {
    return await Promise.race([promise, timeoutPromise]);
  } finally {
    if (timer) clearTimeout(timer);
  }
}

Behavior is otherwise unchanged: it still rejects with the timeout message if the push exceeds the budget, and propagates the push's own rejection if it fails first.

Test plan

• npx tsc --noEmit — clean
• npm run build — succeeds
• npm test — 1766 passed (1760 baseline + 6 new)
• New unit tests (src/__tests__/async-timeout.test.ts) assert the timer is cleared on both the success and failure paths, plus a handle-count check that no timer survives a fast success.
• End-to-end timing demo (inlined old vs new pattern, 3000 ms budget, ~60 ms push):
  • OLD: race returns in 62 ms, but real 3.04s — process hangs on the leaked timer.
  • NEW: race returns in 62 ms, real 0.11s — process exits promptly.

🤖 Generated with Claude Code