From c041a521731e59713c91a795212003b8ae10b6dc Mon Sep 17 00:00:00 2001
From: omartelo <meopedevts@proton.me>
Date: Sun, 1 Nov 2026 18:14:20 -0300
Subject: [PATCH] feat(mcp): manage project services from an agent with the
 *_service tools and lich service

An agent can do to a project's services what the Services footer does:
list, create, edit, delete, start, stop, force-stop and restart one, start
or stop them all, and read its console as it is at the call. A service is
named by its name in the project, the caller's own unless one is named;
spawn.Project resolves the project to the id the services methods take.

services.LiveOutput reads a running service's replay tail, leaving Output
as the window reads it: nil while the service runs.
---
 CHANGELOG.md                            |   2 +
 api/services.go                         |  21 +-
 api/spawn.go                            |  16 +
 api/testdata/contract.golden            |  13 +
 docs/cli.md                             |  51 ++-
 internal/cli/cli.go                     |   2 +
 internal/cli/help.go                    |  12 +
 internal/cli/mcp.go                     |   4 +-
 internal/cli/mcp_test.go                |  75 +++--
 internal/cli/services.go                | 426 ++++++++++++++++++++++++
 internal/cli/services_test.go           | 316 ++++++++++++++++++
 internal/routes/routes.go               |   1 +
 internal/routes/services.go             |   1 +
 internal/services/rpc.go                |   6 +
 internal/services/run.go                |   9 +
 internal/services/services_unix_test.go |  30 ++
 internal/spawn/project_ref.go           |  22 ++
 internal/spawn/project_ref_test.go      |  33 ++
 internal/terminal/service.go            |  12 +
 19 files changed, 1007 insertions(+), 45 deletions(-)
 create mode 100644 internal/cli/services.go
 create mode 100644 internal/cli/services_test.go
 create mode 100644 internal/spawn/project_ref.go
 create mode 100644 internal/spawn/project_ref_test.go

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 379e1563f..68a231997 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -16,6 +16,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - opencode 2 runs in lich. lich tells it from opencode 1 by its version and opens it the way 2 expects: each session on a server of its own, so its profile, its model and lich's tools reach it, with forks, Unfold long pastes, profile logins and the OpenCode Go gauge working as they do on opencode 1. Conversations started in opencode 2, and opencode 1 ones it has continued, show their cost, closing words and search results again, and are listed in History. The card's spinner, ring, bell and title need the lich plugin's next release, installed from Settings › Providers, which now goes where opencode 2 reads plugins and takes the place of the copy an older lich installed. A session lich opens is not on opencode 2's shared background server, so `opencode pair` and the desktop app don't see it.
 - The Description heading on the Pulls screen's Overview has a ⋯ menu, as GitHub's comments do: Copy link copies the pull request's address, Copy Markdown its description as written, and Edit opens the description for editing, which the Edit button beside the heading did before.
 
+- An agent can manage a project's services as the Services footer does: list, create, edit, delete, start, stop, force-stop and restart one, start or stop them all, and read what one has printed, running or stopped, with the `*_service` MCP tools or `lich service` from a terminal. A service is named by its name in the project, the agent's own unless it names another.
+
 ### Changed
 
 - Pull request descriptions, comments and Markdown previews are easier to read, with brighter text, clearer headings and links, inline code highlighted, more room between lines and blocks, and wrapped list items aligned with their text.
diff --git a/api/services.go b/api/services.go
index 0e704fd99..0ad6d4728 100644
--- a/api/services.go
+++ b/api/services.go
@@ -1,16 +1,17 @@
 package api
 
 var (
-	ServicesList      = define[None, []Service]("services.List")
-	ServicesSave      = define[SaveServiceOptions, Service]("services.Save")
-	ServicesDelete    = define[ServiceIDOptions, None]("services.Delete")
-	ServicesStart     = define[ServiceIDOptions, None]("services.Start")
-	ServicesStop      = define[ServiceIDOptions, None]("services.Stop")
-	ServicesForceStop = define[ServiceIDOptions, None]("services.ForceStop")
-	ServicesRestart   = define[ServiceIDOptions, None]("services.Restart")
-	ServicesStartAll  = define[ProjectIDOptions, None]("services.StartAll")
-	ServicesStopAll   = define[ProjectIDOptions, None]("services.StopAll")
-	ServicesOutput    = define[ServiceIDOptions, []byte]("services.Output")
+	ServicesList       = define[None, []Service]("services.List")
+	ServicesSave       = define[SaveServiceOptions, Service]("services.Save")
+	ServicesDelete     = define[ServiceIDOptions, None]("services.Delete")
+	ServicesStart      = define[ServiceIDOptions, None]("services.Start")
+	ServicesStop       = define[ServiceIDOptions, None]("services.Stop")
+	ServicesForceStop  = define[ServiceIDOptions, None]("services.ForceStop")
+	ServicesRestart    = define[ServiceIDOptions, None]("services.Restart")
+	ServicesStartAll   = define[ProjectIDOptions, None]("services.StartAll")
+	ServicesStopAll    = define[ProjectIDOptions, None]("services.StopAll")
+	ServicesOutput     = define[ServiceIDOptions, []byte]("services.Output")
+	ServicesLiveOutput = define[ServiceIDOptions, []byte]("services.LiveOutput")
 )
 
 // The states a Service is in. A service that is not running is stopped when it
diff --git a/api/spawn.go b/api/spawn.go
index 2418278e3..0b310971a 100644
--- a/api/spawn.go
+++ b/api/spawn.go
@@ -13,6 +13,7 @@ var (
 	SpawnRenameFolder = define[RenameFolderOptions, RenamedFolder]("spawn.RenameFolder")
 	SpawnColorFolder  = define[ColorFolderOptions, ColoredFolder]("spawn.ColorFolder")
 	SpawnRename       = define[RenameSessionOptions, RenamedSession]("spawn.Rename")
+	SpawnProject      = define[ProjectRefOptions, ProjectRef]("spawn.Project")
 )
 
 // OpenSessionOptions is one Open call. It travels as a single JSON object rather than
@@ -303,3 +304,18 @@ type RenamedSession struct {
 	Label    string `json:"label"`
 	Previous string `json:"previous"`
 }
+
+// ProjectRefOptions names an open project the way every spawn call does: by
+// name or by directory path, empty for the caller's own.
+type ProjectRefOptions struct {
+	From    string `json:"from"`
+	Project string `json:"project"`
+}
+
+// ProjectRef is the open project a ProjectRefOptions resolved to: the id the
+// methods keyed by project (services.Save, services.StartAll) take.
+type ProjectRef struct {
+	ID   string `json:"id"`
+	Name string `json:"name"`
+	Path string `json:"path"`
+}
diff --git a/api/testdata/contract.golden b/api/testdata/contract.golden
index 42ca8bdfb..f126ca6f5 100644
--- a/api/testdata/contract.golden
+++ b/api/testdata/contract.golden
@@ -157,6 +157,7 @@ relay.Wait(WaitOptions) SendResult
 services.Delete(ServiceIDOptions) None
 services.ForceStop(ServiceIDOptions) None
 services.List(None) []Service
+services.LiveOutput(ServiceIDOptions) base64
 services.Output(ServiceIDOptions) base64
 services.Restart(ServiceIDOptions) None
 services.Save(SaveServiceOptions) Service
