@iowarp/clio-coder 0.4.5 → 0.4.7

package/docs/process/scientific-validation.md

@@ -122,3 +122,26 @@ Clio Coder integrates scientific validation contracts directly into its safety m
 - **High-Rigor Gate Requirements**: Once the rigor is `high`, the finish gate is active. It engages on a settled `turn_end` only when the recent window contains successful workspace mutation evidence and no validation evidence or `limitation` receipt. The window is entries since the last user message, capped at 80 entries:
   - Clio issues a `request_continuation` middleware effect to keep the session running.
   - Clio injects a dynamic warning reminder (`HIGH_RIGOR_REVALIDATION_MESSAGE`) instructing the agent to run a verification command or to call `limitation` before it can conclude the turn.
+
+## Verification boundaries and limitation receipts
+
+File readback establishes artifact inspection, not executed scientific validation. When an agent or worker modifies files but cannot execute the outstanding checks with its admitted tools and approved scope:
+
+1. **The generic `limitation` tool**:
+   - Clio provides the pure canonical `limitation` tool (`src/tools/limitation.ts`), recording a `limitation` tool_call and tool_result receipt in the session ledger.
+   - Arguments:
+     - `scope` (required string): What could not be verified, in one sentence.
+     - `reason` (required enum): One of `no-runner`, `blocked`, `out-of-scope`, `environment`, or `other`.
+     - `paths` (optional array of strings): Repository-relative file paths left unverified.
+   - A prose disclaimer or text summary in conversation is not a limitation receipt; only a successful `limitation` tool call registers a typed receipt in the session ledger.
+
+2. **Recipe instructions vs generic harness**:
+   - Bundled scientific recipes (such as Materio research agents in `library/plugins/materio`) explicitly instruct workers via `<clio_verification_boundary>` in their recipe bodies to call `limitation` when external checks cannot run. This boundary instruction is authored recipe content, not an unconditional harness envelope injected into every worker.
+
+3. **Finish gate enforcement**:
+   - At high rigor (such as when a valid `validation.yaml` contract is present), the finish gate monitors workspace mutations within the recent active turn window (up to 80 entries since the last user message).
+   - If mutating tool calls occurred in that window without executed validation evidence or a `limitation` receipt, `finishContractRegistration` (`src/domains/safety/finish-contract-registration.ts`) emits a `request_continuation` middleware effect accompanied by a reminder (`HIGH_RIGOR_REVALIDATION_MESSAGE`). At normal rigor, it emits an advisory reminder without blocking.
+   - The gate checks structural evidence presence; it does not grade the empirical correctness of scientific code. Runtime turn budgets, deadline limits, operator cancellation, and tool failures still apply.
+   - A limitation receipt never converts missing or failing checks into a pass; it formally records the limitation so callers and operators know the scientific result is incomplete.
+   - Verified by contracts `tests/contracts/materio-plugin.test.ts` and `tests/contracts/safety-policy-remediation.test.ts`.
+

package/evals/scalar-decision-machinery.ts

