@iowarp/clio-coder 0.4.1 → 0.4.2

package/src/domains/providers/runtime-resolution.ts

@@ -273,6 +273,34 @@ function appendThinkingDiagnostics(
 	diagnostics.push(diagnostic(severity, `thinking-${thinking.noticeKind}`, thinking.notice));
 }
 
+const CHAT_TEMPLATE_KWARGS_UNDELIVERABLE = "chat-template-kwargs-undeliverable";
+
+/**
+ * One warning when the family declares chat-template kwargs the runtime
+ * cannot carry (#268). LM Studio ignores `chat_template_kwargs` for every
+ * family measured, so a Nemotron 3.5 target on that runtime runs without the
+ * `force_nonempty_content` its card asks for; the operator sees that once per
+ * target and model rather than finding the key silently missing from the wire.
+ */
+function appendChatTemplateKwargsDiagnostics(
+	diagnostics: RuntimeResolutionDiagnostic[],
+	resolved: ResolvedModelRuntimeCapabilities,
+): void {
+	const undeliverable = resolved.request.undeliverableChatTemplateKwargs;
+	if (!undeliverable || undeliverable.keys.length === 0) return;
+	const keys = undeliverable.keys.join(", ");
+	const declared = undeliverable.declaredUnsupported
+		? "its family entry marks them unsupported there"
+		: "its family entry does not say so";
+	diagnostics.push(
+		diagnostic(
+			"warning",
+			CHAT_TEMPLATE_KWARGS_UNDELIVERABLE,
+			`chat-template kwargs ${keys} cannot reach ${resolved.runtimeId}, which ignores chat_template_kwargs; ${resolved.modelId} runs without them and ${declared}`,
+		),
+	);
+}
+
 function nonNegativeFiniteNumber(value: unknown): number | undefined {
 	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
 }
