@hassangameryt/freeflow 0.7.3 → 0.9.0

package/skills/track-work/scripts/lib/document.mjs

@@ -1,6 +1,7 @@
 import {
   ACTIVE_SLICE_FIELDS,
   CHECKPOINT_TYPES,
+  CONTEXT_HEADINGS,
   CURRENT_SLICE_STATES,
   DECISION_FIELDS,
   DECISION_STATES,
@@ -11,11 +12,16 @@ import {
   HISTORICAL_SLICE_FIELDS,
   HISTORICAL_SLICE_STATES,
   HISTORY_HEADINGS,
+  LEGACY_CHECKPOINT_TYPES,
+  OCCURRED_PATTERN,
   PROPOSED_SLICE_FIELDS,
+  RECORDED_PATTERN,
   SCHEMA_VERSION,
   SLICE_TYPES,
   TASK_STATES,
   TOP_LEVEL_SECTIONS,
+  WORK_AGREEMENT_HEADING,
+  isCalendarDate,
   joinLines,
   nextId,
   parseId,
@@ -251,34 +257,53 @@ function parseTopLevelSections(lines) {
   );
 }
 
+const CONTEXT_LAYOUTS = [CONTEXT_HEADINGS, [CONTEXT_HEADINGS[0], WORK_AGREEMENT_HEADING, ...CONTEXT_HEADINGS.slice(1)]];
+
 function parseContext(lines, section) {
   const headings = findHeadings(lines, section.start, section.end, 3);
-  if (headings.length !== 7)
-    fail("invalid-context", "Current Context must contain exactly the seven canonical headings");
+  const titles = headings.map((heading) => heading.title);
+  if (!CONTEXT_LAYOUTS.some((layout) => layout.join("\n") === titles.join("\n")))
+    fail(
+      "invalid-context",
+      `Current Context must contain the seven canonical headings, with an optional ${WORK_AGREEMENT_HEADING} directly after Goal`,
+    );
   const statements = new Map();
   for (let index = 0; index < headings.length; index += 1) {
-    const expected = [
-      "Goal",
-      "What defines this task",
-      "Settled",
-      "Tentative",
-      "Open",
-      "Current direction",
-      "Boundaries",
-    ][index];
-    if (headings[index].title !== expected) fail("invalid-context", `Expected Current Context heading ${expected}`);
     const end = headings[index + 1]?.index ?? section.end;
-    statements.set(expected, { headingIndex: headings[index].index, start: headings[index].index + 1, end });
+    statements.set(titles[index], { headingIndex: headings[index].index, start: headings[index].index + 1, end });
   }
   return { ...section, headings: statements };
 }
 
+const CURRENT_WORK_LAYOUTS = [
+  ["Current Slice", "Next useful action"],
+  ["Current Slice", "Recovery sources", "Next useful action"],
+];
+
 function parseCurrentWork(lines, section) {
   const headings = findHeadings(lines, section.start, section.end, 3);
-  if (headings.length !== 2 || headings[0].title !== "Current Slice" || headings[1].title !== "Next useful action")
-    fail("invalid-current-work", "Current Work must contain Current Slice followed by Next useful action");
+  const titles = headings.map((heading) => heading.title);
+  if (!CURRENT_WORK_LAYOUTS.some((layout) => layout.join("\n") === titles.join("\n")))
+    fail(
+      "invalid-current-work",
+      "Current Work must contain Current Slice, optional Recovery sources, then Next useful action",
+    );
+  const nextActionHeading = headings[headings.length - 1];
+  const recoveryHeading = headings.length === 3 ? headings[1] : null;
   const sliceContentStart = headings[0].index + 1;
   const sliceContentEnd = headings[1].index;
+  let recoverySources = null;
+  if (recoveryHeading) {
+    recoverySources = {
+      headingIndex: recoveryHeading.index,
+      start: recoveryHeading.index + 1,
+      end: nextActionHeading.index,
+    };
+    for (let index = recoverySources.start; index < recoverySources.end; index += 1) {
+      if (lineHeading(lines[index]))
+        fail("invalid-recovery-sources", `Recovery sources cannot contain headings: ${lines[index]}`);
+    }
+  }
   const content = nonBlankLines(lines.slice(sliceContentStart, sliceContentEnd));
   let currentSlice = null;
   if (content.length === 1 && content[0] === "None") {
@@ -304,9 +329,11 @@ function parseCurrentWork(lines, section) {
   return {
     ...section,
     sliceHeadingIndex: headings[0].index,
-    nextActionHeadingIndex: headings[1].index,
+    sliceEnd: sliceContentEnd,
+    nextActionHeadingIndex: nextActionHeading.index,
     currentSlice,
-    nextAction: { start: headings[1].index + 1, end: section.end },
+    recoverySources,
+    nextAction: { start: nextActionHeading.index + 1, end: section.end },
   };
 }
 
@@ -385,6 +412,8 @@ function parseHistory(lines, section) {
   };
 }
 
+const READABLE_CHECKPOINT_TYPES = new Set([...CHECKPOINT_TYPES, ...LEGACY_CHECKPOINT_TYPES]);
+
 function validateChoice(block, field, choices, required = true) {
   const value = scalarValue(block, field);
   if (!value && !required) return "";
@@ -459,16 +488,46 @@ function validateReferences(document) {
   }
 }
 
+export function validateOccurred(value, path) {
+  const match = OCCURRED_PATTERN.exec(value ?? "");
+  if (!match || !isCalendarDate(match[1]) || (match[2] && !isCalendarDate(match[2])))
+    fail("invalid-occurred", `Occurred in ${path} must be YYYY-MM-DD or YYYY-MM-DD to YYYY-MM-DD: ${value}`);
+  if (match[2] && match[2] < match[1]) fail("invalid-occurred", `Occurred in ${path} ends before it starts: ${value}`);
+  return match[2] ?? match[1];
+}
+
+function validateRecordedTime(slice) {
+  const occurred = scalarValue(slice, "Occurred");
+  const recorded = scalarValue(slice, "Recorded");
+  if (!occurred && !recorded) return;
+  if (!occurred || !recorded)
+    fail("missing-field", `Occurred and Recorded appear together in ${slice.path}; only slice record writes them`);
+  const end = validateOccurred(occurred, slice.path);
+  const match = RECORDED_PATTERN.exec(recorded);
+  if (!match || !isCalendarDate(match[1]))
+    fail("invalid-recorded", `Recorded in ${slice.path} must be "retroactively on YYYY-MM-DD": ${recorded}`);
+  if (end > match[1]) fail("invalid-occurred", `Occurred in ${slice.path} ends after it was recorded: ${occurred}`);
+}
+
 export function validateDocument(document) {
   const { header, context, current, future, history } = document;
   if (!header.name) fail("malformed-header", "Task name cannot be empty");
   const goal = context.headings.get("Goal");
   if (!hasMeaningfulContent(document.lines, goal.start, goal.end))
     fail("missing-field", "Current Context Goal must contain meaningful content");
+  const agreement = context.headings.get(WORK_AGREEMENT_HEADING);
+  if (agreement && !hasMeaningfulContent(document.lines, agreement.start, agreement.end))
+    fail(
+      "missing-field",
+      `Current Context ${WORK_AGREEMENT_HEADING} must contain meaningful content; omit the heading until something is agreed`,
+    );
   if (!hasMeaningfulContent(document.lines, current.nextAction.start, current.nextAction.end))
     fail("missing-field", "Next useful action must contain meaningful content");
   for (const block of allBlocks(document)) {
     if (block.id && !parseId(block.id, block.kind)) fail("invalid-id", `Invalid ${block.kind} ID ${block.id}`);
+    for (const [name, field] of block.fields) {
+      if (!valueText(field)) fail("empty-field", `Empty field ${name} in ${block.path}; omit fields without a value`);
+    }
   }
 
   const ids = new Set();
@@ -489,7 +548,7 @@ export function validateDocument(document) {
     } else {
       validateFields(item, ["State"], {});
       validateChoice(item, "State", FUTURE_CHECKPOINT_STATES);
-      validateChoice(item, "Type", CHECKPOINT_TYPES);
+      validateChoice(item, "Type", READABLE_CHECKPOINT_TYPES);
       validateFields(item, ["Condition", "Applies to"]);
       if (item.id && !parseId(item.id, "checkpoint")) fail("invalid-id", `Invalid Checkpoint ID ${item.id}`);
       const checkpointState = scalarValue(item, "State");
@@ -530,7 +589,7 @@ export function validateDocument(document) {
 
   for (const checkpoint of history.checkpoints.blocks) {
     validateChoice(checkpoint, "State", HISTORICAL_CHECKPOINT_STATES);
-    validateChoice(checkpoint, "Type", CHECKPOINT_TYPES);
+    validateChoice(checkpoint, "Type", READABLE_CHECKPOINT_TYPES);
     validateFields(checkpoint, ["Condition", "Applies to", "Result", "Task effect"]);
     const state = scalarValue(checkpoint, "State");
     if (state === "cancelled" || state === "replaced") requiredValue(checkpoint, "Reason");
@@ -543,6 +602,7 @@ export function validateDocument(document) {
     const state = scalarValue(slice, "State");
     if (state === "blocked") requiredValue(slice, "Resume when");
     if (state === "abandoned") requiredValue(slice, "Reason");
+    validateRecordedTime(slice);
   }
 
   if (header.state === "paused" && current.currentSlice && scalarValue(current.currentSlice, "State") !== "paused")

package/skills/track-work/scripts/lib/format.mjs

@@ -10,13 +10,17 @@ export const CONTEXT_HEADINGS = [
   "Current direction",
   "Boundaries",
 ];
+// Optional: allowed only directly after Goal, and never empty.
+export const WORK_AGREEMENT_HEADING = "Work agreement";
 export const HISTORY_HEADINGS = ["Decisions", "Checkpoints", "Slices"];
 
 export const TASK_STATES = new Set(["active", "paused", "completed", "abandoned"]);
 export const SLICE_TYPES = new Set(["learning", "delivery", "deepening"]);
 export const CURRENT_SLICE_STATES = new Set(["in_progress", "paused"]);
 export const HISTORICAL_SLICE_STATES = new Set(["completed", "blocked", "abandoned"]);
-export const CHECKPOINT_TYPES = new Set(["independent_review", "local_commit", "user_decision", "continuity"]);
+export const CHECKPOINT_TYPES = new Set(["preserve", "publish", "review", "decision", "continuity"]);
+// Earlier type names remain readable so existing records stay valid.
+export const LEGACY_CHECKPOINT_TYPES = new Set(["local_commit", "independent_review", "user_decision"]);
 export const FUTURE_CHECKPOINT_STATES = new Set(["proposed", "pending", "deferred"]);
 export const HISTORICAL_CHECKPOINT_STATES = new Set(["completed", "cancelled", "replaced"]);
 export const DECISION_STATES = new Set(["active", "superseded", "retired"]);
@@ -60,6 +64,8 @@ export const DECISION_FIELDS = new Set([
 export const HISTORICAL_SLICE_FIELDS = new Set([
   "State",
   "Type",
+  "Occurred",
+  "Recorded",
   "Intended result",
   "Authority source",
   "Result",
@@ -71,6 +77,15 @@ export const HISTORICAL_SLICE_FIELDS = new Set([
   "Residual effects",
 ]);
 
+// A Slice recorded after the fact carries when it happened and the date it was recorded.
+export const OCCURRED_PATTERN = /^(\d{4}-\d{2}-\d{2})(?: to (\d{4}-\d{2}-\d{2}))?$/;
+export const RECORDED_PATTERN = /^retroactively on (\d{4}-\d{2}-\d{2})$/;
+
+export function isCalendarDate(value) {
+  const date = new Date(`${value}T00:00:00Z`);
+  return !Number.isNaN(date.getTime()) && date.toISOString().slice(0, 10) === value;
+}
+
 export const IDS = {
   slice: /^S-(\d{3,})$/,
   checkpoint: /^C-(\d{3,})$/,
@@ -111,6 +126,8 @@ export function canonicalLines(name, state = "active", lastUpdated = new Date().
     "",
     "None",
     "",
+    "### Recovery sources",
+    "",
     "### Next useful action",
     "",
     "## Future Work",

package/skills/track-work/scripts/lib/recover.mjs

@@ -0,0 +1,254 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, relative } from "node:path";
+import { parseDocument, sectionContentLines } from "./document.mjs";
+import { renderResume } from "./views.mjs";
+
+// Recovery in one call (Track Work, "Recover After Context Loss"): the resume view, then what each defining artifact
+// and Recovery source points to and whether it can be read now, then where live Git state disagrees with the record.
+// It reports; reading the sources and reconciling stays the agent's work.
+//
+// It also finds the evidence pointers in Material updates for `validate`: files and commits a later context will
+// rely on. A pointer inside the repository that does not resolve is a problem; one outside it is reported, not checked.
+
+const PATH_TOKEN = /^(~\/|\/|\.{1,2}\/)?[A-Za-z0-9_@.-]+(\/[A-Za-z0-9_@.()-]+)*\/?(#[^\s]*)?$/;
+const COMMIT = /^[0-9a-f]{7,40}$/;
+const URL = /^[a-z][a-z0-9+.-]*:\/\//i;
+
+function git(root, args) {
+  try {
+    return execFileSync("git", args, { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  } catch {
+    return null;
+  }
+}
+
+// A path names a file with an extension, a directory with a trailing "/", or starts like one (./, ../, ~/, /). Slashed
+// words such as "lost/weakened" or "17/9" are not paths.
+const looksLikePath = (token) =>
+  PATH_TOKEN.test(token) &&
+  !COMMIT.test(token) &&
+  !token.includes("*") &&
+  (/^(~\/|\/|\.{1,2}\/)/.test(token) ||
+    /\/$/.test(token) ||
+    (/\.[A-Za-z][A-Za-z0-9]{0,7}(#.*)?$/.test(token) && (token.includes("/") || /^[^.]+\.[A-Za-z]/.test(token))));
+const looksLikeCommit = (token) => COMMIT.test(token) && /\d/.test(token) && /[a-f]/.test(token);
+
+// The pointers a line names: backticked tokens, Markdown link targets, a leading "pointer — ..." token, typed
+// trail pointers (commit:<sha>, file:<path>), and bare commit hashes.
+export function pointersIn(line) {
+  const found = [];
+  const add = (kind, value) => {
+    if (!found.some((each) => each.kind === kind && each.value === value)) found.push({ kind, value });
+  };
+  const text = line.replace(/^\s*[-*]\s+/, "");
+  for (const match of text.matchAll(/\]\(([^)\s]+)\)/g)) classify(match[1], add);
+  for (const match of text.matchAll(/`([^`\n]+)`/g)) classify(match[1].trim(), add);
+  const lead = /^(\S+)\s+[—–-]\s/.exec(text);
+  if (lead) classify(lead[1].replace(/[,;:]$/, ""), add);
+  const prose = text.replace(/`[^`\n]*`/g, " ").replace(/\]\([^)]*\)/g, " ");
+  for (const match of prose.matchAll(/\b(?:commit|file|path):([^\s,;)]+)/g))
+    classify(match[1], add, match[0].startsWith("commit:"));
+  for (const word of prose.split(/[\s,;()[\]"'“”]+/)) {
+    const token = word.replace(/[.:]+$/, "");
+    if (looksLikeCommit(token)) add("commit", token);
+    // A bare path in prose must name a file: a slashed word ending in "/" is usually a folder named in passing.
+    else if (token.includes("/") && !token.endsWith("/") && looksLikePath(token) && !URL.test(token))
+      add("path", token.replace(/#.*$/, ""));
+  }
+  return found;
+}
+
+function classify(raw, add, commitOnly = false) {
+  const token = raw.replace(/^(file|path|commit):/, "");
+  if (URL.test(token)) return add("url", token);
+  if (commitOnly || looksLikeCommit(token)) return add("commit", token);
+  const range = /^([0-9a-f]{7,40})\.\.\.?([0-9a-f]{7,40}|HEAD)$/.exec(token);
+  if (range) {
+    add("commit", range[1]);
+    if (range[2] !== "HEAD") add("commit", range[2]);
+    return;
+  }
+  if (looksLikePath(token)) add("path", token.replace(/#.*$/, ""));
+}
+
+// Where a path pointer resolves: the repository root, the task folder, or as given when absolute or home-relative.
+export function resolvePointer(pointer, { root, taskDir }) {
+  if (pointer.startsWith("~/")) return { outside: true, path: join(homedir(), pointer.slice(2)) };
+  if (isAbsolute(pointer)) {
+    const inside = !relative(root, pointer).startsWith("..");
+    return { outside: !inside, path: pointer };
+  }
+  const candidates = [join(taskDir, pointer), join(root, pointer)];
+  const hit = candidates.find((candidate) => existsSync(candidate));
+  return { outside: false, path: hit ?? candidates[1] };
+}
+
+function describe(path) {
+  try {
+    const stat = statSync(path);
+    if (stat.isDirectory()) return `directory, ${readdirSync(path).length} entries`;
+    const text = readFileSync(path, "utf8");
+    return `${text.split("\n").length} lines, ${text.split(/\s+/).filter(Boolean).length} words`;
+  } catch {
+    return null;
+  }
+}
+
+function checkPointer(pointer, context) {
+  if (pointer.kind === "url") return { ...pointer, state: "not checked (URL)" };
+  if (pointer.kind === "commit") {
+    if (!context.isGit) return { ...pointer, state: "not checked (not a Git repository)" };
+    const full = git(context.root, ["rev-parse", "--verify", "--quiet", `${pointer.value}^{commit}`]);
+    return full
+      ? { ...pointer, state: "resolves", commit: full }
+      : { ...pointer, state: "missing", problem: `commit ${pointer.value} is not in this repository` };
+  }
+  const where = resolvePointer(pointer.value, context);
+  const size = describe(where.path);
+  if (size) return { ...pointer, state: "resolves", size, ...(where.outside ? { outside: true } : {}) };
+  if (where.outside) return { ...pointer, state: "not checked (outside the repository)", outside: true };
+  return { ...pointer, state: "missing", problem: `${pointer.value} does not exist` };
+}
+
+const bullets = (lines) => lines.filter((line) => /^\s*[-*]\s+\S/.test(line));
+
+function sourceEntries(lines, context) {
+  return bullets(lines).map((line) => {
+    const text = line.trim().replace(/^[-*]\s+/, "");
+    const trigger = /\bread (?:only )?(?:when|if) ([^.;]+)/i.exec(text)?.[1]?.trim() ?? null;
+    return { text, trigger, pointers: pointersIn(line).map((pointer) => checkPointer(pointer, context)) };
+  });
+}
+
+function liveState(document, context) {
+  const { root } = context;
+  if (!context.isGit) return { git: false, mismatches: [], notes: ["not a Git repository: no live state to compare"] };
+  const branch = git(root, ["branch", "--show-current"]) || null;
+  const head = git(root, ["rev-parse", "--short=12", "HEAD"]);
+  const subject = head ? git(root, ["log", "-1", "--format=%s"]) : null;
+  const dirty = (git(root, ["status", "--porcelain"]) ?? "").split("\n").filter(Boolean).length;
+  const mismatches = [];
+  const notes = [];
+  const current = document.sections["Current Work"];
+  const sliceText = current ? document.lines.slice(current.start, current.end).join("\n") : "";
+  const contextText = sectionContentLines(document, "Current Context").join("\n");
+  const branches = (git(root, ["for-each-ref", "--format=%(refname:short)", "refs/heads"]) ?? "")
+    .split("\n")
+    .filter(Boolean);
+  const named = branches.filter((name) =>
+    new RegExp(`(^|[\\s\`(])${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}([\\s\`),.;:]|$)`).test(
+      `${sliceText}\n${contextText}`,
+    ),
+  );
+  if (!branch) mismatches.push(`HEAD is detached at ${head}`);
+  else if (named.length && !named.includes(branch))
+    mismatches.push(`the record names branch ${named.join(", ")}; HEAD is on ${branch}`);
+  const commits = [...new Set(pointersIn(sliceText.replace(/\n/g, " ")).filter((each) => each.kind === "commit"))];
+  for (const { value } of commits) {
+    const full = git(root, ["rev-parse", "--verify", "--quiet", `${value}^{commit}`]);
+    if (!full) mismatches.push(`the Current Slice names commit ${value}, which this repository does not have`);
+    else if (head && git(root, ["merge-base", "--is-ancestor", full, "HEAD"]) === null)
+      mismatches.push(`the Current Slice names commit ${value}, which is not in HEAD's history`);
+  }
+  const updated = /^Last updated:\s*(\S+)/m.exec(document.lines.slice(0, 10).join("\n"))?.[1];
+  if (updated && head) {
+    const since = (git(root, ["log", "--oneline", `--since=${updated}`, "HEAD"]) ?? "").split("\n").filter(Boolean);
+    if (since.length)
+      notes.push(
+        `${since.length} commit(s) on HEAD since the record's Last updated (${updated}); it may not describe them`,
+      );
+  }
+  if (dirty) notes.push(`${dirty} uncommitted or untracked path(s)`);
+  return { git: true, branch, head, subject, dirty, namedBranches: named, mismatches, notes };
+}
+
+function contextFor(root, recordPath) {
+  return {
+    root,
+    taskDir: dirname(recordPath),
+    isGit: git(root, ["rev-parse", "--is-inside-work-tree"]) === "true",
+  };
+}
+
+function gitRoot(root) {
+  return git(root, ["rev-parse", "--show-toplevel"]) ?? root;
+}
+
+export function renderRecover(text, { root, recordPath }) {
+  const document = parseDocument(text);
+  const context = contextFor(gitRoot(root), recordPath);
+  const defines = document.context.headings.get("What defines this task");
+  const defining = sourceEntries(document.lines.slice(defines.start, defines.end), context);
+  const sources = document.current.recoverySources;
+  const recovery = sources ? sourceEntries(document.lines.slice(sources.start, sources.end), context) : [];
+  const live = liveState(document, context);
+  const pointerLine = (pointer) =>
+    `${pointer.value}: ${pointer.state}${pointer.size ? ` (${pointer.size})` : ""}${pointer.outside && pointer.size ? ", outside the repository" : ""}`;
+  const entryLines = (entries, withTrigger) =>
+    entries.length
+      ? entries.flatMap((entry) => [
+          `- ${entry.text}`,
+          ...(withTrigger ? [`  - ${entry.trigger ? `read when ${entry.trigger}` : "read now"}`] : []),
+          ...(entry.pointers.length
+            ? entry.pointers.map((pointer) => `  - ${pointerLine(pointer)}`)
+            : ["  - no pointer found: recover it from the text"]),
+        ])
+      : ["None."];
+  const lines = [
+    "## Recovery",
+    "",
+    "Read in this order: every defining artifact, then each Recovery source whose trigger applies, then the History entries the next action depends on (`view entry <ID>`).",
+    "",
+    "### Defining artifacts",
+    "",
+    ...entryLines(defining, false),
+    "",
+    "### Recovery sources",
+    "",
+    ...entryLines(recovery, true),
+    "",
+    "### Live state",
+    "",
+    ...(live.git
+      ? [
+          `- ${live.branch ? `branch ${live.branch}` : "detached HEAD"}, HEAD ${live.head ?? "none"}${live.subject ? ` (${live.subject})` : ""}`,
+        ]
+      : []),
+    ...live.notes.map((note) => `- ${note}`),
+    ...(live.mismatches.length
+      ? ["", "Mismatches: resolve each from sources before acting.", ...live.mismatches.map((each) => `- ${each}`)]
+      : ["- no mismatch found between the record and live Git state"]),
+  ];
+  const resume = renderResume(text);
+  return `${resume.trimEnd()}${document.newline}${document.newline}${lines.join(document.newline)}${document.newline}`;
+}
+
+// Evidence pointers in every Material updates list. An unresolved pointer inside the repository is a problem on an
+// Evidence or Result line, which claims it exists, and a warning on any other line (an Extension may name a planned
+// path); the caller decides whether problems fail. Pointers outside the repository are listed, not checked.
+export function checkEvidencePointers(text, { root, recordPath }) {
+  const document = parseDocument(text);
+  const context = contextFor(gitRoot(root), recordPath);
+  const lines = document.lines;
+  const problems = [];
+  const warnings = [];
+  const outside = [];
+  let checked = 0;
+  for (let index = 0; index < lines.length; index += 1) {
+    if (!/^#####\s+Material updates\s*$/.test(lines[index])) continue;
+    for (let at = index + 1; at < lines.length && !/^#{1,5}\s/.test(lines[at]); at += 1) {
+      for (const pointer of pointersIn(lines[at])) {
+        if (pointer.kind === "url") continue;
+        const result = checkPointer(pointer, context);
+        const claims = /^\s*[-*]\s+(Evidence|Result)\b/.test(lines[at]);
+        if (result.problem) (claims ? problems : warnings).push(`line ${at + 1}: ${result.problem}`);
+        else if (result.outside || result.state.startsWith("not checked"))
+          outside.push(`line ${at + 1}: ${pointer.value}`);
+        if (!result.outside && !result.state.startsWith("not checked")) checked += 1;
+      }
+    }
+  }
+  return { checked, problems, warnings, outside };
+}