diff --git a/README.md b/README.md
index ff85912d..36d2aa4e 100644
--- a/README.md
+++ b/README.md
@@ -18,7 +18,7 @@ iloom
 
 #### Links to key sections
 
-[How It Works](#how-it-works-the-multi-agent-workflow) • [Installation](#quick-start) • [Configuration](#configuration) • [Advanced Features](#advanced-features) • [Swarm Mode](#swarm-mode-epic-orchestration) • [Telemetry](#telemetry) • [Limitations](#system-requirements--limitations) • [Contributing](#contributing-to-iloom)
+[How It Works](#how-it-works-the-multi-agent-workflow) • [Installation](#quick-start) • [Configuration](#configuration) • [Advanced Features](#advanced-features) • [Monorepo](#monorepo-support) • [Swarm Mode](#swarm-mode-epic-orchestration) • [Telemetry](#telemetry) • [Limitations](#system-requirements--limitations) • [Contributing](#contributing-to-iloom)
 
 ## How can your team trust the code your AI wrote, when you don't?
 
@@ -688,6 +688,34 @@ Then use `il dev-server`, `il open`, or `il run` as normal.
 
 Docker Compose multi-service stacks are not yet supported — see [#332](https://github.com/iloom-ai/iloom-cli/issues/332) for the roadmap. For full configuration options and known limitations, see the [Complete Command Reference](docs/iloom-commands.md#docker-dev-server-mode).
 
+### Monorepo Support
+
+iloom detects monorepo workspace configurations during `il init` and scopes commands to only the packages relevant to your current task.
+
+**Auto-detection:** iloom recognizes `pnpm-workspace.yaml` and `package.json` `workspaces` field, adding `"monorepo"` to your project capabilities automatically.
+
+**How it works:**
+
+1. **Package detection agent** runs before implementation (or after swarm completion in swarm mode) to determine which packages are affected by the current issue
+2. **Scoped validation** — `il test`, `il lint`, `il compile`, and `il build` run only against the declared packages, using the correct filter syntax for your package manager (pnpm `--filter`, yarn `workspace`, npm `--workspace`)
+3. **Scoped dev server** — `il dev-server` watches for the detection agent's decision and launches from the correct package subdirectory
+
+**Quick setup:**
+
+```bash
+# Auto-detected during init
+il init
+
+# Or add manually to .iloom/package.iloom.json
+{
+  "capabilities": ["monorepo", "web"]
+}
+```
+
+Non-monorepo projects are completely unaffected — all commands behave identically to before.
+
+**-> [Complete Monorepo Guide](docs/monorepo-guide.md)** — Full details on detection, package scoping, dev server behavior, and troubleshooting.
+
 ### Epic Planning and Decomposition
 
 The `il plan` command launches an interactive Architect session that helps you break down complex features into manageable child issues.
@@ -820,7 +848,9 @@ This is an early-stage product.
 
 *   ✅ **Node.js CLI Tools:** Full support with isolated binary generation.
 
-*   ✅ **Multi-Language Projects:** Python, Rust, Ruby, Go, and other languages via `.iloom/package.iloom.json`.    
+*   ✅ **Multi-Language Projects:** Python, Rust, Ruby, Go, and other languages via `.iloom/package.iloom.json`.
+
+*   ✅ **Monorepo Projects:** Automatic detection and scoped commands for pnpm, yarn, and npm workspaces. See [Monorepo Support](#monorepo-support) below.
 
 See all [known limitations](https://github.com/iloom-ai/iloom-cli/issues?q=is:issue+is:open+label:known-limitation) on GitHub. If you're feeling left out - you're absolutely right! The best way to complain about something is to fix it. So...
 
diff --git a/docs/iloom-commands.md b/docs/iloom-commands.md
index f8603228..f4408c75 100644
--- a/docs/iloom-commands.md
+++ b/docs/iloom-commands.md
@@ -800,8 +800,19 @@ il dev-server [identifier] [options]
 
 1. Resolves the target loom
 2. Loads environment variables from `.env` files
-3. Executes dev script from `package.json` or `.iloom/package.iloom.json`
-4. Runs in foreground (useful for debugging and manual testing)
+3. Detects project capabilities (web, monorepo, CLI)
+4. In monorepo mode: waits for `packagesToRun` to be set in loom metadata, then launches from the package subdirectory
+5. Executes dev script from `package.json` or `.iloom/package.iloom.json`
+6. Runs in foreground (useful for debugging and manual testing)
+
+**Monorepo Support:**
+
+When both `web` and `monorepo` capabilities are detected, `il dev-server` waits for the package detection agent to set `packagesToRun` in the loom metadata before launching. This ensures the dev server starts from the correct package subdirectory.
+
+- If `packagesToRun` is already set (detection agent ran before `il dev-server`), the server starts immediately.
+- If `packagesToRun` is empty, `il dev-server` watches the metadata file (with 15-second polling fallback) and launches once the agent populates it.
+- Only the first package in `packagesToRun` is used (multi-package dev servers are not supported in v1).
+- Times out after 60 seconds with an actionable error message if the agent never runs.
 
 **Examples:**
 
@@ -972,6 +983,10 @@ il build
 | Ruby | `bundle install` | `.iloom/package.iloom.json` |
 | Go | `go build ./...` | `.iloom/package.iloom.json` |
 
+**Monorepo Support:**
+
+When `packagesToValidate` is set in the loom metadata, `il build` scopes execution to those specific packages using the package manager's workspace filter flag (`--filter` for pnpm, `--workspace` for npm, `--include` for yarn). Packages that do not define a `build` script are gracefully skipped. When `packagesToValidate` is empty or not set, `il build` runs at the project root as normal.
+
 **Notes:**
 - Works with any language/framework via `.iloom/package.iloom.json`
 - Environment variables are automatically loaded before execution
@@ -1031,6 +1046,10 @@ il lint feat/my-feature
 | Ruby | `rubocop` | `.iloom/package.iloom.json` |
 | Go | `golangci-lint run` | `.iloom/package.iloom.json` |
 
+**Monorepo Support:**
+
+When `packagesToValidate` is set in the loom metadata, `il lint` scopes execution to those specific packages using the package manager's workspace filter flag (`--filter` for pnpm, `--workspace` for npm, `--include` for yarn). Packages that do not define a `lint` script are gracefully skipped. When `packagesToValidate` is empty or not set, `il lint` runs at the project root as normal.
+
 **Notes:**
 - Works with any linter via `.iloom/package.iloom.json`
 - Environment variables are automatically loaded before execution
@@ -1090,6 +1109,10 @@ il test feat/my-feature
 | Ruby | `bundle exec rspec` | `.iloom/package.iloom.json` |
 | Go | `go test ./...` | `.iloom/package.iloom.json` |
 
+**Monorepo Support:**
+
+When `packagesToValidate` is set in the loom metadata, `il test` scopes execution to those specific packages using the package manager's workspace filter flag (`--filter` for pnpm, `--workspace` for npm, `--include` for yarn). Packages that do not define a `test` script are gracefully skipped. When `packagesToValidate` is empty or not set, `il test` runs at the project root as normal.
+
 **Notes:**
 - Works with any test framework via `.iloom/package.iloom.json`
 - Environment variables are automatically loaded before execution
@@ -1156,6 +1179,10 @@ il typecheck feat/my-feature
 | Rust | `cargo check` | `.iloom/package.iloom.json` |
 | Go | `go build ./...` (no-op compile) | `.iloom/package.iloom.json` |
 
+**Monorepo Support:**
+
+When `packagesToValidate` is set in the loom metadata, `il compile` scopes execution to those specific packages using the package manager's workspace filter flag (`--filter` for pnpm, `--workspace` for npm, `--include` for yarn). Packages that do not define a `compile` or `typecheck` script are gracefully skipped. When `packagesToValidate` is empty or not set, `il compile` runs at the project root as normal.
+
 **Notes:**
 - Works with any compiler/type checker via `.iloom/package.iloom.json`
 - Useful for catching type errors without running full test suite
@@ -2162,10 +2189,49 @@ il init "configure neon database with project ID abc-123"
 - IDE preference (VS Code, Cursor, Windsurf, etc.)
 - Merge behavior (local, pr, draft-pr)
 - Permission modes
-- Project type (web app, CLI tool, etc.)
+- Project type (web app, CLI tool, monorepo, etc.)
 - Base port for development servers
 - Environment variable names
 
+**Project Capabilities:**
+
+iloom detects and persists project capabilities in `.iloom/package.iloom.json` under the `capabilities` field. Valid values are:
+
+| Capability | Description | Auto-detected from |
+|------------|-------------|-------------------|
+| `"web"` | Web application with a dev server | React, Next.js, Vite, and other web framework dependencies |
+| `"cli"` | Command-line tool with a `bin` entry | `bin` field in `package.json` |
+| `"monorepo"` | Monorepo with multiple workspace packages | `pnpm-workspace.yaml` file OR `workspaces` field in `package.json` |
+
+Capabilities can also be set manually in `.iloom/package.iloom.json`:
+```json
+{
+  "capabilities": ["monorepo"]
+}
+```
+
+The `monorepo` capability is auto-detected during `il init` when either of these workspace configuration files are present:
+- `pnpm-workspace.yaml` — used by pnpm workspaces
+- `workspaces` field in `package.json` — used by yarn and npm workspaces
+
+**Monorepo Package Detection:**
+
+When the `"monorepo"` capability is set, iloom integrates a dedicated `iloom-monorepo-package-detector` agent into the workflow to determine which packages to run and validate.
+
+*How it works:*
+- The detection agent explores the workspace structure, reads the issue context, and calls MCP tools to set `packagesToRun` and `packagesToValidate` on the loom metadata
+- In **non-swarm mode**: the detection agent runs before the implementation agent begins
+- In **swarm mode**: the detection agent runs after the swarm completes (called by the orchestrator), not by individual child agents
+
+*Package metadata reminder:*
+When the `"monorepo"` capability is set, a UserPromptSubmit hook injects a reminder into each agent session: if the agent touches packages not already listed in `packagesToValidate`, it should call `mcp__recap__set_packages_to_validate` to update the list.
+
+*MCP tools used:*
+- `set_package_to_run` — declare which package to run (dev server, etc.)
+- `set_packages_to_validate` — declare which packages need test/lint/build validation
+
+When the project does not have the `"monorepo"` capability, no detection agent runs and no monorepo instructions appear in prompts.
+
 **Jira Advanced Settings:**
 
 The following Jira settings can be configured in `.iloom/settings.json` under `issueManagement.jira`:
diff --git a/docs/monorepo-guide.md b/docs/monorepo-guide.md
new file mode 100644
index 00000000..465995e5
--- /dev/null
+++ b/docs/monorepo-guide.md
@@ -0,0 +1,142 @@
+# Monorepo Support in iloom
+
+This guide explains how iloom detects and works with monorepo projects, how package detection works, and how validation and dev server commands are scoped to specific packages.
+
+## What is Monorepo Support?
+
+Monorepo support means iloom is aware that your repository contains multiple packages in subdirectories and can scope its commands — validation, testing, linting, and the dev server — to only the packages relevant to a given loom's changes. This keeps CI-style commands fast and avoids running tests for packages that were not touched.
+
+## How Monorepo Detection Works
+
+iloom detects the `monorepo` capability automatically during `il init` by looking for workspace configuration files in the repository root:
+
+- **`pnpm-workspace.yaml`** — used by pnpm workspaces
+- **`workspaces` field in `package.json`** — used by yarn and npm workspaces
+
+When either is present, iloom adds `"monorepo"` to the `capabilities` array in `.iloom/package.iloom.json`:
+
+```json
+{
+  "capabilities": ["monorepo", "web"]
+}
+```
+
+You can also add `"monorepo"` manually to `.iloom/package.iloom.json` if auto-detection does not apply to your project layout.
+
+## The Package Detection Agent
+
+When the `monorepo` capability is set, iloom integrates a dedicated `iloom-monorepo-package-detector` agent into the workflow.
+
+**What it does:**
+
+1. The agent explores the loom's workspace, examines the issue context, and determines which packages were touched or need to run.
+2. It calls MCP tools to write two arrays to the loom metadata file (`~/.config/iloom-ai/looms/<slug>.json`):
+   - `packagesToRun` — packages whose dev server should be started (relative paths from repo root, e.g., `./apps/web`)
+   - `packagesToValidate` — packages that `il test`, `il lint`, `il compile`, and `il build` should be scoped to (relative paths from repo root, e.g., `./packages/api`, `./apps/web`)
+
+**When it runs:**
+
+- **Non-swarm mode**: the detection agent runs before the implementation agent begins.
+- **Swarm mode**: the detection agent runs after the swarm completes, called by the orchestrator. Individual child agents do not invoke it directly.
+
+**UserPromptSubmit hook reminder:**
+
+When `monorepo` capability is set, a `UserPromptSubmit` hook injects a reminder into each agent session: if the agent touches packages not already listed in `packagesToValidate`, it should call `mcp__recap__set_packages_to_validate` to update the list.
+
+## How `packagesToRun` and `packagesToValidate` Work
+
+Both fields are arrays of relative paths from the repository root. They live in the loom metadata file at `~/.config/iloom-ai/looms/<slug>.json`.
+
+| Field | Used by | Purpose |
+|-------|---------|---------|
+| `packagesToRun` | `il dev-server` | Which package's dev server to start |
+| `packagesToValidate` | `il test`, `il lint`, `il compile`, `il build` | Which packages to scope validation to |
+
+These fields are set by the package detection agent. They can also be set manually via MCP tools (`mcp__recap__set_package_to_run`, `mcp__recap__set_packages_to_validate`) if you need to override the agent's decision.
+
+When a field is empty or not set, the corresponding command runs at the project root, covering the entire repository — the same behavior as for non-monorepo looms.
+
+## How Commands Are Scoped
+
+When `packagesToValidate` contains one or more packages, `il test`, `il lint`, `il compile`, and `il build` pass those packages to the package manager's workspace filter mechanism:
+
+| Package Manager | Filter syntax |
+|-----------------|--------------|
+| **pnpm** | `pnpm --filter ./pkg1 --filter ./pkg2 run <script> --if-present` |
+| **npm** | `npm run <script> --workspace=./pkg1 --workspace=./pkg2 --if-present` |
+| **yarn (berry)** | `yarn workspaces foreach --include ./pkg1 --include ./pkg2 run <script>` |
+
+Packages that do not define the target script are gracefully skipped (`--if-present` / `--if-present` equivalent).
+
+When `packagesToValidate` is empty (no packages detected, or a non-monorepo loom), the commands run at the project root without any filter, giving you normal full-repo behavior.
+
+## Dev Server Metadata Watching
+
+When both `web` and `monorepo` capabilities are detected, `il dev-server` needs to know which package's dev server to launch. It reads `packagesToRun` from the loom metadata:
+
+1. If `packagesToRun` is already set when `il dev-server` starts, the server launches immediately from that package's subdirectory.
+2. If `packagesToRun` is empty, `il dev-server` watches the metadata file (with a 15-second polling fallback) and launches once the package detection agent populates the field.
+3. Only the first package in `packagesToRun` is used — multi-package dev servers are not supported in v1.
+4. `il dev-server` times out after 60 seconds with an actionable error if the agent never runs.
+
+For non-monorepo looms (or when only the `web` capability is set), `il dev-server` starts from the workspace root immediately, unchanged from pre-monorepo behavior.
+
+## Non-Monorepo Projects Are Unaffected
+
+Projects without the `monorepo` capability behave identically to before. The `packagesToValidate` and `packagesToRun` fields default to empty arrays, and all commands run at the project root without any workspace filters.
+
+## Example: Full Loom Lifecycle for a Monorepo
+
+```
+1. il start 123
+   └── il init previously detected monorepo capability via pnpm-workspace.yaml
+
+2. Package detection agent runs (before implementation agent in non-swarm mode)
+   └── Sets packagesToRun: ["./apps/web"]
+   └── Sets packagesToValidate: ["./apps/web", "./packages/ui"]
+
+3. Implementation agent works on the issue
+
+4. il test
+   └── Reads packagesToValidate from loom metadata
+   └── Runs: pnpm --filter ./apps/web --filter ./packages/ui run test --if-present
+
+5. il lint
+   └── Runs: pnpm --filter ./apps/web --filter ./packages/ui run lint --if-present
+
+6. il compile
+   └── Runs: pnpm --filter ./apps/web --filter ./packages/ui run compile --if-present
+
+7. il dev-server
+   └── Reads packagesToRun from loom metadata
+   └── Starts dev server in ./apps/web/
+
+8. il finish 123
+```
+
+## Manual Override
+
+If the detection agent sets the wrong packages, you can override them before running validation:
+
+```bash
+# Via the MCP tool (in an agent session)
+mcp__recap__set_packages_to_validate(["./apps/web", "./packages/shared"])
+
+# Or by editing the metadata file directly
+# ~/.config/iloom-ai/looms/<slug>.json
+```
+
+## Troubleshooting
+
+**Detection agent never ran / metadata is empty:**
+- Confirm `"monorepo"` is in `.iloom/package.iloom.json` `capabilities`
+- In swarm mode, confirm the orchestrator called the detection agent after swarm completion
+- In non-swarm mode, confirm the pre-agent hook is configured
+
+**Dev server times out waiting for `packagesToRun`:**
+- Check whether the detection agent completed without error
+- As a workaround, set `packagesToRun` manually via `mcp__recap__set_package_to_run`
+
+**Commands run against the entire monorepo instead of scoped packages:**
+- `packagesToValidate` is empty — either the detection agent has not run yet, or no packages were detected
+- You can set packages manually or re-run the detection agent
diff --git a/src/commands/build.test.ts b/src/commands/build.test.ts
index 3f5434ac..fa592a07 100644
--- a/src/commands/build.test.ts
+++ b/src/commands/build.test.ts
@@ -1,6 +1,7 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest'
 import { BuildCommand } from './build.js'
 import { GitWorktreeManager } from '../lib/GitWorktreeManager.js'
+import { MetadataManager } from '../lib/MetadataManager.js'
 import type { GitWorktree } from '../types/worktree.js'
 import * as packageJson from '../utils/package-json.js'
 import * as packageManager from '../utils/package-manager.js'
@@ -12,6 +13,7 @@ vi.mock('../utils/IdentifierParser.js', () => ({
 		parseForPatternDetection: vi.fn(),
 	})),
 }))
+vi.mock('../lib/MetadataManager.js')
 
 // Mock package utilities
 vi.mock('../utils/package-json.js', () => ({
@@ -47,6 +49,10 @@ describe('BuildCommand', () => {
 	beforeEach(() => {
 		mockGitWorktreeManager = new GitWorktreeManager()
 		command = new BuildCommand(mockGitWorktreeManager)
+		// Set up MetadataManager mock to return no packagesToValidate by default
+		vi.mocked(MetadataManager).mockImplementation(() => ({
+			readMetadata: vi.fn().mockResolvedValue(null),
+		} as unknown as MetadataManager))
 	})
 
 	describe('identifier parsing', () => {
@@ -138,7 +144,7 @@ describe('BuildCommand', () => {
 
 			await command.execute({})
 
-			expect(packageManager.runScript).toHaveBeenCalledWith('build', mockWorktree.path, [])
+			expect(packageManager.runScript).toHaveBeenCalledWith('build', mockWorktree.path, [], { packages: [] })
 		})
 
 		it('should pass worktree path to runScript()', async () => {
@@ -152,7 +158,8 @@ describe('BuildCommand', () => {
 			expect(packageManager.runScript).toHaveBeenCalledWith(
 				'build',
 				mockWorktree.path,
-				[]
+				[],
+				{ packages: [] }
 			)
 		})
 	})
diff --git a/src/commands/compile.test.ts b/src/commands/compile.test.ts
index 6c3b106d..c9c4291c 100644
--- a/src/commands/compile.test.ts
+++ b/src/commands/compile.test.ts
@@ -1,6 +1,7 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest'
 import { CompileCommand } from './compile.js'
 import { GitWorktreeManager } from '../lib/GitWorktreeManager.js'
+import { MetadataManager } from '../lib/MetadataManager.js'
 import type { GitWorktree } from '../types/worktree.js'
 import * as packageJson from '../utils/package-json.js'
 import * as packageManager from '../utils/package-manager.js'
@@ -12,6 +13,7 @@ vi.mock('../utils/IdentifierParser.js', () => ({
 		parseForPatternDetection: vi.fn(),
 	})),
 }))
+vi.mock('../lib/MetadataManager.js')
 
 // Mock package utilities
 vi.mock('../utils/package-json.js', () => ({
@@ -47,6 +49,10 @@ describe('CompileCommand', () => {
 	beforeEach(() => {
 		mockGitWorktreeManager = new GitWorktreeManager()
 		command = new CompileCommand(mockGitWorktreeManager)
+		// Set up MetadataManager mock to return no packagesToValidate by default
+		vi.mocked(MetadataManager).mockImplementation(() => ({
+			readMetadata: vi.fn().mockResolvedValue(null),
+		} as unknown as MetadataManager))
 	})
 
 	describe('identifier parsing', () => {
@@ -116,7 +122,7 @@ describe('CompileCommand', () => {
 
 			await command.execute({})
 
-			expect(packageManager.runScript).toHaveBeenCalledWith('compile', mockWorktree.path, [])
+			expect(packageManager.runScript).toHaveBeenCalledWith('compile', mockWorktree.path, [], { packages: [] })
 		})
 
 		it('should fallback to typecheck if compile does not exist', async () => {
@@ -127,7 +133,7 @@ describe('CompileCommand', () => {
 
 			await command.execute({})
 
-			expect(packageManager.runScript).toHaveBeenCalledWith('typecheck', mockWorktree.path, [])
+			expect(packageManager.runScript).toHaveBeenCalledWith('typecheck', mockWorktree.path, [], { packages: [] })
 		})
 
 		it('should skip silently if neither compile nor typecheck exist', async () => {
@@ -152,7 +158,7 @@ describe('CompileCommand', () => {
 
 			await command.execute({})
 
-			expect(packageManager.runScript).toHaveBeenCalledWith('compile', mockWorktree.path, [])
+			expect(packageManager.runScript).toHaveBeenCalledWith('compile', mockWorktree.path, [], { packages: [] })
 			expect(packageManager.runScript).toHaveBeenCalledTimes(1)
 		})
 	})
diff --git a/src/commands/compile.ts b/src/commands/compile.ts
index a2a29de4..4459d6c6 100644
--- a/src/commands/compile.ts
+++ b/src/commands/compile.ts
@@ -56,10 +56,17 @@ export class CompileCommand extends ScriptCommandBase {
 			return
 		}
 
-		// 5. Run the found script
+		// 5. Read packagesToValidate from loom metadata for monorepo scoping
+		const packages = await this.readPackagesToValidate(worktree.path)
+
+		if (packages.length > 0) {
+			logger.info(`Scoping Compile/Typecheck to packages: ${packages.join(', ')}`)
+		}
+
+		// 6. Run the found script
 		const displayName = scriptToRun === 'compile' ? 'Compile' : 'Typecheck'
 		logger.info(`Running ${displayName}...`)
-		await runScript(scriptToRun, worktree.path, [])
+		await runScript(scriptToRun, worktree.path, [], { packages })
 		logger.success(`${displayName} completed successfully`)
 	}
 }
diff --git a/src/commands/dev-server.test.ts b/src/commands/dev-server.test.ts
index ba3a800a..394aaa1d 100644
--- a/src/commands/dev-server.test.ts
+++ b/src/commands/dev-server.test.ts
@@ -11,6 +11,7 @@ import { loadWorkspaceEnv, isNoEnvFilesFoundError } from '../utils/env.js'
 import type { GitWorktree } from '../types/worktree.js'
 import type { ProjectCapabilities } from '../types/loom.js'
 import fs from 'fs-extra'
+import nodeFsModule from 'node:fs'
 
 // Mock dependencies
 vi.mock('../lib/GitWorktreeManager.js')
@@ -21,6 +22,7 @@ vi.mock('../lib/DockerManager.js')
 vi.mock('../utils/IdentifierParser.js')
 vi.mock('fs-extra')
 vi.mock('../lib/SettingsManager.js')
+vi.mock('node:fs')
 vi.mock('../utils/env.js', async (importOriginal) => {
 	const actual = await importOriginal<typeof import('../utils/env.js')>()
 	return {
@@ -683,6 +685,153 @@ describe('DevServerCommand', () => {
 		})
 	})
 
+	describe('monorepo mode', () => {
+		beforeEach(() => {
+			vi.mocked(mockIdentifierParser.parseForPatternDetection).mockResolvedValue({
+				type: 'issue',
+				number: 87,
+				originalInput: '87',
+			})
+
+			vi.mocked(mockGitWorktreeManager.findWorktreeForIssue).mockResolvedValue(mockWorktree)
+
+			vi.mocked(fs.pathExists).mockResolvedValue(true)
+			vi.mocked(fs.readFile).mockResolvedValue('PORT=3087\n')
+		})
+
+		it('should launch dev server from package subdirectory when packagesToRun is already set', async () => {
+			const mockCapabilities: ProjectCapabilities = {
+				capabilities: ['web', 'monorepo'],
+				binEntries: {},
+			}
+			vi.mocked(mockCapabilityDetector.detectCapabilities).mockResolvedValue(mockCapabilities)
+			vi.mocked(mockMetadataManager.readMetadata).mockResolvedValue({
+				colorHex: null,
+				packagesToRun: ['apps/web'],
+				packagesToValidate: [],
+			})
+			vi.mocked(mockMetadataManager.getMetadataFilePath).mockReturnValue(
+				'/home/.config/iloom-ai/looms/test-worktree.json'
+			)
+
+			const result = await command.execute({ identifier: '87' })
+
+			expect(result.status).toBe('started')
+			expect(mockDevServerManager.runServerForeground).toHaveBeenCalledWith(
+				`${mockWorktree.path}/apps/web`,
+				3087,
+				false,
+				expect.any(Function),
+				expect.any(Object),
+				undefined,
+				undefined
+			)
+		})
+
+		it('should wait for packagesToRun when monorepo+web but packagesToRun is empty, then launch from package dir', async () => {
+			const mockCapabilities: ProjectCapabilities = {
+				capabilities: ['web', 'monorepo'],
+				binEntries: {},
+			}
+			vi.mocked(mockCapabilityDetector.detectCapabilities).mockResolvedValue(mockCapabilities)
+			vi.mocked(mockMetadataManager.getMetadataFilePath).mockReturnValue(
+				'/home/.config/iloom-ai/looms/test-worktree.json'
+			)
+
+			// First readMetadata call (in execute for color): return empty packagesToRun
+			// Second readMetadata call (in waitForPackagesToRun): return populated
+			vi.mocked(mockMetadataManager.readMetadata)
+				.mockResolvedValueOnce({ colorHex: null, packagesToRun: [], packagesToValidate: [] })
+				.mockResolvedValueOnce({ colorHex: null, packagesToRun: [], packagesToValidate: [] })
+				.mockResolvedValueOnce({ colorHex: null, packagesToRun: ['packages/frontend'], packagesToValidate: [] })
+
+			// Mock fs.watch to call the callback immediately with a file change event
+			const mockWatcher = {
+				close: vi.fn(),
+			}
+			vi.mocked(nodeFsModule.watch).mockImplementation((_dir, _opts, callback) => {
+				// Simulate a file change event asynchronously
+				if (typeof callback === 'function') {
+					globalThis.setTimeout(() => {
+						callback('change', 'test-worktree.json')
+					}, 10)
+				}
+				return mockWatcher as unknown as nodeFsModule.FSWatcher
+			})
+
+			const result = await command.execute({ identifier: '87' })
+
+			expect(result.status).toBe('started')
+			expect(mockDevServerManager.runServerForeground).toHaveBeenCalledWith(
+				`${mockWorktree.path}/packages/frontend`,
+				3087,
+				false,
+				expect.any(Function),
+				expect.any(Object),
+				undefined,
+				undefined
+			)
+		})
+
+		it('should behave normally when only web capability (no monorepo)', async () => {
+			const mockCapabilities: ProjectCapabilities = {
+				capabilities: ['web'],
+				binEntries: {},
+			}
+			vi.mocked(mockCapabilityDetector.detectCapabilities).mockResolvedValue(mockCapabilities)
+			vi.mocked(mockMetadataManager.readMetadata).mockResolvedValue({
+				colorHex: null,
+				packagesToRun: [],
+				packagesToValidate: [],
+			})
+
+			const result = await command.execute({ identifier: '87' })
+
+			expect(result.status).toBe('started')
+			// Should use original worktree.path, not a subdirectory
+			expect(mockDevServerManager.runServerForeground).toHaveBeenCalledWith(
+				mockWorktree.path,
+				3087,
+				false,
+				expect.any(Function),
+				expect.any(Object),
+				undefined,
+				undefined
+			)
+		})
+
+		it('should clean up file watcher when packagesToRun is resolved', async () => {
+			const mockCapabilities: ProjectCapabilities = {
+				capabilities: ['web', 'monorepo'],
+				binEntries: {},
+			}
+			vi.mocked(mockCapabilityDetector.detectCapabilities).mockResolvedValue(mockCapabilities)
+			vi.mocked(mockMetadataManager.getMetadataFilePath).mockReturnValue(
+				'/home/.config/iloom-ai/looms/test-worktree.json'
+			)
+
+			vi.mocked(mockMetadataManager.readMetadata)
+				.mockResolvedValueOnce({ colorHex: null, packagesToRun: [], packagesToValidate: [] })
+				.mockResolvedValueOnce({ colorHex: null, packagesToRun: [], packagesToValidate: [] })
+				.mockResolvedValueOnce({ colorHex: null, packagesToRun: ['apps/web'], packagesToValidate: [] })
+
+			const mockWatcher = { close: vi.fn() }
+			vi.mocked(nodeFsModule.watch).mockImplementation((_dir, _opts, callback) => {
+				if (typeof callback === 'function') {
+					globalThis.setTimeout(() => {
+						callback('change', 'test-worktree.json')
+					}, 10)
+				}
+				return mockWatcher as unknown as nodeFsModule.FSWatcher
+			})
+
+			await command.execute({ identifier: '87' })
+
+			// Watcher should have been closed after resolving
+			expect(mockWatcher.close).toHaveBeenCalled()
+		})
+	})
+
 	describe('Docker mode', () => {
 		beforeEach(() => {
 			vi.mocked(mockIdentifierParser.parseForPatternDetection).mockResolvedValue({
diff --git a/src/commands/dev-server.ts b/src/commands/dev-server.ts
index eac8328f..086f6c61 100644
--- a/src/commands/dev-server.ts
+++ b/src/commands/dev-server.ts
@@ -1,5 +1,7 @@
 import path from 'path'
+import fs from 'node:fs'
 import { GitWorktreeManager } from '../lib/GitWorktreeManager.js'
+import { TelemetryService } from '../lib/TelemetryService.js'
 import { MetadataManager } from '../lib/MetadataManager.js'
 import { ProjectCapabilityDetector } from '../lib/ProjectCapabilityDetector.js'
 import { DevServerManager } from '../lib/DevServerManager.js'
@@ -121,7 +123,34 @@ export class DevServerCommand {
 
 		logger.debug(`Detected capabilities: ${capabilities.join(', ')}`)
 
-		// 4. If no web capability, return gracefully with info message
+		// 4a. Monorepo mode: wait for packagesToRun to be populated before launching
+		const isMonorepo = capabilities.includes('web') && capabilities.includes('monorepo')
+		let serverPath = worktree.path
+		if (isMonorepo) {
+			// Re-read metadata to get the latest packagesToRun
+			const latestMetadata = await this.metadataManager.readMetadata(worktree.path)
+			let packagesToRun = latestMetadata?.packagesToRun ?? []
+
+			if (packagesToRun.length === 0) {
+				logger.info('Monorepo detected. Waiting for package detection agent to identify which package to run...')
+				const metadataFilePath = this.metadataManager.getMetadataFilePath(worktree.path)
+				packagesToRun = await this.waitForPackagesToRun(metadataFilePath, worktree.path)
+			}
+
+			const firstPackage = packagesToRun[0]
+			if (!firstPackage) {
+				throw new Error('packagesToRun is empty after waiting for detection')
+			}
+			if (firstPackage.includes('..') || path.isAbsolute(firstPackage)) {
+				throw new Error(
+					`Invalid package path in metadata: "${firstPackage}" must be a relative path within the workspace`
+				)
+			}
+			serverPath = path.join(worktree.path, firstPackage)
+			logger.info(`Launching dev server from monorepo package: ${serverPath}`)
+		}
+
+		// 5. If no web capability, return gracefully with info message
 		if (!capabilities.includes('web')) {
 			const message = 'No web capability detected in this workspace. Dev server not started.'
 			if (input.json) {
@@ -216,7 +245,7 @@ export class DevServerCommand {
 			// This will block until user stops the server (Ctrl+C)
 			// In JSON mode, redirect npm output to stderr so JSON can go to stdout
 			const processInfo = await this.devServerManager.runServerForeground(
-				worktree.path,
+				serverPath,
 				port,
 				!!input.json,
 				// Callback called immediately when process starts (for JSON output)
@@ -234,6 +263,18 @@ export class DevServerCommand {
 			if (processInfo.pid) {
 				finalResult.pid = processInfo.pid
 			}
+
+			// Fire-and-forget telemetry: track dev server started
+			try {
+				TelemetryService.getInstance().track('devServer.started', {
+					mode: dockerConfig ? 'docker' : 'process',
+					success: true,
+					startDurationMs: 0,
+					is_monorepo: isMonorepo,
+				})
+			} catch (err) {
+				logger.debug(`Telemetry error: ${String(err)}`)
+			}
 		} finally {
 			if (tui) {
 				tui.cleanup()
@@ -387,4 +428,122 @@ export class DevServerCommand {
 	private formatLoomIdentifier(parsed: ParsedDevServerInput): string {
 		return parsed.originalInput
 	}
+
+	/**
+	 * Watch the metadata file until packagesToRun is populated.
+	 * Uses fs.watch with a polling fallback (15s interval).
+	 * Resolves with the packagesToRun array, or rejects on SIGINT or timeout.
+	 *
+	 * Maximum wait time is 60 seconds before giving up with an actionable error.
+	 */
+	private waitForPackagesToRun(metadataFilePath: string, worktreePath: string): Promise<string[]> {
+		const MAX_WAIT_MS = 60_000
+		const POLL_INTERVAL_MS = 15_000
+
+		return new Promise((resolve, reject) => {
+			let isChecking = false
+			let watcher: fs.FSWatcher | undefined
+			let pollTimer: NodeJS.Timeout | undefined
+			let timeoutTimer: NodeJS.Timeout | undefined
+			let done = false
+			const expectedFilename = path.basename(metadataFilePath)
+
+			const cleanup = (): void => {
+				done = true
+				if (watcher) {
+					try { watcher.close() } catch { /* ignore */ }
+				}
+				if (pollTimer) {
+					globalThis.clearInterval(pollTimer)
+				}
+				if (timeoutTimer) {
+					globalThis.clearTimeout(timeoutTimer)
+				}
+			}
+
+			const checkMetadata = async (): Promise<boolean> => {
+				if (done || isChecking) return false
+				isChecking = true
+				try {
+					const metadata = await this.metadataManager.readMetadata(worktreePath)
+					if (metadata?.packagesToRun && metadata.packagesToRun.length > 0) {
+						resolve(metadata.packagesToRun)
+						return true
+					}
+				} catch (error: unknown) {
+					// Only suppress errors expected during normal operation:
+					// - ENOENT: metadata file doesn't exist yet
+					// - SyntaxError: file is being written (transient parse failure)
+					const isEnoent =
+						error instanceof Error &&
+						'code' in error &&
+						(error as NodeJS.ErrnoException).code === 'ENOENT'
+					const isSyntaxError = error instanceof SyntaxError
+					if (!isEnoent && !isSyntaxError) {
+						cleanup()
+						process.removeListener('SIGINT', onSignal)
+						reject(error)
+						return false
+					}
+				} finally {
+					isChecking = false
+				}
+				return false
+			}
+
+			const onSignal = (): void => {
+				cleanup()
+				reject(new Error('Dev server watch aborted due to SIGINT'))
+			}
+
+			process.once('SIGINT', onSignal)
+
+			const handleChange = async (): Promise<void> => {
+				if (done) return
+				const resolved = await checkMetadata()
+				if (resolved) {
+					cleanup()
+					process.removeListener('SIGINT', onSignal)
+				}
+			}
+
+			// Maximum wait timeout
+			timeoutTimer = globalThis.setTimeout(() => {
+				cleanup()
+				process.removeListener('SIGINT', onSignal)
+				reject(new Error(
+					`Timed out waiting for package detection agent to identify which package to run after ${MAX_WAIT_MS / 1000}s. ` +
+					`Ensure the detection agent ran and set packagesToRun in the loom metadata.`
+				))
+			}, MAX_WAIT_MS)
+
+			// Attempt to use fs.watch first
+			try {
+				// Watch the metadata file directory for changes
+				const dir = path.dirname(metadataFilePath)
+				watcher = fs.watch(dir, { persistent: false }, (_eventType, filename) => {
+					if (filename === expectedFilename) {
+						void handleChange()
+					}
+				})
+				logger.debug(`Watching metadata directory for changes: ${dir}`)
+			} catch (err) {
+				logger.debug(`fs.watch unavailable, falling back to polling: ${String(err)}`)
+				watcher = undefined
+			}
+
+			// Always set up polling as a fallback / safety net
+			pollTimer = globalThis.setInterval(() => {
+				void handleChange()
+			}, POLL_INTERVAL_MS)
+
+			// Check immediately in case packagesToRun is already set
+			void checkMetadata().then((resolved) => {
+				if (resolved) {
+					cleanup()
+					process.removeListener('SIGINT', onSignal)
+				}
+			})
+		})
+	}
 }
diff --git a/src/commands/finish.ts b/src/commands/finish.ts
index 320a945b..2fcaf78d 100644
--- a/src/commands/finish.ts
+++ b/src/commands/finish.ts
@@ -260,12 +260,16 @@ export class FinishCommand {
 
 		// Read metadata BEFORE workflow execution (cleanup may delete the worktree)
 		let preFinishCreatedAt: string | undefined
+		let preFinishPackagesToValidate: string[] = []
 		try {
 			const metadataManager = new MetadataManager()
 			const metadata = await metadataManager.readMetadata(worktree.path)
 			preFinishCreatedAt = metadata?.created_at ?? undefined
+			preFinishPackagesToValidate = metadata?.packagesToValidate ?? []
 		} catch (error: unknown) {
-			getLogger().debug(`Failed to read metadata for telemetry: ${error instanceof Error ? error.message : String(error)}`)
+			// Non-fatal: metadata is used for telemetry and validation scoping.
+			// If unreadable, validation will run un-scoped (full project).
+			getLogger().debug(`Failed to read metadata: ${error instanceof Error ? error.message : String(error)}`)
 		}
 
 		// Step 4: Branch based on input type
@@ -279,10 +283,10 @@ export class FinishCommand {
 				throw new Error('Issue tracker does not support pull requests')
 			}
 			const pr = await this.issueTracker.fetchPR(parsed.number, repo)
-			await this.executePRWorkflow(parsed, input.options, worktree, pr, result)
+			await this.executePRWorkflow(parsed, input.options, worktree, pr, result, preFinishPackagesToValidate)
 		} else {
 			// Execute traditional issue/branch workflow
-			await this.executeIssueWorkflow(parsed, input.options, worktree, result)
+			await this.executeIssueWorkflow(parsed, input.options, worktree, result, preFinishPackagesToValidate)
 		}
 
 		// Mark overall success if we got here without throwing
@@ -657,7 +661,8 @@ export class FinishCommand {
 		parsed: ParsedFinishInput,
 		options: FinishOptions,
 		worktree: GitWorktree,
-		result: FinishResult
+		result: FinishResult,
+		packagesToValidate: string[] = []
 	): Promise<void> {
 		// Define merge options early so they're available for all code paths
 		const mergeOptions: MergeOptions = {
@@ -705,6 +710,7 @@ export class FinishCommand {
 				await this.validationRunner.runValidations(worktree.path, {
 					dryRun: options.dryRun ?? false,
 					jsonStream: options.jsonStream ?? false,
+					packagesToValidate,
 				})
 				getLogger().success('All validations passed')
 				result.operations.push({
@@ -985,7 +991,8 @@ export class FinishCommand {
 		options: FinishOptions,
 		worktree: GitWorktree,
 		pr: PullRequest,
-		result: FinishResult
+		result: FinishResult,
+		_packagesToValidate: string[] = []
 	): Promise<void> {
 		// Branch based on PR state
 		if (pr.state === 'closed' || pr.state === 'merged') {
diff --git a/src/commands/ignite.test.ts b/src/commands/ignite.test.ts
index 485f4acf..0ed25d2a 100644
--- a/src/commands/ignite.test.ts
+++ b/src/commands/ignite.test.ts
@@ -1555,7 +1555,7 @@ describe('IgniteCommand', () => {
 				expect(mockAgentManager.loadAndPrepare).toHaveBeenCalledWith(
 					expect.anything(), // settings
 					expect.anything(), // template variables
-					['*.md', '!iloom-framework-detector.md'],
+					['*.md', '!iloom-framework-detector.md', '!iloom-monorepo-package-detector.md'],
 					'/path/to/feat/issue-123__test/.claude/agents',
 				)
 
@@ -1724,7 +1724,7 @@ describe('IgniteCommand', () => {
 						ISSUE_NUMBER: '123',
 						WORKSPACE_PATH: '/path/to/feat/issue-123__test',
 					}),
-					['*.md', '!iloom-framework-detector.md'],
+					['*.md', '!iloom-framework-detector.md', '!iloom-monorepo-package-detector.md'],
 					'/path/to/feat/issue-123__test/.claude/agents'
 				)
 			} finally {
@@ -1779,7 +1779,7 @@ describe('IgniteCommand', () => {
 						ISSUE_NUMBER: '123',
 						WORKSPACE_PATH: '/path/to/feat/issue-123__test',
 					}),
-					['*.md', '!iloom-framework-detector.md'],
+					['*.md', '!iloom-framework-detector.md', '!iloom-monorepo-package-detector.md'],
 					'/path/to/feat/issue-123__test/.claude/agents'
 				)
 				expect(launchClaudeSpy).toHaveBeenCalled()
diff --git a/src/commands/ignite.ts b/src/commands/ignite.ts
index a48933c5..ddcbd276 100644
--- a/src/commands/ignite.ts
+++ b/src/commands/ignite.ts
@@ -301,6 +301,11 @@ export class IgniteCommand {
 			// Step 2.2: Get prompt template with variable substitution
 			const variables = this.buildTemplateVariables(context, effectiveOneShot, draftPrNumber, draftPrUrl, effectiveComplexity)
 
+			// Set IS_MONOREPO from metadata capabilities
+			if (metadata?.capabilities?.includes('monorepo')) {
+				variables.IS_MONOREPO = true
+			}
+
 			// Step 2.5: Add first-time user context if needed
 			if (isFirstRun) {
 				variables.FIRST_TIME_USER = true
@@ -467,10 +472,11 @@ export class IgniteCommand {
 				}
 
 				// Exclude init-only agents (e.g., framework-detector which is only for il init)
+				// and detection agents that are invoked explicitly rather than auto-loaded
 				agents = await this.agentManager.loadAndPrepare(
 					this.settings,
 					variables,
-					['*.md', '!iloom-framework-detector.md'],
+					['*.md', '!iloom-framework-detector.md', '!iloom-monorepo-package-detector.md'],
 					path.join(context.workspacePath, '.claude', 'agents')
 				)
 			} catch (error) {
@@ -1078,6 +1084,7 @@ export class IgniteCommand {
 			ISSUE_PREFIX: issuePrefix,
 			...(skipCleanup && { NO_CLEANUP: true }),
 			...(postSwarmReview && { POST_SWARM_REVIEW: true }),
+			...(metadata.capabilities?.includes('monorepo') && { IS_MONOREPO: true }),
 		}
 
 		// Set draft PR mode flags for swarm orchestrator (same logic as buildTemplateVariables)
@@ -1116,6 +1123,8 @@ export class IgniteCommand {
 			'mcp__recap__set_complexity',
 			'mcp__recap__set_loom_state',
 			'mcp__recap__get_loom_state',
+			'mcp__recap__set_package_to_run',
+			'mcp__recap__set_packages_to_validate',
 		]
 
 		// Launch Claude with agent teams enabled
@@ -1133,7 +1142,7 @@ export class IgniteCommand {
 			agents = await this.agentManager.loadAndPrepare(
 				settings,
 				variables,
-				['*.md', '!iloom-framework-detector.md'],
+				['*.md', '!iloom-framework-detector.md', '!iloom-monorepo-package-detector.md'],
 				path.join(epicWorktreePath, '.claude', 'agents')
 			)
 		} catch (error) {
diff --git a/src/commands/lint.test.ts b/src/commands/lint.test.ts
index 0dbba24b..2b8ca1dc 100644
--- a/src/commands/lint.test.ts
+++ b/src/commands/lint.test.ts
@@ -1,6 +1,7 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest'
 import { LintCommand } from './lint.js'
 import { GitWorktreeManager } from '../lib/GitWorktreeManager.js'
+import { MetadataManager } from '../lib/MetadataManager.js'
 import type { GitWorktree } from '../types/worktree.js'
 import * as packageJson from '../utils/package-json.js'
 import * as packageManager from '../utils/package-manager.js'
@@ -12,6 +13,7 @@ vi.mock('../utils/IdentifierParser.js', () => ({
 		parseForPatternDetection: vi.fn(),
 	})),
 }))
+vi.mock('../lib/MetadataManager.js')
 
 // Mock package utilities
 vi.mock('../utils/package-json.js', () => ({
@@ -47,6 +49,10 @@ describe('LintCommand', () => {
 	beforeEach(() => {
 		mockGitWorktreeManager = new GitWorktreeManager()
 		command = new LintCommand(mockGitWorktreeManager)
+		// Set up MetadataManager mock to return no packagesToValidate by default
+		vi.mocked(MetadataManager).mockImplementation(() => ({
+			readMetadata: vi.fn().mockResolvedValue(null),
+		} as unknown as MetadataManager))
 	})
 
 	describe('identifier parsing', () => {
@@ -115,7 +121,7 @@ describe('LintCommand', () => {
 
 			await command.execute({})
 
-			expect(packageManager.runScript).toHaveBeenCalledWith('lint', mockWorktree.path, [])
+			expect(packageManager.runScript).toHaveBeenCalledWith('lint', mockWorktree.path, [], { packages: [] })
 		})
 
 		it('should pass worktree path to runScript()', async () => {
@@ -129,7 +135,8 @@ describe('LintCommand', () => {
 			expect(packageManager.runScript).toHaveBeenCalledWith(
 				'lint',
 				mockWorktree.path,
-				[]
+				[],
+				{ packages: [] }
 			)
 		})
 	})
diff --git a/src/commands/open.ts b/src/commands/open.ts
index 3e3c15be..03ba9d57 100644
--- a/src/commands/open.ts
+++ b/src/commands/open.ts
@@ -66,6 +66,10 @@ export class OpenCommand {
 			await this.openWebBrowser(worktree, input.env)
 		} else if (capabilities.includes('cli')) {
 			await this.runCLITool(worktree.path, binEntries, input.args ?? [])
+		} else if (capabilities.includes('monorepo')) {
+			throw new Error(
+				`This is a monorepo root package. Use 'il open' from a specific package worktree, or run the desired package's dev server or CLI directly.`
+			)
 		} else {
 			throw new Error(
 				`No web or CLI capabilities detected for workspace at ${worktree.path}`
diff --git a/src/commands/script-command-base.ts b/src/commands/script-command-base.ts
index 2c9b12d7..9b5e9c3d 100644
--- a/src/commands/script-command-base.ts
+++ b/src/commands/script-command-base.ts
@@ -1,5 +1,6 @@
 import path from 'path'
 import { GitWorktreeManager } from '../lib/GitWorktreeManager.js'
+import { MetadataManager } from '../lib/MetadataManager.js'
 import { IdentifierParser } from '../utils/IdentifierParser.js'
 import { runScript } from '../utils/package-manager.js'
 import { getPackageScripts } from '../utils/package-json.js'
@@ -65,12 +66,38 @@ export abstract class ScriptCommandBase {
 			throw new Error(`No ${scriptName} script defined in package.json or package.iloom.json`)
 		}
 
-		// 4. Run the script
+		// 4. Read packagesToValidate from loom metadata for monorepo scoping
+		const packages = await this.readPackagesToValidate(worktree.path)
+
+		if (packages.length > 0) {
+			logger.info(`Scoping ${this.getScriptDisplayName()} to packages: ${packages.join(', ')}`)
+		}
+
+		// 5. Run the script
 		logger.info(`Running ${this.getScriptDisplayName()}...`)
-		await runScript(scriptName, worktree.path, [])
+		await runScript(scriptName, worktree.path, [], { packages })
 		logger.success(`${this.getScriptDisplayName()} completed successfully`)
 	}
 
+	/**
+	 * Read packagesToValidate from loom metadata.
+	 * Returns empty array if the metadata file does not exist (graceful degradation for non-loom worktrees).
+	 * Rethrows unexpected errors.
+	 */
+	protected async readPackagesToValidate(worktreePath: string): Promise<string[]> {
+		try {
+			const metadataManager = new MetadataManager()
+			const metadata = await metadataManager.readMetadata(worktreePath)
+			return metadata?.packagesToValidate ?? []
+		} catch (error: unknown) {
+			// Only suppress ENOENT (metadata file not found) — all other errors propagate
+			if (error instanceof Error && 'code' in error && (error as NodeJS.ErrnoException).code === 'ENOENT') {
+				return []
+			}
+			throw error
+		}
+	}
+
 	/**
 	 * Parse explicit identifier input
 	 */
diff --git a/src/commands/test.test.ts b/src/commands/test.test.ts
index 097dd2b8..20839682 100644
--- a/src/commands/test.test.ts
+++ b/src/commands/test.test.ts
@@ -1,6 +1,7 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest'
 import { TestCommand } from './test.js'
 import { GitWorktreeManager } from '../lib/GitWorktreeManager.js'
+import { MetadataManager } from '../lib/MetadataManager.js'
 import type { GitWorktree } from '../types/worktree.js'
 import * as packageJson from '../utils/package-json.js'
 import * as packageManager from '../utils/package-manager.js'
@@ -12,6 +13,7 @@ vi.mock('../utils/IdentifierParser.js', () => ({
 		parseForPatternDetection: vi.fn(),
 	})),
 }))
+vi.mock('../lib/MetadataManager.js')
 
 // Mock package utilities
 vi.mock('../utils/package-json.js', () => ({
@@ -47,6 +49,10 @@ describe('TestCommand', () => {
 	beforeEach(() => {
 		mockGitWorktreeManager = new GitWorktreeManager()
 		command = new TestCommand(mockGitWorktreeManager)
+		// Set up MetadataManager mock to return no packagesToValidate by default
+		vi.mocked(MetadataManager).mockImplementation(() => ({
+			readMetadata: vi.fn().mockResolvedValue(null),
+		} as unknown as MetadataManager))
 	})
 
 	describe('identifier parsing', () => {
@@ -115,7 +121,7 @@ describe('TestCommand', () => {
 
 			await command.execute({})
 
-			expect(packageManager.runScript).toHaveBeenCalledWith('test', mockWorktree.path, [])
+			expect(packageManager.runScript).toHaveBeenCalledWith('test', mockWorktree.path, [], { packages: [] })
 		})
 
 		it('should pass worktree path to runScript()', async () => {
@@ -129,7 +135,8 @@ describe('TestCommand', () => {
 			expect(packageManager.runScript).toHaveBeenCalledWith(
 				'test',
 				mockWorktree.path,
-				[]
+				[],
+				{ packages: [] }
 			)
 		})
 	})
diff --git a/src/lib/MetadataManager.test.ts b/src/lib/MetadataManager.test.ts
index 3fb24b63..d358a095 100644
--- a/src/lib/MetadataManager.test.ts
+++ b/src/lib/MetadataManager.test.ts
@@ -383,6 +383,8 @@ describe('MetadataManager', () => {
         dependencyMap: {},
         mcpConfigPath: null,
         swarmTeamName: null,
+        packagesToRun: [],
+        packagesToValidate: [],
       })
     })
 
@@ -517,6 +519,8 @@ describe('MetadataManager', () => {
         dependencyMap: {},
         mcpConfigPath: null,
         swarmTeamName: null,
+        packagesToRun: [],
+        packagesToValidate: [],
       })
     })
 
@@ -889,6 +893,8 @@ describe('MetadataManager', () => {
         dependencyMap: {},
         mcpConfigPath: null,
         swarmTeamName: null,
+        packagesToRun: [],
+        packagesToValidate: [],
       })
       expect(result[1]).toEqual({
         description: 'Project 2 loom',
@@ -917,6 +923,8 @@ describe('MetadataManager', () => {
         dependencyMap: {},
         mcpConfigPath: null,
         swarmTeamName: null,
+        packagesToRun: [],
+        packagesToValidate: [],
       })
     })
 
@@ -1029,6 +1037,8 @@ describe('MetadataManager', () => {
         dependencyMap: {},
         mcpConfigPath: null,
         swarmTeamName: null,
+        packagesToRun: [],
+        packagesToValidate: [],
       })
     })
 
diff --git a/src/lib/MetadataManager.ts b/src/lib/MetadataManager.ts
index ac5a59d7..6ae9f8d5 100644
--- a/src/lib/MetadataManager.ts
+++ b/src/lib/MetadataManager.ts
@@ -52,6 +52,8 @@ export interface MetadataFile {
   dependencyMap?: Record<string, string[]> // issueNumber -> array of blocking issueNumbers
   mcpConfigPath?: string // Path to per-loom MCP config file (for swarm claude -p commands)
   swarmTeamName?: string // Unique team name for swarm orchestrator (persisted for re-runs)
+  packagesToRun?: string[] // Monorepo packages to run dev server for (relative paths from repo root)
+  packagesToValidate?: string[] // Monorepo packages to scope validation to (relative paths from repo root)
 }
 
 /**
@@ -97,6 +99,8 @@ export interface WriteMetadataInput {
   dependencyMap?: Record<string, string[]> // issueNumber -> array of blocking issueNumbers
   mcpConfigPath?: string // Path to per-loom MCP config file (for swarm claude -p commands)
   swarmTeamName?: string // Unique team name for swarm orchestrator (persisted for re-runs)
+  packagesToRun?: string[] // Monorepo packages to run dev server for (relative paths from repo root)
+  packagesToValidate?: string[] // Monorepo packages to scope validation to (relative paths from repo root)
 }
 
 /**
@@ -143,6 +147,8 @@ export interface LoomMetadata {
   dependencyMap: Record<string, string[]>
   mcpConfigPath: string | null // Path to per-loom MCP config file (null for non-swarm looms)
   swarmTeamName: string | null // Unique team name for swarm orchestrator (null for non-swarm looms)
+  packagesToRun: string[] // Monorepo packages to run dev server for (empty for non-monorepo looms)
+  packagesToValidate: string[] // Monorepo packages to scope validation to (empty for non-monorepo looms)
 }
 
 /**
@@ -196,6 +202,8 @@ export class MetadataManager {
       dependencyMap: data.dependencyMap ?? {},
       mcpConfigPath: data.mcpConfigPath ?? null,
       swarmTeamName: data.swarmTeamName ?? null,
+      packagesToRun: data.packagesToRun ?? [],
+      packagesToValidate: data.packagesToValidate ?? [],
     }
   }
 
@@ -282,6 +290,9 @@ export class MetadataManager {
         ...(input.childIssues && input.childIssues.length > 0 && { childIssues: input.childIssues }),
         ...(input.dependencyMap && Object.keys(input.dependencyMap).length > 0 && { dependencyMap: input.dependencyMap }),
         ...(input.mcpConfigPath && { mcpConfigPath: input.mcpConfigPath }),
+        ...(input.swarmTeamName && { swarmTeamName: input.swarmTeamName }),
+        ...(input.packagesToRun !== undefined && { packagesToRun: input.packagesToRun }),
+        ...(input.packagesToValidate !== undefined && { packagesToValidate: input.packagesToValidate }),
       }
 
       // 3. Write to slugified filename
diff --git a/src/lib/ProjectCapabilityDetector.test.ts b/src/lib/ProjectCapabilityDetector.test.ts
index bc21c00c..87901150 100644
--- a/src/lib/ProjectCapabilityDetector.test.ts
+++ b/src/lib/ProjectCapabilityDetector.test.ts
@@ -2,6 +2,7 @@ import { describe, it, expect, vi, beforeEach } from 'vitest'
 import { ProjectCapabilityDetector } from './ProjectCapabilityDetector.js'
 import * as packageJsonUtils from '../utils/package-json.js'
 import type { PackageJson } from '../utils/package-json.js'
+import fs from 'fs-extra'
 
 vi.mock('../utils/package-json.js', () => ({
   getPackageConfig: vi.fn(),
@@ -10,6 +11,12 @@ vi.mock('../utils/package-json.js', () => ({
   getExplicitCapabilities: vi.fn()
 }))
 
+vi.mock('fs-extra', () => ({
+  default: {
+    pathExists: vi.fn()
+  }
+}))
+
 describe('ProjectCapabilityDetector', () => {
   let detector: ProjectCapabilityDetector
 
@@ -18,6 +25,8 @@ describe('ProjectCapabilityDetector', () => {
     detector = new ProjectCapabilityDetector()
     // Default: no explicit capabilities (fallback to package.json detection)
     vi.mocked(packageJsonUtils.getExplicitCapabilities).mockReturnValue([])
+    // Default: no pnpm-workspace.yaml
+    vi.mocked(fs.pathExists as (path: string) => Promise<boolean>).mockResolvedValue(false)
   })
 
   describe('detectCapabilities', () => {
@@ -329,4 +338,105 @@ describe('ProjectCapabilityDetector', () => {
       expect(result.binEntries).toEqual({})
     })
   })
+
+  describe('monorepo detection', () => {
+    it('should detect monorepo from pnpm-workspace.yaml', async () => {
+      const mockPackageJson: PackageJson = {
+        name: 'my-monorepo',
+        dependencies: {}
+      }
+
+      vi.mocked(packageJsonUtils.getPackageConfig).mockResolvedValueOnce(mockPackageJson)
+      vi.mocked(packageJsonUtils.hasWebDependencies).mockReturnValueOnce(false)
+      vi.mocked(fs.pathExists as (path: string) => Promise<boolean>).mockResolvedValue(true)
+
+      const result = await detector.detectCapabilities('/test/path')
+
+      expect(result.capabilities).toContain('monorepo')
+      expect(result.capabilities).not.toContain('cli')
+      expect(result.capabilities).not.toContain('web')
+    })
+
+    it('should detect monorepo from package.json workspaces field (array)', async () => {
+      const mockPackageJson: PackageJson = {
+        name: 'my-monorepo',
+        workspaces: ['packages/*'],
+        dependencies: {}
+      }
+
+      vi.mocked(packageJsonUtils.getPackageConfig).mockResolvedValueOnce(mockPackageJson)
+      vi.mocked(packageJsonUtils.hasWebDependencies).mockReturnValueOnce(false)
+      // pathExists returns false (no pnpm-workspace.yaml), falls through to workspaces check
+
+      const result = await detector.detectCapabilities('/test/path')
+
+      expect(result.capabilities).toContain('monorepo')
+    })
+
+    it('should detect monorepo from package.json workspaces field (object form)', async () => {
+      const mockPackageJson: PackageJson = {
+        name: 'my-monorepo',
+        workspaces: { packages: ['packages/*'] },
+        dependencies: {}
+      }
+
+      vi.mocked(packageJsonUtils.getPackageConfig).mockResolvedValueOnce(mockPackageJson)
+      vi.mocked(packageJsonUtils.hasWebDependencies).mockReturnValueOnce(false)
+
+      const result = await detector.detectCapabilities('/test/path')
+
+      expect(result.capabilities).toContain('monorepo')
+    })
+
+    it('should combine monorepo with cli capability', async () => {
+      const mockPackageJson: PackageJson = {
+        name: 'my-monorepo-cli',
+        bin: { 'my-cli': './dist/cli.js' },
+        dependencies: {}
+      }
+
+      vi.mocked(packageJsonUtils.getPackageConfig).mockResolvedValueOnce(mockPackageJson)
+      vi.mocked(packageJsonUtils.hasWebDependencies).mockReturnValueOnce(false)
+      vi.mocked(packageJsonUtils.parseBinField).mockReturnValueOnce({ 'my-cli': './dist/cli.js' })
+      vi.mocked(fs.pathExists as (path: string) => Promise<boolean>).mockResolvedValue(true)
+
+      const result = await detector.detectCapabilities('/test/path')
+
+      expect(result.capabilities).toContain('cli')
+      expect(result.capabilities).toContain('monorepo')
+    })
+
+    it('should detect monorepo from explicit capabilities in package.iloom.json', async () => {
+      const mockIloomPackage: PackageJson = {
+        name: 'my-monorepo',
+        capabilities: ['monorepo', 'web']
+      }
+
+      vi.mocked(packageJsonUtils.getPackageConfig).mockResolvedValueOnce(mockIloomPackage)
+      vi.mocked(packageJsonUtils.getExplicitCapabilities).mockReturnValueOnce(['monorepo', 'web'])
+
+      const result = await detector.detectCapabilities('/test/path')
+
+      expect(result.capabilities).toEqual(['monorepo', 'web'])
+      expect(result.binEntries).toEqual({})
+    })
+
+    it('should not set monorepo capability when no workspace markers exist', async () => {
+      const mockPackageJson: PackageJson = {
+        name: 'regular-cli',
+        bin: { 'regular-cli': './dist/cli.js' },
+        dependencies: {}
+      }
+
+      vi.mocked(packageJsonUtils.getPackageConfig).mockResolvedValueOnce(mockPackageJson)
+      vi.mocked(packageJsonUtils.hasWebDependencies).mockReturnValueOnce(false)
+      vi.mocked(packageJsonUtils.parseBinField).mockReturnValueOnce({ 'regular-cli': './dist/cli.js' })
+      // pathExists returns false (default) and no workspaces field
+
+      const result = await detector.detectCapabilities('/test/path')
+
+      expect(result.capabilities).toEqual(['cli'])
+      expect(result.capabilities).not.toContain('monorepo')
+    })
+  })
 })
diff --git a/src/lib/ProjectCapabilityDetector.ts b/src/lib/ProjectCapabilityDetector.ts
index 7c9a7b03..5c9f6ad4 100644
--- a/src/lib/ProjectCapabilityDetector.ts
+++ b/src/lib/ProjectCapabilityDetector.ts
@@ -1,3 +1,5 @@
+import fs from 'fs-extra'
+import path from 'path'
 import { getPackageConfig, parseBinField, hasWebDependencies, getExplicitCapabilities } from '../utils/package-json.js'
 import type { ProjectCapability } from '../types/loom.js'
 
@@ -42,6 +44,14 @@ export class ProjectCapabilityDetector {
         capabilities.push('web')
       }
 
+      // Monorepo detection: has pnpm-workspace.yaml or package.json workspaces field
+      const pnpmWorkspacePath = path.join(worktreePath, 'pnpm-workspace.yaml')
+      if (await fs.pathExists(pnpmWorkspacePath)) {
+        capabilities.push('monorepo')
+      } else if (pkgJson.workspaces) {
+        capabilities.push('monorepo')
+      }
+
       // Parse bin entries for CLI projects
       const binEntries = pkgJson.bin ? parseBinField(pkgJson.bin, pkgJson.name) : {}
 
diff --git a/src/lib/PromptTemplateManager.ts b/src/lib/PromptTemplateManager.ts
index 069d0152..b4e4a658 100644
--- a/src/lib/PromptTemplateManager.ts
+++ b/src/lib/PromptTemplateManager.ts
@@ -58,6 +58,8 @@ export interface TemplateVariables {
 	DIRECT_PROMPT_MODE?: boolean
 	// VS Code environment detection
 	IS_VSCODE_MODE?: boolean  // True when ILOOM_VSCODE=1 environment variable is set
+	// Monorepo capability
+	IS_MONOREPO?: boolean  // True when project has 'monorepo' capability
 	// Multi-language support variables - mutually exclusive
 	HAS_PACKAGE_JSON?: boolean  // True when project has package.json
 	NO_PACKAGE_JSON?: boolean   // True when project does not have package.json (non-Node.js projects)
diff --git a/src/lib/ValidationRunner.test.ts b/src/lib/ValidationRunner.test.ts
index de5a5d96..4b661150 100644
--- a/src/lib/ValidationRunner.test.ts
+++ b/src/lib/ValidationRunner.test.ts
@@ -208,7 +208,7 @@ describe('ValidationRunner', () => {
 				'compile',
 				'/test/worktree',
 				[],
-				{ quiet: true }
+				{ quiet: true, packages: [] }
 			)
 			expect(packageManager.runScript).not.toHaveBeenCalledWith(
 				'typecheck',
@@ -238,7 +238,7 @@ describe('ValidationRunner', () => {
 				'typecheck',
 				'/test/worktree',
 				[],
-				{ quiet: true }
+				{ quiet: true, packages: [] }
 			)
 		})
 
@@ -262,7 +262,7 @@ describe('ValidationRunner', () => {
 				'compile',
 				'/test/worktree',
 				[],
-				{ quiet: true }
+				{ quiet: true, packages: [] }
 			)
 		})
 
@@ -396,7 +396,7 @@ describe('ValidationRunner', () => {
 				'typecheck',
 				'/test/worktree',
 				[],
-				{ quiet: true }
+				{ quiet: true, packages: [] }
 			)
 		})
 
@@ -489,7 +489,7 @@ describe('ValidationRunner', () => {
 				'lint',
 				'/test/worktree',
 				[],
-				{ quiet: true }
+				{ quiet: true, packages: [] }
 			)
 		})
 
@@ -561,7 +561,7 @@ describe('ValidationRunner', () => {
 				'test',
 				'/test/worktree',
 				[],
-				{ quiet: true }
+				{ quiet: true, packages: [] }
 			)
 		})
 
@@ -1360,4 +1360,110 @@ describe('ValidationRunner', () => {
 			})
 		})
 	})
+
+	describe('Monorepo Package Scoping', () => {
+		it('should pass packages to runScript when packagesToValidate is set for lint', async () => {
+			vi.mocked(packageJson.getPackageConfig).mockResolvedValue({
+				name: 'test',
+				scripts: { lint: 'eslint .' },
+			})
+			vi.mocked(packageJson.hasScript).mockImplementation(
+				(_, script) => script === 'lint'
+			)
+			vi.mocked(packageManager.detectPackageManager).mockResolvedValue('pnpm')
+			vi.mocked(packageManager.runScript).mockResolvedValue()
+
+			const result = await runner.runValidations('/test/worktree', {
+				skipTypecheck: true,
+				skipTests: true,
+				packagesToValidate: ['packages/core', 'packages/api'],
+			})
+
+			expect(result.success).toBe(true)
+			expect(packageManager.runScript).toHaveBeenCalledWith(
+				'lint',
+				'/test/worktree',
+				[],
+				{ quiet: true, packages: ['packages/core', 'packages/api'] }
+			)
+		})
+
+		it('should pass packages to runScript when packagesToValidate is set for tests', async () => {
+			vi.mocked(packageJson.getPackageConfig).mockResolvedValue({
+				name: 'test',
+				scripts: { test: 'vitest run' },
+			})
+			vi.mocked(packageJson.hasScript).mockImplementation(
+				(_, script) => script === 'test'
+			)
+			vi.mocked(packageManager.detectPackageManager).mockResolvedValue('pnpm')
+			vi.mocked(packageManager.runScript).mockResolvedValue()
+
+			const result = await runner.runValidations('/test/worktree', {
+				skipTypecheck: true,
+				skipLint: true,
+				packagesToValidate: ['services/auth'],
+			})
+
+			expect(result.success).toBe(true)
+			expect(packageManager.runScript).toHaveBeenCalledWith(
+				'test',
+				'/test/worktree',
+				[],
+				{ quiet: true, packages: ['services/auth'] }
+			)
+		})
+
+		it('should pass packages to runScript when packagesToValidate is set for typecheck', async () => {
+			vi.mocked(packageJson.getPackageConfig).mockResolvedValue({
+				name: 'test',
+				scripts: { compile: 'tsc --build' },
+			})
+			vi.mocked(packageJson.hasScript).mockImplementation(
+				(_, script) => script === 'compile'
+			)
+			vi.mocked(packageManager.detectPackageManager).mockResolvedValue('pnpm')
+			vi.mocked(packageManager.runScript).mockResolvedValue()
+
+			const result = await runner.runValidations('/test/worktree', {
+				skipLint: true,
+				skipTests: true,
+				packagesToValidate: ['packages/core'],
+			})
+
+			expect(result.success).toBe(true)
+			expect(packageManager.runScript).toHaveBeenCalledWith(
+				'compile',
+				'/test/worktree',
+				[],
+				{ quiet: true, packages: ['packages/core'] }
+			)
+		})
+
+		it('should run against full project when packagesToValidate is empty', async () => {
+			vi.mocked(packageJson.getPackageConfig).mockResolvedValue({
+				name: 'test',
+				scripts: { lint: 'eslint .' },
+			})
+			vi.mocked(packageJson.hasScript).mockImplementation(
+				(_, script) => script === 'lint'
+			)
+			vi.mocked(packageManager.detectPackageManager).mockResolvedValue('pnpm')
+			vi.mocked(packageManager.runScript).mockResolvedValue()
+
+			const result = await runner.runValidations('/test/worktree', {
+				skipTypecheck: true,
+				skipTests: true,
+				packagesToValidate: [],
+			})
+
+			expect(result.success).toBe(true)
+			expect(packageManager.runScript).toHaveBeenCalledWith(
+				'lint',
+				'/test/worktree',
+				[],
+				{ quiet: true, packages: [] }
+			)
+		})
+	})
 })
diff --git a/src/lib/ValidationRunner.ts b/src/lib/ValidationRunner.ts
index 64aaa578..eb32f033 100644
--- a/src/lib/ValidationRunner.ts
+++ b/src/lib/ValidationRunner.ts
@@ -28,14 +28,15 @@ export class ValidationRunner {
 		const startTime = Date.now()
 		const steps: ValidationStepResult[] = []
 
-		const { jsonStream } = options
+		const { jsonStream, packagesToValidate } = options
+		const stepOptions = { jsonStream, packagesToValidate }
 
 		// Run typecheck
 		if (!options.skipTypecheck) {
 			const typecheckResult = await this.runTypecheck(
 				worktreePath,
 				options.dryRun ?? false,
-				{ jsonStream }
+				stepOptions
 			)
 			steps.push(typecheckResult)
 
@@ -50,7 +51,7 @@ export class ValidationRunner {
 
 		// Run lint
 		if (!options.skipLint) {
-			const lintResult = await this.runLint(worktreePath, options.dryRun ?? false, { jsonStream })
+			const lintResult = await this.runLint(worktreePath, options.dryRun ?? false, stepOptions)
 			steps.push(lintResult)
 
 			if (!lintResult.passed && !lintResult.skipped) {
@@ -63,7 +64,7 @@ export class ValidationRunner {
 			const testResult = await this.runTests(
 				worktreePath,
 				options.dryRun ?? false,
-				{ jsonStream }
+				stepOptions
 			)
 			steps.push(testResult)
 
@@ -82,7 +83,7 @@ export class ValidationRunner {
 	private async runTypecheck(
 		worktreePath: string,
 		dryRun: boolean,
-		options: { jsonStream?: boolean | undefined } = {}
+		options: { jsonStream?: boolean | undefined; packagesToValidate?: string[] | undefined } = {}
 	): Promise<ValidationStepResult> {
 		const stepStartTime = Date.now()
 
@@ -125,13 +126,15 @@ export class ValidationRunner {
 		}
 
 		const packageManager = await detectPackageManager(worktreePath)
+		const packages = options.packagesToValidate ?? []
 
 		if (dryRun) {
 			const command =
 				packageManager === 'npm'
 					? `npm run ${scriptToRun}`
 					: `${packageManager} ${scriptToRun}`
-			getLogger().info(`[DRY RUN] Would run: ${command}`)
+			const scopeNote = packages.length > 0 ? ` (scoped to: ${packages.join(', ')})` : ''
+			getLogger().info(`[DRY RUN] Would run: ${command}${scopeNote}`)
 			return {
 				step: scriptToRun,
 				passed: true,
@@ -140,10 +143,11 @@ export class ValidationRunner {
 			}
 		}
 
-		getLogger().info(`Running ${scriptToRun}...`)
+		const scopeNote = packages.length > 0 ? ` (scoped to: ${packages.join(', ')})` : ''
+		getLogger().info(`Running ${scriptToRun}...${scopeNote}`)
 
 		try {
-			await runScript(scriptToRun, worktreePath, [], { quiet: true })
+			await runScript(scriptToRun, worktreePath, [], { quiet: true, packages })
 			getLogger().success(`${scriptToRun.charAt(0).toUpperCase() + scriptToRun.slice(1)} passed`)
 
 			return {
@@ -158,7 +162,7 @@ export class ValidationRunner {
 				scriptToRun,
 				worktreePath,
 				packageManager,
-				{ jsonStream: options.jsonStream }
+				{ jsonStream: options.jsonStream, packagesToValidate: packages }
 			)
 
 			if (fixed) {
@@ -191,7 +195,7 @@ export class ValidationRunner {
 	private async runLint(
 		worktreePath: string,
 		dryRun: boolean,
-		options: { jsonStream?: boolean | undefined } = {}
+		options: { jsonStream?: boolean | undefined; packagesToValidate?: string[] | undefined } = {}
 	): Promise<ValidationStepResult> {
 		const stepStartTime = Date.now()
 
@@ -225,11 +229,13 @@ export class ValidationRunner {
 		}
 
 		const packageManager = await detectPackageManager(worktreePath)
+		const packages = options.packagesToValidate ?? []
 
 		if (dryRun) {
 			const command =
 				packageManager === 'npm' ? 'npm run lint' : `${packageManager} lint`
-			getLogger().info(`[DRY RUN] Would run: ${command}`)
+			const scopeNote = packages.length > 0 ? ` (scoped to: ${packages.join(', ')})` : ''
+			getLogger().info(`[DRY RUN] Would run: ${command}${scopeNote}`)
 			return {
 				step: 'lint',
 				passed: true,
@@ -238,10 +244,11 @@ export class ValidationRunner {
 			}
 		}
 
-		getLogger().info('Running lint...')
+		const scopeNote = packages.length > 0 ? ` (scoped to: ${packages.join(', ')})` : ''
+		getLogger().info(`Running lint...${scopeNote}`)
 
 		try {
-			await runScript('lint', worktreePath, [], { quiet: true })
+			await runScript('lint', worktreePath, [], { quiet: true, packages })
 			getLogger().success('Linting passed')
 
 			return {
@@ -256,11 +263,10 @@ export class ValidationRunner {
 				'lint',
 				worktreePath,
 				packageManager,
-				{ jsonStream: options.jsonStream }
+				{ jsonStream: options.jsonStream, packagesToValidate: packages }
 			)
 
 			if (fixed) {
-				// logger.success('Linting passed after Claude auto-fix')
 				return {
 					step: 'lint',
 					passed: true,
@@ -287,7 +293,7 @@ export class ValidationRunner {
 	private async runTests(
 		worktreePath: string,
 		dryRun: boolean,
-		options: { jsonStream?: boolean | undefined } = {}
+		options: { jsonStream?: boolean | undefined; packagesToValidate?: string[] | undefined } = {}
 	): Promise<ValidationStepResult> {
 		const stepStartTime = Date.now()
 
@@ -321,11 +327,13 @@ export class ValidationRunner {
 		}
 
 		const packageManager = await detectPackageManager(worktreePath)
+		const packages = options.packagesToValidate ?? []
 
 		if (dryRun) {
 			const command =
 				packageManager === 'npm' ? 'npm run test' : `${packageManager} test`
-			getLogger().info(`[DRY RUN] Would run: ${command}`)
+			const scopeNote = packages.length > 0 ? ` (scoped to: ${packages.join(', ')})` : ''
+			getLogger().info(`[DRY RUN] Would run: ${command}${scopeNote}`)
 			return {
 				step: 'test',
 				passed: true,
@@ -334,10 +342,11 @@ export class ValidationRunner {
 			}
 		}
 
-		getLogger().info('Running tests...')
+		const scopeNote = packages.length > 0 ? ` (scoped to: ${packages.join(', ')})` : ''
+		getLogger().info(`Running tests...${scopeNote}`)
 
 		try {
-			await runScript('test', worktreePath, [], { quiet: true })
+			await runScript('test', worktreePath, [], { quiet: true, packages })
 			getLogger().success('Tests passed')
 
 			return {
@@ -352,11 +361,10 @@ export class ValidationRunner {
 				'test',
 				worktreePath,
 				packageManager,
-				{ jsonStream: options.jsonStream }
+				{ jsonStream: options.jsonStream, packagesToValidate: packages }
 			)
 
 			if (fixed) {
-				// logger.success('Tests passed after Claude auto-fix')
 				return {
 					step: 'test',
 					passed: true,
@@ -390,7 +398,7 @@ export class ValidationRunner {
 		validationType: 'compile' | 'typecheck' | 'lint' | 'test',
 		worktreePath: string,
 		packageManager: string,
-		options: { jsonStream?: boolean | undefined } = {}
+		options: { jsonStream?: boolean | undefined; packagesToValidate?: string[] | undefined } = {}
 	): Promise<boolean> {
 		// Check if Claude CLI is available
 		const isClaudeAvailable = await detectClaudeCli()
@@ -405,6 +413,10 @@ export class ValidationRunner {
 		// Build prompt based on validation type (matching bash script prompts)
 		const prompt = this.getClaudePrompt(validationType, validationCommand)
 
+		// Build system prompt appendage to instruct auto-fix agents to use il commands for re-validation
+		const packages = options.packagesToValidate ?? []
+		const appendSystemPrompt = this.getAutoFixSystemPrompt(validationType, packages)
+
 		const validationTypeCapitalized = validationType.charAt(0).toUpperCase() + validationType.slice(1)
 		getLogger().info(`Launching Claude to help fix ${validationTypeCapitalized} errors...`)
 
@@ -417,6 +429,7 @@ export class ValidationRunner {
 				permissionMode: options.jsonStream ? 'bypassPermissions' : 'acceptEdits',
 				model: 'sonnet',
 				noSessionPersistence: true,
+				appendSystemPrompt,
 				...(options.jsonStream && { passthroughStdout: true }),
 			})
 
@@ -424,7 +437,7 @@ export class ValidationRunner {
 			getLogger().info(`Re-running ${validationTypeCapitalized} after Claude's fixes...`)
 
 			try {
-				await runScript(validationType, worktreePath, [], { quiet: true })
+				await runScript(validationType, worktreePath, [], { quiet: true, packages })
 				// Validation passed after Claude fix
 				getLogger().success(`${validationTypeCapitalized} passed after Claude auto-fix`)
 				return true
@@ -442,6 +455,27 @@ export class ValidationRunner {
 		}
 	}
 
+	/**
+	 * Get the system prompt appendage for auto-fix agents.
+	 * Instructs agents to use il commands for re-validation (so they benefit from monorepo scoping).
+	 * Note: 'typecheck' maps to 'il compile' since 'il typecheck' is not a CLI command.
+	 */
+	private getAutoFixSystemPrompt(
+		validationType: 'compile' | 'typecheck' | 'lint' | 'test',
+		packages: string[]
+	): string {
+		// 'il typecheck' does not exist — il compile handles both compile and typecheck fallback
+		const commandName = validationType === 'typecheck' ? 'compile' : validationType
+		const ilCommand = `il ${commandName}`
+		let prompt = `IMPORTANT: When re-running validation to verify your fixes, always use '${ilCommand}' instead of raw package manager commands. The il command automatically applies the correct monorepo scoping and configuration.`
+
+		if (packages.length > 0) {
+			prompt += ` This validation is scoped to the following packages: ${packages.join(', ')}.`
+		}
+
+		return prompt
+	}
+
 	/**
 	 * Get validation command string for prompts
 	 * Uses il commands for multi-language project support
diff --git a/src/mcp/recap-server.test.ts b/src/mcp/recap-server.test.ts
index 9a2a1be8..9a20ce4b 100644
--- a/src/mcp/recap-server.test.ts
+++ b/src/mcp/recap-server.test.ts
@@ -547,3 +547,146 @@ describe('recap-server worktreePath resolution', () => {
 		})
 	})
 })
+
+/**
+ * Simulates the set_package_to_run logic from recap-server.ts
+ * Reads metadata file, updates packagesToRun as single-element array, writes back
+ */
+async function setPackageToRun(
+	readMetadata: () => Promise<MetadataFile>,
+	writeMetadata: (metadata: MetadataFile) => Promise<void>,
+	pkg: string
+): Promise<{ success: true; packagesToRun: string[] }> {
+	const metadata = await readMetadata()
+	metadata.packagesToRun = [pkg]
+	await writeMetadata(metadata)
+	return { success: true, packagesToRun: [pkg] }
+}
+
+/**
+ * Simulates the set_packages_to_validate logic from recap-server.ts
+ * Reads metadata file, updates packagesToValidate, writes back
+ */
+async function setPackagesToValidate(
+	readMetadata: () => Promise<MetadataFile>,
+	writeMetadata: (metadata: MetadataFile) => Promise<void>,
+	packages: string[]
+): Promise<{ success: true; packagesToValidate: string[] }> {
+	const metadata = await readMetadata()
+	metadata.packagesToValidate = packages
+	await writeMetadata(metadata)
+	return { success: true, packagesToValidate: packages }
+}
+
+describe('recap-server monorepo package tools', () => {
+	let mockMetadataFile: MetadataFile
+	let readMetadataMock: () => Promise<MetadataFile>
+	let writeMetadataMock: (metadata: MetadataFile) => Promise<void>
+
+	beforeEach(() => {
+		mockMetadataFile = {
+			description: 'Test loom',
+			version: 1,
+			branchName: 'issue-42__test',
+			worktreePath: '/Users/test/dev/repo',
+			projectPath: '/Users/test/dev/repo',
+		}
+
+		readMetadataMock = vi.fn().mockImplementation(async () => ({ ...mockMetadataFile }))
+		writeMetadataMock = vi.fn().mockImplementation(async (metadata: MetadataFile) => {
+			mockMetadataFile = { ...metadata }
+		})
+	})
+
+	describe('set_package_to_run', () => {
+		it('should store single package as array', async () => {
+			const result = await setPackageToRun(readMetadataMock, writeMetadataMock, 'services/admin-api')
+
+			expect(result.success).toBe(true)
+			expect(result.packagesToRun).toEqual(['services/admin-api'])
+			expect(mockMetadataFile.packagesToRun).toEqual(['services/admin-api'])
+		})
+
+		it('should overwrite existing packagesToRun', async () => {
+			mockMetadataFile.packagesToRun = ['services/old-api']
+
+			const result = await setPackageToRun(readMetadataMock, writeMetadataMock, 'services/new-api')
+
+			expect(result.packagesToRun).toEqual(['services/new-api'])
+			expect(mockMetadataFile.packagesToRun).toEqual(['services/new-api'])
+		})
+
+		it('should always store as single-element array', async () => {
+			await setPackageToRun(readMetadataMock, writeMetadataMock, 'packages/ui')
+
+			expect(mockMetadataFile.packagesToRun).toHaveLength(1)
+		})
+
+		it('should preserve other metadata fields when setting packagesToRun', async () => {
+			mockMetadataFile.description = 'Important loom'
+			mockMetadataFile.branchName = 'issue-99__feature'
+
+			await setPackageToRun(readMetadataMock, writeMetadataMock, 'apps/frontend')
+
+			expect(mockMetadataFile.description).toBe('Important loom')
+			expect(mockMetadataFile.branchName).toBe('issue-99__feature')
+			expect(mockMetadataFile.packagesToRun).toEqual(['apps/frontend'])
+		})
+
+		it('should call writeMetadata with updated metadata', async () => {
+			await setPackageToRun(readMetadataMock, writeMetadataMock, 'services/api')
+
+			expect(writeMetadataMock).toHaveBeenCalledWith(
+				expect.objectContaining({ packagesToRun: ['services/api'] })
+			)
+		})
+	})
+
+	describe('set_packages_to_validate', () => {
+		it('should store array of packages', async () => {
+			const packages = ['services/admin-api', 'packages/shared']
+			const result = await setPackagesToValidate(readMetadataMock, writeMetadataMock, packages)
+
+			expect(result.success).toBe(true)
+			expect(result.packagesToValidate).toEqual(packages)
+			expect(mockMetadataFile.packagesToValidate).toEqual(packages)
+		})
+
+		it('should accept empty array', async () => {
+			const result = await setPackagesToValidate(readMetadataMock, writeMetadataMock, [])
+
+			expect(result.packagesToValidate).toEqual([])
+			expect(mockMetadataFile.packagesToValidate).toEqual([])
+		})
+
+		it('should overwrite existing packagesToValidate', async () => {
+			mockMetadataFile.packagesToValidate = ['services/old-api']
+			const newPackages = ['services/new-api', 'packages/ui']
+
+			const result = await setPackagesToValidate(readMetadataMock, writeMetadataMock, newPackages)
+
+			expect(result.packagesToValidate).toEqual(newPackages)
+			expect(mockMetadataFile.packagesToValidate).toEqual(newPackages)
+		})
+
+		it('should preserve other metadata fields when setting packagesToValidate', async () => {
+			mockMetadataFile.description = 'Important loom'
+			mockMetadataFile.branchName = 'issue-99__feature'
+
+			await setPackagesToValidate(readMetadataMock, writeMetadataMock, ['services/api'])
+
+			expect(mockMetadataFile.description).toBe('Important loom')
+			expect(mockMetadataFile.branchName).toBe('issue-99__feature')
+			expect(mockMetadataFile.packagesToValidate).toEqual(['services/api'])
+		})
+
+		it('should call writeMetadata with updated metadata', async () => {
+			const packages = ['services/api', 'apps/web']
+			await setPackagesToValidate(readMetadataMock, writeMetadataMock, packages)
+
+			expect(writeMetadataMock).toHaveBeenCalledWith(
+				expect.objectContaining({ packagesToValidate: packages })
+			)
+		})
+	})
+})
diff --git a/src/mcp/recap-server.ts b/src/mcp/recap-server.ts
index 729d2f4f..017559de 100644
--- a/src/mcp/recap-server.ts
+++ b/src/mcp/recap-server.ts
@@ -487,6 +487,116 @@ server.registerTool(
 	}
 )
 
+// Register set_package_to_run tool
+server.registerTool(
+	'set_package_to_run',
+	{
+		title: 'Set Package to Run',
+		description: 'Set which monorepo package to run a dev server for. Stores as single-element array in loom metadata.',
+		inputSchema: {
+			package: z.string().describe('Relative directory path from repo root (e.g., "services/admin-api")'),
+			worktreePath: z.string().optional().describe('Optional worktree path to scope to a specific loom'),
+		},
+		outputSchema: {
+			success: z.literal(true),
+			packagesToRun: z.array(z.string()),
+		},
+	},
+	async ({ package: pkg, worktreePath }) => {
+		const metadataFilePath = resolveMetadataFilePath(worktreePath)
+
+		// Read existing metadata
+		let metadata: MetadataFile
+		try {
+			const content = await fs.readFile(metadataFilePath, 'utf8')
+			metadata = JSON.parse(content) as MetadataFile
+		} catch (error: unknown) {
+			if (error instanceof SyntaxError) {
+				throw new Error(`Metadata file contains invalid JSON at ${metadataFilePath}`)
+			}
+			if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+				throw new Error(`Metadata file not found at ${metadataFilePath}`)
+			}
+			throw error
+		}
+
+		// Warn if package path doesn't exist on disk (relative to project path or worktree path)
+		const basePath = metadata.projectPath ?? (worktreePath ?? process.cwd())
+		const pkgAbsPath = path.join(basePath, pkg)
+		if (!(await fs.pathExists(pkgAbsPath))) {
+			console.error(`Warning: Package path does not exist on disk: ${pkgAbsPath}`)
+		}
+
+		// Update packagesToRun as single-element array
+		metadata.packagesToRun = [pkg]
+
+		// Write back
+		await fs.writeFile(metadataFilePath, JSON.stringify(metadata, null, 2), { mode: 0o644 })
+
+		const result = { success: true as const, packagesToRun: [pkg] }
+		return {
+			content: [{ type: 'text' as const, text: JSON.stringify(result) }],
+			structuredContent: result,
+		}
+	}
+)
+
+// Register set_packages_to_validate tool
+server.registerTool(
+	'set_packages_to_validate',
+	{
+		title: 'Set Packages to Validate',
+		description: 'Set which monorepo packages to scope validation to. Stores array in loom metadata.',
+		inputSchema: {
+			packages: z.array(z.string()).describe('Array of relative directory paths from repo root (e.g., ["services/admin-api", "packages/shared"])'),
+			worktreePath: z.string().optional().describe('Optional worktree path to scope to a specific loom'),
+		},
+		outputSchema: {
+			success: z.literal(true),
+			packagesToValidate: z.array(z.string()),
+		},
+	},
+	async ({ packages, worktreePath }) => {
+		const metadataFilePath = resolveMetadataFilePath(worktreePath)
+
+		// Read existing metadata
+		let metadata: MetadataFile
+		try {
+			const content = await fs.readFile(metadataFilePath, 'utf8')
+			metadata = JSON.parse(content) as MetadataFile
+		} catch (error: unknown) {
+			if (error instanceof SyntaxError) {
+				throw new Error(`Metadata file contains invalid JSON at ${metadataFilePath}`)
+			}
+			if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+				throw new Error(`Metadata file not found at ${metadataFilePath}`)
+			}
+			throw error
+		}
+
+		// Warn for each package path that doesn't exist on disk
+		const basePath = metadata.projectPath ?? (worktreePath ?? process.cwd())
+		for (const pkg of packages) {
+			const pkgAbsPath = path.join(basePath, pkg)
+			if (!(await fs.pathExists(pkgAbsPath))) {
+				console.error(`Warning: Package path does not exist on disk: ${pkgAbsPath}`)
+			}
+		}
+
+		// Update packagesToValidate
+		metadata.packagesToValidate = packages
+
+		// Write back
+		await fs.writeFile(metadataFilePath, JSON.stringify(metadata, null, 2), { mode: 0o644 })
+
+		const result = { success: true as const, packagesToValidate: packages }
+		return {
+			content: [{ type: 'text' as const, text: JSON.stringify(result) }],
+			structuredContent: result,
+		}
+	}
+)
+
 // Main server startup
 async function main(): Promise<void> {
 	console.error('=== Loom Recap MCP Server Starting ===')
diff --git a/src/types/index.ts b/src/types/index.ts
index 126a8e4e..76fda748 100644
--- a/src/types/index.ts
+++ b/src/types/index.ts
@@ -339,6 +339,12 @@ export interface ValidationOptions {
 	skipLint?: boolean
 	skipTests?: boolean
 	jsonStream?: boolean
+	/**
+	 * Monorepo packages to scope validation to (relative paths from repo root).
+	 * When non-empty, validation commands run only for these packages.
+	 * When empty or undefined, runs against the entire project (default behavior).
+	 */
+	packagesToValidate?: string[]
 }
 
 export interface ValidationStepResult {
diff --git a/src/types/loom.ts b/src/types/loom.ts
index 7b74f655..bcc4deea 100644
--- a/src/types/loom.ts
+++ b/src/types/loom.ts
@@ -1,4 +1,4 @@
-export type ProjectCapability = 'cli' | 'web'
+export type ProjectCapability = 'cli' | 'web' | 'monorepo'
 export type Capability = ProjectCapability
 
 export interface Loom {
diff --git a/src/types/telemetry.ts b/src/types/telemetry.ts
index b607a5ac..1e2a3a3f 100644
--- a/src/types/telemetry.ts
+++ b/src/types/telemetry.ts
@@ -133,6 +133,11 @@ export interface DevServerStartedEvent {
    * Tracks feature adoption without exposing secret IDs or paths.
    */
   docker_build_secrets_count?: number
+  /**
+   * Whether the dev server launched from a monorepo package subdirectory
+   * (both web and monorepo capabilities were detected).
+   */
+  is_monorepo?: boolean
 }
 
 export interface DevServerStoppedEvent {
diff --git a/src/utils/package-json.ts b/src/utils/package-json.ts
index e3730869..5c7a1d7d 100644
--- a/src/utils/package-json.ts
+++ b/src/utils/package-json.ts
@@ -16,8 +16,8 @@ export const ILOOM_PACKAGE_LOCAL_PATH = '.iloom/package.iloom.local.json'
  * Defines project capabilities and custom shell commands for non-Node.js projects
  */
 export const PackageIloomSchema = z.object({
-  capabilities: z.array(z.enum(['cli', 'web'])).optional()
-    .describe('Project capabilities - "cli" for command-line tools (enables CLI isolation), "web" for web applications (enables port assignment and dev server)'),
+  capabilities: z.array(z.enum(['cli', 'web', 'monorepo'])).optional()
+    .describe('Project capabilities - "cli" for command-line tools (enables CLI isolation), "web" for web applications (enables port assignment and dev server), "monorepo" for monorepo projects with workspace packages (enables package-aware commands)'),
   scripts: z.object({
     install: z.string().optional().describe('Install command (e.g., "bundle install", "poetry install")'),
     build: z.string().optional().describe('Build/compile command'),
@@ -37,6 +37,7 @@ export interface PackageJson {
   devDependencies?: Record<string, string>
   scripts?: Record<string, string>
   capabilities?: ProjectCapability[]
+  workspaces?: string[] | { packages: string[] }
   [key: string]: unknown
 }
 
@@ -263,7 +264,7 @@ export async function getPackageScripts(dir: string): Promise<Record<string, Pac
 /**
  * Valid capability values that can be explicitly declared
  */
-const VALID_CAPABILITIES: readonly ProjectCapability[] = ['cli', 'web'] as const
+const VALID_CAPABILITIES: readonly ProjectCapability[] = ['cli', 'web', 'monorepo'] as const
 
 /**
  * Extract explicit capabilities from package configuration
diff --git a/src/utils/package-manager.ts b/src/utils/package-manager.ts
index c597aa56..e892a8bf 100644
--- a/src/utils/package-manager.ts
+++ b/src/utils/package-manager.ts
@@ -166,6 +166,50 @@ export interface RunScriptOptions {
   noCi?: boolean
   /** Callback for server output when using pipe mode (for TUI). When provided, stdio is piped instead of inherited. */
   onOutput?: (data: Buffer) => void
+  /**
+   * Monorepo packages to scope the script to (relative paths from repo root).
+   * When non-empty, uses the package manager's filter syntax to run only for these packages.
+   * Packages missing the target script are gracefully skipped.
+   * When empty or undefined, runs against the entire project.
+   */
+  packages?: string[]
+}
+
+/**
+ * Build package-manager-specific filter args for monorepo scoping.
+ * Returns args to prepend/append to the command for filtering to specific packages.
+ */
+export function buildMonorepoFilterArgs(
+  packageManager: PackageManager,
+  scriptName: string,
+  packages: string[]
+): { prefix: string[]; suffix: string[] } {
+  if (packages.length === 0) {
+    return { prefix: [], suffix: [] }
+  }
+
+  switch (packageManager) {
+    case 'pnpm': {
+      // pnpm uses directory paths with ./ prefix for path-based filtering, or package names otherwise.
+      // Always normalize to path form to match the "relative paths from repo root" contract.
+      const filterArgs = packages.flatMap(pkg => ['--filter', pkg.startsWith('./') ? pkg : `./${pkg}`])
+      return { prefix: filterArgs, suffix: ['--if-present'] }
+    }
+    case 'npm': {
+      // npm run <script> --workspace=pkg1 --workspace=pkg2 --if-present
+      const workspaceArgs = packages.map(pkg => `--workspace=${pkg}`)
+      return { prefix: [], suffix: [...workspaceArgs, '--if-present'] }
+    }
+    case 'yarn': {
+      // yarn workspaces foreach --include pkg1 --include pkg2 run <script>
+      // This works with yarn berry (v2+). For yarn classic, there's no built-in multi-workspace support.
+      const includeArgs = packages.flatMap(pkg => ['--include', pkg])
+      return { prefix: ['workspaces', 'foreach', ...includeArgs], suffix: ['run', scriptName] }
+    }
+    default: {
+      throw new Error(`Unsupported package manager for monorepo filtering: ${packageManager}`)
+    }
+  }
 }
 
 /**
@@ -241,9 +285,31 @@ export async function runScript(
     } else {
       // Execute via package manager (for Node.js projects)
       const packageManager = await detectPackageManager(cwd)
-      const command = packageManager === 'npm' ? ['run', scriptName] : [scriptName]
+      const packages = options.packages ?? []
+
+      let execaArgs: string[]
+
+      if (packages.length > 0) {
+        // Monorepo scoped execution using package manager filter syntax
+        const filterArgs = buildMonorepoFilterArgs(packageManager, scriptName, packages)
+
+        if (packageManager === 'yarn') {
+          // yarn workspaces foreach --include pkg1 run <script> [args...]
+          execaArgs = [...filterArgs.prefix, ...filterArgs.suffix, ...args]
+        } else if (packageManager === 'npm') {
+          // npm run <script> [args...] --workspace=pkg1 --if-present
+          execaArgs = ['run', scriptName, ...args, ...filterArgs.suffix]
+        } else {
+          // pnpm --filter pkg1 --filter pkg2 run <script> [args...] --if-present
+          execaArgs = [...filterArgs.prefix, 'run', scriptName, ...args, ...filterArgs.suffix]
+        }
+      } else {
+        // Standard full-project execution
+        const command = packageManager === 'npm' ? ['run', scriptName] : [scriptName]
+        execaArgs = [...command, ...args]
+      }
 
-      execaProcess = execa(packageManager, [...command, ...args], {
+      execaProcess = execa(packageManager, execaArgs, {
         cwd,
         stdio,
         ...(!options.foreground && !options.onOutput && { timeout: 600000 }), // No timeout for foreground/TUI mode
diff --git a/templates/agents/iloom-framework-detector.md b/templates/agents/iloom-framework-detector.md
index e528b1ab..c605399d 100644
--- a/templates/agents/iloom-framework-detector.md
+++ b/templates/agents/iloom-framework-detector.md
@@ -114,6 +114,7 @@ Create `.iloom/package.iloom.json` with appropriate scripts and capabilities bas
 **Capabilities Detection:**
 - `"cli"` - Include if project has CLI components (e.g., `[[bin]]` in Cargo.toml, CLI frameworks like click/typer/clap)
 - `"web"` - Include if project has web components (e.g., Flask/Django/FastAPI/Rails/Actix/Rocket)
+- `"monorepo"` - Include if project has workspace configuration (e.g., `pnpm-workspace.yaml` exists, `workspaces` field in package.json, multiple project directories with individual build files)
 
 **Common Patterns by Language:**
 
diff --git a/templates/agents/iloom-monorepo-package-detector.md b/templates/agents/iloom-monorepo-package-detector.md
new file mode 100644
index 00000000..d23714d5
--- /dev/null
+++ b/templates/agents/iloom-monorepo-package-detector.md
@@ -0,0 +1,72 @@
+---
+name: iloom-monorepo-package-detector
+description: Explores monorepo workspace structure to determine which packages to run and validate for the current issue. Calls MCP tools to set packagesToRun and packagesToValidate.
+color: green
+model: sonnet
+---
+
+You are a monorepo package detection specialist. Your task is to explore the workspace structure, understand the issue context, and determine which packages need to be run (dev server) and validated (test/lint/build).
+
+## Core Mission
+
+Analyze the monorepo to identify:
+1. **Package to run**: The primary package that needs a dev server (if any)
+2. **Packages to validate**: All packages that should be scoped for test/lint/build validation
+
+## Workflow
+
+### Step 1: Explore Workspace Structure
+
+Discover the monorepo package layout:
+
+1. Check for `pnpm-workspace.yaml` and read it to find workspace globs
+2. If no pnpm workspace, check `package.json` for `workspaces` field
+3. List all discovered packages with their paths relative to repo root
+4. For each package, note its `name` from its package.json and any key dependencies
+
+### Step 2: Understand the Issue Context
+
+Read the issue details to understand what is being changed:
+1. Read the issue via `mcp__issue_management__get_issue`
+2. Identify which packages are likely affected by examining:
+   - File paths mentioned in the issue or plan comments
+   - Package names mentioned in the issue
+   - Dependencies between packages (if package A depends on package B and B is changing, A may need validation)
+
+### Step 3: Determine Packages
+
+Based on your exploration:
+
+**Package to run (dev server):**
+- If the issue involves a web application package, that's the package to run
+- If no web package is involved, skip this step
+- Call `mcp__recap__set_package_to_run` with the relative path (e.g., "apps/web")
+
+**Packages to validate:**
+- Include all packages directly modified by the issue
+- Include packages that depend on modified packages (transitive consumers)
+- Do NOT include the entire monorepo — only affected packages
+- Call `mcp__recap__set_packages_to_validate` with the array of relative paths
+
+### Step 4: Report
+
+Print a summary:
+```
+Monorepo Package Detection Complete
+
+Workspace packages found: N
+- [package-path] ([package-name])
+- ...
+
+Package to run (dev server): [path or "None"]
+Packages to validate: [list of paths]
+
+Reasoning: [Brief explanation of why these packages were selected]
+```
+
+## Behavioral Constraints
+
+1. **Explore, don't guess** — Always read workspace config and package.json files
+2. **Be conservative** — When in doubt, include a package in validation rather than excluding it
+3. **Respect boundaries** — Only set packages that actually exist in the workspace
+4. **No side effects** — Only call the MCP tools for setting packages, do not modify any files
diff --git a/templates/hooks/iloom-hook.js b/templates/hooks/iloom-hook.js
index 80bc11bb..5963e727 100644
--- a/templates/hooks/iloom-hook.js
+++ b/templates/hooks/iloom-hook.js
@@ -325,7 +325,7 @@ async function main() {
 
         if (swarmCompleted) {
           // Swarm finished — show full routing table with swarm-prefixed agents
-          const reminder = `**REMINDER**: You MUST USE subagents to preserve your context window for ongoing conversation.
+          let reminder = `**REMINDER**: You MUST USE subagents to preserve your context window for ongoing conversation.
 
 | Request Type | Action |
 |--------------|--------|
@@ -336,6 +336,21 @@ async function main() {
 | New features / complex changes | \`@agent-iloom-swarm-issue-analyze-and-plan\` → if approved, \`@agent-iloom-swarm-issue-implementer\` - IN THIS CASE IT'S OK TO CREATE/UPDATE ISSUE COMMENTS |
 | Deep questions (how/why something works) | \`@agent-iloom-swarm-issue-analyzer\` |
 | Code review request | \`@agent-iloom-swarm-code-reviewer\` |`;
+
+          // Append monorepo reminder if applicable
+          let swarmIsMonorepo = false;
+          let swarmCurrentPackages = [];
+          const swarmMetadataPath = getMetadataFilePath(cwd);
+          if (fs.existsSync(swarmMetadataPath)) {
+            const swarmContent = fs.readFileSync(swarmMetadataPath, 'utf8');
+            const swarmMeta = JSON.parse(swarmContent);
+            swarmIsMonorepo = swarmMeta.capabilities?.includes('monorepo') || false;
+            swarmCurrentPackages = swarmMeta.packagesToValidate || [];
+          }
+          if (swarmIsMonorepo) {
+            reminder += `\n\n**MONOREPO**: Current packages to validate: [${swarmCurrentPackages.join(', ')}]. If you are touching packages not in this list, call \`mcp__recap__set_packages_to_validate\` to update the list.`;
+          }
+
           const output = {
             hookSpecificOutput: {
               hookEventName: 'UserPromptSubmit',
@@ -360,7 +375,7 @@ async function main() {
         process.exit(0);
       }
 
-      const reminder = `**REMINDER**: You MUST USE subagents to preserve your context window for ongoing conversation.
+      let reminder = `**REMINDER**: You MUST USE subagents to preserve your context window for ongoing conversation.
 
 | Request Type | Action |
 |--------------|--------|
@@ -375,6 +390,20 @@ async function main() {
 
 Regarding creating/updating comments - if it's a trivial fix or quick answer, DO NOT create or update issue comments to avoid polluting the issue history. Only create/update comments for complex changes or new features as outlined above.`;
 
+      // Read metadata to check for monorepo capability and append reminder if applicable
+      let isMonorepo = false;
+      let currentPackages = [];
+      const metadataPath = getMetadataFilePath(cwd);
+      if (fs.existsSync(metadataPath)) {
+        const content = fs.readFileSync(metadataPath, 'utf8');
+        const metadata = JSON.parse(content);
+        isMonorepo = metadata.capabilities?.includes('monorepo') || false;
+        currentPackages = metadata.packagesToValidate || [];
+      }
+      if (isMonorepo) {
+        reminder += `\n\n**MONOREPO**: Current packages to validate: [${currentPackages.join(', ')}]. If you are touching packages not in this list, call \`mcp__recap__set_packages_to_validate\` to update the list.`;
+      }
+
       const output = {
         hookSpecificOutput: {
           hookEventName: 'UserPromptSubmit',
diff --git a/templates/prompts/init-prompt.txt b/templates/prompts/init-prompt.txt
index f2d5836f..9c1aaa74 100644
--- a/templates/prompts/init-prompt.txt
+++ b/templates/prompts/init-prompt.txt
@@ -335,6 +335,7 @@ The agent will:
 **Capabilities:**
 - `"cli"` - Command-line interface/tool (enables CLI isolation features)
 - `"web"` - Web application with dev server (enables port assignment)
+- `"monorepo"` - Monorepo with workspace packages (enables package-aware commands)
 
 **Note:** Scripts in `package.iloom.json` are raw shell commands, not npm script names. iloom will execute them directly.
 
@@ -345,6 +346,7 @@ If the framework detector did not set capabilities, or if you need to ask the us
 - Options:
   - "cli" - Command-line interface/tool
   - "web" - Web application with dev server
+  - "monorepo" - Monorepo with multiple packages/workspaces
   - "both" - Both CLI and web capabilities
   - "neither" - Library or other project type
 
diff --git a/templates/prompts/issue-prompt.txt b/templates/prompts/issue-prompt.txt
index e95ecadd..e36b450c 100644
--- a/templates/prompts/issue-prompt.txt
+++ b/templates/prompts/issue-prompt.txt
@@ -400,6 +400,9 @@ Always prepend: `"Your working directory is <worktree-path>. cd there before doi
 {{#if ARTIFACT_REVIEW_ENABLED}}{{#if ANALYZE_AND_PLAN_REVIEW_ENABLED}}
 6c. If SIMPLE: Run artifact review on combined analysis and plan output via /iloom-swarm-artifact-reviewer skill
 {{/if}}{{/if}}
+{{#if IS_MONOREPO}}
+6.5. Run monorepo package detection via /iloom-swarm-monorepo-package-detector skill to set packagesToRun and packagesToValidate
+{{/if}}
 7. Run implementation via /iloom-swarm-issue-implementer skill. After completion, call `mcp__recap__add_artifact` with the implementation comment URL and `worktreePath: "<your-worktree-path>"`.
 {{#if ARTIFACT_REVIEW_ENABLED}}{{#if IMPLEMENTER_REVIEW_ENABLED}}
 7a. Run artifact review on implementation output via /iloom-swarm-artifact-reviewer skill
@@ -450,6 +453,9 @@ You are orchestrating a set of agents through a development process, with human
 {{/if}}{{/if}}
 14. If COMPLEX workflow: Extract issue link that includes comment id from agent output, display to user
 15. If COMPLEX workflow: WAIT for human review of planning results and approval to continue
+{{#if IS_MONOREPO}}
+15.5. Run monorepo package detection using @agent-iloom-monorepo-package-detector to set packagesToRun and packagesToValidate
+{{/if}}
 16. Run issue implementation for {{ISSUE_NUMBER}} (if needed) using @agent-iloom-issue-implementer
 {{#if ARTIFACT_REVIEW_ENABLED}}{{#if IMPLEMENTER_REVIEW_ENABLED}}
 16a. Run artifact review on implementation output using @agent-iloom-artifact-reviewer
@@ -1082,6 +1088,16 @@ If workflow plan determined SKIP_PLANNING AND complexity is COMPLEX:
 
 **Execute for both SIMPLE and COMPLEX workflows**
 
+{{#if IS_MONOREPO}}
+**MONOREPO PACKAGE DETECTION (pre-implementation):**
+{{#if SWARM_MODE}}
+Before proceeding to implementation, run monorepo package detection via /iloom-swarm-monorepo-package-detector skill.
+{{else}}
+Before proceeding to implementation, run monorepo package detection using @agent-iloom-monorepo-package-detector.
+{{/if}}
+This agent will explore the workspace structure and call MCP tools to set `packagesToRun` and `packagesToValidate`.
+
+{{/if}}
 **PREREQUISITE CHECK — Do not skip this:**
 Before executing implementation, verify that a plan comment exists on the issue (either from STEP 2-SIMPLE or STEP 3). If no plan comment exists and the workflow scan determined NEEDS_PLANNING, you MUST stop and run the appropriate analyze-and-plan or planning skill before proceeding. Do not implement without a documented plan.
 
diff --git a/templates/prompts/swarm-orchestrator-prompt.txt b/templates/prompts/swarm-orchestrator-prompt.txt
index 163c0e01..c9bb5c1b 100644
--- a/templates/prompts/swarm-orchestrator-prompt.txt
+++ b/templates/prompts/swarm-orchestrator-prompt.txt
@@ -544,6 +544,28 @@ IMPORTANT: Only fix the specific issues identified in the review findings. Do NO
 
 **Single pass only.** Do NOT re-review after fixing. This prevents infinite review-fix loops.
 
+{{/if}}
+{{#if IS_MONOREPO}}
+### Step 5.2.8: Run Monorepo Package Detection
+
+Before creating the final commit, run the monorepo package detector to set `packagesToRun` and `packagesToValidate` for the integrated epic branch.
+
+**Delegate this to a subagent:**
+
+- `subagent_type`: `"iloom-swarm-monorepo-package-detector"`
+- `mode`: `"delegate"`
+- Prompt:
+
+```
+Detect monorepo packages for epic #{{EPIC_ISSUE_NUMBER}}.
+
+Working directory: {{EPIC_WORKTREE_PATH}}
+
+Explore the workspace structure and determine which packages were changed by this epic. Call the MCP tools to set packagesToRun and packagesToValidate.
+```
+
+**Error handling**: If the detection agent fails, log the warning and continue. Package detection is non-blocking.
+
 {{/if}}
 ### Step 5.3: Final Commit on Epic Branch