fix: push unpushed commits when working tree is clean but local is ahead of remote

- Check rev-list ahead count instead of relying solely on isClean()
- Handle first push when remote branch doesn't exist yet
- Add isCancel check for shouldCreate confirm prompt
- Use --set-upstream on push for initial branch setup
- Show distinct messages for committed+pushed vs pushed-only vs no-op

Author: tc9011

src/commands/push.test.ts

@@ -139,4 +139,38 @@ describe('push command logic', () => {
 
     expect(mockPrompts.note).toHaveBeenCalledOnce();
   });
+
+  it('throws CliError when user cancels shouldCreate confirm prompt', async () => {
+    const { CliError } = await import('../errors.js');
+    vi.mocked(getGitHubToken).mockReturnValue('ghp_test_token');
+    vi.mocked(ensureGitRepo).mockResolvedValue({ initialized: true });
+    vi.mocked(getRepoRemoteUrl).mockResolvedValue(null);
+    mockPrompts.text.mockResolvedValue('owner/my-skills');
+    vi.mocked(ensureRemote).mockResolvedValue({
+      remoteUrl: 'https://github.com/owner/my-skills.git',
+      added: true,
+    });
+    // Simulate user pressing Ctrl+C on confirm prompt
+    mockPrompts.confirm.mockResolvedValue(Symbol('cancel'));
+    mockPrompts.isCancel.mockImplementation((val) => typeof val === 'symbol');
+
+    const { pushCommand } = await import('./push.js');
+    await expect(pushCommand({})).rejects.toThrow(CliError);
+    expect(pushSkills).not.toHaveBeenCalled();
+  });
+
+  it('shows correct message when committed and pushed', async () => {
+    vi.mocked(getGitHubToken).mockReturnValue('ghp_test_token');
+    vi.mocked(ensureGitRepo).mockResolvedValue({ initialized: false });
+    vi.mocked(getRepoRemoteUrl).mockResolvedValue('https://github.com/user/repo.git');
+    vi.mocked(pushSkills).mockResolvedValue({ committed: false, pushed: true });
+
+    const spinnerStop = vi.fn();
+    mockPrompts.spinner = () => ({ start: vi.fn(), stop: spinnerStop, error: vi.fn() });
+
+    const { pushCommand } = await import('./push.js');
+    await pushCommand({});
+
+    expect(spinnerStop).toHaveBeenCalledWith('Unpushed commits pushed successfully!');
+  });
 });

src/commands/push.ts

@@ -40,6 +40,10 @@ export async function pushCommand(options: { message?: string }): Promise<void>
     const shouldCreate = await p.confirm({
       message: 'Create this repo on GitHub? (requires gh CLI)',
     });
