@fastagent-sh/fastagent 0.21.1 → 0.22.1

package/dist/cli/commands/deploy.js

@@ -1,49 +1,24 @@
 import { preflightDeploy } from "../../deploy/preflight.js";
-import { loadConfig, resolveModelSpec } from "../../engines/pi/config.js";
+import { loadConfig } from "../../engines/pi/config.js";
 import { failStartup, failUsage } from "../fail.js";
 import { enterAgentCommand } from "../shared.js";
 import { agentcoreHost } from "./deploy/agentcore.js";
 import { dockerHost } from "./deploy/docker.js";
 import { flyHost } from "./deploy/fly.js";
 import { railwayHost } from "./deploy/railway.js";
-import { writeArtifacts } from "./deploy/shared.js";
-export { writeArtifacts };
-/** Every host, by the name the CLI takes. Typed over {@link DeployHost} so a host added to the list
- *  without a module here fails to compile. */
+import { applyArtifactPlan, planArtifacts } from "./deploy/shared.js";
+export { applyArtifactPlan, planArtifacts };
+/** Every host, by the name the CLI takes. */
 export const HOSTS = {
     docker: dockerHost,
     fly: flyHost,
     railway: railwayHost,
     agentcore: agentcoreHost,
 };
-/** Infers `Owner` from the literal's own `owner`, so each row carries its exhaustiveness itself. The
- *  alternative — annotating the array as a tuple of `HostOnlyFlag<"fly"> | …` — put the whole guarantee
- *  in one annotation that a third rule invites relaxing to `HostOnlyFlag<DeployHost>[]`, where
- *  `Exclude<DeployHost, DeployHost>` collapses to `never` and every `instead` type-checks empty. */
+/** Infers `Owner` from the literal's own `owner`, so each row carries its exhaustiveness itself. */
 const hostOnlyFlag = (rule) => rule;
-/**
- * ONE table for "this flag belongs to that host", because the fact is symmetric and was not stored
- * that way: each host branch stated the OTHER hosts' flags in its own words, so the same sentence
- * existed three times per flag and had already drifted (`Railway-only` twice, `railway-only` once).
- *
- * Every row is a flag that only WARNS elsewhere. `--tunnel` is host-only too and is deliberately not
- * here: it is a usage GATE (`failUsage`, exit 2) raised in `runDeploy`, not a warning — moving it in
- * would downgrade a refusal to a line of advice.
- *
- * Exported for the exhaustiveness test: the type stops a missing `instead` line, and the test stops it
- * from being typed away.
- */
+/** ONE table for "this flag belongs to that host", because the fact is symmetric and was not stored that way. */
 export const HOST_ONLY_FLAGS = [
-    hostOnlyFlag({
-        flag: "--stop/--no-scale-to-zero",
-        owner: "fly",
-        passed: (opts) => opts.stop === true || opts.scaleToZero === false,
-        instead: {
-            docker: "local Compose stays running",
-            railway: "Railway's App Sleeping is a dashboard toggle (the runbook states the manual step)",
-            agentcore: "AgentCore's idle/lifetime policy lives in the template's LifecycleConfiguration",
-        },
-    }),
     hostOnlyFlag({
         flag: "--into-linked",
         owner: "railway",
@@ -55,26 +30,23 @@ export const HOST_ONLY_FLAGS = [
         },
     }),
 ];
-/** Exported for its own test: nothing covered these six sentences, which is how three of them came to
- *  disagree about the spelling of a host name. */
+/**
+ * Exported for its own test: nothing covered these six sentences, which is how three of them came to disagree about
+ * the spelling of a host name.
+ */
 export function warnHostOnlyFlags(host, opts) {
     for (const rule of HOST_ONLY_FLAGS) {
         if (host === rule.owner || !rule.passed(opts))
             continue;
-        // The `continue` above is exactly the key set `instead` is typed over, but TS cannot narrow a
-        // union member out through a comparison against a per-rule literal, so the read needs a cast —
-        // and a cast is how a hole would reach the operator as the word "undefined". Unreachable while
-        // the rows stay exhaustive, which is what the table's own test asserts.
+        // The `continue` above is exactly the key set `instead` is typed over, but TS cannot narrow a union member out
+        // through a comparison against a per-rule literal, so the read needs a cast — and a cast is how a hole would
+        // reach the operator as the word "undefined".
         const instead = rule.instead[host];
-        // THROWN, not `failStartup`ed, though every other failure in this file exits through that: an
-        // incomplete table is a bug, and fail.ts prints a plain Error's message WITHOUT its stack (it
-        // reserves that shape for user-fixable problems) while exiting the process — which in the test
-        // that covers this table would kill the worker instead of reporting which row is short.
+        // THROWN, not `failStartup`ed, though every other failure in this file exits through that.
         if (instead === undefined) {
             throw new Error(`deploy: HOST_ONLY_FLAGS has no "instead" line for ${host} on ${rule.flag}`);
         }
-        // A colon, not "is": one row names a single flag and the other names a pair, and no verb agrees
-        // with both (the hand-written copies this replaced said "is" and "are" respectively).
+        // A colon, not "is": one row names a single flag and the other names a pair, and no verb agrees with both.
         console.error(`[fastagent] warn: ${rule.flag}: ${rule.owner}-only — ${instead}`);
     }
 }
