@nylorun/runtime 0.30.0-beta → 0.32.0-beta

package/dist/store/postgres/drizzle/0038_t6_agent_manifest_source.sql

@@ -0,0 +1 @@
+ALTER TABLE "nylorun"."agent_manifests" ADD COLUMN "source" json;

package/dist/store/postgres/drizzle/meta/_journal.json

@@ -267,6 +267,13 @@
       "when": 1792238141315,
       "tag": "0037_model_usage_cost_split",
       "breakpoints": true
+    },
+    {
+      "idx": 38,
+      "version": "7",
+      "when": 1792484344984,
+      "tag": "0038_t6_agent_manifest_source",
+      "breakpoints": true
     }
   ]
 }

package/dist/store/postgres/schema.d.ts

@@ -2569,6 +2569,25 @@ export declare const agentManifests: import("drizzle-orm/pg-core").PgTableWithCo
         }, {}, {
             pgColumnBuilderBrand: 'PgCustomColumnBuilderBrand';
         }>;
+        source: import("drizzle-orm/pg-core").PgColumn<{
+            name: "source";
+            tableName: "agent_manifests";
+            dataType: "custom";
+            columnType: "PgCustomColumn";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            pgColumnBuilderBrand: 'PgCustomColumnBuilderBrand';
+        }>;
     };
     dialect: 'pg';
 }>;

package/dist/store/postgres/schema.js

@@ -326,6 +326,12 @@ export const agentManifests = nylorun.table("agent_manifests", {
     /** `{ actor }`: the subject the save acted for, else `application`. */
     savedBy: jsonText().notNull(),
     createdAt: textC().notNull(),
+    /**
+     * The agent folder the version was compiled from (track T6): `{ compiler, files, bytes,
+     * entries }`, each entry `{ path, size, sha256 }` of a definition file. Null for a version
+     * saved as JSON.
+     */
+    source: jsonText(),
 }, (t) => [primaryKey({ name: "agent_manifests_pkey", columns: [t.name, t.version] })]);
 /**
  * A vault (D56): the host model's (`id = 'host'`), or one Environment's, created and deleted with

package/dist/store/postgres/store.js

@@ -295,6 +295,7 @@ function agentManifestOf(row) {
         hash: row.hash,
         savedBy: row.savedBy,
         createdAt: row.createdAt,
+        ...(row.source === null || row.source === undefined ? {} : { source: row.source }),
     };
 }
 /** A pod patch as column values: ISO times become dates, `null` clears. */

package/dist/store/types.d.ts

@@ -204,6 +204,20 @@ export interface AgentManifestRow {
         actor: string;
     };
     createdAt: string;
