Obsidian Cost TuningSAFE

Model-agnostic agent-skills platform with a harness-free canonical layer, verified adapters, and the ccpi package manager. Explore at tonsofskills.com.

The instruction file, verbatim from the audited commit — this is the text the model reads, and the surface the audit's instruction layer examines. Quoted here so you can judge it without cloning anything.

---
name: obsidian-cost-tuning
description: 'Optimize Obsidian resource usage, sync storage, Publish hosting, and

  third-party plugin API costs. Use when managing vault size, reducing

  Sync bandwidth, controlling Publish costs, or optimizing external API

  consumption from community plugins.

  Trigger with phrases like "obsidian costs", "obsidian sync storage",

  "optimize obsidian", "reduce obsidian costs", "obsidian publish costs".

  '
allowed-tools: Read, Write, Edit, Bash(du:*), Bash(find:*), Grep
version: 1.13.0
license: MIT
author: Jeremy Longshore <[email protected]>
tags:
- obsidian
- cost-optimization
- sync
- publish
- storage
compatibility: Designed for Claude Code
---
# Obsidian Cost Tuning

## Overview

Optimize costs across Obsidian's paid services and third-party plugin API usage. Covers Obsidian Sync storage management ($4-$10/mo), Publish hosting optimization ($8/mo per site), vault size reduction strategies, plugin API cost control with caching and quotas, and self-hosted alternatives for zero-cost sync.

## Prerequisites

- Understanding of your Obsidian subscription tier
- Terminal access to the vault directory
- Knowledge of which community plugins make external API calls

## Cost Structure

| Service | Price | Storage | Cost Driver |
|---------|-------|---------|-------------|
| Obsidian (core) | Free | N/A | None |
| Catalyst (early access) | $25 one-time | N/A | One-time |
| Sync (Standard) | $4/mo | 1 GB | Vault size, attachment count |
| Sync (Plus) | $8/mo | 10 GB | Large vaults with media |
| Publish | $8/mo per site | N/A | Published page count, bandwidth |
| Plugin API costs | Varies | N/A | Per-call pricing (AI, translation, etc.) |

## Instructions

### Step 1: Audit Vault Size and Storage Usage

```bash
set -euo pipefail
VAULT_PATH="${1:-$HOME/MyVault}"

echo "=== Vault Storage Audit ==="
echo "Total vault size: $(du -sh "$VAULT_PATH" 2>/dev/null | cut -f1)"
echo ".obsidian size: $(du -sh "$VAULT_PATH/.obsidian" 2>/dev/null | cut -f1)"
echo ""

# File counts by type
echo "=== Files by Type ==="
command find "$VAULT_PATH" -type f -not -path '*/.obsidian/*' -not -path '*/.trash/*' \
  | sed 's/.*\.//' | sort | uniq -c | sort -rn | head -15

echo ""
echo "=== Top 20 Largest Files ==="
command find "$VAULT_PATH" -type f -not -path '*/.obsidian/*' \
  -exec du -h {} + 2>/dev/null | sort -rh | head -20

echo ""
echo "=== Plugin Cache Sizes ==="
for dir in "$VAULT_PATH/.obsidian/plugins"/*/; do
  [ -f "$dir/data.json" ] || continue
  size=$(du -h "$dir/data.json" 2>/dev/null | cut -f1)
  echo "  $(basename "$dir")/data.json: $size"
done
```

### Step 2: Reduce Sync Storage — Exclusion Patterns

Obsidian Sync respects `.obsidian/sync-exclude.json` for excluding paths:

```json
{
  "patterns": [
    "*.pdf",
    "*.mp4",
    "*.mov",
    "*.zip",
    "*.tar.gz",
    "attachments/archives/**",
    "node_modules/**",
    ".git/**"
  ]
}
```

For manual file-level control:

```bash
# Find files over 5MB that consume sync bandwidth
command find "$VAULT_PATH" -type f -size +5M -not -path '*/.obsidian/*' \
  -exec du -h {} + | sort -rh

# Count sync-heavy file types
echo "PDF count: $(command find "$VAULT_PATH" -name '*.pdf' | wc -l)"
echo "Image count: $(command find "$VAULT_PATH" \( -name '*.png' -o -name '*.jpg' -o -name '*.jpeg' \) | wc -l)"
echo "Total attachments: $(du -sh "$VAULT_PATH/attachments" 2>/dev/null | cut -f1)"
```

Strategies to stay under the 1 GB Sync Standard tier:

- Move PDFs to a local folder outside the vault, link with ` URIs
- Compress images before adding: `pngquant --quality=65-80 *.png` or ImageOptim
- Use external image hosting (Cloudinary free tier: 25 credits/mo, ~25K transforms)
- Exclude `.obsidian/plugins/*/data.json` — plugin caches regenerate on launch

### Step 3: Optimize Plugin API Costs

Plugins that call external APIs (AI assistants, translation, image generation) can incur per-call costs. Implement caching in your plugin:

```typescript
// src/services/api-cache.ts
import { Plugin } from 'obsidian';

interface CacheEntry<T> {
  result: T;
  timestamp: number;
}

export class APICache<T> {
  private cache = new Map<string, CacheEntry<T>>();
  private ttlMs: number;

  constructor(ttlMinutes: number = 60) {
    this.ttlMs = ttlMinutes * 60 * 1000;
  }

  get(key: string): T | null {
    const entry = this.cache.get(key);
    if (!entry) return null;
    if (Date.now() - entry.timestamp > this.ttlMs) {
      this.cache.delete(key);
      return null;
    }
    return entry.result;
  }

  set(key: string, result: T) {
    this.cache.set(key, { result, timestamp: Date.now() });
    // Prevent unbounded growth
    if (this.cache.size > 1000) {
      const oldest = this.cache.keys().next().value;
      if (oldest) this.cache.delete(oldest);
    }
  }

  /** Wrap an API call with cache-first logic */
  async getOrFetch(key: string, fetchFn: () => Promise<T>): Promise<T> {
    const cached = this.get(key);
    if (cached !== null) return cached;
    const result = await fetchFn();
    this.set(key, result);
    return result;
  }

  clear() { this.cache.clear(); }
  get size() { return this.cache.size; }
}

// Usage in plugin
const aiCache = new APICache<string>(24 * 60); // 24-hour TTL

async function getSummary(noteContent: string): Promise<string> {
  const hash = simpleHash(noteContent);
  return aiCache.getOrFetch(hash, async () => {
    // Only calls API if not cached
    const response = await requestUrl({ url: 'https://api.openai.com/...', ... });
    return response.json.choices[0].message.content;
  });
}
```

### Step 4: Rate Limiting for External Calls

```typescript
// Prevent runaway API costs with a quota counter
class APIQuota {
  private calls = 0;
  private resetTime = 0;
  private maxCallsPerHour: number;

  constructor(maxPerHour: number) {
    this.maxCallsPerHour = maxPerHour;
  }

  canCall(): boolean {
    const now = Date.now();
    if (now - this.resetTime > 3600000) {
      this.calls = 0;
   

SAFEgrade B · trust 89/100 Nothing in the source contradicts what it says it does. Grade A is reserved for packages that have also passed the behavioural sandbox.

What the source does

Filesystem

none-observed

Network

none-observed

Shell

none-observed

Dependencies

pinned

Secrets in source

none-found

Findings (0)

No findings outside the package's declared scope.

Gates applied: no_behavioural_pass.