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

package/dist/identity/initial-passwords.js

@@ -0,0 +1,159 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { randomInt } from "node:crypto";
+import { Inject, Injectable } from "@nestjs/common";
+import { sql } from "kysely";
+import { ApiError } from "../errors.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { TransactionHost } from "../infra/database/transaction-host.js";
+import { Transactional } from "../infra/database/transactional.decorator.js";
+import { KEYRING } from "../infra/tokens.js";
+import { AccountsService } from "./accounts.js";
+import { audit } from "./audit.js";
+/** Letters and digits without the look-alikes (0 O 1 l I): read off a screen and typed by hand. */
+const ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz23456789";
+/** 20 characters of 56: about 116 bits. */
+const LENGTH = 20;
+/**
+ * How long a generated password waits for its reader. The approving person reads it right after
+ * the call runs; one that is never read expires (the account can still be disabled and recreated).
+ */
+export const INITIAL_PASSWORD_TTL_MS = 24 * 60 * 60 * 1000;
+/** The tool key of the approval a generated password belongs to. */
+export const CREATE_ACCOUNT_TOOL_KEY = "Platform:accounts.create";
+/** A one-time initial password, cryptographically random. */
+export function generateInitialPassword() {
+    let out = "";
+    for (let i = 0; i < LENGTH; i++)
+        out += ALPHABET[randomInt(ALPHABET.length)];
+    return out;
+}
+/** The AAD binding a sealed password to its account (a row moved to another account fails). */
+const aadOf = (accountId) => `capybara:initial-password:${accountId}`;
+/**
+ * Accounts created with a kernel-generated one-time password (Platform tool spec §14.5 item 2).
+ * The password never leaves the kernel except through {@link reveal}: it is not returned to the
+ * caller, not written to the audit, the event log or the logs. It is sealed with the master keyring
+ * in the creation's transaction and read once, on the web, by the person who approved the call.
+ */
+let InitialPasswords = class InitialPasswords {
+    db;
+    txHost;
+    keyring;
+    accounts;
+    constructor(db, txHost, keyring, accounts) {
+        this.db = db;
+        this.txHost = txHost;
+        this.keyring = keyring;
+        this.accounts = accounts;
+    }
+    /**
+     * Creates a local account (never a super admin) with a generated password it must change at
+     * first sign-in, and seals the password for `to`. Returns the account only.
+     */
+    async createAccount(input, actorAccountId, to, auditDetail) {
+        const password = generateInitialPassword();
+        return this.accounts.createByAdmin({ ...input, password, superAdmin: false, mustChangePassword: true }, actorAccountId, undefined, {
+            ...(auditDetail !== undefined && { auditDetail }),
+            inTransaction: (account) => this.seal(account.id, password, to),
+        });
+    }
+    /** Stores the sealed password in the creation's transaction (the hourly job drops expired ones). */
+    async seal(accountId, password, to) {
+        const { data, masterKeyId } = this.keyring.wrap(Buffer.from(password, "utf8"), aadOf(accountId));
+        await this.db
+            .insertInto("account_initial_passwords")
+            .values({
+            account_id: accountId,
+            recipient_account_id: to.recipientAccountId,
+            conversation_id: to.conversationId,
+            run_id: to.runId,
+            call_id: to.callId,
+            master_key_id: masterKeyId,
+            ciphertext: data,
+            expires_at: new Date(Date.now() + INITIAL_PASSWORD_TTL_MS),
+        })
+            .execute();
+    }
+    /**
+     * The password created by an approved `accounts.create` call, read once by the person who
+     * approved it (`approvalId` in `orgId`, decided by `accountId`), then deleted. Anything else (not
+     * that person, not approved, not run yet, read already, expired) is
+     * `account.initial_password_unavailable`, saying nothing about which. Audits the read (without
+     * the password).
+     */
+    async reveal(orgId, approvalId, accountId) {
+        const unavailable = () => new ApiError("account.initial_password_unavailable", "No initial password to show: it was shown already, has expired, or the account was not created by a call you approved");
+        const approval = await this.db
+            .selectFrom("approvals")
+            .select(["conversation_id", "run_id", "call_id", "tool_key", "status", "decided_by"])
+            .where("id", "=", approvalId)
+            .where("org_id", "=", orgId)
+            .executeTakeFirst();
+        if (approval === undefined ||
+            approval.tool_key !== CREATE_ACCOUNT_TOOL_KEY ||
+            approval.status !== "approved" ||
+            approval.decided_by !== accountId) {
+            throw unavailable();
+        }
+        // exactly the row of this approval's call: locked, then deleted by its key
+        const found = await this.db
+            .selectFrom("account_initial_passwords")
+            .select("account_id")
+            .where("conversation_id", "=", approval.conversation_id)
+            .where("run_id", "=", approval.run_id)
+            .where("call_id", "=", approval.call_id)
+            .where("recipient_account_id", "=", accountId)
+            .where("expires_at", ">", sql `now()`)
+            .limit(1)
+            .forUpdate()
+            .executeTakeFirst();
+        if (found === undefined)
+            throw unavailable();
+        const row = await this.db
+            .deleteFrom("account_initial_passwords")
+            .where("account_id", "=", found.account_id)
+            .returning(["account_id", "master_key_id", "ciphertext"])
+            .executeTakeFirst();
+        if (row === undefined)
+            throw unavailable();
+        const password = this.keyring
+            .unwrap(row.master_key_id, row.ciphertext, aadOf(row.account_id))
+            .toString("utf8");
+        const login = (await this.accounts.localLogins([row.account_id])).get(row.account_id) ?? null;
+        await audit(this.db.db, {
+            actorAccountId: accountId,
+            orgId,
+            action: "account.initial_password_shown",
+            target: row.account_id,
+            detail: { approvalId },
+        });
+        return { accountId: row.account_id, login, password };
+    }
+};
+__decorate([
+    Transactional()
+], InitialPasswords.prototype, "reveal", null);
+InitialPasswords = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(TransactionHost)),
+    __param(2, Inject(KEYRING)),
+    __param(3, Inject(AccountsService))
+], InitialPasswords);
+export { InitialPasswords };
+/** Deletes the sealed passwords past `expires_at`; returns how many. */
+export async function deleteExpiredInitialPasswords(db) {
+    const r = await db
+        .deleteFrom("account_initial_passwords")
+        .where("expires_at", "<=", sql `now()`)
+        .executeTakeFirst();
+    return Number(r.numDeletedRows);
+}

