@monosmith/plugin-sdk 2.0.0-beta.1 → 2.0.0-beta.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monosmith/plugin-sdk",
-  "version": "2.0.0-beta.1",
+  "version": "2.0.0-beta.11",
   "description": "The TypeScript SDK for writing smith plugins: the protocol's types, the serve loop, a test host, the conformance checks, templating and key-order-keeping JSON editing. No runtime dependencies.",
   "license": "MIT",
   "type": "module",

package/protocol/protocol-schema.contract.js

@@ -175,6 +175,28 @@ export const protocolSchema = {
             "capability": "dependencies",
             "notification": false
         },
+        "dependencies/link": {
+            "description": "Makes a project depend on a library of the same workspace and language, in the ecosystem's own form, then installs or locks as that needs.",
+            "params": {
+                "$ref": "#/$defs/LinkParams"
+            },
+            "result": {
+                "$ref": "#/$defs/LinkResult"
+            },
+            "capability": "link",
+            "notification": false
+        },
+        "dependencies/unlink": {
+            "description": "Removes the dependency of a project on a library of the same workspace.",
+            "params": {
+                "$ref": "#/$defs/UnlinkParams"
+            },
+            "result": {
+                "$ref": "#/$defs/DependencyResult"
+            },
+            "capability": "link",
+            "notification": false
+        },
         "dependencies/declared": {
             "description": "Lists the dependencies the manifests of the plugin's projects declare.",
             "params": {
@@ -589,6 +611,10 @@ export const protocolSchema = {
                     "type": "boolean",
                     "description": "Dependencies installs and uninstalls packages in its projects."
                 },
+                "link": {
+                    "type": "boolean",
+                    "description": "Link makes a project depend on a library of the same workspace in the ecosystem's own form (a workspace dependency, a path dependency, a project reference), and takes it out again. A plugin without it is refused by the host with one sentence that tells the user to add the dependency by hand."
+                },
                 "declarations": {
                     "type": "boolean",
                     "description": "Declarations lists and rewrites declared dependency specs (sync, up)."
@@ -616,6 +642,10 @@ export const protocolSchema = {
                 "channels": {
                     "type": "boolean",
                     "description": "Channels says a prerelease version the plugin publishes never takes the place of the stable one: the plugin publishes under PublishParams.Tag, a release channel's name, without moving the registry's stable pointer (npm's latest), or its registry orders a prerelease below the release (PyPI, NuGet) and needs no tag. A host does not publish a package of a release channel with a plugin that lacks it."
+                },
+                "declared": {
+                    "type": "boolean",
+                    "description": "Declared says the plugin describes the projects smith.toml declares for its language (DiscoverParams.declared): folders with no manifest of their own. A plugin without it finds a project by its manifest only, and the host refuses a declaration for its language with a message that says so."
                 }
             }
         },
@@ -688,6 +718,21 @@ export const protocolSchema = {
                 "description": {
                     "type": "string"
                 },
+                "title": {
+                    "type": "string",
+                    "description": "Title is the name shown to a person (\"Electron\" for electron). Without it the name is shown."
+                },
+                "aliases": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "description": "Aliases are words that find the choice when a person searches the catalogue (smith compose): \"desktop\", \"serverless\", \"web\"."
+                },
+                "layer": {
+                    "type": "string",
+                    "description": "Layer is where the choice sits in the stack of a project: \"framework\", \"shell\" (a desktop shell), \"host\" (where cloud code runs), \"test\", \"lint\", \"style\" or a layer of the plugin's own. Without it the layer is the axis. It is for display and grouping: the axis decides conflicts."
+                },
                 "language": {
                     "type": "string",
                     "description": "Language is the language plugin the choice applies to (\"node\")."
@@ -710,6 +755,10 @@ export const protocolSchema = {
                     "type": "boolean",
                     "description": "Default marks the choice the host adds when a selection needs its axis and has no choice on it."
                 },
+                "suggested": {
+                    "type": "boolean",
+                    "description": "Suggested marks the choice an asker pre-selects on its axis. The solver never adds it by itself: an axis that a choice needs and that has no Default is asked, and the person answers (ADR 0072)."
+                },
                 "many": {
                     "type": "boolean",
                     "description": "Many allows the choice next to other choices of its axis that are Many too. By default a selection has one choice per axis."
@@ -941,6 +990,28 @@ export const protocolSchema = {
                 "projects"
             ]
         },
+        "DeclaredProject": {
+            "description": "DeclaredProject is a project smith.toml declares: a folder with no manifest.",
+            "type": "object",
+            "properties": {
+                "name": {
+                    "type": "string",
+                    "description": "Name is the project's name, the key of its [projects.<name>] table."
+                },
+                "root": {
+                    "type": "string",
+                    "description": "Root is the workspace-relative folder."
+                },
+                "kind": {
+                    "$ref": "#/$defs/ProjectKind",
+                    "description": "Kind is \"app\", \"lib\" or \"package\", or empty for the plugin's choice."
+                }
+            },
+            "required": [
+                "name",
+                "root"
+            ]
+        },
         "DeclaredResult": {
             "description": "DeclaredResult is every declaration, and the version installed of each name where the plugin can tell.",
             "type": "object",
@@ -1116,6 +1187,20 @@ export const protocolSchema = {
                     "items": {
                         "type": "string"
                     }
+                },
+                "declared": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/$defs/DeclaredProject"
+                    },
+                    "description": "Declared are the projects smith.toml declares for this plugin's language ([projects.<name>] with a root and a language): folders with no manifest of their own, such as a program that is a package of the Go module above it. The plugin describes each one in its result, or answers with an error saying why it cannot."
+                },
+                "settings": {
+                    "type": "object",
+                    "additionalProperties": {
+                        "type": "object"
+                    },
+                    "description": "Settings are this plugin's settings for projects, by project name, from smith.toml [projects.<project>.settings.<plugin>]. They reach the plugin here because the tasks it describes may depend on them (the Go plugin's build tags). A project with no settings is absent."
                 }
             },
             "required": [
@@ -1345,6 +1430,13 @@ export const protocolSchema = {
                 "dir": {
                     "type": "string",
                     "description": "Dir is where it runs, workspace-relative; empty is the workspace root."
+                },
+                "env": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "description": "Env are KEY=VALUE entries added to the environment of the command (GOBIN=<folder> makes go install write there). Absent adds none."
                 }
             },
             "required": [
@@ -1549,6 +1641,13 @@ export const protocolSchema = {
                         "$ref": "#/$defs/Choice"
                     },
                     "description": "Choices are the options on an axis (framework, test, style) the plugin owns. The host lists them (smith choices) and checks a selection of them (smith add --with). Absent means the plugin owns none."
+                },
+                "tools": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/$defs/ToolNeed"
+                    },
+                    "description": "Tools are the programs the plugin needs on the person's machine. The host detects them and, when one is missing, presents the ways to get it (smith tools). Absent means the plugin declares none."
                 }
             },
             "required": [
@@ -1645,6 +1744,94 @@ export const protocolSchema = {
                 }
             }
         },
