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

package/dist/admin/admin.schemas.d.ts

@@ -53,6 +53,19 @@ export declare const DeploymentSettingsBody: z.ZodObject<{
     uiTheme: z.ZodOptional<z.ZodObject<{
         id: z.ZodNullable<z.ZodString>;
     }, z.core.$strict>>;
+    uiArrangement: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+        "agent.detail.section": "agent.detail.section";
+        "conversation.panel": "conversation.panel";
+        "conversation.properties.section": "conversation.properties.section";
+        "conversation.tool-result.card": "conversation.tool-result.card";
+        "file.preview": "file.preview";
+        "org.page": "org.page";
+        "org.settings.section": "org.settings.section";
+        "platform.page": "platform.page";
+    }> & z.core.$partial, z.ZodNullable<z.ZodObject<{
+        hidden: z.ZodArray<z.ZodString>;
+        order: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>>>;
 }, z.core.$strict>;
 export declare const PurposeParams: z.ZodObject<{
     purpose: z.ZodString;

package/dist/agents/agent-lookup.d.ts

@@ -49,6 +49,11 @@ export declare function visibleTo(viewerAccountId: string | null): (eb: Expressi
  * the live org). Deleted agents are never visible.
  */
 export declare function isAgentVisibleTo(db: KernelSchemaDb, agentId: string, accountId: string): Promise<boolean>;
+/**
+ * {@link isAgentVisibleTo} for an agent of `orgId` only: an agent the account can read in another
+ * org is not visible here (UI slots spec R6, the `agent.detail.section` scope rule).
+ */
+export declare function isAgentVisibleIn(db: KernelSchemaDb, orgId: string, agentId: string, accountId: string): Promise<boolean>;
 /**
  * Reads agents for a viewer (the visibility rule {@link visibleTo}): the part of `AgentsService`
  * the conversations, the skill invoker and the attachments read, with no dependency on the

package/dist/agents/agent-lookup.js

@@ -67,6 +67,21 @@ export async function isAgentVisibleTo(db, agentId, accountId) {
         .executeTakeFirst();
     return row !== undefined;
 }
+/**
+ * {@link isAgentVisibleTo} for an agent of `orgId` only: an agent the account can read in another
+ * org is not visible here (UI slots spec R6, the `agent.detail.section` scope rule).
+ */
+export async function isAgentVisibleIn(db, orgId, agentId, accountId) {
+    const row = await db
+        .selectFrom("agents")
+        .select("id")
+        .where("id", "=", agentId)
+        .where("org_id", "=", orgId)
+        .where("deleted_at", "is", null)
+        .where(visibleTo(accountId))
+        .executeTakeFirst();
+    return row !== undefined;
+}
 /**
  * Reads agents for a viewer (the visibility rule {@link visibleTo}): the part of `AgentsService`
  * the conversations, the skill invoker and the attachments read, with no dependency on the

package/dist/background/background.module.js

@@ -7,7 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Module } from "@nestjs/common";
 import { ConversationAccessModule } from "../conversations/access.js";
 import { EventLogModule } from "../conversations/event-log.js";
-import { EnvironmentsModule } from "../environments/environments.module.js";
+import { DevicesModule } from "../devices/devices.module.js";
 import { SandboxModule } from "../sandbox/sandbox.module.js";
 import { BackgroundTaskFinisher } from "./finish.js";
 import { BackgroundTaskStopper } from "./stop.js";
@@ -28,7 +28,7 @@ BackgroundModule = __decorate([
         imports: [
             BackgroundStoreModule,
             SandboxModule,
-            EnvironmentsModule,
+            DevicesModule,
             EventLogModule,
             ConversationAccessModule,
         ],

package/dist/background/launch-lock.d.ts

@@ -3,7 +3,7 @@ import { XactLock } from "../infra/database/xact-lock.js";
 /**
  * The launch lock of one root conversation (decision R9: one provider per transaction-scoped
  * lock): serializes background task reservations in its tree, so the count of running tasks
- * checked against `sandbox.background.maxTasks` (per root conversation, whatever environment it
+ * checked against `sandbox.background.maxTasks` (per root conversation, whatever device it
  * works in) and the insert of the new row are one step. Joins the
  * caller's transaction (`mandatory`), which holds it until it ends.
  */

package/dist/background/launch-lock.js

@@ -14,7 +14,7 @@ import { XactLock } from "../infra/database/xact-lock.js";
 /**
  * The launch lock of one root conversation (decision R9: one provider per transaction-scoped
  * lock): serializes background task reservations in its tree, so the count of running tasks
- * checked against `sandbox.background.maxTasks` (per root conversation, whatever environment it
+ * checked against `sandbox.background.maxTasks` (per root conversation, whatever device it
  * works in) and the insert of the new row are one step. Joins the
  * caller's transaction (`mandatory`), which holds it until it ends.
  */

package/dist/background/poll.job.d.ts

@@ -21,7 +21,7 @@ export declare const launchAbandonedAfterMs: (cfg: KernelConfig) => number;
 /**
  * The worker's background task jobs (spec 2026-11-05-background-bash-design §4.3), each once per
  * tick across replicas:
- * - `background-task-poll` (every `sandbox.background.pollSeconds`): for every environment
+ * - `background-task-poll` (every `sandbox.background.pollSeconds`): for every device
  *   instance with running tasks (of any conversation using it), one exec through
  *   `SandboxService.ifRunning` (which never creates or resumes an instance) reports each task's
  *   exit file and liveness; ended tasks finish through {@link BackgroundTaskFinisher}. Each poll
@@ -47,7 +47,7 @@ export declare class BackgroundTaskPollJob {
      * result: they never started), with a `changed: "background"` frame to their conversations.
      */
     pollOnce(signal?: AbortSignal): Promise<number>;
-    /** Polls the tasks of one environment instance; returns how many finished. */
+    /** Polls the tasks of one device instance; returns how many finished. */
     private pollSandbox;
     /** The poll exec of one instance: each task's report by id. */
     private pollExec;

package/dist/background/poll.job.js

@@ -44,7 +44,7 @@ const POLL_MAX_OUTPUT_BYTES = 4 * 1024 * 1024;
 /**
  * The worker's background task jobs (spec 2026-11-05-background-bash-design §4.3), each once per
  * tick across replicas:
- * - `background-task-poll` (every `sandbox.background.pollSeconds`): for every environment
+ * - `background-task-poll` (every `sandbox.background.pollSeconds`): for every device
  *   instance with running tasks (of any conversation using it), one exec through
  *   `SandboxService.ifRunning` (which never creates or resumes an instance) reports each task's
  *   exit file and liveness; ended tasks finish through {@link BackgroundTaskFinisher}. Each poll
@@ -93,8 +93,8 @@ let BackgroundTaskPollJob = class BackgroundTaskPollJob {
         for (const t of await this.store.runningStarted()) {
             if (t.sid === null || t.sandboxCreatedAt === null)
                 continue;
-            // one exec per instance: the tasks of every conversation sharing the environment
-            const key = `${t.environmentId} ${t.sandboxCreatedAt.getTime()}`;
+            // one exec per instance: the tasks of every conversation sharing the device
+            const key = `${t.deviceId} ${t.sandboxCreatedAt.getTime()}`;
             groups.set(key, [...(groups.get(key) ?? []), t]);
         }
         let finished = 0;
@@ -102,9 +102,9 @@ let BackgroundTaskPollJob = class BackgroundTaskPollJob {
             if (signal.aborted)
                 break;
             try {
-                // the environment's provider is not there (no cloud provider, `@device` not served):
+                // the device's provider is not there (no cloud provider, `@local` not served):
                 // its tasks stay as they are until it is
-                const env = tasks[0]?.environmentId ?? null;
+                const env = tasks[0]?.deviceId ?? null;
                 if (env === null ? !this.sandbox.cloudAvailable : !(await this.sandbox.availableFor(env))) {
                     continue;
                 }
@@ -114,7 +114,7 @@ let BackgroundTaskPollJob = class BackgroundTaskPollJob {
                 if (signal.aborted)
                     break;
                 this.log.warn("cannot poll background tasks; retrying next tick", {
-                    environmentId: tasks[0]?.environmentId,
+                    deviceId: tasks[0]?.deviceId,
                     err,
                 });
             }
@@ -123,13 +123,13 @@ let BackgroundTaskPollJob = class BackgroundTaskPollJob {
             this.log.info("background tasks finished", { count: finished });
         return finished;
     }
-    /** Polls the tasks of one environment instance; returns how many finished. */
+    /** Polls the tasks of one device instance; returns how many finished. */
     async pollSandbox(tasks, signal) {
         const [first] = tasks;
-        // a task from before environments has no instance any more
-        const r = first.environmentId === null
+        // a task from before devices has no instance any more
+        const r = first.deviceId === null
             ? { kind: "not_running", status: "gone" }
-            : await this.sandbox.ifRunning(first.environmentId, { createdAt: first.sandboxCreatedAt }, (p, h, sig) => this.pollExec(actingAs(p, taskActor(first)), h, tasks, sig), signal);
+            : await this.sandbox.ifRunning(first.deviceId, { createdAt: first.sandboxCreatedAt }, (p, h, sig) => this.pollExec(actingAs(p, taskActor(first)), h, tasks, sig), signal);
         const now = new Date();
         let n = 0;
         for (const t of tasks) {

package/dist/background/stop.d.ts

@@ -43,7 +43,7 @@ export declare class BackgroundTaskStopper {
     stop(task: BackgroundTaskRow, why: StopReason, signal?: AbortSignal): Promise<BackgroundTaskRow>;
     /**
      * SIGTERM, the grace period, SIGKILL until the session is empty, then the last lines: in the
-     * task's own instance only (`ifRunning`); a task from before environments has none.
+     * task's own instance only (`ifRunning`); a task from before devices has none.
      */
     private signalTask;
     /**

package/dist/background/stop.js

@@ -138,12 +138,12 @@ let BackgroundTaskStopper = class BackgroundTaskStopper {
     }
     /**
      * SIGTERM, the grace period, SIGKILL until the session is empty, then the last lines: in the
-     * task's own instance only (`ifRunning`); a task from before environments has none.
+     * task's own instance only (`ifRunning`); a task from before devices has none.
      */
     async signalTask(cur, sid, signal) {
-        if (cur.environmentId === null)
+        if (cur.deviceId === null)
             return { kind: "not_running", status: "gone" };
-        return this.sandbox.ifRunning(cur.environmentId, { createdAt: cur.sandboxCreatedAt }, async (tp, h, sig) => {
+        return this.sandbox.ifRunning(cur.deviceId, { createdAt: cur.sandboxCreatedAt }, async (tp, h, sig) => {
             const p = actingAs(tp, taskActor(cur));
             const term = await p.exec(h, {
                 command: termScript(cur.id, sid),

package/dist/background/store.d.ts

@@ -14,10 +14,10 @@ export interface BackgroundTaskRow {
      */
     sandboxConversationId: string;
     /**
-     * The environment the task runs in (the root conversation's when it was launched): its instance
-     * is where the task's processes are. Null only for tasks from before environments (all finished).
+     * The device the task runs in (the root conversation's when it was launched): its instance
+     * is where the task's processes are. Null only for tasks from before devices (all finished).
      */
-    environmentId: string | null;
+    deviceId: string | null;
     runId: string;
     callId: string;
     triggerAccountId: string;
@@ -157,10 +157,10 @@ export declare class BackgroundTaskStore {
     /** Moves the read offset forward only (a concurrent reader never moves it back). */
     advanceOffset(id: string, to: number): Promise<void>;
     /**
-     * Finished tasks of an environment whose process may still exist (any conversation's: they
+     * Finished tasks of a device whose process may still exist (any conversation's: they
      * share the instance).
      */
-    pendingKills(environmentId: string): Promise<BackgroundTaskRow[]>;
+    pendingKills(deviceId: string): Promise<BackgroundTaskRow[]>;
     clearKill(ids: string[]): Promise<void>;
     /** Deletes finished tasks that ended before `before`; a running one is never deleted. */
     pruneFinished(before: Date): Promise<number>;

package/dist/background/store.js

@@ -18,7 +18,7 @@ const toRow = (r) => ({
     orgId: r.org_id,
     conversationId: r.conversation_id,
     sandboxConversationId: r.sandbox_conversation_id,
-    environmentId: r.environment_id,
+    deviceId: r.device_id,
     runId: r.run_id,
     callId: r.call_id,
     triggerAccountId: r.trigger_account_id,
@@ -195,7 +195,7 @@ let BackgroundTaskStore = class BackgroundTaskStore {
             org_id: row.orgId,
             conversation_id: row.conversationId,
             sandbox_conversation_id: row.sandboxConversationId,
-            environment_id: row.environmentId,
+            device_id: row.deviceId,
             run_id: row.runId,
             call_id: row.callId,
             trigger_account_id: row.triggerAccountId,
@@ -314,14 +314,14 @@ let BackgroundTaskStore = class BackgroundTaskStore {
             .execute();
     }
     /**
-     * Finished tasks of an environment whose process may still exist (any conversation's: they
+     * Finished tasks of a device whose process may still exist (any conversation's: they
      * share the instance).
      */
-    async pendingKills(environmentId) {
+    async pendingKills(deviceId) {
         const rows = await this.db
             .selectFrom("background_tasks")
             .selectAll()
-            .where("environment_id", "=", environmentId)
+            .where("device_id", "=", deviceId)
             .where("kill_pending", "=", true)
             .orderBy("started_at", "asc")
             .execute();

package/dist/background/tasks.service.d.ts

@@ -1,6 +1,6 @@
 import { ConversationAccess } from "../conversations/access.js";
 import { EventLog } from "../conversations/event-log.js";
-import { ConversationEnvironments } from "../environments/conversation-environments.js";
+import { ConversationDevices } from "../devices/conversation-devices.js";
 import { KernelDb } from "../infra/database/kernel-db.js";
 import { SandboxService } from "../sandbox/sandbox.service.js";
 import { BackgroundTaskStopper } from "./stop.js";
@@ -45,8 +45,8 @@ export declare class BackgroundTasks {
     private readonly sandbox;
     private readonly eventLog;
     private readonly db;
-    private readonly environments;
-    constructor(access: Pick<ConversationAccess, "isAccessible">, store: Pick<BackgroundTaskStore, "listFor" | "get">, stopper: Pick<BackgroundTaskStopper, "stop">, sandbox: Pick<SandboxService, "availableFor" | "ifRunning">, eventLog: Pick<EventLog, "findByIdem">, db: KernelDb, environments: Pick<ConversationEnvironments, "forTool">);
+    private readonly devices;
+    constructor(access: Pick<ConversationAccess, "isAccessible">, store: Pick<BackgroundTaskStore, "listFor" | "get">, stopper: Pick<BackgroundTaskStopper, "stop">, sandbox: Pick<SandboxService, "availableFor" | "ifRunning">, eventLog: Pick<EventLog, "findByIdem">, db: KernelDb, devices: Pick<ConversationDevices, "forTool">);
     /**
      * The conversation and every sub-agent conversation below it (grandchildren too: their tasks run
      * in the root's sandbox, agent map spec §6); `conversation.not_found` when not visible.
@@ -63,12 +63,12 @@ export declare class BackgroundTasks {
      */
     stop(orgId: string, conversationId: string, accountId: string, taskId: string, actorTokenId?: string, auditDetail?: Record<string, unknown>): Promise<BackgroundTaskView>;
     /**
-     * Whether the task's environment may still be used by its conversation's owner (the access
+     * Whether the task's device may still be used by its conversation's owner (the access
      * re-check every sandbox tool call makes); when it may not, the live read is skipped.
      */
-    private environmentUsable;
+    private deviceUsable;
     /**
-     * The end of the task's output, at most `tail` bytes. Read live when the task's environment
+     * The end of the task's output, at most `tail` bytes. Read live when the task's device
      * instance runs (never resuming a suspended one); a finished task whose sandbox does not run answers
      * with the last lines its finished event kept. Anything else is
      * `background_task.output_unavailable` (409).

package/dist/background/tasks.service.js

@@ -12,7 +12,7 @@ import { Inject, Injectable } from "@nestjs/common";
 import { ConversationAccess } from "../conversations/access.js";
 import { EventLog } from "../conversations/event-log.js";
 import { conversationTree } from "../conversations/tree.js";
-import { ConversationEnvironments } from "../environments/conversation-environments.js";
+import { ConversationDevices } from "../devices/conversation-devices.js";
 import { ApiError } from "../errors.js";
 import { audit } from "../identity/audit.js";
 import { KernelDb } from "../infra/database/kernel-db.js";
@@ -44,15 +44,15 @@ let BackgroundTasks = class BackgroundTasks {
     sandbox;
     eventLog;
     db;
-    environments;
-    constructor(access, store, stopper, sandbox, eventLog, db, environments) {
+    devices;
+    constructor(access, store, stopper, sandbox, eventLog, db, devices) {
         this.access = access;
         this.store = store;
         this.stopper = stopper;
         this.sandbox = sandbox;
         this.eventLog = eventLog;
         this.db = db;
-        this.environments = environments;
+        this.devices = devices;
     }
     /**
      * The conversation and every sub-agent conversation below it (grandchildren too: their tasks run
@@ -119,12 +119,12 @@ let BackgroundTasks = class BackgroundTasks {
         return this.view(after, conversationId);
     }
     /**
-     * Whether the task's environment may still be used by its conversation's owner (the access
+     * Whether the task's device may still be used by its conversation's owner (the access
      * re-check every sandbox tool call makes); when it may not, the live read is skipped.
      */
-    async environmentUsable(orgId, taskConversationId) {
+    async deviceUsable(orgId, taskConversationId) {
         try {
-            await this.environments.forTool(orgId, await rootConversationOf(this.db.db, taskConversationId));
+            await this.devices.forTool(orgId, await rootConversationOf(this.db.db, taskConversationId));
             return true;
         }
         catch (e) {
@@ -134,7 +134,7 @@ let BackgroundTasks = class BackgroundTasks {
         }
     }
     /**
-     * The end of the task's output, at most `tail` bytes. Read live when the task's environment
+     * The end of the task's output, at most `tail` bytes. Read live when the task's device
      * instance runs (never resuming a suspended one); a finished task whose sandbox does not run answers
      * with the last lines its finished event kept. Anything else is
      * `background_task.output_unavailable` (409).
@@ -143,14 +143,14 @@ let BackgroundTasks = class BackgroundTasks {
         const task = await this.owned(orgId, conversationId, accountId, taskId);
         if (task.sid !== null &&
             task.sandboxCreatedAt !== null &&
-            task.environmentId !== null &&
-            (await this.sandbox.availableFor(task.environmentId)) &&
-            (await this.environmentUsable(orgId, task.conversationId))) {
+            task.deviceId !== null &&
+            (await this.sandbox.availableFor(task.deviceId)) &&
+            (await this.deviceUsable(orgId, task.conversationId))) {
             const createdAt = task.sandboxCreatedAt;
             // the person reading it acts in the task's conversation
             const actor = { accountId, conversationId: task.conversationId };
             try {
-                const r = await this.sandbox.ifRunning(task.environmentId, { createdAt }, async (p, h, signal) => {
+                const r = await this.sandbox.ifRunning(task.deviceId, { createdAt }, async (p, h, signal) => {
                     const res = await actingAs(p, actor).exec(h, {
                         command: tailScript(task.id, tail),
                         cwd: rootsOf(h).workspace,
@@ -185,7 +185,7 @@ BackgroundTasks = __decorate([
     __param(3, Inject(SandboxService)),
     __param(4, Inject(EventLog)),
     __param(5, Inject(KernelDb)),
-    __param(6, Inject(ConversationEnvironments))
+    __param(6, Inject(ConversationDevices))
 ], BackgroundTasks);
 export { BackgroundTasks };
 /** Prints `size <bytes>` and `out <base64 of the last `tail` bytes>`. Relative to the workspace root. */

package/dist/catalog/marketplaces.service.d.ts

@@ -188,7 +188,7 @@ export declare function headsToResolve(entries: readonly MarketplaceEntry[], imp
 /** The host versions (an entry's `minKernel` is judged against them). */
 export declare const HOST_VERSIONS: {
     readonly kernel: string;
-    readonly sdk: "0.1.0-rc.8";
+    readonly sdk: "0.1.0-rc.9";
 };
 /** Whether this deployment satisfies the entry's `minKernel`. */
 export declare const entryCompatible: (e: Pick<MarketplaceEntry, "minKernel">) => boolean;

package/dist/channels/channels.module.js

@@ -12,7 +12,7 @@ import { OnWorkerEvent, WorkerHost } from "@nestjs/bullmq";
 import { Inject, Injectable, Module } from "@nestjs/common";
 import { ConversationsModule } from "../conversations/conversations.module.js";
 import { EventLogModule } from "../conversations/event-log.js";
-import { EnvironmentsModule } from "../environments/environments.module.js";
+import { DevicesModule } from "../devices/devices.module.js";
 import { ExtensionsModule } from "../extensions/extensions.module.js";
 import { IdentityModule } from "../identity/identity.module.js";
 import { configuredProcessor, } from "../infra/queue/configured-processor.js";
@@ -39,7 +39,7 @@ let ChannelsModule = class ChannelsModule {
 ChannelsModule = __decorate([
     Module({
         imports: [
-            EnvironmentsModule,
+            DevicesModule,
             EventLogModule,
             ExtensionsModule,
             IdentityModule,

package/dist/channels/inbound.d.ts

@@ -1,7 +1,7 @@
 import type { ChannelCard, InboundEvent, InboundSender, Logger } from "@capybara-hq/plugin-sdk";
 import type { Redis } from "ioredis";
 import { ConversationsService } from "../conversations/conversations.service.js";
-import { EnvironmentsService } from "../environments/environments.service.js";
+import { DevicesService } from "../devices/devices.service.js";
 import { IdentityBinding } from "../identity/binding.js";
 import { ExternalIdentities } from "../identity/external.js";
 import { KernelDb } from "../infra/database/kernel-db.js";
@@ -63,7 +63,7 @@ export declare class ChannelInbound {
     /** The channel queue: inbound jobs (`onEvent` only dedupes and enqueues) and deliveries. */
     private readonly jobs;
     private readonly guests;
-    private readonly environments;
+    private readonly devices;
     private readonly log;
     private readonly actions;
     constructor(kdb: KernelDb, redis: Pick<Redis, "set">, 
@@ -74,7 +74,7 @@ export declare class ChannelInbound {
     /** The channel queue: inbound jobs (`onEvent` only dedupes and enqueues) and deliveries. */
     jobs: Pick<ChannelJobs, "enqueue" | "enqueueInbound">, 
     /** 卡片操作：审批决定与提问回答（授权由这两个服务按点击者映射到的账号判定）。 */
-    approvals: Pick<ApprovalsService, "decide">, questions: Pick<QuestionsService, "answer">, guests: Pick<AnonymousGuests, "ensure">, environments: Pick<EnvironmentsService, "list" | "imDefault" | "setImDefault">, log: Pick<Logger, "warn" | "info">);
+    approvals: Pick<ApprovalsService, "decide">, questions: Pick<QuestionsService, "answer">, guests: Pick<AnonymousGuests, "ensure">, devices: Pick<DevicesService, "list" | "imDefault" | "setImDefault">, log: Pick<Logger, "warn" | "info">);
     /**
      * 插件 `onEvent`：去重并入队后返回（见类注释）。返回后插件才向平台确认；抛错时插件不确认。
      */
@@ -95,13 +95,13 @@ export declare class ChannelInbound {
     handle(connectionId: string, e: InboundEvent): Promise<void>;
     private message;
     /**
-     * Direct-message `/env` (environments spec §4.2 item 8): lists the person's usable environments,
+     * Direct-message `/device` (environments spec §4.2 item 8): lists the person's usable devices,
      * or with a name sets the IM default their next new conversation is bound to. The name matches
-     * case-insensitively against each label (`environmentLabel`: a former default demoted by a
-     * provider switch answers to e.g. "Personal (Docker sandbox)"); the default environment also
-     * answers to 个人环境 / Personal.
+     * case-insensitively against each label (`deviceLabel`: a former default demoted by a
+     * provider switch answers to e.g. "Personal (Docker sandbox)"); the default device also
+     * answers to 个人设备 / Personal.
      */
-    private envCommand;
+    private deviceCommand;
     /**
      * Posts the person's message: `/name args` as a skill invocation when the kernel accepts it, else
      * as typed (phase D spec §9). A retry of the job finds the first write by `clientMessageId`

package/dist/channels/inbound.js

@@ -11,8 +11,8 @@ import { randomUUID } from "node:crypto";
 import { Inject, Injectable } from "@nestjs/common";
 import { ConversationsService } from "../conversations/conversations.service.js";
 import { imSenderContext, recipientLocale, } from "../conversations/message-context.js";
-import { EnvironmentsService } from "../environments/environments.service.js";
-import { DEFAULT_ENVIRONMENT_ALIASES, environmentLabel } from "../environments/label.js";
+import { DevicesService } from "../devices/devices.service.js";
+import { DEFAULT_DEVICE_ALIASES, deviceLabel } from "../devices/label.js";
 import { ApiError } from "../errors.js";
 import { IdentityBinding } from "../identity/binding.js";
 import { ExternalIdentities } from "../identity/external.js";
@@ -75,7 +75,7 @@ let ChannelInbound = class ChannelInbound {
     directorySync;
     jobs;
     guests;
-    environments;
+    devices;
     log;
     actions;
     constructor(kdb, redis, 
@@ -86,7 +86,7 @@ let ChannelInbound = class ChannelInbound {
     /** The channel queue: inbound jobs (`onEvent` only dedupes and enqueues) and deliveries. */
     jobs, 
     /** 卡片操作：审批决定与提问回答（授权由这两个服务按点击者映射到的账号判定）。 */
-    approvals, questions, guests, environments, log) {
+    approvals, questions, guests, devices, log) {
         this.kdb = kdb;
         this.redis = redis;
         this.locks = locks;
@@ -97,7 +97,7 @@ let ChannelInbound = class ChannelInbound {
         this.directorySync = directorySync;
         this.jobs = jobs;
         this.guests = guests;
-        this.environments = environments;
+        this.devices = devices;
         this.log = log;
         this.actions = new ChannelCardActions({
             get db() {
@@ -216,16 +216,16 @@ let ChannelInbound = class ChannelInbound {
             await reply("newConversation");
             return;
         }
-        const envCommand = !isGroup && threadAccount !== null ? parseEnvCommand(e.text) : null;
-        if (envCommand !== null) {
-            await this.envCommand(row.orgId, accountId, envCommand.name, locale, replyText);
+        const deviceCommand = !isGroup && threadAccount !== null ? parseDeviceCommand(e.text) : null;
+        if (deviceCommand !== null) {
+            await this.deviceCommand(row.orgId, accountId, deviceCommand.name, locale, replyText);
             return;
         }
         let conversationId = await findThread(db, k);
         if (conversationId === undefined) {
             let created;
             try {
-                // bound to the person's IM default environment, else their default (environments spec
+                // bound to the person's IM default device, else their default (environments spec
                 // §4.2 item 8); an anonymous sender's stays unbound (no sandbox)
                 created = (await this.conversations.create(row.orgId, accountId, row.agentId, { im: true }))
                     .id;
@@ -294,49 +294,49 @@ let ChannelInbound = class ChannelInbound {
         await this.jobs.enqueue(conversationId);
     }
     /**
-     * Direct-message `/env` (environments spec §4.2 item 8): lists the person's usable environments,
+     * Direct-message `/device` (environments spec §4.2 item 8): lists the person's usable devices,
      * or with a name sets the IM default their next new conversation is bound to. The name matches
-     * case-insensitively against each label (`environmentLabel`: a former default demoted by a
-     * provider switch answers to e.g. "Personal (Docker sandbox)"); the default environment also
-     * answers to 个人环境 / Personal.
+     * case-insensitively against each label (`deviceLabel`: a former default demoted by a
+     * provider switch answers to e.g. "Personal (Docker sandbox)"); the default device also
+     * answers to 个人设备 / Personal.
      */
-    async envCommand(orgId, accountId, name, locale, replyText) {
-        const { items, defaultId } = await this.environments.list(orgId, accountId);
+    async deviceCommand(orgId, accountId, name, locale, replyText) {
+        const { items, defaultId } = await this.devices.list(orgId, accountId);
         const usable = items.filter((v) => v.available);
-        const labelOf = (v) => environmentLabel(v, locale);
-        const current = (await this.environments.imDefault(orgId, accountId)) ?? defaultId;
+        const labelOf = (v) => deviceLabel(v, locale);
+        const current = (await this.devices.imDefault(orgId, accountId)) ?? defaultId;
         const list = usable
-            .map((v) => `- ${labelOf(v)}${v.id === current ? phrase("envCurrent", locale) : ""}`)
+            .map((v) => `- ${labelOf(v)}${v.id === current ? phrase("deviceCurrent", locale) : ""}`)
             .join("\n");
         const fill = (key, vars) => phrase(key, locale).replace(/\{(\w+)\}/g, (m, k) => vars[k] ?? m);
         if (usable.length === 0)
-            return replyText(phrase("envNone", locale));
+            return replyText(phrase("deviceNone", locale));
         if (name === null)
-            return replyText(fill("envList", { list }));
+            return replyText(fill("deviceList", { list }));
         const wanted = name.toLowerCase();
         const is = (v) => labelOf(v).toLowerCase() === wanted;
         // a name the person gave wins over a generated label, and both over the default's aliases
         const hit = usable.find((v) => v.name !== null && is(v)) ??
             usable.find(is) ??
-            usable.find((v) => v.isDefault && DEFAULT_ENVIRONMENT_ALIASES.includes(wanted));
+            usable.find((v) => v.isDefault && DEFAULT_DEVICE_ALIASES.includes(wanted));
         if (hit === undefined) {
             const unavailable = items.find((v) => !v.available && is(v));
             if (unavailable !== undefined) {
-                return replyText(fill("envUnavailable", { name: labelOf(unavailable), list }));
+                return replyText(fill("deviceUnavailable", { name: labelOf(unavailable), list }));
             }
-            return replyText(fill("envUnknown", { name, list }));
+            return replyText(fill("deviceUnknown", { name, list }));
         }
         try {
-            await this.environments.setImDefault(orgId, accountId, hit.id);
+            await this.devices.setImDefault(orgId, accountId, hit.id);
         }
         catch (err) {
             // deleted or made unusable since the list was read
-            if (err instanceof ApiError && err.code.startsWith("environment.")) {
-                return replyText(fill("envUnknown", { name, list }));
+            if (err instanceof ApiError && err.code.startsWith("device.")) {
+                return replyText(fill("deviceUnknown", { name, list }));
             }
             throw err;
         }
-        return replyText(fill("envSwitched", { name: labelOf(hit) }));
+        return replyText(fill("deviceSwitched", { name: labelOf(hit) }));
     }
     /**
      * Posts the person's message: `/name args` as a skill invocation when the kernel accepts it, else
@@ -464,13 +464,13 @@ ChannelInbound = __decorate([
     __param(9, Inject(ApprovalsService)),
     __param(10, Inject(QuestionsService)),
     __param(11, Inject(AnonymousGuests)),
-    __param(12, Inject(EnvironmentsService)),
+    __param(12, Inject(DevicesService)),
     __param(13, Inject(KERNEL_LOGGER))
 ], ChannelInbound);
 export { ChannelInbound };
-/** `/env` or `/env <name>` (the exact command word, case-insensitive); anything else is null. */
-function parseEnvCommand(text) {
-    const m = /^\/env(?:\s+([\s\S]*))?$/i.exec(text.trim());
+/** `/device` or `/device <name>` (the exact command word, case-insensitive); anything else is null. */
+function parseDeviceCommand(text) {
+    const m = /^\/device(?:\s+([\s\S]*))?$/i.exec(text.trim());
     if (m === null)
         return null;
     const name = m[1]?.trim();