nylorun 0.25.1-beta → 0.27.0-beta

package/CHANGELOG.md

@@ -1,5 +1,45 @@
 # nylorun
 
+## 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
+
+- 714bee2: The triggers capability (Host feature `agent-triggers`): an agent-folder/2 folder declares `engine: { triggers: true }` (the root agent's only; `engine.instructions.triggers` replaces its wording), which compiles to `harness.engine.triggers` and offers the root agent the `triggers` tool (`list`, `create`, `delete`) and the text block `triggers@1`. The Runtime serves each call as a `runtime` effect (operation `triggers`, `turn.start.agent.triggers`, Harness API v5.3): a trigger an agent makes is the Agent's (`origin: "agent"`, with its title and the session that made it), runs in the calling session (`session: "this"`) or one of its own (`"own"`, `<session>_t_<id>`), is checked against the limits in force (`runtime.limits.triggers` within the Tenant's), survives upgrades and waits paused while a version lacks the capability; a turn a trigger started can't create one. Tool rules take `kind: "runtime"`, so an `ask` rule can hold a `triggers` call (its interaction carries `metadata.input`); `DELETE /v1/agents/{id}/triggers/{triggerId}` deletes an agent's trigger (`409 trigger_from_manifest` for a manifest's); `GET /v1/runs/stream` serves the Tenant's runs as server-sent events from a cursor (`410 cursor_expired` across a reset). `client.agents.deleteTrigger`, `client.runs.stream` and `nylorun agents triggers rm` follow. The JSON Schemas are republished as `agent-manifest/v8.3`, `harness-manifest/v1.3`, `runtime-manifest/v1.2`, `agent-folder/v1/agent-md.3`, `agent-folder/v1/runtime.2` and `harness-api/v5.3`.
+
+### 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 [714bee2]
+- Updated dependencies
+- Updated dependencies
+  - @nylorun/core@0.35.0-beta
+  - @nylorun/agents@0.34.0-beta
+  - @nylorun/admin@0.19.11-beta
+
 ## 0.25.1-beta
 
 ### Patch 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
@@ -594,15 +595,36 @@ Answer from the documents in the conversation.
 `engine.sandbox` lists any of `bash`, `read`, `write`, `edit`, `grep` and `glob`;
 `artifacts.save`, `outputs` and `sandbox` need a computer; and `engine.instructions.<block>`
 replaces a text block's wording with a Markdown file under `engine/` (the blocks are `skills`,
-`sandbox`, `skill_folder`, `artifacts_save`, `outputs`, `artifacts_read`, `wake`, `memory`,
-`plan`, `connection` and `tool_search`; memory's rule that outside text is data stays). A
-subagent declares its own `engine:`, a subset of its parent's. The compiled manifest lists the
+`sandbox`, `skill_folder`, `artifacts_save`, `outputs`, `artifacts_read`, `wake`, `triggers`,
+`memory`, `plan`, `connection` and `tool_search`; memory's rule that outside text is data stays).
+`engine.triggers: true` offers the root agent the `triggers` tool: it sets up its own schedules,
+one-time runs and follow-ups (`list`, `create`, `delete`), which the Agent keeps beside its
+manifest's triggers (`nylorun agents triggers list`, `rm` for one an agent made). A
+subagent declares its own `engine:`, a subset of its parent's, and never `triggers`. The compiled manifest lists the
 blocks the agent gets, with their versions and hashes (`harness.engine.blocks`).
 `nylorun check --explain` prints each feature on, and the tools and blocks it adds;
 `previewTurn(manifest)` in `@nylorun/agents` returns the exact system text and tool list.
 `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/agents.js

@@ -52,8 +52,10 @@ NYLORUN_TOKEN).
                                       a bearer or headers secret's routing: where its requests
                                       go (over the slot's via) and the gateway's tool prefix
   secrets rm <id> <name>
-  triggers list <id>                  its triggers: status, next and last run, as JSON
+  triggers list <id>                  its triggers: status, next and last run, as JSON; with
+                                      the ones its agents made (origin agent)
   triggers pause|resume <id> <trigger>
+  triggers rm <id> <trigger>          delete a trigger its agent made (not a manifest's)
   triggers run <id> <trigger> [--idempotency-key <k>]
                                       run it once now, as if it fired
   triggers new-secret <id> <trigger>  a webhook trigger's new signing secret (whsec_…), shown
@@ -352,7 +354,7 @@ async function secrets(deps, args) {
     }
     throw usageError(`Usage: nylorun agents secrets <list|get|put|rm> …\n\n${agentsUsage}`);
 }
-/** `nylorun agents triggers <list|pause|resume|run> …` (track T4). */
+/** `nylorun agents triggers <list|pause|resume|run|rm|new-secret> …` (track T4, D83). */
 async function triggers(deps, args) {
     const [verb, ...rest] = args;
     if (isHelp(verb))
@@ -382,6 +384,15 @@ async function triggers(deps, args) {
         printJson(deps, await runtimeCall(() => client.agents.runTrigger(id, trigger, key === undefined ? {} : { idempotencyKey: key })));
         return 0;
     }
+    if (verb === "rm" || verb === "delete") {
+        const usage = "nylorun agents triggers rm <id> <trigger>";
+        const flags = parseFlags(rest, {}, usage);
+        const [id, trigger] = positional(flags, 2, usage);
+        const { client } = await runtimeClient(deps, flags);
+        await runtimeCall(() => client.agents.deleteTrigger(id, trigger));
+        deps.out(`Deleted trigger ${trigger} of Agent ${id}.`);
+        return 0;
+    }
     if (verb === "new-secret") {
         const usage = "nylorun agents triggers new-secret <id> <trigger>";
         const flags = parseFlags(rest, {}, usage);
@@ -390,7 +401,7 @@ async function triggers(deps, args) {
         printJson(deps, await runtimeCall(() => client.agents.rotateWebhookSecret(id, trigger)));
         return 0;
     }
-    throw usageError(`Usage: nylorun agents triggers <list|pause|resume|run|new-secret> …\n\n${agentsUsage}`);
+    throw usageError(`Usage: nylorun agents triggers <list|pause|resume|run|rm|new-secret> …\n\n${agentsUsage}`);
 }
 /** `nylorun agents memories <ls|cat|put|rm|versions> …` (track T5). */
 async function memories(deps, args) {

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/init.js

@@ -49,7 +49,7 @@ export function schemaMappings(root, folder) {
     // Folders under a parent (agents/) share one pattern; a folder at the root is named alone.
     const base = parent === "" ? relative(root, folder).split(sep).join("/") : `${parent}/**`;
     return [
-        { fileMatch: [`${base}/runtime.json`], url: `${SCHEMA_BASE}/runtime.1.json` },
+        { fileMatch: [`${base}/runtime.json`], url: `${SCHEMA_BASE}/runtime.2.json` },
         { fileMatch: [`${base}/tools/*.json`], url: `${SCHEMA_BASE}/tool.json` },
         { fileMatch: [`${base}/flow.json`], url: `${SCHEMA_BASE}/flow.json` },
         { fileMatch: [`${base}/mcp.json`, `!${base}/plugins/**`], url: `${SCHEMA_BASE}/mcp.json` },

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.25.1-beta",
+  "version": "0.27.0-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.10-beta",
-    "@nylorun/agents": "0.33.0-beta",
-    "@nylorun/core": "0.34.0-beta"
+    "@nylorun/admin": "0.19.12-beta",
+    "@nylorun/agents": "0.35.0-beta",
+    "@nylorun/core": "0.36.0-beta"
   },
   "devDependencies": {
     "@earendil-works/pi-ai": "1.3.0",
@@ -46,7 +46,7 @@
     "nylo": "dist/nylo.js"
   },
   "nylorun": {
-    "runtime": "0.40.0-beta",
-    "studio": "0.35.3-beta"
+    "runtime": "0.42.0-beta",
+    "studio": "0.35.5-beta"
   }
 }