+    /** The agent folder the version was compiled from (track T6); none for a version saved as JSON. */
+    source?: AgentManifestSourceRecord;
+}
+/** An agent folder as a version keeps it: its compiler, size and files, each a definition file. */
+export interface AgentManifestSourceRecord {
+    compiler: string;
+    files: number;
+    bytes: number;
+    /** Sorted by path; `sha256` is lowercase hex, the file `sha256:<hex>` in the definition file store. */
+    entries: {
+        path: string;
+        size: number;
+        sha256: string;
+    }[];
 }
 /** A disk lease (R2d step 3): what holds the disk, since when, and until when unless renewed. */
 export interface DiskOperation {

package/dist/tenant/agent-manifests.d.ts

@@ -1,28 +1,4 @@
-/**
- * Agent manifests (protocol 16, track T2): `/v1/agent-manifests/{name}`, named and versioned
- * documents with what runs inside an agent's loop (`harness`) and what the Runtime provides
- * around it (`runtime`). They replace agent definitions (`PUT /v1/agents/:id` before protocol
- * 16) and environment manifests.
- *
- * - **Versions.** A save whose manifest hashes the same as the latest answers it unchanged; any
- *   other writes the next version. A version is never changed or deleted alone.
- * - **Tracking Agents move.** Saving a version moves every Agent that tracks the manifest to it
- *   (track T3, `moveAgent`), in the save's transaction: at once, at its pod's next start, or once
- *   its required secrets are set. A pinned Agent stays, and so does one the version cannot move
- *   (a fixed field) or whose start failed on it. The plan counts both.
- * - **Both sections at once.** The Runtime sees both sections, so it checks them against each
- *   other (`sectionGaps`): every gap is named in one `422 manifest_inconsistent`, which is what
- *   `requires` checked when a session opened before protocol 16. Each section's own checks run
- *   too: the harness's (no code tools, no approvals, HTTP tool timeouts, the skill files) and the
- *   runtime's (the Tenant's limits, its files).
- * - **Plan and drift.** `?dryRun=true` answers what a save would do and saves nothing: the
- *   changes from the latest by section, every reason the Runtime would refuse it, warnings, the
- *   Agents it moves and how many stay on older versions. `If-Match: <version>` refuses
- *   (`412 manifest_changed`) a save whose latest version moved since the client read it; `0` asks
- *   for a manifest that does not exist yet.
- * - **Every client is equal** (Q12): a version records who saved it (`savedBy`).
- */
-import { type AgentManifestChange, type AgentManifestPlan, type AgentManifestV8, type AgentManifestVersions, type AgentManifestView, type PutAgentManifestRequest, type SaveAgentManifestResponse } from "@nylorun/core/contracts";
+import { type AgentManifestChange, type AgentManifestPlan, type AgentManifestSource, type AgentManifestSourceDiff, type AgentManifestV8, type AgentManifestVersions, type AgentManifestView, type PutAgentFolderRequest, type PutAgentManifestRequest, type SaveAgentManifestResponse } from "@nylorun/core/contracts";
 import { type RecipeRequest } from "../sandbox/resolve.js";
 import type { AuthScope, TenantContext } from "./context.js";
 /** What a manifest's runtime section asks of an Agent's recipe, with the harness its loop names. */
@@ -54,6 +30,28 @@ export declare function saveAgentManifest(ctx: TenantContext, name: string, body
     dryRun?: false;
     ifMatch?: number;
 }): Promise<SaveAgentManifestResponse>;
+/**
+ * `PUT /v1/agent-manifests/{name}` with an agent folder by hash (track T6): reads the files the
+ * compiler needs from the definition file store, compiles the folder (`422 folder_invalid` when
+ * it does not), then saves or plans the manifest as a JSON save does, keeping the folder as the
+ * version's source.
+ */
+export declare function saveAgentFolder(ctx: TenantContext, name: string, body: PutAgentFolderRequest, scope: AuthScope, options?: {
+    dryRun?: boolean;
+    ifMatch?: number;
+}): Promise<AgentManifestPlan | SaveAgentManifestResponse>;
+/** `GET /v1/agent-manifests/{name}/versions/{v}/source`: the folder a version was compiled from. */
+export declare function getAgentManifestSource(ctx: TenantContext, name: string, version: number): Promise<AgentManifestSource>;
+/** `GET .../versions/{v}/source/files/{path}`: one file of a version's source, streamed. */
+export declare function readAgentManifestSourceFile(ctx: TenantContext, name: string, version: number, path: string): Promise<{
+    body: ReadableStream<Uint8Array>;
+    size: number;
+}>;
+/**
+ * `GET /v1/agent-manifests/{name}/source/diff?from=&to=`: the files added, removed and changed
+ * (by SHA-256) from version `from`'s source to version `to`'s; a `404` when either was saved as JSON.
+ */
+export declare function diffAgentManifestSources(ctx: TenantContext, name: string, from: number, to: number): Promise<AgentManifestSourceDiff>;
 /** `GET /v1/agent-manifests/{name}` (the latest) and `.../versions/{n}`. */
 export declare function getAgentManifest(ctx: TenantContext, name: string, version?: number): Promise<AgentManifestView>;
 /** `GET /v1/agent-manifests`: each manifest's latest version. */

package/dist/tenant/agent-manifests.js

@@ -21,7 +21,17 @@
  *   (`412 manifest_changed`) a save whose latest version moved since the client read it; `0` asks
  *   for a manifest that does not exist yet.
  * - **Every client is equal** (Q12): a version records who saved it (`savedBy`).
