@iowarp/clio-coder 0.4.9 → 0.5.0

package/src/domains/prompts/fragments/operating/delegation.md

@@ -6,16 +6,21 @@ description: Coordinator delegation and receipt discipline; rendered only when d
 
 # Delegation
 
-You coordinate Clio workers through the dispatch tool. Before your first
+You coordinate Clio workers through the dispatch tool. Explicit operator scope takes
+precedence: when asked not to delegate, work directly without dispatching helpers.
+Do not split a small cohesive change merely because it touches several files.
+When the operator supplies an exact worker task, copy it verbatim into `task`;
+put parent coordination instructions in the appropriate dispatch fields.
+When delegation is allowed, before your first
 edit, count the independent file-scoped changes the request asks for.
-Two or more, or any repository-wide exploration: dispatch, and do not
+Two or more independent tasks, or repository-wide exploration: dispatch, and do not
 edit those files yourself. One narrow change: do it yourself.
 For two or more changes, one dispatch call carries them all as `tasks`,
 one task per change, each naming its file in `intent`, with `agent`
 "coder" and `mode` "parallel". For exploration, dispatch `scout` with
 the question before any repo-wide grep or read, however small the
 repository looks. You keep synthesis and validation: when the receipts
-arrive, spot-check them and run the checks yourself. A worker whose
+arrive, use their typed results and resolve relevant limitations. A worker whose
 intent declares `write_roots` is confined to them and has no bash or
 verify tool, so do not ask it to run tests or scripts: name the checks
 in `verification` and the host runs them after it finishes.
@@ -24,18 +29,29 @@ command execution in the parent, and use its source/test reads as that evidence
 unless a declared verification check actually ran. A worker's unavailable check
 is a reported limitation for you to resolve, not a reason to demand repeated
 attempts through tools it does not have.
-A sealed run receipt is the durable record of delegated work; the
-worker's prose is an advisory claim until its evidence is verified or
-you spot-check it. Spot-check a small, risk-weighted subset of a
-reconnaissance receipt's citations (normally at most six read or search
-calls), and re-read any cited file:line and re-run or inspect the named
-validation before repeating a "tests pass" claim. Failed, cap-exhausted,
-zero-tool, or citation-free reconnaissance is unconfirmed leads, never
-validation.
+Shadow agents are your internal helpers, not separate user assignments.
+For independent research, provenance, or reconnaissance, use `detach:true`
+so the helper works in the background while you continue useful work or answer
+the operator. Collect it with `monitor(mode="collect", batch_id="...")`
+when its result is ready; avoid repeated polling. If your next action depends
+on its findings, wait for that result rather than guessing or duplicating its work.
+A sealed run receipt is the durable record of delegated work. Ordinary
+worker prose remains an advisory claim until its evidence is verified.
+Use host-validated helper findings directly for orientation and planning;
+do not fetch their full receipt or re-read every cited line by default.
+Spot-check a claim when its consequences or uncertainty justify it, and
+re-run or inspect the named validation before repeating a "tests pass" claim.
+Failed or degraded helper results provide navigation leads and limitations,
+not successful verification. Resolve only the missing evidence needed for
+this task instead of repeating the entire investigation.
 Put receipt-derived context in the dispatch briefing field, separate
 from task instructions. Collect detached runs before final synthesis,
