@utdk/posthog 1.0.0-20260712.5-dev.e2949a6

package/docs/agent_platform.md

@@ -0,0 +1,2525 @@
+# Agent Platform
+
+## Operations
+
+### `posthog.agentApplicationsList`
+
+- **HTTP**: `GET /api/projects/{project_id}/agent_applications/`
+- **What it does**: Agent applications — the deployable unit of the platform.
+
+URLs:
+    GET    /api/projects/<team>/agent_applications/             list
+    POST   /api/projects/<team>/agent_applications/             create
+    GET    /api/projects/<team>/agent_applications/<id|slug>/   retrieve
+    PATCH  /api/projects/<team>/agent_applications/<id|slug>/   update
+    DELETE /api/projects/<team>/agent_applications/<id|slug>/   archive
+    POST   /api/projects/<team>/agent_applications/<id|slug>/set_env/        bulk replace env
+    GET    /api/projects/<team>/agent_applications/<id|slug>/env_keys/        list set keys
+    GET    /api/projects/<team>/agent_applications/<id|slug>/env_keys/<KEY>/  is one key set?
+    PUT    /api/projects/<team>/agent_applications/<id|slug>/env_keys/<KEY>/  set one key
+    DELETE /api/projects/<team>/agent_applications/<id|slug>/env_keys/<KEY>/  clear one key
+- **OpenAPI operationId**: `agent_applications_list`
+- **Path params**: None
+- **Query params**: `limit`, `offset`
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ count: number; next?: string | null; previous?: string | null; results: ({ id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at:...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsListInput = Parameters<typeof posthog.agentApplicationsList> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsListOutput = Awaited<ReturnType<typeof posthog.agentApplicationsList>>;
+
+const result: AgentApplicationsListOutput = await posthog.agentApplicationsList();
+
+// Result shape (from schema): { count: number; next?: string | null; previous?: string | null; results: ({ id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at:...
+```
+
+### `posthog.agentApplicationsCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/agent_applications/`
+- **What it does**: Agent applications — the deployable unit of the platform.
+
+URLs:
+    GET    /api/projects/<team>/agent_applications/             list
+    POST   /api/projects/<team>/agent_applications/             create
+    GET    /api/projects/<team>/agent_applications/<id|slug>/   retrieve
+    PATCH  /api/projects/<team>/agent_applications/<id|slug>/   update
+    DELETE /api/projects/<team>/agent_applications/<id|slug>/   archive
+    POST   /api/projects/<team>/agent_applications/<id|slug>/set_env/        bulk replace env
+    GET    /api/projects/<team>/agent_applications/<id|slug>/env_keys/        list set keys
+    GET    /api/projects/<team>/agent_applications/<id|slug>/env_keys/<KEY>/  is one key set?
+    PUT    /api/projects/<team>/agent_applications/<id|slug>/env_keys/<KEY>/  set one key
+    DELETE /api/projects/<team>/agent_applications/<id|slug>/env_keys/<KEY>/  clear one key
+- **OpenAPI operationId**: `agent_applications_create`
+- **Path params**: None
+- **Query params**: None
+- **Response codes**: `201`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at: string | null; created_by_id: number | null; created_by: { [key: string]: ...`
+- OpenAPI response codes: `201`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsCreateInput = Parameters<typeof posthog.agentApplicationsCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsCreateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsCreate>>;
+
+const result: AgentApplicationsCreateOutput = await posthog.agentApplicationsCreate();
+
+// Result shape (from schema): { id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at: string | null; created_by_id: number | null; created_by: { [key: string]: ...
+```
+
+### `posthog.agentMemoryListFiles`
+
+- **HTTP**: `GET /api/projects/{project_id}/agent_applications/{application_id}/memory/files/`
+- **What it does**: List memory file headers under the agent's prefix. Headers only — no bodies.
+- **OpenAPI operationId**: `agent_memory_list_files`
+- **Path params**: `application_id`
+- **Query params**: `prefix`
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ count: number; entries: ({ path: string; description: string; tags: (string)[]; created_at: string | null; updated_at: string | null })[] }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentMemoryListFilesInput = Parameters<typeof posthog.agentMemoryListFiles> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentMemoryListFilesOutput = Awaited<ReturnType<typeof posthog.agentMemoryListFiles>>;
+
+const result: AgentMemoryListFilesOutput = await posthog.agentMemoryListFiles();
+
+// Result shape (from schema): { count: number; entries: ({ path: string; description: string; tags: (string)[]; created_at: string | null; updated_at: string | null })[] }
+```
+
+### `posthog.agentMemoryCreateFile`
+
+- **HTTP**: `POST /api/projects/{project_id}/agent_applications/{application_id}/memory/files/`
+- **What it does**: Create a memory file. Fails if the path already exists — use the update endpoint to overwrite.
+- **OpenAPI operationId**: `agent_memory_create_file`
+- **Path params**: `application_id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ content: string }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentMemoryCreateFileInput = Parameters<typeof posthog.agentMemoryCreateFile> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentMemoryCreateFileOutput = Awaited<ReturnType<typeof posthog.agentMemoryCreateFile>>;
+
+const result: AgentMemoryCreateFileOutput = await posthog.agentMemoryCreateFile();
+
+// Result shape (from schema): { content: string }
+```
+
+### `posthog.agentMemoryDeleteFile`
+
+- **HTTP**: `DELETE /api/projects/{project_id}/agent_applications/{application_id}/memory/files/by_path/`
+- **What it does**: Hard-delete a memory file. Activity log captures the action against the agent.
+- **OpenAPI operationId**: `agent_memory_delete_file`
+- **Path params**: `application_id`
+- **Query params**: `path`
+- **Response codes**: `204`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `unknown`
+- OpenAPI response codes: `204`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentMemoryDeleteFileInput = Parameters<typeof posthog.agentMemoryDeleteFile> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentMemoryDeleteFileOutput = Awaited<ReturnType<typeof posthog.agentMemoryDeleteFile>>;
+
+const result: AgentMemoryDeleteFileOutput = await posthog.agentMemoryDeleteFile();
+
+// Result shape (from schema): unknown
+```
+
+### `posthog.agentMemoryGetFile`
+
+- **HTTP**: `GET /api/projects/{project_id}/agent_applications/{application_id}/memory/files/by_path/`
+- **What it does**: Read one memory file in full (frontmatter + markdown body).
+- **OpenAPI operationId**: `agent_memory_get_file`
+- **Path params**: `application_id`
+- **Query params**: `path`
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ content: string }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentMemoryGetFileInput = Parameters<typeof posthog.agentMemoryGetFile> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentMemoryGetFileOutput = Awaited<ReturnType<typeof posthog.agentMemoryGetFile>>;
+
+const result: AgentMemoryGetFileOutput = await posthog.agentMemoryGetFile();
+
+// Result shape (from schema): { content: string }
+```
+
+### `posthog.agentMemoryUpdateFile`
+
+- **HTTP**: `PATCH /api/projects/{project_id}/agent_applications/{application_id}/memory/files/by_path/`
+- **What it does**: Update a memory file. Any field omitted is preserved from the existing file.
+- **OpenAPI operationId**: `agent_memory_update_file`
+- **Path params**: `application_id`
+- **Query params**: `path`
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ content: string }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentMemoryUpdateFileInput = Parameters<typeof posthog.agentMemoryUpdateFile> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentMemoryUpdateFileOutput = Awaited<ReturnType<typeof posthog.agentMemoryUpdateFile>>;
+
+const result: AgentMemoryUpdateFileOutput = await posthog.agentMemoryUpdateFile();
+
+// Result shape (from schema): { content: string }
+```
+
+### `posthog.agentMemorySearch`
+
+- **HTTP**: `GET /api/projects/{project_id}/agent_applications/{application_id}/memory/search/`
+- **What it does**: BM25 search across the agent's memory files. Ranks by description+tags+path+body with field weighting.
+- **OpenAPI operationId**: `agent_memory_search`
+- **Path params**: `application_id`
+- **Query params**: `limit`, `prefix`, `q`
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ cue: string; count: number; results: ({ path: string; description: string; tags: (string)[]; score: number; snippet: string | null })[] }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentMemorySearchInput = Parameters<typeof posthog.agentMemorySearch> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentMemorySearchOutput = Awaited<ReturnType<typeof posthog.agentMemorySearch>>;
+
+const result: AgentMemorySearchOutput = await posthog.agentMemorySearch();
+
+// Result shape (from schema): { cue: string; count: number; results: ({ path: string; description: string; tags: (string)[]; score: number; snippet: string | null })[] }
+```
+
+### `posthog.agentMemoryListTables`
+
+- **HTTP**: `GET /api/projects/{project_id}/agent_applications/{application_id}/memory/tables/`
+- **What it does**: List the agent's tabular-reference tables (the @posthog/table-* JSONL tables): name + byte size.
+- **OpenAPI operationId**: `agent_memory_list_tables`
+- **Path params**: `application_id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ count: number; tables: ({ name: string; size: number })[] }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentMemoryListTablesInput = Parameters<typeof posthog.agentMemoryListTables> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentMemoryListTablesOutput = Awaited<ReturnType<typeof posthog.agentMemoryListTables>>;
+
+const result: AgentMemoryListTablesOutput = await posthog.agentMemoryListTables();
+
+// Result shape (from schema): { count: number; tables: ({ name: string; size: number })[] }
+```
+
+### `posthog.agentMemoryReadTable`
+
+- **HTTP**: `GET /api/projects/{project_id}/agent_applications/{application_id}/memory/tables/{name}/`
+- **What it does**: Read rows from one tabular-reference table (capped via ?limit).
+- **OpenAPI operationId**: `agent_memory_read_table`
+- **Path params**: `application_id`, `name`
+- **Query params**: `limit`
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ name: string; total: number; returned: number; limit: number; rows: ({ [key: string]: unknown })[] }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentMemoryReadTableInput = Parameters<typeof posthog.agentMemoryReadTable> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentMemoryReadTableOutput = Awaited<ReturnType<typeof posthog.agentMemoryReadTable>>;
+
+const result: AgentMemoryReadTableOutput = await posthog.agentMemoryReadTable();
+
+// Result shape (from schema): { name: string; total: number; returned: number; limit: number; rows: ({ [key: string]: unknown })[] }
+```
+
+### `posthog.agentMemoryTree`
+
+- **HTTP**: `GET /api/projects/{project_id}/agent_applications/{application_id}/memory/tree/`
+- **What it does**: Pre-aggregated folder tree of memory files. Saves the frontend re-derivation work.
+- **OpenAPI operationId**: `agent_memory_tree`
+- **Path params**: `application_id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ root: { [key: string]: unknown } }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentMemoryTreeInput = Parameters<typeof posthog.agentMemoryTree> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentMemoryTreeOutput = Awaited<ReturnType<typeof posthog.agentMemoryTree>>;
+
+const result: AgentMemoryTreeOutput = await posthog.agentMemoryTree();
+
+// Result shape (from schema): { root: { [key: string]: unknown } }
+```
+
+### `posthog.agentApplicationsRevisionsList`
+
+- **HTTP**: `GET /api/projects/{project_id}/agent_applications/{application_id}/revisions/`
+- **What it does**: Revisions of an agent. Created in `draft`, promoted through
+`ready → live` once the bundle has been uploaded + frozen.
+
+URLs (nested under an application):
+
+    Model CRUD:
+        GET   .../revisions/                       list
+        POST  .../revisions/                       create draft
+        GET   .../revisions/<id>/                  retrieve
+        PATCH .../revisions/<id>/                  update spec (draft only)
+
+    Lifecycle:
+        POST  .../revisions/<id>/promote/          ready → live
+        POST  .../revisions/<id>/archive/          → archived
+        POST  .../revisions/<id>/freeze/           draft → ready (stamps sha256)
+        POST  .../revisions/<id>/clone_from/       copy bundle from another rev
+        POST  .../revisions/new_draft/             create draft + clone_from atomically
+
+    Bundle authoring (proxied to the janitor):
+        GET    .../revisions/<id>/manifest/        list paths + sha256
+        GET    .../revisions/<id>/file/?path=…     read one file
+        PUT    .../revisions/<id>/file/?path=…     write one file (draft)
+        DELETE .../revisions/<id>/file/?path=…     delete one file (draft)
+        GET    .../revisions/<id>/bundle/          bulk pull all files
+        PUT    .../revisions/<id>/bundle/          bulk push (replace|merge)
+- **OpenAPI operationId**: `agent_applications_revisions_list`
+- **Path params**: `application_id`
+- **Query params**: `limit`, `offset`
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ count: number; next?: string | null; previous?: string | null; results: ({ id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsRevisionsListInput = Parameters<typeof posthog.agentApplicationsRevisionsList> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsRevisionsListOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsList>>;
+
+const result: AgentApplicationsRevisionsListOutput = await posthog.agentApplicationsRevisionsList();
+
+// Result shape (from schema): { count: number; next?: string | null; previous?: string | null; results: ({ id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_...
+```
+
+### `posthog.agentApplicationsRevisionsCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/agent_applications/{application_id}/revisions/`
+- **What it does**: Revisions of an agent. Created in `draft`, promoted through
+`ready → live` once the bundle has been uploaded + frozen.
+
+URLs (nested under an application):
+
+    Model CRUD:
+        GET   .../revisions/                       list
+        POST  .../revisions/                       create draft
+        GET   .../revisions/<id>/                  retrieve
+        PATCH .../revisions/<id>/                  update spec (draft only)
+
+    Lifecycle:
+        POST  .../revisions/<id>/promote/          ready → live
+        POST  .../revisions/<id>/archive/          → archived
+        POST  .../revisions/<id>/freeze/           draft → ready (stamps sha256)
+        POST  .../revisions/<id>/clone_from/       copy bundle from another rev
+        POST  .../revisions/new_draft/             create draft + clone_from atomically
+
+    Bundle authoring (proxied to the janitor):
+        GET    .../revisions/<id>/manifest/        list paths + sha256
+        GET    .../revisions/<id>/file/?path=…     read one file
+        PUT    .../revisions/<id>/file/?path=…     write one file (draft)
+        DELETE .../revisions/<id>/file/?path=…     delete one file (draft)
+        GET    .../revisions/<id>/bundle/          bulk pull all files
+        PUT    .../revisions/<id>/bundle/          bulk push (replace|merge)
+- **OpenAPI operationId**: `agent_applications_revisions_create`
+- **Path params**: `application_id`
+- **Query params**: None
+- **Response codes**: `201`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...`
+- OpenAPI response codes: `201`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsRevisionsCreateInput = Parameters<typeof posthog.agentApplicationsRevisionsCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsRevisionsCreateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsCreate>>;
+
+const result: AgentApplicationsRevisionsCreateOutput = await posthog.agentApplicationsRevisionsCreate();
+
+// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
+```
+
+### `posthog.agentApplicationsRevisionsDestroy`
+
+- **HTTP**: `DELETE /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/`
+- **What it does**: Revisions of an agent. Created in `draft`, promoted through
+`ready → live` once the bundle has been uploaded + frozen.
+
+URLs (nested under an application):
+
+    Model CRUD:
+        GET   .../revisions/                       list
+        POST  .../revisions/                       create draft
+        GET   .../revisions/<id>/                  retrieve
+        PATCH .../revisions/<id>/                  update spec (draft only)
+
+    Lifecycle:
+        POST  .../revisions/<id>/promote/          ready → live
+        POST  .../revisions/<id>/archive/          → archived
+        POST  .../revisions/<id>/freeze/           draft → ready (stamps sha256)
+        POST  .../revisions/<id>/clone_from/       copy bundle from another rev
+        POST  .../revisions/new_draft/             create draft + clone_from atomically
+
+    Bundle authoring (proxied to the janitor):
+        GET    .../revisions/<id>/manifest/        list paths + sha256
+        GET    .../revisions/<id>/file/?path=…     read one file
+        PUT    .../revisions/<id>/file/?path=…     write one file (draft)
+        DELETE .../revisions/<id>/file/?path=…     delete one file (draft)
+        GET    .../revisions/<id>/bundle/          bulk pull all files
+        PUT    .../revisions/<id>/bundle/          bulk push (replace|merge)
+- **OpenAPI operationId**: `agent_applications_revisions_destroy`
+- **Path params**: `application_id`, `id`
+- **Query params**: None
+- **Response codes**: `204`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `unknown`
+- OpenAPI response codes: `204`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsRevisionsDestroyInput = Parameters<typeof posthog.agentApplicationsRevisionsDestroy> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsRevisionsDestroyOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsDestroy>>;
+
+const result: AgentApplicationsRevisionsDestroyOutput = await posthog.agentApplicationsRevisionsDestroy();
+
+// Result shape (from schema): unknown
+```
+
+### `posthog.agentApplicationsRevisionsRetrieve`
+
+- **HTTP**: `GET /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/`
+- **What it does**: Revisions of an agent. Created in `draft`, promoted through
+`ready → live` once the bundle has been uploaded + frozen.
+
+URLs (nested under an application):
+
+    Model CRUD:
+        GET   .../revisions/                       list
+        POST  .../revisions/                       create draft
+        GET   .../revisions/<id>/                  retrieve
+        PATCH .../revisions/<id>/                  update spec (draft only)
+
+    Lifecycle:
+        POST  .../revisions/<id>/promote/          ready → live
+        POST  .../revisions/<id>/archive/          → archived
+        POST  .../revisions/<id>/freeze/           draft → ready (stamps sha256)
+        POST  .../revisions/<id>/clone_from/       copy bundle from another rev
+        POST  .../revisions/new_draft/             create draft + clone_from atomically
+
+    Bundle authoring (proxied to the janitor):
+        GET    .../revisions/<id>/manifest/        list paths + sha256
+        GET    .../revisions/<id>/file/?path=…     read one file
+        PUT    .../revisions/<id>/file/?path=…     write one file (draft)
+        DELETE .../revisions/<id>/file/?path=…     delete one file (draft)
+        GET    .../revisions/<id>/bundle/          bulk pull all files
+        PUT    .../revisions/<id>/bundle/          bulk push (replace|merge)
+- **OpenAPI operationId**: `agent_applications_revisions_retrieve`
+- **Path params**: `application_id`, `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsRevisionsRetrieveInput = Parameters<typeof posthog.agentApplicationsRevisionsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsRevisionsRetrieveOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsRetrieve>>;
+
+const result: AgentApplicationsRevisionsRetrieveOutput = await posthog.agentApplicationsRevisionsRetrieve();
+
+// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
+```
+
+### `posthog.agentApplicationsRevisionsPartialUpdate`
+
+- **HTTP**: `PATCH /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/`
+- **What it does**: Revisions of an agent. Created in `draft`, promoted through
+`ready → live` once the bundle has been uploaded + frozen.
+
+URLs (nested under an application):
+
+    Model CRUD:
+        GET   .../revisions/                       list
+        POST  .../revisions/                       create draft
+        GET   .../revisions/<id>/                  retrieve
+        PATCH .../revisions/<id>/                  update spec (draft only)
+
+    Lifecycle:
+        POST  .../revisions/<id>/promote/          ready → live
+        POST  .../revisions/<id>/archive/          → archived
+        POST  .../revisions/<id>/freeze/           draft → ready (stamps sha256)
+        POST  .../revisions/<id>/clone_from/       copy bundle from another rev
+        POST  .../revisions/new_draft/             create draft + clone_from atomically
+
+    Bundle authoring (proxied to the janitor):
+        GET    .../revisions/<id>/manifest/        list paths + sha256
+        GET    .../revisions/<id>/file/?path=…     read one file
+        PUT    .../revisions/<id>/file/?path=…     write one file (draft)
+        DELETE .../revisions/<id>/file/?path=…     delete one file (draft)
+        GET    .../revisions/<id>/bundle/          bulk pull all files
+        PUT    .../revisions/<id>/bundle/          bulk push (replace|merge)
+- **OpenAPI operationId**: `agent_applications_revisions_partial_update`
+- **Path params**: `application_id`, `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsRevisionsPartialUpdateInput = Parameters<typeof posthog.agentApplicationsRevisionsPartialUpdate> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsRevisionsPartialUpdateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsPartialUpdate>>;
+
+const result: AgentApplicationsRevisionsPartialUpdateOutput = await posthog.agentApplicationsRevisionsPartialUpdate();
+
+// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
+```
+
+### `posthog.agentApplicationsRevisionsUpdate`
+
+- **HTTP**: `PUT /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/`
+- **What it does**: Spec edits are only allowed while state='draft'. Once promoted to
+ready/live the spec is frozen — change requires a new revision.
+- **OpenAPI operationId**: `agent_applications_revisions_update`
+- **Path params**: `application_id`, `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsRevisionsUpdateInput = Parameters<typeof posthog.agentApplicationsRevisionsUpdate> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsRevisionsUpdateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsUpdate>>;
+
+const result: AgentApplicationsRevisionsUpdateOutput = await posthog.agentApplicationsRevisionsUpdate();
+
+// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
+```
+
+### `posthog.agentApplicationsRevisionsAgentMdUpdate`
+
+- **HTTP**: `PUT /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/agent_md/`
+- **What it does**: Revisions of an agent. Created in `draft`, promoted through
+`ready → live` once the bundle has been uploaded + frozen.
+
+URLs (nested under an application):
+
+    Model CRUD:
+        GET   .../revisions/                       list
+        POST  .../revisions/                       create draft
+        GET   .../revisions/<id>/                  retrieve
+        PATCH .../revisions/<id>/                  update spec (draft only)
+
+    Lifecycle:
+        POST  .../revisions/<id>/promote/          ready → live
+        POST  .../revisions/<id>/archive/          → archived
+        POST  .../revisions/<id>/freeze/           draft → ready (stamps sha256)
+        POST  .../revisions/<id>/clone_from/       copy bundle from another rev
+        POST  .../revisions/new_draft/             create draft + clone_from atomically
+
+    Bundle authoring (proxied to the janitor):
+        GET    .../revisions/<id>/manifest/        list paths + sha256
+        GET    .../revisions/<id>/file/?path=…     read one file
+        PUT    .../revisions/<id>/file/?path=…     write one file (draft)
+        DELETE .../revisions/<id>/file/?path=…     delete one file (draft)
+        GET    .../revisions/<id>/bundle/          bulk pull all files
+        PUT    .../revisions/<id>/bundle/          bulk push (replace|merge)
+- **OpenAPI operationId**: `agent_applications_revisions_agent_md_update`
+- **Path params**: `application_id`, `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsRevisionsAgentMdUpdateInput = Parameters<typeof posthog.agentApplicationsRevisionsAgentMdUpdate> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsRevisionsAgentMdUpdateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsAgentMdUpdate>>;
+
+const result: AgentApplicationsRevisionsAgentMdUpdateOutput = await posthog.agentApplicationsRevisionsAgentMdUpdate();
+
+// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
+```
+
+### `posthog.agentApplicationsRevisionsArchiveCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/archive/`
+- **What it does**: Mark a revision archived. If it was the live one, clear the
+application's live_revision pointer (the app effectively has no
+deployable version until another revision is promoted).
+- **OpenAPI operationId**: `agent_applications_revisions_archive_create`
+- **Path params**: `application_id`, `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsRevisionsArchiveCreateInput = Parameters<typeof posthog.agentApplicationsRevisionsArchiveCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsRevisionsArchiveCreateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsArchiveCreate>>;
+
+const result: AgentApplicationsRevisionsArchiveCreateOutput = await posthog.agentApplicationsRevisionsArchiveCreate();
+
+// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
+```
+
+### `posthog.agentApplicationsRevisionsBundleRetrieve`
+
+- **HTTP**: `GET /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/bundle/`
+- **What it does**: Read the full typed bundle: `{ agent_md, skills, tools, spec }`.
+- **OpenAPI operationId**: `agent_applications_revisions_bundle_retrieve`
+- **Path params**: `application_id`, `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsRevisionsBundleRetrieveInput = Parameters<typeof posthog.agentApplicationsRevisionsBundleRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsRevisionsBundleRetrieveOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsBundleRetrieve>>;
+
+const result: AgentApplicationsRevisionsBundleRetrieveOutput = await posthog.agentApplicationsRevisionsBundleRetrieve();
+
+// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
+```
+
+### `posthog.agentApplicationsRevisionsBundleUpdate`
+
+- **HTTP**: `PUT /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/bundle/`
+- **What it does**: Full-replace the typed bundle. Anything not in the payload is
+deleted. Tool sources are AST-checked + esbuild-compiled by the
+janitor before any S3 writes.
+- **OpenAPI operationId**: `agent_applications_revisions_bundle_update`
+- **Path params**: `application_id`, `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsRevisionsBundleUpdateInput = Parameters<typeof posthog.agentApplicationsRevisionsBundleUpdate> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsRevisionsBundleUpdateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsBundleUpdate>>;
+
+const result: AgentApplicationsRevisionsBundleUpdateOutput = await posthog.agentApplicationsRevisionsBundleUpdate();
+
+// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
+```
+
+### `posthog.agentApplicationsRevisionsBundleFileUpdate`
+
+- **HTTP**: `PUT /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/bundle/file/`
+- **What it does**: Update one `.md` file on a draft revision.
+
+`agent.md` writes go to the draft bundle. `skills/<id>/SKILL.md`
+writes are store-backed — skills are materialized from the skill
+store at freeze, so the edit publishes a new version of the
+referenced store skill and re-pins the draft's `skill_refs` entry
+to it. `<id>` must be a ref alias on this revision; add new skills
+via `bundle/import/` or `skill_refs`. Tool source / schema editing
+is out of scope here — use the per-tool endpoints. Returns the
+updated revision so the caller can refresh in one round-trip.
+- **OpenAPI operationId**: `agent_applications_revisions_bundle_file_update`
+- **Path params**: `application_id`, `id`
+- **Query params**: None
+- **Response codes**: `200`, `409`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...`
+- OpenAPI response codes: `200`, `409`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsRevisionsBundleFileUpdateInput = Parameters<typeof posthog.agentApplicationsRevisionsBundleFileUpdate> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsRevisionsBundleFileUpdateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsBundleFileUpdate>>;
+
+const result: AgentApplicationsRevisionsBundleFileUpdateOutput = await posthog.agentApplicationsRevisionsBundleFileUpdate();
+
+// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
+```
+
+### `posthog.agentApplicationsRevisionsBundleImportCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/bundle/import/`
+- **What it does**: Bulk-merge a set of `.md` files into a draft revision.
+
+Sets `agent_md` on the draft bundle if present. `skills[]` are
+store-backed and merge by `id`: an id already referenced by the
+draft publishes a new version of its store skill; an unreferenced
+id attaches the store skill of that name (publishing the payload's
+body to it), or creates it when no such skill exists — and each
+ref is (re-)pinned to the published version. Skills not mentioned
+are left alone, so the import is safe to retry. Draft-only;
+non-draft revisions return 409 untouched.
+- **OpenAPI operationId**: `agent_applications_revisions_bundle_import_create`
+- **Path params**: `application_id`, `id`
+- **Query params**: None
+- **Response codes**: `200`, `409`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...`
+- OpenAPI response codes: `200`, `409`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsRevisionsBundleImportCreateInput = Parameters<typeof posthog.agentApplicationsRevisionsBundleImportCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsRevisionsBundleImportCreateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsBundleImportCreate>>;
+
+const result: AgentApplicationsRevisionsBundleImportCreateOutput = await posthog.agentApplicationsRevisionsBundleImportCreate();
+
+// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
+```
+
+### `posthog.agentApplicationsRevisionsCloneFromCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/clone_from/`
+- **What it does**: Copy every file from `source_revision_id` into this revision.
+- **OpenAPI operationId**: `agent_applications_revisions_clone_from_create`
+- **Path params**: `application_id`, `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsRevisionsCloneFromCreateInput = Parameters<typeof posthog.agentApplicationsRevisionsCloneFromCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsRevisionsCloneFromCreateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsCloneFromCreate>>;
+
+const result: AgentApplicationsRevisionsCloneFromCreateOutput = await posthog.agentApplicationsRevisionsCloneFromCreate();
+
+// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
+```
+
+### `posthog.agentApplicationsRevisionsCronFireCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/cron/fire/`
+- **What it does**: Fire one cron job out-of-band — the same execution path the
+scheduler walks, but on demand. Authoring UX: the user iterates on
+a cron prompt by clicking 'Fire now' rather than waiting for the
+next scheduled firing. Without this, 'did my prompt do the right
+thing?' is unanswerable until the cron actually fires.
+
+Idempotent via `request_id`: repeat clicks with the same id resolve
+to the same session id rather than firing N times.
+- **OpenAPI operationId**: `agent_applications_revisions_cron_fire_create`
+- **Path params**: `application_id`, `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ ok: boolean; session_id: string; fired_at: string; idempotency_key: string; request_id: string }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsRevisionsCronFireCreateInput = Parameters<typeof posthog.agentApplicationsRevisionsCronFireCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsRevisionsCronFireCreateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsCronFireCreate>>;
+
+const result: AgentApplicationsRevisionsCronFireCreateOutput = await posthog.agentApplicationsRevisionsCronFireCreate();
+
+// Result shape (from schema): { ok: boolean; session_id: string; fired_at: string; idempotency_key: string; request_id: string }
+```
+
+### `posthog.agentRevisionsEnvKeysList`
+
+- **HTTP**: `GET /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/env_keys/`
+- **What it does**: List the names of secrets currently set on this revision.
+
+Returns names only — values stay server-side under
+`EncryptedTextField`. Use this to drive the "set / unset" badge next to
+a declared secret in the editor UI.
+- **OpenAPI operationId**: `agent_revisions_env_keys_list`
+- **Path params**: `application_id`, `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ keys: (string)[] }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentRevisionsEnvKeysListInput = Parameters<typeof posthog.agentRevisionsEnvKeysList> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentRevisionsEnvKeysListOutput = Awaited<ReturnType<typeof posthog.agentRevisionsEnvKeysList>>;
+
+const result: AgentRevisionsEnvKeysListOutput = await posthog.agentRevisionsEnvKeysList();
+
+// Result shape (from schema): { keys: (string)[] }
+```
+
+### `posthog.agentRevisionsEnvKeysClear`
+
+- **HTTP**: `DELETE /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/env_keys/{key}/`
+- **What it does**: GET / PUT / DELETE one secret by name on this revision.
+
+- `GET`    → `{ key, is_set }` (never returns the value).
+- `PUT`    → upserts `{ value }` into the env block.
+- `DELETE` → removes the key. No-op when it wasn't set.
+
+Per-method scope: GET is treated as a write action so the single action
+name maps to one consistent scope; reading whether a secret is set is
+restricted to writers in any case.
+- **OpenAPI operationId**: `agent_revisions_env_keys_clear`
+- **Path params**: `application_id`, `id`, `key`
+- **Query params**: None
+- **Response codes**: `204`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `unknown`
+- OpenAPI response codes: `204`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentRevisionsEnvKeysClearInput = Parameters<typeof posthog.agentRevisionsEnvKeysClear> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentRevisionsEnvKeysClearOutput = Awaited<ReturnType<typeof posthog.agentRevisionsEnvKeysClear>>;
+
+const result: AgentRevisionsEnvKeysClearOutput = await posthog.agentRevisionsEnvKeysClear();
+
+// Result shape (from schema): unknown
+```
+
+### `posthog.agentRevisionsEnvKeysGet`
+
+- **HTTP**: `GET /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/env_keys/{key}/`
+- **What it does**: GET / PUT / DELETE one secret by name on this revision.
+
+- `GET`    → `{ key, is_set }` (never returns the value).
+- `PUT`    → upserts `{ value }` into the env block.
+- `DELETE` → removes the key. No-op when it wasn't set.
+
+Per-method scope: GET is treated as a write action so the single action
+name maps to one consistent scope; reading whether a secret is set is
+restricted to writers in any case.
+- **OpenAPI operationId**: `agent_revisions_env_keys_get`
+- **Path params**: `application_id`, `id`, `key`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ key: string; is_set: boolean }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentRevisionsEnvKeysGetInput = Parameters<typeof posthog.agentRevisionsEnvKeysGet> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentRevisionsEnvKeysGetOutput = Awaited<ReturnType<typeof posthog.agentRevisionsEnvKeysGet>>;
+
+const result: AgentRevisionsEnvKeysGetOutput = await posthog.agentRevisionsEnvKeysGet();
+
+// Result shape (from schema): { key: string; is_set: boolean }
+```
+
+### `posthog.agentRevisionsEnvKeysSet`
+
+- **HTTP**: `PUT /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/env_keys/{key}/`
+- **What it does**: GET / PUT / DELETE one secret by name on this revision.
+
+- `GET`    → `{ key, is_set }` (never returns the value).
+- `PUT`    → upserts `{ value }` into the env block.
+- `DELETE` → removes the key. No-op when it wasn't set.
+
+Per-method scope: GET is treated as a write action so the single action
+name maps to one consistent scope; reading whether a secret is set is
+restricted to writers in any case.
+- **OpenAPI operationId**: `agent_revisions_env_keys_set`
+- **Path params**: `application_id`, `id`, `key`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ key: string; is_set: boolean }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentRevisionsEnvKeysSetInput = Parameters<typeof posthog.agentRevisionsEnvKeysSet> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentRevisionsEnvKeysSetOutput = Awaited<ReturnType<typeof posthog.agentRevisionsEnvKeysSet>>;
+
+const result: AgentRevisionsEnvKeysSetOutput = await posthog.agentRevisionsEnvKeysSet();
+
+// Result shape (from schema): { key: string; is_set: boolean }
+```
+
+### `posthog.agentApplicationsRevisionsFreezeCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/freeze/`
+- **What it does**: Freeze the bundle: draft → ready, stamps sha256 on the row.
+
+Django is a thin proxy here: resolve template refs into the
+bundle, ask the janitor to seal it (the janitor returns the sha
++ the spec it derived from the typed resources), then stamp the
+row. No `transaction.atomic()` — the janitor's freeze is idempotent
+(on retry it re-reads the existing `.frozen` marker + re-derives
+spec), so a partial failure here is recoverable by re-calling
+freeze, not by transactional rollback. Holding an atomic block
+across the janitor HTTP call previously deadlocked the
+agent_revision row against the janitor's spec write — that's
+moved off the janitor side as part of the same fix.
+- **OpenAPI operationId**: `agent_applications_revisions_freeze_create`
+- **Path params**: `application_id`, `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsRevisionsFreezeCreateInput = Parameters<typeof posthog.agentApplicationsRevisionsFreezeCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsRevisionsFreezeCreateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsFreezeCreate>>;
+
+const result: AgentApplicationsRevisionsFreezeCreateOutput = await posthog.agentApplicationsRevisionsFreezeCreate();
+
+// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
+```
+
+### `posthog.agentApplicationsRevisionsManifestRetrieve`
+
+- **HTTP**: `GET /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/manifest/`
+- **What it does**: List every file in this revision's bundle (path, size, sha256).
+- **OpenAPI operationId**: `agent_applications_revisions_manifest_retrieve`
+- **Path params**: `application_id`, `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsRevisionsManifestRetrieveInput = Parameters<typeof posthog.agentApplicationsRevisionsManifestRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsRevisionsManifestRetrieveOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsManifestRetrieve>>;
+
+const result: AgentApplicationsRevisionsManifestRetrieveOutput = await posthog.agentApplicationsRevisionsManifestRetrieve();
+
+// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
+```
+
+### `posthog.agentApplicationsRevisionsPromoteCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/promote/`
+- **What it does**: ready → live. Sets the parent application's live_revision.
+- **OpenAPI operationId**: `agent_applications_revisions_promote_create`
+- **Path params**: `application_id`, `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsRevisionsPromoteCreateInput = Parameters<typeof posthog.agentApplicationsRevisionsPromoteCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsRevisionsPromoteCreateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsPromoteCreate>>;
+
+const result: AgentApplicationsRevisionsPromoteCreateOutput = await posthog.agentApplicationsRevisionsPromoteCreate();
+
+// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
+```
+
+### `posthog.agentApplicationsRevisionsSetEnvCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/set_env/`
+- **What it does**: Replace this revision's encrypted env block.
+
+The body is `{ "env": { "<KEY>": "<value>", ... } }`. The encrypted
+text is stored on `AgentRevision.encrypted_env`; the worker decrypts it
+at session start via the same Fernet schedule (see
+agent-shared/src/runtime/encryption.ts).
+- **OpenAPI operationId**: `agent_applications_revisions_set_env_create`
+- **Path params**: `application_id`, `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsRevisionsSetEnvCreateInput = Parameters<typeof posthog.agentApplicationsRevisionsSetEnvCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsRevisionsSetEnvCreateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsSetEnvCreate>>;
+
+const result: AgentApplicationsRevisionsSetEnvCreateOutput = await posthog.agentApplicationsRevisionsSetEnvCreate();
+
+// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
+```
+
+### `posthog.agentApplicationsRevisionsSkillRefsUpdate`
+
+- **HTTP**: `PUT /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/skill_refs/`
+- **What it does**: Full-replace the draft's store-skill references. They are resolved
+and materialized into the bundle at freeze, not here — this only records
+which skills (and pinned versions) the freeze should pull in.
+- **OpenAPI operationId**: `agent_applications_revisions_skill_refs_update`
+- **Path params**: `application_id`, `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsRevisionsSkillRefsUpdateInput = Parameters<typeof posthog.agentApplicationsRevisionsSkillRefsUpdate> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsRevisionsSkillRefsUpdateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsSkillRefsUpdate>>;
+
+const result: AgentApplicationsRevisionsSkillRefsUpdateOutput = await posthog.agentApplicationsRevisionsSkillRefsUpdate();
+
+// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
+```
+
+### `posthog.agentApplicationsRevisionsSlackManifest`
+
+- **HTTP**: `GET /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/slack_manifest/`
+- **What it does**: Build a Slack app manifest for this revision's slack trigger.
+
+Deterministic: the OAuth scopes and bot event subscriptions are derived
+from the slack trigger config (`mention_only` / `auto_resume_threads` /
+`ack_reaction`) and the agent's Slack tools, so the manifest already
+subscribes to exactly the events the config needs. 400 if the revision
+has no slack trigger.
+- **OpenAPI operationId**: `agent_applications_revisions_slack_manifest`
+- **Path params**: `application_id`, `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ revision_id: string; manifest: unknown; notes: (string)[]; events_url: string | null; interactivity_url: string | null }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsRevisionsSlackManifestInput = Parameters<typeof posthog.agentApplicationsRevisionsSlackManifest> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsRevisionsSlackManifestOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsSlackManifest>>;
+
+const result: AgentApplicationsRevisionsSlackManifestOutput = await posthog.agentApplicationsRevisionsSlackManifest();
+
+// Result shape (from schema): { revision_id: string; manifest: unknown; notes: (string)[]; events_url: string | null; interactivity_url: string | null }
+```
+
+### `posthog.agentApplicationsRevisionsSpecUpdate`
+
+- **HTTP**: `PUT /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/spec/`
+- **What it does**: Revisions of an agent. Created in `draft`, promoted through
+`ready → live` once the bundle has been uploaded + frozen.
+
+URLs (nested under an application):
+
+    Model CRUD:
+        GET   .../revisions/                       list
+        POST  .../revisions/                       create draft
+        GET   .../revisions/<id>/                  retrieve
+        PATCH .../revisions/<id>/                  update spec (draft only)
+
+    Lifecycle:
+        POST  .../revisions/<id>/promote/          ready → live
+        POST  .../revisions/<id>/archive/          → archived
+        POST  .../revisions/<id>/freeze/           draft → ready (stamps sha256)
+        POST  .../revisions/<id>/clone_from/       copy bundle from another rev
+        POST  .../revisions/new_draft/             create draft + clone_from atomically
+
+    Bundle authoring (proxied to the janitor):
+        GET    .../revisions/<id>/manifest/        list paths + sha256
+        GET    .../revisions/<id>/file/?path=…     read one file
+        PUT    .../revisions/<id>/file/?path=…     write one file (draft)
+        DELETE .../revisions/<id>/file/?path=…     delete one file (draft)
+        GET    .../revisions/<id>/bundle/          bulk pull all files
+        PUT    .../revisions/<id>/bundle/          bulk push (replace|merge)
+- **OpenAPI operationId**: `agent_applications_revisions_spec_update`
+- **Path params**: `application_id`, `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsRevisionsSpecUpdateInput = Parameters<typeof posthog.agentApplicationsRevisionsSpecUpdate> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsRevisionsSpecUpdateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsSpecUpdate>>;
+
+const result: AgentApplicationsRevisionsSpecUpdateOutput = await posthog.agentApplicationsRevisionsSpecUpdate();
+
+// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
+```
+
+### `posthog.agentApplicationsRevisionsSystemPrompt`
+
+- **HTTP**: `GET /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/system_prompt/`
+- **What it does**: Return the fully-assembled system prompt for this revision.
+
+Authoring tools call this to preview what the model will actually
+see at session start — the platform framework preamble plus the
+bundle's `agent.md` plus the skills index. Useful for debugging
+author-vs-framework precedence conflicts and verifying
+`spec.framework_prompt.omit` overrides took effect.
+- **OpenAPI operationId**: `agent_applications_revisions_system_prompt`
+- **Path params**: `application_id`, `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ revision_id: string; framework_prompt_version: number; system_prompt: string }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsRevisionsSystemPromptInput = Parameters<typeof posthog.agentApplicationsRevisionsSystemPrompt> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsRevisionsSystemPromptOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsSystemPrompt>>;
+
+const result: AgentApplicationsRevisionsSystemPromptOutput = await posthog.agentApplicationsRevisionsSystemPrompt();
+
+// Result shape (from schema): { revision_id: string; framework_prompt_version: number; system_prompt: string }
+```
+
+### `posthog.agentApplicationsRevisionsToolsDestroy`
+
+- **HTTP**: `DELETE /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/tools/{tool_id}/`
+- **What it does**: Revisions of an agent. Created in `draft`, promoted through
+`ready → live` once the bundle has been uploaded + frozen.
+
+URLs (nested under an application):
+
+    Model CRUD:
+        GET   .../revisions/                       list
+        POST  .../revisions/                       create draft
+        GET   .../revisions/<id>/                  retrieve
+        PATCH .../revisions/<id>/                  update spec (draft only)
+
+    Lifecycle:
+        POST  .../revisions/<id>/promote/          ready → live
+        POST  .../revisions/<id>/archive/          → archived
+        POST  .../revisions/<id>/freeze/           draft → ready (stamps sha256)
+        POST  .../revisions/<id>/clone_from/       copy bundle from another rev
+        POST  .../revisions/new_draft/             create draft + clone_from atomically
+
+    Bundle authoring (proxied to the janitor):
+        GET    .../revisions/<id>/manifest/        list paths + sha256
+        GET    .../revisions/<id>/file/?path=…     read one file
+        PUT    .../revisions/<id>/file/?path=…     write one file (draft)
+        DELETE .../revisions/<id>/file/?path=…     delete one file (draft)
+        GET    .../revisions/<id>/bundle/          bulk pull all files
+        PUT    .../revisions/<id>/bundle/          bulk push (replace|merge)
+- **OpenAPI operationId**: `agent_applications_revisions_tools_destroy`
+- **Path params**: `application_id`, `id`, `tool_id`
+- **Query params**: None
+- **Response codes**: `204`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `unknown`
+- OpenAPI response codes: `204`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsRevisionsToolsDestroyInput = Parameters<typeof posthog.agentApplicationsRevisionsToolsDestroy> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsRevisionsToolsDestroyOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsToolsDestroy>>;
+
+const result: AgentApplicationsRevisionsToolsDestroyOutput = await posthog.agentApplicationsRevisionsToolsDestroy();
+
+// Result shape (from schema): unknown
+```
+
+### `posthog.agentApplicationsRevisionsToolsUpdate`
+
+- **HTTP**: `PUT /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/tools/{tool_id}/`
+- **What it does**: Revisions of an agent. Created in `draft`, promoted through
+`ready → live` once the bundle has been uploaded + frozen.
+
+URLs (nested under an application):
+
+    Model CRUD:
+        GET   .../revisions/                       list
+        POST  .../revisions/                       create draft
+        GET   .../revisions/<id>/                  retrieve
+        PATCH .../revisions/<id>/                  update spec (draft only)
+
+    Lifecycle:
+        POST  .../revisions/<id>/promote/          ready → live
+        POST  .../revisions/<id>/archive/          → archived
+        POST  .../revisions/<id>/freeze/           draft → ready (stamps sha256)
+        POST  .../revisions/<id>/clone_from/       copy bundle from another rev
+        POST  .../revisions/new_draft/             create draft + clone_from atomically
+
+    Bundle authoring (proxied to the janitor):
+        GET    .../revisions/<id>/manifest/        list paths + sha256
+        GET    .../revisions/<id>/file/?path=…     read one file
+        PUT    .../revisions/<id>/file/?path=…     write one file (draft)
+        DELETE .../revisions/<id>/file/?path=…     delete one file (draft)
+        GET    .../revisions/<id>/bundle/          bulk pull all files
+        PUT    .../revisions/<id>/bundle/          bulk push (replace|merge)
+- **OpenAPI operationId**: `agent_applications_revisions_tools_update`
+- **Path params**: `application_id`, `id`, `tool_id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsRevisionsToolsUpdateInput = Parameters<typeof posthog.agentApplicationsRevisionsToolsUpdate> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsRevisionsToolsUpdateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsToolsUpdate>>;
+
+const result: AgentApplicationsRevisionsToolsUpdateOutput = await posthog.agentApplicationsRevisionsToolsUpdate();
+
+// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
+```
+
+### `posthog.agentApplicationsRevisionsToolsDryRunCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/tools/{tool_id}/dry_run/`
+- **What it does**: Execute one persisted custom tool in a single-shot sandbox.
+
+Authoring loop's "test this tool" button. The tool's source must
+already be PUT (compiled.js is what runs); this just invokes it
+with the caller-supplied args and a stubbed ctx. No real secrets
+leave Django — `mock_secrets` is a `{name → placeholder}` map.
+- **OpenAPI operationId**: `agent_applications_revisions_tools_dry_run_create`
+- **Path params**: `application_id`, `id`, `tool_id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ ok: boolean; tool_id: string; result?: unknown; error?: { code: string; message: string }; duration_ms: number }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsRevisionsToolsDryRunCreateInput = Parameters<typeof posthog.agentApplicationsRevisionsToolsDryRunCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsRevisionsToolsDryRunCreateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsToolsDryRunCreate>>;
+
+const result: AgentApplicationsRevisionsToolsDryRunCreateOutput = await posthog.agentApplicationsRevisionsToolsDryRunCreate();
+
+// Result shape (from schema): { ok: boolean; tool_id: string; result?: unknown; error?: { code: string; message: string }; duration_ms: number }
+```
+
+### `posthog.agentApplicationsRevisionsValidateCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/validate/`
+- **What it does**: Pre-flight checks before freeze + promote: agent.md exists,
+every native tool id is registered, every custom tool has its
+compiled.js + schema.json, every skill path exists, every declared
+secret has a value set in this revision's env block. Returns
+`{ ok, errors: [...] }`. Works on any revision state.
+- **OpenAPI operationId**: `agent_applications_revisions_validate_create`
+- **Path params**: `application_id`, `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ ok: boolean; revision_id: string; revision_state: string; errors: ({ code: string; message: string; pointer: string })[]; resolved_natives: (string)[] }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsRevisionsValidateCreateInput = Parameters<typeof posthog.agentApplicationsRevisionsValidateCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsRevisionsValidateCreateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsValidateCreate>>;
+
+const result: AgentApplicationsRevisionsValidateCreateOutput = await posthog.agentApplicationsRevisionsValidateCreate();
+
+// Result shape (from schema): { ok: boolean; revision_id: string; revision_state: string; errors: ({ code: string; message: string; pointer: string })[]; resolved_natives: (string)[] }
+```
+
+### `posthog.agentApplicationsRevisionsNewDraftCreate`
+
+- **HTTP**: `POST /api/projects/{project_id}/agent_applications/{application_id}/revisions/new_draft/`
+- **What it does**: Create a fresh draft revision under `application_id` and seed it
+from `source_revision_id`. Saves the MCP one round-trip vs the
+explicit create + clone_from sequence.
+- **OpenAPI operationId**: `agent_applications_revisions_new_draft_create`
+- **Path params**: `application_id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsRevisionsNewDraftCreateInput = Parameters<typeof posthog.agentApplicationsRevisionsNewDraftCreate> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsRevisionsNewDraftCreateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsNewDraftCreate>>;
+
+const result: AgentApplicationsRevisionsNewDraftCreateOutput = await posthog.agentApplicationsRevisionsNewDraftCreate();
+
+// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
+```
+
+### `posthog.agentApplicationsDestroy`
+
+- **HTTP**: `DELETE /api/projects/{project_id}/agent_applications/{id}/`
+- **What it does**: Agent applications — the deployable unit of the platform.
+
+URLs:
+    GET    /api/projects/<team>/agent_applications/             list
+    POST   /api/projects/<team>/agent_applications/             create
+    GET    /api/projects/<team>/agent_applications/<id|slug>/   retrieve
+    PATCH  /api/projects/<team>/agent_applications/<id|slug>/   update
+    DELETE /api/projects/<team>/agent_applications/<id|slug>/   archive
+    POST   /api/projects/<team>/agent_applications/<id|slug>/set_env/        bulk replace env
+    GET    /api/projects/<team>/agent_applications/<id|slug>/env_keys/        list set keys
+    GET    /api/projects/<team>/agent_applications/<id|slug>/env_keys/<KEY>/  is one key set?
+    PUT    /api/projects/<team>/agent_applications/<id|slug>/env_keys/<KEY>/  set one key
+    DELETE /api/projects/<team>/agent_applications/<id|slug>/env_keys/<KEY>/  clear one key
+- **OpenAPI operationId**: `agent_applications_destroy`
+- **Path params**: `id`
+- **Query params**: None
+- **Response codes**: `204`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `unknown`
+- OpenAPI response codes: `204`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsDestroyInput = Parameters<typeof posthog.agentApplicationsDestroy> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsDestroyOutput = Awaited<ReturnType<typeof posthog.agentApplicationsDestroy>>;
+
+const result: AgentApplicationsDestroyOutput = await posthog.agentApplicationsDestroy();
+
+// Result shape (from schema): unknown
+```
+
+### `posthog.agentApplicationsRetrieve`
+
+- **HTTP**: `GET /api/projects/{project_id}/agent_applications/{id}/`
+- **What it does**: Agent applications — the deployable unit of the platform.
+
+URLs:
+    GET    /api/projects/<team>/agent_applications/             list
+    POST   /api/projects/<team>/agent_applications/             create
+    GET    /api/projects/<team>/agent_applications/<id|slug>/   retrieve
+    PATCH  /api/projects/<team>/agent_applications/<id|slug>/   update
+    DELETE /api/projects/<team>/agent_applications/<id|slug>/   archive
+    POST   /api/projects/<team>/agent_applications/<id|slug>/set_env/        bulk replace env
+    GET    /api/projects/<team>/agent_applications/<id|slug>/env_keys/        list set keys
+    GET    /api/projects/<team>/agent_applications/<id|slug>/env_keys/<KEY>/  is one key set?
+    PUT    /api/projects/<team>/agent_applications/<id|slug>/env_keys/<KEY>/  set one key
+    DELETE /api/projects/<team>/agent_applications/<id|slug>/env_keys/<KEY>/  clear one key
+- **OpenAPI operationId**: `agent_applications_retrieve`
+- **Path params**: `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at: string | null; created_by_id: number | null; created_by: { [key: string]: ...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsRetrieveInput = Parameters<typeof posthog.agentApplicationsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsRetrieveOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRetrieve>>;
+
+const result: AgentApplicationsRetrieveOutput = await posthog.agentApplicationsRetrieve();
+
+// Result shape (from schema): { id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at: string | null; created_by_id: number | null; created_by: { [key: string]: ...
+```
+
+### `posthog.agentApplicationsPartialUpdate`
+
+- **HTTP**: `PATCH /api/projects/{project_id}/agent_applications/{id}/`
+- **What it does**: Agent applications — the deployable unit of the platform.
+
+URLs:
+    GET    /api/projects/<team>/agent_applications/             list
+    POST   /api/projects/<team>/agent_applications/             create
+    GET    /api/projects/<team>/agent_applications/<id|slug>/   retrieve
+    PATCH  /api/projects/<team>/agent_applications/<id|slug>/   update
+    DELETE /api/projects/<team>/agent_applications/<id|slug>/   archive
+    POST   /api/projects/<team>/agent_applications/<id|slug>/set_env/        bulk replace env
+    GET    /api/projects/<team>/agent_applications/<id|slug>/env_keys/        list set keys
+    GET    /api/projects/<team>/agent_applications/<id|slug>/env_keys/<KEY>/  is one key set?
+    PUT    /api/projects/<team>/agent_applications/<id|slug>/env_keys/<KEY>/  set one key
+    DELETE /api/projects/<team>/agent_applications/<id|slug>/env_keys/<KEY>/  clear one key
+- **OpenAPI operationId**: `agent_applications_partial_update`
+- **Path params**: `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at: string | null; created_by_id: number | null; created_by: { [key: string]: ...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsPartialUpdateInput = Parameters<typeof posthog.agentApplicationsPartialUpdate> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsPartialUpdateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsPartialUpdate>>;
+
+const result: AgentApplicationsPartialUpdateOutput = await posthog.agentApplicationsPartialUpdate();
+
+// Result shape (from schema): { id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at: string | null; created_by_id: number | null; created_by: { [key: string]: ...
+```
+
+### `posthog.agentApplicationsUpdate`
+
+- **HTTP**: `PUT /api/projects/{project_id}/agent_applications/{id}/`
+- **What it does**: Agent applications — the deployable unit of the platform.
+
+URLs:
+    GET    /api/projects/<team>/agent_applications/             list
+    POST   /api/projects/<team>/agent_applications/             create
+    GET    /api/projects/<team>/agent_applications/<id|slug>/   retrieve
+    PATCH  /api/projects/<team>/agent_applications/<id|slug>/   update
+    DELETE /api/projects/<team>/agent_applications/<id|slug>/   archive
+    POST   /api/projects/<team>/agent_applications/<id|slug>/set_env/        bulk replace env
+    GET    /api/projects/<team>/agent_applications/<id|slug>/env_keys/        list set keys
+    GET    /api/projects/<team>/agent_applications/<id|slug>/env_keys/<KEY>/  is one key set?
+    PUT    /api/projects/<team>/agent_applications/<id|slug>/env_keys/<KEY>/  set one key
+    DELETE /api/projects/<team>/agent_applications/<id|slug>/env_keys/<KEY>/  clear one key
+- **OpenAPI operationId**: `agent_applications_update`
+- **Path params**: `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at: string | null; created_by_id: number | null; created_by: { [key: string]: ...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsUpdateInput = Parameters<typeof posthog.agentApplicationsUpdate> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsUpdateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsUpdate>>;
+
+const result: AgentApplicationsUpdateOutput = await posthog.agentApplicationsUpdate();
+
+// Result shape (from schema): { id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at: string | null; created_by_id: number | null; created_by: { [key: string]: ...
+```
+
+### `posthog.agentApplicationsApprovalsList`
+
+- **HTTP**: `GET /api/projects/{project_id}/agent_applications/{id}/approvals/`
+- **What it does**: List approval-gated tool requests for this application. Team-admin
+only (per plan §6.1). Default returns all states — pass `?state=queued`
+for the inbox view.
+- **OpenAPI operationId**: `agent_applications_approvals_list`
+- **Path params**: `id`
+- **Query params**: `limit`, `offset`, `state`
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ results: ({ id: string; session_id: string; application_id: string; team_id: number; revision_id: string; turn: number; tool_call_id: string; tool_name: string; proposed_args: { [key: string]: unknown }; decided_args:...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsApprovalsListInput = Parameters<typeof posthog.agentApplicationsApprovalsList> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsApprovalsListOutput = Awaited<ReturnType<typeof posthog.agentApplicationsApprovalsList>>;
+
+const result: AgentApplicationsApprovalsListOutput = await posthog.agentApplicationsApprovalsList();
+
+// Result shape (from schema): { results: ({ id: string; session_id: string; application_id: string; team_id: number; revision_id: string; turn: number; tool_call_id: string; tool_name: string; proposed_args: { [key: string]: unknown }; decided_args:...
+```
+
+### `posthog.agentApplicationsApprovalsRetrieve`
+
+- **HTTP**: `GET /api/projects/{project_id}/agent_applications/{id}/approvals/{approval_id}/`
+- **What it does**: Single approval request — full proposed args, assistant snapshot,
+decision metadata, dispatch outcome. Team-admin only (plan §6.1).
+- **OpenAPI operationId**: `agent_applications_approvals_retrieve`
+- **Path params**: `approval_id`, `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `unknown`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsApprovalsRetrieveInput = Parameters<typeof posthog.agentApplicationsApprovalsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsApprovalsRetrieveOutput = Awaited<ReturnType<typeof posthog.agentApplicationsApprovalsRetrieve>>;
+
+const result: AgentApplicationsApprovalsRetrieveOutput = await posthog.agentApplicationsApprovalsRetrieve();
+
+// Result shape (from schema): unknown
+```
+
+### `posthog.agentApplicationsApprovalsDecide`
+
+- **HTTP**: `POST /api/projects/{project_id}/agent_applications/{id}/approvals/{approval_id}/decide/`
+- **What it does**: Approve or reject a queued `agent`-type tool-approval request.
+
+This is the OWNER decision surface — the only PostHog-authoritative one:
+team admins decide here, in the console. `principal`-type approvals are
+decided by the session principal at the ingress decision API, not here.
+The runtime side runs the tool platform-side on approve and wakes the
+session with a synthetic tool_result either way.
+- **OpenAPI operationId**: `agent_applications_approvals_decide`
+- **Path params**: `approval_id`, `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ ok: boolean; state: string }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsApprovalsDecideInput = Parameters<typeof posthog.agentApplicationsApprovalsDecide> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsApprovalsDecideOutput = Awaited<ReturnType<typeof posthog.agentApplicationsApprovalsDecide>>;
+
+const result: AgentApplicationsApprovalsDecideOutput = await posthog.agentApplicationsApprovalsDecide();
+
+// Result shape (from schema): { ok: boolean; state: string }
+```
+
+### `posthog.agentApplicationsPreviewProxyGet`
+
+- **HTTP**: `GET /api/projects/{project_id}/agent_applications/{id}/preview-proxy/{rest}/`
+- **What it does**: GET passthrough for the preview-proxy — used for `/listen` SSE.
+- **OpenAPI operationId**: `agent_applications_preview_proxy_get`
+- **Path params**: `id`, `rest`
+- **Query params**: `format`, `revision_id`
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at: string | null; created_by_id: number | null; created_by: { [key: string]: ...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsPreviewProxyGetInput = Parameters<typeof posthog.agentApplicationsPreviewProxyGet> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsPreviewProxyGetOutput = Awaited<ReturnType<typeof posthog.agentApplicationsPreviewProxyGet>>;
+
+const result: AgentApplicationsPreviewProxyGetOutput = await posthog.agentApplicationsPreviewProxyGet();
+
+// Result shape (from schema): { id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at: string | null; created_by_id: number | null; created_by: { [key: string]: ...
+```
+
+### `posthog.agentApplicationsPreviewProxy`
+
+- **HTTP**: `POST /api/projects/{project_id}/agent_applications/{id}/preview-proxy/{rest}/`
+- **What it does**: Authoring-side proxy for invoking a *draft* (or any non-live) revision.
+
+Closes the anonymous-draft-invoke gap: the public ingress URL refuses
+non-live invokes that don't carry the `x-agent-preview-secret` header;
+this proxy attaches it after authenticating the Django caller.
+
+URL: `/api/projects/<team>/agent_applications/<app>/preview-proxy/<rest>`
+Auth: standard PAT / session — `agents:write` scope (POST run/send/cancel
+is a mutating invoke; the read-only `listen` GET is `agents:read`).
+- **OpenAPI operationId**: `agent_applications_preview_proxy`
+- **Path params**: `id`, `rest`
+- **Query params**: `format`, `revision_id`
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `string`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsPreviewProxyInput = Parameters<typeof posthog.agentApplicationsPreviewProxy> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsPreviewProxyOutput = Awaited<ReturnType<typeof posthog.agentApplicationsPreviewProxy>>;
+
+const result: AgentApplicationsPreviewProxyOutput = await posthog.agentApplicationsPreviewProxy();
+
+// Result shape (from schema): string
+```
+
+### `posthog.agentApplicationsPreviewToken`
+
+- **HTTP**: `GET /api/projects/{project_id}/agent_applications/{id}/preview-token/`
+- **What it does**: GET sibling of `preview_token_mint`. Same body and response
+shape — exists because `EventSource` can't set headers, so SSE
+callers fetch the token via GET and then attach `?preview_token=`
+to the ingress URL. Behind the same URL (`url_path="preview-token"`)
+thanks to DRF's `@<action>.mapping.get`; DRF resolves it to a
+distinct `view.action`, but it is in `scope_object_write_actions`
+alongside the POST sibling — both return a usable credential, so
+both require `agents:write`.
+- **OpenAPI operationId**: `agent_applications_preview_token`
+- **Path params**: `id`
+- **Query params**: `revision_id`
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ token: string; expires_in: number; ingress_slug: string; endpoints: unknown; auth: unknown; preview_proxy: unknown }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsPreviewTokenInput = Parameters<typeof posthog.agentApplicationsPreviewToken> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsPreviewTokenOutput = Awaited<ReturnType<typeof posthog.agentApplicationsPreviewToken>>;
+
+const result: AgentApplicationsPreviewTokenOutput = await posthog.agentApplicationsPreviewToken();
+
+// Result shape (from schema): { token: string; expires_in: number; ingress_slug: string; endpoints: unknown; auth: unknown; preview_proxy: unknown }
+```
+
+### `posthog.agentApplicationsPreviewTokenMint`
+
+- **HTTP**: `POST /api/projects/{project_id}/agent_applications/{id}/preview-token/`
+- **What it does**: Mint a short-lived JWT for talking to a non-live revision
+directly via the public ingress URL. The caller attaches it as
+the `x-agent-preview-token` header (or `?preview_token=` query
+param for `EventSource`). See `_mint_preview_jwt` for the
+payload + claim binding.
+
+The response also includes `endpoints`, `auth`, and
+`preview_proxy` blocks so the caller can wire a preview
+invocation without grepping the agent-ingress source for which
+path each trigger exposes or which header name carries the
+token. This is the "self-describing" half of preview-mode —
+every piece of info you need to hit ingress is in one response.
+
+POST is the canonical verb — minting credentials for downstream
+`run`/`send`/`cancel` is a write-class capability. A GET sibling
+exists at the same URL for `EventSource` callers (which can't set
+headers); it is also write-scoped, since it returns the same token.
+- **OpenAPI operationId**: `agent_applications_preview_token_mint`
+- **Path params**: `id`
+- **Query params**: `revision_id`
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ token: string; expires_in: number; ingress_slug: string; endpoints: unknown; auth: unknown; preview_proxy: unknown }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsPreviewTokenMintInput = Parameters<typeof posthog.agentApplicationsPreviewTokenMint> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsPreviewTokenMintOutput = Awaited<ReturnType<typeof posthog.agentApplicationsPreviewTokenMint>>;
+
+const result: AgentApplicationsPreviewTokenMintOutput = await posthog.agentApplicationsPreviewTokenMint();
+
+// Result shape (from schema): { token: string; expires_in: number; ingress_slug: string; endpoints: unknown; auth: unknown; preview_proxy: unknown }
+```
+
+### `posthog.agentApplicationsSessionsList`
+
+- **HTTP**: `GET /api/projects/{project_id}/agent_applications/{id}/sessions/`
+- **What it does**: List sessions for this application, most recently active first. Strips the
+conversation transcript from each summary, but includes a `preview`
+(last assistant text, ~120 chars) and `usage_total` (token + cost
+aggregate). Use `agent-applications-sessions-retrieve` for the full
+transcript of a single session.
+- **OpenAPI operationId**: `agent_applications_sessions_list`
+- **Path params**: `id`
+- **Query params**: `created_after`, `created_before`, `limit`, `offset`, `revision_id`, `state`
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ results: ({ usage_total: { tokens_in: number; tokens_out: number; cache_read: number; cache_write: number; cost_input: number; cost_output: number; cost_cache_read: number; cost_cache_write: number; cost_total: number...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsSessionsListInput = Parameters<typeof posthog.agentApplicationsSessionsList> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsSessionsListOutput = Awaited<ReturnType<typeof posthog.agentApplicationsSessionsList>>;
+
+const result: AgentApplicationsSessionsListOutput = await posthog.agentApplicationsSessionsList();
+
+// Result shape (from schema): { results: ({ usage_total: { tokens_in: number; tokens_out: number; cache_read: number; cache_write: number; cost_input: number; cost_output: number; cost_cache_read: number; cost_cache_write: number; cost_total: number...
+```
+
+### `posthog.agentApplicationsSessionsRetrieve`
+
+- **HTTP**: `GET /api/projects/{project_id}/agent_applications/{id}/sessions/{session_id}/`
+- **What it does**: Fetch one session's state — full conversation by default, or just
+the trailing N messages with `?last_n=`. Always returns a
+`usage_total` block aggregated over the entire session, regardless of
+trim. The runner-side queue DB is the source of truth.
+- **OpenAPI operationId**: `agent_applications_sessions_retrieve`
+- **Path params**: `id`, `session_id`
+- **Query params**: `last_n`
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ usage_total: { tokens_in: number; tokens_out: number; cache_read: number; cache_write: number; cost_input: number; cost_output: number; cost_cache_read: number; cost_cache_write: number; cost_total: number }; principa...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsSessionsRetrieveInput = Parameters<typeof posthog.agentApplicationsSessionsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsSessionsRetrieveOutput = Awaited<ReturnType<typeof posthog.agentApplicationsSessionsRetrieve>>;
+
+const result: AgentApplicationsSessionsRetrieveOutput = await posthog.agentApplicationsSessionsRetrieve();
+
+// Result shape (from schema): { usage_total: { tokens_in: number; tokens_out: number; cache_read: number; cache_write: number; cost_input: number; cost_output: number; cost_cache_read: number; cost_cache_write: number; cost_total: number }; principa...
+```
+
+### `posthog.agentApplicationsSessionLogs`
+
+- **HTTP**: `GET /api/projects/{project_id}/agent_applications/{id}/sessions/{session_id}/logs/`
+- **What it does**: Read the runner's structured event log for one session from
+ClickHouse. Filters (limit / after / before / level / search)
+match the shared `LogEntryMixin` helper used by hog_function +
+hog_flow.
+- **OpenAPI operationId**: `agent_applications_session_logs`
+- **Path params**: `id`, `session_id`
+- **Query params**: `after`, `before`, `instance_id`, `level`, `limit`, `search`
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ results: ({ log_source_id: string; instance_id: string; timestamp: string; level: string; message: string })[] }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsSessionLogsInput = Parameters<typeof posthog.agentApplicationsSessionLogs> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsSessionLogsOutput = Awaited<ReturnType<typeof posthog.agentApplicationsSessionLogs>>;
+
+const result: AgentApplicationsSessionLogsOutput = await posthog.agentApplicationsSessionLogs();
+
+// Result shape (from schema): { results: ({ log_source_id: string; instance_id: string; timestamp: string; level: string; message: string })[] }
+```
+
+### `posthog.agentApplicationsStats`
+
+- **HTTP**: `GET /api/projects/{project_id}/agent_applications/{id}/stats/`
+- **What it does**: Roll-up stats for the agent — drives the agent-detail overview tiles.
+- **OpenAPI operationId**: `agent_applications_stats`
+- **Path params**: `id`
+- **Query params**: `since`
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ liveCount: number; sessionsInWindowCount: number; spendInWindowUsd: number; lastActivityAt: string | null; failedInWindowCount: number; pendingApprovalsCount: number }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsStatsInput = Parameters<typeof posthog.agentApplicationsStats> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsStatsOutput = Awaited<ReturnType<typeof posthog.agentApplicationsStats>>;
+
+const result: AgentApplicationsStatsOutput = await posthog.agentApplicationsStats();
+
+// Result shape (from schema): { liveCount: number; sessionsInWindowCount: number; spendInWindowUsd: number; lastActivityAt: string | null; failedInWindowCount: number; pendingApprovalsCount: number }
+```
+
+### `posthog.agentApplicationsUsersList`
+
+- **HTTP**: `GET /api/projects/{project_id}/agent_applications/{id}/users/`
+- **What it does**: List this agent's end-users (the stable identities behind inbound principals) and each user's linked external connections. Connection metadata only — credential material is never returned.
+- **OpenAPI operationId**: `agent_applications_users_list`
+- **Path params**: `id`
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ count: number; results: ({ id: string; principal_kind: string; principal_id: string; metadata?: unknown; created_at: string; connections: ({ id: string; provider: string; scopes: (string)[]; state: string; subject?: s...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsUsersListInput = Parameters<typeof posthog.agentApplicationsUsersList> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsUsersListOutput = Awaited<ReturnType<typeof posthog.agentApplicationsUsersList>>;
+
+const result: AgentApplicationsUsersListOutput = await posthog.agentApplicationsUsersList();
+
+// Result shape (from schema): { count: number; results: ({ id: string; principal_kind: string; principal_id: string; metadata?: unknown; created_at: string; connections: ({ id: string; provider: string; scopes: (string)[]; state: string; subject?: s...
+```
+
+### `posthog.agentApplicationsUsersConnectionDelete`
+
+- **HTTP**: `DELETE /api/projects/{project_id}/agent_applications/{id}/users/{agent_user_id}/connections/{provider}/`
+- **What it does**: Revoke one of an end-user's linked connections. The credential is marked revoked (kept for audit), so the agent can no longer act as that user on the provider.
+- **OpenAPI operationId**: `agent_applications_users_connection_delete`
+- **Path params**: `agent_user_id`, `id`, `provider`
+- **Query params**: None
+- **Response codes**: `204`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `unknown`
+- OpenAPI response codes: `204`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsUsersConnectionDeleteInput = Parameters<typeof posthog.agentApplicationsUsersConnectionDelete> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsUsersConnectionDeleteOutput = Awaited<ReturnType<typeof posthog.agentApplicationsUsersConnectionDelete>>;
+
+const result: AgentApplicationsUsersConnectionDeleteOutput = await posthog.agentApplicationsUsersConnectionDelete();
+
+// Result shape (from schema): unknown
+```
+
+### `posthog.agentApplicationsModels`
+
+- **HTTP**: `GET /api/projects/{project_id}/agent_applications/models/`
+- **What it does**: Served-model catalog — each model's id, provider, context window, and USD-per-million-token pricing — plus the curated auto-level → model map. Project-agnostic; sourced from the AI gateway catalog. Powers the config UI model browser and the agent builder's model-choosing skill.
+- **OpenAPI operationId**: `agent_applications_models`
+- **Path params**: None
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at: string | null; created_by_id: number | null; created_by: { [key: string]: ...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsModelsInput = Parameters<typeof posthog.agentApplicationsModels> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsModelsOutput = Awaited<ReturnType<typeof posthog.agentApplicationsModels>>;
+
+const result: AgentApplicationsModelsOutput = await posthog.agentApplicationsModels();
+
+// Result shape (from schema): { id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at: string | null; created_by_id: number | null; created_by: { [key: string]: ...
+```
+
+### `posthog.agentApplicationsSpecSchema`
+
+- **HTTP**: `GET /api/projects/{project_id}/agent_applications/spec_schema/`
+- **What it does**: The canonical JSON Schema for an agent `spec` — every field, type, enum, default, and the discriminated unions for `models` / `triggers[]` / `tools[]`, each with an inline description. Emitted from the same source the runner validates against (fields with a default are optional on write), so read it BEFORE composing a spec for create / revisions-spec-update instead of guessing the shape. Pass `section` to fetch just one part.
+- **OpenAPI operationId**: `agent_applications_spec_schema`
+- **Path params**: None
+- **Query params**: `section`
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at: string | null; created_by_id: number | null; created_by: { [key: string]: ...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentApplicationsSpecSchemaInput = Parameters<typeof posthog.agentApplicationsSpecSchema> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentApplicationsSpecSchemaOutput = Awaited<ReturnType<typeof posthog.agentApplicationsSpecSchema>>;
+
+const result: AgentApplicationsSpecSchemaOutput = await posthog.agentApplicationsSpecSchema();
+
+// Result shape (from schema): { id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at: string | null; created_by_id: number | null; created_by: { [key: string]: ...
+```
+
+### `posthog.agentFleetApprovalsList`
+
+- **HTTP**: `GET /api/projects/{project_id}/agent_fleet/approvals/`
+- **What it does**: Approval-gated tool requests across every agent in this team. Team-admin only.
+- **OpenAPI operationId**: `agent_fleet_approvals_list`
+- **Path params**: None
+- **Query params**: `agent_id`, `limit`, `offset`, `state`
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `unknown`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentFleetApprovalsListInput = Parameters<typeof posthog.agentFleetApprovalsList> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentFleetApprovalsListOutput = Awaited<ReturnType<typeof posthog.agentFleetApprovalsList>>;
+
+const result: AgentFleetApprovalsListOutput = await posthog.agentFleetApprovalsList();
+
+// Result shape (from schema): unknown
+```
+
+### `posthog.agentFleetLiveSessions`
+
+- **HTTP**: `GET /api/projects/{project_id}/agent_fleet/live_sessions/`
+- **What it does**: Live (non-terminal) sessions across every agent owned by this team, newest activity first.
+- **OpenAPI operationId**: `agent_fleet_live_sessions`
+- **Path params**: None
+- **Query params**: `limit`
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ results: ({ usage_total: { tokens_in: number; tokens_out: number; cache_read: number; cache_write: number; cost_input: number; cost_output: number; cost_cache_read: number; cost_cache_write: number; cost_total: number...`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentFleetLiveSessionsInput = Parameters<typeof posthog.agentFleetLiveSessions> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentFleetLiveSessionsOutput = Awaited<ReturnType<typeof posthog.agentFleetLiveSessions>>;
+
+const result: AgentFleetLiveSessionsOutput = await posthog.agentFleetLiveSessions();
+
+// Result shape (from schema): { results: ({ usage_total: { tokens_in: number; tokens_out: number; cache_read: number; cache_write: number; cost_input: number; cost_output: number; cost_cache_read: number; cost_cache_write: number; cost_total: number...
+```
+
+### `posthog.agentFleetStats`
+
+- **HTTP**: `GET /api/projects/{project_id}/agent_fleet/stats/`
+- **What it does**: Roll-up stats across every agent owned by this team.
+- **OpenAPI operationId**: `agent_fleet_stats`
+- **Path params**: None
+- **Query params**: `since`
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `{ liveCount: number; sessionsInWindowCount: number; spendInWindowUsd: number; lastActivityAt: string | null; failedInWindowCount: number; pendingApprovalsCount: number }`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentFleetStatsInput = Parameters<typeof posthog.agentFleetStats> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentFleetStatsOutput = Awaited<ReturnType<typeof posthog.agentFleetStats>>;
+
+const result: AgentFleetStatsOutput = await posthog.agentFleetStats();
+
+// Result shape (from schema): { liveCount: number; sessionsInWindowCount: number; spendInWindowUsd: number; lastActivityAt: string | null; failedInWindowCount: number; pendingApprovalsCount: number }
+```
+
+### `posthog.agentNativeToolsList`
+
+- **HTTP**: `GET /api/projects/{project_id}/agent_native_tools/`
+- **What it does**: Read-only catalog of every @posthog/* native tool the runner knows.
+- **OpenAPI operationId**: `agent_native_tools_list`
+- **Path params**: None
+- **Query params**: None
+- **Response codes**: `200`
+- **Transport options**: None
+- **TypeScript**: [Client interface](../types.ts)
+
+**Inputs**
+
+- Client input type: `{ [key: string]: unknown }`
+- Client transport options: None
+
+**Outputs**
+
+- Client return type: `({ tools: ({ id: string; schema: { [key: string]: unknown } })[] })[]`
+- OpenAPI response codes: `200`
+
+```ts
+import posthog from "@utdk/posthog";
+
+type AgentNativeToolsListInput = Parameters<typeof posthog.agentNativeToolsList> extends [infer T, ...unknown[]] ? T : undefined;
+type AgentNativeToolsListOutput = Awaited<ReturnType<typeof posthog.agentNativeToolsList>>;
+
+const result: AgentNativeToolsListOutput = await posthog.agentNativeToolsList();
+
+// Result shape (from schema): ({ tools: ({ id: string; schema: { [key: string]: unknown } })[] })[]
+```
+
+
+<!-- prompt-hash:
+8c3694991a4c289225f05a4e8f1e098cc74d085a088d7dffd82f00d93797b7f8
+-->