@iowarp/clio-coder 0.3.1 → 0.3.2

package/src/core/config.ts

@@ -433,6 +433,75 @@ function validatePricing(
 	return out;
 }
 
+function validateLmStudioSettings(
+	issues: Issues,
+	path: string,
+	value: unknown,
+): ClioSettings["targets"][number]["lmstudio"] | undefined {
+	if (!isPlainObject(value)) {
+		issues.add(path, `expected a map, got ${describe(value)}`);
+		return undefined;
+	}
+	issues.unknownKeys(path, value, ["load", "request"]);
+	const out: NonNullable<ClioSettings["targets"][number]["lmstudio"]> = {};
+	if ("load" in value) {
+		if (!isPlainObject(value.load)) {
+			issues.add(`${path}.load`, `expected a map, got ${describe(value.load)}`);
+		} else {
+			issues.unknownKeys(`${path}.load`, value.load, [
+				"contextLength",
+				"flashAttention",
+				"evalBatchSize",
+				"numExperts",
+				"offloadKvCacheToGpu",
+			]);
+			const load: NonNullable<typeof out.load> = {};
+			for (const key of ["contextLength", "evalBatchSize", "numExperts"] as const) {
+				if (key in value.load) {
+					const parsed = expectInteger(issues, `${path}.load.${key}`, value.load[key], { min: 1 });
+					if (parsed !== undefined) load[key] = parsed;
+				}
+			}
+			for (const key of ["flashAttention", "offloadKvCacheToGpu"] as const) {
+				if (key in value.load) {
+					const parsed = expectBoolean(issues, `${path}.load.${key}`, value.load[key]);
+					if (parsed !== undefined) load[key] = parsed;
+				}
+			}
+			if (Object.keys(load).length > 0) out.load = load;
+		}
+	}
+	if ("request" in value) {
+		if (!isPlainObject(value.request)) {
+			issues.add(`${path}.request`, `expected a map, got ${describe(value.request)}`);
+		} else {
+			issues.unknownKeys(`${path}.request`, value.request, ["ttlSeconds", "draftModel", "reasoning"]);
+			const request: NonNullable<typeof out.request> = {};
+			if ("ttlSeconds" in value.request) {
+				const parsed = expectInteger(issues, `${path}.request.ttlSeconds`, value.request.ttlSeconds, { min: 1 });
+				if (parsed !== undefined) request.ttlSeconds = parsed;
+			}
+			if ("draftModel" in value.request) {
+				const parsed = expectString(issues, `${path}.request.draftModel`, value.request.draftModel);
+				if (parsed !== undefined) request.draftModel = parsed;
+			}
+			if ("reasoning" in value.request) {
+				const parsed = expectEnum(issues, `${path}.request.reasoning`, value.request.reasoning, [
+					"auto",
+					"off",
+					"on",
+					"low",
+					"medium",
+					"high",
+				] as const);
+				if (parsed !== undefined) request.reasoning = parsed;
+			}
+			if (Object.keys(request).length > 0) out.request = request;
+		}
+	}
+	return Object.keys(out).length > 0 ? out : undefined;
+}
+
 function validateTarget(issues: Issues, path: string, value: unknown): ClioSettings["targets"][number] | null {
 	if (!isPlainObject(value)) {
 		issues.add(path, `expected a map, got ${describe(value)}`);
@@ -449,6 +518,7 @@ function validateTarget(issues: Issues, path: string, value: unknown): ClioSetti
 		"lifecycle",
 		"gateway",
 		"pricing",
+		"lmstudio",
 	]);
 	const id = "id" in value ? expectString(issues, `${path}.id`, value.id) : undefined;
 	const runtime = "runtime" in value ? expectString(issues, `${path}.runtime`, value.runtime) : undefined;
@@ -490,6 +560,10 @@ function validateTarget(issues: Issues, path: string, value: unknown): ClioSetti
 		const v = validatePricing(issues, `${path}.pricing`, value.pricing);
 		if (v !== undefined) target.pricing = v;
 	}
+	if ("lmstudio" in value) {
+		const v = validateLmStudioSettings(issues, `${path}.lmstudio`, value.lmstudio);
+		if (v !== undefined) target.lmstudio = v;
+	}
 	return target;
 }
 
