@fusengine/harness 0.1.30 → 0.1.32

package/dist/{handle-USWK4NSE.mjs → handle-DJqHZcml.mjs}

@@ -1,16 +1,22 @@
+import { r as resolveMaxLines } from "./limits-CHn8AIL1.mjs";
 import { r as projectLayout } from "./layout-C0jaaCQC.mjs";
-import { C as capVerbosity, F as requiredArchSkill, M as detectModularArchitecture, O as evaluateApex, a as parseEntry, b as frameworkSolidGate, c as EXCLUDE_DIRS$1, d as buildApexTaskInjection, h as buildClaudeMdContext, i as parseEnrichment, l as PROJECT_INDICATORS, s as parseField, t as descFromText, v as skillTriggerGate, w as detectCreationIntent } from "./describe-CPtgUzFS.mjs";
-import { j as detectFramework, k as countLines, n as FAIL_CLOSED, t as evaluate } from "./evaluate-j3gRJ_ng.mjs";
+import { i as walkUpFor, n as projectRoot, r as projectRootOrNull, t as isCodeFile } from "./project-root-3kk7gCOp.mjs";
+import { A as evaluateApex, E as detectCreationIntent, L as requiredArchSkill, P as detectModularArchitecture, S as frameworkSolidGate, T as capVerbosity, _ as buildClaudeMdContext, b as skillTriggerGate, c as parseBodyDesc, d as PROJECT_INDICATORS, l as parseField, n as missingSeoElements, o as parseEnrichment, p as buildApexTaskInjection, r as descFromText, s as parseEntry, t as isHtmlLike, u as EXCLUDE_DIRS$1 } from "./validate-CccewDwk.mjs";
+import { j as detectFramework, k as countLines, n as FAIL_CLOSED, t as evaluate } from "./evaluate-9ch1K2kt.mjs";
 import { t as formatPrompt } from "./types-ernB1Dy3.mjs";
+import { a as nowStamp, l as throttleMs, n as readRoots, o as readState, s as setStateField, t as addRoot } from "./registry-BkoEbdec.mjs";
 import { a as extractText, o as loadIndex, r as cacheStore, t as cacheLookup } from "./store-PrNPm6So.mjs";
-import { t as atomicWrite } from "./json-io-CAn72gI4.mjs";
+import { i as writeJsonFile, r as readJsonFile, t as atomicWrite } from "./json-io-CAn72gI4.mjs";
 import { t as loadRefs } from "./loader-CyAoJv2W.mjs";
 import { a as recordAgent, c as recordRefRead, l as recordTrivialEdit, n as saveTrack, o as recordBrainstormRequired, r as agentsFresh, s as recordDoc, t as loadTrack, u as trivialCount } from "./store-D-ge2ZPI.mjs";
-import { t as contextResponse } from "./claude-B9FYp0Yw.mjs";
+import { n as denyResponse, t as contextResponse } from "./claude-BWZcrZbS.mjs";
 import { basename, dirname, extname, join, relative, resolve, sep } from "node:path";
