kennel 0.2.0 → 0.2.2

package/kernel/packages/notes/src/manifest.ts

@@ -0,0 +1,6 @@
+import type { FolderPluginManifest } from "@raggle-ai/folder-plugin"
+
+export const notesManifest = {
+  id: "notes",
+  label: "Notes",
+} satisfies FolderPluginManifest

package/kernel/packages/notes/src/pages/notes-page.tsx

@@ -0,0 +1,79 @@
+import type { ReactElement } from "react"
+import { useState } from "react"
+
+import { useAiInput } from "../data/ai-input.ts"
+import {
+  folderDocumentHref,
+  folderPathId,
+  folderSectionHref,
+  parseViewerRoute,
+} from "../data/routing.ts"
+import { useFolderNotes } from "../data/use-folder-notes.ts"
+import {
+  AiComposerAction,
+  AiComposerControls,
+} from "../ui/ai-composer-controls.tsx"
+import { FolderNotesList } from "../ui/folder-notes-list.tsx"
+
+/** Folder Notes page: local and linked Markdown notes plus the AI composer. */
+export function NotesPage(): ReactElement {
+  const [composerOpen, setComposerOpen] = useState(false)
+  const href = window.location.href
+  const folder = parseViewerRoute(href).folder
+  const aiInput = useAiInput(folder)
+  const folderId = folder ? folderPathId(folder) : "none"
+  // Metadata events are handled once by the shared shell.
+  const { local: query, linked, files, retryLinked } = useFolderNotes(href)
+
+  return (
+    <>
+      <FolderNotesList
+        key={folderId}
+        action={
+          aiInput ? (
+            <AiComposerAction
+              onOpenChange={setComposerOpen}
+              open={composerOpen}
+            />
+          ) : undefined
+        }
+        documentHref={(file) => {
+          const target = file.folder ?? folder
+          return target
+            ? folderDocumentHref(target, file.relativePath)
+            : file.relativePath
+        }}
+        error={query.error ? String(query.error) : ""}
+        files={files}
+        folder={folder}
+        folderHref={(source) => folderSectionHref(source, "notes")}
+        loading={query.isLoading}
+      />
+      {query.error ? (
+        <button className="px-4" onClick={() => void query.refetch()}>
+          Retry local notes
+        </button>
+      ) : null}
+      {linked.isLoading ? (
+        <p role="status" className="text-muted-foreground px-4 text-sm">
+          Loading linked notes…
+        </p>
+      ) : null}
+      {linked.error ? (
+        <p role="alert" className="px-4 text-sm">
+          Linked notes could not load.{" "}
+          <button type="button" onClick={retryLinked}>
+            Retry
+          </button>
+        </p>
+      ) : null}
+      {aiInput ? (
+        <AiComposerControls
+          adapter={aiInput}
+          onOpenChange={setComposerOpen}
+          open={composerOpen}
+        />
+      ) : null}
+    </>
+  )
+}

package/kernel/packages/notes/src/pages/single-note-page.tsx

@@ -0,0 +1,57 @@
+import type { ComponentProps, ReactNode } from "react"
+
+import { FileRenderer } from "@raggle-ai/ui/components/file-renderer"
+
+/**
+ * Shared page shell for an individual note. The host supplies document loading,
+ * actions, and integrations; Notes composes the shared renderer and page states.
+ */
+export function SingleNotePage({
+  renderer,
+  embedded = false,
+  error,
+  header,
+  live = false,
+  loading = false,
+  panel = false,
+  sessionHeader,
+  tray,
+}: {
+  renderer?: ComponentProps<typeof FileRenderer>
+  embedded?: boolean
+  error?: string
+  header: ReactNode
+  live?: boolean
+  loading?: boolean
+  panel?: boolean
+  sessionHeader?: ReactNode
+  tray?: ReactNode
+}) {
+  return (
+    <section
+      className="markdown-page"
+      data-embedded={embedded || panel ? "true" : undefined}
+      data-panel={panel ? "true" : undefined}
+    >
+      {header}
+      {sessionHeader}
+      {live ? (
+        <div className="pop-live" role="status">
+          <span aria-hidden="true">●</span> Live — refreshing on save
+        </div>
+      ) : null}
+      {error ? (
+        <p role="alert" className="p-6">
+          {error}
+        </p>
+      ) : renderer ? (
+        <FileRenderer {...renderer} />
+      ) : loading ? (
+        <p role="status" className="p-6">
+          Loading file…
+        </p>
+      ) : null}
+      {tray}
+    </section>
+  )
+}

