@agent-compose/sdk 0.8.4 → 0.8.6

package/src/client.ts

@@ -1,3 +1,4 @@
+import type { ConversationRow, CreateChatInput, ChannelIvyState, DriveSharesView, IvyConnectionsView, ListingPage } from "./types/api-conversations.js";
 /**
  * AgentComposeClient — HTTP client for the agent-compose server API.
  *
@@ -32,11 +33,13 @@ import type {
   ConversationsPage, SessionsPage, ConversationDetail, ConversationThread,
   CreateCloudSessionInput, CloudSessionCreated,
   SessionPreview, PreviewOpened, OpenPreviewInput, SessionForked, BackgroundWorkHeld,
-  SessionChangeSet, SessionMergeGated, SessionMergeReport, SessionDiscardReport,
-  SessionChangePreflight, SessionRebaseReport, SessionAutoRebaseState,
+  BackgroundWorkChildDecl, BackgroundWorkStatus, MachineUpsizeOutcome,
+  CreateSessionWaitInput, SessionWait, SessionWaitCreated, SessionWaitList,
+  SessionChangeSet, SessionFilePlane, SessionMergeGated, SessionMergeReport, SessionDiscardReport,
+  SessionChangePreflight, SessionRebaseReport,
   ReviewSuggestionInput, ReviewNotesPublished, ReviewGitCredential,
   SendConversationMessageInput, SendConversationMessageResult,
-  ChannelSessionRow, ChannelSessionsResponse, SessionChannelMessagePosted,
+  ChannelSessionRow, ChannelSessionsResponse,
   SessionDirectMessageSent, BranchClaimGranted, BranchClaimsReleased, BranchClaimState,
   ConversationPresenceSnapshot, StreamConversationOptions, AgentListRow,
   SessionPerfHistoryPage,
@@ -46,20 +49,21 @@ import type {
   SetScopeGrantsInput, SetTemplateScopeInput,
 } from "./types/api-scopes.js";
 import type {
-  Project, ProjectsPage, ProjectRole, ProjectMember,
-  ProjectObjectsPage, ProjectAddPreview,
-  AddProjectObjectInput, AddProjectObjectResult, RefreshProjectObjectResult,
+  Project, ProjectUpdate, ProjectsPage, ProjectRole, ProjectMember,
+  ProjectObject, ProjectObjectsPage, ProjectObjectCounts, ProjectAddPreview,
+  AddProjectObjectInput, AddProjectObjectResult, RefreshProjectObjectResult, ProjectStatus, ThreadStatus, MeStatus,
 } from "./types/api-projects.js";
 import type {
   RegisterResult, RegisterWorkflowInput, TemplateRow, TemplateDetail, ListTemplatesOptions,
   SearchFactoryFilesOptions, FactoryFileSearchResult, FactoryFileWriteResult,
-  FactoryFileListRow, ListFactoryFilesOptions, FactoryFileListPage,
+  FactoryFileListRow, ListFactoryFilesOptions, FactoryFileListPage, FactoryFileConflict, FactoryFileConflictList, ProjectSecretMeta, ProjectSecretList,
   FactoryRow, CreateFactoryInput, UpdateFactoryInput, FactoryPerfSummary,
   ScheduleRow, CreateScheduleInput,
-  SecretOptions, SetSecretResult, SecretListEntry, SessionSecretEntry, SessionSecretInput, SessionSecretRequestCreated, SessionSecretRequestStatus,
+  SecretOptions, SetSecretResult, SecretListEntry, SessionSecretEntry, SessionSecretInput, SessionSecretRequestCreated, SessionSecretRequestStatus, SessionSecretRequestSummary, VaultRequestKind, VaultKeyShape, VaultCatalogEntry, RequestedVaultEntry, VaultCardHint,
   CreateApiKeyInput, ApiKey, ApiKeyCreated, ListApiKeysOptions, ApiKeyPage, UsageResponse,
-  DriveRepoLink, CreateDriveRepoLinkInput,
+  DriveRepoLink, CreateDriveRepoLinkInput, CreateNativeRepoInput, CreateNativeRepoResult,
   DriveMountSession, CreateDriveMountSessionInput,
+  ConnectorGrantSummary,
 } from "./types/api-factory.js";
 import type {
   ComplianceSession, RequestComplianceSessionInput, ListComplianceSessionsOptions,
@@ -85,18 +89,25 @@ export type {
 } from "./types/api-runs.js";
 export type {
   TeamMember, Mention, CreateMentionsInput,
-  ConversationMessagePart, ConversationRow, ConversationMessageRow,
+  CreateChatInput, ChannelIvyState, IvyConnection, HiddenIvyConnection, IvyConnectionsView, IvyConnectionScope, ListingPage,
+  DriveShareItem, DriveShare, HiddenDriveShare, DriveSharesView,
+  WorkspaceConnection, WorkspaceConnectionAudienceEntry, WorkspaceConnectionsScopeView,
+  ConversationMessagePart, ConversationRow, ConversationProject, ConversationMessageRow,
   ConversationsPage, SessionsPage, ConversationDetail,
   CreateCloudSessionInput, CloudSessionCreated, ConversationThread,
+  ConversationUnreadSummary, ConversationUnreadThreads, ConversationReadInput, ConversationReadResult,
   SessionPreview, PreviewOpened, OpenPreviewInput, SessionForked, BackgroundWorkHeld,
+  BackgroundWorkChildDecl, BackgroundWorkStatus, MachineUpsizeOutcome,
+  SessionWaitKind, SessionWaitState, CreateSessionWaitInput, SessionWait, SessionWaitCheck, SessionWaitCheckResult, SessionWaitCheckReview, SessionWaitCreated, SessionWaitList,
   SessionFileChange, SessionChangeSet, SessionChangeStats, SessionDiffReviewBound, ReviewSuggestion,
+  SessionFileHold, SessionFilePlane,
   ReviewSuggestionInput, ReviewNotesPublished, ReviewGitCredential, SessionReviewDocument,
   ReviewSuggestionDecision, ReviewSuggestionDecisions,
   SessionMergeReportDetail, SessionMergeReport, SessionMergeGated, SessionDiscardReport,
-  SessionPreflightFileRow, SessionChangePreflight, SessionRebaseReport, SessionAutoRebaseState,
+  SessionPreflightFileRow, SessionChangePreflight, SessionRebaseReport,
   ConversationPageContext, SendConversationMessageInput, ConversationTurnState,
   SendConversationMessageResult, UnnotifiedMention, ConversationPresenceSnapshot, AgentListRow, StreamConversationOptions,
-  ChannelSessionStatus, ChannelSessionRow, ChannelSessionsResponse, SessionChannelMessagePosted,
+  ChannelSessionStatus, ChannelSessionRow, ChannelWorkerFacts, ChannelSessionsResponse,
   SessionDirectMessageSent, BranchClaimInfo, BranchClaimGranted, BranchClaimsReleased, BranchClaimState,
   SessionPerfBucket, SessionPerfHistoryPage,
 } from "./types/api-conversations.js";
@@ -106,24 +117,30 @@ export type {
   RunContext, SetScopeGrantsInput, SetTemplateScopeInput,
 } from "./types/api-scopes.js";
 export type {
-  Project, ProjectsPage, ProjectRole, ProjectMember,
-  ProjectObject, ProjectObjectsPage, ProjectSkippedFile, ProjectPreviewFile,
+  Project, ProjectUpdate, ProjectsPage, ProjectRole, ProjectMember,
+  ProjectObject, ProjectObjectsPage, ProjectObjectCounts, ProjectSkippedFile, ProjectPreviewFile,
   ProjectAddPreview, AddProjectObjectInput, AddProjectObjectResult,
   RefreshProjectObjectResult,
+  ProjectStatus, ProjectStatusThread, ProjectStatusTask, ProjectStatusPerson, ProjectStatusWorker, ProjectStatusActivity,
+  ProjectStatusActivityKind, ProjectStatusWaitingOn, ProjectStatusWaitingCount, ProjectStatusCounts,
+  ThreadStatus, ThreadStatusWorker, ThreadStatusWorkerState, ThreadStatusWorkerEffort, ThreadStatusTodo, ThreadStatusDirector, ThreadStatusOutput, ThreadStatusEvent, ChatWork, ChatWorkThread,
+  ThreadStatusWaitingOn, ThreadStatusAssignee, ThreadStatusTodoActivity, ChatTodoPatch, ChatTodoComment,
+  MeStatus, MeStatusCounts,
 } from "./types/api-projects.js";
 export type {
   RegisterResult, RegisteredRuntime, RuntimeSourceInput, TemplateSourceRef, RegisterWorkflowInput,
   TemplateRow, TemplateDetail, ListTemplatesOptions,
   FactoryFileSearchRow, FactoryFolderSearchRow, SearchFactoryFilesOptions, FactoryFileSearchResult, FactoryFileWriteResult,
-  FactoryFileListRow, ListFactoryFilesOptions, FactoryFileListPage,
+  FactoryFileListRow, ListFactoryFilesOptions, FactoryFileListPage, FactoryFileConflict, FactoryFileConflictList, ProjectSecretMeta, ProjectSecretList,
   PublicFileLinkState,
   FactoryRow, CreateFactoryInput, UpdateFactoryInput, FactoryPerfSummary,
   ScheduleRow, CreateScheduleInput,
-  SecretOptions, SetSecretResult, SecretListEntry, SessionSecretEntry, SessionSecretInput, SessionSecretRequestCreated, SessionSecretRequestStatus,
+  SecretOptions, SetSecretResult, SecretListEntry, SessionSecretEntry, SessionSecretInput, SessionSecretRequestCreated, SessionSecretRequestStatus, SessionSecretRequestSummary, VaultRequestKind, VaultKeyShape, VaultCatalogEntry, RequestedVaultEntry, VaultCardHint,
   CreateApiKeyInput, ApiKey, ApiKeyCreated, ListApiKeysOptions, ApiKeyPage,
   UsageRollupRow, UsageResponse,
-  DriveRepoLink, CreateDriveRepoLinkInput,
+  DriveRepoLink, CreateDriveRepoLinkInput, CreateNativeRepoInput, CreateNativeRepoResult,
   DriveMountSession, CreateDriveMountSessionInput,
+  ConnectorGrantSummary,
 } from "./types/api-factory.js";
 export type {
   ComplianceScopeKind, ComplianceStatus, ComplianceSession, ComplianceAccess,
@@ -151,6 +168,16 @@ function detectAmbientParentRunId(): string | null {
  *  URL-encoded as defense-in-depth: today's server-side patterns
  *  (`^[a-z][a-z0-9-]*$`) can't produce reserved characters, but a future
  *  relaxation would otherwise quietly become an injection vector. */
