@pmelab/gtd 14.0.1 → 15.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "14.0.1",
+  "version": "15.0.0",
   "private": false,
   "description": "Git-aware CLI that emits the next prompt for an autonomous coding agent based on the current repository state",
   "bin": {

package/src/flows/runtime.ts

@@ -125,6 +125,8 @@ export interface FlowContext {
   readonly glob: (pattern: string) => readonly string[]
   /** The last step's changes, content read on demand. */
   readonly changes: () => readonly Change[]
+  /** Every change from the tree at `hash` to the tree replay stands on. Throws when `hash` resolves to neither. */
+  readonly changesSince: (hash: string) => readonly Change[]
   readonly matches: (path: string, pattern: string) => boolean
   readonly sections: (text: string) => readonly string[]
   readonly sectionBodies: (text: string) => readonly Section[]
@@ -201,17 +203,34 @@ export const read = (path: string): string | undefined => ctx().read(path)
 /** Every path in the tree matching `pattern` (`*` stays within a segment, `**` crosses them). */
 export const glob = (pattern: string): readonly string[] => ctx().glob(pattern)
 
-/** What the last step changed, optionally only the paths matching a glob. */
-export const changes = (pattern?: string): Changes => {
-  const context = ctx()
-  const all = context.changes()
-  const list = pattern === undefined ? all : all.filter((c) => context.matches(c.path, pattern))
-  return Object.freeze(
+const toChanges = (list: readonly Change[]): Changes =>
+  Object.freeze(
     Object.assign([...list], {
       paths: list.map((c) => c.path),
       get: (path: string) => list.find((c) => c.path === path),
     }),
   )
+
+/** What the last step changed, optionally only the paths matching a glob. */
+export const changes = (pattern?: string): Changes => {
+  const context = ctx()
+  const all = context.changes()
+  return toChanges(
+    pattern === undefined ? all : all.filter((c) => context.matches(c.path, pattern)),
+  )
+}
+
+/**
+ * Every change from the tree at `hash` to the tree replay stands on — this
+ * package's own range, when `hash` is captured at its first step. `hash` must
+ * be the episode's base or one of its commits; anything else fails the step.
+ */
+export const changesSince = (hash: string, pattern?: string): Changes => {
+  const context = ctx()
+  const all = context.changesSince(hash)
+  return toChanges(
+    pattern === undefined ? all : all.filter((c) => context.matches(c.path, pattern)),
+  )
 }
 
 /** The commit the process stands on at this point of the flow. */

package/src/workflows/diff.test.ts

@@ -0,0 +1,115 @@
+import { describe, expect, it } from "vitest"
+import type { Change } from "../flows/index.js"
+import { filterChanges, packageDiff } from "./diff.js"
+
+const change = (over: Partial<Change> & Pick<Change, "path" | "status">): Change => ({
+  before: undefined,
+  after: undefined,
+  ...over,
+})
+
+// A cap high enough that nothing is ever dropped, for cases exercising the
+// rendering pipeline rather than the byte-budget behavior itself.
+const NO_CAP = 10_000
+
+describe("packageDiff / rendering", () => {
+  it("renders a normal edit as hunks with three lines of context", () => {
+    const before = Array.from({ length: 10 }, (_, i) => `line ${i + 1}`).join("\n")
+    const after = before.replace("line 5", "line five")
+    const text = packageDiff([change({ path: "a.ts", status: "modified", before, after })], NO_CAP)
+    expect(text).toContain("--- a/a.ts")
+    expect(text).toContain("+++ b/a.ts")
+    expect(text).toContain("-line 5")
+    expect(text).toContain("+line five")
+    // three lines of context on either side of the one changed line
+    expect(text).toContain(" line 2")
+    expect(text).toContain(" line 8")
+    expect(text).not.toContain(" line 1\n")
+  })
+
+  it("degrades a 1500+ line change to its summary line", () => {
+    const before = Array.from({ length: 2000 }, (_, i) => `line ${i}`).join("\n")
+    const after = Array.from({ length: 2000 }, (_, i) => `changed ${i}`).join("\n")
+    const text = packageDiff(
+      [change({ path: "big.ts", status: "modified", before, after })],
+      NO_CAP,
+    )
+    expect(text).toBe("big.ts: +2000/-2000 lines, too large to inline")
+  })
+
+  it("renders files in path order for byte-identical output across replays", () => {
+    const a = change({ path: "z.ts", status: "added", after: "z" })
+    const b = change({ path: "a.ts", status: "added", after: "a" })
+    expect(packageDiff([a, b], NO_CAP)).toBe(packageDiff([b, a], NO_CAP))
+    expect(packageDiff([a, b], NO_CAP).indexOf("a.ts")).toBeLessThan(
+      packageDiff([a, b], NO_CAP).indexOf("z.ts"),
+    )
+  })
+})
+
+describe("filterChanges / exclusion list", () => {
+  it("excludes a lockfile change entirely", () => {
+    const c = change({ path: "package-lock.json", status: "modified", before: "a", after: "b" })
+    expect(filterChanges([c])).toEqual([])
+    expect(packageDiff([c], NO_CAP)).toBe("")
+  })
+
+  it("excludes .gtd/** paths", () => {
+    const c = change({ path: ".gtd/PLAN.md", status: "added", after: "x" })
+    expect(filterChanges([c])).toEqual([])
+  })
+
+  it("excludes a binary file by extension", () => {
+    const c = change({ path: "logo.png", status: "added", after: "binary-ish" })
+    expect(filterChanges([c])).toEqual([])
+  })
+
+  it("excludes a binary file by content, separately from extension", () => {
+    const c = change({ path: "weird.txt", status: "added", after: "abc\0def" })
+    expect(filterChanges([c])).toEqual([])
+  })
+
+  it("keeps an ordinary source file", () => {
+    const c = change({ path: "src/a.ts", status: "added", after: "export const a = 1\n" })
+    expect(filterChanges([c])).toEqual([c])
+  })
+})
+
+describe("packageDiff", () => {
+  it("drops whole files from the end and names them in a trailer", () => {
+    const a = change({ path: "a.ts", status: "added", after: "export const a = 1\n" })
+    const b = change({
+      path: "b.ts",
+      status: "added",
+      after: Array.from({ length: 50 }, (_, i) => `line ${i}`).join("\n"),
+    })
+    const text = packageDiff([a, b], 120)
+    expect(text).toContain("--- /dev/null")
+    expect(text).toContain("+++ b/a.ts")
+    expect(text).not.toContain("b.ts\n")
+    expect(text).toContain("1 file(s) omitted for the judge's byte budget: b.ts")
+  })
+
+  it("counts the omission trailer itself against the cap, so many dropped paths never push the total past it", () => {
+    const kept = change({ path: "a.ts", status: "added", after: "export const a = 1\n" })
+    const rest = Array.from({ length: 6 }, (_, i) =>
+      change({ path: `f${i}.ts`, status: "added", after: "y" }),
+    )
+    // A naive cap check (size the kept text alone, append the trailer
+    // afterwards) would keep a.ts plus two of the small files here — 150
+    // bytes of text — then tack on an unbudgeted trailer for the other four,
+    // landing well past capBytes. Budgeting the trailer itself must instead
+    // drop enough files that the total, trailer included, stays at or under it.
+    const capBytes = 150
+    const text = packageDiff([kept, ...rest], capBytes)
+    expect(Buffer.byteLength(text, "utf8")).toBeLessThanOrEqual(capBytes)
+    expect(text).toContain("omitted")
+  })
+
+  it("keeps every file when the cap is not exceeded", () => {
+    const a = change({ path: "a.ts", status: "added", after: "x" })
+    const text = packageDiff([a], 10_000)
+    expect(text).not.toContain("omitted")
+    expect(text).toContain("a.ts")
+  })
+})

package/src/workflows/diff.ts

@@ -0,0 +1,306 @@
+import type { Change } from "../flows/index.js"
+
+// Pure evidence rendering for `packages.item.spec.pre`: no step, no tree
+// access. Everything here works from the `Change` list a flow already holds.
+
+const CONTEXT = 3
+const TOO_LARGE_LINES = 1500
+
+// ── The fixed exclusion list — no configuration key ─────────────────────────
+
+const LOCKFILES = new Set([
+  "package-lock.json",
+  "npm-shrinkwrap.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "bun.lock",
+  "bun.lockb",
+  "Cargo.lock",
+  "composer.lock",
+  "Gemfile.lock",
+  "poetry.lock",
+  "uv.lock",
+  "Pipfile.lock",
+  "go.sum",
+  "flake.lock",
+  "mix.lock",
+  "pubspec.lock",
+  "Podfile.lock",
+  "gradle.lockfile",
+])
+
+const GENERATED_GLOBS = [
+  "dist/**",
+  "build/**",
+  "out/**",
+  "coverage/**",
+  "node_modules/**",
+  "vendor/**",
+  ".turbo/**",
+  "**/__snapshots__/**",
+  "**/*.snap",
+  "**/*.min.js",
+  "**/*.min.css",
+  "**/*.map",
+]
+
+const BINARY_EXTENSIONS = new Set([
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "webp",
+  "ico",
+  "pdf",
+  "zip",
+  "gz",
+  "tar",
+  "woff",
+  "woff2",
+  "ttf",
+  "otf",
+  "mp4",
+  "wasm",
+  "bin",
+  "exe",
+  "so",
+  "dylib",
+])
+
+// A small, self-contained glob match — `*` stays within a segment, `**`
+// crosses them — kept local rather than reached through another boundary for
+// eighteen fixed patterns.
+const globCache = new Map<string, RegExp>()
+const compileGlob = (glob: string): RegExp => {
+  let pattern = "^"
+  let i = 0
+  while (i < glob.length) {
+    const char = glob[i]!
+    if (char !== "*") {
+      pattern += char.replace(/[.+^${}()|[\]\\?]/g, "\\$&")
+      i += 1
+    } else if (glob[i + 1] !== "*") {
+      pattern += "[^/]*"
+      i += 1
+    } else if (glob[i + 2] === "/") {
+      pattern += "(?:.*/)?"
+      i += 3
+    } else {
+      pattern += ".*"
+      i += 2
+    }
+  }
+  return new RegExp(`${pattern}$`)
+}
+const matchesGlob = (path: string, glob: string): boolean => {
+  let regex = globCache.get(glob)
+  if (regex === undefined) {
+    regex = compileGlob(glob)
+    globCache.set(glob, regex)
+  }
+  return regex.test(path)
+}
+
+const extensionOf = (path: string): string => {
+  const base = path.split("/").pop() ?? path
+  const dot = base.lastIndexOf(".")
+  return dot === -1 ? "" : base.slice(dot + 1).toLowerCase()
+}
+
+const isBinary = (change: Change): boolean =>
+  BINARY_EXTENSIONS.has(extensionOf(change.path)) ||
+  (change.before?.includes("\0") ?? false) ||
+  (change.after?.includes("\0") ?? false)
+
+const isExcluded = (change: Change): boolean =>
+  change.path === ".gtd" ||
+  change.path.startsWith(".gtd/") ||
+  LOCKFILES.has(change.path.split("/").pop() ?? change.path) ||
+  GENERATED_GLOBS.some((glob) => matchesGlob(change.path, glob)) ||
+  isBinary(change)
+
+/** `changes` with lockfiles, generated trees and binaries dropped. */
+export const filterChanges = (changes: readonly Change[]): readonly Change[] =>
+  changes.filter((change) => !isExcluded(change))
+
+// ── Line diff ────────────────────────────────────────────────────────────
+
+interface Op {
+  readonly type: "eq" | "add" | "del"
+  readonly line: string
+}
+
+const linesOf = (content: string | undefined): readonly string[] => {
+  if (content === undefined || content === "") return []
+  const lines = content.split("\n")
+  if (lines[lines.length - 1] === "") lines.pop()
+  return lines
+}
+
+/** `dp[i][j]` = the LCS length of `a[i:]` and `b[j:]`. */
+const lcsTable = (a: readonly string[], b: readonly string[]): number[][] => {
+  const n = a.length
+  const m = b.length
+  const dp: number[][] = Array.from({ length: n + 1 }, () =>
+    Array.from<number>({ length: m + 1 }).fill(0),
+  )
+  for (let i = n - 1; i >= 0; i--) {
+    for (let j = m - 1; j >= 0; j--) {
+      dp[i]![j] = a[i] === b[j] ? dp[i + 1]![j + 1]! + 1 : Math.max(dp[i + 1]![j]!, dp[i]![j + 1]!)
+    }
+  }
+  return dp
+}
+
+/** Walk an LCS table into an edit script, favoring a deletion on a tie. */
+const backtrack = (a: readonly string[], b: readonly string[], dp: number[][]): Op[] => {
+  const ops: Op[] = []
+  let i = 0
+  let j = 0
+  while (i < a.length && j < b.length) {
+    if (a[i] === b[j]) {
+      ops.push({ type: "eq", line: a[i]! })
+      i++
+      j++
+    } else if (dp[i + 1]![j]! >= dp[i]![j + 1]!) {
+      ops.push({ type: "del", line: a[i]! })
+      i++
+    } else {
+      ops.push({ type: "add", line: b[j]! })
+      j++
+    }
+  }
+  while (i < a.length) ops.push({ type: "del", line: a[i++]! })
+  while (j < b.length) ops.push({ type: "add", line: b[j++]! })
+  return ops
+}
+
+/** Longest-common-subsequence edit script between two (already trimmed) line arrays. */
+const lcsOps = (a: readonly string[], b: readonly string[]): Op[] => backtrack(a, b, lcsTable(a, b))
+
+const commonAffixes = (
+  before: readonly string[],
+  after: readonly string[],
+): { readonly prefix: number; readonly suffix: number } => {
+  const maxPrefix = Math.min(before.length, after.length)
+  let prefix = 0
+  while (prefix < maxPrefix && before[prefix] === after[prefix]) prefix++
+  const maxSuffix = maxPrefix - prefix
+  let suffix = 0
+  while (
+    suffix < maxSuffix &&
+    before[before.length - 1 - suffix] === after[after.length - 1 - suffix]
+  )
+    suffix++
+  return { prefix, suffix }
+}
+
+interface Hunk {
+  readonly beforeStart: number
+  readonly beforeCount: number
+  readonly afterStart: number
+  readonly afterCount: number
+  readonly lines: readonly string[]
+}
+
+const buildHunks = (ops: readonly Op[]): readonly Hunk[] => {
+  const beforeLineAt: number[] = []
+  const afterLineAt: number[] = []
+  let bl = 1
+  let al = 1
+  for (const op of ops) {
+    beforeLineAt.push(bl)
+    afterLineAt.push(al)
+    if (op.type !== "add") bl++
+    if (op.type !== "del") al++
+  }
+  const ranges: [number, number][] = []
+  ops.forEach((op, idx) => {
+    if (op.type === "eq") return
+    const start = Math.max(0, idx - CONTEXT)
+    const end = Math.min(ops.length - 1, idx + CONTEXT)
+    const last = ranges[ranges.length - 1]
+    if (last !== undefined && start <= last[1] + 1) {
+      last[1] = Math.max(last[1], end)
+    } else {
+      ranges.push([start, end])
+    }
+  })
+  return ranges.map(([start, end]) => {
+    const slice = ops.slice(start, end + 1)
+    return {
+      beforeStart: beforeLineAt[start]!,
+      beforeCount: slice.filter((op) => op.type !== "add").length,
+      afterStart: afterLineAt[start]!,
+      afterCount: slice.filter((op) => op.type !== "del").length,
+      lines: slice.map(
+        (op) => `${op.type === "add" ? "+" : op.type === "del" ? "-" : " "}${op.line}`,
+      ),
+    }
+  })
+}
+
+const renderHunk = (hunk: Hunk): readonly string[] => [
+  `@@ -${hunk.beforeStart},${hunk.beforeCount} +${hunk.afterStart},${hunk.afterCount} @@`,
+  ...hunk.lines,
+]
+
+/** One file's unified diff, or a summary line when its changed region is too large to inline. */
+const renderFileDiff = (change: Change): string => {
+  const before = linesOf(change.before)
+  const after = linesOf(change.after)
+  const { prefix, suffix } = commonAffixes(before, after)
+  const beforeMiddle = before.slice(prefix, before.length - suffix)
+  const afterMiddle = after.slice(prefix, after.length - suffix)
+  if (beforeMiddle.length > TOO_LARGE_LINES || afterMiddle.length > TOO_LARGE_LINES) {
+    return `${change.path}: +${afterMiddle.length}/-${beforeMiddle.length} lines, too large to inline`
+  }
+  const prefixOps: Op[] = before.slice(0, prefix).map((line) => ({ type: "eq", line }))
+  const suffixOps: Op[] = before.slice(before.length - suffix).map((line) => ({ type: "eq", line }))
+  const ops = [...prefixOps, ...lcsOps(beforeMiddle, afterMiddle), ...suffixOps]
+  const beforePath = change.status === "added" ? "/dev/null" : `a/${change.path}`
+  const afterPath = change.status === "deleted" ? "/dev/null" : `b/${change.path}`
+  return [`--- ${beforePath}`, `+++ ${afterPath}`, ...buildHunks(ops).flatMap(renderHunk)].join(
+    "\n",
+  )
+}
+
+const omissionTrailer = (paths: readonly string[]): string =>
+  `${paths.length} file(s) omitted for the judge's byte budget: ${paths.join(", ")}`
+
+interface RenderedFile {
+  readonly path: string
+  readonly text: string
+}
+
+/** The byte size of keeping `files`' first `keepCount` entries plus the trailer the rest would need — the trailer counts against the cap too, not just the kept text. */
+const sizeWithTrailer = (files: readonly RenderedFile[], keepCount: number): number => {
+  let used = 0
+  for (let i = 0; i < keepCount; i++) {
+    used += Buffer.byteLength(files[i]!.text, "utf8") + (i > 0 ? 1 : 0)
+  }
+  const droppedCount = files.length - keepCount
+  if (droppedCount === 0) return used
+  const trailer = omissionTrailer(files.slice(keepCount).map((f) => f.path))
+  return used + (keepCount > 0 ? 1 : 0) + Buffer.byteLength(trailer, "utf8")
+}
+
+/**
+ * The filtered `changes`, rendered as one unified diff (files in path order)
+ * and bounded to `capBytes`: over the cap, whole files are dropped from the
+ * end — never bytes off a hunk — and named in a trailer line, so the
+ * judge is told what it did not see rather than handed a silently short diff.
+ * The trailer itself is sized against the cap along with the files it keeps,
+ * so a package with many touched files can never push the total past it.
+ */
+export const packageDiff = (changes: readonly Change[], capBytes: number): string => {
+  const files = filterChanges(changes)
+    .slice()
+    .sort((a, b) => a.path.localeCompare(b.path))
+    .map((change) => ({ path: change.path, text: renderFileDiff(change) }))
+  let keepCount = files.length
+  while (keepCount > 0 && sizeWithTrailer(files, keepCount) > capBytes) keepCount--
+  const dropped = files.slice(keepCount).map((f) => f.path)
+  const kept = files.slice(0, keepCount).map((f) => f.text)
+  return [...kept, ...(dropped.length > 0 ? [omissionTrailer(dropped)] : [])].join("\n")
+}

package/src/workflows/packages.ts

@@ -1,7 +1,9 @@
 import {
   answered,
   changes,
+  changesSince,
   glob,
+  head,
   judge,
   numeric,
   read,
@@ -10,31 +12,34 @@ import {
   run,
   scope,
   sectionBodies,
-  start,
   vars,
   wrote,
   type JudgeQuestion,
 } from "../flows/index.js"
+import { packageDiff } from "./diff.js"
 import { healthy } from "./health.js"
 import { ARCHITECTURE, build, fixSpec, fixSuite, reviewPackage, SPEC_FEEDBACK } from "./steps.js"
 import * as t from "./text.js"
 
 const MAX_SECTIONS = 8
+const DIFF_KEY = "diff"
 
 const sectionQuestion = (id: string, title: string): JudgeQuestion => ({
   id,
   primitive: "noul",
-  instructions: `Is the requirement "${title}" already fully satisfied by the code on the range from ${start()} to the working tree?`,
+  instructions: `Is the requirement "${title}" — the "${id}" evidence — already fully satisfied by the code in the "${DIFF_KEY}" evidence?`,
   criteria:
-    "Judge from the package markdown plus that range, read yourself. Only answer yes at a probability clearing the threshold below if genuinely confident nothing in this section is missing.",
+    "Judge from the requirement text and the diff evidence alone. Only answer yes at a probability clearing the threshold below if genuinely confident nothing in this section is missing.",
 })
 
 /**
  * Review one freshly built package against its spec: a pre-judge per
  * section, then an agent review of the sections it did not confidently
- * clear. Resolves `true` when approved.
+ * clear. `since` is the commit the package's own build started from — the
+ * pre-judge's evidence is a diff over exactly that range, never an earlier
+ * package's commits. Resolves `true` when approved.
  */
-export const specReview = async (pkg: string): Promise<boolean> => {
+export const specReview = async (pkg: string, since: string): Promise<boolean> => {
   const found = sectionBodies(read(pkg) ?? "")
   const titles = found.map((section) => section.title)
   const judged = titles.length > 0 && titles.length <= MAX_SECTIONS
@@ -45,6 +50,10 @@ export const specReview = async (pkg: string): Promise<boolean> => {
       evidence[`section-${i + 1}`] = body
       questions.push(sectionQuestion(`section-${i + 1}`, title))
     })
+    // The diff's own even share of the budget: one key per section plus
+    // `diff` itself, so this cap equals what `budgeted` gives it below.
+    const capBytes = Math.floor(numeric(vars.judgeBudgetBytes, 32768) / (found.length + 1))
+    evidence[DIFF_KEY] = packageDiff(changesSince(since), capBytes)
   }
   const { answers, truncated } = await judge("spec.pre", {
     questions,
@@ -52,11 +61,17 @@ export const specReview = async (pkg: string): Promise<boolean> => {
     message: t.packagesItemSpecPreMessage(),
     label: "Judging spec coverage",
   })
-  // A section is cleared only by a confident yes on evidence that was not cut.
+  // A section is cleared only by a confident yes on evidence that was not
+  // cut — its own body, or the diff every question is judged against.
   const clearMinP = numeric(vars.specPreJudge, Infinity)
   const failing = titles.filter((_, i) => {
     const id = `section-${i + 1}`
-    return !judged || truncated.includes(id) || !answered(answers[id], "yes", clearMinP)
+    return (
+      !judged ||
+      truncated.includes(id) ||
+      truncated.includes(DIFF_KEY) ||
+      !answered(answers[id], "yes", clearMinP)
+    )
   })
   if (titles.length > 0 && failing.length === 0) return true
   await reviewPackage(pkg, failing)
@@ -69,10 +84,11 @@ export const specReview = async (pkg: string): Promise<boolean> => {
 
 /** Build `pkg`, keep the suite green, review it against its spec, and close it out, which removes it. */
 export const packageItem = async (pkg: string): Promise<void> => {
+  const since = head()
   await build(pkg)
   for (;;) {
     await healthy(fixSuite)
-    if (await specReview(pkg)) break
+    if (await specReview(pkg, since)) break
     await fixSpec(pkg)
   }
   // The spent technical plan goes with the first package built from it.

package/src/workflows/text.fixture.ts

@@ -22,6 +22,7 @@ export const renderText = <T>(text: () => T, context: TextContext = {}): T => {
     read: context.read ?? (() => undefined),
     glob: () => [],
     changes: () => [],
+    changesSince: unavailable,
     matches: () => false,
     sections: () => [],
     sectionBodies: () => [],

package/src/workflows/text.ts

@@ -621,17 +621,19 @@ review the changes:
 - At least one \`## <Chunk Title>\` heading grouping hunks
   semantically (same feature/refactor/fix, across files), each
   with a short explanation of what changed and why, then one
-  pointer per hunk (\`./\`-relative path, optional \`#line\`;
-  checkboxes are for the human, not you). Put the note's
-  opening line right on the pointer's line:
+  pointer per hunk (\`./\`-relative path, mandatory \`#start-end\`;
+  checkboxes are for the human, not you). A pointer into a NEW file
+  gets a range covering only the region the note is about — never
+  the whole file. Put the note's opening line right on the
+  pointer's line:
 
-      - [ ] ./path/to/file.ts#42 — what this hunk does
+      - [ ] ./path/to/file.ts#42-70 — what this hunk does
 
   Continue a longer note below the pointer, indented exactly two spaces
   — never four or more, which reads as a code block and never
   reflows:
 
-      - [ ] ./path/to/file.ts#42 — what this hunk does
+      - [ ] ./path/to/file.ts#42-70 — what this hunk does
         and here is more detail, continued below it
 
   A note sitting entirely on the line(s) beneath the pointer is