@sealant/api-contracts-next 0.39.0-next.688 → 0.39.0-next.692

package/dist/core-api/control-plane.d.ts

@@ -641,6 +641,7 @@ export declare const ControlPlaneAPI: HttpApi.HttpApi<"sealantControlPlaneApi",
     readonly term: import("effect/Schema").optional<import("effect/Schema").String>;
     readonly mode: import("effect/Schema").optional<import("effect/Schema").Literals<readonly ["pty", "pipe"]>>;
     readonly metadata: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>;
+    readonly user: import("effect/Schema").optional<import("effect/Schema").String>;
 }>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
     readonly authorization: import("effect/Schema").optional<import("effect/Schema").String>;
 }>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
@@ -803,6 +804,9 @@ export declare const ControlPlaneAPI: HttpApi.HttpApi<"sealantControlPlaneApi",
     readonly version: import("effect/Schema").String;
     readonly docsPath: import("effect/Schema").String;
     readonly openApiPath: import("effect/Schema").String;
+    readonly features: import("effect/Schema").optional<import("effect/Schema").Struct<{
+        readonly processUser: import("effect/Schema").Boolean;
+    }>>;
 }>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<never>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"getSetupState", "GET", "/v1/system/setup-state", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
     readonly needsSetup: import("effect/Schema").Boolean;
     readonly sshGateway: import("effect/Schema").NullOr<import("effect/Schema").Struct<{
@@ -913,6 +917,7 @@ export declare const ControlPlaneAPI: HttpApi.HttpApi<"sealantControlPlaneApi",
         readonly args: import("effect/Schema").$Array<import("effect/Schema").String>;
         readonly cwd: import("effect/Schema").optional<import("effect/Schema").String>;
     }>>;
+    readonly user: import("effect/Schema").optional<import("effect/Schema").String>;
 }>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
     readonly runId: import("effect/Schema").String;
     readonly workspaceId: import("effect/Schema").String;
@@ -1024,6 +1029,13 @@ export declare const ControlPlaneAPI: HttpApi.HttpApi<"sealantControlPlaneApi",
         readonly reference: import("effect/Schema").String;
         readonly digestReference: import("effect/Schema").String;
         readonly digest: import("effect/Schema").String;
+        readonly personLayout: import("effect/Schema").optional<import("effect/Schema").Struct<{
+            readonly status: import("effect/Schema").Literals<readonly ["supported", "unsupported", "unknown"]>;
+            readonly missing: import("effect/Schema").$Array<import("effect/Schema").String>;
+            readonly unknown: import("effect/Schema").$Array<import("effect/Schema").String>;
+            readonly runtime: import("effect/Schema").String;
+            readonly acl: import("effect/Schema").Literals<readonly ["supported", "unsupported", "unknown"]>;
+        }>>;
     }>>;
     readonly error: import("effect/Schema").optional<import("effect/Schema").Struct<{
         readonly message: import("effect/Schema").String;
@@ -1154,7 +1166,32 @@ export declare const ControlPlaneAPI: HttpApi.HttpApi<"sealantControlPlaneApi",
         readonly status: import("effect/Schema").Literals<readonly ["pending", "running", "ready", "failed", "stopped"]>;
         readonly endpoint: import("effect/Schema").String;
     }>;
-}>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("./workspaces.js").WorkspaceUnauthorizedError | typeof import("./workspaces.js").WorkspaceNotFoundError | typeof import("./workspaces.js").WorkspaceConflictError | typeof import("./workspaces.js").WorkspaceServiceUnavailableError | typeof import("./workspaces.js").WorkspaceInternalServerError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"listWorkspaceAttempts", "GET", "/v1/workspaces/:workspaceId/attempts", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("./workspaces.js").WorkspaceUnauthorizedError | typeof import("./workspaces.js").WorkspaceNotFoundError | typeof import("./workspaces.js").WorkspaceConflictError | typeof import("./workspaces.js").WorkspaceServiceUnavailableError | typeof import("./workspaces.js").WorkspaceInternalServerError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"inspectWorkspaceImage", "POST", "/v1/workspaces/image", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
+    readonly ownerUserId: import("effect/Schema").String;
+    readonly registryId: import("effect/Schema").String;
+    readonly spec: import("effect/Schema").Unknown;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
+    readonly planHash: import("effect/Schema").String;
+    readonly publishedImage: import("effect/Schema").optional<import("effect/Schema").Struct<{
+        readonly reference: import("effect/Schema").String;
+        readonly digestReference: import("effect/Schema").String;
+        readonly digest: import("effect/Schema").String;
+        readonly personLayout: import("effect/Schema").optional<import("effect/Schema").Struct<{
+            readonly status: import("effect/Schema").Literals<readonly ["supported", "unsupported", "unknown"]>;
+            readonly missing: import("effect/Schema").$Array<import("effect/Schema").String>;
+            readonly unknown: import("effect/Schema").$Array<import("effect/Schema").String>;
+            readonly runtime: import("effect/Schema").String;
+            readonly acl: import("effect/Schema").Literals<readonly ["supported", "unsupported", "unknown"]>;
+        }>>;
+    }>>;
+    readonly personLayout: import("effect/Schema").Struct<{
+        readonly status: import("effect/Schema").Literals<readonly ["supported", "unsupported", "unknown"]>;
+        readonly missing: import("effect/Schema").$Array<import("effect/Schema").String>;
+        readonly unknown: import("effect/Schema").$Array<import("effect/Schema").String>;
+        readonly runtime: import("effect/Schema").String;
+        readonly acl: import("effect/Schema").Literals<readonly ["supported", "unsupported", "unknown"]>;
+    }>;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("./workspaces.js").WorkspaceBadRequestError | typeof import("./workspaces.js").WorkspaceNotFoundError | typeof import("./workspaces.js").WorkspaceInternalServerError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"listWorkspaceAttempts", "GET", "/v1/workspaces/:workspaceId/attempts", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
     readonly workspaceId: import("effect/Schema").String;
 }>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
     readonly ownerUserId: import("effect/Schema").optional<import("effect/Schema").String>;
@@ -1180,6 +1217,13 @@ export declare const ControlPlaneAPI: HttpApi.HttpApi<"sealantControlPlaneApi",
             readonly reference: import("effect/Schema").String;
             readonly digestReference: import("effect/Schema").String;
             readonly digest: import("effect/Schema").String;
+            readonly personLayout: import("effect/Schema").optional<import("effect/Schema").Struct<{
+                readonly status: import("effect/Schema").Literals<readonly ["supported", "unsupported", "unknown"]>;
+                readonly missing: import("effect/Schema").$Array<import("effect/Schema").String>;
+                readonly unknown: import("effect/Schema").$Array<import("effect/Schema").String>;
+                readonly runtime: import("effect/Schema").String;
+                readonly acl: import("effect/Schema").Literals<readonly ["supported", "unsupported", "unknown"]>;
+            }>>;
         }>>;
         readonly error: import("effect/Schema").optional<import("effect/Schema").Struct<{
             readonly message: import("effect/Schema").String;
@@ -1194,7 +1238,32 @@ export declare const ControlPlaneAPI: HttpApi.HttpApi<"sealantControlPlaneApi",
         readonly finishedAt: import("effect/Schema").optional<import("effect/Schema").String>;
         readonly durationMs: import("effect/Schema").optional<import("effect/Schema").Number>;
     }>>;
-}>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("./workspaces.js").WorkspaceBadRequestError | typeof import("./workspaces.js").WorkspaceNotFoundError | typeof import("./workspaces.js").WorkspaceInternalServerError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"listWorkspaceEvents", "GET", "/v1/workspaces/:workspaceId/events", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("./workspaces.js").WorkspaceBadRequestError | typeof import("./workspaces.js").WorkspaceNotFoundError | typeof import("./workspaces.js").WorkspaceInternalServerError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"listWorkspaceCredentials", "GET", "/v1/workspaces/:workspaceId/credentials", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
+    readonly workspaceId: import("effect/Schema").String;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
+    readonly ownerUserId: import("effect/Schema").String;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
+    readonly workspaceId: import("effect/Schema").String;
+    readonly runId: import("effect/Schema").String;
+    readonly homes: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly home: import("effect/Schema").String;
+        readonly onBehalfOfUserId: import("effect/Schema").String;
+        readonly accounts: import("effect/Schema").Struct<{
+            readonly claude: import("effect/Schema").optional<import("effect/Schema").Struct<{
+                readonly connectedAccountId: import("effect/Schema").String;
+                readonly name: import("effect/Schema").String;
+            }>>;
+            readonly codex: import("effect/Schema").optional<import("effect/Schema").Struct<{
+                readonly connectedAccountId: import("effect/Schema").String;
+                readonly name: import("effect/Schema").String;
+            }>>;
+            readonly github: import("effect/Schema").optional<import("effect/Schema").Struct<{
+                readonly connectedAccountId: import("effect/Schema").String;
+                readonly name: import("effect/Schema").String;
+            }>>;
+        }>;
+    }>>;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("./workspaces.js").WorkspaceForbiddenError | typeof import("./workspaces.js").WorkspaceNotFoundError | typeof import("./workspaces.js").WorkspaceConflictError | typeof import("./workspaces.js").WorkspaceInternalServerError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"listWorkspaceEvents", "GET", "/v1/workspaces/:workspaceId/events", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
     readonly workspaceId: import("effect/Schema").String;
 }>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
     readonly ownerUserId: import("effect/Schema").optional<import("effect/Schema").String>;