@@ -24,7 +24,7 @@ if (!python) throw new Error("Pass an existing Python interpreter with NumPy; th
 const fixture = JSON.parse(readFileSync(new URL("./fixtures/scalar-decision.json", import.meta.url), "utf8"));
 const grader = fileURLToPath(new URL("./scalar-decision-grader.py", import.meta.url));
 const { restore } = await isolateClioEnv();
-const root = mkdtempSync(join(tmpdir(), "clio-scalar-decision-"));
+const root = mkdtempSync(join(tmpdir(), "clio-coder-scalar-decision-"));
 
 function grade(source: string, value: string) {
 	const policy = value === fixture.pythonPolicy ? "python-int" : value === fixture.numpyPolicy ? "numpy-integer" : null;

package/examples/extensions/README.md

@@ -0,0 +1,67 @@
+# Local scientific extensions
+
+These installable examples use the harness extension lifecycle, separately from
+library recipes. They require a Clio build containing operator runtime API v1.
+The manifests retain the current package compatibility minimum, 0.4.7; use this
+implementation or a later release that includes it (the original 0.4.7 release
+predates the runtime field).
+
+From the repository root:
+
+```bash
+clio-coder extensions discover examples/extensions/lab-status --json
+clio-coder extensions install examples/extensions/lab-status --project
+clio-coder extensions run lab-status dashboard
+clio-coder extensions run lab-status dashboard --json
+```
+
+In Clio, reload through `/extensions reload`, then invoke
+`/ext:lab-status:dashboard`. Core renders the panel, owns scrolling and Escape,
+and displays the status with the extension's owner label. The default record is
+`jobs.synthetic.json`: **SYNTHETIC FIXTURE**, two completed jobs and one running
+job. These are deterministic demonstration records, not measured cluster facts.
+
+Pass a local JSON record filename as the argument to inspect your own data:
+
+```bash
+clio-coder extensions run lab-status dashboard -- /absolute/path/experiment.json
+```
+
+The record has `experiment` and `jobs` fields. Each job supplies a string `id`,
+positive integer `ranks`, `state` (`queued`, `running`, `completed`, `failed`) and
+nonnegative finite `elapsedSeconds`. Set `synthetic: true` for simulated data.
+Records without that marker are labeled local reported data, not independently
+verified results. Files are regular local files up to 32 KiB and at most 100 jobs.
+The example performs no SSH, scheduler query, submission, provider request or
+credential access. Turn observations repeat the last explicit snapshot; invoke
+the dashboard again to refresh the file. Runtime state resets on reload.
+
+The separate measurement package keeps the existing model tool contract:
+
+```bash
+clio-coder extensions install examples/extensions/measurements --project
+```
+
+Start a new session. The admitted model tool is
+`extension_measurements__summarize`, with input such as
+`{"values":[1,2,3],"units":"seconds"}`. That input is a **synthetic deterministic
+example**, with mean 2 and sample standard deviation 1. A one-value input returns
+`null` for sample standard deviation. Numeric overflow errors instead of
+reporting null or invented valid measurements. Execution still passes the tool
+registry's safety, autonomy and approval rules. Native worker recipes must
+explicitly admit the qualified tool. Installing a runtime never adds tools to
+existing model schemas.
+
+Update source, reinstall with `--force`, then reload operator runtimes at idle.
+Disable and remove exact copies with `--project` or `--user`:
+
+```bash
+clio-coder extensions disable lab-status --project
+clio-coder extensions enable lab-status --project
+clio-coder extensions remove lab-status --project
+```
+
+Do not edit installed package bytes in place. Whole-tree digest drift revokes
+calls; mixed tool/UI packages need a new session even when only UI bytes change.
+Installed runtime code has your account's filesystem/network authority. A child
+process gives bounded teardown and fresh module caches, not an OS sandbox.

package/examples/extensions/lab-status/clio-coder-extension.json

@@ -0,0 +1,14 @@
+{
+	"id": "lab-status",
+	"name": "Local experiment status",
+	"version": "1.0.0",
+	"description": "Inspect a local experiment record; default data is explicitly synthetic.",
+	"compatibility": { "clio": ">=0.4.7" },
+	"runtime": {
+		"api": 1,
+		"entrypoint": "extension.mjs",
+		"commands": [{ "name": "dashboard", "description": "Show synthetic jobs or a named local JSON experiment file." }],
+		"events": ["session_open", "turn_end"],
+		"ui": ["status", "panel"]
+	}
+}

package/examples/extensions/lab-status/extension.mjs

@@ -0,0 +1,68 @@
+import { open } from "node:fs/promises";
+import path from "node:path";
+
+let lastStatus = { text: "Synthetic fixture available; invoke dashboard", tone: "neutral" };
+async function readRecord(file) {
+	const handle = await open(file, "r");
+	try {
+		const info = await handle.stat();
+		if (!info.isFile() || info.size > 32768) throw new Error("Expected a regular local JSON record, at most 32 KiB");
+		const buffer = Buffer.alloc(32769);
+		const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+		if (bytesRead > 32768) throw new Error("Experiment record exceeds 32 KiB");
+		const data = JSON.parse(buffer.subarray(0, bytesRead).toString("utf8"));
+		if (
+			typeof data.experiment !== "string" ||
+			data.experiment.length > 120 ||
+			!Array.isArray(data.jobs) ||
+			data.jobs.length > 100
+		)
+			throw new Error("Invalid experiment record");
+		for (const job of data.jobs) {
+			if (
+				typeof job.id !== "string" ||
+				job.id.length > 80 ||
+				!["queued", "running", "completed", "failed"].includes(job.state) ||
+				!Number.isInteger(job.ranks) ||
+				job.ranks < 1 ||
+				!Number.isFinite(job.elapsedSeconds) ||
+				job.elapsedSeconds < 0
+			)
+				throw new Error("Invalid job record");
+		}
+		return data;
+	} finally {
+		await handle.close();
+	}
+}
+/** @param {import('@iowarp/clio-coder/extensions').ExtensionApi} api */
+export default function extension(api) {
+	api.handle("dashboard", async (args, context) => {
+		const file = args.trim()
+			? path.resolve(context.snapshot.workspace, args.trim())
+			: new URL("./jobs.synthetic.json", import.meta.url);
+		const data = await readRecord(file);
+		context.signal.throwIfAborted();
+		const label = data.synthetic === true ? "SYNTHETIC FIXTURE" : "LOCAL RECORD (reported, not independently verified)";
+		const completed = data.jobs.filter((job) => job.state === "completed").length;
+		lastStatus = { text: `${label}: ${completed}/${data.jobs.length} completed`, tone: "neutral" };
+		const rows = data.jobs.map((job) => [job.id, String(job.ranks), job.state, String(job.elapsedSeconds)]);
+		return {
+			text: `${label}\n${data.experiment}\n${completed}/${data.jobs.length} completed\n${rows.map((row) => row.join(" | ")).join("\n")}\nSource: ${file}`,
+			status: lastStatus,
+			panel: {
+				title: data.experiment,
+				sections: [
+					{
+						kind: "text",
+						text: `${label}\nSource: ${file}\nThis extension reads records only. It never submits or queries cluster jobs.`,
+					},
+					{ kind: "metrics", items: [{ label: "Completed", value: `${completed}/${data.jobs.length}` }] },
+					{ kind: "table", columns: ["Job", "MPI ranks", "State", "Elapsed s"], rows },
+				],
+			},
+		};
+	});
+	api.on("session_open", () => ({ text: "", status: lastStatus }));
+	api.on("turn_end", () => ({ text: "", status: lastStatus }));
+}

package/examples/extensions/lab-status/jobs.synthetic.json

@@ -0,0 +1,9 @@
+{
+	"synthetic": true,
+	"experiment": "Synthetic stencil scaling fixture",
+	"jobs": [
+		{ "id": "fixture-1", "ranks": 8, "state": "completed", "elapsedSeconds": 42 },
+		{ "id": "fixture-2", "ranks": 16, "state": "completed", "elapsedSeconds": 24 },
+		{ "id": "fixture-3", "ranks": 32, "state": "running", "elapsedSeconds": 9 }
+	]
+}

package/examples/extensions/measurements/clio-coder-extension.json

@@ -0,0 +1,28 @@
+{
+	"id": "measurements",
+	"name": "Measurement summary",
+	"version": "1.0.0",
+	"description": "Count, mean, min, max and sample standard deviation of supplied finite measurements.",
+	"compatibility": { "clio": ">=0.4.7" },
+	"capabilities": {
+		"tools": [
+			{
+				"name": "summarize",
+				"description": "Summarize supplied measurements without inventing physical units or provenance.",
+				"runtime": "node",
+				"entrypoint": "summarize.cjs",
+				"timeoutMs": 10000,
+				"maxOutputBytes": 16384,
+				"inputSchema": {
+					"type": "object",
+					"properties": {
+						"values": { "type": "array", "items": { "type": "number" }, "minItems": 1, "maxItems": 1000 },
+						"units": { "type": "string", "maxLength": 40 }
+					},
+					"required": ["values"],
+					"additionalProperties": false
+				}
+			}
+		]
+	}
+}

package/examples/extensions/measurements/summarize.cjs

@@ -0,0 +1,23 @@
+const { values, units } = JSON.parse(process.argv[2]);
+if (!Array.isArray(values) || values.length < 1 || values.length > 1000 || !values.every(Number.isFinite))
+	throw new Error("Expected 1-1000 finite measurements");
+let mean = 0;
+let m2 = 0;
+for (const [index, value] of values.entries()) {
+	const delta = value - mean;
+	mean += delta / (index + 1);
+	m2 += delta * (value - mean);
+}
+if (!Number.isFinite(mean) || !Number.isFinite(m2))
+	throw new Error("Numerical overflow; rescale the supplied measurements");
+console.log(
+	JSON.stringify({
+		count: values.length,
+		mean,
+		min: Math.min(...values),
+		max: Math.max(...values),
+		sampleStandardDeviation: values.length > 1 ? Math.sqrt(m2 / (values.length - 1)) : null,
+		units: units ?? null,
+		source: "caller-supplied measurements; provenance not independently verified",
+	}),
+);

package/library/README.md

@@ -0,0 +1,109 @@
+# Clio Coder Library
+
+The Clio Coder library is the canonical home of shareable packages, contributor entry points, and the generated distribution index.
+
+## Package Kinds
+
+The library organizes shareable packages by kind into dedicated directories:
+
+| Kind | Directory | What an author shares | How it is used |
+| --- | --- | --- | --- |
+| **Skill** | `library/skills/` | A procedure and supporting knowledge for the agent | `/skill <skill-name>` |
+| **Agent** | `library/agents/` | A worker recipe: role, tools, budget, and result contract | `/run <agent-id> <task>` or dispatch |
+| **Prompt** | `library/prompts/` | Reusable task text and parameterized instructions | `/<derived-prompt-name> [arguments]` |
+| **Fleet** | `library/fleets/` | An executable multi-agent coordination recipe | `/fleet run <name>` or preview |
+| **Plugin** | `library/plugins/` | A cohesive bundle of resources released together | Inspect contents, invoke member recipes |
+
+## Browsing and Managing Packages
+
+```bash
+# Discover packages in the catalog
+clio-coder library list
+clio-coder library search <query>
+
+# Install packages
+clio-coder library install skill:<name> --project
+clio-coder library install plugin:materio --project
+
+# Inspect installed packages
+clio-coder library skills --all --json
+
+# Read every discovered recipe with its owner, origin and invocation
+clio-coder library recipes --json
+clio-coder library recipes <query> --kind agent
+```
+
+`library recipes` reads the same bounded, body-free inventory Clio reads through `context(scope="library")`, so the operator and the model agree about which recipes exist, who owns them, where they came from and how each one is actually invoked. Both are reads: installation, removal and activation stay operator actions through `library install` and `/library`, and `/skill <name>` stays the way a skill is activated.
+
+In an interactive session, `/library` opens the recipe browser.
+
+## Using These Packages From Another Agent
+
+The same sources are usable by Claude Code and Codex with no converted copy and no duplicated recipe body.
+
+```bash
+# Claude Code: the repository is a standard marketplace
+claude plugin marketplace add iowarp/clio-coder
+claude plugin install tdd@clio-coder
+
+# Codex: .agents/skills already links the canonical trees, so a session
+# started in a clone sees all 39 skills. For every repository:
+ln -s "$PWD/library/skills" ~/.agents/skills/clio-coder
+ln -s "$PWD/library/plugins/materio/skills" ~/.agents/skills/materio
+```
+
+`.claude-plugin/marketplace.json` is generated by `pnpm run library:pin` from the pinned packages in `registry.yaml` and verified by `pnpm run library:check`. It is never edited by hand.
+
+A package is published there only when a peer host would load a real skill surface from it and nothing it would default-scan into a native component. Agent-, prompt- and fleet-only packages, and packages that keep Clio recipes in a top-level `agents/` directory, stay valid first-class library packages with no peer-host projection; `library:pin` prints which ones and why. See [coding agent interoperability](../docs/guide/interop.md) for what each host actually loads.
+
+## Authoring Templates
+
+Working, valid authoring templates for all five package kinds live in `library/_authoring/templates/`:
+
+- `library/_authoring/templates/skill/`: Single skill package with house metadata, triggers, and evals.
+- `library/_authoring/templates/agent/`: Standalone agent recipe with strict v1 format, custom audience, and `skills: []`.
+- `library/_authoring/templates/prompt/`: Reusable prompt with path-derived invocation and argument placeholders.
+- `library/_authoring/templates/fleet/`: Multi-agent coordination contract with a valid DAG and documented prerequisites.
+- `library/_authoring/templates/plugin/`: Composite bundle demonstrating an agent binding a contained skill, prompts, and assets.
+
+Templates are authoring reference models; they live outside the five catalog kind roots and never enter `library/registry.yaml`.
+
+## Contributing Packages
+
+Every native installable package carries a portable `plugin.json` manifest.
+The optional `extensions["ai.iowarp.clio"]` metadata declares a Clio-specific
+kind, resource paths and components; conventional plugin packages can expose
+`skills/` without it. The key is metadata inside the interoperable manifest,
+and does not name a marketplace service or require a directory. Supported
+foreign plugin manifests enter through the separate reviewed import route.
+
+1. **Choose package kind**: Decide whether your contribution is a single-kind package (`skill`, `agent`, `prompt`, `fleet`) exposing exactly one public recipe, or a composite `plugin` bundle combining multiple resources.
+2. **Copy authoring template**: Copy from `library/_authoring/templates/<kind>/` into your authoring tree.
+3. **Author resources**:
+   - Single-kind packages expose exactly one public resource file under their resource root (`skills`, `agents`, `prompts`, or `fleets`).
+   - Place `README.md` at the package root, outside the resource root, so it is not discovered as a second recipe.
+   - Packages may carry explicitly invoked scripts (e.g. for offline evaluation or verification). Runtime tools and session hooks belong to the separate harness extension lifecycle.
+4. **Validate**:
+   ```bash
+   clio-coder library validate <package-path> --json
+   ```
+   Validates manifest schema, resource payloads, package reference markers, and loader compatibility in a read-only pass.
+5. **Pin and check**:
+   ```bash
+   pnpm run library:pin   # regenerates full-tree pins in library/registry.yaml
+   pnpm run library:check # verifies all package bytes against library/registry.yaml
+   ```
+   For curated skills under `library/skills/`, maintainers also run:
+   ```bash
+   pnpm run skills:pin    # updates normalized skill-body provenance in library/skills/registry.yaml
+   pnpm run skills:check  # verifies skill provenance records
+   ```
+   *Full-tree pins* cover every distributed byte for runtime package integrity; *normalized skill hashes* record advisory provenance for audited instructions.
+6. **Try in isolated project**:
+   ```bash
+   clio-coder library register <package-path> --project
+   clio-coder library install <kind>:<name> --project
+   ```
+7. **Submit a focused fork PR**: Push to your fork and submit a PR against `main`.
+
+Built-in agent recipes and baseline fleets remain product-owned under `src/domains/agents/builtins/` and `src/domains/agents/fleets/`.

package/library/_authoring/templates/agent/README.md

@@ -0,0 +1,28 @@
+# Benchmark Scout Agent Template
+
+This template demonstrates a valid standalone **agent** package for Clio Coder.
+
+## Package Structure
+
+```text
+benchmark-scout/
+  README.md                     # Documentation (outside resource root)
+  plugin.json                   # Portable manifest declaring kind: agent
+  agents/
+    benchmark-scout.md          # Agent recipe (strict v1 format)
+```
+
+> **Important**: Place `README.md` at the package root, never inside the `agents/` resource root. Single-kind packages expose exactly one public candidate in their declared resource directory.
+
+## Recipe Constraints
+
+- Must use version 1 schema (`version: 1`).
+- Standalone agents declare `skills: []` and cannot bind external package skills.
+- Must declare `audience: custom` (only built-in recipes can use other audiences).
+- Valid budget, tools (required and optional), capability class, category, and result contract.
+
+## Validation
+
+```bash
+clio-coder library validate .
+```

package/library/_authoring/templates/agent/agents/benchmark-scout.md

@@ -0,0 +1,30 @@
+---
+version: 1
+name: Benchmark Scout
+description: Inspect computational benchmarks, scaling configurations, and performance harnesses in research codebases.
+tools:
+  required: [read, context]
+  optional: [grep, find, ls]
+skills: []
+audience: custom
+category: science
+capabilityClass: read-only
+latencyClass: balanced
+projectContextTier: bounded
+budget: {toolCalls: 32, readReserve: 4, synthesis: true}
+resultContract: {kind: scout-report}
+tags: [benchmarks, hpc, performance, science]
+---
+
+# Benchmark Scout
+
+You are Benchmark Scout, a read-only specialist for discovering, analyzing, and characterizing performance benchmarks in scientific computing and research software.
+
+## Mission
+Inspect benchmark harnesses, scaling runs (strong and weak scaling), and measurement scripts without modifying the workspace or executing unverified code.
+
+## Procedure
+1. **Discover harnesses**: Locate benchmark definitions, Slurm job scripts, MPI run configurations, and test inputs.
+2. **Analyze configurations**: Check problem sizes, grid resolutions, thread pinning, and environment variables.
+3. **Document baselines**: Summarize reported metrics (throughput, memory bandwidth, latency, speedup).
+4. **Deliver scout report**: Return structured findings under the scout-report contract.

package/library/_authoring/templates/agent/plugin.json

@@ -0,0 +1,23 @@
+{
+	"$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+	"name": "benchmark-scout",
+	"version": "1.0.0",
+	"description": "Inspect computational benchmarks, scaling configurations, and performance harnesses.",
+	"license": "Apache-2.0",
+	"extensions": {
+		"ai.iowarp.clio": {
+			"manifestVersion": 1,
+			"kind": "agent",
+			"resources": {
+				"agents": "agents"
+			},
+			"components": [
+				{
+					"kind": "agent",
+					"id": "benchmark-scout",
+					"path": "agents/benchmark-scout.md"
+				}
+			]
+		}
+	}
+}

package/library/_authoring/templates/fleet/README.md

@@ -0,0 +1,29 @@
+# Pipeline Review Fleet Template
+
+This template demonstrates a valid standalone **fleet** package for Clio Coder.
+
+## Package Structure
+
+```text
+pipeline-review/
+  README.md                     # Documentation (outside resource root)
+  plugin.json                   # Portable manifest declaring kind: fleet
+  fleets/
+    pipeline-review.md          # Multi-agent coordination contract
+```
+
+> **Important**: Place `README.md` at the package root, never inside the `fleets/` resource root. Single-kind packages expose exactly one public candidate in their declared resource directory.
+
+## Graph and Step Semantics
+
+- **Version**: Version 1 or higher (v4 introduces strict write boundaries).
+- **Steps**: Each step specifies `id`, `agent`, `scope`, and `dependencies`.
+- **Graph Validity**: Steps must form a directed acyclic graph (DAG) without cycles or unknown dependencies.
+- **Prompt Body**: Uses strict `{{var}}` interpolation; all variables must be supplied at invocation (e.g. `--var pipeline=configs/pipeline.yaml`).
+- **Prerequisites**: Fleets that reference core built-in agents (e.g., `scout`, `verifier`) should clearly document these dependencies in their body.
+
+## Validation
+
+```bash
+clio-coder library validate .
+```

package/library/_authoring/templates/fleet/fleets/pipeline-review.md

@@ -0,0 +1,31 @@
+---
+version: 1
+name: pipeline-review
+description: Coordinate a two-stage inspection of scientific pipeline data definitions and validation assertions.
+steps:
+  - id: inspect-pipeline
+    agent: scout
+    scope: readonly
+    dependencies: []
+  - id: verify-invariants
+    agent: verifier
+    scope: readonly
+    dependencies: [inspect-pipeline]
+maxWorkers: 2
+onFailure: stop
+---
+
+Review the scientific pipeline specified at: {{pipeline}}.
+
+## Workflow Stages
+
+1. **inspect-pipeline (`scout`)**:
+   Inspect data schemas, pipeline steps, dependency declarations, and configuration inputs in the target pipeline.
+2. **verify-invariants (`verifier`)**:
+   Independently verify that numerical tolerances, sanity checks, regression tests, and invariant assertions are defined and bounded.
+
+## Prerequisites & Environment Requirements
+
+- **Core Agents**: This fleet coordinates the built-in `scout` and `verifier` recipes provided by Clio (`src/domains/agents/builtins/`).
+- **Configuration**: Requires a configured read-only model target with context support.
+- **Variables**: The caller must supply the `{{pipeline}}` variable naming the pipeline configuration or script path (e.g. `--var pipeline=configs/pipeline.yaml`).

package/library/_authoring/templates/fleet/plugin.json

@@ -0,0 +1,23 @@
+{
+	"$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+	"name": "pipeline-review",
+	"version": "1.0.0",
+	"description": "Multi-agent coordination recipe for reviewing scientific data pipelines.",
+	"license": "Apache-2.0",
+	"extensions": {
+		"ai.iowarp.clio": {
+			"manifestVersion": 1,
+			"kind": "fleet",
+			"resources": {
+				"fleets": "fleets"
+			},
+			"components": [
+				{
+					"kind": "fleet",
+					"id": "pipeline-review",
+					"path": "fleets/pipeline-review.md"
+				}
+			]
+		}
+	}
+}

package/library/_authoring/templates/plugin/README.md

@@ -0,0 +1,37 @@
+# Data Curation Plugin Template
+
+This template demonstrates a valid composite **plugin** bundle for Clio Coder.
+
+## Package Structure
+
+```text
+data-curation/
+  README.md                                 # Documentation
+  plugin.json                               # Manifest declaring bundle resources & components
+  assets/
+    curation-guide.md                       # Supporting reference asset (component:resource:guidelines)
+  skills/
+    dataset-curation/
+      SKILL.md                              # Bound skill
+      evals.md                              # Skill evaluation scenarios
+  agents/
+    data-curator.md                         # Agent binding dataset-curation skill
+  prompts/
+    inspect-dataset.md                      # Prompt requiring data-curator agent
+```
+
+## Manifest Declarations
+
+- **Resources**: Declares ordinary `skills`, `agents`, and `prompts` directories under `extensions["ai.iowarp.clio"]`.
+- **Components**:
+  - `resource:guidelines` -> `assets/curation-guide.md`
+  - `skill:dataset-curation` -> `skills/dataset-curation/SKILL.md` (requires `resource:guidelines`)
+  - `agent:data-curator` -> `agents/data-curator.md` (requires `skill:dataset-curation`)
+  - `prompt:inspect-dataset` -> `prompts/inspect-dataset.md` (requires `agent:data-curator`)
+- **Acyclic References**: Component dependencies form a clean DAG.
+
+## Validation
+
+```bash
+clio-coder library validate .
+```

package/library/_authoring/templates/plugin/agents/data-curator.md

@@ -0,0 +1,31 @@
+---
+version: 1
+name: Data Curator
+description: Inspect and curate scientific datasets against FAIR data guidelines and metadata schemas.
+tools:
+  required: [read, context]
+  optional: [grep, find, ls]
+skills: [dataset-curation]
+audience: custom
+category: science
+capabilityClass: read-only
+latencyClass: balanced
+projectContextTier: bounded
+budget: {toolCalls: 32, readReserve: 4, synthesis: true}
+resultContract: {kind: scout-report}
+tags: [data, fair, curation, science]
+---
+
+# Data Curator
+
+You are Data Curator, a read-only specialist for reviewing scientific datasets and confirming compliance with FAIR principles.
+
+Use the bound `dataset-curation` skill to inspect dataset organization, and check the curation reference at ${component:resource:guidelines}.
+
+## Mission
+Inspect dataset layout, format standards (NetCDF, HDF5, CSV, Parquet), metadata schemas, and licensing documentation.
+
+## Procedure
+1. Check for standard dataset metadata descriptors (e.g. README.md, datapackage.json, or CF conventions).
+2. Validate column definitions, units, and missing value encodings against ${component:resource:guidelines}.
+3. Return findings conforming to the scout-report contract.

package/library/_authoring/templates/plugin/assets/curation-guide.md

@@ -0,0 +1,22 @@
+# Dataset Curation Guide
+
+Guidelines for curating and validating scientific research datasets.
+
+## FAIR Principles Checklist
+
+1. **Findable**:
+   - Unique persistent identifier or stable local path.
+   - Comprehensive metadata descriptor (e.g. `datapackage.json` or `README.md`).
+2. **Accessible**:
+   - Clear retrieval instructions and standard open file formats (CSV, Parquet, NetCDF, HDF5, JSON).
+3. **Interoperable**:
+   - Documented vocabulary, standard units (SI), and recognized domain conventions (e.g., Climate and Forecast CF conventions).
+4. **Reusable**:
+   - Explicit license specification (e.g., CC-BY-4.0, CC0, Apache-2.0).
+   - Data provenance and generation parameters recorded.
+
+## Quality Invariants
+
+- No unencoded NaN or infinite values without documented sentinel symbols.
+- Timestamp formats follow ISO 8601 (`YYYY-MM-DDTHH:MM:SSZ`).
+- Geospatial coordinates follow WGS84 with explicit latitude/longitude bounds.