+/** The query string of one page of a scope listing (`cursor`: the previous
+ *  page's `nextCursor`; `limit`: 1..200). Empty for the first page at the
+ *  server's size. */
+function listingPageQuery(page: ListingPage = {}): string {
+  const q = new URLSearchParams();
+  if (page.cursor) q.set("cursor", page.cursor);
+  if (page.limit !== undefined) q.set("limit", String(page.limit));
+  return q.toString() ? `?${q}` : "";
+}
+
 function templatePath(factorySlug: string, ...rest: string[]): string {
   const tail = rest.length > 0
     ? "/" + rest.map(encodeURIComponent).join("/")
@@ -770,6 +797,55 @@ export class AgentComposeClient {
     };
   }
 
+  /** Bounded, cursor-paginated conflicts. A session filter is applied in the database. */
+  /** Project secrets (the group tier) — names + metadata, project members only. */
+  listProjectSecrets(projectId: string): Promise<ProjectSecretList> {
+    return this.fetch(`/api/v1/projects/${encodeURIComponent(projectId)}/secrets`);
+  }
+
+  /** Upsert a project secret. Human credential required (a session toolbelt
+   * key is refused). Values are write-only — never echoed. */
+  upsertProjectSecret(projectId: string, secret: {
+    key: string; value: string;
+    delivery?: "injected" | "brokered"; brokerHost?: string; brokerHeaderName?: string; brokerHeaderScheme?: string;
+  }): Promise<{ key: string; delivery: "injected" | "brokered" }> {
+    return this.fetch(`/api/v1/projects/${encodeURIComponent(projectId)}/secrets`, {
+      method: "POST", body: JSON.stringify(secret),
+    });
+  }
+
+  deleteProjectSecret(projectId: string, key: string): Promise<void> {
+    return this.fetch(`/api/v1/projects/${encodeURIComponent(projectId)}/secrets/${encodeURIComponent(key)}`, { method: "DELETE" });
+  }
+
+  listFactoryFileConflicts(factorySlug: string, opts: { limit?: number; cursor?: string; conversationId?: string } = {}): Promise<FactoryFileConflictList> {
+    const q = new URLSearchParams();
+    if (opts.limit !== undefined) q.set("limit", String(opts.limit));
+    if (opts.cursor) q.set("cursor", opts.cursor);
+    if (opts.conversationId) q.set("conversationId", opts.conversationId);
+    return this.fetch(`/api/v1/factories/${encodeURIComponent(factorySlug)}/files/conflicts?${q}`);
+  }
+
+  async getFactoryFileConflictContent(factorySlug: string, id: string): Promise<Uint8Array> {
+    const bytes = await this.fetch<ArrayBuffer, "arrayBuffer">(
+      `/api/v1/factories/${encodeURIComponent(factorySlug)}/files/conflicts/${encodeURIComponent(id)}/content`,
+      { responseType: "arrayBuffer" },
+    );
+    return new Uint8Array(bytes);
+  }
+
+  /** Records a decision about the exact inspected versions. Stale arms refuse. */
+  resolveFactoryFileConflict(factorySlug: string, id: string, decision: {
+    status: "resolved" | "dismissed";
+    settle: "branch" | "main";
+    expectedOursHash: string | null;
+    expectedTheirsHash: string | null;
+  }): Promise<FactoryFileConflict & { settled: "branch" | "main" | "row" }> {
+    return this.fetch(`/api/v1/factories/${encodeURIComponent(factorySlug)}/files/conflicts/${encodeURIComponent(id)}/resolve`, {
+      method: "POST", body: JSON.stringify(decision),
+    });
+  }
+
   /** Read one file's current content (or a specific revision) as RAW BYTES —
    *  byte-exact for any content type. This is the wire truth; `getFactoryFile`
    *  is a UTF-8 decode over it. Binaries (images, archives) MUST come through
@@ -812,7 +888,7 @@ export class AgentComposeClient {
   // ── User drive mounts ──────────────────────────────────────────────────────
   // `agentc files mount` on a human's own machine: the server forks a user
   // branch, backs it with a mount session (the review surface), and mints a
-  // user-principal gateway token. Human-held credentials only (sign-in
+  // user-principal gateway token. Own-device credentials only (sign-in
   // cookie or a device-flow bridge key) — sandbox session keys are refused.
 
   /** Create a local drive mount (or re-mint an existing one's token by
@@ -860,6 +936,27 @@ export class AgentComposeClient {
   // access. Key callers see what their sender scope allows; the server is the
   // sole authority — these are thin typed wrappers.
 
+  /** Create a shared chat, including its own Ivy by default. */
+  createChat(input: CreateChatInput): Promise<ConversationRow> {
+    return this.fetch("/api/v1/conversations", { method: "POST", body: JSON.stringify(input), headers: { "content-type": "application/json" } });
+  }
+  getChannelIvy(id: string): Promise<ChannelIvyState> {
+    return this.fetch(`/api/v1/conversations/${encodeURIComponent(id)}/ivy`);
+  }
+  /** A project's GitHub grants: its own, and the workspace's it inherits,
+   *  one page at a time (pass the previous page's `nextCursor`). A
+   *  project's access is its members' (and the workspace admins'): a
+   *  member of the workspace who can see a public project without being in
+   *  it gets a 403 `project_member_required`. */
+  listProjectIvyConnections(id: string, page?: ListingPage): Promise<IvyConnectionsView> {
+    return this.fetch(`/api/v1/projects/${encodeURIComponent(id)}/ivy-connections${listingPageQuery(page)}`);
+  }
+  /** A project's Drive shares: its own, and the workspace's it inherits,
+   *  one page at a time. Members only, as listProjectIvyConnections. */
+  listProjectDriveShares(id: string, page?: ListingPage): Promise<DriveSharesView> {
+    return this.fetch(`/api/v1/projects/${encodeURIComponent(id)}/drive-shares${listingPageQuery(page)}`);
+  }
+
   /** List conversations the caller can access, newest-activity first.
    *  Cursor-paginated: pass the previous page's `next_cursor`. */
   listConversations(opts?: { cursor?: string }): Promise<ConversationsPage> {
@@ -987,25 +1084,6 @@ export class AgentComposeClient {
     );
   }
 
