nylorun 0.26.0-beta → 0.27.1-beta

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # nylorun
 
+## 0.27.1-beta
+
+### Patch Changes
+
+- Pin core to the tested release.
+- Pin agents to the tested release.
+- Pin admin to the tested release.
+- Pin runtime to the tested release.
+- Pin studio to the tested release.
+- Updated dependencies [c649f33]
+- Updated dependencies
+- Updated dependencies
+  - @nylorun/core@0.37.0-beta
+  - @nylorun/agents@0.36.0-beta
+  - @nylorun/admin@0.19.13-beta
+
+## 0.27.0-beta
+
+### Minor Changes
+
+- 2afa44d: The Runtime's primitives as its own Agent Plugins (ADR-106, D84). An `agent-folder/3` folder lists them under `plugins:` (`nylorun-memory`, `nylorun-triggers`, `nylorun-plan`, `nylorun-interactions`, `nylorun-artifacts`, `nylorun-sandbox`, which needs a computer), with no versions, and turns one of their tools off with `mcpServers.nylorun.tools.<tool>.enabled: false`. The compiler reads them as the `agent-folder/2` declarations they stand for (`memory`, `loop`, `engine.sandbox`, `engine.artifacts`, `engine.triggers`, which v3 refuses) and records them in `harness.engine.plugins`, each with its tools and the hash of its files. The engine presents their tools as the reserved server `nylorun`: the model reads `nylorun__memory` and the declared plugins' words as one text, with their skills (`memory`, `triggers`) in the catalog, served from the bundle; every effect keeps its target and `toolName`, so the record, tool policy (`kind: "runtime"` rules) and dispatch are unchanged. New: `ask` (`nylorun-interactions`, `harness.loop.ask`), a question that pauses the turn as an A2A `question`; `removeTools` takes `nylorun__<tool>`; `triggers` answers carry `now`; under `nylorun-triggers`, an agent-made trigger's run starts with a `[trigger <id> · <title> · nobody is watching]` line, and a turn a trigger started may set a one-off follow-up (`in` or `at`, `session: "this"`); the sandbox's instructions name the hosts `runtime.json` allows. `nylorun migrate folder <dir> --to 3` writes the plugins that keep an agent's tools and features, and `nylorun check --explain` names the plugin behind each. The JSON Schemas are republished as `agent-manifest/v8.4`, `harness-manifest/v1.4` and `agent-folder/v1/agent-md.4`.
+
+### Patch Changes
+
+- Pin core to the tested release.
+- Pin agents to the tested release.
+- Pin admin to the tested release.
+- Pin runtime to the tested release.
+- Pin studio to the tested release.
+- Updated dependencies [2afa44d]
+- Updated dependencies
+- Updated dependencies
+  - @nylorun/core@0.36.0-beta
+  - @nylorun/agents@0.35.0-beta
+  - @nylorun/admin@0.19.12-beta
+
 ## 0.26.0-beta
 
 ### Minor Changes

package/README.md

@@ -60,6 +60,7 @@ nylorun chat <agent> [--session <id>] [--message <text>]   # send each line (or
 nylorun migrate v8 <agent.json> [--runtime <environment-manifest.json>] [--name <name>] [--out <dir>]   # the three files from a v7 manifest; reads no Runtime
 nylorun migrate folder <dir> [--out <dir>]   # the agent folder of a three-file folder; reads no Runtime
 nylorun migrate folder <dir> --to 2   # make an agent folder agent-folder/2, declaring what it gets today
+nylorun migrate folder <dir> --to 3   # make an agent-folder/2 folder agent-folder/3, with the Runtime's plugins
 nylorun export --folder <name>[@<n>] [--out <dir>]   # the agent folder of a saved manifest (JSON or TypeScript)
 nylorun pull <name>[@<n>] [--out <dir>]   # the folder a version was saved from, byte for byte
 nylorun agent-manifests list [--json]       # name, latest version, runtime kind, harness, Agents
@@ -606,6 +607,24 @@ blocks the agent gets, with their versions and hashes (`harness.engine.blocks`).
 `nylorun migrate folder <dir> --to 2` writes the declarations that keep what an `agent-folder/1`
 folder gets, so nothing changes until you remove a line.
 
