@prismshadow/penguin-server 0.2.11 → 0.2.13

package/dist/api/types.d.ts

@@ -29,8 +29,8 @@ interface ErrorBody {
 type ApprovalMode = "allow-all" | "deny-all" | "read-only" | "always-ask";
 /** Session run status: idle / Task in progress / compacting. */
 type SessionStatus = "idle" | "running" | "compacting";
-/** Session source marker (default = user-created): triggered by Schedule / registered as a subagent session. */
-type SessionSource = "schedule" | "subagent";
+/** Session source marker (default = user-created): triggered by Schedule / registered as a subagent session / created by a Benchmark evaluation or optimization. */
+type SessionSource = "schedule" | "subagent" | "benchmark";
 interface UserInfo {
     /** Semantic id, i.e. login name: `^[a-z][a-z0-9_-]{1,31}$`, immutable after creation. */
     userId: string;
@@ -38,8 +38,31 @@ interface UserInfo {
     isAdmin: boolean;
     /** Still using the initial password (seeded/set by admin): frontend prompts the user to change it soon. */
     passwordIsInitial: boolean;
+    /**
+     * Nickname the account chose (1-32 characters), shown wherever the id would otherwise be.
+     * Omitted when unset — every account that predates the Profile page starts without one, and
+     * a surface with no value falls back to `userId`.
+     */
+    displayName?: string;
+    /**
+     * Avatar as a `data:image/...;base64,` URL, at most 131072 characters. Omitted when unset,
+     * and a surface with no value draws the letter placeholder instead.
+     */
+    avatar?: string;
     createdAt: string;
 }
+/**
+ * PUT /api/me/profile — a patch, not a replacement: an absent field keeps what is stored,
+ * `null` clears it, a string sets it. A body naming neither field is a 400, since it can only
+ * be a mistake.
+ */
+interface UpdateProfileRequest {
+    displayName?: string | null;
+    avatar?: string | null;
+}
+interface UpdateProfileResponse {
+    user: UserInfo;
+}
 interface AuthLoginRequest {
     userId: string;
     password: string;
@@ -95,6 +118,12 @@ interface MeResponse {
      * just an admin's.
      */
     uploadLimits: UploadLimits;
+    /**
+     * Whether company mode is enabled server-wide (the admin switch in server settings, default
+     * on). Off hides the mode switch in every client and 404s every organization route; the
+     * user's own preference (`UiPrefs.companyMode`) only hides the switch for that user.
+     */
+    companyMode: boolean;
 }
 /**
  * Upload limits as the web app sees them: whole MB, the same unit the admin form uses, so the
@@ -184,6 +213,13 @@ interface ServerSettings {
      * image and the JSON framing), which is why raising it needs no separate setting.
      */
     attachmentTotalMb: number;
+    /**
+     * Company mode master switch (default on). Off stops the organization scheduler (no
+     * calendar event or chat mention fires, nothing is backfilled when it is turned on again),
+     * every `/api/projects/:projectId/organizations` route answers 404, and `GET /api/me`
+     * reports it so clients hide the mode switch. Organizations on disk are untouched.
+     */
+    companyMode: boolean;
 }
 interface ServerSettingsResponse {
     settings: ServerSettings;
@@ -192,6 +228,8 @@ interface ServerSettingsResponse {
 interface ServerSettingsUpdateRequest {
     proxyForApp?: boolean;
     proxyForAgent?: boolean;
+    /** Company mode master switch; see `ServerSettings.companyMode`. */
+    companyMode?: boolean;
     /**
      * New proxy address. Accepted forms: any proxy URL undici's dispatcher takes —
      * `http://`, `https://`, `socks5://` / `socks://`, credentials allowed — or bare
@@ -214,6 +252,53 @@ interface ServerSettingsUpdateRequest {
      */
     attachmentTotalMb?: number;
 }
+/**
+ * The endpoints the proxy reachability probe covers. A fixed list: the route takes a provider
+ * id from this set and never a URL, so nothing a caller sends decides what the server fetches.
+ *
+ * GLM is two entries rather than one because it is two hosts: Z.AI serves the global endpoint
+ * and BigModel the mainland one, they are reached over different routes, and a proxy can carry
+ * one and not the other.
+ */
+type ProxyProbeProvider = "openai" | "anthropic" | "gemini" | "deepseek" | "zai" | "bigmodel";
+/**
+ * One probe's verdict. `reachable` means an HTTP answer arrived, whatever its status — a
+ * rejected credential still proves the whole path works. The rest are transport failures,
+ * named so a proxy that swallows connections can be told apart from one whose address does
+ * not resolve: `timeout` (no answer within the probe's window), `dns` (the name never
+ * became an address), `refused` (the connection was refused at the TCP level), `tls` (the
+ * handshake or the certificate failed) and `network` (anything else).
+ */
+type ProxyProbeOutcome = "reachable" | "timeout" | "dns" | "refused" | "tls" | "network";
+/**
+ * One probe target. Served before any probe runs so the page can list what it is about to
+ * request — the URLs are the concrete answer to "what does no API key mean here".
+ */
+interface ProxyProbeTargetDto {
+    provider: ProxyProbeProvider;
+    /** The exact URL a probe requests, unauthenticated. */
+    url: string;
+}
+/** What the probe endpoint would request, without requesting it. */
+interface ProxyProbeTargetsResponse {
+    targets: ProxyProbeTargetDto[];
+}
+/** One provider's probe result. */
+interface ProxyProbeDto extends ProxyProbeTargetDto {
+    outcome: ProxyProbeOutcome;
+    /** Wall time in milliseconds until the answer's headers arrived, or until the attempt failed. */
+    ms: number;
+    /** The HTTP status, present only when `outcome` is `reachable`. */
+    status?: number;
+}
+/**
+ * One probe's answer. The route measures a single target per call: the page asks for all of
+ * them at once and fills each row the moment its own answer lands, so one black-holed host
+ * cannot hold every other result behind its timeout.
+ */
+interface ProxyProbeResponse {
+    probe: ProxyProbeDto;
+}
 /**
  * One draft-screen shortcut: a prompt the user wrote, filed under a name they chose. Clicking it
  * fills the composer exactly like a built-in example does, and sends nothing. Deliberately holds
@@ -249,6 +334,12 @@ interface UiPrefs {
      * known key holding user-authored text rather than a flag or an id.
      */
     draftShortcuts?: DraftShortcut[];
+    /** Personal company-mode switch (default on): off only hides this user's mode switch; organizations keep running. */
+    companyMode?: boolean;
+    /** The work mode the user last chose in the shell: development (default) or company. */
+    workMode?: "dev" | "company";
+    /** The organization last opened in company mode, as `<projectId>/<orgId>`. */
+    lastOrgKey?: string;
     [key: string]: unknown;
 }
 interface PrefsResponse {
@@ -328,7 +419,12 @@ interface ModelInfo {
     provider: string;
     /** Upstream model id (the request id actually sent to AgentHub); paired with `provider` forms the entry's unique key. */
     modelId: string;
-    /** Display name: explicit TOML field (user-edited) takes priority, then the built-in catalog; falls back to unset (frontend shows modelId). */
+    /**
+     * Display name: explicit TOML field (user-edited) takes priority, then the built-in catalog;
+     * falls back to unset (frontend shows modelId). The empty string is reported as such and
+     * means the user cleared the name on a model the catalog does name — render it as modelId,
+     * and send it back unchanged, since absent would ask for the catalog's name instead.
+     */
     displayName?: string;
     contextWindow?: number;
     /** AgentHub client protocol (`openai-chat`, `openai-responses`, etc.); defaults to AgentHub inferring it from modelId. */
@@ -387,7 +483,11 @@ interface ModelUpdateEntry {
     provider: string;
     /** Upstream model id (sent to AgentHub as-is). */
     modelId: string;
-    /** Display name; the server does not persist it when it matches the built-in catalog (keeps the config file clean). */
+    /**
+     * Display name; the server does not persist it when it matches the built-in catalog (keeps
+     * the config file clean). Absent and empty are different requests: absent inherits whatever
+     * the catalog calls the model, the empty string records that the user cleared the name.
+     */
     displayName?: string;
     /**
      * The pair reference this entry was renamed from (provided when either the group or the
@@ -540,10 +640,22 @@ interface ModelProtocolProbeDto {
     /** HTTP status, when a response arrived at all. */
     status?: number;
 }
-/** Detection result: probes run sequentially and stop at the first served protocol, so `probes` lists only the ones actually run, in order. */
+/**
+ * Detection result: probes run sequentially over the candidate base URLs derived from the
+ * one that was typed and stop at the first served protocol, so `probes` lists only the
+ * ones actually run, in order.
+ */
 interface ModelProtocolDetectResponse {
-    /** The first protocol the endpoint serves (an AgentHub client type); absent when none of the three matched. */
+    /** The first protocol an endpoint serves (an AgentHub client type); absent when none of the three matched. */
     detected?: string;
+    /**
+     * The base URL the detected protocol answered at — the typed URL normalized (endpoint
+     * path stripped, repeated `/v1` collapsed) and possibly with a trailing `/v1` added or
+     * removed, so `https://host/v1/chat/completions` comes back as `https://host/v1`.
+     * Present only alongside `detected`; callers write it back into their base URL field,
+     * since that is where the protocol is served.
+     */
+    baseUrl?: string;
     probes: ModelProtocolProbeDto[];
 }
 /**
@@ -1111,6 +1223,25 @@ interface SessionInfo {
     tracePath?: string;
     /** Present when the Session has an ENABLED messaging binding: its channel (the sidebar row's per-channel indicator). */
     messagingChannel?: MessagingChannel;
+    /**
+     * Company mode: the organization that owns this Session — a desk session of one of its
+     * employees, or a session contributing to one of its tickets — read from the organization
+     * caches. Absent for every ordinary Session. Development mode's list and its time buckets
+     * hide every row that carries it (only while company mode is available to that user: it is
+     * stamped either way, and company mode is what lists these Sessions instead), and the
+     * company sidebar's 工位 / 工单会话 groups are where they are listed.
+     */
+    orgId?: string;
+    /**
+     * Which client opened the Session, as stored on the index row: "cli" from the CLI (a
+     * Session adopted from a legacy CLI-direct Trace included), "org" from the organization
+     * runtime (a desk or a ticket session), "web" otherwise. Absent only on a row that
+     * predates the column, which reads as "web". Unlike {@link SessionInfo.orgId} — projected
+     * from the organization caches, so it disappears with the organization and is not read
+     * while company mode is off — this is a durable stamp on the row: development mode's list
+     * hides an "org" Session either way.
+     */
+    client?: "web" | "cli" | "org";
     /**
      * Background work the Session's loaded runtime still owns: command sessions running past
      * their yield window (`exec_command` promotions and `run_in_background` launches) and
@@ -1130,7 +1261,7 @@ interface SessionBackgroundTasks {
     subagents: number;
 }
 /**
- * Session list category, the sidebar's four-way split applied server-side: archived wins
+ * Session list category, the sidebar's five-way split applied server-side: archived wins
  * regardless of origin (archiving is an explicit user action), then the origin's bucket,
  * and a Session with no (or an unknown) source is `active` — user-created rows.
  */
@@ -1196,10 +1327,21 @@ interface SessionCreateRequest {
     approvalMode?: ApprovalMode;
     /**
      * Creating-client hint stored on the Session row: "cli" when the CLI creates the
-     * Session through the API; defaults to "web". Informational provenance only — lists
-     * serve every row regardless of client.
+     * Session through the API, "org" when the organization runtime opened it (a desk or a
+     * ticket session — company mode's own, kept out of development mode's lists whether or
+     * not the organization still exists); defaults to "web". A REQUEST may send only "web" or
+     * "cli": the runtime writes "org" by calling the service directly, so no caller can claim
+     * an organization's provenance for its own Session. Lists serve every row regardless of
+     * client; only development mode's session list filters on it.
+     */
+    client?: "web" | "cli" | "org";
+    /**
+     * Marks the Session as created by a Benchmark evaluation or optimization (the Evaluation
+     * Center's Use flows, and the Test Sessions agent-evaluation launches through the CLI). Only
+     * this value is accepted from a client: `subagent` and `schedule` are written by the server
+     * itself. The Web App files such Sessions into the Evaluations folder of the session list.
      */
-    client?: "web" | "cli";
+    source?: "benchmark";
 }
 interface SessionCreateResponse {
     session: SessionInfo;
@@ -2138,7 +2280,7 @@ type ServerEvent =
     agentId: string;
     sessionId: string;
     source: SessionSource;
-} | ScheduleServerEvent | GoalServerEvent;
+} | ScheduleServerEvent | GoalServerEvent | CompanyServerEvent;
 /** Goal-mode progress on the session channel (the chat page drives its goal banner from these). */
 type GoalServerEvent = 
 /** A goal run began (published before the first round). */
@@ -2430,6 +2572,47 @@ interface FilesWriteRequest {
      */
     ifVersion?: string;
 }
+/** Move or rename one Workspace file (the Files panel's context menu). */
+interface FilesMoveRequest {
+    /** Source path, relative to the Workspace root. */
+    from: string;
+    /** Destination path, relative to the Workspace root. Its parent directory is created when missing. */
+    to: string;
+    /**
+     * Move precondition, read exactly like {@link FilesWriteRequest.ifVersion}: the marker the
+     * caller got from this file's `ETag` on `GET files/content`, which the file must still
+     * carry. It differs on only one point — the marker guards the **source**. The destination
+     * has none, because the caller never read it, which is why an occupied destination is
+     * refused with 409 `target_exists` rather than overwritten.
+     *
+     * A directory `from` is a 400 whatever this field says: a directory carries no single
+     * version marker, so the precondition that protects this operation cannot be expressed for
+     * one, and silently moving a tree without that protection is worse than refusing to move it.
+     */
+    ifVersion?: string;
+}
+/**
+ * One Workspace search match. `kind`, `sizeBytes` and `mtime` are named and typed exactly as
+ * {@link WorkspaceFileEntry} names them: a hit is drawn by the same row renderer as a tree
+ * entry, and it can only render identically if it carries the same fields.
+ */
+interface WorkspaceSearchHit {
+    /** Workspace-relative, "/"-separated, with no leading "./" (a tree entry's `name` is only its last segment). */
+    path: string;
+    kind: "dir" | "file";
+    sizeBytes: number;
+    mtime: string;
+}
+interface WorkspaceSearchResponse {
+    /** Shallowest first, then directories before files, then by name — the order the breadth-first walk produced. */
+    hits: WorkspaceSearchHit[];
+    /**
+     * A cap stopped the walk (200 hits, or 20000 directory entries visited), so this is a
+     * partial list. Breadth-first is what makes that degrade well: the hits that survive
+     * truncation are the shallowest ones, not the ones that happened to be enumerated first.
+     */
+    truncated: boolean;
+}
 /** Batch file existence check (message file cards only list files that actually exist). */
 interface FilesStatRequest {
     /** Paths relative to the Workspace root (≤100 items, each ≤512 characters). */
@@ -2882,6 +3065,11 @@ interface BenchmarkCaseScore {
 interface BenchmarkEvaluation {
     /** Evaluation timestamp (ISO 8601). */
     time: string;
+    /**
+     * Agent under test in this round (the `agent_id` field), part of the record's label; `null`
+     * when the record carries none, as a Benchmark evaluates whichever Agents it is pointed at.
+     */
+    agentId: string | null;
     /** Evaluation summary title (a one-line conclusion; shown separately from the body summary; required when generating, tolerated as unset when displaying). */
     summaryTitle?: string;
     /** Evaluation summary body: how the score was derived, what optimizations were made to the Agent this round (required when generating, tolerated as unset when displaying). */
@@ -2902,6 +3090,11 @@ interface BenchmarkEvaluation {
     durationMs: number;
     cases: BenchmarkCaseScore[];
 }
+/**
+ * Whether the Skill that builds a Benchmark is done with it, and how it ended; see
+ * `BenchmarkSummary.status`.
+ */
+type BenchmarkStatus = "draft" | "published" | "failed";
 interface BenchmarkSummary {
     /** Directory name is the identifier (semantic naming, e.g. swe-bench-v1). */
     id: string;
@@ -2910,10 +3103,26 @@ interface BenchmarkSummary {
     description?: string;
     /** Number of runs per case (the `runs` field in benchmark_config.toml, ≥1; defaults to 1). */
     runs?: number;
+    /**
+     * `draft` while the Skill that builds the Benchmark is still writing its cases and
+     * calibrating their difficulty — the Web App masks such a Benchmark; `published` once the
+     * Benchmark is frozen and its Formal Baseline recorded; `failed` when calibration ended
+     * without a Pilot result that could be frozen, which leaves the Benchmark unusable — the Web
+     * App masks it too and says it has to be deleted and created again. benchmark_config.toml is
+     * read literally: only `draft` is a draft and only `failed` is a failure, so a missing field,
+     * or any other value, reads as published.
+     */
+    status: BenchmarkStatus;
     /** Case count (number of case subfolders). */
     caseCount: number;
     /** Time-ordered evaluation records (the evaluations[] in scoreboard.yaml). */
     evaluations: BenchmarkEvaluation[];
+    /**
+     * Agents this Benchmark has evaluated: the distinct non-null `agentId`s of `evaluations`, in
+     * first-seen order. Empty while nothing has been evaluated — a Benchmark names no Agent of its
+     * own.
+     */
+    agentIds: string[];
 }
 interface BenchmarksResponse {
     benchmarks: BenchmarkSummary[];
@@ -2928,6 +3137,36 @@ interface BenchmarkCaseSummary {
 interface BenchmarkCasesResponse {
     cases: BenchmarkCaseSummary[];
 }
+/**
+ * POST /api/projects/:p/benchmarks (owner only): create a Benchmark by hand. The
+ * server writes the on-disk layout the evaluation Skills read — `benchmark_config.toml`, a
+ * `scoreboard.yaml` holding `evaluations: []`, and one `<case id>/` per case with
+ * `statement/README.md` and `rubric/README.md`. 409 `benchmark_exists` when the directory is
+ * already there; nothing is merged into an existing Benchmark.
+ */
+interface BenchmarkCreateRequest {
+    /** Directory name, which is the identifier: letters, digits, `_` and `-` only. */
+    id: string;
+    title: string;
+    description?: string;
+    /** Runs per case for the optimization loop (integer ≥ 1; default 1). */
+    runs?: number;
+    /** At least one case; ids must be unique within the request. */
+    cases: BenchmarkCreateCase[];
+}
+interface BenchmarkCreateCase {
+    /** Case directory name: `CASE-` followed by letters, digits, `_` and `-` (for example `CASE-001-excel-task`). */
+    id: string;
+    /** Written as the statement README's first heading, which the case list reads back as the case title. */
+    title: string;
+    /** Statement body (Markdown), written after that heading; the Target Agent sees only this side. */
+    statement: string;
+    /** Scoring rubric (Markdown, items totalling 100 points), written verbatim as `rubric/README.md`. */
+    rubric: string;
+}
+interface BenchmarkCreateResponse {
+    benchmark: BenchmarkSummary;
+}
 interface SkillMetadataItem {
     /** Skill directory name (the identity key for install / uninstall / Prompt addressing). */
     name: string;
@@ -3124,6 +3363,50 @@ interface DesktopUpdaterCommandMessage {
     type: "desktop-updater-command";
     action: "check" | "download" | "install";
 }
+/** The two languages the Web App has; the shell's tray menu follows whichever is in use. */
+type DesktopTrayLocale = "zh" | "en";
+/** What the shell is currently doing about its tray icon. */
+interface DesktopTrayStatus {
+    /** Whether an icon is shown in the system tray while the app runs. */
+    showTrayIcon: boolean;
+    /**
+     * The language the tray menu is drawn in. Until a page reports one the shell uses the
+     * device language, so this can differ from the Web App's until the first report lands.
+     */
+    locale: DesktopTrayLocale;
+}
+/**
+ * What one PUT asks the shell to change. Every field is optional and a request must carry at
+ * least one: the switch and the language reach this route from different parts of the page.
+ */
+interface DesktopTrayPatch {
+    showTrayIcon?: boolean;
+    locale?: DesktopTrayLocale;
+}
+/**
+ * GET / PUT /api/desktop/tray (desktop-shell sessions only): the tray preference.
+ * `status` is null until the shell's first push lands (a beat after server start); a
+ * client that finds null reads it as on, which is the shell's own default.
+ */
+interface DesktopTrayStatusResponse {
+    status: DesktopTrayStatus | null;
+}
+/** Shell → server push over the utilityProcess message channel. */
+interface DesktopTrayStatusMessage {
+    type: "desktop-tray-status";
+    status: DesktopTrayStatus;
+}
+/**
+ * Server → shell command over the utilityProcess message channel (relayed from PUT
+ * /api/desktop/tray). A patch, not a snapshot: the switch and the language are written by
+ * different parts of the page at different moments, and neither should have to restate the
+ * other's value to change its own.
+ */
+interface DesktopTrayCommandMessage {
+    type: "desktop-tray-command";
+    showTrayIcon?: boolean;
+    locale?: DesktopTrayLocale;
+}
 /**
  * The outcome of one self-update run (`penguin update --yes` on the server host), carried
  * by {@link UpdateJobStatus.result}. `unsupported` covers both a server not launched via
@@ -3319,5 +3602,724 @@ interface MachinesResponse {
     imageVersion: string | null;
     job: MachineJob | null;
 }
+/**
+ * Organization status: `paused` stops every automatic trigger; humans can still talk to any
+ * desk. These two values are the whole lifecycle — no route deletes an organization, so a
+ * paused one keeps its conversations, employees, desks and tickets.
+ */
+type OrgStatus = "active" | "paused";
+/** Approval mode for desk and ticket sessions; unattended runs never get always-ask. */
+type OrgApprovalMode = "allow-all" | "read-only" | "deny-all";
+/** The five kanban columns, each a directory under `tickets/<yyyy-mm>/`. */
+type OrgTicketStatus = "proposed" | "in_progress" | "review" | "done" | "rejected";
+type OrgTicketPriority = "P0" | "P1" | "P2";
+/** Live employee state: running when the desk or any ticket session has a Task in progress; paused when budget-paused. */
+type OrgEmployeeState = "running" | "idle" | "paused";
+/**
+ * The trigger kinds an `[org_trigger]` block carries. `ticket_notice` is read-only: a ticket
+ * change starts no run of its own, so nothing writes that kind any more, and it stays in the
+ * union because Traces recorded while it did still carry it.
+ */
+type OrgTriggerKind = "init" | "event" | "mention" | "ticket_notice" | "ticket_work";
+/** The ticket changes an employee is told about, listed in the body of its next calendar sweep. */
+type OrgTicketChange = "assigned" | "blocked" | "blocker_closed" | "done" | "rejected";
+/** What the last evaluation of a calendar event did. */
+type OrgCalendarOutcome = "fired" | "queued" | "paused" | "missed" | "error";
+/**
+ * The organization's working language: the language its handbook, its CEO's initialization
+ * run, every employee brief and every desk and ticket run are written in. Detected from the
+ * mission at creation (CJK text → `zh`, anything else → `en`) unless the request names one.
+ */
+type OrgLanguage = "zh" | "en";
+/** The organization's settings as `org_config.toml` records them. */
+interface OrganizationSettings {
+    name: string;
+    mission: string;
+    status: OrgStatus;
+    /** IANA timezone: budget periods (natural months) and chat day files follow it. */
+    timezone: string;
+    approvalMode: OrgApprovalMode;
+    /** Chat @-chain limit: a message whose hop reaches it records its mentions without triggering anyone. */
+    mentionChainLimit: number;
+    budgetWarnRatio: number;
+    budgetPauseRatio: number;
+    createdBy: string;
+    /** The shared workspace root when it is not the organization's own `workspace/` (absolute path). */
+    workspace?: string;
+    /** The model desks and ticket sessions run on when the employee names none; absent = the Project default. */
+    model?: {
+        provider: string;
+        modelId: string;
+    };
+    /** The working language (`language` in `org_config.toml`); absent on an organization written before the field existed, which reads as `en`. */
+    language?: OrgLanguage;
+}
+/** Period spend against the CEO's budget (= the whole organization). */
+interface OrgSpendSummary {
+    /** `yyyy-mm` in the organization's timezone. */
+    period: string;
+    cost: number;
+    budget?: number;
+    /** cost / budget; absent without a budget. */
+    ratio?: number;
+}
+interface OrganizationSummary {
+    projectId: string;
+    orgId: string;
+    name: string;
+    mission: string;
+    status: OrgStatus;
+    employeeCount: number;
+    runningCount: number;
+    pausedCount: number;
+    /** proposed + in_progress + review. */
+    openTickets: number;
+    blockedTickets: number;
+    createdBy: string;
+    spend: OrgSpendSummary;
+    /** Present when `org_config.toml` / `org_chart.yaml` fail validation: the organization is listed but every automatic trigger is held until it is fixed. */
+    invalid?: string;
+}
+interface OrganizationsResponse {
+    organizations: OrganizationSummary[];
+}
+interface OrgEmployeeItem {
+    agentId: string;
+    /** Agent display name (system_config.yaml); falls back to the id. */
+    name: string;
+    title: string;
+    /** null for the CEO (the root). */
+    reportsTo: string | null;
+    duties?: string;
+    /** As written in the chart: a sub-directory of the shared workspace (`.` = all of it) or an absolute path. */
+    workspace: string;
+    /** Where that resolves to; absent when the directory does not exist (the entry is then invalid). */
+    resolvedWorkspace?: string;
+    /** Monthly budget in USD for this employee plus all subordinates; absent = unbounded. */
+    budget?: number;
+    model?: {
+        provider: string;
+        modelId: string;
+    };
+    state: OrgEmployeeState;
+    desk?: {
+        sessionId: string;
+        workspace: string;
+        openedAt: string;
+    };
+    /** Period spend: own sessions, and cumulative (own + every subordinate). */
+    spend: {
+        own: number;
+        cumulative: number;
+        ratio?: number;
+    };
+    /** Why the entry cannot be triggered (missing Agent, missing workspace directory). */
+    invalid?: string;
+}
+interface OrgChartResponse {
+    ceoAgentId: string;
+    employees: OrgEmployeeItem[];
+}
+interface OrgCalendarItem {
+    agentId: string;
+    name: string;
+    title?: string;
+    prompt: string;
+    enabled: boolean;
+    startAt: string;
+    period?: string;
+    endAt?: string;
+    status: ScheduleStatus;
+    invalidReason?: string;
+    nextFireAt?: string;
+    lastFiredAt?: string;
+    /** What the most recent evaluation did (absent until the event has been evaluated once). */
+    lastOutcome?: OrgCalendarOutcome;
+    /** The organization or this employee is paused, so due slots are skipped, not fired. */
+    paused: boolean;
+}
+interface OrgCalendarResponse {
+    events: OrgCalendarItem[];
+    invalidFiles: Array<{
+        agentId: string;
+        name: string;
+        error: string;
+    }>;
+}
+/**
+ * One line of a ticket's operation history, kept in the file's frontmatter apart from the
+ * progress prose: what was done, by whom (`agent:<id>` / `user:<id>` — an employee is recognised
+ * from the Agent id its command subprocesses carry, a person otherwise), and when.
+ */
+type OrgTicketHistoryAction = "created" | "assigned" | "moved" | "blocked" | "unblocked" | "progress" | "session_started" | "session_attached" | "edited";
+interface OrgTicketHistoryEntry {
+    at: string;
+    by: string;
+    action: OrgTicketHistoryAction;
+    /** The action's detail: the column moved to, the new owner, the block reason, the session id. */
+    note?: string;
+}
+/**
+ * The ticket id's slug: lowercase letters in hyphen-joined words, no digits (the date prefix
+ * already carries the numbers), chosen for meaning — derived from an ASCII title, proposed by
+ * the Project's model for a title in another language, or passed explicitly.
+ */
+declare const TICKET_SLUG_PATTERN: RegExp;
+interface OrgTicketItem {
+    ticketId: string;
+    title: string;
+    status: OrgTicketStatus;
+    /** The ONE responsible principal (`agent:<id>` / `user:<id>`); who filed it is the history's `created` entry. */
+    owner: string;
+    parent?: string;
+    notify: string[];
+    priority: OrgTicketPriority;
+    due?: string;
+    /** Non-empty = blocked; the ticket stays in its column. */
+    blocked?: string;
+    blockedBy?: string;
+    /** Contributing session ids, in the order they were attached. */
+    sessions: string[];
+    /** Any contributing session has a Task in progress. */
+    running: boolean;
+    /** Period cost of the contributing sessions (a session attached to n tickets counts 1/n here). */
+    cost: number;
+    /** Header/column disagreement or a duplicate id: shown with a danger mark, left where it is. */
+    invalid?: string;
+}
+interface OrgTicketSessionItem {
+    sessionId: string;
+    agentId: string;
+    title?: string;
+    status: SessionStatus;
+    lastActiveAt?: string;
+}
+interface OrgTicketDetail extends OrgTicketItem {
+    goal: string;
+    acceptanceCriteria: string;
+    /** `## Progress` as plain sentences; who wrote one and when is the matching history entry. */
+    progress: string[];
+    result: string;
+    /** The operation history from the frontmatter, oldest first. */
+    history: OrgTicketHistoryEntry[];
+    /** The whole file, for the Markdown view and for clients that prefer to edit it as text. */
+    body: string;
+    children: string[];
+    /** Own cost plus every descendant's along `Parent`. */
+    rolledUpCost: number;
+    sessionItems: OrgTicketSessionItem[];
+}
+interface OrgTicketsResponse {
+    columns: Record<OrgTicketStatus, OrgTicketItem[]>;
+    /** Files that failed to parse (skipped; also recorded as errors). */
+    invalidFiles: Array<{
+        path: string;
+        error: string;
+    }>;
+}
+/**
+ * What a `system` line records, structured: the kind of event and its parameters, so a client
+ * renders the sentence in the reader's language and with the principals' display names instead
+ * of showing the English `text` verbatim. `text` stays the English sentence (the CLI, older
+ * clients and the file itself read it); `notice` is the same fact for a client that can do better.
+ */
+type OrgChannelNoticeKind = "employee_joined" | "employee_left" | "channel_created" | "channel_archived" | "channel_unarchived" | "channel_joined" | "channel_invited" | "channel_left" | "channel_removed" | "budget_warned" | "budget_paused"
+/**
+ * Legacy, read-only: ticket changes no longer write into a channel — the board is read from
+ * the board and the overview's inbox. These three kinds stay so the lines already in an
+ * organization's message files keep rendering; nothing writes them any more.
+ */
+ | "ticket_blocked" | "ticket_done" | "ticket_rejected";
+/**
+ * The parameters each kind carries, all strings: principals as `agent:<id>` / `user:<id>`
+ * (`agent`, `principal`, `by`, `reportsTo`), a ticket as `ticket` + `title`, a budget event as
+ * `agent`, `period`, `percent`, `cost`, `budget`.
+ */
+interface OrgChannelNotice {
+    kind: OrgChannelNoticeKind;
+    params: Record<string, string>;
+}
+interface OrgChannelMessage {
+    id: string;
+    /** ISO 8601 UTC. */
+    time: string;
+    /** `agent:<id>` / `user:<id>` / `system`. */
+    sender: string;
+    hop: number;
+    text: string;
+    /** Principals mentioned, `all` included. */
+    mentions: string[];
+    refs?: {
+        ticket?: string;
+        session?: string;
+        replyTo?: string;
+    };
+    /** Present on `system` lines the server wrote with a structured notice; absent on lines from before the field existed. */
+    notice?: OrgChannelNotice;
+}
+/**
+ * One channel as the API reports it. The all-hands channel (`default_channel`,
+ * `everyone: true`) exists for as long as the organization does and every employee and
+ * Project member is in it; every other channel carries the membership its members edit.
+ */
+interface OrgChannelItem {
+    channelId: string;
+    /** As stored; the UI renders the all-hands channel's label itself. */
+    name: string;
+    /** "" when unset. */
+    purpose: string;
+    /** True only for `default_channel`: membership is implicit. */
+    everyone: boolean;
+    /** An archived channel is read-only and folded away. */
+    archived: boolean;
+    /** `user:<id>` / `agent:<id>` / `system`. */
+    createdBy: string;
+    /** ISO 8601 UTC. */
+    createdAt: string;
+    /** Implicit membership counted for the all-hands channel. */
+    memberCount: number;
+    /** Whether the caller (person or employee) is a member. */
+    isMember: boolean;
+    /** People only; 0 for an employee caller. */
+    unread: number;
+    /** People only; 0 for an employee caller. */
+    mentionsMe: number;
+    lastMessageAt: string | null;
+}
+interface OrgChannelMember {
+    /** `agent:<id>` or `user:<id>`. */
+    principal: string;
+    name: string;
+    kind: "agent" | "user";
+}
+interface OrgChannelDetail extends OrgChannelItem {
+    /** The all-hands channel resolves to every employee plus every Project member. */
+    members: OrgChannelMember[];
+}
+interface OrgChannelsResponse {
+    /** `default_channel` first, then by name. */
+    channels: OrgChannelItem[];
+}
+interface OrgChannelCreateRequest {
+    channelId: string;
+    name?: string;
+    purpose?: string;
+}
+interface OrgChannelPatchRequest {
+    name?: string;
+    purpose?: string;
+    archived?: boolean;
+}
+interface OrgChannelMemberRequest {
+    /** `agent:<id>` (an employee) or `user:<id>` (a Project member). */
+    principal: string;
+}
+interface OrgChannelMessagesResponse {
+    /** The channel served. */
+    channelId: string;
+    /** The day file served (`yyyy-mm-dd` in the organization's timezone). */
+    date: string;
+    /** The days this channel has a file for, newest first, for paging back. */
+    days: string[];
+    messages: OrgChannelMessage[];
+    /** Messages of this channel after the caller's read cursor in it, across the recent days. */
+    unread: number;
+    /** Of those, the ones that mention the caller (or all). */
+    mentionsMe: number;
+    lastReadId?: string;
+}
+interface OrgBudgetAlert {
+    agentId: string;
+    period: string;
+    warnedAt?: string;
+    pausedAt?: string;
+}
+interface OrgFinanceEmployee {
+    agentId: string;
+    name: string;
+    title: string;
+    reportsTo: string | null;
+    own: number;
+    cumulative: number;
+    budget?: number;
+    ratio?: number;
+    warned: boolean;
+    paused: boolean;
+}
+interface OrgFinanceTicket {
+    ticketId: string;
+    title: string;
+    status: OrgTicketStatus;
+    parent?: string;
+    cost: number;
+    rolledUp: number;
+}
+interface OrgFinanceResponse {
+    period: string;
+    currency: "USD";
+    employees: OrgFinanceEmployee[];
+    tickets: OrgFinanceTicket[];
+    /** Daily cost of the organization's sessions over the period. */
+    daily: Array<{
+        date: string;
+        cost: number;
+    }>;
+    alerts: OrgBudgetAlert[];
+    total: number;
+    /** Some usage ran on a model without pricing: tokens were counted, cost is a lower bound. */
+    unpriced: boolean;
+}
+interface OrgDeskItem {
+    agentId: string;
+    name: string;
+    sessionId: string;
+    title?: string;
+    status: SessionStatus;
+    workspace: string;
+    lastActiveAt?: string;
+}
+interface OrgSessionsResponse {
+    desks: OrgDeskItem[];
+    tickets: Array<{
+        ticketId: string;
+        title: string;
+        status: OrgTicketStatus;
+        sessions: OrgTicketSessionItem[];
+    }>;
+}
+interface OrgDeskResponse {
+    agentId: string;
+    sessionId: string;
+    workspace: string;
+    openedAt: string;
+    /** True when this call created the desk session. */
+    created: boolean;
+}
+interface OrganizationDetail extends OrganizationSummary {
+    settings: OrganizationSettings;
+    board: Record<OrgTicketStatus, number>;
+    /** Today's calendar events (organization timezone) with their outcomes. */
+    today: OrgCalendarItem[];
+    pending: {
+        /** Unread messages mentioning the caller (or all). */
+        mentions: number;
+        reviewTickets: OrgTicketItem[];
+        blockedByMe: OrgTicketItem[];
+    };
+    /** The last messages of the all-hands channel. */
+    recentMessages: OrgChannelMessage[];
+    alerts: OrgBudgetAlert[];
+    /** What the overview's inbox lists; absent only from a server older than the field. */
+    inbox?: OrgInbox;
+    /** The CEO's desk session once opened (creation opens it). */
+    ceoDeskSessionId?: string;
+}
+/**
+ * The overview's inbox: the three things a person is waited on or told about — messages
+ * that name them (or `@all`) in the all-hands channel, the tickets that are blocked (all of
+ * them, whoever they wait on), and the tickets closed as done this period. Newest first in
+ * each list; each capped at a page.
+ */
+interface OrgInbox {
+    mentions: OrgChannelMessage[];
+    blockedTickets: OrgTicketItem[];
+    doneTickets: Array<OrgTicketItem & {
+        closedAt?: string;
+    }>;
+}
+interface OrganizationCreateRequest {
+    /** Semantic id, unique within the Project; also the directory name. */
+    orgId: string;
+    name?: string;
+    mission: string;
+    timezone?: string;
+    /** An existing absolute directory to use as the shared workspace; default = the organization's own `workspace/`. */
+    workspace?: string;
+    /** The model for desks and ticket sessions (a configured pair); default = the Project default. */
+    model?: {
+        provider: string;
+        modelId: string;
+    };
+    /**
+     * The CEO's monthly budget in USD, written as the `budget` of its `org_chart.yaml` entry.
+     * Budgets are compared on the cumulative line, so the CEO's is the whole company's.
+     * Omitted = 100; 0 is a real (zero) budget, not "unbounded" — only clearing the field
+     * later (`PATCH …/employees/:agentId` with `budget: null`) leaves the CEO unbounded.
+     */
+    ceoBudget?: number;
+    /** The working language; omitted = detected from the mission. */
+    language?: OrgLanguage;
+}
+interface OrganizationPatchRequest {
+    name?: string;
+    mission?: string;
+    status?: OrgStatus;
+    approvalMode?: OrgApprovalMode;
+    timezone?: string;
+    mentionChainLimit?: number;
+    budgetWarnRatio?: number;
+    budgetPauseRatio?: number;
+    /** null returns to the organization's own `workspace/`. */
+    workspace?: string | null;
+    /** null returns to the Project default. */
+    model?: {
+        provider: string;
+        modelId: string;
+    } | null;
+    language?: OrgLanguage;
+}
+/**
+ * A semantic id proposed for a display name — the organization and channel dialogs let the
+ * user name the thing first and derive the id from that name. The server asks the Project's
+ * default model for a short English snake_case id (a Chinese name has no mechanical
+ * transliteration), falling back to an ASCII slug of the name when the model is unavailable,
+ * and to a dated placeholder when neither can name it. The request never fails for a name it
+ * cannot translate: a dialog that asked for an id always gets one back.
+ */
+interface SemanticIdSuggestRequest {
+    /** The display name typed so far (or the mission, when nothing else names the thing). */
+    name: string;
+    /** What the id is for: decides the prompt's examples and the fallback's prefix. */
+    kind: "org" | "channel";
+    /** Ids already in use in the target scope; the proposal avoids them. */
+    taken?: string[];
+}
+/**
+ * Why a proposal fell all the way through to a placeholder — what the client tells the user to
+ * explain the id it was just handed. `no_default_model`: the Project has no default model to
+ * ask. `model_failed`: it was asked and the request failed (no credential, a rejection, a
+ * timeout). `unusable_answer`: it answered twice and neither answer yielded an id.
+ * `no_ascii`: no model was consulted at all and the name carries no ASCII to transliterate.
+ */
+type SemanticIdSuggestReason = "no_default_model" | "model_failed" | "unusable_answer" | "no_ascii";
+interface SemanticIdSuggestResponse {
+    /** A valid semantic id (`^[a-z][a-z0-9_]{1,63}$`), not in `taken`. */
+    id: string;
+    /** Who produced it: the model, the ASCII fallback, or the dated placeholder that names nothing. */
+    source: "model" | "fallback" | "placeholder";
+    /** Present only with `source: "placeholder"`: why the two real paths produced nothing. */
+    reason?: SemanticIdSuggestReason;
+}
+interface OrgHireRequest {
+    /** Employ an existing Agent … */
+    agentId?: string;
+    /** … or create one (the two are exclusive). Plugins default to agent-company + agent-development. */
+    newAgent?: {
+        agentId: string;
+        name?: string;
+        description?: string;
+        plugins?: string[];
+    };
+    title: string;
+    reportsTo: string;
+    workspace?: string;
+    budget?: number;
+    duties?: string;
+    model?: {
+        provider: string;
+        modelId: string;
+    };
+}
+interface OrgEmployeePatchRequest {
+    title?: string;
+    reportsTo?: string;
+    workspace?: string;
+    /** null clears the budget. */
+    budget?: number | null;
+    duties?: string;
+    /** null clears the model (back to the Project default). */
+    model?: {
+        provider: string;
+        modelId: string;
+    } | null;
+}
+interface OrgCalendarUpsertRequest {
+    /** POST only: the employee the event belongs to. */
+    agentId?: string;
+    /** POST only: the file name. */
+    name?: string;
+    title?: string;
+    prompt: string;
+    enabled: boolean;
+    startAt: string;
+    period?: string;
+    endAt?: string;
+}
+/**
+ * What a calendar write answers: the stored event, plus advisory `warnings` — one line each —
+ * about the rota: another employee's recurring event on the same start minute, or the same
+ * employee already holding a recurring event (desks that fire together compete for the same
+ * budget minute and the same tickets). The write succeeds regardless; the CLI prints the
+ * lines so the scheduling employee can stagger.
+ */
+interface OrgCalendarWriteResponse extends OrgCalendarItem {
+    warnings?: string[];
+}
+interface OrgTicketCreateRequest {
+    title: string;
+    /** Overrides the slug derived from the title; lowercase English words joined by hyphens. */
+    slug?: string;
+    goal?: string;
+    acceptanceCriteria?: string;
+    /** The whole Markdown body instead of goal + acceptanceCriteria (the frontmatter is still generated). */
+    body?: string;
+    /**
+     * The responsible principal: an employee's `agent:<id>` (or bare Agent id) or a member's
+     * `user:<id>`. Default = the caller — the session's employee inside a desk or ticket
+     * session, else the token's or cookie's user.
+     */
+    owner?: string;
+    parent?: string;
+    notify?: string[];
+    priority?: OrgTicketPriority;
+    due?: string;
+}
+interface OrgTicketUpdateRequest {
+    title?: string;
+    /** The new responsible principal; never null — a ticket always has an owner. */
+    owner?: string;
+    parent?: string | null;
+    notify?: string[];
+    priority?: OrgTicketPriority;
+    due?: string | null;
+    goal?: string;
+    acceptanceCriteria?: string;
+    result?: string;
+}
+interface OrgTicketMoveRequest {
+    status: OrgTicketStatus;
+    /** Required when moving into rejected; recorded under Result. */
+    reason?: string;
+}
+interface OrgTicketBlockRequest {
+    reason: string;
+    /** A ticket id or a principal. */
+    by?: string;
+}
+interface OrgTicketProgressRequest {
+    text: string;
+    /**
+     * The calling session (CLI: PENGUIN_SESSION_ID); the session is booked as a contributing
+     * session and the history entry is attributed to its employee. Honoured only for a request
+     * carrying the local API token — the control environment's credential; a signed-in user's
+     * write is attributed to the user.
+     */
+    sessionId?: string;
+    /**
+     * The calling employee's Agent id (CLI: PENGUIN_AGENT_ID from the control environment), the
+     * identity a write is recorded under; it wins over the session's employee, is honoured only
+     * with the local API token, like sessionId, and is ignored — the write falls back to the
+     * session's employee, then to the person — when it names no employee.
+     */
+    agentId?: string;
+}
+interface OrgTicketStartRequest {
+    /** The employee the ticket session runs as (CLI: PENGUIN_AGENT_ID); defaults to the ticket owner. */
+    agentId?: string;
+    message?: string;
+    /** Another directory inside the shared workspace; defaults to the employee's desk workspace. */
+    workspace?: string;
+}
+interface OrgTicketStartResponse {
+    sessionId: string;
+}
+interface OrgTicketAttachRequest {
+    sessionId: string;
+}
+interface OrgChannelMessageSendRequest {
+    text: string;
+    refs?: {
+        ticket?: string;
+        session?: string;
+        replyTo?: string;
+    };
+    /**
+     * The calling session (CLI: PENGUIN_SESSION_ID): the message is sent as its Agent and
+     * inherits its hop. Honoured only for a request carrying the local API token — the control
+     * environment's credential; a signed-in user's message is sent as the user, at hop 0.
+     */
+    sessionId?: string;
+}
+interface OrgChannelReadRequest {
+    /** Mark everything up to this message id as read. */
+    upTo: string;
+}
+/** The handbook index (`handbook/README.md`), the file every work run reads first. */
+interface OrgHandbookResponse {
+    content: string;
+}
+/** One file of the organization handbook (`handbook/`, the company's knowledge base); `path` is relative to that directory. */
+interface OrgHandbookFile {
+    path: string;
+    size: number;
+    updatedAt: string;
+}
+interface OrgHandbookFilesResponse {
+    /** The index first, then the other documents by path. */
+    files: OrgHandbookFile[];
+}
+interface OrgHandbookFileResponse {
+    path: string;
+    content: string;
+}
+interface OrgHandbookFileWriteRequest {
+    content: string;
+}
+/** Company-mode notifications on the user-level event stream (best effort; the query routes carry the durable state). */
+type CompanyServerEvent = 
+/** A work run (desk session) or ticket session was started by the organization scheduler or a ticket start. */
+{
+    type: "org_run";
+    projectId: string;
+    orgId: string;
+    agentId: string;
+    sessionId: string;
+    kind: OrgTriggerKind;
+}
+/** A new channel message (mentions included, so the client can tell whether it is addressed). */
+ | {
+    type: "org_channel";
+    projectId: string;
+    orgId: string;
+    channelId: string;
+    message: OrgChannelMessage;
+}
+/** A ticket's status, owner, blocked state or contributing sessions changed. */
+ | {
+    type: "org_ticket";
+    projectId: string;
+    orgId: string;
+    ticketId: string;
+    change: string;
+}
+/** Budget warning, pause or resume for an employee. */
+ | {
+    type: "org_budget";
+    projectId: string;
+    orgId: string;
+    agentId: string;
+    state: "warned" | "paused" | "resumed";
+    ratio: number;
+};
+/** How the web app renders a contributed surface: a name from its own registry, or an iframe. */
+type RendererRef = {
+    builtin: string;
+} | {
+    iframe: {
+        src: string;
+        namespace: string;
+    };
+};
+/** One contribution to a web slot: its id, the contributing module, and the slot's data. */
+interface WebContribution {
+    id: string;
+    from: string;
+    [key: string]: unknown;
+}
+interface ContributionsResponse {
+    pages: WebContribution[];
+    agentTabs: WebContribution[];
+    sessionTabs: WebContribution[];
+}
 
-export type { AdminPasswordResetRequest, AdminUserCreateRequest, AdminUserCreateResponse, AdminUsersResponse, AgentCompactionConfigDto, AgentConfigDto, AgentConfigResponse, AgentConfigUpdateRequest, AgentCreateRequest, AgentCreateResponse, AgentHooksConfigDto, AgentHooksResponse, AgentImportRequest, AgentImportResponse, AgentKernelUpdateResponse, AgentMemoryConfigDto, AgentModelConfigDto, AgentPluginsInstallResponse, AgentSchedulesConfigDto, AgentSkillsConfigDto, AgentSkillsResponse, AgentSummary, AgentTraceDateGroup, AgentTraceFileRef, AgentTraceSessionEntry, AgentTraceSessionFile, AgentTraceSessionGroup, AgentTracesResponse, AgentVaultConfigDto, AgentsResponse, ApprovalDecisionRequest, ApprovalMode, AuthLoginRequest, AuthResponse, BenchmarkCaseScore, BenchmarkCaseSummary, BenchmarkCasesResponse, BenchmarkEvaluation, BenchmarkRunScore, BenchmarkSummary, BenchmarksResponse, CaseMaterial, ChatDefaultsDto, CommandPolicyDto, CommandPolicyRuleDto, ContextFileShare, ContextToolShare, CredentialInfo, DefaultModelResponse, DefaultModelUpdateRequest, DesktopUpdateStatus, DesktopUpdateStatusResponse, DesktopUpdaterCommandMessage, DesktopUpdaterStatusMessage, DirEntryInfo, DirListResponse, DirectorySkillItem, DirectorySkillsResponse, DraftShortcut, EndpointModelListRequest, EndpointModelListResponse, ErrorBody, FeishuBindingInfo, FeishuBindingPutRequest, FeishuBindingResponse, FeishuTestRequest, FeishuTestResponse, FilesStatRequest, FilesStatResponse, FilesWriteRequest, GoalResponse, GoalServerEvent, GoalStateView, HistoryMessage, HookArchiveInstallRequest, HookItem, InstallResponse, MachineInfo, MachineJob, MachineServerStatus, MachinesResponse, McpServerTestResponse, MeResponse, MemberAddRequest, MemberAddResponse, MemberInfo, MembersResponse, MemoryFileInfo, MemoryFileResponse, MemoryFilesResponse, MemoryImportMode, MemoryImportRequest, MemoryImportResponse, MemoryOverviewResponse, MemoryScopeExport, MemoryScopeInfo, MemoryTransferFile, MessagesLiveTail, MessagesPageInfo, MessagesResponse, MessagingBindingCommon, MessagingBindingInfo, MessagingBindingStateRequest, MessagingBindingsResponse, MessagingChannel, MessagingChannelState, MessagingDeliveryError, MessagingDeliveryPatch, MessagingRuntimeState, MessagingRuntimeStatus, MessagingTestMessageResponse, ModelInfo, ModelOAuthCodeRequest, ModelOAuthCodeResponse, ModelOAuthErrorCode, ModelOAuthMode, ModelOAuthStartRequest, ModelOAuthStartResponse, ModelOAuthStatusResponse, ModelPricingDto, ModelProtocolDetectRequest, ModelProtocolDetectResponse, ModelProtocolProbeDto, ModelRefDto, ModelTestRequest, ModelTestResponse, ModelUpdateEntry, ModelVisionDetectRequest, ModelVisionDetectResponse, ModelVisionOutcome, ModelsResponse, ModelsUpdateRequest, PasswordChangeRequest, PendingFollowUpInfo, PendingSteeringInfo, PluginFilesResponse, PluginGroupItem, PluginInstallRequest, PluginItem, PluginLibraryResponse, PluginUpdateRef, PrefsResponse, ProjectCreateRequest, ProjectCreateResponse, ProjectRole, ProjectSummary, ProjectUpdateRequest, ProjectUpdateResponse, ProjectsResponse, ProtocolProbeOutcome, QQBindingInfo, QQBindingPutRequest, QQBindingResponse, QQScanPollResponse, QQScanStartResponse, QQTestRequest, QQTestResponse, RecalledMessageResponse, RequestSpan, RestartResponse, RetryNowResponse, ScheduleItem, ScheduleServerEvent, ScheduleStatus, ScheduleUpsertRequest, SchedulesResponse, ServerEvent, ServerSettings, ServerSettingsResponse, ServerSettingsUpdateRequest, SessionBackgroundTasks, SessionCategory, SessionCategoryCounts, SessionContextParts, SessionContextResponse, SessionCreateRequest, SessionCreateResponse, SessionForkRequest, SessionForkResponse, SessionInfo, SessionPatchRequest, SessionProcessInfo, SessionProcessesResponse, SessionResponse, SessionSource, SessionStatus, SessionTracesResponse, SessionsResponse, SkillArchiveInstallRequest, SkillMetadataItem, SteerRequest, SubagentMessageResponse, SubagentRuntimeInfo, TaskCreateRequest, TaskCreateResponse, TaskInputPart, TelegramBindingInfo, TelegramBindingPutRequest, TelegramBindingResponse, TelegramTestRequest, TelegramTestResponse, ToolCallSpan, TraceAnalysisResponse, TraceEventsResponse, TraceFileInfo, TraceImportRequest, TraceImportResponse, TraceModelSegment, TraceOtherSpan, TracePosition, TraceTaskStats, TraceToolSpan, UiPrefs, UpdateCheckResponse, UpdateJobPhase, UpdateJobStatus, UpdateRunResponse, UploadLimits, UsageAgentSeries, UsageBucket, UsageEntitySeriesCounts, UsageErrorCount, UsageErrorItem, UsageErrorKind, UsageErrors, UsageErrorsClearResponse, UsageErrorsPage, UsageGranularity, UsageGroupBy, UsageGroupRow, UsageModelSeries, UsageModelTotal, UsageModelTotals, UsageResponse, UsageSeriesPoint, UsageTrendPointInTrace, UserInfo, VaultEntryInfo, VaultEntryUpdate, VaultResponse, VaultUpdateRequest, VersionResponse, WeChatBindingInfo, WeChatBindingPutRequest, WeChatBindingResponse, WeChatScanPollResponse, WeChatScanStartResponse, WeChatScanStatus, WeChatScanVerifyRequest, WeChatTestResponse, WorkspaceFileEntry, WorkspaceFilesResponse };
+export { type AdminPasswordResetRequest, type AdminUserCreateRequest, type AdminUserCreateResponse, type AdminUsersResponse, type AgentCompactionConfigDto, type AgentConfigDto, type AgentConfigResponse, type AgentConfigUpdateRequest, type AgentCreateRequest, type AgentCreateResponse, type AgentHooksConfigDto, type AgentHooksResponse, type AgentImportRequest, type AgentImportResponse, type AgentKernelUpdateResponse, type AgentMemoryConfigDto, type AgentModelConfigDto, type AgentPluginsInstallResponse, type AgentSchedulesConfigDto, type AgentSkillsConfigDto, type AgentSkillsResponse, type AgentSummary, type AgentTraceDateGroup, type AgentTraceFileRef, type AgentTraceSessionEntry, type AgentTraceSessionFile, type AgentTraceSessionGroup, type AgentTracesResponse, type AgentVaultConfigDto, type AgentsResponse, type ApprovalDecisionRequest, type ApprovalMode, type AuthLoginRequest, type AuthResponse, type BenchmarkCaseScore, type BenchmarkCaseSummary, type BenchmarkCasesResponse, type BenchmarkCreateCase, type BenchmarkCreateRequest, type BenchmarkCreateResponse, type BenchmarkEvaluation, type BenchmarkRunScore, type BenchmarkStatus, type BenchmarkSummary, type BenchmarksResponse, type CaseMaterial, type ChatDefaultsDto, type CommandPolicyDto, type CommandPolicyRuleDto, type CompanyServerEvent, type ContextFileShare, type ContextToolShare, type ContributionsResponse, type CredentialInfo, type DefaultModelResponse, type DefaultModelUpdateRequest, type DesktopTrayCommandMessage, type DesktopTrayLocale, type DesktopTrayPatch, type DesktopTrayStatus, type DesktopTrayStatusMessage, type DesktopTrayStatusResponse, type DesktopUpdateStatus, type DesktopUpdateStatusResponse, type DesktopUpdaterCommandMessage, type DesktopUpdaterStatusMessage, type DirEntryInfo, type DirListResponse, type DirectorySkillItem, type DirectorySkillsResponse, type DraftShortcut, type EndpointModelListRequest, type EndpointModelListResponse, type ErrorBody, type FeishuBindingInfo, type FeishuBindingPutRequest, type FeishuBindingResponse, type FeishuTestRequest, type FeishuTestResponse, type FilesMoveRequest, type FilesStatRequest, type FilesStatResponse, type FilesWriteRequest, type GoalResponse, type GoalServerEvent, type GoalStateView, type HistoryMessage, type HookArchiveInstallRequest, type HookItem, type InstallResponse, type MachineInfo, type MachineJob, type MachineServerStatus, type MachinesResponse, type McpServerTestResponse, type MeResponse, type MemberAddRequest, type MemberAddResponse, type MemberInfo, type MembersResponse, type MemoryFileInfo, type MemoryFileResponse, type MemoryFilesResponse, type MemoryImportMode, type MemoryImportRequest, type MemoryImportResponse, type MemoryOverviewResponse, type MemoryScopeExport, type MemoryScopeInfo, type MemoryTransferFile, type MessagesLiveTail, type MessagesPageInfo, type MessagesResponse, type MessagingBindingCommon, type MessagingBindingInfo, type MessagingBindingStateRequest, type MessagingBindingsResponse, type MessagingChannel, type MessagingChannelState, type MessagingDeliveryError, type MessagingDeliveryPatch, type MessagingRuntimeState, type MessagingRuntimeStatus, type MessagingTestMessageResponse, type ModelInfo, type ModelOAuthCodeRequest, type ModelOAuthCodeResponse, type ModelOAuthErrorCode, type ModelOAuthMode, type ModelOAuthStartRequest, type ModelOAuthStartResponse, type ModelOAuthStatusResponse, type ModelPricingDto, type ModelProtocolDetectRequest, type ModelProtocolDetectResponse, type ModelProtocolProbeDto, type ModelRefDto, type ModelTestRequest, type ModelTestResponse, type ModelUpdateEntry, type ModelVisionDetectRequest, type ModelVisionDetectResponse, type ModelVisionOutcome, type ModelsResponse, type ModelsUpdateRequest, type OrgApprovalMode, type OrgBudgetAlert, type OrgCalendarItem, type OrgCalendarOutcome, type OrgCalendarResponse, type OrgCalendarUpsertRequest, type OrgCalendarWriteResponse, type OrgChannelCreateRequest, type OrgChannelDetail, type OrgChannelItem, type OrgChannelMember, type OrgChannelMemberRequest, type OrgChannelMessage, type OrgChannelMessageSendRequest, type OrgChannelMessagesResponse, type OrgChannelNotice, type OrgChannelNoticeKind, type OrgChannelPatchRequest, type OrgChannelReadRequest, type OrgChannelsResponse, type OrgChartResponse, type OrgDeskItem, type OrgDeskResponse, type OrgEmployeeItem, type OrgEmployeePatchRequest, type OrgEmployeeState, type OrgFinanceEmployee, type OrgFinanceResponse, type OrgFinanceTicket, type OrgHandbookFile, type OrgHandbookFileResponse, type OrgHandbookFileWriteRequest, type OrgHandbookFilesResponse, type OrgHandbookResponse, type OrgHireRequest, type OrgInbox, type OrgLanguage, type OrgSessionsResponse, type OrgSpendSummary, type OrgStatus, type OrgTicketAttachRequest, type OrgTicketBlockRequest, type OrgTicketChange, type OrgTicketCreateRequest, type OrgTicketDetail, type OrgTicketHistoryAction, type OrgTicketHistoryEntry, type OrgTicketItem, type OrgTicketMoveRequest, type OrgTicketPriority, type OrgTicketProgressRequest, type OrgTicketSessionItem, type OrgTicketStartRequest, type OrgTicketStartResponse, type OrgTicketStatus, type OrgTicketUpdateRequest, type OrgTicketsResponse, type OrgTriggerKind, type OrganizationCreateRequest, type OrganizationDetail, type OrganizationPatchRequest, type OrganizationSettings, type OrganizationSummary, type OrganizationsResponse, type PasswordChangeRequest, type PendingFollowUpInfo, type PendingSteeringInfo, type PluginFilesResponse, type PluginGroupItem, type PluginInstallRequest, type PluginItem, type PluginLibraryResponse, type PluginUpdateRef, type PrefsResponse, type ProjectCreateRequest, type ProjectCreateResponse, type ProjectRole, type ProjectSummary, type ProjectUpdateRequest, type ProjectUpdateResponse, type ProjectsResponse, type ProtocolProbeOutcome, type ProxyProbeDto, type ProxyProbeOutcome, type ProxyProbeProvider, type ProxyProbeResponse, type ProxyProbeTargetDto, type ProxyProbeTargetsResponse, type QQBindingInfo, type QQBindingPutRequest, type QQBindingResponse, type QQScanPollResponse, type QQScanStartResponse, type QQTestRequest, type QQTestResponse, type RecalledMessageResponse, type RendererRef, type RequestSpan, type RestartResponse, type RetryNowResponse, type ScheduleItem, type ScheduleServerEvent, type ScheduleStatus, type ScheduleUpsertRequest, type SchedulesResponse, type SemanticIdSuggestReason, type SemanticIdSuggestRequest, type SemanticIdSuggestResponse, type ServerEvent, type ServerSettings, type ServerSettingsResponse, type ServerSettingsUpdateRequest, type SessionBackgroundTasks, type SessionCategory, type SessionCategoryCounts, type SessionContextParts, type SessionContextResponse, type SessionCreateRequest, type SessionCreateResponse, type SessionForkRequest, type SessionForkResponse, type SessionInfo, type SessionPatchRequest, type SessionProcessInfo, type SessionProcessesResponse, type SessionResponse, type SessionSource, type SessionStatus, type SessionTracesResponse, type SessionsResponse, type SkillArchiveInstallRequest, type SkillMetadataItem, type SteerRequest, type SubagentMessageResponse, type SubagentRuntimeInfo, TICKET_SLUG_PATTERN, type TaskCreateRequest, type TaskCreateResponse, type TaskInputPart, type TelegramBindingInfo, type TelegramBindingPutRequest, type TelegramBindingResponse, type TelegramTestRequest, type TelegramTestResponse, type ToolCallSpan, type TraceAnalysisResponse, type TraceEventsResponse, type TraceFileInfo, type TraceImportRequest, type TraceImportResponse, type TraceModelSegment, type TraceOtherSpan, type TracePosition, type TraceTaskStats, type TraceToolSpan, type UiPrefs, type UpdateCheckResponse, type UpdateJobPhase, type UpdateJobStatus, type UpdateProfileRequest, type UpdateProfileResponse, type UpdateRunResponse, type UploadLimits, type UsageAgentSeries, type UsageBucket, type UsageEntitySeriesCounts, type UsageErrorCount, type UsageErrorItem, type UsageErrorKind, type UsageErrors, type UsageErrorsClearResponse, type UsageErrorsPage, type UsageGranularity, type UsageGroupBy, type UsageGroupRow, type UsageModelSeries, type UsageModelTotal, type UsageModelTotals, type UsageResponse, type UsageSeriesPoint, type UsageTrendPointInTrace, type UserInfo, type VaultEntryInfo, type VaultEntryUpdate, type VaultResponse, type VaultUpdateRequest, type VersionResponse, type WeChatBindingInfo, type WeChatBindingPutRequest, type WeChatBindingResponse, type WeChatScanPollResponse, type WeChatScanStartResponse, type WeChatScanStatus, type WeChatScanVerifyRequest, type WeChatTestResponse, type WebContribution, type WorkspaceFileEntry, type WorkspaceFilesResponse, type WorkspaceSearchHit, type WorkspaceSearchResponse };