@capybara-hq/kernel 0.1.0-rc.6 → 0.1.0-rc.8

package/dist/platform/parity.js

@@ -0,0 +1,272 @@
+import { z } from "zod";
+/** `:orgId` is the conversation's org: never an operation field, so never compared. */
+const IMPLICIT = new Set(["orgId"]);
+/** Bounds an operation may tighten but never loosen: the upper ones, then the lower ones. */
+const UPPER = ["maxLength", "maximum", "exclusiveMaximum", "maxItems", "maxProperties"];
+const LOWER = ["minLength", "minimum", "exclusiveMinimum", "minItems", "minProperties"];
+const toJson = (s) => z.toJSONSchema(s, { io: "input", unrepresentable: "any" });
+/** A schema's alternatives: the branches of `anyOf` / `oneOf` (flattened), else itself. */
+function alternatives(s) {
+    const branches = (s.anyOf ?? s.oneOf);
+    return branches ? branches.flatMap(alternatives) : [s];
+}
+const propsOf = (s) => s.properties;
+const requiredOf = (s) => new Set((s.required ?? []));
+/**
+ * The top-level fields of an object schema; of a union, each branch's fields (a field that
+ * differs between branches is the `anyOf` of its branch schemas, required only when every
+ * branch requires it).
+ */
+function fieldsOf(s) {
+    const branches = alternatives(s);
+    const out = new Map();
+    for (const branch of branches) {
+        const req = requiredOf(branch);
+        for (const [k, v] of Object.entries(propsOf(branch) ?? {})) {
+            const f = out.get(k) ?? { schemas: [], requiredIn: 0 };
+            f.schemas.push(v);
+            if (req.has(k))
+                f.requiredIn += 1;
+            out.set(k, f);
+        }
+    }
+    return new Map([...out].map(([k, f]) => {
+        const distinct = [...new Map(f.schemas.map((v) => [JSON.stringify(v), v])).values()];
+        const schema = distinct.length === 1 ? distinct[0] : { anyOf: distinct };
+        return [k, { schema, required: f.requiredIn === branches.length }];
+    }));
+}
+/** The route field at a dotted path (`definition.name`): required only when every step is. */
+function fieldAt(fields, path) {
+    const [head, ...rest] = path.split(".");
+    let f = fields.get(head);
+    for (const seg of rest) {
+        if (f === undefined)
+            return undefined;
+        const holder = alternatives(f.schema).find((a) => propsOf(a)?.[seg] !== undefined);
+        const next = holder && propsOf(holder)?.[seg];
+        if (!holder || !next)
+            return undefined;
+        f = { schema: next, required: f.required && requiredOf(holder).has(seg) };
+    }
+    return f;
+}
+const jsonType = (v) => v === null ? "null" : Array.isArray(v) ? "array" : typeof v;
+/** The JSON types a schema accepts; `undefined` when it accepts anything. */
+function typesOf(s) {
+    if (s.type !== undefined)
+        return new Set(Array.isArray(s.type) ? s.type : [s.type]);
+    if ("const" in s)
+        return new Set([jsonType(s.const)]);
+    if (Array.isArray(s.enum))
+        return new Set(s.enum.map(jsonType));
+    return undefined;
+}
+/** `integer` is a `number`; every other type only itself. */
+const typeFits = (t, allowed) => allowed.has(t) || (t === "integer" && allowed.has("number"));
+const describeTypes = (t) => t === undefined ? "any" : [...t].sort().join(" | ");
+const valuesOf = (s) => "const" in s ? [s.const] : Array.isArray(s.enum) ? s.enum : undefined;
+/**
+ * Why one operation alternative accepts more than one route alternative, or null when it accepts
+ * no more (spec §14.5 item 3). Objects, arrays and records are compared recursively: every
+ * operation property is a route property, every property the route requires the operation
+ * requires, a closed route object is closed in the operation, items and values fit.
+ */
+function misfit(op, route, path, top) {
+    /** The reason, prefixed by the path inside the compared field (none at the field itself). */
+    const at = (p, why) => (p === top ? why : `${p}: ${why}`);
+    const want = typesOf(route);
+    const got = typesOf(op);
+    if (want !== undefined && (got === undefined || [...got].some((t) => !typeFits(t, want)))) {
+        return at(path, `type ${describeTypes(got)} in the operation, ${describeTypes(want)} in the route`);
+    }
+    const allowed = valuesOf(route);
+    if (allowed !== undefined) {
+        const vs = valuesOf(op);
+        const keys = new Set(allowed.map((v) => JSON.stringify(v)));
+        if (vs === undefined || vs.some((v) => !keys.has(JSON.stringify(v)))) {
+            return at(path, `values ${vs === undefined ? "any" : JSON.stringify(vs)} are looser than the route's ${JSON.stringify(allowed)}`);
+        }
+    }
+    for (const k of UPPER) {
+        const r = route[k];
+        const o = op[k];
+        if (r !== undefined && (o === undefined || o > r)) {
+            return at(path, `${k} ${o ?? "unbounded"} is looser than the route's ${r}`);
+        }
+    }
+    for (const k of LOWER) {
+        const r = route[k];
+        const o = op[k];
+        if (r !== undefined && (o === undefined || o < r)) {
+            return at(path, `${k} ${o ?? "unbounded"} is looser than the route's ${r}`);
+        }
+    }
+    for (const k of ["pattern", "format"]) {
+        if (route[k] !== undefined && op[k] !== route[k]) {
+            return at(path, `${k} ${op[k] === undefined ? "none" : JSON.stringify(op[k])} differs from the route's ${JSON.stringify(route[k])}`);
+        }
+    }
+    const sub = (k) => `${path}.${k}`;
+    const rp = propsOf(route);
+    if (rp !== undefined) {
+        const opProps = propsOf(op) ?? {};
+        const opReq = requiredOf(op);
+        for (const k of requiredOf(route)) {
+            if (!opReq.has(k))
+                return at(sub(k), "required by the route, optional or missing here");
+        }
+        for (const [k, v] of Object.entries(opProps)) {
+            const r = rp[k];
+            if (r === undefined)
+                return at(sub(k), "no field of the route");
+            const why = fieldMismatch(v, r, sub(k), top);
+            if (why !== null)
+                return why;
+        }
+    }
+    if (route.additionalProperties === false && op.additionalProperties !== false) {
+        return at(path, "accepts unknown keys, the route does not");
+    }
+    // a record's values: an operation closed to unknown keys accepts none, else its values must fit
+    if (typeof route.additionalProperties === "object" && op.additionalProperties !== false) {
+        const why = fieldMismatch((op.additionalProperties ?? {}), route.additionalProperties, sub("*"), top);
+        if (why !== null)
+            return why;
+    }
+    if (typeof route.propertyNames === "object") {
+        const why = fieldMismatch((op.propertyNames ?? {}), route.propertyNames, sub("<key>"), top);
+        if (why !== null)
+            return why;
+    }
+    if (typeof route.items === "object" && route.items !== null) {
+        const why = fieldMismatch((op.items ?? {}), route.items, sub("[]"), top);
+        if (why !== null)
+            return why;
+    }
+    return null;
+}
+/** Why the operation's schema accepts more than the route's, or null: each op alternative fits one. */
+function fieldMismatch(op, route, path, top) {
+    const routeAlts = alternatives(route);
+    for (const a of alternatives(op)) {
+        const reasons = routeAlts.map((b) => misfit(a, b, path, top));
+        if (!reasons.includes(null))
+            return reasons[0];
+    }
+    return null;
+}
+/**
+ * Compares an operation's input with one mirrored route's body + query + path params (spec
+ * §14.5 item 3), on their input JSON Schemas:
+ * - each input field is compared with the route field of the same name, or the route path its
+ *   `renames` entry names (`skillId` → `id`, `name` → `definition.name`): the same type (an
+ *   operation `integer` fits a route `number`), enum values a subset, bounds no looser
+ *   (`maxLength` / `maximum` / `maxItems` at most the route's, the lower bounds at least), the
+ *   same `pattern` and `format`, and required where the route requires it; nested objects,
+ *   arrays and records recursively (a nested optional route field the operation leaves out is
+ *   allowed, a required one is not);
+ * - a `loosens` entry names an input field allowed to accept more than the route (with the
+ *   reason); it is still compared by type, and an entry that loosens nothing is stale;
+ * - a top-level route field the input neither has nor renames into is listed in `omits`, an input
+ *   field with no route counterpart in `extras`; stale entries of either are findings.
+ */
+export function inputParity(op, route) {
+    const out = [];
+    const add = (field, message) => out.push({ op: op.id, route: route.route, field, message: `${op.id}: ${message}` });
+    const opFields = fieldsOf(toJson(op.input));
+    const routeFields = new Map();
+    for (const part of [route.params, route.query, route.body]) {
+        if (part === undefined)
+            continue;
+        for (const [k, v] of fieldsOf(toJson(part)))
+            if (!IMPLICIT.has(k))
+                routeFields.set(k, v);
+    }
+    const omits = new Set(op.omits ?? []);
+    const extras = new Set(op.extras ?? []);
+    const renames = new Map(Object.entries(op.renames ?? {}));
+    const loosens = new Map(Object.entries(op.loosens ?? {}));
+    const r = `\`${route.route}\``;
+    /** Top-level route fields an input field covers (by name or by a rename into it). */
+    const covered = new Set();
+    for (const [k, opField] of opFields) {
+        const target = renames.get(k) ?? k;
+        const routeField = fieldAt(routeFields, target);
+        if (routeField === undefined) {
+            if (renames.has(k))
+                add(k, `\`renames\` maps \`${k}\` to \`${target}\`, no field of ${r}`);
+            else if (!extras.has(k))
+                add(k, `\`${k}\` is no field of ${r} and not in \`extras\``);
+            continue;
+        }
+        covered.add(target.split(".")[0]);
+        if (extras.has(k))
+            add(k, `\`extras\` names \`${k}\`, which ${r} has as \`${target}\``);
+        const reason = loosens.get(k);
+        const name = target === k ? `\`${k}\`` : `\`${k}\` (\`${target}\`)`;
+        if (reason !== undefined) {
+            if (reason.trim() === "")
+                add(k, `\`loosens\` names \`${k}\` without a reason`);
+            const want = typesOf(routeField.schema);
+            const got = typesOf(opField.schema);
+            if (want !== undefined && (got === undefined || [...got].some((t) => !typeFits(t, want)))) {
+                add(k, `${name}: type ${describeTypes(got)} in the operation, ${describeTypes(want)} in the route (${r}; \`loosens\` excuses bounds, never the type)`);
+            }
+            const looser = (routeField.required && !opField.required) ||
+                fieldMismatch(opField.schema, routeField.schema, target, target) !== null;
+            if (!looser)
+                add(k, `\`loosens\` names ${name}, which is no looser than ${r}`);
+            continue;
+        }
+        if (routeField.required && !opField.required) {
+            add(k, `${name} is required by ${r} but optional here (declare it in \`loosens\` if meant)`);
+        }
+        const why = fieldMismatch(opField.schema, routeField.schema, target, target);
+        if (why !== null)
+            add(k, `${name}: ${why} (${r})`);
+    }
+    for (const k of routeFields.keys()) {
+        if (!covered.has(k) && !omits.has(k)) {
+            add(k, `\`${k}\` of ${r} is missing from the input and not in \`omits\``);
+        }
+    }
+    for (const k of omits) {
+        if (!routeFields.has(k))
+            add(k, `\`omits\` names \`${k}\`, no field of ${r}`);
+        else if (covered.has(k))
+            add(k, `\`omits\` names \`${k}\`, but the input has it`);
+    }
+    for (const k of extras) {
+        if (!opFields.has(k))
+            add(k, `\`extras\` names \`${k}\`, which the input lacks`);
+    }
+    for (const k of renames.keys()) {
+        if (!opFields.has(k))
+            add(k, `\`renames\` names \`${k}\`, which the input lacks`);
+    }
+    for (const k of loosens.keys()) {
+        if (!opFields.has(k))
+            add(k, `\`loosens\` names \`${k}\`, which the input lacks`);
+    }
+    return out;
+}
+/**
+ * {@link inputParity} of every operation against each route it mirrors; a mirrored route whose
+ * schemas are not registered is a finding too (a removed route is `check:platform-ops`'s orphan).
+ */
+export function checkInputParity(ops, routes) {
+    const byRoute = new Map(routes.map((r) => [r.route, r]));
+    return ops.flatMap((op) => op.mirrors.flatMap((m) => {
+        const r = byRoute.get(m);
+        return r !== undefined
+            ? inputParity(op, r)
+            : [
+                {
+                    op: op.id,
+                    route: m,
+                    message: `${op.id} mirrors \`${m}\`, whose schemas are not in ROUTE_SCHEMAS: export them from the controller's <domain>.schemas.ts and list them there`,
+                },
+            ];
+    }));
+}

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