-import { appendFileSync, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, rmdirSync, statSync, writeFileSync } from "node:fs";
+import { appendFileSync, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, rmdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
+import { createHash } from "node:crypto";
+import { mkdir, rmdir } from "node:fs/promises";
 import { execFileSync } from "node:child_process";
+import { Glob } from "bun";
 //#region src/runtime/activity.ts
 /** Min response length (chars) for a lead agent call to count as `sufficient`. */
 const AGENT_QUALITY_MIN = 500;
@@ -1455,30 +1461,1460 @@ function generateProjectMap(cwd, outputDir) {
 	return "";
 }
 //#endregion
+//#region src/runtime/lifecycle/cartographer/detect.ts
+/**
+* Plugin discovery (fs). Ports `detect_plugins.py`: marketplace `plugins` dir
+* resolution + `plugin.json` meta reading.
+*/
+/** Sorted entry names of `dir` (alpha, byte-order), or `[]` on error. */
+function sortedNames$1(dir) {
+	try {
+		return readdirSync(dir).sort((a, b) => a.localeCompare(b, "en"));
+	} catch {
+		return [];
+	}
+}
+/**
+* Read `[version, name]` from `<pluginPath>/.claude-plugin/plugin.json`.
+* @param pluginPath - Absolute plugin directory.
+* @returns The `[version, name]` pair (both "" when absent/unreadable).
+*/
+function readPluginMeta(pluginPath) {
+	const pj = join(pluginPath, ".claude-plugin", "plugin.json");
+	if (!existsSync(pj)) return ["", ""];
+	try {
+		const meta = JSON.parse(readFileSync(pj, "utf-8"));
+		return [meta.version ?? "", meta.name ?? ""];
+	} catch {
+		return ["", ""];
+	}
+}
+/**
+* Auto-detect the marketplace `plugins` dir that contains `cartographer`,
+* falling back to the first marketplace with a `plugins` dir, else `cwd`.
+* Ports `find_marketplace_plugins`.
+* @param home - Home directory (defaults to `~`).
+* @returns The resolved plugins directory.
+*/
+function findMarketplacePlugins(home = homedir()) {
+	const mp = join(home, ".claude", "plugins", "marketplaces");
+	const markets = sortedNames$1(mp);
+	for (const m of markets) if (existsSync(join(mp, m, "plugins", "cartographer"))) return join(mp, m, "plugins");
+	for (const m of markets) if (existsSync(join(mp, m, "plugins"))) return join(mp, m, "plugins");
+	return process.cwd();
+}
+//#endregion
+//#region src/runtime/lifecycle/cartographer/scan.ts
+/**
+* Plugin scanning (fs). Ports `scan_plugins.py`: turns a plugin's
+* agents/skills/commands/hooks into ordered `[type, name, desc]` rows.
+*/
+/** Sorted entry names of `dir` (alpha, byte-order), or `[]` on error. */
+function sortedNames(dir) {
+	try {
+		return readdirSync(dir).sort((a, b) => a.localeCompare(b, "en"));
+	} catch {
+		return [];
+	}
+}
+/** Read a `.md` frontmatter field from a file path, "" when missing/unreadable. */
+function fileField(path, field) {
+	try {
+		return parseField(readFileSync(path, "utf-8"), field);
+	} catch {
+		return "";
+	}
+}
+/** Scan `agents/*.md` → `("agent", name, desc[:50])` rows. */
+function scanAgents(root) {
+	const dir = join(root, "agents");
+	return sortedNames(dir).filter((n) => extname(n) === ".md").map((n) => {
+		const f = join(dir, n);
+		return [
+			"agent",
+			fileField(f, "name") || n.replace(/\.md$/, ""),
+			fileField(f, "description").slice(0, 50)
+		];
+	});
+}
+/** Scan `skills/<dir>/SKILL.md` → `("skill", dir, desc)` rows. */
+function scanSkills(root) {
+	const dir = join(root, "skills");
+	const rows = [];
+	for (const name of sortedNames(dir)) {
+		try {
+			if (!statSync(join(dir, name)).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		const skillMd = join(dir, name, "SKILL.md");
+		let desc = "";
+		if (existsSync(skillMd)) {
+			desc = fileField(skillMd, "description");
+			if (!desc) try {
+				desc = parseBodyDesc(readFileSync(skillMd, "utf-8"));
+			} catch {}
+		}
+		rows.push([
+			"skill",
+			name,
+			desc || "(no description)"
+		]);
+	}
+	return rows;
+}
+/** Scan `commands/*.md` → `("command", "/name", desc[:50])` rows. */
+function scanCommands(root) {
+	const dir = join(root, "commands");
+	return sortedNames(dir).filter((n) => extname(n) === ".md").map((n) => [
+		"command",
+		`/${n.replace(/\.md$/, "")}`,
+		fileField(join(dir, n), "description").slice(0, 50)
+	]);
+}
+/** Scan `hooks/hooks.json` → a single `("hooks", "<events>", "")` row, or none. */
+function scanHooks(root) {
+	const file = join(root, "hooks", "hooks.json");
+	if (!existsSync(file)) return [];
+	try {
+		const raw = JSON.parse(readFileSync(file, "utf-8"));
+		const data = raw && typeof raw === "object" ? raw : {};
+		const hooks = data.hooks && typeof data.hooks === "object" ? data.hooks : data;
+		const events = Object.keys(hooks).filter((k) => !k.startsWith("_")).sort((a, b) => a.localeCompare(b, "en"));
+		return events.length ? [[
+			"hooks",
+			events.join(", "),
+			""
+		]] : [];
+	} catch {
+		return [];
+	}
+}
+/**
+* Scan a single plugin directory into ordered `[type, name, desc]` rows.
+* @param pluginDir - Absolute plugin directory.
+* @returns The agents + skills + commands + hooks rows.
+*/
+function scanPlugin(pluginDir) {
+	return [
+		...scanAgents(pluginDir),
+		...scanSkills(pluginDir),
+		...scanCommands(pluginDir),
+		...scanHooks(pluginDir)
+	];
+}
+//#endregion
+//#region src/policy/cartographer/build-tree.ts
+const SECTION_ORDER = [
+	"agent",
+	"skill",
+	"command"
+];
+/**
+* Format grouped items with tree connectors and optional markdown links.
+* Skill sections link to `./skills/<name>/index.md`; other sections to
+* `./<folder>/<name>.md`; unlinked sections render the bare name.
+* @param prefix - The line prefix (indent + branch glyphs).
+* @param items - The `[name, desc]` pairs to render.
+* @param folder - The link folder ("" disables linking).
+* @param asDirs - Whether items link to a subdirectory `index.md`.
+* @returns The rendered lines.
+*/
+function printItems(prefix, items, folder, asDirs) {
+	return items.map(([name, desc], i) => {
+		const connector = i === items.length - 1 ? "└──" : "├──";
+		const safe = name.replace(/^\/+/, "");
+		let label = name;
+		if (folder && asDirs) label = `[${name}](./${folder}/${safe}/index.md)`;
+		else if (folder) label = `[${name}](./${folder}/${safe}.md)`;
+		const short = desc && desc !== "(no description)" ? ` — ${desc.slice(0, 80)}` : "";
+		return `${prefix}${connector} ${label}${short}`;
+	});
+}
+/**
+* Build an indented tree from scanned items. The `hooks` row renders as a single
+* trailing `└── hooks: …` line; agents/skills/commands render as folder sections.
+* @param items - The scanned `[type, name, desc]` rows.
+* @param linked - When true, leaf names become markdown links.
+* @returns The joined tree text.
+*/
+function buildTree(items, linked = false) {
+	const groups = {};
+	let hooksLine = "";
+	for (const [typ, name, desc] of items) if (typ === "hooks") hooksLine = name;
+	else (groups[typ] ??= []).push([name, desc]);
+	const sections = SECTION_ORDER.filter((s) => s in groups);
+	if (hooksLine) sections.push("hooks");
+	const lines = [];
+	const total = sections.length;
+	for (let idx = 0; idx < total; idx++) {
+		const section = sections[idx] ?? "";
+		if (section === "hooks") {
+			lines.push(`└── hooks: ${hooksLine}`);
+			continue;
+		}
+		const isLast = idx === total - 1;
+		const folder = `${section}s`;
+		const prefix = isLast ? "└──" : "├──";
+		const subPrefix = isLast ? "    " : "│   ";
+		lines.push(`${prefix} ${folder}/`);
+		const linkFolder = linked ? folder : "";
+		const isDirSection = section === "skill";
+		lines.push(...printItems(subPrefix, groups[section] ?? [], linkFolder, linked && isDirSection));
+	}
+	return lines.join("\n");
+}
+//#endregion
+//#region src/runtime/lifecycle/cartographer/write-plugin-map.ts
+/**
+* Per-plugin map writer (fs). Ports `write_plugin_map.py`: writes a level-2
+* `<plugin>/index.md` (indented linked tree) then recurses agents/skills/
+* commands into deeper index trees. Reuses `buildTree`, `mergeLines`, `writeTree`.
+*/
+/** True when `dir` is a real directory. */
+function isDir(dir) {
+	try {
+		return statSync(dir).isDirectory();
+	} catch {
+		return false;
+	}
+}
+/**
+* Write `<outputDir>/<pluginName>/index.md` (indented linked tree) and recurse
+* agents/skills/commands into their own index trees rooted there.
+* @param outputDir - The map root directory.
+* @param pluginName - Display name of the plugin (the index subfolder).
+* @param version - Plugin version ("" to omit).
+* @param items - The scanned `[type, name, desc]` rows.
+* @param pluginPath - Absolute source plugin directory (for recursion).
+*/
+function writePluginMap(outputDir, pluginName, version, items, pluginPath) {
+	const pluginDir = join(outputDir, pluginName);
+	mkdirSync(pluginDir, { recursive: true });
+	const newLines = `# ${pluginName}${version ? ` (v${version})` : ""}\n\n${items.length ? buildTree(items, true) : "└── (empty)"}`.split("\n");
+	const indexPath = join(pluginDir, "index.md");
+	writeFileSync(indexPath, mergeLines(newLines, indexPath).join("\n") + "\n", "utf-8");
+	for (const section of [
+		"agents",
+		"skills",
+		"commands"
+	]) {
+		const src = join(pluginPath, section);
+		if (isDir(src)) writeTree(src, join(pluginDir, section), "../index.md");
+	}
+}
+//#endregion
+//#region src/runtime/lifecycle/cartographer/ecosystem-map.ts
+/**
+* Ecosystem (plugin) map generation (fs). Ports `generate_map.py`: scans every
+* installed plugin into a level-1 `.cartographer/index.md` + per-plugin level-2+
+* trees, preserving enriched descriptions. Reuses `findMarketplacePlugins`,
+* `readPluginMeta`, `scanPlugin`, `mergeLines`, `writePluginMap`.
+*/
+function pluginDirs(dir) {
+	let entries = [];
+	try {
+		entries = readdirSync(dir);
+	} catch {
+		return [];
+	}
+	return entries.filter((n) => !n.startsWith("_") && !n.startsWith(".")).filter((n) => {
+		try {
+			return statSync(join(dir, n)).isDirectory();
+		} catch {
+			return false;
+		}
+	}).sort((a, b) => a.localeCompare(b, "en"));
+}
+function utcStamp(now) {
+	return new Date(now).toISOString().slice(0, 16).replace("T", " ");
+}
+/**
+* Generate the plugin ecosystem map under `<pluginsDir>/.cartographer`.
+* @param now - Clock for the banner timestamp.
+* @param pluginsDirOverride - Override for the marketplace plugins directory.
+* @returns The map navigation context, or "".
+*/
+function generateEcosystemMap(now, pluginsDirOverride) {
+	const pluginsDir = resolve(pluginsDirOverride ?? findMarketplacePlugins());
+	try {
+		if (!statSync(pluginsDir).isDirectory()) return "";
+	} catch {
+		return "";
+	}
+	const outputDir = join(pluginsDir, ".cartographer");
+	mkdirSync(outputDir, { recursive: true });
+	const dirs = pluginDirs(pluginsDir);
+	const lines = [`# Ecosystem Map (${dirs.length} plugins)\n`, `> Auto-generated by cartographer — ${utcStamp(now)}\n`];
+	for (const name of dirs) {
+		const pluginPath = join(pluginsDir, name);
+		const [version, pkgName] = readPluginMeta(pluginPath);
+		const display = pkgName || name;
+		const items = scanPlugin(pluginPath);
+		const agents = items.filter(([t]) => t === "agent").map(([, n]) => n);
+		const ver = version ? ` (v${version})` : "";
+		lines.push(`- [${display}](./${display}/index.md)${ver} → ${agents.length ? agents.join(", ") : "(no agents)"}`);
+		writePluginMap(outputDir, display, version, items, pluginPath);
+		writePluginMap(pluginPath, ".cartographer", version, items, pluginPath);
+	}
+	const indexPath = join(outputDir, "index.md");
+	writeFileSync(indexPath, mergeLines(lines, indexPath).join("\n") + "\n", "utf-8");
+	return `Project map: .cartographer/project/index.md — navigate project files. Plugin skills map: ${outputDir}/index.md — navigate agent skills. Branches link to deeper index.md, leaves link to real files.`;
+}
+//#endregion
 //#region src/runtime/lifecycle/cartographer/session-start.ts
 /**
-* Cartographer SessionStart handler. Ports the project-map half of
-* `generate_project_map.py`: regenerates `.cartographer/project` and emits no
-* additionalContext (the plugin ecosystem map from `generate_map.py` is not
-* ported and stays as Python).
+* Cartographer SessionStart handler. Ports BOTH halves of the Python maps:
+* `generate_project_map.py` (regenerate `.cartographer/project`) and
+* `generate_map.py` (regenerate the plugin ecosystem map), emitting the
+* navigation context from the latter as additionalContext.
 */
 /**
-* Regenerate the project map for `cwd` on SessionStart. Returns "" (side-effect
-* only — no additionalContext).
+* Regenerate the project map + plugin ecosystem map for `cwd` on SessionStart.
+* Emits the ecosystem navigation context as additionalContext (or "").
 * @param cwd - The working directory.
-* @returns "" always.
+* @param now - Clock for the ecosystem map banner timestamp.
+* @returns The SessionStart additionalContext response, or "".
 */
-function cartoSessionStart(cwd) {
+function cartoSessionStart(cwd, now = Date.now()) {
 	generateProjectMap(cwd);
+	const ctx = generateEcosystemMap(now);
+	return ctx ? contextResponse("SessionStart", ctx) : "";
+}
+//#endregion
+//#region src/runtime/lifecycle/lessons/state.ts
+/**
+* Per-project lessons paths. The `fuse-lessons` plugin stores its lessons under
+* `<root>/MEMORY/` (NOT the harness `.harness/memory/`), so these two path
+* helpers override the layout while ALL state/gitignore/throttle logic is
+* reused from `src/memory` (`setStateField`, `ensureMemoryGitignore`,
+* `readState`, `nowStamp`, `throttleMs`).
+*/
+/** Absolute `<root>/MEMORY/LESSON.md` — the curated, committable lessons file. */
+function lessonsFileFor(root) {
+	return join(root, "MEMORY", "LESSON.md");
+}
+/** Absolute `<root>/MEMORY/state.json` — machine-local throttle counter. */
+function lessonsStateFileFor(root) {
+	return join(root, "MEMORY", "state.json");
+}
+//#endregion
+//#region src/runtime/lifecycle/lessons/dispatch.ts
+/**
+* fuse-lessons scope dispatch (TS port of the 4 handler scripts). Routes by
+* event: SessionStart/SubagentStart inject `MEMORY/LESSON.md`; Stop reminds
+* across every project with unsaved code edits; PostToolUse marks the write to
+* arm/silence the per-project throttle. Non-fatal by design.
+*/
+/** Inject `<root>/MEMORY/LESSON.md` as additionalContext for `event`. */
+function injectMemory(cwd, event) {
+	const file = lessonsFileFor(projectRoot(cwd));
+	if (!existsSync(file)) return "";
+	let content = "";
+	try {
+		content = readFileSync(file, "utf-8").trim();
+	} catch {
+		return "";
+	}
+	if (!content) return "";
+	return contextResponse(event, `Project lessons — never reproduce these:\n${content}\nYou may append OR refine/merge/dedupe bullets in MEMORY/LESSON.md — keep it terse.`);
+}
+/** Select roots with unsaved code edits past the throttle, bumping their state. */
+function collectPending(now, window) {
+	const pending = [];
+	for (const root of readRoots()) {
+		const stateFile = lessonsStateFileFor(root);
+		const { lastRemindedAt, lastCodeEditAt } = readState(stateFile);
+		if (lastCodeEditAt <= lastRemindedAt) continue;
+		if (now - lastRemindedAt < window) continue;
+		pending.push(root);
+		setStateField(stateFile, "lastRemindedAt", now);
+	}
+	return pending;
+}
+/** Stop: emit one reminder covering every project with pending lessons. */
+function remindWrite(now) {
+	const pending = collectPending(now, throttleMs());
+	if (pending.length === 0) return "";
+	return contextResponse("Stop", `Before ending: if this session hit a mistake/blocker worth never reproducing, append 1-3 COMPACT bullets OR sharpen/merge existing ones (format \`- [${nowStamp()}] what went wrong → do instead\`, use exactly this timestamp) in each project's lessons file below. Skip if nothing notable.\n${pending.map((r) => `- ${r}/MEMORY/LESSON.md`).join("\n")}`);
+}
+/** PostToolUse: record the relevant throttle timestamp for the edited file. */
+function markWrite(payload, now) {
+	const input = payload.tool_input;
+	if (!input?.file_path) return;
+	const abs = resolve(input.file_path);
+	const root = projectRootOrNull(dirname(abs));
+	if (!root) return;
+	const stateFile = lessonsStateFileFor(root);
+	if (abs === resolve(root, "MEMORY", "LESSON.md")) setStateField(stateFile, "lastRemindedAt", now);
+	else if (isCodeFile(abs)) {
+		setStateField(stateFile, "lastCodeEditAt", now);
+		addRoot(root);
+	}
+}
+/**
+* Route a fuse-lessons event to its handler. Returns the native stdout for
+* context-injecting events (SessionStart/SubagentStart/Stop) or "" for the
+* side-effect-only PostToolUse mark.
+* @param event - The raw hook event name.
+* @param payload - The raw hook payload.
+* @param cwd - Project root for memory injection.
+* @param now - Clock.
+* @returns The native stdout (possibly empty).
+*/
+function dispatchLessons(event, payload, cwd, now) {
+	switch (event) {
+		case "SessionStart":
+		case "SubagentStart": return injectMemory(cwd, event);
+		case "Stop": return remindWrite(now);
+		case "PostToolUse":
+			markWrite(payload, now);
+			return "";
+		default: return "";
+	}
+}
+//#endregion
+//#region src/runtime/lifecycle/aipilot/inject-apex.ts
+/**
+* SubagentStart (matcher "") for the ai-pilot scope: inject APEX AGENTS.md +
+* task context + cartographer paths into every sub-agent. Ports
+* `inject-subagent-context.ts`. The core-scope SubagentStart already surfaces
+* the MCP cache table (`subagent-cache.ts`) in a separate hook entry — this
+* handler only emits the APEX/cartographer block, so there is no double-emit.
+*/
+/** Last 3 completed task subjects (newest first), or "none". */
+function completedTasks(tasks) {
+	const done = Object.entries(tasks).filter(([, t]) => t.status === "completed").sort((a, b) => (b[1].completed_at ?? "").localeCompare(a[1].completed_at ?? "")).slice(0, 3).map(([id, t]) => `#${id}: ${t.subject}`);
+	return done.length > 0 ? done.join(", ") : "none";
+}
+/** Pending task subjects, or "none". */
+function pendingTasks(tasks) {
+	const pending = Object.entries(tasks).filter(([, t]) => t.status === "pending").map(([id, t]) => `#${id}: ${t.subject}`);
+	return pending.length > 0 ? pending.join(", ") : "none";
+}
+/** Cartographer navigation block, or "" when no plugin map is present. */
+function cartographerContext() {
+	const pluginRoot = process.env.CLAUDE_PLUGIN_ROOT;
+	if (!pluginRoot) return "";
+	const pluginsMap = resolve(pluginRoot, "..", ".cartographer", "index.md");
+	if (!existsSync(pluginsMap)) return "";
+	return `\n### 7. Cartographer Maps\nNavigate branches (index.md) -> leaves link to real files:\n- Plugin skills: ${pluginsMap}\n- Project files: .cartographer/project/index.md`;
+}
+/**
+* Build the APEX sub-agent injection for SubagentStart, or "" when the project
+* has no `.claude/apex/` dir. Reads AGENTS.md (first 4KB) + task.json.
+* @param cwd - Fallback project root when `CLAUDE_PROJECT_DIR` is unset.
+* @param home - Home dir (unused placeholder; kept for symmetry/testing).
+* @returns The native hook stdout (possibly empty).
+*/
+async function injectApexSubagentContext(cwd, home = homedir()) {
+	const apexDir = join(process.env.CLAUDE_PROJECT_DIR ?? cwd, ".claude", "apex");
+	if (!existsSync(apexDir)) return "";
+	const agentsFile = Bun.file(join(apexDir, "AGENTS.md"));
+	const agents = await agentsFile.exists() ? (await agentsFile.text()).slice(0, 4e3) : "";
+	const taskData = await readJsonFile(join(apexDir, "task.json"));
+	return contextResponse("SubagentStart", `## APEX Sub-Agent Instructions
+
+You are a sub-agent in APEX workflow. Follow these rules:
+
+### 1. AGENTS.md Rules
+${agents}
+
+### 2. Task Context
+- Last completed: ${taskData ? completedTasks(taskData.tasks) : "none"}
+- Pending: ${taskData ? pendingTasks(taskData.tasks) : "none"}
+
+### 3. Before Starting Work
+- Use TaskUpdate(taskId, status: in_progress) before starting
+
+### 4. SOLID Rules
+- Files < ${resolveMaxLines()} lines | Interfaces in src/interfaces/ | JSDoc/PHPDoc required
+
+### 5. Research Before Code
+- Use Context7/Exa for docs | Write notes to .claude/apex/docs/
+
+### 6. When Done
+- TaskUpdate(taskId, status: completed) triggers auto-commit${cartographerContext()}`);
+}
+//#endregion
+//#region src/runtime/lifecycle/aipilot/cache-base.ts
+/**
+* Shared cache-path + age helpers for the ai-pilot scope.
+* Reuses the harness home-state (`fusengineCache`) so the ai-pilot caches live
+* under the same `~/.claude/fusengine-cache` tree as the core MCP cache — no
+* second cache layer.
+*/
+/** 16-char hex SHA-256 of `text` (project hash / doc topic key). */
+function hashText16(text) {
+	return createHash("sha256").update(text).digest("hex").slice(0, 16);
+}
+/** 16-char project hash from its absolute path. */
+function projectHash(projectPath) {
+	return hashText16(projectPath);
+}
+/** `~/.claude/fusengine-cache` base dir (shared with the core MCP cache). */
+function cacheBaseDir(home = homedir()) {
+	return fusengineCache(home);
+}
+/** Per-type, per-project cache dir: `fusengine-cache/<type>/<projectHash>`. */
+function cacheDirFor(type, projectPath, home = homedir()) {
+	return join(cacheBaseDir(home), type, projectHash(projectPath));
+}
+/** Age in seconds from an ISO timestamp (now - ts). */
+function cacheAge(ts, now = Date.now()) {
+	return Math.floor((now - new Date(ts).getTime()) / 1e3);
+}
+/** Full SHA-256 hex checksum of a file's text; "" when unreadable. */
+async function fileChecksum(path) {
+	try {
+		return createHash("sha256").update(await Bun.file(path).text()).digest("hex");
+	} catch {
+		return "";
+	}
+}
+//#endregion
+//#region src/runtime/lifecycle/aipilot/analytics.ts
+/**
+* Cache analytics for the ai-pilot scope: append hit/miss events to
+* `sessions.jsonl` and aggregate them into `summary.json` on SessionEnd.
+* Ports `cache-analytics-save.ts` + the `logCacheEvent` helper.
+*/
+const TOKEN_WEIGHTS = {
+	explore: 15e3,
+	doc: 1e4,
+	lessons: 3e3,
+	tests: 5e3
+};
+const CATEGORIES = [
+	"explore",
+	"doc",
+	"lessons",
+	"tests"
+];
+/** Append a single cache event to `analytics/sessions.jsonl` (best effort). */
+function logCacheEvent(type, action, projHash, extra = {}, home = homedir()) {
+	try {
+		const dir = join(cacheBaseDir(home), "analytics");
+		mkdirSync(dir, { recursive: true });
+		const entry = {
+			ts: (/* @__PURE__ */ new Date()).toISOString(),
+			session: String(Math.floor(Date.now() / 1e3)),
+			type,
+			action,
+			project_hash: projHash,
+			...extra
+		};
+		appendFileSync(join(dir, "sessions.jsonl"), JSON.stringify(entry) + "\n");
+	} catch {}
+}
+/** Count entries matching a `type`+`action`. */
+function countBy(entries, type, action) {
+	return entries.filter((e) => e.type === type && e.action === action).length;
+}
+/** Format a hit-rate percentage string. */
+function hitRate(hits, misses) {
+	const total = hits + misses;
+	return total === 0 ? "0%" : `${Math.floor(hits * 100 / total)}%`;
+}
+/** Parse the JSONL session log into typed entries. */
+function parseEntries(raw) {
+	return raw.split("\n").filter(Boolean).map((line) => {
+		try {
+			return JSON.parse(line);
+		} catch {
+			return null;
+		}
+	}).filter((e) => e !== null);
+}
+/**
+* Aggregate `sessions.jsonl` into `summary.json` and prune entries > 30 days.
+* Ports `cache-analytics-save.ts`. SessionEnd hook output is ignored by Claude,
+* so this returns nothing — it is a pure side-effect.
+* @param home - Home dir (defaults to `~`).
+* @param now - Clock (defaults to `Date.now()`).
+*/
+async function cacheAnalyticsSave(home = homedir(), now = Date.now()) {
+	const dir = join(cacheBaseDir(home), "analytics");
+	const sessionsFile = join(dir, "sessions.jsonl");
+	const file = Bun.file(sessionsFile);
+	if (!await file.exists()) return;
+	const raw = await file.text();
+	if (!raw.trim()) return;
+	const entries = parseEntries(raw);
+	if (entries.length === 0) return;
+	const hits = {};
+	const misses = {};
+	for (const cat of CATEGORIES) {
+		hits[cat] = countBy(entries, cat, "hit") + (cat === "doc" ? countBy(entries, cat, "blocked") : 0);
+		misses[cat] = countBy(entries, cat, "miss");
+	}
+	const tokensSaved = CATEGORIES.reduce((sum, c) => sum + (hits[c] ?? 0) * (TOKEN_WEIGHTS[c] ?? 0), 0);
+	const sessionCount = new Set(entries.map((e) => e.session).filter(Boolean)).size;
+	const old = await readJsonFile(join(dir, "summary.json"));
+	const merged = {
+		updated: new Date(now).toISOString(),
+		total_sessions: (old?.total_sessions ?? 0) + sessionCount,
+		cache_hits: {},
+		cache_misses: {},
+		hit_rates: {},
+		estimated_tokens_saved: (old?.estimated_tokens_saved ?? 0) + tokensSaved
+	};
+	for (const cat of CATEGORIES) {
+		merged.cache_hits[cat] = (old?.cache_hits?.[cat] ?? 0) + (hits[cat] ?? 0);
+		merged.cache_misses[cat] = (old?.cache_misses?.[cat] ?? 0) + (misses[cat] ?? 0);
+		merged.hit_rates[cat] = hitRate(merged.cache_hits[cat] ?? 0, merged.cache_misses[cat] ?? 0);
+	}
+	await writeJsonFile(join(dir, "summary.json"), merged, true);
+	const cutoff = (/* @__PURE__ */ new Date(now - 30 * 864e5)).toISOString();
+	const kept = entries.filter((e) => e.ts >= cutoff);
+	await Bun.write(sessionsFile, kept.map((e) => JSON.stringify(e)).join("\n") + "\n");
+}
+//#endregion
+//#region src/runtime/lifecycle/aipilot/inject-explore.ts
+/**
+* SubagentStart (matcher "explore-codebase") for the ai-pilot scope: serve a
+* cached architecture report when fresh + config-matching, else inject save
+* instructions. Ports `explore-cache-check.ts`.
+*/
+const TTL_SECONDS$2 = 86400;
+const CONFIG_FILES = [
+	"package.json",
+	"tsconfig.json",
+	"composer.json",
+	"go.mod",
+	"Cargo.toml",
+	"Package.swift",
+	"biome.json",
+	".eslintrc.js",
+	".eslintrc.json"
+];
+/** Compute a config hash from git-tracked config files; "noconfig" on failure. */
+async function configHash(cwd) {
+	try {
+		const proc = Bun.spawn([
+			"git",
+			"ls-tree",
+			"HEAD",
+			...CONFIG_FILES
+		], {
+			cwd,
+			stdout: "pipe",
+			stderr: "ignore"
+		});
+		const output = await new Response(proc.stdout).text();
+		return output.trim() ? hashText16(output) : "noconfig";
+	} catch {
+		return "noconfig";
+	}
+}
+/** Build the cache-miss save-instructions block. */
+function missBlock(cacheDir, metaFile, snapFile, ts, cfgHash, projPath) {
+	return `## EXPLORATION CACHE INSTRUCTIONS\nAfter completing your exploration, save the report for future runs:\n\`\`\`bash\nmkdir -p ${cacheDir}\ncat > ${metaFile} << 'METAEOF'\n{"timestamp":"${ts}","config_hash":"${cfgHash}","project":"${projPath}"}\nMETAEOF\n\`\`\`\nThen write your full exploration report (markdown) to: ${snapFile}`;
+}
+/**
+* SubagentStart for explore-codebase: inject cached architecture or save block.
+* @param cwd - Fallback project root (uses `CLAUDE_PROJECT_DIR` first).
+* @param home - Home dir (defaults to `~`).
+* @param now - Clock (defaults to `Date.now()`).
+* @returns The native hook stdout.
+*/
+async function injectExploreCache(cwd, home = homedir(), now = Date.now()) {
+	const projPath = process.env.CLAUDE_PROJECT_DIR ?? cwd;
+	const pHash = projectHash(projPath);
+	const cacheDir = cacheDirFor("explore", projPath, home);
+	const metaFile = join(cacheDir, "metadata.json");
+	const snapFile = join(cacheDir, "snapshot.md");
+	const cfgHash = await configHash(projPath);
+	let context = "";
+	const meta = await readJsonFile(metaFile);
+	const snapBunFile = Bun.file(snapFile);
+	const snapshot = await snapBunFile.exists() ? await snapBunFile.text() : "";
+	if (meta?.timestamp && snapshot) {
+		const age = cacheAge(meta.timestamp, now);
+		if (age < TTL_SECONDS$2 && meta.config_hash === cfgHash) {
+			context = `## CACHED ARCHITECTURE AVAILABLE (age: ${Math.floor(age / 60)}min)\nUSE this cached report. Do NOT run full exploration. Return it immediately.\n\n${snapshot}`;
+			logCacheEvent("explore", "hit", pHash, {}, home);
+		}
+	}
+	if (!context) {
+		logCacheEvent("explore", "miss", pHash, {}, home);
+		context = missBlock(cacheDir, metaFile, snapFile, new Date(now).toISOString().replace(/\.\d+Z$/, ""), cfgHash, projPath);
+	}
+	return contextResponse("SubagentStart", context);
+}
+//#endregion
+//#region src/runtime/lifecycle/aipilot/inject-doc.ts
+/**
+* SubagentStart (matcher "research-expert") for the ai-pilot scope: inject
+* cached documentation summaries. Ports `doc-cache-inject.ts`. Doc *saving*
+* happens on SubagentStop (`cache-doc.ts`).
+*/
+const TTL_SECONDS$1 = 604800;
+const MAX_SIZE = 8192;
+/** Concatenate fresh, dedup-by-hash cached doc bodies. */
+async function buildDocsContext(entries, docsDir, now) {
+	let ctx = "";
+	let count = 0;
+	let maxAge = 0;
+	const seen = /* @__PURE__ */ new Set();
+	for (const entry of entries) {
+		if (!entry.timestamp) continue;
+		const age = cacheAge(entry.timestamp, now);
+		if (age >= TTL_SECONDS$1) continue;
+		if (age > maxAge) maxAge = age;
+		if (!entry.hash || seen.has(entry.hash)) continue;
+		seen.add(entry.hash);
+		const file = Bun.file(join(docsDir, `${entry.hash}.md`));
+		if (!await file.exists()) continue;
+		const content = await file.text();
+		if (!content) continue;
+		ctx += `\n${content}\n`;
+		count++;
+	}
+	return {
+		ctx,
+		count,
+		maxAge
+	};
+}
+/**
+* SubagentStart for research-expert: inject cached doc summaries, or "".
+* @param cwd - Fallback project root (uses `CLAUDE_PROJECT_DIR` first).
+* @param home - Home dir (defaults to `~`).
+* @param now - Clock (defaults to `Date.now()`).
+* @returns The native hook stdout (possibly empty).
+*/
+async function injectDocCache(cwd, home = homedir(), now = Date.now()) {
+	const projPath = process.env.CLAUDE_PROJECT_DIR ?? cwd;
+	const pHash = projectHash(projPath);
+	const cacheDir = cacheDirFor("doc", projPath, home);
+	const index = await readJsonFile(join(cacheDir, "index.json"));
+	if (!index?.docs?.length) return "";
+	const { ctx, count, maxAge } = await buildDocsContext(index.docs, join(cacheDir, "docs"), now);
+	if (count === 0) return "";
+	logCacheEvent("doc", "hit", pHash, { docs_injected: count }, home);
+	return contextResponse("SubagentStart", `${`## CACHED DOCUMENTATION (${count} docs, ${Math.ceil(maxAge / 3600)}h ago)\nUse this knowledge. Only query Context7 for topics NOT covered below.\n`}${ctx}Full docs: ${join(cacheDir, "docs")}/`.slice(0, MAX_SIZE));
+}
+//#endregion
+//#region src/runtime/lifecycle/aipilot/source-scan.ts
+/**
+* Source-file scanning + project-stack detection for the ai-pilot scope.
+* Ported from the ai-pilot plugin's `cache/source-collector.ts` +
+* the stack detection in `cache/lesson-helpers.ts` (now removed).
+*/
+/** Source file glob patterns (monorepo-aware; separate to avoid brace-wildcards). */
+const SRC_PATTERNS = [
+	"src/**/*.{ts,tsx,js,jsx}",
+	"app/**/*.{ts,tsx,js,jsx}",
+	"apps/*/src/**/*.{ts,tsx,js,jsx}",
+	"packages/*/src/**/*.{ts,tsx,js,jsx}"
+];
+/**
+* Scan source files in `projectPath` (monorepo-aware), capped at `maxFiles`.
+* @param projectPath - Absolute project root.
+* @param maxFiles - Max files to collect (default 200).
+* @returns Absolute paths matching the source patterns.
+*/
+async function scanSourceFiles(projectPath, maxFiles = 200) {
+	const files = [];
+	for (const pattern of SRC_PATTERNS) {
+		try {
+			for await (const p of new Glob(pattern).scan({
+				cwd: projectPath,
+				absolute: true
+			})) {
+				if (p.includes("node_modules")) continue;
+				files.push(p);
+				if (files.length >= maxFiles) break;
+			}
+		} catch {}
+		if (files.length >= maxFiles) break;
+	}
+	return files;
+}
+/** Detect the project stack from config files in the project root. */
+function detectStack(projectPath) {
+	try {
+		const entries = readdirSync(projectPath);
+		if (entries.some((f) => f.startsWith("next.config"))) return "nextjs";
+		if (entries.includes("composer.json")) return "laravel";
+		if (entries.some((f) => f.endsWith(".xcodeproj")) || entries.includes("Package.swift")) return "swift";
+		if (entries.some((f) => f.startsWith("tailwind.config"))) return "tailwindcss";
+	} catch {}
+	return "universal";
+}
+//#endregion
+//#region src/runtime/lifecycle/aipilot/lessons.ts
+/**
+* Lesson aggregation, dedup, merge, and edit categorization for the ai-pilot
+* scope. Ported from the ai-pilot plugin's `cache/lesson-aggregator.ts` +
+* `cache/lesson-helpers.ts` (now removed).
+*/
+/** Deduplicate lessons by `error_type:pattern`, summing counts. */
+function dedupLessons(lessons) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const l of lessons) {
+		const key = `${l.error_type}:${l.pattern}`;
+		const group = groups.get(key);
+		if (group) group.push(l);
+		else groups.set(key, [l]);
+	}
+	return [...groups.values()].map((entries) => {
+		const first = entries[0];
+		return {
+			error_type: first.error_type,
+			pattern: first.pattern,
+			fix: first.fix,
+			last_seen: first.last_seen,
+			count: entries.reduce((s, e) => s + e.count, 0),
+			files: [...new Set(entries.flatMap((e) => e.files))],
+			code: { line: [...new Set(entries.flatMap((e) => e.code?.line ?? []))].slice(0, 5) }
+		};
+	}).sort((a, b) => b.count - a.count);
+}
+/** Aggregate all local lesson JSON files into a flat deduplicated list. */
+async function aggregateLocalLessons(cacheDir) {
+	if (!existsSync(cacheDir)) return [];
+	const files = readdirSync(cacheDir).filter((f) => f.endsWith(".json"));
+	const all = [];
+	for (const f of files) {
+		const data = await readJsonFile(join(cacheDir, f));
+		if (data?.errors) all.push(...data.errors);
+	}
+	return dedupLessons(all);
+}
+/** Load global lessons for a stack (stack-specific + universal). */
+async function loadGlobalLessons(stack, home = homedir()) {
+	const globalDir = join(cacheBaseDir(home), "lessons", "_global");
+	const result = [];
+	for (const name of [`${stack}.json`, "universal.json"]) {
+		const data = await readJsonFile(join(globalDir, name));
+		if (data) result.push(...data);
+	}
+	return result;
+}
+/** Merge local + global lessons, dedup by type+pattern, sort by count desc. */
+function mergeLessons(local, global) {
+	return dedupLessons([...local, ...global]);
+}
+/** Categorize an edit entry by analyzing the new code content. */
+function categorizeEdit(edit) {
+	const n = edit.newStr.toLowerCase();
+	if (n.includes("use client")) return "missing_directive";
+	if (n.includes("displayname")) return "missing_display_name";
+	if (/onkeydown|tabindex|role=/.test(n)) return "missing_a11y";
+	if (/try|catch/.test(n)) return "missing_error_handling";
+	if (/\?\?|if.*null/.test(n)) return "null_safety";
+	return "code_fix";
+}
+//#endregion
+//#region src/runtime/lifecycle/aipilot/inject-lessons.ts
+/**
+* SubagentStart (matcher "") for the ai-pilot scope: inject cached lessons
+* (known project issues) into every agent. Ports `lessons-cache-inject.ts`.
+*/
+const MAX_AGE_MS = 30 * 864e5;
+const MAX_LESSONS = 10;
+/** Remove JSON files older than 30 days from `dir` (best effort). */
+function pruneOldFiles(dir, now) {
+	try {
+		const cutoff = now - MAX_AGE_MS;
+		for (const f of readdirSync(dir).filter((n) => n.endsWith(".json"))) {
+			const path = `${dir}/${f}`;
+			try {
+				if (statSync(path).mtimeMs < cutoff) unlinkSync(path);
+			} catch {}
+		}
+	} catch {}
+}
+/** Render lessons as a numbered known-issues list. */
+function formatLessonList(lessons) {
+	return lessons.map((l, i) => {
+		const code = l.code?.line?.length ? `\n     Code: ${l.code.line.join(" | ").slice(0, 200)}` : "";
+		return `${i + 1}. [${l.count}x] | ${l.pattern ?? "unknown"} -> ${l.fix ?? "see docs"}${code}`;
+	}).join("\n");
+}
+/**
+* SubagentStart lessons injection: aggregate local + global lessons, or "".
+* @param cwd - Fallback project root (uses `CLAUDE_PROJECT_DIR` first).
+* @param home - Home dir (defaults to `~`).
+* @param now - Clock (defaults to `Date.now()`).
+* @returns The native hook stdout (possibly empty).
+*/
+async function injectLessonsCache(cwd, home = homedir(), now = Date.now()) {
+	const projectPath = process.env.CLAUDE_PROJECT_DIR ?? cwd;
+	const pHash = projectHash(projectPath);
+	const cacheDir = cacheDirFor("lessons", projectPath, home);
+	const stack = detectStack(projectPath);
+	pruneOldFiles(cacheDir, now);
+	let localLessons = [];
+	try {
+		localLessons = await aggregateLocalLessons(cacheDir);
+	} catch {}
+	const globalLessons = await loadGlobalLessons(stack, home);
+	if (localLessons.length === 0 && globalLessons.length === 0) return "";
+	const merged = mergeLessons(localLessons, globalLessons).slice(0, MAX_LESSONS);
+	if (merged.length === 0) return "";
+	logCacheEvent("lessons", "hit", pHash, {
+		count: merged.length,
+		stack
+	}, home);
+	return contextResponse("SubagentStart", `## KNOWN PROJECT ISSUES (from previous sniper validations)\nThese errors have been found and fixed before. AVOID them:\n${formatLessonList(merged)}\n\nINSTRUCTION: Check your code against these known issues BEFORE submitting.`);
+}
+//#endregion
+//#region src/runtime/lifecycle/aipilot/inject-test.ts
+/**
+* SubagentStart (matcher "sniper") for the ai-pilot scope: tell sniper which
+* source files changed vs. already-validated. Ports `test-cache-inject.ts`.
+*/
+const TTL_SECONDS = 172800;
+/**
+* SubagentStart for sniper: inject the changed-file list, or "" when nothing
+* useful to say (no cache / no unchanged files).
+* @param cwd - Fallback project root (uses `CLAUDE_PROJECT_DIR` first).
+* @param home - Home dir (defaults to `~`).
+* @param now - Clock (defaults to `Date.now()`).
+* @returns The native hook stdout (possibly empty).
+*/
+async function injectTestCache(cwd, home = homedir(), now = Date.now()) {
+	const projectPath = process.env.CLAUDE_PROJECT_DIR ?? cwd;
+	const cache = await readJsonFile(join(cacheDirFor("tests", projectPath, home), "results.json"));
+	if (!cache?.files || Object.keys(cache.files).length === 0) return "";
+	const srcFiles = await scanSourceFiles(projectPath);
+	if (srcFiles.length === 0) return "";
+	const changed = [];
+	let unchanged = 0;
+	for (const filepath of srcFiles) {
+		const relPath = filepath.replace(`${projectPath}/`, "");
+		const cached = cache.files[relPath];
+		if (!cached) {
+			changed.push(relPath);
+			continue;
+		}
+		if ((await fileChecksum(filepath)).slice(0, 16) !== cached.checksum) {
+			changed.push(relPath);
+			continue;
+		}
+		if (cached.last_tested && cacheAge(cached.last_tested, now) > TTL_SECONDS) {
+			changed.push(relPath);
+			continue;
+		}
+		unchanged++;
+	}
+	if (unchanged === 0) return "";
+	const changedList = changed.map((f) => `- ${f}`).join("\n");
+	return contextResponse("SubagentStart", `## TEST CACHE (${unchanged}/${srcFiles.length} files already validated)\nOnly run linters on these CHANGED files:\n${changedList}\nSKIP linting on ${unchanged} unchanged files - already PASS.`);
+}
+//#endregion
+//#region src/runtime/lifecycle/aipilot/transcript.ts
+/**
+* JSONL transcript parsing helpers for the ai-pilot scope: project-root
+* detection from file paths, file-path extraction, Edit extraction, and the
+* assistant report extraction. Ported into the harness from the ai-pilot
+* plugin's `cache/project-detect.ts` + `cache/lesson-helpers.ts` (now removed).
+*/
+const ROOT_MARKERS = [
+	".git",
+	".hg",
+	"turbo.json",
+	"nx.json",
+	"lerna.json",
+	"pnpm-workspace.yaml"
+];
+const PKG_MARKERS = [
+	"package.json",
+	"composer.json",
+	"Package.swift",
+	"Cargo.toml",
+	"go.mod",
+	"pyproject.toml",
+	"Gemfile",
+	"pom.xml"
+];
+/** Detect the project root by walking up from the first file path to a marker. */
+function projectRootFromPaths(filePaths) {
+	const firstPath = filePaths[0];
+	if (!firstPath) return null;
+	const lastSlash = firstPath.lastIndexOf("/");
+	if (lastSlash <= 0) return null;
+	let dir = firstPath.substring(0, lastSlash);
+	let bestRoot = null;
+	while (dir && dir !== "/" && dir.length > 1) {
+		try {
+			const entries = readdirSync(dir);
+			if (ROOT_MARKERS.some((m) => entries.includes(m))) return dir;
+			if (PKG_MARKERS.some((m) => entries.includes(m))) bestRoot = dir;
+		} catch {
+			break;
+		}
+		const parentSlash = dir.lastIndexOf("/");
+		if (parentSlash <= 0) break;
+		dir = dir.substring(0, parentSlash);
+	}
+	return bestRoot;
+}
+/** Extract all absolute file paths from tool_use entries in a JSONL transcript. */
+async function transcriptFilePaths(transcriptPath) {
+	const text = await Bun.file(transcriptPath).text();
+	const paths = /* @__PURE__ */ new Set();
+	for (const line of text.split("\n").filter(Boolean)) try {
+		const content = JSON.parse(line)?.message?.content;
+		if (!Array.isArray(content)) continue;
+		for (const block of content) {
+			if (block?.type !== "tool_use") continue;
+			const fp = block.input?.file_path ?? block.input?.path ?? "";
+			if (typeof fp === "string" && fp.startsWith("/")) paths.add(fp);
+		}
+	} catch {}
+	return [...paths];
+}
+/** Extract deduplicated Edit tool_use entries (keyed by basename) from a transcript. */
+async function transcriptEdits(transcriptPath) {
+	const text = await Bun.file(transcriptPath).text();
+	const edits = [];
+	for (const line of text.split("\n").filter(Boolean)) try {
+		const content = JSON.parse(line)?.message?.content;
+		if (!Array.isArray(content)) continue;
+		for (const block of content) if (block?.type === "tool_use" && block.name === "Edit" && block.input?.file_path) edits.push({
+			file: block.input.file_path,
+			oldStr: block.input.old_string ?? "",
+			newStr: block.input.new_string ?? ""
+		});
+	} catch {}
+	const seen = /* @__PURE__ */ new Map();
+	for (const e of edits) seen.set(e.file.split("/").pop() ?? e.file, e);
+	return [...seen.values()];
+}
+/** Extract the last assistant text report (first 500 lines) from a transcript. */
+async function transcriptReport(transcriptPath) {
+	const text = await Bun.file(transcriptPath).text();
+	let lastReport = "";
+	for (const line of text.split("\n").filter(Boolean)) try {
+		const entry = JSON.parse(line);
+		if (entry?.message?.role !== "assistant") continue;
+		for (const block of entry.message.content ?? []) if (block.type === "text" && block.text) lastReport = block.text;
+	} catch {}
+	return lastReport.split("\n").slice(0, 500).join("\n");
+}
+//#endregion
+//#region src/runtime/lifecycle/aipilot/cache-doc.ts
+/**
+* SubagentStop (matcher "research-expert") for the ai-pilot scope: extract the
+* agent's synthesis text from the transcript and cache it as documentation.
+* Ports `cache-doc-from-transcript.ts`. SubagentStop output here is a pure
+* side-effect (no stdout needed).
+*/
+const TOOL_PATTERN = /context7__query-docs|exa__get_code_context|exa__web_search/;
+const MAX_DOC_SIZE = 20480;
+const MIN_TEXT_SIZE = 200;
+const MAX_DOCS = 15;
+const RETRY_DELAYS = [
+	500,
+	1e3,
+	2e3
+];
+/** Extract the longest assistant synthesis + queried library ids from a transcript. */
+async function extractSynthesis(path) {
+	const lines = (await Bun.file(path).text()).split("\n").filter(Boolean);
+	const libraries = [];
+	let synthesis = "";
+	for (const line of lines) try {
+		const entry = JSON.parse(line);
+		const role = entry?.type ?? entry?.role;
+		const contents = entry?.message?.content;
+		if (!Array.isArray(contents)) continue;
+		for (const block of contents) {
+			if (block.type === "tool_use" && TOOL_PATTERN.test(block.name ?? "")) {
+				const lib = block.input?.libraryId ?? block.input?.query ?? "";
+				if (lib && !libraries.includes(lib)) libraries.push(lib);
+			}
+			if (role === "assistant" && block.type === "text" && typeof block.text === "string" && block.text.length > synthesis.length) synthesis = block.text;
+		}
+	} catch {}
+	return {
+		text: synthesis,
+		libraries
+	};
+}
+/**
+* SubagentStop research-expert: cache the synthesis text from the transcript.
+* @param transcript - Path to the agent JSONL transcript.
+* @param cwd - Fallback project root.
+* @param home - Home dir (defaults to `~`).
+*/
+async function cacheDocFromTranscript(transcript, cwd, home = homedir()) {
+	if (!transcript || !await Bun.file(transcript).exists()) return;
+	const projPath = projectRootFromPaths(await transcriptFilePaths(transcript)) ?? process.env.CLAUDE_PROJECT_DIR ?? cwd;
+	const cacheDir = cacheDirFor("doc", projPath, home);
+	const docsDir = join(cacheDir, "docs");
+	let result = await extractSynthesis(transcript);
+	for (const delay of RETRY_DELAYS) {
+		if (result.text.length >= MIN_TEXT_SIZE && result.libraries.length > 0) break;
+		await Bun.sleep(delay);
+		result = await extractSynthesis(transcript);
+	}
+	const { text, libraries } = result;
+	if (text.length < MIN_TEXT_SIZE || libraries.length === 0) return;
+	const indexFile = join(cacheDir, "index.json");
+	const index = await readJsonFile(indexFile) ?? {
+		project: projPath,
+		docs: []
+	};
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+	const content = text.slice(0, MAX_DOC_SIZE);
+	const topic = libraries.join(", ");
+	const docHash = hashText16(topic);
+	await Bun.write(join(docsDir, `${docHash}.md`), content);
+	const sizeKb = Math.floor(content.length / 1024);
+	for (const lib of libraries) {
+		index.docs = index.docs.filter((d) => d.library !== lib);
+		index.docs.push({
+			hash: docHash,
+			library: lib,
+			topic,
+			timestamp,
+			size_kb: sizeKb
+		});
+	}
+	if (index.docs.length > MAX_DOCS) index.docs = index.docs.slice(-15);
+	await writeJsonFile(indexFile, index, true);
+}
+//#endregion
+//#region src/runtime/lifecycle/aipilot/cache-lessons.ts
+/**
+* SubagentStop (matcher "sniper") for the ai-pilot scope: capture error
+* patterns + corrected code from the sniper transcript as lessons. Ports
+* `cache-sniper-lessons.ts` (the dead `promote-global-lessons.ts` spawn is
+* dropped — that helper no longer exists). Pure side-effect.
+*/
+/**
+* SubagentStop sniper: extract lessons from the transcript and persist them.
+* @param transcript - Path to the agent JSONL transcript.
+* @param cwd - Fallback project root.
+* @param home - Home dir (defaults to `~`).
+*/
+async function cacheSniperLessons(transcript, cwd, home = homedir()) {
+	if (!transcript || !await Bun.file(transcript).exists()) return;
+	const edits = await transcriptEdits(transcript);
+	if (edits.length === 0) return;
+	const projectPath = projectRootFromPaths(edits.map((e) => e.file)) ?? process.env.CLAUDE_PROJECT_DIR ?? cwd;
+	const pHash = projectHash(projectPath);
+	const cacheDir = cacheDirFor("lessons", projectPath, home);
+	mkdirSync(cacheDir, { recursive: true });
+	const report = await transcriptReport(transcript);
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+	const errors = edits.map((edit) => {
+		const basename = edit.file.split("/").pop() ?? edit.file;
+		const descLine = report.split("\n").find((l) => l.toLowerCase().includes(basename.toLowerCase()));
+		const errorType = categorizeEdit(edit);
+		return {
+			error_type: errorType,
+			pattern: descLine ?? `Code correction in ${basename}`,
+			fix: `Fix ${errorType} in ${basename}`,
+			count: 1,
+			last_seen: timestamp,
+			files: [edit.file],
+			code: { line: (edit.newStr ?? "").split("\n").filter(Boolean).slice(0, 10) }
+		};
+	});
+	await writeJsonFile(join(cacheDir, `${timestamp.replace(/:/g, "-")}.json`), {
+		project: projectPath,
+		timestamp,
+		errors
+	}, true);
+	logCacheEvent("lessons", "hit", pHash, { count: edits.length }, home);
+}
+//#endregion
+//#region src/runtime/lifecycle/aipilot/cache-test.ts
+/**
+* SubagentStop (matcher "sniper") for the ai-pilot scope: extract linter
+* results from the transcript and cache per-file checksums. Ports
+* `cache-test-results.ts`. Pure side-effect.
+*/
+/** Extract linter-related command/output text from a JSONL transcript. */
+async function extractLinterOutput(path) {
+	const text = await Bun.file(path).text();
+	const outputs = [];
+	for (const line of text.split("\n").filter(Boolean)) try {
+		const content = JSON.parse(line)?.message?.content;
+		if (!Array.isArray(content)) continue;
+		for (const block of content) {
+			if (block.type === "tool_use" && block.name === "Bash") {
+				const cmd = block.input?.command ?? "";
+				if (/eslint|tsc|biome|npx.*lint/i.test(cmd)) outputs.push(cmd);
+			}
+			if (block.type === "tool_result" || block.type === "text") outputs.push(block.text ?? block.content ?? "");
+		}
+	} catch {}
+	return outputs.join("\n");
+}
+/**
+* SubagentStop sniper: cache linter results per-file with checksums.
+* @param transcript - Path to the agent JSONL transcript.
+* @param cwd - Fallback project root.
+* @param home - Home dir (defaults to `~`).
+*/
+async function cacheTestResults(transcript, cwd, home = homedir()) {
+	if (!transcript || !await Bun.file(transcript).exists()) return;
+	const projectPath = projectRootFromPaths(await transcriptFilePaths(transcript)) ?? process.env.CLAUDE_PROJECT_DIR ?? cwd;
+	const pHash = projectHash(projectPath);
+	const cacheDir = cacheDirFor("tests", projectPath, home);
+	mkdirSync(cacheDir, { recursive: true });
+	const resultsPath = join(cacheDir, "results.json");
+	const linterOutput = await extractLinterOutput(transcript);
+	if (!linterOutput) return;
+	const srcFiles = await scanSourceFiles(projectPath);
+	if (srcFiles.length === 0) return;
+	const existing = await readJsonFile(resultsPath) ?? {
+		timestamp: "",
+		files: {}
+	};
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+	const newFiles = {};
+	for (const filepath of srcFiles) {
+		const relPath = filepath.replace(`${projectPath}/`, "");
+		const checksum = (await fileChecksum(filepath)).slice(0, 16);
+		if (!checksum) continue;
+		const basename = filepath.split("/").pop() ?? "";
+		newFiles[relPath] = {
+			checksum,
+			eslint: linterOutput.includes(basename) && linterOutput.includes("error") ? "fail" : "pass",
+			tsc: "pass",
+			last_tested: timestamp
+		};
+	}
+	await writeJsonFile(resultsPath, {
+		timestamp,
+		files: {
+			...existing.files,
+			...newFiles
+		}
+	}, true);
+	logCacheEvent("tests", "hit", pHash, { count: Object.keys(newFiles).length }, home);
+}
+//#endregion
+//#region src/runtime/lifecycle/aipilot/apex-task-store.ts
+/**
+* APEX `task.json` mutation helpers + a directory-based lock for the ai-pilot
+* scope. Ported from the ai-pilot plugin's `apex/state.ts` + `apex/task-helpers.ts`
+* (now removed).
+*/
+/**
+* Acquire a directory-based lock with a timeout.
+* @param lockDir - Path to the lock directory.
+* @param timeoutMs - Max wait in ms (default 5000).
+* @returns A release function, or null if acquisition timed out.
+*/
+async function acquireLock(lockDir, timeoutMs = 5e3) {
+	const start = Date.now();
+	while (Date.now() - start < timeoutMs) try {
+		await mkdir(lockDir, { recursive: false });
+		return async () => {
+			try {
+				await rmdir(lockDir);
+			} catch {}
+		};
+	} catch {
+		await Bun.sleep(100);
+	}
+	return null;
+}
+/** Add a new task to `task.json`. */
+async function taskCreate(file, id, subject, desc) {
+	const data = await readJsonFile(file);
+	if (!data) return;
+	data.tasks[id] = {
+		subject,
+		description: desc,
+		status: "pending",
+		phase: "pending",
+		created_at: (/* @__PURE__ */ new Date()).toISOString(),
+		doc_consulted: {},
+		files_modified: [],
+		blockedBy: []
+	};
+	await writeJsonFile(file, data);
+}
+/** Mark a task as in_progress in `task.json`. */
+async function taskStart(file, id, subject, desc, blocked) {
+	const data = await readJsonFile(file);
+	if (!data) return;
+	if (!data.tasks[id]) data.tasks[id] = {
+		subject: "",
+		description: "",
+		status: "in_progress",
+		phase: "analyze",
+		doc_consulted: {},
+		files_modified: []
+	};
+	data.current_task = id;
+	const task = data.tasks[id];
+	Object.assign(task, {
+		status: "in_progress",
+		phase: "analyze",
+		started_at: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	if (subject) task.subject = subject;
+	if (desc) task.description = desc;
+	if (blocked) task.blockedBy = blocked.split(",");
+	await writeJsonFile(file, data);
+}
+/** Mark a task as completed in `task.json`. */
+async function taskComplete(file, id) {
+	const data = await readJsonFile(file);
+	if (!data?.tasks[id]) return;
+	Object.assign(data.tasks[id], {
+		status: "completed",
+		phase: "completed",
+		completed_at: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	await writeJsonFile(file, data);
+}
+//#endregion
+//#region src/runtime/lifecycle/aipilot/sync-task.ts
+/**
+* PostToolUse (matcher "TaskCreate|TaskUpdate") for the ai-pilot scope:
+* synchronize Claude task tools with `.claude/apex/task.json` and prompt an
+* auto-commit on completion when git changes are detected. Ports
+* `sync-task-tracking.ts`.
+*/
+/** True when the project has uncommitted git changes. */
+async function hasGitChanges(cwd) {
+	try {
+		const proc = Bun.spawn([
+			"git",
+			"status",
+			"--porcelain"
+		], {
+			cwd,
+			stdout: "pipe",
+			stderr: "ignore"
+		});
+		return (await new Response(proc.stdout).text()).trim().length > 0;
+	} catch {
+		return false;
+	}
+}
+/** Handle a completed task: emit the commit reminder (or the no-change note). */
+async function onComplete(taskFile, taskId, projectRoot) {
+	await taskComplete(taskFile, taskId);
+	if (!await hasGitChanges(projectRoot)) return contextResponse("PostToolUse", "Task completed. No changes to commit.");
+	return contextResponse("PostToolUse", `Task #${taskId} completed: ${(await readJsonFile(taskFile))?.tasks[taskId]?.subject ?? "Task"}\n\nChanges detected. MANDATORY: Run /fuse-commit-pro:commit to commit with smart detection.`);
+}
+/**
+* PostToolUse TaskCreate/TaskUpdate handler.
+* @param payload - The raw hook payload (`tool_name`, `tool_input`, `tool_response`).
+* @param cwd - Fallback project root (uses `CLAUDE_PROJECT_DIR` first).
+* @returns The native hook stdout (possibly empty).
+*/
+async function syncTaskTracking(payload, cwd) {
+	const toolName = String(payload.tool_name ?? "");
+	if (toolName !== "TaskCreate" && toolName !== "TaskUpdate") return "";
+	const projectRoot = process.env.CLAUDE_PROJECT_DIR ?? cwd;
+	const taskFile = join(projectRoot, ".claude", "apex", "task.json");
+	if (!existsSync(taskFile)) return "";
+	const unlock = await acquireLock(join(projectRoot, ".claude", "apex", ".task.lock"), 1e4);
+	if (!unlock) return "";
+	try {
+		const ti = payload.tool_input ?? {};
+		if (toolName === "TaskCreate") {
+			const existing = (await readJsonFile(taskFile))?.tasks ?? {};
+			await taskCreate(taskFile, payload.tool_response?.id ?? String(Math.max(0, ...Object.keys(existing).map(Number)) + 1), ti.subject ?? "", ti.description ?? "");
+			return "";
+		}
+		const taskId = ti.taskId ?? "";
+		if (!taskId) return "";
+		const newStatus = ti.status ?? "";
+		if (newStatus === "in_progress") {
+			const blocked = ti.addBlockedBy?.join(",") ?? "";
+			await taskStart(taskFile, taskId, ti.subject || void 0, ti.description || void 0, blocked || void 0);
+		}
+		if (newStatus === "completed") return onComplete(taskFile, taskId, projectRoot);
+		return "";
+	} finally {
+		await unlock();
+	}
+}
+//#endregion
+//#region src/runtime/lifecycle/aipilot/dispatch-aipilot.ts
+/**
+* ai-pilot scope dispatcher: routes Claude lifecycle events to the ported
+* cache/injection handlers by (event, agent_type matcher).
+*/
+/** The agent_type a SubagentStart/Stop payload reports. */
+function agentTypeOf(payload) {
+	return String(payload.agent_type ?? payload.subagent_type ?? "");
+}
+/** Extract the `additionalContext` text from a SubagentStart response, or "". */
+function contextTextOf(response) {
+	if (!response) return "";
+	try {
+		return JSON.parse(response).hookSpecificOutput?.additionalContext ?? "";
+	} catch {
+		return "";
+	}
+}
+/**
+* Combine two SubagentStart responses into one (Claude concatenates multiple
+* hooks' additionalContext; collapsing two matcher-"" scripts into one dispatch
+* call must do that join itself). Returns "" when both are empty.
+*/
+function combineContext(a, b) {
+	const parts = [contextTextOf(a), contextTextOf(b)].filter(Boolean);
+	return parts.length ? contextResponse("SubagentStart", parts.join("\n\n")) : "";
+}
+/** The transcript path a SubagentStop payload reports (Stop-only field). */
+function transcriptOf(payload) {
+	const t = payload.agent_transcript_path;
+	return typeof t === "string" ? t : void 0;
+}
+/** SubagentStart routing: cache injectors keyed on agent_type. */
+async function onSubagentStart(payload, cwd, now) {
+	const agent = agentTypeOf(payload);
+	if (agent.includes("explore-codebase")) return injectExploreCache(cwd, void 0, now);
+	if (agent.includes("research-expert")) return injectDocCache(cwd, void 0, now);
+	if (agent.includes("sniper")) return injectTestCache(cwd, void 0, now);
+	return combineContext(await injectApexSubagentContext(cwd), await injectLessonsCache(cwd, void 0, now));
+}
+/** SubagentStop routing: transcript-driven cache writers (side-effects). */
+async function onSubagentStop(payload, cwd) {
+	const agent = agentTypeOf(payload);
+	const transcript = transcriptOf(payload);
+	if (agent.includes("research-expert")) {
+		await cacheDocFromTranscript(transcript, cwd);
+		return "";
+	}
+	if (agent.includes("sniper")) {
+		await cacheSniperLessons(transcript, cwd);
+		await cacheTestResults(transcript, cwd);
+	}
 	return "";
 }
+/**
+* Dispatch an ai-pilot-scope lifecycle event. Returns the native stdout, or
+* `null` when unhandled (caller falls through to the default pipeline).
+*/
+async function dispatchAipilot(event, payload, cwd, now) {
+	if (event === "SubagentStart") return onSubagentStart(payload, cwd, now);
+	if (event === "SubagentStop") return onSubagentStop(payload, cwd);
+	if (event === "SessionEnd") {
+		await cacheAnalyticsSave(void 0, now);
+		return "";
+	}
+	return null;
+}
+/** PostToolUse (TaskCreate/TaskUpdate) sync for the ai-pilot scope. */
+async function aipilotPostToolUse(payload, cwd) {
+	return syncTaskTracking(payload, cwd);
+}
 //#endregion
 //#region src/runtime/lifecycle/dispatch.ts
 /** SessionStart handler keyed on plugin scope. */
 function sessionStart(input) {
 	if (input.scope === "solid") return solidDetectStart();
 	if (input.scope === "rules") return injectRules(process.env.CLAUDE_PLUGIN_ROOT ?? input.cwd);
-	if (input.scope === "carto") return cartoSessionStart(input.cwd);
+	if (input.scope === "carto") return cartoSessionStart(input.cwd, input.now);
+	if (input.scope === "lessons") return dispatchLessons("SessionStart", input.payload, input.cwd, input.now);
 	return sessionStartCore(input.cwd, void 0, input.now);
 }
 /**
@@ -1492,15 +2928,19 @@ function dispatchLifecycle(input) {
 	switch (input.event) {
 		case "SessionStart": return sessionStart(input);
 		case "UserPromptSubmit": return input.scope === "rules" ? injectRules(process.env.CLAUDE_PLUGIN_ROOT ?? input.cwd) : null;
-		case "SubagentStart": return subagentCacheContext(input.payload.session_id);
-		case "SubagentStop": return trackAgentMemory(input.payload, void 0, input.now);
+		case "SubagentStart":
+			if (input.scope === "aipilot") return "";
+			if (input.scope === "lessons") return dispatchLessons("SubagentStart", input.payload, input.cwd, input.now);
+			return subagentCacheContext(input.payload.session_id);
+		case "Stop": return input.scope === "lessons" ? dispatchLessons("Stop", input.payload, input.cwd, input.now) : null;
+		case "SubagentStop": return input.scope === "aipilot" ? "" : trackAgentMemory(input.payload, void 0, input.now);
 		case "TeammateIdle": return validateTeammateOutput(input.payload);
 		case "PostToolUseFailure":
 			logToolFailure(input.payload, void 0, input.now);
 			return "";
 		case "PreCompact": return saveApexState(input.cwd, input.now);
 		case "SessionEnd":
-			cleanupSession(void 0, input.now);
+			if (input.scope !== "aipilot") cleanupSession(void 0, input.now);
 			return "";
 		case "InstructionsLoaded":
 			validateRulesLoaded(input.payload);
@@ -1677,13 +3117,16 @@ function trackWatchResearch(tool, input, now = Date.now(), home = homedir()) {
 /**
 * Dispatch the appropriate PostToolUse tracker for the invoking scope. Carto
 * persists manual enrichments; security records skill reads + MCP research;
-* changelog records watch research. Side-effect only.
+* changelog records watch research; lessons arms the per-project throttle.
+* Side-effect only.
 * @param scope - The invoking plugin scope.
 * @param event - The normalized event.
 * @param input - The raw tool input.
 * @param now - Clock.
+* @param payload - The raw hook payload (for the lessons mark).
+* @param cwd - The project root (for the lessons mark).
 */
-function postTrackingSideEffects(scope, event, input, now) {
+function postTrackingSideEffects(scope, event, input, now, payload = {}, cwd = process.cwd()) {
 	if (scope === "carto" && (event.tool === "Edit" || event.tool === "Write") && event.filePath) {
 		trackEnrichment(event.filePath);
 		return;
@@ -1693,7 +3136,11 @@ function postTrackingSideEffects(scope, event, input, now) {
 		trackMcpResearch(event.tool, input, now);
 		return;
 	}
-	if (scope === "changelog") trackWatchResearch(event.tool, input, now);
+	if (scope === "changelog") {
+		trackWatchResearch(event.tool, input, now);
+		return;
+	}
+	if (scope === "lessons") dispatchLessons("PostToolUse", payload, cwd, now);
 }
 //#endregion
 //#region src/runtime/lifecycle/security/check-skill.ts
@@ -1727,6 +3174,42 @@ function securityAdvisory(tool, filePath, now = Date.now(), home = homedir()) {
 	} });
 }
 //#endregion
+//#region src/runtime/lifecycle/seo/post-tool-use.ts
+/**
+* SEO PostToolUse handler (fs effects). Ports `seo/hooks/validate-seo.ts`: on an
+* edited HTML-like file under a `.fuse-seo` marker, deny when SEO elements are
+* missing. Opt-in only — silent when no marker / non-HTML / file unreadable.
+*/
+/**
+* Validate the edited file's SEO completeness. Returns a deny message (for a
+* `permissionDecision: deny` response) when HTML-like, opted-in, and missing
+* elements; otherwise `null` (allow).
+* @param payload - The raw PostToolUse payload.
+* @returns The deny reason string, or `null` to allow.
+*/
+function seoPostToolUse(payload) {
+	const path = payload.tool_input?.file_path;
+	if (!path || !isHtmlLike(path)) return null;
+	if (!walkUpFor(typeof payload.cwd === "string" ? payload.cwd : dirname(path), ".fuse-seo")) return null;
+	try {
+		const missing = missingSeoElements(readFileSync(path, "utf-8"));
+		if (missing.length === 0) return null;
+		return `fuse-seo: missing SEO elements in ${path}:\n  - ${missing.join("\n  - ")}`;
+	} catch {
+		return null;
+	}
+}
+/**
+* SEO PostToolUse as a ready native response: a `permissionDecision: deny`
+* string when the edited file is missing SEO elements, else `null` (allow).
+* @param payload - The raw PostToolUse payload.
+* @returns The deny response string, or `null` to allow.
+*/
+function seoPostToolUseResponse(payload) {
+	const deny = seoPostToolUse(payload);
+	return deny ? denyResponse("PostToolUse", deny) : null;
+}
+//#endregion
 //#region src/runtime/lifecycle-bridge.ts
 /** Raw event name from a payload (Cline lacks one; lifecycle is Claude-only). */
 function rawEvent(payload) {
@@ -2237,6 +3720,10 @@ async function handlePre(ctx) {
 }
 //#endregion
 //#region src/runtime/handle.ts
+/** Raw Claude hook event name from a payload (empty when absent). */
+function rawEventName(payload) {
+	return typeof payload.hook_event_name === "string" ? payload.hook_event_name : "";
+}
 /**
 * The full hook handler: on a PRE event it gates the tool-use (stateless guards
 * then APEX gates from the session track) and returns the native response; on a
@@ -2253,6 +3740,13 @@ async function handleHook(id, payload, opts) {
 		stdout: "",
 		exit: 0
 	};
+	if (opts.scope === "aipilot") {
+		const ai = await dispatchAipilot(rawEventName(payload), payload, opts.cwd, opts.now);
+		if (ai !== null) return {
+			stdout: ai,
+			exit: 0
+		};
+	}
 	const life = lifecycleStdout(payload, opts.cwd, opts.scope ?? "core", opts.now);
 	if (life !== null) return {
 		stdout: life,
@@ -2279,7 +3773,19 @@ async function handleHook(id, payload, opts) {
 			responseLength: extractText(response).length
 		});
 		if (activity) await recordActivity(file, activity);
-		postTrackingSideEffects(opts.scope ?? "core", event, event.input, opts.now);
+		postTrackingSideEffects(opts.scope ?? "core", event, event.input, opts.now, payload, opts.cwd);
+		const seoDeny = opts.scope === "seo" ? seoPostToolUseResponse(payload) : null;
+		if (seoDeny) return {
+			stdout: seoDeny,
+			exit: 0
+		};
+		if (opts.scope === "aipilot" && (event.tool === "TaskCreate" || event.tool === "TaskUpdate")) {
+			const out = await aipilotPostToolUse(payload, opts.cwd);
+			if (out) return {
+				stdout: out,
+				exit: 0
+			};
+		}
 		const extra = postEditContext(opts.scope ?? "core", event, opts.now);
 		return {
 			stdout: designWarn ? respond(id, designWarn) : extra,
@@ -2297,4 +3803,4 @@ async function handleHook(id, payload, opts) {
 	});
 }
 //#endregion
-export { trimLogFile as $, loadEnriched as A, logToolFailure as B, todayUtc as C, generateProjectMap as D, cartoSessionStart as E, postEditTypescript as F, solidDetectStart as G, trackAgentMemory as H, trackSessionChanges as I, runSessionStartCleanups as J, injectRules as K, validateRulesLoaded as L, countFiles as M, getFileDesc as N, isProject as O, listChildren as P, removeOldFiles as Q, cleanupSession as R, securityStatePath as S, dispatchLifecycle as T, subagentCacheContext as U, validateTeammateOutput as V, detectSolidProfile as W, pruneEmptyDirs as X, sessionStartCore as Y, purgeTtlTree as Z, trackSkillRead as _, isMcpTool as _t, TRIVIAL_BUDGET as a, loadSessionState as at, saveSecurityState as b, queryOf as bt, detectDuplication as c, sessionStatePath as ct, lifecycleStdout as d, taskContext as dt, devContext as et, postEditContext as f, respond as ft, trackMcpResearch as g, MCP_TTL_MS as gt, trackWatchResearch as h, normalizeEvent as ht, REQUIRED_AGENTS as i, fusengineCache as it, mergeLines as j, writeTree as k, dryGate as l, sessionsDir as lt, postTrackingSideEffects as m, trackFile as mt, handlePre as n, projectContext as nt, gate as o, sanitizeSessionId as ot, securityAdvisory as p, recordActivity as pt, readRules as q, DEFAULT_WINDOW_MS as r, claudeHome as rt, preCommitGate as s, saveSessionState as st, handleHook as t, gitContext as tt, extractSymbols as u, promptSubmitContext as ut, isoUtc as v, mcpPostStore as vt, trackEnrichment as w, securityStateDir as x, activityFor as xt, loadSecurityState as y, mcpPreIntercept as yt, saveApexState as z };
+export { detectSolidProfile as $, dispatchLessons as A, activityFor as At, mergeLines as B, securityStateDir as C, trackFile as Ct, dispatchLifecycle as D, mcpPostStore as Dt, trackEnrichment as E, isMcpTool as Et, writePluginMap as F, trackSessionChanges as G, getFileDesc as H, generateProjectMap as I, saveApexState as J, validateRulesLoaded as K, isProject as L, lessonsStateFileFor as M, cartoSessionStart as N, aipilotPostToolUse as O, mcpPreIntercept as Ot, generateEcosystemMap as P, subagentCacheContext as Q, writeTree as R, saveSecurityState as S, recordActivity as St, todayUtc as T, MCP_TTL_MS as Tt, listChildren as U, countFiles as V, postEditTypescript as W, validateTeammateOutput as X, logToolFailure as Y, trackAgentMemory as Z, trackWatchResearch as _, sessionStatePath as _t, TRIVIAL_BUDGET as a, pruneEmptyDirs as at, isoUtc as b, taskContext as bt, detectDuplication as c, trimLogFile as ct, lifecycleStdout as d, projectContext as dt, solidDetectStart as et, postEditContext as f, claudeHome as ft, postTrackingSideEffects as g, saveSessionState as gt, securityAdvisory as h, sanitizeSessionId as ht, REQUIRED_AGENTS as i, sessionStartCore as it, lessonsFileFor as j, dispatchAipilot as k, queryOf as kt, dryGate as l, devContext as lt, seoPostToolUseResponse as m, loadSessionState as mt, handlePre as n, readRules as nt, gate as o, purgeTtlTree as ot, seoPostToolUse as p, fusengineCache as pt, cleanupSession as q, DEFAULT_WINDOW_MS as r, runSessionStartCleanups as rt, preCommitGate as s, removeOldFiles as st, handleHook as t, injectRules as tt, extractSymbols as u, gitContext as ut, trackMcpResearch as v, sessionsDir as vt, securityStatePath as w, normalizeEvent as wt, loadSecurityState as x, respond as xt, trackSkillRead as y, promptSubmitContext as yt, loadEnriched as z };