pi-posthorse 0.10.2 → 0.10.4

package/src/note-inventory.ts

@@ -0,0 +1,111 @@
+import { readdir, realpath, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { isRecord } from "./contracts.ts";
+import {
+	canonicalPath,
+	inside,
+	notePath,
+	scopeDirectory,
+	type NoteIdentity,
+	type NoteScope,
+} from "./note-scopes.ts";
+import { fileIdentity } from "./note-snapshots.ts";
+
+export type NoteFile = NoteIdentity & { readonly path: string };
+/** Maximum overlapped stats; 16, 64 and 256 were equivalent on the measured 212,751-note tree. */
+const WALK_BATCH = 64;
+async function statIfPresent(path: string) {
+	try {
+		return await stat(path);
+	} catch (error) {
+		if (isRecord(error) && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
+			return;
+		}
+		throw error;
+	}
+}
+/** Preserve depth-first listing order and recheck later entries after visiting each folder. */
+async function* folderEntries(directory: string, signal: AbortSignal | undefined) {
+	const entries = await readdir(directory, { withFileTypes: true });
+	let start = 0;
+	while (start < entries.length) {
+		signal?.throwIfAborted();
+		const batch = entries.slice(start, start + WALK_BATCH);
+		const firstFolder = batch.findIndex(
+			(entry) => entry.isDirectory() || entry.isSymbolicLink(),
+		);
+		const paths = batch
+			.slice(0, firstFolder === -1 ? batch.length : firstFolder + 1)
+			.map((entry) => join(directory, entry.name));
+		const infos = await Promise.all(paths.map(statIfPresent));
+		for (const [index, path] of paths.entries()) {
+			start += 1;
+			const info = infos[index];
+			if (info !== undefined) {
+				yield { path, info, alias: batch[index]?.isSymbolicLink() === true };
+			}
+			if (info?.isDirectory() === true) {
+				break;
+			}
+		}
+	}
+}
+type WalkState = {
+	readonly ancestors: readonly string[];
+	readonly scope: NoteScope;
+	readonly notice: (text: string) => void;
+};
+function allowedTarget(path: string, state: WalkState): boolean {
+	const scopeRoot = canonicalPath(scopeDirectory(state.scope));
+	if (state.scope.scope === "") {
+		return !inside(canonicalPath(join(state.scope.root, ".forks")), path);
+	}
+	if (inside(scopeRoot, path)) {
+		return true;
+	}
+	state.notice(`Not indexed: alias outside private notes scope (${path}).`);
+	return false;
+}
+async function walk(
+	directory: string,
+	signal: AbortSignal | undefined,
+	state: WalkState,
+): Promise<NoteFile[]> {
+	signal?.throwIfAborted();
+	const root = await realpath(directory);
+	if (state.ancestors.includes(root) || !allowedTarget(root, state)) {
+		return [];
+	}
+	const next: WalkState = { ...state, ancestors: [...state.ancestors, root] };
+	const files: NoteFile[] = [];
+	for await (const { path, info, alias } of folderEntries(directory, signal)) {
+		if (info.isDirectory()) {
+			for (const file of await walk(path, signal, next)) {
+				files.push(file);
+			}
+		} else if (!alias || allowedTarget(canonicalPath(path), state)) {
+			files.push({ path, ...fileIdentity(info) });
+		}
+	}
+	return files;
+}
+export async function notesUnder(
+	scope: NoteScope,
+	folder: string | undefined,
+	options: { readonly signal: AbortSignal | undefined; readonly notice: (text: string) => void },
+): Promise<NoteFile[]> {
+	const target =
+		folder === undefined || folder === "" || folder === "."
+			? scopeDirectory(scope)
+			: notePath(scope, folder);
+	const info = await statIfPresent(target);
+	options.signal?.throwIfAborted();
+	if (info === undefined) {
+		return [];
+	}
+	const files = info.isDirectory()
+		? await walk(target, options.signal, { scope, ancestors: [], notice: options.notice })
+		: [{ path: target, ...fileIdentity(info) }];
+	options.signal?.throwIfAborted();
+	return files.sort((a, b) => b.mtimeMs - a.mtimeMs);
+}

package/src/note-provenance.ts

@@ -0,0 +1,299 @@
+import { existsSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { isRecord, type EntryLike } from "./contracts.ts";
+import { sessionLines } from "./session-lines.ts";
+import { parseSessionLine } from "./session-files.ts";
+import { sessionNoteTouches } from "./note-evidence.ts";
+import { readManifest, snapshot, type SnapshotNote } from "./note-snapshots.ts";
+import {
+	addressOf,
+	bindingsOf,
+	canonicalPath,
+	forkScope,
+	notePath,
+	sameOwner,
+	sameScope,
+	scopeDirectory,
+	ownedPaths,
+	seedsOf,
+	type ForkBinding,
+	type NoteAddress,
+	type NoteBinding,
+	type NoteScope,
+} from "./note-scopes.ts";
+
+type NotesManager = ExtensionContext["sessionManager"];
+export type NoteSource = {
+	readonly entries: readonly EntryLike[];
+	readonly file: string | undefined;
+};
+type Candidate = SnapshotNote & { readonly cleared: boolean };
+function includedJournalType(type: string | undefined, legacy: boolean): boolean {
+	return legacy || type === undefined || type === "session" || type === "custom";
+}
+async function journalMetadata(
+	file: string,
+	legacy: boolean,
+	signal?: AbortSignal,
+): Promise<readonly EntryLike[]> {
+	const entries: EntryLike[] = [];
+	try {
+		for await (const line of sessionLines(file, signal)) {
+			const type = /^\s*\{\s*"type"\s*:\s*"([^"]+)"/u.exec(line.head)?.[1];
+			if (!includedJournalType(type, legacy)) {
+				continue;
+			}
+			const entry = parseSessionLine(await line.text());
+			if (entry !== undefined && includedJournalType(entry.type, legacy)) {
+				entries.push(entry);
+			}
+		}
+	} catch (error) {
+		if (!isRecord(error) || error.code !== "ENOENT") {
+			throw error;
+		}
+	}
+	return entries;
+}
+/** Read only; opening a SessionManager here could migrate or create an archived source. */
+export async function sourceEntries(
+	file: string | undefined,
+	signal?: AbortSignal,
+): Promise<readonly EntryLike[]> {
+	let current = file;
+	const seen = new Set<string>();
+	const entries: EntryLike[] = [];
+	while (current !== undefined && !seen.has(current)) {
+		seen.add(current);
+		// Each ancestor's current ownership prevents falling through a deleted owned file.
+		const metadata = await journalMetadata(current, false, signal);
+		entries.push(...metadata);
+		current = metadata.find((entry) => entry.type === "session")?.parentSession;
+	}
+	return entries;
+}
+function legacySource(entries: readonly EntryLike[]): NoteScope | undefined {
+	const { touches, defaultDir } = sessionNoteTouches({
+		branch: entries,
+		allEntries: entries,
+		projected: [],
+		retained: new Set(),
+	});
+	const roots = new Set(defaultDir === undefined ? [] : [defaultDir]);
+	for (const touch of touches) {
+		if (touch.absPath !== undefined && touch.absPath.endsWith(`/${touch.notePath}`)) {
+			roots.add(touch.absPath.slice(0, -touch.notePath.length - 1));
+		}
+	}
+	if ([...roots].some((root) => !isAbsolute(root))) {
+		return;
+	}
+	const canonical = new Set([...roots].map(canonicalPath));
+	const [root] = canonical;
+	return canonical.size === 1 && root !== undefined ? { root, scope: "" } : undefined;
+}
+async function sourceScope(
+	manager: NotesManager,
+	source: NoteSource,
+): Promise<NoteScope | undefined> {
+	const header = source.entries.find((entry) => entry.type === "session");
+	const bindings = bindingsOf([...manager.getEntries(), ...source.entries]);
+	const binding =
+		header?.id === undefined || header.timestamp === undefined
+			? bindings.at(-1)
+			: bindings.findLast(
+					(candidate) =>
+						candidate.owner.id === header.id &&
+						candidate.owner.timestamp === header.timestamp,
+				);
+	if (binding !== undefined) {
+		return binding;
+	}
+	const legacy =
+		source.file === undefined ? manager.getEntries() : await journalMetadata(source.file, true);
+	return legacySource(legacy.length > 0 ? legacy : manager.getEntries());
+}
+export async function resolveReference(
+	scope: NoteScope,
+	path: string,
+	entries: readonly EntryLike[],
+): Promise<NoteAddress | undefined> {
+	let source: NoteScope | null = scope;
+	const bindings = bindingsOf(entries);
+	const visited = new Set<string>();
+	while (source !== null) {
+		const current: NoteScope = source;
+		const directory = scopeDirectory(current);
+		if (visited.has(directory)) {
+			throw new Error(`Cyclic note provenance at ${directory}.`);
+		}
+		visited.add(directory);
+		if (existsSync(notePath(current, path))) {
+			return { ...current, path };
+		}
+		// A manifest includes later adoptions; the journal includes later writes and deletions.
+		const binding: NoteBinding | undefined =
+			(await readManifest(directory)) ??
+			bindings.findLast((candidate) => sameScope(candidate, current));
+		if (
+			binding === undefined ||
+			binding.kind === "project" ||
+			ownedPaths(binding, entries).has(path)
+		) {
+			return;
+		}
+		source = binding.source;
+	}
+	return;
+}
+function touchedCandidates(
+	evidence: ReturnType<typeof sessionNoteTouches>,
+	scopes: readonly NoteScope[],
+	allEntries: readonly EntryLike[],
+): Map<string, Candidate> {
+	const bindings = bindingsOf(allEntries);
+	const selected = new Map<string, Candidate>();
+	for (const touch of evidence.touches) {
+		const absolute =
+			touch.absPath ??
+			(evidence.defaultDir === undefined
+				? undefined
+				: join(evidence.defaultDir, touch.notePath));
+		const address = absolute === undefined ? undefined : addressOf(absolute, scopes);
+		if (address === undefined) {
+			continue;
+		}
+		const owner = bindings.findLast((binding) => sameScope(binding, address));
+		const lineage =
+			owner === undefined
+				? address
+				: (seedsOf(owner, allEntries).find((seed) => seed.path === address.path)?.lineage ??
+					address);
+		selected.set(address.path, {
+			path: address.path,
+			source: address,
+			lineage,
+			anchors: [touch.receiptId ?? touch.entryId],
+			cleared: touch.kind === "clear",
+		});
+	}
+	return selected;
+}
+function seedCandidates(
+	manager: NotesManager,
+	source: NoteSource,
+	scope: NoteScope | undefined,
+): Candidate[] {
+	const allEntries = [...manager.getEntries(), ...source.entries];
+	const bindings = bindingsOf(allEntries);
+	const scopes = scope === undefined ? bindings : [...bindings, scope];
+	const evidence = sessionNoteTouches({
+		branch: manager.getBranch(),
+		allEntries,
+		projected: manager.buildSessionProjection().entries,
+		retained: new Set(),
+		directories: new Set(scopes.map(scopeDirectory)),
+	});
+	if (scope === undefined && evidence.touches.length > 0) {
+		throw new Error(
+			"Incomplete notes snapshot: the source notes root is missing or ambiguous.",
+		);
+	}
+	const selected = touchedCandidates(evidence, scopes, allEntries);
+	for (const binding of bindings) {
+		for (const seed of seedsOf(binding, allEntries)) {
+			if (
+				!selected.has(seed.path) &&
+				seed.anchors.some((id) => evidence.visibleIds.has(id))
+			) {
+				selected.set(seed.path, {
+					...seed,
+					source: { root: binding.root, scope: binding.scope, path: seed.path },
+					cleared: false,
+				});
+			}
+		}
+	}
+	return [...selected.values()];
+}
+async function forkBinding(
+	manager: NotesManager,
+	binding: ForkBinding,
+	source: NoteSource,
+): Promise<ForkBinding> {
+	const scope = await sourceScope(manager, source);
+	const candidates = seedCandidates(manager, source, scope);
+	const entries = [...manager.getEntries(), ...source.entries];
+	const files: SnapshotNote[] = [];
+	const absent: string[] = [];
+	for (const candidate of candidates) {
+		// Resolve against the immediate parent's files, not a historical ancestor's version.
+		const address = await resolveReference(scope ?? candidate.source, candidate.path, entries);
+		if (address !== undefined) {
+			files.push({
+				path: candidate.path,
+				source: address,
+				lineage: candidate.lineage,
+				anchors: candidate.anchors,
+			});
+		} else if (candidate.cleared) {
+			absent.push(candidate.path);
+		} else {
+			throw new Error(
+				`Incomplete notes snapshot: source note ${candidate.path} is unavailable.`,
+			);
+		}
+	}
+	return snapshot(
+		{
+			...binding,
+			source: scope === undefined ? null : { root: scope.root, scope: scope.scope },
+			absent,
+		},
+		files,
+	);
+}
+export async function loadNotesBinding(
+	manager: NotesManager,
+	root: string,
+): Promise<{
+	readonly binding: NoteBinding;
+	readonly source: NoteSource;
+	readonly created: boolean;
+}> {
+	const header = manager.getHeader();
+	if (header === null) {
+		throw new Error("Pi did not supply the session header for notes ownership.");
+	}
+	const owner = { id: header.id, timestamp: header.timestamp };
+	const own = bindingsOf(manager.getEntries()).findLast((binding) =>
+		sameOwner(binding.owner, owner),
+	);
+	const source: NoteSource = {
+		entries: await sourceEntries(header.parentSession),
+		file: header.parentSession,
+	};
+	if (own !== undefined) {
+		return { binding: own, source, created: false };
+	}
+	const inherited = bindingsOf([...manager.getEntries(), ...source.entries]);
+	const fork = header.parentSession !== undefined || inherited.length > 0;
+	const binding: NoteBinding = fork
+		? await forkBinding(
+				manager,
+				{
+					version: 1,
+					kind: "fork",
+					owner,
+					root,
+					scope: forkScope(owner),
+					source: null,
+					seeds: [],
+					absent: [],
+				},
+				source,
+			)
+		: { version: 1, kind: "project", owner, root, scope: "" };
+	return { binding, source, created: true };
+}

package/src/note-scopes.ts

@@ -0,0 +1,293 @@
+import { realpathSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { Type, type Static } from "typebox";
+import { Check } from "typebox/value";
+import { isRecord, type EntryLike } from "./contracts.ts";
+
+export const NOTES_BINDING = "posthorse-notes-scope";
+export const NOTES_TOUCH = "posthorse-note-touch";
+const ownerSchema = Type.Object({ id: Type.String(), timestamp: Type.String() });
+const scopeSchema = Type.Object({ root: Type.String(), scope: Type.String() });
+const addressSchema = Type.Object({ ...scopeSchema.properties, path: Type.String() });
+const identitySchema = Type.Object({
+	size: Type.Number(),
+	mtimeMs: Type.Number(),
+	ctimeMs: Type.Number(),
+	ino: Type.Number(),
+	dev: Type.Number(),
+});
+const seedSchema = Type.Object({
+	path: Type.String(),
+	source: addressSchema,
+	lineage: addressSchema,
+	digest: Type.String(),
+	identity: identitySchema,
+	anchors: Type.Array(Type.String()),
+});
+const sharedBinding = {
+	version: Type.Literal(1),
+	owner: ownerSchema,
+	root: Type.String(),
+};
+const bindingSchema = Type.Union([
+	Type.Object({ ...sharedBinding, kind: Type.Literal("project"), scope: Type.Literal("") }),
+	Type.Object({
+		...sharedBinding,
+		kind: Type.Literal("fork"),
+		scope: Type.String(),
+		source: Type.Union([scopeSchema, Type.Null()]),
+		seeds: Type.Array(seedSchema),
+		absent: Type.Array(Type.String()),
+	}),
+]);
+const touchSchema = Type.Object({
+	version: Type.Literal(1),
+	owner: ownerSchema,
+	scope: scopeSchema,
+	rootToolCallId: Type.String(),
+	toolCallId: Type.String(),
+	files: Type.Array(
+		Type.Object({
+			...addressSchema.properties,
+			seed: Type.Optional(seedSchema),
+			kind: Type.Union([
+				Type.Literal("read"),
+				Type.Literal("write"),
+				Type.Literal("clear"),
+				Type.Literal("delete"),
+				Type.Literal("adopt"),
+			]),
+		}),
+	),
+});
+type Immutable<T> = T extends readonly (infer Item)[]
+	? readonly Immutable<Item>[]
+	: T extends object
+		? { readonly [Key in keyof T]: Immutable<T[Key]> }
+		: T;
+export type NoteOwner = Immutable<Static<typeof ownerSchema>>;
+export type NoteScope = Immutable<Static<typeof scopeSchema>>;
+export type NoteAddress = Immutable<Static<typeof addressSchema>>;
+export type NoteIdentity = Immutable<Static<typeof identitySchema>>;
+export type NoteSeed = Immutable<Static<typeof seedSchema>>;
+export type NoteBinding = Immutable<Static<typeof bindingSchema>>;
+export type NoteTouchRecord = Immutable<Static<typeof touchSchema>>;
+export type ForkBinding = Extract<NoteBinding, { readonly kind: "fork" }>;
+
+export function sameOwner(left: NoteOwner, right: NoteOwner): boolean {
+	return left.id === right.id && left.timestamp === right.timestamp;
+}
+export function forkScope(owner: NoteOwner): string {
+	return `.forks/${new Date(owner.timestamp).toISOString().replace(/[:.]/gu, "-")}_${encodeURIComponent(owner.id)}/notes`;
+}
+export function scopeDirectory(scope: NoteScope): string {
+	return join(scope.root, scope.scope);
+}
+export function sameScope(left: NoteScope, right: NoteScope): boolean {
+	return left.root === right.root && left.scope === right.scope;
+}
+export function inside(directory: string, path: string): boolean {
+	const part = relative(directory, path);
+	return part === "" || (part !== ".." && !part.startsWith(`..${sep}`) && !isAbsolute(part));
+}
+export function noteRelative(path: string): string {
+	if (path === "" || isAbsolute(path) || path.includes("\0")) {
+		throw new Error(`Invalid note path ${JSON.stringify(path)}: use a relative path.`);
+	}
+	const normalized = relative(resolve("/"), resolve("/", path));
+	if (
+		path.split(/[/\\]/u).includes("..") ||
+		normalized === "" ||
+		normalized.split(sep)[0] === ".forks"
+	) {
+		throw new Error(
+			`Invalid note path ${JSON.stringify(path)}: must stay outside managed .forks paths and inside its scope.`,
+		);
+	}
+	return normalized;
+}
+/** Resolve existing ancestors too, so aliases to files not created yet have one owner. */
+export function canonicalPath(path: string): string {
+	const absolute = isAbsolute(path) ? path : `${process.cwd()}${sep}${path}`;
+	try {
+		return realpathSync(absolute);
+	} catch (error) {
+		if (!isRecord(error) || (error.code !== "ENOENT" && error.code !== "ENOTDIR")) {
+			throw error;
+		}
+		const parent = dirname(absolute);
+		return parent === absolute
+			? absolute
+			: join(canonicalPath(parent), relative(parent, absolute));
+	}
+}
+export function notePath(scope: NoteScope, path: string): string {
+	const directory = scopeDirectory(scope);
+	const target = join(directory, noteRelative(path));
+	const canonical = canonicalPath(target);
+	const escapesPrivate = scope.scope !== "" && !inside(canonicalPath(directory), canonical);
+	const entersManaged =
+		scope.scope === "" && inside(canonicalPath(join(scope.root, ".forks")), canonical);
+	if (escapesPrivate || entersManaged) {
+		throw new Error(`Note path leaves its scope through a filesystem alias: ${target}`);
+	}
+	return target;
+}
+function validScope(scope: NoteScope): boolean {
+	return (
+		isAbsolute(scope.root) &&
+		(scope.scope === "" || /^\.forks\/[^/\\]+\/notes$/u.test(scope.scope))
+	);
+}
+function validSeed(seed: NoteSeed): boolean {
+	try {
+		return (
+			noteRelative(seed.path) === seed.path &&
+			validScope(seed.source) &&
+			validScope(seed.lineage) &&
+			noteRelative(seed.source.path) === seed.source.path &&
+			noteRelative(seed.lineage.path) === seed.lineage.path
+		);
+	} catch {
+		return false;
+	}
+}
+function validNoteName(path: string): boolean {
+	try {
+		return noteRelative(path) === path;
+	} catch {
+		return false;
+	}
+}
+function validFork(binding: ForkBinding): boolean {
+	return (
+		binding.scope === forkScope(binding.owner) &&
+		(binding.source === null || validScope(binding.source)) &&
+		binding.seeds.every(validSeed) &&
+		binding.absent.every(validNoteName)
+	);
+}
+export function parseBinding(value: unknown): NoteBinding | undefined {
+	if (
+		!Check(bindingSchema, value) ||
+		!validScope(value) ||
+		value.owner.id === "" ||
+		!Number.isFinite(Date.parse(value.owner.timestamp))
+	) {
+		return;
+	}
+	if (value.kind === "fork" && !validFork(value)) {
+		return;
+	}
+	return value;
+}
+export function bindingsOf(entries: readonly EntryLike[]): NoteBinding[] {
+	return entries.flatMap((entry) => {
+		const binding =
+			entry.type === "custom" && entry.customType === NOTES_BINDING
+				? parseBinding(entry.data)
+				: undefined;
+		return binding === undefined ? [] : [binding];
+	});
+}
+export function touchRecords(entries: readonly EntryLike[]): NoteTouchRecord[] {
+	return entries.flatMap((entry) => {
+		if (
+			entry.type !== "custom" ||
+			entry.customType !== NOTES_TOUCH ||
+			!Check(touchSchema, entry.data) ||
+			!validScope(entry.data.scope)
+		) {
+			return [];
+		}
+		try {
+			return entry.data.files.every(
+				(file) =>
+					validScope(file) &&
+					noteRelative(file.path) === file.path &&
+					(file.seed === undefined || validSeed(file.seed)),
+			)
+				? [entry.data]
+				: [];
+		} catch {
+			return [];
+		}
+	});
+}
+export function seedsOf(binding: NoteBinding, entries: readonly EntryLike[]): readonly NoteSeed[] {
+	const seeds = new Map(
+		binding.kind === "fork" ? binding.seeds.map((seed) => [seed.path, seed]) : [],
+	);
+	for (const record of touchRecords(entries)) {
+		if (!sameOwner(record.owner, binding.owner)) {
+			continue;
+		}
+		for (const file of record.files) {
+			if (file.seed !== undefined && sameScope(file, binding)) {
+				seeds.set(file.path, file.seed);
+			}
+		}
+	}
+	return [...seeds.values()];
+}
+export function ownedPaths(binding: NoteBinding, entries: readonly EntryLike[]): Set<string> {
+	const paths = new Set(
+		binding.kind === "fork"
+			? [...binding.absent, ...binding.seeds.map((seed) => seed.path)]
+			: [],
+	);
+	for (const record of touchRecords(entries)) {
+		if (!sameOwner(record.owner, binding.owner)) {
+			continue;
+		}
+		for (const file of record.files) {
+			if (file.kind !== "read" && sameScope(binding, file)) {
+				paths.add(file.path);
+			}
+		}
+	}
+	return paths;
+}
+/** Pure longest-prefix matching is also used for historical paths on unavailable filesystems. */
+export function matchNoteDirectory(
+	path: string,
+	directories: readonly string[],
+): { readonly directory: string; readonly path: string } | undefined {
+	const slash = path.replaceAll("\\", "/");
+	for (const directory of directories.toSorted((a, b) => b.length - a.length)) {
+		const normalized = directory.replaceAll("\\", "/").replace(/\/+$/u, "");
+		const part = slash.startsWith(`${normalized}/`) ? slash.slice(normalized.length + 1) : "";
+		if (part !== "" && part !== ".forks" && !part.startsWith(".forks/")) {
+			return { directory, path: part };
+		}
+	}
+	return;
+}
+export function addressOf(path: string, scopes: readonly NoteScope[]): NoteAddress | undefined {
+	const candidates = scopes.map((scope) => ({
+		scope,
+		directory: canonicalPath(scopeDirectory(scope)),
+	}));
+	for (const target of [canonicalPath(path), resolve(path)]) {
+		const match = matchNoteDirectory(
+			target,
+			candidates.map((candidate) => candidate.directory),
+		);
+		const candidate =
+			match === undefined
+				? undefined
+				: candidates.find((item) => item.directory === match.directory);
+		if (match !== undefined && candidate !== undefined) {
+			return { ...candidate.scope, path: match.path };
+		}
+		if (
+			scopes.some(
+				(scope) =>
+					scope.scope === "" && inside(canonicalPath(join(scope.root, ".forks")), target),
+			)
+		) {
+			return;
+		}
+	}
+	return;
+}