@agent-native/core-corpus 0.212.1 → 0.214.0

package/corpus/templates/content/actions/_database-view-setup.ts

@@ -8,11 +8,30 @@ import { syncPrivateViewIconReferences } from "../server/lib/private-icon-refere
 import {
   CONTENT_DATABASE_FILTER_OPERATORS,
   type ContentDatabaseFilter,
+  type ContentDatabaseItemLayout,
   type ContentDatabaseView,
   type ContentDatabaseViewConfig,
 } from "../shared/api.js";
+import {
+  CONTENT_DATABASE_ITEM_LAYOUT_PRESET_IDS,
+  CONTENT_DATABASE_ITEM_LEADING_KINDS,
+  CONTENT_DATABASE_ITEM_TITLE_WEIGHTS,
+  MAX_ITEM_LAYOUT_META_PROPERTIES,
+  contentDatabaseItemLayoutPresets,
+  contentDatabaseItemLayoutReferenceErrors,
+  dropDeletedContentDatabaseItemLayoutReferences,
+  itemLayoutLeadingCandidates,
+  normalizeContentDatabaseItemLayout,
+  pruneContentDatabaseItemLayout,
+  savableContentDatabaseItemLayout,
+  startingContentDatabaseItemLayout,
+} from "../shared/database-item-layout.js";
 import { contentDatabaseFilterOperatorsForType } from "../shared/database-query.js";
-import type { DocumentPropertyType } from "../shared/properties.js";
+import {
+  normalizePropertyVisibility,
+  parsePropertyOptions,
+  type DocumentPropertyType,
+} from "../shared/properties.js";
 import {
   runDatabaseSetupMutation,
   setupError,
@@ -76,6 +95,77 @@ const tablePatchFields = {
   openPagesIn: z.enum(["preview", "full_page"]).optional(),
 };
 
+const itemLayoutPropertyIdSchema = z.string().trim().min(1).max(200);
+const itemLayoutLinesSchema = z.union([
+  z.literal(1),
+  z.literal(2),
+  z.literal(3),
+]);
+const itemLayoutMetaSchema = z
+  .array(itemLayoutPropertyIdSchema)
+  .max(MAX_ITEM_LAYOUT_META_PROPERTIES);
+
+export const contentDatabaseItemLayoutSchema = z
+  .object({
+    leading: z
+      .object({
+        kind: z.enum(CONTENT_DATABASE_ITEM_LEADING_KINDS),
+        propertyId: itemLayoutPropertyIdSchema.nullable(),
+      })
+      .strict(),
+    titleWeight: z.enum(CONTENT_DATABASE_ITEM_TITLE_WEIGHTS),
+    line2: z
+      .object({
+        propertyId: itemLayoutPropertyIdSchema.nullable(),
+        lines: itemLayoutLinesSchema,
+      })
+      .strict(),
+    line3: itemLayoutMetaSchema,
+    trailing: itemLayoutMetaSchema,
+  })
+  .strict();
+
+const itemLayoutPatchSchema = z
+  .object({
+    leading: z
+      .object({
+        kind: z.enum(CONTENT_DATABASE_ITEM_LEADING_KINDS),
+        propertyId: itemLayoutPropertyIdSchema.nullable().optional(),
+      })
+      .strict()
+      .optional(),
+    titleWeight: z.enum(CONTENT_DATABASE_ITEM_TITLE_WEIGHTS).optional(),
+    line2: z
+      .object({
+        propertyId: itemLayoutPropertyIdSchema.nullable().optional(),
+        lines: itemLayoutLinesSchema.optional(),
+      })
+      .strict()
+      .optional(),
+    line3: itemLayoutMetaSchema.optional(),
+    trailing: itemLayoutMetaSchema.optional(),
+  })
+  .strict()
+  .describe(
+    "List views only. Slots to change in each row; omitted slots keep their saved value. leading.kind checkbox or status uses the first property of that type unless propertyId names one. line2 shows a text, URL, or Blocks property; line3 and trailing list property IDs in order. Trailing values move under the title on narrow screens. Pass null to restore the default rows.",
+  );
+
+const listPatchFields = {
+  itemLayout: itemLayoutPatchSchema.nullable().optional(),
+  itemLayoutPreset: z
+    .enum(CONTENT_DATABASE_ITEM_LAYOUT_PRESET_IDS)
+    .optional()
+    .describe(
+      "List views only. Starts the rows from a preset before itemLayout applies: checklist (checkbox, bold title, two lines of text), reminders (checkbox, one line of text, date, person and tag under it), tracker (status dot, tag, person and date on the right), digest (page icon, bold title, three lines of text, details under it), or default.",
+    ),
+};
+
+const LIST_VIEW_PATCH_KEYS = new Set([
+  "name",
+  "icon",
+  ...Object.keys(listPatchFields),
+]);
+
 const boundedTablePatchSchema = z
   .object(tablePatchFields)
   .strict()
@@ -91,11 +181,12 @@ const boundedTablePatchSchema = z
     }
   });
 