+    if (p.isCancel(shouldCreate)) {
+      p.cancel('Push cancelled.');
+      throw new CliError('Push cancelled by user.');
+    }
 
     if (shouldCreate === true) {
       createGitHubRepo(repo);
@@ -52,11 +56,12 @@ export async function pushCommand(options: { message?: string }): Promise<void>
 
   try {
     const result = await pushSkills(AGENTS_DIR, options.message, token);
-    spinner.stop(
-      result.committed
+    const statusMsg = result.pushed
+      ? result.committed
         ? 'Skills pushed successfully!'
-        : 'No changes to push — already up to date.',
-    );
+        : 'Unpushed commits pushed successfully!'
+      : 'No changes to push — already up to date.';
+    spinner.stop(statusMsg);
 
     // Warn about suspicious files that may contain secrets
     if (result.suspiciousFiles?.length) {

src/git-ops.test.ts

@@ -202,13 +202,15 @@ describe('pushSkills', () => {
 
     expect(mockGit.add).toHaveBeenCalledWith('-A');
     expect(mockGit.commit).toHaveBeenCalledWith('test commit');
-    expect(mockGit.push).toHaveBeenCalledWith('origin', 'main');
+    expect(mockGit.push).toHaveBeenCalledWith('origin', 'main', { '--set-upstream': null });
     expect(result).toEqual({ committed: true, pushed: true });
   });
 
-  it('skips commit when working tree is clean', async () => {
+  it('skips commit and push when working tree is clean and not ahead of remote', async () => {
     mockGit.add.mockResolvedValue(undefined);
     mockGit.status.mockResolvedValue({ isClean: () => true });
+    mockGit.branchLocal.mockResolvedValue({ current: 'main' });
+    mockGit.raw.mockResolvedValue('0\n');
 
     const result = await pushSkills(tempDir);
 
@@ -218,6 +220,37 @@ describe('pushSkills', () => {
     expect(result.pushed).toBe(false);
   });
 
+  it('pushes unpushed commits when working tree is clean but local is ahead of remote', async () => {
+    mockGit.add.mockResolvedValue(undefined);
+    mockGit.status.mockResolvedValue({ isClean: () => true });
+    mockGit.branchLocal.mockResolvedValue({ current: 'main' });
+    mockGit.raw.mockResolvedValue('2\n');
+    mockGit.push.mockResolvedValue(undefined);
+
+    const result = await pushSkills(tempDir);
+
+    expect(mockGit.commit).not.toHaveBeenCalled();
+    expect(mockGit.push).toHaveBeenCalledWith('origin', 'main', { '--set-upstream': null });
+    expect(result.committed).toBe(false);
+    expect(result.pushed).toBe(true);
+  });
+
+  it('commits and pushes on first push when remote branch does not exist yet', async () => {
+    mockGit.status.mockResolvedValue({ isClean: () => false });
+    mockGit.add.mockResolvedValue(undefined);
+    mockGit.commit.mockResolvedValue(undefined);
+    mockGit.branchLocal.mockResolvedValue({ current: 'main' });
+    // rev-list fails because origin/main doesn't exist yet
+    mockGit.raw.mockRejectedValue(new Error('unknown revision origin/main'));
+    mockGit.push.mockResolvedValue(undefined);
+
+    const result = await pushSkills(tempDir, 'initial');
+
+    expect(mockGit.commit).toHaveBeenCalledWith('initial');
+    expect(mockGit.push).toHaveBeenCalledWith('origin', 'main', { '--set-upstream': null });
+    expect(result).toEqual({ committed: true, pushed: true });
+  });
+
   it('uses token with temporary remote URL and restores clean URL', async () => {
     mockGit.status.mockResolvedValue({ isClean: () => false });
     mockGit.add.mockResolvedValue(undefined);
@@ -260,7 +293,7 @@ describe('pushSkills', () => {
     await pushSkills(tempDir, 'test', null);
 
     expect(mockGit.remote).not.toHaveBeenCalled();
-    expect(mockGit.push).toHaveBeenCalledWith('origin', 'master');
+    expect(mockGit.push).toHaveBeenCalledWith('origin', 'master', { '--set-upstream': null });
   });
 
   it('uses auto-generated commit message when none provided', async () => {
@@ -284,7 +317,7 @@ describe('pushSkills', () => {
     mockGit.push.mockRejectedValue(new Error('error: failed to push some refs... non-fast-forward'));
 
     await expect(pushSkills(tempDir, 'test')).rejects.toThrow('Push rejected');
-    await expect(pushSkills(tempDir, 'test')).rejects.toThrow('skills-manager pull');
+    await expect(pushSkills(tempDir, 'test')).rejects.toThrow('sm pull');
   });
 
   it('throws user-friendly error when push is rejected due to fetch first (with token)', async () => {

src/git-ops.ts

@@ -132,32 +132,44 @@ export async function pushSkills(
   await git.add('-A');
   // Check if anything to commit
   const status = await git.status();
-  if (status.isClean()) {
-    return { committed: false, pushed: false, suspiciousFiles: suspicious.length > 0 ? suspicious : undefined };
-  }
+  let committed = false;
 
-  // Commit
-  await git.commit(msg);
+  if (!status.isClean()) {
+    // Commit
+    await git.commit(msg);
+    committed = true;
+  }
 
-  // Push — if token provided, temporarily set the remote URL with auth, then restore
+  // Push — always check if local is ahead of remote (handles previously committed but unpushed work)
   const branch = await getCurrentBranch(git);
+  let aheadCount: number;
+  try {
+    const count = await git.raw(['rev-list', `origin/${branch}..HEAD`, '--count']);
+    aheadCount = parseInt(count.trim(), 10) || 0;
+  } catch {
+    // Remote branch may not exist yet (first push) — treat as ahead if we committed
+    aheadCount = committed ? 1 : 0;
+  }
 
+  if (aheadCount === 0) {
+    return { committed: false, pushed: false, suspiciousFiles: suspicious.length > 0 ? suspicious : undefined };
+  }
   const doPush = async () => {
     try {
-      await git.push('origin', branch);
+      await git.push('origin', branch, { '--set-upstream': null });
     } catch (err) {
       const msg = String(err);
       if (msg.includes('non-fast-forward') || msg.includes('fetch first') || msg.includes('rejected') || msg.includes('failed to push')) {
         throw new Error(
           'Push rejected — remote contains commits that you do not have locally.\n'
           + 'Pull the latest changes first, resolve any conflicts, then push again:\n'
-          + '  skills-manager pull\n'
-          + '  skills-manager push\n'
+          + '  sm pull\n'
+          + '  sm push\n'
           + '\n'
           + 'Or resolve manually:\n'
           + '  cd ~/.agents\n'
           + `  git pull --rebase origin ${branch}   # resolve conflicts if any, then git rebase --continue\n`
-          + '  skills-manager push',
+          + '  sm push',
           { cause: err },
         );
       }
@@ -184,7 +196,7 @@ export async function pushSkills(
     await doPush();
   }
 
-  return { committed: true, pushed: true, suspiciousFiles: suspicious.length > 0 ? suspicious : undefined };
+  return { committed, pushed: true, suspiciousFiles: suspicious.length > 0 ? suspicious : undefined };
 }
 
 /**