+ * - **Agent folders** (track T6, D79): the same route takes a folder by hash
+ *   (`application/vnd.nylorun.folder+json`). The Runtime reads the files the compiler needs from
+ *   the definition file store, compiles them with `@nylorun/core/folder` (a folder that does not
+ *   compile is `422 folder_invalid`, every diagnostic in `details.diagnostics`), and saves the
+ *   manifest as above, with the folder kept as the version's source (`source`, its files recorded
+ *   as the version's definition files). A folder whose manifest is unchanged saves no new
+ *   version, so its source is not saved either. What a folder may hold is the Tenant's Runtime
+ *   limits `folderFiles`, `folderBytes` and `folderTextFileBytes` (track T7), which the compiler
+ *   is given too; `source/diff` compares two versions' sources by path and hash.
  */
+import { compileAgentFolder, folderTextPaths, } from "@nylorun/core/folder";
 import { definitionFilesOf, } from "@nylorun/core/contracts";
 import { hashManifest } from "@nylorun/core/compatibility";
 import { approvalRefusal, codeToolRefusal, harnessIdOf, loopManifestOf, runtimeOf, sectionGaps, } from "@nylorun/core/define";
@@ -35,7 +45,7 @@ import { readRuntimeLimits } from "./runtime-limits.js";
 import { effectiveSandboxConfig, readSandboxConfig } from "../sandbox/tenant-config.js";
 import { actorOf, fileErrors } from "./agents.js";
 import { moveAgent, planMove } from "./agent-versions.js";
-import { definitionFileIssues } from "./definition-files.js";
+import { definitionFileIssues, openDefinitionFile, readDefinitionFile } from "./definition-files.js";
 import { fail } from "./http.js";
 /** What a manifest's runtime section asks of an Agent's recipe, with the harness its loop names. */
 export function manifestRecipeRequest(manifest) {
@@ -73,6 +83,9 @@ function viewOf(row, counts) {
         savedBy: row.savedBy,
         createdAt: row.createdAt,
         agents: counts.get(row.version) ?? 0,
+        ...(row.source === undefined
+            ? {}
+            : { source: { compiler: row.source.compiler, files: row.source.files, bytes: row.source.bytes } }),
     };
 }
 /** Each field that differs between `before` and `after`, by path; arrays compare whole. */
