@fastagent-sh/fastagent 0.29.0 → 0.30.1

package/dist/deploy/secret-store.js

@@ -0,0 +1,98 @@
+/** The gap the target has, as the line a person (or the agent relaying one) acts on. */
+function gapLine(host, missing, held, commands) {
+    const names = missing.map((need) => `${need.name} (${need.hint})`).join("; ");
+    const fromFile = missing.filter((need) => held.includes(need.name));
+    const rest = missing.filter((need) => !held.includes(need.name));
+    const ways = [
+        ...(fromFile.length > 0
+            ? [
+                `\`${commands.push}\` sets ${fromFile.length === 1 ? "the one" : "the ones"} a value file holds (${fromFile.map((n) => n.name).join(", ")})`,
+            ]
+            : []),
+        ...(rest.length > 0
+            ? [
+                `a person types ${fromFile.length > 0 ? "the others" : rest.length === 1 ? "it" : "them"} in a terminal, one command each: ${rest.map((need) => `\`${commands.set(need.name)}\``).join(", ")}`,
+            ]
+            : []),
+        `\`${commands.push} --from-env\` takes them from the environment of a secret manager or a CI job (\`op run\`, \`doppler run\`)`,
+    ];
+    return `${host} has no value for: ${names}. ${ways.join("; ")}. Then re-run. A value is never asked for in a conversation`;
+}
+/** Resolves a gate line when the target still lacks a required name afterwards, undefined once it holds them all. */
+export async function provideSecrets(input) {
+    const { host, store, needs, known, source, asker, commands, mint = [] } = input;
+    try {
+        const have = await store.names();
+        const missing = needs.filter((need) => !have.has(need.name));
+        const ours = new Set(mint.map((made) => made.name));
+        const filed = (name) => {
+            const value = source?.values.get(name);
+            return value !== undefined && value.trim() !== "" ? value : undefined;
+        };
+        // What FastAgent made is not the person's to be asked about: the file records it, so a target that lacks it (a
+        // deployment made again) gets that value, and one the file lacks too gets a new one.
+        const minted = {};
+        const restored = [];
+        for (const { name, make } of mint) {
+            if (have.has(name))
+                continue;
+            const kept = filed(name);
+            if (kept === undefined)
+                minted[name] = make();
+            else {
+                minted[name] = kept;
+                restored.push(name);
+            }
+        }
+        const offered = [...(source?.values ?? [])]
+            .filter(([name, value]) => value.trim() !== "" && known.includes(name) && !have.has(name) && !ours.has(name))
+            .map(([name]) => name);
+        if (missing.length === 0 && offered.length === 0 && Object.keys(minted).length === 0)
+            return undefined;
+        const finishMinted = async () => {
+            if (restored.length > 0) {
+                input.inform?.(`set ${restored.join(", ")} on ${host} from ${source?.file}, where an earlier deploy kept it`);
+            }
+            const made = Object.fromEntries(Object.entries(minted).filter(([name]) => !restored.includes(name)));
+            if (Object.keys(made).length > 0)
+                await input.onMinted?.(made);
+        };
+        const held = offered.filter((name) => missing.some((need) => need.name === name));
+        if (asker === undefined) {
+            const lacking = missing.filter((need) => !(need.name in minted));
+            if (lacking.length > 0)
+                return gapLine(host, lacking, held, commands);
+            // Names a file holds and the target lacks, which nothing requires: said, since nobody was asked to set them.
+            if (offered.length > 0 && source !== undefined) {
+                input.say?.(`${host} lacks ${offered.join(", ")}, which ${source.file} holds; \`${commands.push}\` sets ${offered.length === 1 ? "it" : "them"}`);
+            }
+            if (Object.keys(minted).length > 0) {
+                await store.write(minted);
+                await finishMinted();
+            }
+            return undefined;
+        }
+        const write = { ...minted };
+        if (offered.length > 0 && source !== undefined) {
+            const required = new Set(missing.map((need) => need.name));
+            const list = offered.map((name) => (required.has(name) ? name : `${name} (optional)`)).join(", ");
+            if (await asker.confirm(`${host} lacks ${list}, which ${source.file} holds. Set them on ${host} from it?`)) {
+                for (const name of offered)
+                    write[name] = source.values.get(name);
+            }
+        }
+        for (const need of missing) {
+            if (need.name in write)
+                continue;
+            write[need.name] = await asker.secret(need);
+        }
+        if (Object.keys(write).length > 0)
+            await store.write(write);
+        if (Object.keys(minted).length > 0)
+            await finishMinted();
+        return undefined;
+    }
+    catch (error) {
+        return `${host}'s values could not be read or set: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}

package/dist/deploy/secrets.d.ts

@@ -1,14 +1,14 @@
 /**
  * The environment a deployed agent runs with — host-neutral.
  *
- * The production value file (`.secrets/production/.env`) IS the deployed environment: every variable in it travels, on every host. What the
- * definition declares (`defineTool`/`defineChannel`, the `variables` of `context.json`, plus the model's env key) only says
- * which of those must have a value, so a missing one stops a deploy before its first side effect instead of a boot.
+ * Docker, Fly and Railway keep a deployment's values in a store of their own and are never handed a file (secret-store.ts):
+ * what the definition declares (`defineTool`/`defineChannel`, the `variables` of `context.json`, plus the model's env key)
+ * says which names must have a value there. AgentCore's store is a Secrets Manager secret (agentcore/store.ts).
  */
 import { type DeclaredSecret } from "../declared-secrets.ts";
 /** Is this local auth source an env-var API key (→ becomes a deploy secret) vs OAuth / stored / none? */
 export declare function isEnvKey(source: string | undefined): source is string;
-/** Is `name` one the deployment sets itself (see {@link DEPLOY_OWNED}), including the chunked carriers? */
+/** Is `name` one the deployment sets itself (see {@link DEPLOY_OWNED})? */
 export declare function isDeployOwned(name: string): boolean;
 /** One variable a runbook tells the operator to set, and where to look for its value. */
 export interface DeploymentSecret {
@@ -16,52 +16,35 @@ export interface DeploymentSecret {
     hint: string;
 }
 /**
- * What a runbook lists: the names that must have a value (the model's env key, every declaration — hinted by the file
- * that declared it) and then every other variable the value file carries.
+ * What a runbook lists: the names the deployment declares (the model's env key, every declaration — hinted by the file
+ * that declared it).
  */
-export declare function deploymentSecrets(modelAuth: string | undefined, declared: readonly DeclaredSecret[], values: ReadonlyMap<string, string>, valueFile: string): DeploymentSecret[];
-/**
- * Assemble the VALUES a `--run` deploy sets on the host: every variable the value file carries. Never minted here.
- *
- * `values` is the selected value file, read as data — **the environment running `deploy` is not a source**. A
- * deployment must be reproducible from what it carries, and a variable that happens to be exported on the builder is
- * written down nowhere. CI supplies values by writing the file before running the command.
- *
- * No credentials file travels: a model that does not authenticate through a variable (or its own definition) logs in
- * on the deployment itself (`fastagent login --deployment`), so the box is the only holder of its grant.
- */
-export declare function assembleSecrets(input: {
-    modelAuth: string | undefined;
-    /** Every name the definition declared it needs — what must have a value. */
-    declared?: readonly DeclaredSecret[];
-    /** The selected value file's contents (`loadEnvValues`). The ONLY source of operator-supplied values. */
-    values: ReadonlyMap<string, string>;
-}): {
-    secrets: Record<string, string>;
-    missingSecrets: string[];
-};
-/**
- * The stop for a host CLI signed out with nobody to sign it in. A token goes in the shell's (or CI's) environment,
- * never in the production value file: everything there travels to the box, which runs an agent with a shell.
- */
-export declare function hostSignedOutGate(host: string, login: string, token: string, forAgent: string): string;
+export declare function deploymentSecrets(modelAuth: string | undefined, declared: readonly DeclaredSecret[]): DeploymentSecret[];
+/** One name a deployment cannot start without, and where to find out what it is for. */
+export interface SecretNeed {
+    name: string;
+    hint: string;
+}
+/** What the model's credential asks of the target (preflight.ts's `modelKey`). */
+export interface ModelKey {
+    /** The variables the provider reads its key from. */
+    variables: readonly string[];
+    /** One of them must be set: the value file holds no key and the provider has no login to run on the box. */
+    required: boolean;
+}
 /**
- * The ONE refusal for declared names the deployed environment does not supply a value for — every host reaches it
- * before its first side effect. Host-neutral because the reason is: the value file IS the deployed environment, so a
- * name missing from it is missing from the deployment, whatever platform receives it.
+ * The names the target must hold a value for: the key of a model with no other way in, the model's key when the value
+ * file holds one, and every declaration that does not say the code runs without it, each hinted by the file that
+ * declared it. A name some declaration requires is required.
  */
-export declare function missingValuesGate(missing: readonly string[], valueFile: string): string | undefined;
+export declare function secretNeeds(modelAuth: string | undefined, declared: readonly DeclaredSecret[], modelKey?: ModelKey): SecretNeed[];
 /**
- * The refusal for a setting that shapes what `deploy` plans (a channel's ingress, read when `deploy` imports the
- * channel here) and differs between this process and the value file. The box imports the channel with the file's
- * value, so planning with this one would deploy a different channel than the one planned for: an export in this shell
- * is the usual cause.
+ * Every name the definition declares, optional ones and the model's keys included: what a source may supply, and what
+ * `secrets list` shows.
  */
-export declare function divergentSettingsGate(names: readonly string[], env: NodeJS.ProcessEnv, values: ReadonlyMap<string, string>, valueFile: string): string | undefined;
+export declare function declaredNames(modelAuth: string | undefined, declared: readonly DeclaredSecret[], modelKey?: ModelKey): string[];
 /**
- * Expand `FASTAGENT_ENV` into the process environment — what `start` does first on a host that carries the value file
- * that way. The platform's own variables still win, as they do over a value file anywhere.
+ * The stop for a host CLI signed out with nobody to sign it in. A token goes in the shell's (or CI's) environment,
+ * never in the production value file, which holds the deployment's values and not the CLI's.
  */
-export declare function applyCarriedEnv(env?: NodeJS.ProcessEnv): void;
-/** The carried variables as the base64 JSON {@link collectCarriedEnv} reads back; empty when nothing travels. */
-export declare function encodeCarriedEnv(carried: Readonly<Record<string, string>>): string;
+export declare function hostSignedOutGate(host: string, login: string, token: string, forAgent: string): string;

package/dist/deploy/secrets.js

@@ -1,9 +1,9 @@
 /**
  * The environment a deployed agent runs with — host-neutral.
  *
- * The production value file (`.secrets/production/.env`) IS the deployed environment: every variable in it travels, on every host. What the
- * definition declares (`defineTool`/`defineChannel`, the `variables` of `context.json`, plus the model's env key) only says
- * which of those must have a value, so a missing one stops a deploy before its first side effect instead of a boot.
+ * Docker, Fly and Railway keep a deployment's values in a store of their own and are never handed a file (secret-store.ts):
+ * what the definition declares (`defineTool`/`defineChannel`, the `variables` of `context.json`, plus the model's env key)
+ * says which names must have a value there. AgentCore's store is a Secrets Manager secret (agentcore/store.ts).
  */
 import { dedupeSecrets } from "../declared-secrets.js";
 import { DEV_SERVE_ENV } from "../serving-command.js";
@@ -12,42 +12,34 @@ import { AGENT_ENVIRONMENT_ENV } from "../paths.js";
 export function isEnvKey(source) {
     return source !== undefined && /^[A-Z][A-Z0-9_]*$/.test(source);
 }
-/**
- * Names a deployment sets on the box itself. The value file's copy of one describes THIS machine (a local state path,
- * a port) or rides another carrier (the model rides the release manifest), so it never travels.
- */
+/** Names a deployment sets on the box itself: a value for one describes THIS machine (a local state path, a port). */
 const DEPLOY_OWNED = new Set([
     "PORT",
     "FASTAGENT_MODEL",
+    "FASTAGENT_CONFIG",
+    "FASTAGENT_ROOT",
+    "FASTAGENT_WORKDIR",
     "FASTAGENT_STATE_DIR",
     "FASTAGENT_SECRETS_DIR",
     "FASTAGENT_AUTH_PATH",
     "FASTAGENT_RELEASE_FILE",
-    "FASTAGENT_STORAGE_DIR",
     "FASTAGENT_AGENTCORE",
+    "FASTAGENT_SECRET_ARN",
     "FASTAGENT_INGRESS_SECRET",
     "FASTAGENT_WAKE_SECRET",
     "FASTAGENT_DEV_WORKER",
     DEV_SERVE_ENV,
     AGENT_ENVIRONMENT_ENV,
 ]);
-/** Is `name` one the deployment sets itself (see {@link DEPLOY_OWNED}), including the chunked carriers? */
+/** Is `name` one the deployment sets itself (see {@link DEPLOY_OWNED})? */
 export function isDeployOwned(name) {
-    return DEPLOY_OWNED.has(name) || /^FASTAGENT_ENV(_\d+)?$/.test(name);
-}
-/** The value-file variables that travel: everything with a value that the deployment does not set itself. */
-function carriedValues(values) {
-    const carried = {};
-    for (const [name, value] of values)
-        if (value && !isDeployOwned(name))
-            carried[name] = value;
-    return carried;
+    return DEPLOY_OWNED.has(name);
 }
 /**
- * What a runbook lists: the names that must have a value (the model's env key, every declaration — hinted by the file
- * that declared it) and then every other variable the value file carries.
+ * What a runbook lists: the names the deployment declares (the model's env key, every declaration — hinted by the file
+ * that declared it).
  */
-export function deploymentSecrets(modelAuth, declared, values, valueFile) {
+export function deploymentSecrets(modelAuth, declared) {
     const secrets = [];
     const add = (name, hint) => {
         if (!secrets.some((s) => s.name === name))
@@ -55,118 +47,53 @@ export function deploymentSecrets(modelAuth, declared, values, valueFile) {
     };
     if (isEnvKey(modelAuth))
         add(modelAuth, "your model provider key");
-    for (const { name, source, description } of dedupeSecrets(declared)) {
-        add(name, `required by ${source}${description ? `: ${description}` : ""}`);
+    for (const { name } of dedupeSecrets(declared)) {
+        // Hinted by a declaration that requires it, when one does: a name some declaration requires is required.
+        const declarations = declared.filter((s) => s.name === name);
+        const { declaredIn, description, optional } = declarations.find((s) => !s.optional) ?? declarations[0];
+        add(name, `${optional ? "optional, read by" : "required by"} ${declaredIn}${description ? `: ${description}` : ""}`);
     }
-    for (const name of Object.keys(carriedValues(values)))
-        add(name, `from ${valueFile}`);
     return secrets;
 }
 /**
- * Assemble the VALUES a `--run` deploy sets on the host: every variable the value file carries. Never minted here.
- *
- * `values` is the selected value file, read as data — **the environment running `deploy` is not a source**. A
- * deployment must be reproducible from what it carries, and a variable that happens to be exported on the builder is
- * written down nowhere. CI supplies values by writing the file before running the command.
- *
- * No credentials file travels: a model that does not authenticate through a variable (or its own definition) logs in
- * on the deployment itself (`fastagent login --deployment`), so the box is the only holder of its grant.
+ * The names the target must hold a value for: the key of a model with no other way in, the model's key when the value
+ * file holds one, and every declaration that does not say the code runs without it, each hinted by the file that
+ * declared it. A name some declaration requires is required.
  */
-export function assembleSecrets(input) {
-    const secrets = carriedValues(input.values);
-    const missingSecrets = [];
-    if (isEnvKey(input.modelAuth) && !secrets[input.modelAuth])
-        missingSecrets.push(input.modelAuth);
-    for (const { name } of dedupeSecrets(input.declared ?? [])) {
-        if (!secrets[name] && !missingSecrets.includes(name))
-            missingSecrets.push(name);
+export function secretNeeds(modelAuth, declared, modelKey) {
+    const needs = [];
+    if (isEnvKey(modelAuth))
+        needs.push({ name: modelAuth, hint: "your model provider key" });
+    else if (modelKey?.required && modelKey.variables[0] !== undefined) {
+        needs.push({ name: modelKey.variables[0], hint: "your model provider key: it has no login to run on the box" });
     }
-    return { secrets, missingSecrets };
-}
-/**
- * The stop for a host CLI signed out with nobody to sign it in. A token goes in the shell's (or CI's) environment,
- * never in the production value file: everything there travels to the box, which runs an agent with a shell.
- */
-export function hostSignedOutGate(host, login, token, forAgent) {
-    return (`not logged in to ${host} — run \`${login}\` in a terminal (it opens a browser), or set ${token} in this ` +
-        `shell's environment, never in .secrets/production/.env (everything there travels to the box); then re-run. ` +
-        `From a coding agent, \`${forAgent}\` hands the sign-in to its user`);
-}
-/**
- * The ONE refusal for declared names the deployed environment does not supply a value for — every host reaches it
- * before its first side effect. Host-neutral because the reason is: the value file IS the deployed environment, so a
- * name missing from it is missing from the deployment, whatever platform receives it.
- */
-export function missingValuesGate(missing, valueFile) {
-    if (missing.length === 0)
-        return undefined;
-    return (`no value for: ${missing.join(", ")} — the deployed environment is declared by ${valueFile}, and this deploy ` +
-        `reads only that file (exporting the variable here does not reach the deployment). Add them there and re-run`);
-}
-/**
- * The refusal for a setting that shapes what `deploy` plans (a channel's ingress, read when `deploy` imports the
- * channel here) and differs between this process and the value file. The box imports the channel with the file's
- * value, so planning with this one would deploy a different channel than the one planned for: an export in this shell
- * is the usual cause.
- */
-export function divergentSettingsGate(names, env, values, valueFile) {
-    const differing = names.filter((name) => (env[name] ?? "") !== (values.get(name) ?? ""));
-    if (differing.length === 0)
-        return undefined;
-    const said = differing.map((name) => `${name} is "${env[name] ?? ""}" here and "${values.get(name) ?? ""}" in ${valueFile}`);
-    return (`${said.join("; ")} — the deployment receives only ${valueFile}, and this deploy would plan for a different ` +
-        `channel than the one it starts. Set it in ${valueFile} (or unset it here) and re-run`);
-}
-/**
- * Collect a (possibly CHUNKED) carrier from the environment: `<name>` plus numbered continuations (`_2`, `_3`, …)
- * concatenated in order. A host whose env values have a length cap splits a long value this way.
- */
-function collectChunked(env, name) {
-    const first = env[name];
-    if (!first)
-        return undefined;
-    let value = first;
-    for (let i = 2;; i++) {
-        const part = env[`${name}_${i}`];
-        if (!part)
-            break;
-        value += part;
+    for (const { name } of dedupeSecrets(declared.filter((secret) => !secret.optional))) {
+        if (needs.some((need) => need.name === name))
+            continue;
+        const { declaredIn, description } = declared.find((secret) => secret.name === name && !secret.optional);
+        needs.push({ name, hint: `required by ${declaredIn}${description ? `: ${description}` : ""}` });
     }
-    return value;
+    return needs;
 }
 /**
- * `FASTAGENT_ENV` (+ `_2`, …): the carried variables as ONE base64 JSON object, for a host whose deployment artifact
- * must not depend on which names the value file holds (AgentCore's template is committed and gated on drift). The
- * inverse of {@link encodeCarriedEnv}.
+ * Every name the definition declares, optional ones and the model's keys included: what a source may supply, and what
+ * `secrets list` shows.
  */
-function collectCarriedEnv(env) {
-    const encoded = collectChunked(env, "FASTAGENT_ENV");
-    if (encoded === undefined)
-        return undefined;
-    const parsed = JSON.parse(Buffer.from(encoded, "base64").toString("utf8"));
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-        throw new Error("FASTAGENT_ENV is not an object of variables — redeploy to regenerate it");
-    }
-    const carried = {};
-    for (const [name, value] of Object.entries(parsed)) {
-        if (typeof value !== "string")
-            throw new Error(`FASTAGENT_ENV: ${name} is not a string — redeploy to regenerate it`);
-        carried[name] = value;
-    }
-    return carried;
+export function declaredNames(modelAuth, declared, modelKey) {
+    return [
+        ...new Set([
+            ...(isEnvKey(modelAuth) ? [modelAuth] : []),
+            ...(modelKey?.variables ?? []),
+            ...declared.map(({ name }) => name),
+        ]),
+    ];
 }
 /**
- * Expand `FASTAGENT_ENV` into the process environment — what `start` does first on a host that carries the value file
- * that way. The platform's own variables still win, as they do over a value file anywhere.
+ * The stop for a host CLI signed out with nobody to sign it in. A token goes in the shell's (or CI's) environment,
+ * never in the production value file, which holds the deployment's values and not the CLI's.
  */
-export function applyCarriedEnv(env = process.env) {
-    const carried = collectCarriedEnv(env);
-    if (carried)
-        for (const [name, value] of Object.entries(carried))
-            if (!(name in env))
-                env[name] = value;
-}
-/** The carried variables as the base64 JSON {@link collectCarriedEnv} reads back; empty when nothing travels. */
-export function encodeCarriedEnv(carried) {
-    return Object.keys(carried).length === 0 ? "" : Buffer.from(JSON.stringify(carried), "utf8").toString("base64");
+export function hostSignedOutGate(host, login, token, forAgent) {
+    return (`not logged in to ${host} — run \`${login}\` in a terminal (it opens a browser), or set ${token} in this ` +
+        `shell's environment, not in .secrets/production/.env (that file holds the deployment's values); then re-run. ` +
+        `From a coding agent, \`${forAgent}\` hands the sign-in to its user`);
 }

package/dist/deploy/workspace.d.ts

@@ -1,6 +1,4 @@
 export declare const RELEASE_FILE = "fastagent.release.json";
-/** Where the storage holds the deployed definition, the agent's working directory on the host. */
-export declare const DEPLOYED_DEFINITION_DIR = "definition";
 export interface DeploymentRelease {
     version: 1;
     id: string;
@@ -32,24 +30,20 @@ export declare function applyReleaseEnv(release: DeploymentRelease, env?: NodeJS
  *  resolution only ever splits on the first slash. */
 export declare function isModelSpec(value: string): boolean;
 /**
- * Call while holding the deployment lease. Replaces the deployed definition with the release's (`source`, the image's
- * copy) and returns where it now is; nothing else on the storage is touched.
+ * Call while holding the deployment lease. Records `release` as the one started on the storage at `root`, refusing a
+ * storage another agent's deployments started on: its state is that agent's.
  */
-export declare function applyDeploymentRelease(source: string, root: string, release: DeploymentRelease): Promise<string>;
+export declare function claimDeploymentStorage(root: string, release: DeploymentRelease): Promise<void>;
 /** An unmounted directory must never look like a new disk. */
 export declare function assertStorageMounted(root: string, paths?: string[]): Promise<void>;
 /** `waitSeconds` covers a restart overlapping the old process's exit; a test that wants the refusal
  *  passes a short one rather than waiting out the deployment default. */
 export declare function leaseDeployment(metadata: string, waitSeconds?: number): Promise<() => Promise<void>>;
 /**
- * Prepare the deployed definition and return its path.
+ * Take the deployment's storage at `root`: it must be a mount, one process holds it (the lease), and it is the
+ * storage of the agent `release` names.
  *
  * The lease is NOT returned: it stays held for the process lifetime, because channel activation can
  * start background writers that `close()` does not drain. The kernel drops it when the process exits.
  */
-export declare function prepareDeployment(source: string, root: string, release: DeploymentRelease): Promise<string>;
-/**
- * Install the deployed agent's dependencies into the storage when it has no installed CLI yet (a fresh volume), or
- * when an earlier install died part-way — its `installing` marker is still there, so the next boot redoes it.
- */
-export declare function installAgentDependencies(root: string, agentDir: string): Promise<void>;
+export declare function prepareDeployment(root: string, release: DeploymentRelease): Promise<void>;

package/dist/deploy/workspace.js

@@ -1,21 +1,18 @@
 /**
- * Deployment-owned initialization of a host's storage: the lease, the release journal, and the definition each
- * release replaces. The instance's state, credentials and content (`.state/`, `.secrets/`, `content/`) sit beside the
- * definition and outlive every release; each release links its `content/` to the storage's.
+ * Deployment-owned initialization of a host's storage: the lease, and the record of which agent the storage is for.
+ * The program is the image's, read where it is built; the storage is the instance's root, its working directory with
+ * its state, credentials and content (`.state/`, `.secrets/`, `content/`), which outlives every release.
  */
-import { cp, lstat, mkdir, readFile, rename, rm, symlink } from "node:fs/promises";
+import { mkdir, readFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { spawn } from "node:child_process";
 import { closeSync, openSync } from "node:fs";
 import { once } from "node:events";
 import { writeFileAtomic } from "../atomic-write.js";
 import { log } from "../log.js";
-import { CONTENT_DIRNAME, exists } from "../paths.js";
-import { detectRuntime, readPackageJson } from "../runtime.js";
+import { exists } from "../paths.js";
 export const RELEASE_FILE = "fastagent.release.json";
-/** Where the storage holds the deployed definition, the agent's working directory on the host. */
-export const DEPLOYED_DEFINITION_DIR = "definition";
-/** The deployment's own bookkeeping on the storage: the lease, the release journal, the install marker. */
+/** The deployment's own bookkeeping on the storage: the lease, and the release last started on it. */
 const deploymentMeta = (root) => join(root, ".deployment");
 /** The manifest names the agent the storage belongs to, and that name is also a content entry's name rule (one path
  *  segment). `deploy` asks BEFORE generating artifacts — a name `init` accepts but this rejects is the author's
@@ -60,74 +57,20 @@ export function applyReleaseEnv(release, env = process.env) {
 export function isModelSpec(value) {
     return /^\S+\/\S+$/.test(value);
 }
-/** A completed staging tree is published before its journal; readers start only after recovery. */
-async function finishRelease(root, release) {
-    const meta = deploymentMeta(root), staged = join(meta, "staged"), previous = join(meta, "previous");
-    const target = join(root, DEPLOYED_DEFINITION_DIR);
-    if (await exists(staged)) {
-        if (await exists(target)) {
-            if (await exists(previous))
-                throw new Error(`deployment recovery conflict at ${target}`);
-            await rename(target, previous);
-        }
-        await rename(staged, target);
-    }
-    else if (!(await exists(target))) {
-        throw new Error(`deployment recovery has neither staged nor active content: ${target}`);
-    }
-    writeFileAtomic(join(meta, "applied.json"), JSON.stringify(release));
-    await rm(previous, { recursive: true, force: true });
-    await rm(join(meta, "pending.json"));
-}
 /**
- * Call while holding the deployment lease. Replaces the deployed definition with the release's (`source`, the image's
- * copy) and returns where it now is; nothing else on the storage is touched.
+ * Call while holding the deployment lease. Records `release` as the one started on the storage at `root`, refusing a
+ * storage another agent's deployments started on: its state is that agent's.
  */
-export async function applyDeploymentRelease(source, root, release) {
-    const meta = deploymentMeta(root), staged = join(meta, "staged"), pendingPath = join(meta, "pending.json");
-    await mkdir(meta, { recursive: true });
-    await mkdir(join(root, CONTENT_DIRNAME), { recursive: true });
-    // A storage an earlier FastAgent laid out holds the agent's whole workspace there, which this one would leave
-    // behind unread: said, never silently abandoned.
-    const formerWorkspace = join(root, "base");
-    if (await exists(formerWorkspace)) {
-        throw new Error(`${formerWorkspace} holds a workspace from an earlier FastAgent, which no longer copies one to the host — ` +
-            `move out what you need and delete it, or deploy onto fresh storage`);
-    }
-    if (await exists(pendingPath)) {
-        const pending = parseDeploymentRelease(await readFile(pendingPath, "utf8"));
-        await finishRelease(root, pending);
-    }
+export async function claimDeploymentStorage(root, release) {
+    const meta = deploymentMeta(root);
     const appliedPath = join(meta, "applied.json");
     const applied = (await exists(appliedPath)) ? parseDeploymentRelease(await readFile(appliedPath, "utf8")) : undefined;
-    const definition = join(root, DEPLOYED_DEFINITION_DIR);
-    if (applied?.agent !== undefined && applied.agent !== release.agent) {
+    if (applied !== undefined && applied.agent !== release.agent) {
         throw new Error(`deployment selects ${release.agent}, but this storage belongs to ${applied.agent}`);
     }
-    // Logged on BOTH paths: rebuilding an image without regenerating the manifest keeps the id, and a
-    // deployment that silently kept the old definition looks identical to one that took the new one.
-    if (applied?.id === release.id) {
-        log.info(`[fastagent] release ${release.id} is already applied — keeping the deployed definition`);
-        return definition;
-    }
-    if (applied === undefined && (await exists(definition))) {
-        throw new Error(`refusing to initialize over an existing unowned definition: ${definition}`);
-    }
-    if (!(await exists(source)) || !(await lstat(source)).isDirectory()) {
-        throw new Error(`the release must contain its agent directory: ${source}`);
-    }
-    log.info(`[fastagent] publishing release ${release.id} as ${DEPLOYED_DEFINITION_DIR}/`);
-    await rm(staged, { recursive: true, force: true });
-    await cp(source, staged, { recursive: true, verbatimSymlinks: true });
-    // Where the agent reaches each content entry, on every instance: here, the storage's, which no release replaces.
-    await symlink(join("..", CONTENT_DIRNAME), join(staged, CONTENT_DIRNAME)).catch((error) => {
-        if (error.code !== "EEXIST")
-            throw error;
-        throw new Error(`the release holds ${CONTENT_DIRNAME}/, which a deploy keeps out of the image — rebuild it`);
-    });
-    writeFileAtomic(pendingPath, JSON.stringify(release));
-    await finishRelease(root, release);
-    return definition;
+    log.info(`[fastagent] release ${release.id} on ${root}`);
+    if (applied?.id !== release.id)
+        writeFileAtomic(appliedPath, JSON.stringify(release));
 }
 async function mountedPaths() {
     const mounts = await readFile("/proc/self/mountinfo", "utf8");
@@ -174,41 +117,22 @@ export async function leaseDeployment(metadata, waitSeconds = 35) {
     }
 }
 /**
- * Prepare the deployed definition and return its path.
+ * Take the deployment's storage at `root`: it must be a mount, one process holds it (the lease), and it is the
+ * storage of the agent `release` names.
  *
  * The lease is NOT returned: it stays held for the process lifetime, because channel activation can
  * start background writers that `close()` does not drain. The kernel drops it when the process exits.
  */
-export async function prepareDeployment(source, root, release) {
+export async function prepareDeployment(root, release) {
     await assertStorageMounted(root);
     const meta = deploymentMeta(root);
     await mkdir(meta, { recursive: true });
     const unlock = await leaseDeployment(meta);
     try {
-        return await applyDeploymentRelease(source, root, release);
+        await claimDeploymentStorage(root, release);
     }
     catch (error) {
         await unlock();
         throw error;
     }
 }
-/**
- * Install the deployed agent's dependencies into the storage when it has no installed CLI yet (a fresh volume), or
- * when an earlier install died part-way — its `installing` marker is still there, so the next boot redoes it.
- */
-export async function installAgentDependencies(root, agentDir) {
-    const installing = join(deploymentMeta(root), "installing");
-    // A failed install can leave the CLI link in place before its dependencies are complete.
-    if ((await exists(installing)) || !(await exists(join(agentDir, "node_modules/.bin/fastagent")))) {
-        const { runtime, hasLockfile } = detectRuntime(agentDir, await readPackageJson(agentDir));
-        const args = runtime === "bun" ? ["install", ...(hasLockfile ? ["--frozen-lockfile"] : [])] : [hasLockfile ? "ci" : "install"];
-        writeFileAtomic(installing, "");
-        log.info(`[fastagent] installing the agent's dependencies (${runtime} ${args.join(" ")})…`);
-        // stdio inherited: a five-minute install with no output reads as a hang, and the default 1 MB capture would
-        // kill a noisy one outright.
-        const [code, signal] = (await once(spawn(runtime === "bun" ? "bun" : "npm", args, { cwd: agentDir, stdio: "inherit" }), "exit"));
-        if (code !== 0)
-            throw new Error(`dependency install failed (${signal ?? `exit ${code}`})`);
-        await rm(installing);
-    }
-}