nylorun 0.19.0-beta → 0.20.0-beta

package/CHANGELOG.md

@@ -1,5 +1,58 @@
 # nylorun
 
+## 0.20.0-beta
+
+### Minor Changes
+
+- 498d972: `nylorun check --fix` makes the edits the compiler's diagnostics carry (track T7). A diagnostic one edit fixes has a `fix` (`AgentFolderFix`, in `AgentFolderDiagnostic` and the Runtime API's): `rename_key` for an unknown key with exactly one did-you-mean (in `AGENT.md`, a trigger, a `SKILL.md`, a tool file, `runtime.json`, `mcp.json`, `flow.json` and a JSON Schema's keywords), at its line and column, and none when two keys are as close or the key it would be is already there; `crlf` for a file with CRLF line ends, which is now a `crlf` note (it is read as LF, as before); and `move_skill_secrets` for `secrets` in a root skill's `SKILL.md`, when `AGENT.md` lists none for the skill, or lists them all. Messages, manifests and hashes are unchanged. `applyFolderFixes` in `@nylorun/core/folder` makes them on text: the key token renamed with every other byte kept, LF line ends, and the secrets moved to `AGENT.md`'s `skills` block as `migrate folder` writes it, skipping (with why) a fix whose text is no longer where it was.
+
+  `nylorun check` marks each fixable problem `(fixable with --fix)` and writes nothing. `check --fix` makes the edits in the folder's files, prints each change by file, and checks again until nothing is left to fix; it leaves a file whose bytes changed since it was checked (writing nothing when one changes while it fixes), and a `runtime.json` that `extends` another. `check --json` gives each diagnostic's `fix`, and with `--fix` each folder's `fixed` and `unfixed`.
+
+- b3dad06: Agent folders convert both ways (track T7, D80). `folderOfManifest(manifest)` in `@nylorun/core/folder` (also exported by `@nylorun/agents`) writes the agent folder that compiles back to the same manifest: name, description, metadata, harness, memory, loop and server and skill settings in `AGENT.md`, the first instruction as its body and the rest as `instructions/NN-*.md`, HTTP tools as `tools/<name>.json`, subagents as `agents/<name>/`, a flow as `flow.json` (v3's node tree, naming agents by id and tools by file name) with one flat `agents/<id>/` for its agents and its sub-flows' (a sub-flow is an `agents/<id>/` with its own `flow.json`, and a tool stage or HTTP verifier a `tools/<name>.json` beside the `flow.json` that names it), MCP servers in `mcp.json` with `Bearer ${SLOT}` or `${SLOT}` for a credential, triggers as `triggers/<id>.md`, and `runtime.json` without the slots the compiler derives the same way. It checks itself by compiling the folder, says whether the hash is the same (`exact`), and notes what it writes differently. Skills are written from their bytes when given them, else as a placeholder with the files to copy in. An embedded agent's display `name` is left out with a note, since a folder names an agent by its id.
+
+  `nylorun export --folder <name>[@<version>]` writes the folder of a saved manifest, from JSON or TypeScript; `nylorun migrate folder <dir>` writes the folder of a three-file folder, offline, with its skills; `nylorun pull <name>[@<version>]` writes back the folder a version was saved from, byte for byte, and says to use `export --folder` for a version saved as JSON. None writes over a file with other bytes.
+
+  Deprecated, still read: the three-file format (`agent.manifest.json`), whose `composeManifest` and `nylorun apply` now warn and name `nylorun migrate folder`, and `secrets` in a `SKILL.md`, which the skills loader warns about (a `DeprecationWarning` from `.skills()`): an agent folder lists a skill's secrets in `AGENT.md`.
+
+- b3dad06: Both ends of the agent folder loop (track T7).
+
+  - `nylorun init <path>` names the agent after the path's last segment (`init agents/hello`). `--example` adds `tools/get_order.json`, `mcp.json` (a `Bearer ${ORDERS_MCP_TOKEN}` header) and `triggers/new-order.md`, explained in the folder's README.md, and the result passes `nylorun check`. The first run in a project (the nearest directory with `.git`) writes `.gitattributes` (`* text=auto eol=lf`), ignores `.nylorun/credentials.json` in `.gitignore`, and maps the folder files to their JSON Schemas in `.vscode/settings.json`, merged into an existing file. Its hint names `apply --agent` and `chat`.
+  - `nylorun apply --agent [<id>]` makes the Agent from the manifest after a save (or on an unchanged one), or moves it, as `nylorun agents put` does, and prints what it needs a person for.
+  - `nylorun apply --watch [--save]` checks and plans again on each change to the folders (and the files their `runtime.json` extends); it saves only with `--save`.
+  - A plan's change to the instructions prints their text diff, `-` and `+` lines.
+  - `nylorun chat <agent> [--session <id>] [--message <text>]` opens or reuses a session, sends `--message` or each line of standard input, and prints the reply as it comes.
+  - `nylorun check --json` prints `{ folders: [{ path, ok, manifest?, diagnostics }] }` for CI, with the same exit codes. `check` says "1 file", and `nylorun --version` prints the version.
+  - `packFolder` (`@nylorun/agents`) leaves out what the folder's `.nyloignore` names (gitignore rules), and resolves `extends` in `runtime.json`: the packed file is the merge, the folder's own keys winning, with `.nylorun/origin.json` naming the files it came from; a missing file or a cycle is a `FolderError`. `ignoreMatcher` is exported.
+  - `session.approve(id, approved)` and `session.respond(id, value)` take no options: each makes its own idempotency key.
+  - The Runtime's Agent view names each required secret of the version it runs that has no value, as an attention item (`secret_unset: required secret ORDERS_TOKEN unset`, state `input_required`), until it is set.
+  - The compiler's refusal of an unresolved `extends` says to resolve it before uploading.
+
+### Patch Changes
+
+- 498d972: `@nylorun/agents` exports `harnessSectionOf` and `sectionGaps` from its main entry, as its README documents: the harness section `agentManifests.save` makes from a built agent or flow, and the gaps the Runtime refuses between a manifest's two sections. Both were only in `@nylorun/agents/define` and `@nylorun/core/define`.
+
+  `nylo` no longer says nylorun 0.19 removes it, which 0.19 does not: its message ends "A later nylorun release removes nylo."
+
+- 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 [7bcdc85]
+- Updated dependencies [498d972]
+- Updated dependencies [498d972]
+- Updated dependencies [d23304e]
+- Updated dependencies [b3dad06]
+- Updated dependencies [b3dad06]
+- Updated dependencies [b3dad06]
+- Updated dependencies [498d972]
+- Updated dependencies [b3dad06]
+- Updated dependencies
+- Updated dependencies
+  - @nylorun/core@0.28.0-beta
+  - @nylorun/agents@0.28.0-beta
+  - @nylorun/admin@0.19.4-beta
+
 ## 0.19.0-beta
 
 ### Minor Changes

package/README.md

@@ -53,10 +53,14 @@ nylorun doctor sandbox [--tenant <name>] [--json]   # the sandbox backend the Te
 
 # apply, agent-manifests, agents, sessions, artifacts: the Runtime API (an application key, or NYLORUN_TOKEN)
 # every one takes --tenant <name>, and --as <subject> [--scope <scope>]... to act for a person
-nylorun init <name> [--description <text>]   # write <name>/AGENT.md, a new agent folder
-nylorun check [<dir>...]           # compile each agent folder offline: every problem by file, line and column
-nylorun apply [<dir>...] [--dry-run] [--if-match <n>]   # plan, then save each folder (AGENT.md or agent.manifest.json), its files uploaded
+nylorun init <path> [--description <text>] [--example]   # write <path>/AGENT.md, a new agent folder named after the last segment
+nylorun check [<dir>...] [--fix] [--json]  # compile each agent folder offline: every problem by file, line and column; --fix makes the fixable ones' edits
+nylorun apply [<dir>...] [--dry-run] [--if-match <n>] [--agent [<id>]] [--watch [--save]]   # plan, then save each folder (AGENT.md or agent.manifest.json), its files uploaded
+nylorun chat <agent> [--session <id>] [--message <text>]   # send each line (or --message), print each reply
 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 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
 nylorun agent-manifests get <name>[@<n>] | versions <name> | rm <name>
 nylorun agents list [--state <s>] [--manifest <name>] [--label <key=value>]... [--outdated] [--limit <n>] [--cursor <c>] [--json]   # --outdated (or --behind): moving to another manifest version
@@ -132,8 +136,8 @@ apply`; `nylorun configure` is `nylorun tenant models set`. `nylorun dev`,
 are gone.
 
 The package's second command, `nylo`, was the Runtime client until nylorun took
-its commands. Until nylorun 0.19, which removes it, it names the `nylorun`
-command that replaced each of its own and exits 2:
+its commands. It still ships, and a later release removes it: it names the
+`nylorun` command that replaced each of its own and exits 2:
 
 | `nylo` | `nylorun` |
 | --- | --- |
@@ -478,25 +482,163 @@ from a terminal.
 An agent runs from a saved **agent manifest** (protocol 16): one named, versioned
 document with a harness section (instructions, tools, skills, MCP servers,
 plugins) and a runtime section (kind, image, network, setup, files, secret
-slots). Author it as an agent folder (track T6), one folder per agent:
+slots). Author it as an agent folder (tracks T6 and T7), one folder per agent:
 
 ```
 agents/support/AGENT.md        # frontmatter (name, description), then the instructions
 agents/support/mcp.json        # MCP servers; "Authorization": "Bearer ${GITHUB_TOKEN}" names a slot
 agents/support/runtime.json    # kind, network, secrets (optional)
 agents/support/skills/<skill>/SKILL.md, tools/<tool>.json, triggers/<id>.md, files/**
+agents/support/agents/<id>/    # a subagent, offered to support as the tool <id>
+agents/support/plugins/<name>/ # a vendored Agent Plugin: its skills and mcp.json servers
 ```
 
-`nylorun init support` writes the `AGENT.md`; `nylorun check agents/support`
+A small one, with an HTTP tool and GitHub's MCP server. `AGENT.md`:
+
+<!-- doc-test: folder support AGENT.md -->
+```markdown
+---
+name: support
+description: Answers questions about a customer's orders.
+---
+Answer questions about the customer's orders. Look an order up with lookup_order before you
+answer a question about it. When the customer reports a bug, find the matching GitHub issue.
+```
+
+`tools/lookup_order.json`, an HTTP tool named after its file. `credential` names
+the secret slot `ORDERS_TOKEN`, sent as a bearer token, never a value:
+
+<!-- doc-test: folder support tools/lookup_order.json -->
+```json
+{
+  "description": "Look up one order by its id: its status, items and total.",
+  "inputSchema": {
+    "type": "object",
+    "properties": { "orderId": { "type": "string", "description": "The order's id, such as A-1001." } },
+    "required": ["orderId"],
+    "additionalProperties": false
+  },
+  "http": { "url": "https://orders.example.com/lookup", "method": "POST", "credential": "ORDERS_TOKEN" }
+}
+```
+
+`mcp.json`, in Agent Plugins syntax; `${GITHUB_TOKEN}` names the slot the
+server authenticates with:
+
+<!-- doc-test: folder support mcp.json -->
+```json
+{
+  "mcpServers": {
+    "github": {
+      "type": "streamable-http",
+      "url": "https://api.githubcopilot.com/mcp/",
+      "headers": { "Authorization": "Bearer ${GITHUB_TOKEN}" }
+    }
+  }
+}
+```
+
+With no `runtime.json`, the compiler derives both slots (`ORDERS_TOKEN` and
+`GITHUB_TOKEN`, each bound to its URL) and says so; write their values with
+`nylorun agents secrets put support <name>`.
+
+`nylorun init agents/support` writes the `AGENT.md`; `nylorun check agents/support`
 compiles the folder offline with the Runtime's compiler and prints every problem
 as `file:line:column severity: message`, exiting 1 when it does not compile.
+A problem one edit fixes ends `(fixable with --fix)`: an unknown key with one
+did-you-mean (`memmory` for `memory`), CRLF line ends, and `secrets` in a
+`SKILL.md`. `nylorun check --fix agents/support` makes those edits, and only
+those: it renames the key where it is, keeping every other byte; makes the line
+ends LF; and moves the secrets to `AGENT.md`'s `skills` block, as
+`nylorun migrate folder` writes it. It prints each change, then checks again. It
+leaves a file whose bytes changed since it was checked, and a `runtime.json`
+that `extends` another; without `--fix`, `check` writes nothing.
 `nylorun apply agents/support` checks it the same way (sending nothing when it
 does not compile), plans it, prints the compiler's notes (such as a slot derived
 from `mcp.json`) and saves it, uploading its files by hash; the Runtime keeps the
 folder as the version's source. `--dry-run` also prints the compiled manifest. A
 change only to a file outside the agent, such as a README, is `unchanged`.
 
-Or as three files:
+The loop from an empty folder to an answer:
+
+```
+nylorun init agents/hello --example   # AGENT.md, tools/, mcp.json and triggers/, each explained in its README.md
+nylorun apply agents/hello --agent    # save it, then make the Agent hello from it (or move it to the new version)
+nylorun chat hello                    # send each line, print each reply; --message <text> sends one
+```
+
+`init <path>` names the agent after the path's last segment. The first run in a
+project (the nearest directory with `.git`) also writes `.gitattributes`
+(`* text=auto eol=lf`), ignores `.nylorun/credentials.json` in `.gitignore`, and
+maps the folder files to their JSON Schemas in `.vscode/settings.json`, merged
+into the file that is there. `check --json` prints
+`{ "folders": [{ path, ok, manifest?, diagnostics }] }` for CI, each fixable
+diagnostic with its `fix`; with `--fix`, each folder also lists what was `fixed`
+and what was `unfixed`, with why. A plan's change
+to the instructions prints their text diff. `apply --watch` checks and plans
+again on each change, and saves only with `--save` (for a development manifest:
+each save is a new version that moves the Agents tracking it).
+
+`.nyloignore` in a folder names, in gitignore syntax, what packing leaves out.
+`runtime.json` may say `"extends": "../../platform/pod.runtime.json"`: `apply`
+and `check` merge that file under it (the folder's keys win, objects merge,
+arrays replace), send the merged `runtime.json`, and name the files it came from
+in `.nylorun/origin.json`.
+
+A folder with `flow.json` is a flow: its stages name agents of the folder's one
+`agents/` by id (an `agents/<id>/` with a `flow.json` of its own is a sub-flow),
+`"tool": "<name>"` names `tools/<name>.json` beside the `flow.json`, and its
+`AGENT.md` has frontmatter only (and may set `inputSchema`). A two-stage chain:
+
+<!-- doc-test: folder brief AGENT.md -->
+```markdown
+---
+name: brief
+description: Researches a topic, then writes a short brief on it.
+---
+```
+
+<!-- doc-test: folder brief flow.json -->
+```json
+{ "chain": [{ "agent": "researcher" }, { "agent": "writer" }] }
+```
+
+<!-- doc-test: folder brief agents/researcher/AGENT.md -->
+```markdown
+---
+name: researcher
+description: Lists what matters about the topic.
+---
+List the five facts about the topic a newcomer most needs, each with one sentence of context.
+```
+
+<!-- doc-test: folder brief agents/writer/AGENT.md -->
+```markdown
+---
+name: writer
+description: Writes the brief.
+---
+Write a brief of at most 200 words from the facts you are given, for a reader new to the topic.
+```
+
+[`examples/agents/repo-brief-folder/`](../../examples/agents/repo-brief-folder/)
+is a whole flow as a folder: a switch, a map, a parallel stage, a loop and an HTTP
+tool stage. Without `flow.json`, each `agents/<id>/` is a subagent: the agent
+calls it as the tool `<id>` with `{ task }`, one level deep. `plugins/<name>/`
+folds a plugin's skills and `mcp.json` servers in as `.plugin()` does, and notes
+what Nylorun does not run (hooks, commands).
+
+`nylorun pull support[@3] [--out <dir>]` writes back the folder a version was
+saved from, byte for byte. A version saved as JSON or from TypeScript has none:
+`nylorun export --folder support[@3] [--out <dir>]` writes its folder from the
+manifest instead (instructions as Markdown, tools, `mcp.json`, triggers,
+`runtime.json`, subagents as `agents/<id>/`, and a flow as `flow.json` with its
+agents), says whether it compiles back to the same manifest, and notes what it
+writes differently (a skill's files, which the manifest names by hash only, are
+left to copy in). Neither writes over a file with other bytes.
+
+Or as three files (deprecated: `apply` warns, and `nylorun migrate folder
+agents/triage --out <dir>` writes the agent folder, with its skills, offline):
 
 ```
 agents/triage/agent.manifest.json     # { "manifestSchemaVersion": 8, "name": "triage",
@@ -519,8 +661,9 @@ against, uploading the files the Runtime does not hold (`PUT /v1/files/sha256:
 A manifest whose sections do not fit, or whose runtime misses what its harness
 `requires`, is an error: nothing is saved and the command exits 1. `--dry-run`
 prints the plans only; `--if-match <n>` saves only over version `n`.
-`nylorun apply agents/` applies every subfolder with an `agent.manifest.json`;
-every folder composes before anything is sent.
+`nylorun apply agents/` applies every subfolder with an `AGENT.md` (or an
+`agent.manifest.json`); every folder compiles, or composes, before anything is
+sent.
 
 `nylorun agent-manifests list` shows each manifest's latest version, runtime
 kind, harness and the Agents made from it; `get <name>[@<n>]` prints a version,
@@ -536,7 +679,8 @@ manifest's fields become the runtime file, its `harness` the harness file's `id`
 and v7's `requires` stays in the harness file for `apply` to check. With no
 environment manifest the kind is `pod` when the agent requires one, `virtual`
 when it has skills or requires a sandbox, else `none`. It overwrites no file and
-prints the gaps to fix before `apply`.
+prints the gaps to fix before `apply`. The three files are deprecated: `nylorun
+migrate folder agents/triage --out <dir>` then writes them as an agent folder.
 
 ### `local reset` or `tenant reset`
 

package/dist/cli.js

@@ -13,15 +13,29 @@ ${stackUsage}
                                       the sandbox backend the Tenant's Host offers
 
 Agent manifests:
-  init <name> [--description <text>]  write <name>/AGENT.md, a new agent folder
-  check [<dir>...]                    compile each agent folder offline and print every problem
-                                      by file, line and column (reads no Runtime)
-  apply [<dir>...] [--dry-run] [--if-match <n>]
+  init <path> [--description <text>] [--example]
+                                      write <path>/AGENT.md, a new agent folder named after the
+                                      path's last segment; --example adds a tool, mcp.json and a
+                                      trigger
+  check [<dir>...] [--fix] [--json]   compile each agent folder offline and print every problem
+                                      by file, line and column (reads no Runtime); --fix makes
+                                      the edits the fixable ones name
+  apply [<dir>...] [--dry-run] [--if-match <n>] [--agent [<id>]] [--watch [--save]]
                                       save the agent manifest each folder describes (its AGENT.md,
-                                      or its agent.manifest.json), with its files (Runtime API)
+                                      or its agent.manifest.json), with its files (Runtime API);
+                                      --agent then makes or moves the Agent; --watch plans again
+                                      on each change
+  chat <agent> [--session <id>] [--message <text>]
+                                      talk to an Agent: send each line, print each reply
   migrate v8 <agent.json> [--runtime <environment-manifest.json>] [--name <name>] [--out <dir>]
                                       write the three manifest files from an agent manifest v7
                                       and an environment manifest v1 (reads no Runtime)
+  migrate folder <dir> [--out <dir>]  write the agent folder of a three-file folder
+                                      (agent.manifest.json; reads no Runtime)
+  export --folder <name>[@<version>] [--out <dir>]
+                                      write the agent folder of a saved manifest (Runtime API)
+  pull <name>[@<version>] [--out <dir>]
+                                      write the folder a version was saved from (Runtime API)
 
 Groups, each with its own --help:
   agent-manifests  list | get | versions | rm
@@ -126,6 +140,10 @@ async function main() {
     const [command, ...args] = process.argv.slice(2);
     if (!command || command === "--help" || command === "-h")
         return void console.log(usage);
+    if (command === "--version" || command === "-v" || command === "version") {
+        const { cliVersion } = await import("./stack/versions.js");
+        return void console.log(cliVersion());
+    }
     refuseNativeWindows();
     if (command === "sandbox") {
         const sub = args[0];
@@ -170,6 +188,9 @@ async function main() {
         command === "check" ||
         command === "init" ||
         command === "migrate" ||
+        command === "export" ||
+        command === "pull" ||
+        command === "chat" ||
         command === "agent-manifests" ||
         command === "agents" ||
         command === "sessions" ||
@@ -179,6 +200,9 @@ async function main() {
             check: async () => (await import("./client/folder.js")).checkCommand,
             init: async () => (await import("./client/folder.js")).initCommand,
             migrate: async () => (await import("./client/migrate.js")).migrateCommand,
+            export: async () => (await import("./client/convert.js")).exportCommand,
+            pull: async () => (await import("./client/convert.js")).pullCommand,
+            chat: async () => (await import("./client/chat.js")).chatCommand,
             "agent-manifests": async () => (await import("./client/agent-manifests.js")).agentManifestsCommand,
             agents: async () => (await import("./client/agents.js")).agentsCommand,
             sessions: async () => (await import("./client/sessions.js")).sessionsCommand,

package/dist/client/agents.d.ts

@@ -1,4 +1,22 @@
+/**
+ * `nylorun agents`: the Tenant's Agents (protocol 16: each is one version of an agent manifest
+ * made live, with one environment and one vault, and the sessions that run on it), through the
+ * Runtime API of the installation `target.ts` picks: create or find one by id from a saved
+ * manifest, move it to another version (`pin`, `track`, `put`; track T3) and apply a pending one
+ * (`restart`), fork it, stop, reset or delete it, keep and restore versions of its disk, and
+ * write its secrets. The manifests themselves are `agent-manifests.ts`
+ * and `apply.ts`. A secret's value comes from a file or standard input, never from the command
+ * line, and no command reads one back. None of them starts a local Tenant.
+ */
+import type { AgentView } from "@nylorun/agents";
 import { type StackDeps } from "../stack/commands.js";
 export declare const agentsUsage: string;
+/**
+ * The manifest an Agent runs, as the list prints it: `name@version`, the version it moves to
+ * (track T3), and whether it tracks.
+ */
+export declare function manifestOf(agent: AgentView): string;
+/** What a move left pending, for a person: the version, and what it waits for. */
+export declare function pendingOf(agent: AgentView): string;
 /** `nylorun agents <command> ...` */
 export declare function agentsCommand(deps: StackDeps, args: readonly string[]): Promise<number>;

package/dist/client/agents.js

@@ -72,13 +72,13 @@ const SAVE_REMOVED = "nylorun agents save was removed in protocol 16: agents run
  * The manifest an Agent runs, as the list prints it: `name@version`, the version it moves to
  * (track T3), and whether it tracks.
  */
-function manifestOf(agent) {
+export function manifestOf(agent) {
     const name = parseAgentManifestRef(agent.manifest)?.name ?? agent.manifest;
     const target = agent.targetVersion ? ` → ${agent.targetVersion}` : "";
     return `${name}@${agent.resolvedVersion}${target} ${agent.tracking === "tracking" ? "tracks" : "pinned"}`;
 }
 /** What a move left pending, for a person: the version, and what it waits for. */
-function pendingOf(agent) {
+export function pendingOf(agent) {
     if (!agent.targetVersion)
         return "";
     return agent.waitingFor === "secrets"

package/dist/client/apply-agent.d.ts

@@ -0,0 +1,14 @@
+import { type AgentView, type AgentsClient } from "@nylorun/agents";
+import type { StackDeps } from "../stack/commands.js";
+/**
+ * `--agent [<id>]`, or `--agent=<id>`, taken out of `args`. The word after `--agent` is its id
+ * unless it is a flag or names a directory under `cwd` (a folder to apply).
+ */
+export declare function takeAgentFlag(args: readonly string[], cwd: string): {
+    args: string[];
+    agent?: {
+        id?: string;
+    };
+};
+/** Makes Agent `id` from manifest `name`, or moves it to the manifest's latest version, and says which. */
+export declare function putAgent(deps: StackDeps, client: AgentsClient, label: string, id: string, name: string): Promise<AgentView>;

package/dist/client/apply-agent.js

@@ -0,0 +1,71 @@
+/**
+ * `nylorun apply --agent [<id>]` (track T7): after a manifest is saved, or found unchanged, make the
+ * Agent that runs it, or move it to the latest version, as `nylorun agents put <id> --manifest
+ * <name>` does. The id defaults to the manifest's name. What happened is printed, with what the
+ * Agent needs a person for (an unset required secret).
+ */
+import { statSync } from "node:fs";
+import { resolve } from "node:path";
+import { RuntimeError } from "@nylorun/agents";
+import { manifestOf, pendingOf } from "./agents.js";
+import { runtimeCall, usageError } from "./runtime.js";
+/**
+ * `--agent [<id>]`, or `--agent=<id>`, taken out of `args`. The word after `--agent` is its id
+ * unless it is a flag or names a directory under `cwd` (a folder to apply).
+ */
+export function takeAgentFlag(args, cwd) {
+    const rest = [];
+    let agent;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg.startsWith("--agent=")) {
+            const id = arg.slice("--agent=".length);
+            if (id === "")
+                throw usageError("--agent= needs an Agent id.");
+            agent = { id };
+            continue;
+        }
+        if (arg !== "--agent") {
+            rest.push(arg);
+            continue;
+        }
+        const next = args[index + 1];
+        if (next !== undefined && !next.startsWith("-") && !isDirectory(resolve(cwd, next))) {
+            agent = { id: next };
+            index += 1;
+        }
+        else
+            agent = {};
+    }
+    return { args: rest, ...(agent ? { agent } : {}) };
+}
+function isDirectory(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** Makes Agent `id` from manifest `name`, or moves it to the manifest's latest version, and says which. */
+export async function putAgent(deps, client, label, id, name) {
+    let before;
+    try {
+        before = await client.agents.get(id);
+    }
+    catch (error) {
+        if (!(error instanceof RuntimeError && error.status === 404))
+            await runtimeCall(() => Promise.reject(error));
+    }
+    const agent = await runtimeCall(() => client.agents.put(id, { manifest: name }));
+    const what = !before
+        ? `Made Agent ${agent.id}`
+        : before.resolvedVersion !== agent.resolvedVersion || before.manifest !== agent.manifest || before.targetVersion !== agent.targetVersion
+            ? `Moved Agent ${agent.id} from ${manifestOf(before)}`
+            : `Agent ${agent.id} is unchanged`;
+    deps.err(`${what}: it runs ${manifestOf(agent)} on ${label}${pendingOf(agent)}.`);
+    for (const item of agent.attention ?? [])
+        if (!item.sessionId)
+            deps.err(`  attention: ${item.reason}`);
+    return agent;
+}

package/dist/client/apply.d.ts

@@ -1,7 +1,14 @@
 import { type AgentManifestPlan } from "@nylorun/agents";
 import type { StackDeps } from "../stack/commands.js";
 export declare const applyUsage: string;
+/** How `--watch` runs an apply (`watch.ts`). */
+export interface ApplyOptions {
+    /** Plan, and save nothing. */
+    planOnly?: boolean;
+    /** `nylorun check` printed each folder's diagnostics already. */
+    checked?: boolean;
+}
 /** A plan as lines: the move, then each change, warning and error. */
 export declare function planLines(plan: AgentManifestPlan): string[];
-/** `nylorun apply [dir…] [--dry-run] [--if-match <n>]` */
-export declare function applyCommand(deps: StackDeps, args: readonly string[]): Promise<number>;
+/** `nylorun apply [dir…] [--dry-run] [--if-match <n>] [--agent [<id>]] [--watch [--save]]` */
+export declare function applyCommand(deps: StackDeps, given: readonly string[], options?: ApplyOptions): Promise<number>;