package/kernel/packages/notes/src/server.ts

@@ -0,0 +1,88 @@
+import { readdir, stat } from "node:fs/promises"
+import { basename, extname, relative, resolve, sep } from "node:path"
+
+import type {
+  FolderPluginContext,
+  FolderPluginData,
+  FolderPluginDetection,
+  FolderPluginServer,
+} from "@raggle-ai/folder-plugin/server"
+
+import { notesManifest } from "./manifest.ts"
+
+const markdownExtensions = new Set([".md", ".markdown"])
+
+async function listMarkdownFiles(folder: string) {
+  const files: Array<{
+    activityAt: number
+    folder?: string
+    name: string
+    relativePath: string
+  }> = []
+  const visit = async (current: string) => {
+    const entries = await readdir(current, { withFileTypes: true }).catch(
+      () => [],
+    )
+    for (const entry of entries) {
+      if (entry.name === "node_modules" || entry.name.startsWith(".")) continue
+      const path = resolve(current, entry.name)
+      if (entry.isDirectory()) {
+        await visit(path)
+        continue
+      }
+      if (!entry.isFile() || !markdownExtensions.has(extname(entry.name))) {
+        continue
+      }
+      const details = await stat(path).catch(() => undefined)
+      files.push({
+        activityAt: details?.mtimeMs ?? 0,
+        name: basename(entry.name, extname(entry.name)),
+        relativePath: relative(folder, path).split(sep).join("/"),
+      })
+    }
+  }
+  await visit(folder)
+  return files.sort((left, right) => right.activityAt - left.activityAt)
+}
+
+async function loadNotes(folder: string, linkedFolders: string[] = []) {
+  const localFiles = await listMarkdownFiles(folder)
+  const linked = await Promise.all(
+    linkedFolders.map(async (linkedFolder) => ({
+      files: await listMarkdownFiles(linkedFolder),
+      folder: linkedFolder,
+    })),
+  )
+  return {
+    files: {
+      items: [
+        ...localFiles,
+        ...linked.flatMap((group) =>
+          group.files.map((file) => ({ ...file, folder: group.folder })),
+        ),
+      ],
+    },
+    folder,
+    status: "available",
+  }
+}
+
+export function createNotesPlugin(): FolderPluginServer {
+  return {
+    ...notesManifest,
+    async detect({
+      folder,
+    }: FolderPluginContext): Promise<FolderPluginDetection> {
+      const files = await listMarkdownFiles(folder)
+      return files.length > 0
+        ? { count: files.length, status: "available" }
+        : { status: "available" }
+    },
+    async handle({
+      folder,
+      linkedFolders,
+    }: FolderPluginContext): Promise<FolderPluginData> {
+      return { data: await loadNotes(folder, linkedFolders), kind: "available" }
+    },
+  }
+}

package/kernel/packages/notes/src/ui/ai-composer-controls.tsx

@@ -0,0 +1,70 @@
+import { Plus } from "lucide-react"
+
+import { Button } from "@raggle-ai/ui/components/button"
+
+import type { AiInputAdapter } from "../data/ai-input.ts"
+
+type AiComposerControlsProps = {
+  adapter: AiInputAdapter
+  open: boolean
+  onOpenChange: (open: boolean) => void
+}
+
+function toggleComposer(open: boolean, onOpenChange: (open: boolean) => void) {
+  return () => onOpenChange(!open)
+}
+
+/** Desktop action supplied to the shared folder notes list. */
+export function AiComposerAction({
+  open,
+  onOpenChange,
+}: Omit<AiComposerControlsProps, "adapter">) {
+  const label = open ? "Hide bark input" : "Open bark input"
+  return (
+    <Button
+      aria-controls="bark-composer"
+      aria-expanded={open}
+      aria-label={label}
+      onClick={toggleComposer(open, onOpenChange)}
+      title={label}
+      type="button"
+      variant="outline"
+    >
+      <Plus aria-hidden="true" className="size-4" />
+    </Button>
+  )
+}
+
+/** Mobile toggle and host for the configured folder AI composer. */
+export function AiComposerControls({
+  adapter,
+  open,
+  onOpenChange,
+}: AiComposerControlsProps) {
+  const label = open ? "Hide bark input" : "Open bark input"
+  return (
+    <>
+      <Button
+        aria-controls="bark-composer"
+        aria-expanded={open}
+        aria-label={label}
+        className="mobile-bark-toggle"
+        onClick={toggleComposer(open, onOpenChange)}
+        title={label}
+        type="button"
+        variant="outline"
+      >
+        <Plus aria-hidden="true" />
+      </Button>
+      {open ? (
+        <section
+          aria-label="AI composer"
+          className="ai-input-host"
+          id="bark-composer"
+        >
+          <adapter.Composer />
+        </section>
+      ) : null}
+    </>
+  )
+}

