@@ -95,6 +95,32 @@ firecrawl setup build
 firecrawl setup workflows
 ```
 
+### Skill updates
+
+Interactive CLI sessions (except `init`, `setup`, and the `-y`/`--yes` init
+shorthand) show a boxed notice when installed Firecrawl skills differ from the
+current catalog. The check includes supporting reference files and runs
+independently of CLI releases. Installs record which catalog skills existed, so
+the notice announces skills published later, once, in families whose umbrella
+skill is installed. Skills skipped during setup are not offered again.
+
+Each affected family gets one command: `firecrawl setup core`,
+`firecrawl setup build`, or `firecrawl setup workflows`. These commands install
+the entire current family, including previously skipped skills and
+new skills added since your CLI was released. When installing through npx, failed
+catalog API discovery falls back to this CLI release's known names with a warning.
+Native installs discover skills directly from the Git repository and require that
+repository to be available. An explicit refresh replaces installed files, including
+local edits; the notice itself never changes them.
+
+Checks cover global installations recorded in `~/.agents/.skill-lock.json` with
+files in `~/.agents/skills`. They cache catalog results for 20 hours, repeat the
+notice at most once every 12 hours, and retry failed checks after an hour.
+Non-interactive runs stay quiet. Set `FIRECRAWL_NO_UPDATE_CHECK=1` to disable both
+CLI and skill update notices.
+
+### MCP and web defaults
+
 To install the Firecrawl MCP server into your editors (Cursor, Claude Code, VS Code, etc.):
 
 ```bash
 
@@ -1,6 +1,6 @@
 {
   "name": "firecrawl-cli",
-  "version": "1.26.10",
+  "version": "1.26.11",
   "publishConfig": {
     "tag": "latest"
   },
@@ -86,6 +86,7 @@
     "@inquirer/prompts": "^8.2.1",
     "commander": "^14.0.2",
     "firecrawl": "4.44.0",
+    "string-width": "^4.2.3",
     "yaml": "^2.9.0",
     "zod-to-json-schema": "3.24.6"
   }
 