@@ -1,3 +1,35 @@
+import { AccountsOperations } from "./ops/accounts.ops.js";
+import { AdminOperations } from "./ops/admin.ops.js";
+import { AgentSkillsOperations } from "./ops/agent-skills.ops.js";
+import { AgentTemplatesOperations } from "./ops/agent-templates.ops.js";
+import { AgentsOperations } from "./ops/agents.ops.js";
+import { ApprovalsOperations } from "./ops/approvals.ops.js";
+import { BackgroundOperations } from "./ops/background.ops.js";
+import { CatalogAdminOperations } from "./ops/catalog-admin.ops.js";
+import { ChannelsOperations } from "./ops/channels.ops.js";
+import { ComponentsOperations } from "./ops/components.ops.js";
+import { ConnectorsOperations } from "./ops/connectors.ops.js";
+import { ConversationsOperations } from "./ops/conversations.ops.js";
+import { EnvironmentsOperations } from "./ops/environments.ops.js";
+import { EvalsOperations } from "./ops/evals.ops.js";
+import { ExtensionsOperations } from "./ops/extensions.ops.js";
+import { ExtensionsAdminOperations } from "./ops/extensions-admin.ops.js";
+import { InboxOperations } from "./ops/inbox.ops.js";
+import { MarketplacesOperations } from "./ops/marketplaces.ops.js";
+import { ModelsOperations } from "./ops/models.ops.js";
+import { OrgPluginsOperations } from "./ops/org-plugins.ops.js";
+import { OrgSettingsOperations } from "./ops/org-settings.ops.js";
+import { OrgsOperations } from "./ops/orgs.ops.js";
+import { PlatformOperationsProvider } from "./ops/platform.ops.js";
+import { PluginsOperations } from "./ops/plugins.ops.js";
+import { PreviewersOperations } from "./ops/previewers.ops.js";
+import { RequestsOperations } from "./ops/requests.ops.js";
+import { SkillsOperations } from "./ops/skills.ops.js";
+/**
+ * One provider per domain, each taking `PlatformOperations` as its first constructor argument:
+ * the parity test in `tools/checks` builds the operations from it without a Nest app.
+ */
+export declare const PLATFORM_OPERATION_PROVIDERS: readonly [typeof PlatformOperationsProvider, typeof SkillsOperations, typeof AgentsOperations, typeof AgentTemplatesOperations, typeof PluginsOperations, typeof MarketplacesOperations, typeof RequestsOperations, typeof ConnectorsOperations, typeof ExtensionsOperations, typeof ConversationsOperations, typeof ComponentsOperations, typeof AccountsOperations, typeof OrgsOperations, typeof AdminOperations, typeof CatalogAdminOperations, typeof OrgPluginsOperations, typeof ExtensionsAdminOperations, typeof ModelsOperations, typeof InboxOperations, typeof ApprovalsOperations, typeof ChannelsOperations, typeof OrgSettingsOperations, typeof EvalsOperations, typeof BackgroundOperations, typeof PreviewersOperations, typeof EnvironmentsOperations, typeof AgentSkillsOperations];
 /**
  * The `Platform` tool's operations (ruling P2): one provider per domain, each registering its
  * operations into `PlatformOperations` from `onModuleInit`. It imports the domain modules, which

package/dist/platform/platform-ops.module.js

@@ -6,21 +6,88 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Module } from "@nestjs/common";
 import { AgentsModule } from "../agents/agents.module.js";
+import { BackgroundModule } from "../background/background.module.js";
 import { CatalogModule } from "../catalog/catalog.module.js";
+import { ChannelsModule } from "../channels/channels.module.js";
+import { ConversationsModule } from "../conversations/conversations.module.js";
+import { EnvironmentsModule } from "../environments/environments.module.js";
+import { EvalsModule } from "../evals/evals.module.js";
 import { ExtensionsModule } from "../extensions/extensions.module.js";
+import { FilesModule } from "../files/files.module.js";
+import { IdentityModule } from "../identity/identity.module.js";
+import { InboxModule } from "../inbox/inbox.module.js";
+import { ModelsModule } from "../models/models.module.js";
 import { OrgsModule } from "../orgs/orgs.module.js";
+import { ProvidersModule } from "../runtime/providers.js";
 import { SkillsModule } from "../skills/skills.module.js";
 import { ToolsModule } from "../tools/tools.module.js";
+import { AccountsOperations } from "./ops/accounts.ops.js";
+import { AdminOperations } from "./ops/admin.ops.js";
+import { AgentSkillsOperations } from "./ops/agent-skills.ops.js";
 import { AgentTemplatesOperations } from "./ops/agent-templates.ops.js";
 import { AgentsOperations } from "./ops/agents.ops.js";
+import { ApprovalsOperations } from "./ops/approvals.ops.js";
+import { BackgroundOperations } from "./ops/background.ops.js";
+import { CatalogAdminOperations } from "./ops/catalog-admin.ops.js";
+import { ChannelsOperations } from "./ops/channels.ops.js";
+import { ComponentsOperations } from "./ops/components.ops.js";
 import { ConnectorsOperations } from "./ops/connectors.ops.js";
+import { ConversationsOperations } from "./ops/conversations.ops.js";
+import { EnvironmentsOperations } from "./ops/environments.ops.js";
+import { EvalsOperations } from "./ops/evals.ops.js";
 import { ExtensionsOperations } from "./ops/extensions.ops.js";
+import { ExtensionsAdminOperations } from "./ops/extensions-admin.ops.js";
+import { InboxOperations } from "./ops/inbox.ops.js";
 import { MarketplacesOperations } from "./ops/marketplaces.ops.js";
+import { ModelsOperations } from "./ops/models.ops.js";
+import { OrgPluginsOperations } from "./ops/org-plugins.ops.js";
+import { OrgSettingsOperations } from "./ops/org-settings.ops.js";
+import { OrgsOperations } from "./ops/orgs.ops.js";
 import { PlatformOperationsProvider } from "./ops/platform.ops.js";
 import { PluginsOperations } from "./ops/plugins.ops.js";
+import { PreviewersOperations } from "./ops/previewers.ops.js";
 import { RequestsOperations } from "./ops/requests.ops.js";
 import { SkillsOperations } from "./ops/skills.ops.js";
 import { PlatformModule } from "./platform.module.js";
+/**
+ * One provider per domain, each taking `PlatformOperations` as its first constructor argument:
+ * the parity test in `tools/checks` builds the operations from it without a Nest app.
+ */
+export const PLATFORM_OPERATION_PROVIDERS = [
+    PlatformOperationsProvider,
+    SkillsOperations,
+    AgentsOperations,
+    AgentTemplatesOperations,
+    PluginsOperations,
+    MarketplacesOperations,
+    RequestsOperations,
+    ConnectorsOperations,
+    ExtensionsOperations,
+    ConversationsOperations,
+    ComponentsOperations,
+    // Task 7: admin accounts and orgs
+    AccountsOperations,
+    OrgsOperations,
+    AdminOperations,
+    // Task 8: admin catalog, extensions, marketplaces, models, org uploads
+    CatalogAdminOperations,
+    OrgPluginsOperations,
+    ExtensionsAdminOperations,
+    ModelsOperations,
+    // Task 9: inbox and pending reads
+    InboxOperations,
+    ApprovalsOperations,
+    // Task 10: channels, org settings
+    ChannelsOperations,
+    OrgSettingsOperations,
+    // Task 11: evals, background tasks, file previewers
+    EvalsOperations,
+    BackgroundOperations,
+    PreviewersOperations,
+    // Task 11b: environments, agent skills
+    EnvironmentsOperations,
+    AgentSkillsOperations,
+];
 /**
  * The `Platform` tool's operations (ruling P2): one provider per domain, each registering its
  * operations into `PlatformOperations` from `onModuleInit`. It imports the domain modules, which
@@ -38,18 +105,18 @@ PlatformOpsModule = __decorate([
             CatalogModule,
             ExtensionsModule,
             ToolsModule,
+            ConversationsModule,
+            IdentityModule,
+            ModelsModule,
+            ProvidersModule,
+            InboxModule,
+            ChannelsModule,
+            EvalsModule,
+            EnvironmentsModule,
+            BackgroundModule,
+            FilesModule,
         ],
-        providers: [
-            PlatformOperationsProvider,
-            SkillsOperations,
-            AgentsOperations,
-            AgentTemplatesOperations,
-            PluginsOperations,
-            MarketplacesOperations,
-            RequestsOperations,
-            ConnectorsOperations,
-            ExtensionsOperations,
-        ],
+        providers: [...PLATFORM_OPERATION_PROVIDERS],
     })
 ], PlatformOpsModule);
 export { PlatformOpsModule };

package/dist/platform/route-schemas.d.ts

@@ -0,0 +1,18 @@
+import type { z } from "zod";
+/**
+ * The zod schemas one HTTP route validates (spec §14.5 item 3), as its controller uses them:
+ * `route` is the `check:platform-ops` key (`POST /api/v1/orgs/:orgId/skills`), `params` its path
+ * params but `:orgId` (the conversation's org, never an operation field).
+ */
+export interface RouteSchemas {
+    route: string;
+    body?: z.ZodType;
+    query?: z.ZodType;
+    params?: z.ZodType;
+}
+/**
+ * Every route a Platform operation mirrors, from the exported `<domain>.schemas.ts` next to each
+ * controller. An operation builds its input from these (`pick` / `omit` / `extend`); the parity
+ * test in `tools/checks` compares the two. A route mirrored by a new operation adds its entry here.
+ */
+export declare const ROUTE_SCHEMAS: readonly RouteSchemas[];