package/kernel/packages/notes/src/ui/folder-notes-list.tsx

@@ -0,0 +1,140 @@
+import type { ReactNode } from "react"
+import { useState } from "react"
+import { Link2 } from "lucide-react"
+
+import type { FolderFile } from "@raggle-ai/ui/lib/folder-activity"
+import { Button } from "@raggle-ai/ui/components/button"
+import { NoteCard } from "@raggle-ai/ui/components/note-card"
+
+function folderName(folder: string) {
+  return (
+    folder
+      .replace(/[\\/]+$/, "")
+      .split(/[\\/]/)
+      .at(-1) ?? folder
+  )
+}
+
+/**
+ * Note rows for the main Notes tab, backed by the shared NoteCard so linked
+ * notes render the same way everywhere.
+ */
+export function FolderNotesList({
+  action,
+  documentHref,
+  error,
+  files = [],
+  folder,
+  folderHref,
+  loading,
+}: {
+  action?: ReactNode
+  documentHref: (file: FolderFile) => string
+  error: string
+  files?: FolderFile[]
+  folder?: string
+  folderHref: (folder: string) => string
+  loading: boolean
+}) {
+  const [filter, setFilter] = useState("all")
+  const sources = [
+    ...new Set(files.flatMap((file) => (file.folder ? [file.folder] : []))),
+  ]
+  const filters = [
+    { id: "all", label: "All", count: files.length },
+    {
+      id: "local",
+      label: "This folder",
+      count: files.filter((file) => !file.folder).length,
+    },
+    ...sources.map((source) => ({
+      id: source,
+      label: folderName(source),
+      count: files.filter((file) => file.folder === source).length,
+    })),
+  ]
+  const selected = filters.some((item) => item.id === filter) ? filter : "all"
+  const visible = files
+    .filter(
+      (file) =>
+        selected === "all" ||
+        (selected === "local" ? !file.folder : file.folder === selected),
+    )
+    .sort(
+      (left, right) =>
+        right.activityAt - left.activityAt ||
+        `${left.folder ?? ""}/${left.relativePath}`.localeCompare(
+          `${right.folder ?? ""}/${right.relativePath}`,
+        ),
+    )
+
+  return (
+    <div className="mx-auto grid w-full max-w-3xl gap-4 px-4 py-5">
+      <div className="flex flex-wrap items-center justify-between gap-3">
+        <h1 className="m-0 text-2xl font-semibold text-[#233025]">Notes</h1>
+        {action}
+      </div>
+      {sources.length ? (
+        <div
+          role="group"
+          aria-label="Filter notes by source"
+          className="flex flex-wrap gap-2"
+        >
+          {filters.map((item) => (
+            <Button
+              key={item.id}
+              type="button"
+              size="sm"
+              variant={selected === item.id ? "secondary" : "outline"}
+              className="h-auto min-h-8 max-w-full rounded-full
+                whitespace-normal"
+              aria-pressed={selected === item.id}
+              onClick={() => setFilter(item.id)}
+              title={
+                item.id === "local"
+                  ? folder
+                  : sources.includes(item.id)
+                    ? item.id
+                    : undefined
+              }
+            >
+              {sources.includes(item.id) ? <Link2 aria-hidden="true" /> : null}
+              <span className="break-all">{item.label}</span>
+              <span className="text-muted-foreground">{item.count}</span>
+            </Button>
+          ))}
+        </div>
+      ) : null}
+      {loading ? <p className="m-0 text-sm text-[#6c7a6d]">Loading…</p> : null}
+      {error ? <p className="m-0 text-sm text-[#9c3a3a]">{error}</p> : null}
+      {!loading && !error && !visible.length ? (
+        <p className="m-0 text-sm text-[#6c7a6d]">
+          {files.length ? "No notes match this filter." : "No notes found."}
+        </p>
+      ) : null}
+      {visible.length ? (
+        <ol className="m-0 grid list-none gap-2 p-0">
+          {visible.map((file) => (
+            <li key={`${file.folder ?? ""}:${file.relativePath}`}>
+              <NoteCard
+                activityAt={file.activityAt}
+                context={
+                  file.folder
+                    ? `${file.folder.replace(/[\\/]+$/, "")}/${file.relativePath}`
+                    : folder
+                      ? `${folder.replace(/[\\/]+$/, "")}/${file.relativePath}`
+                      : file.relativePath
+                }
+                folderHref={file.folder ? folderHref(file.folder) : undefined}
+                href={documentHref(file)}
+                linkedFolder={file.folder}
+                path={file.relativePath}
+                title={file.name}
+              />
+            </li>
+          ))}
+        </ol>
+      ) : null}
+    </div>
+  )
+}