@@ -890,6 +964,7 @@ const TOP_LEVEL_KEYS = [
 	"theme",
 	"terminal",
 	"skills",
+	"attribution",
 	"delegation",
 	"keybindings",
 	"compaction",
@@ -1236,7 +1311,13 @@ export function validateSettings(raw: unknown): SettingsValidationResult {
 		if (!isPlainObject(raw.terminal)) {
 			issues.add("terminal", `expected a map, got ${describe(raw.terminal)}`);
 		} else {
-			issues.unknownKeys("terminal", raw.terminal, ["showTerminalProgress", "outputVerbosity"]);
+			issues.unknownKeys("terminal", raw.terminal, [
+				"showTerminalProgress",
+				"outputVerbosity",
+				"tuiMode",
+				"fullscreenScrollbar",
+				"smoothStreaming",
+			]);
 			if ("showTerminalProgress" in raw.terminal) {
 				const v = expectBoolean(issues, "terminal.showTerminalProgress", raw.terminal.showTerminalProgress);
 				if (v !== undefined) settings.terminal.showTerminalProgress = v;
@@ -1246,6 +1327,21 @@ export function validateSettings(raw: unknown): SettingsValidationResult {
 				if (v === "minimal" || v === "default" || v === "verbose") settings.terminal.outputVerbosity = v;
 				else if (v !== undefined) issues.add("terminal.outputVerbosity", "expected minimal, default, or verbose");
 			}
+			if ("tuiMode" in raw.terminal) {
+				const v = expectString(issues, "terminal.tuiMode", raw.terminal.tuiMode);
+				if (v === "regular" || v === "fullscreen") settings.terminal.tuiMode = v;
+				else if (v !== undefined) issues.add("terminal.tuiMode", "expected regular or fullscreen");
+			}
+			if ("fullscreenScrollbar" in raw.terminal) {
+				const v = expectString(issues, "terminal.fullscreenScrollbar", raw.terminal.fullscreenScrollbar);
+				if (v === "hidden" || v === "auto" || v === "always") settings.terminal.fullscreenScrollbar = v;
+				else if (v !== undefined) issues.add("terminal.fullscreenScrollbar", "expected hidden, auto, or always");
+			}
+			if ("smoothStreaming" in raw.terminal) {
+				const v = expectString(issues, "terminal.smoothStreaming", raw.terminal.smoothStreaming);
+				if (v === "off" || v === "auto" || v === "on") settings.terminal.smoothStreaming = v;
+				else if (v !== undefined) issues.add("terminal.smoothStreaming", "expected off, auto, or on");
+			}
 		}
 	}
 
@@ -1261,6 +1357,18 @@ export function validateSettings(raw: unknown): SettingsValidationResult {
 		}
 	}
 
+	if ("attribution" in raw) {
+		if (!isPlainObject(raw.attribution)) {
+			issues.add("attribution", `expected a map, got ${describe(raw.attribution)}`);
+		} else {
+			issues.unknownKeys("attribution", raw.attribution, ["gitCommits"]);
+			if ("gitCommits" in raw.attribution) {
+				const v = expectBoolean(issues, "attribution.gitCommits", raw.attribution.gitCommits);
+				if (v !== undefined) settings.attribution.gitCommits = v;
+			}
+		}
+	}
+
 	if ("delegation" in raw) {
 		settings.delegation = validateDelegation(issues, raw.delegation);
 	}
@@ -1413,7 +1521,7 @@ function readSavedDocument(): unknown {
  * (or stay absent), so materialized defaults such as `workers.profiles: {}`
  * never leak into a file that never had them.
  */
-function applySettingsDelta(saved: unknown, before: unknown, after: unknown): unknown {
+export function applySettingsDelta(saved: unknown, before: unknown, after: unknown): unknown {
 	if (!isPlainObject(before) || !isPlainObject(after)) return cloneValue(after);
 	const out: Record<string, unknown> = isPlainObject(saved) ? { ...saved } : {};
 	for (const [key, next] of Object.entries(after)) {
@@ -1452,6 +1560,27 @@ export interface SettingsUpdateOptions {
 	timeoutMs?: number;
 }
 
+/**
+ * Replace the raw user settings document under the same cross-process lock as
+ * `updateSettings`. Workspace-aware layering owns the only current caller: it
+ * computes and validates the candidate against the project layers before this
+ * helper commits the raw user-layer delta.
+ */
+export function updateSavedSettingsDocument(
+	mutate: (saved: unknown) => unknown,
+	options: SettingsUpdateOptions = {},
+): void {
+	withSettingsLock(() => {
+		// Keep the strict gate updateSettings has always used. readSavedDocument
+		// deliberately degrades parse/read failures to `{}` for recovery callers;
+		// writing through that degraded value would erase a malformed, null, or
+		// transiently unreadable operator document.
+		readSettings();
+		const saved = readSavedDocument();
+		persistSettings(mutate(cloneValue(saved)));
+	}, options);
+}
+
 export function settingsLockPath(): string {
 	return `${settingsPath()}.lock`;
 }

package/src/core/defaults.ts

@@ -78,7 +78,7 @@ export interface WorkersSettings {
  *
  * Fields:
  *   - auto: master switch for the chat-loop's pre-request trigger. Manual
- *     /compact still runs when auto=false.
+ *     /context compact still runs when auto=false.
  *   - threshold: context pressure (estimated_tokens / context_window, 0..1)
  *     at which compaction acts: stale observations are masked first, and a
  *     full LLM summary runs if pressure stays above the threshold.
@@ -113,11 +113,20 @@ export interface RetrySettings {
 }
 
 export type OutputVerbosity = "minimal" | "default" | "verbose";
+export type TuiMode = "regular" | "fullscreen";
+export type FullscreenScrollbar = "hidden" | "auto" | "always";
+export type SmoothStreaming = "off" | "auto" | "on";
 
 export interface TerminalSettings {
 	showTerminalProgress: boolean;
 	/** Transcript detail: collapsed, balanced, or fully transparent. */
 	outputVerbosity: OutputVerbosity;
+	/** Regular scrollback-preserving renderer or alternate-screen sticky layout. */
+	tuiMode: TuiMode;
+	/** Fullscreen transcript scrollbar visibility. */
+	fullscreenScrollbar: FullscreenScrollbar;
+	/** Presentation-only pacing for streamed assistant text and thinking. */
+	smoothStreaming: SmoothStreaming;
 }
 
 export interface ModelSelectorSettings {
@@ -131,6 +140,11 @@ export interface SkillsSettings {
 	trustProjectCompatRoots: boolean;
 }
 
+export interface AttributionSettings {
+	/** Evidence-aware role trailers on commits created through Clio. */
+	gitCommits: boolean;
+}
+
 export type DelegationToolGovernance = "clio-policy" | "agent-managed" | "deny-all";
 
 /**
@@ -314,10 +328,16 @@ export const DEFAULT_SETTINGS = {
 	terminal: {
 		showTerminalProgress: false,
 		outputVerbosity: "default",
+		tuiMode: "regular",
+		fullscreenScrollbar: "auto",
+		smoothStreaming: "off",
 	} as TerminalSettings,
 	skills: {
 		trustProjectCompatRoots: false,
 	} as SkillsSettings,
+	attribution: {
+		gitCommits: true,
+	} as AttributionSettings,
 	delegation: {
 		agents: [] as DelegationAgentConfig[],
 		defaults: {
@@ -391,7 +411,7 @@ autonomy: auto-edit         # read-only | suggest | auto-edit | full-auto
 # directory next to this file).
 targets: []
 # Local runtime examples (uncomment/adapt one; replace your-model-id):
-#   clio-coder configure --id local-lmstudio --runtime lmstudio-native --url http://localhost:1234 --model your-model-id --set-orchestrator --set-fleet-default
+#   clio-coder configure --id local-lmstudio --runtime lmstudio --url http://localhost:1234 --model your-model-id --set-orchestrator --set-fleet-default
 #   clio-coder configure --id local-ollama --runtime ollama-native --url http://localhost:11434 --model your-model-id --set-orchestrator --set-fleet-default
 #   clio-coder configure --id local-llamacpp --runtime llamacpp --url http://127.0.0.1:8080 --model your-model-id --set-orchestrator --set-fleet-default
 #   clio-coder configure --id local-vllm --runtime vllm --url http://localhost:8000 --model your-model-id --set-orchestrator --set-fleet-default
@@ -402,7 +422,7 @@ targets: []
 # Example target block equivalent to one configured local runtime:
 # targets:
 #   - id: local-lmstudio
-#     runtime: lmstudio-native
+#     runtime: lmstudio
 #     url: http://localhost:1234
 #     defaultModel: your-model-id
 #     capabilities:
@@ -498,7 +518,7 @@ routing:
 # Alt+J / Alt+K cycling order: plain target ids or "target/model" refs.
 scope: []
 
-# /models focused picker. Favorites are exact "target/model" refs shown before
+# /model focused picker. Favorites are exact "target/model" refs shown before
 # the full search catalog. Recently selected models are runtime state and live
 # in the state dir (recent-models.json), not in this file.
 modelSelector:
@@ -525,6 +545,15 @@ terminal:
   showTerminalProgress: false
   # Transcript detail: minimal, default, or verbose. Also changeable with /output.
   outputVerbosity: default
+  # regular preserves terminal scrollback; fullscreen keeps the editor/footer
+  # sticky above an independently scrollable alternate-screen transcript.
+  tuiMode: regular
+  # hidden, auto (visible while scrolling), or always in fullscreen mode.
+  fullscreenScrollbar: auto
+  # off preserves immediate 16ms coalescing; auto paces only on a capable,
+  # accessibility-safe local TTY; on requests pacing but still honors stdout
+  # backpressure. CLIO_CODER_SMOOTH_STREAM overrides this for one process.
+  smoothStreaming: off
 
 # Skills are local prompt resources. Project-local compatibility roots such as
 # .agents/skills, .claude/skills, .codex/skills, .github/skills, and
@@ -533,6 +562,11 @@ terminal:
 skills:
   trustProjectCompatRoots: false
 
+# Evidence-aware Git commit provenance. The identity and trailer semantics are
+# compiled into Clio; this switch only enables or disables attribution.
+attribution:
+  gitCommits: true
+
 # External coding agents that speak Agent Client Protocol v1 over stdio.
 # These are delegated harnesses, not model targets, so they stay outside
 # targets[], orchestrator, workers, and model pickers.
@@ -574,7 +608,7 @@ keybindings: {}
 
 # Context compaction controls.
 #   auto              master switch for the pre-request compaction trigger.
-#                     Manual /compact always runs the LLM summary.
+#                     Manual /context compact always runs the LLM summary.
 #   threshold         pressure = estimated_tokens / context_window. Crossing
 #                     it masks stale tool observations first, then runs a
 #                     full LLM summary if pressure stays above the threshold.

package/src/core/domain-loader.ts

@@ -17,7 +17,7 @@
 import { BusChannels } from "./bus-events.js";
 import type { SafeEventBus } from "./event-bus.js";
 import { getSharedBus } from "./shared-bus.js";
-import { resolveShutdownHookBudgetMs, runWithBudget } from "./termination.js";
+import { resolveShutdownHookBudgetMs, runWithBudget, writeShutdownNotice } from "./termination.js";
 
 export interface DomainManifest {
 	name: string;
@@ -60,7 +60,10 @@ export interface LoadResult {
 	stop(): Promise<void>;
 }
 
-export async function loadDomains(modules: ReadonlyArray<DomainModule>): Promise<LoadResult> {
+export async function loadDomains(
+	modules: ReadonlyArray<DomainModule>,
+	options: { diagnostic?: (text: string) => void } = {},
+): Promise<LoadResult> {
 	const order = topoSort(modules);
 	const contracts = new Map<string, DomainContract>();
 	const extensions = new Map<string, DomainExtension>();
@@ -91,7 +94,9 @@ export async function loadDomains(modules: ReadonlyArray<DomainModule>): Promise
 			// The throw below aborts boot; nothing downstream gets a chance to
 			// render the failure, so the structured line must land first.
 			const message = error instanceof Error ? error.message : String(error);
-			process.stderr.write(`[clio:domain] load failed: ${name}: ${message}\n`);
+			(options.diagnostic ?? ((text: string) => process.stderr.write(text)))(
+				`[clio:domain] load failed: ${name}: ${message}\n`,
+			);
 			throw new DomainLoadError(name, error);
 		}
 	}
@@ -105,10 +110,12 @@ export async function loadDomains(modules: ReadonlyArray<DomainModule>): Promise
 			const stopFn = ext.stop.bind(ext);
 			const t0 = debug ? process.hrtime.bigint() : 0n;
 			const completed = await runWithBudget(stopFn, budgetMs, (err) => {
-				console.error(`[clio:domain-loader] ${name}.stop() failed:`, err);
+				const message = err instanceof Error ? err.message : String(err);
+				writeShutdownNotice(`[clio:domain-loader] ${name}.stop() failed: ${message}`);
+				if (debug && err instanceof Error && err.stack) process.stderr.write(`${err.stack}\n`);
 			});
 			if (!completed) {
-				process.stderr.write(`[clio:domain-loader] ${name}.stop() exceeded ${budgetMs}ms budget; abandoning\n`);
+				writeShutdownNotice(`[clio:domain-loader] ${name}.stop() exceeded ${budgetMs}ms budget; abandoning`);
 			}
 			if (debug) {
 				const dt = Number(process.hrtime.bigint() - t0) / 1e6;