@fastagent-sh/fastagent 0.24.3 → 0.25.0

package/dist/cli/commands/destroy.js

@@ -1,10 +1,11 @@
-/** `fastagent destroy agentcore [dir]`: remove every AWS resource the deploy created. */
+/** `fastagent destroy agentcore [agent]`: remove every AWS resource the deploy created. */
 import { basename, resolve } from "node:path";
 import { destroyAgentcoreDeployment } from "../../deploy/agentcore/destroy.js";
 import { agentcoreName } from "../../deploy/agentcore/plan.js";
 import { awsRunner } from "../../deploy/runner.js";
 import { enterAgentEnv } from "../../env.js";
-import { failStartup, failUsage, placementOrExit } from "../fail.js";
+import { selectAgentEnvironment } from "../../paths.js";
+import { agentDirOrExit, failStartup, failUsage } from "../fail.js";
 export async function runDestroy(host, dirArg, opts) {
     // The host argument is DISPATCHED here, as in runLogs. In practice commander rejects anything else first
     // (the spec declares `choices`), so what the operator reads is its message plus the spec's notes, which name
@@ -12,10 +13,11 @@ export async function runDestroy(host, dirArg, opts) {
     // treated as agentcore.
     if (host !== "agentcore")
         failUsage(`destroy: unsupported host "${host}"`);
-    const placement = placementOrExit(resolve(dirArg));
-    enterAgentEnv(placement.agentDir); // AWS_PROFILE/region/proxy may be definition-local, as on deploy
-    const name = agentcoreName(basename(placement.workspace));
-    const outcome = await destroyAgentcoreDeployment({ name, run: opts.run === true }, awsRunner(placement.workspace), (message) => console.error(`[fastagent] destroy: ${message}`));
+    const agentDir = agentDirOrExit(resolve(dirArg));
+    selectAgentEnvironment("production");
+    enterAgentEnv(agentDir);
+    const name = agentcoreName(basename(agentDir));
+    const outcome = await destroyAgentcoreDeployment({ name, run: opts.run === true }, awsRunner(agentDir), (message) => console.error(`[fastagent] destroy: ${message}`));
     if (!outcome.ok) {
         // THE WHOLE PICTURE, before the gate: a half-finished teardown is exactly when an operator needs to know
         // what is out there, what is already gone, and what the retry still has to reach.

package/dist/cli/commands/dev.d.ts

@@ -5,8 +5,6 @@ export interface DevOptions {
     /** false ⇔ `--no-watch`. */
     watch?: boolean;
     tunnel?: boolean;
-    /** false ⇔ `--no-invoke`: withhold `POST /invoke` for THIS run (`http.invoke` is the persistent form). */
-    invoke?: boolean;
     /** false ⇔ `--no-input`. */
     input?: boolean;
 }

package/dist/cli/commands/dev.js

@@ -2,13 +2,14 @@
  * `fastagent dev`: a SUPERVISOR that spawns a worker (this command with FASTAGENT_DEV_WORKER set) to assemble + serve,
  * restarting it on agent edits.
  */
-import { runDevSupervisor } from "../../dev-supervisor.js";
+import { listenForRestart, runDevSupervisor } from "../../dev-supervisor.js";
 import { setLogLevel } from "../../log.js";
-import { createPiAgentFromDir } from "../../engines/pi/open.js";
-import { DEFAULT_HTTP_PORT, mountAgentService } from "../../service.js";
-import { logAgentLoop } from "../../observe.js";
+import { markDevServe } from "../../serving-command.js";
+import { selectAgentEnvironment } from "../../paths.js";
+import { openServing } from "../../harnesses/pi-durable/serve.js";
+import { DEFAULT_HTTP_PORT, serveAgent } from "../../service.js";
 import { failStartup } from "../fail.js";
-import { assertTunnelBindable, cliMountOptions, serveService, withRunOverrides } from "../serve.js";
+import { assertTunnelBindable, cliMountOptions, serveService } from "../serve.js";
 import { enterAgentCommand, parseBind, parsePort, reportAssembly } from "../shared.js";
 /**
  * `dev` binds loopback unless `--bind` says otherwise: a dev serve carries the agent's full tool authority and lands on
@@ -17,32 +18,32 @@ import { enterAgentCommand, parseBind, parsePort, reportAssembly } from "../shar
 const DEV_BIND = "127.0.0.1";
 export async function runDev(dirArg, opts) {
     setLogLevel("debug"); // dev posture: verbose, includes the debug turn trace (content) — supervisor and worker both
+    selectAgentEnvironment("dev");
+    markDevServe(); // the worker inherits both selections
     const isWorker = process.env.FASTAGENT_DEV_WORKER === "1";
+    // First, so a restart asked for while the worker is still assembling is heard: with nothing running it stops at once.
+    if (isWorker)
+        process.on("message", listenForRestart(() => process.kill(process.pid, "SIGTERM")));
     // The model is picked ONCE, in the parent process (a TTY; watch and --no-watch both).
-    const placement = await enterAgentCommand(dirArg, { ...opts, input: isWorker ? false : opts.input });
+    const { agentDir, modelSpec } = await enterAgentCommand(dirArg, { ...opts, input: isWorker ? false : opts.input });
     if (isWorker || opts.watch === false) {
-        await serveOnce(placement, opts);
+        await serveOnce(agentDir, modelSpec, opts);
         return;
     }
     parsePort(opts.port, "--port", "flag"); // flag-shape checks before spawning
     // The --bind/--tunnel conflict is decidable from flags alone: refuse it HERE, before a worker and a tunnel exist.
     assertTunnelBindable(parseBind(opts.bind), opts.tunnel ?? false);
-    await runDevSupervisor(placement, { tunnel: opts.tunnel ?? false });
+    await runDevSupervisor(agentDir, { tunnel: opts.tunnel ?? false });
 }
 /** Assemble the agent and serve it once (the dev worker; also the --no-watch path). */
-async function serveOnce(placement, opts) {
+async function serveOnce(agentDir, modelSpec, opts) {
     const portFlag = parsePort(opts.port, "--port", "flag");
     const host = parseBind(opts.bind) ?? DEV_BIND;
     const tunnel = opts.tunnel ?? false;
     assertTunnelBindable(host, tunnel);
-    const a = await createPiAgentFromDir(placement.agentDir, {
-        model: placement.modelSpec,
-        serving: true, // long-running serve: the scheduler poller runs (and the wake tool is mounted)
-    }).catch(failStartup);
-    // The same report `start` prints; `config:` is dev's own extra (see reportAssembly on the asymmetry).
-    await reportAssembly({ ...a, modelSpec: placement.modelSpec }, { beforeModel: [["config", a.configPath ?? "(none)"]] });
-    // The SAME assembly an embedder gets from `createAgentService` — channels, control plane, schedules, long
-    // connections.
-    const service = await mountAgentService(withRunOverrides(a, opts), cliMountOptions(logAgentLoop)).catch(failStartup);
-    serveService(service, { port: portFlag ?? a.config.http?.port ?? DEFAULT_HTTP_PORT, host }, { tunnel, agentDir: a.agentDir, stateRoot: a.stateRoot });
+    const opened = await openServing(agentDir, { model: modelSpec }).catch(failStartup);
+    await reportAssembly(opened, modelSpec);
+    const { config } = opened.definition;
+    const service = await serveAgent(opened, cliMountOptions(config)).catch(failStartup);
+    serveService(service, { port: portFlag ?? config.http?.port ?? DEFAULT_HTTP_PORT, host }, { tunnel, agentDir, stateRoot: opened.stateRoot, config });
 }

package/dist/cli/commands/env.d.ts

@@ -0,0 +1,12 @@
+export declare function runEnvAdd(args: string[]): Promise<void>;
+export declare function runEnvRemove(args: string[]): Promise<void>;
+export declare function runEnvList(opts?: {
+    json?: boolean;
+}): Promise<void>;
+/**
+ * Install what context.json declares here, mise first when the agent has none (into its package.json): every package at
+ * the newest release its version allows, a newer one where one is out. Apt packages are the image's: one missing here
+ * is said, with how.
+ */
+export declare function runEnvInstall(): Promise<void>;
+export declare function runEnvExec(command: string[]): Promise<void>;

package/dist/cli/commands/env.js

@@ -0,0 +1,190 @@
+/**
+ * `fastagent env add|remove|list|install|exec`: the agent's environment, declared under `environment` in context.json
+ * and installed by the agent's own mise (docs/design/agent-service.md §4), in the agent directory, the current one.
+ */
+import { spawn } from "node:child_process";
+import { resolve } from "node:path";
+import { loadEnvironment, readContextFile } from "../../content/file.js";
+import { aptAdvice, missingAptPackages } from "../../environment/apt.js";
+import { declareEnvironment, declaredVariables, parsePackageArgument, runtimeAdvice, } from "../../environment/declare.js";
+import { checkPackages, ensureMise, enterEnvironment, installPackages, miseBinary } from "../../environment/mise.js";
+import { writeEnvironment } from "../../authoring.js";
+import { log } from "../../log.js";
+import { agentDirOrExit, failStartup } from "../fail.js";
+import { dotEnvPath, enterAgentEnv } from "../../env.js";
+import { missingSecrets } from "../../declared-secrets.js";
+const NONE = { packages: {}, aptPackages: [], variables: {} };
+/**
+ * The agent directory, the current one, entered as every command that runs in it is: its `.env` in `process.env`, and
+ * the proxy that `.env` may declare. mise's downloads go through that proxy, and `env exec` runs its command with the
+ * same values the agent's own commands get.
+ */
+function enterAgentHere() {
+    const agentDir = agentDirOrExit(resolve("."));
+    enterAgentEnv(agentDir);
+    return agentDir;
+}
+export async function runEnvAdd(args) {
+    const agentDir = enterAgentHere();
+    const parsed = args.map(parsePackageArgument);
+    const apt = parsed.flatMap((one) => ("apt" in one ? [one.apt] : []));
+    await edit(agentDir, (current) => {
+        const packages = { ...current.packages };
+        const aptPackages = [...current.aptPackages];
+        for (const one of parsed) {
+            if ("apt" in one) {
+                if (!aptPackages.includes(one.apt))
+                    aptPackages.push(one.apt);
+            }
+            else {
+                packages[one.name] = one.version;
+            }
+        }
+        return { ...current, packages, aptPackages };
+    }).catch(failStartup);
+    const missing = missingAptPackages(apt);
+    if (missing && missing.length > 0)
+        log.warn(`[fastagent] ${aptAdvice(missing)}`);
+}
+export async function runEnvRemove(args) {
+    const agentDir = enterAgentHere();
+    await edit(agentDir, (current) => {
+        const packages = { ...current.packages };
+        let aptPackages = [...current.aptPackages];
+        for (const arg of args) {
+            const apt = arg.startsWith("apt:") ? arg.slice("apt:".length) : undefined;
+            const declared = apt !== undefined ? aptPackages.includes(apt) : Object.hasOwn(packages, arg);
+            if (!declared)
+                throw noPackage(current, arg);
+            if (apt !== undefined)
+                aptPackages = aptPackages.filter((name) => name !== apt);
+            else
+                delete packages[arg];
+        }
+        return { ...current, packages, aptPackages };
+    }).catch(failStartup);
+}
+export async function runEnvList(opts = {}) {
+    const agentDir = enterAgentHere();
+    const declared = await Promise.resolve()
+        .then(() => loadEnvironment(agentDir) ?? NONE)
+        .catch(failStartup);
+    const variables = declaredVariables(declared);
+    if (opts.json) {
+        // Whether each variable has a value here, never the value.
+        const listed = {
+            packages: Object.entries(declared.packages).map(([name, version]) => ({ name, version })),
+            apt: declared.aptPackages,
+            variables: variables.map(({ name, description }) => ({ name, description, set: Boolean(process.env[name]) })),
+        };
+        console.log(JSON.stringify(listed, null, 2));
+    }
+    else {
+        printEnvironment(declared, variables);
+    }
+    if (Object.keys(declared.packages).length > 0) {
+        const bin = miseBinary(agentDir);
+        if (!bin) {
+            log.warn(`[fastagent] the packages are not checked: the agent's mise is not installed here — run ` +
+                `\`fastagent env install\``);
+        }
+        else {
+            const { refusals, runtime } = await checkPackages(agentDir, bin, declared.packages).catch(failStartup);
+            for (const refusal of refusals)
+                log.warn(`[fastagent] ${refusal}`);
+            if (runtime)
+                log.warn(`[fastagent] ${runtimeAdvice(runtime)}`);
+        }
+    }
+    const missing = missingAptPackages(declared.aptPackages);
+    if (missing && missing.length > 0)
+        log.warn(`[fastagent] ${aptAdvice(missing)}`);
+    const unset = missingSecrets(variables).map(({ name }) => name);
+    if (unset.length > 0) {
+        log.warn(`[fastagent] no value here for ${unset.join(", ")}: dev and start refuse to run until they have one — set ` +
+            `them in ${dotEnvPath(agentDir)}`);
+    }
+}
+function printEnvironment(declared, variables) {
+    const names = [
+        ...Object.keys(declared.packages),
+        ...declared.aptPackages.map((name) => `apt:${name}`),
+        ...variables.map(({ name }) => name),
+    ];
+    if (names.length === 0)
+        console.log("(none: the agent runs this machine's commands)");
+    const width = Math.max(0, ...names.map((name) => name.length));
+    for (const [name, version] of Object.entries(declared.packages)) {
+        console.log(`${name.padEnd(width)}  ${version}`);
+    }
+    for (const name of declared.aptPackages)
+        console.log(`${`apt:${name}`.padEnd(width)}  (installed by the image)`);
+    // Whether each has a value here, never the value.
+    for (const { name, description } of variables) {
+        console.log(`${name.padEnd(width)}  ${(process.env[name] ? "set" : "not set").padEnd(8)}  ${description}`);
+    }
+}
+/**
+ * Install what context.json declares here, mise first when the agent has none (into its package.json): every package at
+ * the newest release its version allows, a newer one where one is out. Apt packages are the image's: one missing here
+ * is said, with how.
+ */
+export async function runEnvInstall() {
+    const agentDir = enterAgentHere();
+    await Promise.resolve()
+        .then(async () => {
+        const declared = loadEnvironment(agentDir) ?? NONE;
+        if (Object.keys(declared.packages).length > 0) {
+            await installPackages(agentDir, await checkedMise(agentDir, declared.packages), declared.packages, "all");
+            // Nothing in the agent directory changes, so `dev` does not restart: its PATH names the releases it started on.
+            log.info("[fastagent] a running `fastagent dev` keeps the releases it started with until it restarts");
+        }
+        const missing = missingAptPackages(declared.aptPackages);
+        if (missing && missing.length > 0)
+            log.warn(`[fastagent] ${aptAdvice(missing)}`);
+    })
+        .catch(failStartup);
+}
+export async function runEnvExec(command) {
+    const agentDir = enterAgentHere();
+    await enterEnvironment(agentDir).catch(failStartup);
+    const [program, ...args] = command;
+    const code = await new Promise((done, fail) => {
+        const child = spawn(program, args, { stdio: "inherit" });
+        child.on("error", fail);
+        child.on("close", (exit, signal) => done(exit ?? (signal ? 1 : 0)));
+    }).catch((error) => failStartup(error.code === "ENOENT" ? new Error(`${program}: command not found in the environment`) : error));
+    process.exit(code);
+}
+/**
+ * Change the declaration with `change`, checked as a whole. A package it adds or declares at another version is checked
+ * and installed first at the newest release its version allows, whatever older one this machine has, so a declared
+ * package is one that installs; what else it declares is installed when nothing here matches it. The declaration is
+ * then written under context.json's lock, `change` applied to it as it is by then, so two edits at once keep both.
+ * `change` is therefore called twice, and computes alone.
+ */
+async function edit(agentDir, change) {
+    // Read whole, as the write that follows is: a refused content entry stops the edit before anything is installed.
+    const current = readContextFile(agentDir).environment ?? NONE;
+    const next = declareEnvironment(change(current)) ?? NONE;
+    const added = Object.keys(next.packages).filter((name) => current.packages[name] !== next.packages[name]);
+    if (added.length > 0) {
+        await installPackages(agentDir, await checkedMise(agentDir, next.packages), next.packages, added);
+    }
+    return writeEnvironment(agentDir, (now) => declareEnvironment(change(now ?? NONE)) ?? NONE);
+}
+/** The refusal for a package `environment` does not declare, with what it does. */
+function noPackage(environment, name) {
+    const has = [...Object.keys(environment.packages), ...environment.aptPackages.map((apt) => `apt:${apt}`)];
+    return new Error(`the environment has no package "${name}" (it has: ${has.join(", ") || "none"})`);
+}
+/** The agent's mise (added when it has none), once `packages` pass: a refused one stops the command. */
+async function checkedMise(agentDir, packages) {
+    const bin = await ensureMise(agentDir);
+    const { refusals, runtime } = await checkPackages(agentDir, bin, packages);
+    if (refusals.length > 0)
+        throw new Error(refusals.join("\n"));
+    if (runtime)
+        log.warn(`[fastagent] ${runtimeAdvice(runtime)}`);
+    return bin;
+}

package/dist/cli/commands/info.js

@@ -1,182 +1,121 @@
-/** `fastagent info [dir] [--json]`: print what the directory ASSEMBLES into, WITHOUT booting a server. */
+/** `fastagent info [agent] [--json]`: print what the directory builds into, WITHOUT opening or serving the agent. */
 import { resolve } from "node:path";
+import { channelIngress } from "../../channels/discover.js";
+import { loadContent, loadEnvironment } from "../../content/file.js";
+import { contentAbsentHere, resolveContent } from "../../content/resolve.js";
+import { describeSecrets, missingSecrets } from "../../declared-secrets.js";
 import { enterAgentEnv } from "../../env.js";
-import { inspectChannels } from "../../channels/discover.js";
-import { loadConfig, providerOf, resolveModel, resolveModelSpec } from "../../engines/pi/config.js";
-import { machineModels } from "../../engines/pi/models.js";
-import { agentModels } from "../../engines/pi/agent-models.js";
-import { resolveSessionsDir, resolveStateRoot } from "../../paths.js";
-import { CODING_TOOL_NAMES, resolveAgentTools } from "../../engines/pi/create.js";
-import { loadAgentDefinition } from "../../engines/pi/definition.js";
-import { describeIndirectTools, describePrompt, reportFindingsIfChanged, reportToolCollisions, } from "../../engines/pi/report.js";
-import { allSecrets, describeSecrets, missingSecrets } from "../../declared-secrets.js";
-import { log } from "../../log.js";
-import { reportModuleLoadFailures } from "../../loader.js";
-import { readMachine, withMachine } from "../../engines/pi/machine.js";
+import { modelEnvironment } from "../../harnesses/models/environment.js";
+import { buildDefinition, modelSpecFor, prepareDefinition, secretsManifest } from "../../harnesses/pi-durable/open.js";
+import { readCommands } from "../../harnesses/pi-durable/text.js";
+import { resolveStateRoot } from "../../paths.js";
 import { nextRun } from "../../schedule/cron.js";
-import { loadRoutines } from "../../schedule/discover.js";
-import { failStartup, placementOrExit } from "../fail.js";
+import { contentLines } from "../content-view.js";
+import { agentDirOrExit, failStartup } from "../fail.js";
 export async function runInfo(dirArg, opts) {
-    const dir = resolve(dirArg);
-    const { agentDir, workspace } = placementOrExit(dir);
-    enterAgentEnv(agentDir); // skills/tools may read env — and fetch — at load time
-    const { config, path: configPath } = await loadConfig(agentDir).catch(failStartup);
-    const modelSpec = resolveModelSpec(opts.model, config);
-    // agentDir = where the agent lives (definition + config + machinery); workspace = what it works ON (its cwd, whose
-    // AGENTS.md ancestors are ② context).
-    const definition = await loadAgentDefinition(agentDir, { cwd: workspace }).catch(failStartup);
-    // What this agent HAS: the definition's skills and prompt templates plus the ones its machine lends (machine.ts).
-    const machineResources = await readMachine(workspace);
-    const skills = withMachine(definition.skills, machineResources.skills);
-    const prompts = withMachine(definition.prompts, machineResources.prompts);
-    // A tool that fails to load, for any reason (a missing dep, a top-level throw, or just not being a tool), is
-    // isolated the same way everywhere (G2).
-    const tools = await resolveAgentTools(config, agentDir, workspace)
-        .then((r) => ({
-        names: r.toolNames,
-        indirect: r.indirectTools,
-        collisions: r.toolCollisions,
-        failures: r.toolFailures,
-        secrets: allSecrets(r.toolSecrets),
-        error: undefined,
-    }))
-        .catch((e) => ({
-        names: [],
-        indirect: [],
-        collisions: [],
-        failures: [],
-        secrets: [],
-        error: e.message,
+    const agentDir = agentDirOrExit(resolve(dirArg));
+    enterAgentEnv(agentDir); // code may read its secrets, and fetch, when it is built
+    const definition = await prepareDefinition(agentDir).catch(failStartup);
+    const { config } = definition;
+    const modelSpec = modelSpecFor(config, opts.model);
+    const manifest = secretsManifest(definition);
+    const declared = manifest.flatMap(({ name, optional, declaredIn }) => declaredIn.map((source) => ({ name, optional, source })));
+    const unsetSecrets = missingSecrets(declared);
+    // Built only when every required secret has a value: building is what reads them. A module that is not what its
+    // directory holds is said as the refusal `dev` and `start` would stop on.
+    const code = unsetSecrets.length === 0
+        ? await Promise.resolve()
+            .then(() => buildDefinition(definition))
+            .catch(failStartup)
+        : undefined;
+    // Reported, not fatal: `info` is how an author finds out a content entry is missing, or the environment refused.
+    let content = [];
+    let contentAbsent = [];
+    let contentError;
+    try {
+        const declaration = loadContent(agentDir);
+        content = resolveContent(agentDir, declaration);
+        contentAbsent = contentAbsentHere(declaration);
+    }
+    catch (error) {
+        contentError = error.message;
+    }
+    // Read already, by the definition's secrets: a refused environment is a definition that does not open.
+    const environment = loadEnvironment(agentDir);
+    const models = await modelEnvironment(agentDir, {}, code?.providers ?? []);
+    const slash = modelSpec?.indexOf("/") ?? -1;
+    const modelError = modelSpec === undefined || models.models.getModel(modelSpec.slice(0, slash), modelSpec.slice(slash + 1))
+        ? undefined
+        : `no provider "${modelSpec.slice(0, Math.max(slash, 0))}" offers "${modelSpec.slice(slash + 1)}"`;
+    const channels = [...(code?.channels ?? new Map())].map(([name, module]) => ({
+        name,
+        ingress: channelIngress(module),
     }));
-    // IMPORTED, like tools and schedules: a channel's declared secrets are part of what this command
-    // exists to report (and a channel that cannot load is what `dev` would fail on next).
-    const inspected = await inspectChannels(agentDir).catch(failStartup);
-    const channels = inspected.channels.map((c) => c.name);
-    // Loaded (imported + validated), not just discovered.
-    const sched = await loadRoutines(agentDir).catch(failStartup);
-    // What the definition DECLARED it needs, and which of those have no value here. `info` reports
-    // (never asserts): it is the read-only view of the same list `dev`/`start` refuse to boot without
-    // and `deploy` requires a value for.
-    const declaredSecrets = [
-        ...tools.secrets,
-        ...allSecrets(sched.secrets),
-        ...allSecrets(inspected.secrets),
-    ];
-    const unsetSecrets = missingSecrets(declaredSecrets);
-    const routines = sched.routines.map((r) => ({
-        name: r.name,
-        cron: r.cron ?? null,
-        tz: r.tz ?? null,
-        // A routine with no cron has no next fire — it is reached by name (`POST /run`, `routine run`), which is a
-        // fact worth printing rather than a null to squint at.
-        next: r.cron === undefined ? null : (nextRun(r.cron, r.tz, new Date())?.toISOString() ?? null),
+    const schedules = (code?.schedules ?? []).map((s) => ({
+        name: s.name,
+        cron: s.cron,
+        tz: s.tz ?? null,
+        next: nextRun(s.cron, s.tz, new Date())?.toISOString() ?? null,
     }));
-    // The default sessions/auth paths WITHOUT creating anything (info is read-only; dev/start mkdir/login create them,
-    // info must not).
+    const commands = readCommands(agentDir).map(({ name, description }) => ({ name, description: description ?? null }));
     const stateRoot = resolveStateRoot(agentDir);
-    const sessionsDir = resolveSessionsDir(agentDir);
-    // Both layers: "what is this agent's state" is the question `info` answers, and a credential it runs on can live in
-    // a file the agent dir does not contain.
-    const models = agentModels(agentDir, {}, { cwd: workspace });
-    const { auth } = models;
-    // RESOLVE the spec, do not just echo it: a spec is only real once its provider/model exist in the agent's own
-    // surface (built-ins + its models.json), which is exactly what a custom endpoint changes.
-    const modelError = modelSpec
-        ? await models
-            .runtime()
-            .then((runtime) => {
-            resolveModel(runtime, modelSpec);
-            return undefined;
-        })
-            .catch((error) => error.message)
-        : undefined;
-    // The machine's own endpoints, which this agent inherits unless its models.json declares the same provider.
-    const machine = await machineModels(agentDir).then((value) => ({ value, error: undefined }), (error) => ({ value: undefined, error: error.message }));
-    const modelFromMachine = modelSpec !== undefined && machine.value?.inherited.includes(providerOf(modelSpec)) === true;
+    const auth = models.auth;
     if (opts.json) {
         console.log(JSON.stringify({
             agentDir,
-            workspace,
-            configPath: configPath ?? null,
+            name: definition.name,
+            content,
+            contentAbsent,
+            contentError: contentError ?? null,
+            environment: environment ?? null,
             model: modelSpec ?? null,
             modelError: modelError ?? null,
-            modelFromMachine,
-            machineModels: machine.value ?? null,
-            machineModelsError: machine.error ?? null,
             thinkingLevel: config.thinkingLevel ?? null,
-            codingTools: [...CODING_TOOL_NAMES],
-            context: definition.contextFiles.map((f) => f.path),
-            systemPrompt: definition.systemPrompt?.path ?? null,
-            appendSystemPrompt: definition.appendSystemPrompt?.path ?? null,
-            skills: skills.map((skill) => ({ name: skill.name, description: skill.description })),
-            prompts: prompts.map((prompt) => ({ name: prompt.name, description: prompt.description ?? null })),
-            tools: tools.names,
-            indirectTools: tools.indirect,
-            toolError: tools.error ?? null,
-            channels,
-            routines,
-            routineFailures: sched.failures,
-            channelFailures: inspected.failures,
+            tools: code?.tools.map(({ name }) => name) ?? null,
+            extensions: code?.extensions.map(({ name }) => name) ?? null,
+            channels: code === undefined ? null : channels,
+            schedules: code === undefined ? null : schedules,
+            commands,
+            secrets: manifest,
+            unsetSecrets: unsetSecrets.map(({ name }) => name),
             stateRoot,
-            sessionsDir,
-            authPath: auth.path,
-            fallbackAuthPath: auth.fallback ?? null,
-            diagnostics: definition.diagnostics,
-            skillCollisions: definition.collisions,
-            shadowed: definition.shadowed,
-            ignored: definition.ignored,
-            toolCollisions: tools.collisions,
-            toolFailures: tools.failures,
-            declaredSecrets,
-            unsetSecrets,
+            authPath: auth?.path ?? null,
+            fallbackAuthPath: auth?.fallback ?? null,
         }, null, 2));
         return;
     }
-    // One padded label writer, so labels stay aligned.
     const line = (label, value) => console.log(`${`${label}:`.padEnd(13)} ${value}`);
     /** A continuation under the previous line, aligned to the same column (no label, so no bare colon). */
     const cont = (value) => console.log(`${"".padEnd(13)} ${value}`);
-    line("agent", agentDir);
-    line("workspace", workspace);
-    line("config", configPath ?? "(none)");
-    line("model", modelSpec ?? "(not set — pass --model, set FASTAGENT_MODEL, or config.model)");
+    line("agent", `${definition.name} — ${agentDir}`);
+    for (const [label, value] of contentLines(content, contentAbsent))
+        line(label, value);
+    if (contentError)
+        cont(`⚠ ${contentError}`);
+    line("environment", environment ? describeEnvironment(environment) : "(none: the machine's commands)");
+    line("model", modelSpec ?? "(not set — pass --model, set FASTAGENT_MODEL, or model in fastagent.config.ts)");
     if (modelError)
         cont(`⚠ does not resolve: ${modelError}`);
-    if (modelFromMachine)
-        cont(`endpoint from the machine's ${machine.value?.path} (does not ship with a deploy)`);
     if (config.thinkingLevel)
         line("thinking", config.thinkingLevel);
-    line("codingTools", CODING_TOOL_NAMES.join(", "));
-    line("context", definition.contextFiles.map((f) => f.path).join(", ") || "(none)");
-    line("prompt", describePrompt(definition));
-    line("skills", skills.map((skill) => skill.name).join(", ") || "(none)");
-    line("prompts", prompts.map((prompt) => prompt.name).join(", ") || "(none)");
-    line("tools", tools.error ? "(could not load — see warning below)" : tools.names.join(", ") || "(none)");
-    if (tools.indirect.length > 0)
-        line("indirect", describeIndirectTools(tools.indirect));
-    line("channels", channels.join(", ") || "(none)");
-    line("routines", routines.map((r) => `${r.name} (${r.cron === null ? "on demand" : `next ${r.next ?? "never"}`})`).join(", ") ||
-        "(none)");
-    line("secrets", declaredSecrets.length > 0 ? describeSecrets(declaredSecrets) : "(none declared)");
-    if (unsetSecrets.length > 0)
-        cont(`⚠ dev/start refuse to boot until set: ${unsetSecrets.map((s) => s.name).join(", ")}`);
-    line("state", stateRoot);
-    line("sessions", sessionsDir);
-    line("auth", auth.fallback === undefined ? auth.path : `${auth.path} (then ${auth.fallback})`);
-    if (machine.error)
-        line("endpoints", `⚠ ${machine.error}`);
-    else if (machine.value) {
-        const { path, inherited, overridden } = machine.value;
-        const parts = [inherited.join(", ") || "(none inherited)"];
-        if (overridden.length > 0)
-            parts.push(`overridden by the agent: ${overridden.join(", ")}`);
-        line("endpoints", `${path}: ${parts.join("; ")}`);
+    const unbuilt = "(not built: a required secret has no value)";
+    line("tools", code ? code.tools.map(({ name }) => name).join(", ") || "(none)" : unbuilt);
+    if (code && code.extensions.length > 0)
+        line("extensions", code.extensions.map(({ name }) => name).join(", "));
+    line("channels", code ? channels.map((c) => `${c.name} (${c.ingress})`).join(", ") || "(none)" : unbuilt);
+    line("schedules", code ? schedules.map((s) => `${s.name} (next ${s.next ?? "never"})`).join(", ") || "(none)" : unbuilt);
+    line("commands", commands.map(({ name }) => `/${name}`).join(", ") || "(none)");
+    line("secrets", declared.length > 0 ? describeSecrets(declared) : "(none declared)");
+    if (unsetSecrets.length > 0) {
+        cont(`⚠ dev, start and deployments refuse to boot until set: ${unsetSecrets.map((s) => s.name).join(", ")}`);
     }
-    reportToolCollisions(tools.collisions);
-    reportModuleLoadFailures(tools.failures);
-    reportModuleLoadFailures(sched.failures);
-    reportModuleLoadFailures(inspected.failures);
-    if (tools.error)
-        log.warn(`[fastagent] ${tools.error}`);
-    reportFindingsIfChanged(definition.dir, definition);
+    line("state", stateRoot);
+    if (auth)
+        line("auth", auth.fallback === undefined ? auth.path : `${auth.path} (then ${auth.fallback})`);
+}
+/** The packages and apt packages an environment declares, as one line. */
+function describeEnvironment(environment) {
+    const packages = Object.entries(environment.packages).map(([name, version]) => `${name} ${version}`);
+    const apt = environment.aptPackages.map((name) => `apt:${name}`);
+    return [...packages, ...apt].join(", ") || "(none: the machine's commands)";
 }

package/dist/cli/commands/init.d.ts

@@ -1,7 +1,7 @@
 export interface InitOptions {
     /** false ⇔ `--no-install`. */
     install: boolean;
-    /** The agent directory's name inside `dir` — undefined = the default. */
-    agentDir?: string;
+    /** `--content` sources, each a directory the agent works on. */
+    content: string[];
 }
 export declare function runInit(dirArg: string, opts: InitOptions): Promise<void>;