@@ -1237,6 +1306,13 @@ export declare const ControlPlaneAPI: HttpApi.HttpApi<"sealantControlPlaneApi",
             readonly reference: import("effect/Schema").String;
             readonly digestReference: import("effect/Schema").String;
             readonly digest: import("effect/Schema").String;
+            readonly personLayout: import("effect/Schema").optional<import("effect/Schema").Struct<{
+                readonly status: import("effect/Schema").Literals<readonly ["supported", "unsupported", "unknown"]>;
+                readonly missing: import("effect/Schema").$Array<import("effect/Schema").String>;
+                readonly unknown: import("effect/Schema").$Array<import("effect/Schema").String>;
+                readonly runtime: import("effect/Schema").String;
+                readonly acl: import("effect/Schema").Literals<readonly ["supported", "unsupported", "unknown"]>;
+            }>>;
         }>>;
         readonly error: import("effect/Schema").optional<import("effect/Schema").Struct<{
             readonly message: import("effect/Schema").String;
@@ -1248,7 +1324,39 @@ export declare const ControlPlaneAPI: HttpApi.HttpApi<"sealantControlPlaneApi",
         readonly finishedAt: import("effect/Schema").optional<import("effect/Schema").String>;
         readonly expiresAt: import("effect/Schema").optional<import("effect/Schema").String>;
     }>>;
-}>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("./workspaces.js").WorkspaceBadRequestError | typeof import("./workspaces.js").WorkspaceInternalServerError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"recoverWorkspace", "POST", "/v1/workspaces/:workspaceId/recover", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("./workspaces.js").WorkspaceBadRequestError | typeof import("./workspaces.js").WorkspaceInternalServerError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"putWorkspaceCredentials", "POST", "/v1/workspaces/:workspaceId/credentials", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
+    readonly workspaceId: import("effect/Schema").String;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
+    readonly ownerUserId: import("effect/Schema").String;
+    readonly onBehalfOfUserId: import("effect/Schema").String;
+    readonly home: import("effect/Schema").String;
+    readonly uid: import("effect/Schema").optional<import("effect/Schema").Int>;
+    readonly gid: import("effect/Schema").optional<import("effect/Schema").Int>;
+    readonly claude: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").String>>;
+    readonly codex: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").String>>;
+    readonly github: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").String>>;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
+    readonly workspaceId: import("effect/Schema").String;
+    readonly runId: import("effect/Schema").String;
+    readonly home: import("effect/Schema").Struct<{
+        readonly home: import("effect/Schema").String;
+        readonly onBehalfOfUserId: import("effect/Schema").String;
+        readonly accounts: import("effect/Schema").Struct<{
+            readonly claude: import("effect/Schema").optional<import("effect/Schema").Struct<{
+                readonly connectedAccountId: import("effect/Schema").String;
+                readonly name: import("effect/Schema").String;
+            }>>;
+            readonly codex: import("effect/Schema").optional<import("effect/Schema").Struct<{
+                readonly connectedAccountId: import("effect/Schema").String;
+                readonly name: import("effect/Schema").String;
+            }>>;
+            readonly github: import("effect/Schema").optional<import("effect/Schema").Struct<{
+                readonly connectedAccountId: import("effect/Schema").String;
+                readonly name: import("effect/Schema").String;
+            }>>;
+        }>;
+    }>;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("./workspaces.js").WorkspaceBadRequestError | typeof import("./workspaces.js").WorkspaceForbiddenError | typeof import("./workspaces.js").WorkspaceNotFoundError | typeof import("./workspaces.js").WorkspaceConflictError | typeof import("./workspaces.js").WorkspaceBadGatewayError | typeof import("./workspaces.js").WorkspaceServiceUnavailableError | typeof import("./workspaces.js").WorkspaceInternalServerError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"recoverWorkspace", "POST", "/v1/workspaces/:workspaceId/recover", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
     readonly workspaceId: import("effect/Schema").String;
 }>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
     readonly ownerUserId: import("effect/Schema").String;
@@ -1256,7 +1364,17 @@ export declare const ControlPlaneAPI: HttpApi.HttpApi<"sealantControlPlaneApi",
     readonly workspaceId: import("effect/Schema").String;
     readonly state: import("effect/Schema").Literals<readonly ["requested", "not-retained"]>;
     readonly recoverable: import("effect/Schema").optional<import("effect/Schema").Boolean>;