+**The Runtime's plugins (`agent-folder/3`, ADR-106).** A v3 folder names the Runtime's features
+as plugins instead of keys:
+
+```yaml
+format: agent-folder/3
+plugins: [nylorun-memory, nylorun-triggers, nylorun-plan, nylorun-interactions, nylorun-artifacts, nylorun-sandbox]
+mcpServers:
+  nylorun:
+    tools: { save_artifact: { enabled: false } }   # one plugin tool turned off
+engine: { outputs: true, toolSearch: false }        # the harness's own, as in v2
+```
+
+Their tools reach the model as the server `nylorun` (`nylorun__memory`, `nylorun__bash`…), with
+the declared plugins' words and skills, and each call's effect is the one it was in v2. The plugins
+follow the Runtime installed, so they take no version. `nylorun-interactions` adds `ask`, a
+question to whoever gave the agent its task. `nylorun migrate folder <dir> --to 3` writes the
+plugins that keep an `agent-folder/2` folder's tools and features.
+
 The loop from an empty folder to an answer:
 
 ```

package/dist/cli.js

@@ -36,6 +36,8 @@ Agent manifests:
                                       (agent.manifest.json; reads no Runtime)
   migrate folder <dir> --to 2         make an agent folder agent-folder/2, declaring every
                                       engine feature it gets today, so nothing it gets changes
+  migrate folder <dir> --to 3         make an agent-folder/2 folder agent-folder/3, declaring
+                                      its Runtime features as plugins (plugins: [nylorun-...])
   export --folder <name>[@<version>] [--out <dir>]
                                       write the agent folder of a saved manifest (Runtime API)
   pull <name>[@<version>] [--out <dir>]

package/dist/client/folder.js

@@ -116,7 +116,8 @@ async function fixFolder(pack, diagnostics, cwd) {
 export function explainLines(agents) {
     const lines = [];
     for (const agent of agents) {
-        lines.push(`  ${agent.agent}: ${agent.declared ? "declares its engine features (agent-folder/2)" : "every engine feature by default (agent-folder/1)"}`);
+        const plugins = agent.features.some((item) => item.declaredBy.startsWith("nylorun-"));
+        lines.push(`  ${agent.agent}: ${plugins ? "declares the Runtime's plugins (agent-folder/3)" : agent.declared ? "declares its engine features (agent-folder/2)" : "every engine feature by default (agent-folder/1)"}`);
         for (const item of agent.features) {
             const adds = [
                 ...(item.tools.length > 0 ? [`tools ${item.tools.join(", ")}`] : []),

package/dist/client/migrate-format.d.ts

@@ -1,5 +1,5 @@
 import type { StackDeps } from "../stack/commands.js";
-export declare const migrateFormatUsage = "nylorun migrate folder <dir> --to 2\n\nMakes the agent folder <dir> agent-folder/2, in place: it adds format: agent-folder/2 to its\nAGENT.md, and to it and each subagent's AGENT.md the engine: block that declares every engine\nfeature the folder gets today by default (the sandbox tools, save_artifact and the outputs folder\nwhen runtime.json has a computer, read_artifact, tool search). Nothing the model reads or may\ncall changes, which it checks before it writes; then remove the lines the agent does not need.\nReads no Runtime.";
+export declare const migrateFormatUsage = "nylorun migrate folder <dir> --to 2|3\n\nMakes the agent folder <dir> agent-folder/2, in place: it adds format: agent-folder/2 to its\nAGENT.md, and to it and each subagent's AGENT.md the engine: block that declares every engine\nfeature the folder gets today by default (the sandbox tools, save_artifact and the outputs folder\nwhen runtime.json has a computer, read_artifact, tool search). Nothing the model reads or may\ncall changes, which it checks before it writes; then remove the lines the agent does not need.\n\nWith --to 3, makes an agent-folder/2 folder agent-folder/3 (ADR-106): the Runtime's plugins\n(plugins: [nylorun-memory, ...]) in place of memory, loop, runtime.selfWake and engine's\nsandbox, artifacts and triggers, with mcpServers.nylorun turning off the tools the folder left\nout, and memory's instructions moved to the end of AGENT.md's body. Every agent keeps the same\ntools and features, which it checks before it writes; the words the model reads become the\nplugins'. Reads no Runtime.";
 /** The `engine:` block that keeps what an agent-folder/1 agent gets, as YAML lines. */
 export declare function engineLines(computer: boolean): string[];
 /**
@@ -8,5 +8,5 @@ export declare function engineLines(computer: boolean): string[];
  * none). Undefined when it has no frontmatter.
  */
 export declare function withFrontmatter(text: string, lines: readonly string[], format?: string): string | undefined;
-/** `nylorun migrate folder <dir> --to 2` */
+/** `nylorun migrate folder <dir> --to 2|3` */
 export declare function migrateFormatCommand(deps: StackDeps, dir: string, to: string): Promise<number>;

package/dist/client/migrate-format.js

@@ -17,18 +17,25 @@ import { readFile, writeFile } from "node:fs/promises";
 import { join, relative } from "node:path";
 import { AGENT_FOLDER_FILE, checkFolder } from "@nylorun/agents";
 import { SANDBOX_TOOL_NAMES } from "@nylorun/core/define";
-import { previewTurn } from "@nylorun/core/engine";
+import { previewTurn, runtimeToolOf } from "@nylorun/core/engine";
+import { folderV3Edit } from "@nylorun/core/folder";
 import { CliError } from "../errors.js";
 import { diagnosticLines, packed } from "./folder.js";
 import { usageError } from "./runtime.js";
-export const migrateFormatUsage = `nylorun migrate folder <dir> --to 2
+export const migrateFormatUsage = `nylorun migrate folder <dir> --to 2|3
 
 Makes the agent folder <dir> agent-folder/2, in place: it adds format: agent-folder/2 to its
 AGENT.md, and to it and each subagent's AGENT.md the engine: block that declares every engine
 feature the folder gets today by default (the sandbox tools, save_artifact and the outputs folder
 when runtime.json has a computer, read_artifact, tool search). Nothing the model reads or may
 call changes, which it checks before it writes; then remove the lines the agent does not need.
-Reads no Runtime.`;
+
+With --to 3, makes an agent-folder/2 folder agent-folder/3 (ADR-106): the Runtime's plugins
+(plugins: [nylorun-memory, ...]) in place of memory, loop, runtime.selfWake and engine's
+sandbox, artifacts and triggers, with mcpServers.nylorun turning off the tools the folder left
+out, and memory's instructions moved to the end of AGENT.md's body. Every agent keeps the same
+tools and features, which it checks before it writes; the words the model reads become the
+plugins'. Reads no Runtime.`;
 /** The `engine:` block that keeps what an agent-folder/1 agent gets, as YAML lines. */
 export function engineLines(computer) {
     return computer
@@ -73,10 +80,89 @@ function seen(manifest) {
     const one = (item) => ({ system: item.system, tools: item.tools });
     return JSON.stringify({ root: one(preview), pinned: preview.pinned, agents: Object.fromEntries(Object.entries(preview.agents).map(([id, item]) => [id, one(item)])) });
 }
-/** `nylorun migrate folder <dir> --to 2` */
+/** What each agent of a compiled folder may call, by the effects of its tools, and what is pinned. */
+function effects(manifest) {
+    if ("kind" in manifest.harness)
+        return "";
+    const preview = previewTurn(manifest);
+    // The skill tools come with the plugins' skills (memory, triggers), so they are left out here.
+    const skillTools = new Set(["load_skill", "read_skill_resource"]);
+    const tools = (item) => item.tools
+        .map((tool) => runtimeToolOf(tool.name) ?? tool.name)
+        .filter((name) => !skillTools.has(name))
+        .sort();
+    return JSON.stringify({ root: tools(preview), pinned: preview.pinned.length, agents: Object.fromEntries(Object.entries(preview.agents).map(([id, item]) => [id, tools(item)])) });
+}
+/** `nylorun migrate folder <dir> --to 3` (ADR-106). */
+async function migrateToV3(deps, dir) {
+    const cwd = deps.cwd ?? process.cwd();
+    const where = relative(cwd, dir) || ".";
+    const before = await checkFolder(await packed(dir));
+    if (!before.manifest) {
+        for (const line of diagnosticLines(dir, cwd, before.diagnostics))
+            deps.err(line);
+        throw new CliError(`${where} does not compile: fix it first (nylorun check ${where}).`, 1);
+    }
+    if (before.compiler === "agent-folder/3") {
+        deps.out(`${where} is agent-folder/3 already: nothing to do.`);
+        return 0;
+    }
+    if (before.compiler !== "agent-folder/2")
+        throw new CliError(`${where} is ${before.compiler}: migrate it to agent-folder/2 first (nylorun migrate folder ${where} --to 2).`, 1);
+    const harness = before.manifest.harness;
+    if ("kind" in harness)
+        throw new CliError(`${where} is a flow: migrate each agent folder it holds instead.`, 1);
+    const read = async (path) => readFile(join(dir, ...path.split("/")), "utf8");
+    const edits = new Map();
+    const runtimeJson = await read("runtime.json").catch(() => undefined);
+    const root = folderV3Edit({ agentMd: await read(AGENT_FOLDER_FILE), ...(runtimeJson === undefined ? {} : { runtimeJson }), role: "root" });
+    if (!root.ok)
+        throw new CliError(`${join(where, AGENT_FOLDER_FILE)}: ${root.reason}.`, 1);
+    edits.set(AGENT_FOLDER_FILE, root.agentMd);
+    if (root.runtimeJson !== undefined && root.runtimeJson !== runtimeJson)
+        edits.set("runtime.json", root.runtimeJson);
+    for (const tool of harness.tools ?? []) {
+        if (!tool.agent)
+            continue;
+        const path = `agents/${tool.name}/${AGENT_FOLDER_FILE}`;
+        const edited = folderV3Edit({ agentMd: await read(path), role: "subagent" });
+        if (!edited.ok)
+            throw new CliError(`${join(where, path)}: ${edited.reason}.`, 1);
+        edits.set(path, edited.agentMd);
+    }
+    const pack = await packed(dir);
+    const encoder = new TextEncoder();
+    const files = new Map(pack.files);
+    const entries = pack.entries.map((entry) => {
+        const text = edits.get(entry.path);
+        if (text === undefined)
+            return entry;
+        const bytes = encoder.encode(text);
+        const source = files.get(entry.path);
+        files.set(entry.path, { ...source, size: bytes.byteLength, read: async () => bytes });
+        return { ...entry, size: bytes.byteLength, sha256: sha256Hex(bytes) };
+    });
+    const after = await checkFolder({ ...pack, entries, files });
+    if (!after.manifest) {
+        for (const line of diagnosticLines(dir, cwd, after.diagnostics))
+            deps.err(line);
+        throw new CliError(`${where} would not compile as agent-folder/3: nothing was written.`, 1);
+    }
+    if (effects(after.manifest) !== effects(before.manifest))
+        throw new CliError(`${where} as agent-folder/3 would change what its agents may call: nothing was written.`, 1);
+    for (const [path, text] of edits)
+        await writeFile(join(dir, ...path.split("/")), text);
+    for (const path of edits.keys())
+        deps.out(`wrote ${join(where, path)}`);
+    deps.out(`${where} is agent-folder/3: its agents keep their tools, now named nylorun__<tool>, with the plugins' words. Check what each gets with nylorun check --explain ${where}, and update instructions that name the tools.`);
+    return 0;
+}
+/** `nylorun migrate folder <dir> --to 2|3` */
 export async function migrateFormatCommand(deps, dir, to) {
+    if (to === "3" || to === "agent-folder/3")
+        return migrateToV3(deps, dir);
     if (to !== "2" && to !== "agent-folder/2")
-        throw usageError(`--to takes 2 (agent-folder/2).\n${migrateFormatUsage}`);
+        throw usageError(`--to takes 2 (agent-folder/2) or 3 (agent-folder/3).\n${migrateFormatUsage}`);
     const cwd = deps.cwd ?? process.cwd();
     const where = relative(cwd, dir) || ".";
     const before = await checkFolder(await packed(dir));

package/dist/client/migrate.js

@@ -75,7 +75,7 @@ export async function migrateCommand(deps, args) {
         return 0;
     }
     if (version === "folder") {
-        // `--to 2`: an agent folder made agent-folder/2 in place (ADR-100).
+        // `--to 2` or `--to 3`: an agent folder made agent-folder/2 (ADR-100) or agent-folder/3 (ADR-106) in place.
         const to = rest.indexOf("--to");
         if (to < 0)
             return migrateFolderCommand(deps, rest);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nylorun",
-  "version": "0.26.0-beta",
+  "version": "0.27.1-beta",
   "type": "module",
   "license": "Apache-2.0",
   "description": "Set up and run local Nylorun Tenants (Runtime and Studio) with Docker Compose, and act on a Tenant through its Runtime and Management APIs",
@@ -30,9 +30,9 @@
     "prepack": "npm run build"
   },
   "dependencies": {
-    "@nylorun/admin": "0.19.11-beta",
-    "@nylorun/agents": "0.34.0-beta",
-    "@nylorun/core": "0.35.0-beta"
+    "@nylorun/admin": "0.19.13-beta",
+    "@nylorun/agents": "0.36.0-beta",
+    "@nylorun/core": "0.37.0-beta"
   },
   "devDependencies": {
     "@earendil-works/pi-ai": "1.3.0",
@@ -46,7 +46,7 @@
     "nylo": "dist/nylo.js"
   },
   "nylorun": {
-    "runtime": "0.41.0-beta",
-    "studio": "0.35.4-beta"
+    "runtime": "0.43.0-beta",
+    "studio": "0.35.6-beta"
   }
 }