@ema.co/machina 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ema Unlimited
+
+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/README.md

@@ -0,0 +1,88 @@
+# **eMa***china*
+
+Agent-skills packages for **eMa***china*. Each skill is a self-contained package under [`skills/<name>/`](skills/) with a `SKILL.md` plus optional `references/`, `assets/`, and `scripts/` — the [Agent Skills](https://agentskills.io/specification) / [anthropics/skills](https://github.com/anthropics/skills) layout. This repo ships one marketplace, **`ema`**, with one plugin, **`emachina`**, that exposes every package under `skills/`.
+
+This is **not** an application — there is no app build. The two audiences are covered below: [install as a consumer](#install-as-a-consumer) and [develop on this repo](#develop-on-this-repo).
+
+## Skills
+
+Packages live under [`skills/`](skills/) — that dir is the authoritative set; the table below is a convenience index.
+
+| Skill | What it does | Docs |
+| ----- | ------------ | ---- |
+| [harvest](skills/harvest/) | Universal context harvester — gather/synthesize context from files, URLs, transcripts, CRM, web, or tools into one `harvest-yield.md`. Invoke with `/harvest`. | [Architecture](skills/harvest/README.md) |
+
+## Install (as a consumer)
+
+You want to *use* the skills, not develop them. The plugin is `emachina`, in marketplace `ema`.
+
+### Claude Code
+
+In a Claude Code session:
+
+```text
+/plugin marketplace add Ema-Unlimited/eMachina
+/plugin install emachina@ema
+```
+
+`marketplace add` also accepts a URL or a local path (e.g. a clone: `/plugin marketplace add ~/path/to/eMachina`). After install, the skills are discoverable — e.g. type `/harvest` or describe a gathering task and the `harvest` skill triggers on its description. Verified with `claude plugin validate --strict`; consumer `marketplace add` / `install` confirmed locally.
+
+### Cursor
+
+Install via Cursor's plugin marketplace when published, or open a clone of this repo directly — Cursor loads project skills from `.agents/skills/` ([Cursor Agent Skills docs](https://cursor.com/docs/skills)), which the `.agents/skills → ../skills` hub exposes. No separate `.cursor/skills` symlink is needed.
+
+## Develop on this repo
+
+You want to author or change a skill.
+
+**1. Get the repo and open it.**
+
+```bash
+git clone git@github.com:Ema-Unlimited/eMachina.git
+cd eMachina
+```
+
+Open in Claude Code or Cursor. Packages under `skills/` are discovered through the symlink hub (below) — no install step needed for local development; edits are live.
+
+**2. Read the guidelines first.** [`AGENTS.md`](AGENTS.md) is the canonical project instruction ([`CLAUDE.md`](CLAUDE.md) just imports it, since Claude Code looks for that filename). Authorship rules for packages under `skills/` are in [`skills/AGENTS.md`](skills/AGENTS.md).
+
+**3. Author or change a skill** (full procedure in [`AGENTS.md`](AGENTS.md) → *Author or change a skill*):
+- Put the package at `skills/<name>/` with a `SKILL.md` (name + description frontmatter). It is **auto-discovered** under the plugin `source` — no manifest edit needed.
+- Edit the **canonical tree** `skills/<name>/`, never a nested copy under the discovery dirs (`.claude/skills/`, `.agents/skills/`) — those resolve here via symlink.
+- Only touch [`.agents/plugin/marketplace.json`](.agents/plugin/marketplace.json) to add/rename a **plugin** entry itself. Never edit the `.claude-plugin/` or `.cursor-plugin/` views — they are symlinks into it.
+
+**4. Validate before you push.**
+
+```bash
+# Plugin manifest (both symlinked views resolve to the same file)
+claude plugin validate .claude-plugin/marketplace.json --strict
+
+# Example: harvest's yield-contract validator (per-skill tooling lives in the package)
+python3 skills/harvest/evals/scripts/validate_yield.py <path/to/harvest-yield.md>
+```
+
+> The yield validator needs `pyyaml` (`pip install pyyaml`).
+
+**5. Ship via a PR.** Main is protected — branch, push, open a PR (see [`AGENTS.md`](AGENTS.md)). Package a skill for distribution via a discovered packager (e.g. skill-creator) — no fixed `~/.agents/...` path is assumed.
+
+## Layout
+
+```text
+.agents/plugin/marketplace.json                              # canonical manifest — marketplace "ema" → plugin "emachina"
+.claude-plugin/marketplace.json → ../.agents/plugin/marketplace.json   # Claude Code view (symlink)
+.cursor-plugin/marketplace.json → ../.agents/plugin/marketplace.json   # Cursor view (symlink)
+.agents/skills  → ../skills           # agent-agnostic hub (Cursor reads this directly)
+.claude/skills  → ../.agents/skills   # Claude Code view (routes through the hub)
+.harvest/                         # harvest runtime yields (gitignored; see below)
+skills/<name>/                    # Canonical packages
+```
+
+One manifest, two symlinked views — edit `.agents/plugin/marketplace.json` only. Skills auto-resolve through the symlink (`source: "./"` is relative to the repo root, i.e. the symlink's location).
+
+`.harvest/` tracking (from [`.gitignore`](.gitignore)) — yields (and any transient captures) stay ignored; the agent-memory files under `.harvest/` stay tracked:
+
+```gitignore
+.harvest/*
+!.harvest/AGENTS.md
+!.harvest/CLAUDE.md
+```

package/dist/mcp/atom/backends.js

@@ -0,0 +1,100 @@
+/**
+ * Vendored from @ema/knowledge-service `src/atom/backends.ts` (2026-07-13).
+ * Reference backends: a filesystem StorageBackend (the local staging tier) and a
+ * store-derived RetrievalBackend that needs NO DE (keyword scan + audience filter).
+ * Cloud implementations (GCS storage; DE/Vertex retrieval via the ema MCP) satisfy
+ * the same interfaces — the seam `corpus.ts` selects at runtime.
+ */
+import { mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+function idToFile(id) {
+    return `${id.replace(/[^a-zA-Z0-9._-]/g, "_")}.json`;
+}
+/** PRIMARY store backed by the local filesystem. One JSON blob per atom, keyed by id. */
+export class LocalStorageBackend {
+    dir;
+    name = "local-fs";
+    constructor(dir) {
+        this.dir = dir;
+        mkdirSync(dir, { recursive: true });
+    }
+    async put(atom) {
+        writeFileSync(join(this.dir, idToFile(atom.id)), JSON.stringify(atom, null, 2));
+    }
+    async get(id) {
+        const path = join(this.dir, idToFile(id));
+        if (!existsSync(path))
+            return null;
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    async has(id) {
+        return existsSync(join(this.dir, idToFile(id)));
+    }
+    async list() {
+        if (!existsSync(this.dir))
+            return [];
+        return readdirSync(this.dir)
+            .filter((f) => f.endsWith(".json"))
+            .map((f) => JSON.parse(readFileSync(join(this.dir, f), "utf8")));
+    }
+    async delete(id) {
+        const path = join(this.dir, idToFile(id));
+        if (existsSync(path))
+            rmSync(path);
+    }
+}
+/** Caller audience matches an atom iff the atom is public or its token is in the caller set. */
+export function audienceVisible(atomAudience, caller) {
+    // Array guard: a nullish or non-array caller must fail closed for a scoped atom
+    // (return false), never throw and never fall through to string `.includes` substring matching.
+    return atomAudience === "public" || (Array.isArray(caller) && caller.includes(atomAudience));
+}
+function tokenize(s) {
+    return s.toLowerCase().match(/[a-z0-9]+/g) ?? [];
+}
+/**
+ * DE-free retrieval: an index derived from the primary store. Keyword-overlap scoring
+ * over name+description+body, with the `audience` hard filter applied. This is the
+ * "works without DE/Vertex" path; org-wide semantic search composes via the ema MCP.
+ */
+export class StoreScanRetrieval {
+    name = "store-scan";
+    atoms = new Map();
+    /** Optionally hydrate the projection from the primary store. */
+    async rebuildFrom(storage) {
+        this.atoms.clear();
+        for (const a of await storage.list())
+            this.atoms.set(a.id, a);
+    }
+    async index(atom) {
+        this.atoms.set(atom.id, atom);
+    }
+    async remove(id) {
+        this.atoms.delete(id);
+    }
+    async search(query, opts) {
+        const caller = opts.audience ?? ["public"];
+        const qTokens = tokenize(query);
+        const hits = [];
+        for (const atom of this.atoms.values()) {
+            if (atom.status === "retracted")
+                continue;
+            if (!audienceVisible(atom.audience, caller))
+                continue;
+            const hay = tokenize(`${atom.name} ${atom.description} ${atom.body}`);
+            const haySet = new Set(hay);
+            const matched = qTokens.filter((t) => haySet.has(t)).length;
+            if (matched === 0)
+                continue;
+            hits.push({
+                id: atom.id,
+                name: atom.name,
+                description: atom.description,
+                audience: atom.audience,
+                score: qTokens.length ? matched / qTokens.length : 0,
+            });
+        }
+        hits.sort((a, b) => b.score - a.score);
+        return hits.slice(0, opts.limit ?? 10);
+    }
+}

package/dist/mcp/atom/core.js

@@ -0,0 +1,93 @@
+/**
+ * Vendored from @ema/knowledge-service `src/atom/core.ts` (2026-07-13).
+ * The one common normalized path: buildAtom + submitChanges + search, over pluggable
+ * backends. The write-ingress invariant: BLOCKING validate → dedup(has(id)) →
+ * primary-write-is-truth → best-effort projection → retract = tombstone-not-delete.
+ * Conformance: `test/atom-conformance.test.mjs`.
+ */
+import { contentAddressId } from "./id.js";
+import { validateAtomInput, assertValidChange, ValidationError } from "./validate.js";
+/** Validate + normalize caller input into a content-addressed Atom. Throws ValidationError on invalid input. */
+export function buildAtom(input) {
+    const errors = validateAtomInput(input);
+    if (errors.length > 0)
+        throw new ValidationError(errors);
+    const audience = input.audience ?? "internal"; // public must be explicit
+    const id = contentAddressId({ name: input.name, description: input.description, body: input.body });
+    return {
+        id,
+        audience,
+        name: input.name,
+        description: input.description,
+        body: input.body,
+        status: "active",
+        produced_by: input.produced_by ?? "unknown",
+        produced_at: new Date().toISOString(),
+        ...(input.supersedes !== undefined ? { supersedes: input.supersedes } : {}),
+        ...(input.derived_from !== undefined ? { derived_from: input.derived_from } : {}),
+    };
+}
+/** Best-effort projection — a retrieval-backend failure must NOT fail a primary write. */
+async function project(retrieval, fn) {
+    if (!retrieval)
+        return undefined;
+    try {
+        await fn(retrieval);
+        return undefined;
+    }
+    catch (err) {
+        return `retrieval projection (${retrieval.name}) failed: ${err.message}`;
+    }
+}
+/**
+ * The sole write ingress. Writes the PRIMARY store first (success = published), then
+ * best-effort projects to the retrieval backend. Ops: publish | retract | set_audience.
+ */
+export async function submitChanges(change, backends) {
+    assertValidChange(change); // BLOCKING validation — no client can bypass
+    const { storage, retrieval } = backends;
+    switch (change.op) {
+        case "publish": {
+            if (!change.atom)
+                throw new Error("submitChanges(publish): `atom` is required");
+            const atom = buildAtom(change.atom);
+            if (await storage.has(atom.id)) {
+                return { status: "deduplicated", id: atom.id, atom: (await storage.get(atom.id)) ?? atom };
+            }
+            await storage.put(atom); // PRIMARY write — the publish is durable once this returns
+            const warning = await project(retrieval, (r) => r.index(atom));
+            return { status: "published", id: atom.id, atom, ...(warning ? { warning } : {}) };
+        }
+        case "retract": {
+            if (!change.id)
+                throw new Error("submitChanges(retract): `id` is required");
+            const existing = await storage.get(change.id);
+            if (!existing)
+                throw new Error(`submitChanges(retract): atom "${change.id}" not found`);
+            const tombstoned = { ...existing, status: "retracted" };
+            await storage.put(tombstoned); // kept, not purged (append-only tombstone)
+            await project(retrieval, (r) => r.remove(change.id));
+            return { status: "retracted", id: change.id, atom: tombstoned };
+        }
+        case "set_audience": {
+            const id = change.id; // guaranteed present + valid by assertValidChange
+            const audience = change.audience;
+            const existing = await storage.get(id);
+            if (!existing)
+                throw new Error(`submitChanges(set_audience): atom "${id}" not found`);
+            const updated = { ...existing, audience }; // id unchanged (audience ∉ identity)
+            await storage.put(updated);
+            await project(retrieval, (r) => r.index(updated));
+            return { status: "audience_set", id, atom: updated };
+        }
+        default: {
+            throw new Error(`submitChanges: unknown op "${change.op}"`);
+        }
+    }
+}
+/** The sole read path — delegates to the retrieval backend with the audience hard filter. */
+export async function search(query, opts, backends) {
+    if (!backends.retrieval)
+        throw new Error("search: no retrieval backend configured");
+    return backends.retrieval.search(query, opts);
+}

package/dist/mcp/atom/hash.js

@@ -0,0 +1,41 @@
+/**
+ * Vendored from @ema/knowledge-service `src/pipeline/hash.ts` (2026-07-13) — the canonical
+ * hashing for content-addressed atom ids. Wire-conformance guarded by
+ * `test/atom-conformance.test.mjs` (golden vectors frozen from the canonical lib).
+ */
+import { createHash } from "node:crypto";
+/** Full-width (64 hex char) SHA-256 of a string. */
+export function sha256Hex(input) {
+    return createHash("sha256").update(input).digest("hex");
+}
+/**
+ * Deterministic ("canonical") JSON: object keys sorted recursively, arrays kept
+ * in order, no insignificant whitespace, `undefined` object values omitted (JSON
+ * semantics). The same logical value always serializes identically.
+ */
+export function canonicalJson(value) {
+    return JSON.stringify(canonicalize(value));
+}
+function canonicalize(value) {
+    // Honor toJSON (e.g. Date -> ISO string) before structural recursion, matching
+    // JSON.stringify semantics — otherwise a Date collapses to {} and two distinct
+    // timestamps would hash identically.
+    if (value !== null &&
+        typeof value === "object" &&
+        typeof value.toJSON === "function") {
+        return canonicalize(value.toJSON());
+    }
+    if (Array.isArray(value))
+        return value.map(canonicalize);
+    if (value !== null && typeof value === "object") {
+        const source = value;
+        const out = {};
+        for (const key of Object.keys(source).sort()) {
+            const v = source[key];
+            if (v !== undefined)
+                out[key] = canonicalize(v);
+        }
+        return out;
+    }
+    return value;
+}

package/dist/mcp/atom/id.js

@@ -0,0 +1,25 @@
+/**
+ * Vendored from @ema/knowledge-service `src/atom/id.ts` (2026-07-13).
+ * Content-addressing + audience grammar. Conformance: `test/atom-conformance.test.mjs`.
+ */
+import { sha256Hex, canonicalJson } from "./hash.js";
+/**
+ * Single-token audience grammar (one token per atom):
+ *   public | internal | internal:<slug> | tenant:<slug> | customer:<slug>
+ */
+export const AUDIENCE_RE = /^(public|internal(:[a-z0-9-]+)?|tenant:[a-z0-9-]+|customer:[a-z0-9-]+)$/;
+export function isValidAudience(token) {
+    // typeof guard FIRST: RegExp.test coerces its arg to a string, so an array like
+    // ["internal"] would stringify to "internal" and falsely match — then fail-closed
+    // to invisible-for-everyone. Require an actual string.
+    return typeof token === "string" && AUDIENCE_RE.test(token);
+}
+/**
+ * Content-addressed id: `atom:` + 32 hex (128-bit) prefix of the SHA-256 of the
+ * canonical content. Identical content → identical id → dedup. Audience/provenance
+ * are excluded (they are mutable / not content).
+ */
+export function contentAddressId(c) {
+    const hash = sha256Hex(canonicalJson({ name: c.name, description: c.description, body: c.body }));
+    return `atom:${hash.slice(0, 32)}`;
+}

package/dist/mcp/atom/index.js

@@ -0,0 +1,17 @@
+/**
+ * eMachina's OWNED atom kernel — the local staging tier of the knowledge substrate.
+ *
+ * Vendored from @ema/knowledge-service `/atom` (2026-07-13) per the greenfield decision
+ * (.harvest/knowledge-substrate-greenfield-goals): own the ~small local kernel; consume
+ * everything org-wide (DE search, publish, auth) as MCP runtime resources — never a
+ * build-time dependency on the sibling repo. Wire-contract conformance with canonical
+ * KS is guarded by frozen golden vectors in `test/atom-conformance.test.mjs`: same
+ * input MUST produce the same content-addressed id, or staged atoms stop being
+ * portable to the org corpus.
+ */
+export * from "./types.js";
+export { contentAddressId, isValidAudience, AUDIENCE_RE } from "./id.js";
+export { sha256Hex, canonicalJson } from "./hash.js";
+export { buildAtom, submitChanges, search } from "./core.js";
+export { LocalStorageBackend, StoreScanRetrieval, audienceVisible } from "./backends.js";
+export { validate, validateChange, validateAtomInput, assertValidChange, ValidationError, LIMITS, } from "./validate.js";

package/dist/mcp/atom/types.js

@@ -0,0 +1,7 @@
+/**
+ * Vendored from @ema/knowledge-service `src/atom/types.ts` (2026-07-13) — the single Atom
+ * type + the two pluggable backends (StorageBackend primary, RetrievalBackend projection).
+ * ONE unstructured Atom; `audience` is the single hard ACL filter; immutable + append-only
+ * (new content = new content-addressed atom + `supersedes`; retract = tombstone).
+ */
+export {};

package/dist/mcp/atom/validate.js

@@ -0,0 +1,91 @@
+/**
+ * Vendored from @ema/knowledge-service `src/atom/validate.ts` (2026-07-13).
+ * Blocking, typed validation — enforced INSIDE the write path (submitChanges) so no
+ * client can bypass it. `validate()` is also exported for pre-flight checks.
+ * Conformance: `test/atom-conformance.test.mjs`.
+ */
+import { isValidAudience } from "./id.js";
+export const LIMITS = {
+    MAX_NAME: 512,
+    MAX_DESCRIPTION: 4096,
+    MAX_BODY: 1_000_000, // 1M chars — generous for free-form knowledge, catches runaway/garbage
+};
+const ATOM_ID_RE = /^atom:[a-f0-9]{16,64}$/;
+/**
+ * typeof guard FIRST, then the regex — RegExp.test coerces its arg via ToString, so a
+ * single-element array like ["atom:abc…"] stringifies to "atom:abc…" and would falsely
+ * match (then get written raw / crash downstream). Same hardening as isValidAudience.
+ */
+function isValidAtomId(v) {
+    return typeof v === "string" && ATOM_ID_RE.test(v);
+}
+export class ValidationError extends Error {
+    errors;
+    constructor(errors) {
+        super(`validation failed: ${errors.join("; ")}`);
+        this.name = "ValidationError";
+        this.errors = errors;
+    }
+}
+function reqString(v, field, max, errors) {
+    if (typeof v !== "string" || v.trim() === "") {
+        errors.push(`${field} is required and must be a non-empty string`);
+    }
+    else if (v.length > max) {
+        errors.push(`${field} exceeds max length ${max} (got ${v.length})`);
+    }
+}
+/** Field-level validation for a publish payload. Returns a list of errors (empty = valid). */
+export function validateAtomInput(input) {
+    const errors = [];
+    if (input === null || typeof input !== "object")
+        return ["atom input must be an object"];
+    reqString(input.name, "name", LIMITS.MAX_NAME, errors);
+    reqString(input.description, "description", LIMITS.MAX_DESCRIPTION, errors);
+    reqString(input.body, "body", LIMITS.MAX_BODY, errors);
+    if (input.audience !== undefined && !isValidAudience(input.audience)) {
+        errors.push(`invalid audience token "${input.audience}" (expect public|internal[:slug]|tenant:slug|customer:slug)`);
+    }
+    if (input.supersedes !== undefined && !isValidAtomId(input.supersedes)) {
+        errors.push(`supersedes must be a valid atom id (atom:<hex>), got "${String(input.supersedes)}"`);
+    }
+    if (input.produced_by !== undefined && typeof input.produced_by !== "string") {
+        errors.push("produced_by must be a string");
+    }
+    return errors;
+}
+/** Op-level validation for a submitChanges request. Returns a list of errors (empty = valid). */
+export function validateChange(change) {
+    if (change === null || typeof change !== "object")
+        return ["change must be an object"];
+    switch (change.op) {
+        case "publish":
+            if (change.atom === undefined)
+                return ["publish requires `atom`"];
+            return validateAtomInput(change.atom);
+        case "retract":
+            return isValidAtomId(change.id) ? [] : [`retract requires a valid atom id, got "${String(change.id)}"`];
+        case "set_audience": {
+            const errors = [];
+            if (!isValidAtomId(change.id))
+                errors.push(`set_audience requires a valid atom id, got "${String(change.id)}"`);
+            if (change.audience === undefined || !isValidAudience(change.audience)) {
+                errors.push(`set_audience requires a valid audience token, got "${change.audience}"`);
+            }
+            return errors;
+        }
+        default:
+            return [`unknown op "${String(change.op)}" (expect publish|retract|set_audience)`];
+    }
+}
+/** Public pre-flight: `{ valid, errors }`. Clients may call before submitChanges. */
+export function validate(change) {
+    const errors = validateChange(change);
+    return { valid: errors.length === 0, errors };
+}
+/** Blocking assertion used inside submitChanges. Throws ValidationError on any violation. */
+export function assertValidChange(change) {
+    const errors = validateChange(change);
+    if (errors.length > 0)
+        throw new ValidationError(errors);
+}

package/dist/mcp/capabilities.js

@@ -0,0 +1,77 @@
+/**
+ * Capability registry — the SINGLE SOURCE OF TRUTH for the tool surface.
+ *
+ * generateTools() (tools.ts), the dispatch-map parity guard (server.ts), and
+ * config's wired/pending report all DERIVE from this. Adding a noun/method is one
+ * edit here — capabilities are DATA, not metadata re-encoded across files. This is
+ * the "stable surface + registry" the mcp-build-principles yield chose; it's also
+ * the migration the reviewer flagged to do before the 5th (or the generated
+ * `automation`) noun.
+ *
+ * This module is intentionally DEPENDENCY-FREE (no handler imports) so nothing can
+ * import-cycle through it; handlers are wired to these names in server.ts (the
+ * composition root), and a load-time parity guard there fails loudly on drift.
+ */
+export const CAPABILITIES = [
+    {
+        name: "config",
+        status: "wired",
+        description: "Inspect eMachina's readiness (the needs/state check). Run this FIRST, and whenever a downstream " +
+            "tool reports a gap. Returns which capabilities are wired vs pending, plus required next steps.",
+        methods: [{ name: "status", description: "return the readiness snapshot" }],
+    },
+    {
+        name: "yield",
+        status: "wired",
+        description: "Manage harvest YIELD artifacts — the deterministic substrate. The agent RUNS the harvest procedure " +
+            "(intake/gather/synthesis = thinking); this tool validates/lists/reads/scaffolds the yields it produces. " +
+            "`validate` is a blocking gate over the canonical contract.",
+        methods: [
+            { name: "validate", description: "run the canonical validator (blocking gate)" },
+            { name: "list", description: "list yield slugs under .harvest/" },
+            { name: "get", description: "read a yield by slug" },
+            { name: "scaffold", description: "create a new yield from the canonical skeleton" },
+        ],
+        extraProperties: {
+            slug: { type: "string", description: "Yield slug (directory under .harvest/) — for get/scaffold/validate" },
+            path: { type: "string", description: "Explicit path to a yield .md — overrides slug for validate" },
+        },
+    },
+    {
+        name: "curate",
+        status: "wired",
+        description: "Memorialize / keep-memory-healthy over the corpus (publish, supersede, dedup, advise), powered by " +
+            "the owned atom kernel's submitChanges — content-addressed dedup + kernel-enforced validation " +
+            "(wire-conformant with canonical KS via golden vectors). Local corpus is the staging tier; org-wide " +
+            "COMPOSES with the ema toolkit's knowledge() by swapping the StorageBackend.",
+        methods: [
+            { name: "publish", description: "memorialize a yield (by slug) or explicit content as an atom" },
+            { name: "supersede", description: "publish an atom that supersedes a prior one (needs `supersedes`)" },
+            { name: "advise", description: "pre-flight the lib's validation on a yield without writing" },
+            { name: "status", description: "report curate readiness" },
+        ],
+        extraProperties: {
+            slug: { type: "string", description: "Yield slug to memorialize (for publish/supersede/advise)" },
+            name: { type: "string", description: "Atom title (if not using slug)" },
+            description: { type: "string", description: "Atom description (if not using slug)" },
+            body: { type: "string", description: "Atom body/content (if not using slug)" },
+            audience: { type: "string", description: "Audience token: public | internal[:slug] | tenant:slug | customer:slug" },
+            supersedes: { type: "string", description: "Atom id this one supersedes (for method=supersede)" },
+        },
+    },
+    {
+        name: "retrieve",
+        status: "wired",
+        description: "Search / rank the LOCAL corpus (curated atoms + .harvest yields) via the owned atom kernel's search — " +
+            "works offline, with or without DE. Org-wide search COMPOSES with the ema toolkit's knowledge(), not a " +
+            "rebuilt DE client (the scar tissue harvest set out to avoid).",
+        methods: [{ name: "search", description: "query the corpus (relevance-ranked, audience-filtered)" }],
+        extraProperties: {
+            query: { type: "string", description: "Search query (for method=search)" },
+            limit: { type: "number", description: "Max results (default 10)" },
+            audience: { type: "string", description: "Caller audience tokens to filter by (default public+internal)" },
+        },
+    },
+];
+export const WIRED = CAPABILITIES.filter((c) => c.status === "wired").map((c) => c.name);
+export const PENDING = CAPABILITIES.filter((c) => c.status === "pending").map((c) => c.name);

package/dist/mcp/handlers/config/adapter.js

@@ -0,0 +1,7 @@
+import { findRepoRoot } from "../../state.js";
+import { dispatchConfig } from "./index.js";
+/** Adapter: resolve context (repo root). Thin — the only place this noun touches cwd. */
+export async function handleConfig(args) {
+    const ctx = { repoRoot: findRepoRoot(process.cwd()) };
+    return dispatchConfig(args, ctx);
+}

package/dist/mcp/handlers/config/formatters.js

@@ -0,0 +1,25 @@
+import { success } from "../../responses.js";
+import { PENDING, WIRED } from "../../capabilities.js";
+/** Shape the readiness snapshot. wired/pending derive from the capability registry
+ * (SSOT). config OWNS the state report, so it sets _required_next_steps explicitly
+ * (middleware's ??= then leaves it untouched). */
+export function formatStatus(state) {
+    return success({
+        repoRoot: state.repoRoot,
+        // Per-capability runtime readiness (distinct from the surface definition in the registry).
+        readiness: {
+            config: { ready: true, detail: "always available" },
+            yield: state.yieldValidator,
+            curate: { ready: state.knowledgeSubstrate.ready, detail: state.knowledgeSubstrate.detail },
+            retrieve: { ready: state.knowledgeSubstrate.ready, detail: state.knowledgeSubstrate.detail },
+        },
+        harvest_dir: state.harvestDir,
+        wired: WIRED,
+        pending: PENDING,
+    }, {
+        _next_step: state.requiredNextSteps.length
+            ? 'Address _required_next_steps, or call a wired tool — e.g. yield(method="list").'
+            : 'All checked capabilities ready — yield(method="list") to see the corpus.',
+        ...(state.requiredNextSteps.length ? { _required_next_steps: state.requiredNextSteps } : {}),
+    });
+}

package/dist/mcp/handlers/config/index.js

@@ -0,0 +1,17 @@
+import { getState } from "../../state.js";
+import { clarificationNeeded, error } from "../../responses.js";
+import { formatStatus } from "./formatters.js";
+/** Dispatch by explicit `method` — never inferred. */
+export async function dispatchConfig(args, ctx) {
+    const method = args.method;
+    switch (method) {
+        case "status":
+            return formatStatus(getState(ctx.repoRoot));
+        case undefined:
+            return clarificationNeeded("Which operation?", ["status"], {
+                _tip: 'config(method="status") returns the readiness snapshot.',
+            });
+        default:
+            return error(`Unknown method: ${method}`, { _tip: "config supports: status." });
+    }
+}

package/dist/mcp/handlers/corpus.js

@@ -0,0 +1,33 @@
+/**
+ * Shared local-corpus helpers for curate (write) + retrieve (read).
+ *
+ * The local atom corpus is an atom-kernel StorageBackend (src/mcp/atom) rooted at
+ * `<repoRoot>/.knowledge/atoms` (distinct from `.harvest/{slug}/` yields, which
+ * follow the harvest write convention). Curate memorializes atoms here; retrieve
+ * searches here PLUS the raw `.harvest` yields. Org-wide storage/retrieval swaps
+ * this LocalStorageBackend for GcsStorageBackend + DE (compose, don't rebuild).
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { LocalStorageBackend } from "../atom/index.js";
+export const HARVEST = ".harvest";
+export const CORPUS_REL = ".knowledge/atoms";
+/** The local atom corpus (primary StorageBackend for curate/retrieve; GCS in org-wide mode). */
+export function corpusStore(repoRoot) {
+    return new LocalStorageBackend(join(repoRoot, CORPUS_REL));
+}
+/** Read a harvest yield's markdown by slug, or null if absent. */
+export function readYield(repoRoot, slug) {
+    const path = join(repoRoot, HARVEST, slug, "harvest-yield.md");
+    return existsSync(path) ? readFileSync(path, "utf8") : null;
+}
+/** First meaningful (non-heading, non-quote, non-frontmatter) line → minimal description. */
+export function deriveDescription(content, slug) {
+    const body = content.replace(/^---[\s\S]*?---/m, "");
+    for (const line of body.split("\n")) {
+        const t = line.trim();
+        if (t && !t.startsWith("#") && !t.startsWith(">") && !t.startsWith("`"))
+            return t.slice(0, 200);
+    }
+    return slug;
+}