-}>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("./workspaces.js").WorkspaceBadRequestError | typeof import("./workspaces.js").WorkspaceNotFoundError | typeof import("./workspaces.js").WorkspaceConflictError | typeof import("./workspaces.js").WorkspaceInternalServerError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"renameWorkspace", "PATCH", "/v1/workspaces/:workspaceId/name", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("./workspaces.js").WorkspaceBadRequestError | typeof import("./workspaces.js").WorkspaceNotFoundError | typeof import("./workspaces.js").WorkspaceConflictError | typeof import("./workspaces.js").WorkspaceInternalServerError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"releaseWorkspaceCredentials", "DELETE", "/v1/workspaces/:workspaceId/credentials", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
+    readonly workspaceId: import("effect/Schema").String;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
+    readonly ownerUserId: import("effect/Schema").String;
+    readonly home: import("effect/Schema").String;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<never>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
+    readonly workspaceId: import("effect/Schema").String;
+    readonly runId: import("effect/Schema").String;
+    readonly home: import("effect/Schema").String;
+    readonly released: import("effect/Schema").Boolean;
+}>>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<typeof import("./workspaces.js").WorkspaceBadRequestError | typeof import("./workspaces.js").WorkspaceForbiddenError | typeof import("./workspaces.js").WorkspaceNotFoundError | typeof import("./workspaces.js").WorkspaceConflictError | typeof import("./workspaces.js").WorkspaceBadGatewayError | typeof import("./workspaces.js").WorkspaceServiceUnavailableError | typeof import("./workspaces.js").WorkspaceInternalServerError>, never, never> | import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"renameWorkspace", "PATCH", "/v1/workspaces/:workspaceId/name", import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<import("effect/Schema").Struct<{
     readonly workspaceId: import("effect/Schema").String;
 }>>, import("effect/unstable/httpapi/HttpApiEndpoint").StringTree<never>, import("effect/unstable/httpapi/HttpApiEndpoint").Json<import("effect/Schema").Struct<{
     readonly name: import("effect/Schema").String;

package/dist/core-api/sessions.d.ts

@@ -30,6 +30,18 @@ export type SessionAuthorizationHeaders = typeof sessionAuthorizationHeadersSche
  */
 export declare const sessionModeSchema: Schema.Literals<readonly ["pty", "pipe"]>;
 export type SessionMode = typeof sessionModeSchema.Type;
+/**
+ * The Linux user a process runs as (Mend ADR 0016): a user name of the image's passwd, or a numeric
+ * uid. The process takes its uid, gid, supplementary groups and `HOME`, `USER`, `LOGNAME` and
+ * `SHELL` from the passwd entry, umask 0002. Absent: the workspace's own user, as before.
+ */
+export declare const workspaceProcessUserSchema: Schema.String;
+export type WorkspaceProcessUser = typeof workspaceProcessUserSchema.Type;
+/**
+ * The stable `code` a create or exec answers while no workspace runtime can start a process as
+ * another user: Core asks sealantd to, and no released sealantd does yet. Nothing is started.
+ */
+export declare const PROCESS_USER_UNSUPPORTED_CODE = "user-unsupported";
 export declare const createSessionRequestSchema: Schema.Struct<{
     readonly workspaceId: Schema.String;
     readonly ownerUserId: Schema.String;
@@ -46,6 +58,8 @@ export declare const createSessionRequestSchema: Schema.Struct<{
     readonly mode: Schema.optional<Schema.Literals<readonly ["pty", "pipe"]>>;
     /** Opaque caller correlation bag: stored verbatim, echoed on reads, no platform semantics. */
     readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    /** Run the session's process as this Linux user (see `workspaceProcessUserSchema`). */
+    readonly user: Schema.optional<Schema.String>;
 }>;
 export type CreateSessionRequest = typeof createSessionRequestSchema.Type;
 export declare const sessionSchema: Schema.Struct<{
@@ -185,6 +199,8 @@ export declare class SessionNotFoundError extends SessionNotFoundError_base {
 }
 declare const SessionConflictError_base: Schema.Class<SessionConflictError, Schema.TaggedStruct<"SessionConflictError", {
     readonly message: Schema.String;
+    /** A stable reason, where one applies (`user-unsupported`). */
+    readonly code: Schema.optional<Schema.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class SessionConflictError extends SessionConflictError_base {
 }
@@ -245,6 +261,8 @@ export declare const SessionsGroup: HttpApiGroup.HttpApiGroup<"sessions", HttpAp
     readonly mode: Schema.optional<Schema.Literals<readonly ["pty", "pipe"]>>;
     /** Opaque caller correlation bag: stored verbatim, echoed on reads, no platform semantics. */
     readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    /** Run the session's process as this Linux user (see `workspaceProcessUserSchema`). */
+    readonly user: Schema.optional<Schema.String>;
 }>>, HttpApiEndpoint.StringTree<Schema.Struct<{
     readonly authorization: Schema.optional<Schema.String>;
 }>>, HttpApiEndpoint.Json<Schema.Struct<{

package/dist/core-api/sessions.js

@@ -28,6 +28,17 @@ export const sessionAuthorizationHeadersSchema = Schema.Struct({
  * rejected.
  */
 export const sessionModeSchema = Schema.Literals(["pty", "pipe"]);
+/**
+ * The Linux user a process runs as (Mend ADR 0016): a user name of the image's passwd, or a numeric
+ * uid. The process takes its uid, gid, supplementary groups and `HOME`, `USER`, `LOGNAME` and
+ * `SHELL` from the passwd entry, umask 0002. Absent: the workspace's own user, as before.
+ */
+export const workspaceProcessUserSchema = Schema.String.check(Schema.isPattern(/^(?:[a-z_][a-z0-9_-]{0,31}|[0-9]{1,10})$/));
+/**
+ * The stable `code` a create or exec answers while no workspace runtime can start a process as
+ * another user: Core asks sealantd to, and no released sealantd does yet. Nothing is started.
+ */
+export const PROCESS_USER_UNSUPPORTED_CODE = "user-unsupported";
 export const createSessionRequestSchema = Schema.Struct({
     workspaceId: NonEmptyString,
     ownerUserId: NonEmptyString,
@@ -44,6 +55,8 @@ export const createSessionRequestSchema = Schema.Struct({
     mode: Schema.optional(sessionModeSchema),
     /** Opaque caller correlation bag: stored verbatim, echoed on reads, no platform semantics. */
     metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+    /** Run the session's process as this Linux user (see `workspaceProcessUserSchema`). */
+    user: Schema.optional(workspaceProcessUserSchema),
 });
 export const sessionSchema = Schema.Struct({
     sessionId: NonEmptyString,
@@ -129,7 +142,11 @@ export class SessionForbiddenError extends Schema.TaggedErrorClass()("SessionFor
 }
 export class SessionNotFoundError extends Schema.TaggedErrorClass()("SessionNotFoundError", { message: Schema.String }, { httpApiStatus: 404 }) {
 }
-export class SessionConflictError extends Schema.TaggedErrorClass()("SessionConflictError", { message: Schema.String }, { httpApiStatus: 409 }) {
+export class SessionConflictError extends Schema.TaggedErrorClass()("SessionConflictError", {
+    message: Schema.String,
+    /** A stable reason, where one applies (`user-unsupported`). */
+    code: Schema.optional(NonEmptyString),
+}, { httpApiStatus: 409 }) {
 }
 export class SessionBadGatewayError extends Schema.TaggedErrorClass()("SessionBadGatewayError", { message: Schema.String }, { httpApiStatus: 502 }) {
 }

package/dist/core-api/system.d.ts

@@ -5,6 +5,14 @@ export declare const systemIndexResponseSchema: Schema.Struct<{
     readonly version: Schema.String;
     readonly docsPath: Schema.String;
     readonly openApiPath: Schema.String;
+    /**
+     * What this control plane can do that an older one cannot, so a client refuses a request it would
+     * otherwise send to a server that ignores part of it. Absent from older control planes: nothing.
+     */
+    readonly features: Schema.optional<Schema.Struct<{
+        /** A process can run as a given Linux user (`user` on exec and sessions). */
+        readonly processUser: Schema.Boolean;
+    }>>;
 }>;
 export type SystemIndexResponse = typeof systemIndexResponseSchema.Type;
 export declare const systemHealthResponseSchema: Schema.Struct<{
@@ -36,6 +44,14 @@ export declare const SystemGroup: HttpApiGroup.HttpApiGroup<"system", HttpApiEnd
     readonly version: Schema.String;
     readonly docsPath: Schema.String;
     readonly openApiPath: Schema.String;
+    /**
+     * What this control plane can do that an older one cannot, so a client refuses a request it would
+     * otherwise send to a server that ignores part of it. Absent from older control planes: nothing.
+     */
+    readonly features: Schema.optional<Schema.Struct<{
+        /** A process can run as a given Linux user (`user` on exec and sessions). */
+        readonly processUser: Schema.Boolean;
+    }>>;
 }>>, HttpApiEndpoint.Json<never>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getSetupState", "GET", "/v1/system/setup-state", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
     readonly needsSetup: Schema.Boolean;
     readonly sshGateway: Schema.NullOr<Schema.Struct<{

package/dist/core-api/system.js

@@ -6,6 +6,14 @@ export const systemIndexResponseSchema = Schema.Struct({
     version: NonEmptyString,
     docsPath: NonEmptyString,
     openApiPath: NonEmptyString,
+    /**
+     * What this control plane can do that an older one cannot, so a client refuses a request it would
+     * otherwise send to a server that ignores part of it. Absent from older control planes: nothing.
+     */
+    features: Schema.optional(Schema.Struct({
+        /** A process can run as a given Linux user (`user` on exec and sessions). */
+        processUser: Schema.Boolean,
+    })),
 });
 export const systemHealthResponseSchema = Schema.Struct({
     status: Schema.Literal("ok"),

package/dist/core-api/workspaces.d.ts

@@ -47,10 +47,48 @@ export declare const workspaceSshTargetSchema: Schema.Struct<{
     }>;
 }>;
 export type WorkspaceSshTarget = typeof workspaceSshTargetSchema.Type;
+/**
+ * Whether an image can run Mend's per-person layout on a runtime (Mend ADR 0016): the verdict of
+ * the image build's probe (`metadata.imageProbe`: setuid `sudo` and a usable sudoers rule,
+ * `useradd`, `setfacl`, `setpriv`, `flock`, a writable passwd, the `mend` group and the reserved
+ * ids, and what its sealantd reports), the runtime's `no_new_privs` (Kubernetes), and ACLs on
+ * `/workspace` as the operator declares them (`SEALANT_WORKSPACE_ACLS`). What is not known is
+ * `unknown`, never `supported`.
+ */
+export declare const workspaceImagePersonLayoutSchema: Schema.Struct<{
+    readonly status: Schema.Literals<readonly ["supported", "unsupported", "unknown"]>;
+    /**
+     * Stable codes of what the image or the runtime lacks (`setuid-sudo`, `sudo-no-new-privileges`,
+     * `useradd`, `setpriv`, `flock`, `reserved-ids`, `sealantd:<capability>`, `acl`, …).
+     */
+    readonly missing: Schema.$Array<Schema.String>;
+    /** What could not be read: `probe` (an image built before the probe), `sealantd`, `flock`, `acl`. */
+    readonly unknown: Schema.$Array<Schema.String>;
+    /** The runtime the answer is for: the workspace's, or the deployment's default before create. */
+    readonly runtime: Schema.String;
+    /** ACLs on that runtime's `/workspace`, as the operator declared them. */
+    readonly acl: Schema.Literals<readonly ["supported", "unsupported", "unknown"]>;
+}>;
+export type WorkspaceImagePersonLayout = typeof workspaceImagePersonLayoutSchema.Type;
 export declare const workspacePublishedImageSchema: Schema.Struct<{
     readonly reference: Schema.String;
     readonly digestReference: Schema.String;
     readonly digest: Schema.String;
+    /** Absent from control planes before the per-person capability. */
+    readonly personLayout: Schema.optional<Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["supported", "unsupported", "unknown"]>;
+        /**
+         * Stable codes of what the image or the runtime lacks (`setuid-sudo`, `sudo-no-new-privileges`,
+         * `useradd`, `setpriv`, `flock`, `reserved-ids`, `sealantd:<capability>`, `acl`, …).
+         */
+        readonly missing: Schema.$Array<Schema.String>;
+        /** What could not be read: `probe` (an image built before the probe), `sealantd`, `flock`, `acl`. */
+        readonly unknown: Schema.$Array<Schema.String>;
+        /** The runtime the answer is for: the workspace's, or the deployment's default before create. */
+        readonly runtime: Schema.String;
+        /** ACLs on that runtime's `/workspace`, as the operator declared them. */
+        readonly acl: Schema.Literals<readonly ["supported", "unsupported", "unknown"]>;
+    }>>;
 }>;
 export declare const workspaceErrorSchema: Schema.Struct<{
     readonly message: Schema.String;
@@ -144,6 +182,8 @@ export declare const execWorkspaceRequestSchema: Schema.Struct<{
         readonly args: Schema.$Array<Schema.String>;
         readonly cwd: Schema.optional<Schema.String>;
     }>>;
+    /** Run every command as this Linux user (see `workspaceProcessUserSchema`). */
+    readonly user: Schema.optional<Schema.String>;
 }>;
 export type ExecWorkspaceRequest = typeof execWorkspaceRequestSchema.Type;
 /**
@@ -504,6 +544,215 @@ export declare const restartWorkspaceResponseSchema: Schema.Struct<{
     readonly status: Schema.Literals<readonly ["queued", "running", "ready", "failed", "cancelled", "stopped", "retained"]>;
 }>;
 export type RestartWorkspaceResponse = typeof restartWorkspaceResponseSchema.Type;
+/**
+ * What a create would build, read before the create (Mend ADR 0016 needs the per-person capability
+ * before it chooses a layout): the spec is planned exactly as the build plans it, and the latest
+ * image published for that plan answers. Nothing is created, built or reserved.
+ */
+export declare const inspectWorkspaceImageRequestSchema: Schema.Struct<{
+    readonly ownerUserId: Schema.String;
+    readonly registryId: Schema.String;
+    /** The spec a create would send (`CreateWorkspaceRequest.spec`). */
+    readonly spec: Schema.Unknown;
+}>;
+export type InspectWorkspaceImageRequest = typeof inspectWorkspaceImageRequestSchema.Type;
+export declare const inspectWorkspaceImageResponseSchema: Schema.Struct<{
+    /** The hash of the image plan the spec renders: one per distinct build input. */
+    readonly planHash: Schema.String;
+    /** The latest image published for the plan; absent when none has been built yet. */
+    readonly publishedImage: Schema.optional<Schema.Struct<{
+        readonly reference: Schema.String;
+        readonly digestReference: Schema.String;
+        readonly digest: Schema.String;
+        /** Absent from control planes before the per-person capability. */
+        readonly personLayout: Schema.optional<Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["supported", "unsupported", "unknown"]>;
+            /**
+             * Stable codes of what the image or the runtime lacks (`setuid-sudo`, `sudo-no-new-privileges`,
+             * `useradd`, `setpriv`, `flock`, `reserved-ids`, `sealantd:<capability>`, `acl`, …).
+             */
+            readonly missing: Schema.$Array<Schema.String>;
+            /** What could not be read: `probe` (an image built before the probe), `sealantd`, `flock`, `acl`. */
+            readonly unknown: Schema.$Array<Schema.String>;
+            /** The runtime the answer is for: the workspace's, or the deployment's default before create. */
+            readonly runtime: Schema.String;
+            /** ACLs on that runtime's `/workspace`, as the operator declared them. */
+            readonly acl: Schema.Literals<readonly ["supported", "unsupported", "unknown"]>;
+        }>>;
+    }>>;
+    /** The image's per-person capability (`unknown` when none has been built yet). */
+    readonly personLayout: Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["supported", "unsupported", "unknown"]>;
+        /**
+         * Stable codes of what the image or the runtime lacks (`setuid-sudo`, `sudo-no-new-privileges`,
+         * `useradd`, `setpriv`, `flock`, `reserved-ids`, `sealantd:<capability>`, `acl`, …).
+         */
+        readonly missing: Schema.$Array<Schema.String>;
+        /** What could not be read: `probe` (an image built before the probe), `sealantd`, `flock`, `acl`. */
+        readonly unknown: Schema.$Array<Schema.String>;
+        /** The runtime the answer is for: the workspace's, or the deployment's default before create. */
+        readonly runtime: Schema.String;
+        /** ACLs on that runtime's `/workspace`, as the operator declared them. */
+        readonly acl: Schema.Literals<readonly ["supported", "unsupported", "unknown"]>;
+    }>;
+}>;
+export type InspectWorkspaceImageResponse = typeof inspectWorkspaceImageResponseSchema.Type;
+/** The providers a home holds logins for (docs/connected-accounts-design.md §6c). */
+export declare const workspaceCredentialHomeProviders: readonly ["claude", "codex", "github"];
+export type WorkspaceCredentialHomeProvider = (typeof workspaceCredentialHomeProviders)[number];
+/**
+ * Put one person's logins into one home of a RUNNING workspace (docs/connected-accounts-design.md
+ * §6c). A home holds one person's logins while it is held: the first put names its person, a put
+ * for anyone else is refused (`home-held`) until the home is released. Core writes a copy of each
+ * named account (no refresh token, like a launch) owned by the home's owner, mode 0600, and keeps it
+ * refreshed there; GitHub is written as `<home>/.config/gh/hosts.yml`. Values are connected-account
+ * ids ("cacc_…") or per-provider account names of `onBehalfOfUserId`, resolved exactly as at create
+ * ("default" is the account `true` picks); `null` removes that provider's login from the home (the
+ * person has not connected it). A provider left out is left as it is.
+ */
+export declare const putWorkspaceCredentialsRequestSchema: Schema.Struct<{
+    /** The workspace's owner (owner scope; uniform 404 otherwise). */
+    readonly ownerUserId: Schema.String;
+    /** The person whose logins the home holds: every named account must be theirs. */
+    readonly onBehalfOfUserId: Schema.String;
+    /**
+     * Absolute path of the home inside the executor: a person's home, a conversation home, or
+     * `/root`. Normalised, never under `/workspace`, and reached without a symbolic link. It must
+     * exist; its owner owns the files.
+     */
+    readonly home: Schema.String;
+    /**
+     * The home's owner, given together: a home that does not exist yet is made for them (mode 0700,
+     * seeded from `/etc/skel`), so a put can run beside the `useradd` that makes its user. Without
+     * them a missing home is refused (`home-unusable`).
+     */
+    readonly uid: Schema.optional<Schema.Int>;
+    readonly gid: Schema.optional<Schema.Int>;
+    readonly claude: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly codex: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly github: Schema.optional<Schema.NullOr<Schema.String>>;
+}>;
+export type PutWorkspaceCredentialsRequest = typeof putWorkspaceCredentialsRequestSchema.Type;
+/** One account whose copy a home holds. */
+export declare const workspaceHomeAccountSchema: Schema.Struct<{
+    readonly connectedAccountId: Schema.String;
+    /** The account's name under its provider, as it is now. */
+    readonly name: Schema.String;
+}>;
+export type WorkspaceHomeAccount = typeof workspaceHomeAccountSchema.Type;
+/** One home of a running workspace and the logins Core keeps in it. */
+export declare const workspaceCredentialHomeSchema: Schema.Struct<{
+    readonly home: Schema.String;
+    /** The one person whose logins the home holds. */
+    readonly onBehalfOfUserId: Schema.String;
+    /** By provider; a provider the home holds no login for is absent. */
+    readonly accounts: Schema.Struct<{
+        readonly claude: Schema.optional<Schema.Struct<{
+            readonly connectedAccountId: Schema.String;
+            /** The account's name under its provider, as it is now. */
+            readonly name: Schema.String;
+        }>>;
+        readonly codex: Schema.optional<Schema.Struct<{
+            readonly connectedAccountId: Schema.String;
+            /** The account's name under its provider, as it is now. */
+            readonly name: Schema.String;
+        }>>;
+        readonly github: Schema.optional<Schema.Struct<{
+            readonly connectedAccountId: Schema.String;
+            /** The account's name under its provider, as it is now. */
+            readonly name: Schema.String;
+        }>>;
+    }>;
+}>;
+export type WorkspaceCredentialHome = typeof workspaceCredentialHomeSchema.Type;
+export declare const putWorkspaceCredentialsResponseSchema: Schema.Struct<{
+    readonly workspaceId: Schema.String;
+    /** The launch attempt whose executor was written. */
+    readonly runId: Schema.String;
+    /** The home as it is after the put. */
+    readonly home: Schema.Struct<{
+        readonly home: Schema.String;
+        /** The one person whose logins the home holds. */
+        readonly onBehalfOfUserId: Schema.String;
+        /** By provider; a provider the home holds no login for is absent. */
+        readonly accounts: Schema.Struct<{
+            readonly claude: Schema.optional<Schema.Struct<{
+                readonly connectedAccountId: Schema.String;
+                /** The account's name under its provider, as it is now. */
+                readonly name: Schema.String;
+            }>>;
+            readonly codex: Schema.optional<Schema.Struct<{
+                readonly connectedAccountId: Schema.String;
+                /** The account's name under its provider, as it is now. */
+                readonly name: Schema.String;
+            }>>;
+            readonly github: Schema.optional<Schema.Struct<{
+                readonly connectedAccountId: Schema.String;
+                /** The account's name under its provider, as it is now. */
+                readonly name: Schema.String;
+            }>>;
+        }>;
+    }>;
+}>;
+export type PutWorkspaceCredentialsResponse = typeof putWorkspaceCredentialsResponseSchema.Type;
+/** Release one home: its login files are removed and its record deleted. */
+export declare const releaseWorkspaceCredentialsQuerySchema: Schema.Struct<{
+    readonly ownerUserId: Schema.String;
+    readonly home: Schema.String;
+}>;
+export type ReleaseWorkspaceCredentialsQuery = typeof releaseWorkspaceCredentialsQuerySchema.Type;
+export declare const releaseWorkspaceCredentialsResponseSchema: Schema.Struct<{
+    readonly workspaceId: Schema.String;
+    readonly runId: Schema.String;
+    readonly home: Schema.String;
+    /** `false`: the home held nothing (already released); its login files were removed anyway. */
+    readonly released: Schema.Boolean;
+}>;
+export type ReleaseWorkspaceCredentialsResponse = typeof releaseWorkspaceCredentialsResponseSchema.Type;
+export declare const listWorkspaceCredentialsQuerySchema: Schema.Struct<{
+    readonly ownerUserId: Schema.String;
+}>;
+export type ListWorkspaceCredentialsQuery = typeof listWorkspaceCredentialsQuerySchema.Type;
+/** The homes of the workspace's running executor, oldest first. */
+export declare const listWorkspaceCredentialsResponseSchema: Schema.Struct<{
+    readonly workspaceId: Schema.String;
+    readonly runId: Schema.String;
+    readonly homes: Schema.$Array<Schema.Struct<{
+        readonly home: Schema.String;
+        /** The one person whose logins the home holds. */
+        readonly onBehalfOfUserId: Schema.String;
+        /** By provider; a provider the home holds no login for is absent. */
+        readonly accounts: Schema.Struct<{
+            readonly claude: Schema.optional<Schema.Struct<{
+                readonly connectedAccountId: Schema.String;
+                /** The account's name under its provider, as it is now. */
+                readonly name: Schema.String;
+            }>>;
+            readonly codex: Schema.optional<Schema.Struct<{
+                readonly connectedAccountId: Schema.String;
+                /** The account's name under its provider, as it is now. */
+                readonly name: Schema.String;
+            }>>;
+            readonly github: Schema.optional<Schema.Struct<{
+                readonly connectedAccountId: Schema.String;
+                /** The account's name under its provider, as it is now. */
+                readonly name: Schema.String;
+            }>>;
+        }>;
+    }>>;
+}>;
+export type ListWorkspaceCredentialsResponse = typeof listWorkspaceCredentialsResponseSchema.Type;
+/**
+ * Stable `code`s of the `WorkspaceConflictError` the credential routes answer:
+ * `workspace-not-running` (no ready executor), `connected-account-invalid` (a named account is
+ * marked invalid: reconnect it), `home-held` (the home holds another person's logins: release it
+ * first; `/root` while the launch's own logins are at `$HOME`, or for anyone but the workspace's
+ * owner), `home-unusable` (the home does not exist, is not a directory, is reached through a
+ * symbolic link, or a login directory in it links outside it), `home-busy` (another write into the
+ * home, or too many into this workspace, is still running: nothing was done, try again).
+ */
+export declare const workspaceCredentialsConflictCodes: readonly ["workspace-not-running", "connected-account-invalid", "home-held", "home-unusable", "home-busy"];
+export type WorkspaceCredentialsConflictCode = (typeof workspaceCredentialsConflictCodes)[number];
 export declare const expireWorkspaceRequestSchema: Schema.Struct<{
     readonly ownerUserId: Schema.String;
     readonly ttlSeconds: Schema.optional<Schema.NullOr<Schema.Int>>;
@@ -626,6 +875,21 @@ export declare const workspaceSummarySchema: Schema.Struct<{
         readonly reference: Schema.String;
         readonly digestReference: Schema.String;
         readonly digest: Schema.String;
+        /** Absent from control planes before the per-person capability. */
+        readonly personLayout: Schema.optional<Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["supported", "unsupported", "unknown"]>;
+            /**
+             * Stable codes of what the image or the runtime lacks (`setuid-sudo`, `sudo-no-new-privileges`,
+             * `useradd`, `setpriv`, `flock`, `reserved-ids`, `sealantd:<capability>`, `acl`, …).
+             */
+            readonly missing: Schema.$Array<Schema.String>;
+            /** What could not be read: `probe` (an image built before the probe), `sealantd`, `flock`, `acl`. */
+            readonly unknown: Schema.$Array<Schema.String>;
+            /** The runtime the answer is for: the workspace's, or the deployment's default before create. */
+            readonly runtime: Schema.String;
+            /** ACLs on that runtime's `/workspace`, as the operator declared them. */
+            readonly acl: Schema.Literals<readonly ["supported", "unsupported", "unknown"]>;
+        }>>;
     }>>;
     readonly error: Schema.optional<Schema.Struct<{
         readonly message: Schema.String;
@@ -753,6 +1017,21 @@ export declare const workspaceDetailsSchema: Schema.Struct<{
         readonly reference: Schema.String;
         readonly digestReference: Schema.String;
         readonly digest: Schema.String;
+        /** Absent from control planes before the per-person capability. */
+        readonly personLayout: Schema.optional<Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["supported", "unsupported", "unknown"]>;
+            /**
+             * Stable codes of what the image or the runtime lacks (`setuid-sudo`, `sudo-no-new-privileges`,
+             * `useradd`, `setpriv`, `flock`, `reserved-ids`, `sealantd:<capability>`, `acl`, …).
+             */
+            readonly missing: Schema.$Array<Schema.String>;
+            /** What could not be read: `probe` (an image built before the probe), `sealantd`, `flock`, `acl`. */
+            readonly unknown: Schema.$Array<Schema.String>;
+            /** The runtime the answer is for: the workspace's, or the deployment's default before create. */
+            readonly runtime: Schema.String;
+            /** ACLs on that runtime's `/workspace`, as the operator declared them. */
+            readonly acl: Schema.Literals<readonly ["supported", "unsupported", "unknown"]>;
+        }>>;
     }>>;
     readonly error: Schema.optional<Schema.Struct<{
         readonly message: Schema.String;
@@ -881,6 +1160,21 @@ export declare const listWorkspacesResponseSchema: Schema.Struct<{
             readonly reference: Schema.String;
             readonly digestReference: Schema.String;
             readonly digest: Schema.String;
+            /** Absent from control planes before the per-person capability. */
+            readonly personLayout: Schema.optional<Schema.Struct<{
+                readonly status: Schema.Literals<readonly ["supported", "unsupported", "unknown"]>;
+                /**
+                 * Stable codes of what the image or the runtime lacks (`setuid-sudo`, `sudo-no-new-privileges`,
+                 * `useradd`, `setpriv`, `flock`, `reserved-ids`, `sealantd:<capability>`, `acl`, …).
+                 */
+                readonly missing: Schema.$Array<Schema.String>;
+                /** What could not be read: `probe` (an image built before the probe), `sealantd`, `flock`, `acl`. */
+                readonly unknown: Schema.$Array<Schema.String>;
+                /** The runtime the answer is for: the workspace's, or the deployment's default before create. */
+                readonly runtime: Schema.String;
+                /** ACLs on that runtime's `/workspace`, as the operator declared them. */
+                readonly acl: Schema.Literals<readonly ["supported", "unsupported", "unknown"]>;
+            }>>;
         }>>;
         readonly error: Schema.optional<Schema.Struct<{
             readonly message: Schema.String;
@@ -932,6 +1226,21 @@ export declare const workspaceAttemptSummarySchema: Schema.Struct<{
         readonly reference: Schema.String;
         readonly digestReference: Schema.String;
         readonly digest: Schema.String;
+        /** Absent from control planes before the per-person capability. */
+        readonly personLayout: Schema.optional<Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["supported", "unsupported", "unknown"]>;
+            /**
+             * Stable codes of what the image or the runtime lacks (`setuid-sudo`, `sudo-no-new-privileges`,
+             * `useradd`, `setpriv`, `flock`, `reserved-ids`, `sealantd:<capability>`, `acl`, …).
+             */
+            readonly missing: Schema.$Array<Schema.String>;
+            /** What could not be read: `probe` (an image built before the probe), `sealantd`, `flock`, `acl`. */
+            readonly unknown: Schema.$Array<Schema.String>;
+            /** The runtime the answer is for: the workspace's, or the deployment's default before create. */
+            readonly runtime: Schema.String;
+            /** ACLs on that runtime's `/workspace`, as the operator declared them. */
+            readonly acl: Schema.Literals<readonly ["supported", "unsupported", "unknown"]>;
+        }>>;
     }>>;
     readonly error: Schema.optional<Schema.Struct<{
         readonly message: Schema.String;
@@ -981,6 +1290,21 @@ export declare const listWorkspaceAttemptsResponseSchema: Schema.Struct<{
             readonly reference: Schema.String;
             readonly digestReference: Schema.String;
             readonly digest: Schema.String;
+            /** Absent from control planes before the per-person capability. */
+            readonly personLayout: Schema.optional<Schema.Struct<{
+                readonly status: Schema.Literals<readonly ["supported", "unsupported", "unknown"]>;
+                /**
+                 * Stable codes of what the image or the runtime lacks (`setuid-sudo`, `sudo-no-new-privileges`,
+                 * `useradd`, `setpriv`, `flock`, `reserved-ids`, `sealantd:<capability>`, `acl`, …).
+                 */
+                readonly missing: Schema.$Array<Schema.String>;
+                /** What could not be read: `probe` (an image built before the probe), `sealantd`, `flock`, `acl`. */
+                readonly unknown: Schema.$Array<Schema.String>;
+                /** The runtime the answer is for: the workspace's, or the deployment's default before create. */
+                readonly runtime: Schema.String;
+                /** ACLs on that runtime's `/workspace`, as the operator declared them. */
+                readonly acl: Schema.Literals<readonly ["supported", "unsupported", "unknown"]>;
+            }>>;
         }>>;
         readonly error: Schema.optional<Schema.Struct<{
             readonly message: Schema.String;
@@ -1215,6 +1539,8 @@ export declare const WorkspacesGroup: HttpApiGroup.HttpApiGroup<"workspaces", Ht
         readonly args: Schema.$Array<Schema.String>;
         readonly cwd: Schema.optional<Schema.String>;
     }>>;
+    /** Run every command as this Linux user (see `workspaceProcessUserSchema`). */
+    readonly user: Schema.optional<Schema.String>;
 }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
     readonly runId: Schema.String;
     readonly workspaceId: Schema.String;
@@ -1415,6 +1741,21 @@ export declare const WorkspacesGroup: HttpApiGroup.HttpApiGroup<"workspaces", Ht
         readonly reference: Schema.String;
         readonly digestReference: Schema.String;
         readonly digest: Schema.String;
+        /** Absent from control planes before the per-person capability. */
+        readonly personLayout: Schema.optional<Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["supported", "unsupported", "unknown"]>;
+            /**
+             * Stable codes of what the image or the runtime lacks (`setuid-sudo`, `sudo-no-new-privileges`,
+             * `useradd`, `setpriv`, `flock`, `reserved-ids`, `sealantd:<capability>`, `acl`, …).
+             */
+            readonly missing: Schema.$Array<Schema.String>;
+            /** What could not be read: `probe` (an image built before the probe), `sealantd`, `flock`, `acl`. */
+            readonly unknown: Schema.$Array<Schema.String>;
+            /** The runtime the answer is for: the workspace's, or the deployment's default before create. */
+            readonly runtime: Schema.String;
+            /** ACLs on that runtime's `/workspace`, as the operator declared them. */
+            readonly acl: Schema.Literals<readonly ["supported", "unsupported", "unknown"]>;
+        }>>;
     }>>;
     readonly error: Schema.optional<Schema.Struct<{
         readonly message: Schema.String;
@@ -1637,7 +1978,51 @@ export declare const WorkspacesGroup: HttpApiGroup.HttpApiGroup<"workspaces", Ht
         readonly status: Schema.Literals<readonly ["pending", "running", "ready", "failed", "stopped"]>;
         readonly endpoint: Schema.String;
     }>;
-}>>, HttpApiEndpoint.Json<typeof WorkspaceUnauthorizedError | typeof WorkspaceNotFoundError | typeof WorkspaceConflictError | typeof WorkspaceServiceUnavailableError | typeof WorkspaceInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listWorkspaceAttempts", "GET", "/:workspaceId/attempts", HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, HttpApiEndpoint.Json<typeof WorkspaceUnauthorizedError | typeof WorkspaceNotFoundError | typeof WorkspaceConflictError | typeof WorkspaceServiceUnavailableError | typeof WorkspaceInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"inspectWorkspaceImage", "POST", "/image", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly ownerUserId: Schema.String;
+    readonly registryId: Schema.String;
+    /** The spec a create would send (`CreateWorkspaceRequest.spec`). */
+    readonly spec: Schema.Unknown;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    /** The hash of the image plan the spec renders: one per distinct build input. */
+    readonly planHash: Schema.String;
+    /** The latest image published for the plan; absent when none has been built yet. */
+    readonly publishedImage: Schema.optional<Schema.Struct<{
+        readonly reference: Schema.String;
+        readonly digestReference: Schema.String;
+        readonly digest: Schema.String;
+        /** Absent from control planes before the per-person capability. */
+        readonly personLayout: Schema.optional<Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["supported", "unsupported", "unknown"]>;
+            /**
+             * Stable codes of what the image or the runtime lacks (`setuid-sudo`, `sudo-no-new-privileges`,
+             * `useradd`, `setpriv`, `flock`, `reserved-ids`, `sealantd:<capability>`, `acl`, …).
+             */
+            readonly missing: Schema.$Array<Schema.String>;
+            /** What could not be read: `probe` (an image built before the probe), `sealantd`, `flock`, `acl`. */
+            readonly unknown: Schema.$Array<Schema.String>;
+            /** The runtime the answer is for: the workspace's, or the deployment's default before create. */
+            readonly runtime: Schema.String;
+            /** ACLs on that runtime's `/workspace`, as the operator declared them. */
+            readonly acl: Schema.Literals<readonly ["supported", "unsupported", "unknown"]>;
+        }>>;
+    }>>;
+    /** The image's per-person capability (`unknown` when none has been built yet). */
+    readonly personLayout: Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["supported", "unsupported", "unknown"]>;
+        /**
+         * Stable codes of what the image or the runtime lacks (`setuid-sudo`, `sudo-no-new-privileges`,
+         * `useradd`, `setpriv`, `flock`, `reserved-ids`, `sealantd:<capability>`, `acl`, …).
+         */
+        readonly missing: Schema.$Array<Schema.String>;
+        /** What could not be read: `probe` (an image built before the probe), `sealantd`, `flock`, `acl`. */
+        readonly unknown: Schema.$Array<Schema.String>;
+        /** The runtime the answer is for: the workspace's, or the deployment's default before create. */
+        readonly runtime: Schema.String;
+        /** ACLs on that runtime's `/workspace`, as the operator declared them. */
+        readonly acl: Schema.Literals<readonly ["supported", "unsupported", "unknown"]>;
+    }>;
+}>>, HttpApiEndpoint.Json<typeof WorkspaceBadRequestError | typeof WorkspaceNotFoundError | typeof WorkspaceInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listWorkspaceAttempts", "GET", "/:workspaceId/attempts", HttpApiEndpoint.StringTree<Schema.Struct<{
     readonly workspaceId: Schema.String;
 }>>, HttpApiEndpoint.StringTree<Schema.Struct<{
     readonly ownerUserId: Schema.optional<Schema.String>;
@@ -1676,6 +2061,21 @@ export declare const WorkspacesGroup: HttpApiGroup.HttpApiGroup<"workspaces", Ht
             readonly reference: Schema.String;
             readonly digestReference: Schema.String;
             readonly digest: Schema.String;
+            /** Absent from control planes before the per-person capability. */
+            readonly personLayout: Schema.optional<Schema.Struct<{
+                readonly status: Schema.Literals<readonly ["supported", "unsupported", "unknown"]>;
+                /**
+                 * Stable codes of what the image or the runtime lacks (`setuid-sudo`, `sudo-no-new-privileges`,
+                 * `useradd`, `setpriv`, `flock`, `reserved-ids`, `sealantd:<capability>`, `acl`, …).
+                 */
+                readonly missing: Schema.$Array<Schema.String>;
+                /** What could not be read: `probe` (an image built before the probe), `sealantd`, `flock`, `acl`. */
+                readonly unknown: Schema.$Array<Schema.String>;
+                /** The runtime the answer is for: the workspace's, or the deployment's default before create. */
+                readonly runtime: Schema.String;
+                /** ACLs on that runtime's `/workspace`, as the operator declared them. */
+                readonly acl: Schema.Literals<readonly ["supported", "unsupported", "unknown"]>;
+            }>>;
         }>>;
         readonly error: Schema.optional<Schema.Struct<{
             readonly message: Schema.String;
@@ -1690,7 +2090,37 @@ export declare const WorkspacesGroup: HttpApiGroup.HttpApiGroup<"workspaces", Ht
         readonly finishedAt: Schema.optional<Schema.String>;
         readonly durationMs: Schema.optional<Schema.Number>;
     }>>;
-}>>, HttpApiEndpoint.Json<typeof WorkspaceBadRequestError | typeof WorkspaceNotFoundError | typeof WorkspaceInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listWorkspaceEvents", "GET", "/:workspaceId/events", HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, HttpApiEndpoint.Json<typeof WorkspaceBadRequestError | typeof WorkspaceNotFoundError | typeof WorkspaceInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listWorkspaceCredentials", "GET", "/:workspaceId/credentials", HttpApiEndpoint.StringTree<Schema.Struct<{
+    readonly workspaceId: Schema.String;
+}>>, HttpApiEndpoint.StringTree<Schema.Struct<{
+    readonly ownerUserId: Schema.String;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly workspaceId: Schema.String;
+    readonly runId: Schema.String;
+    readonly homes: Schema.$Array<Schema.Struct<{
+        readonly home: Schema.String;
+        /** The one person whose logins the home holds. */
+        readonly onBehalfOfUserId: Schema.String;
+        /** By provider; a provider the home holds no login for is absent. */
+        readonly accounts: Schema.Struct<{
+            readonly claude: Schema.optional<Schema.Struct<{
+                readonly connectedAccountId: Schema.String;
+                /** The account's name under its provider, as it is now. */
+                readonly name: Schema.String;
+            }>>;
+            readonly codex: Schema.optional<Schema.Struct<{
+                readonly connectedAccountId: Schema.String;
+                /** The account's name under its provider, as it is now. */
+                readonly name: Schema.String;
+            }>>;
+            readonly github: Schema.optional<Schema.Struct<{
+                readonly connectedAccountId: Schema.String;
+                /** The account's name under its provider, as it is now. */
+                readonly name: Schema.String;
+            }>>;
+        }>;
+    }>>;
+}>>, HttpApiEndpoint.Json<typeof WorkspaceForbiddenError | typeof WorkspaceNotFoundError | typeof WorkspaceConflictError | typeof WorkspaceInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listWorkspaceEvents", "GET", "/:workspaceId/events", HttpApiEndpoint.StringTree<Schema.Struct<{
     readonly workspaceId: Schema.String;
 }>>, HttpApiEndpoint.StringTree<Schema.Struct<{
     readonly ownerUserId: Schema.optional<Schema.String>;
@@ -1747,6 +2177,21 @@ export declare const WorkspacesGroup: HttpApiGroup.HttpApiGroup<"workspaces", Ht
             readonly reference: Schema.String;
             readonly digestReference: Schema.String;
             readonly digest: Schema.String;
+            /** Absent from control planes before the per-person capability. */
+            readonly personLayout: Schema.optional<Schema.Struct<{
+                readonly status: Schema.Literals<readonly ["supported", "unsupported", "unknown"]>;
+                /**
+                 * Stable codes of what the image or the runtime lacks (`setuid-sudo`, `sudo-no-new-privileges`,
+                 * `useradd`, `setpriv`, `flock`, `reserved-ids`, `sealantd:<capability>`, `acl`, …).
+                 */
+                readonly missing: Schema.$Array<Schema.String>;
+                /** What could not be read: `probe` (an image built before the probe), `sealantd`, `flock`, `acl`. */
+                readonly unknown: Schema.$Array<Schema.String>;
+                /** The runtime the answer is for: the workspace's, or the deployment's default before create. */
+                readonly runtime: Schema.String;
+                /** ACLs on that runtime's `/workspace`, as the operator declared them. */
+                readonly acl: Schema.Literals<readonly ["supported", "unsupported", "unknown"]>;
+            }>>;
         }>>;
         readonly error: Schema.optional<Schema.Struct<{
             readonly message: Schema.String;
@@ -1758,7 +2203,58 @@ export declare const WorkspacesGroup: HttpApiGroup.HttpApiGroup<"workspaces", Ht
         readonly finishedAt: Schema.optional<Schema.String>;
         readonly expiresAt: Schema.optional<Schema.String>;
     }>>;
-}>>, HttpApiEndpoint.Json<typeof WorkspaceBadRequestError | typeof WorkspaceInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"recoverWorkspace", "POST", "/:workspaceId/recover", HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, HttpApiEndpoint.Json<typeof WorkspaceBadRequestError | typeof WorkspaceInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"putWorkspaceCredentials", "POST", "/:workspaceId/credentials", HttpApiEndpoint.StringTree<Schema.Struct<{
+    readonly workspaceId: Schema.String;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    /** The workspace's owner (owner scope; uniform 404 otherwise). */
+    readonly ownerUserId: Schema.String;
+    /** The person whose logins the home holds: every named account must be theirs. */
+    readonly onBehalfOfUserId: Schema.String;
+    /**
+     * Absolute path of the home inside the executor: a person's home, a conversation home, or
+     * `/root`. Normalised, never under `/workspace`, and reached without a symbolic link. It must
+     * exist; its owner owns the files.
+     */
+    readonly home: Schema.String;
+    /**
+     * The home's owner, given together: a home that does not exist yet is made for them (mode 0700,
+     * seeded from `/etc/skel`), so a put can run beside the `useradd` that makes its user. Without
+     * them a missing home is refused (`home-unusable`).
+     */
+    readonly uid: Schema.optional<Schema.Int>;
+    readonly gid: Schema.optional<Schema.Int>;
+    readonly claude: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly codex: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly github: Schema.optional<Schema.NullOr<Schema.String>>;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly workspaceId: Schema.String;
+    /** The launch attempt whose executor was written. */
+    readonly runId: Schema.String;
+    /** The home as it is after the put. */
+    readonly home: Schema.Struct<{
+        readonly home: Schema.String;
+        /** The one person whose logins the home holds. */
+        readonly onBehalfOfUserId: Schema.String;
+        /** By provider; a provider the home holds no login for is absent. */
+        readonly accounts: Schema.Struct<{
+            readonly claude: Schema.optional<Schema.Struct<{
+                readonly connectedAccountId: Schema.String;
+                /** The account's name under its provider, as it is now. */
+                readonly name: Schema.String;
+            }>>;
+            readonly codex: Schema.optional<Schema.Struct<{
+                readonly connectedAccountId: Schema.String;
+                /** The account's name under its provider, as it is now. */
+                readonly name: Schema.String;
+            }>>;
+            readonly github: Schema.optional<Schema.Struct<{
+                readonly connectedAccountId: Schema.String;
+                /** The account's name under its provider, as it is now. */
+                readonly name: Schema.String;
+            }>>;
+        }>;
+    }>;
+}>>, HttpApiEndpoint.Json<typeof WorkspaceBadRequestError | typeof WorkspaceForbiddenError | typeof WorkspaceNotFoundError | typeof WorkspaceConflictError | typeof WorkspaceBadGatewayError | typeof WorkspaceServiceUnavailableError | typeof WorkspaceInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"recoverWorkspace", "POST", "/:workspaceId/recover", HttpApiEndpoint.StringTree<Schema.Struct<{
     readonly workspaceId: Schema.String;
 }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
     readonly ownerUserId: Schema.String;
@@ -1766,7 +2262,18 @@ export declare const WorkspacesGroup: HttpApiGroup.HttpApiGroup<"workspaces", Ht
     readonly workspaceId: Schema.String;
     readonly state: Schema.Literals<readonly ["requested", "not-retained"]>;
     readonly recoverable: Schema.optional<Schema.Boolean>;
-}>>, HttpApiEndpoint.Json<typeof WorkspaceBadRequestError | typeof WorkspaceNotFoundError | typeof WorkspaceConflictError | typeof WorkspaceInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"renameWorkspace", "PATCH", "/:workspaceId/name", HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, HttpApiEndpoint.Json<typeof WorkspaceBadRequestError | typeof WorkspaceNotFoundError | typeof WorkspaceConflictError | typeof WorkspaceInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"releaseWorkspaceCredentials", "DELETE", "/:workspaceId/credentials", HttpApiEndpoint.StringTree<Schema.Struct<{
+    readonly workspaceId: Schema.String;
+}>>, HttpApiEndpoint.StringTree<Schema.Struct<{
+    readonly ownerUserId: Schema.String;
+    readonly home: Schema.String;
+}>>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly workspaceId: Schema.String;
+    readonly runId: Schema.String;
+    readonly home: Schema.String;
+    /** `false`: the home held nothing (already released); its login files were removed anyway. */
+    readonly released: Schema.Boolean;
+}>>, HttpApiEndpoint.Json<typeof WorkspaceBadRequestError | typeof WorkspaceForbiddenError | typeof WorkspaceNotFoundError | typeof WorkspaceConflictError | typeof WorkspaceBadGatewayError | typeof WorkspaceServiceUnavailableError | typeof WorkspaceInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"renameWorkspace", "PATCH", "/:workspaceId/name", HttpApiEndpoint.StringTree<Schema.Struct<{
     readonly workspaceId: Schema.String;
 }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
     readonly name: Schema.String;

