@capybara-hq/kernel 0.1.0-rc.24 → 0.1.0-rc.26

package/dist/platform/ops/inbox.ops.js

@@ -34,12 +34,10 @@ const ADMIN_CONSOLE_PENDING = "Review it in the admin console (plugins, pending
 const requestName = (r) => r.item?.name ?? r.entry?.name ?? r.agent?.name ?? r.kind;
 const requester = (r) => r.requestedByName ?? "a deleted account";
 /** The name an org notice is about. */
-const orgNoticeName = (n) => n.kind === "skill_renamed" ? n.skillRenamed.to : n.detail.name;
+const orgNoticeName = (n) => n.detail.name;
 /** An org notice in one English sentence, as the inbox tells it. */
 function orgNoticeSummary(n) {
     switch (n.kind) {
-        case "skill_renamed":
-            return `Skill "${n.skillRenamed.from}" was renamed to "${n.skillRenamed.to}": a platform skill on in this org has its name; agents keep it.`;
         case "item_shared": {
             const d = n.detail;
             return `${d.ref.kind} ${d.name} was shared with ${d.org === "all_orgs" ? "every org" : d.org.name}.`;
@@ -182,18 +180,6 @@ function platformRow(i) {
                 next: "Open the plugin in the admin console to see the error and retry.",
             };
         }
-        case "platform_migration": {
-            const r = i.run;
-            const failed = r.itemsFailed.slice(0, 5).join(", ");
-            return {
-                ...base,
-                name: "platform components migration",
-                state: r.stuck ? "stuck" : "failed",
-                summary: r.stuck
-                    ? "The platform components migration run has not finished for over an hour; its worker stopped. The next run starts at the next worker start or day."
-                    : `The platform components migration could not write ${r.itemsFailed.length} catalog item(s): ${failed}${r.itemsFailed.length > 5 ? ", …" : ""}. The next run tries them again.`,
-            };
-        }
         case "ownership_transferred":
             return {
                 ...base,
@@ -243,9 +229,7 @@ let InboxOperations = class InboxOperations {
         if (row === undefined)
             return null;
         const base = { id: row.id, createdAt: row.created_at.toISOString() };
-        return (row.kind === "skill_renamed"
-            ? { ...base, kind: row.kind, skillRenamed: row.detail }
-            : { ...base, kind: row.kind, detail: row.detail });
+        return { ...base, kind: row.kind, detail: row.detail };
     }
     /** A platform notice by id (dismissed or not), or null. */
     async platformNotice(id) {
@@ -292,7 +276,7 @@ let InboxOperations = class InboxOperations {
             }),
             defineOperation({
                 id: "inbox.dismiss-notice",
-                description: "Dismiss an org notice from the inbox for every org admin (org admins): the id of a notice row from inbox.list (types skill_renamed, item_shared, shared_item_updated, upload_confirmed, upload_rejected). Approvals and requests are not dismissed here: they are decided on the web.",
+                description: "Dismiss an org notice from the inbox for every org admin (org admins): the id of a notice row from inbox.list (types item_shared, shared_item_updated, upload_confirmed, upload_rejected). Approvals and requests are not dismissed here: they are decided on the web.",
                 input: NoticeInput,
                 example: NOTICE_EXAMPLE,
                 authz: { orgAction: "catalog.decide" },
@@ -323,7 +307,7 @@ let InboxOperations = class InboxOperations {
             }),
             defineOperation({
                 id: "inbox.platform-list",
-                description: "List the platform inbox (super admin), newest first, one compact row each (type, what, state, summary, next step): orgs' requests to the platform, plugins waiting for a permission confirmation, this org's uploads waiting for you, failed scope syncs, a failed or stuck components migration and ownership notices. Only the newest 100 items are read (truncated: more wait); listed is how many of them are shown, otherOrgItems how many are items of plugins other orgs own (only counted). total counts everything waiting on the platform, other orgs' items included, as the admin console does; byType splits total by type (everything waiting, not the listed page). Nothing is decided here: requests and confirmations are done in the admin console. Pages by 50: pass the returned next as params.cursor.",
+                description: "List the platform inbox (super admin), newest first, one compact row each (type, what, state, summary, next step): orgs' requests to the platform, plugins waiting for a permission confirmation, this org's uploads waiting for you, failed scope syncs and ownership notices. Only the newest 100 items are read (truncated: more wait); listed is how many of them are shown, otherOrgItems how many are items of plugins other orgs own (only counted). total counts everything waiting on the platform, other orgs' items included, as the admin console does; byType splits total by type (everything waiting, not the listed page). Nothing is decided here: requests and confirmations are done in the admin console. Pages by 50: pass the returned next as params.cursor.",
                 input: z.object({ cursor: Cursor.optional() }).strict(),
                 example: {},
                 authz: { superAdmin: true },

package/dist/platform/ops/platform.ops.d.ts

@@ -32,6 +32,7 @@ export declare class PlatformOperationsProvider implements OnModuleInit {
      * default-on spec §8): every tool the org offers that the definition does not turn off, builtins
      * by name, extension tools as `plugin__<plugin>__<tool>`, connector tools as
      * `mcp__<slug>__<tool>`; the ones that cannot load now are listed with the registry's reason.
+     * Listed for the source of the conversation the operation runs in (memory plugin spec §6.2).
      */
     private toolKeys;
     onModuleInit(): void;

package/dist/platform/ops/platform.ops.js

@@ -10,6 +10,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 import { Inject, Injectable } from "@nestjs/common";
 import { z } from "zod";
 import { AgentsService } from "../../agents/agents.service.js";
+import { conversationSourceOf } from "../../conversations/source.js";
 import { AccountsService } from "../../identity/accounts.js";
 import { PreferencesSchema } from "../../identity/me.schemas.js";
 import { KernelDb } from "../../infra/database/kernel-db.js";
@@ -81,12 +82,14 @@ let PlatformOperationsProvider = class PlatformOperationsProvider {
      * default-on spec §8): every tool the org offers that the definition does not turn off, builtins
      * by name, extension tools as `plugin__<plugin>__<tool>`, connector tools as
      * `mcp__<slug>__<tool>`; the ones that cannot load now are listed with the registry's reason.
+     * Listed for the source of the conversation the operation runs in (memory plugin spec §6.2).
      */
-    async toolKeys(orgId, d) {
-        const resolved = await this.tools.forAgent(orgId, {
+    async toolKeys(ctx, d) {
+        const resolved = await this.tools.forAgent(ctx.orgId, {
             disabledTools: d.disabledTools ?? [],
             subagentTools: d.subagentTools,
             subagents: d.subagents,
+            source: await conversationSourceOf(this.db.db, ctx.conversationId),
         });
         return {
             keys: [...new Set(resolved.tools.map((t) => t.key))],
@@ -142,7 +145,7 @@ let PlatformOperationsProvider = class PlatformOperationsProvider {
                     const agent = await this.agents.get(ctx.orgId, ctx.agentId, ctx.actorAccountId);
                     const d = agent.definition;
                     const [{ keys: toolKeys, unavailable }, skills] = await Promise.all([
-                        this.toolKeys(ctx.orgId, d),
+                        this.toolKeys(ctx, d),
                         this.skillNames(ctx, d),
                     ]);
                     const sandbox = toolKeys.some((k) => SANDBOX_TOOL_NAMES.includes(k));

package/dist/roles/worker-role.d.ts

@@ -1,9 +1,10 @@
-import { PluginScopeSyncProcessor } from "../catalog/scope-sync.js";
+import { PluginScopeSyncProcessor } from "../catalog/scope-sync-workers.js";
 import { ChannelsProcessor } from "../channels/channels.module.js";
 import { ChannelOutbound } from "../channels/outbound.js";
 import { TitleQueue } from "../conversations/titles.js";
 import { EvalsProcessor } from "../evals/evals.module.js";
 import { EvalWorker } from "../evals/worker.js";
+import { LifecycleHooksProcessor } from "../extensions/lifecycle-hooks.js";
 import { KernelConfigService } from "../infra/config/kernel-config.service.js";
 import { LockedIntervalScheduler } from "../infra/schedule/locked-interval.js";
 import { ScheduledRuns } from "../infra/schedule/scheduled-runs.js";
@@ -15,8 +16,8 @@ import { UsageReporter } from "../runtime/usage-report.js";
 /**
  * The worker role's parts, driven by `KernelLifecycle` at fixed points of its start order and stop
  * phases (so they stay ordered after the extension load and before the extension host closes): the
- * queue consumers (runs, sub-agent runs, evals, maintenance, the plugin scope sync, channel
- * deliveries, `usage.report`, titles) and the schedulers of the `@LockedCron` / `@LockedInterval` jobs. Provided only by
+ * queue consumers (runs, sub-agent runs, evals, maintenance, the plugin scope sync, lifecycle
+ * hook deliveries, channel deliveries, `usage.report`, titles) and the schedulers of the `@LockedCron` / `@LockedInterval` jobs. Provided only by
  * `WorkerModule`, so a process without the worker role has none of them.
  */
 export declare class WorkerRole {
@@ -36,13 +37,14 @@ export declare class WorkerRole {
     private readonly evalsProcessor;
     private readonly maintenanceProcessor;
     private readonly scopeProcessor;
+    private readonly lifecycleProcessor;
     /** The startup config (the roles). */
     private readonly config;
     /** The run worker was started: the runs phase drains it. */
     private runsStarted;
     /** The eval worker was started: the runs phase drains it. */
     private evalsStarted;
-    constructor(config: KernelConfigService, log: KernelLogger, intervals: LockedIntervalScheduler, scheduledRuns: ScheduledRuns, runWorker: RunWorker, evalWorker: EvalWorker, usageReport: UsageReporter, titles: TitleQueue, channelOutbound: ChannelOutbound, runsProcessor: RunsProcessor, subagentRunsProcessor: SubagentRunsProcessor, usageProcessor: UsageReportProcessor, titleProcessor: TitleProcessor, channelsProcessor: ChannelsProcessor, evalsProcessor: EvalsProcessor, maintenanceProcessor: MaintenanceProcessor, scopeProcessor: PluginScopeSyncProcessor);
+    constructor(config: KernelConfigService, log: KernelLogger, intervals: LockedIntervalScheduler, scheduledRuns: ScheduledRuns, runWorker: RunWorker, evalWorker: EvalWorker, usageReport: UsageReporter, titles: TitleQueue, channelOutbound: ChannelOutbound, runsProcessor: RunsProcessor, subagentRunsProcessor: SubagentRunsProcessor, usageProcessor: UsageReportProcessor, titleProcessor: TitleProcessor, channelsProcessor: ChannelsProcessor, evalsProcessor: EvalsProcessor, maintenanceProcessor: MaintenanceProcessor, scopeProcessor: PluginScopeSyncProcessor, lifecycleProcessor: LifecycleHooksProcessor);
     /**
      * Starts the queue consumers (after the extension load), then opens the schedules' start gate:
      * the cron and interval timers were armed at application bootstrap, but every tick before this
@@ -60,6 +62,9 @@ export declare class WorkerRole {
     drainRuns(budgetMs: number): Promise<void> | undefined;
     /** The eval cases in progress stop (undefined: never started). */
     drainEvals(budgetMs: number): Promise<void> | undefined;
-    /** Closes the maintenance queue's worker and the plugin scope sync's (it stops between pairs). */
+    /**
+     * Closes the maintenance queue's worker, the plugin scope sync's (it stops between pairs) and
+     * the lifecycle hook deliveries' (calls in flight are aborted and retried).
+     */
     closeMaintenance(): Promise<void>;
 }

package/dist/roles/worker-role.js

@@ -8,12 +8,13 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { Inject, Injectable } from "@nestjs/common";
-import { PluginScopeSyncProcessor } from "../catalog/scope-sync.js";
+import { PluginScopeSyncProcessor } from "../catalog/scope-sync-workers.js";
 import { ChannelsProcessor } from "../channels/channels.module.js";
 import { ChannelOutbound } from "../channels/outbound.js";
 import { TitleQueue } from "../conversations/titles.js";
 import { EvalsProcessor } from "../evals/evals.module.js";
 import { EvalWorker } from "../evals/worker.js";
+import { LifecycleHooksProcessor } from "../extensions/lifecycle-hooks.js";
 import { KernelConfigService } from "../infra/config/kernel-config.service.js";
 import { LockedIntervalScheduler } from "../infra/schedule/locked-interval.js";
 import { ScheduledRuns } from "../infra/schedule/scheduled-runs.js";
@@ -25,8 +26,8 @@ import { UsageReporter } from "../runtime/usage-report.js";
 /**
  * The worker role's parts, driven by `KernelLifecycle` at fixed points of its start order and stop
  * phases (so they stay ordered after the extension load and before the extension host closes): the
- * queue consumers (runs, sub-agent runs, evals, maintenance, the plugin scope sync, channel
- * deliveries, `usage.report`, titles) and the schedulers of the `@LockedCron` / `@LockedInterval` jobs. Provided only by
+ * queue consumers (runs, sub-agent runs, evals, maintenance, the plugin scope sync, lifecycle
+ * hook deliveries, channel deliveries, `usage.report`, titles) and the schedulers of the `@LockedCron` / `@LockedInterval` jobs. Provided only by
  * `WorkerModule`, so a process without the worker role has none of them.
  */
 let WorkerRole = class WorkerRole {
@@ -46,13 +47,14 @@ let WorkerRole = class WorkerRole {
     evalsProcessor;
     maintenanceProcessor;
     scopeProcessor;
+    lifecycleProcessor;
     /** The startup config (the roles). */
     config;
     /** The run worker was started: the runs phase drains it. */
     runsStarted = false;
     /** The eval worker was started: the runs phase drains it. */
     evalsStarted = false;
-    constructor(config, log, intervals, scheduledRuns, runWorker, evalWorker, usageReport, titles, channelOutbound, runsProcessor, subagentRunsProcessor, usageProcessor, titleProcessor, channelsProcessor, evalsProcessor, maintenanceProcessor, scopeProcessor) {
+    constructor(config, log, intervals, scheduledRuns, runWorker, evalWorker, usageReport, titles, channelOutbound, runsProcessor, subagentRunsProcessor, usageProcessor, titleProcessor, channelsProcessor, evalsProcessor, maintenanceProcessor, scopeProcessor, lifecycleProcessor) {
         this.log = log;
         this.intervals = intervals;
         this.scheduledRuns = scheduledRuns;
@@ -69,6 +71,7 @@ let WorkerRole = class WorkerRole {
         this.evalsProcessor = evalsProcessor;
         this.maintenanceProcessor = maintenanceProcessor;
         this.scopeProcessor = scopeProcessor;
+        this.lifecycleProcessor = lifecycleProcessor;
         this.config = config.get();
     }
     /**
@@ -96,6 +99,7 @@ let WorkerRole = class WorkerRole {
         checkpoint();
         this.maintenanceProcessor.start();
         this.scopeProcessor.start();
+        this.lifecycleProcessor.start();
         this.channelOutbound.startWorker(this.channelsProcessor.worker);
         this.usageReport.startWorker(this.usageProcessor.worker);
         this.titles.startWorker(this.titleProcessor.worker);
@@ -105,8 +109,6 @@ let WorkerRole = class WorkerRole {
         // The gate opens: from here on ticks run; the runOnStart jobs run once now, in the background
         this.scheduledRuns.open();
         this.intervals.runStartJobs();
-        // Every plugin's scope converges once per worker start (a failed or lost sync is retried)
-        this.scopeProcessor.resync();
     }
     /**
      * Closes the start gate and stops the schedulers (no new tick; the runs in progress get the stop
@@ -123,9 +125,16 @@ let WorkerRole = class WorkerRole {
     drainEvals(budgetMs) {
         return this.evalsStarted ? this.evalWorker.close(budgetMs) : undefined;
     }
-    /** Closes the maintenance queue's worker and the plugin scope sync's (it stops between pairs). */
+    /**
+     * Closes the maintenance queue's worker, the plugin scope sync's (it stops between pairs) and
+     * the lifecycle hook deliveries' (calls in flight are aborted and retried).
+     */
     async closeMaintenance() {
-        await Promise.all([this.maintenanceProcessor.worker.close(), this.scopeProcessor.close()]);
+        await Promise.all([
+            this.maintenanceProcessor.worker.close(),
+            this.scopeProcessor.close(),
+            this.lifecycleProcessor.close(),
+        ]);
     }
 };
 WorkerRole = __decorate([
@@ -146,6 +155,7 @@ WorkerRole = __decorate([
     __param(13, Inject(ChannelsProcessor)),
     __param(14, Inject(EvalsProcessor)),
     __param(15, Inject(MaintenanceProcessor)),
-    __param(16, Inject(PluginScopeSyncProcessor))
+    __param(16, Inject(PluginScopeSyncProcessor)),
+    __param(17, Inject(LifecycleHooksProcessor))
 ], WorkerRole);
 export { WorkerRole };

package/dist/roles/worker.module.js

@@ -10,7 +10,6 @@ import { BackgroundModule } from "../background/background.module.js";
 import { BackgroundTaskPollJob } from "../background/poll.job.js";
 import { CatalogModule } from "../catalog/catalog.module.js";
 import { CatalogJobs } from "../catalog/jobs.js";
-import { PlatformMigration } from "../catalog/platform-migration.js";
 import { PluginScopeWorkersModule } from "../catalog/scope-sync-workers.js";
 import { ChannelsModule, ChannelWorkersModule } from "../channels/channels.module.js";
 import { GatewayCheckJob } from "../channels/supervisor.js";
@@ -24,11 +23,11 @@ import { LegacySandboxCleanupJob } from "../devices/legacy-cleanup.job.js";
 import { EvalWorkersModule } from "../evals/evals.module.js";
 import { ExtensionsModule } from "../extensions/extensions.module.js";
 import { PluginsReconcileJob } from "../extensions/lifecycle.js";
+import { LifecycleHookWorkersModule } from "../extensions/lifecycle-hooks.js";
 import { InitialPasswordCleanupJob } from "../identity/initial-passwords.job.js";
 import { OutboxRelayModule } from "../infra/outbox/outbox-relay.module.js";
 import { KernelScheduleModule } from "../infra/schedule/schedule.module.js";
 import { DirectoryScanJob } from "../orgs/directory-sync.js";
-import { OffboardSweepJob } from "../orgs/offboarding.js";
 import { OrgLockModule } from "../orgs/org-lock.js";
 import { OrgsModule } from "../orgs/orgs.module.js";
 import { MaintenanceModule } from "../runtime/maintenance.js";
@@ -69,6 +68,7 @@ let WorkerModule = WorkerModule_1 = class WorkerModule {
                 ChannelWorkersModule.forRoot(config),
                 MaintenanceModule,
                 PluginScopeWorkersModule,
+                LifecycleHookWorkersModule,
                 // the domains the fixed-period jobs call
                 RuntimeModule,
                 RunJobsModule,
@@ -100,9 +100,7 @@ let WorkerModule = WorkerModule_1 = class WorkerModule {
                 InitialPasswordCleanupJob,
                 ClientReportsCron,
                 CatalogJobs,
-                PlatformMigration,
                 DirectoryScanJob,
-                OffboardSweepJob,
                 PluginsReconcileJob,
                 GatewayCheckJob,
                 WorkerRole,

package/dist/runtime/context/build.d.ts

@@ -237,6 +237,9 @@ export declare function summaryText(summary: string): string;
  *   summary: the latest one follows the summary) /
  *   `run_context` (`role: "system"` at its position, `runContextText`; covered by the summary: the
  *   current context follows the summary whole; a user message's sender line by `senderLines`) /
+ *   `plugin_context` (`role: "system"` at its position, `pluginContextText`, nothing for empty
+ *   text; covered by the summary: the latest non-empty one per plugin, in plugin-name order,
+ *   follows the summary after `device_paths`) /
  *   `background_task_finished`（`role: "system"`, the text of
  *   {@link renderBackgroundFinished}, placed like a user_message）/ `subagent_delivery` (likewise,
  *   the text of {@link renderSubagentDelivery})；`tool_result` 事件还原为紧随其 assistant 消息之后的一条 user 消息

package/dist/runtime/context/build.js

@@ -6,6 +6,7 @@ import { catalogText, isAlwaysLoaded } from "../../tools/builtins/tool-search.js
 import { renderSubagentDelivery } from "../subagents/render.js";
 import { devicePathsAt, devicePathsText } from "./device-paths.js";
 import { LEGACY_CATALOG_HEADER, LEGACY_SKILL_TEXTS, usesLegacyToolNames } from "./legacy-text.js";
+import { pluginContextsAfterSummary, pluginContextText } from "./plugin-context.js";
 import { currentRunContext, runContextEvents, runContextFullText, runContextText, scheduleHeader, senderLines, } from "./run-context.js";
 import { invokedSkillNames, invokedSkillsText, SKILL_TEXTS, skillsCatalogEvents, snapshotChangeText, snapshotCurrentText, snapshotSystemText, systemSkillsCatalog, } from "./skills.js";
 import { toolsChangedText } from "./tool-changes.js";
@@ -341,6 +342,9 @@ export function summaryText(summary) {
  *   summary: the latest one follows the summary) /
  *   `run_context` (`role: "system"` at its position, `runContextText`; covered by the summary: the
  *   current context follows the summary whole; a user message's sender line by `senderLines`) /
+ *   `plugin_context` (`role: "system"` at its position, `pluginContextText`, nothing for empty
+ *   text; covered by the summary: the latest non-empty one per plugin, in plugin-name order,
+ *   follows the summary after `device_paths`) /
  *   `background_task_finished`（`role: "system"`, the text of
  *   {@link renderBackgroundFinished}, placed like a user_message）/ `subagent_delivery` (likewise,
  *   the text of {@link renderSubagentDelivery})；`tool_result` 事件还原为紧随其 assistant 消息之后的一条 user 消息
@@ -561,6 +565,10 @@ export function buildModelRequest(input) {
         if (paths) {
             messages.push({ role: "system", content: devicePathsText(paths.payload) });
         }
+        // memory spec §6.1: each plugin's context in effect at the boundary follows the summary again
+        for (const text of pluginContextsAfterSummary(events, after)) {
+            messages.push({ role: "system", content: text });
+        }
         // 被摘要覆盖的变更提醒不再发送：摘要时生效的目录与 system 里的不同 → 紧随摘要补上完整的当前目录
         const covered = skillSnaps.filter((e) => e.seq <= after).at(-1);
         // (phase B: plus the current pinned skills and tool-name map when they differ from system's)
@@ -639,6 +647,13 @@ export function buildModelRequest(input) {
             case "device_paths":
                 messages.push({ role: "system", content: devicePathsText(e.payload) });
                 break;
+            // a context@1 provider's text (memory spec §6.1); empty text (nothing any more) renders nothing
+            case "plugin_context": {
+                const text = pluginContextText(e.payload);
+                if (text !== "")
+                    messages.push({ role: "system", content: text });
+                break;
+            }
             // hook_denied is not model-visible: the model sees only the denied tool call's tool_result
             // (and nothing for a denied model request), so request building skips it
             case "hook_denied":

package/dist/runtime/context/plugin-context.d.ts

@@ -0,0 +1,20 @@
+import type { ConversationEvent, EventPayload } from "../../conversations/events.js";
+/**
+ * The `plugin_context` event (memory spec §6.1): the text a `context@1` provider added to the
+ * conversation at a run start, written only when it changed. Model-visible: rendered at its
+ * position as a system message; after a summary that covers it, the latest non-empty one per
+ * plugin follows the summary again. Its text is in the log, so it needs no `DriftReason`.
+ */
+/** The payload of a `plugin_context` event. */
+export type PluginContextPayload = EventPayload<"plugin_context">;
+/** The idempotency key of a run's `plugin_context` event for `plugin`. */
+export declare const pluginContextIdemKey: (runId: string, plugin: string) => string;
+/** The system message of a `plugin_context` event (empty text renders nothing: ""). */
+export declare function pluginContextText(p: PluginContextPayload): string;
+/** The latest `plugin_context` payload of each plugin at or before `uptoSeq`. */
+export declare function latestPluginContexts(events: readonly ConversationEvent[], uptoSeq: number): Map<string, PluginContextPayload>;
+/**
+ * The system messages that follow a summary covering up to `after`: the latest non-empty
+ * `plugin_context` of each plugin, in plugin-name order.
+ */
+export declare function pluginContextsAfterSummary(events: readonly ConversationEvent[], after: number): string[];

package/dist/runtime/context/plugin-context.js

@@ -0,0 +1,30 @@
+/** The idempotency key of a run's `plugin_context` event for `plugin`. */
+export const pluginContextIdemKey = (runId, plugin) => `plugin_context:${runId}:${plugin}`;
+/** The system message of a `plugin_context` event (empty text renders nothing: ""). */
+export function pluginContextText(p) {
+    if (p.text === "")
+        return "";
+    return `<plugin-context plugin="${p.plugin}">\n${p.text}\n</plugin-context>`;
+}
+/** The latest `plugin_context` payload of each plugin at or before `uptoSeq`. */
+export function latestPluginContexts(events, uptoSeq) {
+    const latest = new Map();
+    for (const e of events) {
+        if (e.type !== "plugin_context" || e.seq > uptoSeq)
+            continue;
+        const prev = latest.get(e.payload.plugin);
+        if (!prev || e.seq > prev.seq)
+            latest.set(e.payload.plugin, { seq: e.seq, payload: e.payload });
+    }
+    return new Map([...latest].map(([plugin, v]) => [plugin, v.payload]));
+}
+/**
+ * The system messages that follow a summary covering up to `after`: the latest non-empty
+ * `plugin_context` of each plugin, in plugin-name order.
+ */
+export function pluginContextsAfterSummary(events, after) {
+    return [...latestPluginContexts(events, after)]
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+        .map(([, p]) => pluginContextText(p))
+        .filter((text) => text !== "");
+}

package/dist/runtime/langgraph-loop.js

@@ -148,6 +148,7 @@ export class LangGraphLoop {
             mediaCache,
             agentId: ctx.agentId,
             accountId: ctx.triggerAccountId,
+            source: ctx.source,
             ...(ctx.conversationKind !== undefined && { conversationKind: ctx.conversationKind }),
             ...(ctx.parent !== undefined && { parentRunId: ctx.parent.runId, parent: ctx.parent }),
             ...(ctx.subagent === true && { subagent: true }),
@@ -221,6 +222,9 @@ export class LangGraphLoop {
                 agentVersion: ctx.agentVersion,
                 agent: ctx.agent,
                 accountId: ctx.triggerAccountId,
+                source: ctx.source,
+                ownerAccountId: ctx.ownerAccountId,
+                role: ctx.role,
                 signal: ctx.signal,
                 ...(ctx.limits.deadline !== undefined && { deadline: ctx.limits.deadline }),
                 ...(ctx.conversationKind !== undefined && { conversationKind: ctx.conversationKind }),

package/dist/runtime/loop.d.ts

@@ -1,6 +1,8 @@
+import type { ConversationSource } from "@capybara-hq/plugin-sdk";
 import type { AgentDefinition } from "../agents/definition.js";
 import type { KernelConfig } from "../config/schema.js";
 import type { AbsorbableEvent } from "../conversations/events.js";
+import type { OrgRole } from "../orgs/roles.js";
 import type { StreamSink } from "./model-call.js";
 /** 一次运行交给 loop 的上下文（spec 4.4）。 */
 export interface LoopContext {
@@ -12,6 +14,12 @@ export interface LoopContext {
     agentId: string;
     /** 发起本次运行的人（对话发起人）：工具调用用其个人凭据，审计记为 actor。 */
     triggerAccountId: string;
+    /** The conversation's source, read once per run (memory plugin spec §6.2). */
+    source: ConversationSource;
+    /** The conversation's owner (`conversations.account_id`); plugin tool handlers receive it. */
+    ownerAccountId: string;
+    /** The trigger account's org role when the run starts; plugin tool handlers receive it. */
+    role: OrgRole;
     agent: AgentDefinition;
     agentVersion: number;
     /** 用户中止或到达 deadline 时触发：进行中的模型调用立即停下。 */

package/dist/runtime/maintenance.d.ts

@@ -4,8 +4,10 @@ import { OwnedPluginCleanup } from "../catalog/owned-plugin-cleanup.js";
 import { ScheduledRuns } from "../infra/schedule/scheduled-runs.js";
 import type { KernelLogger } from "../log.js";
 import { DirectorySync } from "../orgs/directory-sync.js";
+import { Offboarding } from "../orgs/offboarding.js";
 import { SandboxService } from "../sandbox/sandbox.service.js";
 import { ScheduledTaskFirer } from "../schedules/fire.js";
+import { DeviceOpResolver } from "../tools/device-op-resolver.js";
 import { ToolDrift } from "../tools/drift.js";
 import { RunQueue } from "./run-queue.js";
 import { Waits } from "./waits.js";
@@ -16,27 +18,30 @@ export declare const MAINTENANCE_CONCURRENCY = 5;
  * The one consumer of `cap-kernel-maintenance` (decision R11 of the Nest kernel spec): dispatches
  * each one-off job by name to its domain (`wait-timeout` → {@link Waits}, `sandbox-destroy-for` and
  * `sandbox-reset-files` → {@link SandboxService}, `drift-connector` → {@link ToolDrift}, `directory-sync` →
- * {@link DirectorySync}, `bg-wake` and `ensure-run` → {@link RunQueue.ensureRun}, `stop-tree` →
+ * {@link DirectorySync}, `run-stop` → {@link Offboarding.stopRun}, `bg-wake` and `ensure-run` → {@link RunQueue.ensureRun}, `stop-tree` →
  * {@link processStopTree} and `deliver-to-parent` → {@link processDeliverToParent} (both in
  * runtime/subagents/tree-jobs.ts, over {@link Waits}), `owned-plugin-cleanup` →
- * {@link OwnedPluginCleanup}, `sched-fire` → {@link ScheduledTaskFirer}). The name of a periodic job (a `@LockedCron` / `@LockedInterval` job,
+ * {@link OwnedPluginCleanup}, `sched-fire` and `sched-settle` → {@link ScheduledTaskFirer}, `device-op-resolve` →
+ * {@link DeviceOpResolver}). The name of a periodic job (a `@LockedCron` / `@LockedInterval` job,
  * such as `sandbox-suspend-idle`) runs that job's body once ({@link ScheduledRuns.runNow}), as the
  * maintenance handlers did when those jobs were schedulers on this queue: an operator's or a
  * test's one-off run, not a second schedule (decision R23 of the Nest kernel spec). Any other
- * name is warned and completes. The producers are the domains' own (same names, ids and options).
+ * name fails the job (BullMQ retries it; in a rolling deploy a newer replica knows it). The producers are the domains' own (same names, ids and options).
  */
 export declare class MaintenanceProcessor extends WorkerHost<Worker> {
     private readonly waits;
     private readonly sandbox;
     private readonly drift;
     private readonly directory;
+    private readonly offboarding;
     private readonly runs;
     private readonly ownedCleanup;
     private readonly scheduledTasks;
+    private readonly deviceOps;
     private readonly scheduled;
     private readonly log;
     private readonly queue;
-    constructor(waits: Pick<Waits, "processTimeout" | "childFinished" | "stopChildren" | "stopDescendantsOfStopped" | "stopTree">, sandbox: Pick<SandboxService, "destroyDevice" | "resetFileSystem">, drift: Pick<ToolDrift, "check">, directory: Pick<DirectorySync, "runSyncJob">, runs: Pick<RunQueue, "ensureRun">, ownedCleanup: Pick<OwnedPluginCleanup, "run">, scheduledTasks: Pick<ScheduledTaskFirer, "fire">, scheduled: Pick<ScheduledRuns, "runNow">, log: Pick<KernelLogger, "error" | "warn">, queue: Pick<Queue, "removeJobScheduler">);
+    constructor(waits: Pick<Waits, "processTimeout" | "childFinished" | "stopChildren" | "stopDescendantsOfStopped" | "stopTree">, sandbox: Pick<SandboxService, "destroyDevice" | "resetFileSystem">, drift: Pick<ToolDrift, "check">, directory: Pick<DirectorySync, "runSyncJob">, offboarding: Pick<Offboarding, "stopRun">, runs: Pick<RunQueue, "ensureRun">, ownedCleanup: Pick<OwnedPluginCleanup, "run">, scheduledTasks: Pick<ScheduledTaskFirer, "fire" | "settle">, deviceOps: Pick<DeviceOpResolver, "resolve">, scheduled: Pick<ScheduledRuns, "runNow">, log: Pick<KernelLogger, "error" | "warn">, queue: Pick<Queue, "removeJobScheduler">);
     /**
      * Removes the retired job schedulers (`RETIRED_SCHEDULER_IDS`, runtime/retired-schedulers.ts): every fixed-period
      * maintenance job is a `@LockedCron` / `@LockedInterval` now. Idempotent; called once when a

package/dist/runtime/maintenance.js

@@ -19,13 +19,16 @@ import { runJob } from "../infra/queue/run-job.js";
 import { KernelScheduleModule } from "../infra/schedule/schedule.module.js";
 import { ScheduledRuns } from "../infra/schedule/scheduled-runs.js";
 import { KERNEL_LOGGER } from "../infra/tokens.js";
+import { DEVICE_OP_RESOLVE_JOB, } from "../local-devices/policy-op-jobs.js";
 import { DIRECTORY_SYNC_JOB, DirectorySync } from "../orgs/directory-sync.js";
+import { Offboarding, RUN_STOP_JOB } from "../orgs/offboarding.js";
 import { OrgsModule } from "../orgs/orgs.module.js";
 import { runSandboxDestroyFor, runSandboxResetFiles, SANDBOX_DESTROY_FOR_JOB, SANDBOX_RESET_FILES_JOB, } from "../sandbox/jobs.js";
 import { SandboxModule } from "../sandbox/sandbox.module.js";
 import { SandboxService } from "../sandbox/sandbox.service.js";
 import { ScheduledTaskFireModule, ScheduledTaskFirer } from "../schedules/fire.js";
-import { SCHED_FIRE_JOB } from "../schedules/job-ids.js";
+import { SCHED_FIRE_JOB, SCHED_SETTLE_JOB, } from "../schedules/job-ids.js";
+import { DeviceOpResolver } from "../tools/device-op-resolver.js";
 import { ToolDrift } from "../tools/drift.js";
 import { DRIFT_CONNECTOR_JOB } from "../tools/job-ids.js";
 import { ToolsModule } from "../tools/tools.module.js";
@@ -42,35 +45,40 @@ export const MAINTENANCE_CONCURRENCY = 5;
  * The one consumer of `cap-kernel-maintenance` (decision R11 of the Nest kernel spec): dispatches
  * each one-off job by name to its domain (`wait-timeout` → {@link Waits}, `sandbox-destroy-for` and
  * `sandbox-reset-files` → {@link SandboxService}, `drift-connector` → {@link ToolDrift}, `directory-sync` →
- * {@link DirectorySync}, `bg-wake` and `ensure-run` → {@link RunQueue.ensureRun}, `stop-tree` →
+ * {@link DirectorySync}, `run-stop` → {@link Offboarding.stopRun}, `bg-wake` and `ensure-run` → {@link RunQueue.ensureRun}, `stop-tree` →
  * {@link processStopTree} and `deliver-to-parent` → {@link processDeliverToParent} (both in
  * runtime/subagents/tree-jobs.ts, over {@link Waits}), `owned-plugin-cleanup` →
- * {@link OwnedPluginCleanup}, `sched-fire` → {@link ScheduledTaskFirer}). The name of a periodic job (a `@LockedCron` / `@LockedInterval` job,
+ * {@link OwnedPluginCleanup}, `sched-fire` and `sched-settle` → {@link ScheduledTaskFirer}, `device-op-resolve` →
+ * {@link DeviceOpResolver}). The name of a periodic job (a `@LockedCron` / `@LockedInterval` job,
  * such as `sandbox-suspend-idle`) runs that job's body once ({@link ScheduledRuns.runNow}), as the
  * maintenance handlers did when those jobs were schedulers on this queue: an operator's or a
  * test's one-off run, not a second schedule (decision R23 of the Nest kernel spec). Any other
- * name is warned and completes. The producers are the domains' own (same names, ids and options).
+ * name fails the job (BullMQ retries it; in a rolling deploy a newer replica knows it). The producers are the domains' own (same names, ids and options).
  */
 let MaintenanceProcessor = class MaintenanceProcessor extends WorkerHost {
     waits;
     sandbox;
     drift;
     directory;
+    offboarding;
     runs;
     ownedCleanup;
     scheduledTasks;
+    deviceOps;
     scheduled;
     log;
     queue;
-    constructor(waits, sandbox, drift, directory, runs, ownedCleanup, scheduledTasks, scheduled, log, queue) {
+    constructor(waits, sandbox, drift, directory, offboarding, runs, ownedCleanup, scheduledTasks, deviceOps, scheduled, log, queue) {
         super();
         this.waits = waits;
         this.sandbox = sandbox;
         this.drift = drift;
         this.directory = directory;
+        this.offboarding = offboarding;
         this.runs = runs;
         this.ownedCleanup = ownedCleanup;
         this.scheduledTasks = scheduledTasks;
+        this.deviceOps = deviceOps;
         this.scheduled = scheduled;
         this.log = log;
         this.queue = queue;
@@ -109,6 +117,23 @@ let MaintenanceProcessor = class MaintenanceProcessor extends WorkerHost {
             case DIRECTORY_SYNC_JOB:
                 await this.directory.runSyncJob(job.data);
                 return;
+            // a departed member's run stop, owed by the offboarding (transactional outbox spec §8.1)
+            case RUN_STOP_JOB:
+                try {
+                    await this.offboarding.stopRun(job.data);
+                }
+                catch (err) {
+                    // nothing stops the run after its last attempt: say so (the failed job is kept)
+                    if (job.attemptsMade + 1 >= (job.opts.attempts ?? 1)) {
+                        this.log.error("a departed member's run could not be stopped", {
+                            jobId: job.id,
+                            runId: job.data.runId,
+                            err,
+                        });
+                    }
+                    throw err;
+                }
+                return;
             // the end of a conversation's wake window (background Bash spec §3)
             case BG_WAKE_JOB: {
                 // fired before the window ended (clock skew): it reschedules under its next retry id
@@ -136,10 +161,22 @@ let MaintenanceProcessor = class MaintenanceProcessor extends WorkerHost {
             case SCHED_FIRE_JOB:
                 await this.scheduledTasks.fire(job.data.taskRunId);
                 return;
+            // a task run's settle check, claimed or unfired (ruling R26)
+            case SCHED_SETTLE_JOB:
+                await this.scheduledTasks.settle(job.data);
+                return;
+            // a device policy op whose outcome was not recorded (transactional outbox spec §7)
+            case DEVICE_OP_RESOLVE_JOB:
+                await this.deviceOps.resolve(job.data);
+                return;
             default:
                 if (await this.scheduled.runNow(job.name))
                     return;
-                this.log.warn("unknown maintenance job", { name: job.name, jobId: job.id });
+                // never completed unrun: in a rolling deploy an old worker meets a job a newer replica
+                // owed (its outbox row is gone once added); failing it leaves it to BullMQ's retries, so a
+                // newer replica can take it within the job's attempts (old workers still go first, see
+                // docs/deploy/upgrade.md)
+                throw new Error(`unknown maintenance job "${job.name}"`);
         }
     }
     failed(job, err) {
@@ -161,12 +198,14 @@ MaintenanceProcessor = __decorate([
     __param(1, Inject(SandboxService)),
     __param(2, Inject(ToolDrift)),
     __param(3, Inject(DirectorySync)),
-    __param(4, Inject(RunQueue)),
-    __param(5, Inject(OwnedPluginCleanup)),
-    __param(6, Inject(ScheduledTaskFirer)),
-    __param(7, Inject(ScheduledRuns)),
-    __param(8, Inject(KERNEL_LOGGER)),
-    __param(9, Inject(getQueueToken(MAINTENANCE_QUEUE_NAME)))
+    __param(4, Inject(Offboarding)),
+    __param(5, Inject(RunQueue)),
+    __param(6, Inject(OwnedPluginCleanup)),
+    __param(7, Inject(ScheduledTaskFirer)),
+    __param(8, Inject(DeviceOpResolver)),
+    __param(9, Inject(ScheduledRuns)),
+    __param(10, Inject(KERNEL_LOGGER)),
+    __param(11, Inject(getQueueToken(MAINTENANCE_QUEUE_NAME)))
 ], MaintenanceProcessor);
 export { MaintenanceProcessor };
 /**
@@ -186,7 +225,7 @@ MaintenanceModule = __decorate([
             SandboxModule,
             ToolsModule,
             OrgsModule,
-            // the removed org plugins' cleanup and its daily sweep (worker-only through this module)
+            // the removed org plugins' cleanup job (worker-only through this module)
             OwnedPluginCleanupModule,
             // the scheduled task fire job and the scanner (worker-only through this module)
             ScheduledTaskFireModule,