diff --git a/.changeset/astro-plugin-doctor-cwd.md b/.changeset/astro-plugin-doctor-cwd.md
new file mode 100644
index 0000000..8d09c41
--- /dev/null
+++ b/.changeset/astro-plugin-doctor-cwd.md
@@ -0,0 +1,5 @@
+---
+"@rrlab/astro-plugin": patch
+---
+
+`rr tsc doctor` looks for what `astro check` needs, `@astrojs/check` and `typescript`, in each package it checks instead of the directory `rr` was started from. Run at a monorepo root, it used to look for them there, and reported them missing when only the Astro package had them.
diff --git a/.changeset/astro-plugin-non-astro-packages.md b/.changeset/astro-plugin-non-astro-packages.md
new file mode 100644
index 0000000..742b370
--- /dev/null
+++ b/.changeset/astro-plugin-non-astro-packages.md
@@ -0,0 +1,5 @@
+---
+"@rrlab/astro-plugin": patch
+---
+
+In a monorepo, `rr tsc` and `rr check` run `astro check` only in the Astro packages, the ones with an `astro.config.*` or with `astro` in `dependencies`, `devDependencies` or `peerDependencies`, and `tsc --noEmit` in the other packages with a `tsconfig.json`. `astro check` used to run in every one of them, so in a plain TypeScript package it booted Astro, printed Vite warnings and wrote `.astro/` into the package. Such a package needs only `typescript`, and `rr tsc doctor` there checks `tsc`.
diff --git a/.changeset/cli-tsc-doctor-workspace.md b/.changeset/cli-tsc-doctor-workspace.md
new file mode 100644
index 0000000..98ce314
--- /dev/null
+++ b/.changeset/cli-tsc-doctor-workspace.md
@@ -0,0 +1,5 @@
+---
+"@rrlab/cli": minor
+---
+
+`rr tsc doctor` checks the packages `rr tsc` checks. In a monorepo it runs the health check in each workspace package with a `tsconfig.json`, one row per package, instead of once at the workspace root, which `rr tsc` never checks. The other `doctor` commands and `rr doctor` run in the package they report on, the one with the nearest `package.json`, instead of the directory `rr` was started from. Plugins get that package as `doctor({ cwd })`, typed by the new `DoctorOptions`.
diff --git a/run-run/CLAUDE.md b/run-run/CLAUDE.md
index fd313e6..99252f3 100644
--- a/run-run/CLAUDE.md
+++ b/run-run/CLAUDE.md
@@ -21,7 +21,7 @@ If you find yourself tempted to add a `pnpm <script>` that exists only to call `
 | Path | npm name | Role |
 |---|---|---|
 | `cli/` | `@rrlab/cli` | The kernel. Commander program, plugin registry, `rr` bin. Deep-dive in `cli/CLAUDE.md`. |
-| `astro-plugin/` | `@rrlab/astro-plugin` | `tsc` via `astro check`, which covers `.astro` and `.ts` files alike. |
+| `astro-plugin/` | `@rrlab/astro-plugin` | `tsc` via `astro check`, which covers `.astro` and `.ts` files alike. A monorepo's packages without Astro get `tsc --noEmit`. |
 | `biome-plugin/` | `@rrlab/biome-plugin` | `lint` + `format` + `jsc` via Biome. |
 | `oxc-plugin/` | `@rrlab/oxc-plugin` | `lint` (oxlint) + `format` (oxfmt) + `tsc` (oxlint type-aware). `jsc` is composed by the kernel. |
 | `ts-plugin/` | `@rrlab/ts-plugin` | `tsc` (TypeScript). Has `install()` that scaffolds `tsconfig.json` from a preset. |
diff --git a/run-run/astro-plugin/README.md b/run-run/astro-plugin/README.md
index 9d59bd0..fd64913 100644
--- a/run-run/astro-plugin/README.md
+++ b/run-run/astro-plugin/README.md
@@ -18,11 +18,15 @@ It needs `@rrlab/cli`, Astro 5 or later, `@astrojs/check` 0.9 or later, and Type
 | --- | --- |
 | `typecheck` | `rr tsc` (workspace-aware in monorepos), `rr check`, `rr tsc doctor` |
 
-`rr tsc` runs `astro check` in each package with a `tsconfig.json`. It reports the same diagnostics as `astro check`, for `.astro` files and plain `.ts` files alike, and fails when `astro check` exits non-zero, which it does on any error by default.
+`rr tsc` runs `astro check` in an Astro package: one with an `astro.config.*`, or with `astro` in its `dependencies`, `devDependencies` or `peerDependencies`. It reports the same diagnostics as `astro check`, for `.astro` files and plain `.ts` files alike, and fails when `astro check` exits non-zero, which it does on any error by default.
+
+In a monorepo, `rr tsc` checks each package with a `tsconfig.json`. It runs `astro check` in the Astro packages and `tsc --noEmit` in the others, so `astro` type-checks the whole workspace.
 
 `astro check` also checks your `.ts` files, so in an Astro project it replaces `ts`. Configure one `typecheck` provider. If another plugin also provides one, such as `ts` or `oxc`, narrow it: `oxc({ only: ["lint", "format"] })`.
 
-If `@astrojs/check` or `typescript` is missing, `rr tsc` fails and names it. Left alone, `astro check` would prompt to install them instead of checking anything.
+If `@astrojs/check` or `typescript` is missing, `rr tsc` fails and names it. Left alone, `astro check` would prompt to install them instead of checking anything. A package that isn't an Astro package needs only `typescript`.
+
+`rr tsc doctor` checks the packages `rr tsc` checks, each for the checker `rr tsc` runs there: `astro` and what `astro check` needs in an Astro package, `tsc` in the others.
 
 ## Removal
 
diff --git a/run-run/astro-plugin/src/__tests__/check.test.ts b/run-run/astro-plugin/src/__tests__/check.test.ts
index b903da8..2289de9 100644
--- a/run-run/astro-plugin/src/__tests__/check.test.ts
+++ b/run-run/astro-plugin/src/__tests__/check.test.ts
@@ -1,4 +1,4 @@
-import { readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -6,7 +6,7 @@ import { fileURLToPath } from "node:url";
 import { createShellService } from "@variablelab/clibuddy";
 import { satisfies } from "semver";
 import { afterEach, describe, expect, it } from "vitest";
-import { AstroCheckService } from "../index.ts";
+import { AstroCheckService, isAstroProject } from "../index.ts";
 
 // These run the real `astro check` against a tmp Astro project, so they are slow.
 const TIMEOUT = 60_000;
@@ -14,8 +14,10 @@ const PLUGIN_NODE_MODULES = path.resolve(path.dirname(fileURLToPath(import.meta.
 
 // astro refuses to start on a Node older than its own `engines.node` (astro 7 needs a
 // newer one than this repo's floor), so the tests that run it are skipped there. The
-// missing-dependency tests never start astro, so they run everywhere.
+// missing-dependency tests and those of a package without Astro never start astro, so
+// they run everywhere.
 const astroPkg = JSON.parse(readFileSync(path.join(PLUGIN_NODE_MODULES, "astro/package.json"), "utf8")) as {
+  version: string;
   engines: { node: string };
 };
 const ASTRO_RUNS = satisfies(process.versions.node, astroPkg.engines.node);
@@ -24,28 +26,49 @@ const CLEAN_PAGE = `---\nconst answer: number = 42;\n---\n<p>{answer}</p>\n`;
 const BROKEN_PAGE = `---\nconst answer: number = "forty-two";\n---\n<p>{answer}</p>\n`;
 const CLEAN_TS = "export const ok: number = 1;\n";
 const BROKEN_TS = 'export const bad: number = "not a number";\n';
+const ALL_DEPS = ["astro", "@astrojs/check", "typescript"];
 
-let tmpDir: string | undefined;
+const manifest = (fields: Record<string, unknown> = {}) =>
+  `${JSON.stringify({ name: "astro-fixture", private: true, type: "module", ...fields })}\n`;
+// A plain TS package's tsconfig: nothing from astro to extend.
+const PLAIN_TSCONFIG = `${JSON.stringify({
+  compilerOptions: { target: "es2022", module: "esnext", moduleResolution: "bundler", strict: true, noEmit: true },
+  include: ["src"],
+})}\n`;
+
+const tmpDirs: string[] = [];
 
 afterEach(async () => {
-  if (tmpDir) await fs.rm(tmpDir, { recursive: true, force: true });
-  tmpDir = undefined;
+  await Promise.all(tmpDirs.splice(0).map((dir) => fs.rm(dir, { recursive: true, force: true })));
 });
 
 /**
- * A minimal Astro project shaped like www (the `astro/tsconfigs/strict` preset,
- * `.astro/types.d.ts` included). Its node_modules links the given packages from
- * this plugin's own devDependencies, so `astro check` resolves them from the
- * project root as it would in a host project.
+ * A minimal Astro project shaped like www (`astro` in its dependencies, the
+ * `astro/tsconfigs/strict` preset, `.astro/types.d.ts` included). Its
+ * node_modules links the given packages from this plugin's own devDependencies,
+ * so `astro check` resolves them from the project root as it would in a host
+ * project.
  */
-async function makeProject(files: Record<string, string>, deps = ["astro", "@astrojs/check", "typescript"]) {
-  tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "rr-astro-plugin-"));
-  const all = {
-    "package.json": `${JSON.stringify({ name: "astro-fixture", private: true, type: "module" })}\n`,
-    "tsconfig.json": `${JSON.stringify({ extends: "astro/tsconfigs/strict", include: [".astro/types.d.ts", "**/*"] })}\n`,
-    ...files,
-  };
-  for (const [rel, content] of Object.entries(all)) {
+function makeProject(files: Record<string, string>, deps = ALL_DEPS) {
+  return makeDir(
+    {
+      "package.json": manifest({ dependencies: { astro: astroPkg.version } }),
+      "tsconfig.json": `${JSON.stringify({ extends: "astro/tsconfigs/strict", include: [".astro/types.d.ts", "**/*"] })}\n`,
+      ...files,
+    },
+    deps,
+  );
+}
+
+/** A plain TS package, as a monorepo has next to its Astro app: no `astro` dependency, no `astro.config.*`. */
+function makePackage(files: Record<string, string>, deps = ["typescript"]) {
+  return makeDir({ "package.json": manifest(), "tsconfig.json": PLAIN_TSCONFIG, ...files }, deps);
+}
+
+async function makeDir(files: Record<string, string>, deps: string[] = []) {
+  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "rr-astro-plugin-"));
+  tmpDirs.push(tmpDir);
+  for (const [rel, content] of Object.entries(files)) {
     const abs = path.join(tmpDir, rel);
     await fs.mkdir(path.dirname(abs), { recursive: true });
     await fs.writeFile(abs, content);
@@ -62,6 +85,40 @@ function service(cwd: string) {
   return new AstroCheckService(createShellService({ cwd }), cwd);
 }
 
+describe("isAstroProject()", () => {
+  it.each(["dependencies", "devDependencies", "peerDependencies"])("is true with astro in %s", async (field) => {
+    const dir = await makeDir({ "package.json": manifest({ [field]: { astro: "^7.0.0" } }) });
+    expect(await isAstroProject(dir)).toBe(true);
+  });
+
+  it.each(["mjs", "js", "ts", "mts", "cjs", "cts"])("is true with an astro.config.%s and no astro dependency", async (ext) => {
+    const dir = await makeDir({ "package.json": manifest(), [`astro.config.${ext}`]: "export default {};\n" });
+    expect(await isAstroProject(dir)).toBe(true);
+  });
+
+  it("is false with neither", async () => {
+    const dir = await makeDir({ "package.json": manifest({ dependencies: { react: "^19.0.0" } }) });
+    expect(await isAstroProject(dir)).toBe(false);
+  });
+
+  it("reads the package's own manifest, not its workspace root's", async () => {
+    const root = await makeDir({
+      "package.json": manifest({ devDependencies: { astro: "^7.0.0" } }),
+      "packages/lib/package.json": manifest(),
+    });
+    expect(await isAstroProject(path.join(root, "packages/lib"))).toBe(false);
+  });
+
+  it.each([
+    ["missing", {}],
+    ["malformed", { "package.json": "{ not json" }],
+    ["not an object", { "package.json": "null\n" }],
+  ])("is false when package.json is %s", async (_, files: Record<string, string>) => {
+    const dir = await makeDir(files);
+    expect(await isAstroProject(dir)).toBe(false);
+  });
+});
+
 describe("AstroCheckService.check()", () => {
   it.runIf(ASTRO_RUNS)(
     "passes on a project without type errors",
@@ -98,6 +155,75 @@ describe("AstroCheckService.check()", () => {
     TIMEOUT,
   );
 
+  it.runIf(ASTRO_RUNS)(
+    "runs astro check in a component library, with astro as a peer dependency and no config",
+    async () => {
+      // tsc can't check a .astro file (no inputs), so a library without a config still needs astro check.
+      const cwd = await makeProject({
+        "package.json": manifest({ peerDependencies: { astro: ">=5.0.0" } }),
+        "src/Button.astro": BROKEN_PAGE,
+      });
+      const report = await service(cwd).check({ cwd });
+      expect(report.ok).toBe(false);
+      expect(report.output).toContain("$ astro check");
+      expect(report.output).toContain("src/Button.astro");
+    },
+    TIMEOUT,
+  );
+
+  it.runIf(ASTRO_RUNS)(
+    "runs astro check in a project with an astro.config but no astro dependency of its own",
+    async () => {
+      // As in a monorepo app whose `astro` is hoisted to the workspace root.
+      const cwd = await makeProject({
+        "package.json": manifest(),
+        "astro.config.mjs": "export default {};\n",
+        "src/pages/index.astro": CLEAN_PAGE,
+      });
+      const report = await service(cwd).check({ cwd });
+      expect(report.ok, report.output).toBe(true);
+      expect(report.output).toContain("$ astro check");
+    },
+    TIMEOUT,
+  );
+
+  it(
+    "runs tsc, not astro check, in a package without Astro",
+    async () => {
+      // A monorepo's plain TS package, where astro's deps resolve as they do once hoisted. astro check
+      // ran there, booted Astro, warned about Vite and wrote `.astro/` into the package.
+      const cwd = await makePackage({ "src/bad.ts": BROKEN_TS }, ALL_DEPS);
+      const report = await service(cwd).check({ cwd });
+      expect(report.ok).toBe(false);
+      expect(report.output).toContain("$ tsc --noEmit --pretty");
+      expect(report.output).not.toContain("$ astro check");
+      expect(report.output).toContain("src/bad.ts");
+      expect(report.output).toMatch(/Type 'string' is not assignable to type 'number'/);
+      expect(existsSync(path.join(cwd, ".astro"))).toBe(false);
+    },
+    TIMEOUT,
+  );
+
+  it(
+    "passes a package without Astro and without type errors",
+    async () => {
+      const cwd = await makePackage({ "src/ok.ts": CLEAN_TS });
+      const report = await service(cwd).check({ cwd });
+      expect(report.ok, report.output).toBe(true);
+      expect(report.output).toContain("$ tsc --noEmit --pretty");
+    },
+    TIMEOUT,
+  );
+
+  it("fails naming only typescript when a package without Astro can't resolve it", async () => {
+    const cwd = await makePackage({ "src/ok.ts": CLEAN_TS }, []);
+    const report = await service(cwd).check({ cwd });
+    expect(report.ok).toBe(false);
+    expect(report.output).toMatchInlineSnapshot(
+      `"@rrlab/astro-plugin requires typescript to be installed in the host project. Run: rr plugins add astro  (or: pnpm add -D typescript)"`,
+    );
+  });
+
   it("fails without running astro when @astrojs/check is missing", async () => {
     // Left to itself, astro would prompt to install it: a hang under capture, a false pass without stdin.
     const cwd = await makeProject({ "src/pages/index.astro": BROKEN_PAGE }, ["astro", "typescript"]);
@@ -123,4 +249,36 @@ describe("AstroCheckService.doctor()", () => {
     expect(report.ok).toBe(false);
     expect(report.output).toContain("requires @astrojs/check, typescript to be installed");
   });
+
+  it("checks tsc, the checker it runs there, in a package without Astro", async () => {
+    const cwd = await makePackage({});
+    const report = await service(cwd).doctor();
+    expect(report.ok, report.output).toBe(true);
+    expect(report.output).toContain("$ tsc --help");
+  });
+
+  it("asks only for typescript in a package without Astro", async () => {
+    const cwd = await makePackage({}, []);
+    const report = await service(cwd).doctor();
+    expect(report.ok).toBe(false);
+    expect(report.output).toContain("requires typescript to be installed");
+    expect(report.output).not.toContain("@astrojs/check");
+  });
+
+  it("checks the package it's given, not the one rr runs in", async () => {
+    // `rr tsc doctor` at a workspace root hands it each package `rr tsc` checks.
+    const root = await makeProject({}, ["astro"]);
+    const pkg = await makePackage({});
+    const report = await service(root).doctor({ cwd: pkg });
+    expect(report.ok, report.output).toBe(true);
+    expect(report.output).toContain("$ tsc --help");
+  });
+
+  it("fails for a package it's given that can't run its checker, wherever rr runs", async () => {
+    const root = await makeProject({});
+    const pkg = await makeProject({}, ["astro"]);
+    const report = await service(root).doctor({ cwd: pkg });
+    expect(report.ok).toBe(false);
+    expect(report.output).toContain("requires @astrojs/check, typescript to be installed");
+  });
 });
diff --git a/run-run/astro-plugin/src/index.ts b/run-run/astro-plugin/src/index.ts
index c0f8a60..3f32edd 100644
--- a/run-run/astro-plugin/src/index.ts
+++ b/run-run/astro-plugin/src/index.ts
@@ -1,5 +1,8 @@
+import fs from "node:fs/promises";
 import { createRequire } from "node:module";
+import path from "node:path";
 import {
+  type DoctorOptions,
   definePlugin,
   type InstallContext,
   type InstallResult,
@@ -19,42 +22,101 @@ const FROM = import.meta.url;
 const localRequire = createRequire(FROM);
 // What `astro check` loads from the project root before checking anything.
 const CHECK_DEPS = ["@astrojs/check", "typescript"] as const;
+// What a package without Astro is checked with instead.
+const TSC_DEPS = ["typescript"] as const;
+// astro 7 looks for the first four; astro 5, the peer floor, also loads a CommonJS config.
+const CONFIG_FILES = ["mjs", "js", "ts", "mts", "cjs", "cts"].map((ext) => `astro.config.${ext}`);
 const astroColor = colorize("#BC52EE");
 
+/**
+ * The `typecheck` provider. In a monorepo `rr tsc` hands it every package with
+ * a `tsconfig.json`, and no second provider can cover the ones without Astro,
+ * so each package gets the checker that fits it: `astro check` in an Astro
+ * package, `tsc --noEmit` in any other. Run there, `astro check` would boot
+ * Astro, warn about Vite and write `.astro/` into the package.
+ */
 export class AstroCheckService extends ToolService implements TypeChecker {
   #cwd: string;
+  #tsc: ToolService;
 
   constructor(shellService: ShellService, cwd: string) {
     super({ bin: "astro", color: astroColor, shellService, from: FROM });
     this.#cwd = cwd;
+    this.#tsc = new ToolService({ pkg: "typescript", bin: "tsc", color: astroColor, shellService, from: FROM });
   }
 
   async check(options: TypeCheckOptions = {}): Promise<RunReport> {
     const cwd = options.cwd ?? this.#cwd;
-    const missing = missingCheckDeps(cwd);
+    const { astro, missing } = await checkerAt(cwd);
     if (missing.length > 0) return missingDepsReport(missing);
+    // `--pretty` forces color + formatting even when captured (tsc otherwise
+    // drops color off a TTY); see decisions/013.
+    if (!astro) return this.#tsc.runReport(["--noEmit", "--pretty"], { cwd });
     // `astro check`, not @astrojs/check's own `astro-check` bin: only the
     // former runs `astro sync` first, so generated types (content collections,
     // `astro:env`, …) exist. Its diagnostics keep their color when captured.
     return this.runReport(["check"], { cwd });
   }
 
-  override async doctor(): Promise<RunReport> {
-    const missing = missingCheckDeps(this.#cwd);
+  override async doctor(options: DoctorOptions = {}): Promise<RunReport> {
+    const cwd = options.cwd ?? this.#cwd;
+    const { astro, missing } = await checkerAt(cwd);
     if (missing.length > 0) return missingDepsReport(missing);
-    return super.doctor();
+    return astro ? super.doctor({ cwd }) : this.#tsc.doctor({ cwd });
   }
 }
 
 /**
- * Lists the `astro check` dependencies the project at `root` can't resolve,
- * looking them up the way astro does (`require.resolve(pkg, { paths: [root] })`).
- * When one is missing, astro prompts to install it instead of checking: under a
+ * Picks the checker for the package at `dir`, `astro check` in an Astro
+ * package and `tsc` in any other, and lists what that checker needs but can't
+ * resolve there.
+ */
+async function checkerAt(dir: string): Promise<{ astro: boolean; missing: string[] }> {
+  const astro = await isAstroProject(dir);
+  return { astro, missing: missingCheckDeps(dir, astro ? CHECK_DEPS : TSC_DEPS) };
+}
+
+/**
+ * Whether the package at `dir` is an Astro project: it has an `astro.config.*`,
+ * or `astro` in its `dependencies`, `devDependencies` or `peerDependencies`.
+ * Either is enough. An app whose `astro` is hoisted to the workspace root has
+ * only the config, and a component library has only the dependency, since
+ * Astro needs a config file only when there is something to configure.
+ */
+export async function isAstroProject(dir: string): Promise<boolean> {
+  const configs = await Promise.all(CONFIG_FILES.map((name) => pathExists(path.join(dir, name))));
+  if (configs.some(Boolean)) return true;
+  const { dependencies, devDependencies, peerDependencies } = await readManifest(dir);
+  return [dependencies, devDependencies, peerDependencies].some((deps) => isRecord(deps) && "astro" in deps);
+}
+
+/**
+ * The package's own `package.json`, or `{}` when it has none or it doesn't
+ * parse. Not the nearest one up the tree: an `astro` dependency of the
+ * workspace root doesn't make every package under it an Astro package.
+ */
+async function readManifest(dir: string): Promise<Record<string, unknown>> {
+  try {
+    const manifest: unknown = JSON.parse(await fs.readFile(path.join(dir, "package.json"), "utf8"));
+    return isRecord(manifest) ? manifest : {};
+  } catch {
+    return {};
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+/**
+ * Lists the `deps` the project at `root` can't resolve, looking them up the way
+ * astro does (`require.resolve(pkg, { paths: [root] })`). When one `astro check`
+ * needs is missing, astro prompts to install it instead of checking: under a
  * captured run that prompt hangs, and with stdin closed astro exits 0 having
- * checked nothing. So we fail before running it.
+ * checked nothing. So we fail before running it, and name what is missing.
  */
-export function missingCheckDeps(root: string): string[] {
-  return CHECK_DEPS.filter((pkg) => {
+export function missingCheckDeps(root: string, deps: readonly string[] = CHECK_DEPS): string[] {
+  return deps.filter((pkg) => {
     try {
       localRequire.resolve(pkg, { paths: [root] });
       return false;
@@ -88,6 +150,15 @@ export async function uninstall(_ctx: UninstallContext): Promise<UninstallResult
   return { removeDependencies: ["@astrojs/check", "typescript"] };
 }
 
+async function pathExists(p: string): Promise<boolean> {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 const astro = definePlugin({
   apiVersion: 1,
   name: "astro",
diff --git a/run-run/cli/CLAUDE.md b/run-run/cli/CLAUDE.md
index eb57ff6..e993f7c 100644
--- a/run-run/cli/CLAUDE.md
+++ b/run-run/cli/CLAUDE.md
@@ -107,7 +107,7 @@ export function create<Name>Command(ctx: ContextValue) {
 
 The service is resolved **inside** the action / doctor callback via `ctx.plugins.getServiceOrThrow`, not hoisted to the top of the factory — so the command tree is identical regardless of which plugins are configured (the `doctor` subcommand always exists; the throw happens only on invocation). That keeps `--help` and the `--usage` KDL spec stable across machines. `jsc` is the one exception: it has no single registry capability, so it resolves via `ctx.plugins.getJsChecker()` — the composed-capability resolver, shared with `rr check`.
 
-`.addDoctorCommand(fn)` (on the `Cmd` base class) attaches the per-tool `doctor` subcommand that every plugin-backed command exposes; its callback resolves the service and delegates to `doctorOneAction`, rendering the canonical `doctor (<tool>) · <pkg>` row.
+`.addDoctorCommand(fn)` (on the `Cmd` base class) attaches the per-tool `doctor` subcommand that every plugin-backed command exposes; its callback resolves the service and delegates to `doctorOneAction`, rendering the canonical `doctor (<tool>) · <pkg>` row and running `service.doctor({ cwd })` in that package. `tsc doctor` is the exception: it delegates to `tscDoctorAction`, which checks the packages `tsc` checks, so in a monorepo it fans out to one row per workspace package with a `tsconfig.json`. A plugin whose health depends on the package (astro resolves `@astrojs/check` from it) reads `options.cwd` in its `doctor` override.
 
 `MissingPluginError` (`src/errors/missing-plugin.ts`) takes just a `capability` and builds the `rr plugins add <alias>` hint by looking up which plugins provide it via `providersOf(capability)` in `src/lib/plugin/directory.ts`; `getServiceOrThrow` / `getJsChecker` raise it for you. The per-command `Powered by:` / `See also:` block is produced by `Cmd.addHelpTextAfter` (`src/program/base.ts`) and is **fully derived from the declared capabilities** — there's no `render/command-help.ts` / `render/powered-by.ts` anymore:
 
diff --git a/run-run/cli/src/actions/doctor.ts b/run-run/cli/src/actions/doctor.ts
index 4cee6b0..eaf4e2c 100644
--- a/run-run/cli/src/actions/doctor.ts
+++ b/run-run/cli/src/actions/doctor.ts
@@ -17,19 +17,25 @@ export type DoctorOneActionConfig = {
 };
 
 /**
- * A single tool's `doctor` as one board row (`doctor (<tool>) · <pkg>`) — used
- * by the `doctor` subcommand each plugin-backed command exposes.
+ * A single tool's `doctor` as one board row (`doctor (<tool>) · <pkg>`), run in
+ * that package — used by the `doctor` subcommand each plugin-backed command
+ * exposes, except `tsc doctor`, which checks the packages `tsc` checks
+ * (`tscDoctorAction`).
  */
 export async function doctorOneAction({ ctx, service }: DoctorOneActionConfig): Promise<void> {
-  const result = await runBoard([reportTask(targetLabel("doctor", service, ctx.appPkg), () => service.doctor())]);
+  const { appPkg } = ctx;
+  const label = targetLabel("doctor", service, appPkg);
+  const result = await runBoard([reportTask(label, () => service.doctor({ cwd: appPkg.dirPath }))]);
   if (!result.ok) process.exitCode = 1;
 }
 
 /**
  * Top-level `rr doctor` — runs the `doctor()` of every distinct capability
- * impl registered with the kernel. Distinct because a single plugin (e.g.
- * biome) often serves multiple kinds (`lint`, `format`, `jscheck`) from the same
- * `BiomeService` instance; running its doctor three times is wasteful.
+ * impl registered with the kernel, in the current package. Distinct because a
+ * single plugin (e.g. biome) often serves multiple kinds (`lint`, `format`,
+ * `jscheck`) from the same `BiomeService` instance; running its doctor three
+ * times is wasteful. It stays one row per tool, so in a monorepo it doesn't fan
+ * the typecheck provider out over the workspace the way `rr tsc doctor` does.
  */
 export async function doctorAction({ ctx }: DoctorActionConfig): Promise<void> {
   const services = ctx.plugins.getAllServices();
@@ -41,7 +47,7 @@ export async function doctorAction({ ctx }: DoctorActionConfig): Promise<void> {
 
   // Each tool's health check is one parallel board row — a fan-out across
   // tools, so the rows carry the tool name and the title omits a single tool.
-  const tasks = services.map((svc) => reportTask(svc.ui, () => svc.doctor()));
+  const tasks = services.map((svc) => reportTask(svc.ui, () => svc.doctor({ cwd: ctx.appPkg.dirPath })));
   const result = await runBoard(tasks, { title: fanoutTitle("doctor", undefined, services.length, "tools") });
   if (!result.ok) process.exitCode = 1;
 }
diff --git a/run-run/cli/src/actions/tsc.ts b/run-run/cli/src/actions/tsc.ts
index fc4c35e..b5f07b1 100644
--- a/run-run/cli/src/actions/tsc.ts
+++ b/run-run/cli/src/actions/tsc.ts
@@ -1,3 +1,4 @@
+import type { Pkg } from "@variablelab/clibuddy";
 import { type BoardTask, reportTask, runBoard } from "#src/render/board.ts";
 import { fanoutTitle, targetLabel } from "#src/render/labels.ts";
 import type { ContextValue } from "#src/services/context.ts";
@@ -9,15 +10,26 @@ export type TscActionConfig = {
   tsc: TypeChecker & Doctor;
 };
 
+export type TscDoctorActionConfig = {
+  ctx: ContextValue;
+  tsc: TypeChecker & Doctor;
+};
+
 type Scripts = Record<string, string | undefined> | undefined;
 
 const getPreScript = (scripts: Scripts) => scripts?.pretscheck ?? scripts?.pretsc ?? scripts?.pretypecheck;
 
+const isTsProject = (appPkg: Pkg, dir: string) => appPkg.hasFile("tsconfig.json", dir);
+
+/** The packages a monorepo's `rr tsc` checks: each workspace package with a `tsconfig.json`, never the root. */
+async function getTsProjects(appPkg: Pkg) {
+  const projects = await appPkg.getWorkspaceProjects();
+  return projects.filter((project) => isTsProject(appPkg, project.rootDir));
+}
+
 export async function tscAction({ ctx, tsc }: TscActionConfig): Promise<void> {
   const { appPkg, shell } = ctx;
 
-  const isTsProject = (dir: string) => appPkg.hasFile("tsconfig.json", dir);
-
   // A package's `pretscheck`/`pretsc`/`pretypecheck` runs captured, inside the task, so its
   // output stays grouped with that package. It may use shell features, so it
   // goes through `/bin/sh -c`. A failing pre-script fails the task before tsc.
@@ -38,7 +50,7 @@ export async function tscAction({ ctx, tsc }: TscActionConfig): Promise<void> {
     });
 
   if (!appPkg.isMonorepo()) {
-    if (!isTsProject(appPkg.dirPath)) {
+    if (!isTsProject(appPkg, appPkg.dirPath)) {
       logger.info("No tsconfig.json found, skipping typecheck");
       return;
     }
@@ -51,8 +63,7 @@ export async function tscAction({ ctx, tsc }: TscActionConfig): Promise<void> {
     return;
   }
 
-  const projects = await appPkg.getWorkspaceProjects();
-  const tsProjects = projects.filter((project) => isTsProject(project.rootDir));
+  const tsProjects = await getTsProjects(appPkg);
 
   if (!tsProjects.length) {
     logger.warn("No ts projects found in the monorepo, skipping typecheck");
@@ -63,3 +74,26 @@ export async function tscAction({ ctx, tsc }: TscActionConfig): Promise<void> {
   const result = await runBoard(tasks, { title: fanoutTitle("tsc", tsc, tsProjects.length, "packages") });
   if (!result.ok) process.exitCode = 1;
 }
+
+/**
+ * `rr tsc doctor` — the typecheck provider's `doctor`, run in the packages
+ * `rr tsc` checks: in a monorepo, one row per workspace package with a
+ * `tsconfig.json`; otherwise the single `doctor (<tool>) · <pkg>` row. Where
+ * `rr tsc` would skip (no `tsconfig.json`), it still checks the current
+ * package, since the tool can be broken there all the same.
+ */
+export async function tscDoctorAction({ ctx, tsc }: TscDoctorActionConfig): Promise<void> {
+  const { appPkg } = ctx;
+  const tsProjects = appPkg.isMonorepo() ? await getTsProjects(appPkg) : [];
+
+  if (!tsProjects.length) {
+    const label = targetLabel("doctor", tsc, appPkg);
+    const result = await runBoard([reportTask(label, () => tsc.doctor({ cwd: appPkg.dirPath }))]);
+    if (!result.ok) process.exitCode = 1;
+    return;
+  }
+
+  const tasks = tsProjects.map((p) => reportTask(p.manifest.name ?? p.rootDir, () => tsc.doctor({ cwd: p.rootDir })));
+  const result = await runBoard(tasks, { title: fanoutTitle("doctor", tsc, tsProjects.length, "packages") });
+  if (!result.ok) process.exitCode = 1;
+}
diff --git a/run-run/cli/src/lib/plugin/__tests__/tool-service.test.ts b/run-run/cli/src/lib/plugin/__tests__/tool-service.test.ts
new file mode 100644
index 0000000..e3ea89b
--- /dev/null
+++ b/run-run/cli/src/lib/plugin/__tests__/tool-service.test.ts
@@ -0,0 +1,50 @@
+import { mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { stripVTControlCharacters } from "node:util";
+import { createShellService } from "@variablelab/clibuddy";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { ToolService } from "#src/lib/plugin/tool-service.ts";
+
+let dir: string;
+let bin: string;
+
+// A stand-in tool that prints the directory it was spawned in and fails, so
+// even `doctor()`, which drops the output of a passing run, surfaces it.
+beforeAll(() => {
+  dir = realpathSync(mkdtempSync(path.join(tmpdir(), "rr-tool-service-")));
+  bin = path.join(dir, "where");
+  writeFileSync(bin, "#!/bin/sh\npwd -P\nexit 1\n", { mode: 0o755 });
+});
+
+afterAll(() => rmSync(dir, { recursive: true, force: true }));
+
+const plain = (output: string) => stripVTControlCharacters(output);
+
+class WhereService extends ToolService {
+  constructor() {
+    super({ bin: "where", color: (s) => s, shellService: createShellService(), from: import.meta.url });
+  }
+
+  override async getBinDir() {
+    return bin;
+  }
+}
+
+describe("ToolService", () => {
+  it("runs doctor() in the given cwd", async () => {
+    const report = await new WhereService().doctor({ cwd: dir });
+    expect(report.ok).toBe(false);
+    expect(plain(report.output)).toBe(`$ where --help\n${dir}`);
+  });
+
+  it("runs doctor() where rr runs without one", async () => {
+    const report = await new WhereService().doctor();
+    expect(plain(report.output)).toBe(`$ where --help\n${realpathSync(process.cwd())}`);
+  });
+
+  it("runs runReport() in the given cwd", async () => {
+    const report = await new WhereService().runReport([], { cwd: dir });
+    expect(plain(report.output)).toBe(`$ where\n${dir}`);
+  });
+});
diff --git a/run-run/cli/src/lib/plugin/index.ts b/run-run/cli/src/lib/plugin/index.ts
index 9ed44c3..57f4106 100644
--- a/run-run/cli/src/lib/plugin/index.ts
+++ b/run-run/cli/src/lib/plugin/index.ts
@@ -7,6 +7,7 @@ export type {
   ClackPrompts,
   ClackPromptsSelectOption,
   Doctor,
+  DoctorOptions,
   FileOp,
   FormatOptions,
   Formatter,
diff --git a/run-run/cli/src/lib/plugin/tool-service.ts b/run-run/cli/src/lib/plugin/tool-service.ts
index 67df177..7fbcccd 100644
--- a/run-run/cli/src/lib/plugin/tool-service.ts
+++ b/run-run/cli/src/lib/plugin/tool-service.ts
@@ -1,5 +1,5 @@
 import { palette, resolvePackageBin, type ShellService } from "@variablelab/clibuddy";
-import type { RunReport } from "#src/types/tool.ts";
+import type { DoctorOptions, RunReport } from "#src/types/tool.ts";
 
 export type ToolServiceOptions = {
   pkg?: string;
@@ -58,8 +58,7 @@ export class ToolService {
    * and the caller can aggregate. See `decisions/013-check-stream-to-capture-contract.md`.
    */
   async runReport(args: string[] = [], options: RunReportOptions = {}): Promise<RunReport> {
-    const sh = options.cwd ? this.#shellService.at(options.cwd) : this.#shellService;
-    const output = await sh.runCaptured(await this.getBinDir(), args, { throwOnError: false });
+    const output = await this.#shellAt(options.cwd).runCaptured(await this.getBinDir(), args, { throwOnError: false });
     // Lead the captured output with the command line that ran — the same
     // `$ <cmd>` the streaming path prints via `printCmdLine`, so it stays
     // visible even when captured. It's dim so it reads as context, not result.
@@ -83,13 +82,14 @@ export class ToolService {
    * mirroring `runReport`'s strict `=== 0`.
    */
   async runStreamed(command: string, args: string[] = [], options: RunReportOptions = {}): Promise<number> {
-    const sh = options.cwd ? this.#shellService.at(options.cwd) : this.#shellService;
-    const result = await sh.run(command, args, { throwOnError: false, verbose: false });
+    const result = await this.#shellAt(options.cwd).run(command, args, { throwOnError: false, verbose: false });
     return result.exitCode ?? 1;
   }
 
-  async doctor(): Promise<RunReport> {
-    const output = await this.#shellService.runCaptured(await this.getBinDir(), ["--help"], { throwOnError: false });
+  async doctor(options: DoctorOptions = {}): Promise<RunReport> {
+    const output = await this.#shellAt(options.cwd).runCaptured(await this.getBinDir(), ["--help"], {
+      throwOnError: false,
+    });
     const ok = output.exitCode === 0;
     // Same shape as the other verbs: lead with the `$ <bin> --help` liveness
     // command (the tool's full help text is noise on success, so it's dropped);
@@ -100,6 +100,11 @@ export class ToolService {
     const detail = combine(output.stdout, output.stderr);
     return { ok, output: detail ? `${command}\n${detail}` : command };
   }
+
+  /** The shell to spawn in: at `cwd` when given, else where `rr` runs. */
+  #shellAt(cwd: string | undefined): ShellService {
+    return cwd ? this.#shellService.at(cwd) : this.#shellService;
+  }
 }
 
 /** Joins the non-empty, trimmed streams of a captured run. */
diff --git a/run-run/cli/src/program/commands/tscheck.ts b/run-run/cli/src/program/commands/tscheck.ts
index 4f3a425..62137be 100644
--- a/run-run/cli/src/program/commands/tscheck.ts
+++ b/run-run/cli/src/program/commands/tscheck.ts
@@ -1,5 +1,4 @@
-import { doctorOneAction } from "#src/actions/doctor.ts";
-import { tscAction } from "#src/actions/tsc.ts";
+import { tscAction, tscDoctorAction } from "#src/actions/tsc.ts";
 import type { ContextValue } from "#src/services/context.ts";
 import { createCommand } from "../base.ts";
 
@@ -18,6 +17,6 @@ export function createTsCheckCommand(ctx: ContextValue) {
     .addHelpTextAfter(ctx)
     .addDoctorCommand(async () => {
       const tsc = ctx.plugins.getServiceOrThrow("typecheck");
-      await doctorOneAction({ ctx, service: tsc });
+      await tscDoctorAction({ ctx, tsc });
     });
 }
diff --git a/run-run/cli/src/services/__tests__/static-checker.test.ts b/run-run/cli/src/services/__tests__/static-checker.test.ts
index 65aceee..370a032 100644
--- a/run-run/cli/src/services/__tests__/static-checker.test.ts
+++ b/run-run/cli/src/services/__tests__/static-checker.test.ts
@@ -93,6 +93,14 @@ describe("StaticCheckService", () => {
       expect(res.output).toContain("boom");
     });
 
+    it("runs both providers' doctors with the options it was given", async () => {
+      const linter = makeLinter();
+      const formatter = makeFormatter();
+      await new StaticCheckService(linter, formatter).doctor({ cwd: "/repo/packages/a" });
+      expect(linter.doctor).toHaveBeenCalledWith({ cwd: "/repo/packages/a" });
+      expect(formatter.doctor).toHaveBeenCalledWith({ cwd: "/repo/packages/a" });
+    });
+
     it("returns ok=false when only the formatter doctor fails", async () => {
       const formatter = makeFormatter({ doctor: vi.fn(async () => ({ ok: false, output: "kaput" })) });
       const res = await new StaticCheckService(makeLinter(), formatter).doctor();
diff --git a/run-run/cli/src/services/static-checker.ts b/run-run/cli/src/services/static-checker.ts
index 48db379..e75f1a3 100644
--- a/run-run/cli/src/services/static-checker.ts
+++ b/run-run/cli/src/services/static-checker.ts
@@ -1,4 +1,12 @@
-import type { Doctor, Formatter, Linter, RunReport, StaticChecker, StaticCheckerOptions } from "#src/types/tool.ts";
+import type {
+  Doctor,
+  DoctorOptions,
+  Formatter,
+  Linter,
+  RunReport,
+  StaticChecker,
+  StaticCheckerOptions,
+} from "#src/types/tool.ts";
 
 export class StaticCheckService implements StaticChecker, Doctor {
   #linter: Linter & Doctor;
@@ -23,8 +31,8 @@ export class StaticCheckService implements StaticChecker, Doctor {
     ]);
   }
 
-  async doctor(): Promise<RunReport> {
-    const [lintRes, fmtRes] = await Promise.all([this.#linter.doctor(), this.#formatter.doctor()]);
+  async doctor(options: DoctorOptions = {}): Promise<RunReport> {
+    const [lintRes, fmtRes] = await Promise.all([this.#linter.doctor(options), this.#formatter.doctor(options)]);
 
     return this.#mergeReports([
       { ui: this.#linter.ui, report: lintRes },
diff --git a/run-run/cli/src/types/tool.ts b/run-run/cli/src/types/tool.ts
index 263faa2..c87995c 100644
--- a/run-run/cli/src/types/tool.ts
+++ b/run-run/cli/src/types/tool.ts
@@ -20,8 +20,13 @@ export type TypeCheckOptions = {
   cwd?: string;
 };
 
+export type DoctorOptions = {
+  /** The package to check the tool from. Defaults to where `rr` runs. */
+  cwd?: string;
+};
+
 export type Doctor = {
-  doctor: () => Promise<RunReport>;
+  doctor: (options?: DoctorOptions) => Promise<RunReport>;
 };
 
 export type Formatter = {
diff --git a/run-run/cli/test/integration/tsc.test.ts b/run-run/cli/test/integration/tsc.test.ts
index 718338a..bafc03f 100644
--- a/run-run/cli/test/integration/tsc.test.ts
+++ b/run-run/cli/test/integration/tsc.test.ts
@@ -1,3 +1,4 @@
+import path from "node:path";
 import { afterEach, beforeEach, describe, expect, test } from "vitest";
 import { createTestCli, fixtures, makeFixture } from "#test/helpers.ts";
 
@@ -24,6 +25,65 @@ describe("rr tsc", () => {
     });
   });
 
+  describe("doctor in a pnpm workspace", () => {
+    const workspace = (plugin: "ts" | "astro", packages: Record<string, string>) =>
+      makeFixture(`tsc-doctor-${plugin}-workspace`, {
+        "package.json": fixtures.pkg(),
+        "pnpm-workspace.yaml": "packages:\n  - packages/*\n",
+        "run-run.config.mts": fixtures.config([plugin]),
+        ...packages,
+      });
+
+    const tsPackage = (name: string) => ({
+      [`packages/${name}/package.json`]: fixtures.pkg(name),
+      [`packages/${name}/tsconfig.json`]: fixtures.tsconfig(),
+      [`packages/${name}/src/ok.ts`]: "export const ok: number = 1;\n",
+    });
+
+    test("checks the packages `rr tsc` checks, one row each, and not the workspace root", () => {
+      fixture = workspace("ts", {
+        ...tsPackage("a"),
+        ...tsPackage("b"),
+        // No tsconfig.json: `rr tsc` skips it, so doctor does too.
+        "packages/c/package.json": fixtures.pkg("c"),
+      });
+      const r = cli("tsc doctor", { cwd: fixture.dir });
+      const combined = r.stdout + r.stderr;
+      expect(combined).toContain("doctor (tsc) · 2 packages");
+      expect(combined).toMatch(/✔ a\b/);
+      expect(combined).toMatch(/✔ b\b/);
+      expect(combined).not.toMatch(/[✔✖] c\b/);
+      expect(combined).not.toContain("rr-test-fixture");
+      expect(r.status).toBe(0);
+    });
+
+    test("from inside a package, checks that package alone", () => {
+      fixture = workspace("ts", { ...tsPackage("a"), ...tsPackage("b") });
+      const r = cli("tsc doctor", { cwd: path.join(fixture.dir, "packages/a") });
+      const combined = r.stdout + r.stderr;
+      expect(combined).toContain("doctor (tsc) · a");
+      expect(combined).not.toMatch(/· \d+ packages/);
+      expect(r.status).toBe(0);
+    });
+
+    test("checks each package with the tool `rr tsc` runs there, and fails for the one that can't run it", () => {
+      // astro: `site` is an Astro package missing @astrojs/check; `lib` is plain TS, checked with tsc.
+      fixture = workspace("astro", {
+        "packages/site/package.json": `${JSON.stringify({ name: "site", private: true, dependencies: { astro: "^7.0.0" } })}\n`,
+        "packages/site/tsconfig.json": fixtures.tsconfig(),
+        ...tsPackage("lib"),
+      });
+      // pnpm's bin shim puts its virtual store on NODE_PATH, where @astrojs/check resolves from anywhere.
+      const r = cli("tsc doctor", { cwd: fixture.dir, env: { NODE_PATH: undefined } });
+      const combined = r.stdout + r.stderr;
+      expect(combined).toContain("doctor (astro) · 2 packages");
+      expect(combined).toMatch(/✖ site\b/);
+      expect(combined).toContain("requires @astrojs/check to be installed");
+      expect(combined).toMatch(/✔ lib\b/);
+      expect(r.status).toBe(1);
+    });
+  });
+
   describe("happy path", () => {
     beforeEach(() => {
       fixture = makeFixture("tsc-ok", {