@fusengine/harness 0.1.30 → 0.1.31

package/dist/cli/bin.mjs

@@ -3,7 +3,7 @@ import { r as resolveTtlSec } from "../ttl-BG55s6HZ.mjs";
 import { t as detectHarness } from "../harness-C8Nxxyn_.mjs";
 import { n as stagedContent, r as stagedFiles, t as checkStaged } from "../run-CXsV-wIJ.mjs";
 import { n as writeInitFile, t as initFor } from "../run-D91N4ul1.mjs";
-import { t as handleHook } from "../handle-USWK4NSE.mjs";
+import { t as handleHook } from "../handle-DW9cWdVt.mjs";
 //#region src/cli/bin.ts
 /**
 * harness — CLI for @fusengine/harness.
@@ -32,7 +32,8 @@ if (cmd === "hook") {
 		"rules",
 		"carto",
 		"security",
-		"changelog"
+		"changelog",
+		"aipilot"
 	])).has(scopeArg) ? scopeArg : "core";
 	const outcome = await handleHook(id, await readStdin(), {
 		now: Date.now(),

package/dist/{describe-CPtgUzFS.mjs → describe-BYqhoV4c.mjs}

@@ -708,11 +708,10 @@ function detectClaudeMdProjectType(cwd) {
 function buildApexInstruction(projectType, maxLines) {
 	return `INSTRUCTION: This is a development task. Use APEX methodology:
 
-**TRACKING FILE**: [project]/.claude/apex/task.json
+**TRACKING FILE**: [project]/.claude/apex/task.json (auto-created on first Write/Edit)
 
-1. **ANALYZE** (3 AGENTS IN PARALLEL):
-   - explore-codebase + research-expert + general-purpose
-   - Project type: ${projectType}\n\n2. **PLAN**: TaskCreate (<${maxLines} lines per file)\n\n3. **EXECUTE**: ${projectType}-expert, SOLID principles\n\n4. **EXAMINE**: Run sniper agent after ANY modification`;
+1. **ANALYZE** (MANDATORY - 3 AGENTS IN PARALLEL):
+   - explore-codebase + research-expert + ${projectType}-expert (framework expertise)\n   - Project type detected: ${projectType}\n\n2. **PLAN**: Use TaskCreate to break down tasks (<${maxLines} lines per file)\n\n3. **EXECUTE**: ${projectType}-expert, follow SOLID principles, split at ${maxLines - 10} lines\n\n4. **EXAMINE**: Run sniper agent after ANY modification\n\n**IMPORTANT**: Read .claude/apex/task.json to check documentation status before writing code.`;
 }
 /**
 * Build the UserPromptSubmit injection text: read `~/.claude/CLAUDE.md` and,

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

@@ -1,16 +1,20 @@
+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 { 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-BYqhoV4c.mjs";
 import { j as detectFramework, k as countLines, n as FAIL_CLOSED, t as evaluate } from "./evaluate-j3gRJ_ng.mjs";
 import { t as formatPrompt } from "./types-ernB1Dy3.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 { 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;
@@ -1473,6 +1477,1040 @@ function cartoSessionStart(cwd) {
 	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) {
@@ -1492,15 +2530,15 @@ 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": return input.scope === "aipilot" ? "" : subagentCacheContext(input.payload.session_id);
+		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);
@@ -2237,6 +3275,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 +3295,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,
@@ -2280,6 +3329,13 @@ async function handleHook(id, payload, opts) {
 		});
 		if (activity) await recordActivity(file, activity);
 		postTrackingSideEffects(opts.scope ?? "core", event, event.input, opts.now);
+		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 +3353,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 { purgeTtlTree as $, isProject as A, cleanupSession as B, todayUtc as C, activityFor as Ct, dispatchAipilot as D, aipilotPostToolUse as E, getFileDesc as F, subagentCacheContext as G, logToolFailure as H, listChildren as I, injectRules as J, detectSolidProfile as K, postEditTypescript as L, loadEnriched as M, mergeLines as N, cartoSessionStart as O, countFiles as P, pruneEmptyDirs as Q, trackSessionChanges as R, securityStatePath as S, queryOf as St, dispatchLifecycle as T, validateTeammateOutput as U, saveApexState as V, trackAgentMemory as W, runSessionStartCleanups as X, readRules as Y, sessionStartCore as Z, trackSkillRead as _, normalizeEvent as _t, TRIVIAL_BUDGET as a, claudeHome as at, saveSecurityState as b, mcpPostStore as bt, detectDuplication as c, sanitizeSessionId as ct, lifecycleStdout as d, sessionsDir as dt, removeOldFiles as et, postEditContext as f, promptSubmitContext as ft, trackMcpResearch as g, trackFile as gt, trackWatchResearch as h, recordActivity as ht, REQUIRED_AGENTS as i, projectContext as it, writeTree as j, generateProjectMap as k, dryGate as l, saveSessionState as lt, postTrackingSideEffects as m, respond as mt, handlePre as n, devContext as nt, gate as o, fusengineCache as ot, securityAdvisory as p, taskContext as pt, solidDetectStart as q, DEFAULT_WINDOW_MS as r, gitContext as rt, preCommitGate as s, loadSessionState as st, handleHook as t, trimLogFile as tt, extractSymbols as u, sessionStatePath as ut, isoUtc as v, MCP_TTL_MS as vt, trackEnrichment as w, securityStateDir as x, mcpPreIntercept as xt, loadSecurityState as y, isMcpTool as yt, validateRulesLoaded as z };

package/dist/index.mjs

@@ -4,7 +4,7 @@ import { n as STATE_ROOT, r as projectLayout, t as STATE_GITIGNORE } from "./lay
 import { t as compactJson } from "./compact-json-DK2nX-MK.mjs";
 import { n as projectRoot, r as projectRootOrNull, t as isCodeFile } from "./project-root-ff0_poWU.mjs";
 import { n as detectMode, r as modeFor, t as detectHarness } from "./harness-C8Nxxyn_.mjs";
-import { A as solidReadGate, C as capVerbosity, D as docConsultedGate, E as brainstormGate, F as requiredArchSkill, M as detectModularArchitecture, N as detectProjectType, O as evaluateApex, P as isApexCommand, S as MAX_TOKENS, T as APEX_GATES, _ as detectRequiredSkills, a as parseEntry, b as frameworkSolidGate, c as EXCLUDE_DIRS, d as buildApexTaskInjection, f as loadApexTaskState, g as detectClaudeMdProjectType, h as buildClaudeMdContext, i as parseEnrichment, j as DEV_KEYWORDS, k as freshnessGate, l as PROJECT_INDICATORS, m as buildApexInstruction, n as firstComment, o as parseBodyDesc, p as DEV_VERBS, r as firstHeading, s as parseField, t as descFromText, u as buildApexTaskContext, v as skillTriggerGate, w as detectCreationIntent, x as MAX_EXA_RESULTS, y as SKILL_TRIGGERS } from "./describe-CPtgUzFS.mjs";
+import { A as solidReadGate, C as capVerbosity, D as docConsultedGate, E as brainstormGate, F as requiredArchSkill, M as detectModularArchitecture, N as detectProjectType, O as evaluateApex, P as isApexCommand, S as MAX_TOKENS, T as APEX_GATES, _ as detectRequiredSkills, a as parseEntry, b as frameworkSolidGate, c as EXCLUDE_DIRS, d as buildApexTaskInjection, f as loadApexTaskState, g as detectClaudeMdProjectType, h as buildClaudeMdContext, i as parseEnrichment, j as DEV_KEYWORDS, k as freshnessGate, l as PROJECT_INDICATORS, m as buildApexInstruction, n as firstComment, o as parseBodyDesc, p as DEV_VERBS, r as firstHeading, s as parseField, t as descFromText, u as buildApexTaskContext, v as skillTriggerGate, w as detectCreationIntent, x as MAX_EXA_RESULTS, y as SKILL_TRIGGERS } from "./describe-BYqhoV4c.mjs";
 import { A as evaluateFileSize, C as securityGuard, D as SYSTEM_INSTALL, E as PROJECT_INSTALL, O as matchPatterns, S as CRITICAL_PATTERNS, T as GIT_BLOCKED, _ as CODE_REDIRECT, a as registerGuard, b as protectedPathGuard, c as GO_DECL_RE, d as PY_MODEL_RE, f as SWIFT_PROTO_RE, g as CODE_MUTATORS, h as ASK_WRITERS, i as clearUserGuards, j as detectFramework, k as countLines, l as JAVA_DECL_RE, m as interfaceSeparationGuard, n as FAIL_CLOSED, o as runGuards, p as TS_DECL_RE, r as GUARDS, s as installGuard, t as evaluate, u as PHP_DECL_RE, v as bashWriteGuard, w as GIT_ASK, x as ASK_PATTERNS, y as PROTECTED_FRAGMENTS } from "./evaluate-j3gRJ_ng.mjs";
 import { i as resolveSessions, n as formatDocSatisfactionStatus, r as isDocConsulted, t as formatDocDeny } from "./doc-helpers-Dd_x1-tZ.mjs";
 import { i as parseFrontmatter, n as scoreReferences, r as globToRe, t as routeReferences } from "./router-D8cVrI-s.mjs";

package/dist/policy/index.mjs

@@ -1,4 +1,4 @@
-import { A as solidReadGate, C as capVerbosity, D as docConsultedGate, E as brainstormGate, F as requiredArchSkill, M as detectModularArchitecture, N as detectProjectType, O as evaluateApex, P as isApexCommand, S as MAX_TOKENS, T as APEX_GATES, _ as detectRequiredSkills, a as parseEntry, b as frameworkSolidGate, c as EXCLUDE_DIRS, d as buildApexTaskInjection, f as loadApexTaskState, g as detectClaudeMdProjectType, h as buildClaudeMdContext, i as parseEnrichment, j as DEV_KEYWORDS, k as freshnessGate, l as PROJECT_INDICATORS, m as buildApexInstruction, n as firstComment, o as parseBodyDesc, p as DEV_VERBS, r as firstHeading, s as parseField, t as descFromText, u as buildApexTaskContext, v as skillTriggerGate, w as detectCreationIntent, x as MAX_EXA_RESULTS, y as SKILL_TRIGGERS } from "../describe-CPtgUzFS.mjs";
+import { A as solidReadGate, C as capVerbosity, D as docConsultedGate, E as brainstormGate, F as requiredArchSkill, M as detectModularArchitecture, N as detectProjectType, O as evaluateApex, P as isApexCommand, S as MAX_TOKENS, T as APEX_GATES, _ as detectRequiredSkills, a as parseEntry, b as frameworkSolidGate, c as EXCLUDE_DIRS, d as buildApexTaskInjection, f as loadApexTaskState, g as detectClaudeMdProjectType, h as buildClaudeMdContext, i as parseEnrichment, j as DEV_KEYWORDS, k as freshnessGate, l as PROJECT_INDICATORS, m as buildApexInstruction, n as firstComment, o as parseBodyDesc, p as DEV_VERBS, r as firstHeading, s as parseField, t as descFromText, u as buildApexTaskContext, v as skillTriggerGate, w as detectCreationIntent, x as MAX_EXA_RESULTS, y as SKILL_TRIGGERS } from "../describe-BYqhoV4c.mjs";
 import { A as evaluateFileSize, C as securityGuard, D as SYSTEM_INSTALL, E as PROJECT_INSTALL, O as matchPatterns, S as CRITICAL_PATTERNS, T as GIT_BLOCKED, _ as CODE_REDIRECT, a as registerGuard, b as protectedPathGuard, c as GO_DECL_RE, d as PY_MODEL_RE, f as SWIFT_PROTO_RE, g as CODE_MUTATORS, h as ASK_WRITERS, i as clearUserGuards, j as detectFramework, k as countLines, l as JAVA_DECL_RE, m as interfaceSeparationGuard, n as FAIL_CLOSED, o as runGuards, p as TS_DECL_RE, r as GUARDS, s as installGuard, t as evaluate, u as PHP_DECL_RE, v as bashWriteGuard, w as GIT_ASK, x as ASK_PATTERNS, y as PROTECTED_FRAGMENTS } from "../evaluate-j3gRJ_ng.mjs";
 import "../policy-la_KkjCS.mjs";
 export { APEX_GATES, ASK_PATTERNS, ASK_WRITERS, CODE_MUTATORS, CODE_REDIRECT, CRITICAL_PATTERNS, DEV_KEYWORDS, DEV_VERBS, EXCLUDE_DIRS, FAIL_CLOSED, GIT_ASK, GIT_BLOCKED, GO_DECL_RE, GUARDS, JAVA_DECL_RE, MAX_EXA_RESULTS, MAX_TOKENS, PHP_DECL_RE, PROJECT_INDICATORS, PROJECT_INSTALL, PROTECTED_FRAGMENTS, PY_MODEL_RE, SKILL_TRIGGERS, SWIFT_PROTO_RE, SYSTEM_INSTALL, TS_DECL_RE, bashWriteGuard, brainstormGate, buildApexInstruction, buildApexTaskContext, buildApexTaskInjection, buildClaudeMdContext, capVerbosity, clearUserGuards, countLines, descFromText, detectClaudeMdProjectType, detectCreationIntent, detectFramework, detectModularArchitecture, detectProjectType, detectRequiredSkills, docConsultedGate, evaluate, evaluateApex, evaluateFileSize, firstComment, firstHeading, frameworkSolidGate, freshnessGate, installGuard, interfaceSeparationGuard, isApexCommand, loadApexTaskState, matchPatterns, parseBodyDesc, parseEnrichment, parseEntry, parseField, protectedPathGuard, registerGuard, requiredArchSkill, runGuards, securityGuard, skillTriggerGate, solidReadGate };

package/dist/runtime/index.d.mts

@@ -355,9 +355,18 @@ declare function trackSessionChanges(sessionIdRaw: unknown, filePath: string, ho
 */
 declare function postEditTypescript(filePath: string): string;
 //#endregion