package/dist/identity/me.controller.d.ts

@@ -6,6 +6,7 @@ import { OrgsService } from "../orgs/orgs.service.js";
 import type { OrgRole } from "../orgs/roles.js";
 import { type Account, AccountsService } from "./accounts.js";
 import { type ApiTokenRecord, ApiTokenService } from "./api-tokens.js";
+import { type PreferencesSchema } from "./me.schemas.js";
 import { type Principal } from "./principal.js";
 import { SessionService } from "./sessions.js";
 import { SettingsService } from "./settings.js";
@@ -44,6 +45,17 @@ export declare class MeController {
         /** Whether `POST /api/v1/orgs` would accept this account (the `orgCreation` setting). */
         canCreateOrg: boolean;
     }>;
+    /**
+     * The person's preferences (run context spec §3.4): `timeZone` null = follow the browser's time
+     * zone sent with each message; a set zone overrides it for the messages sent afterwards.
+     */
+    preferences(principal: Principal): Promise<{
+        timeZone: string | null;
+    }>;
+    /** Replaces the person's preferences; an unknown time zone → 400 `validation_failed`. */
+    setPreferences(principal: Principal, body: z.infer<typeof PreferencesSchema>): Promise<{
+        timeZone: string | null;
+    }>;
     /** 切换当前组织（仅 Web 会话）；`null` 清空。非成员或已软删除的组织 → `org.not_found`。 */
     setCurrentOrg(principal: Principal, body: z.infer<typeof CurrentOrgSchema>): Promise<void>;
     /**

package/dist/identity/me.controller.js

@@ -18,7 +18,8 @@ import { OrgsService } from "../orgs/orgs.service.js";
 import { AccountsService } from "./accounts.js";
 import { ApiTokenService, FutureIsoDate } from "./api-tokens.js";
 import { MAX_PASSWORD_LENGTH } from "./login.js";
-import { CurrentPrincipal, requireUser, SessionOnly } from "./principal.js";
+import { PreferencesBody } from "./me.schemas.js";
+import { AllowPendingPasswordChange, CurrentPrincipal, requireUser, SessionOnly, } from "./principal.js";
 import { SessionService } from "./sessions.js";
 import { SettingsService } from "./settings.js";
 /** The credential throttlers of a password change (per account, per client IP). */