@@ -83,28 +55,22 @@ export async function runDeploy(host, dirArg, opts) {
         // A flag/host combination the parser cannot see (host is an argument) — usage class, exit 2.
         failUsage(`deploy stopped: --tunnel is supported only by the local Docker target`);
     }
-    // The picker's write-back lands the model in fastagent.config.* — exactly what the model-travel
-    // gate below requires (--model/env don't reach the deployed box) — and an inline login stores the
-    // credential `--run` then carries. Runs BEFORE loadConfig; the read-back sees the rewritten file
-    // because loadConfig cache-busts on mtime (a failed write-back still gates, correctly).
+    // The picker's write-back lands the model in fastagent.config.ts.
     const placement = await enterAgentCommand(dirArg, opts);
-    // ONE deploy semantic: bake the WORKSPACE (WYSIWYG). Artifacts land under the agent dir
-    // (`fastagent/`) plus the one workspace-root `.dockerignore` the packers require; host CLIs run
-    // from the workspace, which is the build context.
+    // ONE deploy semantic: bake the WORKSPACE (WYSIWYG).
     const { agentDir, workspace } = placement;
     const { config } = await loadConfig(agentDir).catch(failStartup);
-    const modelSpec = resolveModelSpec(opts.model, config);
-    // The host-neutral pre-flight (model-travel gate, channel discovery, model-auth probe, container facts +
-    // their warnings) lives in deploy/preflight.ts — testable in isolation. The CLI prints its messages and
-    // stops on its gate; the host branch below adds only the host-specific artifacts + runbook + run drive.
+    // The host-neutral pre-flight (the model and its source, channel discovery, model-auth probe, container facts +
+    // their warnings) lives in deploy/preflight.ts.
     const pre = await preflightDeploy({
         placement,
         config,
-        modelSpec,
         run: !!opts.run,
         force: !!opts.force,
         externalClock: host === "agentcore", // cron rides EventBridge there — the resident-host notes don't apply
-        authPathFlag: opts.authPath, // flag > FASTAGENT_AUTH_PATH > default — resolved by preflight (one owner)
+        // AgentCore DOES get a public URL (the forwarder's, AuthType NONE) — but nothing of ours answers behind it:
+        // that relay reaches the channels' routes only, each verifying its platform's signature (agentcore-service.ts).
+        publicUrl: host !== "agentcore",
     }).catch(failStartup);
     if (!pre.ok)
         failStartup(new Error(`deploy stopped: ${pre.gate}`));
@@ -122,9 +88,21 @@ export async function runDeploy(host, dirArg, opts) {
         channels,
         webhookChannels: channels.filter((channel) => channel.ingress === "webhook"),
         longConnectionChannels: channels.filter((channel) => channel.ingress === "long-connection"),
-        // The ownership predicate is bound HERE, from the same lookup that chose the host, so no host
-        // module can pass one — the four that did each stated theirs twice, in a position where a
-        // neighbour's type-checks and silently makes `--force` a no-op for the host's own artifact.
-        write: (artifacts, options) => writeArtifacts(workspace, artifacts, { ...options, isOurs: target.isOurs }),
+        // The ownership predicate is bound HERE, from the same lookup that chose the host, so no host module can pass
+        // one.
+        // Reporting a stale artifact is enough when only generating them — the operator reads the line and decides. But
+        // `--run` would then deploy FROM it: a determinate mismatch between what ships and what the definition says,
+        // the same class as a Dockerfile that cannot read the manifest, and gated the
+        // same way. `--force` regenerates ours; a file we did not generate is never touched by either, and the marker
+        // line is how an operator takes a path back on purpose.
+        write: async (artifacts, options) => {
+            const plan = await planArtifacts(workspace, artifacts, { ...options, isOurs: target.isOurs });
+            if (opts.run && plan.stale.length > 0) {
+                failStartup(new Error(`deploy stopped: ${plan.stale.join(", ")} no longer match what this definition generates, and --run ` +
+                    `would deploy from them. Re-run with --force to regenerate, or remove each file's generated-by ` +
+                    `marker to own it yourself.`));
+            }
+            await applyArtifactPlan(plan);
+        },
     });
 }

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