package/dist/platform/route-schemas.js

@@ -0,0 +1,63 @@
+import { ADMIN_ROUTES } from "../admin/admin.schemas.js";
+import { ADMIN_EXTENSION_ROUTES } from "../admin/extensions.schemas.js";
+import { AGENT_ROUTES } from "../agents/agents.schemas.js";
+import { AGENT_TEMPLATE_ROUTES } from "../agents/templates.schemas.js";
+import { BACKGROUND_ROUTES } from "../background/background.schemas.js";
+import { ADMIN_CATALOG_ROUTES } from "../catalog/admin-catalog.schemas.js";
+import { COMPONENT_SCOPE_ROUTES } from "../catalog/component-scope.schemas.js";
+import { MARKETPLACE_ROUTES } from "../catalog/marketplaces.schemas.js";
+import { ORG_CATALOG_ROUTES } from "../catalog/org-catalog.schemas.js";
+import { ORG_EXTENSION_ROUTES } from "../catalog/org-extension.schemas.js";
+import { ORG_PLUGIN_UPLOAD_ROUTES } from "../catalog/org-plugin-uploads.schemas.js";
+import { CHANNEL_ROUTES } from "../channels/channels.schemas.js";
+import { CONVERSATION_ROUTES } from "../conversations/conversations.schemas.js";
+import { ENVIRONMENT_ROUTES } from "../environments/environments.schemas.js";
+import { EVAL_ROUTES } from "../evals/evals.schemas.js";
+import { EXTENSION_POINT_ROUTES } from "../extensions/point-defaults.schemas.js";
+import { FILE_PREVIEWER_ROUTES } from "../files/previewers.schemas.js";
+import { ME_ROUTES } from "../identity/me.schemas.js";
+import { INBOX_ROUTES } from "../inbox/inbox.schemas.js";
+import { ORG_MODEL_ROUTES } from "../models/org-models.schemas.js";
+import { ORG_ROUTES, ORG_SETTINGS_ROUTES } from "../orgs/orgs.schemas.js";
+import { SKILL_ROUTES } from "../skills/skills.schemas.js";
+import { APPROVAL_ROUTES } from "../tools/approvals.schemas.js";
+import { CONNECTOR_ROUTES } from "../tools/connectors.schemas.js";
+/**
+ * Every route a Platform operation mirrors, from the exported `<domain>.schemas.ts` next to each
+ * controller. An operation builds its input from these (`pick` / `omit` / `extend`); the parity
+ * test in `tools/checks` compares the two. A route mirrored by a new operation adds its entry here.
+ */
+export const ROUTE_SCHEMAS = [
+    ...SKILL_ROUTES,
+    ...AGENT_ROUTES,
+    ...AGENT_TEMPLATE_ROUTES,
+    ...ORG_CATALOG_ROUTES,
+    ...ADMIN_CATALOG_ROUTES,
+    ...MARKETPLACE_ROUTES,
+    ...CONNECTOR_ROUTES,
+    ...COMPONENT_SCOPE_ROUTES,
+    ...ORG_EXTENSION_ROUTES,
+    ...CONVERSATION_ROUTES,
+    // Task 7: admin accounts, orgs, deployment settings, platform models
+    ...ADMIN_ROUTES,
+    ...ORG_ROUTES,
+    // Task 8: admin catalog, extensions, marketplaces, models, org uploads
+    ...ADMIN_EXTENSION_ROUTES,
+    ...ORG_PLUGIN_UPLOAD_ROUTES,
+    ...EXTENSION_POINT_ROUTES,
+    ...ORG_MODEL_ROUTES,
+    // Task 9: inbox and pending reads
+    ...INBOX_ROUTES,
+    ...APPROVAL_ROUTES,
+    // Task 10: channels, org settings
+    ...CHANNEL_ROUTES,
+    ...ORG_SETTINGS_ROUTES,
+    // Task 11: evals, background tasks, file previewers
+    ...EVAL_ROUTES,
+    ...BACKGROUND_ROUTES,
+    ...FILE_PREVIEWER_ROUTES,
+    // Task 11b: environments
+    ...ENVIRONMENT_ROUTES,
+    // personal preferences (run context spec §3.4)
+    ...ME_ROUTES,
+];