+        "LinkOption": {
+            "description": "LinkOption is one way to write the dependency, with its consequence in words a person who read no manual can follow.",
+            "type": "object",
+            "properties": {
+                "spec": {
+                    "type": "string",
+                    "description": "Spec is the value passed back in LinkParams.Spec."
+                },
+                "label": {
+                    "type": "string",
+                    "description": "Label is the option in a few words."
+                },
+                "meaning": {
+                    "type": "string",
+                    "description": "Meaning says what happens with this option."
+                }
+            },
+            "required": [
+                "spec",
+                "label",
+                "meaning"
+            ]
+        },
+        "LinkParams": {
+            "description": "LinkParams asks a plugin to make Project depend on Library, a lib or package of the same workspace and language, in the ecosystem's own form, and to install or lock as that needs. The host has checked that both exist, that the languages match, that Library is not an app, and that the link makes no cycle; the plugin answers with an error that names the file when it cannot write the dependency.",
+            "type": "object",
+            "properties": {
+                "project": {
+                    "$ref": "#/$defs/Project",
+                    "description": "Project is the project that gains the dependency."
+                },
+                "library": {
+                    "$ref": "#/$defs/Project",
+                    "description": "Library is the project it depends on."
+                },
+                "quiet": {
+                    "type": "boolean",
+                    "description": "Quiet keeps the package manager's output unless it fails."
+                },
+                "plan": {
+                    "type": "boolean",
+                    "description": "Plan asks for the plan only: the plugin writes nothing and answers with the manifest, the line it would write and the choices the user has."
+                },
+                "spec": {
+                    "type": "string",
+                    "description": "Spec is the version range the user chose from LinkResult.Options; empty means the plugin's default, or the form the workspace already uses."
+                }
+            },
+            "required": [
+                "project",
+                "library"
+            ]
+        },
+        "LinkResult": {
+            "description": "LinkResult is what a link wrote, or with LinkParams.Plan would write.",
+            "type": "object",
+            "properties": {
+                "files": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "description": "Files are the workspace-relative files changed (or to be changed)."
+                },
+                "notes": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "description": "Notes are for the user."
+                },
+                "manifest": {
+                    "type": "string",
+                    "description": "Manifest is the file the dependency goes into, workspace-relative."
+                },
+                "line": {
+                    "type": "string",
+                    "description": "Line is the dependency as it is written there, for the plan shown before anything is written (\"@acme/core\": \"*\")."
+                },
+                "options": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/$defs/LinkOption"
+                    },
+                    "description": "Options are the real choices of the range written, with the default first. Empty when the ecosystem has none, or the workspace already follows a convention (then Line shows it)."
+                }
+            }
+        },
         "PackageStore": {
             "description": "PackageStore is where a package manager keeps what it downloaded (npm's ~/.npm, Go's module cache). A generated pipeline restores it before setup and saves it after a run, keyed on Files, so `npm ci` or `go mod download` fetches only what changed. A pull request from a fork restores it and never writes the base repository's cache.",
             "type": "object",
@@ -1864,6 +2051,17 @@ export const protocolSchema = {
                 "tag": {
                     "type": "string",
                     "description": "Tag is the name of the release channel the version belongs to (npm's dist-tag \"beta\"). When set, the plugin publishes under it and leaves the registry's stable pointer where it is, or ignores it when its registry has no such pointer. Only sent to a plugin with the channels capability."
+                },
+                "propagationWait": {
+                    "type": "string",
+                    "description": "PropagationWait is the longest time a plugin waits, in a Finalize call, for the packages of the release to be fetchable from the registry: a duration such as \"15m\", \"0\" to not wait. Empty means the default. Only npm has such a wait. A publish never waits."
+                },
+                "finalize": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/$defs/TagMove"
+                    },
+                    "description": "Finalize turns the call into the last phase of a release: nothing is published; for each move the plugin waits until its packages are fetchable, then moves the dist-tag. The host sends it after every project has published, so a wait never blocks another publish."
                 }
             },
             "required": [
@@ -1884,6 +2082,27 @@ export const protocolSchema = {
                 "registry": {
                     "type": "string"
                 },
+                "notes": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "description": "Notes are things the person must know about a publish that succeeded, such as a dist-tag that was not moved; the host prints them and the report keeps them."
+                },
+                "pendingMoves": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/$defs/TagMove"
+                    },
+                    "description": "PendingMoves are the dist-tags the call did not move, because the packages the release needs were not fetchable yet. A publish returns them for the host to move at the end of the release; a Finalize call returns the ones still waiting when its time ran out. The release then ends with a warning, never silently."
+                },
+                "moved": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "description": "Moved names the dist-tags a Finalize call moved (\"name@version tag\")."
+                },
                 "assets": {
                     "type": "array",
                     "items": {
@@ -2292,6 +2511,36 @@ export const protocolSchema = {
                 "blocking"
             ]
         },
+        "TagMove": {
+            "description": "TagMove is a dist-tag a publish left where it was, because the packages the release needs were not fetchable yet.",
+            "type": "object",
+            "properties": {
+                "package": {
+                    "type": "string",
+                    "description": "Package and Version name the package that carries the tag."
+                },
+                "version": {
+                    "type": "string"
+                },
+                "tag": {
+                    "type": "string",
+                    "description": "Tag is the dist-tag to move to Version."
+                },
+                "awaits": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "description": "Awaits are the packages that must be fetchable first."
+                }
+            },
+            "required": [
+                "package",
+                "version",
+                "tag",
+                "awaits"
+            ]
+        },
         "Task": {
             "description": "Task is a command the host can run, hash and cache.",
             "type": "object",
@@ -2362,6 +2611,132 @@ export const protocolSchema = {
                 "command"
             ]
         },
