@bragduck/cli 2.29.2 → 2.36.2

package/dist/bin/bragduck.js

@@ -9,11 +9,11 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// node_modules/tsup/assets/esm_shims.js
+// ../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/esm_shims.js
 import path from "path";
 import { fileURLToPath } from "url";
 var init_esm_shims = __esm({
-  "node_modules/tsup/assets/esm_shims.js"() {
+  "../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/esm_shims.js"() {
     "use strict";
   }
 });
@@ -22,7 +22,7 @@ var init_esm_shims = __esm({
 import { config } from "dotenv";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { dirname, join } from "path";
-var __filename, __dirname, APP_NAME, CONFIG_KEYS, DEFAULT_CONFIG, OAUTH_CONFIG, ATLASSIAN_OAUTH_CONFIG, API_ENDPOINTS, ENCRYPTION_CONFIG, STORAGE_PATHS, HTTP_STATUS, CONFIG_FILES;
+var __filename, __dirname, APP_NAME, CONFIG_KEYS, DEFAULT_CONFIG, OAUTH_CONFIG, ATLASSIAN_OAUTH_CONFIG, GOOGLE_OAUTH_CONFIG, SLACK_OAUTH_CONFIG, API_ENDPOINTS, ENCRYPTION_CONFIG, STORAGE_PATHS, HTTP_STATUS, CONFIG_FILES;
 var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
@@ -55,7 +55,7 @@ var init_constants = __esm({
       TIMEOUT_MS: 12e4,
       // 2 minutes
       MIN_PORT: 8e3,
-      MAX_PORT: 9e3
+      MAX_PORT: 8004
     };
     ATLASSIAN_OAUTH_CONFIG = {
       CLIENT_ID: "kJlsd66DLTnENE8p7Ru2JwqZg1Sie4yZ",
@@ -65,6 +65,16 @@ var init_constants = __esm({
       ACCESSIBLE_RESOURCES_URL: "https://api.atlassian.com/oauth/token/accessible-resources",
       API_GATEWAY_URL: "https://api.atlassian.com"
     };
+    GOOGLE_OAUTH_CONFIG = {
+      CLIENT_ID: "1009691892834-l4hu4qce7jg4a6k1eh2kru0uov1a9fho.apps.googleusercontent.com",
+      AUTH_URL: "https://accounts.google.com/o/oauth2/v2/auth",
+      SCOPES: "https://www.googleapis.com/auth/drive.metadata.readonly"
+    };
+    SLACK_OAUTH_CONFIG = {
+      CLIENT_ID: "2492403850420.10637070025476",
+      AUTH_URL: "https://slack.com/oauth/v2/authorize",
+      USER_SCOPE: "search:read"
+    };
     API_ENDPOINTS = {
       AUTH: {
         INITIATE: "/v1/auth/cli/initiate",
@@ -74,6 +84,13 @@ var init_constants = __esm({
         TOKEN: "/v1/auth/atlassian/token",
         REFRESH: "/v1/auth/atlassian/refresh"
       },
+      GOOGLE: {
+        TOKEN: "/v1/auth/google/token",
+        REFRESH: "/v1/auth/google/refresh"
+      },
+      SLACK: {
+        TOKEN: "/v1/auth/slack/token"
+      },
       BRAGS: {
         CREATE: "/v1/brags",
         LIST: "/v1/brags",
@@ -169,7 +186,7 @@ var init_env_loader = __esm({
 });
 
 // src/utils/errors.ts
-var BragduckError, AuthenticationError, GitError, ApiError, NetworkError, ValidationError, OAuthError, TokenExpiredError, GitHubError, BitbucketError, GitLabError, JiraError, ConfluenceError, AtlassianError;
+var BragduckError, AuthenticationError, GitError, ApiError, NetworkError, ValidationError, OAuthError, TokenExpiredError, GitHubError, BitbucketError, GitLabError, JiraError, ConfluenceError, AtlassianError, GoogleDocsError, SlackError;
 var init_errors = __esm({
   "src/utils/errors.ts"() {
     "use strict";
@@ -266,6 +283,18 @@ var init_errors = __esm({
         this.name = "AtlassianError";
       }
     };
+    GoogleDocsError = class extends BragduckError {
+      constructor(message, details) {
+        super(message, "GOOGLE_DOCS_ERROR", details);
+        this.name = "GoogleDocsError";
+      }
+    };
+    SlackError = class extends BragduckError {
+      constructor(message, details) {
+        super(message, "SLACK_ERROR", details);
+        this.name = "SlackError";
+      }
+    };
   }
 });
 
@@ -788,92 +817,95 @@ async function findAvailablePort() {
 async function startOAuthCallbackServer(expectedState) {
   const port = await findAvailablePort();
   const timeout = OAUTH_CONFIG.TIMEOUT_MS;
-  return new Promise((resolve, reject) => {
+  const callbackUrl = `http://127.0.0.1:${port}${OAUTH_CONFIG.CALLBACK_PATH}`;
+  return new Promise((resolveHandle, rejectHandle) => {
     let server = null;
     let timeoutId = null;
-    const cleanup = () => {
-      if (timeoutId) {
-        globalThis.clearTimeout(timeoutId);
-      }
-      if (server) {
-        if (typeof server.closeAllConnections === "function") {
-          server.closeAllConnections();
-        }
-        server.close(() => {
-          logger.debug("OAuth server closed");
-        });
-        server.unref();
-      }
-    };
-    const handleRequest = (req, res) => {
-      const parsedUrl = parse(req.url || "", true);
-      logger.debug(`OAuth callback received: ${req.url}`);
-      if (parsedUrl.pathname === OAUTH_CONFIG.CALLBACK_PATH) {
-        const { code, state, error, error_description } = parsedUrl.query;
-        if (error) {
-          const errorMsg = error_description || error;
-          logger.debug(`OAuth error: ${errorMsg}`);
-          res.writeHead(400, { "Content-Type": "text/html" });
-          res.end(ERROR_HTML(String(errorMsg)));
-          cleanup();
-          reject(new OAuthError(`OAuth error: ${errorMsg}`));
-          return;
+    const resultPromise = new Promise((resolveResult, rejectResult) => {
+      const cleanup = () => {
+        if (timeoutId) {
+          globalThis.clearTimeout(timeoutId);
         }
-        if (!code || !state) {
-          const errorMsg = "Missing code or state parameter";
-          logger.debug(errorMsg);
-          res.writeHead(400, { "Content-Type": "text/html" });
-          res.end(ERROR_HTML(errorMsg));
-          cleanup();
-          reject(new OAuthError(errorMsg));
-          return;
+        if (server) {
+          if (typeof server.closeAllConnections === "function") {
+            server.closeAllConnections();
+          }
+          server.close(() => {
+            logger.debug("OAuth server closed");
+          });
+          server.unref();
         }
-        if (state !== expectedState) {
-          const errorMsg = "Invalid state parameter (possible CSRF attack)";
-          logger.debug(errorMsg);
-          res.writeHead(400, { "Content-Type": "text/html" });
-          res.end(ERROR_HTML(errorMsg));
-          cleanup();
-          reject(new OAuthError(errorMsg));
+      };
+      const handleRequest = (req, res) => {
+        const parsedUrl = parse(req.url || "", true);
+        logger.debug(`OAuth callback received: ${req.url}`);
+        if (parsedUrl.pathname === OAUTH_CONFIG.CALLBACK_PATH) {
+          const { code, state, error, error_description } = parsedUrl.query;
+          if (error) {
+            const errorMsg = error_description || error;
+            logger.debug(`OAuth error: ${errorMsg}`);
+            res.writeHead(400, { "Content-Type": "text/html" });
+            res.end(ERROR_HTML(String(errorMsg)));
+            cleanup();
+            rejectResult(new OAuthError(`OAuth error: ${errorMsg}`));
+            return;
+          }
+          if (!code || !state) {
+            const errorMsg = "Missing code or state parameter";
+            logger.debug(errorMsg);
+            res.writeHead(400, { "Content-Type": "text/html" });
+            res.end(ERROR_HTML(errorMsg));
+            cleanup();
+            rejectResult(new OAuthError(errorMsg));
+            return;
+          }
+          if (state !== expectedState) {
+            const errorMsg = "Invalid state parameter (possible CSRF attack)";
+            logger.debug(errorMsg);
+            res.writeHead(400, { "Content-Type": "text/html" });
+            res.end(ERROR_HTML(errorMsg));
+            cleanup();
+            rejectResult(new OAuthError(errorMsg));
+            return;
+          }
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(SUCCESS_HTML);
+          globalThis.setTimeout(() => {
+            cleanup();
+            resolveResult({
+              code: String(code),
+              state: String(state),
+              port
+            });
+          }, 100);
           return;
         }
-        res.writeHead(200, { "Content-Type": "text/html" });
-        res.end(SUCCESS_HTML);
-        globalThis.setTimeout(() => {
-          cleanup();
-          resolve({
-            code: String(code),
-            state: String(state),
-            port
-          });
-        }, 100);
-        return;
-      }
-      res.writeHead(404, { "Content-Type": "text/plain" });
-      res.end("Not Found");
-    };
-    server = createServer(handleRequest);
-    server.on("error", (error) => {
-      logger.debug(`OAuth server error: ${error.message}`);
-      cleanup();
-      reject(new OAuthError(`OAuth server error: ${error.message}`));
-    });
-    server.listen(port, "127.0.0.1", () => {
-      logger.debug(
-        `OAuth callback server listening on http://127.0.0.1:${port}${OAUTH_CONFIG.CALLBACK_PATH}`
-      );
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Not Found");
+      };
+      server = createServer(handleRequest);
+      server.on("error", (error) => {
+        logger.debug(`OAuth server error: ${error.message}`);
+        cleanup();
+        rejectResult(new OAuthError(`OAuth server error: ${error.message}`));
+        rejectHandle(new OAuthError(`OAuth server error: ${error.message}`));
+      });
+      server.listen(port, "127.0.0.1", () => {
+        logger.debug(
+          `OAuth callback server listening on http://127.0.0.1:${port}${OAUTH_CONFIG.CALLBACK_PATH}`
+        );
+        resolveHandle({ callbackUrl, resultPromise });
+      });
+      timeoutId = globalThis.setTimeout(() => {
+        logger.debug("OAuth callback timeout");
+        cleanup();
+        rejectResult(
+          new OAuthError("Authentication timeout - no callback received within 2 minutes")
+        );
+      }, timeout);
     });
-    timeoutId = globalThis.setTimeout(() => {
-      logger.debug("OAuth callback timeout");
-      cleanup();
-      reject(new OAuthError("Authentication timeout - no callback received within 2 minutes"));
-    }, timeout);
   });
 }
-async function getCallbackUrl() {
-  const port = await findAvailablePort();
-  return `http://127.0.0.1:${port}${OAUTH_CONFIG.CALLBACK_PATH}`;
-}
 var SUCCESS_HTML, ERROR_HTML;
 var init_oauth_server = __esm({
   "src/utils/oauth-server.ts"() {
@@ -1039,7 +1071,7 @@ var init_browser = __esm({
 // src/services/auth.service.ts
 import { randomBytes as randomBytes2 } from "crypto";
 import { readFileSync as readFileSync2 } from "fs";
-import { fileURLToPath as fileURLToPath3, URLSearchParams } from "url";
+import { fileURLToPath as fileURLToPath3, URLSearchParams as URLSearchParams2 } from "url";
 import { dirname as dirname2, join as join3 } from "path";
 import { ofetch } from "ofetch";
 function getUserAgent() {
@@ -1083,7 +1115,7 @@ var init_auth_service = __esm({
        * Build the OAuth authorization URL
        */
       async buildAuthUrl(state, callbackUrl) {
-        const params = new URLSearchParams({
+        const params = new URLSearchParams2({
           client_id: OAUTH_CONFIG.CLIENT_ID,
           redirect_uri: callbackUrl,
           state
@@ -1136,7 +1168,7 @@ var init_auth_service = __esm({
       async login() {
         logger.debug("Starting OAuth login flow");
         const state = this.generateState();
-        const callbackUrl = await getCallbackUrl();
+        const { callbackUrl, resultPromise } = await startOAuthCallbackServer(state);
         storageService.setOAuthState({
           state,
           createdAt: Date.now()
@@ -1145,7 +1177,6 @@ var init_auth_service = __esm({
         logger.debug(`Callback URL: ${callbackUrl}`);
         const authUrl = await this.buildAuthUrl(state, callbackUrl);
         logger.debug(`Authorization URL: ${authUrl}`);
-        const serverPromise = startOAuthCallbackServer(state);
         try {
           await openBrowser(authUrl);
         } catch {
@@ -1155,7 +1186,7 @@ var init_auth_service = __esm({
         }
         let callbackResult;
         try {
-          callbackResult = await serverPromise;
+          callbackResult = await resultPromise;
         } catch (error) {
           storageService.deleteOAuthState();
           throw error;
@@ -1259,15 +1290,15 @@ __export(version_exports, {
   getCurrentVersion: () => getCurrentVersion,
   version: () => version
 });
-import { readFileSync as readFileSync4 } from "fs";
-import { fileURLToPath as fileURLToPath5 } from "url";
-import { dirname as dirname4, join as join6 } from "path";
+import { readFileSync as readFileSync6 } from "fs";
+import { fileURLToPath as fileURLToPath7 } from "url";
+import { dirname as dirname6, join as join8 } from "path";
 import chalk4 from "chalk";
 import boxen2 from "boxen";
 function getCurrentVersion() {
   try {
-    const packageJsonPath2 = join6(__dirname5, "../../package.json");
-    const packageJson2 = JSON.parse(readFileSync4(packageJsonPath2, "utf-8"));
+    const packageJsonPath2 = join8(__dirname7, "../../package.json");
+    const packageJson2 = JSON.parse(readFileSync6(packageJsonPath2, "utf-8"));
     return packageJson2.version;
   } catch {
     logger.debug("Failed to read package.json version");
@@ -1349,7 +1380,7 @@ function formatVersion(includePrefix = true) {
   const prefix = includePrefix ? "v" : "";
   return `${prefix}${version}`;
 }
-var __filename5, __dirname5, version;
+var __filename7, __dirname7, version;
 var init_version = __esm({
   "src/utils/version.ts"() {
     "use strict";
@@ -1357,22 +1388,22 @@ var init_version = __esm({
     init_api_service();
     init_storage_service();
     init_logger();
-    __filename5 = fileURLToPath5(import.meta.url);
-    __dirname5 = dirname4(__filename5);
+    __filename7 = fileURLToPath7(import.meta.url);
+    __dirname7 = dirname6(__filename7);
     version = getCurrentVersion();
   }
 });
 
 // src/services/api.service.ts
-import { ofetch as ofetch3 } from "ofetch";
-import { readFileSync as readFileSync5 } from "fs";
-import { fileURLToPath as fileURLToPath6 } from "url";
-import { URLSearchParams as URLSearchParams3 } from "url";
-import { dirname as dirname5, join as join7 } from "path";
+import { ofetch as ofetch5 } from "ofetch";
+import { readFileSync as readFileSync7 } from "fs";
+import { fileURLToPath as fileURLToPath8 } from "url";
+import { URLSearchParams as URLSearchParams6 } from "url";
+import { dirname as dirname7, join as join9 } from "path";
 function getCliVersion() {
   try {
-    const packageJsonPath2 = join7(__dirname6, "../../package.json");
-    const packageJson2 = JSON.parse(readFileSync5(packageJsonPath2, "utf-8"));
+    const packageJsonPath2 = join9(__dirname8, "../../package.json");
+    const packageJson2 = JSON.parse(readFileSync7(packageJsonPath2, "utf-8"));
     return packageJson2.version;
   } catch {
     logger.debug("Failed to read package.json version");
@@ -1384,7 +1415,7 @@ function getPlatformInfo() {
   const arch = process.arch;
   return `${platform}-${arch}`;
 }
-var __filename6, __dirname6, ApiService, apiService;
+var __filename8, __dirname8, ApiService, apiService;
 var init_api_service = __esm({
   "src/services/api.service.ts"() {
     "use strict";
@@ -1393,14 +1424,14 @@ var init_api_service = __esm({
     init_constants();
     init_errors();
     init_logger();
-    __filename6 = fileURLToPath6(import.meta.url);
-    __dirname6 = dirname5(__filename6);
+    __filename8 = fileURLToPath8(import.meta.url);
+    __dirname8 = dirname7(__filename8);
     ApiService = class {
       baseURL;
       client;
       constructor() {
         this.baseURL = process.env.API_BASE_URL || "https://api.bragduck.com";
-        this.client = ofetch3.create({
+        this.client = ofetch5.create({
           baseURL: this.baseURL,
           // Request interceptor
           onRequest: async ({ request, options }) => {
@@ -1564,7 +1595,7 @@ var init_api_service = __esm({
         const { limit = 50, offset = 0, tags, search } = params;
         logger.debug(`Listing brags: limit=${limit}, offset=${offset}`);
         try {
-          const queryParams = new URLSearchParams3({
+          const queryParams = new URLSearchParams6({
             limit: limit.toString(),
             offset: offset.toString()
           });
@@ -1661,7 +1692,7 @@ var init_api_service = __esm({
        */
       setBaseURL(url) {
         this.baseURL = url;
-        this.client = ofetch3.create({
+        this.client = ofetch5.create({
           baseURL: url
         });
       }
@@ -1679,9 +1710,9 @@ var init_api_service = __esm({
 // src/cli.ts
 init_esm_shims();
 import { Command } from "commander";
-import { readFileSync as readFileSync6 } from "fs";
-import { fileURLToPath as fileURLToPath7 } from "url";
-import { dirname as dirname6, join as join8 } from "path";
+import { readFileSync as readFileSync8 } from "fs";
+import { fileURLToPath as fileURLToPath9 } from "url";
+import { dirname as dirname8, join as join10 } from "path";
 
 // src/commands/auth.ts
 init_esm_shims();
@@ -1700,7 +1731,7 @@ init_errors();
 init_logger();
 import { randomBytes as randomBytes3 } from "crypto";
 import { readFileSync as readFileSync3 } from "fs";
-import { fileURLToPath as fileURLToPath4, URLSearchParams as URLSearchParams2 } from "url";
+import { fileURLToPath as fileURLToPath4, URLSearchParams as URLSearchParams3 } from "url";
 import { dirname as dirname3, join as join4 } from "path";
 import { ofetch as ofetch2 } from "ofetch";
 import { select } from "@inquirer/prompts";
@@ -1735,7 +1766,7 @@ var AtlassianAuthService = class {
    * Build the Atlassian OAuth authorization URL
    */
   buildAuthUrl(state, callbackUrl) {
-    const params = new URLSearchParams2({
+    const params = new URLSearchParams3({
       audience: ATLASSIAN_OAUTH_CONFIG.AUDIENCE,
       client_id: ATLASSIAN_OAUTH_CONFIG.CLIENT_ID,
       scope: ATLASSIAN_OAUTH_CONFIG.SCOPES,
@@ -1833,7 +1864,7 @@ var AtlassianAuthService = class {
   async login() {
     logger.debug("Starting Atlassian OAuth login flow");
     const state = this.generateState();
-    const callbackUrl = await getCallbackUrl();
+    const { callbackUrl, resultPromise } = await startOAuthCallbackServer(state);
     storageService.setOAuthState({
       state,
       createdAt: Date.now()
@@ -1842,7 +1873,6 @@ var AtlassianAuthService = class {
     logger.debug(`Callback URL: ${callbackUrl}`);
     const authUrl = this.buildAuthUrl(state, callbackUrl);
     logger.debug(`Authorization URL: ${authUrl}`);
-    const serverPromise = startOAuthCallbackServer(state);
     try {
       await openBrowser(authUrl);
     } catch {
@@ -1852,7 +1882,7 @@ var AtlassianAuthService = class {
     }
     let callbackResult;
     try {
-      callbackResult = await serverPromise;
+      callbackResult = await resultPromise;
     } catch (error) {
       storageService.deleteOAuthState();
       throw error;
@@ -1937,6 +1967,348 @@ var AtlassianAuthService = class {
 };
 var atlassianAuthService = new AtlassianAuthService();
 
+// src/services/google-auth.service.ts
+init_esm_shims();
+init_constants();
+init_storage_service();
+init_oauth_server();
+init_browser();
+init_errors();
+init_logger();
+import { randomBytes as randomBytes4 } from "crypto";
+import { readFileSync as readFileSync4 } from "fs";
+import { fileURLToPath as fileURLToPath5, URLSearchParams as URLSearchParams4 } from "url";
+import { dirname as dirname4, join as join5 } from "path";
+import { ofetch as ofetch3 } from "ofetch";
+var __filename5 = fileURLToPath5(import.meta.url);
+var __dirname5 = dirname4(__filename5);
+function getUserAgent3() {
+  try {
+    const packageJsonPath2 = join5(__dirname5, "../../package.json");
+    const packageJson2 = JSON.parse(readFileSync4(packageJsonPath2, "utf-8"));
+    const version2 = packageJson2.version;
+    const platform = process.platform;
+    const arch = process.arch;
+    return `BragDuck-CLI/${version2} (${platform}-${arch})`;
+  } catch {
+    logger.debug("Failed to read package.json version");
+    return "BragDuck-CLI/2.0.0";
+  }
+}
+var GoogleAuthService = class {
+  apiBaseUrl;
+  refreshPromise = null;
+  constructor() {
+    this.apiBaseUrl = process.env.API_BASE_URL || "https://api.bragduck.com";
+  }
+  /**
+   * Generate a random state string for CSRF protection
+   */
+  generateState() {
+    return randomBytes4(32).toString("hex");
+  }
+  /**
+   * Build the Google OAuth authorization URL
+   */
+  buildAuthUrl(state, callbackUrl) {
+    const params = new URLSearchParams4({
+      client_id: GOOGLE_OAUTH_CONFIG.CLIENT_ID,
+      scope: GOOGLE_OAUTH_CONFIG.SCOPES,
+      redirect_uri: callbackUrl,
+      state,
+      response_type: "code",
+      access_type: "offline",
+      prompt: "consent"
+    });
+    return `${GOOGLE_OAUTH_CONFIG.AUTH_URL}?${params.toString()}`;
+  }
+  /**
+   * Exchange authorization code for tokens via BragDuck backend
+   */
+  async exchangeCodeForToken(code, redirectUri) {
+    try {
+      const tokenUrl = `${this.apiBaseUrl}${API_ENDPOINTS.GOOGLE.TOKEN}`;
+      logger.debug(`Exchanging Google authorization code via: ${tokenUrl}`);
+      const response = await ofetch3(tokenUrl, {
+        method: "POST",
+        body: {
+          code,
+          redirect_uri: redirectUri
+        },
+        headers: {
+          "Content-Type": "application/json",
+          "User-Agent": getUserAgent3()
+        }
+      });
+      logger.debug("Google token exchange successful");
+      return response;
+    } catch (error) {
+      const detail = error?.data?.message || error?.data?.error_description || error.message;
+      logger.debug(`Google token exchange failed: ${detail}`);
+      throw new GoogleDocsError(`Failed to exchange Google authorization code: ${detail}`);
+    }
+  }
+  /**
+   * Full OAuth login flow:
+   * 1. Open browser to Google consent screen
+   * 2. Wait for callback with authorization code
+   * 3. Exchange code for tokens via BragDuck backend
+   * 4. Store credentials under 'google-docs'
+   */
+  async login() {
+    logger.debug("Starting Google OAuth login flow");
+    const state = this.generateState();
+    const { callbackUrl: rawCallbackUrl, resultPromise } = await startOAuthCallbackServer(state);
+    const callbackUrl = rawCallbackUrl.replace("127.0.0.1", "localhost");
+    storageService.setOAuthState({
+      state,
+      createdAt: Date.now()
+    });
+    logger.debug(`OAuth state: ${state}`);
+    logger.debug(`Callback URL: ${callbackUrl}`);
+    const authUrl = this.buildAuthUrl(state, callbackUrl);
+    logger.debug(`Authorization URL: ${authUrl}`);
+    try {
+      await openBrowser(authUrl);
+    } catch {
+      logger.warning("Could not open browser automatically");
+      logger.info("Please open this URL in your browser:");
+      logger.log(authUrl);
+    }
+    let callbackResult;
+    try {
+      callbackResult = await resultPromise;
+    } catch (error) {
+      storageService.deleteOAuthState();
+      throw error;
+    }
+    storageService.deleteOAuthState();
+    const tokenResponse = await this.exchangeCodeForToken(callbackResult.code, callbackUrl);
+    const expiresAt = tokenResponse.expires_in ? Date.now() + tokenResponse.expires_in * 1e3 : void 0;
+    const credentials = {
+      accessToken: tokenResponse.access_token,
+      refreshToken: tokenResponse.refresh_token,
+      expiresAt,
+      authMethod: "oauth"
+    };
+    await storageService.setServiceCredentials("google-docs", credentials);
+    logger.debug("Google OAuth login successful");
+    let email = "authenticated";
+    try {
+      const about = await ofetch3(
+        "https://www.googleapis.com/drive/v3/about?fields=user",
+        {
+          headers: {
+            Authorization: `Bearer ${tokenResponse.access_token}`
+          }
+        }
+      );
+      email = about.user?.emailAddress || email;
+    } catch {
+      logger.debug("Could not fetch Google user info after login");
+    }
+    return { email };
+  }
+  /**
+   * Refresh Google OAuth tokens via BragDuck backend.
+   * Uses a singleton promise to prevent concurrent refresh race conditions.
+   */
+  async refreshToken() {
+    if (this.refreshPromise) {
+      return this.refreshPromise;
+    }
+    this.refreshPromise = this.doRefreshToken();
+    try {
+      await this.refreshPromise;
+    } finally {
+      this.refreshPromise = null;
+    }
+  }
+  async doRefreshToken() {
+    logger.debug("Refreshing Google OAuth token");
+    const creds = await storageService.getServiceCredentials("google-docs");
+    if (!creds?.refreshToken) {
+      throw new GoogleDocsError("No Google refresh token available", {
+        hint: "Run: bragduck auth google"
+      });
+    }
+    try {
+      const response = await ofetch3(
+        `${this.apiBaseUrl}${API_ENDPOINTS.GOOGLE.REFRESH}`,
+        {
+          method: "POST",
+          body: {
+            refresh_token: creds.refreshToken
+          },
+          headers: {
+            "Content-Type": "application/json",
+            "User-Agent": getUserAgent3()
+          }
+        }
+      );
+      const expiresAt = response.expires_in ? Date.now() + response.expires_in * 1e3 : void 0;
+      const updatedCreds = {
+        ...creds,
+        accessToken: response.access_token,
+        refreshToken: response.refresh_token ?? creds.refreshToken,
+        expiresAt
+      };
+      await storageService.setServiceCredentials("google-docs", updatedCreds);
+      logger.debug("Google token refresh successful");
+    } catch (error) {
+      const detail = error?.data?.message || error?.data?.error_description || error.message;
+      logger.debug(`Google token refresh failed: ${detail}`);
+      throw new GoogleDocsError(
+        `Google token refresh failed: ${detail}. Please run "bragduck auth google" to re-authenticate.`
+      );
+    }
+  }
+};
+var googleAuthService = new GoogleAuthService();
+
+// src/services/slack-auth.service.ts
+init_esm_shims();
+init_constants();
+init_storage_service();
+init_browser();
+init_errors();
+init_logger();
+import { randomBytes as randomBytes5 } from "crypto";
+import { readFileSync as readFileSync5 } from "fs";
+import { fileURLToPath as fileURLToPath6, URLSearchParams as URLSearchParams5 } from "url";
+import { dirname as dirname5, join as join6 } from "path";
+import { ofetch as ofetch4 } from "ofetch";
+var __filename6 = fileURLToPath6(import.meta.url);
+var __dirname6 = dirname5(__filename6);
+var POLL_INTERVAL_MS = 2e3;
+var POLL_TIMEOUT_MS = 12e4;
+function getUserAgent4() {
+  try {
+    const packageJsonPath2 = join6(__dirname6, "../../package.json");
+    const packageJson2 = JSON.parse(readFileSync5(packageJsonPath2, "utf-8"));
+    const version2 = packageJson2.version;
+    const platform = process.platform;
+    const arch = process.arch;
+    return `BragDuck-CLI/${version2} (${platform}-${arch})`;
+  } catch {
+    logger.debug("Failed to read package.json version");
+    return "BragDuck-CLI/2.0.0";
+  }
+}
+var SlackAuthService = class {
+  apiBaseUrl;
+  constructor() {
+    this.apiBaseUrl = process.env.API_BASE_URL || "https://api.bragduck.com";
+  }
+  /**
+   * The HTTPS redirect URI registered with Slack.
+   * Slack redirects here after the user authorises.
+   */
+  get redirectUri() {
+    return `${this.apiBaseUrl}/v1/auth/slack/callback`;
+  }
+  /**
+   * Generate a random state string for CSRF protection
+   */
+  generateState() {
+    return randomBytes5(32).toString("hex");
+  }
+  /**
+   * Build the Slack OAuth v2 authorization URL.
+   * Uses user_scope param (not scope) to request a user token.
+   */
+  buildAuthUrl(state) {
+    const params = new URLSearchParams5({
+      client_id: SLACK_OAUTH_CONFIG.CLIENT_ID,
+      user_scope: SLACK_OAUTH_CONFIG.USER_SCOPE,
+      redirect_uri: this.redirectUri,
+      state
+    });
+    return `${SLACK_OAUTH_CONFIG.AUTH_URL}?${params.toString()}`;
+  }
+  /**
+   * Poll the BragDuck backend until the Slack callback arrives or timeout
+   */
+  async pollForCode(state) {
+    const pollUrl = `${this.apiBaseUrl}/v1/auth/slack/poll`;
+    const deadline = Date.now() + POLL_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+      await new Promise((r) => globalThis.setTimeout(r, POLL_INTERVAL_MS));
+      const result = await ofetch4(`${pollUrl}?state=${state}`, {
+        headers: { "User-Agent": getUserAgent4() }
+      }).catch(() => null);
+      if (!result) continue;
+      if (result.status === "complete" && result.code) {
+        return result.code;
+      }
+      if (result.status === "error") {
+        throw new SlackError(`Slack OAuth error: ${result.error}`);
+      }
+    }
+    throw new SlackError("Slack authentication timed out. Please try again.");
+  }
+  /**
+   * Exchange authorization code for a user token via BragDuck backend
+   */
+  async exchangeCodeForToken(code) {
+    try {
+      const tokenUrl = `${this.apiBaseUrl}${API_ENDPOINTS.SLACK.TOKEN}`;
+      logger.debug(`Exchanging Slack authorization code via: ${tokenUrl}`);
+      const response = await ofetch4(tokenUrl, {
+        method: "POST",
+        body: {
+          code,
+          redirect_uri: this.redirectUri
+        },
+        headers: {
+          "Content-Type": "application/json",
+          "User-Agent": getUserAgent4()
+        }
+      });
+      logger.debug("Slack token exchange successful");
+      return response;
+    } catch (error) {
+      const detail = error?.data?.message || error?.data?.error_description || error.message;
+      logger.debug(`Slack token exchange failed: ${detail}`);
+      throw new SlackError(`Failed to exchange Slack authorization code: ${detail}`);
+    }
+  }
+  /**
+   * Full OAuth login flow:
+   * 1. Open browser to Slack consent screen (redirect_uri → BragDuck backend)
+   * 2. Poll backend until the code arrives
+   * 3. Exchange code for user token
+   * 4. Store credentials under 'slack' service key
+   * Returns team name for confirmation display.
+   */
+  async login() {
+    logger.debug("Starting Slack OAuth login flow");
+    const state = this.generateState();
+    const authUrl = this.buildAuthUrl(state);
+    logger.debug(`Authorization URL: ${authUrl}`);
+    logger.debug(`Redirect URI: ${this.redirectUri}`);
+    try {
+      await openBrowser(authUrl);
+    } catch {
+      logger.warning("Could not open browser automatically");
+      logger.info("Please open this URL in your browser:");
+      logger.log(authUrl);
+    }
+    logger.info("Waiting for Slack authorization...");
+    const code = await this.pollForCode(state);
+    const tokenResponse = await this.exchangeCodeForToken(code);
+    const credentials = {
+      accessToken: tokenResponse.access_token,
+      username: tokenResponse.user_id,
+      authMethod: "oauth"
+    };
+    await storageService.setServiceCredentials("slack", credentials);
+    logger.debug("Slack OAuth login successful");
+    return { teamName: tokenResponse.team_name };
+  }
+};
+var slackAuthService = new SlackAuthService();
+
 // src/commands/auth.ts
 init_storage_service();
 
@@ -1955,9 +2327,9 @@ import simpleGit from "simple-git";
 init_esm_shims();
 init_errors();
 import { existsSync as existsSync2 } from "fs";
-import { join as join5 } from "path";
+import { join as join7 } from "path";
 function validateGitRepository(path4) {
-  const gitDir = join5(path4, ".git");
+  const gitDir = join7(path4, ".git");
   if (!existsSync2(gitDir)) {
     throw new GitError(
       "Not a git repository. Please run this command from within a git repository.",
@@ -2268,6 +2640,18 @@ var GitHubService = class {
         });
       }
       if (error.message?.includes("Could not resolve to a Repository")) {
+        try {
+          const { stdout: remoteUrl } = await execAsync2("command git remote get-url origin", {
+            cwd: repoPath || process.cwd()
+          });
+          if (remoteUrl.includes("github.com")) {
+            throw new GitHubError("Cannot access this GitHub repository", {
+              hint: 'For private repositories, run "gh auth refresh -s repo" to add the required scope'
+            });
+          }
+        } catch (remoteErr) {
+          if (remoteErr instanceof GitHubError) throw remoteErr;
+        }
         throw new GitHubError("This repository is not hosted on GitHub", {
           hint: "Only GitHub repositories are currently supported for PR scanning"
         });
@@ -2575,9 +2959,15 @@ async function authCommand(subcommand) {
     await authGitLab();
   } else if (subcommand === "atlassian") {
     await authAtlassian();
+  } else if (subcommand === "google") {
+    await authGoogle();
+  } else if (subcommand === "slack") {
+    await authSlack();
   } else {
     logger.error(`Unknown auth subcommand: ${subcommand}`);
-    logger.info("Available subcommands: login, status, bitbucket, gitlab, atlassian");
+    logger.info(
+      "Available subcommands: login, status, bitbucket, gitlab, atlassian, google, slack"
+    );
     process.exit(1);
   }
 }
@@ -2649,43 +3039,87 @@ async function authStatus() {
   logger.log("");
   logger.info("Authentication Status:");
   logger.log("");
-  const services = await storageService.getAuthenticatedServices();
   const bragduckAuth = await storageService.isServiceAuthenticated("bragduck");
   if (bragduckAuth) {
     const userInfo = authService.getUserInfo();
     logger.info(`${colors.success("\u2713")} Bragduck: ${userInfo?.name || "Authenticated"}`);
   } else {
     logger.info(`${colors.error("\u2717")} Bragduck: Not authenticated`);
+    logger.info(theme.secondary(`  Run: bragduck auth login`));
   }
+  logger.log("");
+  logger.info("Git Sources:");
+  logger.log("");
   const ghStatus = await githubService.getAuthStatus();
   if (ghStatus.installed) {
     if (ghStatus.authenticated) {
-      logger.info(`${colors.success("\u2713")} GitHub CLI (gh): Authenticated`);
+      logger.info(`${colors.success("\u2713")} GitHub: Authenticated`);
     } else {
-      logger.info(`${colors.error("\u2717")} GitHub CLI (gh): Not authenticated`);
+      logger.info(`${colors.error("\u2717")} GitHub: Not authenticated`);
       logger.info(theme.secondary("  Run: gh auth login"));
     }
   } else {
-    logger.info(`${colors.error("\u2717")} GitHub CLI (gh): Not installed`);
+    logger.info(`${colors.error("\u2717")} GitHub: gh CLI not installed`);
     logger.info(theme.secondary("  Install from: https://cli.github.com"));
   }
-  for (const service of services) {
-    if (service !== "bragduck") {
-      const creds = await storageService.getServiceCredentials(service);
-      let methodLabel = "";
-      if (creds?.authMethod === "oauth") {
-        methodLabel = " (Cloud - OAuth)";
-      } else if (creds?.authMethod === "basic") {
-        methodLabel = " (Server - API Token)";
-      }
-      logger.info(`${colors.success("\u2713")} ${service}: Authenticated${methodLabel}`);
-    }
+  const gitlabAuth = await storageService.isServiceAuthenticated("gitlab");
+  if (gitlabAuth) {
+    const creds = await storageService.getServiceCredentials("gitlab");
+    const instanceLabel = creds?.instanceUrl ? ` (${creds.instanceUrl})` : " (gitlab.com)";
+    logger.info(`${colors.success("\u2713")} GitLab: Authenticated${instanceLabel}`);
+  } else {
+    logger.info(`${colors.error("\u2717")} GitLab: Not connected`);
+    logger.info(theme.secondary("  Run: bragduck auth gitlab"));
+  }
+  const bitbucketAuth = await storageService.isServiceAuthenticated("bitbucket");
+  if (bitbucketAuth) {
+    const creds = await storageService.getServiceCredentials("bitbucket");
+    const userLabel = creds?.username ? ` (${creds.username})` : "";
+    logger.info(`${colors.success("\u2713")} Bitbucket: Authenticated${userLabel}`);
+  } else {
+    logger.info(`${colors.error("\u2717")} Bitbucket: Not connected`);
+    logger.info(theme.secondary("  Run: bragduck auth bitbucket"));
   }
   logger.log("");
-  if (services.length === 0) {
-    logger.info(`Run ${theme.command("bragduck auth login")} to authenticate with Bragduck`);
-    logger.log("");
+  logger.info("Project Management:");
+  logger.log("");
+  const jiraAuth = await storageService.isServiceAuthenticated("jira");
+  const confluenceAuth = await storageService.isServiceAuthenticated("confluence");
+  if (jiraAuth || confluenceAuth) {
+    const creds = await storageService.getServiceCredentials("jira");
+    let methodLabel = "";
+    if (creds?.authMethod === "oauth") {
+      methodLabel = " (Cloud - OAuth)";
+    } else if (creds?.authMethod === "basic") {
+      methodLabel = " (Server - API Token)";
+    }
+    logger.info(`${colors.success("\u2713")} Atlassian${methodLabel}`);
+    if (jiraAuth) logger.info(theme.secondary("  \xB7 Jira"));
+    if (confluenceAuth) logger.info(theme.secondary("  \xB7 Confluence"));
+  } else {
+    logger.info(`${colors.error("\u2717")} Atlassian (Jira + Confluence): Not connected`);
+    logger.info(theme.secondary("  Run: bragduck auth atlassian"));
+  }
+  logger.log("");
+  logger.info("Document Sources:");
+  logger.log("");
+  const googleDocsAuth = await storageService.isServiceAuthenticated("google-docs");
+  if (googleDocsAuth) {
+    logger.info(`${colors.success("\u2713")} Google Docs (OAuth)`);
+  } else {
+    logger.info(`${colors.error("\u2717")} Google Docs: Not connected`);
+    logger.info(theme.secondary("  Run: bragduck auth google"));
+  }
+  const slackAuth = await storageService.isServiceAuthenticated("slack");
+  if (slackAuth) {
+    const creds = await storageService.getServiceCredentials("slack");
+    const userLabel = creds?.username ? ` (user: ${creds.username})` : "";
+    logger.info(`${colors.success("\u2713")} Slack: Connected${userLabel}`);
+  } else {
+    logger.info(`${colors.error("\u2717")} Slack: Not connected`);
+    logger.info(theme.secondary("  Run: bragduck auth slack"));
   }
+  logger.log("");
 }
 async function authBitbucket() {
   logger.log("");
@@ -2862,11 +3296,75 @@ Services configured:
     process.exit(1);
   }
 }
+async function authGoogle() {
+  logger.log("");
+  logger.info("Opening browser for Google authentication...");
+  logger.log("");
+  try {
+    const result = await googleAuthService.login();
+    logger.log("");
+    logger.log(
+      boxen(
+        theme.success("\u2713 Successfully authenticated with Google") + `
+
+Account: ${result.email}
+
+Services configured:
+  - Google Docs (OAuth)`,
+        boxStyles.success
+      )
+    );
+    logger.log("");
+  } catch (error) {
+    const err = error;
+    logger.log("");
+    logger.log(
+      boxen(
+        theme.error("\u2717 Authentication Failed") + "\n\n" + (err.message || "Unknown error"),
+        boxStyles.error
+      )
+    );
+    logger.log("");
+    process.exit(1);
+  }
+}
+async function authSlack() {
+  logger.log("");
+  logger.info("Opening browser for Slack authentication...");
+  logger.log("");
+  try {
+    const result = await slackAuthService.login();
+    logger.log("");
+    logger.log(
+      boxen(
+        theme.success("\u2713 Successfully authenticated with Slack") + `
+
+Workspace: ${result.teamName}
+
+Services configured:
+  - Slack messages (OAuth)`,
+        boxStyles.success
+      )
+    );
+    logger.log("");
+  } catch (error) {
+    const err = error;
+    logger.log("");
+    logger.log(
+      boxen(
+        theme.error("\u2717 Authentication Failed") + "\n\n" + (err.message || "Unknown error"),
+        boxStyles.error
+      )
+    );
+    logger.log("");
+    process.exit(1);
+  }
+}
 
 // src/commands/sync.ts
 init_esm_shims();
 
-// node_modules/@inquirer/core/dist/esm/lib/errors.mjs
+// ../../node_modules/.pnpm/@inquirer+core@9.2.1/node_modules/@inquirer/core/dist/esm/lib/errors.mjs
 init_esm_shims();
 var CancelPromptError = class extends Error {
   name = "CancelPromptError";
@@ -2878,7 +3376,7 @@ init_api_service();
 init_storage_service();
 init_auth_service();
 import { select as select4 } from "@inquirer/prompts";
-import boxen6 from "boxen";
+import boxen5 from "boxen";
 
 // src/utils/source-detector.ts
 init_esm_shims();
@@ -3458,7 +3956,7 @@ init_logger();
 init_storage_service();
 import { exec as exec5 } from "child_process";
 import { promisify as promisify5 } from "util";
-import { URLSearchParams as URLSearchParams4 } from "url";
+import { URLSearchParams as URLSearchParams7 } from "url";
 var execAsync5 = promisify5(exec5);
 var GitLabService = class {
   DEFAULT_INSTANCE = "https://gitlab.com";
@@ -3604,7 +4102,7 @@ var GitLabService = class {
   async getMergedMRs(options = {}) {
     const { projectPath } = await this.getProjectFromGit();
     const encodedPath = encodeURIComponent(projectPath);
-    const params = new URLSearchParams4({
+    const params = new URLSearchParams7({
       state: "merged",
       order_by: "updated_at",
       sort: "desc",
@@ -4072,6 +4570,9 @@ var JiraService = class {
         logger.debug(
           `Fetched ${newIssuesCount} new issues (total: ${allIssues.length} of ${response.total})${startAt + maxResults < response.total ? ", fetching next page..." : ""}`
         );
+        if (options.onProgress) {
+          options.onProgress(allIssues.length, response.total);
+        }
         if (newIssuesCount === 0) {
           logger.debug("All results are duplicates, stopping pagination");
           break;
@@ -4239,7 +4740,8 @@ var jiraSyncAdapter = {
     return jiraService.getIssues({
       days: options.days,
       limit: options.limit,
-      author: author || void 0
+      author: author || void 0,
+      onProgress: options.onProgress
     });
   },
   async isAuthenticated() {
@@ -4557,6 +5059,9 @@ var ConfluenceService = class {
         logger.debug(
           `Fetched ${newPagesCount} new pages (total: ${allPages.length}, duplicates: ${response.results.length - newPagesCount})${response.size === limit ? ", fetching next page..." : ""}`
         );
+        if (options.onProgress) {
+          options.onProgress(allPages.length);
+        }
         if (newPagesCount === 0) {
           logger.debug("All results are duplicates, stopping pagination");
           break;
@@ -4706,7 +5211,8 @@ var confluenceSyncAdapter = {
     return confluenceService.getPages({
       days: options.days,
       limit: options.limit,
-      author: author || void 0
+      author: author || void 0,
+      onProgress: options.onProgress ? (fetched) => options.onProgress(fetched, 0) : void 0
     });
   },
   async isAuthenticated() {
@@ -4722,174 +5228,526 @@ var confluenceSyncAdapter = {
   }
 };
 
-// src/sync/adapter-factory.ts
-var AdapterFactory = class {
+// src/sync/google-docs-adapter.ts
+init_esm_shims();
+
+// src/services/google-docs.service.ts
+init_esm_shims();
+init_errors();
+init_logger();
+init_storage_service();
+var GoogleDocsService = class {
   /**
-   * Get adapter for a specific source type
+   * Get stored Google credentials, auto-refreshing OAuth tokens if expired
    */
-  static getAdapter(source, repoPath) {
-    switch (source) {
-      case "github":
-        return repoPath ? new GitHubSyncAdapter(repoPath) : githubSyncAdapter;
-      case "bitbucket":
-      case "atlassian":
-        return repoPath ? new BitbucketSyncAdapter(repoPath) : bitbucketSyncAdapter;
-      case "gitlab":
-        return repoPath ? new GitLabSyncAdapter(repoPath) : gitlabSyncAdapter;
-      case "jira":
-        return jiraSyncAdapter;
-      case "confluence":
-        return confluenceSyncAdapter;
+  async getCredentials() {
+    const creds = await storageService.getServiceCredentials("google-docs");
+    if (!creds || !creds.accessToken) {
+      throw new GoogleDocsError("Not authenticated with Google Docs", {
+        hint: "Run: bragduck auth google"
+      });
+    }
+    if (creds.expiresAt && creds.expiresAt < Date.now()) {
+      if (creds.refreshToken) {
+        logger.debug("Google OAuth token expired, refreshing...");
+        await googleAuthService.refreshToken();
+        const refreshed = await storageService.getServiceCredentials("google-docs");
+        if (!refreshed?.accessToken) {
+          throw new GoogleDocsError("Token refresh failed", {
+            hint: "Run: bragduck auth google"
+          });
+        }
+        return refreshed;
+      }
+      throw new GoogleDocsError("OAuth token has expired and no refresh token available", {
+        hint: "Run: bragduck auth google"
+      });
+    }
+    return creds;
+  }
+  /**
+   * Make authenticated request to Google APIs.
+   * Retries once on 401 (auto-refresh).
+   */
+  async request(url) {
+    const creds = await this.getCredentials();
+    logger.debug(`Google API: GET ${url}`);
+    const options = {
+      headers: {
+        Authorization: `Bearer ${creds.accessToken}`,
+        Accept: "application/json"
+      }
+    };
+    let response = await fetch(url, options);
+    if (response.status === 401 && creds.refreshToken) {
+      logger.debug("Google API 401, attempting token refresh and retry");
+      await googleAuthService.refreshToken();
+      const refreshedCreds = await storageService.getServiceCredentials("google-docs");
+      if (refreshedCreds?.accessToken) {
+        response = await fetch(url, {
+          headers: {
+            Authorization: `Bearer ${refreshedCreds.accessToken}`,
+            Accept: "application/json"
+          }
+        });
+      }
+    }
+    if (!response.ok) {
+      const status = response.status;
+      const statusText = response.statusText;
+      let errorDetail = statusText;
+      try {
+        const body = await response.json();
+        errorDetail = body?.error?.message || body?.error?.errors?.[0]?.message || statusText;
+        logger.debug(`Google API error body: ${JSON.stringify(body)}`);
+      } catch {
+      }
+      if (status === 401) {
+        throw new GoogleDocsError(`Invalid or expired Google token: ${errorDetail}`, {
+          hint: "Run: bragduck auth google"
+        });
+      } else if (status === 403) {
+        throw new GoogleDocsError(`Forbidden - check Drive API permissions: ${errorDetail}`, {
+          hint: "Token needs: drive.metadata.readonly"
+        });
+      } else if (status === 429) {
+        throw new GoogleDocsError("Rate limit exceeded", {
+          hint: "Wait a few minutes before trying again"
+        });
+      }
+      throw new GoogleDocsError(`API request failed: ${errorDetail}`);
+    }
+    return response.json();
+  }
+  /**
+   * Get current user's email address via Drive API (works with drive.metadata.readonly scope)
+   */
+  async getCurrentUser() {
+    try {
+      const about = await this.request(
+        "https://www.googleapis.com/drive/v3/about?fields=user"
+      );
+      return about.user?.emailAddress || null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Validate Google credentials using Drive API (drive.metadata.readonly scope is sufficient)
+   */
+  async validateCredentials() {
+    try {
+      await this.request(
+        "https://www.googleapis.com/drive/v3/about?fields=user"
+      );
+    } catch (error) {
+      if (error instanceof GoogleDocsError) {
+        throw error;
+      }
+      throw new GoogleDocsError("Could not access Google Drive API", {
+        hint: "Check that your credentials are valid",
+        originalError: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  /**
+   * Map Google Workspace MIME type to a short display label
+   */
+  getMimeTypeLabel(mimeType) {
+    switch (mimeType) {
+      case "application/vnd.google-apps.document":
+        return "Doc";
+      case "application/vnd.google-apps.spreadsheet":
+        return "Sheet";
+      case "application/vnd.google-apps.presentation":
+        return "Slides";
       default:
-        throw new Error(`Unknown source type: ${source}`);
+        return "Doc";
     }
   }
   /**
-   * Check if adapter is available for source
+   * Transform a Google Drive file to GitCommit format
    */
-  static isSupported(source) {
-    return source === "github" || source === "bitbucket" || source === "atlassian" || source === "gitlab" || source === "jira" || source === "confluence";
+  transformDocToCommit(file) {
+    const isOwner = file.owners?.[0]?.me === true;
+    const contributionType = isOwner ? "created" : "edited";
+    const typeLabel = this.getMimeTypeLabel(file.mimeType);
+    return {
+      sha: file.id,
+      message: `Google Doc [${typeLabel}]: ${file.name}`,
+      author: file.lastModifyingUser?.displayName || "Unknown",
+      authorEmail: file.lastModifyingUser?.emailAddress || "unknown@example.com",
+      date: file.modifiedByMeTime || file.modifiedTime,
+      url: file.webViewLink,
+      diffStats: {
+        filesChanged: 1,
+        insertions: 50,
+        deletions: 0
+      },
+      externalId: file.id,
+      externalType: contributionType,
+      externalSource: "google-docs",
+      externalUrl: file.webViewLink
+    };
+  }
+  /**
+   * Fetch Google Docs the user has contributed to
+   */
+  async getDocs(options = {}) {
+    const allFiles = [];
+    let pageToken;
+    const pageSize = 100;
+    let cutoffDate = "";
+    if (options.days) {
+      const cutoff = /* @__PURE__ */ new Date();
+      cutoff.setDate(cutoff.getDate() - options.days);
+      cutoffDate = cutoff.toISOString().replace(/\.\d{3}Z$/, "Z");
+    }
+    const docTypes = [
+      "mimeType='application/vnd.google-apps.document'",
+      "mimeType='application/vnd.google-apps.spreadsheet'",
+      "mimeType='application/vnd.google-apps.presentation'"
+    ].join(" or ");
+    const queryParts = [`(${docTypes})`, "trashed = false"];
+    if (cutoffDate) {
+      queryParts.push(`modifiedTime > '${cutoffDate}'`);
+    }
+    const q = queryParts.join(" and ");
+    const fields = "nextPageToken,files(id,name,mimeType,createdTime,modifiedTime,modifiedByMeTime,webViewLink,owners(me,displayName,emailAddress),lastModifyingUser(displayName,emailAddress))";
+    while (true) {
+      const params = new URLSearchParams({
+        q,
+        fields,
+        pageSize: pageSize.toString(),
+        orderBy: "modifiedByMeTime desc"
+      });
+      if (pageToken) {
+        params.set("pageToken", pageToken);
+      }
+      const url = `https://www.googleapis.com/drive/v3/files?${params.toString()}`;
+      const response = await this.request(url);
+      if (response.files && response.files.length > 0) {
+        const cutoffMs = cutoffDate ? new Date(cutoffDate).getTime() : 0;
+        const userInteracted = response.files.filter((f) => {
+          const modifiedByMeMs = f.modifiedByMeTime ? new Date(f.modifiedByMeTime).getTime() : 0;
+          const isOwnerCreatedRecently = f.owners?.[0]?.me === true && new Date(f.createdTime).getTime() >= cutoffMs;
+          return modifiedByMeMs >= cutoffMs || isOwnerCreatedRecently;
+        });
+        allFiles.push(...userInteracted);
+      }
+      if (options.onProgress) {
+        options.onProgress(allFiles.length, 0);
+      }
+      if (!response.nextPageToken) {
+        break;
+      }
+      if (options.limit && allFiles.length >= options.limit) {
+        break;
+      }
+      pageToken = response.nextPageToken;
+    }
+    const files = options.limit ? allFiles.slice(0, options.limit) : allFiles;
+    return files.map((file) => this.transformDocToCommit(file));
   }
 };
+var googleDocsService = new GoogleDocsService();
 
-// src/commands/sync.ts
-init_logger();
+// src/sync/google-docs-adapter.ts
+var googleDocsSyncAdapter = {
+  name: "google-docs",
+  async validate() {
+    await googleDocsService.validateCredentials();
+  },
+  async getRepositoryInfo() {
+    const user = await googleDocsService.getCurrentUser();
+    const userName = user || "Unknown User";
+    return {
+      owner: userName,
+      name: "Google Docs",
+      fullName: `${userName}'s Google Docs`,
+      url: "https://drive.google.com"
+    };
+  },
+  async fetchWorkItems(options) {
+    return googleDocsService.getDocs({
+      days: options.days,
+      limit: options.limit,
+      onProgress: options.onProgress ? (fetched) => options.onProgress(fetched, 0) : void 0
+    });
+  },
+  async isAuthenticated() {
+    try {
+      await this.validate();
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  async getCurrentUser() {
+    return googleDocsService.getCurrentUser();
+  }
+};
 
-// src/utils/auth-helper.ts
+// src/sync/slack-adapter.ts
 init_esm_shims();
-init_auth_service();
-import boxen5 from "boxen";
 
-// src/commands/init.ts
+// src/services/slack.service.ts
 init_esm_shims();
-init_auth_service();
+init_errors();
 init_logger();
-import ora from "ora";
-import boxen3 from "boxen";
-import chalk5 from "chalk";
-async function initCommand() {
-  logger.log("");
-  logger.log(
-    boxen3(
-      chalk5.yellow.bold("\u26A0 Deprecation Notice") + `
-
-The ${chalk5.cyan("init")} command is deprecated.
-Please use ${chalk5.cyan("bragduck auth login")} instead.
-
-` + chalk5.dim("This command will be removed in v3.0.0"),
-      {
-        padding: 1,
-        borderStyle: "round",
-        borderColor: "yellow",
-        dimBorder: true
+init_storage_service();
+import { URLSearchParams as URLSearchParams8 } from "url";
+var SlackService = class {
+  /**
+   * Get stored Slack credentials.
+   * Slack user tokens (xoxp-) don't expire by default — no expiry check needed.
+   */
+  async getCredentials() {
+    const creds = await storageService.getServiceCredentials("slack");
+    if (!creds || !creds.accessToken) {
+      throw new SlackError("Not authenticated with Slack", {
+        hint: "Run: bragduck auth slack"
+      });
+    }
+    return creds;
+  }
+  /**
+   * Make authenticated GET request to Slack Web API
+   */
+  async request(url) {
+    const creds = await this.getCredentials();
+    logger.debug(`Slack API: GET ${url}`);
+    const response = await fetch(url, {
+      headers: {
+        Authorization: `Bearer ${creds.accessToken}`,
+        Accept: "application/json"
       }
-    )
-  );
-  logger.log("");
-  logger.info("Starting authentication flow...");
-  logger.log("");
-  const isAuthenticated = await authService.isAuthenticated();
-  if (isAuthenticated) {
-    const userInfo = authService.getUserInfo();
-    if (userInfo) {
-      logger.log(
-        boxen3(
-          `${chalk5.yellow("Already authenticated!")}
-
-${chalk5.gray("User:")} ${userInfo.name}
-${chalk5.gray("Email:")} ${userInfo.email}
-
-${chalk5.dim("Run")} ${chalk5.cyan("bragduck logout")} ${chalk5.dim("to sign out")}`,
-          {
-            padding: 1,
-            margin: 1,
-            borderStyle: "round",
-            borderColor: "yellow"
-          }
-        )
-      );
-      logger.log("");
-      globalThis.setTimeout(() => {
-        process.exit(0);
-      }, 100);
-      return;
+    });
+    if (!response.ok) {
+      const status = response.status;
+      let errorDetail = response.statusText;
+      try {
+        const body = await response.json();
+        errorDetail = body?.error || errorDetail;
+        logger.debug(`Slack API error body: ${JSON.stringify(body)}`);
+      } catch {
+      }
+      if (status === 401) {
+        throw new SlackError(`Invalid or expired Slack token: ${errorDetail}`, {
+          hint: "Run: bragduck auth slack"
+        });
+      } else if (status === 429) {
+        throw new SlackError("Rate limit exceeded", {
+          hint: "Wait a few minutes before trying again"
+        });
+      }
+      throw new SlackError(`API request failed: ${errorDetail}`);
     }
+    const data = await response.json();
+    if (data.ok === false) {
+      if (data.error === "invalid_auth" || data.error === "token_revoked") {
+        throw new SlackError(`Invalid or revoked Slack token: ${data.error}`, {
+          hint: "Run: bragduck auth slack"
+        });
+      }
+      throw new SlackError(`Slack API error: ${data.error}`);
+    }
+    return data;
   }
-  const spinner = ora("Opening browser for authentication...").start();
-  try {
-    spinner.text = "Waiting for authentication...";
-    const userInfo = await authService.login();
-    spinner.succeed("Authentication successful!");
-    logger.log("");
-    logger.log(
-      boxen3(
-        `${chalk5.green.bold("\u2713 Successfully authenticated!")}
-
-${chalk5.gray("Welcome,")} ${chalk5.cyan(userInfo.name)}
-${chalk5.gray("Email:")} ${userInfo.email}
-
-${chalk5.dim("You can now use")} ${chalk5.cyan("bragduck scan")} ${chalk5.dim("to create brags!")}`,
-        {
-          padding: 1,
-          margin: 1,
-          borderStyle: "round",
-          borderColor: "green"
-        }
-      )
-    );
-    logger.log("");
-    globalThis.setTimeout(() => {
-      process.exit(0);
-    }, 100);
-    return;
-  } catch (error) {
-    spinner.fail("Authentication failed");
-    logger.log("");
-    const err = error;
-    logger.log(
-      boxen3(
-        `${chalk5.red.bold("\u2717 Authentication Failed")}
-
-${err.message}
-
-${chalk5.dim("Hint:")} ${getErrorHint(err)}`,
-        {
-          padding: 1,
-          margin: 1,
-          borderStyle: "round",
-          borderColor: "red"
+  /**
+   * Validate Slack credentials via auth.test
+   */
+  async validateCredentials() {
+    const creds = await this.getCredentials();
+    const response = await fetch("https://slack.com/api/auth.test", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${creds.accessToken}`,
+        "Content-Type": "application/json"
+      }
+    });
+    const data = await response.json();
+    if (!data.ok) {
+      throw new SlackError(`Slack credentials invalid: ${data.error || "unknown error"}`, {
+        hint: "Run: bragduck auth slack"
+      });
+    }
+  }
+  /**
+   * Get current Slack user display name via auth.test
+   */
+  async getCurrentUser() {
+    try {
+      const creds = await this.getCredentials();
+      const response = await fetch("https://slack.com/api/auth.test", {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${creds.accessToken}`,
+          "Content-Type": "application/json"
         }
-      )
-    );
-    process.exit(1);
+      });
+      const data = await response.json();
+      return data.ok ? data.user : null;
+    } catch {
+      return null;
+    }
   }
-}
-function getErrorHint(error) {
-  if (error.name === "OAuthError") {
-    if (error.message.includes("timeout")) {
-      return "Try again and complete the authentication within 2 minutes";
+  /**
+   * Fetch messages sent by the authenticated user via search.messages.
+   * Paginates across all pages until exhausted or limit reached.
+   */
+  async getMessages(options = {}) {
+    const creds = await this.getCredentials();
+    if (!creds.username) {
+      throw new SlackError("No Slack user ID stored", {
+        hint: "Run: bragduck auth slack"
+      });
     }
-    if (error.message.includes("CSRF")) {
-      return "This might be a security issue. Try running the command again";
+    let query = `from:<@${creds.username}>`;
+    if (options.days) {
+      const cutoff = /* @__PURE__ */ new Date();
+      cutoff.setDate(cutoff.getDate() - options.days);
+      const dateStr = cutoff.toISOString().slice(0, 10);
+      query += ` after:${dateStr}`;
     }
-    return "Check your internet connection and try again";
+    const allMessages = [];
+    let page = 1;
+    while (true) {
+      const params = new URLSearchParams8({
+        query,
+        count: "100",
+        page: page.toString()
+      });
+      const url = `https://slack.com/api/search.messages?${params.toString()}`;
+      const response = await this.request(url);
+      const matches = response.messages?.matches || [];
+      allMessages.push(...matches);
+      if (options.onProgress) {
+        options.onProgress(allMessages.length, response.messages?.paging?.total || 0);
+      }
+      const paging = response.messages?.paging;
+      if (!paging || page >= paging.pages) {
+        break;
+      }
+      if (options.limit && allMessages.length >= options.limit) {
+        break;
+      }
+      page++;
+    }
+    const messages = options.limit ? allMessages.slice(0, options.limit) : allMessages;
+    return messages.map((msg) => this.transformMessageToCommit(msg));
   }
-  if (error.name === "NetworkError") {
-    return "Check your internet connection and firewall settings";
+  /**
+   * Transform a Slack message to GitCommit format
+   */
+  transformMessageToCommit(msg) {
+    const channelName = msg.channel?.name || msg.channel?.id || "unknown";
+    const preview = msg.text.slice(0, 100);
+    const date = new Date(parseFloat(msg.ts) * 1e3).toISOString();
+    return {
+      sha: msg.ts,
+      message: `Slack [#${channelName}]: ${preview}`,
+      author: msg.username || "Unknown",
+      authorEmail: "unknown@slack",
+      date,
+      url: msg.permalink,
+      diffStats: {
+        filesChanged: 1,
+        insertions: 1,
+        deletions: 0
+      },
+      externalId: msg.ts,
+      externalType: "message",
+      externalSource: "slack",
+      externalUrl: msg.permalink
+    };
+  }
+};
+var slackService = new SlackService();
+
+// src/sync/slack-adapter.ts
+var slackSyncAdapter = {
+  name: "slack",
+  async validate() {
+    await slackService.validateCredentials();
+  },
+  async getRepositoryInfo() {
+    const user = await slackService.getCurrentUser();
+    const userName = user || "Unknown User";
+    return {
+      owner: userName,
+      name: "Slack",
+      fullName: `${userName}'s Slack Messages`,
+      url: "https://slack.com"
+    };
+  },
+  async fetchWorkItems(options) {
+    return slackService.getMessages({
+      days: options.days,
+      limit: options.limit,
+      onProgress: options.onProgress ? (fetched, total) => options.onProgress(fetched, total) : void 0
+    });
+  },
+  async isAuthenticated() {
+    try {
+      await this.validate();
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  async getCurrentUser() {
+    return slackService.getCurrentUser();
+  }
+};
+
+// src/sync/adapter-factory.ts
+var AdapterFactory = class {
+  /**
+   * Get adapter for a specific source type
+   */
+  static getAdapter(source, repoPath) {
+    switch (source) {
+      case "github":
+        return repoPath ? new GitHubSyncAdapter(repoPath) : githubSyncAdapter;
+      case "bitbucket":
+      case "atlassian":
+        return repoPath ? new BitbucketSyncAdapter(repoPath) : bitbucketSyncAdapter;
+      case "gitlab":
+        return repoPath ? new GitLabSyncAdapter(repoPath) : gitlabSyncAdapter;
+      case "jira":
+        return jiraSyncAdapter;
+      case "confluence":
+        return confluenceSyncAdapter;
+      case "google-docs":
+        return googleDocsSyncAdapter;
+      case "slack":
+        return slackSyncAdapter;
+      default:
+        throw new Error(`Unknown source type: ${source}`);
+    }
   }
-  if (error.name === "AuthenticationError") {
-    return "Verify your credentials and try again";
+  /**
+   * Check if adapter is available for source
+   */
+  static isSupported(source) {
+    return source === "github" || source === "bitbucket" || source === "atlassian" || source === "gitlab" || source === "jira" || source === "confluence" || source === "google-docs" || source === "slack";
   }
-  return "Try running the command again or check the logs with DEBUG=* bragduck init";
-}
+};
+
+// src/commands/sync.ts
+init_logger();
 
 // src/utils/auth-helper.ts
+init_esm_shims();
+init_auth_service();
+import boxen4 from "boxen";
 init_logger();
 
 // src/ui/prompts.ts
 init_esm_shims();
 import { checkbox, confirm, input as input2, select as select3, editor } from "@inquirer/prompts";
-import boxen4 from "boxen";
+import boxen3 from "boxen";
 
 // src/ui/formatters.ts
 init_esm_shims();
@@ -4978,7 +5836,13 @@ function formatRefinedCommitsTable(brags, selectedCommits) {
     } else {
       displaySha = `#${index + 1}`;
     }
-    const original = isNewBragType ? typeof brag.original_input === "string" ? brag.original_input.split("\n")[0] || "" : "Raw input" : brag.original_message.split("\n")[0] || "";
+    let original;
+    if (isNewBragType) {
+      const input3 = brag.original_input;
+      original = typeof input3 === "string" ? input3.split("\n")[0] || "" : "Raw input";
+    } else {
+      original = brag.original_message.split("\n")[0] || "";
+    }
     const title = brag.refined_title;
     const description = brag.refined_description.length > 100 ? brag.refined_description.substring(0, 97) + "..." : brag.refined_description;
     const tags = (brag.suggested_tags || []).join(", ") || "none";
@@ -5231,7 +6095,7 @@ ${theme.label("Impact Score")} ${colors.highlight(impactScore)}`;
 
 ${theme.label("PR Link")} ${colors.link(prUrl)}`;
       }
-      console.log(boxen4(bragDetails, boxStyles.info));
+      console.log(boxen3(bragDetails, boxStyles.info));
       console.log("");
       const action = await select3({
         message: `What would you like to do with this brag?`,
@@ -5308,7 +6172,7 @@ async function ensureAuthenticated() {
   }
   logger.log("");
   logger.log(
-    boxen5(
+    boxen4(
       theme.warning("Not authenticated") + "\n\nYou need to be logged in to use this command.\n\nWould you like to authenticate now?",
       boxStyles.warning
     )
@@ -5324,7 +6188,7 @@ async function ensureAuthenticated() {
     return false;
   }
   try {
-    await initCommand();
+    await authCommand("login");
     return true;
   } catch {
     return false;
@@ -5333,24 +6197,35 @@ async function ensureAuthenticated() {
 
 // src/ui/spinners.ts
 init_esm_shims();
-import ora2 from "ora";
-function createSpinner(text) {
-  return ora2({
+import ora from "ora";
+function createFetchSpinner(text) {
+  return ora({
     text,
     color: "cyan",
-    spinner: "dots"
+    spinner: "bouncingBar"
+  });
+}
+function createValidateSpinner(text) {
+  return ora({
+    text,
+    color: "cyan",
+    spinner: "line"
   });
 }
 function createStepSpinner(currentStep, totalSteps, text) {
   const stepIndicator = theme.step(currentStep, totalSteps);
-  return ora2({
+  return ora({
     text: `${stepIndicator} ${text}`,
     color: "cyan",
     spinner: "dots"
   });
 }
+function updateStepSpinner(spinner, currentStep, totalSteps, text) {
+  const stepIndicator = theme.step(currentStep, totalSteps);
+  spinner.text = `${stepIndicator} ${text}`;
+}
 function fetchingBragsSpinner() {
-  return createSpinner("Fetching your brags...");
+  return createFetchSpinner("Fetching your brags...");
 }
 function succeedSpinner(spinner, text) {
   if (text) {
@@ -5375,6 +6250,20 @@ function failStepSpinner(spinner, currentStep, totalSteps, text) {
   spinner.fail(`${stepIndicator} ${colors.error(text)}`);
 }
 
+// src/ui/header.ts
+init_esm_shims();
+init_logger();
+function showCommandHeader(userInfo, tier) {
+  if (!userInfo?.email) return;
+  if (tier) {
+    const tierLabel = tier.charAt(0).toUpperCase() + tier.slice(1).toLowerCase() + " plan";
+    logger.log(colors.dim(`  ${userInfo.email}  \xB7  ${tierLabel}`));
+  } else {
+    logger.log(colors.dim(`  ${userInfo.email}`));
+  }
+  logger.log("");
+}
+
 // src/utils/repo-scanner.ts
 init_esm_shims();
 import { promises as fs2 } from "fs";
@@ -5627,12 +6516,12 @@ async function syncSingleRepository(repo, days, sortOption, scanMode, orgId, opt
     return { repoName: repo.name, service: repo.service, created: 0, skipped: duplicates.length };
   }
   logger.log("");
-  const createSpinner2 = createStepSpinner(
+  const createSpinner = createStepSpinner(
     4,
     TOTAL_STEPS,
     `Creating ${theme.count(acceptedBrags.length)} brag${acceptedBrags.length > 1 ? "s" : ""}`
   );
-  createSpinner2.start();
+  createSpinner.start();
   const createRequest = {
     brags: acceptedBrags.map((refined, index) => {
       const originalCommit = selectedCommits[index];
@@ -5646,7 +6535,10 @@ async function syncSingleRepository(repo, days, sortOption, scanMode, orgId, opt
         repository: repoInfo.url,
         date: originalCommit?.date || (/* @__PURE__ */ new Date()).toISOString(),
         commit_url: originalCommit?.url || "",
+        impactLevel: refined.suggested_impactLevel,
+        typeId: refined.suggested_typeId,
         impact_score: refined.suggested_impactLevel,
+        impactDescription: refined.impact_description,
         impact_description: refined.impact_description,
         attachments: originalCommit?.url ? [originalCommit.url] : [],
         orgId: orgId || void 0,
@@ -5673,14 +6565,14 @@ async function syncSingleRepository(repo, days, sortOption, scanMode, orgId, opt
     ]);
     logger.debug(`API response: ${createResponse.created} brags created`);
     succeedStepSpinner(
-      createSpinner2,
+      createSpinner,
       4,
       TOTAL_STEPS,
       `Created ${theme.count(createResponse.created)} brag${createResponse.created > 1 ? "s" : ""}`
     );
     logger.log("");
   } catch (error) {
-    failStepSpinner(createSpinner2, 4, TOTAL_STEPS, "Failed to create brags");
+    failStepSpinner(createSpinner, 4, TOTAL_STEPS, "Failed to create brags");
     logger.log("");
     throw error;
   }
@@ -5812,7 +6704,7 @@ async function syncMultipleRepositories(repos, options) {
 
 // src/commands/sync.ts
 async function promptSelectService() {
-  const nonGitServices = ["atlassian", "jira", "confluence"];
+  const nonGitServices = ["atlassian", "jira", "confluence", "google-docs", "slack"];
   const authenticatedServices = await storageService.getAuthenticatedServices();
   const allServices = [
     "github",
@@ -5820,7 +6712,9 @@ async function promptSelectService() {
     "bitbucket",
     "atlassian",
     "jira",
-    "confluence"
+    "confluence",
+    "google-docs",
+    "slack"
   ];
   const authenticatedSyncServices = authenticatedServices.filter(
     (service) => service !== "bragduck" && allServices.includes(service)
@@ -5835,7 +6729,7 @@ async function promptSelectService() {
   for (const service of nonGitServices) {
     const isAuth = await storageService.isServiceAuthenticated(service);
     const indicator = isAuth ? "\u2713" : "\u2717";
-    const serviceLabel = service.charAt(0).toUpperCase() + service.slice(1);
+    const serviceLabel = getServiceLabel(service);
     serviceChoices.push({
       name: `${indicator} ${serviceLabel}`,
       value: service,
@@ -5843,7 +6737,7 @@ async function promptSelectService() {
     });
   }
   if (authenticatedSyncServices.length > 0) {
-    const serviceNames = authenticatedSyncServices.map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join(", ");
+    const serviceNames = authenticatedSyncServices.map(getServiceLabel).join(", ");
     serviceChoices.push({
       name: `\u2713 All authenticated services (${serviceNames})`,
       value: "all",
@@ -5858,7 +6752,8 @@ async function promptSelectService() {
 }
 async function syncSingleService(sourceType, options, TOTAL_STEPS, sharedDays, sharedOrgId) {
   const adapter = AdapterFactory.getAdapter(sourceType);
-  const repoSpinner = createStepSpinner(2, TOTAL_STEPS, "Validating repository");
+  const validationText = sourceType === "jira" || sourceType === "confluence" ? "Connecting to Atlassian instance" : sourceType === "google-docs" ? "Connecting to Google Drive" : "Validating repository";
+  const repoSpinner = createStepSpinner(2, TOTAL_STEPS, validationText);
   repoSpinner.start();
   const VALIDATION_TIMEOUT = 3e4;
   let repoInfo;
@@ -5904,7 +6799,16 @@ async function syncSingleService(sourceType, options, TOTAL_STEPS, sharedDays, s
   fetchSpinner.start();
   const workItems = await adapter.fetchWorkItems({
     days,
-    author: await adapter.getCurrentUser() || void 0
+    author: await adapter.getCurrentUser() || void 0,
+    onProgress: (fetched, total) => {
+      const progress = total > 0 ? `${fetched} of ${total}` : `${fetched} so far`;
+      updateStepSpinner(
+        fetchSpinner,
+        3,
+        TOTAL_STEPS,
+        `Fetching work items from the last ${days} days (${progress})`
+      );
+    }
   });
   if (workItems.length === 0) {
     failStepSpinner(fetchSpinner, 3, TOTAL_STEPS, `No work items found in the last ${days} days`);
@@ -5921,6 +6825,8 @@ async function syncSingleService(sourceType, options, TOTAL_STEPS, sharedDays, s
   logger.log("");
   logger.log(formatCommitStats(workItems));
   logger.log("");
+  const dupSpinner = createFetchSpinner("Checking for duplicates...");
+  dupSpinner.start();
   const existingBrags = await apiService.listBrags({ limit: 100 });
   logger.debug(`Fetched ${existingBrags.brags.length} existing brags`);
   const existingUrls = new Set(existingBrags.brags.flatMap((b) => b.attachments || []));
@@ -5929,13 +6835,14 @@ async function syncSingleService(sourceType, options, TOTAL_STEPS, sharedDays, s
   const newWorkItems = workItems.filter((c) => !c.url || !existingUrls.has(c.url));
   logger.debug(`Found ${duplicates.length} duplicates, ${newWorkItems.length} new items`);
   if (duplicates.length > 0) {
-    logger.log("");
-    logger.info(
-      colors.dim(
-        `\u2139 ${duplicates.length} work item${duplicates.length > 1 ? "s" : ""} already exist in Bragduck (will be skipped)`
-      )
+    succeedSpinner(
+      dupSpinner,
+      `${duplicates.length} item${duplicates.length > 1 ? "s" : ""} already synced, skipping`
     );
     logger.log("");
+  } else {
+    succeedSpinner(dupSpinner, "No duplicates found");
+    logger.log("");
   }
   if (newWorkItems.length === 0) {
     logger.log("");
@@ -6022,23 +6929,27 @@ async function syncSingleService(sourceType, options, TOTAL_STEPS, sharedDays, s
   if (sharedOrgId === void 0) {
     const userInfo = authService.getUserInfo();
     if (userInfo?.id) {
+      const orgSpinner = createFetchSpinner("Loading organizations...");
+      orgSpinner.start();
       try {
         const orgsResponse = await apiService.listUserOrganisations(userInfo.id);
+        orgSpinner.stop();
         if (orgsResponse.items.length > 0) {
           selectedOrgId = await promptSelectOrganisation(orgsResponse.items);
           logger.log("");
         }
       } catch {
+        orgSpinner.stop();
         logger.debug("Failed to fetch organisations, skipping org selection");
       }
     }
   }
-  const createSpinner2 = createStepSpinner(
+  const createSpinner = createStepSpinner(
     5,
     TOTAL_STEPS,
     `Creating ${theme.count(acceptedBrags.length)} brag${acceptedBrags.length > 1 ? "s" : ""}`
   );
-  createSpinner2.start();
+  createSpinner.start();
   const createRequest = {
     brags: acceptedBrags.map((refined, index) => {
       const originalCommit = selectedCommits[index];
@@ -6056,7 +6967,10 @@ async function syncSingleService(sourceType, options, TOTAL_STEPS, sharedDays, s
         repository: repoInfo.url,
         date: originalCommit?.date || (/* @__PURE__ */ new Date()).toISOString(),
         commit_url: originalCommit?.url || "",
+        impactLevel: refined.suggested_impactLevel,
+        typeId: refined.suggested_typeId,
         impact_score: refined.suggested_impactLevel,
+        impactDescription: refined.impact_description,
         impact_description: refined.impact_description,
         attachments: originalCommit?.url ? [originalCommit.url] : [],
         orgId: selectedOrgId || void 0,
@@ -6083,14 +6997,14 @@ async function syncSingleService(sourceType, options, TOTAL_STEPS, sharedDays, s
     ]);
     logger.debug(`API response: ${createResponse.created} brags created`);
     succeedStepSpinner(
-      createSpinner2,
+      createSpinner,
       5,
       TOTAL_STEPS,
       `Created ${theme.count(createResponse.created)} brag${createResponse.created > 1 ? "s" : ""}`
     );
     logger.log("");
   } catch (error) {
-    failStepSpinner(createSpinner2, 5, TOTAL_STEPS, "Failed to create brags");
+    failStepSpinner(createSpinner, 5, TOTAL_STEPS, "Failed to create brags");
     logger.log("");
     throw error;
   }
@@ -6109,7 +7023,9 @@ async function syncAllAuthenticatedServices(options) {
     "bitbucket",
     "atlassian",
     "jira",
-    "confluence"
+    "confluence",
+    "google-docs",
+    "slack"
   ];
   const authenticatedServices = await storageService.getAuthenticatedServices();
   let servicesToSync = authenticatedServices.filter(
@@ -6176,14 +7092,18 @@ async function syncAllAuthenticatedServices(options) {
   if (!options.turbo) {
     const userInfo = authService.getUserInfo();
     if (userInfo?.id) {
+      const orgSpinner = createFetchSpinner("Loading organizations...");
+      orgSpinner.start();
       try {
         const orgsResponse = await apiService.listUserOrganisations(userInfo.id);
+        orgSpinner.stop();
         if (orgsResponse.items.length > 0) {
           const defaultOrgId = storageService.getConfig("defaultCompany");
           sharedOrgId = await promptSelectOrganisationWithDefault(orgsResponse.items, defaultOrgId);
           logger.log("");
         }
       } catch {
+        orgSpinner.stop();
         logger.debug("Failed to fetch organisations, skipping org selection");
       }
     }
@@ -6192,7 +7112,7 @@ async function syncAllAuthenticatedServices(options) {
   for (let i = 0; i < servicesToSync.length; i++) {
     const service = servicesToSync[i];
     if (!service) continue;
-    const serviceLabel = service.charAt(0).toUpperCase() + service.slice(1);
+    const serviceLabel = getServiceLabel(service);
     logger.log(
       colors.highlight(`\u2501\u2501\u2501 Syncing ${i + 1}/${servicesToSync.length}: ${serviceLabel} \u2501\u2501\u2501`)
     );
@@ -6233,7 +7153,7 @@ async function syncAllAuthenticatedServices(options) {
       )
     );
     for (const result of successful) {
-      const serviceLabel = result.service.charAt(0).toUpperCase() + result.service.slice(1);
+      const serviceLabel = getServiceLabel(result.service);
       if (result.created === 0 && result.skipped > 0) {
         logger.info(
           `  \u2022 ${serviceLabel}: ${colors.dim(`All ${result.skipped} item${result.skipped !== 1 ? "s" : ""} already synced`)}`
@@ -6253,17 +7173,17 @@ async function syncAllAuthenticatedServices(options) {
       colors.warning(`\u2717 Failed to sync ${failed.length} service${failed.length > 1 ? "s" : ""}:`)
     );
     for (const result of failed) {
-      const serviceLabel = result.service.charAt(0).toUpperCase() + result.service.slice(1);
+      const serviceLabel = getServiceLabel(result.service);
       logger.info(`  \u2022 ${serviceLabel}: ${result.error}`);
     }
     logger.log("");
   }
   if (totalCreated > 0) {
     const allCreatedBrags = results.filter((r) => r.createdBrags).flatMap((r) => r.createdBrags);
-    logger.log(boxen6(formatSuccessMessage(totalCreated, allCreatedBrags), boxStyles.success));
+    logger.log(boxen5(formatSuccessMessage(totalCreated, allCreatedBrags), boxStyles.success));
   } else if (successful.length > 0) {
     logger.log(
-      boxen6(
+      boxen5(
         theme.secondary("No new brags created (all items already exist or were skipped)"),
         boxStyles.info
       )
@@ -6281,13 +7201,22 @@ async function syncCommand(options = {}) {
       process.exit(1);
     }
     logger.debug("Fetching subscription status...");
-    const subscriptionStatus = await apiService.getSubscriptionStatus();
+    const subSpinner = createValidateSpinner("Checking subscription...");
+    subSpinner.start();
+    let subscriptionStatus;
+    try {
+      subscriptionStatus = await apiService.getSubscriptionStatus();
+    } catch (error) {
+      failSpinner(subSpinner, "Failed to check subscription");
+      throw error;
+    }
     logger.debug("Subscription status response:", JSON.stringify(subscriptionStatus, null, 2));
     if (subscriptionStatus.tier === "FREE") {
       logger.debug("FREE tier detected - blocking sync command");
+      failSpinner(subSpinner, "Free plan \u2014 upgrade to use CLI sync");
       logger.log("");
       logger.log(
-        boxen6(
+        boxen5(
           theme.warning("CLI Access Requires Subscription") + "\n\nThe Bragduck CLI is available for Plus and Pro subscribers.\nUpgrade now to unlock:\n\n  \u2022 Automatic work item scanning\n  \u2022 AI-powered brag generation\n  \u2022 Unlimited brags\n\n" + colors.highlight("Start your free trial today"),
           {
             ...boxStyles.warning,
@@ -6299,7 +7228,13 @@ async function syncCommand(options = {}) {
       logger.log("");
       return;
     }
+    succeedSpinner(
+      subSpinner,
+      `${subscriptionStatus.tier.charAt(0).toUpperCase() + subscriptionStatus.tier.slice(1).toLowerCase()} plan \xB7 Ready`
+    );
     logger.debug(`Subscription tier "${subscriptionStatus.tier}" - proceeding with sync`);
+    const userInfo = authService.getUserInfo();
+    showCommandHeader(userInfo, subscriptionStatus.tier);
     let selectedSource;
     if (options.all) {
       selectedSource = "all";
@@ -6310,7 +7245,9 @@ async function syncCommand(options = {}) {
         logger.log("");
         logger.error(`Unsupported source: ${options.source}`);
         logger.log("");
-        logger.info("Supported sources: github, gitlab, bitbucket, atlassian, jira, confluence");
+        logger.info(
+          "Supported sources: github, gitlab, bitbucket, atlassian, jira, confluence, google-docs"
+        );
         return;
       }
       selectedSource = sourceType;
@@ -6325,6 +7262,69 @@ async function syncCommand(options = {}) {
       const detectionSpinner = createStepSpinner(1, TOTAL_STEPS, "Preparing sync");
       detectionSpinner.start();
       if (selectedSource === "git") {
+        let authCheckService;
+        let authCheckPassed = false;
+        try {
+          const detection = await sourceDetector.detectSources({}, process.cwd());
+          if (detection.detected.length > 0) {
+            authCheckService = detection.detected[0]?.type;
+            authCheckPassed = detection.detected.some((s) => s.isAuthenticated);
+          }
+        } catch {
+        }
+        if (!authCheckPassed && authCheckService) {
+          failStepSpinner(detectionSpinner, 1, TOTAL_STEPS, "Not authenticated");
+          logger.log("");
+          logger.log(
+            boxen5(
+              theme.warning("Authentication Required") + `
+
+Not authenticated with ${authCheckService.charAt(0).toUpperCase() + authCheckService.slice(1)}.
+
+To authenticate:
+
+` + getGitAuthCommand(authCheckService),
+              { ...boxStyles.warning, padding: 1, margin: 1 }
+            )
+          );
+          logger.log("");
+          return;
+        }
+        if (!authCheckPassed && !authCheckService) {
+          const gitServices = ["github", "gitlab", "bitbucket"];
+          const authResults = await Promise.all(
+            gitServices.map(async (s) => ({
+              service: s,
+              auth: await sourceDetector.checkAuthentication(s)
+            }))
+          );
+          const anyAuth = authResults.some((r) => r.auth);
+          if (!anyAuth) {
+            failStepSpinner(
+              detectionSpinner,
+              1,
+              TOTAL_STEPS,
+              "Not authenticated with any git service"
+            );
+            logger.log("");
+            logger.log(
+              boxen5(
+                theme.warning("Authentication Required") + `
+
+Not authenticated with any git service.
+
+To authenticate:
+
+  GitHub:    ${theme.command("gh auth login")}
+  GitLab:    ${theme.command("bragduck auth gitlab")}
+  Bitbucket: ${theme.command("bragduck auth atlassian")}`,
+                { ...boxStyles.warning, padding: 1, margin: 1 }
+              )
+            );
+            logger.log("");
+            return;
+          }
+        }
         succeedStepSpinner(detectionSpinner, 1, TOTAL_STEPS, "Discovering repositories");
         logger.log("");
         const repos = await discoverRepositories();
@@ -6346,7 +7346,7 @@ async function syncCommand(options = {}) {
         const result2 = await syncMultipleRepositories(repos, options);
         if (result2.totalCreated > 0 || result2.totalSkipped > 0) {
           logger.log("");
-          logger.log(boxen6(formatMultiRepoSummary(result2), boxStyles.success));
+          logger.log(boxen5(formatMultiRepoSummary(result2), boxStyles.success));
         } else {
           logger.log("");
           logger.info("No brags created.");
@@ -6373,13 +7373,31 @@ async function syncCommand(options = {}) {
           );
           return;
         }
+        if (!creds?.accessToken) {
+          failStepSpinner(detectionSpinner, 1, TOTAL_STEPS, `Not authenticated with ${sourceType}`);
+          logger.log("");
+          logger.log(
+            boxen5(
+              theme.warning("Authentication Required") + `
+
+Not authenticated with ${sourceType.charAt(0).toUpperCase() + sourceType.slice(1)}.
+
+To authenticate:
+
+  ${theme.command("bragduck auth atlassian")}`,
+              { ...boxStyles.warning, padding: 1, margin: 1 }
+            )
+          );
+          logger.log("");
+          return;
+        }
       }
       succeedStepSpinner(detectionSpinner, 1, TOTAL_STEPS, `Source: ${theme.value(sourceType)}`);
       logger.log("");
       const result = await syncSingleService(sourceType, options, TOTAL_STEPS);
       if (result.created > 0) {
         logger.log(
-          boxen6(formatSuccessMessage(result.created, result.createdBrags), boxStyles.success)
+          boxen5(formatSuccessMessage(result.created, result.createdBrags), boxStyles.success)
         );
       } else if (result.skipped > 0) {
         logger.log("");
@@ -6406,12 +7424,29 @@ async function syncCommand(options = {}) {
     const err = error;
     logger.log("");
     logger.log(
-      boxen6(formatErrorMessage(err.message, getErrorHint2(err, sourceType)), boxStyles.error)
+      boxen5(formatErrorMessage(err.message, getErrorHint(err, sourceType)), boxStyles.error)
     );
     process.exit(1);
   }
 }
-function getErrorHint2(error, sourceType) {
+function getServiceLabel(service) {
+  if (service === "google-docs") return "Google Docs";
+  if (service === "slack") return "Slack";
+  return service.charAt(0).toUpperCase() + service.slice(1);
+}
+function getGitAuthCommand(service) {
+  if (service === "github") {
+    return `  ${theme.command("gh auth login")}`;
+  }
+  if (service === "gitlab") {
+    return `  ${theme.command("bragduck auth gitlab")}`;
+  }
+  if (service === "bitbucket" || service === "atlassian") {
+    return `  ${theme.command("bragduck auth atlassian")}`;
+  }
+  return `  ${theme.command("bragduck auth login")}`;
+}
+function getErrorHint(error, sourceType) {
   if (error.name === "GitHubError") {
     return 'Make sure you are in a GitHub repository and have authenticated with "gh auth login"';
   }
@@ -6424,6 +7459,9 @@ function getErrorHint2(error, sourceType) {
     }
     return 'Run "bragduck auth login" to login again';
   }
+  if (error.name === "GoogleDocsError") {
+    return 'Run "bragduck auth google" to re-authenticate with Google';
+  }
   if (error.name === "NetworkError") {
     return "Check your internet connection and try again";
   }
@@ -6438,17 +7476,17 @@ init_esm_shims();
 init_auth_service();
 init_logger();
 import { confirm as confirm2 } from "@inquirer/prompts";
-import boxen7 from "boxen";
-import chalk6 from "chalk";
-import ora3 from "ora";
+import boxen6 from "boxen";
+import chalk5 from "chalk";
+import ora2 from "ora";
 async function logoutCommand() {
   const isAuthenticated = await authService.isAuthenticated();
   if (!isAuthenticated) {
     logger.log(
-      boxen7(
-        `${chalk6.yellow("Not currently authenticated")}
+      boxen6(
+        `${chalk5.yellow("Not currently authenticated")}
 
-${chalk6.dim("Nothing to logout from")}`,
+${chalk5.dim("Nothing to logout from")}`,
         {
           padding: 1,
           margin: 1,
@@ -6463,25 +7501,25 @@ ${chalk6.dim("Nothing to logout from")}`,
   const userName = userInfo?.name || "Unknown User";
   logger.log("");
   const shouldLogout = await confirm2({
-    message: `Are you sure you want to logout? (${chalk6.cyan(userName)})`,
+    message: `Are you sure you want to logout? (${chalk5.cyan(userName)})`,
     default: false
   });
   if (!shouldLogout) {
     logger.info("Logout cancelled");
     return;
   }
-  const spinner = ora3("Logging out...").start();
+  const spinner = ora2("Logging out...").start();
   try {
     await authService.logout();
     spinner.succeed("Logged out successfully");
     logger.log("");
     logger.log(
-      boxen7(
-        `${chalk6.green.bold("\u2713 Logged out successfully")}
+      boxen6(
+        `${chalk5.green.bold("\u2713 Logged out successfully")}
 
-${chalk6.dim("Your credentials have been cleared")}
+${chalk5.dim("Your credentials have been cleared")}
 
-${chalk6.dim("Run")} ${chalk6.cyan("bragduck init")} ${chalk6.dim("to login again")}`,
+${chalk5.dim("Run")} ${chalk5.cyan("bragduck init")} ${chalk5.dim("to login again")}`,
         {
           padding: 1,
           margin: 1,
@@ -6497,295 +7535,13 @@ ${chalk6.dim("Run")} ${chalk6.cyan("bragduck init")} ${chalk6.dim("to login agai
   }
 }
 
-// src/commands/scan.ts
-init_esm_shims();
-import boxen8 from "boxen";
-import chalk7 from "chalk";
-init_api_service();
-init_storage_service();
-init_logger();
-init_browser();
-init_auth_service();
-async function scanCommand(options = {}) {
-  logger.log("");
-  logger.log(
-    boxen8(
-      chalk7.yellow.bold("\u26A0 Deprecation Notice") + `
-
-The ${chalk7.cyan("scan")} command is deprecated.
-Please use ${chalk7.cyan("bragduck sync")} instead.
-
-` + chalk7.dim("This command will be removed in v3.0.0"),
-      {
-        padding: 1,
-        borderStyle: "round",
-        borderColor: "yellow",
-        dimBorder: true
-      }
-    )
-  );
-  logger.log("");
-  const TOTAL_STEPS = 5;
-  try {
-    const isAuthenticated = await ensureAuthenticated();
-    if (!isAuthenticated) {
-      process.exit(1);
-    }
-    logger.debug("Fetching subscription status...");
-    const subscriptionStatus = await apiService.getSubscriptionStatus();
-    logger.debug("Subscription status response:", JSON.stringify(subscriptionStatus, null, 2));
-    logger.debug(
-      `Checking tier: "${subscriptionStatus.tier}" (type: ${typeof subscriptionStatus.tier})`
-    );
-    logger.debug(`Tier === 'FREE': ${subscriptionStatus.tier === "FREE"}`);
-    if (subscriptionStatus.tier === "FREE") {
-      logger.debug("FREE tier detected - blocking scan command");
-      logger.log("");
-      logger.log(
-        boxen8(
-          theme.warning("CLI Access Requires Subscription") + "\n\nThe Bragduck CLI is available for Plus and Pro subscribers.\nUpgrade now to unlock:\n\n  \u2022 Automatic PR scanning\n  \u2022 AI-powered brag generation\n  \u2022 Unlimited brags\n\n" + colors.highlight("Start your free trial today!"),
-          {
-            ...boxStyles.warning,
-            padding: 1,
-            margin: 1
-          }
-        )
-      );
-      logger.log("");
-      const shouldOpenBrowser = await promptConfirm(
-        "Open subscription plans in your browser?",
-        true
-      );
-      if (shouldOpenBrowser) {
-        logger.log("");
-        const plansUrl = "https://bragduck.com/app/settings/plans";
-        try {
-          await openBrowser(plansUrl);
-          logger.info(theme.secondary("Opening browser..."));
-        } catch {
-          logger.warning("Could not open browser automatically");
-          logger.info(`Please visit: ${theme.value(plansUrl)}`);
-        }
-      }
-      logger.log("");
-      return;
-    }
-    logger.debug(`Subscription tier "${subscriptionStatus.tier}" - proceeding with scan`);
-    const repoSpinner = createStepSpinner(1, TOTAL_STEPS, "Validating GitHub repository");
-    repoSpinner.start();
-    await githubService.validateGitHubRepository();
-    const repoInfo = await githubService.getRepositoryInfo();
-    succeedStepSpinner(
-      repoSpinner,
-      1,
-      TOTAL_STEPS,
-      `Repository: ${theme.value(repoInfo.fullName)}`
-    );
-    logger.log("");
-    let days = options.days;
-    if (!days) {
-      const defaultDays = storageService.getConfig("defaultCommitDays");
-      days = await promptDaysToScan(defaultDays);
-      logger.log("");
-    }
-    const prSpinner = createStepSpinner(
-      2,
-      TOTAL_STEPS,
-      `Fetching merged PRs from the last ${days} days`
-    );
-    prSpinner.start();
-    let prs;
-    if (options.all) {
-      prs = await githubService.getMergedPRs({ days });
-    } else {
-      prs = await githubService.getPRsByCurrentUser({ days });
-    }
-    const commits = prs.map((pr) => githubService.transformPRToCommit(pr));
-    if (commits.length === 0) {
-      failStepSpinner(prSpinner, 2, TOTAL_STEPS, `No merged PRs found in the last ${days} days`);
-      logger.log("");
-      logger.info("Try increasing the number of days or check your GitHub activity");
-      return;
-    }
-    succeedStepSpinner(
-      prSpinner,
-      2,
-      TOTAL_STEPS,
-      `Found ${theme.count(commits.length)} PR${commits.length > 1 ? "s" : ""}`
-    );
-    logger.log("");
-    logger.log(formatCommitStats(commits));
-    logger.log("");
-    let sortedCommits = [...commits];
-    if (commits.length > 1) {
-      const sortOption = await promptSortOption();
-      logger.log("");
-      if (sortOption === "date") {
-        sortedCommits.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
-      } else if (sortOption === "size") {
-        sortedCommits.sort((a, b) => {
-          const sizeA = (a.diffStats?.insertions || 0) + (a.diffStats?.deletions || 0);
-          const sizeB = (b.diffStats?.insertions || 0) + (b.diffStats?.deletions || 0);
-          return sizeB - sizeA;
-        });
-      } else if (sortOption === "files") {
-        sortedCommits.sort((a, b) => {
-          const filesA = a.diffStats?.filesChanged || 0;
-          const filesB = b.diffStats?.filesChanged || 0;
-          return filesB - filesA;
-        });
-      }
-    }
-    const selectedShas = await promptSelectCommits(sortedCommits);
-    if (selectedShas.length === 0) {
-      logger.log("");
-      logger.info(theme.secondary("No PRs selected. Scan cancelled."));
-      logger.log("");
-      return;
-    }
-    const selectedCommits = sortedCommits.filter((c) => selectedShas.includes(c.sha));
-    logger.log(formatSelectionSummary(selectedCommits.length, selectedCommits));
-    logger.log("");
-    const existingBrags = await apiService.listBrags({ limit: 100 });
-    logger.debug(`Fetched ${existingBrags.brags.length} existing brags`);
-    const existingUrls = new Set(existingBrags.brags.flatMap((b) => b.attachments || []));
-    logger.debug(`Existing PR URLs in attachments: ${existingUrls.size}`);
-    const duplicates = selectedCommits.filter((c) => c.url && existingUrls.has(c.url));
-    const newCommits = selectedCommits.filter((c) => !c.url || !existingUrls.has(c.url));
-    logger.debug(`Duplicates: ${duplicates.length}, New: ${newCommits.length}`);
-    if (duplicates.length > 0) {
-      logger.log("");
-      logger.info(
-        colors.warning(
-          `${duplicates.length} PR${duplicates.length > 1 ? "s" : ""} already added to Bragduck - skipping`
-        )
-      );
-      logger.log("");
-    }
-    if (newCommits.length === 0) {
-      logger.log("");
-      logger.info(
-        theme.secondary("All selected PRs already exist in Bragduck. Nothing to refine.")
-      );
-      logger.log("");
-      return;
-    }
-    const refineSpinner = createStepSpinner(
-      3,
-      TOTAL_STEPS,
-      `Refining ${theme.count(newCommits.length)} PR${newCommits.length > 1 ? "s" : ""} with AI`
-    );
-    refineSpinner.start();
-    const refineRequest = {
-      brags: newCommits.map((c) => ({
-        text: c.message,
-        date: c.date,
-        title: c.message.split("\n")[0]
-        // First line as initial title
-      }))
-    };
-    const refineResponse = await apiService.refineBrags(refineRequest);
-    let refinedBrags = refineResponse.refined_brags;
-    succeedStepSpinner(refineSpinner, 3, TOTAL_STEPS, "PRs refined successfully");
-    logger.log("");
-    logger.info("Preview of refined brags:");
-    logger.log("");
-    logger.log(formatRefinedCommitsTable(refinedBrags, newCommits));
-    logger.log("");
-    const acceptedBrags = await promptReviewBrags(refinedBrags, newCommits);
-    if (acceptedBrags.length === 0) {
-      logger.log("");
-      logger.info(theme.secondary("No brags selected for creation. Scan cancelled."));
-      logger.log("");
-      return;
-    }
-    logger.log("");
-    let selectedOrgId = null;
-    const userInfo = authService.getUserInfo();
-    if (userInfo?.id) {
-      try {
-        const orgsResponse = await apiService.listUserOrganisations(userInfo.id);
-        if (orgsResponse.items.length > 0) {
-          selectedOrgId = await promptSelectOrganisation(orgsResponse.items);
-          logger.log("");
-        }
-      } catch {
-        logger.debug("Failed to fetch organisations, skipping org selection");
-      }
-    }
-    const createSpinner2 = createStepSpinner(
-      4,
-      TOTAL_STEPS,
-      `Creating ${theme.count(acceptedBrags.length)} brag${acceptedBrags.length > 1 ? "s" : ""}`
-    );
-    createSpinner2.start();
-    const createRequest = {
-      brags: acceptedBrags.map((refined, index) => {
-        const originalCommit = newCommits[index];
-        const repoTag = repoInfo.name;
-        const tagsWithRepo = refined.suggested_tags.includes(repoTag) ? refined.suggested_tags : [repoTag, ...refined.suggested_tags];
-        return {
-          commit_sha: originalCommit?.sha || `brag-${index}`,
-          title: refined.refined_title,
-          description: refined.refined_description,
-          tags: tagsWithRepo,
-          repository: repoInfo.url,
-          date: originalCommit?.date || "",
-          commit_url: originalCommit?.url || "",
-          impact_score: refined.suggested_impactLevel,
-          impact_description: refined.impact_description,
-          attachments: originalCommit?.url ? [originalCommit.url] : [],
-          orgId: selectedOrgId || void 0
-        };
-      })
-    };
-    const createResponse = await apiService.createBrags(createRequest);
-    succeedStepSpinner(
-      createSpinner2,
-      4,
-      TOTAL_STEPS,
-      `Created ${theme.count(createResponse.created)} brag${createResponse.created > 1 ? "s" : ""}`
-    );
-    logger.log("");
-    logger.log(boxen8(formatSuccessMessage(createResponse.created), boxStyles.success));
-  } catch (error) {
-    if (error instanceof CancelPromptError) {
-      logger.log("");
-      logger.info(theme.secondary("Scan cancelled."));
-      logger.log("");
-      return;
-    }
-    const err = error;
-    logger.log("");
-    logger.log(boxen8(formatErrorMessage(err.message, getErrorHint3(err)), boxStyles.error));
-    process.exit(1);
-  }
-}
-function getErrorHint3(error) {
-  if (error.name === "GitHubError") {
-    return 'Make sure you are in a GitHub repository and have authenticated with "gh auth login"';
-  }
-  if (error.name === "GitError") {
-    return "Make sure you are in a git repository. Note: Only GitHub repositories are supported for PR scanning.";
-  }
-  if (error.name === "TokenExpiredError" || error.name === "AuthenticationError") {
-    return 'Run "bragduck init" to login again';
-  }
-  if (error.name === "NetworkError") {
-    return "Check your internet connection and try again";
-  }
-  if (error.name === "ApiError") {
-    return "The server might be experiencing issues. Try again later";
-  }
-  return "Try running with DEBUG=* for more information";
-}
-
 // src/commands/list.ts
 init_esm_shims();
 init_api_service();
-import boxen9 from "boxen";
+import boxen7 from "boxen";
 import Table2 from "cli-table3";
 init_logger();
+init_auth_service();
 async function listCommand(options = {}) {
   logger.log("");
   try {
@@ -6818,6 +7574,7 @@ async function listCommand(options = {}) {
       return;
     }
     succeedSpinner(spinner, `Found ${response.total} brag${response.total > 1 ? "s" : ""}`);
+    showCommandHeader(authService.getUserInfo());
     logger.log("");
     if (options.oneline) {
       logger.log(formatBragsOneline(response.brags));
@@ -6850,7 +7607,7 @@ async function listCommand(options = {}) {
   } catch (error) {
     const err = error;
     logger.log("");
-    logger.log(boxen9(formatErrorMessage(err.message, getErrorHint4(err)), boxStyles.error));
+    logger.log(boxen7(formatErrorMessage(err.message, getErrorHint2(err)), boxStyles.error));
     process.exit(1);
   }
 }
@@ -6872,7 +7629,7 @@ function formatBragsTable(brags) {
     const title = brag.title;
     const description = truncateText(brag.description, 100);
     const tags = brag.tags.length > 0 ? brag.tags.join(", ") : colors.dim("none");
-    const repository = brag.repository ? truncateText(extractRepoName(brag.repository), 25) : colors.dim("none");
+    const repository = brag.externalUrl ? truncateText(extractRepoName(brag.externalUrl), 25) : colors.dim("none");
     table.push([
       colors.highlight(date),
       colors.white(title),
@@ -6903,7 +7660,7 @@ function extractRepoName(url) {
     return url;
   }
 }
-function getErrorHint4(error) {
+function getErrorHint2(error) {
   if (error.name === "TokenExpiredError" || error.name === "AuthenticationError") {
     return 'Run "bragduck init" to login again';
   }
@@ -6921,8 +7678,8 @@ init_esm_shims();
 init_storage_service();
 init_logger();
 init_constants();
-import boxen10 from "boxen";
-import chalk8 from "chalk";
+import boxen8 from "boxen";
+import chalk6 from "chalk";
 import Table3 from "cli-table3";
 init_errors();
 var VALID_CONFIG_KEYS = Object.values(CONFIG_KEYS);
@@ -6957,7 +7714,7 @@ async function configCommand(subcommand, key, value) {
     const err = error;
     logger.log("");
     logger.log(
-      boxen10(formatErrorMessage(err.message, getConfigHint(err)), {
+      boxen8(formatErrorMessage(err.message, getConfigHint(err)), {
         padding: 1,
         margin: 1,
         borderStyle: "round",
@@ -6978,7 +7735,7 @@ async function handleListConfig() {
     gitlabInstance: storageService.getConfig("gitlabInstance")
   };
   const table = new Table3({
-    head: [chalk8.cyan("Key"), chalk8.cyan("Value"), chalk8.cyan("Default")],
+    head: [chalk6.cyan("Key"), chalk6.cyan("Value"), chalk6.cyan("Default")],
     colWidths: [25, 40, 40],
     wordWrap: true,
     style: {
@@ -6987,61 +7744,61 @@ async function handleListConfig() {
     }
   });
   table.push([
-    chalk8.white("defaultCommitDays"),
-    chalk8.yellow(String(config2.defaultCommitDays)),
-    chalk8.dim(String(DEFAULT_CONFIG.defaultCommitDays))
+    chalk6.white("defaultCommitDays"),
+    chalk6.yellow(String(config2.defaultCommitDays)),
+    chalk6.dim(String(DEFAULT_CONFIG.defaultCommitDays))
   ]);
   table.push([
-    chalk8.white("autoVersionCheck"),
-    chalk8.yellow(String(config2.autoVersionCheck)),
-    chalk8.dim(String(DEFAULT_CONFIG.autoVersionCheck))
+    chalk6.white("autoVersionCheck"),
+    chalk6.yellow(String(config2.autoVersionCheck)),
+    chalk6.dim(String(DEFAULT_CONFIG.autoVersionCheck))
   ]);
   table.push([
-    chalk8.white("defaultSource"),
-    chalk8.yellow(config2.defaultSource || "not set"),
-    chalk8.dim("not set")
+    chalk6.white("defaultSource"),
+    chalk6.yellow(config2.defaultSource || "not set"),
+    chalk6.dim("not set")
   ]);
   table.push([
-    chalk8.white("sourcePriority"),
-    chalk8.yellow(config2.sourcePriority ? config2.sourcePriority.join(", ") : "not set"),
-    chalk8.dim("not set")
+    chalk6.white("sourcePriority"),
+    chalk6.yellow(config2.sourcePriority ? config2.sourcePriority.join(", ") : "not set"),
+    chalk6.dim("not set")
   ]);
   table.push([
-    chalk8.white("jiraInstance"),
-    chalk8.yellow(config2.jiraInstance || "not set"),
-    chalk8.dim("not set")
+    chalk6.white("jiraInstance"),
+    chalk6.yellow(config2.jiraInstance || "not set"),
+    chalk6.dim("not set")
   ]);
   table.push([
-    chalk8.white("confluenceInstance"),
-    chalk8.yellow(config2.confluenceInstance || "not set"),
-    chalk8.dim("not set")
+    chalk6.white("confluenceInstance"),
+    chalk6.yellow(config2.confluenceInstance || "not set"),
+    chalk6.dim("not set")
   ]);
   table.push([
-    chalk8.white("gitlabInstance"),
-    chalk8.yellow(config2.gitlabInstance || "not set"),
-    chalk8.dim("not set")
+    chalk6.white("gitlabInstance"),
+    chalk6.yellow(config2.gitlabInstance || "not set"),
+    chalk6.dim("not set")
   ]);
   logger.info("Current configuration:");
   logger.log("");
   logger.log(table.toString());
   logger.log("");
-  logger.info(chalk8.dim("To change a value: ") + chalk8.cyan("bragduck config set <key> <value>"));
+  logger.info(chalk6.dim("To change a value: ") + chalk6.cyan("bragduck config set <key> <value>"));
   logger.log("");
 }
 async function handleGetConfig(key) {
   validateConfigKey(key);
   const value = storageService.getConfig(key);
   const defaultValue = DEFAULT_CONFIG[key];
-  logger.info(`Configuration for ${chalk8.cyan(key)}:`);
+  logger.info(`Configuration for ${chalk6.cyan(key)}:`);
   logger.log("");
-  logger.log(`  ${chalk8.white("Current:")} ${chalk8.yellow(String(value))}`);
-  logger.log(`  ${chalk8.white("Default:")} ${chalk8.dim(String(defaultValue))}`);
+  logger.log(`  ${chalk6.white("Current:")} ${chalk6.yellow(String(value))}`);
+  logger.log(`  ${chalk6.white("Default:")} ${chalk6.dim(String(defaultValue))}`);
   logger.log("");
   if (value === defaultValue) {
-    logger.info(chalk8.dim("Using default value"));
+    logger.info(chalk6.dim("Using default value"));
   } else {
     logger.info(
-      chalk8.dim("Custom value set. Reset with: ") + chalk8.cyan(`bragduck config set ${key} ${defaultValue}`)
+      chalk6.dim("Custom value set. Reset with: ") + chalk6.cyan(`bragduck config set ${key} ${defaultValue}`)
     );
   }
   logger.log("");
@@ -7051,10 +7808,10 @@ async function handleSetConfig(key, value) {
   const typedValue = validateAndConvertValue(key, value);
   storageService.setConfig(key, typedValue);
   logger.log(
-    boxen10(
-      `${chalk8.green.bold("\u2713 Configuration updated")}
+    boxen8(
+      `${chalk6.green.bold("\u2713 Configuration updated")}
 
-${chalk8.white(key)}: ${chalk8.yellow(String(typedValue))}`,
+${chalk6.white(key)}: ${chalk6.yellow(String(typedValue))}`,
       {
         padding: 1,
         margin: 1,
@@ -7151,13 +7908,15 @@ function getConfigHint(error) {
 // src/cli.ts
 init_version();
 init_logger();
-var __filename7 = fileURLToPath7(import.meta.url);
-var __dirname7 = dirname6(__filename7);
-var packageJsonPath = join8(__dirname7, "../../package.json");
-var packageJson = JSON.parse(readFileSync6(packageJsonPath, "utf-8"));
+var __filename9 = fileURLToPath9(import.meta.url);
+var __dirname9 = dirname8(__filename9);
+var packageJsonPath = join10(__dirname9, "../../package.json");
+var packageJson = JSON.parse(readFileSync8(packageJsonPath, "utf-8"));
 var program = new Command();
-program.name("bragduck").description("CLI tool for managing developer achievements and brags\nAliases: bd, duck, brag").version(packageJson.version, "-v, --version", "Display version number").helpOption("-h, --help", "Display help information").option("--skip-version-check", "Skip automatic version check on startup").option("--debug", "Enable debug mode (shows detailed logs)");
-program.command("auth [subcommand]").description("Manage authentication (subcommands: login, status, bitbucket, gitlab)").action(async (subcommand) => {
+program.name("bragduck").description("CLI tool for managing developer achievements and brags\nAliases: duck, brag").version(packageJson.version, "-v, --version", "Display version number").helpOption("-h, --help", "Display help information").option("--skip-version-check", "Skip automatic version check on startup").option("--debug", "Enable debug mode (shows detailed logs)");
+program.command("auth [subcommand]").description(
+  "Manage authentication (subcommands: login, status, github, gitlab, bitbucket, atlassian, google, slack)"
+).action(async (subcommand) => {
   try {
     await authCommand(subcommand);
   } catch (error) {
@@ -7173,22 +7932,6 @@ program.command("sync").description("Sync work items and create brags").option("
     process.exit(1);
   }
 });
-program.command("init").description("Authenticate with Bragduck").action(async () => {
-  try {
-    await initCommand();
-  } catch (error) {
-    console.error(error);
-    process.exit(1);
-  }
-});
-program.command("scan").description("Scan git commits and create brags (deprecated, use sync)").option("-d, --days <number>", "Number of days to scan", (val) => parseInt(val, 10)).option("-a, --all", "Include all commits (not just current user)").action(async (options) => {
-  try {
-    await scanCommand(options);
-  } catch (error) {
-    console.error(error);
-    process.exit(1);
-  }
-});
 program.command("list").description("List your existing brags").option("-l, --limit <number>", "Number of brags to display", (val) => parseInt(val, 10), 50).option("-o, --offset <number>", "Number of brags to skip", (val) => parseInt(val, 10), 0).option("-t, --tags <tags>", "Filter by tags (comma-separated)").option("-s, --search <query>", "Search brags by keyword").option("--oneline", "Show only date and title for each brag").action(async (options) => {
   try {
     await listCommand(options);