package/dist/roles/worker.module.js

@@ -22,6 +22,7 @@ import { LegacySandboxCleanupJob } from "../environments/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 { InitialPasswordCleanupJob } from "../identity/initial-passwords.job.js";
 import { KernelScheduleModule } from "../infra/schedule/schedule.module.js";
 import { DirectoryScanJob } from "../orgs/directory-sync.js";
 import { OffboardSweepJob } from "../orgs/offboarding.js";
@@ -85,6 +86,7 @@ let WorkerModule = WorkerModule_1 = class WorkerModule {
                 LegacySandboxCleanupJob,
                 BackgroundTaskPollJob,
                 ToolJobs,
+                InitialPasswordCleanupJob,
                 CatalogJobs,
                 PlatformMigration,
                 DirectoryScanJob,

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

@@ -233,6 +233,8 @@ export declare function summaryText(summary: string): string;
  *   `user_message` / `assistant_message`（content 原样，含 opaque；aborted 的也回放；媒体引用按
  *   {@link resolveMedia} 换成 base64 或文字占位）/ `reminder`
  *   （`role: "system"`，放在它所在的位置）/ `tools_changed` (`role: "system"`, the text of {@link toolsChangedText}, at its position) /
+ *   `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`) /
  *   `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

@@ -5,6 +5,7 @@ import { isAbsorbable, } from "../../conversations/events.js";
 import { catalogText, isAlwaysLoaded } from "../../tools/builtins/tool-search.js";
 import { renderSubagentDelivery } from "../subagents/render.js";
 import { LEGACY_CATALOG_HEADER, LEGACY_SKILL_TEXTS, usesLegacyToolNames } from "./legacy-text.js";
+import { currentRunContext, runContextEvents, runContextFullText, runContextText, senderLines, } from "./run-context.js";
 import { invokedSkillNames, invokedSkillsText, SKILL_TEXTS, skillsCatalogEvents, snapshotChangeText, snapshotCurrentText, snapshotSystemText, systemSkillsCatalog, } from "./skills.js";
 import { toolsChangedText } from "./tool-changes.js";
 /**
@@ -335,6 +336,8 @@ export function summaryText(summary) {
  *   `user_message` / `assistant_message`（content 原样，含 opaque；aborted 的也回放；媒体引用按
  *   {@link resolveMedia} 换成 base64 或文字占位）/ `reminder`
  *   （`role: "system"`，放在它所在的位置）/ `tools_changed` (`role: "system"`, the text of {@link toolsChangedText}, at its position) /
+ *   `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`) /
  *   `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 消息
