@iowarp/clio-coder 0.3.7 → 0.3.9

package/src/domains/agents/fleet-contract.ts

@@ -16,6 +16,7 @@ import { Type } from "typebox";
 import { Value } from "typebox/value";
 import { resolvePackageRoot } from "../../core/package-root.js";
 import { clioConfigDir } from "../../core/xdg.js";
+import { enabledExtensionResourceRoots } from "../extensions/index.js";
 import { type FleetCommandRegistry, loadFleetCommands } from "./fleet-commands.js";
 import { parseFrontmatter } from "./frontmatter.js";
 import { normalizeWriteBoundary, WRITE_BOUNDARY_MAX_ENTRIES } from "./write-boundary.js";
@@ -198,7 +199,7 @@ export interface FleetContract {
 	path: string;
 }
 
-export type FleetContractSource = "builtin" | "user" | "project";
+export type FleetContractSource = "builtin" | "extension" | "user" | "project";
 
 export interface FleetContractListing {
 	name: string;
@@ -758,6 +759,7 @@ export function parseFleetContract(raw: string, sourcePath: string): FleetContra
 	}
 	if (version < FLEET_WRITE_BOUNDARY_VERSION) assertNoWritesBefore(frontmatter, sourcePath, version);
 	if (version < FLEET_DYNAMIC_STEP_VERSION) assertNoV5FieldsBefore(frontmatter, sourcePath, version);
+	if (version >= FLEET_DYNAMIC_STEP_VERSION) assertNoGateWrites(frontmatter, sourcePath);
 	const schemaError = firstSchemaError(frontmatter, version);
 	if (schemaError !== null) {
 		throw new Error(`fleet contract ${sourcePath}: ${schemaError}`);
@@ -849,6 +851,17 @@ function assertNoWritesBefore(frontmatter: Record<string, unknown>, sourcePath:
 	}
 }
 
