@@ -312,51 +312,54 @@ export const layer = (options: { readonly hostCwd: string; readonly home: string
 			 * runs once more on a new one; nothing else is retried here.
 			 */
 			const request =
-				(session: Session, name: string, what: string) =>
-				<A>(
-					run: (connection: McpClient.Connection) => Effect.Effect<A, McpClient.Failed>,
-					/** Why the server, as it stands, no longer offers what is asked; checked before every attempt. */
-					unavailable: (server: Server) => string | undefined = () => undefined,
-				): Effect.Effect<A, string> =>
-					Effect.gen(function* () {
-						for (let attempt = 1; ; attempt++) {
-							const server = session.servers.get(name);
-							if (server === undefined || server.closed || server.config.enabled === false)
-								return yield* Effect.fail(`MCP server "${name}" is disabled.`);
-							const reason = unavailable(server);
-							if (reason !== undefined) return yield* Effect.fail(reason);
-							const live = yield* open(server).pipe(
-								Effect.mapError((error) => `MCP server "${name}" is not connected: ${error}`),
-							);
-							live.inflight += 1;
-							const exit = yield* run(live.connection).pipe(
-								Effect.exit,
-								Effect.ensuring(
-									Effect.suspend(() => {
-										live.inflight -= 1;
-										return release(live);
-									}),
-								),
-							);
-							if (Exit.isSuccess(exit)) return exit.value;
-							const error = Cause.findErrorOption(exit.cause);
-							if (error._tag === "None") return yield* Effect.failCause(exit.cause as Cause.Cause<never>);
-							const failure = error.value;
-							if (failure._tag === "Mcp.SessionExpiredError" && attempt === 1) {
-								yield* retire(server, live).pipe(server.lock.withPermits(1));
-								continue;
-							}
-							if (failure._tag === "Mcp.NeedsAuthError") {
-								yield* Effect.gen(function* () {
-									server.state = "needs-auth";
-									server.error = failure.message;
-									yield* retire(server, live);
-								}).pipe(server.lock.withPermits(1));
-								return yield* Effect.fail(`MCP server "${name}" needs sign-in: ${failure.message}`);
+				/** `what` prefixes a failure, naming what failed; without it the server's message is the failure. */
+				(session: Session, name: string, what: string | undefined) =>
+					<A>(
+						run: (connection: McpClient.Connection) => Effect.Effect<A, McpClient.Failed>,
+						/** Why the server, as it stands, no longer offers what is asked; checked before every attempt. */
+						unavailable: (server: Server) => string | undefined = () => undefined,
+					): Effect.Effect<A, string> =>
+						Effect.gen(function* () {
+							for (let attempt = 1; ; attempt++) {
+								const server = session.servers.get(name);
+								if (server === undefined || server.closed || server.config.enabled === false)
+									return yield* Effect.fail(`MCP server "${name}" is disabled.`);
+								const reason = unavailable(server);
+								if (reason !== undefined) return yield* Effect.fail(reason);
+								const live = yield* open(server).pipe(
+									Effect.mapError((error) => `MCP server "${name}" is not connected: ${error}`),
+								);
+								live.inflight += 1;
+								const exit = yield* run(live.connection).pipe(
+									Effect.exit,
+									Effect.ensuring(
+										Effect.suspend(() => {
+											live.inflight -= 1;
+											return release(live);
+										}),
+									),
+								);
+								if (Exit.isSuccess(exit)) return exit.value;
+								const error = Cause.findErrorOption(exit.cause);
+								if (error._tag === "None") return yield* Effect.failCause(exit.cause as Cause.Cause<never>);
+								const failure = error.value;
+								if (failure._tag === "Mcp.SessionExpiredError" && attempt === 1) {
+									yield* retire(server, live).pipe(server.lock.withPermits(1));
+									continue;
+								}
+								if (failure._tag === "Mcp.NeedsAuthError") {
+									yield* Effect.gen(function* () {
+										server.state = "needs-auth";
+										server.error = failure.message;
+										yield* retire(server, live);
+									}).pipe(server.lock.withPermits(1));
+									return yield* Effect.fail(`MCP server "${name}" needs sign-in: ${failure.message}`);
+								}
+								return yield* Effect.fail(
+									what === undefined ? failure.message : `${what} failed: ${failure.message}`,
+								);
 							}
-							return yield* Effect.fail(`${what} failed: ${failure.message}`);
-						}
-					});
+						});
 
 			/** One call of one of the server's tools. A tool call is never retried after the server may have run it. */
 			const call = (session: Session, name: string, tool: string) => (run: McpTool.Run) =>
@@ -378,7 +381,8 @@ export const layer = (options: { readonly hostCwd: string; readonly home: string
 				server.config.enabled !== false && server.resources && (server.config.exposure ?? "direct") !== "hidden";
 
 			const resourceServer = (session: Session, name: string): McpResources.Server => {
-				const reach = request(session, name, `MCP server "${name}"`);
+				// Listings name the server beside each failure already, as Pi does.
+				const reach = request(session, name, undefined);
 				return {
 					name,
 					resources: (cursor) => reach((connection) => connection.resources(cursor)),
@@ -507,6 +511,16 @@ export const layer = (options: { readonly hostCwd: string; readonly home: string
 								[...session.servers.values()]
 									.filter(withResources)
 									.map((server) => resourceServer(session, server.name)),
+							// A server still connecting may offer resources once it has.
+							ready: () =>
+								Effect.forEach(
+									[...session.servers.values()],
+									(server) =>
+										server.config.enabled === false || server.ready === undefined
+											? Effect.void
+											: Deferred.await(server.ready),
+									{ discard: true },
+								),
 							content: output,
 						}),
 					);
 
@@ -81,6 +81,10 @@ const raw = (args: Record<string, unknown>, key: string): Effect.Effect<string |
 	return Effect.succeed(value);
 };
 
+/** A cursor the model passed back: exactly as the server gave it, and absent when blank. */
+const cursorArgument = (args: Record<string, unknown>) =>
+	raw(args, "cursor").pipe(Effect.map((value) => (value?.trim() === "" ? undefined : value)));
+
 /** A name the model typed: trimmed, and absent when blank. */
 const argument = (args: Record<string, unknown>, key: string) =>
 	raw(args, key).pipe(Effect.map((value) => value?.trim() || undefined));
@@ -91,6 +95,8 @@ type Page = { readonly items: ReadonlyArray<Item>; readonly nextCursor?: string
 /** The three resource tools. `servers` answers, when a tool runs, which servers it reaches. */
 export const make = (input: {
 	readonly servers: () => ReadonlyArray<Server>;
+	/** Settles once no server these tools may reach is still connecting. */
+	readonly ready: () => Effect.Effect<void>;
 	readonly content: Omit<McpContent.Options, "readable">;
 }): ReadonlyArray<RegisteredTool> => {
 	const options = { ...input.content, readable: true };
@@ -117,8 +123,8 @@ export const make = (input: {
 	) =>
 		Effect.fnUntraced(function* (args: Record<string, unknown>) {
 			const name = yield* argument(args, "server");
-			// A cursor is the server's opaque token, handed back exactly as it was given.
-			const cursor = yield* raw(args, "cursor");
+			const cursor = yield* cursorArgument(args);
+			yield* input.ready();
 			const visible = (item: Item) => !isMcpApp(item);
 			if (name !== undefined) {
 				const server = yield* find(name);
@@ -150,6 +156,7 @@ export const make = (input: {
 		const uri = yield* argument(args, "uri");
 		if (name === undefined) return yield* Effect.fail("server must be provided");
 		if (uri === undefined) return yield* Effect.fail("uri must be provided");
+		yield* input.ready();
 		const server = yield* find(name);
 		const result = yield* server.read(uri);
 		// Several contents (a directory, say) are labeled with their URIs.
 
@@ -193,6 +193,13 @@
 				"{\"server\":\"e2e\",\"resources\":[{\"server\":\"e2e\",\"name\":\"data\",\"uri\":\"fixture://data.bin\",\"mimeType\":\"application/octet-stream\"}]}"
 			]
 		},
+		"resources-blank": {
+			"status": "completed",
+			"isError": false,
+			"content": [
+				"{\"server\":\"e2e\",\"resources\":[{\"server\":\"e2e\",\"name\":\"notes\",\"uri\":\"fixture://notes.txt\",\"mimeType\":\"text/plain\"}],\"nextCursor\":\" page-2 \"}"
+			]
+		},
 		"templates": {
 			"status": "completed",
 			"isError": false,
 
@@ -119,6 +119,8 @@ it("mcp: config layers, plugin bucket, direct tools, a crash mid-exchange and th
 				pendingCall("list_mcp_resources", { server: "e2e" }, "resources-page"),
 				// The server's cursor goes back exactly as it was given, spaces and all.
 				pendingCall("list_mcp_resources", { server: "e2e", cursor: " page-2 " }, "resources-next"),
+				// Models fill optional strings with "": a blank cursor is no cursor.
+				pendingCall("list_mcp_resources", { server: "e2e", cursor: "" }, "resources-blank"),
 				pendingCall("list_mcp_resource_templates", {}, "templates"),
 				pendingCall("read_mcp_resource", { server: "e2e", uri: "fixture://notes.txt" }, "read-text"),
 				pendingCall("read_mcp_resource", { server: "e2e", uri: "fixture://data.bin" }, "read-binary"),
@@ -239,6 +241,7 @@ it("mcp: config layers, plugin bucket, direct tools, a crash mid-exchange and th
 				"resources-all",
 				"resources-page",
 				"resources-next",
+				"resources-blank",
 				"templates",
 				"read-text",
 				"read-binary",
 
@@ -10,7 +10,7 @@ CodeWork connects to [MCP](https://modelcontextprotocol.io) servers over stdio o
 
 MCP servers always run on your machine, the one running CodeWork, whatever sandbox the session uses.
 
-- A stdio server starts in the session's directory when the session runs in the local sandbox, otherwise in the project directory.
+- A stdio server starts in the session's directory when the session runs in the local sandbox, otherwise in the session's folder on your machine.
 - HTTP servers are called from your machine.
 - Output too large to show, and binary files, are saved to your OS temp directory.
 
@@ -41,7 +41,9 @@ User servers go in `~/.codework/mcp.json`, project servers in `.codework/mcp.jso
 | `url`, `headers`                                 | HTTP   | A streamable HTTP endpoint. SSE is not supported.                                                 |
 | `enabled`, `timeout`, `exposure`, `toolExposure` | both   | Off switch, per-request timeout in seconds (default 60), and which tools the model sees.          |
 
-`env` and `headers` values can use `${NAME}` for an environment variable, or `!command` to use a command's output.
+`env` and `headers` values can use `${NAME}` or `$NAME` for an environment variable (`$$` for a literal `$`), or `!command` to use a command's output. A command runs once, and its output is reused until CodeWork restarts.
+
+Servers that need you to sign in are not supported yet.
 
 A broken file or entry is reported and skipped. The other servers still connect.
 
@@ -66,6 +68,6 @@ Servers with resources also add `list_mcp_resources`, `list_mcp_resource_templat
 ## Connections
 
 - Servers connect in the background. A message waits up to 10 seconds for servers it starts whose tools the model sees: all of them at first, then new or changed ones.
-- If a server stops, the next call starts it again.
+- If a server stops, the next call starts it again. If it fails to connect, your next message tries again.
 - Edits to `mcp.json` apply from your next message. Changing only `exposure` or `toolExposure` keeps the server running.
 - Server log messages go to `~/.codework/mcp.log`.