@@ -0,0 +1,4 @@
+export interface DestroyOptions {
+    run?: boolean;
+}
+export declare function runDestroy(host: string, dirArg: string, opts: DestroyOptions): Promise<void>;

package/dist/cli/commands/destroy.js

@@ -0,0 +1,56 @@
+/** `fastagent destroy agentcore [dir]`: 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 { spawnRunner } from "../../deploy/runner.js";
+import { enterAgentEnv } from "../../env.js";
+import { failStartup, failUsage, placementOrExit } 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
+    // the other hosts' own commands. This stays as the seam: a host added to `choices` must not be silently
+    // 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 }, spawnRunner("aws", placement.workspace), (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.
+        if (outcome.found.length > 0) {
+            console.log(`what a deploy of "${name}" put in this account:`);
+            for (const item of outcome.found)
+                console.log(`  ${item}`);
+        }
+        if (outcome.removed.length > 0) {
+            console.log(`deleted before stopping:`);
+            for (const item of outcome.removed)
+                console.log(`  ${item}`);
+        }
+        // The kept bucket belongs in EVERY report: it is the one thing this command decided not to delete, and a
+        // failure elsewhere is no reason for the operator to stop hearing about it.
+        for (const item of outcome.kept)
+            console.log(`\nKEPT: ${item}`);
+        failStartup(new Error(`destroy stopped: ${outcome.gate}`));
+    }
+    if (!opts.run) {
+        if (outcome.found.length === 0) {
+            console.log(`nothing in this account for "${name}" — no stack, bucket, repository or log group.`);
+            return;
+        }
+        console.log(`what a deploy of "${name}" put in this account:`);
+        for (const item of outcome.found)
+            console.log(`  ${item}`);
+        for (const item of outcome.kept)
+            console.log(`  NOT MINE TO DELETE: ${item}`);
+        console.log(`\nnothing was deleted. Re-run with --run to delete all of it.`);
+        return;
+    }
+    console.log(outcome.removed.length > 0 ? `deleted:` : `nothing left to delete for "${name}".`);
+    for (const item of outcome.removed)
+        console.log(`  ${item}`);
+    for (const item of outcome.kept)
+        console.log(`\nKEPT: ${item}`);
+}

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

@@ -2,10 +2,11 @@ export interface DevOptions {
     port?: string;
     bind?: string;
     model?: string;
-    authPath?: string;
     /** 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

@@ -1,51 +1,48 @@
 /**
- * `fastagent dev`: a SUPERVISOR that spawns a worker (this command with FASTAGENT_DEV_WORKER set) to
- * assemble + serve, restarting it on agent edits. A fresh process per reload means what is served
- * is always the latest code, including modules a tool/config imports.
+ * `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 { setLogLevel } from "../../log.js";
 import { createPiAgentFromDir } from "../../engines/pi/open.js";
-import { mountAgentService } from "../../service.js";
+import { DEFAULT_HTTP_PORT, mountAgentService } from "../../service.js";
 import { logAgentLoop } from "../../observe.js";
 import { failStartup } from "../fail.js";
-import { assertTunnelBindable, cliMountOptions, resolveBindHost, serveService } from "../serve.js";
+import { assertTunnelBindable, cliMountOptions, serveService, withRunOverrides } 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
+ * networks its author does not own. `--bind 0.0.0.0` gives back the reach a container or a phone needs.
+ */
+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
     const isWorker = process.env.FASTAGENT_DEV_WORKER === "1";
