openplanr 3.0.1 → 3.1.0

package/lib/host-packages/openai/openplanr/skills/sync/SKILL.md

@@ -6,25 +6,40 @@ license: MIT
 
 # OpenPlanr Sync
 
-Reconcile local planning artifacts and, when requested, GitHub or Linear state.
-Reason about conflicts in this active session. Local and GitHub work never require
+Reconcile local planning artifacts and, when requested, ~~project tracker state.
+Reason about conflicts in this active session. Local and tracker work never require
 the OpenPlanr CLI.
 
-Remote steps run through the host's own connections, as described in
-[tracker connections](references/tracker-connections.md), which also holds the status
-mapping and what to tell the user when a connection is missing:
+Remote steps run through the host's own ~~project tracker connection. The
+[tracker sync reference](references/tracker-connections.md) holds which connection to
+use per tracker, the status mapping, link shapes and what to tell the user when a
+connection is missing; [connectors](references/connectors.md) lists the trackers
+OpenPlanr syncs with and how to connect each in the current host.
 
-- GitHub: the host's GitHub connection, or, when the GitHub CLI is signed in, the
-  packaged [sync helper](scripts/sync.mjs), which creates and edits issues through `gh`;
-  close or reopen an issue with `gh issue close` or `gh issue reopen`. `openplanr github`
-  is an optional equivalent; `openplanr sync` only repairs local cross-references.
-- Linear: the host's Linear connection.
+When the GitHub CLI is signed in, the packaged [sync helper](scripts/sync.mjs) creates
+and edits issues through `gh`; close or reopen an issue with `gh issue close` or
+`gh issue reopen`. Other trackers go through the host's connection only.
+`openplanr sync` only repairs local cross-references.
 
 Audit is read-only by default. Apply local changes only when the request asks for
 reconciliation, and push remote changes only when the request asks for external
 synchronization. If a connection is unavailable, complete local reconciliation
 and report only the external step that could not run.
 
+## With nothing connected
+
+Audit and local reconciliation run in full. Report the remote step as not run,
+name ~~project tracker as the category it needs, and give the current host's step
+from [connectors](references/connectors.md).
+
+## If ~~project tracker is connected
+
+Before any remote write, list every issue change: each issue to create, update,
+close or reopen, with its title and the status it moves to. Write only when the
+request explicitly asked for that push or the user approves the list. Afterwards,
+report each item that was not updated and why, and name the category and product
+the changes went to.
+
 ## Return
 
 Lead with what is aligned, repaired or still blocked. Summarize aligned, locally

package/lib/host-packages/openai/openplanr/skills/sync/openplanr.skill.json