@@ -7,6 +7,33 @@ describe('CLI argv parsing', () => {
   const cliPath = resolve(process.cwd(), 'dist/index.js');
   const testWithBuiltCli = existsSync(cliPath) ? it : it.skip;
 
+  testWithBuiltCli(
+    'skips skill notices for setup commands, not matching query words',
+    () => {
+      for (const [args, expected] of [
+        [['search', 'setup', '--help'], true],
+        [['search', 'init', '--help'], true],
+        [['init', '--help'], false],
+        [['setup', '--help'], false],
+        [['-y'], false],
+        [['--yes'], false],
+      ] as const) {
+        const script = `
+        require('./dist/utils/update-notice').maybeShowUpdateNotice = async () => {};
+        require('./dist/utils/skill-update-notice').maybeShowSkillUpdateNotice = async () => console.log('SKILL_NOTICE_CHECK');
+        require('./dist/commands/init').handleInitCommand = async () => {};
+        process.argv = [process.execPath, ${JSON.stringify(cliPath)}, ...${JSON.stringify(args)}];
+        require(${JSON.stringify(cliPath)});
+      `;
+        const result = spawnSync(process.execPath, ['-e', script], {
+          encoding: 'utf8',
+        });
+        expect(result.status).toBe(0);
+        expect(result.stdout.includes('SKILL_NOTICE_CHECK')).toBe(expected);
+      }
+    }
+  );
+
   testWithBuiltCli('rejects invalid PDF page caps before scraping', () => {
     for (const value of ['0', '10001', '2.5', '3pages']) {
       const result = spawnSync(
 
@@ -3,10 +3,22 @@ import { execSync } from 'child_process';
 import * as skillsNative from '../../commands/skills-native';
 import { handleInitCommand } from '../../commands/init';
 import { CLI_SKILLS, WORKFLOW_SKILLS } from '../../commands/skills-install';
+import { getCatalogSkills } from '../../utils/skill-catalog';
 
 const cliSkillFlags = `--skill ${CLI_SKILLS.join(' ')}`;
 const workflowSkillFlags = `--skill ${WORKFLOW_SKILLS.join(' ')}`;
 
+vi.mock('../../utils/skill-catalog', () => ({
+  getCatalogSkills: vi.fn(async () => [
+    ...CLI_SKILLS.map((name) => ({ name, family: 'core', files: {} })),
+    ...WORKFLOW_SKILLS.map((name) => ({
+      name,
+      family: 'workflows',
+      files: {},
+    })),
+  ]),
+}));
+
 const { installMcpMock, getApiKeyMock, confirmMock, checkboxMock } = vi.hoisted(
   () => ({
     installMcpMock: vi.fn(),
@@ -98,6 +110,21 @@ describe('handleInitCommand', () => {
     );
   });
 
+  it('installs newly published workflows during non-interactive init', async () => {
+    vi.mocked(getCatalogSkills)
+      .mockResolvedValueOnce(
+        CLI_SKILLS.map((name) => ({ name, family: 'core', files: {} }))
+      )
+      .mockResolvedValueOnce([
+        { name: 'firecrawl-new-workflow', family: 'workflows', files: {} },
+      ]);
+    await handleInitCommand({ yes: true, skipInstall: true, skipAuth: true });
+    expect(execSync).toHaveBeenCalledWith(
+      'npx -y skills add firecrawl/skills --full-depth --global --yes --skill firecrawl-new-workflow',
+      expect.objectContaining({ stdio: ['ignore', 'pipe', 'pipe'] })
+    );
+  });
+
   it('summarizes interactive skills success even when npx output has no count', async () => {
     confirmMock
       .mockResolvedValueOnce(true)
@@ -141,6 +168,35 @@ describe('handleInitCommand', () => {
     expect(execSync).toHaveBeenCalledTimes(1);
   });
 
+  it('continues interactive workflow installation when catalog discovery fails', async () => {
+    confirmMock
+      .mockResolvedValueOnce(true)
+      .mockResolvedValueOnce(false)
+      .mockResolvedValueOnce(false);
+    checkboxMock
+      .mockResolvedValueOnce(['workflows'])
+      .mockResolvedValueOnce(['firecrawl-lead-research']);
+    vi.mocked(getCatalogSkills).mockRejectedValueOnce(new Error('HTTP 403'));
+    await handleInitCommand({ skipInstall: true, skipAuth: true });
+    expect(checkboxMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: 'Which workflow skills?',
+        choices: WORKFLOW_SKILLS.map((name) => ({
+          name,
+          value: name,
+          checked: true,
+        })),
+      })
+    );
+    expect(execSync).toHaveBeenCalledWith(
+      'npx -y skills add firecrawl/skills --full-depth --global --yes --skill firecrawl-lead-research',
+      expect.anything()
+    );
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining('Skills installed')
+    );
+  });
+
   it('summarizes native interactive installation independently of its count', async () => {
     confirmMock
       .mockResolvedValueOnce(true)
 
@@ -42,6 +42,19 @@ import { configureWebDefaults } from '../../utils/web-defaults';
 import { getApiKey } from '../../utils/config';
 import { browserLogin, isAuthenticated } from '../../utils/auth';
 import { saveCredentials } from '../../utils/credentials';
+import { getCatalogSkills } from '../../utils/skill-catalog';
+
+vi.mock('../../utils/skill-catalog', () => ({
+  getCatalogSkills: vi.fn(async () => [
+    ...CLI_SKILLS.map((name) => ({ name, family: 'core', files: {} })),
+    ...BUILD_SKILLS.map((name) => ({ name, family: 'build', files: {} })),
+    ...WORKFLOW_SKILLS.map((name) => ({
+      name,
+      family: 'workflows',
+      files: {},
+    })),
+  ]),
+}));
 
 vi.mock('child_process', () => ({
   execFileSync: vi.fn(),
@@ -106,6 +119,63 @@ describe('handleSetupCommand', () => {
     expect(CLI_SKILLS).toContain('firecrawl-alexandria');
   });
 
+  it('refreshes the current workflow catalog, including skills absent from this CLI release', async () => {
+    vi.mocked(getCatalogSkills).mockResolvedValueOnce([
+      { name: 'firecrawl-new-workflow', family: 'workflows', files: {} },
+      { name: 'firecrawl-build', family: 'build', files: {} },
+    ]);
+    await handleSetupCommand('workflows', { agent: 'cursor' });
+    expectSkillsInstall(
+      'npx -y skills add firecrawl/skills --full-depth --global --yes --agent cursor --skill firecrawl-new-workflow'
+    );
+  });
+
+  it.each(['Catalog unavailable', 'HTTP 403', 'Invalid catalog response'])(
+    'falls back to release skills with a warning when discovery fails: %s',
+    async (message) => {
+      vi.spyOn(console, 'error').mockImplementation(() => {});
+      vi.mocked(getCatalogSkills).mockRejectedValueOnce(new Error(message));
+      await handleSetupCommand('workflows', {});
+      expectSkillsInstall(
+        `npx -y skills add firecrawl/skills --full-depth --global --yes ${workflowSkillFlags}`
+      );
+      expect(console.error).toHaveBeenCalledWith(
+        expect.stringContaining("using this CLI release's skill list")
+      );
+    }
+  );
+
+  it('installs a newly published skill by full name once the catalog lists it', async () => {
+    vi.mocked(getCatalogSkills).mockResolvedValueOnce([
+      { name: 'firecrawl-new-workflow', family: 'workflows', files: {} },
+    ]);
+    await handleSetupCommand('firecrawl-new-workflow', {});
+    expectSkillsInstall(
+      'npx -y skills add firecrawl/skills --full-depth --global --yes --skill firecrawl-new-workflow'
+    );
+  });
+
+  it('rejects a full skill name the catalog does not list', async () => {
+    const exit = vi.spyOn(process, 'exit').mockImplementation(((
+      code?: number
+    ) => {
+      throw new Error(`process.exit:${code}`);
+    }) as never);
+    await expect(
+      handleSetupCommand('firecrawl-typo-workflow', {})
+    ).rejects.toThrow('process.exit:1');
+    expect(execFileSync).not.toHaveBeenCalled();
+    exit.mockRestore();
+  });
+
+  it('accepts a full skill name when the catalog cannot be reached', async () => {
+    vi.mocked(getCatalogSkills).mockRejectedValueOnce(new Error('offline'));
+    await handleSetupCommand('firecrawl-new-workflow', {});
+    expectSkillsInstall(
+      'npx -y skills add firecrawl/skills --full-depth --global --yes --skill firecrawl-new-workflow'
+    );
+  });
+
   it('passes --agent to npx as one argument, never through a shell', async () => {
     const agent = 'cursor; touch /tmp/pwned';
     await handleSetupCommand('core', { agent });