@@ -72,6 +73,19 @@ let MeController = class MeController {
         const canCreateOrg = orgCreation === "anyone" || p.account.isSuperAdmin;
         return { account: p.account, via: p.via, currentOrgId: current, memberships, canCreateOrg };
     }
+    /**
+     * The person's preferences (run context spec §3.4): `timeZone` null = follow the browser's time
+     * zone sent with each message; a set zone overrides it for the messages sent afterwards.
+     */
+    async preferences(principal) {
+        return this.accounts.preferences(requireUser(principal).account.id);
+    }
+    /** Replaces the person's preferences; an unknown time zone → 400 `validation_failed`. */
+    async setPreferences(principal, body) {
+        return this.accounts.setPreferences(requireUser(principal).account.id, {
+            timeZone: body.timeZone,
+        });
+    }
     /** 切换当前组织（仅 Web 会话）；`null` 清空。非成员或已软删除的组织 → `org.not_found`。 */
     async setCurrentOrg(principal, body) {
         const p = requireUser(principal);
@@ -97,6 +111,11 @@ let MeController = class MeController {
             throw new ApiError("auth.invalid_credentials", "Current password is incorrect");
         }
         await this.throttler.succeeded(CHANGE_PASSWORD_THROTTLERS, req);
+        if (p.account.mustChangePassword && body.newPassword === body.currentPassword) {
+            throw new ApiError("validation_failed", "Choose a password other than the initial one", [
+                { path: "newPassword", message: "must differ from the initial password" },
+            ]);
+        }
         // 新密码、吊销其他会话（PG revoked_at）与个人令牌在同一个 PG 事务里完成
         const revoked = await this.accounts.changePassword(p.account.id, body.newPassword, p.sessionId);
         try {
@@ -125,8 +144,18 @@ let MeController = class MeController {
 };
 __decorate([
     Get(),
+    AllowPendingPasswordChange(),
     __param(0, CurrentPrincipal())
 ], MeController.prototype, "me", null);
+__decorate([
+    Get("preferences"),
+    __param(0, CurrentPrincipal())
+], MeController.prototype, "preferences", null);
+__decorate([
+    Put("preferences"),
+    __param(0, CurrentPrincipal()),
+    __param(1, ZBody(PreferencesBody))
+], MeController.prototype, "setPreferences", null);
 __decorate([
     Put("current-org"),
     SessionOnly(),
@@ -137,6 +166,7 @@ __decorate([
 __decorate([
     Put("password"),
     SessionOnly(),
+    AllowPendingPasswordChange(),
     HttpCode(204),
     __param(0, CurrentPrincipal()),
     __param(1, ZBody(ChangePasswordBody)),

package/dist/identity/me.schemas.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import type { RouteSchemas } from "../platform/route-schemas.js";
+/** `PUT /me/preferences`: the person's preferences (run context spec §3.4). */
+export declare const PreferencesSchema: z.ZodObject<{
+    timeZone: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+declare const PreferencesBody_base: import("../infra/validation/create-zod-dto.js").ZodDtoClass<z.ZodObject<{
+    timeZone: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>>;
+export declare class PreferencesBody extends PreferencesBody_base {
+}
+/** The `/me` routes the Platform operations mirror (`check:platform-ops` keys). */
+export declare const ME_ROUTES: readonly RouteSchemas[];
+export {};

package/dist/identity/me.schemas.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+import { createZodDto } from "../infra/validation/create-zod-dto.js";
+import { IanaTimeZone } from "../time-zone.js";
+/** `PUT /me/preferences`: the person's preferences (run context spec §3.4). */
+export const PreferencesSchema = z
+    .object({
+    /** The person's time zone (IANA); null = follow the browser (run context spec §3.4). */
+    timeZone: IanaTimeZone.nullable(),
+})
+    .strict();
+export class PreferencesBody extends createZodDto(PreferencesSchema, "PreferencesBody") {
+}
+/** The `/me` routes the Platform operations mirror (`check:platform-ops` keys). */
+export const ME_ROUTES = [
+    { route: "GET /api/v1/me/preferences" },
+    { route: "PUT /api/v1/me/preferences", body: PreferencesSchema },
+];

package/dist/identity/principal.d.ts

@@ -30,6 +30,7 @@ export declare const PUBLIC_KEY = "capybara:auth:public";
 export declare const SESSION_ONLY_KEY = "capybara:auth:session-only";
 export declare const SUPER_ADMIN_KEY = "capybara:auth:super-admin";
 export declare const ALLOW_SERVICE_KEY = "capybara:auth:allow-service";
+export declare const PASSWORD_CHANGE_KEY = "capybara:auth:password-change";
 /**
  * 不要求凭据：无凭据时放行（principal 为 undefined）；带了有效凭据仍解析，无效凭据按无凭据处理。
  * 非安全方法照样要求 `X-Capybara-Csrf: 1`（防登录 CSRF）。新增公开路由必须同时更新 public-routes 元测试的清单。
@@ -39,6 +40,13 @@ export declare const Public: () => MethodDecorator & ClassDecorator;
 export declare const SessionOnly: () => MethodDecorator;
 /** 仅超级管理员（user principal 且 `isSuperAdmin`）；否则 `forbidden`。 */
 export declare const SuperAdmin: () => MethodDecorator & ClassDecorator;
+/**
+ * Reachable by an account that must change its generated initial password first
+ * (`Account.mustChangePassword`): the guard refuses every other route with
+ * `auth.password_change_required`. Only `GET /me` and `PUT /me/password` carry it (public routes
+ * such as logout are reachable anyway).
+ */
+export declare const AllowPendingPasswordChange: () => MethodDecorator;
 /**
  * 允许服务令牌（service principal）访问。默认拒绝：未标注的路由只接受 user principal，service → `forbidden`。
  * 组织级路由由 OrgGuard 再核对令牌所属组织与角色。

package/dist/identity/principal.js

@@ -4,6 +4,7 @@ export const PUBLIC_KEY = "capybara:auth:public";
 export const SESSION_ONLY_KEY = "capybara:auth:session-only";
 export const SUPER_ADMIN_KEY = "capybara:auth:super-admin";
 export const ALLOW_SERVICE_KEY = "capybara:auth:allow-service";
+export const PASSWORD_CHANGE_KEY = "capybara:auth:password-change";
 /**
  * 不要求凭据：无凭据时放行（principal 为 undefined）；带了有效凭据仍解析，无效凭据按无凭据处理。
  * 非安全方法照样要求 `X-Capybara-Csrf: 1`（防登录 CSRF）。新增公开路由必须同时更新 public-routes 元测试的清单。
@@ -13,6 +14,13 @@ export const Public = () => SetMetadata(PUBLIC_KEY, true);
 export const SessionOnly = () => SetMetadata(SESSION_ONLY_KEY, true);
 /** 仅超级管理员（user principal 且 `isSuperAdmin`）；否则 `forbidden`。 */
 export const SuperAdmin = () => SetMetadata(SUPER_ADMIN_KEY, true);
+/**
+ * Reachable by an account that must change its generated initial password first
+ * (`Account.mustChangePassword`): the guard refuses every other route with
+ * `auth.password_change_required`. Only `GET /me` and `PUT /me/password` carry it (public routes
+ * such as logout are reachable anyway).
+ */
+export const AllowPendingPasswordChange = () => SetMetadata(PASSWORD_CHANGE_KEY, true);
 /**
  * 允许服务令牌（service principal）访问。默认拒绝：未标注的路由只接受 user principal，service → `forbidden`。
  * 组织级路由由 OrgGuard 再核对令牌所属组织与角色。

package/dist/identity/settings.d.ts

@@ -133,6 +133,8 @@ export declare class SettingsService {
      */
     get(): Promise<DeploymentSettings>;
     /** Updates settings under the super admin lock, re-checking the actor (else `forbidden`). */
-    update(patch: DeploymentSettingsPatch, actorAccountId: string, actorTokenId?: string): Promise<DeploymentSettings>;
+    update(patch: DeploymentSettingsPatch, actorAccountId: string, actorTokenId?: string, 
+    /** Merged into the audit detail (the Platform tool's `via: "agent"`). */
+    auditDetail?: Record<string, unknown>): Promise<DeploymentSettings>;
     private write;
 }

package/dist/identity/settings.js

@@ -241,15 +241,17 @@ let SettingsService = class SettingsService {
         return out;
     }
     /** Updates settings under the super admin lock, re-checking the actor (else `forbidden`). */
-    async update(patch, actorAccountId, actorTokenId) {
+    async update(patch, actorAccountId, actorTokenId, 
+    /** Merged into the audit detail (the Platform tool's `via: "agent"`). */
+    auditDetail) {
         const check = DEPLOYMENT_SETTINGS_PATCH.safeParse(patch);
         if (!check.success) {
             throw new ApiError("validation_failed", "Invalid deployment settings", check.error.issues.map((i) => ({ path: i.path.join("."), message: i.message })));
         }
-        await this.write(check.data, actorAccountId, actorTokenId);
+        await this.write(check.data, actorAccountId, actorTokenId, auditDetail);
         return this.get();
     }
-    async write(patch, actorAccountId, actorTokenId) {
+    async write(patch, actorAccountId, actorTokenId, auditDetail) {
         await this.adminLock.lockAndAuthorize(actorAccountId);
         // The super admin lock serializes every settings write: the current overrides are read
         // and merged under it, so no concurrent change is lost
@@ -294,7 +296,7 @@ let SettingsService = class SettingsService {
             actorAccountId,
             ...(actorTokenId !== undefined && { actorTokenId }),
             action: "deployment.settings.updated",
-            detail: patch,
+            detail: { ...patch, ...auditDetail },
         });
     }
 };

package/dist/inbox/inbox.schemas.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+import type { RouteSchemas } from "../platform/route-schemas.js";
+/** `:id` of a notice dismissal (the org's and the platform's inbox). */
+export declare const InboxNoticeParams: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+/** The inbox routes (the org's and the super admin's) the Platform inbox operations mirror. */
+export declare const INBOX_ROUTES: readonly RouteSchemas[];

package/dist/inbox/inbox.schemas.js

@@ -0,0 +1,11 @@
+import { z } from "zod";
+/** `:id` of a notice dismissal (the org's and the platform's inbox). */
+export const InboxNoticeParams = z.object({ id: z.string().min(1).max(100) });
+/** The inbox routes (the org's and the super admin's) the Platform inbox operations mirror. */
+export const INBOX_ROUTES = [
+    { route: "GET /api/v1/orgs/:orgId/inbox" },
+    { route: "POST /api/v1/orgs/:orgId/inbox/notices/:id/dismiss", params: InboxNoticeParams },
+    { route: "GET /api/v1/admin/inbox" },
+    { route: "GET /api/v1/admin/inbox/count" },
+    { route: "POST /api/v1/admin/inbox/notices/:id/dismiss", params: InboxNoticeParams },
+];

package/dist/inbox/platform-inbox.controller.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import type { z } from "zod";
 import { type Principal } from "../identity/principal.js";
 import { PlatformInboxService, type PlatformInboxView } from "./platform-inbox.service.js";
 declare const NoticeParamsSchema: z.ZodObject<{

package/dist/inbox/platform-inbox.controller.js

@@ -8,12 +8,12 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { Controller, Get, HttpCode, Inject, Post } from "@nestjs/common";
-import { z } from "zod";
 import { CurrentPrincipal, requireUser, SuperAdmin, } from "../identity/principal.js";
 import { createZodDto } from "../infra/validation/create-zod-dto.js";
 import { ZParam } from "../infra/validation/zod-params.js";
+import { InboxNoticeParams } from "./inbox.schemas.js";
 import { PlatformInboxService } from "./platform-inbox.service.js";
-const NoticeParamsSchema = z.object({ id: z.string().min(1).max(100) });
+const NoticeParamsSchema = InboxNoticeParams;
 class NoticeParams extends createZodDto(NoticeParamsSchema, "PlatformInboxNoticeParams") {
 }
 /**

package/dist/index.d.ts

@@ -63,6 +63,10 @@ export { type ContextJob, type JobWrapper, type LogContext, logContext, setJobWr
 export { type Org, OrgsService } from "./orgs/orgs.service.js";
 export type { KernelOverride } from "./overrides.js";
 export { fetchNpmPackage, IntegrityMismatchError, type NpmFetchConfig, NpmFetchError, PackageTooLargeError, } from "./packages/npm.js";
+export { checkInputParity, inputParity, type ParityFinding, type ParityOperation, } from "./platform/parity.js";
+export { PLATFORM_OPERATION_PROVIDERS } from "./platform/platform-ops.module.js";
+export { PlatformOperations } from "./platform/registry.js";
+export { ROUTE_SCHEMAS, type RouteSchemas } from "./platform/route-schemas.js";
 export { UNKNOWN_RESULT_TEXT } from "./runtime/context/pairing.js";
 export type { AgentLoop, LoopContext, LoopOutcome } from "./runtime/loop.js";
 export { MAINTENANCE_QUEUE_NAME } from "./runtime/maintenance-queue.js";

package/dist/index.js

@@ -60,6 +60,12 @@ export { createConfiguredLogger, loggerOptionsFromConfig } from "./log-config.js
 export { logContext, setJobWrapper, setTraceContextSource, withJobContext, withLogContext, } from "./log-context.js";
 export { OrgsService } from "./orgs/orgs.service.js";
 export { fetchNpmPackage, IntegrityMismatchError, NpmFetchError, PackageTooLargeError, } from "./packages/npm.js";
+// Test seam: the Platform input-parity test in tools/checks (no runtime caller).
+export { checkInputParity, inputParity, } from "./platform/parity.js";
+// Test seam (the parity test builds every operation from these without a Nest app).
+export { PLATFORM_OPERATION_PROVIDERS } from "./platform/platform-ops.module.js";
+export { PlatformOperations } from "./platform/registry.js";
+export { ROUTE_SCHEMAS } from "./platform/route-schemas.js";
 export { UNKNOWN_RESULT_TEXT } from "./runtime/context/pairing.js";
 export { MAINTENANCE_QUEUE_NAME } from "./runtime/maintenance-queue.js";
 export { runJobId } from "./runtime/run-queue.js";

package/dist/lifecycle/kernel-lifecycle.js

@@ -26,6 +26,7 @@ import { ExtensionRegistry } from "../extensions/registry.js";
 import { ReplicaStatusStore } from "../extensions/sources.js";
 import { syncPackage } from "../extensions/sync.js";
 import { AccountsService } from "../identity/accounts.js";
+import { insecurePublicUrlWarning } from "../identity/cookies.js";
 import { waitWithin } from "../infra/close-within.js";
 import { KernelConfigService } from "../infra/config/kernel-config.service.js";
 import { KernelDb } from "../infra/database/kernel-db.js";
@@ -277,6 +278,9 @@ let KernelLifecycle = class KernelLifecycle {
         this.listening = await this.shutdown.trackInFlight(this.http.listen(port));
         this.checkpoint();
         this.log.info("kernel started", { roles: this.config.roles, port: this.listening });
+        const insecure = insecurePublicUrlWarning(this.config);
+        if (insecure !== null)
+            this.log.warn(insecure);
         await this.warnIfSetupPending();
         return this.listening;
     }

package/dist/models/enablement.d.ts

@@ -36,6 +36,8 @@ export interface ModelDisableChange {
 export interface ModelDisableActor {
     accountId: string;
     tokenId?: string | undefined;
+    /** Merged into the audit detail (a write made through the Platform tool). */
+    auditDetail?: Record<string, unknown>;
 }
 /**
  * Models disabled on two layers (spec B §5.3, table `model_disabled`): the platform's list (the

package/dist/models/enablement.js

@@ -157,6 +157,7 @@ let ModelEnablement = class ModelEnablement {
                     scope: orgId === null ? "platform" : "org",
                     disabled: added,
                     enabled: removed,
+                    ...actor.auditDetail,
                 },
             });
         }

package/dist/models/org-models.schemas.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+import type { RouteSchemas } from "../platform/route-schemas.js";
+/** `:purpose` as the org purpose route takes it (`@Param`). */
+export declare const ModelPurposePathParams: z.ZodObject<{
+    purpose: z.ZodString;
+}, z.core.$strip>;
+/** The org's model routes (the admin console's are the platform-admin domain's). */
+export declare const ORG_MODEL_ROUTES: readonly RouteSchemas[];

package/dist/models/org-models.schemas.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { ModelsQuery } from "../agents/models.controller.js";
+import { ModelDisabledPatch, ModelProviderParams } from "./enablement.controller.js";
+import { PURPOSE_PUT } from "./purposes.js";
+/** `:purpose` as the org purpose route takes it (`@Param`). */
+export const ModelPurposePathParams = z.object({ purpose: z.string().min(1) });
+/** The org's model routes (the admin console's are the platform-admin domain's). */
+export const ORG_MODEL_ROUTES = [
+    { route: "GET /api/v1/orgs/:orgId/models", query: ModelsQuery },
+    { route: "GET /api/v1/orgs/:orgId/models/catalog" },
+    { route: "GET /api/v1/orgs/:orgId/model-purposes" },
+    {
+        route: "PUT /api/v1/orgs/:orgId/model-purposes/:purpose",
+        params: ModelPurposePathParams,
+        body: PURPOSE_PUT,
+    },
+    {
+        route: "PATCH /api/v1/orgs/:orgId/models/:provider/disabled",
+        params: ModelProviderParams,
+        body: ModelDisabledPatch,
+    },
+];

package/dist/models/prices.d.ts

@@ -53,7 +53,9 @@ export declare class PricesService {
         provider: string;
         model: string;
         price: null;
-    }, actorAccountId: string, actorTokenId?: string): Promise<void>;
+    }, actorAccountId: string, actorTokenId?: string, 
+    /** Merged into the audit detail (the Platform tool's `via: "agent"`). */
+    auditDetail?: Record<string, unknown>): Promise<void>;
     /** The write of {@link put}, under the super admin lock. */
     private write;
 }

package/dist/models/prices.js

@@ -90,15 +90,17 @@ let PricesService = class PricesService {
      * 设置或删除（`price: null`）一个模型的价格：事务内取超级管理员锁并复核发起人仍是活跃超级管理员
      * （否则 `forbidden`），写审计 `model_price.updated` / `model_price.deleted`。
      */
-    async put(input, actorAccountId, actorTokenId) {
+    async put(input, actorAccountId, actorTokenId, 
+    /** Merged into the audit detail (the Platform tool's `via: "agent"`). */
+    auditDetail) {
         const check = MODEL_PRICE_PUT.safeParse(input);
         if (!check.success) {
             throw new ApiError("validation_failed", "Invalid model price", check.error.issues.map((i) => ({ path: i.path.join("."), message: i.message })));
         }
-        await this.write(check.data, actorAccountId, actorTokenId);
+        await this.write(check.data, actorAccountId, actorTokenId, auditDetail);
     }
     /** The write of {@link put}, under the super admin lock. */
-    async write(v, actorAccountId, actorTokenId) {
+    async write(v, actorAccountId, actorTokenId, auditDetail) {
         await this.adminLock.lockAndAuthorize(actorAccountId);
         const target = `${v.provider}/${v.model}`;
         if ("price" in v) {
@@ -112,7 +114,7 @@ let PricesService = class PricesService {
                 ...(actorTokenId !== undefined && { actorTokenId }),
                 action: "model_price.deleted",
                 target,
-                detail: { provider: v.provider, model: v.model },
+                detail: { provider: v.provider, model: v.model, ...auditDetail },
             });
             return;
         }
@@ -133,7 +135,7 @@ let PricesService = class PricesService {
             ...(actorTokenId !== undefined && { actorTokenId }),
             action: "model_price.updated",
             target,
-            detail: { ...v },
+            detail: { ...v, ...auditDetail },
         });
     }
 };

package/dist/models/purposes.d.ts

@@ -155,12 +155,22 @@ export declare class ModelPurposesService {
      */
     private check;
     private set;
+    /**
+     * The checks {@link set} runs before writing, nothing written: an unknown purpose, and a target
+     * model the scope cannot use, of another kind, or with invalid params (the Platform tool's
+     * precheck, so a known failure never reaches the confirmation card).
+     */
+    validate(orgId: string | null, purpose: string, target: PurposeTarget | null): Promise<void>;
     /** The mapping write of {@link set}, under the super admin or org lock. */
     private write;
     /** 设置（或 `null` 清除）部署默认；只有超级管理员（事务内复核）。 */
-    setDefault(purpose: string, target: PurposeTarget | null, actor: string, actorTokenId?: string): Promise<PurposeView>;
+    setDefault(purpose: string, target: PurposeTarget | null, actor: string, actorTokenId?: string, 
+    /** Merged into the audit detail (a write made through the Platform tool). */
+    auditDetail?: Record<string, unknown>): Promise<PurposeView>;
     /** 设置（或 `null` 清除）组织覆盖；事务内锁组织并复核 `org.models.manage`。 */
-    setOrg(orgId: string, purpose: string, target: PurposeTarget | null, actor: string, actorTokenId?: string): Promise<PurposeView>;
+    setOrg(orgId: string, purpose: string, target: PurposeTarget | null, actor: string, actorTokenId?: string, 
+    /** Merged into the audit detail (a write made through the Platform tool). */
+    auditDetail?: Record<string, unknown>): Promise<PurposeView>;
     /**
      * 生效的映射：组织覆盖，否则部署默认；都没有 → `model.unconfigured`；用途未声明 → `model.purpose_unknown`。
      * An effective target the org cannot use counts as unconfigured there (spec B §5.3): checked in