-  /** Post one message into a channel AS the calling session (ADR-0057 Seam
-   *  4) — progress, results, questions, attributed to the session (title +
-   *  runtime mark). Session toolbelt credential ONLY (the calling session
-   *  resolves from the key server-side — 403 `session_credential_required`
-   *  otherwise); the session must be attached (409 `not_attached`). By
-   *  default the post lands in the thread of the message that last
-   *  addressed the session from that channel (the room when none);
-   *  `threadRootId` overrides it — must be a root message in the channel
-   *  (400 `invalid_thread_root`). The post never triggers any turn. */
-  postSessionChannelMessage(
-    channelId: string,
-    input: { text: string; threadRootId?: string },
-  ): Promise<SessionChannelMessagePosted> {
-    return this.fetch<SessionChannelMessagePosted>(
-      `/api/v1/conversations/${encodeURIComponent(channelId)}/session-messages`,
-      { method: "POST", body: { text: input.text, ...(input.threadRootId ? { threadRootId: input.threadRootId } : {}) } },
-    );
-  }
-
   /** Message ANOTHER session's conversation AS the calling session
    *  (`agentc session message @alias`). Session toolbelt credential ONLY —
    *  the sender resolves from the key. `target` is an @alias (team-scoped)
@@ -1095,19 +1173,88 @@ export class AgentComposeClient {
    *  background-work busy lease: while it is live, the between-turns
    *  park/suspend leaves the session's VM running so work the turn left
    *  behind keeps executing. The lease lapses on its own — re-hold to
-   *  extend past `minutes` (server-capped). Write-tier. */
-  holdBackgroundWork(conversationId: string, input?: { minutes?: number }): Promise<BackgroundWorkHeld> {
+   *  extend past `minutes` (server-capped). `children` descriptors
+   *  ({pid, journalPath, label}) register the DETACHED processes the hold
+   *  vouches for, so the platform can verify and reattach them after a
+   *  park (task #63). Write-tier. */
+  holdBackgroundWork(
+    conversationId: string,
+    input?: { minutes?: number; children?: BackgroundWorkChildDecl[] },
+  ): Promise<BackgroundWorkHeld> {
     return this.fetch<BackgroundWorkHeld>(
       `/api/v1/conversations/${encodeURIComponent(conversationId)}/background-work`,
-      { method: "POST", body: { ...(input?.minutes !== undefined ? { minutes: input.minutes } : {}) } },
+      { method: "POST", body: {
+        ...(input?.minutes !== undefined ? { minutes: input.minutes } : {}),
+        ...(input?.children !== undefined ? { children: input.children } : {}),
+      } },
+    );
+  }
+
+  // ── Session waits (owner ruling 2026-09-23: no watch runs inside a session
+  // sandbox). The session declares what it waits for and ends its turn; the
+  // platform senses the arrival and wakes it. Own-session key posture. ─────
+
+  /** Declare one wait (`agentc wait`): `POST /sessions/:id/waits`. */
+  createSessionWait(conversationId: string, input: CreateSessionWaitInput): Promise<SessionWaitCreated> {
+    return this.fetch<SessionWaitCreated>(
+      `/api/v1/sessions/${encodeURIComponent(conversationId)}/waits`,
+      { method: "POST", body: input },
+    );
+  }
+
+  /** This session's waits, newest first; open only unless `all`. */
+  listSessionWaits(conversationId: string, opts: { all?: boolean } = {}): Promise<SessionWaitList> {
+    const q = opts.all ? "?all=1" : "";
+    return this.fetch<SessionWaitList>(`/api/v1/sessions/${encodeURIComponent(conversationId)}/waits${q}`);
+  }
+
+  /** Cancel an open wait (`agentc wait cancel`): open -> cancelled. */
+  cancelSessionWait(conversationId: string, waitId: string): Promise<SessionWait> {
+    return this.fetch<SessionWait>(
+      `/api/v1/sessions/${encodeURIComponent(conversationId)}/waits/${encodeURIComponent(waitId)}`,
+      { method: "DELETE" },
+    );
+  }
+
+  /** Request ONE machine size up for a cloud session (task #110 — the
+   *  auto-resize policy's agent door). The platform arbitrates: within the
+   *  team's daily cap the upsize is auto-granted (and executes the moment
+   *  no live turn / background work holds the machine — home essentials
+   *  carry over); past the cap it becomes an owner approval card.
+   *  Deliberately not `resize`: the in-sandbox toolbelt key may call THIS,
+   *  because the kill only ever happens under platform policy or human
+   *  approval. Refusals (memory ceiling, template-pinned, ended) arrive as
+   *  HTTP 409s carrying `code`. Write-tier. */
+  requestMachineUpsize(
+    conversationId: string, input?: { reason?: string },
+  ): Promise<MachineUpsizeOutcome> {
+    return this.fetch<MachineUpsizeOutcome>(
+      `/api/v1/conversations/${encodeURIComponent(conversationId)}/machine/request-upsize`,
+      { method: "POST", body: input?.reason ? { reason: input.reason } : {} },
+    );
+  }
+
+  /** The session's background-work status: the lease deadline, the declared
+   *  children, and the owed-report marker a mid-work park leaves behind.
+   *  Read-tier. */
+  getBackgroundWork(conversationId: string): Promise<BackgroundWorkStatus> {
+    return this.fetch<BackgroundWorkStatus>(
+      `/api/v1/conversations/${encodeURIComponent(conversationId)}/background-work`,
     );
   }
 
   /** Release the session's background-work lease (the work finished).
-   *  Idempotent — `released` is false when no lease was held. */
-  async releaseBackgroundWork(conversationId: string): Promise<boolean> {
+   *  Idempotent — `released` is false when no lease was held. `pid` scopes
+   *  the release to ONE declared child (what a `--while-pid` holder passes
+   *  when its watched process dies): the child is pruned from the declared
+   *  registry, and the lease clears only when it was the last — a sibling's
+   *  death never erases the other holders' declarations. */
+  async releaseBackgroundWork(
+    conversationId: string, opts?: { pid?: number },
+  ): Promise<boolean> {
+    const pidQuery = opts?.pid !== undefined ? `?pid=${encodeURIComponent(opts.pid)}` : "";
     const body = await this.fetch<{ released: boolean }>(
-      `/api/v1/conversations/${encodeURIComponent(conversationId)}/background-work`,
+      `/api/v1/conversations/${encodeURIComponent(conversationId)}/background-work${pidQuery}`,
       { method: "DELETE" },
     );
     return body.released;
@@ -1168,17 +1315,30 @@ export class AgentComposeClient {
     return new Uint8Array(buf);
   }
 
+  /** Where ONE path's current version lives for a session
+   *  (`GET /conversations/:id/changes/file`): `main` when the main drive
+   *  holds the session branch's version (landed, or never changed on the
+   *  branch), else `branch` with `why` naming what keeps it off main. The
+   *  answer a `file:<path>?session=<id>` link resolves when it is opened.
+   *  404 = missing path or no access (uniform, no existence oracle). */
+  getSessionFilePlane(conversationId: string, path: string): Promise<SessionFilePlane> {
+    const q = new URLSearchParams({ path });
+    return this.fetch<SessionFilePlane>(
+      `/api/v1/conversations/${encodeURIComponent(conversationId)}/changes/file?${q}`,
+    );
+  }
+
   /** Publish a diff review's WHOLE document — prose notes plus structured
    *  suggestions, FULL REPLACE on every call (`POST
    *  /conversations/:id/review-notes`; `agentc review publish`). Callable
-   *  ONLY with the bound review session's own toolbelt credential — any
-   *  other key (another session, a human cookie, a plain API key) refuses
-   *  403. `conversationId` is the REVIEWED session's conversation (in a
-   *  review sandbox: `AGENT_COMPOSE_REVIEW_OF_CONVERSATION_ID`).
+   *  ONLY with the toolbelt credential of a review session spawned for this
+   *  diff, which replaces its own document — any other key (another
+   *  session, a human cookie, a plain API key) refuses 403.
+   *  `conversationId` is the REVIEWED session's conversation (in a review
+   *  sandbox: `AGENT_COMPOSE_REVIEW_OF_CONVERSATION_ID`).
    *
-   *  Failures: 403 `session_credential_required` | `not_review_session` |
-   *  `review_superseded` (a newer review replaced this one); 400
-   *  `suggestion_path_not_in_change_set` (naming the offenders); 409
+   *  Failures: 403 `session_credential_required` | `not_review_session`;
+   *  400 `suggestion_path_not_in_change_set` (naming the offenders); 409
    *  `review_disabled`. */
   publishReviewNotes(
     conversationId: string,
@@ -1214,6 +1374,43 @@ export class AgentComposeClient {
     );
   }
 
+  /** Mint a short-lived native-git credential for a linked repo's MIRROR
+   *  namespace (`POST /:slug/repo-links/:id/git-credential`, git-door
+   *  slice 4). mode "fetch" (default) reads the mirror — gated on link
+   *  visibility; mode "mirror" pushes real GitHub history through the
+   *  closure-verified door — gated on the repo_link WRITE capability.
+   *  409 `git_remote_unavailable` when no git plane serves the factory. */
+  getRepoLinkGitCredential(linkId: string, opts?: { mode?: "fetch" | "mirror" | "github" | "native"; factorySlug?: string }):
+    Promise<{
+      url: string; username: string; password: string; repoUrl: string;
+      /** Absent in `github` mode (the credential targets github.com, not the platform git plane). */
+      namespace?: string; expiresAt: string; mode: string;
+      /** `github` mode only: the host the credential is for. */
+      host?: string;
+      /** `github` mode only: the token's ceiling — "write" (contents:write,
+       *  push-capable) for viewers with write capability on the link,
+       *  "read" (clone/fetch only) otherwise. */
+      access?: "read" | "write";
+      /** `github` mode only: the GRANTED permission map GitHub echoed at
+       *  mint (e.g. `{contents:"write", pulls:"write"}`). A capability
+       *  missing here (pulls, issues) means the App installation does not
+       *  carry it — the OWNER must widen the installation; retrying can
+       *  never help. */
+      permissions?: Record<string, string>;
+      /** `github` mode only: the INSTALLATION's recorded grant ledger
+       *  (`key:level` strings, probe-synced). A capability present here
+       *  but missing from `permissions` is a platform downscope; missing
+       *  from both layers, an App-installation gap only the owner can
+       *  widen. Empty = not yet recorded (reconnect or next probe). */
+      installationScopes?: string[];
+    }> {
+    const slug = opts?.factorySlug ?? DEFAULT_FACTORY;
+    return this.fetch(
+      `/api/v1/factories/${encodeURIComponent(slug)}/repo-links/${encodeURIComponent(linkId)}/git-credential`,
+      { method: "POST", body: JSON.stringify({ mode: opts?.mode ?? "fetch" }), headers: { "content-type": "application/json" } },
+    );
+  }
+
   /** Approve the session's proposed changes: 3-way merge its branch into
    *  `main`, then continue the session on a fresh branch off post-merge
    *  `main`. Write-tier + human caller. Pass `opts.branch` (the branch you
@@ -1224,9 +1421,14 @@ export class AgentComposeClient {
    *  converged on) a kind='merge' approval routed to the session's
    *  approvers. Discriminate on `object`.
    *
-   *  Failures: 403 `role_read_only` (read-only member) or a plain 403 for
-   *  session toolbelt keys (agents cannot self-approve); 409 `turn_active`
-   *  (a turn is running — retry when idle) | `branch_changed`; 400
+   *  Failures: 403 `role_read_only` (read-only member); 403 `not_own_branch`
+   *  (a session toolbelt key merges ONLY its own bound session's branch —
+   *  the agent self-merge door, owner ruling 2026-08-31); 403 `merge_gated`
+   *  (a gated session's self-merge — a designated approver merges from the
+   *  Changes panel instead, and no card is minted); 409 `turn_active` (a
+   *  turn is running — retry when idle; a session's OWN self-merge is
+   *  exempt) | `branch_changed` | `branch_claimed` (a teammate session
+   *  holds the branch claim — merge after it releases); 400
    *  `no_branch` (session predates branching); 502 `quiesce_failed`
    *  (nothing changed — safe to retry) | `merge_failed` (branch retained,
    *  named in the body) | `rebranch_failed` (merge landed; retry safe). */
@@ -1290,24 +1492,6 @@ export class AgentComposeClient {
     );
   }
 
-  /** Arm/disarm the OPT-IN main-advance auto-rebase reflex for a session
-   *  (default OFF): when armed and the drive's main moves, the platform
-   *  preflights and — only on a provably clean fold (zero conflicts) —
-   *  rebases the session's branch from main headlessly, posting a quiet
-   *  receipt. Trade-off (why default OFF): the agent's view of files it
-   *  did not touch can change mid-task. Human, write-tier act.
-   *
-   *  Failures: 409 `review_session_scratch` | `plane_unsupported`; 403
-   *  (needs a user-bound human caller with write access). */
-  setSessionAutoRebase(
-    conversationId: string, enabled: boolean,
-  ): Promise<SessionAutoRebaseState> {
-    return this.fetch<SessionAutoRebaseState>(
-      `/api/v1/conversations/${encodeURIComponent(conversationId)}/changes/autorebase`,
-      { method: "POST", body: { enabled } },
-    );
-  }
-
   // ── Conversation membership (ADR-0045) ────────────────────────────────────
   // Channel rosters carry roles (`owner > write > read`). Inviting is a
   // `write` action; removing and re-roling are `owner` (or team admin)
@@ -1336,8 +1520,10 @@ export class AgentComposeClient {
     return body.members;
   }
 
-  /** Remove a member (conversation `owner` or team admin only).
-   *  Throws 400 `last_owner` when the target is the roster's last owner. */
+  /** Remove a member (conversation `owner` or team admin), or leave the
+   *  chat yourself: `userId` "me" (or your own id) is the self-leave door.
+   *  Throws 400 `last_owner` when the target is the roster's last owner and
+   *  400 `creator_cannot_leave` when the chat's creator tries to leave it. */
   async removeConversationMember(conversationId: string, userId: string): Promise<ConversationMember[]> {
     const body = await this.fetch<{ members: ConversationMember[] }>(
       `/api/v1/conversations/${encodeURIComponent(conversationId)}/members/${encodeURIComponent(userId)}`,
@@ -1497,6 +1683,13 @@ export class AgentComposeClient {
     };
   }
 
+  /** The credential's user role on the active team; null for a creator-less
+   * key or a user with no membership. */
+  async getTeamRole(): Promise<string | null> {
+    const body = await this.fetch<{ role: string | null }>("/api/v1/team/role");
+    return body.role;
+  }
+
   /** List the human members of your team — the people you (or an agent) can
    *  @-flag with `createMentions`. Each row's `userId` is what
    *  `mentionedUserIds` expects. */
@@ -1682,9 +1875,16 @@ export class AgentComposeClient {
 
   /** Rename a project (requires `write` role). */
   async renameProject(id: string, name: string): Promise<Project> {
+    return this.updateProject(id, { name });
+  }
+
+  /** Change a project's name, tier, description or dates (one PATCH; see
+   *  ProjectUpdate for who may set what). 400 `date_order` when the target
+   *  date would come before the start date. */
+  async updateProject(id: string, patch: ProjectUpdate): Promise<Project> {
     const body = await this.fetch<{ project: Project }>(
       `/api/v1/projects/${encodeURIComponent(id)}`,
-      { method: "PATCH", body: { name } },
+      { method: "PATCH", body: patch },
     );
     return body.project;
   }
@@ -1718,7 +1918,11 @@ export class AgentComposeClient {
     return body.members;
   }
 
-  /** Remove a member — project owner/team admin, or self-leave. Throws 400
+  /** Remove a member — project owner/team admin, or self-leave (`me`).
+   *  Leaving a project takes its chats with it: the person loses their row
+   *  in every chat filed in the project, public and private, except a chat
+   *  they reach through another project they remain in, the home room, a
+   *  chat they created, and a chat they are the last owner of. Throws 400
    *  `last_owner` when the target is the roster's last owner. */
   async removeProjectMember(id: string, userId: string): Promise<ProjectMember[]> {
     const body = await this.fetch<{ members: ProjectMember[] }>(
@@ -1728,6 +1932,14 @@ export class AgentComposeClient {
     return body.members;
   }
 
+  /** What leaving the project would take from the caller: the chats they
+   *  lose with it, and the project's shared files and folders. */
+  async leaveProjectPreview(id: string): Promise<{ chats: number; files: number }> {
+    return this.fetch<{ chats: number; files: number }>(
+      `/api/v1/projects/${encodeURIComponent(id)}/leave-preview`,
+    );
+  }
+
   /** Change a member's role (project owner or team admin). Throws 400
    *  `last_owner` when demoting the roster's last owner. */
   async setProjectMemberRole(
@@ -1742,15 +1954,56 @@ export class AgentComposeClient {
     return body.members;
   }
 
-  /** List a project's objects (member only), newest first. Cursor-paginated. */
-  listProjectObjects(id: string, opts?: { cursor?: string }): Promise<ProjectObjectsPage> {
+  /** List a project's objects (member only), newest first. Cursor-paginated.
+   *  `type` narrows to one object kind at the server, under the same
+   *  cursor — `"conversation"` is a project's chats alone, however many
+   *  files it holds. */
+  listProjectObjects(id: string, opts?: { cursor?: string; type?: ProjectObject["type"] }): Promise<ProjectObjectsPage> {
     const q = new URLSearchParams();
     if (opts?.cursor) q.set("cursor", opts.cursor);
+    if (opts?.type) q.set("type", opts.type);
     return this.fetch<ProjectObjectsPage>(
       `/api/v1/projects/${encodeURIComponent(id)}/objects${q.toString() ? `?${q}` : ""}`,
     );
   }
 
+  /** How many objects of each kind the project holds for the caller
+   *  (member only): the whole project's counts, where a page of
+   *  `listProjectObjects` holds at most fifty. */
+  getProjectObjectCounts(id: string): Promise<ProjectObjectCounts> {
+    return this.fetch<ProjectObjectCounts>(`/api/v1/projects/${encodeURIComponent(id)}/objects/counts`);
+  }
+
+  /** The project status view (member only): its outcome threads with their
+   *  plans, workers, people and next dates, the project's progress, finish
+   *  line and next check-in, and what moved lately. `threads` is
+   *  cursor-paginated; `recentlyClosed` rides the first page. */
+  getProjectStatus(id: string, opts?: { cursor?: string; limit?: number }): Promise<ProjectStatus> {
+    const q = new URLSearchParams();
+    if (opts?.cursor) q.set("cursor", opts.cursor);
+    if (opts?.limit) q.set("limit", String(opts.limit));
+    return this.fetch<ProjectStatus>(
+      `/api/v1/projects/${encodeURIComponent(id)}/status${q.toString() ? `?${q}` : ""}`,
+    );
+  }
+
+  /** One thread's status for the inline expansion of a status row: its
+   *  summary, workers by state, to-dos and last events. 404 for a thread
+   *  the caller cannot read. */
+  getThreadStatus(threadId: string): Promise<ThreadStatus> {
+    return this.fetch<ThreadStatus>(`/api/v1/threads/${encodeURIComponent(threadId)}/status`);
+  }
+
+  /** The caller's personal status in the current workspace: the threads
+   *  relevant to them (posted, mentioned, asked, a to-do, or in the chat),
+   *  grouped client-side by project. `threads` is cursor-paginated. */
+  getMeStatus(opts?: { cursor?: string; limit?: number }): Promise<MeStatus> {
+    const q = new URLSearchParams();
+    if (opts?.cursor) q.set("cursor", opts.cursor);
+    if (opts?.limit) q.set("limit", String(opts.limit));
+    return this.fetch<MeStatus>(`/api/v1/me/status${q.toString() ? `?${q}` : ""}`);
+  }
+
   /** DRY-RUN preview of a session add: the files that WOULD be shared (from
    *  the caller's owned scopes) + any owned-but-skipped entries (paths
    *  concealed from the caller are omitted). Powers the consent dialog. Same
@@ -1914,6 +2167,28 @@ export class AgentComposeClient {
     return body.links;
   }
 
+  /** Create a repo whose origin IS Agent Compose (`manage` scope) — no
+   *  GitHub behind it; clone/fetch/push ride the platform git door. 409
+   *  names the missing prerequisite (graph drive, git plane) or an
+   *  overlapping placement. */
+  async createNativeRepo(
+    input: CreateNativeRepoInput, opts?: { factorySlug?: string },
+  ): Promise<CreateNativeRepoResult> {
+    const slug = opts?.factorySlug ?? DEFAULT_FACTORY;
+    return this.fetch<CreateNativeRepoResult>(
+      `/api/v1/factories/${encodeURIComponent(slug)}/repo-links/native`,
+      { method: "POST", body: input });
+  }
+
+  /** The caller's own connector grants and the workspace's GitHub
+   *  installations (metadata only — never tokens; a teammate's other
+   *  accounts never come back). Used by `agentc repos link` to default
+   *  `--grant` when the team holds exactly one active GitHub grant. */
+  async listConnectorGrants(): Promise<ConnectorGrantSummary[]> {
+    const body = await this.fetch<{ data: ConnectorGrantSummary[] }>("/api/v1/connectors");
+    return body.data;
+  }
+
   /** Unlink (§6.3: the prefix's files and history stay on the drive). */
   deleteRepoLink(linkId: string, opts?: { factorySlug?: string }): Promise<void> {
     const slug = opts?.factorySlug ?? DEFAULT_FACTORY;
@@ -1986,26 +2261,89 @@ export class AgentComposeClient {
    *  toolbelt credential (the in-sandbox agent's door) or by a session
    *  writer. */
   requestSessionSecrets(
-    conversationId: string, keys: string[], opts?: { reason?: string },
+    conversationId: string, keys: string[],
+    opts?: {
+      reason?: string; setLabel?: string; kind?: VaultRequestKind; shapes?: Record<string, VaultKeyShape>;
+      savedEntry?: RequestedVaultEntry;
+      /** A REPLACEMENT: the keys are held already and did not work; the card
+       *  asks for a new value of the same key. */
+      replace?: boolean;
+      /** A different credential of a kind the work already holds under
+       *  another name (the server refuses such an ask without it). */
+      distinct?: boolean;
+    },
   ): Promise<SessionSecretRequestCreated> {
     return this.fetch(
       `/api/v1/conversations/${encodeURIComponent(conversationId)}/secret-requests`,
-      { method: "POST", body: { keys, ...(opts?.reason ? { reason: opts.reason } : {}) } });
+      { method: "POST", body: {
+        keys,
+        ...(opts?.reason ? { reason: opts.reason } : {}),
+        // Suggested batch name — prefills the vault form's save-as-set label.
+        ...(opts?.setLabel ? { setLabel: opts.setLabel } : {}),
+        // WHAT KIND of credential — the vault page leads with the user's
+        // matching STANDING entries (personal-vault reuse, 2026-08-31).
+        ...(opts?.kind ? { kind: opts.kind } : {}),
+        // WHICH standing entry — by label and/or a card's last four — so the
+        // card and the vault page lead with that exact one.
+        ...(opts?.savedEntry ? { savedEntry: opts.savedEntry } : {}),
+        // Per-key DELIVERY (brokered onto a host, or injected) — required
+        // for every key of an api_key ask.
+        ...(opts?.shapes ? { shapes: opts.shapes } : {}),
+        ...(opts?.replace ? { replace: true } : {}),
+        ...(opts?.distinct ? { distinct: true } : {}),
+      } });
+  }
+
+  /** The session's STANDING-vault catalog (2026-08-31): entries the vault
+   *  could grant to this session — labels, kinds, field NAMES, last-used.
+   *  Values are write-only and never on this wire. Query it BEFORE asking
+   *  the human for a credential: a matching entry means the ask is a GRANT
+   *  ask naming it, never a blank re-entry form. For the session's own key
+   *  it also carries `reaches`: what the session already reaches with no
+   *  credential asked for (`agentc access`), so a need met there is never
+   *  a vault ask. */
+  getSessionVaultCatalog(conversationId: string): Promise<{ entries: VaultCatalogEntry[]; note?: string; reaches?: string }> {
+    return this.fetch(
+      `/api/v1/conversations/${encodeURIComponent(conversationId)}/vault-catalog`);
   }
 
   /** Poll a vault link's status (`pending` → `fulfilled`; `expired` when the
-   *  clock ran out). The in-sandbox `agentc secrets request --wait` loop. */
+   *  clock ran out; `cancelled` when the human denied it or the requester
+   *  withdrew it — attribution rides the answer). The in-sandbox
+   *  `agentc secrets session request --wait` loop. */
   getSessionSecretRequest(conversationId: string, requestId: string): Promise<SessionSecretRequestStatus> {
     return this.fetch(
       `/api/v1/conversations/${encodeURIComponent(conversationId)}/secret-requests/${encodeURIComponent(requestId)}`);
   }
 
+  /** List a session's OPEN vault requests (pending + unexpired), newest
+   *  first — receipts only (keys, reason, clocks). The cancel verb's
+   *  `--all` enumeration. */
+  async listSessionSecretRequests(conversationId: string): Promise<SessionSecretRequestSummary[]> {
+    const body = await this.fetch<{ requests: SessionSecretRequestSummary[] }>(
+      `/api/v1/conversations/${encodeURIComponent(conversationId)}/secret-requests`);
+    return body.requests;
+  }
+
+  /** Cancel one vault request (task #111). The requesting agent withdraws
+   *  its own ask (session toolbelt key), or a session writer denies it.
+   *  409 `request_not_pending` when it already settled. */
+  cancelSessionSecretRequest(
+    conversationId: string, requestId: string, opts?: { reason?: string },
+  ): Promise<{ requestId: string; status: "cancelled" }> {
+    return this.fetch(
+      `/api/v1/conversations/${encodeURIComponent(conversationId)}/secret-requests/${encodeURIComponent(requestId)}/cancel`,
+      { method: "POST", body: { ...(opts?.reason ? { reason: opts.reason } : {}) } });
+  }
+
   // ── API keys ───────────────────────────────────────────────────────────────
   // Both endpoints require an admin-scoped key as the bearer token.
 
   /** Create a new API key on the caller's team. The plaintext `key` is
    *  returned once — it cannot be retrieved later.
    *
+   *  `scopes` omitted mints `read` alone; every scope asked for must be one
+   *  the caller holds (a key carries no more than whoever mints it).
    *  When `factorySlug` is set, the new key is restricted to that factory.
    *  Factory-scoped keys can only mint other keys bound to the same factory. */
   createApiKey(input: CreateApiKeyInput): Promise<ApiKeyCreated> {