npm · local0.11.6

Evidence

const last = _deprecationLogLastAt.get(key) || 0;

    if (now - last < DEPRECATION_LOG_INTERVAL_MS) continue;

    _deprecationLogLastAt.set(key, now);

    console.warn(`[awareness_recall] [deprecated param used] ${key} — migrate to single-parameter \`query\` (F-053)`);

  }

}

Remediation

Strip C0/C1 control codes before printing user-controlled values. Python: re.sub(r"[\x00-\x08\x0b-\x1f\x7f]", "", s). Prefer a structured logger (json/logfmt) over raw print to stdout.

Evidence

if (hit) results.byCategory[category].hits++;

    const status = hit ? '✅' : '❌';

    console.log(`  ${status} [${category}] "${query}"`);

    if (!hit) {

      console.log(`     Expected: ${expectedTitles.join(', ')}`);

      console.log(`     Got top-5: ${titles.join(' | ') || '(none)'}`);

Remediation

Strip C0/C1 control codes before printing user-controlled values. Python: re.sub(r"[\x00-\x08\x0b-\x1f\x7f]", "", s). Prefer a structured logger (json/logfmt) over raw print to stdout.

Evidence

jsonResponse(res, { error: 'Not Found' }, 404);

  } catch (err) {

    console.error('[awareness-local] request error:', err.message);

    track('error_occurred', { error_code: err.code || 'unknown', component: 'api' });

    jsonResponse(res, { error: 'Internal Server Error' }, 500);

  }

Remediation

Strip C0/C1 control codes before printing user-controlled values. Python: re.sub(r"[\x00-\x08\x0b-\x1f\x7f]", "", s). Prefer a structured logger (json/logfmt) over raw print to stdout.

Evidence

}

  } catch {

    console.log(`Awareness Local: running (PID ${pid})`);

    console.log(`  Raw response: ${resp.body}`);

  }

}

Remediation

Strip C0/C1 control codes before printing user-controlled values. Python: re.sub(r"[\x00-\x08\x0b-\x1f\x7f]", "", s). Prefer a structured logger (json/logfmt) over raw print to stdout.

Evidence

).all();

} catch (err) {

  // Skills table may not exist in older DBs — don't silently pretend 0.

  console.warn(`[card-quality-report] skills query failed: ${err.message}`);

}

// ---------------------------------------------------------------------------

Remediation

Strip C0/C1 control codes before printing user-controlled values. Python: re.sub(r"[\x00-\x08\x0b-\x1f\x7f]", "", s). Prefer a structured logger (json/logfmt) over raw print to stdout.

Evidence

