From 3ea50d8768bfebb0a5cef372f2b2c6f13c5b9aae Mon Sep 17 00:00:00 2001
From: Will Scott <will@webboss.com>
Date: Sat, 25 Jul 2026 15:12:56 -0500
Subject: [PATCH 1/3] Label overlap + add Chunks-view legend (v3.2)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Chuck couldn't tell intentional RAG overlap from duplicate content, and
the Chunks view assumed vocabulary it never defined. All deterministic —
no AI calls.

API (api/chunk.js):
- addOverlap() records overlap_word_count on each section it modifies;
  enhanceChunks() carries it into the response
- settings.target_words exposes the active {min,max,target} size range
  so the UI reads it live instead of mirroring CHUNK_SIZES

UI (public/index.html):
- Overlap prefix renders dimmed with a "↔ Nw overlap" badge + tooltip
  explaining the intentional carry-over
- Collapsible "How to read this" legend defines Chunk, L#, Path,
  Sections, w/t, live target size range, and overlap
- Chunk meta pill gets an explanatory tooltip; "1 sections" plural fixed
- Heading-path breadcrumb labeled "PATH" with tooltip + legend entry
- Content Summary stat labels swapped (big=Chunks, small=Sections) to
  match the chunk cards and legend

Smoke-tested on the page Chuck screenshotted (Hayes Barton Place
assisted-living: Chunk 2's 29-word overlap now renders labeled) plus
searchinfluence.com, Wikipedia RAG article, and getchunks itself.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 SESSION_LOG.md    |  18 ++++++
 api/chunk.js      |  11 +++-
 public/index.html | 142 +++++++++++++++++++++++++++++++++++++++++-----
 tasks/todo.md     |  52 +++++++++++++++++
 4 files changed, 208 insertions(+), 15 deletions(-)

diff --git a/SESSION_LOG.md b/SESSION_LOG.md
index 1bb41e3..614f5cd 100644
--- a/SESSION_LOG.md
+++ b/SESSION_LOG.md
@@ -1,5 +1,23 @@
 # getchunks Session Log
 
+## 2026-07-24 — Chunk Quality plan (from Chuck's feedback) + repo moved out of archive
+
+**Session ran from ontologizer-next; planning only, no code changes here yet.**
+
+**Origin:** Chuck Wilkins Slack feedback — he couldn't interpret the Chunks view on the Hayes Barton Place assisted-living page and mistook the overlap prefix for duplicate content. Verified root cause: the sentence appears exactly once on the live page (`https://www.hayesbartonplace.com/bloomsbury-at-hayes-barton-place/assisted-living`); the "duplicate" is `addOverlap()` prepending the entire 29-word prior section because the overlap window (35w, 10% of medium target) exceeds the section length. `addOverlap()` doesn't record what it prepended, so the UI can't label it. Will's framing: keep everything deterministic — zero AI tokens.
+
+**Plan written (NOT yet executed):** "Chunk Quality upgrade (v3.2 → v3.4)" at the bottom of `tasks/todo.md`. Summary: v3.2 = overlap labeling + "how to read this" legend (needs `overlap_word_count` from the API); v3.3 = deterministic per-chunk flags (entity anchor, dangling reference, thin/oversized, generic heading, answer-buried, near-duplicate via Jaccard shingles, Flesch-Kincaid) + 0–100 Chunkability score; v3.4 = client-side BM25 retrieval simulator, paste-queries coverage matrix, markdown optimization-report export. Phase 4 parked: template query generator, `?queries=` deep-link from Ontologizer fan-out, compare mode.
+
+**Repo moved:** `~/Development/Development Archive/getchunks` → `~/Development/getchunks`. Git and Vercel unaffected (deploys from GitHub `searchinfluence/getchunks`). Working tree has exactly one modification: the plan appended to `tasks/todo.md`.
+
+**Next session:** get Will's approval on the plan, then branch `feature/chunk-quality-v3.2` off `main`. Smoke-test v3.2 against the Hayes Barton Place URL above (the exact page Chuck screenshotted).
+
+**2026-07-24 (cont.) — Phase 1 (v3.2) EXECUTED on `feature/chunk-quality-v3.2`, uncommitted, awaiting Will's review before PR:**
+- `api/chunk.js`: `addOverlap()` now records `overlap_word_count` per small chunk (carried through `enhanceChunks()`); `settings.target_words` ({min,max,target}) added so the UI reads size ranges live instead of mirroring `CHUNK_SIZES`.
+- `public/index.html`: overlap prefix rendered dimmed + dotted-underline with `↔ Nw overlap` badge and "intentional RAG carry-over" tooltip (UI splits the prefix with `^(?:\S+\s+){N}` against the reported count); collapsible "How to read this" legend at top of Chunks view (Chunk/L#/Sections/w-t/live size range/overlap); Content Summary stat labels swapped (they were reversed vs the chunk cards: big=Chunks, small=Sections).
+- Smoke-tested via `vercel dev --listen 3001` + Playwright: Hayes Barton Place Chunk 2 sec 2 = `overlap_word_count: 29`, renders badged/dimmed exactly as planned; 7 badges total (2w–35w). 3 more URLs (SI home, Wikipedia RAG, getchunks) — 0 prefix mismatches, no warnings, zero-overlap case clean. Screenshots in session scratchpad.
+- Will's review feedback, addressed same-branch: (1) tooltip on the chunk meta pill spelling out each part ("Chunk 1 of 4 on this page • starts at a level-2 heading (an <h2>) • …") + fixed "1 sections" plural; (2) breadcrumb now labeled "PATH" with a tooltip + legend bullet explaining it's the heading path (parent headings above the chunk, starting with the page title) stored for retrieval context. (3) His "actionable layer / score" ask = Phase 2 (v3.3 flags + Chunkability score) — confirmed as next.
+
 ## 2026-07-21 (cont. 2) — Dead-CSS cleanup, cross-links, Ontologizer preview fix
 
 **getchunks dead-CSS cleanup (#9, merged):** Removed 235 lines of orphaned rules whose classes left the DOM in the marketing-shell rebuild (.header/.header-content/.logo-*/.tagline/.header-description/.main-section/.form-card/.features/.feature*/old .faq-*/.footer + their @media entries). Verified render pixel-identical at 1440px; `<style>` braces balanced 243/243. Auto-deployed.
diff --git a/api/chunk.js b/api/chunk.js
index de49c79..c496ba4 100644
--- a/api/chunk.js
+++ b/api/chunk.js
@@ -254,6 +254,7 @@ async function chunkUrl(url, options) {
     settings: {
       strategy: finalOptions.strategy,
       chunk_size: finalOptions.chunkSize,
+      target_words: CHUNK_SIZES[finalOptions.chunkSize],
       overlap_words: finalOptions.overlap,
       extractor: extractorUsed,
       tokenizer: options.tokenizer,
@@ -657,8 +658,13 @@ function addOverlap(smallChunks, overlapWords) {
   for (let i = 0; i < smallChunks.length; i++) {
     if (i === 0) { result.push(smallChunks[i]); continue; }
     const prevWords = smallChunks[i - 1].text.trim().split(/\s+/);
-    const overlap = prevWords.slice(-Math.min(overlapWords, prevWords.length)).join(' ');
-    result.push({ ...smallChunks[i], text: `${overlap} ${smallChunks[i].text}` });
+    const overlapCount = Math.min(overlapWords, prevWords.length);
+    const overlap = prevWords.slice(-overlapCount).join(' ');
+    result.push({
+      ...smallChunks[i],
+      text: `${overlap} ${smallChunks[i].text}`,
+      overlap_word_count: overlapCount,
+    });
   }
   return result;
 }
@@ -685,6 +691,7 @@ function enhanceChunks(bigChunks, tokenizer) {
       return {
         text,
         content_type: sc.content_type || detectContentType(text),
+        overlap_word_count: sc.overlap_word_count || 0,
         chunk_index: idx + 1,
         word_count,
         char_count,
diff --git a/public/index.html b/public/index.html
index 306c3c3..ea1a47a 100644
--- a/public/index.html
+++ b/public/index.html
@@ -411,6 +411,64 @@
             font-weight: 600;
         }
 
+        .overlap-badge {
+            display: inline-block;
+            background: rgba(52, 144, 181, 0.1);
+            border: 1px solid rgba(52, 144, 181, 0.4);
+            color: var(--info-blue);
+            padding: 2px 8px;
+            border-radius: 12px;
+            font-size: 0.75rem;
+            font-weight: 700;
+            margin-right: 8px;
+            white-space: nowrap;
+            cursor: help;
+        }
+
+        .overlap-prefix {
+            color: var(--muted-text);
+            background: rgba(52, 144, 181, 0.07);
+            border-bottom: 1px dotted var(--dark-gray);
+            cursor: help;
+        }
+
+        .chunks-legend {
+            background: var(--background-gray);
+            border: 1px solid var(--border-gray);
+            border-radius: 12px;
+            margin-bottom: 30px;
+            color: var(--content-text);
+        }
+
+        .chunks-legend summary {
+            cursor: pointer;
+            font-weight: 700;
+            font-size: 1rem;
+            padding: 16px 30px;
+            list-style-position: inside;
+        }
+
+        .chunks-legend[open] summary {
+            border-bottom: 1px solid var(--border-gray);
+        }
+
+        .chunks-legend-body {
+            padding: 20px 30px;
+            font-size: 0.95rem;
+        }
+
+        .chunks-legend-body p {
+            margin-bottom: 12px;
+        }
+
+        .chunks-legend-body ul {
+            margin: 0 0 0 20px;
+        }
+
+        .chunks-legend-body li {
+            margin-bottom: 8px;
+        }
+
         .loading {
             display: none;
             text-align: center;
@@ -597,6 +655,16 @@
             line-height: 1.4;
             color: rgba(255, 255, 255, 0.75);
             word-break: break-word;
+            cursor: help;
+        }
+
+        .big-chunk-breadcrumb .crumb-label {
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+            font-size: 0.7rem;
+            font-weight: 700;
+            opacity: 0.6;
+            margin-right: 6px;
         }
 
         .big-chunk-breadcrumb .crumb-sep {
@@ -615,6 +683,7 @@
             max-width: 40%;
             overflow: hidden;
             text-overflow: ellipsis;
+            cursor: help;
         }
 
         @media (max-width: 640px) {
@@ -2069,6 +2138,27 @@ <h2 id="faq-heading" class="section-title">Frequently asked questions</h2>
             function displayChunksView(data) {
                 let html = '';
 
+                // Collapsible legend (v3.2) — defines the vocabulary before the data
+                const tw = data.settings?.target_words;
+                const overlapSetting = data.settings?.overlap_words || 0;
+                html += `<details class="chunks-legend">`;
+                html += `<summary>ℹ️ How to read this</summary>`;
+                html += `<div class="chunks-legend-body">`;
+                html += `<p>This view shows the page the way a retrieval system (RAG, AI search) stores it: split into standalone pieces it can fetch one at a time.</p>`;
+                html += `<ul>`;
+                html += `<li><strong>Chunk</strong> — one heading section of the page: a heading plus its content, up to the next heading.</li>`;
+                html += `<li><strong>L#</strong> — that heading's level. L2 = an &lt;h2&gt;.</li>`;
+                html += `<li><strong>Path</strong> — the breadcrumb under a chunk title: the parent headings above it, starting with the page title. Retrieval systems store it so a fetched section keeps its page context.</li>`;
+                html += `<li><strong>Sections</strong> — the numbered retrieval units inside a chunk. This is what a search or AI system actually fetches and quotes.</li>`;
+                html += `<li><strong>w / t</strong> — word count / token count (tokens are how AI models measure text).</li>`;
+                if (tw) {
+                    html += `<li><strong>Section size</strong> — this run aims for ${tw.min}–${tw.max} words per section (${escapeHtml(String(data.settings.chunk_size))}, target ${tw.target}).</li>`;
+                }
+                if (overlapSetting > 0) {
+                    html += `<li><strong><span class="overlap-badge" style="cursor:default;margin-right:0;">↔ overlap</span></strong> — the dimmed opening words repeat the end of the previous section on purpose (up to ${overlapSetting} words on this run). Standard RAG practice so a section still makes sense when retrieved alone — not duplicate content.</li>`;
+                }
+                html += `</ul></div></details>`;
+
                 // Source metadata block (new in v3)
                 if (data.source) {
                     const s = data.source;
@@ -2099,8 +2189,8 @@ <h2 id="faq-heading" class="section-title">Frequently asked questions</h2>
                     html += `<div class="chunks-summary">`;
                     html += `<h3>📊 Content Summary</h3>`;
                     html += `<div class="summary-stats">`;
-                    html += `<div class="stat"><strong>${data.summary.total_big_chunks}</strong> Sections</div>`;
-                    html += `<div class="stat"><strong>${data.summary.total_small_chunks}</strong> Chunks</div>`;
+                    html += `<div class="stat"><strong>${data.summary.total_big_chunks}</strong> Chunks</div>`;
+                    html += `<div class="stat"><strong>${data.summary.total_small_chunks}</strong> Sections</div>`;
                     html += `<div class="stat"><strong>${data.summary.total_words.toLocaleString()}</strong> Words</div>`;
                     html += `<div class="stat"><strong>${tokens.toLocaleString()}</strong> Tokens</div>`;
                     html += `</div>`;
@@ -2132,19 +2222,29 @@ <h2 id="faq-heading" class="section-title">Frequently asked questions</h2>
                         const breadcrumb = Array.isArray(chunk.heading_path) ? chunk.heading_path : [];
                         const showBreadcrumb = breadcrumb.length > 1 || (breadcrumb.length === 1 && breadcrumb[0] !== chunk.title);
                         if (showBreadcrumb) {
-                            html += `<div class="big-chunk-breadcrumb">`;
+                            const crumbTip = 'Heading path — the parent headings above this chunk, starting with the page title. Stored with every section so a retrieval system knows where on the page the content came from.';
+                            html += `<div class="big-chunk-breadcrumb" title="${escapeHtml(crumbTip)}">`;
+                            html += `<span class="crumb-label">Path</span>`;
                             html += breadcrumb.map(p => escapeHtml(p)).join('<span class="crumb-sep">›</span>');
                             html += `</div>`;
                         }
                         html += `</div>`;
 
                         const tokens = chunk.metadata?.total_tokens ?? chunk.metadata?.total_tokens_estimate;
-                        let metaText = `Chunk ${chunk.big_chunk_index} • L${chunk.level} • ${chunk.small_chunks.length} sections`;
+                        const secCount = chunk.small_chunks.length;
+                        const secLabel = `section${secCount === 1 ? '' : 's'}`;
+                        let metaText = `Chunk ${chunk.big_chunk_index} • L${chunk.level} • ${secCount} ${secLabel}`;
+                        const tipParts = [
+                            `Chunk ${chunk.big_chunk_index} of ${data.big_chunks.length} on this page`,
+                            `starts at a level-${chunk.level} heading (an <h${chunk.level}>)`,
+                            `${secCount} retrieval ${secLabel}`,
+                        ];
                         if (chunk.metadata) {
                             metaText += ` • ${chunk.metadata.total_words}w • ${tokens}t`;
+                            tipParts.push(`${chunk.metadata.total_words} words`, `${tokens} tokens`);
                         }
-                        const metaTitle = chunk.fragment ? ` title="${escapeHtml(chunk.fragment)}"` : '';
-                        html += `<div class="big-chunk-meta"${metaTitle}>${metaText}</div>`;
+                        if (chunk.fragment) tipParts.push(`anchor: ${chunk.fragment}`);
+                        html += `<div class="big-chunk-meta" title="${escapeHtml(tipParts.join(' • '))}">${metaText}</div>`;
                         html += `</div>`;
 
                         // Small chunks container
@@ -2154,26 +2254,42 @@ <h2 id="faq-heading" class="section-title">Frequently asked questions</h2>
                             const wordCount = smallChunk.word_count;
                             const tokens = smallChunk.tokens ?? smallChunk.token_estimate;
                             const contentType = smallChunk.content_type;
+                            const overlapWords = smallChunk.overlap_word_count || 0;
 
                             html += `<div class="small-chunk">`;
                             html += `<div class="small-chunk-index">${smallIndex + 1}</div>`;
                             html += `<div class="small-chunk-content">`;
 
-                            if (text.startsWith('- ')) {
-                                const listItems = text.split('\n').map(item => {
+                            // Overlap prefix (v3.2): the API prepends the tail of the
+                            // previous section and reports how many words it added.
+                            // Render that prefix dimmed + labeled so it doesn't read
+                            // as duplicate content.
+                            let body = text;
+                            if (overlapWords > 0) {
+                                const match = text.match(new RegExp(`^(?:\\S+\\s+){${overlapWords}}`));
+                                if (match) {
+                                    const tip = `Repeated from the previous section on purpose (${overlapWords}-word overlap) so this section stands alone if retrieved by itself — not duplicate content.`;
+                                    html += `<span class="overlap-badge" title="${escapeHtml(tip)}">↔ ${overlapWords}w overlap</span>`;
+                                    html += `<span class="overlap-prefix" title="${escapeHtml(tip)}">${escapeHtml(match[0].trimEnd())}</span> `;
+                                    body = text.slice(match[0].length);
+                                }
+                            }
+
+                            if (body.startsWith('- ')) {
+                                const listItems = body.split('\n').map(item => {
                                     if (item.startsWith('- ')) {
                                         return `<li>${escapeHtml(item.substring(2))}</li>`;
                                     }
                                     return '';
                                 }).filter(Boolean).join('');
                                 html += `<ul>${listItems}</ul>`;
-                            } else if (text.startsWith('> ')) {
-                                html += `<blockquote>${escapeHtml(text.substring(2))}</blockquote>`;
-                            } else if (text.startsWith('```')) {
-                                const code = text.replace(/```\n?/g, '');
+                            } else if (body.startsWith('> ')) {
+                                html += `<blockquote>${escapeHtml(body.substring(2))}</blockquote>`;
+                            } else if (body.startsWith('```')) {
+                                const code = body.replace(/```\n?/g, '');
                                 html += `<pre><code>${escapeHtml(code)}</code></pre>`;
                             } else {
-                                html += escapeHtml(text);
+                                html += escapeHtml(body);
                             }
 
                             if (wordCount || tokens || contentType) {
diff --git a/tasks/todo.md b/tasks/todo.md
index d98d015..f249524 100644
--- a/tasks/todo.md
+++ b/tasks/todo.md
@@ -101,3 +101,55 @@ Housekeeping:
 **Rate limiting — DONE (2026-07-21, via Vercel Firewall API):** Two additive custom rules live on prj_wOIeC5... (team will-scotts-projects, Pro). `chunk-rate-limit`: path pre `/api/chunk`, 20 req/60s/IP → deny. `feedback-rate-limit`: path pre `/api/feedback`, 5 req/600s/IP → deny. firewallEnabled=true, config version 2. Managed WAF ruleset untouched. Applied via `PATCH /v1/security/firewall/config` (rules.insert) after `vercel login` refresh; the CLI has no firewall command. To tune later: edit in the dashboard Firewall tab or re-PATCH.
 
 **Deferred:** fixture/snapshot tests for split/merge/overlap; nested-content extraction fix for the cheerio fallback path.
+
+## Plan: Chunk Quality upgrade (v3.2 → v3.4) — 2026-07-24
+
+**Origin:** Chuck Wilkins feedback — he couldn't interpret the Chunks view (mistook overlap for duplicate content, asked what "good" looks like and how to turn output into page optimizations). Goal: move the tool from "is this page chunkable?" to "here's what to change" — 100% deterministic, zero AI tokens.
+
+**Constraint:** all analysis is pure code (regex, word counts, stoplists, token overlap, BM25, Jaccard shingles, Flesch-Kincaid). No LLM calls anywhere.
+
+### Phase 1 — Comprehension (v3.2): make current output self-explanatory
+Branch: `feature/chunk-quality-v3.2`
+
+- [x] `api/chunk.js`: `addOverlap()` records `overlap_word_count` on each small chunk it modifies (words prepended from the previous chunk) — carried through `enhanceChunks()`; also added `settings.target_words` ({min,max,target}) so the UI reads size ranges live instead of mirroring `CHUNK_SIZES`
+- [x] UI: render the overlap prefix dimmed/underlined inside the section text, with a `↔ Nw overlap` badge + tooltip ("Repeated from the previous chunk on purpose so this chunk stands alone if retrieved by itself")
+- [x] UI: collapsible "How to read this" legend at the top of Chunks view — defines Chunk (heading section), L# (heading level), sections (retrieval units), w/t, target size ranges (pull live from `settings`), and overlap. Also swapped the Content Summary stat labels (big=Chunks, small=Sections) — they were reversed vs the chunk cards
+- [x] Smoke test on the Hayes Barton Place page (the exact page Chuck screenshotted) — Chunk 2 sec 2 reports `overlap_word_count: 29`, renders badged + dimmed; 7 overlap badges total (2w–35w). Playwright-verified. Plus 3 known URLs (searchinfluence.com, Wikipedia RAG article, getchunks itself): 0 prefix-regex mismatches, target_words tracks auto-detected size, zero-overlap case clean.
+
+### Phase 2 — Diagnosis (v3.3): flags + Chunkability score
+Branch: `feature/chunk-quality-v3.3`
+
+- [ ] `api/chunk.js`: new pure function `analyzeChunks(bigChunks, source, settings)` → per-chunk `flags[]` (`{code, severity, message, fix}`) + top-level `chunkability: {score, grade, top_fixes[]}`
+- [ ] Anchor-term set: tokenized page title + H1 + `og:site_name` + JSON-LD Organization/LocalBusiness names (all already captured in `source`)
+- [ ] Flags (all deterministic):
+  - [ ] `no-entity-anchor` — no anchor term appears in chunk text
+  - [ ] `dangling-reference` — chunk opens `^(Our|This|These|It|They|He|She)\b`
+  - [ ] `thin-section` — big chunk word count under target min
+  - [ ] `oversized-section` — big chunk over target max with no subheading
+  - [ ] `generic-heading` — heading in stoplist (~30 entries: "Why Choose Us", "Learn More", "Overview", …)
+  - [ ] `answer-buried` — zero stemmed content-word overlap between heading and first sentence
+  - [ ] `near-duplicate` — word 5-gram Jaccard ≥ 0.6 between chunk pair, after subtracting the known overlap prefix
+  - [ ] `readability` — Flesch-Kincaid grade per chunk (info-level, no score deduction initially)
+- [ ] Score: 100 minus weighted deductions; same input → same score (re-run after edits shows the delta)
+- [ ] UI: score card in `chunks-summary` (score + grade + top 3 fixes)
+- [ ] UI: color-coded flag chips on chunk cards (red/amber/info), each expanding to its one-line fix
+- [ ] UI: "show only flagged" filter toggle
+- [ ] Tune weights + stoplist against 5 real client pages before shipping
+
+### Phase 3 — Action (v3.4): retrieval simulator + report export
+Branch: `feature/chunk-quality-v3.4`
+
+- [ ] Client-side BM25 (~60 lines, no deps) over small chunks
+- [ ] "Test retrieval" panel: single question → ranked chunks with scores, winner highlighted with its flags shown (does the winning chunk stand alone?)
+- [ ] Multi-query textarea (one per line — from GSC, keyword tools, or an Ontologizer fan-out run) → coverage matrix: query → best chunk → score → covered / weak / gap
+- [ ] "Copy optimization report" — markdown export: URL, score, flags grouped by severity with specific edits, coverage gaps. This is the SEO-facing deliverable; JSON stays for devs
+- [ ] CSV copy for the coverage matrix
+
+### Phase 4 — Later / optional
+- [ ] Template query generator (entity × heading permutations) to prefill the simulator — zero-AI fan-out approximation
+- [ ] `?queries=` URL param so Ontologizer's fan-out tab can deep-link into the chunker
+- [ ] Compare mode: re-run same URL, show score delta
+- [ ] Docs: README section explaining every flag and the score formula (determinism = explainability; publish the rubric)
+
+### Review
+_(fill in after execution)_

From c3491628099b110aece0789d7a99d87eaea0eaaa Mon Sep 17 00:00:00 2001
From: Will Scott <will@webboss.com>
Date: Sat, 25 Jul 2026 15:32:36 -0500
Subject: [PATCH 2/3] Accept schemeless URLs in the input (seasidefl.com works)

type="url" made the browser reject bare domains before submit. Switch to
type="text" (inputmode="url" keeps the mobile keyboard) and default to
https:// in the submit handler when no scheme is given. Full URLs pass
through untouched; the API's scheme allowlist stays strict.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 public/index.html | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/public/index.html b/public/index.html
index ea1a47a..2371a54 100644
--- a/public/index.html
+++ b/public/index.html
@@ -1523,9 +1523,11 @@ <h1>Chunk any web page for RAG</h1>
                         <label for="url-input">Website URL</label>
                         <div class="url-input-group">
                             <input
-                                type="url"
+                                type="text"
+                                inputmode="url"
+                                spellcheck="false"
                                 id="url-input"
-                                placeholder="https://example.com/article-or-page"
+                                placeholder="example.com/article-or-page"
                                 required
                                 autocomplete="url"
                             >
@@ -1864,8 +1866,10 @@ <h2 id="faq-heading" class="section-title">Frequently asked questions</h2>
             form.addEventListener('submit', async function(e) {
                 e.preventDefault();
 
-                const url = urlInput.value.trim();
+                let url = urlInput.value.trim();
                 if (!url) return;
+                // Accept bare domains — default to https when no scheme given
+                if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(url)) url = `https://${url}`;
 
                 // Get advanced options values
                 const chunkSize = chunkSizeSelect.value === 'auto' ? undefined : chunkSizeSelect.value;

From b90bfa7f58795b31c322208f28926f107e99d011 Mon Sep 17 00:00:00 2001
From: Will Scott <will@webboss.com>
Date: Sat, 25 Jul 2026 15:37:05 -0500
Subject: [PATCH 3/3] Replace native title tooltips with CSS tooltips
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The title attribute gave a help cursor but no visible tip in practice —
native tooltips need a long hover rest and never render in some embedded
browsers. New [data-tip] component renders the hint as a styled ::after
immediately on hover (.tip-right modifier anchors the chunk meta pill's
tip to its right edge). big-chunk-meta drops overflow:hidden/ellipsis so
the pseudo-element isn't clipped; it wraps instead when narrow.

The overlap prefix keeps its native title as a best-effort extra — CSS
tooltips don't position reliably on multi-line inline spans, and the
badge beside it carries the same message.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 SESSION_LOG.md    |  1 +
 public/index.html | 56 ++++++++++++++++++++++++++++++++++++++---------
 2 files changed, 47 insertions(+), 10 deletions(-)

diff --git a/SESSION_LOG.md b/SESSION_LOG.md
index 614f5cd..c7f78cf 100644
--- a/SESSION_LOG.md
+++ b/SESSION_LOG.md
@@ -17,6 +17,7 @@
 - `public/index.html`: overlap prefix rendered dimmed + dotted-underline with `↔ Nw overlap` badge and "intentional RAG carry-over" tooltip (UI splits the prefix with `^(?:\S+\s+){N}` against the reported count); collapsible "How to read this" legend at top of Chunks view (Chunk/L#/Sections/w-t/live size range/overlap); Content Summary stat labels swapped (they were reversed vs the chunk cards: big=Chunks, small=Sections).
 - Smoke-tested via `vercel dev --listen 3001` + Playwright: Hayes Barton Place Chunk 2 sec 2 = `overlap_word_count: 29`, renders badged/dimmed exactly as planned; 7 badges total (2w–35w). 3 more URLs (SI home, Wikipedia RAG, getchunks) — 0 prefix mismatches, no warnings, zero-overlap case clean. Screenshots in session scratchpad.
 - Will's review feedback, addressed same-branch: (1) tooltip on the chunk meta pill spelling out each part ("Chunk 1 of 4 on this page • starts at a level-2 heading (an <h2>) • …") + fixed "1 sections" plural; (2) breadcrumb now labeled "PATH" with a tooltip + legend bullet explaining it's the heading path (parent headings above the chunk, starting with the page title) stored for retrieval context. (3) His "actionable layer / score" ask = Phase 2 (v3.3 flags + Chunkability score) — confirmed as next.
+- More review feedback, same branch (PR #10): URL input now accepts bare domains (type="text" + inputmode="url", submit handler prepends https:// when schemeless; API validation untouched). Native title="" tooltips weren't showing for Will (help cursor but no tip — native titles need a long hover and never render in some embedded browsers), so replaced with a pure-CSS [data-tip] ::after tooltip component (instant, styled, .tip-right modifier for the meta pill; big-chunk-meta lost its overflow:hidden ellipsis so the pseudo-element isn't clipped). overlap-prefix keeps native title only — CSS tooltips don't position reliably on multi-line inline spans; the adjacent badge carries the working tooltip.
 
 ## 2026-07-21 (cont. 2) — Dead-CSS cleanup, cross-links, Ontologizer preview fix
 
diff --git a/public/index.html b/public/index.html
index 2371a54..00e73ab 100644
--- a/public/index.html
+++ b/public/index.html
@@ -649,13 +649,55 @@
             margin: 0;
         }
 
+        /* Pure-CSS tooltips — native title="" is unreliable (long hover delay,
+           never shown in some embedded browsers), so hints render as a styled
+           ::after that appears immediately on hover. */
+        [data-tip] {
+            position: relative;
+            cursor: help;
+        }
+
+        [data-tip]::after {
+            content: attr(data-tip);
+            position: absolute;
+            top: calc(100% + 8px);
+            left: 0;
+            z-index: 30;
+            width: max-content;
+            max-width: 320px;
+            background: var(--si-dark-navy);
+            color: var(--white);
+            border: 1px solid var(--surface-slate-border);
+            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.25);
+            padding: 10px 14px;
+            border-radius: 8px;
+            font-size: 0.8rem;
+            font-weight: 400;
+            line-height: 1.5;
+            white-space: normal;
+            text-align: left;
+            opacity: 0;
+            visibility: hidden;
+            transition: opacity 0.15s ease;
+            pointer-events: none;
+        }
+
+        [data-tip]:hover::after {
+            opacity: 1;
+            visibility: visible;
+        }
+
+        [data-tip].tip-right::after {
+            left: auto;
+            right: 0;
+        }
+
         .big-chunk-breadcrumb {
             margin-top: 6px;
             font-size: 0.85rem;
             line-height: 1.4;
             color: rgba(255, 255, 255, 0.75);
             word-break: break-word;
-            cursor: help;
         }
 
         .big-chunk-breadcrumb .crumb-label {
@@ -679,11 +721,7 @@
             border-radius: 20px;
             font-size: 0.85rem;
             font-weight: 500;
-            white-space: nowrap;
             max-width: 40%;
-            overflow: hidden;
-            text-overflow: ellipsis;
-            cursor: help;
         }
 
         @media (max-width: 640px) {
@@ -693,8 +731,6 @@
             }
             .big-chunk-meta {
                 max-width: 100%;
-                white-space: normal;
-                text-overflow: clip;
             }
         }
 
@@ -2227,7 +2263,7 @@ <h2 id="faq-heading" class="section-title">Frequently asked questions</h2>
                         const showBreadcrumb = breadcrumb.length > 1 || (breadcrumb.length === 1 && breadcrumb[0] !== chunk.title);
                         if (showBreadcrumb) {
                             const crumbTip = 'Heading path — the parent headings above this chunk, starting with the page title. Stored with every section so a retrieval system knows where on the page the content came from.';
-                            html += `<div class="big-chunk-breadcrumb" title="${escapeHtml(crumbTip)}">`;
+                            html += `<div class="big-chunk-breadcrumb" data-tip="${escapeHtml(crumbTip)}">`;
                             html += `<span class="crumb-label">Path</span>`;
                             html += breadcrumb.map(p => escapeHtml(p)).join('<span class="crumb-sep">›</span>');
                             html += `</div>`;
@@ -2248,7 +2284,7 @@ <h2 id="faq-heading" class="section-title">Frequently asked questions</h2>
                             tipParts.push(`${chunk.metadata.total_words} words`, `${tokens} tokens`);
                         }
                         if (chunk.fragment) tipParts.push(`anchor: ${chunk.fragment}`);
-                        html += `<div class="big-chunk-meta" title="${escapeHtml(tipParts.join(' • '))}">${metaText}</div>`;
+                        html += `<div class="big-chunk-meta tip-right" data-tip="${escapeHtml(tipParts.join(' • '))}">${metaText}</div>`;
                         html += `</div>`;
 
                         // Small chunks container
@@ -2273,7 +2309,7 @@ <h2 id="faq-heading" class="section-title">Frequently asked questions</h2>
                                 const match = text.match(new RegExp(`^(?:\\S+\\s+){${overlapWords}}`));
                                 if (match) {
                                     const tip = `Repeated from the previous section on purpose (${overlapWords}-word overlap) so this section stands alone if retrieved by itself — not duplicate content.`;
-                                    html += `<span class="overlap-badge" title="${escapeHtml(tip)}">↔ ${overlapWords}w overlap</span>`;
+                                    html += `<span class="overlap-badge" data-tip="${escapeHtml(tip)}">↔ ${overlapWords}w overlap</span>`;
                                     html += `<span class="overlap-prefix" title="${escapeHtml(tip)}">${escapeHtml(match[0].trimEnd())}</span> `;
                                     body = text.slice(match[0].length);
                                 }