@@ -237,6 +250,9 @@ export async function saveAgentManifest(ctx, name, body, scope, options = {}) {
     const { requestId: _, ...manifest } = body;
     if (manifest.name !== name)
         fail(400, `The manifest is named ${manifest.name}, and the path names ${name}: they must match.`);
+    return saveManifest(ctx, name, manifest, scope, options);
+}
+async function saveManifest(ctx, name, manifest, scope, options, folder) {
     const hash = agentManifestHash(manifest);
     const gaps = sectionGaps(manifest);
     return ctx.store.tx(async (t) => {
@@ -248,12 +264,33 @@ export async function saveAgentManifest(ctx, name, body, scope, options = {}) {
                 : `Agent manifest ${name} is at version ${latest.version}, not ${options.ifMatch}: someone saved it since you read it. Read it again, or save without If-Match to replace it.`, { code: "manifest_changed", details: { latest: latest?.version ?? 0 } });
         const unchanged = latest?.hash === hash;
         const to = unchanged ? latest.version : (latest?.version ?? 0) + 1;
+        // A folder whose manifest is unchanged keeps the latest version, and with it that version's source.
+        const notes = folder === undefined
+            ? undefined
+            : unchanged && canonical(latest?.source?.entries ?? null) !== canonical(folder.source.entries)
+                ? [
+                    ...folder.diagnostics,
+                    {
+                        severity: "note",
+                        code: "source_not_saved",
+                        message: "Source files changed that are not part of the agent; the manifest is unchanged, so no version is saved",
+                    },
+                ]
+                : folder.diagnostics;
         const counts = await t.agentsOfManifest(name);
         const checked = await errorsOf(t, manifest);
         // The version as it would be saved, for the plan of the Agents it moves.
         const row = unchanged
             ? latest
-            : { name, version: to, body: manifest, hash, savedBy: { actor: actorOf(scope) }, createdAt: new Date().toISOString() };
+            : {
+                name,
+                version: to,
+                body: manifest,
+                hash,
+                savedBy: { actor: actorOf(scope) },
+                createdAt: new Date().toISOString(),
+                ...(folder === undefined ? {} : { source: folder.source }),
+            };
         if (options.dryRun) {
             const errors = [...gaps, ...checked.errors];
             // A save with errors moves nothing; one that changes nothing moves no Agent either.
@@ -268,6 +305,7 @@ export async function saveAgentManifest(ctx, name, body, scope, options = {}) {
                 errors,
                 behind: moves?.behind ?? (await agentsBehind(t, name, to)).length,
                 moves: { now: moves?.now ?? 0, nextStart: moves?.nextStart ?? 0, secrets: moves?.secrets ?? 0 },
+                ...(folder === undefined ? {} : { manifest, diagnostics: [...notes], compiler: folder.compiler }),
             };
         }
         if (gaps.length > 0)
@@ -287,8 +325,9 @@ export async function saveAgentManifest(ctx, name, body, scope, options = {}) {
             });
         if (checked.errors.length > 0)
             fail(400, checked.errors.join(" "));
+        const folderNotes = notes === undefined ? {} : { diagnostics: [...notes] };
         if (unchanged)
-            return { manifest: viewOf(latest, counts), unchanged: true, warnings: warningsOf(ctx, manifest, to, undefined) };
+            return { manifest: viewOf(latest, counts), unchanged: true, warnings: warningsOf(ctx, manifest, to, undefined), ...folderNotes };
         await t.insertAgentManifest(row);
         // Its files by hash, skills' and runtime files' alike, for the sweep that deletes unused ones.
         const shas = new Set(definitionFilesOf(loopManifestOf(manifest)));
@@ -296,13 +335,148 @@ export async function saveAgentManifest(ctx, name, body, scope, options = {}) {
             if ("files" in file)
                 for (const sha of Object.values(file.files))
                     shas.add(sha);
+        // A folder's every file too: the version keeps its source.
+        for (const entry of folder?.source.entries ?? [])
+            shas.add(`sha256:${entry.sha256}`);
         if (shas.size > 0)
             await t.insertDefinitionFileUses(manifestFileOwner(name), hash, [...shas]);
         // Every Agent that tracks the manifest moves to the new version (track T3).
         const moves = await moveTracking(t, row, true);
-        return { manifest: viewOf(row, await t.agentsOfManifest(name)), unchanged: false, warnings: warningsOf(ctx, manifest, to, moves) };
+        return {
+            manifest: viewOf(row, await t.agentsOfManifest(name)),
+            unchanged: false,
+            warnings: warningsOf(ctx, manifest, to, moves),
+            ...folderNotes,
+        };
     });
 }