+        "ToolInstall": {
+            "description": "ToolInstall is one way to get a tool with a package manager. Manager is one of: \"winget\", \"brew\", \"brew-cask\", \"apt\", \"dnf\", \"pacman\", \"npm\", \"uv\", \"fnm\", \"rustup\", \"cargo\" and \"go\" (go install, for a tool published as a Go module). The host builds the exact command from the manager and Package; Package may hold {major}, {major.minor} and {version} (the whole version), which the pinned or suggested version fills. The language's own installers (uv, fnm, rustup, cargo) are offered only when they are already on the machine.",
+            "type": "object",
+            "properties": {
+                "manager": {
+                    "type": "string"
+                },
+                "package": {
+                    "type": "string"
+                },
+                "note": {
+                    "type": "string",
+                    "description": "Note adds a sentence the person needs before choosing (\"a new terminal is needed\")."
+                }
+            },
+            "required": [
+                "manager",
+                "package"
+            ]
+        },
+        "ToolNeed": {
+            "description": "ToolNeed is a program on the person's machine that a plugin needs to build, test or run its projects (Python, the .NET SDK, Docker). A plugin publishes the tools it needs in InitializeResult.Tools. The host detects them, and when one is missing it presents the ways to get it (ADR 0077): it never installs in silence. The plugin writes facts only (what the tool is, how to detect it, how each system gets it); the host decides how to ask.",
+            "type": "object",
+            "properties": {
+                "name": {
+                    "type": "string",
+                    "description": "Name identifies the tool across plugins and in commands (smith tools install python). Two plugins that need the same tool use the same Name."
+                },
+                "title": {
+                    "type": "string",
+                    "description": "Title is what the tool is called in text: \"Python\", \"the .NET SDK\". Doctor words the check \"<Title> is installed\"."
+                },
+                "why": {
+                    "type": "string",
+                    "description": "Why says in plain words what smith needs the tool for."
+                },
+                "consequence": {
+                    "type": "string",
+                    "description": "Consequence says what stops working while the tool is missing, as the end of a sentence that starts \"If you skip it, \": \"smith test and smith build fail for the python projects\"."
+                },
+                "program": {
+                    "type": "string",
+                    "description": "Program is the program that carries the tool on PATH (\"python3\")."
+                },
+                "alternatives": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "description": "Alternatives are other programs that also count (\"python\", \"py\")."
+                },
+                "versionArgs": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "description": "VersionArgs are the arguments that make Program print its version. Absent means --version."
+                },
+                "pins": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/$defs/ToolVersionPin"
+                    },
+                    "description": "Pins are the files where a workspace pins the version it wants. The first pin the host finds gives the version range. Absent means any version counts."
+                },
+                "choice": {
+                    "type": "string",
+                    "description": "Choice limits the tool to stacks that have this choice (\"azure-functions\"): the tool is not needed by a project built without it. Absent means every project of the plugin needs it."
+                },
+                "files": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "description": "Files limit the tool to projects that hold one of these files in their folder (\"build.gradle.kts\"): a Gradle build needs gradle, a Maven build does not. A tool that the tasks of a project run (gradle, mvn) is declared this way. Absent means every project of the plugin needs it."
+                },
+                "systems": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "description": "Systems limits the tool to these systems, named as Go names them (\"windows\", \"darwin\", \"linux\"): the Xcode Command Line Tools exist only on \"darwin\". Absent means every system."
+                },
+                "suggested": {
+                    "type": "string",
+                    "description": "Suggested is the version smith installs when no pin says one: \"3.13\". It fills {major} and {major.minor} in the install entries."
+                },
+                "optional": {
+                    "type": "boolean",
+                    "description": "Optional marks a tool whose absence only costs a feature (running a function app locally). Doctor reports it as a warning, not a failure."
+                },
+                "exact": {
+                    "type": "boolean",
+                    "description": "Exact says Suggested is the one version the workspace wants, such as the version CI pins: an installed version that differs, older or newer, is reported as different, and an install fetches that version."
+                },
+                "install": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/$defs/ToolInstall"
+                    },
+                    "description": "Install are the ways to get the tool, per package manager and system."
+                },
+                "download": {
+                    "type": "string",
+                    "description": "Download is the official page of the tool, for the person who installs it by hand or has no package manager."
+                },
+                "source": {
+                    "type": "string",
+                    "description": "Source is the address of the page the Install entries were checked against."
+                },
+                "checked": {
+                    "type": "string",
+                    "description": "Checked is the date (YYYY-MM-DD) the entries were last checked."
+                }
+            },
+            "required": [
+                "name",
+                "title",
+                "why",
+                "consequence",
+                "program",
+                "download",
+                "source",
+                "checked"
+            ]
+        },
         "ToolPin": {
             "description": "ToolPin is a tool the plugin installs at a pinned version (in CI, the dev container, the venv) against the newest release; informational.",
             "type": "object",
@@ -2386,6 +2761,23 @@ export const protocolSchema = {
                 "pinned"
             ]
         },
