@thinkingsage/kanon 0.8.0

package/src/attribution-backfill.ts

@@ -0,0 +1,319 @@
+/**
+ * One-shot attribution backfill (ADR-0064, Requirement 9).
+ *
+ * The PURE core here classifies an existing artifact and computes the
+ * attribution draft it would receive, WITHOUT touching disk. It is the logic
+ * validated by the corpus dry-run: 24 skip (in-house), 39 clean (verbatim), 3
+ * manual review. The CLI runner (registered in src/cli.ts) walks `knowledge/`,
+ * calls `planArtifactBackfill` per artifact, and writes drafts for the "clean"
+ * bucket while listing the "manual" bucket for a human relationship call.
+ *
+ * `author` is never modified. An artifact that already has an `attribution`
+ * block is skipped (idempotent).
+ */
+
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { deriveAttributionDraft } from "./attribution";
+import { generateCatalog } from "./catalog";
+import { isParseError, loadKnowledgeArtifact } from "./parser";
+import { serializeCanonical } from "./rosetta/canonical";
+import { codePointCompare } from "./rosetta/contracts";
+import type {
+	AttributionRecord,
+	Frontmatter,
+	KnowledgeArtifact,
+	UpstreamWork,
+} from "./schemas";
+/** Where a scanned artifact lands after classification. */
+export type BackfillClassification =
+	| "skip-in-house"
+	| "skip-has-attribution"
+	| "clean"
+	| "manual-review";
+
+export interface BackfillPlan {
+	name: string;
+	classification: BackfillClassification;
+	/** The draft to write (present for `clean` and `manual-review`). */
+	draft?: AttributionRecord;
+	/** Why it was routed to manual review (present for `manual-review`). */
+	reason?: string;
+}
+
+/**
+ * Author strings that mark in-house authorship (no upstream to credit) or a
+ * scaffolder default. Matched case-insensitively as a whole-string or a
+ * contains check for the org names.
+ */
+const IN_HOUSE_AUTHORS = [
+	"steven j. miklovic",
+	"steven",
+	"kanon",
+	"johns hopkins drcc",
+	"jhu sheridan libraries",
+	"context-bazaar",
+	// Scaffolder defaults — not a person or upstream.
+	"kiro power builder",
+	"demo",
+];
+
+/**
+ * Prose markers in an `author` string that imply the artifact was adapted or
+ * repackaged from an upstream — routes to manual review for a `relationship`
+ * decision rather than a blind `verbatim` backfill.
+ */
+const ADAPTATION_MARKERS =
+	/\b(adapted|packaged|repackaged|derived|based on|forked|modified)\b|\bby\b.*\bfor\b|\(.*\b(packaged|adapted)\b.*\)/i;
+
+/** A source banner in the body, e.g. "> **Source and adaptation:** ...". */
+const SOURCE_BANNER = /Source and adaptation:/i;
+/** A github-style repo slug, optionally with @commit, inside a banner. */
+const BANNER_REPO = /\b([\w.-]+\/[\w.-]+)\b(?:[^\n]*?@([0-9a-f]{7,40}))?/i;
+
+function isInHouseAuthor(author: string): boolean {
+	const a = author.trim().toLowerCase();
+	if (a.length === 0) return true;
+	return IN_HOUSE_AUTHORS.some((h) => a === h || a.includes(h));
+}
+
+/**
+ * Parse a body source banner into repo/commit and, when it names a distinct
+ * original work/author beyond the packaging repo, a second upstream work.
+ * Returns null when no banner is present.
+ */
+export function scanBodyBanner(body: string): {
+	sourceRepo?: string;
+	sourceCommit?: string;
+	url?: string;
+	/** A distinct original work named by the banner (→ second upstream + manual). */
+	secondWork?: UpstreamWork;
+} | null {
+	const bannerLineIdx = body.search(SOURCE_BANNER);
+	if (bannerLineIdx === -1) return null;
+	// Take the banner plus a little following text (the blockquote body).
+	const snippet = body.slice(bannerLineIdx, bannerLineIdx + 600);
+
+	const repoMatch = snippet.match(BANNER_REPO);
+	const sourceRepo = repoMatch?.[1];
+	const sourceCommit = repoMatch?.[2];
+	const url = sourceRepo ? `https://github.com/${sourceRepo}` : undefined;
+
+	// Detect a distinct original work: a "public-domain"/year/author phrasing
+	// beyond the packaging repo (e.g. Strunk's 1918 text behind obra's repo).
+	let secondWork: UpstreamWork | undefined;
+	const originalMatch = snippet.match(
+		/\b(?:by|text by|written by)\s+([A-Z][A-Za-z.\-\s]+?(?:Jr\.|Sr\.|[A-Z][a-z]+))\b/,
+	);
+	if (originalMatch) {
+		const author = originalMatch[1].trim();
+		const yearMatch = snippet.match(/\b(1[6-9]\d{2}|20\d{2})\b/);
+		const pd = /public[-\s]?domain/i.test(snippet);
+		secondWork = {
+			work: yearMatch ? `Original work (${yearMatch[1]})` : "Original work",
+			authors: [author],
+			license: pd ? "public-domain" : undefined,
+			relationship: "verbatim",
+		} as UpstreamWork;
+	}
+
+	return { sourceRepo, sourceCommit, url, secondWork };
+}
+
+/**
+ * Classify one artifact and compute its backfill draft (pure).
+ *
+ * @param frontmatter the artifact's parsed frontmatter
+ * @param body        the artifact's markdown body (for the banner scan)
+ */
+export function planArtifactBackfill(
+	frontmatter: Frontmatter,
+	body: string,
+): BackfillPlan {
+	const name = frontmatter.name;
+
+	// Idempotent: never overwrite an existing attribution block.
+	if (frontmatter.attribution?.upstream?.length) {
+		return { name, classification: "skip-has-attribution" };
+	}
+
+	const author = frontmatter.author ?? "";
+
+	// Adaptation/packaging prose implies a real upstream even when the string
+	// also names an in-house adapter ("adapted for Kanon by <curator>"), so this
+	// check MUST precede the in-house contains-check below — otherwise
+	// "robin (revfactory), adapted ... by Steven J. Miklovic" is misfiled as
+	// in-house because it contains a curator name.
+	const hasAdaptationMarker = ADAPTATION_MARKERS.test(author);
+
+	// In-house / scaffolder default → no upstream to credit (only when there is
+	// no adaptation marker pointing at a real upstream).
+	if (!hasAdaptationMarker && isInHouseAuthor(author)) {
+		return { name, classification: "skip-in-house" };
+	}
+
+	// Derive a base draft from author/license/provenance.
+	const provenance = frontmatter.provenance;
+	const draft = deriveAttributionDraft({
+		upstreamFrontmatter: frontmatter as unknown as Record<string, unknown>,
+		sourceRepo: provenance?.upstream,
+		sourceCommit: provenance?.sourceRevision,
+		sourcePath: provenance?.sourcePath,
+		curatedBy: undefined,
+	});
+
+	// Body-banner scan (task 11.2): enrich the derived work and detect a
+	// distinct second upstream.
+	const banner = scanBodyBanner(body);
+	if (banner) {
+		const [first, ...rest] = draft.upstream;
+		if (banner.sourceRepo) first["source-repo"] = banner.sourceRepo;
+		if (banner.sourceCommit) first["source-commit"] = banner.sourceCommit;
+		if (banner.url && !first.url) first.url = banner.url;
+		// When the banner names the packaging repo, the frontmatter author is the
+		// packager → relationship packaged.
+		if (banner.sourceRepo) first.relationship = "packaged";
+		draft.upstream = [first, ...rest];
+		if (banner.secondWork) {
+			draft.upstream.push(banner.secondWork);
+			return {
+				name,
+				classification: "manual-review",
+				draft,
+				reason: `body banner names a distinct original work (${banner.secondWork.authors.join(", ")}); confirm relationships`,
+			};
+		}
+	}
+
+	// Adaptation/packaging prose in the author string → manual relationship call.
+	if (hasAdaptationMarker) {
+		return {
+			name,
+			classification: "manual-review",
+			draft,
+			reason: `author string implies adaptation/packaging ("${author}"); set relationship by hand`,
+		};
+	}
+
+	return { name, classification: "clean", draft };
+}
+
+/** Summary counts for a backfill run/dry-run. */
+export interface BackfillSummary {
+	skipInHouse: number;
+	skipHasAttribution: number;
+	clean: number;
+	manualReview: number;
+	plans: BackfillPlan[];
+}
+
+/**
+ * Fold a list of per-artifact plans into a summary (pure). Used by both the
+ * dry-run report and the applying runner.
+ */
+export function summarizeBackfill(plans: BackfillPlan[]): BackfillSummary {
+	const summary: BackfillSummary = {
+		skipInHouse: 0,
+		skipHasAttribution: 0,
+		clean: 0,
+		manualReview: 0,
+		plans,
+	};
+	for (const plan of plans) {
+		switch (plan.classification) {
+			case "skip-in-house":
+				summary.skipInHouse++;
+				break;
+			case "skip-has-attribution":
+				summary.skipHasAttribution++;
+				break;
+			case "clean":
+				summary.clean++;
+				break;
+			case "manual-review":
+				summary.manualReview++;
+				break;
+		}
+	}
+	return summary;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// IO runner (impure orchestration shell)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/** Options for a backfill run over one or more knowledge directories. */
+export interface BackfillRunOptions {
+	/** Knowledge source directories to scan (e.g. ["knowledge", "packages"]). */
+	knowledgeDirs: string[];
+	/** When true, classify and report without writing any file. */
+	dryRun: boolean;
+}
+
+/**
+ * Re-serialize an artifact carrying its new `attribution` block and write ONLY
+ * `knowledge.md` back, mirroring the provenance backfill's write discipline
+ * (deterministic canonical bytes; auxiliary files/workflows left untouched).
+ */
+async function writeAttributionIntoKnowledgeMd(
+	artifactDir: string,
+	artifact: KnowledgeArtifact,
+): Promise<boolean> {
+	const { plan } = serializeCanonical(artifact, {
+		emitEmptyAuxiliaryFiles: false,
+		emitBodyOverrides: false,
+		emitWorkflows: false,
+	});
+	if (!plan) return false;
+	const knowledgeFile = plan.outputFiles.find(
+		(f) => f.relativePath === "knowledge.md",
+	);
+	if (!knowledgeFile) return false;
+	const content =
+		typeof knowledgeFile.content === "string"
+			? knowledgeFile.content
+			: new TextDecoder().decode(knowledgeFile.content);
+	await writeFile(join(artifactDir, "knowledge.md"), content, "utf-8");
+	return true;
+}
+
+/**
+ * Walk each knowledge directory, plan a backfill per artifact, and (unless
+ * dry-run) write the `attribution` block for the `clean` bucket. Artifacts in
+ * `manual-review` are reported with their draft but NOT written — a human must
+ * confirm the relationship first. Deterministic: directories are visited in
+ * code-point name order.
+ */
+export async function runAttributionBackfill(
+	options: BackfillRunOptions,
+): Promise<BackfillSummary> {
+	const plans: BackfillPlan[] = [];
+
+	// Enumerate artifact directories via the catalog scan, which handles BOTH
+	// the flat (knowledge/<artifact>/) and namespaced
+	// (knowledge/<group>/<artifact>/) layouts — a plain readdir would miss the
+	// nested kiro-official/byron-powers artifacts (AGENTS.md: two-layout scan).
+	const entries = await generateCatalog(options.knowledgeDirs);
+	const artifactDirs = entries.map((e) => e.path).sort(codePointCompare);
+
+	for (const artifactDir of artifactDirs) {
+		const loaded = await loadKnowledgeArtifact(artifactDir);
+		if (isParseError(loaded)) continue;
+
+		const artifact = loaded.data;
+		const plan = planArtifactBackfill(artifact.frontmatter, artifact.body);
+		plans.push(plan);
+
+		// Only the clean bucket is written automatically; manual-review needs a
+		// human relationship call, and skips write nothing.
+		if (!options.dryRun && plan.classification === "clean" && plan.draft) {
+			const withAttribution: KnowledgeArtifact = {
+				...artifact,
+				frontmatter: { ...artifact.frontmatter, attribution: plan.draft },
+			};
+			await writeAttributionIntoKnowledgeMd(artifactDir, withAttribution);
+		}
+	}
+
+	return summarizeBackfill(plans);
+}

package/src/attribution-report.ts

@@ -0,0 +1,95 @@
+/**
+ * Pure NOTICES report generator (ADR-0064, Requirement 8).
+ *
+ * `renderAttributionReport` takes the list of catalog entries and emits a
+ * deterministic, byte-stable NOTICES string grouped by license. It performs no
+ * IO, so it is unit-tested and reproducible (mirrors the ADR-0049 reconciliation
+ * report). The `kanon attribute` command (src/cli.ts) loads the catalog and
+ * hands the entries here.
+ */
+
+import type { CatalogEntry, UpstreamWork } from "./schemas";
+
+/** A single credited upstream work with the artifact it appears in. */
+interface CreditLine {
+	artifact: string;
+	work: UpstreamWork;
+}
+
+/** Case-insensitive, then case-sensitive, code-point string compare. */
+function compareStrings(a: string, b: string): number {
+	const la = a.toLowerCase();
+	const lb = b.toLowerCase();
+	if (la < lb) return -1;
+	if (la > lb) return 1;
+	if (a < b) return -1;
+	if (a > b) return 1;
+	return 0;
+}
+
+const NO_LICENSE_GROUP = "(no license declared)";
+
+/**
+ * Render a deterministic NOTICES report grouped by license. Entries without an
+ * `attribution` block contribute nothing. Within each license group, works are
+ * sorted by title then artifact name so identical input yields identical output.
+ */
+export function renderAttributionReport(
+	entries: readonly CatalogEntry[],
+): string {
+	// Collect every credited upstream work, keyed by license group.
+	const byLicense = new Map<string, CreditLine[]>();
+
+	for (const entry of entries) {
+		const upstream = entry.attribution?.upstream;
+		if (!upstream || upstream.length === 0) continue;
+		for (const work of upstream) {
+			const group = work.license?.trim() || NO_LICENSE_GROUP;
+			const list = byLicense.get(group) ?? [];
+			list.push({ artifact: entry.name, work });
+			byLicense.set(group, list);
+		}
+	}
+
+	const licenseGroups = [...byLicense.keys()].sort(compareStrings);
+
+	const lines: string[] = [];
+	lines.push("NOTICES");
+	lines.push("=======");
+	lines.push("");
+	lines.push(
+		"Upstream works this library derives from, grouped by license. Generated",
+	);
+	lines.push("by `kanon attribute` — do not edit by hand.");
+	lines.push("");
+
+	if (licenseGroups.length === 0) {
+		lines.push("No upstream attribution recorded.");
+		lines.push("");
+		return lines.join("\n");
+	}
+
+	for (const license of licenseGroups) {
+		lines.push(`## ${license}`);
+		lines.push("");
+		const works = (byLicense.get(license) ?? [])
+			.slice()
+			.sort(
+				(a, b) =>
+					compareStrings(a.work.work, b.work.work) ||
+					compareStrings(a.artifact, b.artifact),
+			);
+		for (const { artifact, work } of works) {
+			const authors =
+				work.authors.length > 0 ? work.authors.join(", ") : "(author unknown)";
+			const urlSuffix = work.url ? ` <${work.url}>` : "";
+			lines.push(
+				`- ${work.work} — ${authors} [${work.relationship}]${urlSuffix}`,
+			);
+			lines.push(`    used in: ${artifact}`);
+		}
+		lines.push("");
+	}
+
+	return lines.join("\n");
+}

package/src/attribution.ts

@@ -0,0 +1,239 @@
+/**
+ * Pure attribution-draft derivation (see ADR-0064, design §"Field derivation").
+ *
+ * `deriveAttributionDraft` builds an {@link AttributionRecord} from an upstream
+ * artifact's frontmatter plus the acquisition data the import path already
+ * knows (`source-repo`/`source-commit`/`url`). It is deliberately IO-free and
+ * side-effect-free so it can be unit-tested with fixtures and reused by both
+ * the interactive wizard (task 5) and the one-shot backfill (task 11).
+ *
+ * The draft always sets `relationship: "verbatim"` — the copyright-relevant
+ * relationship is NOT derivable and is the one required human input, elicited
+ * by the wizard or hand-set during backfill.
+ */
+
+import type { AttributionRecord, UpstreamWork } from "./schemas";
+import { RelationshipSchema } from "./schemas";
+
+/** Inputs available at import/acquisition time for deriving a draft. */
+export interface DeriveAttributionInput {
+	/** The upstream artifact's own frontmatter (source of `work`/`authors`/`license`). */
+	upstreamFrontmatter: Record<string, unknown>;
+	/** Acquisition repo, e.g. `owner/repo` (same value written to provenance). */
+	sourceRepo?: string;
+	/** Acquisition revision/commit. */
+	sourceCommit?: string;
+	/** Relative source path within the upstream repo (used to build a `url`). */
+	sourcePath?: string;
+	/** An explicit upstream URL; when absent one is built from repo + path. */
+	url?: string;
+	/** Curator identity (git/config); recorded as `curated-by`. */
+	curatedBy?: string;
+}
+
+/**
+ * Read a string frontmatter field, trimming and treating blank as absent.
+ */
+function readString(
+	fm: Record<string, unknown>,
+	key: string,
+): string | undefined {
+	const value = fm[key];
+	if (typeof value !== "string") return undefined;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
+}
+
+/**
+ * Split an upstream `author` string into a list of author names. Upstream
+ * `author` is free-text; we keep it as a single author entry rather than
+ * guessing at parenthetical packagers or "adapted by" prose — that nuance is a
+ * `relationship` decision the human makes, not something to infer here. When
+ * `author` is absent, `authors` is empty (the wizard/validator then flag it).
+ */
+function deriveAuthors(fm: Record<string, unknown>): string[] {
+	const author = readString(fm, "author");
+	return author ? [author] : [];
+}
+
+/**
+ * Build an upstream URL from `owner/repo` + a source path when no explicit URL
+ * was supplied. Best-effort: returns undefined if we cannot form a plausible
+ * https URL (the schema treats `url` as optional).
+ */
+function buildUrl(input: DeriveAttributionInput): string | undefined {
+	if (input.url && input.url.trim().length > 0) return input.url.trim();
+	const repo = input.sourceRepo?.trim();
+	if (!repo) return undefined;
+	// Only build a URL for a github-style `owner/repo` slug.
+	if (!/^[^/\s]+\/[^/\s]+$/.test(repo)) return undefined;
+	const base = `https://github.com/${repo}`;
+	const path = input.sourcePath?.trim();
+	if (!path) return base;
+	const commit = input.sourceCommit?.trim();
+	const ref = commit && commit.length > 0 ? commit : "HEAD";
+	const cleanPath = path.replace(/^\/+/, "");
+	return `${base}/blob/${ref}/${cleanPath}`;
+}
+
+/**
+ * Derive a draft {@link AttributionRecord} for a single upstream work.
+ *
+ * `work` falls back to the upstream `name` when no more specific title is
+ * present. `relationship` is always `verbatim` in the draft.
+ */
+export function deriveAttributionDraft(
+	input: DeriveAttributionInput,
+): AttributionRecord {
+	const fm = input.upstreamFrontmatter ?? {};
+
+	const work =
+		readString(fm, "work") ??
+		readString(fm, "title") ??
+		readString(fm, "name") ??
+		input.sourceRepo?.trim() ??
+		"";
+
+	const upstream: UpstreamWork = {
+		work,
+		authors: deriveAuthors(fm),
+		relationship: "verbatim",
+	};
+
+	const url = buildUrl(input);
+	if (url) upstream.url = url;
+
+	const license = readString(fm, "license");
+	if (license) upstream.license = license;
+
+	const sourceRepo = input.sourceRepo?.trim();
+	if (sourceRepo) upstream["source-repo"] = sourceRepo;
+
+	const sourceCommit = input.sourceCommit?.trim();
+	if (sourceCommit) upstream["source-commit"] = sourceCommit;
+
+	const record: AttributionRecord = { upstream: [upstream] };
+
+	const curatedBy = input.curatedBy?.trim();
+	if (curatedBy) record["curated-by"] = curatedBy;
+
+	return record;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// Attribution wizard (import-time capture shell)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * How the attribution step behaves during import (Requirement 3, 4):
+ *
+ * - `interactive`: confirm the derived draft and require a `relationship` select.
+ * - `defaults`: accept the derived draft unchanged (`relationship: verbatim`),
+ *   no prompts — used by `--attribution-defaults` and the non-TTY fallback.
+ * - `skip`: write no attribution block — used by `--no-attribution`.
+ */
+export type AttributionWizardMode = "interactive" | "defaults" | "skip";
+
+/**
+ * Prompt callbacks, injectable so the wizard is unit-testable without a live
+ * TTY. Mirrors the surface of `@clack/prompts` we use. In production the import
+ * path passes real `@clack/prompts` bindings; tests pass stubs.
+ */
+export interface AttributionPrompts {
+	/** Free-text prompt returning the entered string (or a cancel symbol). */
+	text(opts: {
+		message: string;
+		initialValue?: string;
+		placeholder?: string;
+	}): Promise<unknown>;
+	/** Single-select prompt returning the chosen value (or a cancel symbol). */
+	select<T>(opts: {
+		message: string;
+		options: { value: T; label: string; hint?: string }[];
+		initialValue?: T;
+	}): Promise<unknown>;
+	/** Cancellation guard — exits the flow if the value is a cancel symbol. */
+	handleCancel(value: unknown): void;
+}
+
+const RELATIONSHIP_HINTS: Record<UpstreamWork["relationship"], string> = {
+	verbatim: "vendored unchanged; the body is upstream's",
+	adapted: "materially edited from upstream",
+	"inspired-by": "original expression here; only the idea is upstream's",
+	packaged: "repackaged/reformatted; authorship unchanged",
+};
+
+/**
+ * Confirm a derived attribution draft and elicit the one non-derivable field,
+ * `relationship`. Returns the finalized record, or `undefined` when skipped.
+ *
+ * In `interactive` mode the curator may correct the derived `work`, `authors`
+ * (comma-separated), and `curated-by`, then must pick a `relationship`. In
+ * `defaults` mode the draft is returned unchanged. Only the FIRST upstream work
+ * is prompted; multi-upstream cases (rare at import time) are hand-completed or
+ * come from the backfill's body-banner scan.
+ */
+export async function runAttributionWizard(
+	draft: AttributionRecord,
+	opts: { mode: AttributionWizardMode; prompts?: AttributionPrompts },
+): Promise<AttributionRecord | undefined> {
+	if (opts.mode === "skip") return undefined;
+	if (opts.mode === "defaults") return draft;
+
+	const prompts = opts.prompts;
+	if (!prompts) {
+		// No prompt bindings available (non-TTY): behave as defaults.
+		return draft;
+	}
+
+	const [first, ...rest] = draft.upstream;
+
+	const workRaw = await prompts.text({
+		message: "Upstream work title",
+		initialValue: first.work,
+	});
+	prompts.handleCancel(workRaw);
+
+	const authorsRaw = await prompts.text({
+		message: "Upstream author(s), comma-separated",
+		initialValue: first.authors.join(", "),
+	});
+	prompts.handleCancel(authorsRaw);
+
+	const relationshipRaw = await prompts.select<UpstreamWork["relationship"]>({
+		message: "Relationship to the upstream work",
+		initialValue: first.relationship,
+		options: RelationshipSchema.options.map((r) => ({
+			value: r,
+			label: r,
+			hint: RELATIONSHIP_HINTS[r],
+		})),
+	});
+	prompts.handleCancel(relationshipRaw);
+
+	const curatedByRaw = await prompts.text({
+		message: "Curated by (leave blank to omit)",
+		initialValue: draft["curated-by"] ?? "",
+	});
+	prompts.handleCancel(curatedByRaw);
+
+	const authors = String(authorsRaw)
+		.split(",")
+		.map((s) => s.trim())
+		.filter((s) => s.length > 0);
+
+	const confirmedFirst: UpstreamWork = {
+		...first,
+		work: String(workRaw).trim() || first.work,
+		authors,
+		relationship: relationshipRaw as UpstreamWork["relationship"],
+	};
+
+	const result: AttributionRecord = { upstream: [confirmedFirst, ...rest] };
+	const curatedBy = String(curatedByRaw).trim();
+	if (curatedBy) result["curated-by"] = curatedBy;
+	else if (draft["curated-by"]) result["curated-by"] = draft["curated-by"];
+	if (draft.notice) result.notice = draft.notice;
+
+	return result;
+}