-and report receipt integrity, evidence verification, briefing
-provenance, and project-context provenance as separate facts. Never
+and keep grounded findings, ungrounded leads, and limitations distinct.
+Use validated helper results directly for navigation and planning; verify
+consequential code or test claims before acting on them. Do not repeat the
+helper's entire investigation or fill the operator's answer with receipt
+bookkeeping; name a run or failure when it matters, with full provenance
+available for inspection. Never
 narrate or summarize a worker you did not dispatch; if you cannot
 dispatch, say so and name the reason.
 A note headed `[worker result] <agent> · run <id> · <outcome> · shared

package/src/domains/prompts/fragments/operating/skills.md

@@ -6,16 +6,24 @@ description: Coordinator skill suggestion discipline; rendered only when context
 
 # Skills
 
-Skills are workflows for git delivery, planning, coding practice,
-context priming/handoff, research, and plan stress-testing.
-context (scope="skills") lists installed and marketplace skills; never
+context (scope="skills") lists ready Clio workflows, installed skill packages and their state,
+and additional marketplace skills. Other-agent folders are discovery-only: explicit import is required,
+then foreign imports need the trust-imports setting before use. Never call discovered files installed.
+Never
 guess a skill or search the repository for one.
 {SKILL_ACTIVATION_POLICY}
-Only the operator installs marketplace skills; a [Marketplace] reminder
-states its own offer options. When the operator names a skill or asks
+A declined installation (Not now or Cancel) settles the offer for this task: do not
+load the unavailable skill, offer it again, or install it. Continue within the requested
+scope using available tools. For proposal-only work, leave implementation tasks blocked.
+Install marketplace packages only when the operator requests or approves installation.
+An explicit request authorizes you to run the documented CLI through bash, subject to the normal tool permissions:
+`clio-coder library install skill:<name> --user` (active profile) or `--project` (current workspace).
+The same library commands manage plugins, agents, prompts, and fleets by their kind:name reference.
+After installing, re-read context(scope="skills") before reporting counts. Installed does not mean ready:
+report `/library reload` if the running session has not admitted the new package yet.
+Use `library update`, `library remove`, and `library inspect` for existing packages.
+`/skill <name>` is an interactive activation command, not a shell command.
+Bundled availability does not mean installed; damaged, disabled, and shadowed are different states.
+Never bypass integrity checks or claim installation grants additional authority.
+A [Marketplace] reminder states its own offer options. When the operator names a skill or asks
 how it works, answer from it. If nothing fits, suggest none.
-
-If gateway is on the attached direct-tool surface, use
-gateway(op="call", capability="clio_library", args={}) to read the catalog
-of recipes and installable packages; it activates and installs nothing.
-Without gateway, this catalog route is unavailable.

package/src/domains/prompts/fragments/operating/worker.md

@@ -7,3 +7,5 @@ description: Assigned-task contract for a bounded fleet worker
 # Assigned Task Contract
 
 The assigned task is authoritative; role guidance is a persona, not a replacement. Do not invent a different task, source tree, file path, or implementation plan.
+
+Inherited conversation is background from the coordinating session, not unfinished work for you. You are already the dispatched worker. Execute the latest assigned task yourself using your admitted tools; do not repeat the parent’s request to dispatch or ask it to delegate you again. Preserve inherited safety and operator scope constraints. Report checks you actually performed separately from checks the host will run. Once the assigned work is complete, return the required result without repeating successful checks.

package/src/domains/providers/cache-deployment.ts

@@ -1,10 +1,11 @@
+import { lookup } from "node:dns/promises";
 import { canonicalEndpointUrl } from "../../core/endpoint-key.js";
 import type { TargetDescriptor } from "./types/target-descriptor.js";
 
 /** Fresh observations, not a persisted cache handle or permission to administer a server. */
 export interface CacheDeploymentObservation {
 	observedAt: number;
-	backend: "llamacpp" | "vllm" | "unknown";
+	backend: "llamacpp" | "vllm" | "lmstudio" | "unknown";
 	model: string;
 	build: string | null;
 	/** Absent server epoch stays unknown; Clio never invents one from a build number. */
@@ -111,6 +112,35 @@ export async function observeCacheDeployment(
 				reason: observation.build === binding.build ? "vllm-scheduler-unverified" : "deployment-build-mismatch",
 			};
 		}
+		if (binding.backend === "lmstudio") {
+			// An explicit binding is still not permission to warm an Internet endpoint.
+			const addresses = await lookup(control.hostname.replace(/^\[|\]$/g, ""), { all: true });
+			if (addresses.length === 0 || addresses.some(({ address }) => !isLocalAddress(address)))
+				return { ...observation, reason: "warming-requires-local-deployment" };
+			const catalog = record(await get(`${root}/api/v1/models`));
+			const selected = Array.isArray(catalog.models)
+				? catalog.models
+						.map(record)
+						.find(
+							(row) =>
+								row.key === binding.model ||
+								(Array.isArray(row.loaded_instances) &&
+									row.loaded_instances.some((instance) => record(instance).id === binding.model)),
+						)
+				: undefined;
+			if (selected?.type !== "llm") return { ...observation, reason: "deployment-model-mismatch" };
+			const instances = Array.isArray(selected.loaded_instances) ? selected.loaded_instances.map(record) : [];
+			if (instances.length === 0) return { ...observation, reason: "model-not-loaded" };
+			// LM Studio has no public slot-idleness API. Require spare configured
+			// parallelism and opt-in; local endpoint leases are checked by the caller.
+			if (
+				instances.length !== 1 ||
+				Number(record(instances[0]?.config).parallel) < 2 ||
+				!Number.isFinite(Number(record(instances[0]?.config).parallel))
+			)
+				return { ...observation, reason: "endpoint-capacity-unverified" };
+			return { ...observation, warm: "bounded", reason: "loaded-local-deployment" };
+		}
 		let props = record(await get(`${root}/props`));
 		const router = props.role === "router";
 		if (router) {
@@ -124,7 +154,7 @@ export async function observeCacheDeployment(
 		}
 		observation.build = typeof props.build_info === "string" ? props.build_info : null;
 		if (observation.build !== binding.build) return { ...observation, reason: "deployment-build-mismatch" };
-		if (!observation.build.endsWith("-c841aee"))
+		if (!observation.build?.endsWith("-c841aee"))
 			return { ...observation, reason: "deployment-cache-protocol-unverified" };
 		if (props.is_sleeping !== false) return { ...observation, reason: "model-not-loaded" };
 		if (typeof props.model_alias === "string" && props.model_alias !== binding.model)
@@ -145,3 +175,16 @@ export async function observeCacheDeployment(
 		return { ...observation, reason: options.signal?.aborted ? "superseded" : "deployment-unavailable" };
 	}
 }
+
+function isLocalAddress(address: string): boolean {
+	if (address === "::1" || /^(fc|fd)[0-9a-f]{2}:/i.test(address)) return true;
+	const parts = address.split(".").map(Number);
+	if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) return false;
+	const second = parts[1];
+	return (
+		parts[0] === 127 ||
+		parts[0] === 10 ||
+		(parts[0] === 192 && parts[1] === 168) ||
+		(parts[0] === 172 && second !== undefined && second >= 16 && second <= 31)
+	);
+}

package/src/domains/providers/contract.ts

@@ -69,6 +69,43 @@ export interface TargetStatus {
 	discoveredModelsSource?: "probe" | "cache" | "runtime" | "none";
 	/** Probe-only per-model load state keyed by wire model id. */
 	discoveredModelStates?: Readonly<Record<string, ProbeModelStatus>> | null;
+	/**
+	 * Result of the last opt-in live tool-call probe (`targets --probe --tools`).
+	 * Held in memory with the rest of the status; never persisted.
+	 */
+	toolProbe?: ToolCallVerification;
+}
+
+/**
+ * A live streamed tool-call check for one (target, model). `verified` means
+ * the model streamed a schema-valid call through the engine path a turn uses;
+ * `failed` carries the reason; `skipped` means the probe could not run.
+ */
+export interface ToolCallVerification {
+	status: "verified" | "failed" | "skipped";
+	modelId: string | null;
+	streamed: boolean;
+	/** Response frames the server sent; null when the transport was not observable. */
+	frames: number | null;
+	toolCall: boolean;
+	argumentsValid: boolean;
+	latencyMs: number | null;
+	/** Epoch ms when the probe finished. */
+	checkedAt: number;
+	error?: string;
+}
+
+export interface LiveProbeOptions {
+	/** Explicit generating reasoning qualification. Omitted/false keeps discovery passive. */
+	reasoning?: boolean;
+	/** Opt-in streamed tool-call probe. Generates tokens and can load a cold model. */
+	tools?: boolean;
+	/**
+	 * Generation timeout for the tool probe in ms. Defaults to 120 s so a cold
+	 * load of a large local model fits; the HTTP probe keeps its own timeout.
+	 */
+	toolsTimeoutMs?: number;
+	signal?: AbortSignal;
 }
 
 export interface ProvidersContract {
@@ -87,35 +124,39 @@ export interface ProvidersContract {
 	/** Config-only readiness sweep. Does not hit the network. */
 	probeAll(): Promise<void>;
 
-	/** Live liveness + probeModels sweep. */
-	probeAllLive(): Promise<void>;
+	/** Passive live metadata sweep. `reasoning: true` / `tools: true` explicitly enable generation. */
+	probeAllLive(options?: LiveProbeOptions): Promise<void>;
 
 	/**
 	 * Probe a single target live. Null when the id is not in settings.targets.
-	 * `reasoning: false` skips an inference-based reasoning-capability probe while
-	 * retaining the target's liveness and model-catalog checks.
+	 * `reasoning: true` opts into generating reasoning qualification; otherwise
+	 * only passive liveness and model-catalog checks run. `tools: true`
+	 * adds the streamed tool-call probe against the chat or default model.
 	 */
 	/** Optional cancellation covers auth and metadata; a cancelled probe does not publish health. */
-	probeTarget(id: string, options?: { reasoning?: boolean; signal?: AbortSignal }): Promise<TargetStatus | null>;
+	probeTarget(id: string, options?: LiveProbeOptions): Promise<TargetStatus | null>;
 
 	/** Clear in-memory live connection state for a configured target. */
 	disconnectTarget(id: string): TargetStatus | null;
 
 	/**
 	 * Cached reasoning detection result for a given (target, wire model id).
-	 * Returns true/false when a probe has populated the cache, null otherwise.
+	 * Returns true for positive observed reasoning, null when unqualified.
 	 * Surfaces local-server reasoning capability that is per loaded model and
 	 * cannot be inferred from runtime defaults alone.
 	 */
 	getDetectedReasoning(targetId: string, modelId: string): boolean | null;
 
 	/**
-	 * Probe an target's loaded model for reasoning support. Caches the result
-	 * keyed by `(targetId, modelId)` and returns it. Null when the runtime
-	 * lacks `probeReasoning`, the target is unknown, or the probe could not
-	 * reach the server.
+	 * Return cached positive reasoning evidence unless `active: true` explicitly
+	 * authorizes generating qualification. Only positive observations are cached;
+	 * errors and responses without reasoning are inconclusive, never false.
 	 */
-	probeReasoningForModel(targetId: string, modelId: string): Promise<boolean | null>;
+	probeReasoningForModel(
+		targetId: string,
+		modelId: string,
+		options?: { active?: boolean; signal?: AbortSignal },
+	): Promise<boolean | null>;
 
 	/**
 	 * Shared auth access for both API keys and OAuth credentials. Provider ids