-    // The model is picked ONCE, in the parent process (a TTY; watch and --no-watch both); a spawned
-    // worker inherits the choice through FASTAGENT_MODEL and must not prompt even when the pick was
-    // cancelled.
+    // 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 });
     if (isWorker || opts.watch === false) {
         await serveOnce(placement, 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. The worker repeats the check because `http.host` can supply the address instead.
-    assertTunnelBindable(parseBind(opts.bind), opts.tunnel ?? false, "flag");
+    // 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 });
 }
 /** Assemble the agent and serve it once (the dev worker; also the --no-watch path). */
 async function serveOnce(placement, opts) {
     const portFlag = parsePort(opts.port, "--port", "flag");
-    const bindFlag = parseBind(opts.bind);
+    const host = parseBind(opts.bind) ?? DEV_BIND;
     const tunnel = opts.tunnel ?? false;
-    const a = await createPiAgentFromDir(placement.workspace, {
+    assertTunnelBindable(host, tunnel);
+    const a = await createPiAgentFromDir(placement.agentDir, {
         model: opts.model,
-        authPath: opts.authPath, // flag > FASTAGENT_AUTH_PATH > default — resolved by the opener (one owner)
-        serving: true, // long-running serve: the scheduler poller runs (wake mounts iff config.selfSchedule)
+        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, { beforeModel: [["config", a.configPath ?? "(none)"]] });
-    const host = resolveBindHost(bindFlag, a.config.http?.host, tunnel);
-    // The SAME assembly an embedder gets from `createAgentService` — channels, control plane,
-    // schedules, long connections. `dev` opens the directory itself only because its startup report
-    // prints the opened values before anything mounts. The turn trace (tool calls + reply) logs at
-    // debug level: shown here, gated out in start (level info), keeping end-user content out of
-    // production logs.
-    const service = await mountAgentService(a, cliMountOptions(logAgentLoop)).catch(failStartup);
-    serveService(service, { port: portFlag ?? a.config.http?.port ?? 8787, host }, { tunnel, agentDir: a.agentDir, stateRoot: a.stateRoot });
+    // 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 });
 }

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

@@ -1,7 +1,5 @@
 export interface InfoOptions {
     json?: boolean;
     model?: string;
-    authPath?: string;
-    sessionsDir?: string;
 }
 export declare function runInfo(dirArg: string, opts: InfoOptions): Promise<void>;

package/dist/cli/commands/info.js

@@ -1,37 +1,40 @@
-/** `fastagent info [dir] [--json]`: print what the directory ASSEMBLES into, WITHOUT booting a server. Read-only. */
+/** `fastagent info [dir] [--json]`: print what the directory ASSEMBLES into, WITHOUT booting a server. */
 import { resolve } from "node:path";
-import { loadDotEnv } from "../../env.js";
-import { discoverChannelFiles } from "../../channels/discover.js";
-import { defaultSessionsDir, loadConfig, resolveAuthPath, resolveModel, resolveModelSpec, resolveSessionsDirOverride, } from "../../engines/pi/config.js";
-import { createPiModelRuntime } from "../../engines/pi/models.js";
-import { resolveStateRoot, workspaceHint } from "../../paths.js";
+import { enterAgentEnv } from "../../env.js";
+import { inspectChannels } from "../../channels/discover.js";
+import { loadConfig, providerOf, resolveAuthLayers, resolveModel, resolveModelSpec } from "../../engines/pi/config.js";
+import { createPiModelRuntime, machineModels } from "../../engines/pi/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 { 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 { nextRun } from "../../schedule/cron.js";
-import { loadSchedules } from "../../schedule/discover.js";
+import { loadRoutines } from "../../schedule/discover.js";
 import { failStartup, placementOrExit } from "../fail.js";
 export async function runInfo(dirArg, opts) {
     const dir = resolve(dirArg);
     const { agentDir, workspace } = placementOrExit(dir);
-    loadDotEnv(agentDir); // skills/tools may read env at load time
+    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).
+    // 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);
-    // 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): info, dev, AND start report it and keep going with
-    // the tools that loaded. The `error`/`.catch` below only fires for a whole-load fault (an unreadable
-    // tools/ dir), not a single bad file.
+    // What this agent HAS: the definition's skills plus the ones its machine lends (machine.ts).
+    const skills = withMachine(definition.skills, (await readMachine(workspace)).skills);
+    // 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,
         deferred: r.deferredToolNames,
         collisions: r.toolCollisions,
         failures: r.toolFailures,
+        secrets: allSecrets(r.toolSecrets),
         error: undefined,
     }))
         .catch((e) => ({
@@ -39,38 +42,52 @@ export async function runInfo(dirArg, opts) {
         deferred: [],
         collisions: [],
         failures: [],
+        secrets: [],
         error: e.message,
     }));
-    const channels = await discoverChannelFiles(agentDir).catch(failStartup);
-    // Loaded (imported + validated), not just discovered: info's job is "fix only what it reports", so a
-    // broken schedule file (bad cron/tz, failed import) must show up HERE, not first at dev/start — and
-    // loading is what makes the next fire instant printable. Consistent with tools (info imports those too).
-    const sched = await loadSchedules(agentDir).catch(failStartup);
-    const schedules = sched.schedules.map((s) => ({
-        name: s.name,
-        cron: s.cron,
-        tz: s.tz ?? null,
-        next: nextRun(s.cron, s.tz, new Date())?.toISOString() ?? null,
+    // 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),
     }));
-    // The default sessions/auth paths WITHOUT creating anything (info is read-only; dev/start mkdir/login
-    // create them, info must not).
+    // The default sessions/auth paths WITHOUT creating anything (info is read-only; dev/start mkdir/login create them,
+    // info must not).
     const stateRoot = resolveStateRoot(agentDir);
-    const sessionsDir = resolveSessionsDirOverride(opts.sessionsDir) ?? defaultSessionsDir(stateRoot);
-    const authPath = resolveAuthPath(agentDir, opts.authPath); // flag > FASTAGENT_AUTH_PATH > default — the one owner
-    // 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.
-    // Reporting a healthy-looking spec that `dev`/`start` then reject is the failure this pre-empts.
-    // Reported as DATA rather than thrown — a broken agent is what `info` is for — and read-only: the
-    // runtime reads models.json without creating anything (its catalog cache is written on refresh, and
-    // there is none here).
+    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 auth = resolveAuthLayers(agentDir);
+    // 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 createPiModelRuntime({ agentDir, authPath })
+        ? await createPiModelRuntime({ agentDir, auth })
             .then((models) => {
             resolveModel(models, 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;
     if (opts.json) {
         console.log(JSON.stringify({
             agentDir,
@@ -78,60 +95,77 @@ export async function runInfo(dirArg, opts) {
             configPath: configPath ?? 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),
             persona: definition.persona !== undefined,
-            skills: definition.skills.map((skill) => ({ name: skill.name, description: skill.description })),
+            skills: skills.map((skill) => ({ name: skill.name, description: skill.description })),
             tools: tools.names,
             deferredTools: tools.deferred,
             toolError: tools.error ?? null,
             channels,
-            schedules,
-            scheduleFailures: sched.failures,
-            selfSchedule: config.selfSchedule ?? false,
+            routines,
+            routineFailures: sched.failures,
+            channelFailures: inspected.failures,
             stateRoot,
             sessionsDir,
-            authPath,
+            authPath: auth.path,
+            fallbackAuthPath: auth.fallback ?? null,
             diagnostics: definition.diagnostics,
             skillCollisions: definition.collisions,
             toolCollisions: tools.collisions,
             toolFailures: tools.failures,
+            declaredSecrets,
+            unsetSecrets,
         }, null, 2));
         return;
     }
-    // One padded label writer: hand-spaced labels drifted out of alignment the moment a longer one
-    // (agent/workspace/selfSchedule) joined the report.
+    // 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);
-    const hint = workspaceHint({ agentDir, workspace });
-    if (hint)
-        line("hint", hint);
     line("config", configPath ?? "(none)");
     line("model", modelSpec ?? "(not set — pass --model, set FASTAGENT_MODEL, or config.model)");
     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("persona", definition.persona ? "persona.md" : "(none)");
-    line("skills", definition.skills.map((skill) => skill.name).join(", ") || "(none)");
+    line("skills", skills.map((skill) => skill.name).join(", ") || "(none)");
     line("tools", tools.error ? "(could not load — see warning below)" : tools.names.join(", ") || "(none)");
     if (tools.deferred.length > 0)
         line("deferred", `${tools.deferred.join(", ")} (activated via search_tools)`);
     line("channels", channels.join(", ") || "(none)");
-    line("schedules", schedules.map((s) => `${s.name} (next ${s.next ?? "never"})`).join(", ") || "(none)");
-    line("selfSchedule", config.selfSchedule ? "on (mounts the wake tool when serving)" : "off");
+    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", authPath);
+    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("; ")}`);
+    }
     reportToolCollisions(tools.collisions);
     reportModuleLoadFailures(tools.failures);
     reportModuleLoadFailures(sched.failures);
+    reportModuleLoadFailures(inspected.failures);
     if (tools.error)
         log.warn(`[fastagent] ${tools.error}`);
     reportFindingsIfChanged(definition.dir, definition);

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

@@ -1,8 +1,7 @@
 export interface InitOptions {
-    minimal: boolean;
     /** false ⇔ `--no-install`. */
     install: boolean;
-    /** The agent directory's name inside `dir` — undefined = the default, `"."` = `dir` itself (`--flat`). */
+    /** The agent directory's name inside `dir` — undefined = the default. */
     agentDir?: string;
 }
 export declare function runInit(dirArg: string, opts: InitOptions): Promise<void>;