package/kernel/packages/notes/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "@raggle-ai/tsconfig/base.json",
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "jsx": "preserve",
+    "baseUrl": ".",
+    "allowImportingTsExtensions": true,
+    "paths": {
+      "~/*": ["${configDir}/../../packages/*/src"]
+    }
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist", "eslint.config.mjs"]
+}

package/kernel/packages/schemas/ICON-POLICY.md

@@ -0,0 +1,43 @@
+# Record icon safety
+
+## Sources
+
+Schema records use a local PNG/JPEG from an explicit `icon` field first.
+Otherwise, they use an explicit `website` field or a labelled `Website:` line
+in the Markdown body. Evidence URLs and remote `icon` URLs are not used.
+
+A local image must resolve inside the record's own directory and the collection
+root. The server checks this again when it reads the image. Input is limited to
+512 KiB and one megapixel. PNG/JPEG files are decoded with Sharp and converted
+to small PNG images without source metadata. Invalid images are not displayed.
+
+## Network approval
+
+Cached icons remain available when network access is disabled. New downloads
+are disabled by default. To approve downloads, set both variables on the viewer:
+
+```sh
+KENNEL_EXTERNAL_ICONS=1
+KENNEL_FAVICON_ALLOWED_HOSTS=www.networkrail.co.uk,www.tpximpact.com
+```
+
+The list uses exact host names, separated by commas. It does not accept wildcards.
+Approving `example.org` does not approve `www.example.org` or other subdomains.
+Only approve public domains whose disclosure to Google's favicon service is
+acceptable. DNS and external requests are not made for unapproved cache misses.
+
+Set `KENNEL_EXTERNAL_ICONS=0`, or remove the approval list, to stop new downloads.
+This does not remove cached icons.
+
+## Disk cache
+
+Default location: `~/.cache/kennel/favicons`, or
+`$XDG_CACHE_HOME/kennel/favicons`. `KENNEL_FAVICON_CACHE_DIR` overrides it.
+
+Files use `sha256(host).png` names. Cache reads are size-limited and images are
+validated again. Valid images remain available without a network refresh.
+To replace an old icon, remove its cache file and approve its host before the
+next request. Failed approved downloads have a five-minute negative cache.
+
+Writes use a temporary file in the same directory, then an atomic rename.
+New directories have mode `0700`; new cache files have mode `0600`.

package/kernel/packages/schemas/SKILL.md