-const updateTablePatchSchema = z
+const updateViewPatchSchema = z
   .object({
     name: z.string().trim().min(1).max(500).optional(),
     icon: iconValueSchema.nullable().optional(),
     ...tablePatchFields,
+    ...listPatchFields,
   })
   .strict()
   .refine(
@@ -125,7 +216,7 @@ export const updateContentDatabaseViewAgentSchema = z.discriminatedUnion(
         expectedConfigurationRevision: z.string().min(1),
         operation: z.literal("update"),
         viewId: z.string().trim().min(1).max(200),
-        patch: updateTablePatchSchema,
+        patch: updateViewPatchSchema,
       })
       .strict(),
   ],
@@ -147,7 +238,7 @@ function uniqueReferences(values: readonly string[], field: string) {
 
 function validateTablePatch(
   patch:
-    | z.infer<typeof updateTablePatchSchema>
+    | z.infer<typeof updateViewPatchSchema>
     | z.infer<typeof boundedTablePatchSchema>,
   definitions: readonly (typeof schema.documentPropertyDefinitions.$inferSelect)[],
 ) {
@@ -228,6 +319,174 @@ function validateTablePatch(
   }
 }
 
+type PropertyDefinitionRow =
+  typeof schema.documentPropertyDefinitions.$inferSelect;
+
+function itemLayoutProperties(definitions: readonly PropertyDefinitionRow[]) {
+  return definitions.map((definition) => ({
+    definition: {
+      id: definition.id,
+      type: definition.type as DocumentPropertyType,
+      options: parsePropertyOptions(definition.optionsJson),
+      visibility: normalizePropertyVisibility(definition.visibility),
+    },
+  }));
+}
+
+/**
+ * Checks the layout a full-view save carries against the view's saved one:
+ * new slot references the rows can't show are dropped, saved ones stay.
+ */
+export function withSavableItemLayout<
+  T extends { itemLayout?: unknown; hiddenPropertyIds?: unknown },
+>(
+  view: T,
+  savedLayout: unknown,
+  definitions: readonly PropertyDefinitionRow[],
+): T {
+  const layout = normalizeContentDatabaseItemLayout(view.itemLayout);
+  return layout
+    ? {
+        ...view,
+        itemLayout: savableContentDatabaseItemLayout(
+          layout,
+          normalizeContentDatabaseItemLayout(savedLayout),
+          itemLayoutProperties(definitions),
+          Array.isArray(view.hiddenPropertyIds) ? view.hiddenPropertyIds : [],
+        ),
+      }
+    : view;
+}
+
+/**
+ * A view's properties in the order its UI lists them, so presets and slot
+ * defaults pick the same first checkbox, status or text field the UI does.
+ */
+function viewOrderedDefinitions(
+  view: ContentDatabaseView,
+  definitions: readonly PropertyDefinitionRow[],
+) {
+  const order = view.propertyOrderIds ?? [];
+  const rank = (id: string) => {
+    const index = order.indexOf(id);
+    return index < 0 ? order.length : index;
+  };
+  return [...definitions].sort(
+    (a, b) => rank(a.id) - rank(b.id) || a.position - b.position,
+  );
+}
+
+/**
+ * The default rows' properties as the view's settings define them: those not
+ * hidden, in its order. The rows also leave out a "hide when empty" property
+ * that none of the loaded rows fills; the server doesn't see which rows the
+ * view loads, so it keeps those, and their blank values take no space.
+ */
+function defaultListRowProperties(
+  view: ContentDatabaseView,
+  definitions: readonly PropertyDefinitionRow[],
+) {
+  const hidden = new Set(view.hiddenPropertyIds ?? []);
+  return itemLayoutProperties(
+    viewOrderedDefinitions(view, definitions).filter(
+      (definition) =>
+        definition.visibility !== "always_hide" && !hidden.has(definition.id),
+    ),
+  );
+}
+
+/**
+ * Applies an agent's item layout patch to a list view. Returns undefined
+ * when the patch leaves the layout alone and null to restore default rows.
+ */
+function nextListItemLayout(
+  patch: z.infer<typeof updateViewPatchSchema>,
+  view: ContentDatabaseView,
+  definitions: readonly PropertyDefinitionRow[],
+): ContentDatabaseItemLayout | null | undefined {
+  const { itemLayout, itemLayoutPreset } = patch;
+  if (itemLayout === undefined && itemLayoutPreset === undefined) {
+    return undefined;
+  }
+  if (itemLayout === null && itemLayoutPreset !== undefined) {
+    setupError(
+      "INVALID_VIEW_REFERENCE",
+      "Pass itemLayoutPreset or itemLayout: null, not both.",
+      400,
+    );
+  }
+  if (itemLayout === null) return null;
+  const allProperties = itemLayoutProperties(
+    viewOrderedDefinitions(view, definitions),
+  );
+  // Properties hidden in this view can't be put in a slot, as in the UI.
+  const hidden = new Set(view.hiddenPropertyIds ?? []);
+  const properties = allProperties.filter(
+    (property) => !hidden.has(property.definition.id),
+  );
+  let base = view.itemLayout ?? null;
+  if (itemLayoutPreset !== undefined) {
+    const preset = contentDatabaseItemLayoutPresets(properties).find(
+      (candidate) => candidate.id === itemLayoutPreset,
+    )!;
+    if (preset.missingPropertyType) {
+      setupError(
+        "INVALID_VIEW_REFERENCE",
+        `The ${preset.id} preset needs a ${preset.missingPropertyType} property.`,
+        400,
+      );
+    }
+    base = preset.layout;
+  }
+  if (!itemLayout) {
+    return (
+      base &&
+      dropDeletedContentDatabaseItemLayoutReferences(base, allProperties)
+    );
+  }
+  base ??= startingContentDatabaseItemLayout(
+    defaultListRowProperties(view, definitions),
+  );
+  for (const slot of ["line3", "trailing"] as const) {
+    const ids = itemLayout[slot];
+    if (ids) uniqueReferences(ids, slot);
+  }
+  const leading = itemLayout.leading && {
+    kind: itemLayout.leading.kind,
+    propertyId:
+      itemLayout.leading.propertyId ??
+      itemLayoutLeadingCandidates(properties, itemLayout.leading.kind)[0]
+        ?.definition.id ??
+      null,
+  };
+  const withPatch = (from: ContentDatabaseItemLayout) =>
+    normalizeContentDatabaseItemLayout({
+      leading: leading ?? from.leading,
+      titleWeight: itemLayout.titleWeight ?? from.titleWeight,
+      line2: {
+        propertyId:
+          itemLayout.line2?.propertyId !== undefined
+            ? itemLayout.line2.propertyId
+            : from.line2.propertyId,
+        lines: itemLayout.line2?.lines ?? from.line2.lines,
+      },
+      line3: itemLayout.line3 ?? from.line3,
+      trailing: itemLayout.trailing ?? from.trailing,
+    })!;
+  // Only the slots this patch names are checked. Saved slots that name a
+  // hidden property keep it for when it's shown again, and saved slots that
+  // name a deleted one drop it; neither fails an unrelated edit.
+  const [error] = contentDatabaseItemLayoutReferenceErrors(
+    withPatch(pruneContentDatabaseItemLayout(base, properties)),
+    properties,
+  );
+  if (error) setupError("INVALID_VIEW_REFERENCE", error, 400);
+  return dropDeletedContentDatabaseItemLayoutReferences(
+    withPatch(base),
+    allProperties,
+  );
+}
+
 function parseRawConfig(value: string | null) {
   if (!value) return {} as Record<string, unknown>;
   try {
@@ -373,14 +632,43 @@ export async function runUpdateContentDatabaseView(
             404,
           );
         }
-        if (existing.type !== "table") {
+        const patchKeys = Object.keys(input.patch);
+        let patch: Record<string, unknown> = input.patch;
+        if (existing.type === "list") {
+          const unsupported = patchKeys.find(
+            (key) => !LIST_VIEW_PATCH_KEYS.has(key),
+          );
+          if (unsupported) {
+            setupError(
+              "UNSUPPORTED_SCHEMA_CHANGE",
+              `List views accept only name, icon, itemLayout, and itemLayoutPreset here, not ${unsupported}.`,
+              400,
+            );
+          }
+          const { itemLayoutPreset: _preset, ...rest } = input.patch;
+          const itemLayout = nextListItemLayout(
+            input.patch,
+            existing,
+            context.definitions,
+          );
+          patch = itemLayout === undefined ? rest : { ...rest, itemLayout };
+        } else if (existing.type === "table") {
+          const listKey = patchKeys.find((key) => key in listPatchFields);
+          if (listKey) {
+            setupError(
+              "UNSUPPORTED_SCHEMA_CHANGE",
+              `${listKey} applies only to list views.`,
+              400,
+            );
+          }
+          validateTablePatch(input.patch, context.definitions);
+        } else {
           setupError(
             "UNSUPPORTED_SCHEMA_CHANGE",
-            "Ordinary database setup can update only table views.",
+            "Ordinary database setup can update only table and list views.",
             400,
           );
         }
-        validateTablePatch(input.patch, context.definitions);
         viewId = existing.id;
         const index = rawViews.findIndex(
           (view) =>
@@ -398,7 +686,7 @@ export async function runUpdateContentDatabaseView(
         nextViews = [...rawViews];
         nextViews[index] = {
           ...(rawViews[index] as Record<string, unknown>),
-          ...input.patch,
+          ...patch,
         };
       }
 
@@ -480,9 +768,15 @@ export async function runReplaceContentDatabaseViews(input: {
             typeof candidate === "object" &&
             (candidate as { id?: unknown }).id === view.id,
         );
-        return saved && typeof saved === "object"
-          ? { ...(saved as Record<string, unknown>), ...view }
-          : view;
+        const savedView =
+          saved && typeof saved === "object"
+            ? (saved as Record<string, unknown>)
+            : null;
+        return withSavableItemLayout(
+          savedView ? { ...savedView, ...view } : view,
+          savedView?.itemLayout,
+          context.definitions,
+        );
       });
       const nextRaw: Record<string, unknown> = {
         ...rawConfig,

package/corpus/templates/content/actions/_github-source-freshness.ts

@@ -65,19 +65,56 @@ function checkedWithin(lastRefreshedAt: string | null, ms: number) {
   return Number.isFinite(at) && Date.now() - at < ms;
 }
 
-function linkState(link: GitHubLink) {
+function linkState(metadataJson: string | undefined) {
   let metadata: unknown;
   try {
-    metadata = JSON.parse(link.metadataJson);
+    metadata = JSON.parse(metadataJson ?? "");
   } catch {
-    // coercion-ok: a link whose metadata can't be read has no one to read GitHub as, so the sweep passes it by.
+    // coercion-ok: a link whose metadata can't be read has no state; the sweep passes it by.
     return null;
   }
   return readGitHubSourceState(metadata);
 }
 
 function linkedBy(link: GitHubLink): string | null {
-  return linkState(link)?.linkedBy || null;
+  return linkState(link.metadataJson)?.linkedBy || null;
+}
+
+/** What the collection's status line shows about a link, as one comparable string. */
+function statusShown(metadataJson: string | undefined) {
+  const state = linkState(metadataJson);
+  return JSON.stringify([
+    state?.syncedCommitSha ?? null,
+    state?.pendingCommitSha ?? null,
+    state?.progress?.done ?? null,
+    state?.progress?.total ?? null,
+    state?.problem?.code ?? null,
+    state?.skippedCount ?? 0,
+    state?.skipped.map((file) => `${file.reason}:${file.path}`) ?? [],
+    state?.imagesWaiting ?? 0,
+  ]);
+}
+
+/**
+ * Reads what a link's status line shows now. Compare a reading from before a
+ * sync with one from after to learn whether the sync changed it, like a new
+ * problem or a few more files done.
+ */
+export async function readGitHubStatusShown(sourceId: string) {
+  const [source] = await getDb()
+    .select({ metadataJson: schema.contentDatabaseSources.metadataJson })
+    .from(schema.contentDatabaseSources)
+    .where(eq(schema.contentDatabaseSources.id, sourceId))
+    .limit(1);
+  return statusShown(source?.metadataJson);
+}
+
+/** Whether a sync changed what the status line shows, like a new problem. */
+async function statusChanged(link: GitHubLink) {
+  return (
+    statusShown(link.metadataJson) !==
+    (await readGitHubStatusShown(link.sourceId))
+  );
 }
 
 export function githubSyncChangedRows(result: GitHubSyncResult) {
@@ -85,30 +122,40 @@ export function githubSyncChangedRows(result: GitHubSyncResult) {
 }
 
 /**
- * Tells everyone who can read the collection that a sync nobody asked for
- * changed its rows. It is the event the sync action sends, so open pages,
- * tables, page lists and Trash update in place.
+ * Tells everyone who can read the collection that its rows or status changed.
+ * It is the event the sync action sends, so open pages, tables, page lists,
+ * Trash and the status line update in place. An action whose sync failed
+ * sends it too, since a failed action sends no change event of its own.
  */
-function announceSync(
-  link: GitHubLink,
+export function announceGitHubSyncChange(
+  databaseDocumentId: string,
   owner: string | null,
-  result: GitHubSyncResult,
 ) {
-  if (!githubSyncChangedRows(result)) return;
   recordChange({
     source: "action",
     type: "change",
     key: "sync-github-folder",
     ...(owner ? { owner } : {}),
-    ...documentChangeResource(link.databaseDocumentId),
+    ...documentChangeResource(databaseDocumentId),
   });
 }
 
+/** For a sync nobody asked for that changed rows or the status line. */
+async function announceSync(
+  link: GitHubLink,
+  owner: string | null,
+  result: GitHubSyncResult,
+) {
+  if (result.state === "busy") return;
+  if (!githubSyncChangedRows(result) && !(await statusChanged(link))) return;
+  announceGitHubSyncChange(link.databaseDocumentId, owner);
+}
+
 async function syncBeforeRead(link: GitHubLink | undefined) {
   if (!link || checkedWithin(link.lastRefreshedAt, GITHUB_SOURCE_STALE_MS)) {
     return false;
   }
-  const state = linkState(link);
+  const state = linkState(link.metadataJson);
   if (
     state?.pendingCommitSha &&
     checkedWithin(state.checkedAt, PUSH_LEFT_TO_SWEEP_MS)
@@ -116,8 +163,9 @@ async function syncBeforeRead(link: GitHubLink | undefined) {
     return false;
   }
   const until = Date.now() + READ_SYNC_BUDGET_MS;
+  let result: GitHubSyncResult;
   try {
-    const result = await syncGitHubSource({
+    result = await syncGitHubSource({
       sourceId: link.sourceId,
       budgetMs: READ_SYNC_BUDGET_MS,
     });
@@ -129,8 +177,6 @@ async function syncBeforeRead(link: GitHubLink | undefined) {
       if (!result.commitSha) await waitForGitHubSync(link.sourceId, until);
       return true;
     }
-    announceSync(link, linkedBy(link), result);
-    return githubSyncChangedRows(result);
   } catch (error) {
     // coercion-ok: the read goes on with the rows Content has; the next read or background sync tries GitHub again.
     console.warn(
@@ -139,6 +185,15 @@ async function syncBeforeRead(link: GitHubLink | undefined) {
     );
     return false;
   }
+  // The rows changed either way, so the read rereads them even when telling
+  // open pages fails.
+  await announceSync(link, linkedBy(link), result).catch((error: unknown) => {
+    console.warn(
+      "[github-source] change event failed:",
+      error instanceof Error ? error.message : String(error),
+    );
+  });
+  return githubSyncChangedRows(result);
 }
 
 /**
@@ -237,7 +292,7 @@ export async function runGitHubSourceSweep(context: RecurringSweepContext) {
               signal: context.signal,
             }),
         );
-        announceSync(link, owner, result);
+        await announceSync(link, owner, result);
       } catch (error) {
         // coercion-ok: one link's failure is recorded on that link by the sync; the rest still run.
         console.warn(

package/corpus/templates/content/actions/_github-source-metadata.ts

@@ -14,6 +14,17 @@ import {
 /** Most skipped files a link remembers for its status line. */
 const MAX_REMEMBERED_SKIPS = 50;
 
+/** A file the folder has that no row shows, and why. */
+export interface GitHubSkippedFile {
+  path: string;
+  reason: GitHubSourceSkipReason;
+}
+
+/** A file skipped once it was read, with the blob it was read at. */
+export interface GitHubReadSkip extends GitHubSkippedFile {
+  blobSha: string;
+}
+
 /**
  * Everything a GitHub link keeps between syncs, stored under `github` in the
  * source's metadata. Rows keep their own blob SHA, so a sync that stops
@@ -40,7 +51,15 @@ export interface GitHubSourceState extends GitHubFolderLocation {
    */
   cutShort: string[];
   files: number;
-  skipped: Array<{ path: string; reason: GitHubSourceSkipReason }>;
+  /** Up to 50 skipped files; `skippedCount` says how many there are. */
+  skipped: GitHubSkippedFile[];
+  skippedCount: number;
+  /**
+   * Every file skipped once it was read, so later syncs pass each by while
+   * its blob is unchanged rather than reading it again. One per Markdown
+   * file at most, so a link never keeps more than 2,000.
+   */
+  readSkips: GitHubReadSkip[];
   /** Images rows couldn't store yet because file storage isn't set up. */
   imagesWaiting: number;
   problem: {
@@ -103,6 +122,24 @@ function stringOrNull(value: unknown): string | null {
   return typeof value === "string" && value ? value : null;
 }
 
+function readSkippedFiles(
+  value: unknown,
+): Array<GitHubSkippedFile & { blobSha?: unknown }> {
+  return (Array.isArray(value) ? value : []).flatMap((raw) => {
+    const skip = asRecord(raw);
+    if (
+      !skip ||
+      typeof skip.path !== "string" ||
+      (skip.reason !== "mdx" &&
+        skip.reason !== "too-large" &&
+        skip.reason !== "not-text")
+    ) {
+      return [];
+    }
+    return [{ path: skip.path, reason: skip.reason, blobSha: skip.blobSha }];
+  });
+}
+
 export function readGitHubSourceState(
   metadata: unknown,
 ): GitHubSourceState | null {
@@ -119,6 +156,16 @@ export function readGitHubSourceState(
   const progress = asRecord(github.progress);
   const problem = asRecord(github.problem);
   const claim = asRecord(github.claim);
+  const skipped = readSkippedFiles(github.skipped).map(({ path, reason }) => ({
+    path,
+    reason,
+  }));
+  const readSkips = readSkippedFiles(github.readSkips).flatMap(
+    (skip): GitHubReadSkip[] =>
+      typeof skip.blobSha === "string"
+        ? [{ path: skip.path, reason: skip.reason, blobSha: skip.blobSha }]
+        : [],
+  );
   return {
     owner: github.owner,
     repo: github.repo,
@@ -143,18 +190,12 @@ export function readGitHubSourceState(
       (path): path is string => typeof path === "string",
     ),
     files: typeof github.files === "number" ? github.files : 0,
-    skipped: (Array.isArray(github.skipped) ? github.skipped : []).flatMap(
-      (raw) => {
-        const skip = asRecord(raw);
-        return skip &&
-          typeof skip.path === "string" &&
-          (skip.reason === "mdx" ||
-            skip.reason === "too-large" ||
-            skip.reason === "not-text")
-          ? [{ path: skip.path, reason: skip.reason }]
-          : [];
-      },
-    ),
+    skipped,
+    skippedCount:
+      typeof github.skippedCount === "number"
+        ? github.skippedCount
+        : skipped.length,
+    readSkips,
     imagesWaiting:
       typeof github.imagesWaiting === "number" ? github.imagesWaiting : 0,
     problem:
@@ -174,10 +215,14 @@ export function readGitHubSourceState(
   };
 }
 
+/** The first 50 skipped files in path order, which the status line lists. */
 export function rememberedSkips(
-  skipped: Array<{ path: string; reason: GitHubSourceSkipReason }>,
-) {
-  return skipped.slice(0, MAX_REMEMBERED_SKIPS);
+  skipped: GitHubSkippedFile[],
+): GitHubSkippedFile[] {
+  return [...skipped]
+    .sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0))
+    .slice(0, MAX_REMEMBERED_SKIPS)
+    .map(({ path, reason }) => ({ path, reason }));
 }
 
 /** The status agents and the status line read; never includes the claim. */
@@ -199,7 +244,8 @@ export function githubSourceStatus(
     pendingCommitSha: state.pendingCommitSha,
     progress: state.progress,
     files: state.files,
-    skipped: state.skipped,
+    skipped: state.skipped.map(({ path, reason }) => ({ path, reason })),
+    skippedCount: state.skippedCount,
     imagesWaiting: state.imagesWaiting,
     problem: state.problem,
   };