@fastagent-sh/fastagent 0.29.0 → 0.30.1

package/dist/content/declare.js

@@ -1,18 +1,18 @@
 /**
- * WHAT AN AUTHOR DECLARES an agent works on, read and refused in ONE place (file.ts reads the files through
- * it): the `content` map of `context.json`, which is shared and so holds only repositories every instance reaches, and
- * the `content` map of `context.local.json`, the directories of this machine it is bound to. Pure: what is on the disk
- * is resolve.ts's question. docs/design/agent-model.md §3 is the rule.
+ * WHAT AN AGENT WORKS ON, declared and refused in ONE place (file.ts reads the files through it): the `content` map of
+ * the program's `context.json`, which holds only repositories every instance reaches, and the `content` map of an
+ * instance's `fastagent.json`, which adds repositories and directories of its own. An instance only adds: a name the
+ * program declares is not one it may take. Pure: what is on the disk is resolve.ts's question.
+ * docs/design/agent-artifact.md §3.3 and §4.2 are the rule.
  */
-import { homedir } from "node:os";
-import { isAbsolute, join, resolve } from "node:path";
-import { CONTEXT_FILE, LOCAL_CONTEXT_FILE, isUnderDir } from "../paths.js";
+import { isAbsolute } from "node:path";
+import { CONTEXT_FILE, configurationPath, isUnderDir } from "../paths.js";
 /**
- * The keys an entry and a binding carry, in the order they are written: where it is, then how it is treated. One list
- * each, so a key the reader accepts is one the writer keeps.
+ * The keys an entry carries, in the order they are written: where it is, then how it is treated. One list each, so a
+ * key the reader accepts is one the writer keeps.
  */
-const ENTRY_KEYS = ["github", "ref", "description"];
-const BINDING_KEYS = ["path", "description"];
+const GITHUB_KEYS = ["github", "ref", "description"];
+const PATH_KEYS = ["path", "description"];
 /** A name becomes a directory name, so it is one path segment (the spelling a release's agent name has). */
 const NAME = /^[A-Za-z0-9_-]+$/;
 /** Whether `name` can name a content entry. */
@@ -24,13 +24,9 @@ const GITHUB_REPO = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
 export function isGithubRepo(repo) {
     return GITHUB_REPO.test(repo);
 }
-/** `entry` with its keys in {@link ENTRY_KEYS} order: the form written. */
+/** `entry` with its keys in the order they are written. */
 export function canonicalEntry(entry) {
-    return pick(entry, ENTRY_KEYS);
-}
-/** `binding` with its keys in {@link BINDING_KEYS} order: the form written. */
-export function canonicalBinding(binding) {
-    return pick(binding, BINDING_KEYS);
+    return pick(entry, "github" in entry ? GITHUB_KEYS : PATH_KEYS);
 }
 function pick(value, keys) {
     const out = {};
@@ -41,42 +37,26 @@ function pick(value, keys) {
     }
     return out;
 }