+        "ToolVersionPin": {
+            "description": "ToolVersionPin names a file that pins the version of a tool and how to read it. Format is one of: \"text\" (the first word of the file, as in .nvmrc and .python-version), \"go-mod\" (the toolchain line, else the go line), \"pyproject\" (requires-python), \"global-json\" (sdk.version) and \"rust-toolchain\" (the channel).",
+            "type": "object",
+            "properties": {
+                "file": {
+                    "type": "string",
+                    "description": "File is the base name of the file, looked up at the workspace root and in the folders of the projects that use the tool."
+                },
+                "format": {
+                    "type": "string"
+                }
+            },
+            "required": [
+                "file",
+                "format"
+            ]
+        },
         "Toolchain": {
             "description": "Toolchain is a runtime the pipeline must install, and how. Plugins asking for the same name share one setup step (the first plugin's).",
             "type": "object",
@@ -2437,6 +2829,22 @@ export const protocolSchema = {
                 "packages"
             ]
         },
+        "UnlinkParams": {
+            "description": "UnlinkParams asks a plugin to remove the dependency of Project on Library. Notes of the result say so when the manifest held no such dependency.",
+            "type": "object",
+            "properties": {
+                "project": {
+                    "$ref": "#/$defs/Project"
+                },
+                "library": {
+                    "$ref": "#/$defs/Project"
+                }
+            },
+            "required": [
+                "project",
+                "library"
+            ]
+        },
         "VersionParams": {
             "description": "VersionParams asks a plugin to record a new version in a project manifest.",
             "type": "object",

package/protocol/protocol-types.contract.d.ts

@@ -177,6 +177,13 @@ export interface Capabilities {
     published?: boolean;
     /** Dependencies installs and uninstalls packages in its projects. */
     dependencies?: boolean;
+    /**
+     * Link makes a project depend on a library of the same workspace in the ecosystem's own form (a
+     * workspace dependency, a path dependency, a project reference), and takes it out again. A plugin
+     * without it is refused by the host with one sentence that tells the user to add the dependency
+     * by hand.
+     */
+    link?: boolean;
     /** Declarations lists and rewrites declared dependency specs (sync, up). */
     declarations?: boolean;
     /** Latest reports the newest releases of dependencies and pinned tools. */
@@ -204,6 +211,13 @@ export interface Capabilities {
      * plugin that lacks it.
      */
     channels?: boolean;
+    /**
+     * Declared says the plugin describes the projects smith.toml declares for its language
+     * (DiscoverParams.declared): folders with no manifest of their own. A plugin without it finds a
+     * project by its manifest only, and the host refuses a declaration for its language with a
+     * message that says so.
+     */
+    declared?: boolean;
 }
 /**
  * ChangeKindParams asks a plugin what changing a project's kind edits. The plugin writes nothing:
@@ -265,6 +279,19 @@ export interface Choice {
      */
     name: string;
     description?: string;
+    /** Title is the name shown to a person ("Electron" for electron). Without it the name is shown. */
+    title?: string;
+    /**
+     * Aliases are words that find the choice when a person searches the catalogue (smith compose):
+     * "desktop", "serverless", "web".
+     */
+    aliases?: string[];
+    /**
+     * Layer is where the choice sits in the stack of a project: "framework", "shell" (a desktop
+     * shell), "host" (where cloud code runs), "test", "lint", "style" or a layer of the plugin's own.
+     * Without it the layer is the axis. It is for display and grouping: the axis decides conflicts.
+     */
+    layer?: string;
     /** Language is the language plugin the choice applies to ("node"). */
     language: string;
     /**
@@ -280,6 +307,12 @@ export interface Choice {
     needs?: string[];
     /** Default marks the choice the host adds when a selection needs its axis and has no choice on it. */
     default?: boolean;
+    /**
+     * Suggested marks the choice an asker pre-selects on its axis. The solver never adds it by
+     * itself: an axis that a choice needs and that has no Default is asked, and the person answers
+     * (ADR 0072).
+     */
+    suggested?: boolean;
     /**
      * Many allows the choice next to other choices of its axis that are Many too. By default a
      * selection has one choice per axis.
@@ -406,6 +439,15 @@ export interface Declaration {
 export interface DeclaredParams {
     projects: Project[];
 }
+/** DeclaredProject is a project smith.toml declares: a folder with no manifest. */
+export interface DeclaredProject {
+    /** Name is the project's name, the key of its [projects.<name>] table. */
+    name: string;
+    /** Root is the workspace-relative folder. */
+    root: string;
+    /** Kind is "app", "lib" or "package", or empty for the plugin's choice. */
+    kind?: ProjectKind;
+}
 /**
  * DeclaredResult is every declaration, and the version installed of each name where the plugin can
  * tell.
@@ -502,6 +544,20 @@ export interface DevcontainerFeature {
  */
 export interface DiscoverParams {
     manifests: string[];
+    /**
+     * Declared are the projects smith.toml declares for this plugin's language ([projects.<name>]
+     * with a root and a language): folders with no manifest of their own, such as a program that is a
+     * package of the Go module above it. The plugin describes each one in its result, or answers with
+     * an error saying why it cannot.
+     */
+    declared?: DeclaredProject[];
+    /**
+     * Settings are this plugin's settings for projects, by project name, from smith.toml
+     * [projects.<project>.settings.<plugin>]. They reach the plugin here because the tasks it
+     * describes may depend on them (the Go plugin's build tags). A project with no settings is
+     * absent.
+     */
+    settings?: Record<string, Record<string, unknown>>;
 }
 /**
  * DiscoverResult describes every manifest that is a project of this plugin. A manifest the plugin
@@ -612,6 +668,11 @@ export interface FixStep {
     argv: string[];
     /** Dir is where it runs, workspace-relative; empty is the workspace root. */
     dir?: string;
+    /**
+     * Env are KEY=VALUE entries added to the environment of the command (GOBIN=<folder> makes go
+     * install write there). Absent adds none.
+     */
+    env?: string[];
 }
 /**
  * GenerateParams asks a plugin to scaffold a project. The host chooses the directory from the kind
@@ -743,6 +804,12 @@ export interface InitializeResult {
      * owns none.
      */
     choices?: Choice[];
+    /**
+     * Tools are the programs the plugin needs on the person's machine. The host detects them and,
+     * when one is missing, presents the ways to get it (smith tools). Absent means the plugin
+     * declares none.
+     */
+    tools?: ToolNeed[];
 }
 /**
  * Input is one input of an ActionStep. Values are written as quoted YAML strings, except true and
@@ -795,6 +862,62 @@ export interface LatestResult {
     unreachable?: Record<string, string>;
     tools?: ToolPin[];
 }
+/**
+ * LinkOption is one way to write the dependency, with its consequence in words a person who read no
+ * manual can follow.
+ */
+export interface LinkOption {
+    /** Spec is the value passed back in LinkParams.Spec. */
+    spec: string;
+    /** Label is the option in a few words. */
+    label: string;
+    /** Meaning says what happens with this option. */
+    meaning: string;
+}
+/**
+ * LinkParams asks a plugin to make Project depend on Library, a lib or package of the same
+ * workspace and language, in the ecosystem's own form, and to install or lock as that needs. The
+ * host has checked that both exist, that the languages match, that Library is not an app, and that
+ * the link makes no cycle; the plugin answers with an error that names the file when it cannot
+ * write the dependency.
+ */
+export interface LinkParams {
+    /** Project is the project that gains the dependency. */
+    project: Project;
+    /** Library is the project it depends on. */
+    library: Project;
+    /** Quiet keeps the package manager's output unless it fails. */
+    quiet?: boolean;
+    /**
+     * Plan asks for the plan only: the plugin writes nothing and answers with the manifest, the line
+     * it would write and the choices the user has.
+     */
+    plan?: boolean;
+    /**
+     * Spec is the version range the user chose from LinkResult.Options; empty means the plugin's
+     * default, or the form the workspace already uses.
+     */
+    spec?: string;
+}
+/** LinkResult is what a link wrote, or with LinkParams.Plan would write. */
+export interface LinkResult {
+    /** Files are the workspace-relative files changed (or to be changed). */
+    files?: string[];
+    /** Notes are for the user. */
+    notes?: string[];
+    /** Manifest is the file the dependency goes into, workspace-relative. */
+    manifest?: string;
+    /**
+     * Line is the dependency as it is written there, for the plan shown before anything is written
+     * ("@acme/core": "*").
+     */
+    line?: string;
+    /**
+     * Options are the real choices of the range written, with the default first. Empty when the
+     * ecosystem has none, or the workspace already follows a convention (then Line shows it).
+     */
+    options?: LinkOption[];
+}
 /**
  * PackageStore is where a package manager keeps what it downloaded (npm's ~/.npm, Go's module
  * cache). A generated pipeline restores it before setup and saves it after a run, keyed on Files,
@@ -973,6 +1096,18 @@ export interface PublishParams {
      * capability.
      */
     tag?: string;
+    /**
+     * PropagationWait is the longest time a plugin waits, in a Finalize call, for the packages of the
+     * release to be fetchable from the registry: a duration such as "15m", "0" to not wait. Empty
+     * means the default. Only npm has such a wait. A publish never waits.
+     */
+    propagationWait?: string;
+    /**
+     * Finalize turns the call into the last phase of a release: nothing is published; for each move
+     * the plugin waits until its packages are fetchable, then moves the dist-tag. The host sends it
+     * after every project has published, so a wait never blocks another publish.
+     */
+    finalize?: TagMove[];
 }
 /**
  * PublishResult reports what happened. Skipped with a reason is a success: an already-published
@@ -982,6 +1117,20 @@ export interface PublishResult {
     published: boolean;
     skipped?: string;
     registry?: string;
+    /**
+     * Notes are things the person must know about a publish that succeeded, such as a dist-tag that
+     * was not moved; the host prints them and the report keeps them.
+     */
+    notes?: string[];
+    /**
+     * PendingMoves are the dist-tags the call did not move, because the packages the release needs
+     * were not fetchable yet. A publish returns them for the host to move at the end of the release;
+     * a Finalize call returns the ones still waiting when its time ran out. The release then ends
+     * with a warning, never silently.
+     */
+    pendingMoves?: TagMove[];
+    /** Moved names the dist-tags a Finalize call moved ("name@version tag"). */
+    moved?: string[];
     /**
      * Assets are the workspace-relative files built for the release, in upload order; in a dry run,
      * the files that would be built.
@@ -1185,6 +1334,19 @@ export interface Step {
      */
     cacheFiles?: string[];
 }
+/**
+ * TagMove is a dist-tag a publish left where it was, because the packages the release needs were
+ * not fetchable yet.
+ */
+export interface TagMove {
+    /** Package and Version name the package that carries the tag. */
+    package: string;
+    version: string;
+    /** Tag is the dist-tag to move to Version. */
+    tag: string;
+    /** Awaits are the packages that must be fetchable first. */
+    awaits: string[];
+}
 /** Task is a command the host can run, hash and cache. */
 export interface Task {
     /** Command is an argv array; it is never passed through a shell. */
@@ -1228,6 +1390,101 @@ export interface Task {
     /** ServeTimeout is how long to wait for ServeURL, as a Go duration ("60s"); empty means 60s. */
     serveTimeout?: string;
 }
+/**
+ * ToolInstall is one way to get a tool with a package manager. Manager is one of: "winget", "brew",
+ * "brew-cask", "apt", "dnf", "pacman", "npm", "uv", "fnm", "rustup", "cargo" and "go" (go install,
+ * for a tool published as a Go module). The host builds the exact command from the manager and
+ * Package; Package may hold {major}, {major.minor} and {version} (the whole version), which the
+ * pinned or suggested version fills. The language's own installers (uv, fnm, rustup, cargo) are
+ * offered only when they are already on the machine.
+ */
+export interface ToolInstall {
+    manager: string;
+    package: string;
+    /** Note adds a sentence the person needs before choosing ("a new terminal is needed"). */
+    note?: string;
+}
+/**
+ * ToolNeed is a program on the person's machine that a plugin needs to build, test or run its
+ * projects (Python, the .NET SDK, Docker). A plugin publishes the tools it needs in
+ * InitializeResult.Tools. The host detects them, and when one is missing it presents the ways to
+ * get it (ADR 0077): it never installs in silence. The plugin writes facts only (what the tool is,
+ * how to detect it, how each system gets it); the host decides how to ask.
+ */
+export interface ToolNeed {
+    /**
+     * Name identifies the tool across plugins and in commands (smith tools install python). Two
+     * plugins that need the same tool use the same Name.
+     */
+    name: string;
+    /**
+     * Title is what the tool is called in text: "Python", "the .NET SDK". Doctor words the check
+     * "<Title> is installed".
+     */
+    title: string;
+    /** Why says in plain words what smith needs the tool for. */
+    why: string;
+    /**
+     * Consequence says what stops working while the tool is missing, as the end of a sentence that
+     * starts "If you skip it, ": "smith test and smith build fail for the python projects".
+     */
+    consequence: string;
+    /** Program is the program that carries the tool on PATH ("python3"). */
+    program: string;
+    /** Alternatives are other programs that also count ("python", "py"). */
+    alternatives?: string[];
+    /** VersionArgs are the arguments that make Program print its version. Absent means --version. */
+    versionArgs?: string[];
+    /**
+     * Pins are the files where a workspace pins the version it wants. The first pin the host finds
+     * gives the version range. Absent means any version counts.
+     */
+    pins?: ToolVersionPin[];
+    /**
+     * Choice limits the tool to stacks that have this choice ("azure-functions"): the tool is not
+     * needed by a project built without it. Absent means every project of the plugin needs it.
+     */
+    choice?: string;
+    /**
+     * Files limit the tool to projects that hold one of these files in their folder
+     * ("build.gradle.kts"): a Gradle build needs gradle, a Maven build does not. A tool that the
+     * tasks of a project run (gradle, mvn) is declared this way. Absent means every project of the
+     * plugin needs it.
+     */
+    files?: string[];
+    /**
+     * Systems limits the tool to these systems, named as Go names them ("windows", "darwin",
+     * "linux"): the Xcode Command Line Tools exist only on "darwin". Absent means every system.
+     */
+    systems?: string[];
+    /**
+     * Suggested is the version smith installs when no pin says one: "3.13". It fills {major} and
+     * {major.minor} in the install entries.
+     */
+    suggested?: string;
+    /**
+     * Optional marks a tool whose absence only costs a feature (running a function app locally).
+     * Doctor reports it as a warning, not a failure.
+     */
+    optional?: boolean;
+    /**
+     * Exact says Suggested is the one version the workspace wants, such as the version CI pins: an
+     * installed version that differs, older or newer, is reported as different, and an install
+     * fetches that version.
+     */
+    exact?: boolean;
+    /** Install are the ways to get the tool, per package manager and system. */
+    install?: ToolInstall[];
+    /**
+     * Download is the official page of the tool, for the person who installs it by hand or has no
+     * package manager.
+     */
+    download: string;
+    /** Source is the address of the page the Install entries were checked against. */
+    source: string;
+    /** Checked is the date (YYYY-MM-DD) the entries were last checked. */
+    checked: string;
+}
 /**
  * ToolPin is a tool the plugin installs at a pinned version (in CI, the dev container, the venv)
  * against the newest release; informational.
@@ -1240,6 +1497,20 @@ export interface ToolPin {
     /** Newer is true when Latest is a release the pin does not cover. */
     newer?: boolean;
 }
+/**
+ * ToolVersionPin names a file that pins the version of a tool and how to read it. Format is one of:
+ * "text" (the first word of the file, as in .nvmrc and .python-version), "go-mod" (the toolchain
+ * line, else the go line), "pyproject" (requires-python), "global-json" (sdk.version) and
+ * "rust-toolchain" (the channel).
+ */
+export interface ToolVersionPin {
+    /**
+     * File is the base name of the file, looked up at the workspace root and in the folders of the
+     * projects that use the tool.
+     */
+    file: string;
+    format: string;
+}
 /**
  * Toolchain is a runtime the pipeline must install, and how. Plugins asking for the same name share
  * one setup step (the first plugin's).
@@ -1267,6 +1538,14 @@ export interface UninstallParams {
     project: Project;
     packages: string[];
 }
+/**
+ * UnlinkParams asks a plugin to remove the dependency of Project on Library. Notes of the result
+ * say so when the manifest held no such dependency.
+ */
+export interface UnlinkParams {
+    project: Project;
+    library: Project;
+}
 /** VersionParams asks a plugin to record a new version in a project manifest. */
 export interface VersionParams {
     project: Project;
@@ -1403,6 +1682,21 @@ export interface ProtocolMethods {
         result: DependencyResult;
         capability: 'dependencies';
     };
+    /**
+     * Makes a project depend on a library of the same workspace and language, in the ecosystem's own
+     * form, then installs or locks as that needs.
+     */
+    'dependencies/link': {
+        params: LinkParams;
+        result: LinkResult;
+        capability: 'link';
+    };
+    /** Removes the dependency of a project on a library of the same workspace. */
+    'dependencies/unlink': {
+        params: UnlinkParams;
+        result: DependencyResult;
+        capability: 'link';
+    };
     /** Lists the dependencies the manifests of the plugin's projects declare. */
     'dependencies/declared': {
         params: DeclaredParams;

package/serve/index.d.ts

@@ -1,4 +1,4 @@
 export { serve, serveStreams } from './serve.use-case.ts';
 export { capabilitiesOf, implementsMethod } from './capabilities-of.algorithm.ts';
-export type { APISurfaceReader, Awaitable, Cancellable, CIContributor, ComponentLister, Contributor, DeclarationEditor, DependencyManager, Deriver, Discoverer, DoctorContributor, Generator, KindChanger, LatestReader, Plugin, PluginDescription, Publisher, RegistryReader, Remover, SmithPlugin, Versioner, } from './plugin.contract.ts';
+export type { APISurfaceReader, Awaitable, Cancellable, CIContributor, ComponentLister, Contributor, DeclarationEditor, DependencyManager, Deriver, Discoverer, DoctorContributor, Generator, KindChanger, LatestReader, Linker, Plugin, PluginDescription, Publisher, RegistryReader, Remover, SmithPlugin, Versioner, } from './plugin.contract.ts';
 export type { FrameSink, ServeStreams } from './protocol-streams.contract.ts';

package/serve/plugin-members.config.js

@@ -20,6 +20,8 @@ export const PLUGIN_MEMBERS = {
     'published': { member: 'published', requires: ['published'] },
     'dependencies/install': { member: 'install', requires: ['install', 'uninstall'] },
     'dependencies/uninstall': { member: 'uninstall', requires: ['install', 'uninstall'] },
+    'dependencies/link': { member: 'link', requires: ['link', 'unlink'] },
+    'dependencies/unlink': { member: 'unlink', requires: ['link', 'unlink'] },
     'dependencies/declared': { member: 'declared', requires: ['declared', 'rewrite'] },
     'dependencies/rewrite': { member: 'rewrite', requires: ['declared', 'rewrite'] },
     'dependencies/latest': { member: 'latest', requires: ['latest'] },

package/serve/plugin.contract.d.ts

@@ -1,4 +1,4 @@
-import type { DeriveParams, DeriveResult, APISurfaceParams, APISurfaceResult, ChangeKindParams, ChangeKindResult, CIParams, CIResult, ComponentsParams, ComponentsResult, ContributeParams, ContributeResult, DeclaredParams, DeclaredResult, DependencyResult, DiscoverParams, DiscoverResult, DoctorParams, DoctorResult, GenerateParams, GenerateResult, InitializeParams, InitializeResult, InstallParams, LatestParams, LatestResult, PublishedParams, PublishedResult, PublishParams, PublishResult, RemoveParams, RemoveResult, RewriteParams, UninstallParams, VersionParams, VersionResult } from '../protocol/index.ts';
+import type { DeriveParams, DeriveResult, APISurfaceParams, APISurfaceResult, ChangeKindParams, ChangeKindResult, CIParams, CIResult, ComponentsParams, ComponentsResult, ContributeParams, ContributeResult, DeclaredParams, DeclaredResult, DependencyResult, DiscoverParams, DiscoverResult, DoctorParams, DoctorResult, GenerateParams, GenerateResult, InitializeParams, InitializeResult, InstallParams, LatestParams, LatestResult, LinkParams, LinkResult, PublishedParams, PublishedResult, PublishParams, PublishResult, RemoveParams, RemoveResult, RewriteParams, UninstallParams, UnlinkParams, VersionParams, VersionResult } from '../protocol/index.ts';
 /** A result now or later: every method of a plugin may be `async`. */
 export type Awaitable<T> = T | Promise<T>;
 /** What a plugin says about itself. The serve loop fills in `protocolVersion` and `capabilities`. */
@@ -61,6 +61,11 @@ export interface DependencyManager {
     install: (params: InstallParams, signal: AbortSignal) => Awaitable<DependencyResult>;
     uninstall: (params: UninstallParams, signal: AbortSignal) => Awaitable<DependencyResult>;
 }
+/** `dependencies/link` and `dependencies/unlink`: both, or the capability is not advertised. */
+export interface Linker {
+    link: (params: LinkParams, signal: AbortSignal) => Awaitable<LinkResult>;
+    unlink: (params: UnlinkParams, signal: AbortSignal) => Awaitable<DependencyResult>;
+}
 /** `dependencies/declared` and `dependencies/rewrite`: both, or the capability is not advertised. */
 export interface DeclarationEditor {
     declared: (params: DeclaredParams, signal: AbortSignal) => Awaitable<DeclaredResult>;
@@ -93,4 +98,4 @@ export interface Cancellable {
  * from `cancellable`. How many requests it can work on at once is declared in
  * `describe`'s `concurrency`: omit it for one at a time, in order.
  */
-export type SmithPlugin = Plugin & Partial<Discoverer & Generator & Versioner & Publisher & RegistryReader & CIContributor & DoctorContributor & Remover & KindChanger & ComponentLister & Deriver & APISurfaceReader & DependencyManager & DeclarationEditor & LatestReader & Contributor & Cancellable>;
+export type SmithPlugin = Plugin & Partial<Discoverer & Generator & Versioner & Publisher & RegistryReader & CIContributor & DoctorContributor & Remover & KindChanger & ComponentLister & Deriver & APISurfaceReader & DependencyManager & Linker & DeclarationEditor & LatestReader & Contributor & Cancellable>;