@iowarp/clio-coder 0.4.6 → 0.4.8

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

@@ -3,42 +3,22 @@ import path from "node:path";
 import { warnLegacyNaming } from "../../../core/naming-compat.js";
 import { resolvePackageRoot } from "../../../core/package-root.js";
 import { clioConfigDir } from "../../../core/xdg.js";
-import {
-	type InstallSkillInput,
-	type InstallSkillResult,
-	installSkillFromSource,
-	isSkillName,
-	parseSkillSourceSpec,
-	type SkillInstallShaping,
-} from "./install.js";
+import { pluginResourcePath, readPluginManifest } from "../../plugins/index.js";
+import { discoverLibrary, installLibraryPlan, planLibraryInstall, resolveLibraryPackage } from "../library.js";
+import type { InstallSkillInput, InstallSkillResult, SkillInstallShaping } from "./install.js";
 import { loadSkills, type Skill } from "./loader.js";
 
 /**
- * Local skill marketplace. Entries come from two real sources only:
- *
- *  1. A catalog directory of actual SKILL.md packages: CLIO_CODER_SKILL_CATALOG_DIR,
- *     else a repo-level skills/ folder in the working tree, else the skills/
- *     catalog the installed clio-coder package carries. Metadata is read from
- *     the packages themselves via the normal skill loader.
- *  2. A JSON index file: CLIO_CODER_SKILL_MARKETPLACE_INDEX, else
- *     <config>/skill-marketplace.json, else the skill-marketplace.json the
- *     package carries. Entries point at installable sources.
- *
- * The package fallbacks are what make a fresh npm install a marketplace at
- * all: before them, an operator outside this repository with no env var set
- * had no catalog and no index, so every bare-name install and every
- * `/skill <name>` for a catalog skill failed. The package catalog is a
- * marketplace source only, never a discovery root; catalog skills stay
- * uninstalled until the operator asks, and install copies them out of the
- * package into a Clio root without touching the network.
- *
- * There is no synthetic or hardcoded marketplace data; an empty result means
- * no marketplace is configured.
+ * Skill-facing adapter for the canonical library, plus explicit authoring probes
+ * of unmanaged source trees. Runtime offers and activation use the library;
+ * only an explicit catalogDir/indexPath request invokes a raw source audit.
  */
 
 export type MarketplaceSkillOrigin = "catalog" | "index";
-export type LibraryEntryKind = "skill" | "agent" | "prompt" | "fleet";
-export type LibraryRequirementRef = `${LibraryEntryKind}:${string}`;
+
+import type { LibraryEntryKind, LibraryRequirementRef } from "../library-types.js";
+
+export type { LibraryEntryKind, LibraryRequirementRef } from "../library-types.js";
 
 /**
  * The diagnostic that means "nothing is wrong, nothing is configured". Callers
@@ -48,10 +28,10 @@ export type LibraryRequirementRef = `${LibraryEntryKind}:${string}`;
 export const MARKETPLACE_UNCONFIGURED = "no local skill marketplace catalog or index configured";
 
 export interface MarketplaceSkill {
-	kind: LibraryEntryKind;
+	kind: Exclude<LibraryEntryKind, "plugin">;
 	name: string;
 	description: string;
-	/** Local path or URL accepted by `clio-coder skills install`. */
+	/** Local path or URL accepted by `clio-coder library install`. */
 	sourceUrl: string;
 	version?: string;
 	audit?: "pass" | "warn" | "fail" | "unknown";