-/** Read `context.json`'s `content` map (undefined is none). Every refusal names the entry; nothing is defaulted. */
-export function declareContent(raw) {
-    return entriesByName(raw).map(([name, entry]) => declareOne(name, entry));
+/**
+ * Read a `content` map (undefined is none) from `from`. Every refusal names the entry; nothing is defaulted. The
+ * program's declares repositories only, since it is shared; an instance's may name a directory too.
+ */
+export function declareContent(raw, from) {
+    return entriesByName(raw).map(([name, entry]) => declareOne(name, entry, from));
 }
 /**
- * Read `context.local.json`'s `content` map (undefined is none) beside `declared`, with relative paths resolved against
- * `agentDir`. A binding under a declared entry's name is that entry's checkout here; any other is a directory of this
- * machine alone.
+ * The program's entries and the instance's, as one list. An instance only adds: a name both declare (ignoring case,
+ * as names are a directory) is refused, naming both, so nothing is shadowed.
  */
-export function declareBindings(raw, declared, agentDir) {
-    return entriesByName(raw).map(([name, binding]) => {
-        const at = `content "${name}"`;
-        const e = objectWithKeys(at, binding, BINDING_KEYS);
-        if (typeof e.path !== "string" || e.path === "")
-            throw new Error(`${at}: "path" must be a non-empty string`);
-        const path = absolutePath(e.path, agentDir);
-        const shared = declared.find((entry) => entry.name.toLowerCase() === name.toLowerCase());
-        if (shared !== undefined) {
-            if (shared.name !== name) {
-                throw new Error(`${at} binds the entry ${CONTEXT_FILE} names "${shared.name}": spell it the same`);
-            }
-            if (e.description !== undefined) {
-                throw new Error(`${at} binds this machine's checkout of the entry ${CONTEXT_FILE} declares, which says "description" for ` +
-                    `every instance: give it only "path"`);
-            }
-            return { name, path, kind: "checkout" };
+export function joinContent(program, instance) {
+    for (const added of instance) {
+        const taken = program.find((entry) => entry.name.toLowerCase() === added.name.toLowerCase());
+        if (taken !== undefined) {
+            throw new Error(`content "${added.name}" is declared by the program (${CONTEXT_FILE} names "${taken.name}") and by the ` +
+                `instance: an instance adds to the program's content and does not replace it — name it otherwise`);
         }
-        const description = descriptionOf(at, e);
-        return { name, path, kind: "local", ...(description !== undefined ? { description } : {}) };
-    });
-}
-/** `path` as written in `context.local.json`, absolute: `~/` is the home directory, a relative one the agent's. */
-function absolutePath(path, agentDir) {
-    if (path === "~" || path.startsWith("~/"))
-        return join(homedir(), path.slice(1));
-    return isAbsolute(path) ? resolve(path) : resolve(agentDir, path);
+    }
+    return [...program, ...instance];
 }
 /** The entries of a `content` map, each name checked, unique ignoring case. */
 function entriesByName(raw) {
@@ -110,24 +90,43 @@ function objectWithKeys(at, value, keys) {
     }
     return e;
 }
-function descriptionOf(at, e) {
-    if (e.description !== undefined && (typeof e.description !== "string" || e.description === "")) {
-        throw new Error(`${at}: "description" must be a non-empty string`);
+/** `path` as written in an instance configuration, absolute: `~/` is the home directory, a relative one `base`'s. */
+function absolutePath(path, from, at) {
+    const absolute = configurationPath(path, from.base);
+    if (absolute === undefined) {
+        throw new Error(`${at}: "path" must be absolute here, since ${from.file} is not a file its directory could anchor`);
     }
-    return e.description;
+    return absolute;
 }
-function declareOne(name, entry) {
+function declareOne(name, entry, from) {
     const at = `content "${name}"`;
-    const e = objectWithKeys(at, entry, ENTRY_KEYS);
-    for (const key of ["github", "ref"]) {
+    const e = objectWithKeys(at, entry, [...GITHUB_KEYS, "path"]);
+    if (from.origin === "program" && e.path !== undefined) {
+        throw new Error(`${at}: ${from.file} is shared, so it declares only the repositories every instance reaches — add a directory ` +
+            `to the instance's configuration instead (fastagent content add <dir>)`);
+    }
+    for (const key of ["github", "ref", "path"]) {
         if (e[key] !== undefined && (typeof e[key] !== "string" || e[key] === "")) {
             throw new Error(`${at}: "${key}" must be a non-empty string`);
         }
     }
-    const description = descriptionOf(at, e);
+    if (e.description !== undefined && (typeof e.description !== "string" || e.description === "")) {
+        throw new Error(`${at}: "description" must be a non-empty string`);
+    }
+    const base = {
+        name,
+        origin: from.origin,
+        ...(e.description !== undefined ? { description: e.description } : {}),
+    };
+    if (e.github !== undefined && e.path !== undefined)
+        throw new Error(`${at} names both "github" and "path": give one`);
+    if (e.path !== undefined) {
+        if (e.ref !== undefined)
+            throw new Error(`${at}: "ref" applies to a repository, and ${at} is a directory`);
+        return { ...base, kind: "local", path: absolutePath(e.path, from, at) };
+    }
     if (e.github === undefined) {
-        throw new Error(`${at} needs "github": ${CONTEXT_FILE} is shared, so it declares only what every instance reaches — bind a ` +
-            `directory of this machine in ${LOCAL_CONTEXT_FILE} instead (fastagent content add <dir>)`);
+        throw new Error(`${at} needs "github"${from.origin === "instance" ? ' or "path"' : ""}`);
     }
     const repo = e.github;
     if (!isGithubRepo(repo))
@@ -136,7 +135,7 @@ function declareOne(name, entry) {
     // git reads a leading "-" as an option, and no branch, tag or commit name has one.
     if (ref?.startsWith("-"))
         throw new Error(`${at}: "ref" must name a branch, tag or commit, got "${ref}"`);
-    return { name, repo, ...(ref !== undefined ? { ref } : {}), ...(description !== undefined ? { description } : {}) };
+    return { ...base, kind: "github", repo, ...(ref !== undefined ? { ref } : {}) };
 }
 /**
  * A directory the agent is bound to and the agent directory are kept apart (agent-model.md §2): a definition is

package/dist/content/file.d.ts

@@ -1,32 +1,43 @@
 import { type DeclaredEnvironment } from "../environment/declare.ts";
-import { type BoundContent, type ContentBinding, type ContentDeclaration, type ContentEntry, type DeclaredContent } from "./declare.ts";
+import { type ContentEntry, type DeclaredContent } from "./declare.ts";
 /** `context.json` as read: the content entries as written and as declared, and the environment. */
 export interface ContextFile {
     $schema?: string;
     content: Record<string, ContentEntry>;
     declared: DeclaredContent[];
     environment?: DeclaredEnvironment;
-}
-/** `context.local.json` as read: the bindings as written and as declared. */
-export interface LocalContextFile {
-    content: Record<string, ContentBinding>;
-    bound: BoundContent[];
+    /** The program's MCP servers as written. Their shape is the MCP reader's to check; an edit keeps them as they are. */
+    mcpServers?: Record<string, unknown>;
 }
 /** Read `text`, the contents of `path`, whole: what an edit, which writes the whole, reads. */
 export declare function parseContextFile(text: string, path: string): ContextFile;
-/** Read `text`, the contents of `path`, whole, beside the entries `context.json` declares. */
-export declare function parseLocalContextFile(text: string, path: string, declared: readonly DeclaredContent[], agentDir: string): LocalContextFile;
 /** The agent's `context.json`, read whole. */
 export declare function readContextFile(agentDir: string): ContextFile;
-/** The content of the agent in `agentDir`: what `context.json` declares, and what this machine binds. */
-export declare function loadContent(agentDir: string): ContentDeclaration;
+/** The instance configuration's content, as far as this reads it: its `content` map and where it is from. */
+export interface InstanceContent {
+    values: unknown;
+    label: string;
+    /** The configuration file's directory, which a relative `path` is relative to. */
+    directory?: string;
+}
+/**
+ * The content of the agent whose program is in `agentDir`: what its `context.json` declares, and what `instance` adds
+ * to it (an instance only adds: a name both declare is refused).
+ */
+export declare function loadContent(agentDir: string, instance?: InstanceContent): DeclaredContent[];
+/** What an instance configuration's `content` declares. */
+export declare function instanceContent({ values, label, directory }: InstanceContent): DeclaredContent[];
 /** The environment the agent in `agentDir` declares, or undefined when it declares none. */
 export declare function loadEnvironment(agentDir: string): DeclaredEnvironment | undefined;
+/** The program's `mcpServers` map as written in `context.json`, and the file's path, which names it in a refusal. */
+export declare function readProgramMcpServers(agentDir: string): {
+    values: unknown;
+    path: string;
+};
 /** The text `context.json` is written as. An environment that declares nothing is left out. */
 export declare function contextFileText(file: {
     $schema?: string;
     content: Record<string, ContentEntry>;
     environment?: DeclaredEnvironment;
+    mcpServers?: Record<string, unknown>;
 }): string;
-/** The text `context.local.json` is written as. */
-export declare function localContextFileText(content: Record<string, ContentBinding>): string;

package/dist/content/file.js

@@ -1,19 +1,19 @@
 /**
- * The agent's `context.json` and this machine's `context.local.json`, read in ONE place, so the opener, `info`,
- * `content list`, `env`, `tool` and deploy read one declaration; and the one shape each is written in. A reader
- * declares the part it uses (its content, or its environment), so a part that is refused stops what uses it and is
- * reported where it is, not as the other's; an edit declares the whole, since it writes the whole. JSON, like
- * `mcp.json` and `package.json`, so a command, a client or the agent itself can edit it without touching TypeScript.
+ * The program's `context.json` and the content an instance's configuration adds, read in ONE place, so the opener,
+ * `info`, `content list`, `env`, `tool` and deploy read one declaration; and the one shape `context.json` is written
+ * in. A reader declares the part it uses (its content, or its environment), so a part that is refused stops what uses
+ * it and is reported where it is, not as the other's; an edit declares the whole, since it writes the whole. JSON,
+ * like `mcp.json` and `package.json`, so a command, a client or the agent itself can edit it without touching
+ * TypeScript.
  */
 import { readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
-import { CONTEXT_FILE, LOCAL_CONTEXT_FILE } from "../paths.js";
+import { CONTEXT_FILE } from "../paths.js";
 import { declareEnvironment } from "../environment/declare.js";
-import { declareBindings, declareContent, } from "./declare.js";
-const FILE_KEYS = ["$schema", "content", "environment"];
-const LOCAL_FILE_KEYS = ["content"];
+import { declareContent, joinContent } from "./declare.js";
+const FILE_KEYS = ["$schema", "content", "environment", "mcpServers"];
 /** `text`, the contents of `path`, as the object a context file is: refused when the file itself is wrong. */
-function parseFile(text, path, keys = FILE_KEYS) {
+function parseFile(text, path) {
     let raw;
     try {
         raw = JSON.parse(text);
@@ -25,12 +25,17 @@ function parseFile(text, path, keys = FILE_KEYS) {
         throw new Error(`${path} must hold a JSON object`);
     const file = raw;
     for (const key of Object.keys(file)) {
-        if (!keys.includes(key))
-            throw new Error(`${path}: unknown key "${key}" (valid keys: ${keys.join(", ")})`);
+        if (!FILE_KEYS.includes(key)) {
+            throw new Error(`${path}: unknown key "${key}" (valid keys: ${FILE_KEYS.join(", ")})`);
+        }
     }
     if (file.$schema !== undefined && typeof file.$schema !== "string") {
         throw new Error(`${path}: "$schema" must be a string`);
     }
+    if (file.mcpServers !== undefined &&
+        (typeof file.mcpServers !== "object" || file.mcpServers === null || Array.isArray(file.mcpServers))) {
+        throw new Error(`${path}: "mcpServers" must be an object of servers by name`);
+    }
     return file;
 }
 /** One part of `context.json` at `path`, declared by `declare`; its refusal names the file. */
@@ -45,24 +50,19 @@ function declarePart(path, declare) {
 /** Read `text`, the contents of `path`, whole: what an edit, which writes the whole, reads. */
 export function parseContextFile(text, path) {
     const file = parseFile(text, path);
-    const declared = declarePart(path, () => declareContent(file.content));
+    const declared = declarePart(path, () => declareContent(file.content, { origin: "program", file: CONTEXT_FILE }));
     const environment = declarePart(path, () => declareEnvironment(file.environment));
     return {
         ...(file.$schema !== undefined ? { $schema: file.$schema } : {}),
         content: (file.content ?? {}),
         declared,
         ...(environment !== undefined ? { environment } : {}),
+        ...(file.mcpServers !== undefined ? { mcpServers: file.mcpServers } : {}),
     };
 }
-/** Read `text`, the contents of `path`, whole, beside the entries `context.json` declares. */
-export function parseLocalContextFile(text, path, declared, agentDir) {
-    const file = parseFile(text, path, LOCAL_FILE_KEYS);
-    const bound = declarePart(path, () => declareBindings(file.content, declared, resolve(agentDir)));
-    return { content: (file.content ?? {}), bound };
-}
-/** The agent's context file `name` and its path, or undefined text when it has none (it declares nothing). */
-function contextFileAt(agentDir, name = CONTEXT_FILE) {
-    const path = join(resolve(agentDir), name);
+/** The agent's `context.json` and its path, or undefined text when it has none (it declares nothing). */
+function contextFileAt(agentDir) {
+    const path = join(resolve(agentDir), CONTEXT_FILE);
     try {
         return { path, text: readFileSync(path, "utf8") };
     }
@@ -77,16 +77,25 @@ export function readContextFile(agentDir) {
     const { path, text } = contextFileAt(agentDir);
     return text === undefined ? { content: {}, declared: [] } : parseContextFile(text, path);
 }
-/** This machine's `context.local.json` for the agent in `agentDir`, read whole, beside what it `declared`. */
-function readLocalContextFile(agentDir, declared) {
-    const { path, text } = contextFileAt(agentDir, LOCAL_CONTEXT_FILE);
-    return text === undefined ? { content: {}, bound: [] } : parseLocalContextFile(text, path, declared, agentDir);
-}
-/** The content of the agent in `agentDir`: what `context.json` declares, and what this machine binds. */
-export function loadContent(agentDir) {
+/**
+ * The content of the agent whose program is in `agentDir`: what its `context.json` declares, and what `instance` adds
+ * to it (an instance only adds: a name both declare is refused).
+ */
+export function loadContent(agentDir, instance) {
     const { path, text } = contextFileAt(agentDir);
-    const declared = text === undefined ? [] : declarePart(path, () => declareContent(parseFile(text, path).content));
-    return { declared, bound: readLocalContextFile(agentDir, declared).bound };
+    const program = text === undefined
+        ? []
+        : declarePart(path, () => declareContent(parseFile(text, path).content, { origin: "program", file: CONTEXT_FILE }));
+    return joinContent(program, instance === undefined ? [] : instanceContent(instance));
+}
+/** What an instance configuration's `content` declares. */
+export function instanceContent({ values, label, directory }) {
+    const content = typeof values === "object" && values !== null ? values.content : undefined;
+    return declarePart(label, () => declareContent(content, {
+        origin: "instance",
+        file: label,
+        ...(directory === undefined ? {} : { base: directory }),
+    }));
 }
 /** The environment the agent in `agentDir` declares, or undefined when it declares none. */
 export function loadEnvironment(agentDir) {
@@ -96,6 +105,11 @@ export function loadEnvironment(agentDir) {
     const file = parseFile(text, path);
     return declarePart(path, () => declareEnvironment(file.environment));
 }
+/** The program's `mcpServers` map as written in `context.json`, and the file's path, which names it in a refusal. */
+export function readProgramMcpServers(agentDir) {
+    const { path, text } = contextFileAt(agentDir);
+    return { values: text === undefined ? undefined : parseFile(text, path).mcpServers, path };
+}
 /** The text `context.json` is written as. An environment that declares nothing is left out. */
 export function contextFileText(file) {
     const packages = file.environment?.packages ?? {};
@@ -110,10 +124,9 @@ export function contextFileText(file) {
         ...(file.$schema !== undefined ? { $schema: file.$schema } : {}),
         content: file.content,
         ...(Object.keys(environment).length > 0 ? { environment } : {}),
+        ...(file.mcpServers !== undefined && Object.keys(file.mcpServers).length > 0
+            ? { mcpServers: file.mcpServers }
+            : {}),
     };
     return `${JSON.stringify(out, null, 2)}\n`;
 }
-/** The text `context.local.json` is written as. */
-export function localContextFileText(content) {
-    return `${JSON.stringify({ content }, null, 2)}\n`;
-}

package/dist/content/git.d.ts

@@ -8,16 +8,6 @@ export declare function checkoutOf(dir: string): {
     root: string;
     origin?: string;
 } | undefined;
-/**
- * Why the directory `local` cannot stand for github `repo` on this machine, or undefined when it can: it is the root
- * of a checkout whose `origin` is that repository.
- */
-export declare function checkoutProblem(local: string, repo: string): string | undefined;
-/**
- * What to say when the checkout `dir` is not at `ref`, or undefined when it is: on that branch, or at the commit `ref`
- * names. FastAgent never moves a checkout the user owns, so this is said, not acted on.
- */
-export declare function refNotice(dir: string, ref: string): string | undefined;
 /**
  * What a start did with a clone: made it, moved it to what the remote has now, found it there already, or kept it as
  * it is, for the `reason` given (git refused to touch the agent's work, or the remote could not be reached).

package/dist/content/git.js

@@ -3,11 +3,11 @@
  * `ref`, and a clone, made or brought up to date in place. git's own configuration applies throughout (credential helpers, `url.<base>.insteadOf`), so
  * a private repository is reached the way the user's own `git clone` reaches it.
  */
-import { existsSync, mkdirSync, realpathSync, renameSync, rmSync, statSync } from "node:fs";
+import { existsSync, mkdirSync, renameSync, rmSync, statSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { gitFor } from "../git.js";
 const WHY = "github content needs it on this machine";
-const { answer: gitAnswer } = gitFor(WHY);
+const { answer: checkoutAnswer } = gitFor(WHY);
 /** The `owner/repo` a GitHub remote URL names, in any of its spellings (https, ssh, scp-like), or undefined. */
 export function githubRepoOf(url) {
     const match = /^(?:(?:https?|git|ssh):\/\/(?:[^@/]+@)?github\.com\/|(?:[^@/:]+@)?github\.com:)([\w.-]+)\/([\w.-]+?)(?:\.git)?\/?$/i.exec(url.trim());
@@ -24,46 +24,12 @@ function githubUrl(repo) {
 export function checkoutOf(dir) {
     if (!existsSync(dir) || !statSync(dir).isDirectory())
         return undefined;
-    const root = gitAnswer(["rev-parse", "--show-toplevel"], dir);
+    const root = checkoutAnswer(["rev-parse", "--show-toplevel"], dir);
     if (root === undefined)
         return undefined;
-    const origin = gitAnswer(["config", "--get", "remote.origin.url"], root);
+    const origin = checkoutAnswer(["config", "--get", "remote.origin.url"], root);
     return { root, ...(origin ? { origin } : {}) };
 }
-/**
- * Why the directory `local` cannot stand for github `repo` on this machine, or undefined when it can: it is the root
- * of a checkout whose `origin` is that repository.
- */
-export function checkoutProblem(local, repo) {
-    if (!existsSync(local))
-        return "does not exist";
-    const checkout = checkoutOf(local);
-    if (checkout === undefined)
-        return "is not a git checkout";
-    if (realpathSync(checkout.root) !== realpathSync(local))
-        return `is inside the checkout ${checkout.root}, not its root`;
-    const of = checkout.origin === undefined ? undefined : githubRepoOf(checkout.origin);
-    if (of?.toLowerCase() !== repo.toLowerCase()) {
-        return `is a checkout of ${checkout.origin ?? "no origin"}, not of github ${repo}`;
-    }
-    return undefined;
-}
-/**
- * What to say when the checkout `dir` is not at `ref`, or undefined when it is: on that branch, or at the commit `ref`
- * names. FastAgent never moves a checkout the user owns, so this is said, not acted on.
- */
-export function refNotice(dir, ref) {
-    const branch = gitAnswer(["symbolic-ref", "--quiet", "--short", "HEAD"], dir);
-    if (branch === ref)
-        return undefined;
-    const head = gitAnswer(["rev-parse", "HEAD"], dir);
-    const target = gitAnswer(["rev-parse", "--verify", "--quiet", "--end-of-options", `${ref}^{commit}`], dir);
-    if (head !== undefined && head === target) {
-        return undefined;
-    }
-    const at = branch ?? `a detached ${head?.slice(0, 7) ?? "HEAD"}`;
-    return `the checkout is on ${at}, declared ${ref}; it is left as it is`;
-}
 /** A commit named in full: fetched by its hash, since `clone --branch` takes only a branch or a tag. */
 const FULL_COMMIT = /^[0-9a-f]{40}$/i;
 /**
@@ -97,7 +63,7 @@ const HELPER_KEY = "credential.https://github.com.helper";
  */
 export async function refreshClone(repo, ref, dir, env = process.env) {
     // The agent's environment, whose GITHUB_TOKEN the clone's credential helper reads.
-    const { run: runGit } = gitFor(WHY, env);
+    const { run: runGit, answer: gitAnswer } = gitFor(WHY, env);
     // A library caller can hand this anything; git reads a leading "-" as an option, and no repository or ref has one
     // (a declaration with one is refused at load, declare.ts).
     if (repo.startsWith("-") || ref?.startsWith("-")) {

package/dist/content/resolve.d.ts

@@ -1,4 +1,4 @@
-import { type BoundContent, type ContentDeclaration, type DeclaredContent } from "./declare.ts";
+import { type DeclaredContent } from "./declare.ts";
 import { type CloneOutcome } from "./git.ts";
 /** A content entry, resolved for this instance. */
 export type ResolvedContent = {
@@ -8,42 +8,38 @@ export type ResolvedContent = {
     description?: string;
     /** Where the agent reaches it on this instance, absolute. */
     location: string;
-    /** What to tell the user about how it resolved: a checkout off its `ref`, a clone not made yet. */
+    /** What to tell the user about how it resolved: a clone not made yet. */
     notices: string[];
 } & ({
-    /** A directory only this machine has, bound in `context.local.json`. */
+    /** A directory of this machine, where the instance configuration says. */
     kind: "local";
 } | {
+    /** A clone fastagent makes at `content/<name>` and brings up to date at each start while it holds nothing of the agent's. */
     kind: "github";
     /** `owner/repo`. */
     repo: string;
     ref?: string;
-    /**
-     * A clone fastagent makes at `content/<name>` and brings up to date at each start while it holds nothing of the
-     * agent's. False when this machine binds its own checkout, which is never touched.
-     */
-    clone: boolean;
 });
+/** The directories an instance's content is kept apart from. */
+export interface ContentPlaces {
+    /** The definition's own directory, which is released and read as it is. */
+    dir: string;
+    /** The instance's working directory, where clones are made. */
+    workdir: string;
+}
 /** Resolve the agent's content for this instance. Refuses, naming the entry, what cannot be. */
-export declare function resolveContent(agentDir: string, { declared, bound }: ContentDeclaration): ResolvedContent[];
+export declare function resolveContent(declared: readonly DeclaredContent[], places: ContentPlaces): ResolvedContent[];
 /**
- * The bindings of a directory only this machine has that point at nothing here: the directory was moved or removed.
- * Not an error, since the binding is this machine's alone; the agent is not told of it, and whoever opens the agent
- * says so.
+ * Whether the content `name` can be the directory `target` of this machine: one that exists, and is apart from the
+ * definition's directory, since a definition is released, content is kept, and one directory cannot be both. The
+ * working directory is the instance's own writable place, so a directory inside it is only a directory the agent
+ * already reaches. Refuses, naming the entry, what cannot be.
  */
-export declare function contentAbsentHere({ bound }: ContentDeclaration): BoundContent[];
-/** What is said of a binding {@link contentAbsentHere} returns, after the word "content". */
-export declare function absentNotice(binding: BoundContent): string;
-/**
- * Whether the content `name` can be bound to the directory `target` of this machine: a directory, apart from the agent
- * directory, and for a declared repository the root of a checkout of it. Returns what to tell the user (a checkout off
- * its `ref`); refuses, naming the entry, what cannot be.
- */
-export declare function checkBinding(agentDir: string, name: string, target: string, repository?: Pick<DeclaredContent, "repo" | "ref">): string[];
+export declare function checkDirectory({ dir }: Pick<ContentPlaces, "dir">, name: string, target: string): void;
 /**
  * Make a clone real, or bring it up to date at its `ref` in place, by git's rules, which never overwrite what the
  * agent did in it (git.ts `refreshClone`): what git refuses, or a remote that cannot be reached, keeps it as it is,
- * with the reason. Only a process that runs the agent calls this. A checkout this machine binds is never cloned over.
+ * with the reason. Only a process that runs the agent calls this.
  */
 export declare function cloneContent(entry: Extract<ResolvedContent, {
     kind: "github";