vellum 0.2.1 → 0.2.2

package/src/__tests__/view-image-tool.test.ts

@@ -0,0 +1,217 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, test, expect, afterAll, mock } from 'bun:test';
+import { mkdtempSync, writeFileSync, mkdirSync, rmSync, realpathSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const testDir = realpathSync(mkdtempSync(join(tmpdir(), 'view-image-test-')));
+
+mock.module('../util/platform.js', () => ({
+  getDataDir: () => testDir,
+  getRootDir: () => testDir,
+  isMacOS: () => process.platform === 'darwin',
+  isLinux: () => process.platform === 'linux',
+  isWindows: () => process.platform === 'win32',
+  getSocketPath: () => join(testDir, 'test.sock'),
+  getPidPath: () => join(testDir, 'test.pid'),
+  getDbPath: () => join(testDir, 'test.db'),
+  getLogPath: () => join(testDir, 'test.log'),
+  ensureDataDir: () => {},
+  migrateToDataLayout: () => {},
+  migrateToWorkspaceLayout: () => {},
+}));
+
+mock.module('../util/logger.js', () => ({
+  getLogger: () => new Proxy({} as Record<string, unknown>, {
+    get: () => () => {},
+  }),
+}));
+
+mock.module('../config/loader.js', () => ({
+  getConfig: () => ({ memory: {} }),
+}));
+
+await import('../tools/filesystem/view-image.js');
+
+import { getTool } from '../tools/registry.js';
+import type { ToolContext } from '../tools/types.js';
+
+afterAll(() => {
+  try { rmSync(testDir, { recursive: true }); } catch { /* best effort */ }
+});
+
+const tool = getTool('view_image')!;
+
+function makeContext(workingDir: string = testDir): ToolContext {
+  return {
+    workingDir,
+    sessionId: 'test-session',
+    conversationId: 'test-conversation',
+  };
+}
+
+// Minimal valid JPEG: FF D8 FF E0 header + enough bytes
+const JPEG_HEADER = Buffer.from([
+  0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46,
+  0x49, 0x46, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01,
+  0x00, 0x01, 0x00, 0x00,
+]);
+
+// Minimal valid PNG header
+const PNG_HEADER = Buffer.from([
+  0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A,
+  0x00, 0x00, 0x00, 0x0D, 0x49, 0x48, 0x44, 0x52,
+]);
+
+// Minimal valid GIF header
+const GIF_HEADER = Buffer.from([
+  0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 0x01, 0x00,
+  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+]);
+
+// Minimal valid WebP header (RIFF....WEBP)
+const WEBP_HEADER = Buffer.from([
+  0x52, 0x49, 0x46, 0x46, 0x24, 0x00, 0x00, 0x00,
+  0x57, 0x45, 0x42, 0x50, 0x56, 0x50, 0x38, 0x20,
+]);
+
+// ── Success cases ───────────────────────────────────────────────────
+
+describe('view_image tool', () => {
+  test('loads a JPEG file', async () => {
+    const imgPath = join(testDir, 'test.jpg');
+    writeFileSync(imgPath, JPEG_HEADER);
+
+    const result = await tool.execute({ path: 'test.jpg' }, makeContext());
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Image loaded');
+    expect(result.content).toContain('image/jpeg');
+    expect((result as any).contentBlocks).toBeDefined();
+    expect((result as any).contentBlocks[0].type).toBe('image');
+    expect((result as any).contentBlocks[0].source.media_type).toBe('image/jpeg');
+  });
+
+  test('loads a PNG file', async () => {
+    const imgPath = join(testDir, 'test.png');
+    writeFileSync(imgPath, PNG_HEADER);
+
+    const result = await tool.execute({ path: 'test.png' }, makeContext());
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('image/png');
+  });
+
+  test('loads a GIF file', async () => {
+    const imgPath = join(testDir, 'test.gif');
+    writeFileSync(imgPath, GIF_HEADER);
+
+    const result = await tool.execute({ path: 'test.gif' }, makeContext());
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('image/gif');
+  });
+
+  test('loads a WebP file', async () => {
+    const imgPath = join(testDir, 'test.webp');
+    writeFileSync(imgPath, WEBP_HEADER);
+
+    const result = await tool.execute({ path: 'test.webp' }, makeContext());
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('image/webp');
+  });
+
+  test('loads image with absolute path', async () => {
+    const imgPath = join(testDir, 'absolute.jpg');
+    writeFileSync(imgPath, JPEG_HEADER);
+
+    const result = await tool.execute({ path: imgPath }, makeContext());
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Image loaded');
+  });
+
+  test('returns base64-encoded data in content blocks', async () => {
+    const imgPath = join(testDir, 'base64.jpg');
+    writeFileSync(imgPath, JPEG_HEADER);
+
+    const result = await tool.execute({ path: 'base64.jpg' }, makeContext());
+
+    expect(result.isError).toBe(false);
+    const blocks = (result as any).contentBlocks;
+    expect(blocks[0].source.type).toBe('base64');
+    expect(blocks[0].source.data.length).toBeGreaterThan(0);
+  });
+});
+
+// ── Error cases ─────────────────────────────────────────────────────
+
+describe('view_image error handling', () => {
+  test('rejects missing path', async () => {
+    const result = await tool.execute({}, makeContext());
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('path is required');
+  });
+
+  test('rejects unsupported file extension', async () => {
+    const txtPath = join(testDir, 'readme.txt');
+    writeFileSync(txtPath, 'not an image');
+
+    const result = await tool.execute({ path: 'readme.txt' }, makeContext());
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('unsupported image format');
+    expect(result.content).toContain('.txt');
+  });
+
+  test('rejects nonexistent file', async () => {
+    const result = await tool.execute({ path: 'nonexistent.jpg' }, makeContext());
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('file not found');
+  });
+
+  test('rejects directory path', async () => {
+    const dirPath = join(testDir, 'subdir');
+    mkdirSync(dirPath, { recursive: true });
+    // Create a .jpg-named directory
+    const fakePath = join(testDir, 'fakedir.jpg');
+    mkdirSync(fakePath, { recursive: true });
+
+    const result = await tool.execute({ path: 'fakedir.jpg' }, makeContext());
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('is not a file');
+  });
+
+  test('blocks path traversal outside working directory', async () => {
+    const result = await tool.execute({ path: '../../etc/passwd.jpg' }, makeContext());
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('outside the working directory');
+  });
+
+  test('rejects file with unrecognizable magic bytes', async () => {
+    const imgPath = join(testDir, 'corrupt.jpg');
+    writeFileSync(imgPath, Buffer.from([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]));
+
+    const result = await tool.execute({ path: 'corrupt.jpg' }, makeContext());
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('could not detect image format');
+  });
+
+  test('detects JPEG format from magic bytes regardless of extension', async () => {
+    // Write JPEG magic bytes to a .png file
+    const imgPath = join(testDir, 'misnamed.png');
+    writeFileSync(imgPath, JPEG_HEADER);
+
+    const result = await tool.execute({ path: 'misnamed.png' }, makeContext());
+
+    expect(result.isError).toBe(false);
+    // Should detect as JPEG from magic bytes, not PNG from extension
+    expect(result.content).toContain('image/jpeg');
+  });
+});

package/src/__tests__/workspace-git-service.test.ts

@@ -9,6 +9,8 @@ import {
   _resetGitServiceRegistry,
   _resetBreaker,
   _getConsecutiveFailures,
+  _resetInitBreaker,
+  _getInitConsecutiveFailures,
   isDeadlineExpired,
 } from '../workspace/git-service.js';
 
@@ -945,6 +947,190 @@ describe('WorkspaceGitService', () => {
     });
   });
 
