@iowarp/clio-coder 0.4.5 → 0.4.7

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/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/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) };
@@ -1041,7 +1081,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 +1123,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.

package/src/engine/tui.ts

@@ -80,11 +80,13 @@ export {
 	getKeybindings,
 	Input,
 	isKeyRelease,
+	isKeyRepeat,
 	KeybindingsManager,
 	Markdown,
 	Marked,
 	matchesKey,
 	ProcessTerminal,
+	parseKey,
 	ScrollView,
 	setKeybindings,
 	stripTerminalSequences,
@@ -97,6 +99,7 @@ export {
 	visibleWidth,
 	wrapTextWithAnsi,
 } from "@earendil-works/pi-tui";
+export { decodePrintableKey } from "@earendil-works/pi-tui/dist/keys.js";
 export {
 	InstrumentedTuiAltScreen,
 	InstrumentedTuiMainScreen,

package/src/engine/worker-runtime.ts

@@ -1,3 +1,9 @@
+import type { WorkerContextSeed } from "../domains/context/worker/contract.js";
+import { createWorkerContextGuard, WorkerContextExhaustedError } from "../domains/context/worker/pressure.js";
+import { createWorkerObservationStore } from "../domains/context/worker/recall.js";
+import { seededWorkerMessages } from "../worker/context-seed.js";
+import { engineStreamSimple } from "./api-registry.js";
+import { estimateInputTokensFromContext, resolveReservedOutputTokens } from "./apis/output-budget.js";
 /**
  * Worker-subprocess engine boundary.
  *
@@ -10,7 +16,6 @@
  */
 
 import path from "node:path";
-import { validateSettingsFile } from "../core/config.js";
 import {
 	configureGuardrails,
 	guardrailValuesFromSettings,
@@ -18,6 +23,7 @@ import {
 	isWorkerToolCallCapSynthesisReason,
 } from "../core/guardrails.js";
 import { runtimeSpeaksResponseSchemaDialect } from "../core/response-schema.js";
+import { readLayeredSettings } from "../core/settings-layers.js";
 import { agentSkillToolPolicy } from "../core/skill-activation.js";
 import { type ToolName, ToolNames } from "../core/tool-names.js";
 import {
@@ -89,6 +95,7 @@ import { createWorkerSafety, createWorkerToolRegistry } from "./worker-tools.js"
 export interface WorkerRunInput {
 	sessionId?: string;
 	systemPrompt: string;
+	contextSeed?: WorkerContextSeed;
 	dynamicPromptMessages?: ReadonlyArray<WorkerPromptMessage>;
 	agentId: string;
 	task: string;
@@ -360,6 +367,8 @@ function resolveWorkerRuntimeBudget(input: Pick<WorkerRunInput, "budget">): Work
  */
 export function startWorkerRun(input: WorkerRunInput, emit: WorkerEventEmit): WorkerRunHandle {
 	assertResponseSchemaRuntime(input);
+	if (input.contextSeed && input.runtime.kind !== "http")
+		throw new Error("worker context: history seeds require a native Pi runtime");
 	// The wire carries the contract as data; the one strict parser owns its
 	// shape. The worker subprocess may not import it (it stays slim), so the
 	// check lands here, before any model call. The wire parser, not the recipe
@@ -382,11 +391,11 @@ export function startWorkerRun(input: WorkerRunInput, emit: WorkerEventEmit): Wo
 	// so it must register them here before any agent.prompt() touches a local
 	// runtime (lmstudio, ollama-native).
 	registerClioApiProviders();
-	// The worker is a fresh process; mirror the orchestrator's global output
-	// budget so dispatched runs honor settings.defaults.maxTokens too. Use the
-	// non-throwing read: a worker must not abort over a settings issue the parent
-	// already surfaced.
-	const workerSettings = validateSettingsFile().settings;
+	// The worker is a fresh process. Resolve its workspace's trusted settings
+	// layers so project output limits and guardrails survive dispatch. Keep the
+	// best-effort read: the parent already surfaced settings diagnostics, and
+	// untrusted or changed project settings must still fall back to lower layers.
+	const workerSettings = readLayeredSettings(input.cwd ?? process.cwd()).settings;
 	setGlobalDefaultMaxOutputTokens(workerSettings.chat.maxOutputTokens);
 	// Same mirroring for guardrail policy: the fresh process needs its settings
 	// projection installed before any registry or tool construction reads it.
@@ -484,6 +493,7 @@ export function startWorkerRun(input: WorkerRunInput, emit: WorkerEventEmit): Wo
 				}
 			: {}),
 	});
+	const observations = createWorkerObservationStore();
 	const registry = createWorkerToolRegistry(
 		input.middlewareSnapshot,
 		safety,
@@ -512,6 +522,7 @@ export function startWorkerRun(input: WorkerRunInput, emit: WorkerEventEmit): Wo
 		input.autonomy,
 		(effects) => middlewareToolChoice.apply(effects),
 		input.agentLedger,
+		observations.recall,
 	);
 	const contractCwd = input.cwd ?? process.cwd();
 	let resultContractRepairsQueued = 0;
@@ -621,13 +632,46 @@ export function startWorkerRun(input: WorkerRunInput, emit: WorkerEventEmit): Wo
 		input.runtimeResolution?.effectiveThinkingLevel ?? input.thinkingLevel,
 	);
 
+	const inheritedMessages = seededWorkerMessages(input.contextSeed);
+	const inheritedCount = inheritedMessages.length;
+	const contextGuard = createWorkerContextGuard(observations.archive);
 	const options: EngineAgentOptions = {
+		streamFn: (currentModel, currentContext, streamOptions) => {
+			const window = input.runtimeResolution?.capabilities.contextWindow ?? currentModel.contextWindow;
+			let messages: AgentMessage[];
+			try {
+				messages = contextGuard({
+					messages: currentContext.messages,
+					systemPrompt: currentContext.systemPrompt ?? "",
+					tools: currentContext.tools ?? [],
+					contextWindow: window,
+					threshold: workerSettings.context.compaction.threshold,
+					autoEvict: workerSettings.context.compaction.auto && workerSettings.context.workingSet.enabled,
+					outputReserve: resolveReservedOutputTokens(currentModel.maxTokens, {
+						api: currentModel.api,
+						contextWindow: window,
+						inputTokens: estimateInputTokensFromContext(currentContext),
+					}),
+				});
+			} catch (error) {
+				if (error instanceof WorkerContextExhaustedError) {
+					workerBoundFailure = error.message;
+					emit({ type: "clio_coder_run_outcome", payload: { outcomeCode: "worker_context_exhausted" } });
+				}
+				throw error;
+			}
+			return engineStreamSimple(
+				currentModel,
+				{ ...currentContext, messages: messages as typeof currentContext.messages },
+				streamOptions,
+			);
+		},
 		initialState: {
 			systemPrompt: input.systemPrompt,
 			model,
 			thinkingLevel: effectiveThinkingLevel,
 			tools,
-			messages: [],
+			messages: inheritedMessages,
 		},
 		onPayload: async (payload, currentModel) => {
 			const middlewareChoice = middlewareToolChoice.current();
@@ -1003,12 +1047,12 @@ export function startWorkerRun(input: WorkerRunInput, emit: WorkerEventEmit): Wo
 			await agent.waitForIdle();
 			unsubscribe();
 			if (workerBoundFailure !== null) {
-				return { messages: agent.state.messages, exitCode: 1 };
+				return { messages: agent.state.messages.slice(inheritedCount), exitCode: 1 };
 			}
 			if (permissionFailure) {
-				return { messages: agent.state.messages, exitCode: WORKER_EXIT_PERMISSION_REQUIRED };
+				return { messages: agent.state.messages.slice(inheritedCount), exitCode: WORKER_EXIT_PERMISSION_REQUIRED };
 			}
-			const messages = agent.state.messages;
+			const messages = agent.state.messages.slice(inheritedCount);
 			const errorMessage = getTerminalAgentError(messages);
 			if (errorMessage !== null) {
 				if (errorMessage.length > 0) {
@@ -1020,15 +1064,15 @@ export function startWorkerRun(input: WorkerRunInput, emit: WorkerEventEmit): Wo
 		} catch (err) {
 			unsubscribe();
 			if (workerBoundFailure !== null) {
-				return { messages: agent.state.messages, exitCode: 1 };
+				return { messages: agent.state.messages.slice(inheritedCount), exitCode: 1 };
 			}
 			if (permissionFailure) {
-				return { messages: agent.state.messages, exitCode: WORKER_EXIT_PERMISSION_REQUIRED };
+				return { messages: agent.state.messages.slice(inheritedCount), exitCode: WORKER_EXIT_PERMISSION_REQUIRED };
 			}
 			const msg = err instanceof Error ? err.message : String(err);
-			emit({ type: "agent_end", messages: agent.state.messages });
+			emit({ type: "agent_end", messages: agent.state.messages.slice(inheritedCount) });
 			process.stderr.write(`[worker] agent error: ${msg}\n`);
-			return { messages: agent.state.messages, exitCode: 1 };
+			return { messages: agent.state.messages.slice(inheritedCount), exitCode: 1 };
 		} finally {
 			clearActiveEscalation();
 			unsubscribePermission();