@@ -0,0 +1,185 @@
+---
+name: kennel-schemas
+description: View, create, and update Kennel schema-backed collections (folder `schema.json` or `_schema.json` files with `x-kennel` hints) and their records — meetings, people, clients, projects, prospects, partners, research, or tasks. Use when the user asks to view, list, read, summarize, open, or link the custom items of a schema folder; or to give a folder a typed schema, frontmatter/YAML fields, icon and UI hints, filters, list or tab views, schema-backed Markdown records, or a reusable content pattern. Complements the kennel-cli skill (validation) and the raggle-schema-manager skill (raggle.json wiring).
+---
+
+# Kennel Schemas
+
+This package (`@raggle-ai/schemas`) owns everything a custom schema promises:
+the `x-kennel` contract, schema loading, the record indexer, the server seam,
+and the viewer UI. This skill is the agent-facing guidance: how to view a
+collection's records and how to create or update the schema that defines them.
+
+The schema is the contract; records must follow it. The schema also becomes
+Raggle's display contract — as part of the same change, wire it into the
+relative `raggle.json` (see the raggle-schema-manager skill) or the collection
+stays invisible to search and views. For the collection/index behavior and
+`x-kennel` fields, see `docs/core-folders.md` in the Kennel repo.
+
+## Viewing a collection
+
+1. **Identify the collection folder.** Use the folder the user names, or the
+   folder containing the item they point at.
+2. **Find the owning schema.** Walk up from the folder for `schema.json`
+   (`_schema.json` when the folder already uses that convention;
+   `schema.json` wins when both exist) and search downward with
+   `find <folder> \( -name "schema.json" -o -name "_schema.json" \)`
+   (skip `node_modules`). Stop descending at nested schema folders — they own
+   their own items. A schema that is only a `$ref` points at a published
+   HTTPS schema; read the fetched target, and if the view later fails to
+   load, check that `$ref` first.
+3. **Read the schema for item anatomy.** Pull out `x-kennel.documents`
+   (which files are records and their parser), `title`, `properties`, and the
+   `x-kennel.ui` hints (`primaryField`, `secondaryField`, `filters`,
+   `numericFilters`, `sort`)
+   plus `x-kennel.icon`. State what one record is, how it is stored, and
+   which fields the viewer shows.
+4. **Enumerate the records.** For
+   `{ "glob": "*.md", "parser": "markdown-frontmatter" }` every Markdown file
+   with frontmatter is a record; for YAML globs every matching `.yml` file is
+   a record. Setup files (`AGENTS.md`, `README.md`, `SKILL.md`) are records
+   only when a pattern names them explicitly (folder records whose
+   frontmatter lives inside the file). Skip hidden folders and
+   `node_modules`.
+5. **Read each record's fields.** Parse frontmatter (Markdown) or the
+   YAML/JSON body. Title precedence: `title` field → first `# heading` →
+   filename. Badge candidates: `status`, `kind`, `type`, `relationship`,
+   then `date`, `updated`, `lastContact`. Detail candidates: `summary`,
+   `people`, `owner`, `nextAction`, `role`, `organisation`, `source`.
+6. **Present or open the records.** Render a list (title + badge + one-line
+   detail, grouped by folder when records span subfolders), and/or open the
+   collection in the viewer and return the link. Do not invent values;
+   unknown fields are "Not recorded".
+7. **Verify before reporting.** Run `kennel schema <folder>`,
+   `kennel doctor <folder>`, and `kennel validate <folder>` (the kennel-cli
+   skill; a separate compact-validator bundle). Report real discrepancies —
+   records missing declared fields, dangling file references — alongside the
+   view. When viewing through the viewer, confirm the collection page loads.
+
+## Viewing in the Kennel viewer
+
+| Target                                   | Command                                                        | What the user sees                              |
+| ---------------------------------------- | -------------------------------------------------------------- | ----------------------------------------------- |
+| Whole collection (folder)                | `knl view <folder>` (reuses 127.0.0.1:5180)                    | Folder viewer; the schema tab lists the records |
+| Single record file                       | `knl pop <record>.md` (reuses 127.0.0.1:5180)                  | One document pop-up                             |
+| Phone-accessible link (explicit request) | `kennel serve <folder> --lan` / `kennel pop <record>.md --lan` | Private LAN link (same network required)        |
+
+`kennel`, `kennel pop`, `kennel view`, and `kennel serve` above are the
+platform viewer CLI. The validation commands — `kennel schema`,
+`kennel doctor`, `kennel validate` — share the `kennel` name but come from
+the separate `kennel-cli` bundle; do not read one's output with the other's
+expectations. Localhost previews always reuse the single always-running hot
+viewer on `http://127.0.0.1:5180` — never add `--port` for localhost; for
+launch mechanics follow the kennel-preview skill.
+
+## Creating or updating a schema
+
+Workflow:
+
+1. Identify the exact folder that owns the collection.
+2. Read existing `schema.json`, `_schema.json`, `kennel.json`, `raggle.json`,
+   and nearby records before editing.
+3. Ask for missing product intent only when it cannot be inferred:
+   collection purpose, required record fields, icon or visual identity,
+   filters/groups/tabs and numeric ranges the UI must support, and the record
+   format (Markdown frontmatter, YAML, or JSON).
+4. For normal collections, ask whether to start from a published Raggle
+   schema. If the user gives a URL, fetch it and use it as the starting
+   point; otherwise use published schemas only as examples.
+5. Create or update the nearest `schema.json`. Use `_schema.json` only when
+   the folder already uses that convention.
+6. Update existing records, or create the smallest sample record, so the
+   folder validates against the schema.
+7. Run Kennel validation when available.
+8. **Wire it into the relative `raggle.json`** — the nearest one, walking up
+   from the collection folder. Add one `schemas` entry
+   `{ "path": "<collection folder>", "schema": "<schema file>" }`, both paths
+   relative to that `raggle.json`. Do not duplicate the entry in both the
+   repo root and a nested config. Without this entry the schema is dead
+   weight.
+
+Schema shape — JSON Schema draft 2020-12:
+
+```json
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "meetings/schema.json",
+  "title": "Meetings",
+  "type": "object",
+  "x-kennel": {
+    "documents": [{ "glob": "*.md", "parser": "markdown-frontmatter" }],
+    "icon": "calendar-days",
+    "ui": {
+      "primaryField": "title",
+      "secondaryField": "date",
+      "filters": ["status", "type"],
+      "sort": [{ "field": "date", "direction": "desc" }]
+    }
+  },
+  "required": ["title", "slug", "status"],
+  "properties": {
+    "title": { "type": "string", "minLength": 1 },
+    "slug": { "$ref": "#/$defs/slug" },
+    "status": { "type": "string" }
+  },
+  "additionalProperties": true,
+  "$defs": {
+    "slug": {
+      "type": "string",
+      "pattern": "^[a-z0-9]+(?:-[a-z0-9]+)*$"
+    }
+  }
+}
+```
+
+Treat `x-kennel.documents` as required for content discovery; `x-kennel.icon`
+and `x-kennel.ui` are optional hints. Icon names use Lucide kebab case
+(matching the UI icon set). Standard setup files (`AGENTS.md`, `README.md`,
+`SKILL.md`) are ignored unless a document pattern names them, so a
+folder-record collection like `*/AGENTS.md` keeps its records.
+
+Field design:
+
+- Put fields used for filters, tabs, sorting, badges, and search in
+  frontmatter or YAML.
+- Use enums for stable statuses, types, and stages; arrays for tags,
+  participants, evidence, next actions.
+- Use file-reference fields when the record points at other records
+  (`people/*.md`, `meetings/*.md`).
+- Use `format: "date"`, `format: "date-time"`, `format: "uri"`, and
+  `format: "email"` where useful.
+- Keep `additionalProperties: true` when existing records carry flexible
+  metadata.
+- Do not make a field required unless records can be filled consistently.
+
+Record setup — for Markdown records keep schema data in YAML frontmatter and
+prose in the body:
+
+```markdown
+---
+title: Example Meeting
+slug: example-meeting
+status: planned
+date: 2026-08-10
+participants: []
+---
+
+# Example Meeting
+```
+
+When creating examples, use known facts only: `null`, empty arrays, or clear
+placeholders where the schema allows them. Note the null caveat: a property
+typed `"number"` alone rejects an explicit `null`; pair `"type":
+["number", "null"]` on optional numeric fields.
+
+## Boundaries
+
+- Schema edits belong to this skill; record edits follow the repo's normal
+  content conventions. Re-view after either.
+- After importing or copying a published schema: adjust fields to the folder
+  purpose, keep required fields realistic, align icons and UI hints, remove
+  fields nobody will maintain, and validate current records against the
+  result.
+- If `kennel` is not available, verify the JSON parses and that required
+  fields match at least one record, and state that full validation did not
+  run.