+function assertNoGateWrites(frontmatter: Record<string, unknown>, sourcePath: string): void {
+	for (const value of Array.isArray(frontmatter.steps) ? frontmatter.steps : []) {
+		if (typeof value !== "object" || value === null) continue;
+		const step = value as Record<string, unknown>;
+		if (step.kind !== "gate" || typeof step.id !== "string" || step.id.length === 0 || !("writes" in step)) continue;
+		throw new Error(
+			`fleet contract ${sourcePath}: gate step '${step.id}' must not declare 'writes'; its write boundary is derived from 'path'`,
+		);
+	}
+}
+
 function assertNoV5FieldsBefore(frontmatter: Record<string, unknown>, sourcePath: string, version: number): void {
 	const forbidden = ["target", "profile"] as const;
 	if ("writers" in frontmatter) {
@@ -958,13 +971,22 @@ function builtinFleetsDir(): string {
 	return join(resolvePackageRoot(), "src", "domains", "agents", "fleets");
 }
 
+function fleetSources(cwd: string): ReadonlyArray<{ dir: string; source: FleetContractSource }> {
+	return [
+		{ dir: builtinFleetsDir(), source: "builtin" },
+		...enabledExtensionResourceRoots("fleets", cwd)
+			.sort((left, right) => left.source.localeCompare(right.source))
+			.map((root) => ({ dir: root.path, source: "extension" as const })),
+		{ dir: join(clioConfigDir(), "fleets"), source: "user" },
+		{ dir: fleetsDir(cwd), source: "project" },
+	];
+}
+
 function fleetContractPath(cwd: string, name: string): { path: string; source: FleetContractSource } | null {
-	const projectPath = join(fleetsDir(cwd), `${name}.md`);
-	if (existsSync(projectPath)) return { path: projectPath, source: "project" };
-	const userPath = join(clioConfigDir(), "fleets", `${name}.md`);
-	if (existsSync(userPath)) return { path: userPath, source: "user" };
-	const builtinPath = join(builtinFleetsDir(), `${name}.md`);
-	if (existsSync(builtinPath)) return { path: builtinPath, source: "builtin" };
+	for (const source of [...fleetSources(cwd)].reverse()) {
+		const candidate = join(source.dir, `${name}.md`);
+		if (existsSync(candidate)) return { path: candidate, source: source.source };
+	}
 	return null;
 }
 
@@ -1004,11 +1026,7 @@ export function listFleetContracts(cwd: string): FleetContractListing[] {
 		registryError = err instanceof Error ? err.message : String(err);
 	}
 	const listings = new Map<string, FleetContractListing>();
-	const sources: ReadonlyArray<{ dir: string; source: FleetContractSource }> = [
-		{ dir: builtinFleetsDir(), source: "builtin" },
-		{ dir: join(clioConfigDir(), "fleets"), source: "user" },
-		{ dir: fleetsDir(cwd), source: "project" },
-	];
+	const sources = fleetSources(cwd);
 	for (const { dir, source } of sources) {
 		for (const file of listDirectory(dir)) {
 			const path = join(dir, file);

package/src/domains/agents/recipe.ts

@@ -131,7 +131,7 @@ export interface AgentRecipe {
 	resultContract: ResultContract;
 	product?: AgentProduct;
 	tags: ReadonlyArray<string>;
-	source: "builtin" | "user" | "project";
+	source: "builtin" | "extension" | "user" | "project";
 	filepath: string;
 	/** Persona prompt body. */
 	body: string;
@@ -140,6 +140,12 @@ export interface AgentRecipe {
 export interface RecipeSource {
 	dir: string;
 	source: AgentRecipe["source"];
+	/** Project root whose extension and skill resources are being discovered. */
+	cwd?: string;
+	/** Stable provenance used to correlate resources from one extension. */
+	origin?: string;
+	/** The declaring extension's skill root; extension agents may bind only here. */
+	skillRoot?: string;
 }
 
 export function recipeIdFromPath(absPath: string, rootDir: string): string {

package/src/domains/agents/registry.ts

@@ -1,5 +1,8 @@
-import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, realpathSync } from "node:fs";
 import path from "node:path";
+import { resolvePackageRoot } from "../../core/package-root.js";
+import { clioConfigDir } from "../../core/xdg.js";
+import { enabledExtensionResourceRoots } from "../extensions/index.js";
 import { loadSkills } from "../resources/skills/loader.js";
 import { parseFrontmatter } from "./frontmatter.js";
 import { type AgentRecipe, type RecipeSource, recipeIdFromPath } from "./recipe.js";
@@ -20,10 +23,29 @@ function resolveBoundSkills(recipe: AgentRecipe, source: RecipeSource): AgentRec
 	// only the operator's discovered skill roots; a recipe cannot smuggle an
 	// arbitrary filesystem path into worker context through a skill name.
 	const packageSkills = path.resolve(source.dir, "..", "..", "..", "..", "skills");
-	const skills = loadSkills({
-		cwd: process.cwd(),
-		...(source.source === "builtin" && existsSync(packageSkills) ? { explicitSkillPaths: [packageSkills] } : {}),
-	});
+	if (source.source === "extension" && source.skillRoot === undefined) {
+		throw new Error(`agent recipe: ${recipe.filepath}: extension declares bound skills but no skills resource root`);
+	}
+	const skills =
+		source.source === "extension"
+			? loadSkills({
+					cwd: source.cwd ?? process.cwd(),
+					disableDiscovery: true,
+					explicitSkillPaths: source.skillRoot === undefined ? [] : [source.skillRoot],
+				})
+			: loadSkills({
+					cwd: source.cwd ?? process.cwd(),
+					...(source.source === "builtin" && existsSync(packageSkills) ? { explicitSkillPaths: [packageSkills] } : {}),
+				});
+	if (source.source === "extension" && source.skillRoot !== undefined) {
+		const canonicalRoot = realpathSync(source.skillRoot);
+		for (const skill of skills.items) {
+			const relative = path.relative(canonicalRoot, realpathSync(skill.filePath));
+			if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+				throw new Error(`agent recipe: ${recipe.filepath}: bound skill escapes its extension: ${skill.filePath}`);
+			}
+		}
+	}
 	const byName = new Map(skills.items.map((skill) => [skill.name, skill.filePath]));
 	const missing = recipe.skills.filter((skill) => !byName.has(skill));
 	if (missing.length > 0) {
@@ -95,6 +117,10 @@ export function mergeRecipes(...sources: ReadonlyArray<ReadonlyArray<AgentRecipe
 				continue;
 			}
 			const builtin = builtinById.get(recipe.id);
+			if (recipe.source === "extension" && builtin) {
+				process.stderr.write(`[clio:agents] ignore override id=${recipe.id} by=extension reason=reserved-builtin\n`);
+				continue;
+			}
 			if (recipe.source === "user" && builtin && isShadowAgent(normalizeAgentSpec(builtin))) {
 				process.stderr.write(`[clio:agents] ignore override id=${recipe.id} by=user reason=reserved-shadow\n`);
 				continue;
@@ -109,3 +135,45 @@ export function mergeRecipes(...sources: ReadonlyArray<ReadonlyArray<AgentRecipe
 	}
 	return Array.from(byId.values()).sort((left, right) => left.id.localeCompare(right.id));
 }
+
+/**
+ * Discover the one native-agent catalog used by listing, fleet admission, and
+ * dispatch. Extension recipes occupy the same precedence slot as extension
+ * fleets: after builtins and before operator/user and project recipes. Their
+ * skill bindings remain constrained to the declaring extension's skill root.
+ */
+export function discoverAgentRecipes(
+	cwd = process.cwd(),
+	diagnostics: AgentRecipeDiagnostic[] = [],
+): ReadonlyArray<AgentRecipe> {
+	const builtin = loadRecipesFromDir(
+		{
+			dir: path.join(resolvePackageRoot(), "src", "domains", "agents", "builtins"),
+			source: "builtin",
+			cwd,
+		},
+		diagnostics,
+	);
+	const skillRoots = new Map(enabledExtensionResourceRoots("skills", cwd).map((root) => [root.source, root.path]));
+	const extensionRecipes = enabledExtensionResourceRoots("agents", cwd)
+		.sort((left, right) => left.source.localeCompare(right.source))
+		.map((root) => {
+			const skillRoot = skillRoots.get(root.source);
+			return loadRecipesFromDir(
+				{
+					dir: root.path,
+					source: "extension",
+					cwd,
+					origin: root.source,
+					...(skillRoot === undefined ? {} : { skillRoot }),
+				},
+				diagnostics,
+			);
+		});
+	const user = loadRecipesFromDir({ dir: path.join(clioConfigDir(), "agents"), source: "user", cwd }, diagnostics);
+	const project = loadRecipesFromDir(
+		{ dir: path.join(cwd, ".clio-coder", "agents"), source: "project", cwd },
+		diagnostics,
+	);
+	return mergeRecipes(builtin, ...extensionRecipes, user, project);
+}

package/src/domains/agents/result-contract.ts

@@ -8,6 +8,27 @@ export type ResultContract =
 	| { kind: "scout-report" }
 	| { kind: "verifier-report" }
 	| { kind: "council-report" }
+	/**
+	 * One council member's ballot under `synthesis: "vote"`.
+	 *
+	 * The vote is a strict majority over the members' `verdict` fields, computed
+	 * by the coordinator with no model call. Nothing asked a member for that
+	 * field before this kind existed, and nothing could: an unnamed council
+	 * seats the builtin `researcher`, whose `research-report` accepts only
+	 * `source` and `findings`, so a member that emitted a verdict failed its own
+	 * postcondition and a member that obeyed its postcondition emitted no
+	 * verdict. Every vote therefore resolved to `no_verdict_field` with an empty
+	 * tally, on every input (#230).
+	 *
+	 * The ballot is the coordinator's postcondition for that slot, not the
+	 * recipe's, in the same way `reviewer` and the compete `judge` answer the
+	 * gate that dispatched them. It rides in as a `resultContractOverride` on
+	 * the member request, so the seated recipe keeps its persona and any recipe
+	 * can be voted with. No recipe may declare it: `parseResultContract` rejects
+	 * the kind, and a Scout subtask may not request it, because it is a
+	 * topology's ballot rather than an agent's work product.
+	 */
+	| { kind: "council-ballot" }
 	| { kind: "debugger-report" }
 	| { kind: "research-report" }
 	| { kind: "mutation-report" }
@@ -273,6 +294,67 @@ export function parseDelegationPlanResult(output: string | null): DelegationPlan
 	return { tasks };
 }
 
+/**
+ * Longest verdict token a ballot may cast, in bytes.
+ *
+ * A tally groups members by their exact verdict string, so a verdict that is a
+ * sentence can only ever tie with itself and a council of any size reports
+ * `no_majority`. The bound is what makes a majority reachable: it forces the
+ * decision into a token members can match (`yes`, `no`, `keep`, an option
+ * name) and pushes the reasoning into `text`, where the report already reads
+ * it. A newline is refused for the same reason.
+ */
+export const COUNCIL_BALLOT_VERDICT_MAX_BYTES = 64;
+
+/**
+ * The ballot's wire shape, quoted verbatim to the member that must cast it and
+ * by the repair round that corrects it. Exported because the council composes
+ * the member's ask from it, which is the rule this module already states: a
+ * contract's example is written once so a prompt cannot drift from its
+ * validator.
+ */
+export const COUNCIL_BALLOT_SHAPE = '{"verdict":"yes","text":"the answer and the evidence behind it"}';
+
+interface CouncilBallot {
+	/** The comparable token the tally counts. */
+	verdict: string;
+	/** The member's answer in prose, which is what the council report shows. */
+	text: string;
+}
+
+/**
+ * Read a council member's ballot. The council reads a verdict out of the
+ * member's terminal text with its own reader, because the judge synthesis
+ * carries the same two fields under no contract at all; this one is what
+ * decides whether the member is allowed to seal that text as its result.
+ */
+function parseCouncilBallot(output: string | null): CouncilBallot | null {
+	const parsed = parseJson(output);
+	if (!parsed.ok) return null;
+	const value = parsed.value;
+	if (!hasOnlyKeys(value, ["verdict", "text"]) || !string(value.verdict) || !string(value.text)) return null;
+	const verdict = value.verdict.trim();
+	if (verdict.includes("\n") || Buffer.byteLength(verdict, "utf8") > COUNCIL_BALLOT_VERDICT_MAX_BYTES) return null;
+	return { verdict, text: value.text.trim() };
+}
+
+function validateCouncilBallot(contract: ResultContract, output: string | null): ResultContractValidation {
+	const parsed = parseJson(output);
+	if (!parsed.ok) return failure(contract, "unmeasured", parsed.reason);
+	const ballot = parseCouncilBallot(output);
+	if (ballot === null) {
+		return failure(
+			contract,
+			"unmeasured",
+			`A council ballot must carry only verdict and text, both non-empty strings, with verdict a single line of at most ${COUNCIL_BALLOT_VERDICT_MAX_BYTES} bytes so the tally can match it against the other members`,
+		);
+	}
+	// Unmeasured, like every other contract whose shape carries no correctness
+	// claim: casting a well-formed ballot says nothing about whether the member
+	// was right, and the tally is a count of opinions rather than a check.
+	return success(contract, "unmeasured", ballot);
+}
+
 export interface CouncilReportMember {
 	label: string;
 	runId: string;
@@ -1249,6 +1331,8 @@ export function validateResultContract(input: ResultContractValidationInput): Re
 				? failure(input.contract, "fail", "council-report is malformed")
 				: success(input.contract, "unmeasured", { council: report });
 		}
+		case "council-ballot":
+			return validateCouncilBallot(input.contract, input.output);
 		case "debugger-report":
 			return validateDebugger(input.contract, input.output);
 		case "research-report":
@@ -1347,6 +1431,8 @@ function resultContractShape(contract: ResultContract): string {
 			return '{"verdict":"pass","checks":[{"name":"npm run typecheck","passed":true,"evidence":"exit 0"}]}';
 		case "council-report":
 			return '{"members":[{"label":"alpha","runId":"run-1","round":1,"answer":"..."}],"synthesis":{"kind":"none"}}';
+		case "council-ballot":
+			return COUNCIL_BALLOT_SHAPE;
 		case "debugger-report":
 			return '{"diagnosis":"...","reproduction":"reproduced","evidence":["..."]}';
 		case "research-report":
@@ -1463,8 +1549,31 @@ export function resultContractRepairMessages(
 	] as const;
 }
 
-/** Strict frontmatter parser for the one recipe result-contract schema. */
-export function parseResultContract(value: unknown, sourcePath: string): ResultContract {
+/** Kinds an agent recipe may declare in its frontmatter. */
+const RECIPE_DECLARABLE_KINDS = [
+	"scout-report",
+	"verifier-report",
+	"council-report",
+	"debugger-report",
+	"research-report",
+	"mutation-report",
+	"provenance-report",
+	"oracle-report",
+	"external-delegation",
+	"artifact-report",
+	"context-handbook",
+	"delegation-plan",
+] as const;
+
+/**
+ * Kinds the coordinator authors and hands to a worker on the wire, which no
+ * recipe may declare. A council ballot is the topology's postcondition for a
+ * vote member's slot, so it arrives as a `resultContractOverride` on the
+ * request and never out of frontmatter.
+ */
+const COORDINATOR_AUTHORED_KINDS = ["council-ballot"] as const;
+
+function parseContract(value: unknown, sourcePath: string, kinds: ReadonlyArray<string>): ResultContract {
 	if (value === null || typeof value !== "object" || Array.isArray(value)) {
 		throw new Error(`agent recipe: ${sourcePath}: resultContract must be an object`);
 	}
@@ -1481,22 +1590,24 @@ export function parseResultContract(value: unknown, sourcePath: string): ResultC
 		}
 		return { kind: "architect-plan", path: record.path };
 	}
-	const kinds = [
-		"scout-report",
-		"verifier-report",
-		"council-report",
-		"debugger-report",
-		"research-report",
-		"mutation-report",
-		"provenance-report",
-		"oracle-report",
-		"external-delegation",
-		"artifact-report",
-		"context-handbook",
-		"delegation-plan",
-	] as const;
-	if (!(kinds as ReadonlyArray<string>).includes(record.kind) || !only("kind")) {
+	if (!kinds.includes(record.kind) || !only("kind")) {
 		throw new Error(`agent recipe: ${sourcePath}: resultContract.kind is unsupported or has unknown keys`);
 	}
 	return { kind: record.kind as Exclude<ResultContract["kind"], "architect-plan"> };
 }
+
+/** Strict frontmatter parser for the one recipe result-contract schema. */
+export function parseResultContract(value: unknown, sourcePath: string): ResultContract {
+	return parseContract(value, sourcePath, RECIPE_DECLARABLE_KINDS);
+}
+
+/**
+ * The same parser for a contract that arrived on a WorkerSpec. It admits what a
+ * recipe may declare plus what the coordinator may author, because a dispatch
+ * request can override the seated recipe's postcondition and the worker has to
+ * be able to read the contract it will be validated against. Keeping the recipe
+ * parser strict is the point: a recipe still cannot claim a coordinator's kind.
+ */
+export function parseWorkerResultContract(value: unknown, sourcePath: string): ResultContract {
+	return parseContract(value, sourcePath, [...RECIPE_DECLARABLE_KINDS, ...COORDINATOR_AUTHORED_KINDS]);
+}

package/src/domains/agents/write-boundary.ts

@@ -1,3 +1,12 @@
+import {
+	normalizePathBoundary,
+	normalizePathBoundaryEntry,
+	PATH_BOUNDARY_MAX_ENTRIES,
+	type PathBoundary,
+	pathBoundariesOverlap,
+	pathBoundaryCovers,
+} from "../../core/path-boundary.js";
+
 /**
  * Declared write boundaries: the repo paths a fleet step is allowed to change.
  *
@@ -30,37 +39,14 @@
  * a step that needs more of the tree than that should say `workspace` and mean
  * it in a contract that does not claim a boundary.
  */
-export const WRITE_BOUNDARY_MAX_ENTRIES = 32;
+export const WRITE_BOUNDARY_MAX_ENTRIES = PATH_BOUNDARY_MAX_ENTRIES;
 
 /** A normalized allowlist. Empty means "changes nothing", which is `readonly`. */
-export type WriteBoundary = ReadonlyArray<string>;
-
-const GLOB_CHARACTERS = /[*?[\]{}]/u;
+export type WriteBoundary = PathBoundary;
 
 /** Normalize one declared entry, or throw explaining exactly what is wrong. */
 export function normalizeWriteBoundaryEntry(entry: string): string {
-	const raw = entry.trim();
-	if (raw.length === 0) throw new Error("write boundary: entry must be a non-empty path");
-	if (raw.includes("\\")) {
-		throw new Error(`write boundary: entry '${entry}' must use '/' separators`);
-	}
-	if (GLOB_CHARACTERS.test(raw)) {
-		throw new Error(`write boundary: entry '${entry}' looks like a glob, which v1 does not support`);
-	}
-	if (raw.startsWith("/") || /^[A-Za-z]:/u.test(raw)) {
-		throw new Error(`write boundary: entry '${entry}' must be repository-relative, not absolute`);
-	}
-	const subtree = raw.endsWith("/");
-	const segments = raw.split("/").filter((segment) => segment.length > 0);
-	if (segments.length === 0) {
-		throw new Error(`write boundary: entry '${entry}' must name a path inside the repository`);
-	}
-	for (const segment of segments) {
-		if (segment === "..") throw new Error(`write boundary: entry '${entry}' must not contain '..'`);
-		if (segment === ".") throw new Error(`write boundary: entry '${entry}' must not contain '.' segments`);
-	}
-	const joined = segments.join("/");
-	return subtree ? `${joined}/` : joined;
+	return normalizePathBoundaryEntry(entry);
 }
 
 /**
@@ -69,38 +55,17 @@ export function normalizeWriteBoundaryEntry(entry: string): string {
  * and a sealed verdict can both carry.
  */
 export function normalizeWriteBoundary(entries: ReadonlyArray<string>): string[] {
-	if (entries.length > WRITE_BOUNDARY_MAX_ENTRIES) {
-		throw new Error(`write boundary: at most ${WRITE_BOUNDARY_MAX_ENTRIES} entries may be declared`);
-	}
-	const normalized = new Set(entries.map(normalizeWriteBoundaryEntry));
-	// A file entry covered by a declared subtree is redundant, not an error: the
-	// operator said the directory, and saying one of its files again changes
-	// nothing about what is allowed.
-	return [...normalized].sort();
-}
-
-/** Repo-relative path with the separators this grammar speaks. */
-function toRepoRelativePosix(path: string): string {
-	return path.split("\\").join("/");
+	return normalizePathBoundary(entries);
 }
 
 /** Whether the boundary permits a change to one repo-relative path. */
 export function writeBoundaryCovers(boundary: WriteBoundary, path: string): boolean {
-	const candidate = toRepoRelativePosix(path);
-	return boundary.some((entry) => (entry.endsWith("/") ? candidate.startsWith(entry) : candidate === entry));
-}
-
-/** Whether two declared entries can describe the same path. */
-function entriesOverlap(left: string, right: string): boolean {
-	if (left === right) return true;
-	if (left.endsWith("/") && right.startsWith(left)) return true;
-	if (right.endsWith("/") && left.startsWith(right)) return true;
-	return false;
+	return pathBoundaryCovers(boundary, path);
 }
 
 /** Whether two boundaries share any path. Empty boundaries never overlap. */
 export function writeBoundariesOverlap(left: WriteBoundary, right: WriteBoundary): boolean {
-	return left.some((entry) => right.some((other) => entriesOverlap(entry, other)));
+	return pathBoundariesOverlap(left, right);
 }
 
 /** Operator-facing rendering, used verbatim in violation messages. */

package/src/domains/config/classify.ts

@@ -61,6 +61,9 @@ const NEXT_TURN_FIELDS = new Set<string>([
 	"delegation",
 	"compaction",
 	"context",
+	// The pre-warm reads its setting when a trigger fires, and every trigger sits
+	// on a turn boundary, so a change takes effect before the next turn runs.
+	"prewarm",
 	"retry",
 ]);
 

package/src/domains/context/codewiki/coordinator.ts

@@ -140,8 +140,16 @@ export function coordinateCodewikiWrite(
 	options: CodewikiCoordinateOptions = {},
 ): Promise<CodewikiCoordinatedResult | null> {
 	const workspace = resolve(cwd);
-	return enqueueWorkspace(workspace, () =>
-		withStateFileLock(codewikiPath(workspace), async () => {
+	return enqueueWorkspace(workspace, () => {
+		// Taking the lease creates the lock's parent, so a project that was never
+		// indexed gained an empty `.clio-coder/` from every successful write: the
+		// incremental refresh is contractually a no-op there, and it was
+		// materializing state before it could say so (issue #248). The check runs
+		// inside the queue, so a writer that built the codewiki ahead of this task
+		// has already finished and this one sees it. The recheck under the lock
+		// stays, and is what still decides the race.
+		if (options.requireExisting && !existsSync(codewikiPath(workspace))) return Promise.resolve(null);
+		return withStateFileLock(codewikiPath(workspace), async () => {
 			if (options.requireExisting && !existsSync(codewikiPath(workspace))) return null;
 			const current = options.readCurrent?.(workspace) ?? readCodewiki(workspace);
 			const request = await select(current, workspace);
@@ -152,8 +160,8 @@ export function coordinateCodewikiWrite(
 			if (wrote) writeCodewiki(workspace, worker.codewiki);
 			await options.afterCommit?.(worker, workspace);
 			return { codewiki: !worker.changed && current ? current : worker.codewiki, worker, wrote };
-		}),
-	);
+		});
+	});
 }
 
 /** Serialize a non-build artifact transaction such as reset with every writer. */

package/src/domains/context/project-rules.ts

@@ -203,12 +203,62 @@ function ruleMatchesAnyPath(rule: ProjectRule, workingPaths: ReadonlyArray<strin
 			continue;
 		}
 		for (const path of workingPaths) {
-			if (regex.test(normalizeGlobInput(path))) return true;
+			const normalized = normalizeGlobInput(path);
+			if (regex.test(normalized)) return true;
+			if (normalized.endsWith("/") && globMatchesInsideDirectory(regex, pattern, normalized)) return true;
 		}
 	}
 	return false;
 }
 
+function materializedGlobVariants(pattern: string): string[] {
+	let variants = [""];
+	const normalized = normalizeGlobInput(pattern);
+	for (let index = 0; index < normalized.length; index += 1) {
+		const character = normalized[index];
+		if (character === undefined) break;
+		if (character === "*" && normalized[index + 1] === "*" && normalized[index + 2] === "/") {
+			variants = variants.flatMap((prefix) => [prefix, `${prefix}x/`]).slice(0, 64);
+			index += 2;
+			continue;
+		}
+		if (character === "*" && normalized[index + 1] === "*") {
+			variants = variants.map((prefix) => `${prefix}x`);
+			index += 1;
+			continue;
+		}
+		if (character === "*" || character === "?") {
+			variants = variants.map((prefix) => `${prefix}x`);
+			continue;
+		}
+		if (character === "[") {
+			const end = normalized.indexOf("]", index + 1);
+			const selected = end === -1 ? "x" : (normalized[index + 1] ?? "x");
+			variants = variants.map((prefix) => `${prefix}${selected}`);
+			index = end === -1 ? index : end;
+			continue;
+		}
+		variants = variants.map((prefix) => `${prefix}${character}`);
+	}
+	return variants;
+}
+
+function globMatchesInsideDirectory(regex: RegExp, pattern: string, directory: string): boolean {
+	const candidates = new Set<string>([`${directory}x`, `${directory}x/x`]);
+	for (const materialized of materializedGlobVariants(pattern)) {
+		if (materialized.startsWith(directory)) candidates.add(materialized);
+		const segments = materialized.split("/");
+		for (let index = 0; index < segments.length; index += 1) {
+			const suffix = segments.slice(index).join("/");
+			if (suffix.length > 0) candidates.add(`${directory}${suffix}`);
+		}
+		for (let index = 0; index < materialized.length; index += 1) {
+			candidates.add(`${directory}${materialized.slice(index)}`);
+		}
+	}
+	return [...candidates].some((candidate) => regex.test(candidate));
+}
+
 /**
  * Select the rules that should load now. Unconditional rules (no `paths`) always
  * load; a path-scoped rule loads only when one of its globs matches a path