+//#region src/runtime/lifecycle/aipilot/dispatch-aipilot.d.ts
+/**
+* Dispatch an ai-pilot-scope lifecycle event. Returns the native stdout, or
+* `null` when unhandled (caller falls through to the default pipeline).
+*/
+declare function dispatchAipilot(event: string, payload: Record<string, unknown>, cwd: string, now: number): Promise<string | null>;
+/** PostToolUse (TaskCreate/TaskUpdate) sync for the ai-pilot scope. */
+declare function aipilotPostToolUse(payload: Record<string, unknown>, cwd: string): Promise<string>;
+//#endregion
 //#region src/runtime/lifecycle/dispatch.d.ts
 /** Which plugin's hooks.json invoked the harness (selects SessionStart behavior). */
-type PluginScope = "core" | "solid" | "rules" | "carto" | "security" | "changelog";
+type PluginScope = "core" | "solid" | "rules" | "carto" | "security" | "changelog" | "aipilot";
 /** Inputs the lifecycle dispatcher needs (clock + roots injected). */
 interface LifecycleInput {
   event: string;
@@ -600,4 +609,4 @@ interface PreContext {
 */
 declare function handlePre(ctx: PreContext): Promise<HandleOutcome>;
 //#endregion
-export { Activity, DEFAULT_WINDOW_MS, DuplicationVerdict, type GateInput, HandleOptions, HandleOutcome, LifecycleInput, MCP_TTL_MS, McpIntercept, NormalizedEvent, PluginScope, PreContext, REQUIRED_AGENTS, SolidProfile, TRIVIAL_BUDGET, ToolEvent, activityFor, cartoSessionStart, claudeHome, cleanupSession, countFiles, detectDuplication, detectSolidProfile, devContext, dispatchLifecycle, dryGate, extractSymbols, fusengineCache, gate, generateProjectMap, getFileDesc, gitContext, handleHook, handlePre, harnessStateDir, injectRules, isMcpTool, isProject, isoUtc, lifecycleStdout, listChildren, loadEnriched, loadSecurityState, loadSessionState, logToolFailure, mcpPostStore, mcpPreIntercept, mergeLines, normalizeEvent, postEditContext, postEditTypescript, postTrackingSideEffects, preCommitGate, projectContext, promptSubmitContext, pruneEmptyDirs, purgeTtlTree, queryOf, readRules, recordActivity, removeOldFiles, respond, runSessionStartCleanups, sanitizeSessionId, saveApexState, saveSecurityState, saveSessionState, securityAdvisory, securityStateDir, securityStatePath, sessionStartCore, sessionStatePath, sessionsDir, solidDetectStart, subagentCacheContext, taskContext, todayUtc, trackAgentMemory, trackEnrichment, trackFile, trackMcpResearch, trackSessionChanges, trackSkillRead, trackWatchResearch, trimLogFile, validateRulesLoaded, validateTeammateOutput, writeTree };
+export { Activity, DEFAULT_WINDOW_MS, DuplicationVerdict, type GateInput, HandleOptions, HandleOutcome, LifecycleInput, MCP_TTL_MS, McpIntercept, NormalizedEvent, PluginScope, PreContext, REQUIRED_AGENTS, SolidProfile, TRIVIAL_BUDGET, ToolEvent, activityFor, aipilotPostToolUse, cartoSessionStart, claudeHome, cleanupSession, countFiles, detectDuplication, detectSolidProfile, devContext, dispatchAipilot, dispatchLifecycle, dryGate, extractSymbols, fusengineCache, gate, generateProjectMap, getFileDesc, gitContext, handleHook, handlePre, harnessStateDir, injectRules, isMcpTool, isProject, isoUtc, lifecycleStdout, listChildren, loadEnriched, loadSecurityState, loadSessionState, logToolFailure, mcpPostStore, mcpPreIntercept, mergeLines, normalizeEvent, postEditContext, postEditTypescript, postTrackingSideEffects, preCommitGate, projectContext, promptSubmitContext, pruneEmptyDirs, purgeTtlTree, queryOf, readRules, recordActivity, removeOldFiles, respond, runSessionStartCleanups, sanitizeSessionId, saveApexState, saveSecurityState, saveSessionState, securityAdvisory, securityStateDir, securityStatePath, sessionStartCore, sessionStatePath, sessionsDir, solidDetectStart, subagentCacheContext, taskContext, todayUtc, trackAgentMemory, trackEnrichment, trackFile, trackMcpResearch, trackSessionChanges, trackSkillRead, trackWatchResearch, trimLogFile, validateRulesLoaded, validateTeammateOutput, writeTree };

package/dist/runtime/index.mjs

@@ -1,5 +1,5 @@
 import { r as projectLayout } from "../layout-C0jaaCQC.mjs";
-import { $ as trimLogFile, A as loadEnriched, B as logToolFailure, C as todayUtc, D as generateProjectMap, E as cartoSessionStart, F as postEditTypescript, G as solidDetectStart, H as trackAgentMemory, I as trackSessionChanges, J as runSessionStartCleanups, K as injectRules, L as validateRulesLoaded, M as countFiles, N as getFileDesc, O as isProject, P as listChildren, Q as removeOldFiles, R as cleanupSession, S as securityStatePath, T as dispatchLifecycle, U as subagentCacheContext, V as validateTeammateOutput, W as detectSolidProfile, X as pruneEmptyDirs, Y as sessionStartCore, Z as purgeTtlTree, _ as trackSkillRead, _t as isMcpTool, a as TRIVIAL_BUDGET, at as loadSessionState, b as saveSecurityState, bt as queryOf, c as detectDuplication, ct as sessionStatePath, d as lifecycleStdout, dt as taskContext, et as devContext, f as postEditContext, ft as respond, g as trackMcpResearch, gt as MCP_TTL_MS, h as trackWatchResearch, ht as normalizeEvent, i as REQUIRED_AGENTS, it as fusengineCache, j as mergeLines, k as writeTree, l as dryGate, lt as sessionsDir, m as postTrackingSideEffects, mt as trackFile, n as handlePre, nt as projectContext, o as gate, ot as sanitizeSessionId, p as securityAdvisory, pt as recordActivity, q as readRules, r as DEFAULT_WINDOW_MS, rt as claudeHome, s as preCommitGate, st as saveSessionState, t as handleHook, tt as gitContext, u as extractSymbols, ut as promptSubmitContext, v as isoUtc, vt as mcpPostStore, w as trackEnrichment, x as securityStateDir, xt as activityFor, y as loadSecurityState, yt as mcpPreIntercept, z as saveApexState } from "../handle-USWK4NSE.mjs";
+import { $ as purgeTtlTree, A as isProject, B as cleanupSession, C as todayUtc, Ct as activityFor, D as dispatchAipilot, E as aipilotPostToolUse, F as getFileDesc, G as subagentCacheContext, H as logToolFailure, I as listChildren, J as injectRules, K as detectSolidProfile, L as postEditTypescript, M as loadEnriched, N as mergeLines, O as cartoSessionStart, P as countFiles, Q as pruneEmptyDirs, R as trackSessionChanges, S as securityStatePath, St as queryOf, T as dispatchLifecycle, U as validateTeammateOutput, V as saveApexState, W as trackAgentMemory, X as runSessionStartCleanups, Y as readRules, Z as sessionStartCore, _ as trackSkillRead, _t as normalizeEvent, a as TRIVIAL_BUDGET, at as claudeHome, b as saveSecurityState, bt as mcpPostStore, c as detectDuplication, ct as sanitizeSessionId, d as lifecycleStdout, dt as sessionsDir, et as removeOldFiles, f as postEditContext, ft as promptSubmitContext, g as trackMcpResearch, gt as trackFile, h as trackWatchResearch, ht as recordActivity, i as REQUIRED_AGENTS, it as projectContext, j as writeTree, k as generateProjectMap, l as dryGate, lt as saveSessionState, m as postTrackingSideEffects, mt as respond, n as handlePre, nt as devContext, o as gate, ot as fusengineCache, p as securityAdvisory, pt as taskContext, q as solidDetectStart, r as DEFAULT_WINDOW_MS, rt as gitContext, s as preCommitGate, st as loadSessionState, t as handleHook, tt as trimLogFile, u as extractSymbols, ut as sessionStatePath, v as isoUtc, vt as MCP_TTL_MS, w as trackEnrichment, x as securityStateDir, xt as mcpPreIntercept, y as loadSecurityState, yt as isMcpTool, z as validateRulesLoaded } from "../handle-DW9cWdVt.mjs";
 //#region src/runtime/storage.ts
 /**
 * The project's single state dir (`<root>/.harness`) — neutral + harness-agnostic,
@@ -9,4 +9,4 @@ function harnessStateDir(root) {
 	return projectLayout(root).stateDir;
 }
 //#endregion
-export { DEFAULT_WINDOW_MS, MCP_TTL_MS, REQUIRED_AGENTS, TRIVIAL_BUDGET, activityFor, cartoSessionStart, claudeHome, cleanupSession, countFiles, detectDuplication, detectSolidProfile, devContext, dispatchLifecycle, dryGate, extractSymbols, fusengineCache, gate, generateProjectMap, getFileDesc, gitContext, handleHook, handlePre, harnessStateDir, injectRules, isMcpTool, isProject, isoUtc, lifecycleStdout, listChildren, loadEnriched, loadSecurityState, loadSessionState, logToolFailure, mcpPostStore, mcpPreIntercept, mergeLines, normalizeEvent, postEditContext, postEditTypescript, postTrackingSideEffects, preCommitGate, projectContext, promptSubmitContext, pruneEmptyDirs, purgeTtlTree, queryOf, readRules, recordActivity, removeOldFiles, respond, runSessionStartCleanups, sanitizeSessionId, saveApexState, saveSecurityState, saveSessionState, securityAdvisory, securityStateDir, securityStatePath, sessionStartCore, sessionStatePath, sessionsDir, solidDetectStart, subagentCacheContext, taskContext, todayUtc, trackAgentMemory, trackEnrichment, trackFile, trackMcpResearch, trackSessionChanges, trackSkillRead, trackWatchResearch, trimLogFile, validateRulesLoaded, validateTeammateOutput, writeTree };
+export { DEFAULT_WINDOW_MS, MCP_TTL_MS, REQUIRED_AGENTS, TRIVIAL_BUDGET, activityFor, aipilotPostToolUse, cartoSessionStart, claudeHome, cleanupSession, countFiles, detectDuplication, detectSolidProfile, devContext, dispatchAipilot, dispatchLifecycle, dryGate, extractSymbols, fusengineCache, gate, generateProjectMap, getFileDesc, gitContext, handleHook, handlePre, harnessStateDir, injectRules, isMcpTool, isProject, isoUtc, lifecycleStdout, listChildren, loadEnriched, loadSecurityState, loadSessionState, logToolFailure, mcpPostStore, mcpPreIntercept, mergeLines, normalizeEvent, postEditContext, postEditTypescript, postTrackingSideEffects, preCommitGate, projectContext, promptSubmitContext, pruneEmptyDirs, purgeTtlTree, queryOf, readRules, recordActivity, removeOldFiles, respond, runSessionStartCleanups, sanitizeSessionId, saveApexState, saveSecurityState, saveSessionState, securityAdvisory, securityStateDir, securityStatePath, sessionStartCore, sessionStatePath, sessionsDir, solidDetectStart, subagentCacheContext, taskContext, todayUtc, trackAgentMemory, trackEnrichment, trackFile, trackMcpResearch, trackSessionChanges, trackSkillRead, trackWatchResearch, trimLogFile, validateRulesLoaded, validateTeammateOutput, writeTree };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fusengine/harness",
-  "version": "0.1.30",
+  "version": "0.1.31",
   "description": "Harness-agnostic toolkit for AI coding agents: runtime harness detection (Claude Code, Codex, Cursor, Cline, Gemini, Aider...), pure policy core (env config, project/framework detection, SOLID/file-size limits, APEX freshness, guard patterns, portable prompts), cache, project memory, ref routing, state/locks, statusline, per-harness adapters (Claude/Cursor/Cline/Gemini) and a cli-mode harness-check binary. Bun-native, with a built dist for Node + bundlers.",
   "type": "module",
   "module": "src/index.ts",