@capybara-hq/kernel 0.1.0-rc.12 → 0.1.0-rc.14

package/dist/tools/builtins/sandbox/bash.js

@@ -142,15 +142,15 @@ async function runInBackground(deps, ctx, input) {
     const requested = input.timeout;
     const seconds = Math.max(1, Math.ceil(Math.min(requested ?? maxMs, maxMs) / 1000));
     const root = sandboxConversationOf(ctx);
-    // the environment the task will run in (the root conversation's, bound for good)
-    let environmentId;
+    // the device the task will run in (the root conversation's, bound for good)
+    let deviceId;
     try {
-        environmentId = await deps.environments.forTool(ctx.orgId, root);
+        deviceId = await deps.devices.forTool(ctx.orgId, root);
     }
     catch (e) {
         throw mapSandboxError(e, deps.log);
     }
-    if (!(await sandbox.availableFor(environmentId)))
+    if (!(await sandbox.availableFor(deviceId)))
         throw noSandboxError();
     const maxTasks = cfg.sandbox.background.maxTasks;
     const id = newTaskId();
@@ -161,7 +161,7 @@ async function runInBackground(deps, ctx, input) {
         orgId: ctx.orgId,
         conversationId: ctx.conversationId,
         sandboxConversationId: root,
-        environmentId,
+        deviceId,
         runId: ctx.runId,
         callId: ctx.callId,
         // the run's trigger account (the pipeline passes `runs.trigger_account_id` as `accountId`)
@@ -238,7 +238,7 @@ async function runInBackground(deps, ctx, input) {
             const sid = out;
             try {
                 // under the shared lease: no rebuild can come between the launch and this read
-                const instance = await currentInstance(environmentId);
+                const instance = await currentInstance(deviceId);
                 if (instance === null)
                     throw new Error("the sandbox instance could not be read");
                 const marked = await background.markStarted(id, {

package/dist/tools/builtins/sandbox/common.d.ts

@@ -5,7 +5,7 @@ import type { BackgroundTaskStore } from "../../../background/store.js";
 import type { KernelConfig } from "../../../config/schema.js";
 import type { AttachmentsService } from "../../../conversations/attachments.service.js";
 import type { EventLog } from "../../../conversations/event-log.js";
-import { type ConversationEnvironments } from "../../../environments/conversation-environments.js";
+import { type ConversationDevices } from "../../../devices/conversation-devices.js";
 import type { KernelConfigService } from "../../../infra/config/kernel-config.service.js";
 import { type HeldProvider, type SandboxService } from "../../../sandbox/sandbox.service.js";
 import type { StorageService } from "../../../storage/storage.service.js";
@@ -19,11 +19,11 @@ export interface SandboxToolDeps {
      */
     sandbox: Pick<SandboxService, "cloudAvailable" | "availableFor" | "withSandbox"> & Partial<Pick<SandboxService, "pathLease" | "currentInstance" | "ifRunning">>;
     /**
-     * The environment a call enters: the root conversation's, checked for its owner every call.
+     * The device a call enters: the root conversation's, checked for its owner every call.
      * `usableNow` (absent in test stubs: only the cloud provider counts) tells a listing whether a
-     * conversation's environment can run without a cloud provider (ruling R8).
+     * conversation's device can run without a cloud provider (ruling R8).
      */
-    environments: Pick<ConversationEnvironments, "forTool"> & Partial<Pick<ConversationEnvironments, "usableNow">>;
+    devices: Pick<ConversationDevices, "forTool"> & Partial<Pick<ConversationDevices, "usableNow">>;
     /** Background `Bash` tasks; absent in test stubs, where `run_in_background` is refused. */
     background?: Pick<BackgroundTaskStore, "reserve" | "markStarted" | "failLaunch" | "finishStoppedLaunch" | "releaseStop" | "get" | "advanceOffset">;
     /**
@@ -38,7 +38,7 @@ export interface SandboxToolDeps {
     storage: Pick<StorageService, "kernel" | "deployment" | "available">;
     /**
      * `publishChanged`: `Deliver` announces `changed: files` (UI refresh B). `latestOfType` reads the
-     * conversation's latest `environment_paths` (absent in test stubs, which record none).
+     * conversation's latest `device_paths` (absent in test stubs, which record none).
      */
     eventLog: Pick<EventLog, "append" | "latestFileState"> & Partial<Pick<EventLog, "publishChanged" | "latestOfType">>;
     config: Pick<KernelConfigService, "get">;
@@ -51,22 +51,22 @@ export interface SandboxToolDeps {
  * every provider call).
  */
 export interface SandboxSession {
-    /** The environment the call runs in (path leases are taken on it). */
-    environmentId: string;
+    /** The device the call runs in (path leases are taken on it). */
+    deviceId: string;
     h: SandboxHandle;
     /** The instance's roots: every path the call builds or checks is under one of them. */
     roots: SandboxRoots;
     p: HeldProvider;
     signal: AbortSignal;
 }
-/** This conversation's first use of its environment (in the instance's workspace). */
+/** This conversation's first use of its device (in the instance's workspace). */
 export declare const sandboxStartedNotice: (roots: SandboxRoots) => string;
 /** {@link sandboxStartedNotice} of an instance with the default roots. */
 export declare const SANDBOX_STARTED_NOTICE: string;
-/** A new instance came up on the environment's kept files. */
-export declare const SANDBOX_RESTARTED_NOTICE = "The environment's instance was restarted; files are kept, running processes are gone and temporary files may be gone.";
+/** A new instance came up on the device's kept files. */
+export declare const SANDBOX_RESTARTED_NOTICE = "The device's instance was restarted; files are kept, running processes are gone and temporary files may be gone.";
 /**
- * The environment's files were reset (on request, or after they were lost) since this conversation
+ * The device's files were reset (on request, or after they were lost) since this conversation
  * last used it.
  */
 export declare const sandboxFilesResetNotice: (roots: SandboxRoots) => string;
@@ -83,13 +83,13 @@ export declare function noSandboxError(): ToolError;
 export declare const SANDBOX_UNREACHABLE_TEXT = "The sandbox provider can't be reached (the connection failed), so this call did nothing in the sandbox; retrying won't help until a super admin checks the sandbox extension's configuration (Admin console \u2192 Extensions). Continue without the sandbox, or ask the person to have a super admin check it.";
 /** A provider connection that broke during the call: the provider may have acted before it broke. */
 export declare const SANDBOX_CONNECTION_DROPPED_TEXT = "The connection to the sandbox provider broke during this call, so it may or may not have taken effect; check the sandbox state before retrying. If it fails again, continue without the sandbox and ask the person to have a super admin check the sandbox extension's configuration (Admin console \u2192 Extensions).";
-/** The directory of attachments in the environment (each conversation has a subdirectory). */
+/** The directory of attachments in the device (each conversation has a subdirectory). */
 export declare const attachmentsRoot: (roots: SandboxRoots) => string;
 /** {@link attachmentsRoot} of an instance with the default roots. */
 export declare const ATTACHMENTS_ROOT: string;
 /**
  * One conversation's attachment directory: the first 12 hex digits of the root conversation's
- * UUID, so conversations sharing an environment do not overwrite each other's files.
+ * UUID, so conversations sharing a device do not overwrite each other's files.
  */
 export declare const attachmentsDir: (roots: SandboxRoots, rootConversationId: string) => string;
 /** The conversation's marker of synced attachments: `{ <attachment id>: <file name> }`. */
@@ -144,7 +144,7 @@ export declare function clip(s: string, max: number): string;
 export declare function withNotices(notices: readonly string[], text: string): string;
 /**
  * The root-independent checks of a path (`validateSandboxPathShape`: non-empty, absolute, no
- * control characters, no empty or `..` segments), run before the call enters its environment, so
+ * control characters, no empty or `..` segments), run before the call enters its device, so
  * a malformed path never creates or resumes an instance; root membership is checked inside
  * ({@link checkPath}).
  */
@@ -176,41 +176,41 @@ export declare function assignAttachmentNames(items: readonly {
  */
 export declare function mapSandboxError(e: unknown, log: Pick<Logger, "warn"> | undefined): unknown;
 /**
- * Runs `fn` in the environment of the call's conversation (a sub-agent: its root's): resolves and
- * checks the environment for the conversation's owner (binding an unbound conversation to the
+ * Runs `fn` in the device of the call's conversation (a sub-agent: its root's): resolves and
+ * checks the device for the conversation's owner (binding an unbound conversation to the
  * owner's default first), then `SandboxService.withSandbox` (the instance created, resumed or
  * rebuilt on the kept files as needed, every `exec` carrying the call's actor). Attachments are
  * synced first. Returns the value and the notices to put before the result (first use, a new
  * instance, newly copied attachments). When `withSandbox` rebuilds a gone instance and calls
  * `fn` again, the notices are the last call's. The instance's roots are recorded for the model
- * on the conversation's first call and whenever they change ({@link recordEnvironmentPaths}).
+ * on the conversation's first call and whenever they change ({@link recordDevicePaths}).
  */
 export declare function inSandbox<T>(deps: SandboxToolDeps, ctx: BuiltinCallContext, fn: (s: SandboxSession) => Promise<T>): Promise<{
     value: T;
     notices: string[];
 }>;
-/** The conversation whose environment a call uses (the root conversation's for a sub-agent). */
+/** The conversation whose device a call uses (the root conversation's for a sub-agent). */
 export declare const sandboxConversationOf: (ctx: BuiltinCallContext) => string;
 /**
- * Runs `fn` under the per-path lease of `path` in the session's environment (spec §10.4: the
+ * Runs `fn` under the per-path lease of `path` in the session's device (spec §10.4: the
  * kernel's own read-modify-write of one file never loses another holder's update, from any
- * conversation sharing the environment). `fn` gets `signal` combined with the path lease's: pass
+ * conversation sharing the device). `fn` gets `signal` combined with the path lease's: pass
  * it to every provider call, so a lost path lease stops the write. Without `pathLease` (test
  * stubs) it just runs `fn` with `signal`.
  */
-export declare function withPathLease<T>(deps: Pick<SandboxToolDeps, "sandbox">, s: Pick<SandboxSession, "environmentId">, path: string, signal: AbortSignal, fn: (signal: AbortSignal) => Promise<T>): Promise<T>;
+export declare function withPathLease<T>(deps: Pick<SandboxToolDeps, "sandbox">, s: Pick<SandboxSession, "deviceId">, path: string, signal: AbortSignal, fn: (signal: AbortSignal) => Promise<T>): Promise<T>;
 /**
  * Whether a sandbox tool call of the conversation tree rooted at `conversationId` can run: a
- * cloud provider is loaded, or (ruling R8) the conversation's environment runs on a registered
- * kernel provider (`@device`). Without a conversation only the cloud provider counts.
+ * cloud provider is loaded, or (ruling R8) the conversation's device runs on a registered
+ * kernel provider (`@local`). Without a conversation only the cloud provider counts.
  */
-export declare function sandboxUsable(deps: Pick<SandboxToolDeps, "sandbox" | "environments">, orgId: string, conversationId: string | undefined): Promise<boolean>;
+export declare function sandboxUsable(deps: Pick<SandboxToolDeps, "sandbox" | "devices">, orgId: string, conversationId: string | undefined): Promise<boolean>;
 /**
  * The reason the registry reports the sandbox tools unavailable with, or null when they can run
  * ({@link sandboxUsable}; the listing passes the root conversation of the run). An eval replay
  * lists them as available (`replay`: its calls are never executed). `memo` (one per listing)
  * makes every sandbox tool of a listing share one answer.
  */
-export declare const unavailableWhenNoSandbox: (deps: Pick<SandboxToolDeps, "sandbox" | "environments">) => (ctx: ToolListingScope) => Promise<string | null>;
+export declare const unavailableWhenNoSandbox: (deps: Pick<SandboxToolDeps, "sandbox" | "devices">) => (ctx: ToolListingScope) => Promise<string | null>;
 /** 读出的字节是否像二进制（开头 8 KB 里有 NUL）。 */
 export declare function looksBinary(data: Uint8Array): boolean;

package/dist/tools/builtins/sandbox/common.js

@@ -1,25 +1,25 @@
 import { DEFAULT_SANDBOX_ROOTS, DeviceProtocolError, isFileSystemGoneError, isSandboxGoneError, ToolError, validateSandboxPath, validateSandboxPathShape, } from "@capybara-hq/plugin-sdk";
-import { ANONYMOUS_NO_ENVIRONMENT, } from "../../../environments/conversation-environments.js";
+import { ANONYMOUS_NO_DEVICE, } from "../../../devices/conversation-devices.js";
 import { ApiError } from "../../../errors.js";
-import { environmentPathsChange } from "../../../runtime/context/environment-paths.js";
+import { devicePathsChange } from "../../../runtime/context/device-paths.js";
 import { SandboxPathBusyError } from "../../../sandbox/leases.js";
 import { SandboxLockLostError, } from "../../../sandbox/sandbox.service.js";
 import { SandboxProviderUnreachableError } from "../../../sandbox/unreachable.js";
 // ---- 模型可见文案（英文） ----
-/** This conversation's first use of its environment (in the instance's workspace). */
-export const sandboxStartedNotice = (roots) => `Environment started (first use in this conversation); the working directory is ${roots.workspace}, shared with the environment's other conversations.`;
+/** This conversation's first use of its device (in the instance's workspace). */
+export const sandboxStartedNotice = (roots) => `Device started (first use in this conversation); the working directory is ${roots.workspace}, shared with the device's other conversations.`;
 /** {@link sandboxStartedNotice} of an instance with the default roots. */
 export const SANDBOX_STARTED_NOTICE = sandboxStartedNotice(DEFAULT_SANDBOX_ROOTS);
-/** A new instance came up on the environment's kept files. */
-export const SANDBOX_RESTARTED_NOTICE = "The environment's instance was restarted; files are kept, running processes are gone and temporary files may be gone.";
+/** A new instance came up on the device's kept files. */
+export const SANDBOX_RESTARTED_NOTICE = "The device's instance was restarted; files are kept, running processes are gone and temporary files may be gone.";
 /**
- * The environment's files were reset (on request, or after they were lost) since this conversation
+ * The device's files were reset (on request, or after they were lost) since this conversation
  * last used it.
  */
-export const sandboxFilesResetNotice = (roots) => `The environment's files were reset; earlier files in ${roots.workspace} and running processes are gone and temporary files may be gone, so recreate anything you still need.`;
+export const sandboxFilesResetNotice = (roots) => `The device's files were reset; earlier files in ${roots.workspace} and running processes are gone and temporary files may be gone, so recreate anything you still need.`;
 /** {@link sandboxFilesResetNotice} of an instance with the default roots. */
 export const SANDBOX_FILES_RESET_NOTICE = sandboxFilesResetNotice(DEFAULT_SANDBOX_ROOTS);
-const BUSY_TEXT = "The environment is busy: all its command slots are taken by commands of this or another conversation sharing it; wait for one to finish and retry.";
+const BUSY_TEXT = "The device is busy: all its command slots are taken by commands of this or another conversation sharing it; wait for one to finish and retry.";
 const NO_SANDBOX_TEXT = "No sandbox is configured in this deployment; ask an administrator to install a sandbox plugin, or do the task without the sandbox.";
 /** 没有沙箱提供方时「工具不可用」的原因（进提醒，内核在后面补句号）：与调用时的错误同一句话。 */
 export const SANDBOX_UNAVAILABLE_REASON = NO_SANDBOX_TEXT.slice(0, -1);
@@ -27,12 +27,12 @@ export const SANDBOX_UNAVAILABLE_REASON = NO_SANDBOX_TEXT.slice(0, -1);
 export function noSandboxError() {
     return new ToolError(NO_SANDBOX_TEXT);
 }
-const PATH_BUSY_TEXT = "Another sub-agent or another conversation in this environment is writing this file; wait a moment and retry.";
+const PATH_BUSY_TEXT = "Another sub-agent or another conversation on this device is writing this file; wait a moment and retry.";
 const ANONYMOUS_TEXT = "The sandbox is not available to anonymous IM senders; do the task without the sandbox, or ask the person to link their account and start a new conversation.";
-const ENV_NOT_FOUND_TEXT = "This conversation's environment was deleted or its owner can no longer use it; ask the user to start a new conversation in another environment.";
-const ENV_FORBIDDEN_TEXT = "This conversation's owner may no longer use its environment; ask the user to start a new conversation in an environment they can use.";
-const ENV_UNAVAILABLE_TEXT = "This conversation's environment is kept by a sandbox provider that is not active in this deployment; ask the user to start a new conversation in another environment, or an administrator to re-enable that provider.";
-const ENV_FILES_LOST_TEXT = "This environment's files are gone. Ask the user to reset its files on the environments page, then retry.";
+const ENV_NOT_FOUND_TEXT = "This conversation's device was deleted or its owner can no longer use it; ask the user to start a new conversation on another device.";
+const ENV_FORBIDDEN_TEXT = "This conversation's owner may no longer use its device; ask the user to start a new conversation on a device they can use.";
+const ENV_UNAVAILABLE_TEXT = "This conversation's device is kept by a sandbox provider that is not active in this deployment; ask the user to start a new conversation on another device, or an administrator to re-enable that provider.";
+const ENV_FILES_LOST_TEXT = "This device's files are gone. Ask the user to reset its files on the devices page, then retry.";
 /**
  * A provider call that never connected (refused, unknown host, unreachable network): the request
  * did not reach the provider, so the call did nothing in the sandbox.
@@ -40,20 +40,20 @@ const ENV_FILES_LOST_TEXT = "This environment's files are gone. Ask the user to
 export const SANDBOX_UNREACHABLE_TEXT = "The sandbox provider can't be reached (the connection failed), so this call did nothing in the sandbox; retrying won't help until a super admin checks the sandbox extension's configuration (Admin console → Extensions). Continue without the sandbox, or ask the person to have a super admin check it.";
 /** A provider connection that broke during the call: the provider may have acted before it broke. */
 export const SANDBOX_CONNECTION_DROPPED_TEXT = "The connection to the sandbox provider broke during this call, so it may or may not have taken effect; check the sandbox state before retrying. If it fails again, continue without the sandbox and ask the person to have a super admin check the sandbox extension's configuration (Admin console → Extensions).";
-const DEVICE_FILES_LOST_TEXT = "This environment's directory is gone from its connected machine. Ask the person to run capybara-device logout, then capybara-device login into this environment, on that machine, then retry.";
-const FILES_GONE_TEXT = "This environment's files are gone. Ask the user to reset its files on the environments page (for a connected machine: to run capybara-device logout, then capybara-device login, on it), then retry.";
-const DEVICE_OFFLINE_TEXT = "The connected machine is offline. Ask the person to start capybara-device on it.";
-const DEVICE_OUTDATED_TEXT = "The connected machine runs an outdated capybara-device. Ask the person to update it on that machine and start it again.";
-const DEVICE_REVOKED_TEXT = "The connected machine of this environment was disconnected. Ask the person to run capybara-device logout, then capybara-device login on it, or to start a new conversation in another environment.";
-const deviceProtocolText = (detail) => `The connected machine sent an answer the platform cannot read (${detail}). Ask the person to update capybara-device on that machine, then retry.`;
+const DEVICE_FILES_LOST_TEXT = "This device's directory is gone from the device's machine. Ask the person to run capybara-device logout, then capybara-device login into this device, on that machine, then retry.";
+const FILES_GONE_TEXT = "This device's files are gone. Ask the user to reset its files on the devices page (for a local device: to run capybara-device logout, then capybara-device login, on it), then retry.";
+const DEVICE_OFFLINE_TEXT = "The device's machine is offline. Ask the person to start capybara-device on it, or to start a new conversation on another device.";
+const DEVICE_OUTDATED_TEXT = "The device's machine runs an outdated capybara-device. Ask the person to update it on that machine and start it again.";
+const DEVICE_REVOKED_TEXT = "The device's machine was disconnected. Ask the person to run capybara-device logout, then capybara-device login on it, or to start a new conversation on another device.";
+const deviceProtocolText = (detail) => `The device's machine sent an answer the platform cannot read (${detail}). Ask the person to update capybara-device on that machine, then retry.`;
 const LOCK_LOST_TEXT = "The sandbox operation was interrupted because the sandbox lock was lost; check the sandbox state and retry.";
-/** The directory of attachments in the environment (each conversation has a subdirectory). */
+/** The directory of attachments in the device (each conversation has a subdirectory). */
 export const attachmentsRoot = (roots) => `${roots.workspace}/attachments`;
 /** {@link attachmentsRoot} of an instance with the default roots. */
 export const ATTACHMENTS_ROOT = attachmentsRoot(DEFAULT_SANDBOX_ROOTS);
 /**
  * One conversation's attachment directory: the first 12 hex digits of the root conversation's
- * UUID, so conversations sharing an environment do not overwrite each other's files.
+ * UUID, so conversations sharing a device do not overwrite each other's files.
  */
 export const attachmentsDir = (roots, rootConversationId) => `${attachmentsRoot(roots)}/${rootConversationId.replaceAll("-", "").slice(0, 12)}`;
 /** The conversation's marker of synced attachments: `{ <attachment id>: <file name> }`. */
@@ -122,7 +122,7 @@ export function withNotices(notices, text) {
 }
 /**
  * The root-independent checks of a path (`validateSandboxPathShape`: non-empty, absolute, no
- * control characters, no empty or `..` segments), run before the call enters its environment, so
+ * control characters, no empty or `..` segments), run before the call enters its device, so
  * a malformed path never creates or resumes an instance; root membership is checked inside
  * ({@link checkPath}).
  */
@@ -320,28 +320,28 @@ export function mapSandboxError(e, log) {
             return new ToolError(BUSY_TEXT);
         if (e.code === "sandbox.unavailable") {
             const reason = e.details?.[0]?.reason;
-            if (reason === ANONYMOUS_NO_ENVIRONMENT)
+            if (reason === ANONYMOUS_NO_DEVICE)
                 return new ToolError(ANONYMOUS_TEXT);
             return new ToolError(NO_SANDBOX_TEXT);
         }
         const detail = e.details?.[0];
-        if (e.code === "environment.not_found")
+        if (e.code === "device.not_found")
             return new ToolError(ENV_NOT_FOUND_TEXT);
-        if (e.code === "environment.forbidden" && detail?.reason === "machine_revoked") {
+        if (e.code === "device.forbidden" && detail?.reason === "machine_revoked") {
             return new ToolError(DEVICE_REVOKED_TEXT);
         }
-        if (e.code === "environment.forbidden")
+        if (e.code === "device.forbidden")
             return new ToolError(ENV_FORBIDDEN_TEXT);
-        if (e.code === "environment.unavailable")
+        if (e.code === "device.unavailable")
             return new ToolError(ENV_UNAVAILABLE_TEXT);
-        if (e.code === "environment.files_lost" && detail?.source === "device") {
+        if (e.code === "device.files_lost" && detail?.source === "local") {
             return new ToolError(DEVICE_FILES_LOST_TEXT);
         }
-        if (e.code === "environment.files_lost")
+        if (e.code === "device.files_lost")
             return new ToolError(ENV_FILES_LOST_TEXT);
-        if (e.code === "environment.offline")
+        if (e.code === "device.offline")
             return new ToolError(DEVICE_OFFLINE_TEXT);
-        if (e.code === "environment.program_outdated")
+        if (e.code === "device.program_outdated")
             return new ToolError(DEVICE_OUTDATED_TEXT);
     }
     // an operation outside withSandbox's own mapping (it records lost files itself)
@@ -356,27 +356,27 @@ export function mapSandboxError(e, log) {
     return e;
 }
 /**
- * Runs `fn` in the environment of the call's conversation (a sub-agent: its root's): resolves and
- * checks the environment for the conversation's owner (binding an unbound conversation to the
+ * Runs `fn` in the device of the call's conversation (a sub-agent: its root's): resolves and
+ * checks the device for the conversation's owner (binding an unbound conversation to the
  * owner's default first), then `SandboxService.withSandbox` (the instance created, resumed or
  * rebuilt on the kept files as needed, every `exec` carrying the call's actor). Attachments are
  * synced first. Returns the value and the notices to put before the result (first use, a new
  * instance, newly copied attachments). When `withSandbox` rebuilds a gone instance and calls
  * `fn` again, the notices are the last call's. The instance's roots are recorded for the model
- * on the conversation's first call and whenever they change ({@link recordEnvironmentPaths}).
+ * on the conversation's first call and whenever they change ({@link recordDevicePaths}).
  */
 export async function inSandbox(deps, ctx, fn) {
     try {
-        const environmentId = await deps.environments.forTool(ctx.orgId, sandboxConversationOf(ctx));
+        const deviceId = await deps.devices.forTool(ctx.orgId, sandboxConversationOf(ctx));
         return await deps.sandbox.withSandbox({
             orgId: ctx.orgId,
-            environmentId,
+            deviceId,
             // a sub-agent is told when another holder rebuilt the shared instance (final review m5)
             holderConversationId: ctx.conversationId,
             actor: { accountId: ctx.accountId, conversationId: ctx.conversationId },
         }, async (h, p, info, signal) => {
-            const s = { environmentId, h, roots: info.roots, p, signal };
-            await recordEnvironmentPaths(deps, ctx, info.roots);
+            const s = { deviceId, h, roots: info.roots, p, signal };
+            await recordDevicePaths(deps, ctx, info.roots);
             const notices = [];
             if (info.filesReset)
                 notices.push(sandboxFilesResetNotice(info.roots));
@@ -398,32 +398,32 @@ export async function inSandbox(deps, ctx, fn) {
 }
 /**
  * Environments spec §13.1, ruling R22: the calling conversation's log (the log its model reads; a
- * sub-agent's own too) gets an `environment_paths` event on its first sandbox call, the default
+ * sub-agent's own too) gets an `device_paths` event on its first sandbox call, the default
  * roots included, and again whenever the held instance's roots differ from the latest recorded
  * ones; always before the call's result. One indexed read per call (migration 0094); parallel
  * calls that saw the same latest event write one event (its idempotency key).
  */
-async function recordEnvironmentPaths(deps, ctx, roots) {
+async function recordDevicePaths(deps, ctx, roots) {
     if (!deps.eventLog.latestOfType)
         return;
-    const latest = await deps.eventLog.latestOfType(ctx.conversationId, "environment_paths");
-    const change = environmentPathsChange(latest, roots, ctx.runId);
+    const latest = await deps.eventLog.latestOfType(ctx.conversationId, "device_paths");
+    const change = devicePathsChange(latest, roots, ctx.runId);
     if (change)
         await deps.eventLog.append(ctx.conversationId, [change]);
 }
-/** The conversation whose environment a call uses (the root conversation's for a sub-agent). */
+/** The conversation whose device a call uses (the root conversation's for a sub-agent). */
 export const sandboxConversationOf = (ctx) => ctx.sandboxConversationId ?? ctx.conversationId;
 /**
- * Runs `fn` under the per-path lease of `path` in the session's environment (spec §10.4: the
+ * Runs `fn` under the per-path lease of `path` in the session's device (spec §10.4: the
  * kernel's own read-modify-write of one file never loses another holder's update, from any
- * conversation sharing the environment). `fn` gets `signal` combined with the path lease's: pass
+ * conversation sharing the device). `fn` gets `signal` combined with the path lease's: pass
  * it to every provider call, so a lost path lease stops the write. Without `pathLease` (test
  * stubs) it just runs `fn` with `signal`.
  */
 export async function withPathLease(deps, s, path, signal, fn) {
     if (!deps.sandbox.pathLease)
         return fn(signal);
-    const lease = await deps.sandbox.pathLease(s.environmentId, path, signal);
+    const lease = await deps.sandbox.pathLease(s.deviceId, path, signal);
     try {
         return await fn(AbortSignal.any([signal, lease.signal]));
     }
@@ -433,15 +433,15 @@ export async function withPathLease(deps, s, path, signal, fn) {
 }
 /**
  * Whether a sandbox tool call of the conversation tree rooted at `conversationId` can run: a
- * cloud provider is loaded, or (ruling R8) the conversation's environment runs on a registered
- * kernel provider (`@device`). Without a conversation only the cloud provider counts.
+ * cloud provider is loaded, or (ruling R8) the conversation's device runs on a registered
+ * kernel provider (`@local`). Without a conversation only the cloud provider counts.
  */
 export async function sandboxUsable(deps, orgId, conversationId) {
     if (deps.sandbox.cloudAvailable)
         return true;
-    if (conversationId === undefined || !deps.environments.usableNow)
+    if (conversationId === undefined || !deps.devices.usableNow)
         return false;
-    return deps.environments.usableNow(orgId, conversationId);
+    return deps.devices.usableNow(orgId, conversationId);
 }
 /**
  * The reason the registry reports the sandbox tools unavailable with, or null when they can run

package/dist/tools/builtins/sandbox/edit.js

@@ -57,10 +57,10 @@ export function sandboxEditTool(deps) {
                 throw new ToolError(SAME_TEXT);
             checkPathShape(input.file_path, "file_path");
             let path = "";
-            const { value: edit, notices } = await inSandbox(deps, ctx, ({ environmentId, h, roots, p, signal }) => {
+            const { value: edit, notices } = await inSandbox(deps, ctx, ({ deviceId, h, roots, p, signal }) => {
                 path = checkWritable(input.file_path, roots);
                 // read, replace, write: one holder at a time per file
-                return withPathLease(deps, { environmentId }, path, signal, async (signal) => {
+                return withPathLease(deps, { deviceId }, path, signal, async (signal) => {
                     const st = await p.stat(h, path, signal);
                     if (st === null)
                         throw new ToolError(notFound(path));

package/dist/tools/builtins/sandbox/index.d.ts

@@ -6,7 +6,7 @@ export { assignAttachmentNames, RUN_DEADLINE_MARGIN_MS, runTimeLeftMs, SANDBOX_R
 export { compileGlob, GlobPatternError, MAX_GLOB_STARS } from "./glob-match.js";
 /**
  * The sandbox builtins (M5 T8): Bash / Read / Write / Edit / Glob / Grep / Deliver, all run in the
- * conversation's environment (`SandboxService.withSandbox`) after syncing attachments to
+ * conversation's device (`SandboxService.withSandbox`) after syncing attachments to
  * `<workspace>/attachments` (the instance's roots, environments spec §13.1); unavailable without
  * a provider for it. Allowed by default; with the org setting `sandboxToolPolicy` set to ask,
  * every one but Read / Glob / Grep needs approval (see policy.ts).

package/dist/tools/builtins/sandbox/index.js

@@ -13,7 +13,7 @@ export { assignAttachmentNames, RUN_DEADLINE_MARGIN_MS, runTimeLeftMs, SANDBOX_R
 export { compileGlob, GlobPatternError, MAX_GLOB_STARS } from "./glob-match.js";
 /**
  * The sandbox builtins (M5 T8): Bash / Read / Write / Edit / Glob / Grep / Deliver, all run in the
- * conversation's environment (`SandboxService.withSandbox`) after syncing attachments to
+ * conversation's device (`SandboxService.withSandbox`) after syncing attachments to
  * `<workspace>/attachments` (the instance's roots, environments spec §13.1); unavailable without
  * a provider for it. Allowed by default; with the org setting `sandboxToolPolicy` set to ask,
  * every one but Read / Glob / Grep needs approval (see policy.ts).

package/dist/tools/builtins/sandbox/task-output.d.ts

@@ -14,12 +14,12 @@ export interface TaskEnv {
     store: NonNullable<SandboxToolDeps["background"]>;
     tasks: NonNullable<SandboxToolDeps["tasks"]>;
     ifRunning: SandboxService["ifRunning"];
-    environments: SandboxToolDeps["environments"];
+    devices: SandboxToolDeps["devices"];
     log: SandboxToolDeps["log"];
 }
 /**
  * The task tools' dependencies; throws the tool's error when they are missing, or when the
- * conversation's environment cannot run (no cloud provider, and not a registered `@device` one:
+ * conversation's device cannot run (no cloud provider, and not a registered `@local` one:
  * ruling R8).
  */
 export declare function taskEnv(deps: SandboxToolDeps, ctx: BuiltinCallContext): Promise<TaskEnv>;
@@ -29,14 +29,14 @@ export declare function taskEnv(deps: SandboxToolDeps, ctx: BuiltinCallContext):
  */
 export declare function ownedTask(env: TaskEnv, ctx: BuiltinCallContext, id: string): Promise<BackgroundTaskRow>;
 /**
- * The per-call access re-check of every sandbox tool (`inSandbox`): the conversation's environment
+ * The per-call access re-check of every sandbox tool (`inSandbox`): the conversation's device
  * may still be used by its owner. The task tools read a task's own instance without `inSandbox`,
  * so they check here first; errors become the tools' errors.
  */
-export declare function recheckEnvironment(env: TaskEnv, ctx: BuiltinCallContext): Promise<void>;
+export declare function recheckDevice(env: TaskEnv, ctx: BuiltinCallContext): Promise<void>;
 /**
- * `ifRunning` on the task's own environment instance (its execs act for the task's trigger in its
- * conversation); sandbox errors become the tools' errors. A task from before environments has no
+ * `ifRunning` on the task's own device instance (its execs act for the task's trigger in its
+ * conversation); sandbox errors become the tools' errors. A task from before devices has no
  * instance (`not_running`).
  */
 export declare function onTaskInstance<T>(env: TaskEnv, task: BackgroundTaskRow, fn: (p: HeldProvider, h: SandboxHandle, signal: AbortSignal) => Promise<T>, signal: AbortSignal): Promise<IfRunningResult<T>>;

package/dist/tools/builtins/sandbox/task-output.js

@@ -51,7 +51,7 @@ const SPEC = {
 };
 /**
  * The task tools' dependencies; throws the tool's error when they are missing, or when the
- * conversation's environment cannot run (no cloud provider, and not a registered `@device` one:
+ * conversation's device cannot run (no cloud provider, and not a registered `@local` one:
  * ruling R8).
  */
 export async function taskEnv(deps, ctx) {
@@ -65,7 +65,7 @@ export async function taskEnv(deps, ctx) {
         store: background,
         tasks,
         ifRunning: deps.sandbox.ifRunning.bind(deps.sandbox),
-        environments: deps.environments,
+        devices: deps.devices,
         log: deps.log,
     };
 }
@@ -83,28 +83,28 @@ export async function ownedTask(env, ctx, id) {
     return task;
 }
 /**
- * The per-call access re-check of every sandbox tool (`inSandbox`): the conversation's environment
+ * The per-call access re-check of every sandbox tool (`inSandbox`): the conversation's device
  * may still be used by its owner. The task tools read a task's own instance without `inSandbox`,
  * so they check here first; errors become the tools' errors.
  */
-export async function recheckEnvironment(env, ctx) {
+export async function recheckDevice(env, ctx) {
     try {
-        await env.environments.forTool(ctx.orgId, sandboxConversationOf(ctx));
+        await env.devices.forTool(ctx.orgId, sandboxConversationOf(ctx));
     }
     catch (e) {
         throw mapSandboxError(e, env.log);
     }
 }
 /**
- * `ifRunning` on the task's own environment instance (its execs act for the task's trigger in its
- * conversation); sandbox errors become the tools' errors. A task from before environments has no
+ * `ifRunning` on the task's own device instance (its execs act for the task's trigger in its
+ * conversation); sandbox errors become the tools' errors. A task from before devices has no
  * instance (`not_running`).
  */
 export async function onTaskInstance(env, task, fn, signal) {
-    if (task.environmentId === null)
+    if (task.deviceId === null)
         return { kind: "not_running", status: "gone" };
     try {
-        return await env.ifRunning(task.environmentId, { createdAt: task.sandboxCreatedAt }, (p, h, sig) => fn(actingAs(p, taskActor(task)), h, sig), signal);
+        return await env.ifRunning(task.deviceId, { createdAt: task.sandboxCreatedAt }, (p, h, sig) => fn(actingAs(p, taskActor(task)), h, sig), signal);
     }
     catch (e) {
         throw mapSandboxError(e, env.log);
@@ -269,7 +269,7 @@ export function taskOutputTool(deps) {
             const { task_id, block = true, timeout } = input;
             const env = await taskEnv(deps, ctx);
             let task = await ownedTask(env, ctx, task_id);
-            await recheckEnvironment(env, ctx);
+            await recheckDevice(env, ctx);
             if (block && task.status === "running") {
                 const wait = Math.max(0, Math.min(timeout ?? TASK_OUTPUT_DEFAULT_TIMEOUT_MS, TASK_OUTPUT_MAX_TIMEOUT_MS, runTimeLeftMs(ctx.runDeadline)));
                 const until = Date.now() + wait;

package/dist/tools/builtins/sandbox/task-stop.js

@@ -1,7 +1,7 @@
 import { rootsOf, ToolError } from "@capybara-hq/plugin-sdk";
 import { decodeTail, tailCommand } from "../../../background/session.js";
 import { clip, display, mapSandboxError, sandboxBaseTimeoutMs, unavailableWhenNoSandbox, } from "./common.js";
-import { onTaskInstance, ownedTask, recheckEnvironment, statusLine, taskEnv, } from "./task-output.js";
+import { onTaskInstance, ownedTask, recheckDevice, statusLine, taskEnv, } from "./task-output.js";
 /** The time limit of reading a stopped task's last lines. */
 const TAIL_EXEC_TIMEOUT_MS = 10_000;
 const SPEC = {
@@ -84,7 +84,7 @@ export function taskStopTool(deps) {
             const { task_id } = input;
             const env = await taskEnv(deps, ctx);
             const task = await ownedTask(env, ctx, task_id);
-            await recheckEnvironment(env, ctx);
+            await recheckDevice(env, ctx);
             if (task.status !== "running") {
                 return ended(env, task, "had already finished", ctx.signal);
             }

package/dist/tools/builtins/sandbox/write.js

@@ -46,10 +46,10 @@ export function sandboxWriteTool(deps) {
             const data = new TextEncoder().encode(input.content);
             checkPathShape(input.file_path, "file_path");
             let path = "";
-            const { value, notices } = await inSandbox(deps, ctx, ({ environmentId, h, roots, p, signal }) => {
+            const { value, notices } = await inSandbox(deps, ctx, ({ deviceId, h, roots, p, signal }) => {
                 path = checkWritable(input.file_path, roots);
                 // stat, read the previous content, write: one holder at a time per file
-                return withPathLease(deps, { environmentId }, path, signal, async (signal) => {
+                return withPathLease(deps, { deviceId }, path, signal, async (signal) => {
                     const st = await p.stat(h, path, signal);
                     if (st?.isDir)
                         throw new ToolError(isDirectory(path));

package/dist/tools/builtins/skill-load.d.ts

@@ -8,7 +8,7 @@ import { type SandboxToolDeps } from "./sandbox/common.js";
  * Builtin tool `Skill` (M5 T14, ruling M17): resolves the name against the latest skills catalog
  * snapshot in the log to an id and version, and returns that version's SKILL.md body and file list
  * (the result names the version). A skill with other files is copied whole into the conversation's
- * environment at `<skills root>/<name>@<digest>/` (the instance's skills root, `/skills` by default; the provider writes as root, commands read only; the
+ * device at `<skills root>/<name>@<digest>/` (the instance's skills root, `/skills` by default; the provider writes as root, commands read only; the
  * digest is {@link skillDigest} of the version's file manifest, so versions of one skill coexist in
  * the shared file system). Without a sandbox provider only the body is given, with a note that
  * scripts are unavailable.

package/dist/tools/builtins/skill-load.js

@@ -14,7 +14,7 @@ import { clip, display, inSandbox, sandboxBaseTimeoutMs, sandboxConversationOf,
  * Builtin tool `Skill` (M5 T14, ruling M17): resolves the name against the latest skills catalog
  * snapshot in the log to an id and version, and returns that version's SKILL.md body and file list
  * (the result names the version). A skill with other files is copied whole into the conversation's
- * environment at `<skills root>/<name>@<digest>/` (the instance's skills root, `/skills` by default; the provider writes as root, commands read only; the
+ * device at `<skills root>/<name>@<digest>/` (the instance's skills root, `/skills` by default; the provider writes as root, commands read only; the
  * digest is {@link skillDigest} of the version's file manifest, so versions of one skill coexist in
  * the shared file system). Without a sandbox provider only the body is given, with a note that
  * scripts are unavailable.
@@ -49,7 +49,7 @@ const SPEC = {
     description: "Load a skill from the skills list: returns the skill's instructions " +
         "(its SKILL.md) and the list of its files. Call it before starting a task that matches a " +
         "skill's description, then follow the returned instructions. If the skill has scripts or other " +
-        "files, they are copied read-only to <name>@<version-id>/ in the skills directory of this environment; run scripts " +
+        "files, they are copied read-only to <name>@<version-id>/ in the skills directory of this device; run scripts " +
         "there with an interpreter (sh, python3, node). Call it again when the skills list changes. Pass args when the task gives the skill arguments (they replace " +
         "$ARGUMENTS and $1, $2… in the instructions). Do not use it for skills that are not in the list.",
     inputSchema: {