+/**
+ * `PUT /v1/agent-manifests/{name}` with an agent folder by hash (track T6): reads the files the
+ * compiler needs from the definition file store, compiles the folder (`422 folder_invalid` when
+ * it does not), then saves or plans the manifest as a JSON save does, keeping the folder as the
+ * version's source.
+ */
+export async function saveAgentFolder(ctx, name, body, scope, options = {}) {
+    const entries = [...body.entries].sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+    const limits = folderLimitsOf(await ctx.store.tx((t) => readRuntimeLimits(t)));
+    if (entries.length > limits.files)
+        fail(413, `An agent folder holds at most ${limits.files} files (the Runtime limit folderFiles); this one holds ${entries.length}`, {
+            code: "limit_exceeded",
+            details: { limit: "folderFiles", value: limits.files },
+        });
+    const bytes = entries.reduce((sum, entry) => sum + entry.size, 0);
+    if (bytes > limits.totalBytes)
+        fail(413, `An agent folder holds at most ${limits.totalBytes} bytes (the Runtime limit folderBytes); this one holds ${bytes}`, {
+            code: "limit_exceeded",
+            details: { limit: "folderBytes", value: limits.totalBytes },
+        });
+    // Every file must be held: the version keeps them all as its source.
+    const shas = [...new Set(entries.map((entry) => `sha256:${entry.sha256}`))].sort();
+    const held = await ctx.store.tx((t) => t.heldDefinitionFiles(shas));
+    const missing = entries.filter((entry) => !held.has(`sha256:${entry.sha256}`));
+    if (missing.length > 0)
+        fail(400, `The folder names ${missing.length} file(s) the Runtime does not hold; upload each with PUT /v1/files/sha256:<hex> first: ${missing
+            .slice(0, 20)
+            .map((entry) => entry.path)
+            .join(", ")}`, { code: "definition_files_missing", details: { missing: missing.map((entry) => `sha256:${entry.sha256}`) } });
+    for (const entry of entries)
+        if (held.get(`sha256:${entry.sha256}`) !== entry.size)
+            fail(400, `${entry.path} is listed with ${entry.size} bytes, and the Runtime holds ${held.get(`sha256:${entry.sha256}`)} for its hash`);
+    // The files the compiler reads, each at most the text file limit (it reports a larger one).
+    const files = new Map();
+    for (const path of folderTextPaths(entries)) {
+        const entry = entries.find((item) => item.path === path);
+        if (entry.size > limits.textFileBytes)
+            continue;
+        const bytes = await readDefinitionFile(ctx.blobs, `sha256:${entry.sha256}`);
+        if (bytes)
+            files.set(path, bytes);
+    }
+    const compiled = compileAgentFolder({ entries, files, name, limits });
+    if (!compiled.manifest) {
+        const errors = compiled.diagnostics.filter((item) => item.severity === "error");
+        fail(422, `Agent folder ${name} does not compile: ${errors.length} error(s), the first: ${located(errors[0])}`, {
+            code: "folder_invalid",
+            details: { diagnostics: compiled.diagnostics },
+        });
+    }
+    const source = {
+        compiler: compiled.compiler,
+        files: entries.length,
+        bytes,
+        entries: entries.map((entry) => ({ path: entry.path, size: entry.size, sha256: entry.sha256 })),
+    };
+    return saveManifest(ctx, name, compiled.manifest, scope, options, {
+        source,
+        diagnostics: compiled.diagnostics,
+        compiler: compiled.compiler,
+    });
+}
+/** What a folder may hold: the Tenant's Runtime limits, as the compiler takes them. */
+function folderLimitsOf(limits) {
+    return { files: limits.folderFiles, totalBytes: limits.folderBytes, textFileBytes: limits.folderTextFileBytes };
+}
+/** A diagnostic as a person reads it: `file:line:column message`. */
+function located(diagnostic) {
+    if (!diagnostic)
+        return "unknown";
+    const where = diagnostic.file
+        ? `${diagnostic.file}${diagnostic.line ? `:${diagnostic.line}${diagnostic.column ? `:${diagnostic.column}` : ""}` : ""} `
+        : "";
+    return `${where}${diagnostic.message}`;
+}
+/** The source of version `version` of manifest `name`, or a `404` for one saved as JSON. */
+async function sourceOf(ctx, name, version) {
+    const row = (await ctx.store.tx((t) => t.agentManifest(name, version))) ?? notFound(name, version);
+    if (!row.source)
+        fail(404, `Version ${version} of agent manifest ${name} was saved as JSON: it has no source.`, { code: "not_found" });
+    return row.source;
+}
+/** `GET /v1/agent-manifests/{name}/versions/{v}/source`: the folder a version was compiled from. */
+export async function getAgentManifestSource(ctx, name, version) {
+    const source = await sourceOf(ctx, name, version);
+    return { name, version, ...source };
+}
+/** `GET .../versions/{v}/source/files/{path}`: one file of a version's source, streamed. */
+export async function readAgentManifestSourceFile(ctx, name, version, path) {
+    const source = await sourceOf(ctx, name, version);
+    const entry = source.entries.find((item) => item.path === path);
+    if (!entry)
+        fail(404, `Version ${version} of agent manifest ${name} has no file ${path}.`, { code: "not_found" });
+    const body = await openDefinitionFile(ctx.blobs, `sha256:${entry.sha256}`);
+    if (!body)
+        fail(404, `The Runtime no longer holds ${path} of version ${version} of agent manifest ${name}.`, { code: "not_found" });
+    return { body: body, size: entry.size };
+}
+/**
+ * `GET /v1/agent-manifests/{name}/source/diff?from=&to=`: the files added, removed and changed
+ * (by SHA-256) from version `from`'s source to version `to`'s; a `404` when either was saved as JSON.
+ */
+export async function diffAgentManifestSources(ctx, name, from, to) {
+    const before = new Map((await sourceOf(ctx, name, from)).entries.map((entry) => [entry.path, entry]));
+    const after = (await sourceOf(ctx, name, to)).entries;
+    const diff = { name, from, to, added: [], removed: [], changed: [], unchanged: 0 };
+    for (const entry of after) {
+        const was = before.get(entry.path);
+        before.delete(entry.path);
+        if (!was)
+            diff.added.push(entry);
+        else if (was.sha256 === entry.sha256)
+            diff.unchanged++;
+        else
+            diff.changed.push({
+                path: entry.path,
+                from: { size: was.size, sha256: was.sha256 },
+                to: { size: entry.size, sha256: entry.sha256 },
+            });
+    }
+    diff.removed.push(...before.values());
+    const byPath = (a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+    diff.added.sort(byPath);
+    diff.removed.sort(byPath);
+    diff.changed.sort(byPath);
+    return diff;
+}
 /** `GET /v1/agent-manifests/{name}` (the latest) and `.../versions/{n}`. */
 export async function getAgentManifest(ctx, name, version) {
     return ctx.store.tx(async (t) => {

package/dist/tenant/agents.d.ts

@@ -17,10 +17,11 @@ export declare function liveEnvironment(t: Tx, id: string, options?: {
  * An Agent's state (protocol 16), from its desired state, its compute and its sessions, and
  * every state that holds with the session behind it (`attention`), highest first. A session waits
  * on a person while it is paused (an approval or an interaction) or uncertain, and the Agent while
- * a move waits for its required secrets (track T3); a session's last turn
- * failed while it is `failed`; a turn runs while it is `running`, `runnable` or `waiting`.
+ * a move waits for its required secrets (track T3), or a required secret of the version it runs
+ * has no value (`unsetSecrets`, track T7: a tool would fail when it is called); a session's last
+ * turn failed while it is `failed`; a turn runs while it is `running`, `runnable` or `waiting`.
  */
-export declare function stateOf(agent: Pick<Environment, "desiredState" | "pod"> & Partial<Pick<Environment, "targetVersion" | "appliedVersion" | "version" | "failedVersion">>, sessions: readonly Pick<Session, "id" | "status">[]): {
+export declare function stateOf(agent: Pick<Environment, "desiredState" | "pod"> & Partial<Pick<Environment, "targetVersion" | "appliedVersion" | "version" | "failedVersion">>, sessions: readonly Pick<Session, "id" | "status">[], unsetSecrets?: readonly string[]): {
     state: AgentState;
     attention: AgentAttention[];
 };

package/dist/tenant/agents.js

@@ -22,7 +22,8 @@
  *   the Agent's id).
  * - **State on read.** `state` is derived when it is read, the first rule that holds: `paused`
  *   (desired `off`, track T6), `failing` (its compute failed or was lost, or a session's last
- *   turn failed), `input_required` (a session waits on a person), `working` (a turn runs),
+ *   turn failed), `input_required` (a session waits on a person, or a required secret is unset),
+ *   `working` (a turn runs),
  *   `sleeping`; `attention` names the sessions behind each that holds (`stateOf`).
  * - **Secret slots** (D64): when its manifest declares `secrets`, a secret write sends only the
  *   value, the binding comes from the slot, and a name it does not declare is
@@ -110,16 +111,20 @@ const STATE_RANK = ["paused", "failing", "input_required", "working", "sleeping"
  * An Agent's state (protocol 16), from its desired state, its compute and its sessions, and
  * every state that holds with the session behind it (`attention`), highest first. A session waits
  * on a person while it is paused (an approval or an interaction) or uncertain, and the Agent while
- * a move waits for its required secrets (track T3); a session's last turn
- * failed while it is `failed`; a turn runs while it is `running`, `runnable` or `waiting`.
+ * a move waits for its required secrets (track T3), or a required secret of the version it runs
+ * has no value (`unsetSecrets`, track T7: a tool would fail when it is called); a session's last
+ * turn failed while it is `failed`; a turn runs while it is `running`, `runnable` or `waiting`.
  */
-export function stateOf(agent, sessions) {
+export function stateOf(agent, sessions, unsetSecrets = []) {
     const attention = [];
     if (agent.desiredState === "off")
         attention.push({ state: "paused", reason: "desired off" });
     // A move that waits for a person to set its required secrets (track T3).
     if (agent.targetVersion !== undefined && agent.appliedVersion === agent.version)
         attention.push({ state: "input_required", reason: `secret_required: version ${agent.targetVersion} waits for its required secrets` });
+    // A required secret of the version it runs, unset (track T7).
+    for (const name of unsetSecrets)
+        attention.push({ state: "input_required", reason: `secret_unset: required secret ${name} unset` });
     const pod = agent.pod;
     if (pod && (pod.observed === "failed" || pod.observed === "lost") && pod.desired !== "deleted")
         attention.push({ state: "failing", reason: `compute ${pod.observed}${pod.reason ? `: ${pod.reason}` : ""}` });
@@ -152,7 +157,7 @@ async function viewOf(ctx, t, environment, owner) {
         : undefined;
     const pod = environment.pod;
     const visible = sessions.filter((session) => owner === undefined || session.ownerUserId === owner);
-    const { state, attention } = stateOf(environment, visible);
+    const { state, attention } = stateOf(environment, visible, await unsetRequiredSecrets(t, environment));
     return {
         id: environment.id,
         manifest: manifestRefOf(environment),
@@ -230,6 +235,22 @@ async function slotsAhead(t, environment) {
     const target = await t.agentManifest(environment.manifestName, environment.targetVersion);
     return target ? runtimeOf(target.body).secrets : environment.applied.secrets;
 }
+/**
+ * The required secret slots of the version `environment` runs (its applied runtime) that its vault
+ * holds no value for, by name: the Agent's attention (track T7), before a tool fails for want of
+ * one. A move waiting on the next version's secrets is its own attention item (`stateOf`).
+ */
+async function unsetRequiredSecrets(t, environment) {
+    const required = Object.entries(environment.applied.secrets ?? {}).filter(([, slot]) => slot.required === true);
+    if (required.length === 0)
+        return [];
+    const vault = await t.vaultOfEnvironment(environment.id);
+    const rows = vault ? await t.credentialsForVault(vault.id) : [];
+    return required
+        .filter(([name, slot]) => !rows.some((row) => row.name === name && slotHolds(slot, row)))
+        .map(([name]) => name)
+        .sort();
+}
 /** Each secret slot `environment` declares (`slotsAhead`), and whether its vault holds a value that fills it. */
 async function slotsOf(t, environment) {
     const declared = await slotsAhead(t, environment);

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const RUNTIME_VERSION = "0.30.0-beta";
+export declare const RUNTIME_VERSION = "0.32.0-beta";

package/dist/version.js

@@ -1,3 +1,3 @@
 // Kept in step with package.json by runtime/server/scripts/check-package.mjs, which runs in npm run check.
 // release:prepare also rewrites this when it bumps @nylorun/runtime.
-export const RUNTIME_VERSION = "0.30.0-beta";
+export const RUNTIME_VERSION = "0.32.0-beta";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nylorun/runtime",
-  "version": "0.30.0-beta",
+  "version": "0.32.0-beta",
   "description": "Nylorun Runtime: the agent execution Host on Postgres, Restate and S2, and model providers.",
   "type": "module",
   "license": "Apache-2.0",
@@ -65,8 +65,8 @@
     "@hono/node-server": "^2.1.5",
     "@hono/zod-openapi": "^1.6.3",
     "@modelcontextprotocol/sdk": "^1.32.1",
-    "@nylorun/core": "0.26.0-beta",
-    "@nylorun/harness": "0.29.2-beta",
+    "@nylorun/core": "0.28.0-beta",
+    "@nylorun/harness": "0.29.4-beta",
     "@restatedev/restate-sdk": "1.17.3",
     "@restatedev/restate-sdk-clients": "1.17.3",
     "@s2-dev/streamstore": "0.28.0",