leglas-mcp 0.2.0 → 0.3.0

package/README.md

@@ -52,7 +52,7 @@ and sessions that clean up after themselves.
 - Ask for changes without leaving the comparison: describe what you
   want on the direction you're looking at, and Leglas turns it into a
   precise request for your agent, file path included. Leave
-  `leglas watch --run "claude -p {prompt}"` running in another terminal
+  `npx leglas watch --run "claude -p {prompt}"` running in another terminal
   and your agent picks each request up as you send it. In Claude Code,
   the Leglas MCP server can also push each request straight into your
   open session as a channel event (channels are a research preview:
@@ -76,57 +76,81 @@ preview of your app root. Add a config file to compare more than one thing.
 
 It works with whatever you're building in. Leglas never imports or
 executes your framework, so the target can be Next, Vite, Remix,
-SvelteKit, Astro, or a folder of static files. Requires Node 24 or
-newer.
+SvelteKit, Astro, or a folder of static files.
+
+## Install
+
+There is nothing you have to install: `npx leglas` fetches the CLI on
+first use and starts from npm's cache after that, and every instruction
+Leglas writes for agents uses the same form, so a fresh clone works
+with no setup at all. Requires Node 24 or newer.
+
+Two optional upgrades:
+
+- `npm install -D leglas` pins the version in a project. Teammates and
+  CI get the same Leglas from their normal install, and `npx` resolves
+  the local copy from then on.
+- `npm install -g leglas` is for typing `leglas` without the prefix.
 
 ## Working with coding agents
 
-Run `leglas init` once. It writes a section into your project's
-`AGENTS.md`, creates a starter config, and gitignores Leglas's working
-directory. That section travels with the repo, so Claude Code, Cursor,
-Codex, or whatever you switch to next opens the project already knowing
-how to add design directions to it. Every command accepts `--json` and
-prints a single machine-readable envelope, so agents drive the same CLI
-you do.
+The fastest way in is the agent skill:
+
+```sh
+npx skills add FredAmartey/leglas
+```
+
+One install, and your agent recognises "give me a few directions for the
+pricing page" as a Leglas exploration in any project, including ones
+that have never seen Leglas. It sets the project up itself and gets to
+work.
+
+In a project, run `npx leglas init` once. It writes a section into your
+project's `AGENTS.md`, creates a starter config, and gitignores Leglas's
+working directory. That section travels with the repo, so Claude Code,
+Cursor, Codex, or whatever you switch to next opens the project already
+knowing how to add design directions to it. Every command accepts
+`--json` and prints a single machine-readable envelope, so agents drive
+the same CLI you do.
 
 The instructions center on one rule: add beside what exists, never
 rewrite it. Two directions that rewrite the same file cannot render from
 one server, and asking an agent to "make the hero calmer" tempts it to
 edit the hero. The supporting commands:
 
-- `leglas explore hero --count 6` briefs the exploration: what the set
+- `npx leglas explore hero --count 6` briefs the exploration: what the set
   is for, why it only works if the six genuinely disagree, and how each
   direction registers. Unbriefed, six requests come back as six variants
   of one idea. With `--based-on "Aurora"` the goal flips: six deliberate
   variants of a direction you already like, and drifting into a new
   direction is the failure. The designs themselves are the agent's;
   Leglas prescribes none.
-- `leglas new hero --from src/Hero.tsx` scaffolds a switcher under
+- `npx leglas new hero --from src/Hero.tsx` scaffolds a switcher under
   `.leglas/variants/hero/`. With `--from`, the baseline re-exports your
   real component, so you never compare against a stale copy. Leglas
   prints the one line to add in your component and does not edit it,
   because rewriting a file it does not understand is how a tool breaks a
   codebase. Scaffolded branch points return the fallback in production
   builds, so a committed one cannot expose an unreleased direction.
-- `leglas classify --change package.json --rewrite src/theme.css` answers
+- `npx leglas classify --change package.json --rewrite src/theme.css` answers
   where a direction should live before it is written. Changing
   dependencies, build configuration, or an existing file's behaviour
   cannot be additive, so those directions build on their own git branch
   and register with `leglas add --branch`. Everything else stays in-app,
   where switching is instant.
-- `leglas show "Aurora" --json` answers for one direction: its entry, the
+- `npx leglas show "Aurora" --json` answers for one direction: its entry, the
   source file behind it, the variants based on it, what it is being compared
   against, and anything still pending on it. Copying a direction from the
   rail hands over a block that ends in this command, so an agent given the
   block can go and get the rest.
-- `leglas keep "Aurora" --to src/components/hero.tsx` moves the winner
+- `npx leglas keep "Aurora" --to src/components/hero.tsx` moves the winner
   into real source and ends the exploration.
 
 Asking for a change works from the interface too. Type what you want
 changed into the field under the rail (or press `R`) and Leglas composes a
 prompt naming the direction and the file behind it, copies it to your
 clipboard, and queues it. The direction it means is the one highlighted
-directly above the field. Your agent drains the queue with `leglas requests --json` and clears
+directly above the field. Your agent drains the queue with `npx leglas requests --json` and clears
 it with `--clear`. Leglas runs no model of its own; your agent already
 knows your conventions and your taste.
 
@@ -136,6 +160,9 @@ For agent hosts that cannot run shell commands, `leglas-mcp` exposes the
 same operations as MCP tools over stdio: `start`, `add`, `list`, `show`,
 `classify`, `explore`, `scaffold`, `keep`, `requests`, and `init`. Each
 tool calls exactly what the CLI calls and returns the same envelope.
+`watch` is the one command with no tool behind it: it is a loop that
+holds a terminal open, and on a host that speaks channels the server
+already pushes each request into the session as it arrives.
 
 ```sh
 claude mcp add leglas -- npx -y leglas-mcp
@@ -147,9 +174,34 @@ Or in `.mcp.json`:
 { "mcpServers": { "leglas": { "command": "npx", "args": ["-y", "leglas-mcp"] } } }
 ```
 
-The host's working directory names the project. The `start` tool boots
-the viewer and returns its URL, and anything it started stops when the
-session ends.
+The host's working directory names the project, the same contract as the
+CLI. A host that starts the server somewhere else is asked where the
+project is, over MCP roots. The `start` tool boots the viewer and returns
+its URL, and anything it started stops when the session ends.
+
+### As an Agent Plugin
+
+The repository is also an [Agent Plugin](https://agent-plugins.org), the
+open standard for shipping Agent Skills and MCP server configuration in
+one format. Clients that implement it install the skill and the server
+together, instead of the two steps above. It is a layout rather than a
+build: `plugin.json` and `mcp.json` at the root, the skill in
+`skills/leglas/`, nothing generated.
+
+An Agent Plugins client starts a plugin's server in the plugin's own
+install directory rather than the project, so on that path the working
+directory names a copy of Leglas and nothing else. The server therefore
+takes the project from the workspace the host declares over MCP roots,
+and the working directory only when it sits inside one. If a host offers
+neither, `LEGLAS_PROJECT_DIR` names the project outright; without it the
+tools report that there is no project rather than writing into a plugin
+cache. `mcp.json` passes `${PLUGIN_ROOT}` for exactly that check, and
+nothing else.
+
+The plugin's version covers the skill and the configuration, not the
+server it launches: `npx` fetches the current `leglas-mcp` the same way
+every `npx leglas` in these instructions fetches the current CLI, which
+keeps both faces of Leglas on one version in a project they share.
 
 ## Configuration
 

package/dist/bin.js

@@ -3,10 +3,12 @@ import { createRequire } from "node:module";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CHANNEL_CAPABILITY, CHANNEL_INSTRUCTIONS, startChannel } from "./channel.js";
+import { hostProject } from "./project.js";
 import { registerLeglasTools } from "./tools.js";
 /**
- * The stdio face. An agent host spawns this in the project directory, which
- * is the same contract as the CLI: the working directory names the project.
+ * The stdio face. A host that spawns this in the project directory gets the
+ * CLI's contract, where the working directory names the project; a host that
+ * spawns it somewhere else is asked where the project is. See project.ts.
  */
 function version() {
     const require = createRequire(import.meta.url);
@@ -18,7 +20,12 @@ const server = new McpServer({ name: "leglas", version: version() },
 // speak channels; on Claude Code they let change requests from the
 // interface arrive in the open session as events.
 { capabilities: { experimental: CHANNEL_CAPABILITY }, instructions: CHANNEL_INSTRUCTIONS });
-const tools = registerLeglasTools(server, { cwd: process.cwd() });
+const project = hostProject(server.server, {
+    cwd: process.cwd(),
+    override: process.env["LEGLAS_PROJECT_DIR"],
+    pluginRoot: process.env["LEGLAS_PLUGIN_ROOT"],
+});
+const tools = registerLeglasTools(server, { project });
 let channel = null;
 let stopping = false;
 const shutdown = async () => {
@@ -39,4 +46,4 @@ transport.onclose = () => {
 };
 await server.connect(transport);
 // Only after connect: a notification with no transport throws.
-channel = startChannel(server, { cwd: process.cwd() });
+channel = startChannel(server, { project });

package/dist/channel.d.ts

@@ -1,5 +1,6 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { type PendingRequest } from "leglas";
+import type { Project } from "./project.js";
 /**
  * The push face, for hosts that treat an MCP server as a channel.
  *
@@ -51,7 +52,7 @@ export type Channel = {
  * because the queue file still holds the request.
  */
 export declare function startChannel(server: McpServer, options: {
-    cwd: string;
+    project: Project;
     pollMs?: number;
     /** Tests gate this to force overlapping polls; production reads the file. */
     read?: (cwd: string) => Promise<PendingRequest[]>;

package/dist/channel.js

@@ -70,7 +70,16 @@ export function startChannel(server, options) {
         }
     };
     const push = async () => {
-        const fresh = unpushed(await read(options.cwd), pushed);
+        // The first poll waits here for the host to initialize, which is what
+        // makes the queue this reads the project's rather than whatever directory
+        // the process happened to start in.
+        const located = await options.project.locate();
+        if (!located.ok) {
+            // Settled for the life of the process, so there is no queue coming.
+            clearInterval(timer);
+            return;
+        }
+        const fresh = unpushed(await read(located.directory), pushed);
         for (const request of fresh) {
             pushed.add(request.id);
             try {

package/dist/index.d.ts

@@ -2,3 +2,5 @@ export { registerLeglasTools } from "./tools.js";
 export type { LeglasTools } from "./tools.js";
 export { CHANNEL_CAPABILITY, CHANNEL_INSTRUCTIONS, CHANNEL_POLL_MS, channelEvent, startChannel, unpushed, } from "./channel.js";
 export type { Channel, ChannelEvent } from "./channel.js";
+export { UNRESOLVED_PROJECT, fixedProject, hostProject } from "./project.js";
+export type { HostProjectOptions, Located, Project, RootsHost } from "./project.js";

package/dist/index.js

@@ -1,2 +1,3 @@
 export { registerLeglasTools } from "./tools.js";
 export { CHANNEL_CAPABILITY, CHANNEL_INSTRUCTIONS, CHANNEL_POLL_MS, channelEvent, startChannel, unpushed, } from "./channel.js";
+export { UNRESOLVED_PROJECT, fixedProject, hostProject } from "./project.js";

package/dist/project.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Which project the tools act on.
+ *
+ * Every other face of Leglas learns this the same easy way: the CLI runs in
+ * the project, so the working directory is the answer. An MCP server is not
+ * always so lucky. An Agent Plugins client starts a plugin's server in the
+ * plugin's own install directory (Agent Plugins 1.0.0 §7.2.1), which holds a
+ * copy of Leglas and never a project anyone is designing. Taken at face value
+ * there, the working directory would send `init` into a plugin cache, leave
+ * the rail empty, and report all of it as success.
+ *
+ * So the directory is asked for rather than assumed:
+ *
+ * 1. `LEGLAS_PROJECT_DIR`, when someone has said outright where to work.
+ * 2. The workspace the host declares over MCP roots, which is the project it
+ *    has open. The working directory wins when it sits inside one of those
+ *    roots, because a host started in `packages/app` means that, not the
+ *    repository above it. Several roots and no match takes the first, which
+ *    is a guess, and the reason the override above exists.
+ * 3. The working directory, which is the right answer for every host that
+ *    starts the server in the project, and the reason nothing changes for
+ *    `claude mcp add` or a hand-written `.mcp.json`.
+ *
+ * When none of those name a project, the tools say so. Refusing is the whole
+ * point: a wrong directory is worse than no directory, because it writes.
+ */
+export type Located = {
+    ok: true;
+    directory: string;
+} | {
+    ok: false;
+    reason: string;
+};
+export type Project = {
+    /**
+     * The project directory, resolved once and held for the life of the process.
+     * A viewer, a request queue, and a channel all bind to one project, so a
+     * session that changed its mind halfway would already have a server running
+     * against the old one.
+     */
+    locate(): Promise<Located>;
+};
+/** A project fixed to one directory: what an embedder or a test already knows. */
+export declare function fixedProject(directory: string): Project;
+/**
+ * The part of an MCP server this needs. The SDK's `Server` satisfies it
+ * structurally, which keeps the resolution testable without a transport.
+ */
+export type RootsHost = {
+    getClientCapabilities(): {
+        roots?: unknown;
+    } | undefined;
+    listRoots(): Promise<{
+        roots: {
+            uri: string;
+        }[];
+    }>;
+    oninitialized?: (() => void) | undefined;
+};
+export type HostProjectOptions = {
+    /** The process working directory. */
+    cwd: string;
+    /** `LEGLAS_PROJECT_DIR`: an explicit answer that ends the search. */
+    override?: string | undefined;
+    /**
+     * `LEGLAS_PLUGIN_ROOT`: where an Agent Plugins client installed us, which
+     * the plugin's own `mcp.json` passes as `${PLUGIN_ROOT}`. Its only use is
+     * recognising a working directory that means nothing.
+     */
+    pluginRoot?: string | undefined;
+};
+/**
+ * Worded for every way the search comes up empty: a host with no roots, a host
+ * with an empty workspace, and a host that failed to answer. Naming only the
+ * first would describe the others wrongly.
+ */
+export declare const UNRESOLVED_PROJECT: string;
+export declare function hostProject(host: RootsHost, options: HostProjectOptions): Project;

package/dist/project.js

@@ -0,0 +1,102 @@
+import { realpathSync } from "node:fs";
+import { isAbsolute, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+/** A project fixed to one directory: what an embedder or a test already knows. */
+export function fixedProject(directory) {
+    const located = { ok: true, directory };
+    return { locate: async () => located };
+}
+/**
+ * Worded for every way the search comes up empty: a host with no roots, a host
+ * with an empty workspace, and a host that failed to answer. Naming only the
+ * first would describe the others wrongly.
+ */
+export const UNRESOLVED_PROJECT = "Leglas could not tell which project to work in. This agent host started the " +
+    "Leglas MCP server in the plugin's own directory and named no workspace to " +
+    "work in, so there is no project here to act on. Set LEGLAS_PROJECT_DIR to " +
+    "the project directory, or run the leglas CLI in the project instead.";
+export function hostProject(host, options) {
+    let pending = null;
+    return { locate: () => (pending ??= discover(host, options)) };
+}
+async function discover(host, options) {
+    const override = options.override?.trim();
+    if (override !== undefined && override !== "") {
+        return { ok: true, directory: resolve(override) };
+    }
+    const cwd = canonical(options.cwd);
+    const roots = await declaredRoots(host);
+    if (roots.some((root) => contains(canonical(root), cwd))) {
+        return { ok: true, directory: options.cwd };
+    }
+    const first = roots[0];
+    if (first !== undefined)
+        return { ok: true, directory: first };
+    const pluginRoot = options.pluginRoot?.trim();
+    // A client that does not expand ${PLUGIN_ROOT} leaves the literal behind; it
+    // matches no real directory, so the check simply does not fire.
+    if (pluginRoot !== undefined && pluginRoot !== "" && contains(canonical(pluginRoot), cwd)) {
+        return { ok: false, reason: UNRESOLVED_PROJECT };
+    }
+    return { ok: true, directory: options.cwd };
+}
+async function declaredRoots(host) {
+    await initialized(host);
+    if (host.getClientCapabilities()?.roots === undefined)
+        return [];
+    try {
+        const { roots } = await host.listRoots();
+        return roots
+            .map((root) => toDirectory(root.uri))
+            .filter((directory) => directory !== null);
+    }
+    catch {
+        // A host that advertises roots and then refuses to list them has told us
+        // nothing, which leaves the working directory as good a guess as before.
+        return [];
+    }
+}
+/**
+ * Roots can only be asked for once the client has initialized; asking earlier
+ * is a protocol error. A stdio server is connected well before a host gets
+ * around to initializing, and the channel starts polling immediately, so this
+ * wait is the ordinary path rather than an edge case.
+ */
+function initialized(host) {
+    if (host.getClientCapabilities() !== undefined)
+        return Promise.resolve();
+    return new Promise((ready) => {
+        const previous = host.oninitialized;
+        host.oninitialized = () => {
+            previous?.();
+            ready();
+        };
+    });
+}
+/** Roots are file URIs by the spec; a host that sends a bare path still reads. */
+function toDirectory(uri) {
+    if (uri.startsWith("file:")) {
+        try {
+            return fileURLToPath(uri);
+        }
+        catch {
+            return null;
+        }
+    }
+    return isAbsolute(uri) ? uri : null;
+}
+function contains(parent, child) {
+    if (child === parent)
+        return true;
+    return child.startsWith(parent.endsWith(sep) ? parent : parent + sep);
+}
+/** Compared paths are real paths: /tmp is a symlink on macOS, among others. */
+function canonical(directory) {
+    const absolute = resolve(directory);
+    try {
+        return realpathSync(absolute);
+    }
+    catch {
+        return absolute;
+    }
+}

package/dist/tools.d.ts

@@ -1,8 +1,9 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { Project } from "./project.js";
 export type LeglasTools = {
     /** Stop anything the tools started. Wired to the transport's close. */
     shutdown(): Promise<void>;
 };
 export declare function registerLeglasTools(server: McpServer, options: {
-    cwd: string;
+    project: Project;
 }): LeglasTools;

package/dist/tools.js

@@ -23,8 +23,24 @@ async function capture(invoke) {
     }
     return { content: [{ type: "text", text: lines.join("\n") }], isError: exitCode !== 0 };
 }
+/**
+ * Run a command in the project, or report that there is no project to run it
+ * in. Resolution is asked for on the first call and held after that, so the
+ * cost lands once and every tool acts on the same directory.
+ */
+async function inProject(project, invoke) {
+    const located = await project.locate();
+    if (!located.ok) {
+        // The CLI's shape for a failure, so a host parses this like any other.
+        return {
+            content: [{ type: "text", text: JSON.stringify({ ok: false, error: located.reason }) }],
+            isError: true,
+        };
+    }
+    return capture((deps) => invoke(located.directory, deps));
+}
 export function registerLeglasTools(server, options) {
-    const cwd = options.cwd;
+    const project = options.project;
     // One viewer per MCP process. The handle is held so a host that dies or
     // disconnects never leaves a dev server running on a port nobody remembers.
     let viewer = null;
@@ -46,7 +62,7 @@ export function registerLeglasTools(server, options) {
                 ],
             };
         }
-        return capture(async (deps) => {
+        return inProject(project, async (cwd, deps) => {
             const result = await run({ port, userPort: undefined, configPath: undefined, open: false, json: true, cwd }, { open: async () => { }, log: deps.log });
             viewer = result;
             return result;
@@ -71,12 +87,12 @@ export function registerLeglasTools(server, options) {
             basedOn: z.string().optional()
                 .describe("Title of the direction this is a variant of; the rail groups the family."),
         },
-    }, async ({ title, url, note, tags, branch, file, basedOn }) => capture((deps) => runAdd({ preview: { title, url, note, tags, branch, file, basedOn }, json: true, cwd }, deps)));
+    }, async ({ title, url, note, tags, branch, file, basedOn }) => inProject(project, (cwd, deps) => runAdd({ preview: { title, url, note, tags, branch, file, basedOn }, json: true, cwd }, deps)));
     server.registerTool("list", {
         title: "List previews",
         description: "Every preview, shared and local, with its URL and backing branch if any.",
         inputSchema: {},
-    }, async () => capture((deps) => runList({ json: true, cwd }, deps)));
+    }, async () => inProject(project, (cwd, deps) => runList({ json: true, cwd }, deps)));
     server.registerTool("show", {
         title: "Inspect one direction",
         description: "Everything Leglas knows about one direction: its full entry, the source file behind " +
@@ -89,7 +105,7 @@ export function registerLeglasTools(server, options) {
                 .min(1)
                 .describe("The direction's title as the config spells it, not a renamed display name."),
         },
-    }, async ({ title }) => capture((deps) => runShow({ title, json: true, cwd }, deps)));
+    }, async ({ title }) => inProject(project, (cwd, deps) => runShow({ title, json: true, cwd }, deps)));
     server.registerTool("classify", {
         title: "Decide where a direction should live",
         description: "Before writing a direction, declare what it will touch and learn whether it can be " +
@@ -103,7 +119,7 @@ export function registerLeglasTools(server, options) {
             }))
                 .min(1),
         },
-    }, async ({ changes }) => capture((deps) => runClassify({ changes, json: true, cwd }, deps)));
+    }, async ({ changes }) => inProject(project, (cwd, deps) => runClassify({ changes, json: true, cwd }, deps)));
     server.registerTool("explore", {
         title: "Brief an exploration",
         description: "What a set for a surface needs and how it registers here. Directions must genuinely " +
@@ -118,7 +134,9 @@ export function registerLeglasTools(server, options) {
                 .optional()
                 .describe("An existing direction's title: ask for variants of it instead of new directions."),
         },
-    }, async ({ surface, count, basedOn }) => capture((deps) => runExplore({ surface, count: count ?? 3, basedOn: basedOn ?? null, json: true }, deps)));
+    }, async ({ surface, count, basedOn }) => capture((deps) => 
+    // The brief is the same wherever it is read from; it touches no project.
+    runExplore({ surface, count: count ?? 3, basedOn: basedOn ?? null, json: true }, deps)));
     server.registerTool("scaffold", {
         title: "Scaffold a branch point",
         description: "Create a switcher and a first direction for a surface under .leglas/variants/. " +
@@ -128,7 +146,7 @@ export function registerLeglasTools(server, options) {
             from: z.string().optional().describe("Path of the component rendering this surface today."),
             print: z.boolean().optional().describe("Print the scaffold instead of writing it."),
         },
-    }, async ({ surface, from, print }) => capture((deps) => runNew({ surface, print: print ?? false, json: true, from, cwd }, deps)));
+    }, async ({ surface, from, print }) => inProject(project, (cwd, deps) => runNew({ surface, print: print ?? false, json: true, from, cwd }, deps)));
     server.registerTool("keep", {
         title: "Keep a winner",
         description: "Move the winning direction into real source, delete the rest of the exploration, and " +
@@ -137,24 +155,25 @@ export function registerLeglasTools(server, options) {
             title: z.string().min(1).describe("Title of the direction to keep."),
             to: z.string().min(1).describe("Path in real source where the winner should live."),
         },
-    }, async ({ title, to }) => capture((deps) => runKeep({ title, to, json: true, cwd }, deps)));
+    }, async ({ title, to }) => inProject(project, (cwd, deps) => runKeep({ title, to, json: true, cwd }, deps)));
     server.registerTool("requests", {
         title: "Collect change requests",
         description: "Pending change requests made from the interface, each naming the direction and the file " +
             "behind it. Call this when starting work in a project that uses Leglas, and again before " +
             "changing any direction: the user may have described the change from the interface while " +
-            "you worked, and collecting marks it picked up there. Pass clear once they are done.",
+            "you worked, and collecting marks it picked up there. Pass clear once they are done: it " +
+            "drops what you collected and reports anything that arrived since, which is yours to do next.",
         inputSchema: {
             clear: z.boolean().optional(),
         },
-    }, async ({ clear }) => capture((deps) => runRequests({ json: true, clear: clear ?? false, cwd }, deps)));
+    }, async ({ clear }) => inProject(project, (cwd, deps) => runRequests({ json: true, clear: clear ?? false, cwd }, deps)));
     server.registerTool("init", {
         title: "Prepare a project",
         description: "Write the AGENTS.md section, a starter config, and the gitignore entry into this project.",
         inputSchema: {
             force: z.boolean().optional().describe("Rewrite the AGENTS.md section if it exists."),
         },
-    }, async ({ force }) => capture((deps) => runInit({ cwd, force: force ?? false, json: true }, deps)));
+    }, async ({ force }) => inProject(project, (cwd, deps) => runInit({ cwd, force: force ?? false, json: true }, deps)));
     return {
         shutdown: async () => {
             const running = viewer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leglas-mcp",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Stdio MCP server exposing Leglas to agent hosts that cannot run a shell.",
   "type": "module",
   "bin": {
@@ -15,7 +15,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
     "zod": "^3.25.76",
-    "leglas": "^0.2.0"
+    "leglas": "^0.3.0"
   },
   "license": "MIT",
   "repository": {