@@ -173,6 +174,7 @@ spawn.File(FileSessionOptions) FiledSession
 spawn.Folders(FoldersOptions) []SessionFolder
 spawn.Open(OpenSessionOptions) OpenedSession
 spawn.OpenSubagent(OpenSubagentOptions) OpenedSession
+spawn.Project(ProjectRefOptions) ProjectRef
 spawn.Rename(RenameSessionOptions) RenamedSession
 spawn.RenameFolder(RenameFolderOptions) RenamedFolder
 spawn.Worktrees(WorktreesOptions) []WorktreeCheckout
@@ -1191,6 +1193,17 @@ OpenSubagentOptions {
 	ultracode bool
 }
 
+ProjectRefOptions {
+	from string
+	project string
+}
+
+ProjectRef {
+	id string
+	name string
+	path string
+}
+
 RenameSessionOptions {
 	from string
 	target string
diff --git a/docs/cli.md b/docs/cli.md
index b95507afc..2568ca1c9 100644
--- a/docs/cli.md
+++ b/docs/cli.md
@@ -672,6 +672,44 @@ session on /home/you/src/revu again reopens the project with them.
 - **The home project is refused**, as the window refuses it.
 - Unlike the window's close, nothing asks first when sessions are running.
 
+### `lich service [--project <name-or-path>] [--name <name>] [--command <command>] [--start-with-lich[=false]] [--json] <verb> [args]`
+
+Manages a project's services, the commands the window's Services footer runs
+on a console of their own. The project defaults to the caller's own; a service
+is named by its name in the project, matched without regard to case. Flags go
+before the verb.
+
+- `list` prints every service with its state (`running`, `stopping`,
+  `stopped`, `failed`):
+
+  ```
+  service	state	command
+  web	running	pnpm dev
+  db	stopped	docker compose up db
+  ```
+
+- `add <name> <command>` saves a new one, stopped; `--start-with-lich` starts
+  it whenever lich starts with the project open.
+- `edit <service>` changes only what `--name`, `--command` and
+  `--start-with-lich` (`=false` to clear it) give. A running service keeps its
+  old command until its next start.
+- `delete <service>` removes a stopped one; a running one is refused.
+- `start <service>` and `stop <service>`. Stop asks as Ctrl+C at the console
+  does, so the row printed may still read `stopping`.
+- `force-stop <service>` kills one that ignores the stop or takes too long.
+- `restart <service>` stops a running one and starts it again once it exits,
+  picking up an edited command; one that is not running is started.
+- `start-all` and `stop-all` start or stop every service of the project, and
+  print the list as it is afterwards.
+- `output <service>` prints the console as it is at that moment, terminal
+  escapes included: what a running one has printed so far (its last 2 MiB),
+  or what a stopped or failed one printed in its last run. One read, not a
+  stream.
+
+`list`, `start-all` and `stop-all` print the project's services; every other
+verb but `output` prints the one service as it is afterwards. `--json` prints
+them as the `services` RPC result shapes them, and `output` as a JSON string.
+
 ### `lich rename [--project <name-or-path>] [--json] [<session>] <label>`
 
 Renames a session — the name on its card, which is also the name it is addressed
@@ -1007,6 +1045,17 @@ at lich.
 | `open_session` | optional `project` (a name, or an absolute directory path, which is opened as a project first), `kind`, `worktree`, `base`, `model`, `effort`, `ultracode`, `folder` — `lich open` — plus optional `prompt` and `private` — `lich open --prompt [--private]`, the same hand-off in the same call. |
 | `close_session` | `session`, optional `project`, `worktree` (`keep`/`remove`), `force`. |
 | `close_project` | `project` (a name or a directory path) — `lich close-project`. |
+| `list_services` | optional `project`: the project's services with their state, as JSON. `lich service list`. |
+| `create_service` | `name`, `command`, optional `start_with_lich` and `project`. Saved, not started. `lich service add`. |
+| `edit_service` | `service`, optional `name`, `command`, `start_with_lich` and `project`; what is left out stays. `lich service edit`. |
+| `delete_service` | `service`, optional `project`; a running one is refused. `lich service delete`. |
+| `start_service` | `service`, optional `project`. `lich service start`. |
+| `stop_service` | `service`, optional `project`; asks it to stop as Ctrl+C does, so the answer may read `stopping`. `lich service stop`. |
+| `force_stop_service` | `service`, optional `project`; kills it without waiting. `lich service force-stop`. |
+| `restart_service` | `service`, optional `project`. `lich service restart`. |
+| `start_all_services` | optional `project`; answers with the project's services. `lich service start-all`. |
+| `stop_all_services` | optional `project`; answers with the project's services. `lich service stop-all`. |
+| `read_service_output` | `service`, optional `project`: the console as it is now, a running one's so far or a stopped one's last run. `lich service output`. |
 | `rename_session` | `label`, optional `session` (omitted renames the caller's own) and `project` — `lich rename`. |
 | `control_session` | Experimental. `session`, `action` (`prompt`, `abort`, `model`, `effort`, `command`), optional `value`, `args` (`command` only) and `project`. `lich control`. Delivered is a result, not an error; a command the session never took is withdrawn and fails. |
 | `ask_session` | Experimental. `session`, `question`, optional `project`. `lich ask`: the answer is the result, and every way it ends without one is an error. |
@@ -1023,7 +1072,7 @@ error: the agent should read what went wrong and act on it, not lose the turn.
 clients inject into the agent's system prompt. It is the one place the whole
 journey (fan out into worktree sessions, carry on, collect) is told as one;
 the tool descriptions each only explain their own door. `list_sessions`,
-`list_worktrees` and `list_folders` are annotated `readOnlyHint`, so a client
+`list_worktrees`, `list_folders`, `list_services` and `read_service_output` are annotated `readOnlyHint`, so a client
 may auto-allow them.
 
 `file_session`, `rename_folder` and `color_folder` refuse a call that leaves out
diff --git a/internal/cli/cli.go b/internal/cli/cli.go
index 83b1ef355..240a8f3fe 100644
--- a/internal/cli/cli.go
+++ b/internal/cli/cli.go
@@ -161,6 +161,8 @@ func dispatch(args []string, c *client) int {
 		return c.run(c.close, args[1:])
 	case "close-project":
 		return c.run(c.closeProject, args[1:])
+	case "service":
+		return c.run(c.service, args[1:])
 	case "rename":
 		return c.run(c.rename, args[1:])
 	case "control":
diff --git a/internal/cli/help.go b/internal/cli/help.go
index 9e4ab29c2..7ba1a478d 100644
--- a/internal/cli/help.go
+++ b/internal/cli/help.go
@@ -115,6 +115,18 @@ var commands = []command{
 			"it, so opening a session on its path reopens it. The project the command\n" +
 			"runs in and the home project are refused.",
 	},
+	{
+		name: "service",
+		args: "[--project <name-or-path>] [--name <name>] [--command <command>]\n" +
+			"            [--start-with-lich[=false]] [--json]\n" +
+			"            list | add <name> <command> | edit <service> | delete <service>\n" +
+			"            | start <service> | stop <service> | force-stop <service>\n" +
+			"            | restart <service> | start-all | stop-all | output <service>",
+		about: "Manage a project's services, the commands lich runs on a console of their\n" +
+			"own: list, save, change, delete, start, stop, kill or restart one, start\n" +
+			"or stop them all, or print its console as it is now. Flags go before\n" +
+			"the verb; edit changes only the ones given.",
+	},
 	{
 		name: "rename",
 		args: "[--project <name-or-path>] [--json] [<session>] <label>",
diff --git a/internal/cli/mcp.go b/internal/cli/mcp.go
index 7355ec4dc..3a08ca33d 100644
--- a/internal/cli/mcp.go
+++ b/internal/cli/mcp.go
@@ -465,7 +465,7 @@ func property(kind, description string) map[string]any {
 }
 
 // mcpTools is the whole tool surface. Adding one is an entry here, or in
-// folderTools, controlTools, askTools, closeProjectTools or browserTools. That is why registering
+// folderTools, controlTools, askTools, closeProjectTools, serviceTools or browserTools. That is why registering
 // MCP once buys every tool lich grows later, on every provider that took the
 // registration, with no further per-provider work.
 var mcpTools = append([]mcpTool{
@@ -761,7 +761,7 @@ var mcpTools = append([]mcpTool{
 			return "Answer sent.", nil
 		},
 	},
-}, append(append(append(append(folderTools, controlTools...), askTools...), closeProjectTools...), browserTools...)...)
+}, append(append(append(append(append(folderTools, controlTools...), askTools...), closeProjectTools...), serviceTools...), browserTools...)...)
 
 // handOver gives a just-opened session its first task, wording the outcome the
 // way send_to_session words it — the caller should not have to learn two
diff --git a/internal/cli/mcp_test.go b/internal/cli/mcp_test.go
index fee1017d0..474949919 100644
--- a/internal/cli/mcp_test.go
+++ b/internal/cli/mcp_test.go
@@ -228,42 +228,53 @@ func TestMCPListsEveryTool(t *testing.T) {
 	resultOf(t, replies[0], &result)
 
 	want := map[string][]string{
-		"list_sessions":      {},
-		"open_session":       {},
-		"close_session":      {"session"},
-		"close_project":      {"project"},
-		"rename_session":     {"label"},
-		"list_worktrees":     {},
-		"send_to_session":    {"session", "prompt"},
-		"wait_for_answer":    {},
-		"reply_to_session":   {"answer"},
-		"list_folders":       {},
-		"file_session":       {"folder"},
-		"rename_folder":      {"folder", "to"},
-		"color_folder":       {"folder", "color"},
-		"control_session":    {"session", "action"},
-		"ask_session":        {"session", "question"},
-		"browser_open":       {},
-		"browser_info":       {},
-		"browser_click":      {},
-		"browser_type":       {"text"},
-		"browser_press":      {"key"},
-		"browser_screenshot": {},
-		"browser_navigate":   {"url"},
-		"browser_reload":     {},
-		"browser_back":       {},
-		"browser_forward":    {},
-		"browser_scroll":     {},
-		"browser_dialog":     {"accept"},
-		"browser_list":       {},
-		"browser_close":      {},
-		"browser_tabs":       {},
-		"browser_tab":        {"action"},
+		"list_sessions":       {},
+		"open_session":        {},
+		"close_session":       {"session"},
+		"close_project":       {"project"},
+		"list_services":       {},
+		"create_service":      {"name", "command"},
+		"edit_service":        {"service"},
+		"delete_service":      {"service"},
+		"start_service":       {"service"},
+		"stop_service":        {"service"},
+		"force_stop_service":  {"service"},
+		"restart_service":     {"service"},
+		"start_all_services":  {},
+		"stop_all_services":   {},
+		"read_service_output": {"service"},
+		"rename_session":      {"label"},
+		"list_worktrees":      {},
+		"send_to_session":     {"session", "prompt"},
+		"wait_for_answer":     {},
+		"reply_to_session":    {"answer"},
+		"list_folders":        {},
+		"file_session":        {"folder"},
+		"rename_folder":       {"folder", "to"},
+		"color_folder":        {"folder", "color"},
+		"control_session":     {"session", "action"},
+		"ask_session":         {"session", "question"},
+		"browser_open":        {},
+		"browser_info":        {},
+		"browser_click":       {},
+		"browser_type":        {"text"},
+		"browser_press":       {"key"},
+		"browser_screenshot":  {},
+		"browser_navigate":    {"url"},
+		"browser_reload":      {},
+		"browser_back":        {},
+		"browser_forward":     {},
+		"browser_scroll":      {},
+		"browser_dialog":      {"accept"},
+		"browser_list":        {},
+		"browser_close":       {},
+		"browser_tabs":        {},
+		"browser_tab":         {"action"},
 	}
 	// The read-only ones, which a client may auto-allow. wait_for_answer is
 	// not among them: collecting drains the inbox.
 	readOnly := map[string]bool{
-		"list_sessions": true, "list_worktrees": true, "list_folders": true,
+		"list_sessions": true, "list_worktrees": true, "list_folders": true, "list_services": true, "read_service_output": true,
 		"browser_info": true, "browser_list": true, "browser_screenshot": true, "browser_tabs": true,
 	}
 	if len(result.Tools) != len(want) {
diff --git a/internal/cli/services.go b/internal/cli/services.go
new file mode 100644
index 000000000..73aedc704
--- /dev/null
+++ b/internal/cli/services.go
@@ -0,0 +1,426 @@
+package cli
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"flag"
+	"fmt"
+	"strings"
+
+	"github.com/lichdotdev/lich/api"
+)
+
+// A project's services on both surfaces: `lich service` and the *_service MCP
+// tools. Both name a service by its name within a project, the caller's own
+// unless one is named, because the id is nothing a person or an agent has seen;
+// the methods underneath are the window's own (api.Services*).
+
+// serviceEdit is what an edit changes; a nil field keeps the saved value.
+type serviceEdit struct {
+	name, command *string
+	startWithLich *bool
+}
+
+// projectServices is the project a call is aimed at and the services saved in it.
+func projectServices(ctx context.Context, c *client, project string) (api.ProjectRef, []api.Service, error) {
+	ref, err := callMethod(ctx, c, api.SpawnProject, api.ProjectRefOptions{From: c.sessionID(), Project: project}, shortCall)
+	if err != nil {
+		return api.ProjectRef{}, nil, err
+	}
+	all, err := callMethod(ctx, c, api.ServicesList, api.None{}, shortCall)
+	if err != nil {
+		return api.ProjectRef{}, nil, err
+	}
+	own := []api.Service{}
+	for _, s := range all {
+		if s.ProjectID == ref.ID {
+			own = append(own, s)
+		}
+	}
+	return ref, own, nil
+}
+
+// findService matches the way services.Save keeps names apart: case aside.
+func findService(ref api.ProjectRef, list []api.Service, name string) (api.Service, error) {
+	names := make([]string, 0, len(list))
+	for _, s := range list {
+		if strings.EqualFold(s.Name, strings.TrimSpace(name)) {
+			return s, nil
+		}
+		names = append(names, fmt.Sprintf("%q", s.Name))
+	}
+	if len(names) == 0 {
+		return api.Service{}, fmt.Errorf("%s has no services", ref.Name)
+	}
+	return api.Service{}, fmt.Errorf("no service named %q in %s. Its services: %s", name, ref.Name, strings.Join(names, ", "))
+}
+
+func createService(ctx context.Context, c *client, project, name, command string, startWithLich bool) (api.Service, error) {
+	ref, err := callMethod(ctx, c, api.SpawnProject, api.ProjectRefOptions{From: c.sessionID(), Project: project}, shortCall)
+	if err != nil {
+		return api.Service{}, err
+	}
+	return callMethod(ctx, c, api.ServicesSave, api.SaveServiceOptions{
+		ProjectID: ref.ID, Name: name, Command: command, StartWithLich: startWithLich,
+	}, shortCall)
+}
+
+func editService(ctx context.Context, c *client, project, name string, edit serviceEdit) (api.Service, error) {
+	ref, list, err := projectServices(ctx, c, project)
+	if err != nil {
+		return api.Service{}, err
+	}
+	s, err := findService(ref, list, name)
+	if err != nil {
+		return api.Service{}, err
+	}
+	opts := api.SaveServiceOptions{
+		ID: s.ID, ProjectID: s.ProjectID, Name: s.Name, Command: s.Command, StartWithLich: s.StartWithLich,
+	}
+	if edit.name != nil {
+		opts.Name = *edit.name
+	}
+	if edit.command != nil {
+		opts.Command = *edit.command
+	}
+	if edit.startWithLich != nil {
+		opts.StartWithLich = *edit.startWithLich
+	}
+	return callMethod(ctx, c, api.ServicesSave, opts, shortCall)
+}
+
+// actOnService runs one of the id-keyed methods (start, stop, delete) on the
+// service name names, and answers with the service as it is afterwards; a
+// deleted one as it was.
+func actOnService(ctx context.Context, c *client, project, name string, m api.Method[api.ServiceIDOptions, api.None]) (api.Service, error) {
+	ref, list, err := projectServices(ctx, c, project)
+	if err != nil {
+		return api.Service{}, err
+	}
+	s, err := findService(ref, list, name)
+	if err != nil {
+		return api.Service{}, err
+	}
+	if _, err := callMethod(ctx, c, m, api.ServiceIDOptions{ID: s.ID}, shortCall); err != nil {
+		return api.Service{}, err
+	}
+	if m.Name == api.ServicesDelete.Name {
+		return s, nil
+	}
+	_, list, err = projectServices(ctx, c, project)
+	if err != nil {
+		return api.Service{}, err
+	}
+	return findService(ref, list, s.Name)
+}
+
+// actOnProject runs StartAll or StopAll on a project and answers with its
+// services as they are afterwards.
+func actOnProject(ctx context.Context, c *client, project string, m api.Method[api.ProjectIDOptions, api.None]) ([]api.Service, error) {
+	ref, _, err := projectServices(ctx, c, project)
+	if err != nil {
+		return nil, err
+	}
+	if _, err := callMethod(ctx, c, m, api.ProjectIDOptions{ID: ref.ID}, shortCall); err != nil {
+		return nil, err
+	}
+	_, list, err := projectServices(ctx, c, project)
+	return list, err
+}
+
+// serviceOutput is the service's console at the moment of the call: what the
+// run still going has printed so far, or else what its last run printed.
+func serviceOutput(ctx context.Context, c *client, project, name string) (string, error) {
+	ref, list, err := projectServices(ctx, c, project)
+	if err != nil {
+		return "", err
+	}
+	s, err := findService(ref, list, name)
+	if err != nil {
+		return "", err
+	}
+	m := api.ServicesOutput
+	if s.State == api.ServiceRunning || s.State == api.ServiceStopping {
+		m = api.ServicesLiveOutput
+	}
+	out, err := callMethod(ctx, c, m, api.ServiceIDOptions{ID: s.ID}, shortCall)
+	return string(out), err
+}
+
+// serviceVerbs are the `lich service` verbs that run one id-keyed method on
+// one service, and projectVerbs the ones that run a method on the project.
+var (
+	serviceVerbs = map[string]api.Method[api.ServiceIDOptions, api.None]{
+		"delete": api.ServicesDelete, "start": api.ServicesStart, "stop": api.ServicesStop,
+		"force-stop": api.ServicesForceStop, "restart": api.ServicesRestart,
+	}
+	projectVerbs = map[string]api.Method[api.ProjectIDOptions, api.None]{
+		"start-all": api.ServicesStartAll, "stop-all": api.ServicesStopAll,
+	}
+)
+
+// service is `lich service`: whatever the window's Services footer does to a
+// project's services, from a terminal.
+func (c *client) service(args []string) error {
+	flags := newFlagSet("service")
+	project := flags.String("project", "", "project the service is in, by name or by directory path; defaults to the caller's own")
+	name := flags.String("name", "", "edit: the service's new name")
+	command := flags.String("command", "", "edit: the service's new command")
+	startWithLich := flags.Bool("start-with-lich", false, "add, edit: start the service whenever lich starts with its project open")
+	asJSON := flags.Bool("json", false, "print the result as JSON")
+	if err := c.parse(flags, args); err != nil {
+		return err
+	}
+	ctx := context.Background()
+	verb, rest := flags.Arg(0), flags.Args()
+	if len(rest) > 0 {
+		rest = rest[1:]
+	}
+	serviceMethod, isServiceVerb := serviceVerbs[verb]
+	projectMethod, isProjectVerb := projectVerbs[verb]
+
+	switch {
+	case verb == "list" && len(rest) == 0:
+		_, list, err := projectServices(ctx, c, *project)
+		return c.printServices(list, err, *asJSON)
+	case isProjectVerb && len(rest) == 0:
+		list, err := actOnProject(ctx, c, *project, projectMethod)
+		return c.printServices(list, err, *asJSON)
+	case verb == "output" && len(rest) == 1:
+		out, err := serviceOutput(ctx, c, *project, rest[0])
+		return c.printOutput(out, err, *asJSON)
+	case isServiceVerb && len(rest) == 1:
+		s, err := actOnService(ctx, c, *project, rest[0], serviceMethod)
+		return c.printService(s, err, *asJSON)
+	case verb == "add" && len(rest) == 2:
+		s, err := createService(ctx, c, *project, rest[0], rest[1], *startWithLich)
+		return c.printService(s, err, *asJSON)
+	case verb == "edit" && len(rest) == 1:
+		s, err := editService(ctx, c, *project, rest[0], setEdit(flags, *name, *command, *startWithLich))
+		return c.printService(s, err, *asJSON)
+	}
+	return usageError("service")
+}
+
+// setEdit keeps only the edit flags given on the command line: an absent one
+// leaves the saved value alone, where its zero value would clear it.
+func setEdit(flags *flag.FlagSet, name, command string, startWithLich bool) serviceEdit {
+	var edit serviceEdit
+	flags.Visit(func(f *flag.Flag) {
+		switch f.Name {
+		case "name":
+			edit.name = &name
+		case "command":
+			edit.command = &command
+		case "start-with-lich":
+			edit.startWithLich = &startWithLich
+		}
+	})
+	return edit
+}
+
+func (c *client) printService(s api.Service, err error, asJSON bool) error {
+	if err == nil && asJSON {
+		return c.emit(s)
+	}
+	return c.printServices([]api.Service{s}, err, false)
+}
+
+func (c *client) printOutput(out string, err error, asJSON bool) error {
+	if err != nil {
+		return err
+	}
+	if asJSON {
+		return c.emit(out)
+	}
+	fmt.Fprint(c.stdout, out)
+	return nil
+}
+
+func (c *client) printServices(list []api.Service, err error, asJSON bool) error {
+	if err != nil {
+		return err
+	}
+	if asJSON {
+		return c.emit(list)
+	}
+	if len(list) == 0 {
+		fmt.Fprintln(c.stdout, "No services.")
+		return nil
+	}
+	fmt.Fprintln(c.stdout, "service\tstate\tcommand")
+	for _, s := range list {
+		fmt.Fprintf(c.stdout, "%s\t%s\t%s\n", s.Name, s.State, s.Command)
+	}
+	return nil
+}
+
+func serviceJSON(v any) (string, error) {
+	out, err := json.Marshal(v)
+	if err != nil {
+		return "", fmt.Errorf("encode the service: %w", err)
+	}
+	return string(out), nil
+}
+
+const (
+	serviceProjectUsage = "The project the service is in, by name or by directory path. " +
+		"Leave it out for the project this session runs in."
+	serviceNameUsage = "The service, by its name in the project."
+)
+
+func projectActionTool(name, description string, m api.Method[api.ProjectIDOptions, api.None]) mcpTool {
+	return mcpTool{
+		Name: name, Description: description,
+		Schema: schema(map[string]any{"project": property("string", serviceProjectUsage)}),
+		Run: func(ctx context.Context, c *client, args mcpArgs) (string, error) {
+			list, err := actOnProject(ctx, c, args.text("project"), m)
+			if err != nil {
+				return "", err
+			}
+			return serviceJSON(list)
+		},
+	}
+}
+
+// serviceByName is the schema of a tool that names one service and nothing else.
+func serviceByName() map[string]any {
+	return schema(map[string]any{
+		"project": property("string", serviceProjectUsage),
+		"service": property("string", serviceNameUsage),
+	}, "service")
+}
+
+func serviceActionTool(name, description string, m api.Method[api.ServiceIDOptions, api.None]) mcpTool {
+	return mcpTool{
+		Name: name, Description: description, Schema: serviceByName(),
+		Run: func(ctx context.Context, c *client, args mcpArgs) (string, error) {
+			s, err := actOnService(ctx, c, args.text("project"), args.text("service"), m)
+			if err != nil {
+				return "", err
+			}
+			return serviceJSON(s)
+		},
+	}
+}
+
+// serviceTools are the project services as MCP tools, appended to mcpTools.
+var serviceTools = []mcpTool{
+	{
+		Name: "list_services",
+		Description: "List a project's services: commands saved once (a dev server, a container, a " +
+			"tunnel) that lich runs on a console of their own, outside the session list. Each " +
+			"carries its name, command, whether it starts with lich, and its state: `running`, " +
+			"`stopping`, `stopped` (exited 0 or was asked to stop) or `failed` (exited on its own " +
+			"with another code, in exitCode).",
+		Schema:   schema(map[string]any{"project": property("string", serviceProjectUsage)}),
+		ReadOnly: true,
+		Run: func(ctx context.Context, c *client, args mcpArgs) (string, error) {
+			_, list, err := projectServices(ctx, c, args.text("project"))
+			if err != nil {
+				return "", err
+			}
+			return serviceJSON(list)
+		},
+	},
+	{
+		Name: "create_service",
+		Description: "Save a new service in a project: a command lich runs in the project's " +
+			"directory until it exits. It is not started; start_service does that. Its name must " +
+			"be free in the project.",
+		Schema: schema(map[string]any{
+			"project":         property("string", serviceProjectUsage),
+			"name":            property("string", "The service's name, unique in the project."),
+			"command":         property("string", "The shell command the service runs."),
+			"start_with_lich": property("boolean", "Start the service whenever lich starts with its project open."),
+		}, "name", "command"),
+		Run: func(ctx context.Context, c *client, args mcpArgs) (string, error) {
+			s, err := createService(ctx, c, args.text("project"), args.text("name"), args.text("command"), args.flag("start_with_lich"))
+			if err != nil {
+				return "", err
+			}
+			return serviceJSON(s)
+		},
+	},
+	{
+		Name: "edit_service",
+		Description: "Change a saved service's name, command or start_with_lich; what is left out " +
+			"stays as it is. A running service keeps the command it started with until its next start.",
+		Schema: schema(map[string]any{
+			"project":         property("string", serviceProjectUsage),
+			"service":         property("string", serviceNameUsage),
+			"name":            property("string", "The service's new name."),
+			"command":         property("string", "The service's new command."),
+			"start_with_lich": property("boolean", "Start the service whenever lich starts with its project open."),
+		}, "service"),
+		Run: func(ctx context.Context, c *client, args mcpArgs) (string, error) {
+			edit, err := mcpEdit(args)
+			if err != nil {
+				return "", err
+			}
+			s, err := editService(ctx, c, args.text("project"), args.text("service"), edit)
+			if err != nil {
+				return "", err
+			}
+			return serviceJSON(s)
+		},
+	},
+	serviceActionTool("delete_service",
+		"Delete a saved service. A running one is refused: stop it first.", api.ServicesDelete),
+	serviceActionTool("start_service",
+		"Start a service on its own console in its project's directory. One already running is left alone.",
+		api.ServicesStart),
+	serviceActionTool("stop_service",
+		"Ask a running service to stop, as Ctrl+C at its console does. The answer may still read "+
+			"`stopping`: list_services shows when it is down.", api.ServicesStop),
+	serviceActionTool("force_stop_service",
+		"Kill a running service without waiting for it to agree: for one that ignores stop_service "+
+			"or takes too long over it.", api.ServicesForceStop),
+	serviceActionTool("restart_service",
+		"Stop a running service and start it again once it exits, picking up an edited command; "+
+			"one that is not running is started.", api.ServicesRestart),
+	projectActionTool("start_all_services",
+		"Start every service of a project that is not running.", api.ServicesStartAll),
+	projectActionTool("stop_all_services",
+		"Ask every running service of a project to stop, as stop_service does.", api.ServicesStopAll),
+	{
+		Name: "read_service_output",
+		Description: "Read a service's console as it is right now, terminal escapes included: what " +
+			"a running one has printed so far, or what a stopped or failed one printed in its last " +
+			"run. It is one read, not a stream: call it again to see what came since.",
+		Schema:   serviceByName(),
+		ReadOnly: true,
+		Run: func(ctx context.Context, c *client, args mcpArgs) (string, error) {
+			out, err := serviceOutput(ctx, c, args.text("project"), args.text("service"))
+			if err != nil {
+				return "", err
+			}
+			if out == "" {
+				return "The service has printed nothing yet.", nil
+			}
+			return out, nil
+		},
+	},
+}
+
+// mcpEdit keeps only the edit arguments the call carried, as setEdit does for flags.
+func mcpEdit(args mcpArgs) (serviceEdit, error) {
+	var edit serviceEdit
+	if _, ok := args["name"]; ok {
+		name := args.text("name")
+		edit.name = &name
+	}
+	if _, ok := args["command"]; ok {
+		command := args.text("command")
+		edit.command = &command
+	}
+	if _, ok := args["start_with_lich"]; ok {
+		start := args.flag("start_with_lich")
+		edit.startWithLich = &start
+	}
+	if edit == (serviceEdit{}) {
+		return edit, errors.New("name what to change: name, command or start_with_lich")
+	}
+	return edit, nil
+}
diff --git a/internal/cli/services_test.go b/internal/cli/services_test.go
new file mode 100644
index 000000000..f5677e679
--- /dev/null
+++ b/internal/cli/services_test.go
@@ -0,0 +1,316 @@
+package cli
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"net"
+	"net/http/httptest"
+	"strconv"
+	"strings"
+	"sync"
+	"testing"
+
+	"github.com/lichdotdev/lich/api"
+	"github.com/lichdotdev/lich/internal/routes"
+	"github.com/lichdotdev/lich/internal/rpc"
+	"github.com/lichdotdev/lich/internal/spawn"
+)
+
+// fakeServices stands in for internal/services behind its RPC methods, the
+// boundary the CLI talks to; the project is resolved by the real spawn.Project.
+type fakeServices struct {
+	mu    sync.Mutex
+	saved []api.Service
+	saves []api.SaveServiceOptions
+	calls []string
+}
+
+func (f *fakeServices) list(context.Context, api.None) ([]api.Service, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	return append([]api.Service(nil), f.saved...), nil
+}
+
+func (f *fakeServices) save(_ context.Context, o api.SaveServiceOptions) (api.Service, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	f.saves = append(f.saves, o)
+	if o.ID == "" {
+		o.ID = "new"
+	}
+	s := api.Service{ServiceConfig: api.ServiceConfig(o), State: api.ServiceStopped}
+	return s, nil
+}
+
+func (f *fakeServices) by(verb, state string) func(context.Context, api.ServiceIDOptions) (api.None, error) {
+	return func(_ context.Context, o api.ServiceIDOptions) (api.None, error) {
+		f.mu.Lock()
+		defer f.mu.Unlock()
+		f.calls = append(f.calls, verb+" "+o.ID)
+		for i := range f.saved {
+			if f.saved[i].ID == o.ID {
+				f.saved[i].State = state
+			}
+		}
+		return api.None{}, nil
+	}
+}
+
+func (f *fakeServices) all(verb, state string) func(context.Context, api.ProjectIDOptions) (api.None, error) {
+	return func(_ context.Context, o api.ProjectIDOptions) (api.None, error) {
+		f.mu.Lock()
+		defer f.mu.Unlock()
+		f.calls = append(f.calls, verb+" "+o.ID)
+		for i := range f.saved {
+			if f.saved[i].ProjectID == o.ID {
+				f.saved[i].State = state
+			}
+		}
+		return api.None{}, nil
+	}
+}
+
+func (f *fakeServices) output(_ context.Context, o api.ServiceIDOptions) ([]byte, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	f.calls = append(f.calls, "output "+o.ID)
+	return []byte("listening on :3000\r\n"), nil
+}
+
+func (f *fakeServices) live(_ context.Context, o api.ServiceIDOptions) ([]byte, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	f.calls = append(f.calls, "live "+o.ID)
+	return []byte("building\r\n"), nil
+}
+
+func wiredServices(t *testing.T) (func(string) string, *fakeServices) {
+	t.Helper()
+	f := &fakeServices{saved: []api.Service{
+		{ServiceConfig: api.ServiceConfig{ID: "w1", ProjectID: "p1", Name: "Web", Command: "pnpm dev", StartWithLich: true}, State: api.ServiceStopped},
+		{ServiceConfig: api.ServiceConfig{ID: "o1", ProjectID: "p9", Name: "web", Command: "other"}, State: api.ServiceStopped},
+	}}
+	d := rpc.New()
+	routes.Spawn(d, spawn.New(&spawnStore{}, &spawnGit{}, &spawnTerminal{}, nil))
+	rpc.Handle(d, api.ServicesList, f.list)
+	rpc.Handle(d, api.ServicesSave, f.save)
+	rpc.Handle(d, api.ServicesDelete, f.by("delete", api.ServiceStopped))
+	rpc.Handle(d, api.ServicesStart, f.by("start", api.ServiceRunning))
+	rpc.Handle(d, api.ServicesStop, f.by("stop", api.ServiceStopping))
+	rpc.Handle(d, api.ServicesForceStop, f.by("force-stop", api.ServiceStopped))
+	rpc.Handle(d, api.ServicesRestart, f.by("restart", api.ServiceRunning))
+	rpc.Handle(d, api.ServicesStartAll, f.all("start-all", api.ServiceRunning))
+	rpc.Handle(d, api.ServicesStopAll, f.all("stop-all", api.ServiceStopping))
+	rpc.Handle(d, api.ServicesOutput, f.output)
+	rpc.Handle(d, api.ServicesLiveOutput, f.live)
+	server := httptest.NewServer(d)
+	t.Cleanup(server.Close)
+	return sessionEnv(strconv.Itoa(server.Listener.Addr().(*net.TCPAddr).Port)), f
+}
+
+func runService(t *testing.T, env func(string) string, args ...string) (string, string, int) {
+	t.Helper()
+	var stdout, stderr bytes.Buffer
+	code := Run(append([]string{"service"}, args...), "test", env, &stdout, &stderr)
+	return stdout.String(), stderr.String(), code
+}
+
+// A list shows the caller's own project only: the other project's "web" is
+// not one an unqualified name may reach.
+func TestServiceListShowsTheCallersProject(t *testing.T) {
+	t.Parallel()
+	env, _ := wiredServices(t)
+
+	out, stderr, code := runService(t, env, "list")
+	if code != 0 {
+		t.Fatalf("exit = %d, stderr = %q", code, stderr)
+	}
+	if !strings.Contains(out, "Web\tstopped\tpnpm dev") || strings.Contains(out, "other") {
+		t.Errorf("stdout = %q, want lich's service and nothing else", out)
+	}
+}
+
+func TestServiceAddSavesANewOneInTheProject(t *testing.T) {
+	t.Parallel()
+	env, f := wiredServices(t)
+
+	if _, stderr, code := runService(t, env, "--start-with-lich", "add", "db", "docker compose up"); code != 0 {
+		t.Fatalf("exit = %d, stderr = %q", code, stderr)
+	}
+	want := api.SaveServiceOptions{ProjectID: "p1", Name: "db", Command: "docker compose up", StartWithLich: true}
+	if len(f.saves) != 1 || f.saves[0] != want {
+		t.Errorf("saves = %+v, want %+v", f.saves, want)
+	}
+}
+
+// An edit changes the flags given and keeps the rest, start-with-lich among
+// them: a bool flag left out must not read as false.
+func TestServiceEditKeepsWhatItWasNotGiven(t *testing.T) {
+	t.Parallel()
+	env, f := wiredServices(t)
+
+	if _, stderr, code := runService(t, env, "--command", "pnpm start", "edit", "web"); code != 0 {
+		t.Fatalf("exit = %d, stderr = %q", code, stderr)
+	}
+	want := api.SaveServiceOptions{ID: "w1", ProjectID: "p1", Name: "Web", Command: "pnpm start", StartWithLich: true}
+	if len(f.saves) != 1 || f.saves[0] != want {
+		t.Errorf("saves = %+v, want %+v", f.saves, want)
+	}
+}
+
+func TestServiceStartStopAndDeleteReachTheNamedOne(t *testing.T) {
+	t.Parallel()
+	env, f := wiredServices(t)
+
+	out, stderr, code := runService(t, env, "start", "WEB")
+	if code != 0 || !strings.Contains(out, "Web\trunning") {
+		t.Fatalf("start: exit = %d, stdout = %q, stderr = %q", code, out, stderr)
+	}
+	for _, verb := range []string{"stop", "delete"} {
+		if _, stderr, code := runService(t, env, verb, "web"); code != 0 {
+			t.Fatalf("%s: exit = %d, stderr = %q", verb, code, stderr)
+		}
+	}
+	if strings.Join(f.calls, ",") != "start w1,stop w1,delete w1" {
+		t.Errorf("calls = %v, want each verb on lich's Web", f.calls)
+	}
+}
+
+func TestServiceRefusesANameTheProjectLacks(t *testing.T) {
+	t.Parallel()
+	env, f := wiredServices(t)
+
+	_, stderr, code := runService(t, env, "start", "api")
+	if code == 0 || !strings.Contains(stderr, `no service named "api" in lich`) || !strings.Contains(stderr, `"Web"`) {
+		t.Errorf("exit = %d, stderr = %q; want the miss refused with the names there are", code, stderr)
+	}
+	if len(f.calls) != 0 {
+		t.Errorf("calls = %v, want none", f.calls)
+	}
+	if _, stderr, code := runService(t, env, "start"); code == 0 || !strings.Contains(stderr, "usage: lich service") {
+		t.Errorf("exit = %d, stderr = %q; want the usage", code, stderr)
+	}
+}
+
+func serviceTool(t *testing.T, name string) mcpTool {
+	t.Helper()
+	for _, tool := range serviceTools {
+		if tool.Name == name {
+			return tool
+		}
+	}
+	t.Fatalf("no tool %q", name)
+	return mcpTool{}
+}
+
+func TestEditServiceToolKeepsWhatItWasNotGiven(t *testing.T) {
+	t.Parallel()
+	env, f := wiredServices(t)
+	c := &client{env: env, running: noInstance}
+
+	out, err := serviceTool(t, "edit_service").Run(t.Context(), c, mcpArgs{"service": "web", "start_with_lich": false})
+	if err != nil {
+		t.Fatalf("edit_service: %v", err)
+	}
+	want := api.SaveServiceOptions{ID: "w1", ProjectID: "p1", Name: "Web", Command: "pnpm dev"}
+	if len(f.saves) != 1 || f.saves[0] != want {
+		t.Errorf("saves = %+v, want %+v", f.saves, want)
+	}
+	var s api.Service
+	if err := json.Unmarshal([]byte(out), &s); err != nil || s.ID != "w1" {
+		t.Errorf("result = %q (%v), want the service as JSON", out, err)
+	}
+	if _, err := serviceTool(t, "edit_service").Run(t.Context(), c, mcpArgs{"service": "web"}); err == nil {
+		t.Error("an edit that names nothing to change was accepted")
+	}
+}
+
+func TestStartServiceToolAnswersWithTheStateAfter(t *testing.T) {
+	t.Parallel()
+	env, _ := wiredServices(t)
+	c := &client{env: env, running: noInstance}
+
+	out, err := serviceTool(t, "start_service").Run(t.Context(), c, mcpArgs{"service": "Web"})
+	if err != nil || !strings.Contains(out, `"state":"running"`) {
+		t.Errorf("start_service = %q, %v; want the service running", out, err)
+	}
+}
+
+func TestServiceRestartAndForceStopReachTheNamedOne(t *testing.T) {
+	t.Parallel()
+	env, f := wiredServices(t)
+
+	for _, verb := range []string{"restart", "force-stop"} {
+		if _, stderr, code := runService(t, env, verb, "web"); code != 0 {
+			t.Fatalf("%s: exit = %d, stderr = %q", verb, code, stderr)
+		}
+	}
+	if strings.Join(f.calls, ",") != "restart w1,force-stop w1" {
+		t.Errorf("calls = %v, want each verb on lich's Web", f.calls)
+	}
+}
+
+// start-all and stop-all reach the caller's project and print its services
+// as they are afterwards.
+func TestServiceStartAllAndStopAllReachTheProject(t *testing.T) {
+	t.Parallel()
+	env, f := wiredServices(t)
+
+	out, stderr, code := runService(t, env, "start-all")
+	if code != 0 || !strings.Contains(out, "Web\trunning") {
+		t.Fatalf("start-all: exit = %d, stdout = %q, stderr = %q", code, out, stderr)
+	}
+	if _, stderr, code := runService(t, env, "stop-all"); code != 0 {
+		t.Fatalf("stop-all: exit = %d, stderr = %q", code, stderr)
+	}
+	if strings.Join(f.calls, ",") != "start-all p1,stop-all p1" {
+		t.Errorf("calls = %v, want both on lich", f.calls)
+	}
+}
+
+// output reads the last run of a stopped service and the console so far of a
+// running one, each from the method that holds it.
+func TestServiceOutputReadsTheConsoleAsItIsNow(t *testing.T) {
+	t.Parallel()
+	env, f := wiredServices(t)
+
+	out, stderr, code := runService(t, env, "output", "web")
+	if code != 0 || out != "listening on :3000\r\n" {
+		t.Fatalf("output: exit = %d, stdout = %q, stderr = %q", code, out, stderr)
+	}
+	f.mu.Lock()
+	f.saved[0].State = api.ServiceRunning
+	f.mu.Unlock()
+	if out, stderr, code := runService(t, env, "output", "web"); code != 0 || out != "building\r\n" {
+		t.Errorf("exit = %d, stdout = %q, stderr = %q; want the running console", code, out, stderr)
+	}
+	if strings.Join(f.calls, ",") != "output w1,live w1" {
+		t.Errorf("calls = %v, want the last run, then the live one", f.calls)
+	}
+}
+
+func TestStopAllServicesToolAnswersWithTheProjectsServices(t *testing.T) {
+	t.Parallel()
+	env, f := wiredServices(t)
+	c := &client{env: env, running: noInstance}
+
+	out, err := serviceTool(t, "stop_all_services").Run(t.Context(), c, mcpArgs{})
+	if err != nil || !strings.Contains(out, `"state":"stopping"`) || strings.Contains(out, "other") {
+		t.Errorf("stop_all_services = %q, %v; want lich's services stopping", out, err)
+	}
+	if strings.Join(f.calls, ",") != "stop-all p1" {
+		t.Errorf("calls = %v", f.calls)
+	}
+}
+
+func TestReadServiceOutputToolReturnsTheText(t *testing.T) {
+	t.Parallel()
+	env, _ := wiredServices(t)
+	c := &client{env: env, running: noInstance}
+
+	out, err := serviceTool(t, "read_service_output").Run(t.Context(), c, mcpArgs{"service": "web"})
+	if err != nil || out != "listening on :3000\r\n" {
+		t.Errorf("read_service_output = %q, %v", out, err)
+	}
+}
diff --git a/internal/routes/routes.go b/internal/routes/routes.go
index 88afbc7c5..129bb9ce3 100644
--- a/internal/routes/routes.go
+++ b/internal/routes/routes.go
@@ -50,4 +50,5 @@ func Spawn(d *rpc.Handler, s *spawn.Service) {
 	rpc.Handle(d, api.SpawnRenameFolder, s.RenameFolder)
 	rpc.Handle(d, api.SpawnColorFolder, s.ColorFolder)
 	rpc.Handle(d, api.SpawnRename, s.Rename)
+	rpc.Handle(d, api.SpawnProject, s.Project)
 }
diff --git a/internal/routes/services.go b/internal/routes/services.go
index b1deeec6b..97f27c0c9 100644
--- a/internal/routes/services.go
+++ b/internal/routes/services.go
@@ -18,4 +18,5 @@ func Services(d *rpc.Handler, s *services.Service) {
 	rpc.Handle(d, api.ServicesStartAll, s.StartAll)
 	rpc.Handle(d, api.ServicesStopAll, s.StopAll)
 	rpc.Handle(d, api.ServicesOutput, s.Output)
+	rpc.Handle(d, api.ServicesLiveOutput, s.LiveOutput)
 }
diff --git a/internal/services/rpc.go b/internal/services/rpc.go
index d9044aa1c..7e37c459c 100644
--- a/internal/services/rpc.go
+++ b/internal/services/rpc.go
@@ -47,3 +47,9 @@ func (s *Service) StopAll(_ context.Context, opts api.ProjectIDOptions) (api.Non
 func (s *Service) Output(_ context.Context, opts api.ServiceIDOptions) ([]byte, error) {
 	return s.output(opts.ID), nil
 }
+
+// LiveOutput is what a running service has printed so far, read at the moment
+// of the call: nil once it is not running, when Output has its last run.
+func (s *Service) LiveOutput(_ context.Context, opts api.ServiceIDOptions) ([]byte, error) {
+	return s.liveOutput(opts.ID), nil
+}
diff --git a/internal/services/run.go b/internal/services/run.go
index a06a783a2..5f46bd678 100644
--- a/internal/services/run.go
+++ b/internal/services/run.go
@@ -142,6 +142,15 @@ func (s *Service) output(id string) []byte {
 	return r.tail
 }
 
+// liveOutput is what service id has printed so far in the run still going;
+// nil when it is not running.
+func (s *Service) liveOutput(id string) []byte {
+	if !s.up(id) {
+		return nil
+	}
+	return s.term.ServiceOutput(terminalPrefix + id)
+}
+
 // Running is every service whose process is up, stopping ones included.
 func (s *Service) Running() []api.Service {
 	list, err := s.list()
diff --git a/internal/services/services_unix_test.go b/internal/services/services_unix_test.go
index 3837f013f..0bead24a9 100644
--- a/internal/services/services_unix_test.go
+++ b/internal/services/services_unix_test.go
@@ -3,6 +3,7 @@
 package services
 
 import (
+	"bytes"
 	"context"
 	"slices"
 	"strings"
@@ -386,3 +387,32 @@ func TestClosingAProjectKillsWhatOutstaysTheGrace(t *testing.T) {
 		t.Errorf("after closing its project the service is %s", got)
 	}
 }
+
+// LiveOutput reads a running service's console as it is at the call, and
+// nothing once the run is over: Output has it then.
+func TestLiveOutputReadsARunningService(t *testing.T) {
+	svc, _, _ := newTestServices(t)
+	v := save(t, svc, "p1", "talker", "echo listening; sleep 30", false)
+	if out, _ := svc.LiveOutput(context.Background(), api.ServiceIDOptions{ID: v.ID}); out != nil {
+		t.Errorf("LiveOutput before any run = %q", out)
+	}
+	if _, err := svc.Start(context.Background(), api.ServiceIDOptions{ID: v.ID}); err != nil {
+		t.Fatal(err)
+	}
+	deadline := time.Now().Add(10 * time.Second)
+	var out []byte
+	for time.Now().Before(deadline) && !bytes.Contains(out, []byte("listening")) {
+		out, _ = svc.LiveOutput(context.Background(), api.ServiceIDOptions{ID: v.ID})
+		time.Sleep(20 * time.Millisecond)
+	}
+	if !bytes.Contains(out, []byte("listening")) {
+		t.Fatalf("LiveOutput = %q, want what the run printed so far", out)
+	}
+	if _, err := svc.ForceStop(context.Background(), api.ServiceIDOptions{ID: v.ID}); err != nil {
+		t.Fatal(err)
+	}
+	waitState(t, svc, v.ID, api.ServiceStopped)
+	if out, _ := svc.LiveOutput(context.Background(), api.ServiceIDOptions{ID: v.ID}); out != nil {
+		t.Errorf("LiveOutput after the run = %q", out)
+	}
+}
diff --git a/internal/spawn/project_ref.go b/internal/spawn/project_ref.go
new file mode 100644
index 000000000..57a7343d5
--- /dev/null
+++ b/internal/spawn/project_ref.go
@@ -0,0 +1,22 @@
+package spawn
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/lichdotdev/lich/api"
+)
+
+// Project resolves an open project as every other spawn call does, for a
+// caller that goes on to a method keyed by project id.
+func (s *Service) Project(ctx context.Context, opts api.ProjectRefOptions) (api.ProjectRef, error) {
+	projects, err := s.sessions.LoadState(ctx, api.None{})
+	if err != nil {
+		return api.ProjectRef{}, fmt.Errorf("read the workspace: %w", err)
+	}
+	p, err := resolveProject(projects, opts.From, opts.Project)
+	if err != nil {
+		return api.ProjectRef{}, err
+	}
+	return api.ProjectRef{ID: p.ID, Name: p.Name, Path: p.Path}, nil
+}
diff --git a/internal/spawn/project_ref_test.go b/internal/spawn/project_ref_test.go
new file mode 100644
index 000000000..6502564e7
--- /dev/null
+++ b/internal/spawn/project_ref_test.go
@@ -0,0 +1,33 @@
+package spawn
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/lichdotdev/lich/api"
+)
+
+func TestProjectResolvesTheCallersOwnAndOneNamed(t *testing.T) {
+	svc, _, _ := filer(t)
+
+	own, err := svc.Project(t.Context(), api.ProjectRefOptions{From: "s1"})
+	if err != nil || own.ID != "p1" || own.Name != "lich" {
+		t.Errorf("own = %+v, %v; want the caller's project", own, err)
+	}
+	named, err := svc.Project(t.Context(), api.ProjectRefOptions{From: "s1", Project: "revu"})
+	if err != nil || named != (api.ProjectRef{ID: "p2", Name: "revu", Path: "/src/revu"}) {
+		t.Errorf("named = %+v, %v; want revu", named, err)
+	}
+}
+
+func TestProjectRefusesOneItCannotResolve(t *testing.T) {
+	svc, sessions, _ := filer(t)
+
+	if _, err := svc.Project(t.Context(), api.ProjectRefOptions{From: "s1", Project: "nope"}); err == nil {
+		t.Error("resolved a project that is not open")
+	}
+	sessions.loadErr = errors.New("database is locked")
+	if _, err := svc.Project(t.Context(), api.ProjectRefOptions{From: "s1"}); err == nil {
+		t.Error("resolved a project in a workspace it could not read")
+	}
+}
diff --git a/internal/terminal/service.go b/internal/terminal/service.go
index 80e5a96c8..fae7d5db4 100644
--- a/internal/terminal/service.go
+++ b/internal/terminal/service.go
@@ -102,6 +102,18 @@ func (s *Service) KillService(id string) {
 	}
 }
 
+// ServiceOutput is what service id has printed so far, capped like a
+// session's replay tail; nil when it is not running.
+func (s *Service) ServiceOutput(id string) []byte {
+	s.mu.Lock()
+	sess, ok := s.sessions[id]
+	s.mu.Unlock()
+	if !ok || sess.service == nil {
+		return nil
+	}
+	return sess.replay.snapshot()
+}
+
 // serviceInput is onInput for a service's console: typed bytes go straight to
 // the PTY, none of a session's bookkeeping applies, and a Ctrl+C among them
 // tells the service it was asked to stop. It reports whether id is a service.