+  describe('commitIfDirty diff error handling', () => {
+    test('non-1 exit code from git diff --cached --quiet is treated as an error', async () => {
+      const service = new WorkspaceGitService(testDir);
+      await service.ensureInitialized();
+
+      // Create a file so the workspace is dirty and commitIfDirty will
+      // proceed past the "clean" early-return.
+      writeFileSync(join(testDir, 'test.txt'), 'content');
+
+      // Access the private execGit method and wrap it so that
+      // 'git diff --cached --quiet' throws with exit code 2 (simulating
+      // a real git error rather than the expected exit code 1 for
+      // "staged changes exist").
+      const proto = Object.getPrototypeOf(service);
+      const originalExecGit = proto.execGit;
+      proto.execGit = async function (this: unknown, args: string[]) {
+        if (args[0] === 'diff' && args[1] === '--cached' && args[2] === '--quiet') {
+          const err = new Error(
+            'Git command failed: git diff --cached --quiet\nError: simulated error\nStderr: ',
+          ) as Error & { code?: number };
+          err.code = 2;
+          throw err;
+        }
+        return originalExecGit.call(this, args);
+      };
+
+      try {
+        // commitIfDirty should propagate the error (not treat code 2 as
+        // "staged changes exist")
+        await expect(
+          service.commitIfDirty(() => ({ message: 'should not commit' })),
+        ).rejects.toThrow();
+      } finally {
+        // Restore the original method
+        proto.execGit = originalExecGit;
+      }
+    });
+  });
+
+  describe('init circuit breaker', () => {
+    test('init breaker opens after consecutive failures', async () => {
+      // Use a directory that doesn't exist so init fails
+      const badDir = '/nonexistent/path/that/does/not/exist';
+      const service = new WorkspaceGitService(badDir);
+
+      // First failure — breaker does NOT open (requires 2+ failures)
+      await expect(service.ensureInitialized()).rejects.toThrow();
+      expect(_getInitConsecutiveFailures(service)).toBe(1);
+
+      // Second failure — expire the backoff window from the first failure
+      // so the attempt actually runs (not blocked by breaker).
+      const internal = service as unknown as {
+        initNextAllowedAttemptMs: number;
+      };
+      internal.initNextAllowedAttemptMs = Date.now() - 1;
+
+      await expect(service.ensureInitialized()).rejects.toThrow();
+      expect(_getInitConsecutiveFailures(service)).toBe(2);
+
+      // Third attempt within the backoff window — breaker is now open
+      // (2+ consecutive failures) so the attempt is skipped.
+      await expect(service.ensureInitialized()).rejects.toThrow(
+        'Init circuit breaker open: backing off after repeated failures',
+      );
+      // Failure count should NOT increase (the breaker prevented the attempt)
+      expect(_getInitConsecutiveFailures(service)).toBe(2);
+    });
+
+    test('init breaker skips init attempts during backoff window', async () => {
+      const service = new WorkspaceGitService(testDir);
+
+      // Force the init breaker open
+      const internal = service as unknown as {
+        initConsecutiveFailures: number;
+        initNextAllowedAttemptMs: number;
+      };
+      internal.initConsecutiveFailures = 3;
+      internal.initNextAllowedAttemptMs = Date.now() + 60_000; // far in the future
+
+      // ensureInitialized should throw with circuit breaker message
+      await expect(service.ensureInitialized()).rejects.toThrow(
+        'Init circuit breaker open: backing off after repeated failures',
+      );
+
+      // Failure count should NOT increase (the breaker prevented the attempt)
+      expect(_getInitConsecutiveFailures(service)).toBe(3);
+    });
+
+    test('init breaker resets on success', async () => {
+      const service = new WorkspaceGitService(testDir);
+
+      // Simulate prior init failures
+      const internal = service as unknown as {
+        initConsecutiveFailures: number;
+        initNextAllowedAttemptMs: number;
+      };
+      internal.initConsecutiveFailures = 3;
+      // Set backoff in the past so the breaker is closed and allows retry
+      internal.initNextAllowedAttemptMs = Date.now() - 1;
+
+      // This should succeed and reset the init breaker
+      await service.ensureInitialized();
+
+      expect(_getInitConsecutiveFailures(service)).toBe(0);
+      expect(service.isInitialized()).toBe(true);
+    });
+
+    test('init breaker allows retry after backoff window expires', async () => {
+      const service = new WorkspaceGitService(testDir);
+
+      // Simulate prior init failures with expired backoff
+      const internal = service as unknown as {
+        initConsecutiveFailures: number;
+        initNextAllowedAttemptMs: number;
+      };
+      internal.initConsecutiveFailures = 5;
+      internal.initNextAllowedAttemptMs = Date.now() - 1; // expired
+
+      // Breaker should be closed (backoff expired), allowing init to proceed
+      await service.ensureInitialized();
+
+      expect(_getInitConsecutiveFailures(service)).toBe(0);
+      expect(service.isInitialized()).toBe(true);
+    });
+
+    test('init breaker is independent from commit breaker', async () => {
+      const service = new WorkspaceGitService(testDir);
+      await service.ensureInitialized();
+
+      // Force commit breaker open
+      const internal = service as unknown as {
+        consecutiveFailures: number;
+        nextAllowedAttemptMs: number;
+      };
+      internal.consecutiveFailures = 5;
+      internal.nextAllowedAttemptMs = Date.now() + 60_000;
+
+      // Init breaker should still be clean
+      expect(_getInitConsecutiveFailures(service)).toBe(0);
+
+      // Commit breaker should be open
+      expect(_getConsecutiveFailures(service)).toBe(5);
+
+      // Reset commit breaker
+      _resetBreaker(service);
+
+      // Force init breaker open
+      const internal2 = service as unknown as {
+        initConsecutiveFailures: number;
+        initNextAllowedAttemptMs: number;
+      };
+      internal2.initConsecutiveFailures = 3;
+      internal2.initNextAllowedAttemptMs = Date.now() + 60_000;
+
+      // Commit breaker should be clean
+      expect(_getConsecutiveFailures(service)).toBe(0);
+
+      // Init breaker should be open
+      expect(_getInitConsecutiveFailures(service)).toBe(3);
+
+      // Reset init breaker
+      _resetInitBreaker(service);
+      expect(_getInitConsecutiveFailures(service)).toBe(0);
+    });
+
+    test('already initialized service bypasses init breaker check', async () => {
+      const service = new WorkspaceGitService(testDir);
+      await service.ensureInitialized();
+      expect(service.isInitialized()).toBe(true);
+
+      // Force init breaker open
+      const internal = service as unknown as {
+        initConsecutiveFailures: number;
+        initNextAllowedAttemptMs: number;
+      };
+      internal.initConsecutiveFailures = 5;
+      internal.initNextAllowedAttemptMs = Date.now() + 60_000;
+
+      // ensureInitialized should succeed via the fast path (already initialized)
+      // without hitting the breaker
+      await service.ensureInitialized();
+    });
+  });
+
   describe('isDeadlineExpired helper', () => {
     test('returns false when deadlineMs is undefined', () => {
       expect(isDeadlineExpired(undefined)).toBe(false);

package/src/__tests__/workspace-heartbeat-service.test.ts

@@ -1,8 +1,10 @@
-import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { describe, test, expect, beforeEach, afterEach, afterAll } from 'bun:test';
 import { mkdirSync, rmSync, writeFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { execFileSync } from 'node:child_process';
+import type { CommitMessageProvider, CommitContext, CommitMessageResult } from '../workspace/commit-message-provider.js';
+
 import {
   WorkspaceGitService,
   _resetGitServiceRegistry,
@@ -11,7 +13,7 @@ import {
   HeartbeatService,
   _resetHeartbeatState,
 } from '../workspace/heartbeat-service.js';
-import type { CommitMessageProvider, CommitContext, CommitMessageResult } from '../workspace/commit-message-provider.js';
+import { _resetEnrichmentService, getEnrichmentService } from '../workspace/commit-message-enrichment-service.js';
 
 describe('HeartbeatService', () => {
   let testDir: string;
@@ -31,12 +33,20 @@ describe('HeartbeatService', () => {
     services.set(testDir, service);
   });
 
-  afterEach(() => {
+  afterEach(async () => {
+    // Shut down any in-flight enrichment work before removing the test directory
+    try { await getEnrichmentService().shutdown(); } catch { /* ignore */ }
+    _resetEnrichmentService();
     if (existsSync(testDir)) {
       rmSync(testDir, { recursive: true, force: true });
     }
   });
 
+  afterAll(async () => {
+    try { await getEnrichmentService().shutdown(); } catch { /* ignore */ }
+    _resetEnrichmentService();
+  });
+
   describe('heartbeat check with age threshold', () => {
     test('does not commit when workspace is clean', async () => {
       const heartbeat = new HeartbeatService({

package/src/agent-heartbeat/agent-heartbeat-service.ts

@@ -0,0 +1,155 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { getLogger } from '../util/logger.js';
+import { getWorkspacePromptPath } from '../util/platform.js';
+import { getConfig } from '../config/loader.js';
+import { createConversation } from '../memory/conversation-store.js';
+import type { AgentHeartbeatAlert } from '../daemon/ipc-contract.js';
+
+const log = getLogger('agent-heartbeat');
+
+const DEFAULT_CHECKLIST = `- Check the current weather and note anything notable
+- Review any recent news headlines worth flagging
+- Look for calendar events or reminders coming up soon`;
+
+export interface AgentHeartbeatDeps {
+  processMessage: (conversationId: string, content: string) => Promise<{ messageId: string }>;
+  alerter: (alert: AgentHeartbeatAlert) => void;
+  /** Override for current hour (0-23), for testing. */
+  getCurrentHour?: () => number;
+}
+
+export class AgentHeartbeatService {
+  private readonly deps: AgentHeartbeatDeps;
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private activeRun: Promise<void> | null = null;
+
+  constructor(deps: AgentHeartbeatDeps) {
+    this.deps = deps;
+  }
+
+  start(): void {
+    const config = getConfig().agentHeartbeat;
+    if (!config.enabled) {
+      log.info('Agent heartbeat disabled by config');
+      return;
+    }
+    if (this.timer) return;
+
+    log.info({ intervalMs: config.intervalMs }, 'Agent heartbeat service started');
+    this.timer = setInterval(() => {
+      this.runOnce().catch((err) => {
+        log.error({ err }, 'Agent heartbeat runOnce failed');
+      });
+    }, config.intervalMs);
+  }
+
+  async stop(): Promise<void> {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    if (this.activeRun) {
+      let timerId: ReturnType<typeof setTimeout>;
+      const timeout = new Promise<void>((resolve) => { timerId = setTimeout(resolve, 5_000); });
+      await Promise.race([this.activeRun, timeout]);
+      clearTimeout(timerId!);
+    }
+    log.info('Agent heartbeat service stopped');
+  }
+
+  async runOnce(): Promise<void> {
+    const config = getConfig().agentHeartbeat;
+    if (!config.enabled) return;
+
+    // Active hours guard — only applied when both bounds are set.
+    // The schema rejects configs where only one bound is provided.
+    if (config.activeHoursStart != null && config.activeHoursEnd != null) {
+      const hour = this.deps.getCurrentHour?.() ?? new Date().getHours();
+      if (!isWithinActiveHours(hour, config.activeHoursStart, config.activeHoursEnd)) {
+        log.debug({ hour, activeHoursStart: config.activeHoursStart, activeHoursEnd: config.activeHoursEnd }, 'Outside active hours, skipping');
+        return;
+      }
+    }
+
+    // Overlap prevention
+    if (this.activeRun) {
+      log.debug('Previous heartbeat run still active, skipping');
+      return;
+    }
+
+    const run = this.executeRun();
+    this.activeRun = run;
+    try {
+      await run;
+    } finally {
+      this.activeRun = null;
+    }
+  }
+
+  private async executeRun(): Promise<void> {
+    log.info('Running agent heartbeat');
+
+    try {
+      const checklist = this.readChecklist();
+      const prompt = this.buildPrompt(checklist);
+
+      const conversation = createConversation({
+        title: 'Agent Heartbeat',
+        threadType: 'background',
+      });
+
+      await this.deps.processMessage(conversation.id, prompt);
+      log.info({ conversationId: conversation.id }, 'Agent heartbeat completed');
+    } catch (err) {
+      log.error({ err }, 'Agent heartbeat failed');
+      try {
+        this.deps.alerter({
+          type: 'agent_heartbeat_alert',
+          title: 'Agent Heartbeat Failed',
+          body: err instanceof Error ? err.message : String(err),
+        });
+      } catch (alertErr) {
+        log.warn({ alertErr }, 'Failed to broadcast heartbeat alert');
+      }
+    }
+  }
+
+  private readChecklist(): string {
+    const heartbeatPath = getWorkspacePromptPath('HEARTBEAT.md');
+    if (existsSync(heartbeatPath)) {
+      try {
+        return readFileSync(heartbeatPath, 'utf-8');
+      } catch (err) {
+        log.warn({ err, heartbeatPath }, 'Failed to read HEARTBEAT.md, using default checklist');
+      }
+    }
+    return DEFAULT_CHECKLIST;
+  }
+
+  /** @internal Exposed for testing. */
+  buildPrompt(checklist: string): string {
+    return `You are running a periodic heartbeat check. Review the following checklist and take any necessary actions.
+
+<heartbeat-checklist>
+${checklist}
+</heartbeat-checklist>
+
+<heartbeat-disposition>
+After completing your review, end your response with one of:
+- HEARTBEAT_OK — if everything looks good, no action needed
+- HEARTBEAT_ALERT — if you found issues that need attention (describe them before this marker)
+</heartbeat-disposition>`;
+  }
+}
+
+/**
+ * Check if the given hour falls within the active window.
+ * Handles overnight windows (e.g. start=22, end=6).
+ */
+function isWithinActiveHours(hour: number, start: number, end: number): boolean {
+  if (start <= end) {
+    return hour >= start && hour < end;
+  }
+  // Overnight window: e.g. 22-6 means 22,23,0,1,2,3,4,5
+  return hour >= start || hour < end;
+}

package/src/bundler/app-bundler.ts

@@ -25,6 +25,8 @@ const bundlerLog = getLogger('app-bundler');
 import { APP_VERSION } from '../version.js';
 const PACKAGE_VERSION = APP_VERSION;
 
+const SHORT_HASH_LENGTH = 8;
+const HASH_DISPLAY_LENGTH = 12;
 const MAX_BUNDLE_SIZE_BYTES = 25 * 1024 * 1024; // 25 MB
 const ASSET_FETCH_TIMEOUT_MS = 10_000;
 
@@ -35,7 +37,7 @@ interface FetchedAsset {
 
 /**
  * Extract all remote (http/https) URLs from HTML content.
- * Looks in src=, href= on asset elements (not <a> tags), and CSS url() references.
+ * Looks in src=, href= on all elements except <a> tags, and CSS url() references.
  */
 export function extractRemoteUrls(html: string): string[] {
   const urls = new Set<string>();
@@ -50,11 +52,13 @@ export function extractRemoteUrls(html: string): string[] {
     }
   }
 
-  // Match href="..." only on <link> elements (stylesheets, icons, preloads), not <a> tags.
-  // Captures <link ...href="..."> where href appears anywhere within the tag.
-  const linkRe = /<link\b[^>]*?\bhref\s*=\s*(?:"([^"]*?)"|'([^']*?)'|([^\s>]+))[^>]*?\/?>/gi;
-  while ((m = linkRe.exec(html)) !== null) {
-    const url = m[1] ?? m[2] ?? m[3];
+  // Match href="..." on any element except navigation/resolution tags (not assets).
+  // Captures the tag name and href value so we can skip them.
+  const hrefRe = /<(\w+)\b[^>]*?\bhref\s*=\s*(?:"([^"]*?)"|'([^']*?)'|([^\s>]+))[^>]*?\/?>/gi;
+  while ((m = hrefRe.exec(html)) !== null) {
+    const tagName = m[1];
+    if (['a', 'base', 'area'].includes(tagName.toLowerCase())) continue;
+    const url = m[2] ?? m[3] ?? m[4];
     if (url && /^https?:\/\//i.test(url)) {
       urls.add(url);
     }
@@ -77,7 +81,7 @@ export function extractRemoteUrls(html: string): string[] {
  * Uses a hash of the URL to avoid collisions, preserving the original extension.
  */
 function assetFilename(url: string): string {
-  const hash = createHash('sha256').update(url).digest('hex').slice(0, 12);
+  const hash = createHash('sha256').update(url).digest('hex').slice(0, HASH_DISPLAY_LENGTH);
   let ext = '';
   try {
     const parsed = new URL(url);
@@ -213,7 +217,7 @@ export async function packageApp(
   const allAssets = [...allAssetsMap.values()];
 
   // Create the zip archive
-  const bundleFilename = `${app.name.replace(/[^a-zA-Z0-9_-]/g, '_')}-${randomUUID().slice(0, 8)}.vellumapp`;
+  const bundleFilename = `${app.name.replace(/[^a-zA-Z0-9_-]/g, '_')}-${randomUUID().slice(0, SHORT_HASH_LENGTH)}.vellumapp`;
   const bundlePath = join(tmpdir(), bundleFilename);
 
   await new Promise<void>((resolve, reject) => {