package/dist/core-api/workspaces.js

@@ -2,6 +2,7 @@ import { Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
 import { BudgetExceededError } from "./budgets.js";
 import { runCommandSchema, runSchema } from "./runs.js";
+import { workspaceProcessUserSchema } from "./sessions.js";
 const NonEmptyString = Schema.String.check(Schema.isNonEmpty(), Schema.isTrimmed());
 /**
  * `retained`: the workspace's executor ended (or its capture launch failed after it started)
@@ -54,10 +55,34 @@ export const workspaceSshTargetSchema = Schema.Struct({
         endpoint: Schema.String,
     }),
 });
+/**
+ * Whether an image can run Mend's per-person layout on a runtime (Mend ADR 0016): the verdict of
+ * the image build's probe (`metadata.imageProbe`: setuid `sudo` and a usable sudoers rule,
+ * `useradd`, `setfacl`, `setpriv`, `flock`, a writable passwd, the `mend` group and the reserved
+ * ids, and what its sealantd reports), the runtime's `no_new_privs` (Kubernetes), and ACLs on
+ * `/workspace` as the operator declares them (`SEALANT_WORKSPACE_ACLS`). What is not known is
+ * `unknown`, never `supported`.
+ */
+export const workspaceImagePersonLayoutSchema = Schema.Struct({
+    status: Schema.Literals(["supported", "unsupported", "unknown"]),
+    /**
+     * Stable codes of what the image or the runtime lacks (`setuid-sudo`, `sudo-no-new-privileges`,
+     * `useradd`, `setpriv`, `flock`, `reserved-ids`, `sealantd:<capability>`, `acl`, …).
+     */
+    missing: Schema.Array(Schema.String),
+    /** What could not be read: `probe` (an image built before the probe), `sealantd`, `flock`, `acl`. */
+    unknown: Schema.Array(Schema.String),
+    /** The runtime the answer is for: the workspace's, or the deployment's default before create. */
+    runtime: NonEmptyString,
+    /** ACLs on that runtime's `/workspace`, as the operator declared them. */
+    acl: Schema.Literals(["supported", "unsupported", "unknown"]),
+});
 export const workspacePublishedImageSchema = Schema.Struct({
     reference: NonEmptyString,
     digestReference: NonEmptyString,
     digest: NonEmptyString,
+    /** Absent from control planes before the per-person capability. */
+    personLayout: Schema.optional(workspaceImagePersonLayoutSchema),
 });
 export const workspaceErrorSchema = Schema.Struct({
     message: Schema.String,
@@ -141,6 +166,8 @@ export const execWorkspaceRequestSchema = Schema.Struct({
     ownerUserId: NonEmptyString,
     /** Commands execute sequentially in the workspace, each recorded like any other process. */
     commands: Schema.Array(runCommandSchema).check(Schema.isNonEmpty(), Schema.isMaxLength(32)),
+    /** Run every command as this Linux user (see `workspaceProcessUserSchema`). */
+    user: Schema.optional(workspaceProcessUserSchema),
 });
 /**
  * Bind a standby workspace's working directory, or a bindable extra mount, to one subdirectory of
@@ -453,6 +480,121 @@ export const restartWorkspaceResponseSchema = Schema.Struct({
     runId: NonEmptyString,
     status: workspaceStatusSchema,
 });
+/**
+ * What a create would build, read before the create (Mend ADR 0016 needs the per-person capability
+ * before it chooses a layout): the spec is planned exactly as the build plans it, and the latest
+ * image published for that plan answers. Nothing is created, built or reserved.
+ */
+export const inspectWorkspaceImageRequestSchema = Schema.Struct({
+    ownerUserId: NonEmptyString,
+    registryId: NonEmptyString,
+    /** The spec a create would send (`CreateWorkspaceRequest.spec`). */
+    spec: Schema.Unknown,
+});
+export const inspectWorkspaceImageResponseSchema = Schema.Struct({
+    /** The hash of the image plan the spec renders: one per distinct build input. */
+    planHash: NonEmptyString,
+    /** The latest image published for the plan; absent when none has been built yet. */
+    publishedImage: Schema.optional(workspacePublishedImageSchema),
+    /** The image's per-person capability (`unknown` when none has been built yet). */
+    personLayout: workspaceImagePersonLayoutSchema,
+});
+/** The providers a home holds logins for (docs/connected-accounts-design.md §6c). */
+export const workspaceCredentialHomeProviders = ["claude", "codex", "github"];
+/**
+ * Put one person's logins into one home of a RUNNING workspace (docs/connected-accounts-design.md
+ * §6c). A home holds one person's logins while it is held: the first put names its person, a put
+ * for anyone else is refused (`home-held`) until the home is released. Core writes a copy of each
+ * named account (no refresh token, like a launch) owned by the home's owner, mode 0600, and keeps it
+ * refreshed there; GitHub is written as `<home>/.config/gh/hosts.yml`. Values are connected-account
+ * ids ("cacc_…") or per-provider account names of `onBehalfOfUserId`, resolved exactly as at create
+ * ("default" is the account `true` picks); `null` removes that provider's login from the home (the
+ * person has not connected it). A provider left out is left as it is.
+ */
+export const putWorkspaceCredentialsRequestSchema = Schema.Struct({
+    /** The workspace's owner (owner scope; uniform 404 otherwise). */
+    ownerUserId: NonEmptyString,
+    /** The person whose logins the home holds: every named account must be theirs. */
+    onBehalfOfUserId: NonEmptyString,
+    /**
+     * Absolute path of the home inside the executor: a person's home, a conversation home, or
+     * `/root`. Normalised, never under `/workspace`, and reached without a symbolic link. It must
+     * exist; its owner owns the files.
+     */
+    home: NonEmptyString,
+    /**
+     * The home's owner, given together: a home that does not exist yet is made for them (mode 0700,
+     * seeded from `/etc/skel`), so a put can run beside the `useradd` that makes its user. Without
+     * them a missing home is refused (`home-unusable`).
+     */
+    uid: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))),
+    gid: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))),
+    claude: Schema.optional(Schema.NullOr(NonEmptyString)),
+    codex: Schema.optional(Schema.NullOr(NonEmptyString)),
+    github: Schema.optional(Schema.NullOr(NonEmptyString)),
+});
+/** One account whose copy a home holds. */
+export const workspaceHomeAccountSchema = Schema.Struct({
+    connectedAccountId: NonEmptyString,
+    /** The account's name under its provider, as it is now. */
+    name: NonEmptyString,
+});
+/** One home of a running workspace and the logins Core keeps in it. */
+export const workspaceCredentialHomeSchema = Schema.Struct({
+    home: NonEmptyString,
+    /** The one person whose logins the home holds. */
+    onBehalfOfUserId: NonEmptyString,
+    /** By provider; a provider the home holds no login for is absent. */
+    accounts: Schema.Struct({
+        claude: Schema.optional(workspaceHomeAccountSchema),
+        codex: Schema.optional(workspaceHomeAccountSchema),
+        github: Schema.optional(workspaceHomeAccountSchema),
+    }),
+});
+export const putWorkspaceCredentialsResponseSchema = Schema.Struct({
+    workspaceId: NonEmptyString,
+    /** The launch attempt whose executor was written. */
+    runId: NonEmptyString,
+    /** The home as it is after the put. */
+    home: workspaceCredentialHomeSchema,
+});
+/** Release one home: its login files are removed and its record deleted. */
+export const releaseWorkspaceCredentialsQuerySchema = Schema.Struct({
+    ownerUserId: NonEmptyString,
+    home: NonEmptyString,
+});
+export const releaseWorkspaceCredentialsResponseSchema = Schema.Struct({
+    workspaceId: NonEmptyString,
+    runId: NonEmptyString,
+    home: NonEmptyString,
+    /** `false`: the home held nothing (already released); its login files were removed anyway. */
+    released: Schema.Boolean,
+});
+export const listWorkspaceCredentialsQuerySchema = Schema.Struct({
+    ownerUserId: NonEmptyString,
+});
+/** The homes of the workspace's running executor, oldest first. */
+export const listWorkspaceCredentialsResponseSchema = Schema.Struct({
+    workspaceId: NonEmptyString,
+    runId: NonEmptyString,
+    homes: Schema.Array(workspaceCredentialHomeSchema),
+});
+/**
+ * Stable `code`s of the `WorkspaceConflictError` the credential routes answer:
+ * `workspace-not-running` (no ready executor), `connected-account-invalid` (a named account is
+ * marked invalid: reconnect it), `home-held` (the home holds another person's logins: release it
+ * first; `/root` while the launch's own logins are at `$HOME`, or for anyone but the workspace's
+ * owner), `home-unusable` (the home does not exist, is not a directory, is reached through a
+ * symbolic link, or a login directory in it links outside it), `home-busy` (another write into the
+ * home, or too many into this workspace, is still running: nothing was done, try again).
+ */
+export const workspaceCredentialsConflictCodes = [
+    "workspace-not-running",
+    "connected-account-invalid",
+    "home-held",
+    "home-unusable",
+    "home-busy",
+];
 export const expireWorkspaceRequestSchema = Schema.Struct({
     ownerUserId: NonEmptyString,
     // Seconds from now until the workspace expires; null clears the TTL (never expires); omitted =
@@ -929,6 +1071,68 @@ HttpApiEndpoint.post("restartWorkspace", "/:workspaceId/restart", {
     ],
 }))
     .add(
+// A read: plans the spec as a build would and looks up what was published for it.
+HttpApiEndpoint.post("inspectWorkspaceImage", "/image", {
+    payload: inspectWorkspaceImageRequestSchema,
+    success: inspectWorkspaceImageResponseSchema,
+    error: [WorkspaceBadRequestError, WorkspaceNotFoundError, WorkspaceInternalServerError],
+}))
+    .add(
+// Synchronous: the files are written over the control connection before this answers.
+HttpApiEndpoint.post("putWorkspaceCredentials", "/:workspaceId/credentials", {
+    params: workspaceIdParams,
+    payload: putWorkspaceCredentialsRequestSchema,
+    success: putWorkspaceCredentialsResponseSchema,
+    error: [
+        // A malformed home, or nothing to do.
+        WorkspaceBadRequestError,
+        // The caller may not act for the people named (only a service key may).
+        WorkspaceForbiddenError,
+        // The workspace or a named account (unknown, someone else's, archived).
+        WorkspaceNotFoundError,
+        // See `workspaceCredentialsConflictCodes`.
+        WorkspaceConflictError,
+        // The executor did not confirm the write.
+        WorkspaceBadGatewayError,
+        // SEALANT_CREDENTIALS_KEY is not configured, or Core cannot reach the executor.
+        WorkspaceServiceUnavailableError,
+        WorkspaceInternalServerError,
+    ],
+}))
+    .add(
+// Synchronous: the files are removed before this answers. Idempotent.
+HttpApiEndpoint.delete("releaseWorkspaceCredentials", "/:workspaceId/credentials", {
+    params: workspaceIdParams,
+    query: releaseWorkspaceCredentialsQuerySchema,
+    success: releaseWorkspaceCredentialsResponseSchema,
+    error: [
+        // A malformed home, or nothing to do.
+        WorkspaceBadRequestError,
+        // The caller may not act for the people named (only a service key may).
+        WorkspaceForbiddenError,
+        // The workspace or a named account (unknown, someone else's, archived).
+        WorkspaceNotFoundError,
+        // See `workspaceCredentialsConflictCodes`.
+        WorkspaceConflictError,
+        // The executor did not confirm the write.
+        WorkspaceBadGatewayError,
+        // SEALANT_CREDENTIALS_KEY is not configured, or Core cannot reach the executor.
+        WorkspaceServiceUnavailableError,
+        WorkspaceInternalServerError,
+    ],
+}))
+    .add(HttpApiEndpoint.get("listWorkspaceCredentials", "/:workspaceId/credentials", {
+    params: workspaceIdParams,
+    query: listWorkspaceCredentialsQuerySchema,
+    success: listWorkspaceCredentialsResponseSchema,
+    error: [
+        WorkspaceForbiddenError,
+        WorkspaceNotFoundError,
+        WorkspaceConflictError,
+        WorkspaceInternalServerError,
+    ],
+}))
+    .add(
 // Synchronous: sets (or clears) the workspace TTL column; the worker reaper enforces it.
 HttpApiEndpoint.post("expireWorkspace", "/:workspaceId/expire", {
     params: workspaceIdParams,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sealant/api-contracts-next",
-  "version": "0.39.0-next.688",
+  "version": "0.39.0-next.692",
   "description": "Contract-first HTTP API definitions for Sealant services",
   "license": "Apache-2.0",
   "repository": {
@@ -28,7 +28,7 @@
   "peerDependencies": {
     "effect": ">=4.0.0-beta.85 <5"
   },
-  "gitHead": "9886d5dfe4fe6482de550a518af915e28daf79d2",
+  "gitHead": "856412ff6b8e8fcae303941ede49f4492c498d4a",
   "publishConfig": {
     "access": "public"
   }