@@ -463,11 +466,21 @@ export function buildModelRequest(input) {
         }
         racedPending = racedPending.filter((x) => x.seq > toSeq);
     };
-    /** A user message's blocks, with its fork report when it has one. */
+    /** Run context spec §4: the sender lines, by the messages after the summary boundary. */
+    const senders = senderLines(events, after);
+    /**
+     * A user message's blocks: its sender line first when the sender changed (a separate block, so
+     * `content[0]` stays the typed text), then its own blocks, then its fork report when it has one.
+     */
     const userBlocks = (u) => {
         const report = forkReports.get(u.seq);
+        const line = senders.get(u.seq);
         const blocks = blocksOf(u.payload.content);
-        return report === undefined ? blocks : [...blocks, { type: "text", text: report }];
+        return [
+            ...(line === undefined ? [] : [{ type: "text", text: line }]),
+            ...blocks,
+            ...(report === undefined ? [] : [{ type: "text", text: report }]),
+        ];
     };
     /** 被某次模型调用跳过（运行中途到达）、尚未被吸收的可吸收事件，按 seq 升序。 */
     let deferred = [];
@@ -526,6 +539,14 @@ export function buildModelRequest(input) {
             role: "user",
             content: [{ type: "text", text: summaryText(summary.payload.text) }],
         });