@@ -96,7 +76,7 @@ export interface DiscoverMarketplaceOptions {
  */
 function packageCatalogDir(): string | null {
 	try {
-		return path.join(resolvePackageRoot(), "skills");
+		return path.join(resolvePackageRoot(), "library", "skills");
 	} catch {
 		return null;
 	}
@@ -104,7 +84,7 @@ function packageCatalogDir(): string | null {
 
 function packageIndexPath(): string | null {
 	try {
-		return path.join(resolvePackageRoot(), "skills", "skill-marketplace.json");
+		return path.join(resolvePackageRoot(), "library", "skills", "skill-marketplace.json");
 	} catch {
 		return null;
 	}
@@ -250,6 +230,8 @@ function resolveCatalogDir(options: DiscoverMarketplaceOptions): string | null {
 	if (options.catalogDir) return path.resolve(options.catalogDir);
 	const fromEnv = process.env.CLIO_CODER_SKILL_CATALOG_DIR;
 	if (fromEnv && fromEnv.trim().length > 0) return path.resolve(fromEnv.trim());
+	const repoLibraryCatalog = path.join(options.cwd ?? process.cwd(), "library", "skills");
+	if (looksLikeSkillCatalog(repoLibraryCatalog)) return repoLibraryCatalog;
 	const repoCatalog = path.join(options.cwd ?? process.cwd(), "skills");
 	if (looksLikeSkillCatalog(repoCatalog)) return repoCatalog;
 	// The package's own catalog: rows resolve to local files, so a bare-name
@@ -297,6 +279,15 @@ function catalogSkills(dir: string, diagnostics: string[]): MarketplaceSkill[] {
 }
 
 export function discoverMarketplaceSkills(options: DiscoverMarketplaceOptions = {}): MarketplaceDiscoveryResult {
+	// Automatic promotion and /skill consume the same pinned library as the CLI.
+	// Explicit source probes below support authoring audits of unmanaged skill trees.
+	if (options.indexPath === undefined && options.catalogDir === undefined) {
+		const library = discoverLibrary(options.cwd ? { cwd: options.cwd } : {});
+		const skills: MarketplaceSkill[] = library.entries
+			.filter((entry) => entry.kind === "skill" && entry.origin !== "installed")
+			.map((entry) => ({ ...entry, kind: "skill", origin: entry.origin === "index" ? "index" : "catalog" }));
+		return { status: skills.length ? "installable" : "unavailable", skills, diagnostics: library.diagnostics };
+	}
 	const diagnostics: string[] = [];
 	const skills: MarketplaceSkill[] = [];
 	const seen = new Set<string>();
@@ -367,31 +358,31 @@ export function resolveMarketplaceShaping(options: DiscoverMarketplaceOptions =
 	};
 }
 
-/**
- * The single install entry point for every frontend (headless CLI, TUI
- * pending-skill prompt, skills hub). Source resolution, in precedence order:
- *
- *  1. A GitHub URL installs directly.
- *  2. An existing local path installs directly; paths always beat same-named
- *     marketplace entries.
- *  3. A bare skill name resolves through the local marketplace.
- *
- * Anything else is an error naming both failed interpretations. Overwriting
- * an existing install always requires an explicit `force: true`.
- */
+/** Skill-offer adapter: resolve a package and commit through the shared library engine. */
 export function installSkill(input: InstallSkillInput): InstallSkillResult {
 	const requested = input.source.trim();
 	const source = requested === "clio-dev" ? "clio-coder-dev" : requested === "clio-test" ? "clio-coder-test" : requested;
 	if (source !== requested) warnLegacyNaming(requested, source);
-	const spec = parseSkillSourceSpec(source);
-	if (spec?.kind === "local" && isSkillName(source) && !existsSync(spec.path)) {
-		const skill = getMarketplaceSkills({ ...(input.cwd ? { cwd: input.cwd } : {}) }).find(
-			(entry) => entry.name === source,
-		);
-		if (!skill) {
-			throw new Error(`"${source}" is neither an existing local path nor available in the local marketplace`);
-		}
-		return installSkillFromSource({ ...input, ...marketplaceInstallShaping(skill), source: skill.sourceUrl });
-	}
-	return installSkillFromSource({ ...input, source });
+	if (input.overlay || input.exclude?.length || input.configDir)
+		throw new Error("package installs use the prepared manifest tree and the active Clio profile");
+	const entry = resolveLibraryPackage(source, input.cwd ? { cwd: input.cwd } : {});
+	if (entry.kind !== "skill") throw new Error(`expected a skill package, found ${entry.kind}:${entry.name}`);
+	if (input.name && input.name !== entry.name) throw new Error("package identities cannot be renamed at install");
+	const plan = planLibraryInstall(entry, {
+		...(input.cwd ? { cwd: input.cwd } : {}),
+		scope: input.scope ?? "user",
+		force: input.force ?? false,
+	});
+	installLibraryPlan(plan);
+	const candidate = readPluginManifest(plan.path);
+	const component = candidate.manifest?.clio.components.find((item) => item.kind === "skill");
+	if (!component) throw new Error("installed skill package has no skill component");
+	return {
+		name: entry.name,
+		scope: input.scope ?? "user",
+		path: pluginResourcePath(plan.path, component.path),
+		sourceUrl: entry.sourceUrl,
+		installedHash: plan.sha256,
+		warnings: [],
+	};
 }

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

@@ -143,7 +143,7 @@ export function matchMarketplaceSkills(
  * is not the enforcement mechanism.
  *
  * This gates the promotion flow only. Operator-driven installs through
- * `clio-coder skills install <url>` keep their existing behavior.
+ * `clio-coder library install <url>` keep their existing behavior.
  */
 export const OWN_MARKETPLACE_URL_PREFIX = "https://github.com/iowarp/clio-coder/";
 
@@ -160,7 +160,7 @@ export function assertPromotionInstallSource(entry: MarketplaceSkill): void {
 	throw new Error(
 		`skill promotion: refusing to install "${entry.name}" from ${entry.sourceUrl}; ` +
 			"promotion installs only from Clio's own marketplace (local catalog or " +
-			`${OWN_MARKETPLACE_URL_PREFIX}). Install manually with clio-coder skills install if intended.`,
+			`${OWN_MARKETPLACE_URL_PREFIX}). Install manually with clio-coder library install if intended.`,
 	);
 }
 

package/src/domains/resources/skills/provenance-pin.ts

@@ -1,7 +1,7 @@
 /**
  * Local-first skill provenance pinning.
  *
- * `skills/registry.yaml` (regenerated with `npm run skills:pin`) pins the
+ * `library/skills/registry.yaml` (regenerated with `pnpm run skills:pin`) pins the
  * provenance-stripped sha256 of every marketplace skill's SKILL.md. At
  * activation time, a skill carrying marketplace provenance (`registry-id`
  * frontmatter) is compared against the pinned entry on the same normalized
@@ -16,6 +16,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import yaml from "yaml";
+import { resolvePackageRoot } from "../../../core/package-root.js";
 
 export const SKILL_PIN_MANIFEST_FILENAME = "registry.yaml";
 
@@ -34,9 +35,21 @@ function isPlainObject(value: unknown): value is Record<string, unknown> {
 /** Resolve the manifest path using the same catalog resolution as the marketplace. */
 function resolveSkillPinManifestPath(cwd: string): string | null {
 	const fromEnv = process.env.CLIO_CODER_SKILL_CATALOG_DIR;
-	const catalogDir = fromEnv && fromEnv.trim().length > 0 ? path.resolve(fromEnv.trim()) : path.join(cwd, "skills");
-	const manifestPath = path.join(catalogDir, SKILL_PIN_MANIFEST_FILENAME);
-	return existsSync(manifestPath) ? manifestPath : null;
+	if (fromEnv && fromEnv.trim().length > 0) {
+		const manifestPath = path.join(path.resolve(fromEnv.trim()), SKILL_PIN_MANIFEST_FILENAME);
+		return existsSync(manifestPath) ? manifestPath : null;
+	}
+	const repoLibraryManifest = path.join(cwd, "library", "skills", SKILL_PIN_MANIFEST_FILENAME);
+	if (existsSync(repoLibraryManifest)) return repoLibraryManifest;
+	const repoManifest = path.join(cwd, "skills", SKILL_PIN_MANIFEST_FILENAME);
+	if (existsSync(repoManifest)) return repoManifest;
+	try {
+		const bundledManifest = path.join(resolvePackageRoot(), "library", "skills", SKILL_PIN_MANIFEST_FILENAME);
+		if (existsSync(bundledManifest)) return bundledManifest;
+	} catch {
+		// Package root may be unavailable in isolated harnesses.
+	}
+	return null;
 }
 
 function loadSkillPinManifest(manifestPath: string): Map<string, SkillPinEntry> | null {

package/src/domains/safety/action-classifier.ts

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { artifactDefaultPath } from "../../core/artifact-paths.js";
 import { canonicalizeExistingPath } from "../../core/path-canonical.js";
-import { ToolNames } from "../../core/tool-names.js";
+import { isHarnessExtensionToolName, ToolNames } from "../../core/tool-names.js";
 import { extractCommandCdTargets, extractCommandWriteTargets } from "./protected-artifacts.js";
 
 /**
@@ -129,7 +129,7 @@ function baseClassify(tool: string): ActionClass | null {
 		case ToolNames.Steer:
 			return "dispatch";
 		default:
-			return null;
+			return isHarnessExtensionToolName(tool) ? "execute" : null;
 	}
 }
 

package/src/domains/safety/default-path-policy.ts

@@ -67,10 +67,12 @@ export const DEFAULT_DAMAGE_CONTROL_PATH_POLICY: PathPolicyInput = {
 		// widen its own permissions in two tool calls. Both are authored by the
 		// operator through the CLI (`clio-coder verifiers author` lands nothing
 		// before `--yes`), so model-side writes and deletes are refused.
-		// Skills also refuse model-side writes and deletes; installs go through `clio-coder skills install`.
+		// Skills also refuse model-side writes and deletes; installs go through `clio-coder library install`.
 		".clio-coder/safety.yaml",
 		".clio-coder/verifiers.yaml",
 		".clio-coder/skills/",
+		".clio-coder/plugins/",
+		".clio-coder/extensions/",
 		"/etc/",
 		"/usr/",
 		"/bin/",

package/src/domains/safety/policy-engine.ts

@@ -354,7 +354,7 @@ export function createSafetyPolicyEngine(options: SafetyPolicyEngineOptions = {}
 			}
 			const skillReason =
 				mutationCommand !== null && invokesClioSkillMutation(mutationCommand)
-					? "skill installation and updates require the operator CLI or an explicit operator install choice; draft outside active skill roots"
+					? "resource installation and lifecycle changes require the operator CLI or an explicit operator install choice; draft outside installed resource roots"
 					: skillMutationReason(
 							skillRoots,
 							pathPolicyTargets(catalogCommand === null ? call : { tool: ToolNames.Bash, args: { command: catalogCommand } }),

package/src/domains/safety/protected-artifacts.ts

@@ -416,7 +416,14 @@ export function invokesClioSkillMutation(command: string): boolean {
 			args = args.slice(flag === "--skill" || flag === "--api-key" ? 2 : 1);
 		}
 		if (rootHelp) continue;
-		if (args[0] !== "skills" && args[0] !== "library") continue;
+		if (
+			args[0] !== "skills" &&
+			args[0] !== "library" &&
+			args[0] !== "plugins" &&
+			args[0] !== "extensions" &&
+			args[0] !== "interop"
+		)
+			continue;
 		if (resourceCliMutatesSkills(args[0], args.slice(1))) return true;
 	}
 	return false;
@@ -440,7 +447,10 @@ function shellCommandArguments(segment: ReadonlyArray<ShellToken>): string[] {
 	return args.map((token) => token.value);
 }
 
-function resourceCliMutatesSkills(resource: "skills" | "library", args: ReadonlyArray<string>): boolean {
+function resourceCliMutatesSkills(
+	resource: "skills" | "library" | "plugins" | "extensions" | "interop",
+	args: ReadonlyArray<string>,
+): boolean {
 	// Both resource parsers accept flags before the verb. Consume their value
 	// options so a catalog path called --yes or --help is not treated as a flag.
 	const valueOptions =
@@ -449,6 +459,7 @@ function resourceCliMutatesSkills(resource: "skills" | "library", args: Readonly
 			: ["--kind", "--from"];
 	let verb: string | undefined;
 	let confirmed = false;
+	let dryRun = false;
 	for (let index = 0; index < args.length; index += 1) {
 		const arg = args[index];
 		if (arg === undefined) continue;
@@ -458,12 +469,17 @@ function resourceCliMutatesSkills(resource: "skills" | "library", args: Readonly
 		}
 		if (arg === "--help" || arg === "-h") return false;
 		if (arg === "--yes") confirmed = true;
+		if (arg === "--dry-run") dryRun = true;
 		if (!arg.startsWith("-")) verb ??= arg;
 	}
 	if (resource === "skills") return verb === "install" || verb === "update" || verb === "sync";
-	// Unconfirmed library add only prints a plan. A confirmed add can install
-	// skill dependencies of any resource kind, or resolve an untyped skill ref.
-	return verb === "add" && confirmed;
+	if (resource === "plugins" || resource === "extensions")
+		return ["install", "update", "remove", "enable", "disable", "pin"].includes(verb ?? "");
+	if (resource === "interop") return verb === "adopt" && confirmed && !dryRun;
+	// A package of any kind may carry skills or require a skill dependency.
+	// Only install/update implement a dry-run; other mutations cannot spend it.
+	if ((verb === "install" || verb === "update") && dryRun) return false;
+	return ["install", "update", "remove", "enable", "disable", "pin", "register", "sync"].includes(verb ?? "");
 }
 
 const STANDARD_DEV_TARGETS = new Set(["/dev/null", "/dev/stdout", "/dev/stderr", "/dev/tty", "/dev/zero"]);

package/src/domains/safety/skill-authority.ts

@@ -10,7 +10,10 @@ import { extractCommandCdTargets } from "./protected-artifacts.js";
  * may install or replace a symlink after the session starts. Reads stay allowed.
  */
 export function activeClioSkillRoots(cwd: string): string[] {
-	return [path.join(cwd, ".clio-coder", "skills"), path.join(clioConfigDir(), "skills")];
+	return ["skills", "plugins", "extensions"].flatMap((kind) => [
+		path.join(cwd, ".clio-coder", kind),
+		path.join(clioConfigDir(), kind),
+	]);
 }
 
 export function skillMutationReason(
@@ -40,7 +43,7 @@ export function skillMutationReason(
 							isSameOrDescendant(candidate, boundary) ||
 							(target.operation === "delete" && isSameOrDescendant(boundary, candidate))
 						) {
-							return `active skill tree ${root} is operator-owned; draft changes outside active skill roots and ask the operator to install or update them`;
+							return `active resource tree ${root} is operator-owned; draft changes outside installed resource roots and use the operator install or update interface`;
 						}
 					}
 				}

package/src/domains/session/compaction/compact.ts

@@ -593,6 +593,9 @@ function addCompactionUsage(total: CompactionUsage | undefined, raw: unknown): C
 		output: base.output + output,
 		cacheRead: base.cacheRead + cacheRead,
 		cacheWrite: base.cacheWrite + cacheWrite,
+		...(base.cacheWrite1h === undefined && usage.cacheWrite1h === undefined
+			? {}
+			: { cacheWrite1h: (base.cacheWrite1h ?? 0) + numberOrZero(usage.cacheWrite1h) }),
 		reasoning: base.reasoning + numberOrZero(usage.reasoning),
 		totalTokens: base.totalTokens + totalTokens,
 		cost: { total: base.cost.total + numberOrZero(usage.cost?.total) },
@@ -605,7 +608,7 @@ function retainReportedUsage(previous: Record<string, unknown>, raw: unknown): R
 	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return previous;
 	const usage = raw as Record<string, unknown>;
 	const known = { ...previous };
-	for (const field of ["input", "output", "cacheRead", "cacheWrite", "totalTokens"]) {
+	for (const field of ["input", "output", "cacheRead", "cacheWrite", "cacheWrite1h", "totalTokens"]) {
 		const value = numberOrZero(usage[field]);
 		if (value > 0) known[field] = value;
 	}

package/src/domains/session/entries.ts

@@ -114,6 +114,7 @@ export interface CompactionUsage {
 	output: number;
 	cacheRead: number;
 	cacheWrite: number;
+	cacheWrite1h?: number;
 	reasoning: number;
 	totalTokens: number;
 	cost: { total: number };

package/src/domains/session/usage.ts

@@ -13,10 +13,8 @@
  * every surface's accounting, which is the same thing the tools/interactive
  * boundary rule exists to prevent.
  *
- * Assistant turns marked aborted or error are skipped for the same reason the
- * context estimator skips them: their usage is not a completed call. A
- * cancelled partial persists a fully populated all-zero usage object, so
- * counting it would add an API call worth nothing.
+ * Failed/aborted calls with reported usage still consumed resources. Skip
+ * only all-zero SDK placeholders, whose accounting was never observed.
  */
 
 import {
@@ -39,6 +37,7 @@ export interface LedgerUsageCall {
 	output: number;
 	cacheRead: number;
 	cacheWrite: number;
+	cacheWrite1h?: number;
 	reasoningTokens: number;
 	totalTokens: number;
 	costUsd: number;
@@ -58,7 +57,7 @@ function numberAt(source: Record<string, unknown>, key: string): number {
 }
 
 function reasoningTokensOf(usage: Record<string, unknown>): number {
-	const direct = numberAt(usage, "reasoningTokens");
+	const direct = numberAt(usage, "reasoning") || numberAt(usage, "reasoningTokens");
 	if (direct > 0) return direct;
 	const details = usage.outputTokensDetails ?? usage.completionTokensDetails;
 	if (details && typeof details === "object") return numberAt(details as Record<string, unknown>, "reasoningTokens");
@@ -109,6 +108,7 @@ export function ledgerUsageCalls(
 				output: usage.output,
 				cacheRead: usage.cacheRead,
 				cacheWrite: usage.cacheWrite,
+				...(usage.cacheWrite1h === undefined ? {} : { cacheWrite1h: usage.cacheWrite1h }),
 				reasoningTokens: usage.reasoning,
 				totalTokens: usage.totalTokens,
 				costUsd: usage.cost.total,
@@ -129,8 +129,6 @@ export function ledgerUsageCalls(
 		const payload = entry.payload;
 		if (!payload || typeof payload !== "object" || Array.isArray(payload)) continue;
 		const record = payload as Record<string, unknown>;
-		const stopReason = record.stopReason;
-		if (stopReason === "aborted" || stopReason === "error") continue;
 		const rawUsage = record.usage;
 		if (!rawUsage || typeof rawUsage !== "object" || Array.isArray(rawUsage)) continue;
 		const usage = rawUsage as Record<string, unknown>;
@@ -156,6 +154,7 @@ export function ledgerUsageCalls(
 			output,
 			cacheRead,
 			cacheWrite,
+			...(typeof usage.cacheWrite1h === "number" ? { cacheWrite1h: numberAt(usage, "cacheWrite1h") } : {}),
 			reasoningTokens: reasoningTokensOf(usage),
 			totalTokens,
 			costUsd,

package/src/domains/share/archive.ts

@@ -644,7 +644,7 @@ function withStagedExtensionPackage<T>(
 	input: { id: string; files: ReadonlyArray<{ relativePath: string; buffer: Buffer }> },
 	fn: (root: string) => T,
 ): T {
-	const stagingParent = mkdtempSync(path.join(tmpdir(), "clio-share-extension-"));
+	const stagingParent = mkdtempSync(path.join(tmpdir(), "clio-coder-share-extension-"));
 	const root = path.join(stagingParent, input.id);
 	try {
 		mkdirSync(root, { recursive: true });

package/src/engine/acp/server.ts

@@ -2559,6 +2559,17 @@ export async function serveClioAcpAgent(options: ClioAcpServerOptions): Promise<
 		}
 		const text = promptText(params);
 		if (text.length === 0) throw new AcpRequestError(-32602, "prompt text is required", { code: "invalid_params" });
+		// Check the same credential authority as the runtime, without resolving or
+		// echoing a secret. Desktop services do not inherit a terminal's API keys.
+		const targetId = routingSnapshot().target;
+		const target = targetId ? options.providers?.getTarget(targetId) : undefined;
+		const runtime = target ? options.providers?.getRuntime(target.runtime) : undefined;
+		if (target && runtime && options.providers && !options.providers.auth.statusForTarget(target, runtime).available) {
+			throw new AcpRequestError(-32000, "credentials for the selected target are unavailable", {
+				code: "prompt_not_admitted",
+				reason: "authentication-required",
+			});
+		}
 		if (options.session?.current()?.id !== session.id && options.session) options.session.resume(session.id);
 		const active = createActivePromptState();
 		session.activePrompt = active;

package/src/engine/ai.ts

@@ -76,6 +76,7 @@ export interface EngineTextCompletionResult {
 		output: number;
 		cacheRead: number;
 		cacheWrite: number;
+		cacheWrite1h?: number;
 		reasoning: number;
 		totalTokens: number;
 		costUsd: number;
@@ -110,6 +111,7 @@ export async function completeEngineText(input: EngineTextCompletionInput): Prom
 			output: response.usage.output,
 			cacheRead: response.usage.cacheRead,
 			cacheWrite: response.usage.cacheWrite,
+			...(response.usage.cacheWrite1h === undefined ? {} : { cacheWrite1h: response.usage.cacheWrite1h }),
 			reasoning: response.usage.reasoning ?? 0,
 			totalTokens: response.usage.totalTokens,
 			costUsd: response.usage.cost.total,

package/src/engine/apis/openai-completions.ts

@@ -385,6 +385,46 @@ function stripThinkingFromContext(context: Context): Context {
 	};
 }
 
+/**
+ * Pi 0.85 drops assistant turns with neither text nor tools, even when it has
+ * serialized their raw reasoning field. Give only an interrupted, same-model
+ * raw-reasoning turn a request-local notice so a continuation retains its work.
+ * Never turn private reasoning into answer text or modify the saved transcript.
+ * Opaque signatures and cross-model conversion remain the provider's concern.
+ */
+function preserveInterruptedReasoning(
+	context: Context,
+	model: Model<"openai-completions">,
+	resolved: ResolvedModelRuntimeCapabilities,
+): Context {
+	if (!resolved.thinking.thinkingActive || model.compat?.requiresThinkingAsText) return context;
+	return {
+		...context,
+		messages: context.messages.map((message) => {
+			if (
+				message.role !== "assistant" ||
+				message.stopReason !== "length" ||
+				message.provider !== model.provider ||
+				message.api !== model.api ||
+				message.model !== model.id ||
+				message.content.length === 0 ||
+				!message.content.every(
+					(block) =>
+						block.type === "thinking" &&
+						!block.redacted &&
+						block.thinking.trim().length > 0 &&
+						["reasoning", "reasoning_content", "reasoning_text"].includes(block.thinkingSignature ?? ""),
+				)
+			)
+				return message;
+			return {
+				...message,
+				content: [...message.content, { type: "text" as const, text: "Response interrupted before its answer." }],
+			};
+		}),
+	};
+}
+
 function withStrippedPartial<TEvent extends AssistantMessageEvent>(event: TEvent): TEvent {
 	if (!("partial" in event)) return event;
 	return { ...event, partial: stripThinkingFromMessage(event.partial as AssistantMessage) };
@@ -506,11 +546,15 @@ function applyLmStudioPayload(
 	return next;
 }
 
-function applyLlamaCppPromptCachePayload(payload: Record<string, unknown>, model: Model<Api>): Record<string, unknown> {
+function applyLlamaCppPromptCachePayload(
+	payload: Record<string, unknown>,
+	model: Model<Api>,
+	retention: StreamOptions["cacheRetention"],
+): Record<string, unknown> {
 	const metadata = runtimeMetadata(model);
 	if (model.provider !== "llamacpp" || metadata?.runtimeId !== "llamacpp") return payload;
 	if (payload.cache_prompt !== undefined) return payload;
-	return { ...payload, cache_prompt: true };
+	return { ...payload, cache_prompt: retention !== "none" };
 }
 
 function shouldApplyLlamaCppPromptCache(model: Model<"openai-completions">): boolean {
@@ -522,13 +566,14 @@ function shouldApplyLlamaCppPromptCache(model: Model<"openai-completions">): boo
 function composeThinkingOnPayload(
 	resolved: ResolvedModelRuntimeCapabilities,
 	base: AnyOnPayload | undefined,
+	retention: StreamOptions["cacheRetention"],
 ): AnyOnPayload {
 	return async (payload, model) => {
 		if (!isPlainRecord(payload)) {
 			return base ? await base(payload, model) : undefined;
 		}
 		const next = applyLmStudioPayload(
-			applyThinkingPayload(applyLlamaCppPromptCachePayload(payload, model), resolved.thinking, resolved, model),
+			applyThinkingPayload(applyLlamaCppPromptCachePayload(payload, model, retention), resolved.thinking, resolved, model),
 			model,
 			resolved,
 		);
@@ -585,7 +630,7 @@ function withSamplingOverrides<TOptions extends StreamOptions>(
 		applied.mechanism === "on-off" ||
 		applied.mechanism === "none"
 	) {
-		merged.onPayload = composeThinkingOnPayload(resolved, options?.onPayload);
+		merged.onPayload = composeThinkingOnPayload(resolved, options?.onPayload, options?.cacheRetention);
 	}
 	return merged as TOptions;
 }
@@ -1041,7 +1086,12 @@ export const openAICompletionsApiProvider: EngineApiProvider<"openai-completions
 											...(options?.apiKey !== undefined ? { apiKey: options.apiKey } : {}),
 											...(options?.signal !== undefined ? { signal: options.signal } : {}),
 										},
-										(requestModel) => piOpenAICompletions.stream(requestModel, effectiveContext, capturedOptions),
+										(requestModel) =>
+											piOpenAICompletions.stream(
+												requestModel,
+												preserveInterruptedReasoning(effectiveContext, requestModel, resolved),
+												capturedOptions,
+											),
 									),
 								),
 							),
@@ -1078,7 +1128,12 @@ export const openAICompletionsApiProvider: EngineApiProvider<"openai-completions
 											...(options?.apiKey !== undefined ? { apiKey: options.apiKey } : {}),
 											...(options?.signal !== undefined ? { signal: options.signal } : {}),
 										},
-										(requestModel) => piOpenAICompletions.streamSimple(requestModel, effectiveContext, capturedOptions),
+										(requestModel) =>
+											piOpenAICompletions.streamSimple(
+												requestModel,
+												preserveInterruptedReasoning(effectiveContext, requestModel, resolved),
+												capturedOptions,
+											),
 									),
 								),
 							),

package/src/engine/notices/pi-tui-LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Mario Zechner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.