@panaversity/ksor 0.0.57 → 0.0.59

package/templates/scaffold/.agents/skills/format-checker/check.mjs

@@ -12672,6 +12672,139 @@ function nearMissOf(baseName) {
 	return null;
 }
 /**
+* The takedown ledger's OTHER baseline: every entry any COMMITTED version of
+* `.ksor/takedowns.yaml` has ever carried.
+*
+* The committed lock is a baseline too, and a good one — it holds each entry's
+* digest, so an entry retargeted in place is caught. What it cannot do is prove
+* that an entry was never deleted, because the lock travels in the SAME change
+* as the ledger: delete the row, recompute `ledger_sha256`, empty
+* `ledger_entries`, and the two agree with each other about a denial that is
+* gone. Only history remembers.
+*
+* The baseline may be INCOMPLETE only if it SAYS so: every version history
+* holds is read, or `entries` comes back null and the caller reports that it
+* could not verify. A version silently skipped would contribute neither
+* digests nor ids while the answer still read "verified"
+* (`git-ledger.integration.test.ts`).
+*
+* This lives in the record module because THREE surfaces need the same answer —
+* `ksor build`, the emitted checker, and the site's stage (decision 19: a
+* surface that refuses must refuse on both surfaces). Plain `git log` / `git
+* show`, so nothing here needs installing.
+*/
+const LEDGER = ".ksor/takedowns.yaml";
+/**
+* `spawnSync` defaults to a 1 MB stdout buffer, and past it the child is KILLED
+* — `status` comes back null, so the query reads as a failure. A ledger with a
+* few thousand entries, or one entry carrying a long reason, clears 1 MB
+* easily, and the version was then dropped from the baseline while the caller
+* was still told history had been verified. The ceiling stays finite on
+* purpose: past it this returns null, which is a state the caller SAYS.
+*/
+const MAX_BUFFER$1 = 67108864;
+/** One git query, read-only. Null on any non-zero exit, including no git at all. */
+function git(root, args) {
+	const r = spawnSync("git", [...args], {
+		cwd: root,
+		encoding: "utf8",
+		maxBuffer: MAX_BUFFER$1
+	});
+	return r.status === 0 ? r.stdout : null;
+}
+function historicLedger(root) {
+	const inside = git(root, ["rev-parse", "--is-inside-work-tree"]);
+	if (inside === null || inside.trim() !== "true") return {
+		repository: false,
+		shallow: false,
+		entries: null,
+		unreadable: null
+	};
+	const shallow = (git(root, ["rev-parse", "--is-shallow-repository"]) ?? "").trim() === "true";
+	const born = git(root, [
+		"rev-parse",
+		"--verify",
+		"--quiet",
+		"HEAD"
+	]) !== null;
+	const entries = shallow ? null : born ? historicEntries(root) : [];
+	return {
+		repository: true,
+		shallow,
+		entries,
+		unreadable: entries !== null ? null : shallow ? "shallow" : "unreadable"
+	};
+}
+/**
+* Every id history has ever recorded, each with the text it carried the FIRST
+* time it was written. A version that parses contributes each entry's digest,
+* so an entry EDITED in place is caught, not only one deleted; a version that
+* no longer parses still contributes its ids, read permissively — the point
+* there is that an id once written never disappears.
+*
+* FIRST, not every: keying this by `id\tdigest` kept one baseline entry per
+* version an id ever had, so a tamper that was COMMITTED and then UNDONE left
+* two digests for one id, the restored entry matched only one of them, and
+* `ksor-ledger-amended` fired for good. The record became permanently
+* unbuildable — by a tamper that had already been put right — and the only
+* escape was rewriting git history, which is not a remedy a refusal may
+* demand (found in review, 2026-08-25).
+*
+* Taking the OLDEST is what makes the guarantee both enforceable and
+* escapable. It still refuses a committed tamper (the baseline is what the
+* entry said when it was written, so committing the edit does not launder
+* it), and the remedy it names — put the entry back — now actually clears
+* it. Taking the NEWEST would have done the opposite on both counts.
+*/
+function historicEntries(root) {
+	const atRoot = `${(git(root, ["rev-parse", "--show-prefix"]) ?? "").trim()}${LEDGER}`;
+	const commits = git(root, [
+		"log",
+		"--full-history",
+		"--topo-order",
+		"--format=%H",
+		"--",
+		LEDGER
+	]);
+	if (commits === null) return null;
+	const seen = /* @__PURE__ */ new Map();
+	for (const sha of commits.split("\n").filter((s) => s !== "")) {
+		const text = git(root, ["show", `${sha}:${atRoot}`]);
+		if (text === null) {
+			const listed = git(root, [
+				"ls-tree",
+				"--full-tree",
+				"--name-only",
+				sha,
+				"--",
+				atRoot
+			]);
+			if (listed !== null && listed.trim() === "") continue;
+			return null;
+		}
+		const where = sha.slice(0, 7);
+		const parsed = parseLedger(text, LEDGER);
+		if (parsed.ok) {
+			for (const entry of parsed.ledger.entries) seen.set(entry.id, {
+				id: entry.id,
+				digest: entryDigest(entry),
+				entry,
+				where
+			});
+			continue;
+		}
+		for (const m of text.matchAll(/^\s*(?:-\s+)?id:\s*["']?([^\s"']+)/gm)) {
+			const id = m[1] ?? "";
+			if (!seen.has(id)) seen.set(id, {
+				id,
+				digest: null,
+				where
+			});
+		}
+	}
+	return [...seen.values()].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+}
+/**
 * The widening rule: a link, a `ksor.superseded_by` pointer or a companion
 * body may reach a target whose audience contains `public` or contains every
 * identifier in the source's — then every reader of the source can read the
@@ -13537,6 +13670,11 @@ function checkAgainstPolicy(concept, policy, refusals) {
 }
 const hex64 = string().regex(/^[0-9a-f]{64}$/, "a sha256 hex digest");
 const viewerList = array(string().min(1));
+const bundleEntry = object({
+	viewer: string().min(1),
+	sha256: hex64,
+	files: number().int().nonnegative()
+}).strict();
 const lockSchema = object({
 	format: literal(1),
 	build_id: string().regex(/^sha256:[0-9a-f]{64}$/),
@@ -13584,7 +13722,8 @@ const lockSchema = object({
 	indexes: array(object({
 		path: string().min(1),
 		sha256: hex64
-	}).strict())
+	}).strict()),
+	bundles: array(bundleEntry)
 }).strict();
 function parseLock(text) {
 	let value;
@@ -13609,139 +13748,6 @@ function parseLock(text) {
 		lock: parsed.data
 	};
 }
-/**
-* The takedown ledger's OTHER baseline: every entry any COMMITTED version of
-* `.ksor/takedowns.yaml` has ever carried.
-*
-* The committed lock is a baseline too, and a good one — it holds each entry's
-* digest, so an entry retargeted in place is caught. What it cannot do is prove
-* that an entry was never deleted, because the lock travels in the SAME change
-* as the ledger: delete the row, recompute `ledger_sha256`, empty
-* `ledger_entries`, and the two agree with each other about a denial that is
-* gone. Only history remembers.
-*
-* The baseline may be INCOMPLETE only if it SAYS so: every version history
-* holds is read, or `entries` comes back null and the caller reports that it
-* could not verify. A version silently skipped would contribute neither
-* digests nor ids while the answer still read "verified"
-* (`git-ledger.integration.test.ts`).
-*
-* This lives in the record module because THREE surfaces need the same answer —
-* `ksor build`, the emitted checker, and the site's stage (decision 19: a
-* surface that refuses must refuse on both surfaces). Plain `git log` / `git
-* show`, so nothing here needs installing.
-*/
-const LEDGER = ".ksor/takedowns.yaml";
-/**
-* `spawnSync` defaults to a 1 MB stdout buffer, and past it the child is KILLED
-* — `status` comes back null, so the query reads as a failure. A ledger with a
-* few thousand entries, or one entry carrying a long reason, clears 1 MB
-* easily, and the version was then dropped from the baseline while the caller
-* was still told history had been verified. The ceiling stays finite on
-* purpose: past it this returns null, which is a state the caller SAYS.
-*/
-const MAX_BUFFER = 67108864;
-/** One git query, read-only. Null on any non-zero exit, including no git at all. */
-function git(root, args) {
-	const r = spawnSync("git", [...args], {
-		cwd: root,
-		encoding: "utf8",
-		maxBuffer: MAX_BUFFER
-	});
-	return r.status === 0 ? r.stdout : null;
-}
-function historicLedger(root) {
-	const inside = git(root, ["rev-parse", "--is-inside-work-tree"]);
-	if (inside === null || inside.trim() !== "true") return {
-		repository: false,
-		shallow: false,
-		entries: null,
-		unreadable: null
-	};
-	const shallow = (git(root, ["rev-parse", "--is-shallow-repository"]) ?? "").trim() === "true";
-	const born = git(root, [
-		"rev-parse",
-		"--verify",
-		"--quiet",
-		"HEAD"
-	]) !== null;
-	const entries = shallow ? null : born ? historicEntries(root) : [];
-	return {
-		repository: true,
-		shallow,
-		entries,
-		unreadable: entries !== null ? null : shallow ? "shallow" : "unreadable"
-	};
-}
-/**
-* Every id history has ever recorded, each with the text it carried the FIRST
-* time it was written. A version that parses contributes each entry's digest,
-* so an entry EDITED in place is caught, not only one deleted; a version that
-* no longer parses still contributes its ids, read permissively — the point
-* there is that an id once written never disappears.
-*
-* FIRST, not every: keying this by `id\tdigest` kept one baseline entry per
-* version an id ever had, so a tamper that was COMMITTED and then UNDONE left
-* two digests for one id, the restored entry matched only one of them, and
-* `ksor-ledger-amended` fired for good. The record became permanently
-* unbuildable — by a tamper that had already been put right — and the only
-* escape was rewriting git history, which is not a remedy a refusal may
-* demand (found in review, 2026-08-25).
-*
-* Taking the OLDEST is what makes the guarantee both enforceable and
-* escapable. It still refuses a committed tamper (the baseline is what the
-* entry said when it was written, so committing the edit does not launder
-* it), and the remedy it names — put the entry back — now actually clears
-* it. Taking the NEWEST would have done the opposite on both counts.
-*/
-function historicEntries(root) {
-	const atRoot = `${(git(root, ["rev-parse", "--show-prefix"]) ?? "").trim()}${LEDGER}`;
-	const commits = git(root, [
-		"log",
-		"--full-history",
-		"--topo-order",
-		"--format=%H",
-		"--",
-		LEDGER
-	]);
-	if (commits === null) return null;
-	const seen = /* @__PURE__ */ new Map();
-	for (const sha of commits.split("\n").filter((s) => s !== "")) {
-		const text = git(root, ["show", `${sha}:${atRoot}`]);
-		if (text === null) {
-			const listed = git(root, [
-				"ls-tree",
-				"--full-tree",
-				"--name-only",
-				sha,
-				"--",
-				atRoot
-			]);
-			if (listed !== null && listed.trim() === "") continue;
-			return null;
-		}
-		const where = sha.slice(0, 7);
-		const parsed = parseLedger(text, LEDGER);
-		if (parsed.ok) {
-			for (const entry of parsed.ledger.entries) seen.set(entry.id, {
-				id: entry.id,
-				digest: entryDigest(entry),
-				entry,
-				where
-			});
-			continue;
-		}
-		for (const m of text.matchAll(/^\s*(?:-\s+)?id:\s*["']?([^\s"']+)/gm)) {
-			const id = m[1] ?? "";
-			if (!seen.has(id)) seen.set(id, {
-				id,
-				digest: null,
-				where
-			});
-		}
-	}
-	return [...seen.values()].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
-}
 /** The inputs a projection reads; nothing else moves `source_commit` (the lock itself included). */
 const INPUTS = [
 	"knowledge",

package/templates/scaffold/.agents/skills/intake-interview/SKILL.md

@@ -146,11 +146,12 @@ never an email address.
   MAP from each actor to its natural name — `"human:bashiraziz": Bashir Aziz`.
   Keyed by the actor exactly as the record stores it, quoted because it
   contains a colon. Nothing else — the site looks the actor up at render time,
-  so pages read "Owner · Bashir Aziz" instead of "Owner · human:bashiraziz". Every skill that records a governance
-  act (this one, add-sources when it names a `ksor.owner`, `ksor takedown` for
-  withdrawals) asks the owner for a natural name whenever it is about to write
-  an actor that isn't in `people.yaml` yet — the owner is the only source of a
-  display name, never a convention-based guess.
+  so pages read "Owner · Bashir Aziz" instead of "Owner · human:bashiraziz". This
+  is the skill that writes actors into the policy, so it is the one that asks
+  the owner for a natural name for each — the owner is the only source of a
+  display name, never a convention-based guess. An actor that arrives later
+  (an owner named in a document, an approver added by hand) gets its entry
+  when the owner adds one; the site prints the identifier until then.
 - **Offer to start replacing the starter documents — they are already
   published.** All five ship `status: stable`, approved by
   `ksor-starter/KSOR-STAMP-VERSION`, so the site and `llms.txt` carry them from

package/templates/scaffold/.claude/skills/format-checker/check.mjs

@@ -12672,6 +12672,139 @@ function nearMissOf(baseName) {
 	return null;
 }
 /**
+* The takedown ledger's OTHER baseline: every entry any COMMITTED version of
+* `.ksor/takedowns.yaml` has ever carried.
+*
+* The committed lock is a baseline too, and a good one — it holds each entry's
+* digest, so an entry retargeted in place is caught. What it cannot do is prove
+* that an entry was never deleted, because the lock travels in the SAME change
+* as the ledger: delete the row, recompute `ledger_sha256`, empty
+* `ledger_entries`, and the two agree with each other about a denial that is
+* gone. Only history remembers.
+*
+* The baseline may be INCOMPLETE only if it SAYS so: every version history
+* holds is read, or `entries` comes back null and the caller reports that it
+* could not verify. A version silently skipped would contribute neither
+* digests nor ids while the answer still read "verified"
+* (`git-ledger.integration.test.ts`).
+*
+* This lives in the record module because THREE surfaces need the same answer —
+* `ksor build`, the emitted checker, and the site's stage (decision 19: a
+* surface that refuses must refuse on both surfaces). Plain `git log` / `git
+* show`, so nothing here needs installing.
+*/
+const LEDGER = ".ksor/takedowns.yaml";
+/**
+* `spawnSync` defaults to a 1 MB stdout buffer, and past it the child is KILLED
+* — `status` comes back null, so the query reads as a failure. A ledger with a
+* few thousand entries, or one entry carrying a long reason, clears 1 MB
+* easily, and the version was then dropped from the baseline while the caller
+* was still told history had been verified. The ceiling stays finite on
+* purpose: past it this returns null, which is a state the caller SAYS.
+*/
+const MAX_BUFFER$1 = 67108864;
+/** One git query, read-only. Null on any non-zero exit, including no git at all. */
+function git(root, args) {
+	const r = spawnSync("git", [...args], {
+		cwd: root,
+		encoding: "utf8",
+		maxBuffer: MAX_BUFFER$1
+	});
+	return r.status === 0 ? r.stdout : null;
+}
+function historicLedger(root) {
+	const inside = git(root, ["rev-parse", "--is-inside-work-tree"]);
+	if (inside === null || inside.trim() !== "true") return {
+		repository: false,
+		shallow: false,
+		entries: null,
+		unreadable: null
+	};
+	const shallow = (git(root, ["rev-parse", "--is-shallow-repository"]) ?? "").trim() === "true";
+	const born = git(root, [
+		"rev-parse",
+		"--verify",
+		"--quiet",
+		"HEAD"
+	]) !== null;
+	const entries = shallow ? null : born ? historicEntries(root) : [];
+	return {
+		repository: true,
+		shallow,
+		entries,
+		unreadable: entries !== null ? null : shallow ? "shallow" : "unreadable"
+	};
+}
+/**
+* Every id history has ever recorded, each with the text it carried the FIRST
+* time it was written. A version that parses contributes each entry's digest,
+* so an entry EDITED in place is caught, not only one deleted; a version that
+* no longer parses still contributes its ids, read permissively — the point
+* there is that an id once written never disappears.
+*
+* FIRST, not every: keying this by `id\tdigest` kept one baseline entry per
+* version an id ever had, so a tamper that was COMMITTED and then UNDONE left
+* two digests for one id, the restored entry matched only one of them, and
+* `ksor-ledger-amended` fired for good. The record became permanently
+* unbuildable — by a tamper that had already been put right — and the only
+* escape was rewriting git history, which is not a remedy a refusal may
+* demand (found in review, 2026-08-25).
+*
+* Taking the OLDEST is what makes the guarantee both enforceable and
+* escapable. It still refuses a committed tamper (the baseline is what the
+* entry said when it was written, so committing the edit does not launder
+* it), and the remedy it names — put the entry back — now actually clears
+* it. Taking the NEWEST would have done the opposite on both counts.
+*/
+function historicEntries(root) {
+	const atRoot = `${(git(root, ["rev-parse", "--show-prefix"]) ?? "").trim()}${LEDGER}`;
+	const commits = git(root, [
+		"log",
+		"--full-history",
+		"--topo-order",
+		"--format=%H",
+		"--",
+		LEDGER
+	]);
+	if (commits === null) return null;
+	const seen = /* @__PURE__ */ new Map();
+	for (const sha of commits.split("\n").filter((s) => s !== "")) {
+		const text = git(root, ["show", `${sha}:${atRoot}`]);
+		if (text === null) {
+			const listed = git(root, [
+				"ls-tree",
+				"--full-tree",
+				"--name-only",
+				sha,
+				"--",
+				atRoot
+			]);
+			if (listed !== null && listed.trim() === "") continue;
+			return null;
+		}
+		const where = sha.slice(0, 7);
+		const parsed = parseLedger(text, LEDGER);
+		if (parsed.ok) {
+			for (const entry of parsed.ledger.entries) seen.set(entry.id, {
+				id: entry.id,
+				digest: entryDigest(entry),
+				entry,
+				where
+			});
+			continue;
+		}
+		for (const m of text.matchAll(/^\s*(?:-\s+)?id:\s*["']?([^\s"']+)/gm)) {
+			const id = m[1] ?? "";
+			if (!seen.has(id)) seen.set(id, {
+				id,
+				digest: null,
+				where
+			});
+		}
+	}
+	return [...seen.values()].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+}
+/**
 * The widening rule: a link, a `ksor.superseded_by` pointer or a companion
 * body may reach a target whose audience contains `public` or contains every
 * identifier in the source's — then every reader of the source can read the
@@ -13537,6 +13670,11 @@ function checkAgainstPolicy(concept, policy, refusals) {
 }
 const hex64 = string().regex(/^[0-9a-f]{64}$/, "a sha256 hex digest");
 const viewerList = array(string().min(1));
+const bundleEntry = object({
+	viewer: string().min(1),
+	sha256: hex64,
+	files: number().int().nonnegative()
+}).strict();
 const lockSchema = object({
 	format: literal(1),
 	build_id: string().regex(/^sha256:[0-9a-f]{64}$/),
@@ -13584,7 +13722,8 @@ const lockSchema = object({
 	indexes: array(object({
 		path: string().min(1),
 		sha256: hex64
-	}).strict())
+	}).strict()),
+	bundles: array(bundleEntry)
 }).strict();
 function parseLock(text) {
 	let value;
@@ -13609,139 +13748,6 @@ function parseLock(text) {
 		lock: parsed.data
 	};
 }
-/**
-* The takedown ledger's OTHER baseline: every entry any COMMITTED version of
-* `.ksor/takedowns.yaml` has ever carried.
-*
-* The committed lock is a baseline too, and a good one — it holds each entry's
-* digest, so an entry retargeted in place is caught. What it cannot do is prove
-* that an entry was never deleted, because the lock travels in the SAME change
-* as the ledger: delete the row, recompute `ledger_sha256`, empty
-* `ledger_entries`, and the two agree with each other about a denial that is
-* gone. Only history remembers.
-*
-* The baseline may be INCOMPLETE only if it SAYS so: every version history
-* holds is read, or `entries` comes back null and the caller reports that it
-* could not verify. A version silently skipped would contribute neither
-* digests nor ids while the answer still read "verified"
-* (`git-ledger.integration.test.ts`).
-*
-* This lives in the record module because THREE surfaces need the same answer —
-* `ksor build`, the emitted checker, and the site's stage (decision 19: a
-* surface that refuses must refuse on both surfaces). Plain `git log` / `git
-* show`, so nothing here needs installing.
-*/
-const LEDGER = ".ksor/takedowns.yaml";
-/**
-* `spawnSync` defaults to a 1 MB stdout buffer, and past it the child is KILLED
-* — `status` comes back null, so the query reads as a failure. A ledger with a
-* few thousand entries, or one entry carrying a long reason, clears 1 MB
-* easily, and the version was then dropped from the baseline while the caller
-* was still told history had been verified. The ceiling stays finite on
-* purpose: past it this returns null, which is a state the caller SAYS.
-*/
-const MAX_BUFFER = 67108864;
-/** One git query, read-only. Null on any non-zero exit, including no git at all. */
-function git(root, args) {
-	const r = spawnSync("git", [...args], {
-		cwd: root,
-		encoding: "utf8",
-		maxBuffer: MAX_BUFFER
-	});
-	return r.status === 0 ? r.stdout : null;
-}
-function historicLedger(root) {
-	const inside = git(root, ["rev-parse", "--is-inside-work-tree"]);
-	if (inside === null || inside.trim() !== "true") return {
-		repository: false,
-		shallow: false,
-		entries: null,
-		unreadable: null
-	};
-	const shallow = (git(root, ["rev-parse", "--is-shallow-repository"]) ?? "").trim() === "true";
-	const born = git(root, [
-		"rev-parse",
-		"--verify",
-		"--quiet",
-		"HEAD"
-	]) !== null;
-	const entries = shallow ? null : born ? historicEntries(root) : [];
-	return {
-		repository: true,
-		shallow,
-		entries,
-		unreadable: entries !== null ? null : shallow ? "shallow" : "unreadable"
-	};
-}
-/**
-* Every id history has ever recorded, each with the text it carried the FIRST
-* time it was written. A version that parses contributes each entry's digest,
-* so an entry EDITED in place is caught, not only one deleted; a version that
-* no longer parses still contributes its ids, read permissively — the point
-* there is that an id once written never disappears.
-*
-* FIRST, not every: keying this by `id\tdigest` kept one baseline entry per
-* version an id ever had, so a tamper that was COMMITTED and then UNDONE left
-* two digests for one id, the restored entry matched only one of them, and
-* `ksor-ledger-amended` fired for good. The record became permanently
-* unbuildable — by a tamper that had already been put right — and the only
-* escape was rewriting git history, which is not a remedy a refusal may
-* demand (found in review, 2026-08-25).
-*
-* Taking the OLDEST is what makes the guarantee both enforceable and
-* escapable. It still refuses a committed tamper (the baseline is what the
-* entry said when it was written, so committing the edit does not launder
-* it), and the remedy it names — put the entry back — now actually clears
-* it. Taking the NEWEST would have done the opposite on both counts.
-*/
-function historicEntries(root) {
-	const atRoot = `${(git(root, ["rev-parse", "--show-prefix"]) ?? "").trim()}${LEDGER}`;
-	const commits = git(root, [
-		"log",
-		"--full-history",
-		"--topo-order",
-		"--format=%H",
-		"--",
-		LEDGER
-	]);
-	if (commits === null) return null;
-	const seen = /* @__PURE__ */ new Map();
-	for (const sha of commits.split("\n").filter((s) => s !== "")) {
-		const text = git(root, ["show", `${sha}:${atRoot}`]);
-		if (text === null) {
-			const listed = git(root, [
-				"ls-tree",
-				"--full-tree",
-				"--name-only",
-				sha,
-				"--",
-				atRoot
-			]);
-			if (listed !== null && listed.trim() === "") continue;
-			return null;
-		}
-		const where = sha.slice(0, 7);
-		const parsed = parseLedger(text, LEDGER);
-		if (parsed.ok) {
-			for (const entry of parsed.ledger.entries) seen.set(entry.id, {
-				id: entry.id,
-				digest: entryDigest(entry),
-				entry,
-				where
-			});
-			continue;
-		}
-		for (const m of text.matchAll(/^\s*(?:-\s+)?id:\s*["']?([^\s"']+)/gm)) {
-			const id = m[1] ?? "";
-			if (!seen.has(id)) seen.set(id, {
-				id,
-				digest: null,
-				where
-			});
-		}
-	}
-	return [...seen.values()].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
-}
 /** The inputs a projection reads; nothing else moves `source_commit` (the lock itself included). */
 const INPUTS = [
 	"knowledge",

package/templates/scaffold/.claude/skills/intake-interview/SKILL.md

@@ -146,11 +146,12 @@ never an email address.
   MAP from each actor to its natural name — `"human:bashiraziz": Bashir Aziz`.
   Keyed by the actor exactly as the record stores it, quoted because it
   contains a colon. Nothing else — the site looks the actor up at render time,
-  so pages read "Owner · Bashir Aziz" instead of "Owner · human:bashiraziz". Every skill that records a governance
-  act (this one, add-sources when it names a `ksor.owner`, `ksor takedown` for
-  withdrawals) asks the owner for a natural name whenever it is about to write
-  an actor that isn't in `people.yaml` yet — the owner is the only source of a
-  display name, never a convention-based guess.
+  so pages read "Owner · Bashir Aziz" instead of "Owner · human:bashiraziz". This
+  is the skill that writes actors into the policy, so it is the one that asks
+  the owner for a natural name for each — the owner is the only source of a
+  display name, never a convention-based guess. An actor that arrives later
+  (an owner named in a document, an approver added by hand) gets its entry
+  when the owner adds one; the site prints the identifier until then.
 - **Offer to start replacing the starter documents — they are already
   published.** All five ship `status: stable`, approved by
   `ksor-starter/KSOR-STAMP-VERSION`, so the site and `llms.txt` carry them from

package/templates/scaffold/.ksor/people.yaml

@@ -26,7 +26,7 @@
 # name has to keep rendering on those acts.
 #
 # Optional. An actor with no entry renders exactly as stored, as it did before
-# this file existed. The intake and add-sources skills offer to add one; the
-# owner can also edit this file by hand — it is theirs.
+# this file existed. The intake interview offers to add one; the owner can
+# also edit this file by hand — it is theirs.
 version: "0.1"
 people: {}