@iowarp/clio-coder 0.3.4 → 0.3.6

package/src/core/response-model-id.ts

@@ -0,0 +1,134 @@
+/** What Clio directly observed about a provider response model id. */
+export type ResponseModelIdObservation =
+	| { state: "reported"; reportedModelId: string }
+	| { state: "not-reported" }
+	| { state: "not-observed" }
+	| { state: "legacy-difference-only"; differingModelId: string | null };
+
+export type MissingResponseModelIdObservation = "not-observed" | "legacy-difference-only";
+
+/** Call counts grouped by the exact response model-id observation state. */
+export interface ResponseModelIdObservationCounts {
+	reportedCalls: number;
+	notReportedCalls: number;
+	notObservedCalls: number;
+	legacyDifferenceOnlyCalls: number;
+}
+
+export function emptyResponseModelIdObservationCounts(): ResponseModelIdObservationCounts {
+	return { reportedCalls: 0, notReportedCalls: 0, notObservedCalls: 0, legacyDifferenceOnlyCalls: 0 };
+}
+
+export function addResponseModelIdObservationCount(
+	counts: ResponseModelIdObservationCounts,
+	observation: ResponseModelIdObservation,
+	calls = 1,
+): void {
+	switch (observation.state) {
+		case "reported":
+			counts.reportedCalls += calls;
+			break;
+		case "not-reported":
+			counts.notReportedCalls += calls;
+			break;
+		case "not-observed":
+			counts.notObservedCalls += calls;
+			break;
+		case "legacy-difference-only":
+			counts.legacyDifferenceOnlyCalls += calls;
+			break;
+	}
+}
+
+export function addResponseModelIdObservationCounts(
+	counts: ResponseModelIdObservationCounts,
+	additional: Readonly<ResponseModelIdObservationCounts>,
+): void {
+	counts.reportedCalls += additional.reportedCalls;
+	counts.notReportedCalls += additional.notReportedCalls;
+	counts.notObservedCalls += additional.notObservedCalls;
+	counts.legacyDifferenceOnlyCalls += additional.legacyDifferenceOnlyCalls;
+}
+
+export function responseModelIdObservationCountsLabel(counts: ResponseModelIdObservationCounts): string {
+	const parts: string[] = [];
+	if (counts.reportedCalls > 0) parts.push(`reported ${counts.reportedCalls}`);
+	if (counts.notReportedCalls > 0) parts.push(`not reported ${counts.notReportedCalls}`);
+	if (counts.notObservedCalls > 0) parts.push(`not observed ${counts.notObservedCalls}`);
+	if (counts.legacyDifferenceOnlyCalls > 0) parts.push(`legacy difference-only ${counts.legacyDifferenceOnlyCalls}`);
+	return parts.join(", ");
+}
+
+function nonEmptyString(value: unknown): string | null {
+	return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+
+function parsedObservation(value: unknown): ResponseModelIdObservation | null {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
+	const record = value as Record<string, unknown>;
+	switch (record.state) {
+		case "reported": {
+			const reportedModelId = nonEmptyString(record.reportedModelId);
+			return reportedModelId === null ? null : { state: "reported", reportedModelId };
+		}
+		case "not-reported":
+			return { state: "not-reported" };
+		case "not-observed":
+			return { state: "not-observed" };
+		case "legacy-difference-only":
+			return { state: "legacy-difference-only", differingModelId: nonEmptyString(record.differingModelId) };
+		default:
+			return null;
+	}
+}
+
+/**
+ * Read the current observation shape and the short-lived #193 shape. A caller
+ * chooses how to label a missing field because a live message is not historical,
+ * while a persisted row without either shape predates model-id presence capture.
+ */
+export function responseModelIdObservationFromRecord(
+	record: Readonly<Record<string, unknown>>,
+	missing: MissingResponseModelIdObservation,
+): ResponseModelIdObservation {
+	const current = parsedObservation(record.responseModelIdObservation);
+	if (current !== null) return current;
+	if (Object.hasOwn(record, "servedModel")) {
+		const reportedModelId = nonEmptyString(record.servedModel);
+		return reportedModelId === null ? { state: "not-reported" } : { state: "reported", reportedModelId };
+	}
+	if (missing === "not-observed") return { state: "not-observed" };
+	return { state: "legacy-difference-only", differingModelId: nonEmptyString(record.responseModel) };
+}
+
+/** Human vocabulary shared by usage, footer, and receipt projections. */
+export function responseModelIdObservationLabel(observation: ResponseModelIdObservation): string {
+	switch (observation.state) {
+		case "reported":
+			return "reported";
+		case "not-reported":
+			return "not reported";
+		case "not-observed":
+			return "not observed";
+		case "legacy-difference-only":
+			return "legacy difference-only";
+	}
+}
+
+/** Model id used for accounting without claiming more than the observation supports. */
+export function attributedModelId(
+	observation: ResponseModelIdObservation,
+	requestedModelId: string,
+	differingResponseModelId: string | null,
+): string {
+	switch (observation.state) {
+		case "reported":
+			return observation.reportedModelId;
+		case "not-reported":
+			return "unknown";
+		case "not-observed":
+			return differingResponseModelId ?? requestedModelId;
+		case "legacy-difference-only":
+			return observation.differingModelId ?? requestedModelId;
+	}
+}

package/src/core/toml.ts

@@ -0,0 +1,62 @@
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { join } from "node:path";
+import type { TomlTable } from "smol-toml";
+
+type SmolTomlModule = typeof import("smol-toml");
+
+const require = createRequire(import.meta.url);
+let parse: SmolTomlModule["parse"] | undefined;
+
+function parser(): SmolTomlModule["parse"] {
+	parse ??= (require("smol-toml") as SmolTomlModule).parse;
+	return parse;
+}
+
+/** Parse one TOML document, returning no structure when the input is malformed. */
+export function parseTomlDocument(raw: string): TomlTable | null {
+	try {
+		return parser()(raw);
+	} catch {
+		return null;
+	}
+}
+
+function isTomlTable(value: unknown): value is TomlTable {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
+}
+
+/** Resolve a structural table path from a parsed document. */
+export function tomlTableAt(document: TomlTable, path: ReadonlyArray<string>): TomlTable | null {
+	let value: unknown = document;
+	for (const segment of path) {
+		if (!isTomlTable(value) || !Object.hasOwn(value, segment)) return null;
+		value = value[segment];
+	}
+	return isTomlTable(value) ? value : null;
+}
+
+export interface TomlFileReader {
+	read(relativePath: string): TomlTable | null;
+}
+
+/**
+ * Create an operation-scoped TOML reader. Each relative path is read and
+ * parsed at most once, including missing and malformed files.
+ */
+export function createTomlFileReader(root: string): TomlFileReader {
+	const documents = new Map<string, TomlTable | null>();
+	return {
+		read(relativePath) {
+			if (documents.has(relativePath)) return documents.get(relativePath) ?? null;
+			let document: TomlTable | null = null;
+			try {
+				document = parseTomlDocument(readFileSync(join(root, relativePath), "utf8"));
+			} catch {
+				document = null;
+			}
+			documents.set(relativePath, document);
+			return document;
+		},
+	};
+}

package/src/core/workspace-files.ts

@@ -133,7 +133,6 @@ export const WORKSPACE_EXCLUDED_DIRS: ReadonlySet<string> = new Set([
 	".superpowers",
 	".codex",
 	".claude",
-	".clio-coder-benchmark",
 ]);
 
 function comparePaths(a: string, b: string): number {

package/src/domains/agents/builtins/architect.md

@@ -11,7 +11,7 @@ category: plan
 capabilityClass: artifact-write
 latencyClass: deep
 projectContextTier: bounded
-budget: {toolCalls: 32, readReserve: 5, synthesis: true}
+budget: {toolCalls: 32, readReserve: 5, synthesis: true, maximum: {toolCalls: 150, readReserve: 16}}
 resultContract: {kind: architect-plan, path: .clio-coder/artifacts/PLAN.md}
 tags: [architecture, boundaries, migration]
 ---

package/src/domains/agents/catalog.ts

@@ -71,7 +71,9 @@ function fleetPromptPurpose(description: string): string {
 }
 
 function fleetPromptLine(spec: AgentSpec): string {
-	const budget = spec.budget ? `${spec.budget.toolCalls} calls` : "default budget";
+	const budget = spec.budget.maximum
+		? `${spec.budget.toolCalls}..${spec.budget.maximum.toolCalls} calls`
+		: `${spec.budget.toolCalls} calls`;
 	const purpose = fleetPromptPurpose(spec.description);
 	return `- ${spec.id} (${spec.capabilityClass}, ${budget})${purpose.length > 0 ? `: ${purpose}` : ""}`;
 }
@@ -160,9 +162,8 @@ export function renderAgentCatalogSectionsFromSpecs(input: ReadonlyArray<AgentSp
 function formatSpecLine(spec: AgentSpec, suffix: string): string {
 	const tags = spec.tags.length > 0 ? `, tags=${spec.tags.join("/")}` : "";
 	const skills = spec.skills.length > 0 ? `, skills=${spec.skills.join("/")}` : "";
-	const budget = spec.budget
-		? `, budget=${spec.budget.toolCalls}/${spec.budget.readReserve}/${spec.budget.synthesis ? "synthesize" : "stop"}`
-		: ", budget=operator-default";
+	const maximum = spec.budget.maximum ? `..${spec.budget.maximum.toolCalls}/${spec.budget.maximum.readReserve}` : "";
+	const budget = `, budget=${spec.budget.toolCalls}/${spec.budget.readReserve}${maximum}/${spec.budget.synthesis ? "synthesize" : "stop"}`;
 	return `- ${spec.name} [${spec.id}] (${spec.audience}, ${spec.category}, ${spec.capabilityClass}, ${spec.latencyClass}, ${spec.source}${tags}${skills}${budget})${suffix}`;
 }
 

package/src/domains/agents/recipe.ts

@@ -9,33 +9,33 @@ import type {
 	AgentProjectContextTier,
 } from "./spec.js";
 
-/** Authored worker-loop phase policy carried by an agent recipe. */
-export interface AgentBudget {
+/** One bounded worker-loop phase policy. */
+export interface AgentBudgetPhase {
 	/** Admitted tool-call boundary before the final-response phase. */
 	toolCalls: number;
 	/** Tail of the admitted boundary reserved for canonical `read` calls. */
 	readReserve: number;
+}
+
+/** Authored worker-loop phase policy carried by an agent recipe. */
+export interface AgentBudget extends AgentBudgetPhase {
 	/** Whether reaching the boundary transitions to text-only synthesis. */
 	synthesis: boolean;
+	/** Optional upper bound for invocation-level requests. Absence pins the default exactly. */
+	maximum?: AgentBudgetPhase;
 }
 
-const AGENT_BUDGET_KEYS = ["toolCalls", "readReserve", "synthesis"] as const;
+const AGENT_BUDGET_KEYS = ["toolCalls", "readReserve", "synthesis", "maximum"] as const;
 
-/** Strict parser shared by the one recipe schema and direct contract fixtures. */
-export function parseAgentBudget(value: unknown, sourcePath: string): AgentBudget | undefined {
-	if (value === undefined) return undefined;
-	const prefix = `agent budget: ${sourcePath}: budget`;
+function parseAgentBudgetPhase(value: unknown, prefix: string, relationTarget: string): AgentBudgetPhase {
 	if (value === null || typeof value !== "object" || Array.isArray(value)) {
 		throw new Error(`${prefix} must be a non-null YAML object`);
 	}
-
 	const record = value as Record<string, unknown>;
 	for (const key of Object.keys(record)) {
-		if (!(AGENT_BUDGET_KEYS as ReadonlyArray<string>).includes(key)) {
-			throw new Error(`${prefix}.${key} is unknown`);
-		}
+		if (key !== "toolCalls" && key !== "readReserve") throw new Error(`${prefix}.${key} is unknown`);
 	}
-	for (const key of AGENT_BUDGET_KEYS) {
+	for (const key of ["toolCalls", "readReserve"] as const) {
 		if (!Object.hasOwn(record, key)) throw new Error(`${prefix}.${key} is required`);
 	}
 
@@ -50,12 +50,52 @@ export function parseAgentBudget(value: unknown, sourcePath: string): AgentBudge
 		throw new Error(`${prefix}.readReserve must be a finite safe integer`);
 	}
 	if (readReserve < 0) throw new Error(`${prefix}.readReserve must be greater than or equal to 0`);
-	if (readReserve >= toolCalls) throw new Error(`${prefix}.readReserve must be less than budget.toolCalls`);
+	if (readReserve >= toolCalls) throw new Error(`${prefix}.readReserve must be less than ${relationTarget}`);
+
+	return { toolCalls, readReserve };
+}
+
+/** Strict parser shared by the one recipe schema and direct contract fixtures. */
+export function parseAgentBudget(value: unknown, sourcePath: string): AgentBudget | undefined {
+	if (value === undefined) return undefined;
+	const prefix = `agent budget: ${sourcePath}: budget`;
+	if (value === null || typeof value !== "object" || Array.isArray(value)) {
+		throw new Error(`${prefix} must be a non-null YAML object`);
+	}
+
+	const record = value as Record<string, unknown>;
+	for (const key of Object.keys(record)) {
+		if (!(AGENT_BUDGET_KEYS as ReadonlyArray<string>).includes(key)) {
+			throw new Error(`${prefix}.${key} is unknown`);
+		}
+	}
+	for (const key of ["toolCalls", "readReserve", "synthesis"] as const) {
+		if (!Object.hasOwn(record, key)) throw new Error(`${prefix}.${key} is required`);
+	}
+
+	const phase = parseAgentBudgetPhase(
+		{ toolCalls: record.toolCalls, readReserve: record.readReserve },
+		prefix,
+		"budget.toolCalls",
+	);
 
 	const synthesis = record.synthesis;
 	if (typeof synthesis !== "boolean") throw new Error(`${prefix}.synthesis must be a boolean`);
 
-	return { toolCalls, readReserve, synthesis };
+	const maximum =
+		record.maximum === undefined
+			? undefined
+			: parseAgentBudgetPhase(record.maximum, `${prefix}.maximum`, "budget.maximum.toolCalls");
+	if (maximum !== undefined) {
+		if (maximum.toolCalls < phase.toolCalls) {
+			throw new Error(`${prefix}.maximum.toolCalls must be greater than or equal to budget.toolCalls`);
+		}
+		if (maximum.readReserve < phase.readReserve) {
+			throw new Error(`${prefix}.maximum.readReserve must be greater than or equal to budget.readReserve`);
+		}
+	}
+
+	return { ...phase, synthesis, ...(maximum === undefined ? {} : { maximum }) };
 }
 
 export interface AgentToolAnyOfRequirement {

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

@@ -1147,12 +1147,13 @@ export interface ResultContractRepairInput {
 	attempt: number;
 	/** `path:line` anchors from reads that succeeded in this run. */
 	anchors: ReadonlyArray<string>;
+	/** True only when admission preauthorized a larger tool-call revision phase. */
+	toolsAvailable?: boolean;
 }
 
 /**
- * One repair directive. It states the validator's reason, the exact shape, and
- * that tool use is over, so the model's only remaining move is to emit the
- * terminal document from evidence it already has.
+ * One repair directive. It states the validator's reason and exact shape. Tool
+ * use remains closed unless dispatch preauthorized a larger revision phase.
  */
 export function resultContractRepairMessage(input: ResultContractRepairInput): string {
 	const last = input.attempt >= RESULT_CONTRACT_REPAIR_LIMIT;
@@ -1161,7 +1162,9 @@ export function resultContractRepairMessage(input: ResultContractRepairInput): s
 			? "FINAL RESULT REQUIRED IN THIS RESPONSE. Your previous response still did not satisfy this run's result contract."
 			: "Your previous response did not satisfy this run's result contract.",
 		`Validator reason: ${input.reason}`,
-		"Tool use is over. Answer from the evidence you already gathered.",
+		input.toolsAvailable === true
+			? "You may use the admitted tools to repair this validator failure, then emit the required terminal result."
+			: "Tool use is over. Answer from the evidence you already gathered.",
 		`Emit exactly this shape and nothing else: ${resultContractShape(input.contract)}`,
 		"Do not add prose, code fences, or commentary around it. Do not describe work you intend to do next.",
 	];

package/src/domains/context/bootstrap.ts

@@ -2,6 +2,7 @@ import { execFileSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join, parse } from "node:path";
 import type { ContextActivityPayload } from "../../core/bus-events.js";
+import { createTomlFileReader, type TomlFileReader, tomlTableAt } from "../../core/toml.js";
 import { classifyProjectPreload, type ProjectPreloadClass } from "../prompts/preload.js";
 import { detectProjectType, type ProjectType } from "../session/workspace/project-type.js";
 import {
@@ -15,7 +16,7 @@ import { type ClioMdSection, type ParsedClioMd, parseClioMd, serializeClioMd, tr
 import { buildCodewikiCandidate, coordinateCodewikiWrite } from "./codewiki/coordinator.js";
 import type { Codewiki } from "./codewiki/schema.js";
 import type { Fingerprint } from "./fingerprint.js";
-import { hasTomlTable, type ProjectMetadata, readProjectMetadata } from "./project-metadata.js";
+import { type ProjectMetadata, readProjectMetadata } from "./project-metadata.js";
 import { renderPromptContext } from "./prompt-context.js";
 import type { SiblingContextFile } from "./sibling-files.js";
 import {
@@ -49,6 +50,8 @@ export interface BootstrapIo {
 export interface BootstrapGenerateInput {
 	cwd: string;
 	expectedProjectName?: string;
+	/** Operation-scoped parsed TOML documents shared by bootstrap consumers. */
+	tomlFiles?: TomlFileReader;
 	projectType: ProjectType;
 	siblingFiles: ReadonlyArray<SiblingContextFile>;
 	adoption: AdoptionScanResult;
@@ -211,8 +214,8 @@ function projectNameFrom(metadata: ProjectMetadata, cwd: string): string {
 	return titleFromPackageName(parse(cwd).base || "Project");
 }
 
-function projectName(cwd: string): string {
-	return projectNameFrom(readProjectMetadata(cwd), cwd);
+function projectName(cwd: string, tomlFiles: TomlFileReader): string {
+	return projectNameFrom(readProjectMetadata(cwd, tomlFiles), cwd);
 }
 
 function projectTypeLabel(projectType: ProjectType): string {
@@ -270,8 +273,9 @@ function resolveDefaultIdentity(
 	cwd: string,
 	projectType: ProjectType,
 	files: ReadonlyArray<SiblingContextFile>,
+	tomlFiles: TomlFileReader,
 ): DeterministicIdentity {
-	const metadata = readProjectMetadata(cwd);
+	const metadata = readProjectMetadata(cwd, tomlFiles);
 	const name = projectNameFrom(metadata, cwd);
 	const context = allContextText(files);
 	if (/Clio owns the agent loop/i.test(context) && /pi-(?:ai|SDK)/i.test(context)) {
@@ -303,8 +307,8 @@ function resolveDefaultIdentity(
  * which tells a reader nothing the directory name did not. A model sentence is
  * strictly better than that, and only than that.
  */
-function stabilizedIdentity(input: BootstrapGenerateInput, modelIdentity: unknown): string {
-	const deterministic = resolveDefaultIdentity(input.cwd, input.projectType, input.siblingFiles);
+function stabilizedIdentity(input: BootstrapGenerateInput, modelIdentity: unknown, tomlFiles: TomlFileReader): string {
+	const deterministic = resolveDefaultIdentity(input.cwd, input.projectType, input.siblingFiles, tomlFiles);
 	const model = typeof modelIdentity === "string" ? modelIdentity.trim() : "";
 	if (deterministic.bare && model.length > 0) return model;
 	return deterministic.text;
@@ -504,23 +508,21 @@ function cmakeVerificationLines(cwd: string): string[] {
  * other way. Tox wins when both are declared because it typically wraps the
  * pytest run.
  */
-function pythonVerificationLines(cwd: string): string[] {
-	let pyproject = "";
-	try {
-		pyproject = readFileSync(join(cwd, "pyproject.toml"), "utf8");
-	} catch {
-		pyproject = "";
-	}
-	if (existsSync(join(cwd, "tox.ini")) || hasTomlTable(pyproject, "tool.tox")) {
+function pythonVerificationLines(cwd: string, tomlFiles: TomlFileReader): string[] {
+	const pyproject = tomlFiles.read("pyproject.toml");
+	if (existsSync(join(cwd, "tox.ini")) || (pyproject !== null && tomlTableAt(pyproject, ["tool", "tox"]))) {
 		return ["Run `tox` before handoff."];
 	}
-	if (existsSync(join(cwd, "pytest.ini")) || hasTomlTable(pyproject, "tool.pytest.ini_options")) {
+	if (
+		existsSync(join(cwd, "pytest.ini")) ||
+		(pyproject !== null && tomlTableAt(pyproject, ["tool", "pytest", "ini_options"]))
+	) {
 		return ["Run `pytest` before handoff."];
 	}
 	return [];
 }
 
-function verificationSection(cwd: string): ClioMdSection | null {
+function verificationSection(cwd: string, tomlFiles: TomlFileReader): ClioMdSection | null {
 	const scripts = packageScripts(cwd);
 	const pm = packageManager(cwd);
 	const hasScript = (name: string) => typeof scripts[name] === "string";
@@ -557,7 +559,8 @@ function verificationSection(cwd: string): ClioMdSection | null {
 	// Cargo's commands are defined by the toolchain, not by each project, so
 	// naming them for any Cargo workspace carries the same confidence as a
 	// declared package script.
-	if (existsSync(join(cwd, "Cargo.toml"))) {
+	const cargo = tomlFiles.read("Cargo.toml");
+	if (cargo !== null && (tomlTableAt(cargo, ["package"]) || tomlTableAt(cargo, ["workspace"]))) {
 		lines.push("Run `cargo build` and `cargo test` before handoff.");
 	}
 	// Go's commands are defined by the toolchain, not by each project, so
@@ -566,7 +569,7 @@ function verificationSection(cwd: string): ClioMdSection | null {
 	if (existsSync(join(cwd, "go.mod"))) {
 		lines.push("Run `go build ./...` and `go test ./...` before handoff.");
 	}
-	lines.push(...pythonVerificationLines(cwd));
+	lines.push(...pythonVerificationLines(cwd, tomlFiles));
 	if (lines.length === 0) return null;
 	return { title: "Verification expectations", body: lines.join(" ") };
 }
@@ -717,6 +720,7 @@ function stabilizeGeneratedOutput(
 	onModelSectionRetained?: () => void,
 	groundModelOutput = false,
 ): BootstrapStructuredOutput {
+	const tomlFiles = input.tomlFiles ?? createTomlFileReader(input.cwd);
 	const existing = input.existingClioMd;
 	const conventions: string[] = [];
 	for (const convention of existing?.conventions ?? []) pushUnique(conventions, convention);
@@ -727,7 +731,7 @@ function stabilizeGeneratedOutput(
 	for (const invariant of existing?.invariants ?? []) pushUnique(invariants, invariant);
 	for (const invariant of inferInvariants(input.siblingFiles)) pushUnique(invariants, invariant);
 
-	const verification = verificationSection(input.cwd);
+	const verification = verificationSection(input.cwd, tomlFiles);
 	const inferredSections = inferHeuristicSections(input);
 	const existingSections = existing?.sections ?? [];
 	const ordinarySections: ClioMdSection[] = [];
@@ -754,8 +758,8 @@ function stabilizeGeneratedOutput(
 	}
 	return {
 		...base,
-		projectName: existing?.projectName ?? projectName(input.cwd),
-		identity: existing?.identity ?? stabilizedIdentity(input, base.identity),
+		projectName: existing?.projectName ?? projectName(input.cwd, tomlFiles),
+		identity: existing?.identity ?? stabilizedIdentity(input, base.identity, tomlFiles),
 		conventions: conventions.slice(0, 6),
 		invariants: invariants.slice(0, 3),
 		sections: [...retainedOrdinarySections, ...(verification ? [verification] : [])],
@@ -819,9 +823,11 @@ function inferHeuristicSections(input: BootstrapGenerateInput): ClioMdSection[]
  * unavailable or fails.
  */
 function heuristicBootstrapOutputSync(input: BootstrapGenerateInput): BootstrapStructuredOutput {
-	return stabilizeGeneratedOutput(input, {
-		projectName: projectName(input.cwd),
-		identity: resolveDefaultIdentity(input.cwd, input.projectType, input.siblingFiles).text,
+	const tomlFiles = input.tomlFiles ?? createTomlFileReader(input.cwd);
+	const sharedInput = input.tomlFiles ? input : { ...input, tomlFiles };
+	return stabilizeGeneratedOutput(sharedInput, {
+		projectName: projectName(input.cwd, tomlFiles),
+		identity: resolveDefaultIdentity(input.cwd, input.projectType, input.siblingFiles, tomlFiles).text,
 		conventions: inferConventions(input.cwd, input.siblingFiles, input.codewiki),
 		invariants: inferInvariants(input.siblingFiles),
 		sections: inferHeuristicSections(input),
@@ -1229,6 +1235,7 @@ function codewikiEntryPoints(codewiki: Codewiki, limit = 6): string[] {
 
 export async function runBootstrap(input: RunBootstrapInput = {}): Promise<RunBootstrapResult> {
 	const cwd = input.cwd ?? process.cwd();
+	const tomlFiles = createTomlFileReader(cwd);
 	const projectType = detectProjectType(cwd);
 	progress(input, {
 		phase: "scan",
@@ -1327,7 +1334,8 @@ export async function runBootstrap(input: RunBootstrapInput = {}): Promise<RunBo
 		});
 		output = await (input.generate ?? heuristicBootstrapOutput)({
 			cwd,
-			expectedProjectName: projectName(cwd),
+			expectedProjectName: projectName(cwd, tomlFiles),
+			tomlFiles,
 			projectType,
 			siblingFiles,
 			adoption,
@@ -1342,7 +1350,8 @@ export async function runBootstrap(input: RunBootstrapInput = {}): Promise<RunBo
 		output = stabilizeGeneratedOutput(
 			{
 				cwd,
-				expectedProjectName: projectName(cwd),
+				expectedProjectName: projectName(cwd, tomlFiles),
+				tomlFiles,
 				projectType,
 				siblingFiles,
 				adoption,
@@ -1372,7 +1381,7 @@ export async function runBootstrap(input: RunBootstrapInput = {}): Promise<RunBo
 	} else {
 		output = existingParsed
 			? bootstrapOutputFromParsed(existingParsed)
-			: await heuristicBootstrapOutput({ cwd, projectType, siblingFiles, adoption, codewiki });
+			: await heuristicBootstrapOutput({ cwd, tomlFiles, projectType, siblingFiles, adoption, codewiki });
 		progress(input, {
 			phase: "generate",
 			status: "completed",