+        // run context spec §5: snapshots covered by the summary are not rendered; the context in
+        // effect at the summary's boundary follows it whole
+        if (runContextEvents(events).some((e) => e.seq <= after)) {
+            messages.push({
+                role: "system",
+                content: runContextFullText(currentRunContext(events, after)),
+            });
+        }
         // 被摘要覆盖的变更提醒不再发送：摘要时生效的目录与 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)
@@ -594,6 +615,11 @@ export function buildModelRequest(input) {
             case "tools_changed":
                 messages.push({ role: "system", content: toolsChangedText(e.payload) });
                 break;
+            // who the agent is and the facts of the day (run context spec §4): the first snapshot whole,
+            // a later one as the changes against the fold before it
+            case "run_context":
+                messages.push({ role: "system", content: runContextText(events, e) });
+                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/compaction.js

@@ -1,6 +1,7 @@
 import { renderBackgroundFinished } from "../../background/render.js";
 import { renderSubagentDelivery } from "../subagents/render.js";
 import { latestSummary } from "./build.js";
+import { senderTranscriptLabel } from "./run-context.js";
 import { toolsChangedText } from "./tool-changes.js";
 /** 压缩请求的标记：放在 system 中，便于识别（model-fake 据此返回摘要）。 */
 export const COMPACTION_MARKER = "CAPYBARA_COMPACTION";
@@ -106,7 +107,13 @@ function transcriptLine(e) {
     switch (e.type) {
         case "user_message": {
             const text = renderBlocks(e.payload.content);
-            return text ? `User: ${text}` : null;
+            if (!text)
+                return null;
+            // run context spec §5: the sender as logged (older logs have none: unchanged)
+            const sender = e.payload.sender;
+            return sender !== undefined
+                ? `User (${senderTranscriptLabel(sender)}): ${text}`
+                : `User: ${text}`;
         }
         case "assistant_message": {
             const text = renderBlocks(e.payload.content);
@@ -127,6 +134,8 @@ function transcriptLine(e) {
         // phase D: a forked skill's report is user content of the request (build.ts)
         case "skill_fork_result":
             return `User: ${e.payload.text}`;
+        // run_context is left out: its current values follow the summary anyway (build.ts), and
+        // stale names should not be summarised as current
         case "tool_result":
             return `Tool result ${e.payload.toolKey}${e.payload.isError ? " (error)" : ""}: ${e.payload.content}`;
         default: