@abot-ai/runtime 1.6.0 → 1.7.0

package/dist/src/web-ui/system-host-setup/local-connection.js

@@ -2,23 +2,21 @@ import { installLocalMacCompanion, LocalCompanionSetupError } from "../../comput
 import { acceptConfigMutationRequest } from "../local-runtime/config-mutation-request.js";
 import { readBody, sendJson } from "../local-runtime/http.js";
 import { canSetUpLocalMac, localMacSetupRuntimeUrl } from "./local-setup-availability.js";
+import { HostSetupMutation } from "./setup-mutation.js";
 export const LOCAL_HOST_SETUP_PATH = "/web-api/runtime/system-host/connect-local";
 function isEmptyLocalSetupRequest(body) {
     return JSON.stringify(body) === "{}";
 }
 export class LocalHostConnection {
     dependencies;
-    pending;
+    mutation;
     constructor(dependencies) {
         this.dependencies = dependencies;
+        this.mutation = dependencies.mutation ?? new HostSetupMutation();
     }
-    get busy() { return this.pending !== undefined; }
+    get busy() { return this.mutation.busy; }
     rejectConcurrentMutation(response) {
-        if (!this.busy)
-            return false;
-        sendJson(response, 409, { ok: false, error: "host_setup_in_progress",
-            message: "Computer access is being connected. Wait for setup to finish." });
-        return true;
+        return this.mutation.rejectConcurrentMutation(response);
     }
     async handle(request, response) {
         if (request.method !== "POST") {
@@ -37,18 +35,17 @@ export class LocalHostConnection {
             sendJson(response, 400, { ok: false, error: "unexpected_host_configuration_fields" });
             return;
         }
+        await this.mutation.run(response, () => this.completeConnection(request, response));
+    }
+    async completeConnection(request, response) {
         const readiness = await this.dependencies.readiness();
         if (!canSetUpLocalMac(request, readiness)) {
             sendJson(response, 409, { ok: false, error: "host_local_setup_unavailable",
                 message: "Direct setup requires ABot running natively on this Mac through its local address. Use a pairing code on the Mac for Docker or a forwarded Runtime." });
             return;
         }
-        if (this.rejectConcurrentMutation(response))
-            return;
-        const pending = this.connect(localMacSetupRuntimeUrl(request));
-        this.pending = pending;
         try {
-            await pending;
+            await this.connect(localMacSetupRuntimeUrl(request));
             sendJson(response, 200, { ok: true });
         }
         catch (error) {
@@ -56,10 +53,6 @@ export class LocalHostConnection {
                 throw error;
             sendJson(response, 503, { ok: false, error: error.code, message: error.message });
         }
-        finally {
-            if (this.pending === pending)
-                this.pending = undefined;
-        }
     }
     async connect(url) {
         const bundle = await this.dependencies.bundle();
@@ -73,5 +66,5 @@ export class LocalHostConnection {
             ...(host ? { upgradeHostId: host.hostId } : {}),
         });
     }
-    async close() { await this.pending?.catch(() => undefined); }
+    async close() { await this.mutation.close(); }
 }

package/dist/src/web-ui/system-host-setup/routes.d.ts

@@ -12,12 +12,14 @@ export type HostSetupRouteDependencies = {
 /** GUI writes use same-origin JSON; native code downloads use the expiring setup grant. */
 export declare class HostSetupRoutes {
     private readonly dependencies;
+    private readonly mutation;
     private readonly local;
     constructor(dependencies: HostSetupRouteDependencies);
     rejectConcurrentMutation(response: ServerResponse): boolean;
     close(): Promise<void>;
     private bundle;
     handle(request: IncomingMessage, response: ServerResponse, pathname: string): Promise<void>;
+    private issueSetupInstaller;
     private downloadBundle;
     private hasCurrentSetupGrant;
 }

package/dist/src/web-ui/system-host-setup/routes.js

@@ -5,12 +5,15 @@ import { readBody, sendJson } from "../local-runtime/http.js";
 import { hostBearerCredential } from "./native-authorization.js";
 import { renderCompanionInstaller, } from "./installers.js";
 import { InstallerInputError } from "./installer-contract.js";
+import { WINDOWS_COMPANION_STORE_URL } from "../../computer-access/companion/windows-store/identity.js";
 import { readInstallerCompanionBundle } from "./companion-bundle.js";
 import { LocalHostConnection, LOCAL_HOST_SETUP_PATH } from "./local-connection.js";
+import { handleWindowsStoreConnection, WINDOWS_STORE_CONNECTION_PATH } from "./windows-store-route.js";
+import { HostSetupMutation } from "./setup-mutation.js";
 const setupPath = "/web-api/runtime/system-host/setup";
 const bundlePath = "/web-api/runtime/system-host/bundle";
 export function isHostSetupRoute(pathname) {
-    return [setupPath, bundlePath, LOCAL_HOST_SETUP_PATH].includes(pathname);
+    return [setupPath, bundlePath, LOCAL_HOST_SETUP_PATH, WINDOWS_STORE_CONNECTION_PATH].includes(pathname);
 }
 export function sendHostSetupInputError(response, error) {
     if (!(error instanceof InstallerInputError))
@@ -37,6 +40,9 @@ function isSetupPlatformRequest(value) {
         return true;
     return platform === "windows" || platform === "macos";
 }
+function canDownloadCompanionInstaller(platform) {
+    return platform === "macos" || platform === "linux";
+}
 function requestRuntimeOrigin(request) {
     const encrypted = "encrypted" in request.socket && request.socket.encrypted;
     return new URL(`${encrypted ? "https" : "http"}://${request.headers.host}`)
@@ -45,21 +51,29 @@ function requestRuntimeOrigin(request) {
 /** GUI writes use same-origin JSON; native code downloads use the expiring setup grant. */
 export class HostSetupRoutes {
     dependencies;
+    mutation = new HostSetupMutation();
     local;
     constructor(dependencies) {
         this.dependencies = dependencies;
-        this.local = new LocalHostConnection({ ...dependencies, bundle: () => this.bundle() });
+        this.local = new LocalHostConnection({ ...dependencies, mutation: this.mutation, bundle: () => this.bundle() });
     }
     rejectConcurrentMutation(response) {
-        return this.local.rejectConcurrentMutation(response);
+        return this.mutation.rejectConcurrentMutation(response);
     }
-    async close() { await this.local.close(); }
+    async close() { await this.mutation.close(); }
     async bundle() {
         if (this.dependencies.bundleFile)
             return readFile(this.dependencies.bundleFile);
         return readInstallerCompanionBundle();
     }
     async handle(request, response, pathname) {
+        if (pathname === WINDOWS_STORE_CONNECTION_PATH) {
+            await handleWindowsStoreConnection(request, response, {
+                ...this.dependencies,
+                mutation: this.mutation,
+            });
+            return;
+        }
         if (pathname === LOCAL_HOST_SETUP_PATH) {
             await this.local.handle(request, response);
             return;
@@ -89,10 +103,21 @@ export class HostSetupRoutes {
             });
             return;
         }
-        if (this.rejectConcurrentMutation(response))
+        const platform = input.platform;
+        if (!canDownloadCompanionInstaller(platform)) {
+            sendJson(response, 410, {
+                ok: false,
+                error: "windows_store_required",
+                message: "Install or update ABot AI Companion through Microsoft Store.",
+                storeUrl: WINDOWS_COMPANION_STORE_URL,
+            });
             return;
+        }
+        await this.mutation.run(response, () => this.issueSetupInstaller(request, response, platform));
+    }
+    async issueSetupInstaller(request, response, platform) {
         const readiness = await this.dependencies.readiness();
-        if (!readiness.platforms.includes(input.platform)) {
+        if (!readiness.platforms.includes(platform)) {
             sendJson(response, 409, {
                 ok: false,
                 error: "host_setup_not_required",
@@ -103,14 +128,12 @@ export class HostSetupRoutes {
         // Read and hash the exact running build before creating a setup grant.
         const bundle = await this.bundle();
         await this.dependencies.prepareCompanion();
-        if (this.rejectConcurrentMutation(response))
-            return;
         const upgrading = Boolean(this.dependencies.store.host());
         const pairing = upgrading
             ? this.dependencies.store.beginBundleUpgrade()
             : this.dependencies.store.begin(15 * 60_000);
         const installer = await renderCompanionInstaller({
-            platform: input.platform,
+            platform,
             url: requestRuntimeOrigin(request),
             code: pairing.code,
             expiresAt: pairing.expiresAt,

package/dist/src/web-ui/system-host-setup/setup-mutation.d.ts

@@ -0,0 +1,9 @@
+import type { ServerResponse } from "node:http";
+/** One installation owns one in-flight computer setup across connection routes. */
+export declare class HostSetupMutation {
+    private pending?;
+    get busy(): boolean;
+    rejectConcurrentMutation(response: ServerResponse): boolean;
+    run(response: ServerResponse, operation: () => Promise<void>): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/src/web-ui/system-host-setup/setup-mutation.js

@@ -0,0 +1,27 @@
+import { sendJson } from "../local-runtime/http.js";
+/** One installation owns one in-flight computer setup across connection routes. */
+export class HostSetupMutation {
+    pending;
+    get busy() { return this.pending !== undefined; }
+    rejectConcurrentMutation(response) {
+        if (!this.busy)
+            return false;
+        sendJson(response, 409, { ok: false, error: "host_setup_in_progress",
+            message: "Computer access is being connected. Wait for setup to finish." });
+        return true;
+    }
+    async run(response, operation) {
+        if (this.rejectConcurrentMutation(response))
+            return;
+        const pending = Promise.resolve().then(operation);
+        this.pending = pending;
+        try {
+            await pending;
+        }
+        finally {
+            if (this.pending === pending)
+                this.pending = undefined;
+        }
+    }
+    async close() { await this.pending?.catch(() => undefined); }
+}

package/dist/src/web-ui/system-host-setup/windows-store-route.d.ts

@@ -0,0 +1,13 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { HostPairingStore } from "../../computer-access/companion/pairing-store.js";
+import type { HostReadiness } from "./readiness.js";
+import type { HostSetupMutation } from "./setup-mutation.js";
+export declare const WINDOWS_STORE_CONNECTION_PATH = "/web-api/runtime/system-host/store-connect";
+type StoreConnectionDependencies = Readonly<{
+    store: HostPairingStore;
+    readiness(): Promise<HostReadiness>;
+    prepareCompanion(): Promise<void>;
+    mutation: HostSetupMutation;
+}>;
+export declare function handleWindowsStoreConnection(request: IncomingMessage, response: ServerResponse, dependencies: StoreConnectionDependencies): Promise<void>;
+export {};

package/dist/src/web-ui/system-host-setup/windows-store-route.js

@@ -0,0 +1,68 @@
+import { COMPANION_RELEASE_VERSION } from "../../computer-access/companion/release-version.js";
+import { createStoreConnectionLink, normalizeStoreConnectionOrigin } from "../../computer-access/companion/windows-store/connection-link.js";
+import { WINDOWS_COMPANION_STORE_URL } from "../../computer-access/companion/windows-store/identity.js";
+import { acceptConfigMutationRequest } from "../local-runtime/config-mutation-request.js";
+import { readBody, sendJson } from "../local-runtime/http.js";
+export const WINDOWS_STORE_CONNECTION_PATH = "/web-api/runtime/system-host/store-connect";
+function canStartWindowsStoreConnection(readiness) {
+    if (!readiness.platforms.includes("windows"))
+        return false;
+    if (readiness.restartRequired)
+        return false;
+    if (readiness.route === "wsl_interop")
+        return false;
+    return readiness.route !== "native";
+}
+function hasEmptyConnectionBody(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return false;
+    return Object.keys(value).length === 0;
+}
+export async function handleWindowsStoreConnection(request, response, dependencies) {
+    response.setHeader("Cache-Control", "no-store");
+    if (request.method !== "POST") {
+        sendJson(response, 405, { ok: false, error: "method_not_allowed" });
+        return;
+    }
+    if (!acceptConfigMutationRequest(request, response))
+        return;
+    let body;
+    try {
+        body = JSON.parse((await readBody(request, { maxBytes: 1_024 })).toString());
+    }
+    catch { /* rejected below */ }
+    if (!hasEmptyConnectionBody(body)) {
+        sendJson(response, 400, { ok: false, error: "invalid_store_connection_request" });
+        return;
+    }
+    await dependencies.mutation.run(response, () => issueWindowsStoreConnection(request, response, dependencies));
+}
+async function issueWindowsStoreConnection(request, response, dependencies) {
+    if (!canStartWindowsStoreConnection(await dependencies.readiness())) {
+        sendJson(response, 409, { ok: false, error: "host_setup_not_required", message: "Refresh the computer connection status." });
+        return;
+    }
+    const encrypted = "encrypted" in request.socket && request.socket.encrypted;
+    let origin;
+    try {
+        origin = normalizeStoreConnectionOrigin(`${encrypted ? "https" : "http"}://${request.headers.host}`);
+    }
+    catch {
+        sendJson(response, 400, { ok: false, error: "host_store_connection_rejected", message: "Store connection requires a local HTTP Runtime origin on this computer." });
+        return;
+    }
+    await dependencies.prepareCompanion();
+    const previous = dependencies.store.host();
+    const pairing = previous ? dependencies.store.beginBundleUpgrade() : dependencies.store.begin(15 * 60_000);
+    try {
+        const launchUrl = createStoreConnectionLink({
+            version: 1, url: origin, code: pairing.code, expiresAt: pairing.expiresAt,
+            companionRelease: COMPANION_RELEASE_VERSION,
+            ...(previous ? { upgradeHostId: previous.hostId } : {}),
+        });
+        sendJson(response, 200, { ok: true, launchUrl, expiresAt: pairing.expiresAt, storeUrl: WINDOWS_COMPANION_STORE_URL });
+    }
+    catch {
+        sendJson(response, 400, { ok: false, error: "host_store_connection_rejected", message: "Store connection requires a local HTTP Runtime origin on this computer." });
+    }
+}

package/docs/configuration.md

@@ -17,6 +17,21 @@ local paths, and profile choices there. The provider, concrete model id, and
 default profile are required configuration; the runtime does not supply a
 built-in model choice.
 
+## Web UI history pages
+
+`webUi.pageSize` controls the number of sessions or messages loaded per page in
+ordinary conversations and SPARK. It defaults to `20` and accepts a positive integer:
+
+```json
+{ "webUi": { "pageSize": 20 } }
+```
+
+The Web UI loads more sessions while scrolling down and older messages while
+scrolling up. Message activity travels with the corresponding message page.
+Read state and active requests remain independent of the displayed page.
+Pagination does not truncate model history or change the session file format;
+opening a conversation still reads its canonical JSON file before projecting a page.
+
 ## Secrets
 
 Do not put secret values in JSON config. Store them in `.env`, service
@@ -427,6 +442,37 @@ secrets declarations, and skill bindings remain in each plugin package.
 Runtime orchestration does not hardcode concrete tool names or use the catalog
 to classify the user request.
 
+
+A model profile can further restrict that catalog with `plugins.deny`, including
+inside its linked `models/<profile>.config.json` file:
+
+```json
+{
+  "plugins": {
+    "deny": ["filesystem.read_file", "memory"]
+  }
+}
+```
+
+These selectors use the same matching rules as the global deny list. They can
+only remove globally available capabilities. Omission or an empty list adds no
+model restriction. The effective primary profile selected for the request owns
+the restriction for the entire request, including delegated roles, per-step
+model overrides and approval resumes. Both Supervisor/Worker and Execution
+Agent use the same filtered catalog and execution guard. This metadata stays in
+the Runtime and is not sent to the model provider. Plugin loading and
+`prepareRequest` hooks remain part of the existing shared plugin lifecycle.
+
+In the Web UI **Models** workspace, expand **Plugin access** to allow or block
+plugins for the selected model. Expand a plugin to control its individual tools.
+The switches edit exact plugin IDs and qualified `plugin.tool` deny selectors;
+turning a plugin off and on preserves its individual tool restrictions. Counts
+show the tools available after global and model restrictions. Save the model
+file, then apply configuration changes. Global restrictions still apply and
+cannot be lifted here. Shared bare-tool rules, wildcards, missing-plugin IDs and
+selectors that affect another plugin remain unchanged; review them under
+**Saved rules** and edit them in the displayed model configuration file.
+
 For public or multi-model installs, keep each model's detailed calibration in a
 separate model profile file instead of expanding the main runtime config:
 

package/docs/installation.md

@@ -145,6 +145,42 @@ Computer access connection shared by SYSTEM tools, ABot Spark and compatible
 plugins. Direct native/WSL command access can already work; the shared companion
 adds desktop access and background collection without a second ABot Spark setup.
 
+#### Windows: Microsoft Store connection
+
+**ABot AI Companion** is available from
+[Microsoft Store](https://apps.microsoft.com/detail/9PK2FDQQLQS9).
+The product ID is `9PK2FDQQLQS9`.
+
+Start with the computer connection card on **Home**, or the optional **Computer**
+setup step:
+
+1. Choose **Install from Microsoft Store** to open **ABot AI Companion**.
+2. Install it once on the Windows computer you want to connect.
+3. Return to ABot and choose **I already have it**.
+4. Choose **Open Companion**. The browser may ask permission to open it.
+5. Check the Runtime address shown by Companion and approve the connection.
+6. Companion shows connection progress; this can take a few seconds. Wait for
+   **Your computer is ready** in the Web UI.
+
+If Companion is already installed, start at step 3. The short-lived connection
+link is a private invitation; do not share it. Request a new link if it expires.
+The Web UI confirms the live connection rather than guessing whether the app is
+installed.
+
+If the computer is already paired but offline, choose **Open Companion**, then
+start the saved connection in the app. If you disconnected inside Companion or
+removed its saved connection, choose **Set up again** in ABot. Confirm the
+reset, then open Companion and approve the new connection. Re-pairing revokes the
+previous computer connection; it does not erase saved insights.
+
+Store updates are intended to preserve the saved pairing. Computer actions and
+optional Spark collection retain their existing, separate permission controls.
+Computer content used by ABot may reach your selected model provider. Installation
+alone does not start Spark collection. See [Windows Companion Store delivery](windows-companion-store.md)
+for connection details and update compatibility.
+
+#### macOS
+
 When ABot runs natively on your Mac, open its local Web UI and choose **Connect
 this Mac**. ABot uses its installed Node runtime and companion bundle, pairs the
 computer and enables startup at sign-in. This path does not download a Finder
@@ -205,11 +241,15 @@ not change Computer access pairing or send a model request. Application-specific
 Automation/Apple Events and protected-file access may still require separate
 consent for the applications or locations used by a later SYSTEM command.
 
-For Windows or Linux, download setup and run it in that computer's graphical
-login. Windows setup installs the companion and a private Node runtime; Linux
-uses an existing Node.js installation. Setup pairs automatically and enables
-startup at sign-in. Wait for **Ready** in the Web UI; downloading alone does not
-establish a connection. WSL uses the same Windows companion setup, which does
+#### Linux and WSL
+
+For Linux, download setup and run it in that computer's graphical login. Setup
+uses an existing Node.js installation, pairs automatically and enables startup
+at sign-in. Wait for **Ready** in the Web UI; downloading alone does not establish
+a connection. This Linux flow is unchanged by the Windows Store integration.
+
+Running ABot in WSL and existing WSL interop access are unchanged. To connect the
+Windows desktop to a WSL Runtime, use the Windows Companion flow above; it does
 not require changing interop settings or restarting the distribution.
 
 Installation does not enable ABot Spark collection or disabled plugin tools.
@@ -355,22 +395,3 @@ profile without changing runtime policy or another model's settings.
 
 The repository ignores `.env`, `local/runtime.config.json`, `.runtime/`, and
 `dist/`. Do not commit local secrets or generated runtime state.
-
-## Verify Package Surface
-
-Before publishing or opening a release PR:
-
-```bash
-npm test -- --run
-npm run build
-npm run smoke:runtime-package
-npm run check:runtime-package
-npm run smoke:packed-runtime-package
-git diff --check
-```
-
-`npm run build` regenerates `runtime.config.schema.json`, clears stale `dist`,
-and compiles the published TypeScript declarations.
-
-For the full public release checklist, see
-[`docs/publishing.md`](publishing.md).

package/docs/plugins.md

@@ -16,6 +16,9 @@ the same physical directory, the catalog is discovered only once.
 Open **Plugins** to see installed manifests, capability counts,
 and enabled, partially enabled or disabled selections. Switches save the selected
 plugin's configuration while preserving capability-specific allow/deny rules.
+Whole-plugin switches use `plugins.disabledPluginIds`, an exact list of plugin
+IDs independent of capability names and qualified selectors. The list does not
+interpret wildcards; legacy `allow` and `deny` rules keep their existing meaning.
 Choose **Manage tools** on a plugin to manage its declared tools inside the same card.
 The card keeps its size; the tool list scrolls when needed. Use **Back** or Escape
 to return to the plugin overview. For example, disabling filesystem.read_file
@@ -26,14 +29,164 @@ tools switched off.
 Global, parent-plugin and broad tool deny rules remain explicit blockers.
 A child switch does not silently remove those rules or enable sibling tools.
 
+Install, configuration saves, enable/disable and Remove require every owning Runtime to be idle.
+While a conversation or Job is running, these actions return a clear message
+without saving the requested change. Open but idle conversations do not block
+changes; browsing and reviewing repositories remain available. If another process
+owns an environment, use the owning Web UI so its activity can be verified.
+
 Choose **Apply changes** to activate saved settings. The Web process replaces
 only its own idle environments and preserves session and Job files. If any
 environment is working, or another process owns it, changes remain saved and
 the UI explains why they cannot yet be applied. Saving a switch alone does not
 change tools available to an already running agent.
 
-This screen manages packages already installed on disk; it does not install
-plugins from a marketplace.
+## Configure Plugin Values
+
+Choose **Configure** on an installed plugin, or use the same form during its
+installation review. Fields come from the existing `settings.defaults` and
+`secrets` declarations. Strings, numbers and booleans use ordinary controls;
+objects, arrays and null defaults use JSON. The host checks declared setting
+names and top-level default types. A null default supplies no type information;
+semantic checks such as URL validity remain the plugin's responsibility.
+The form shows whether each setting uses the plugin default or a local value.
+Saving credentials alone leaves inherited defaults unchanged. Editing a setting
+creates a local override, even when its value equals today's default; **Use plugin
+default** removes that override when saved. Existing saved values stay local until
+explicitly reset, so no upgrade automatically rewrites a user's configuration.
+No manifest schema or SDK changes are required. If an upgraded plugin changes a
+setting's default type, an incompatible retained value blocks loading with an
+explicit configuration error. Configure remains available to correct the value;
+the host does not silently replace it with a default.
+
+**Save changes** persists values locally; **Apply changes** loads them into new
+idle Runtime owners. Existing owners retain their loaded values, including when
+activation fails and restores the previous configuration. GET returns settings
+and credential-presence flags, never secret values. Passwords remain in their
+mounted controls until submitted, and are cleared after submission.
+
+Values are shared across environments of the same consumer root and are stored
+in `<consumer-root>/.runtime/plugin-configuration.json`, outside plugin packages,
+with owner-only file permissions. On POSIX, an existing file with any group or
+other-user permission is rejected before its contents are read. Restore its
+permissions with `chmod 600 .runtime/plugin-configuration.json` from the installation
+root; the host does not change permissions automatically. They are local plaintext
+configuration, not an
+encrypted vault. This file must not be committed, published, or shared with a
+plugin repository. The existing `.runtime/` exclusion also keeps it out of Git
+and packages. Settings override declared defaults; undeclared settings are not
+passed to plugins. A locally configured secret is bound to its declared name
+and environment-variable name and is delivered through `context.secrets.get`.
+Without a local override, the existing process environment remains the source.
+Saving plugin values does not write `.env` or change `process.env`. Browser revision
+tokens use a private process key rather than an unkeyed digest of secret-bearing
+content. Reload an open form after restarting its Web UI process.
+
+Keys removed from the current manifest, or whose environment binding changed,
+appear under **Keys no longer used by this plugin** without exposing their values.
+They remain saved until the user selects **Delete saved key** and saves. Ordinary
+settings edits do not delete them. A changed binding under the same key name
+requires explicitly deleting the old saved key before setting or clearing its
+replacement; both choices can be submitted in one save. Configure remains
+available for these keys even when the plugin has no current settings or secrets.
+
+For each secret, keep the current value, replace it, or explicitly clear it.
+Clear suppresses an inherited value for this plugin without deleting a shared
+environment variable. Clearing a required secret prevents the plugin from
+loading on the next Apply until the key is configured again. Remove retains
+local settings and secrets; a later installation review shows the retained
+settings and presence flags. Required secrets are checked before installation
+commits, and failed selection saves roll back the local configuration and package.
+
+## Install Community Plugins
+
+The **Installed** tab manages the existing catalog. **Discover** links to the
+[ABot Marketplace](https://abot-ai.com/marketplace/) and installs public GitHub packages independently of that directory.
+The Marketplace is a directory of community-owned repositories; listing approval
+does not grant a repository permission to run on a user's machine.
+
+Paste a repository URL in **Discover**, optionally choosing a branch, tag or
+commit and a folder inside the repository. **Review plugin** resolves the source
+to an exact commit, validates the manifest and its declared files without
+executing plugin code, and displays its tools and configuration form.
+Fill in required secrets before confirming installation.
+**Install and enable** downloads the same commit, checks the reviewed content
+digest, and installs it at `<consumer-root>/plugins/<manifest.name>`. Existing
+plugin IDs and capability IDs are rejected; this flow never replaces a plugin.
+Package publication and selection saving share the configuration lock with Apply;
+a failed save removes the uncommitted package before Apply can discover it.
+The normal configuration controls and global restrictions still apply.
+The review offers **Install and enable** at both ends. After installation, the
+UI returns to **Installed** with a status message. Choose **Apply changes** to
+load the plugin into the Runtime.
+
+Publishers must commit a complete package: `plugin.json`, its built CommonJS
+`.cjs` entrypoint, referenced skills and all required assets. Bundle dependencies
+that are not supplied by the public plugin SDK. Installation does not execute
+`npm install`, build commands, lifecycle scripts or repository code. Public HTTPS
+repositories on `github.com` are supported; private repositories, updates and
+Studio packages are outside this first installation flow. Repository ZIPs are
+limited to 25 MiB and 2,000 entries, with at most 16 MiB per extracted file and
+64 MiB total. Symlinks, traversal and non-portable filenames are rejected.
+
+### Install In ABot Links
+
+Computer Access setup registers the `abot:` URL scheme on Windows, macOS and
+Linux desktops. Existing installations can use **Update** in Computer Access
+to install Companion release 12 and register links while keeping their pairing.
+A website can render an ordinary link using this contract:
+
+```js
+const link = new URL("abot://install");
+link.searchParams.set("kind", "plugin");
+link.searchParams.set("repo", "https://github.com/owner/plugin");
+link.searchParams.set("ref", "v1.0.0"); // optional; a commit is recommended
+link.searchParams.set("path", "plugins/example"); // optional repository folder
+installAnchor.href = link.toString();
+```
+
+Clicking the link opens **Discover** in the Runtime saved in the local Computer
+Access pairing, with the source ready for review. A link cannot choose another
+Runtime address or bypass local installation confirmation. The browser may ask
+to open ABot. Without Computer Access, users can paste the same repository URL.
+Companion disconnect/uninstall removes its owned protocol registration.
+
+The local API uses `POST /runtime/plugins/inspect` with
+`{ repository, ref?, path? }`, returning `{ ok, review }`.
+Installation uses `POST /runtime/plugins/install` with
+`{ source: review.source, digest: review.digest }`. Both require same-origin
+JSON requests and completed Runtime setup. These APIs operate on the configured
+consumer root and configuration file; they do not depend on the Marketplace.
+
+## Remove Community Plugins
+
+**Remove** is available in the ongoing Plugins screen for packages installed by
+this GitHub flow. After confirmation, it saves a disable, applies configuration
+through the existing idle-owner checks, and only then deletes the installed
+folder. Built-in plugins and manually copied folders without an installation
+receipt do not offer Remove. Removal adds only the target's exact ID to
+`plugins.disabledPluginIds`, so names shared with other tools or qualified
+selectors cannot change another plugin's selection.
+
+If work starts after the disable was saved but before Apply, the files remain.
+Finish the active work, then choose **Remove** again. A failed Apply or any
+concurrent configuration change also prevents deletion. Removal verifies the
+moved directory before deleting it and retires its cached CommonJS modules so
+a later installation loads the new entrypoint and package-local dependencies.
+Selection rules remain in the configuration so removal cannot widen another
+plugin's allow policy. Installing the same plugin again clears its exact disabled
+ID and preserves other disabled IDs and capability-specific deny rules. Existing
+qualified denies are not inferred to be removal-generated; review such legacy
+rules explicitly in Advanced settings if they still disable the tools.
+
+`POST /runtime/plugins/remove` accepts `{ pluginId }`, with the same origin,
+JSON and completed-setup requirements as installation. It returns `removed`,
+`activation`, a status message and the refreshed plugin snapshot. This removes
+the installed plugin folder, including data the plugin kept inside it; files
+stored elsewhere are retained. If Apply succeeds but a later removal check fails,
+the error retains its HTTP status and code and includes `activation` with status
+`ready`. The UI refreshes the active environments; `config_changed` still marks
+the newer saved configuration as pending activation.
 
 ## Package Shape
 
@@ -143,6 +296,16 @@ input, effect, and approval. Optional capability metadata such as client event
 presentation, payload authoring, development roles, and selection grounding
 belongs here as well—not in runtime orchestration.
 
+An operation may declare `outputChannels` alongside `summary`, for example
+`{"text":"content","data":"metadata"}`. Both fields are required when declared:
+`content` can carry substantive output (possibly bounded or summarized),
+`metadata` contains only identifiers/status/counts/receipts, and `conditional`
+depends on the operation inputs. Omission means unknown, not metadata. This
+passive declaration describes the saved Studio channels, not every field in a
+chat tool result; it changes no execution or binding behavior. Only selected
+Studio `prepare_draft` operations expose it to models; ordinary tool summaries
+and discovery stay concise. Whole Data bindings do not need field pointers.
+
 A plugin declares sensitive operations with `approval: "always"` in its
 manifest, as the bundled EXEC and SYSTEM plugins do. Apply that policy to every
 operation when the whole plugin is sensitive. The generic approval boundary