@@ -447,6 +475,7 @@ export function resolveRuntimeTarget(
 	const decisions = capabilityDecisions(runtime, capabilities);
 	appendCapabilityDiagnostics(diagnostics, input, capabilities, decisions, targetId);
 	appendThinkingDiagnostics(diagnostics, modelRuntime, requestedThinkingLevel);
+	appendChatTemplateKwargsDiagnostics(diagnostics, modelRuntime);
 
 	if (hasError(diagnostics)) return { ok: false, diagnostics };
 
@@ -493,6 +522,7 @@ function withoutStaleRuntimeDiagnostics(
 ): RuntimeResolutionDiagnostic[] {
 	return diagnostics.filter((entry) => {
 		if (entry.code.startsWith("thinking-")) return false;
+		if (entry.code === CHAT_TEMPLATE_KWARGS_UNDELIVERABLE) return false;
 		if (entry.code === "output-budget-unknown" && decisions.maxTokens > 0) return false;
 		if (entry.code === "tools-unsupported" && decisions.tools) return false;
 		return true;
@@ -545,6 +575,7 @@ export function refineRuntimeTargetWithModelHints(
 	const decisions = capabilityDecisions(target.runtime, capabilities);
 	const diagnostics = withoutStaleRuntimeDiagnostics(target.diagnostics, decisions);
 	appendThinkingDiagnostics(diagnostics, modelRuntime, target.requestedThinkingLevel);
+	appendChatTemplateKwargsDiagnostics(diagnostics, modelRuntime);
 	return {
 		...target,
 		capabilities,

package/src/domains/providers/runtimes/common/probe-helpers.ts

@@ -374,6 +374,8 @@ export interface LlamaCppStatusEnrichment {
 	modelId?: string;
 	serverFlags?: LlamaCppServerFlags;
 	notes?: string[];
+	/** The router's own load state for the selected model, when it reports one. */
+	loadState?: ProbeModelStatus["state"];
 }
 
 function argsFromStatus(status: unknown): string[] {
@@ -490,8 +492,11 @@ export async function probeLlamaCppModelStatus(
 	const entries = await probeOpenAIModelEntries(base, ctx);
 	const selected = selectedModelEntry(entries, target);
 	if (!selected) return {};
+	const loadState = modelStateFromOpenAIModelEntry({ id: selected.id, status: selected.status })?.state;
+	const withState = (enrichment: LlamaCppStatusEnrichment): LlamaCppStatusEnrichment =>
+		loadState === undefined ? enrichment : { ...enrichment, loadState };
 	const args = argsFromStatus(selected.status);
-	if (args.length === 0) return { notes: statusNotes(selected.id, selected.status) };
+	if (args.length === 0) return withState({ notes: statusNotes(selected.id, selected.status) });
 	const flags = parseLlamaCppServerFlags(args);
 	const caps: Partial<CapabilityFlags> = {};
 	const window = llamaCppRequestContextWindow(flags);
@@ -512,7 +517,7 @@ export async function probeLlamaCppModelStatus(
 		);
 	}
 	if (notes.length > 0) enrichment.notes = notes;
-	return enrichment;
+	return withState(enrichment);
 }
 
 /**

package/src/domains/providers/runtimes/local-native/llamacpp.ts

@@ -56,7 +56,15 @@ const llamacppRuntime: RuntimeDescriptor = {
 		const health = await (ctx.signal ? probeHttp({ ...healthOpts, signal: ctx.signal }) : probeHttp(healthOpts));
 		if (!health.ok) return health;
 		const status = await probeLlamaCppModelStatus(base, target, ctx);
-		const props = await probeLlamaCppProps(base, ctx, status.modelId ?? target.defaultModel);
+		// A router answers /props?model=<id> by loading that model, and with
+		// --models-max 1 that evicts whatever is resident: every probe of a
+		// fleet target's default model unloaded the chat model, so the next turn
+		// prefilled from zero (11,601 tokens, cache_n 0, on the round-3 resume
+		// run on mini). The router's model list already carries the worker's
+		// flags (--parallel, --ctx-size) for an unloaded model, so the worker is
+		// asked only when it is resident.
+		const resident = status.loadState === undefined || status.loadState === "loaded";
+		const props = await probeLlamaCppProps(base, ctx, resident ? (status.modelId ?? target.defaultModel) : undefined);
 		const catalog = await probeOpenAIModelCatalog(base, ctx);
 		const result: ProbeResult = { ok: true };
 		if (catalog.models.length > 0) result.models = catalog.models;

package/src/domains/providers/types/cost-provenance.ts

@@ -5,3 +5,22 @@ export type CostProvenance = "known" | "known_free" | "estimated" | "unknown";
 export function normalizeCostProvenance(value: CostProvenance | undefined): CostProvenance {
 	return value ?? "unknown";
 }
+
+const COST_PROVENANCE_VALUES: ReadonlySet<string> = new Set<CostProvenance>([
+	"known",
+	"known_free",
+	"estimated",
+	"unknown",
+]);
+
+/**
+ * Validate an unvalidated wire value (a dispatch bus payload crossing a
+ * worker process boundary, never runtime-checked against this closed set
+ * before) against the four real provenance values. An unrecognized value
+ * keeps `fallback` rather than being accepted as-is, matching how the
+ * observability projection's run summary already treated this field; the
+ * interactive dispatch board previously accepted any truthy string here.
+ */
+export function resolveCostProvenance(value: unknown, fallback: CostProvenance): CostProvenance {
+	return typeof value === "string" && COST_PROVENANCE_VALUES.has(value) ? (value as CostProvenance) : fallback;
+}

package/src/domains/providers/types/local-model-quirks.ts

@@ -2,7 +2,7 @@
  * Engine-visible quirks extracted from a knowledge-base entry. The catalog YAML
  * keeps free-form `quirks` (gpu tiers, runtime preferences, serving notes), so
  * `KnowledgeBaseEntry.quirks` stays `Record<string, unknown>`. This module
- * narrows the slice the engine consumes (KV cache layout, per-mode sampling)
+ * narrows the slice the engine consumes (per-mode sampling and thinking)
  * into a typed shape that flows through `model.clioCoder.quirks` at synth time.
  *
  * Field naming follows the Hugging Face / model-card terminology so the YAML
@@ -13,19 +13,7 @@
  */
 
 import type { ThinkingBudgetByLevel, ThinkingEffortByLevel } from "../thinking-control-policy.js";
-
-export const KV_CACHE_QUANTS = ["f32", "f16", "q8_0", "q4_0", "q4_1", "iq4_nl", "q5_0", "q5_1"] as const;
-
-export type KvCacheQuant = (typeof KV_CACHE_QUANTS)[number];
-
-export interface KvCacheQuirks {
-	/** Quantization type for the key cache. `false` disables quantization (full precision). */
-	kQuant?: KvCacheQuant | false;
-	/** Quantization type for the value cache. Requires flash attention to take effect. */
-	vQuant?: KvCacheQuant | false;
-	/** Force fp16 KV cache regardless of K/V quant settings. */
-	useFp16?: boolean;
-}
+import { type ThinkingLevel, VALID_THINKING_LEVELS } from "./capability-flags.js";
 
 export interface SamplingProfile {
 	temperature?: number;
@@ -36,7 +24,6 @@ export interface SamplingProfile {
 	repeatPenalty?: number;
 	presencePenalty?: number;
 	frequencyPenalty?: number;
-	maxTokens?: number;
 }
 
 export interface SamplingQuirks {
@@ -59,6 +46,20 @@ export interface SamplingQuirks {
  */
 export type ThinkingMechanism = "effort-levels" | "budget-tokens" | "on-off" | "always-on" | "none";
 
+export type ChatTemplateKwargValue = string | number | boolean;
+
+export interface ChatTemplateKwargsByLevel {
+	key: string;
+	values: Partial<Record<ThinkingLevel, string | number>>;
+	lmstudio?: "unsupported" | string;
+}
+
+export interface ChatTemplateKwargsQuirks {
+	static?: Record<string, ChatTemplateKwargValue>;
+	byLevel?: ChatTemplateKwargsByLevel;
+	lmstudio?: "unsupported" | string | Record<string, string>;
+}
+
 export interface ThinkingQuirks {
 	mechanism: ThinkingMechanism;
 	/** Token budget for budget-tokens mechanism, keyed by Clio's thinking level. */
@@ -67,24 +68,19 @@ export interface ThinkingQuirks {
 	effortByLevel?: ThinkingEffortByLevel;
 	/** 2-5 line free-text guidance rendered into the Runtime prompt block. */
 	guidance?: string;
+	chatTemplateKwargs?: ChatTemplateKwargsQuirks;
 }
 
 export interface LocalModelQuirks {
-	kvCache?: KvCacheQuirks;
 	sampling?: SamplingQuirks;
 	thinking?: ThinkingQuirks;
+	chatTemplateKwargs?: ChatTemplateKwargsQuirks;
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 
-function asKvCacheQuant(value: unknown): KvCacheQuant | false | undefined {
-	if (value === false) return false;
-	if (typeof value !== "string") return undefined;
-	return (KV_CACHE_QUANTS as ReadonlyArray<string>).includes(value) ? (value as KvCacheQuant) : undefined;
-}
-
 function asPositive(value: unknown): number | undefined {
 	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
 }
@@ -98,17 +94,6 @@ function asPenalty(value: unknown): number | undefined {
 	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
 
-function extractKvCache(raw: unknown): KvCacheQuirks | undefined {
-	if (!isRecord(raw)) return undefined;
-	const out: KvCacheQuirks = {};
-	const k = asKvCacheQuant(raw.kQuant);
-	if (k !== undefined) out.kQuant = k;
-	const v = asKvCacheQuant(raw.vQuant);
-	if (v !== undefined) out.vQuant = v;
-	if (typeof raw.useFp16 === "boolean") out.useFp16 = raw.useFp16;
-	return Object.keys(out).length > 0 ? out : undefined;
-}
-
 function extractSamplingProfile(raw: unknown): SamplingProfile | undefined {
 	if (!isRecord(raw)) return undefined;
 	const out: SamplingProfile = {};
@@ -129,8 +114,6 @@ function extractSamplingProfile(raw: unknown): SamplingProfile | undefined {
 	if (pp !== undefined) out.presencePenalty = pp;
 	const fp = asPenalty(raw.frequencyPenalty);
 	if (fp !== undefined) out.frequencyPenalty = fp;
-	const maxTokens = asInteger(raw.maxTokens);
-	if (maxTokens !== undefined) out.maxTokens = maxTokens;
 	return Object.keys(out).length > 0 ? out : undefined;
 }
 
@@ -185,6 +168,66 @@ function extractEffortByLevel(raw: unknown): ThinkingQuirks["effortByLevel"] | u
 	return Object.keys(out).length > 0 ? out : undefined;
 }
 
+function extractChatTemplateKwargs(raw: unknown): ChatTemplateKwargsQuirks | undefined {
+	if (!isRecord(raw)) return undefined;
+	const out: ChatTemplateKwargsQuirks = {};
+
+	if (isRecord(raw.static)) {
+		const staticMap: Record<string, ChatTemplateKwargValue> = {};
+		for (const [k, v] of Object.entries(raw.static)) {
+			if (typeof v === "boolean") {
+				staticMap[k] = v;
+			} else if (typeof v === "number" && Number.isFinite(v)) {
+				staticMap[k] = v;
+			} else if (typeof v === "string" && v.length > 0) {
+				staticMap[k] = v;
+			}
+		}
+		if (Object.keys(staticMap).length > 0) out.static = staticMap;
+	}
+
+	if (isRecord(raw.byLevel)) {
+		const byLevelRaw = raw.byLevel;
+		if (typeof byLevelRaw.key === "string" && byLevelRaw.key.trim().length > 0 && isRecord(byLevelRaw.values)) {
+			const values: Partial<Record<ThinkingLevel, string | number>> = {};
+			for (const level of VALID_THINKING_LEVELS) {
+				const val = byLevelRaw.values[level];
+				if (typeof val === "string" && val.length > 0) {
+					values[level] = val;
+				} else if (typeof val === "number" && Number.isFinite(val)) {
+					values[level] = val;
+				}
+			}
+			if (Object.keys(values).length > 0) {
+				const byLevel: ChatTemplateKwargsByLevel = {
+					key: byLevelRaw.key.trim(),
+					values,
+				};
+				if (typeof byLevelRaw.lmstudio === "string" && byLevelRaw.lmstudio.trim().length > 0) {
+					byLevel.lmstudio = byLevelRaw.lmstudio.trim();
+				}
+				out.byLevel = byLevel;
+			}
+		}
+	}
+
+	if (typeof raw.lmstudio === "string" && raw.lmstudio.trim().length > 0) {
+		out.lmstudio = raw.lmstudio.trim();
+	} else if (isRecord(raw.lmstudio)) {
+		const lmstudioMap: Record<string, string> = {};
+		for (const [k, v] of Object.entries(raw.lmstudio)) {
+			if (typeof v === "string" && v.trim().length > 0) {
+				lmstudioMap[k] = v.trim();
+			}
+		}
+		if (Object.keys(lmstudioMap).length > 0) {
+			out.lmstudio = lmstudioMap;
+		}
+	}
+
+	return Object.keys(out).length > 0 ? out : undefined;
+}
+
 function extractThinkingQuirks(raw: unknown): ThinkingQuirks | undefined {
 	if (!isRecord(raw)) return undefined;
 	const mechanism = asThinkingMechanism(raw.mechanism);
@@ -195,6 +238,8 @@ function extractThinkingQuirks(raw: unknown): ThinkingQuirks | undefined {
 	const effortByLevel = extractEffortByLevel(raw.effortByLevel);
 	if (effortByLevel) out.effortByLevel = effortByLevel;
 	if (typeof raw.guidance === "string" && raw.guidance.length > 0) out.guidance = raw.guidance;
+	const chatTemplateKwargs = extractChatTemplateKwargs(raw.chatTemplateKwargs);
+	if (chatTemplateKwargs) out.chatTemplateKwargs = chatTemplateKwargs;
 	return out;
 }
 
@@ -206,11 +251,14 @@ function extractThinkingQuirks(raw: unknown): ThinkingQuirks | undefined {
 export function extractLocalModelQuirks(raw: unknown): LocalModelQuirks | undefined {
 	if (!isRecord(raw)) return undefined;
 	const out: LocalModelQuirks = {};
-	const kvCache = extractKvCache(raw.kvCache);
-	if (kvCache) out.kvCache = kvCache;
 	const sampling = extractSampling(raw.sampling);
 	if (sampling) out.sampling = sampling;
 	const thinking = extractThinkingQuirks(raw.thinking);
 	if (thinking) out.thinking = thinking;
+	const chatTemplateKwargs =
+		extractChatTemplateKwargs(raw.chatTemplateKwargs) ??
+		extractChatTemplateKwargs(isRecord(raw.thinking) ? raw.thinking.chatTemplateKwargs : undefined) ??
+		extractChatTemplateKwargs(isRecord(raw.request) ? raw.request.chatTemplateKwargs : undefined);
+	if (chatTemplateKwargs) out.chatTemplateKwargs = chatTemplateKwargs;
 	return Object.keys(out).length > 0 ? out : undefined;
 }

package/src/domains/resources/skills/loader.ts

@@ -217,20 +217,8 @@ function defaultPrecedenceForScope(scope: ResourceScope): number {
  * this gate with skills: both substitute another agent's project file into
  * Clio's context, so one opt-in covers both.
  */
-let warnedLegacyProjectTrustEnv = false;
-
 export function projectCompatTrusted(explicit?: boolean): boolean {
-	if (explicit === true) return true;
-	if (process.env.CLIO_CODER_TRUST_PROJECT_RESOURCES === "1") return true;
-	if (process.env.CLIO_CODER_TRUST_PROJECT_SKILLS !== "1") return false;
-	if (!warnedLegacyProjectTrustEnv) {
-		warnedLegacyProjectTrustEnv = true;
-		process.emitWarning("CLIO_CODER_TRUST_PROJECT_SKILLS is deprecated; use CLIO_CODER_TRUST_PROJECT_RESOURCES instead", {
-			code: "CLIO_CODER_DEPRECATED_ENV",
-			type: "DeprecationWarning",
-		});
-	}
-	return true;
+	return explicit === true;
 }
 
 /**
@@ -453,7 +441,16 @@ function validateDescription(description: string | null): string[] {
 	return [];
 }
 
-function extractMetadata(frontmatter: Record<string, unknown>): Record<string, unknown> {
+/**
+ * The deprecation names the file: a bare "clio: skill metadata" warning at
+ * boot left the operator hunting across five compatibility roots for the
+ * SKILL.md that carried the key, and `doctor` scanned only two of them.
+ */
+function warnLegacySkillMetadata(filePath: string): void {
+	warnLegacyNaming(`clio: skill metadata in ${filePath}`, "clio-coder: skill metadata");
+}
+
+function extractMetadata(frontmatter: Record<string, unknown>, filePath: string): Record<string, unknown> {
 	const metadata: Record<string, unknown> = {};
 	for (const [key, value] of Object.entries(frontmatter)) {
 		if (CORE_FRONTMATTER_KEYS.has(key)) continue;
@@ -462,7 +459,7 @@ function extractMetadata(frontmatter: Record<string, unknown>): Record<string, u
 			continue;
 		}
 		if (key === "clio") {
-			warnLegacyNaming("clio: skill metadata", "clio-coder: skill metadata");
+			warnLegacySkillMetadata(filePath);
 			if (!("clio-coder" in frontmatter)) metadata.clioCoder = value;
 			continue;
 		}
@@ -471,13 +468,13 @@ function extractMetadata(frontmatter: Record<string, unknown>): Record<string, u
 	return metadata;
 }
 
-function extractProvenance(frontmatter: Record<string, unknown>): SkillProvenance | undefined {
+function extractProvenance(frontmatter: Record<string, unknown>, filePath: string): SkillProvenance | undefined {
 	// Provenance lives nested under the reserved `clio-coder:` block; the flat
 	// top-level keys remain readable for already-installed copies stamped
 	// before the nested form existed.
 	const canonicalRaw = frontmatter["clio-coder"];
 	const legacyRaw = frontmatter.clio;
-	if (legacyRaw !== undefined) warnLegacyNaming("clio: skill metadata", "clio-coder: skill metadata");
+	if (legacyRaw !== undefined) warnLegacySkillMetadata(filePath);
 	const clioCoderRaw = canonicalRaw ?? legacyRaw;
 	const clioCoder =
 		clioCoderRaw !== null && typeof clioCoderRaw === "object" && !Array.isArray(clioCoderRaw)
@@ -671,7 +668,7 @@ function loadSkillFile(
 		scope,
 		...(root.origin ? { source: root.origin } : {}),
 	};
-	const provenance = extractProvenance(parsed.frontmatter);
+	const provenance = extractProvenance(parsed.frontmatter, filePath);
 	const allowedTools = declaredToolSurface(parsed.frontmatter, "allowed-tools", filePath, diagnostics);
 	const disallowedTools = declaredToolSurface(parsed.frontmatter, "disallowed-tools", filePath, diagnostics);
 	const skill: Skill = {
@@ -691,7 +688,7 @@ function loadSkillFile(
 		pathSubject,
 		trusted: root.trusted ?? true,
 		precedence: root.precedence ?? defaultPrecedenceForScope(scope),
-		metadata: extractMetadata(parsed.frontmatter),
+		metadata: extractMetadata(parsed.frontmatter, filePath),
 		diagnostics,
 		...(provenance ? { provenance } : {}),
 	};

package/src/domains/safety/call-target.ts

@@ -168,7 +168,7 @@ const CALL_TARGET_FIELDS: Readonly<Record<string, ReadonlyArray<string>>> = {
 	grep: ["pattern", "path", "mode", "glob", "ignore_case", "literal", "context", "limit", "include_ignored"],
 	find: ["pattern", "path", "order", "limit", "include_ignored"],
 	ls: ["path", "limit"],
-	code_nav: ["mode", "query", "limit"],
+	code_nav: ["source", "mode", "query", "limit"],
 	context: ["scope", "query", "name", "limit", "ref", "include_tree"],
 	credential_present: ["name", "source", "file"],
 	write: ["path"],

package/src/domains/safety/loop-detector.ts

@@ -33,10 +33,12 @@ const DEFAULT_WINDOW_MS = 30_000;
 // stops them before they burn a turn. Callers that need a different cadence
 // pass `maxRepeats` explicitly.
 const DEFAULT_MAX_REPEATS = 3;
-// Sized so a consecutive or single-interleaved verbatim spiral still counts
-// its third repeat at any call latency, while an identical check separated by
-// two or more other calls (a fix-verify loop) stays below the threshold.
-const DEFAULT_KEEP_LAST_ATTEMPTS = 4;
+// Sized so a batch-shaped spiral still counts its third repeat at any call
+// latency: a model that re-emits the same parallel batch of up to sixteen
+// calls three times has every key inside the retained tail. Fix-verify loops
+// are not this detector's concern any more; the loop guard keys attempts by
+// the turn's write/edit epoch, so a check rerun after a change is a new key.
+const DEFAULT_KEEP_LAST_ATTEMPTS = 48;
 
 export function createLoopState(opts?: {
 	windowMs?: number;
@@ -138,6 +140,7 @@ export function observe(state: LoopDetectorState, key: string, now: number): [Lo
 		recent: next,
 		windowMs: state.windowMs,
 		maxRepeats: state.maxRepeats,
+		keepLastAttempts: keepLast,
 	};
 	return [newState, { looping, key, count }];
 }

package/src/domains/session/task-board.ts

@@ -421,10 +421,8 @@ function applyMutation(
 	// Completion is the ledger's only load-bearing claim, so it carries two
 	// structural conditions rather than a bare status flip. Evidence is
 	// mandatory: a completed row becomes a passed validation record, and a row
-	// without evidence would assert a validation that nobody performed. The
-	// task must also have been started, because work that was never entered
-	// cannot have produced a result; the honest closes for it are block and
-	// drop, which record a reason instead.
+	// without evidence would assert a validation that nobody performed. Work
+	// that did not happen is closed with block or drop, which record a reason.
 	if (mutation.op === "done") {
 		if (mutation.evidence.trim().length === 0) {
 			return {
@@ -432,13 +430,16 @@ function applyMutation(
 					"done requires note as the evidence that the task actually finished (the command you ran, the file:line you verified). If the work did not happen, use block with a reason or drop it.",
 			};
 		}
-		if (target.status === "pending") {
-			return {
-				error: `task ${target.id} was never started, so it cannot be completed. Start it and do the work, or record the truth with block (reason) or drop.`,
-			};
-		}
 	}
 	const notes: string[] = [];
+	// A model that did the work without announcing it on the board closes
+	// several tasks in a row at the end of the turn. Refusing done on a pending
+	// task cost a live session six start/done pairs of pure ceremony; the
+	// evidence note is the load-bearing claim, so the start is recorded
+	// implicitly and named in the notes.
+	if (mutation.op === "done" && target.status === "pending") {
+		notes.push(`started ${target.id} implicitly: done on a pending task records the start and the completion together`);
+	}
 	const tasks = board.tasks.map((task): TaskBoardTask => {
 		if (task.id !== target.id) {
 			// One active task at a time: starting a task parks any other active