ORDER BY created_at ASC`

      ).all();

    } catch (err) {

      console.warn(`${LOG_PREFIX} _pushCardsV2 query failed:`, err.message);

      return { synced: 0, errors: 0, conflicts: 0 };

    }

    if (!cards.length) return { synced: 0, errors: 0, conflicts: 0 };

Remediation

Strip C0/C1 control codes before printing user-controlled values. Python: re.sub(r"[\x00-\x08\x0b-\x1f\x7f]", "", s). Prefer a structured logger (json/logfmt) over raw print to stdout.

Evidence

);

      process.exit(0);

    }

    console.error(

      `[awareness-local] Port ${port} is held by another process but workspace switch failed:\n` +

      `  ${switchRes ? `HTTP ${switchRes.status}: ${switchRes.body.slice(0, 200)}` : 'no response'}\n` +

      `  Stop the existing daemon or pass --port <other> to run a second instance.`

    );

    process.exit(1);

Remediation

Strip C0/C1 control codes before printing user-controlled values. Python: re.sub(r"[\x00-\x08\x0b-\x1f\x7f]", "", s). Prefer a structured logger (json/logfmt) over raw print to stdout.

Evidence

headers: { ...this._authHeaders(), 'Content-Type': 'application/json', 'Content-Length': String(Buffer.byteLength(jsonBody)) },

      });

      if (status >= 200 && status < 300) return JSON.parse(body);

      console.warn(`${LOG_PREFIX} POST ${endpoint} → HTTP ${status}: ${body.slice(0, 200)}`);

      return null;

    } catch (err) { console.warn(`${LOG_PREFIX} POST ${endpoint} failed:`, err.message); return null; }

  }

Remediation

Strip C0/C1 control codes before printing user-controlled values. Python: re.sub(r"[\x00-\x08\x0b-\x1f\x7f]", "", s). Prefer a structured logger (json/logfmt) over raw print to stdout.

Evidence

for (const event of parsed) {

        // Handle event asynchronously — don't block the stream

        handleSSEEvent(event).catch((err) => {

          console.warn(`${LOG_PREFIX} SSE event handler error:`, err.message);

        });

      }

    });

Remediation

Strip C0/C1 control codes before printing user-controlled values. Python: re.sub(r"[\x00-\x08\x0b-\x1f\x7f]", "", s). Prefer a structured logger (json/logfmt) over raw print to stdout.

Evidence

}).catch(() => {});

      let lastPct = 0;

      for (let i = 0; i < 60; i++) {

        const r = await fetch('/api/v1/scan/status').catch(() => null);

        if (r && r.ok) {

          const s = await r.json();

          const status = s?.status || 'idle';

Remediation

Pass timeout= on every call: - HTTP: `requests.get(url, timeout=5)`, `httpx.get(url, timeout=5.0)` - Node fetch: `AbortSignal.timeout(5000)` - Subprocess: `subprocess.run(["cmd"], timeout=30, check=True)` Pick a value short enough to fail fast and retry.

Evidence

// Derive has_docs / has_readme from scan/files if scan/status doesn't provide them.

    try {

      const r = await fetch(`${base}/scan/files?category=docs&limit=1`);

      if (r.ok) {

        const d = await r.json();

        if ((d?.total || 0) > 0) meta.has_docs = true;

Remediation

Pass timeout= on every call: - HTTP: `requests.get(url, timeout=5)`, `httpx.get(url, timeout=5.0)` - Node fetch: `AbortSignal.timeout(5000)` - Subprocess: `subprocess.run(["cmd"], timeout=30, check=True)` Pick a value short enough to fail fast and retry.

Evidence

const started = Date.now();

    try {

      const url = `/api/v1/search?q=${encodeURIComponent(query)}&limit=${Math.max(limit, 8)}`;

      const r = await fetch(url);

      const elapsedMs = Date.now() - started;

      if (!r.ok) return { items: [], meta: { elapsedMs, total: 0, raw_hits: 0 } };

      const data = await r.json();

Remediation

Pass timeout= on every call: - HTTP: `requests.get(url, timeout=5)`, `httpx.get(url, timeout=5.0)` - Node fetch: `AbortSignal.timeout(5000)` - Subprocess: `subprocess.run(["cmd"], timeout=30, check=True)` Pick a value short enough to fail fast and retry.

Evidence

};

    try {

      const r = await fetch(`${base}/stats`);

      if (r.ok) {

        const s = await r.json();

        meta.total_cards = s?.totalKnowledge ?? s?.stats?.totalKnowledge ?? 0;

Remediation

Pass timeout= on every call: - HTTP: `requests.get(url, timeout=5)`, `httpx.get(url, timeout=5.0)` - Node fetch: `AbortSignal.timeout(5000)` - Subprocess: `subprocess.run(["cmd"], timeout=30, check=True)` Pick a value short enough to fail fast and retry.

Evidence

async function getProjectDir() {

    try {

      const r = await fetch('/healthz');

      const j = await r.json();

      return j?.project_dir || '—';

    } catch { return '—'; }

Remediation

Pass timeout= on every call: - HTTP: `requests.get(url, timeout=5)`, `httpx.get(url, timeout=5.0)` - Node fetch: `AbortSignal.timeout(5000)` - Subprocess: `subprocess.run(["cmd"], timeout=30, check=True)` Pick a value short enough to fail fast and retry.

Evidence

/** Fetch recent knowledge cards for tag-hotness based question generation. */

  async function loadKnowledgeMeta({ limit = 30 } = {}) {

    try {

      const r = await fetch(`/api/v1/knowledge?limit=${limit}`);

      if (!r.ok) return [];

      const data = await r.json();

      return data?.items || [];

Remediation

Pass timeout= on every call: - HTTP: `requests.get(url, timeout=5)`, `httpx.get(url, timeout=5.0)` - Node fetch: `AbortSignal.timeout(5000)` - Subprocess: `subprocess.run(["cmd"], timeout=30, check=True)` Pick a value short enough to fail fast and retry.

Evidence

async function fetchJson(url, opts) {

    try {

      const r = await fetch(url, opts);

      if (!r.ok) return null;

      return await r.json();

    } catch { return null; }

Remediation

Pass timeout= on every call: - HTTP: `requests.get(url, timeout=5)`, `httpx.get(url, timeout=5.0)` - Node fetch: `AbortSignal.timeout(5000)` - Subprocess: `subprocess.run(["cmd"], timeout=30, check=True)` Pick a value short enough to fail fast and retry.

Evidence

// Load workspaces async

  try {

    const ws = await (await fetch('/api/v1/workspaces')).json();

    const el = document.getElementById('ws-list');

    if (!ws || Object.keys(ws).length === 0) {

      el.innerHTML = `<span style="color:var(--text-muted);font-size:0.82rem">${t('settings.ws_no')}</span>`;

Remediation

Pass timeout= on every call: - HTTP: `requests.get(url, timeout=5)`, `httpx.get(url, timeout=5.0)` - Node fetch: `AbortSignal.timeout(5000)` - Subprocess: `subprocess.run(["cmd"], timeout=30, check=True)` Pick a value short enough to fail fast and retry.

Evidence

async function fetchJson(url) {

    try {

      const r = await fetch(url);

      if (!r.ok) return null;

      return await r.json();

    } catch { return null; }

Remediation

Pass timeout= on every call: - HTTP: `requests.get(url, timeout=5)`, `httpx.get(url, timeout=5.0)` - Node fetch: `AbortSignal.timeout(5000)` - Subprocess: `subprocess.run(["cmd"], timeout=30, check=True)` Pick a value short enough to fail fast and retry.

Evidence

async function getWikiSummary() {

    try {

      const r = await fetch('/api/v1/scan/files?category=wiki&limit=10');

      if (r.ok) {

        const data = await r.json();

        const pages = Array.isArray(data?.files) ? data.files : [];

Remediation

Pass timeout= on every call: - HTTP: `requests.get(url, timeout=5)`, `httpx.get(url, timeout=5.0)` - Node fetch: `AbortSignal.timeout(5000)` - Subprocess: `subprocess.run(["cmd"], timeout=30, check=True)` Pick a value short enough to fail fast and retry.

Evidence

// ── Helpers ──

async function api(path, options) {

  try { const r = await fetch(API + path, options); if (!r.ok) throw new Error('HTTP ' + r.status); return await r.json(); } catch (e) { console.error('[api]', path, e); return null; }

}

let workspaceDataLoadToken = 0;

Remediation

Pass timeout= on every call: - HTTP: `requests.get(url, timeout=5)`, `httpx.get(url, timeout=5.0)` - Node fetch: `AbortSignal.timeout(5000)` - Subprocess: `subprocess.run(["cmd"], timeout=30, check=True)` Pick a value short enough to fail fast and retry.

Evidence

} catch {}

    try {

      const r = await fetch(`${base}/scan/files?category=wiki&limit=5`);

      if (r.ok) {

        const data = await r.json();

        const pages = Array.isArray(data?.files) ? data.files : [];

Remediation

Pass timeout= on every call: - HTTP: `requests.get(url, timeout=5)`, `httpx.get(url, timeout=5.0)` - Node fetch: `AbortSignal.timeout(5000)` - Subprocess: `subprocess.run(["cmd"], timeout=30, check=True)` Pick a value short enough to fail fast and retry.

Evidence

} catch {}

    try {

      const r = await fetch(`${base}/scan/status`);

      if (r.ok) {

        const s = await r.json();

        const langs = s?.languages || s?.language_counts || {};

Remediation

Pass timeout= on every call: - HTTP: `requests.get(url, timeout=5)`, `httpx.get(url, timeout=5.0)` - Node fetch: `AbortSignal.timeout(5000)` - Subprocess: `subprocess.run(["cmd"], timeout=30, check=True)` Pick a value short enough to fail fast and retry.

Evidence

return r.json();

  }

  async function get(path) {

    const r = await fetch(`${API}${path}`);

    if (!r.ok) throw new Error(`${path} → ${r.status}`);

    return r.json();

  }

Remediation

Pass timeout= on every call: - HTTP: `requests.get(url, timeout=5)`, `httpx.get(url, timeout=5.0)` - Node fetch: `AbortSignal.timeout(5000)` - Subprocess: `subprocess.run(["cmd"], timeout=30, check=True)` Pick a value short enough to fail fast and retry.

Evidence

// than asking them to "connect cloud" a second time.

        (async () => {

          try {

            const r = await fetch('/api/v1/sync/status');

            if (r.ok) {

              const s = await r.json();

              if (s?.cloud_enabled || s?.enabled || s?.connected) {

Remediation

Pass timeout= on every call: - HTTP: `requests.get(url, timeout=5)`, `httpx.get(url, timeout=5.0)` - Node fetch: `AbortSignal.timeout(5000)` - Subprocess: `subprocess.run(["cmd"], timeout=30, check=True)` Pick a value short enough to fail fast and retry.

Evidence

async function checkDaemon() {

  try {

    const resp = await fetch('/healthz');

    if (!resp.ok) throw new Error();

    const d = await resp.json();

    document.getElementById('daemon-dot').className = 'dot ok';

Remediation

Pass timeout= on every call: - HTTP: `requests.get(url, timeout=5)`, `httpx.get(url, timeout=5.0)` - Node fetch: `AbortSignal.timeout(5000)` - Subprocess: `subprocess.run(["cmd"], timeout=30, check=True)` Pick a value short enough to fail fast and retry.

Evidence

priority: z.string().optional().describe('Priority filter (tasks/risks)'),

        session_id: z.string().optional().describe('Session ID (for session_history)'),

        agent_role: z.string().optional().describe('Agent role filter'),

        query: z.string().optional().describe('Keyword filter'),

      },

      async (params) => {

        try {

Remediation

Shape the schema to the tool's actual intent: - Zod: chain `.enum([...])`, `.regex(/.../)`, or `.max(n)`; prefer `z.enum([...])` or `z.literal(...)` when the value set is small. - Pydantic: use `Literal["a", "b"]` or `Field(max_length=..., pattern=r"...")`. - JSON Schema: add `"enum"`, `"pattern"`, or `"maxLength"` to the property. An overbroad schema is an "overpowered tool" — the model has nothing to prevent it from calling the tool with input far beyond what the tool's prose contract

Evidence

'Memory identifier (ignored in local mode, uses project dir)',

      ),

      source: z.string().optional().describe('Client source identifier'),

      query: z.string().optional().describe('Current user request or task focus for context shaping'),

      days: z.number().optional().default(7).describe(

        'Days of history to load',

      ),

Remediation

Shape the schema to the tool's actual intent: - Zod: chain `.enum([...])`, `.regex(/.../)`, or `.max(n)`; prefer `z.enum([...])` or `z.literal(...)` when the value set is small. - Pydantic: use `Literal["a", "b"]` or `Field(max_length=..., pattern=r"...")`. - JSON Schema: add `"enum"`, `"pattern"`, or `"maxLength"` to the property. An overbroad schema is an "overpowered tool" — the model has nothing to prevent it from calling the tool with input far beyond what the tool's prose contract

Evidence

priority: z.string().optional().describe('Priority filter (tasks/risks)'),

      session_id: z.string().optional().describe('Session ID (for session_history)'),

      agent_role: z.string().optional().describe('Agent role filter'),

      query: z.string().optional().describe('Keyword filter'),

    },

    async (params) => {

      try {

Remediation

Shape the schema to the tool's actual intent: - Zod: chain `.enum([...])`, `.regex(/.../)`, or `.max(n)`; prefer `z.enum([...])` or `z.literal(...)` when the value set is small. - Pydantic: use `Literal["a", "b"]` or `Field(max_length=..., pattern=r"...")`. - JSON Schema: add `"enum"`, `"pattern"`, or `"maxLength"` to the property. An overbroad schema is an "overpowered tool" — the model has nothing to prevent it from calling the tool with input far beyond what the tool's prose contract

Evidence

'Memory identifier (ignored in local mode, uses project dir)'

        ),

        source: z.string().optional().describe('Client source identifier'),

        query: z.string().optional().describe('Current user request or task focus for context shaping'),

        days: z.number().optional().default(7).describe(

          'Days of history to load'

        ),

Remediation

Shape the schema to the tool's actual intent: - Zod: chain `.enum([...])`, `.regex(/.../)`, or `.max(n)`; prefer `z.enum([...])` or `z.literal(...)` when the value set is small. - Pydantic: use `Literal["a", "b"]` or `Field(max_length=..., pattern=r"...")`. - JSON Schema: add `"enum"`, `"pattern"`, or `"maxLength"` to the property. An overbroad schema is an "overpowered tool" — the model has nothing to prevent it from calling the tool with input far beyond what the tool's prose contract

Evidence

"benchmark:universal": "node bin/awareness-local.mjs benchmark --project ../../tests/memory-benchmark/projects/universal-core --dataset ../../tests/memory-benchmark/datasets/universal_core.jsonl --backend all --reindex --report ../../tests/memory-benchmark/reports/universal_core_baseline.json",

    "benchmark:universal:robust": "node bin/awareness-local.mjs benchmark --project ../../tests/memory-benchmark/projects/universal-core --dataset ../../tests/memory-benchmark/datasets/universal_robust.js

Remediation

Prefer libraries that do not require install-time code execution: - Drop `postinstall`/`preinstall`/`prepare` scripts if the work can happen at runtime or build-time instead. - Ship pre-built native binaries rather than compiling via a custom `cmdclass` or `build_ext` override. - For Dockerfiles: replace `RUN curl … | sh` with a pinned download + checksum verification + explicit `RUN` of a named script. - If the hook is unavoidable, document exactly what it does so downstream reviewers

Evidence

}

          if (!Array.isArray(methods)) methods = [];

          let pitfalls = [];

          if (s.pitfalls) { try { pitfalls = JSON.parse(s.pitfalls); } catch {} }

          let verification = [];

          if (s.verification) { try { verification = JSON.parse(s.verification); } catch {} }

          return {

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

function _safeJsonParse(val, fallback) {

  if (Array.isArray(val)) return val;

  if (typeof val === 'string') {

    try { const p = JSON.parse(val); if (Array.isArray(p)) return p; } catch {}

  }

  return fallback;

}

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

}

  function tearDown(markComplete = true) {

    if (pollAbort) { try { pollAbort(); } catch {} pollAbort = null; }

    if (overlayEl) {

      overlayEl.remove();

      overlayEl = null;

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

let pitfalls = [];

          try { pitfalls = JSON.parse(skill.pitfalls || '[]'); } catch {}

          let verification = [];

          try { verification = JSON.parse(skill.verification || '[]'); } catch {}

          // Hydrate top-3 source cards so the skill is self-contained —

          // LLM sees the linked context, not just IDs. "skill = head of its

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

}

      el.innerHTML = h || `<span style="color:var(--text-muted);font-size:0.82rem">${t('settings.ws_no_user')}</span>`;

    }

  } catch {}

}

function settingDisplay(label, value, isHtml) {

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

const s = await r.json();

        meta.total_cards = s?.totalKnowledge ?? s?.stats?.totalKnowledge ?? 0;

      }

    } catch {}

    try {

      const r = await fetch(`${base}/scan/status`);

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

try {

      await post('/cloud/auth/open-browser', { url });

    } catch {

      try { window.open(url, '_blank'); } catch {}

    }

  }

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

try {

        const documents = batch.map(node => {

          let meta = {};

          try { meta = JSON.parse(node.metadata || '{}'); } catch (_) {}

          return {

            title: node.title,

            content: node.content || '',

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

function setLocale(loc) {

  if (!LOCALES[loc]) return;

  currentLocale = loc;

  try { localStorage.setItem('awareness_locale', loc); } catch {}

  // Re-apply static labels + re-render current view

  applyStaticI18n();

  if (typeof updateLangLabel === 'function') updateLangLabel();

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

const res = await pushCard(apiBase, memoryId, auth, card, card.version ?? undefined);

      if (res.status >= 200 && res.status < 300) {

        let cid = null;

        try { cid = JSON.parse(res.body)?.id || JSON.parse(res.body)?.cloud_id; } catch {}

        const sql = cid

          ? 'UPDATE knowledge_cards SET cloud_id = ?, synced_to_cloud = 1 WHERE id = ?'

          : 'UPDATE knowledge_cards SET synced_to_cloud = 1 WHERE id = ?';

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

try { localStorage.setItem(k, v); } catch {}

  };

  const del = (k) => {

    try { localStorage.removeItem(k); } catch {}

  };

  const State = {

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

const content = esc(r.content || "");

      let daysAgo = 0;

      if (r.created_at) {

        try { daysAgo = Math.floor((Date.now() - new Date(r.created_at).getTime()) / 86400000); } catch {}

      }

      if (score > 0.8 && daysAgo > 3) {

        return `    <aha score="${score.toFixed(2)}" days-ago="${daysAgo}">${content}</aha>`;

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

headers: { 'Content-Type': 'application/json' },

          body: JSON.stringify({ enabled }),

        });

      } catch {}

    };

    root.querySelector('[data-action="next"]').onclick = async () => { await persistOptIn(); onNext(); };

    root.querySelectorAll('[data-action="skip-all"]').forEach((b) => {

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

const pages = Array.isArray(data?.files) ? data.files : [];

        meta.wiki_titles = pages.map((p) => p.title).filter(Boolean).slice(0, 5);

      }

    } catch {}

    return meta;

  }

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

let pitfalls = [];

          if (s.pitfalls) { try { pitfalls = JSON.parse(s.pitfalls); } catch {} }

          let verification = [];

          if (s.verification) { try { verification = JSON.parse(s.verification); } catch {} }

          return {

            id: s.id,

            title: s.name || '',

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

meta.has_readme = !!s?.has_readme;

        meta.has_docs = !!s?.has_docs || !!s?.doc_count;

      }

    } catch {}

    // Derive has_docs / has_readme from scan/files if scan/status doesn't provide them.

    try {

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

})),

        };

      }

    } catch {}

    return { total: 0, samples: [] };

  }

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

meta.has_readme = true;

        }

      }

    } catch {}

    try {

      const r = await fetch(`${base}/scan/files?category=wiki&limit=5`);

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

try { return localStorage.getItem(k); } catch { return null; }

  };

  const write = (k, v) => {

    try { localStorage.setItem(k, v); } catch {}

  };

  const del = (k) => {

    try { localStorage.removeItem(k); } catch {}

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

// -- Core logic (exported for testing) -------------------------------------

function parseTags(raw) {

  if (!raw) return [];

  try { const p = JSON.parse(raw); if (Array.isArray(p)) return p.map(String); } catch {}

  return String(raw).split(',').map(s => s.trim()).filter(Boolean);

}

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

const filtered = candidates.filter((sig) => {

    let sigTags = [];

    try { sigTags = JSON.parse(sig.metadata || '{}').tags || []; } catch {}

    const hasTagOverlap = sigTags.some((t) => memTags.has(String(t).toLowerCase()));

    const sigWords = (sig.title || '').toLowerCase().split(/\s+/).filter((w) => w.length > 3);

    const hasKeyword = sigWords.some((w) => memText.includes(w));

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

headers: { 'Content-Type': 'application/json' },

        body: JSON.stringify({ installation_id: this.installationId }),

      }).catch(() => {});

    } catch {}

  }

  shutdown() {

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

}

        await new Promise((r) => setTimeout(r, 1000));

      }

    } catch {}

    onProgress({ pct: 100 });

    return { files: 0, symbols: 0, wiki: 0 };

  }

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

try {

    const saved = localStorage.getItem('awareness_locale');

    if (saved && LOCALES[saved]) return saved;

  } catch {}

  // Detect browser language

  const nav = (navigator.language || navigator.userLanguage || 'en').toLowerCase();

  if (nav.startsWith('zh')) return 'zh';

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

// channel. Fire-and-forget — absence of embedder / closed task just

    // skips the cache write.

    if (task.status !== 'open') {

      try { this.db.prepare('DELETE FROM task_embeddings WHERE task_id = ?').run(task.id); } catch {}

    } else if (this._embedder?.embed) {

      const text = `${task.title || ''} ${task.description || ''}`.substring(0, 400);

      Promise.resolve(this._embedder.embed(text, 'passage'))

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

return d.toLocaleDateString(undefined, { month:'short', day:'numeric', year: d.getFullYear() !== now.getFullYear() ? 'numeric' : undefined });

  } catch { return iso; }

}

function parseTags(t) { if (Array.isArray(t)) return t; if (typeof t === 'string') { try { const p = JSON.parse(t); if (Array.isArray(p)) return p; } catch {} } return []; }

function catLabel(c) { return (c || 'other').replace(/_/g, ' ').replace(/\b\w/g, x => x.toUpperCase()); }

function confClass(c) { return c >= 0.8 ? 'high' 

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

const triggerConditions = JSON.parse(skill.trigger_conditions || '[]');

          const sourceCardIds = JSON.parse(skill.source_card_ids || '[]');

          let pitfalls = [];

          try { pitfalls = JSON.parse(skill.pitfalls || '[]'); } catch {}

          let verification = [];

          try { verification = JSON.parse(skill.verification || '[]'); } catch {}

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.