@@ -13,6 +13,17 @@
   ],
   "execution": "host-agent",
   "resources": [
+    {
+      "path": "references/connectors.md",
+      "kind": "reference",
+      "hosts": [
+        "claude-code",
+        "codex",
+        "chatgpt",
+        "cursor"
+      ],
+      "executable": false
+    },
     {
       "path": "references/tracker-connections.md",
       "kind": "reference",

package/lib/host-packages/openai/openplanr/skills/sync/references/connectors.md

@@ -0,0 +1,62 @@
+# Connectors
+
+OpenPlanr skills name a kind of service, such as `~~chat`, instead of a product. Connect
+the product your team uses through your host: the vendor publishes the connector, and
+you sign in through the host. OpenPlanr bundles no connectors; they and their credentials
+live in your host. Two optional features need a token: Linear sync (`openplanr linear`) and
+company sign-in (`openplanr company login`). Only when you use them does OpenPlanr store a
+token, in your OS keychain, or in an encrypted file at `~/.planr/credentials.enc` if you set
+`PLANR_CREDENTIAL_FILE_PASSPHRASE`. Tokens are sent only to Linear or to the company server
+you sign in to.
+`openplanr company logout` removes company tokens.
+Every skill also works with nothing connected and reports any remote step it skipped.
+
+| Category | Placeholder | Products |
+| --- | --- | --- |
+| Chat | `~~chat` | Slack, Microsoft Teams |
+| Project tracker | `~~project tracker` | Linear, GitHub Issues, Jira, Asana |
+| Source control | `~~source control` | GitHub, GitLab, Bitbucket |
+
+Never paste a token into a chat, file or command for OpenPlanr. After you connect a
+service, start a new request so the host loads its tools.
+
+## Chat (`~~chat`)
+
+Share a status report, sprint note or release notes as a message draft that you review and send yourself.
+
+| Product | Use | Claude Code | Codex | Cursor |
+| --- | --- | --- | --- | --- |
+| Slack | Message drafts | Run `/plugin install slack@claude-plugins-official`, then sign in to Slack from `/mcp`. A workspace admin may need to approve the app. | Install Slack from `/plugins` and sign in when asked. A workspace admin may need to approve the app. | Run `/add-plugin slack`, or install Slack from Customize, then sign in when asked. A workspace admin may need to approve the app. |
+
+Message format for Slack, drafting through the connector: standard Markdown, which the connector converts on send ([Slack's messaging guidance](https://github.com/slackapi/slack-mcp-plugin/blob/main/skills/slack-messaging/SKILL.md)): `**bold**`, `_italic_`, `[link text](https://example.com)`, `-` lists, `>` quotes. Do not use mrkdwn's `*bold*` or `<url|text>` here.
+
+Message format for Slack, text to paste: Slack mrkdwn ([formatting](https://docs.slack.dev/messaging/formatting-message-text)): `*bold*`, `_italic_`, `<https://example.com|link text>`, lines starting with `•` or `-` for lists, `>` for quotes; no headings or tables; escape `&`, `<` and `>` as `&amp;`, `&lt;` and `&gt;`.
+
+Also works with: [Microsoft Teams](https://learn.microsoft.com/en-us/microsoft-copilot-studio/mcp-teams-tools) (read for context). Add the vendor's connector in your host the same way.
+
+Verified: [Slack](https://docs.slack.dev/ai/slack-mcp-server) on 2026-10-09, [Microsoft Teams](https://learn.microsoft.com/en-us/microsoft-copilot-studio/mcp-teams-tools) on 2026-10-09.
+
+## Project tracker (`~~project tracker`)
+
+Push planning status to linked issues after you approve each change, and read issue state back.
+
+| Product | Use | Claude Code | Codex | Cursor |
+| --- | --- | --- | --- | --- |
+| Linear | OpenPlanr syncs with it | Run `/plugin install linear@claude-plugins-official`, then sign in to Linear from `/mcp`. | Install Linear from `/plugins` and sign in when asked. | Run `/add-plugin linear`, or install Linear from Customize, then sign in when asked. |
+| GitHub Issues | OpenPlanr syncs with it | Install the GitHub CLI from cli.github.com and run `gh auth login`. | Install GitHub from `/plugins` and sign in when asked, or install the GitHub CLI and run `gh auth login`. | Install the GitHub CLI from cli.github.com and run `gh auth login`. |
+
+Also works with: [Jira](https://support.atlassian.com/atlassian-ai-gateway/docs/get-started-with-the-atlassian-remote-mcp-server/) (read for context), [Asana](https://developers.asana.com/docs/using-asanas-mcp-server) (read for context). Add the vendor's connector in your host the same way.
+
+Verified: [Linear](https://linear.app/docs/mcp) on 2026-10-09, [GitHub Issues](https://cli.github.com/manual/gh_auth_login) on 2026-10-09, [Jira](https://support.atlassian.com/atlassian-ai-gateway/docs/get-started-with-the-atlassian-remote-mcp-server/) on 2026-10-09, [Asana](https://developers.asana.com/docs/using-asanas-mcp-server) on 2026-10-09.
+
+## Source control (`~~source control`)
+
+Read pull request and branch state for status reports and sprint reviews.
+
+| Product | Use | Claude Code | Codex | Cursor |
+| --- | --- | --- | --- | --- |
+| GitHub | Read for context | Install the GitHub CLI from cli.github.com and run `gh auth login`. | Install GitHub from `/plugins` and sign in when asked, or install the GitHub CLI and run `gh auth login`. | Install the GitHub CLI from cli.github.com and run `gh auth login`. |
+
+Also works with: [GitLab](https://docs.gitlab.com/user/gitlab_duo/model_context_protocol/mcp_server/) (read for context), [Bitbucket](https://support.atlassian.com/atlassian-ai-gateway/docs/get-started-with-the-atlassian-remote-mcp-server/) (read for context). Add the vendor's connector in your host the same way.
+
+Verified: [GitHub](https://cli.github.com/manual/gh_auth_login) on 2026-10-09, [GitLab](https://docs.gitlab.com/user/gitlab_duo/model_context_protocol/mcp_server/) on 2026-10-09, [Bitbucket](https://support.atlassian.com/atlassian-ai-gateway/docs/get-started-with-the-atlassian-remote-mcp-server/) on 2026-10-09.

package/lib/host-packages/openai/openplanr/skills/sync/references/tracker-connections.md

@@ -1,7 +1,9 @@
-# GitHub and Linear connections
+# Tracker sync reference
 
-These skills store and read no GitHub or Linear credentials. Remote steps run through a
-connection the host already has; the planning files stay the source of truth.
+These skills store and read no tracker or source control credentials. Remote steps
+run through a connection the host already has; the planning files stay the source of
+truth. OpenPlanr syncs with the trackers marked "OpenPlanr syncs with it" in
+[connectors](connectors.md), and reads other products for context only.
 
 ## Use the host's connection
 
@@ -14,16 +16,10 @@ command, URL or file.
 
 ## When a connection is missing
 
-Finish the local work first. Then report the remote step as not run and give the one
-line for the current host:
-
-| Host | Linear | GitHub |
-| --- | --- | --- |
-| Claude Code | Run `/plugin install linear@claude-plugins-official`, then sign in to Linear from `/mcp`. | Install the GitHub CLI (cli.github.com) and run `gh auth login`. |
-| Codex | Run `codex mcp add linear --url https://mcp.linear.app/mcp`, then `codex mcp login linear`. | Install the GitHub plugin from `/plugins`, or run `gh auth login`. |
-| Cursor | Add Linear from the Cursor Marketplace and sign in to Linear. | Install the GitHub CLI (cli.github.com) and run `gh auth login`. |
-
-Ask the user to try again once connected; never retry the remote step on your own.
+Finish the local work first. Then report the remote step as not run, naming the
+category, and give the one connect step for the current host from
+[connectors](connectors.md). Ask the user to try again once connected; never retry the
+remote step on your own.
 
 ## Status mapping
 

package/lib/json-schema.mjs

@@ -2,7 +2,8 @@
 /**
  * Minimal JSON Schema (draft 2020-12) subset extracted from conformance/runner.mjs.
  * Supports the constructs used by packaged Protocol schemas, including local
- * JSON-pointer and caller-resolved external `$ref` references.
+ * JSON-pointer and caller-resolved external `$ref` references. Any other keyword or
+ * format is reported as an error rather than ignored.
  *
  * Zero third-party deps. Safe to import from node:test suites.
  */
@@ -30,6 +31,146 @@ const matchesType = (v, t) => {
 
 const FORMAT_DATE = /^\d{4}-\d{2}-\d{2}$/;
 const FORMAT_DATETIME = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/;
+const SUPPORTED_FORMATS = new Set(['date', 'date-time']);
+
+const ANNOTATION_KEYWORDS = [
+  '$schema',
+  '$id',
+  '$defs',
+  '$comment',
+  'title',
+  'description',
+  'default',
+  'examples',
+  'deprecated',
+  'readOnly',
+  'writeOnly',
+];
+const VALIDATION_KEYWORDS = [
+  '$ref',
+  'type',
+  'const',
+  'enum',
+  'minLength',
+  'maxLength',
+  'pattern',
+  'format',
+  'minimum',
+  'maximum',
+  'exclusiveMinimum',
+  'minItems',
+  'maxItems',
+  'prefixItems',
+  'items',
+  'uniqueItems',
+  'contains',
+  'minContains',
+  'maxContains',
+  'required',
+  'properties',
+  'additionalProperties',
+  'maxProperties',
+  'dependentRequired',
+  'unevaluatedProperties',
+  'oneOf',
+  'anyOf',
+  'allOf',
+  'if',
+  'then',
+  'else',
+  'not',
+];
+const KNOWN_KEYWORDS = new Set([...ANNOTATION_KEYWORDS, ...VALIDATION_KEYWORDS]);
+const TYPE_NAMES = new Set(['array', 'boolean', 'integer', 'null', 'number', 'object', 'string']);
+
+const isSchema = (value) =>
+  typeof value === 'boolean' ||
+  (value !== null && typeof value === 'object' && !Array.isArray(value));
+/** @type {(value: unknown) => value is Record<string, unknown>} */
+const isPlainObject = (value) =>
+  value !== null && typeof value === 'object' && !Array.isArray(value);
+const isCount = (value) => Number.isSafeInteger(value) && value >= 0;
+/** @type {(value: unknown) => value is string[]} */
+const isUniqueStrings = (value) =>
+  Array.isArray(value) &&
+  value.every((item) => typeof item === 'string') &&
+  new Set(value).size === value.length;
+const isSchemaArray = (value) => Array.isArray(value) && value.length > 0 && value.every(isSchema);
+const isSchemaMap = (value) => isPlainObject(value) && Object.values(value).every(isSchema);
+/** @type {Map<string, RegExp | null>} */
+const compiledPatterns = new Map();
+const MAX_COMPILED_PATTERNS = 1024;
+/** @type {(source: string) => RegExp | null} */
+const tryCompilePattern = (source) => {
+  try {
+    return new RegExp(source);
+  } catch (error) {
+    if (error instanceof SyntaxError) return null;
+    throw error;
+  }
+};
+/** Returns the compiled pattern, or null when it is not a valid regular expression. */
+const compilePattern = (source) => {
+  if (!compiledPatterns.has(source)) {
+    if (compiledPatterns.size >= MAX_COMPILED_PATTERNS) compiledPatterns.clear();
+    compiledPatterns.set(source, tryCompilePattern(source));
+  }
+  return compiledPatterns.get(source) ?? null;
+};
+
+const describeValue = (value) => {
+  const text = String(JSON.stringify(value));
+  return text.length > 80 ? `${text.slice(0, 77)}...` : text;
+};
+
+/**
+ * Expected value shape of each supported keyword, per draft 2020-12.
+ * @type {Record<string, [string, (value: unknown) => boolean]>}
+ */
+const KEYWORD_SHAPES = {
+  $ref: ['a string', (value) => typeof value === 'string'],
+  $defs: ['an object of schemas', isSchemaMap],
+  type: [
+    'a type name or a non-empty array of unique type names',
+    (value) =>
+      (typeof value === 'string' && TYPE_NAMES.has(value)) ||
+      (isUniqueStrings(value) && value.length > 0 && value.every((name) => TYPE_NAMES.has(name))),
+  ],
+  enum: ['an array', Array.isArray],
+  minLength: ['a non-negative integer', isCount],
+  maxLength: ['a non-negative integer', isCount],
+  pattern: [
+    'a valid regular expression string',
+    (value) => typeof value === 'string' && compilePattern(value) !== null,
+  ],
+  minimum: ['a finite number', Number.isFinite],
+  maximum: ['a finite number', Number.isFinite],
+  exclusiveMinimum: ['a finite number', Number.isFinite],
+  minItems: ['a non-negative integer', isCount],
+  maxItems: ['a non-negative integer', isCount],
+  prefixItems: ['a non-empty array of schemas', isSchemaArray],
+  items: ['a schema', isSchema],
+  uniqueItems: ['a boolean', (value) => typeof value === 'boolean'],
+  contains: ['a schema', isSchema],
+  minContains: ['a non-negative integer', isCount],
+  maxContains: ['a non-negative integer', isCount],
+  required: ['an array of unique strings', isUniqueStrings],
+  properties: ['an object of schemas', isSchemaMap],
+  additionalProperties: ['a schema', isSchema],
+  maxProperties: ['a non-negative integer', isCount],
+  dependentRequired: [
+    'an object of unique string arrays',
+    (value) => isPlainObject(value) && Object.values(value).every(isUniqueStrings),
+  ],
+  unevaluatedProperties: ['a schema', isSchema],
+  oneOf: ['a non-empty array of schemas', isSchemaArray],
+  anyOf: ['a non-empty array of schemas', isSchemaArray],
+  allOf: ['a non-empty array of schemas', isSchemaArray],
+  if: ['a schema', isSchema],
+  then: ['a schema', isSchema],
+  else: ['a schema', isSchema],
+  not: ['a schema', isSchema],
+};
 
 function resolveJsonPointer(root, reference) {
   if (reference === '#') return root;
@@ -41,12 +182,73 @@ function resolveJsonPointer(root, reference) {
     .reduce((value, part) => value?.[part], root);
 }
 
+/** Frozen schema nodes that passed every node check; a mutable node is re-checked on each call. */
+const wellFormedSchemas = new WeakSet();
+
+/** True when the node and every keyword value its checks read can no longer change. */
+const isFrozenNode = (schema) =>
+  Object.isFrozen(schema) &&
+  Object.values(schema).every(Object.isFrozen) &&
+  (!isPlainObject(schema.dependentRequired) ||
+    Object.values(schema.dependentRequired).every(Object.isFrozen));
+
+/**
+ * Records unsupported keywords and formats and malformed keyword values, once per schema node.
+ * They go to a shared sink so `not`, `if` and combinator branches cannot swallow them.
+ */
+const checkSchemaNode = (schema, path, context) => {
+  if (wellFormedSchemas.has(schema) || context.checkedSchemas.has(schema)) return;
+  context.checkedSchemas.add(schema);
+  const errorCount = context.schemaErrors.length;
+  for (const keyword of Object.keys(schema)) {
+    if (!KNOWN_KEYWORDS.has(keyword) && !keyword.startsWith('x-')) {
+      context.schemaErrors.push({
+        path,
+        rule: 'unsupported-keyword',
+        detail: `schema keyword '${keyword}' is not supported by this validator`,
+      });
+    }
+  }
+  if (Object.hasOwn(schema, 'format') && !SUPPORTED_FORMATS.has(schema.format)) {
+    context.schemaErrors.push({
+      path,
+      rule: 'unsupported-format',
+      detail: `schema format ${JSON.stringify(schema.format)} is not supported by this validator`,
+    });
+  }
+  for (const [keyword, [expected, isValid]] of Object.entries(KEYWORD_SHAPES)) {
+    if (Object.hasOwn(schema, keyword) && !isValid(schema[keyword])) {
+      context.schemaErrors.push({
+        path,
+        rule: 'schema',
+        detail: `schema keyword '${keyword}' must be ${expected}, got ${describeValue(schema[keyword])}`,
+      });
+    }
+  }
+  if (context.schemaErrors.length === errorCount && isFrozenNode(schema)) {
+    wellFormedSchemas.add(schema);
+  }
+};
+
+/** Records an unresolvable or circular `$ref` once per schema node. */
+const reportReference = (schema, path, detail, context) => {
+  if (context.reportedReferences.has(schema)) return;
+  context.reportedReferences.add(schema);
+  context.schemaErrors.push({ path, rule: '$ref', detail });
+};
+
+/** Validates one node and returns the object property names it evaluated. */
 const validateNode = (value, schema, path, errs, context) => {
-  if (schema === true) return;
+  /** @type {Set<string>} */
+  const evaluated = new Set();
+  if (schema === true) return evaluated;
   if (schema === false) {
     errs.push({ path, rule: 'schema:false', detail: 'value not allowed' });
-    return;
+    return evaluated;
   }
+  // A non-schema child is reported by its parent's keyword-shape check.
+  if (!isSchema(schema)) return evaluated;
+  checkSchemaNode(schema, path, context);
 
   if (typeof schema?.$ref === 'string') {
     const reference = schema.$ref;
@@ -61,21 +263,27 @@ const validateNode = (value, schema, path, errs, context) => {
       nextRoot = result?.rootSchema ?? resolved;
       resolvedBase = result?.base ?? resolved?.$id ?? context.base;
     }
-    if (!resolved) {
-      errs.push({ path, rule: '$ref', detail: `could not resolve schema reference ${reference}` });
-      return;
+    if (!isSchema(resolved)) {
+      const detail =
+        resolved === undefined || resolved === null
+          ? `could not resolve schema reference ${reference}`
+          : `schema reference ${reference} resolved to ${typeOf(resolved)}, not a schema`;
+      reportReference(schema, path, detail, context);
+      return evaluated;
     }
-    const referenceKey = `${context.base ?? '<root>'}:${reference}`;
+    // Recursion that descends into the instance changes `path`; only a repeat at the same location loops.
+    const referenceKey = `${path} ${context.base ?? '<root>'}:${reference}`;
     if (context.referenceStack.includes(referenceKey)) {
-      errs.push({ path, rule: '$ref', detail: `circular schema reference ${reference}` });
-      return;
+      reportReference(schema, path, `circular schema reference ${reference}`, context);
+      return evaluated;
     }
-    validateNode(value, resolved, path, errs, {
+    const referenced = validateNode(value, resolved, path, errs, {
       ...context,
       rootSchema: nextRoot,
       base: resolvedBase,
       referenceStack: [...context.referenceStack, referenceKey],
     });
+    for (const key of referenced) evaluated.add(key);
   }
 
   if (schema.type !== undefined) {
@@ -86,7 +294,7 @@ const validateNode = (value, schema, path, errs, context) => {
         rule: 'type',
         detail: `expected ${types.join('|')}, got ${typeOf(value)}`,
       });
-      return;
+      return evaluated;
     }
   }
 
@@ -125,22 +333,13 @@ const validateNode = (value, schema, path, errs, context) => {
         detail: `length ${value.length} > ${schema.maxLength}`,
       });
     }
-    if (typeof schema.pattern === 'string') {
-      try {
-        if (!new RegExp(schema.pattern).test(value)) {
-          errs.push({
-            path,
-            rule: 'pattern',
-            detail: `value ${JSON.stringify(value)} does not match /${schema.pattern}/`,
-          });
-        }
-      } catch (e) {
-        errs.push({
-          path,
-          rule: 'pattern',
-          detail: `invalid regex /${schema.pattern}/: ${e instanceof Error ? e.message : String(e)}`,
-        });
-      }
+    const pattern = typeof schema.pattern === 'string' ? compilePattern(schema.pattern) : null;
+    if (pattern && !pattern.test(value)) {
+      errs.push({
+        path,
+        rule: 'pattern',
+        detail: `value ${JSON.stringify(value)} does not match /${schema.pattern}/`,
+      });
     }
     if (typeof schema.format === 'string') {
       if (schema.format === 'date' && !FORMAT_DATE.test(value)) {
@@ -166,6 +365,13 @@ const validateNode = (value, schema, path, errs, context) => {
     if (typeof schema.maximum === 'number' && value > schema.maximum) {
       errs.push({ path, rule: 'maximum', detail: `value ${value} > ${schema.maximum}` });
     }
+    if (typeof schema.exclusiveMinimum === 'number' && value <= schema.exclusiveMinimum) {
+      errs.push({
+        path,
+        rule: 'exclusiveMinimum',
+        detail: `value ${value} <= ${schema.exclusiveMinimum}`,
+      });
+    }
   }
 
   if (Array.isArray(value)) {
@@ -231,8 +437,34 @@ const validateNode = (value, schema, path, errs, context) => {
         }
       }
     }
+    if (
+      typeof schema.maxProperties === 'number' &&
+      Object.keys(value).length > schema.maxProperties
+    ) {
+      errs.push({
+        path,
+        rule: 'maxProperties',
+        detail: `property count ${Object.keys(value).length} > ${schema.maxProperties}`,
+      });
+    }
+    if (schema.dependentRequired !== null && typeof schema.dependentRequired === 'object') {
+      for (const [trigger, dependencies] of Object.entries(schema.dependentRequired)) {
+        if (!Object.hasOwn(value, trigger) || !Array.isArray(dependencies)) continue;
+        for (const dependency of dependencies) {
+          if (!Object.hasOwn(value, dependency)) {
+            errs.push({
+              path,
+              rule: 'dependentRequired',
+              detail: `property '${trigger}' requires property '${dependency}'`,
+            });
+          }
+        }
+      }
+    }
     const props = schema.properties || {};
     for (const [k, v] of Object.entries(value)) {
+      if (Object.hasOwn(props, k)) evaluated.add(k);
+      else if (schema.additionalProperties !== undefined) evaluated.add(k);
       if (!Object.hasOwn(props, k)) {
         if (schema.additionalProperties === false) {
           errs.push({ path, rule: 'additionalProperties', detail: `unknown property '${k}'` });
@@ -253,8 +485,11 @@ const validateNode = (value, schema, path, errs, context) => {
     let matched = 0;
     for (const sub of schema.oneOf) {
       const e = [];
-      validateNode(value, sub, path, e, context);
-      if (e.length === 0) matched++;
+      const branch = validateNode(value, sub, path, e, context);
+      if (e.length === 0) {
+        matched++;
+        for (const key of branch) evaluated.add(key);
+      }
     }
     if (matched !== 1) {
       const titles = schema.oneOf.map((s) => s.title || '(unnamed)').join(' | ');
@@ -270,8 +505,11 @@ const validateNode = (value, schema, path, errs, context) => {
     let matched = 0;
     for (const sub of schema.anyOf) {
       const candidateErrors = [];
-      validateNode(value, sub, path, candidateErrors, context);
-      if (candidateErrors.length === 0) matched += 1;
+      const branch = validateNode(value, sub, path, candidateErrors, context);
+      if (candidateErrors.length === 0) {
+        matched += 1;
+        for (const key of branch) evaluated.add(key);
+      }
     }
     if (matched === 0) {
       const titles = schema.anyOf.map((sub) => sub.title || '(unnamed)').join(' | ');
@@ -285,15 +523,22 @@ const validateNode = (value, schema, path, errs, context) => {
 
   if (Array.isArray(schema.allOf)) {
     for (const sub of schema.allOf) {
-      validateNode(value, sub, path, errs, context);
+      for (const key of validateNode(value, sub, path, errs, context)) evaluated.add(key);
     }
   }
 
   if (schema.if !== undefined) {
     const conditionErrors = [];
-    validateNode(value, schema.if, path, conditionErrors, context);
-    const branch = conditionErrors.length === 0 ? schema.then : schema.else;
-    if (branch !== undefined) validateNode(value, branch, path, errs, context);
+    const condition = validateNode(value, schema.if, path, conditionErrors, context);
+    const passed = conditionErrors.length === 0;
+    if (passed) for (const key of condition) evaluated.add(key);
+    const branch = passed ? schema.then : schema.else;
+    if (branch !== undefined) {
+      const branchErrors = [];
+      const branchEvaluated = validateNode(value, branch, path, branchErrors, context);
+      errs.push(...branchErrors);
+      if (branchErrors.length === 0) for (const key of branchEvaluated) evaluated.add(key);
+    }
   }
 
   if (schema.not !== undefined) {
@@ -303,6 +548,24 @@ const validateNode = (value, schema, path, errs, context) => {
       errs.push({ path, rule: 'not', detail: 'value matched a forbidden subschema' });
     }
   }
+
+  if (
+    schema.unevaluatedProperties !== undefined &&
+    value !== null &&
+    typeof value === 'object' &&
+    !Array.isArray(value)
+  ) {
+    for (const [k, v] of Object.entries(value)) {
+      if (evaluated.has(k)) continue;
+      if (schema.unevaluatedProperties === false) {
+        errs.push({ path, rule: 'unevaluatedProperties', detail: `unevaluated property '${k}'` });
+      } else {
+        validateNode(v, schema.unevaluatedProperties, `${path}.${k}`, errs, context);
+      }
+      evaluated.add(k);
+    }
+  }
+  return evaluated;
 };
 
 /** @type {typeof import('./json-schema.d.mts').validateJson} */
@@ -315,13 +578,27 @@ export const validateJson = (
   } = {},
 ) => {
   const errs = [];
+  /** @type {{ path: string, rule: string, detail: string }[]} */
+  const schemaErrors = [];
+  if (!isSchema(schema)) {
+    return [
+      {
+        path: '$',
+        rule: 'schema',
+        detail: `expected a schema object or boolean, got ${typeOf(schema)}`,
+      },
+    ];
+  }
   validateNode(value, schema, '$', errs, {
     rootSchema: schema,
     resolveRef,
     base,
     referenceStack: [],
+    schemaErrors,
+    checkedSchemas: new WeakSet(),
+    reportedReferences: new WeakSet(),
   });
-  return errs;
+  return [...schemaErrors, ...errs];
 };
 
 /**