@fusengine/harness 0.1.34 → 0.1.36

package/dist/cli/bin.mjs

@@ -3,13 +3,85 @@ 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-CUL70W0k.mjs";
 import { n as writeInitFile, t as initFor } from "../run-Do2JltgU.mjs";
-import { t as handleHook } from "../handle-DMHjTY1E.mjs";
+import { Dt as claudeHome, Et as todayUtc, t as handleHook } from "../handle-DL2sZiWH.mjs";
+import { join } from "node:path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+//#region src/changelog/fetch.ts
+/**
+* Changelog scanner — ports the changelog-watcher plugin's `fetch-changelog`
+* into the harness (exposed as the `harness changelog` CLI verb). Fetches the
+* official Claude Code changelog, detects how many versions are new since the
+* last check, persists per-day state, and returns a JSON summary. Dual-runtime:
+* global `fetch` + `node:fs` (works under Node 20+ and Bun, no imports needed).
+*/
+const CHANGELOG_URL = "https://code.claude.com/docs/en/changelog.md";
+/**
+* Parse up to 10 semver versions from the changelog, newest first. Matches the
+* current docs format (`<Update label="X.Y.Z" …>` MDX blocks) AND the legacy
+* markdown headers (`## vX.Y.Z` / `## X.Y.Z`) so it survives a format rollback.
+*/
+function parseVersions(md) {
+	return [...md.matchAll(/<Update\s+label="v?(\d+\.\d+\.\d+)"|^##\s+v?(\d+\.\d+\.\d+)/gm)].map((m) => m[1] ?? m[2] ?? "").filter(Boolean).slice(0, 10);
+}
+/** Count versions newer than `lastKnown` (stops at the first match). */
+function countNew(versions, lastKnown) {
+	if (!lastKnown) return 0;
+	let n = 0;
+	for (const v of versions) {
+		if (v === lastKnown) break;
+		n++;
+	}
+	return n;
+}
+/** Read the saved `last_version` for today's state file ("" when absent/corrupt). */
+function lastKnownVersion(stateFile) {
+	if (!existsSync(stateFile)) return "";
+	try {
+		return JSON.parse(readFileSync(stateFile, "utf8")).last_version ?? "";
+	} catch {
+		return "";
+	}
+}
+/**
+* Fetch + parse the changelog, diff against the saved state, persist, and return
+* the scan summary. Throws on network failure (the CLI maps it to exit 1).
+* @param now - Clock (ms).
+* @param home - Home dir.
+*/
+async function scanChangelog(now = Date.now(), home = homedir()) {
+	const res = await fetch(CHANGELOG_URL, { signal: AbortSignal.timeout(1e4) });
+	if (!res.ok) throw new Error(`changelog fetch failed: ${res.status}`);
+	const versions = parseVersions(await res.text());
+	const latest = versions[0] ?? "";
+	const dir = join(claudeHome(home), "logs", "00-changelog");
+	const today = todayUtc(now);
+	const stateFile = join(dir, `${today}-state.json`);
+	const lastKnown = lastKnownVersion(stateFile);
+	const newCount = countNew(versions, lastKnown);
+	try {
+		mkdirSync(dir, { recursive: true });
+		writeFileSync(stateFile, JSON.stringify({
+			last_version: latest,
+			previous: lastKnown,
+			new_versions: newCount,
+			checked: today
+		}, null, 2));
+	} catch {}
+	return {
+		latest,
+		new_since_last_check: newCount,
+		recent_versions: versions
+	};
+}
+//#endregion
 //#region src/cli/bin.ts
 /**
 * harness — CLI for @fusengine/harness.
 *   harness check          cli-mode: check staged files (pre-commit), exit non-zero on a violation
 *   harness init [id]      write the wiring file for a harness (defaults to the detected one)
 *   harness hook <id>      runtime: read a hook payload on stdin, route to the adapter, print the response
+*   harness changelog      fetch + diff the Claude Code changelog, print a JSON summary (changelog-watcher)
 */
 async function readStdin() {
 	const chunks = [];
@@ -35,7 +107,8 @@ if (cmd === "hook") {
 		"changelog",
 		"aipilot",
 		"lessons",
-		"seo"
+		"seo",
+		"memory"
 	])).has(scopeArg) ? scopeArg : "core";
 	const outcome = await handleHook(id, await readStdin(), {
 		now: Date.now(),
@@ -56,7 +129,17 @@ if (cmd === "hook") {
 	const written = files.map((f) => writeInitFile(process.cwd(), f));
 	process.stdout.write(`harness: wired ${id} -> ${written.join(", ")}\n`);
 	process.exit(0);
-} else {
+} else if (cmd === "changelog") try {
+	process.stdout.write(JSON.stringify(await scanChangelog()) + "\n");
+	process.exit(0);
+} catch (e) {
+	process.stdout.write(JSON.stringify({
+		status: "error",
+		message: e instanceof Error ? e.message : "changelog fetch failed"
+	}) + "\n");
+	process.exit(1);
+}
+else {
 	const files = stagedFiles();
 	if (files.length === 0) process.exit(0);
 	const violations = checkStaged(files, stagedContent);

package/dist/{handle-DMHjTY1E.mjs → handle-DL2sZiWH.mjs}

@@ -16,6 +16,88 @@ import { homedir } from "node:os";
 import { createHash } from "node:crypto";
 import { mkdir, rmdir } from "node:fs/promises";
 import { execFileSync } from "node:child_process";
+//#region src/runtime/home-state.ts
+/** Home `~/.claude` dir (single source for every home-based hook path). */
+function claudeHome(home = homedir()) {
+	return join(home, ".claude");
+}
+/** `~/.claude/fusengine-cache` base dir for legacy session/cache state. */
+function fusengineCache(home = homedir()) {
+	return join(claudeHome(home), "fusengine-cache");
+}
+/** `~/.claude/fusengine-cache/sessions` — per-session JSON state dir. */
+function sessionsDir(home = homedir()) {
+	return join(fusengineCache(home), "sessions");
+}
+const SID_RE = /^[a-zA-Z0-9_-]{1,128}$/;
+/** Validate a session id (1-128 url-safe chars); null when invalid. */
+function sanitizeSessionId(sid) {
+	const s = String(sid ?? "").trim();
+	return SID_RE.test(s) ? s : null;
+}
+/** Unified per-session state file path: `sessions/session-<sid>.json`. */
+function sessionStatePath(sid, home = homedir()) {
+	return join(sessionsDir(home), `session-${sid}.json`);
+}
+/** Load a session-state dict, or `{}` when missing/corrupt (mirrors Python). */
+function loadSessionState(sid, home = homedir()) {
+	const path = sessionStatePath(sid, home);
+	try {
+		if (!existsSync(path)) return {};
+		const data = JSON.parse(readFileSync(path, "utf-8"));
+		return typeof data === "object" && data !== null && !Array.isArray(data) ? data : {};
+	} catch {
+		return {};
+	}
+}
+/** Atomically persist a session-state dict (0o600 via atomicWrite, indent 2). */
+function saveSessionState(sid, state, home = homedir()) {
+	mkdirSync(sessionsDir(home), {
+		recursive: true,
+		mode: 448
+	});
+	atomicWrite(sessionStatePath(sid, home), JSON.stringify(state, null, 2));
+}
+//#endregion
+//#region src/runtime/lifecycle/security/skill-state.ts
+/**
+* Shared security-tracker state: per-UTC-day JSON under
+* `~/.claude/logs/00-security`. Ports the state helpers of
+* `check-security-skill.py` / `track-skill-read.py` / `track-mcp-research.py`.
+*/
+/** `~/.claude/logs/00-security` state directory. */
+function securityStateDir(home = homedir()) {
+	return join(claudeHome(home), "logs", "00-security");
+}
+/** Current UTC date as `YYYY-MM-DD`. */
+function todayUtc(now = Date.now()) {
+	return new Date(now).toISOString().slice(0, 10);
+}
+/** Current UTC instant as `YYYY-MM-DDTHH:MM:SSZ` (seconds, no millis). */
+function isoUtc(now = Date.now()) {
+	return new Date(now).toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+/** Today's security-state file path. */
+function securityStatePath(now = Date.now(), home = homedir()) {
+	return join(securityStateDir(home), `${todayUtc(now)}-state.json`);
+}
+/** Load today's security state, or `{}` when missing/corrupt. */
+function loadSecurityState(now = Date.now(), home = homedir()) {
+	const path = securityStatePath(now, home);
+	try {
+		if (!existsSync(path)) return {};
+		const data = JSON.parse(readFileSync(path, "utf-8"));
+		return typeof data === "object" && data !== null && !Array.isArray(data) ? data : {};
+	} catch {
+		return {};
+	}
+}
+/** Persist today's security state (indent 2, no trailing newline). */
+function saveSecurityState(state, now = Date.now(), home = homedir()) {
+	mkdirSync(securityStateDir(home), { recursive: true });
+	writeFileSync(securityStatePath(now, home), JSON.stringify(state, null, 2), "utf-8");
+}
+//#endregion
 //#region src/runtime/activity.ts
 /** Min response length (chars) for a lead agent call to count as `sufficient`. */
 const AGENT_QUALITY_MIN = 500;
@@ -671,49 +753,6 @@ function taskContext(cwd) {
 	return ctx ? contextResponse("PreToolUse", ctx) : "";
 }
 //#endregion
-//#region src/runtime/home-state.ts
-/** Home `~/.claude` dir (single source for every home-based hook path). */
-function claudeHome(home = homedir()) {
-	return join(home, ".claude");
-}
-/** `~/.claude/fusengine-cache` base dir for legacy session/cache state. */
-function fusengineCache(home = homedir()) {
-	return join(claudeHome(home), "fusengine-cache");
-}
-/** `~/.claude/fusengine-cache/sessions` — per-session JSON state dir. */
-function sessionsDir(home = homedir()) {
-	return join(fusengineCache(home), "sessions");
-}
-const SID_RE = /^[a-zA-Z0-9_-]{1,128}$/;
-/** Validate a session id (1-128 url-safe chars); null when invalid. */
-function sanitizeSessionId(sid) {
-	const s = String(sid ?? "").trim();
-	return SID_RE.test(s) ? s : null;
-}
-/** Unified per-session state file path: `sessions/session-<sid>.json`. */
-function sessionStatePath(sid, home = homedir()) {
-	return join(sessionsDir(home), `session-${sid}.json`);
-}
-/** Load a session-state dict, or `{}` when missing/corrupt (mirrors Python). */
-function loadSessionState(sid, home = homedir()) {
-	const path = sessionStatePath(sid, home);
-	try {
-		if (!existsSync(path)) return {};
-		const data = JSON.parse(readFileSync(path, "utf-8"));
-		return typeof data === "object" && data !== null && !Array.isArray(data) ? data : {};
-	} catch {
-		return {};
-	}
-}
-/** Atomically persist a session-state dict (0o600 via atomicWrite, indent 2). */
-function saveSessionState(sid, state, home = homedir()) {
-	mkdirSync(sessionsDir(home), {
-		recursive: true,
-		mode: 448
-	});
-	atomicWrite(sessionStatePath(sid, home), JSON.stringify(state, null, 2));
-}
-//#endregion
 //#region src/runtime/dev-context.ts
 /** Run a git subcommand in `cwd`, returning trimmed stdout or "" on error. */
 function git(cwd, args) {
@@ -1258,7 +1297,7 @@ function trackSessionChanges(sessionIdRaw, filePath, home = homedir(), now = Dat
 //#endregion
 //#region src/runtime/lifecycle/post-edit-ts.ts
 const TS_EXT$1 = /\.(ts|tsx)$/;
-const TIMEOUT_MS$1 = 1e4;
+const TIMEOUT_MS$2 = 1e4;
 /** True when `bin` is resolvable on PATH (mirrors shutil.which). */
 function hasBin(bin) {
 	try {
@@ -1279,7 +1318,7 @@ function run(bin, args) {
 			out: execFileSync(bin, args, {
 				encoding: "utf-8",
 				stdio: "pipe",
-				timeout: TIMEOUT_MS$1
+				timeout: TIMEOUT_MS$2
 			})
 		};
 	} catch (err) {
@@ -3017,45 +3056,6 @@ function trackEnrichment(filePath) {
 	} catch {}
 }
 //#endregion
-//#region src/runtime/lifecycle/security/skill-state.ts
-/**
-* Shared security-tracker state: per-UTC-day JSON under
-* `~/.claude/logs/00-security`. Ports the state helpers of
-* `check-security-skill.py` / `track-skill-read.py` / `track-mcp-research.py`.
-*/
-/** `~/.claude/logs/00-security` state directory. */
-function securityStateDir(home = homedir()) {
-	return join(claudeHome(home), "logs", "00-security");
-}
-/** Current UTC date as `YYYY-MM-DD`. */
-function todayUtc(now = Date.now()) {
-	return new Date(now).toISOString().slice(0, 10);
-}
-/** Current UTC instant as `YYYY-MM-DDTHH:MM:SSZ` (seconds, no millis). */
-function isoUtc(now = Date.now()) {
-	return new Date(now).toISOString().replace(/\.\d{3}Z$/, "Z");
-}
-/** Today's security-state file path. */
-function securityStatePath(now = Date.now(), home = homedir()) {
-	return join(securityStateDir(home), `${todayUtc(now)}-state.json`);
-}
-/** Load today's security state, or `{}` when missing/corrupt. */
-function loadSecurityState(now = Date.now(), home = homedir()) {
-	const path = securityStatePath(now, home);
-	try {
-		if (!existsSync(path)) return {};
-		const data = JSON.parse(readFileSync(path, "utf-8"));
-		return typeof data === "object" && data !== null && !Array.isArray(data) ? data : {};
-	} catch {
-		return {};
-	}
-}
-/** Persist today's security state (indent 2, no trailing newline). */
-function saveSecurityState(state, now = Date.now(), home = homedir()) {
-	mkdirSync(securityStateDir(home), { recursive: true });
-	writeFileSync(securityStatePath(now, home), JSON.stringify(state, null, 2), "utf-8");
-}
-//#endregion
 //#region src/runtime/lifecycle/security/track-skill-read.ts
 /**
 * Security skill-read tracker (PostToolUse Read). Ports `track-skill-read.py`:
@@ -3204,6 +3204,260 @@ function securityAdvisory(tool, filePath, now = Date.now(), home = homedir()) {
 	} });
 }
 //#endregion
+//#region src/runtime/lifecycle/memory/client.ts
+/**
+* Graphiti neural-memory HTTP client (best-effort). Ports the urllib calls in
+* the memory-neural scripts: POST /episodes (store) + POST /search (recall).
+* Every call swallows network errors and honors a 5s timeout, so a hook never
+* fails or hangs when the Graphiti server is absent.
+*/
+const TIMEOUT_MS$1 = 5e3;
+/** Base URL `http://<NEURAL_MEMORY_HOST>:<GRAPHITI_PORT>` (env-overridable). */
+function neuralBase(env = process.env) {
+	return `http://${env.NEURAL_MEMORY_HOST ?? "localhost"}:${env.GRAPHITI_PORT ?? "8000"}`;
+}
+/** POST an episode to Graphiti `/episodes`. Resolves silently on any failure. */
+async function postEpisode(ep, env = process.env) {
+	try {
+		await fetch(`${neuralBase(env)}/episodes`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(ep),
+			signal: AbortSignal.timeout(TIMEOUT_MS$1)
+		});
+	} catch {}
+}
+/**
+* POST a query to Graphiti `/search`; returns hits or `[]` on any failure
+* (network error, timeout, non-2xx, malformed JSON).
+* @param query - The search query.
+* @param numResults - Max results requested.
+* @param env - Env (for host/port overrides).
+* @returns The recall hits, possibly empty.
+*/
+async function searchMemory(query, numResults, env = process.env) {
+	try {
+		const resp = await fetch(`${neuralBase(env)}/search`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				query,
+				num_results: numResults
+			}),
+			signal: AbortSignal.timeout(TIMEOUT_MS$1)
+		});
+		if (!resp.ok) return [];
+		const data = await resp.json();
+		return Array.isArray(data.results) ? data.results : [];
+	} catch {
+		return [];
+	}
+}
+/** Severity (1-10) of a Bash stderr by keyword (mirrors auto-capture-error). */
+function bashSeverity(stderr) {
+	const s = stderr.toLowerCase();
+	if (s.includes("fatal") || s.includes("panic")) return 10;
+	if (s.includes("error") || s.includes("failed")) return 8;
+	if (s.includes("warning")) return 4;
+	if (s.includes("deprecated")) return 2;
+	return 5;
+}
+/** Severity (1-10) of a finished agent by name (mirrors capture-agent-lesson). */
+function agentSeverity(name) {
+	if (name === "sniper" || name === "sniper-faster") return 8;
+	if (name === "research-expert") return 6;
+	if (name.endsWith("-expert")) return 7;
+	return 5;
+}
+/** Salience from severity: 0.40·sev/10 + 0.30 + 0.20·0.5 + 0.10·0.5. */
+function salience(severity) {
+	return .4 * severity / 10 + .3 + .2 * .5 + .1 * .5;
+}
+//#endregion
+//#region src/runtime/lifecycle/memory/state.ts
+/**
+* fuse-memory-neural scope state: per-line logs under
+* `~/.claude/logs/00-memory` + project-type detection. Ports the shared
+* filesystem helpers of the four memory-neural scripts.
+*/
+/** `~/.claude/logs/00-memory` log directory. */
+function memoryLogDir(home = homedir()) {
+	return join(claudeHome(home), "logs", "00-memory");
+}
+/**
+* Append a line to a memory log file, creating the dir. When `rotateAt > 0` and
+* the file exceeds it, keep only the newest `keep` lines. Best-effort (errors
+* swallowed), so a hook never fails on a logging issue.
+* @param name - Log file name (e.g. `operations.log`).
+* @param line - Line to append (newline added).
+* @param rotateAt - Rotate when line count exceeds this (0 disables).
+* @param keep - Lines to keep on rotation.
+* @param home - Home dir.
+*/
+function appendMemoryLog(name, line, rotateAt = 0, keep = 0, home = homedir()) {
+	const dir = memoryLogDir(home);
+	try {
+		mkdirSync(dir, { recursive: true });
+		const file = join(dir, name);
+		appendFileSync(file, `${line}\n`, "utf-8");
+		if (rotateAt > 0) {
+			const lines = readFileSync(file, "utf-8").split("\n").filter((l) => l.length > 0);
+			if (lines.length > rotateAt) writeFileSync(file, `${lines.slice(-keep).join("\n")}\n`, "utf-8");
+		}
+	} catch {}
+}
+/** Detect the project type from cwd markers (mirrors recall-on-session.py). */
+function detectProjectType(cwd) {
+	for (const [f, t] of [
+		["package.json", "node"],
+		["composer.json", "php"],
+		["Package.swift", "swift"],
+		["Cargo.toml", "rust"],
+		["go.mod", "go"]
+	]) if (existsSync(join(cwd, f))) return t;
+	if (existsSync(join(cwd, "requirements.txt")) || existsSync(join(cwd, "pyproject.toml"))) return "python";
+	return "unknown";
+}
+//#endregion
+//#region src/runtime/lifecycle/memory/agent-lesson.ts
+/**
+* SubagentStop memory handler. Ports `capture-agent-lesson.py`: log a finished
+* agent's conclusion and, when salient enough, store it as a Graphiti episode.
+* Skips explore-codebase/websearch agents and errored exits.
+*/
+/** Agents whose conclusions are never captured. */
+const SKIP = /* @__PURE__ */ new Set(["explore-codebase", "websearch"]);
+/**
+* Handle SubagentStop: log + maybe store the agent's conclusion. Side-effect
+* only (no stdout).
+* @param payload - The raw hook payload.
+* @param now - Clock.
+*/
+async function captureAgentLesson(payload, now) {
+	const name = typeof payload.agent_name === "string" ? payload.agent_name : "unknown";
+	const lastMsg = typeof payload.last_assistant_message === "string" ? payload.last_assistant_message : "";
+	const exitReason = typeof payload.exit_reason === "string" ? payload.exit_reason : "unknown";
+	if (!lastMsg || exitReason === "error" || SKIP.has(name)) return;
+	const lesson = lastMsg.slice(0, 1e3);
+	const ts = isoUtc(now);
+	appendMemoryLog("agent-lessons.log", `[${ts}] ${name} | ${exitReason} | ${lesson.slice(0, 80)}...`);
+	if (salience(agentSeverity(name)) <= .3) return;
+	await postEpisode({
+		name: "agent_lesson",
+		episode_body: `Agent ${name} conclusion: ${lesson}`,
+		source_description: `agent-stop-${name}`,
+		reference_time: ts
+	});
+}
+//#endregion
+//#region src/runtime/lifecycle/memory/capture-error.ts
+/**
+* PostToolUse (Bash) memory handler. Ports `auto-capture-error.py`: on a
+* non-zero Bash exit with stderr, store an episode in Graphiti and surface a
+* `<memory-capture>` hint to search past errors / store the eventual solution.
+*/
+/** Extract exit code + stderr from a PostToolUse Bash payload (either field). */
+function bashResult(payload) {
+	const r = payload.tool_result ?? payload.tool_response;
+	return {
+		exit: String(r?.exit_code ?? "0"),
+		stderr: typeof r?.stderr === "string" ? r.stderr : ""
+	};
+}
+/**
+* Handle a Bash PostToolUse: capture a failed command's error in neural memory
+* and return the native additionalContext stdout (or "" when nothing to emit).
+* @param payload - The raw hook payload.
+* @param now - Clock.
+* @returns The native stdout (possibly empty).
+*/
+async function captureBashError(payload, now) {
+	const { exit, stderr } = bashResult(payload);
+	if (exit === "0" || !stderr) return "";
+	if (salience(bashSeverity(stderr)) <= .3) return "";
+	const errorMsg = stderr.slice(0, 500);
+	await postEpisode({
+		name: "bash_error",
+		episode_body: `Bash error (exit ${exit}): ${errorMsg}`,
+		source_description: "auto-capture",
+		reference_time: isoUtc(now)
+	});
+	return contextResponse("PostToolUse", `Error captured in neural memory (Graphiti).\nSearch for similar past errors: use mcp__qdrant__qdrant-find with query "${errorMsg}"\nIf you solve this, store the solution: use mcp__qdrant__qdrant-store`);
+}
+//#endregion
+//#region src/runtime/lifecycle/memory/track-ops.ts
+/**
+* PostToolUse (mcp__graphiti|mcp__qdrant) memory handler. Ports
+* `track-memory-ops.py`: append `[ts] <tool> | ok|error` to
+* `operations.log`, rotating at 1000 lines (keeping the newest 500).
+*/
+/** Append a memory-operation log line for a graphiti/qdrant tool call. */
+function trackMemoryOp(payload, now) {
+	const tool = typeof payload.tool_name === "string" ? payload.tool_name : "unknown";
+	const status = (payload.tool_result ?? payload.tool_response)?.error ? "error" : "ok";
+	appendMemoryLog("operations.log", `[${isoUtc(now)}] ${tool} | ${status}`, 1e3, 500);
+}
+//#endregion
+//#region src/runtime/lifecycle/memory/recall.ts
+/**
+* SessionStart memory handler. Ports `recall-on-session.py`: detect the project
+* type, recall relevant lessons from Graphiti, log the recall, and inject a
+* neural-memory-recall additionalContext block.
+*/
+/**
+* Handle SessionStart: recall past lessons for this project and return the
+* native additionalContext stdout (or "" when there is nothing to recall).
+* @param cwd - Project root.
+* @param now - Clock.
+* @returns The native stdout (possibly empty).
+*/
+async function recallOnSession(cwd, now) {
+	const projectType = detectProjectType(cwd);
+	const projectName = basename(cwd);
+	const hits = await searchMemory(`${projectType} ${projectName} common errors`, 5);
+	appendMemoryLog("recalls.log", `[${isoUtc(now)}] session_recall | ${projectType} | ${projectName}`);
+	if (hits.length === 0) return "";
+	return contextResponse("SessionStart", `Relevant lessons from past sessions:\n${hits.slice(0, 5).map((r) => `- ${r.content || r.name || "unknown"}`).join("\n")}\nFor deeper search: use mcp__qdrant__qdrant-find with project-specific queries.`);
+}
+//#endregion
+//#region src/runtime/lifecycle/memory/dispatch.ts
+/**
+* fuse-memory-neural scope dispatcher (async; the handlers hit Graphiti over
+* HTTP, best-effort). Routes by event: SessionStart recalls past lessons,
+* PostToolUse captures Bash errors / tracks graphiti+qdrant ops, SubagentStop
+* captures agent conclusions. Returns the native stdout when handled, or `null`
+* to fall through to the generic pipeline.
+*/
+/** Is this a graphiti/qdrant MCP tool call? */
+function isMemoryTool(tool) {
+	return tool.startsWith("mcp__graphiti") || tool.startsWith("mcp__qdrant");
+}
+/**
+* Dispatch a memory-scope lifecycle event to its ported handler.
+* @param event - Raw hook event name.
+* @param payload - Raw hook payload.
+* @param cwd - Project root.
+* @param now - Clock.
+* @returns The native stdout, or `null` when unhandled.
+*/
+async function dispatchMemory(event, payload, cwd, now) {
+	if (event === "SessionStart") return recallOnSession(cwd, now);
+	if (event === "SubagentStop") {
+		await captureAgentLesson(payload, now);
+		return "";
+	}
+	if (event === "PostToolUse") {
+		const tool = typeof payload.tool_name === "string" ? payload.tool_name : "";
+		if (tool === "Bash") return captureBashError(payload, now);
+		if (isMemoryTool(tool)) {
+			trackMemoryOp(payload, now);
+			return "";
+		}
+		return null;
+	}
+	return null;
+}
+//#endregion
 //#region src/runtime/lifecycle/seo/post-tool-use.ts
 /**
 * SEO PostToolUse handler (fs effects). Ports `seo/hooks/validate-seo.ts`: on an
@@ -3819,6 +4073,27 @@ async function handlePre(ctx) {
 	};
 }
 //#endregion
+//#region src/runtime/handle-scope-async.ts
+/**
+* Pre-pipeline async scope interception for {@link handleHook}. The aipilot and
+* memory scopes reach external resources (cache files / Graphiti HTTP) and may
+* emit stdout for lifecycle events, so they run before the sync gate pipeline.
+*/
+/**
+* Run the async per-scope dispatcher for the invoking scope, if any.
+* @param scope - The invoking plugin scope.
+* @param event - The raw hook event name.
+* @param payload - The raw hook payload.
+* @param cwd - Project root.
+* @param now - Clock.
+* @returns The native stdout when intercepted, or `null` to fall through.
+*/
+async function asyncScopeStdout(scope, event, payload, cwd, now) {
+	if (scope === "aipilot") return dispatchAipilot(event, payload, cwd, now);
+	if (scope === "memory") return dispatchMemory(event, payload, cwd, now);
+	return null;
+}
+//#endregion
 //#region src/runtime/handle.ts
 /** Raw Claude hook event name from a payload (empty when absent). */
 function rawEventName(payload) {
@@ -3840,13 +4115,11 @@ 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 asyncOut = await asyncScopeStdout(opts.scope, rawEventName(payload), payload, opts.cwd, opts.now);
+	if (asyncOut !== null) return {
+		stdout: asyncOut,
+		exit: 0
+	};
 	const life = lifecycleStdout(payload, opts.cwd, opts.scope ?? "core", opts.now);
 	if (life !== null) return {
 		stdout: life,
@@ -3903,4 +4176,4 @@ async function handleHook(id, payload, opts) {
 	});
 }
 //#endregion
-export { detectSolidProfile as $, dispatchLessons as A, mcpPreIntercept as At, mergeLines as B, securityStateDir as C, defaultStateDir as Ct, dispatchLifecycle as D, MCP_TTL_MS as Dt, trackEnrichment as E, normalizeEvent 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, activityFor as Mt, cartoSessionStart as N, aipilotPostToolUse as O, isMcpTool as Ot, generateEcosystemMap as P, subagentCacheContext as Q, writeTree as R, saveSecurityState as S, recordActivity as St, todayUtc as T, trackFile 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, queryOf as jt, dispatchAipilot as k, mcpPostStore 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, projectHash$1 as wt, loadSecurityState as x, respond as xt, trackSkillRead as y, promptSubmitContext as yt, loadEnriched as z };
+export { sessionStartCore as $, writePluginMap as A, sanitizeSessionId as At, trackSessionChanges as B, aipilotPostToolUse as C, saveSecurityState as Ct, lessonsStateFileFor as D, claudeHome as Dt, lessonsFileFor as E, todayUtc as Et, mergeLines as F, validateTeammateOutput as G, cleanupSession as H, countFiles as I, detectSolidProfile as J, trackAgentMemory as K, getFileDesc as L, isProject as M, sessionStatePath as Mt, writeTree as N, sessionsDir as Nt, cartoSessionStart as O, fusengineCache as Ot, loadEnriched as P, runSessionStartCleanups as Q, listChildren as R, dispatchLifecycle as S, loadSecurityState as St, dispatchLessons as T, securityStatePath as Tt, saveApexState as U, validateRulesLoaded as V, logToolFailure as W, injectRules as X, solidDetectStart as Y, readRules as Z, postTrackingSideEffects as _, mcpPostStore as _t, TRIVIAL_BUDGET as a, gitContext as at, trackSkillRead as b, activityFor as bt, detectDuplication as c, taskContext as ct, lifecycleStdout as d, defaultStateDir as dt, pruneEmptyDirs as et, postEditContext as f, projectHash$1 as ft, securityAdvisory as g, isMcpTool as gt, dispatchMemory as h, MCP_TTL_MS as ht, REQUIRED_AGENTS as i, devContext as it, generateProjectMap as j, saveSessionState as jt, generateEcosystemMap as k, loadSessionState as kt, dryGate as l, respond as lt, seoPostToolUseResponse as m, normalizeEvent as mt, handlePre as n, removeOldFiles as nt, gate as o, projectContext as ot, seoPostToolUse as p, trackFile as pt, subagentCacheContext as q, DEFAULT_WINDOW_MS as r, trimLogFile as rt, preCommitGate as s, promptSubmitContext as st, handleHook as t, purgeTtlTree as tt, extractSymbols as u, recordActivity as ut, trackWatchResearch as v, mcpPreIntercept as vt, dispatchAipilot as w, securityStateDir as wt, trackEnrichment as x, isoUtc as xt, trackMcpResearch as y, queryOf as yt, postEditTypescript as z };

package/dist/runtime/index.d.mts

@@ -393,7 +393,7 @@ declare function aipilotPostToolUse(payload: Record<string, unknown>, cwd: strin
 //#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" | "aipilot" | "lessons" | "seo";
+type PluginScope = "core" | "solid" | "rules" | "carto" | "security" | "changelog" | "aipilot" | "lessons" | "seo" | "memory";
 /** Inputs the lifecycle dispatcher needs (clock + roots injected). */
 interface LifecycleInput {
   event: string;
@@ -589,6 +589,17 @@ declare function lessonsFileFor(root: string): string;
 /** Absolute `<root>/MEMORY/state.json` — machine-local throttle counter. */
 declare function lessonsStateFileFor(root: string): string;
 //#endregion
+//#region src/runtime/lifecycle/memory/dispatch.d.ts
+/**
+* Dispatch a memory-scope lifecycle event to its ported handler.
+* @param event - Raw hook event name.
+* @param payload - Raw hook payload.
+* @param cwd - Project root.
+* @param now - Clock.
+* @returns The native stdout, or `null` when unhandled.
+*/
+declare function dispatchMemory(event: string, payload: Record<string, unknown>, cwd: string, now: number): Promise<string | null>;
+//#endregion
 //#region src/runtime/lifecycle/seo/post-tool-use.d.ts
 /**
 * Validate the edited file's SEO completeness. Returns a deny message (for a
@@ -705,4 +716,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, aipilotPostToolUse, cartoSessionStart, claudeHome, cleanupSession, countFiles, defaultStateDir, detectDuplication, detectSolidProfile, devContext, dispatchAipilot, dispatchLessons, dispatchLifecycle, dryGate, extractSymbols, fusengineCache, gate, generateEcosystemMap, generateProjectMap, getFileDesc, gitContext, handleHook, handlePre, harnessStateDir, injectRules, isMcpTool, isProject, isoUtc, lessonsFileFor, lessonsStateFileFor, lifecycleStdout, listChildren, loadEnriched, loadSecurityState, loadSessionState, logToolFailure, mcpPostStore, mcpPreIntercept, mergeLines, normalizeEvent, postEditContext, postEditTypescript, postTrackingSideEffects, preCommitGate, projectContext, projectHash, promptSubmitContext, pruneEmptyDirs, purgeTtlTree, queryOf, readRules, recordActivity, removeOldFiles, respond, runSessionStartCleanups, sanitizeSessionId, saveApexState, saveSecurityState, saveSessionState, securityAdvisory, securityStateDir, securityStatePath, seoPostToolUse, seoPostToolUseResponse, sessionStartCore, sessionStatePath, sessionsDir, solidDetectStart, subagentCacheContext, taskContext, todayUtc, trackAgentMemory, trackEnrichment, trackFile, trackMcpResearch, trackSessionChanges, trackSkillRead, trackWatchResearch, trimLogFile, validateRulesLoaded, validateTeammateOutput, writePluginMap, 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, defaultStateDir, detectDuplication, detectSolidProfile, devContext, dispatchAipilot, dispatchLessons, dispatchLifecycle, dispatchMemory, dryGate, extractSymbols, fusengineCache, gate, generateEcosystemMap, generateProjectMap, getFileDesc, gitContext, handleHook, handlePre, harnessStateDir, injectRules, isMcpTool, isProject, isoUtc, lessonsFileFor, lessonsStateFileFor, lifecycleStdout, listChildren, loadEnriched, loadSecurityState, loadSessionState, logToolFailure, mcpPostStore, mcpPreIntercept, mergeLines, normalizeEvent, postEditContext, postEditTypescript, postTrackingSideEffects, preCommitGate, projectContext, projectHash, promptSubmitContext, pruneEmptyDirs, purgeTtlTree, queryOf, readRules, recordActivity, removeOldFiles, respond, runSessionStartCleanups, sanitizeSessionId, saveApexState, saveSecurityState, saveSessionState, securityAdvisory, securityStateDir, securityStatePath, seoPostToolUse, seoPostToolUseResponse, sessionStartCore, sessionStatePath, sessionsDir, solidDetectStart, subagentCacheContext, taskContext, todayUtc, trackAgentMemory, trackEnrichment, trackFile, trackMcpResearch, trackSessionChanges, trackSkillRead, trackWatchResearch, trimLogFile, validateRulesLoaded, validateTeammateOutput, writePluginMap, writeTree };

package/dist/runtime/index.mjs

@@ -1,5 +1,5 @@
 import { r as projectLayout } from "../layout-C0jaaCQC.mjs";
-import { $ as detectSolidProfile, A as dispatchLessons, At as mcpPreIntercept, B as mergeLines, C as securityStateDir, Ct as defaultStateDir, D as dispatchLifecycle, Dt as MCP_TTL_MS, E as trackEnrichment, Et as normalizeEvent, F as writePluginMap, G as trackSessionChanges, H as getFileDesc, I as generateProjectMap, J as saveApexState, K as validateRulesLoaded, L as isProject, M as lessonsStateFileFor, Mt as activityFor, N as cartoSessionStart, O as aipilotPostToolUse, Ot as isMcpTool, P as generateEcosystemMap, Q as subagentCacheContext, R as writeTree, S as saveSecurityState, St as recordActivity, T as todayUtc, Tt as trackFile, U as listChildren, V as countFiles, W as postEditTypescript, X as validateTeammateOutput, Y as logToolFailure, Z as trackAgentMemory, _ as trackWatchResearch, _t as sessionStatePath, a as TRIVIAL_BUDGET, at as pruneEmptyDirs, b as isoUtc, bt as taskContext, c as detectDuplication, ct as trimLogFile, d as lifecycleStdout, dt as projectContext, et as solidDetectStart, f as postEditContext, ft as claudeHome, g as postTrackingSideEffects, gt as saveSessionState, h as securityAdvisory, ht as sanitizeSessionId, i as REQUIRED_AGENTS, it as sessionStartCore, j as lessonsFileFor, jt as queryOf, k as dispatchAipilot, kt as mcpPostStore, l as dryGate, lt as devContext, m as seoPostToolUseResponse, mt as loadSessionState, n as handlePre, nt as readRules, o as gate, ot as purgeTtlTree, p as seoPostToolUse, pt as fusengineCache, q as cleanupSession, r as DEFAULT_WINDOW_MS, rt as runSessionStartCleanups, s as preCommitGate, st as removeOldFiles, t as handleHook, tt as injectRules, u as extractSymbols, ut as gitContext, v as trackMcpResearch, vt as sessionsDir, w as securityStatePath, wt as projectHash, x as loadSecurityState, xt as respond, y as trackSkillRead, yt as promptSubmitContext, z as loadEnriched } from "../handle-DMHjTY1E.mjs";
+import { $ as sessionStartCore, A as writePluginMap, At as sanitizeSessionId, B as trackSessionChanges, C as aipilotPostToolUse, Ct as saveSecurityState, D as lessonsStateFileFor, Dt as claudeHome, E as lessonsFileFor, Et as todayUtc, F as mergeLines, G as validateTeammateOutput, H as cleanupSession, I as countFiles, J as detectSolidProfile, K as trackAgentMemory, L as getFileDesc, M as isProject, Mt as sessionStatePath, N as writeTree, Nt as sessionsDir, O as cartoSessionStart, Ot as fusengineCache, P as loadEnriched, Q as runSessionStartCleanups, R as listChildren, S as dispatchLifecycle, St as loadSecurityState, T as dispatchLessons, Tt as securityStatePath, U as saveApexState, V as validateRulesLoaded, W as logToolFailure, X as injectRules, Y as solidDetectStart, Z as readRules, _ as postTrackingSideEffects, _t as mcpPostStore, a as TRIVIAL_BUDGET, at as gitContext, b as trackSkillRead, bt as activityFor, c as detectDuplication, ct as taskContext, d as lifecycleStdout, dt as defaultStateDir, et as pruneEmptyDirs, f as postEditContext, ft as projectHash, g as securityAdvisory, gt as isMcpTool, h as dispatchMemory, ht as MCP_TTL_MS, i as REQUIRED_AGENTS, it as devContext, j as generateProjectMap, jt as saveSessionState, k as generateEcosystemMap, kt as loadSessionState, l as dryGate, lt as respond, m as seoPostToolUseResponse, mt as normalizeEvent, n as handlePre, nt as removeOldFiles, o as gate, ot as projectContext, p as seoPostToolUse, pt as trackFile, q as subagentCacheContext, r as DEFAULT_WINDOW_MS, rt as trimLogFile, s as preCommitGate, st as promptSubmitContext, t as handleHook, tt as purgeTtlTree, u as extractSymbols, ut as recordActivity, v as trackWatchResearch, vt as mcpPreIntercept, w as dispatchAipilot, wt as securityStateDir, x as trackEnrichment, xt as isoUtc, y as trackMcpResearch, yt as queryOf, z as postEditTypescript } from "../handle-DL2sZiWH.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, aipilotPostToolUse, cartoSessionStart, claudeHome, cleanupSession, countFiles, defaultStateDir, detectDuplication, detectSolidProfile, devContext, dispatchAipilot, dispatchLessons, dispatchLifecycle, dryGate, extractSymbols, fusengineCache, gate, generateEcosystemMap, generateProjectMap, getFileDesc, gitContext, handleHook, handlePre, harnessStateDir, injectRules, isMcpTool, isProject, isoUtc, lessonsFileFor, lessonsStateFileFor, lifecycleStdout, listChildren, loadEnriched, loadSecurityState, loadSessionState, logToolFailure, mcpPostStore, mcpPreIntercept, mergeLines, normalizeEvent, postEditContext, postEditTypescript, postTrackingSideEffects, preCommitGate, projectContext, projectHash, promptSubmitContext, pruneEmptyDirs, purgeTtlTree, queryOf, readRules, recordActivity, removeOldFiles, respond, runSessionStartCleanups, sanitizeSessionId, saveApexState, saveSecurityState, saveSessionState, securityAdvisory, securityStateDir, securityStatePath, seoPostToolUse, seoPostToolUseResponse, sessionStartCore, sessionStatePath, sessionsDir, solidDetectStart, subagentCacheContext, taskContext, todayUtc, trackAgentMemory, trackEnrichment, trackFile, trackMcpResearch, trackSessionChanges, trackSkillRead, trackWatchResearch, trimLogFile, validateRulesLoaded, validateTeammateOutput, writePluginMap, writeTree };
+export { DEFAULT_WINDOW_MS, MCP_TTL_MS, REQUIRED_AGENTS, TRIVIAL_BUDGET, activityFor, aipilotPostToolUse, cartoSessionStart, claudeHome, cleanupSession, countFiles, defaultStateDir, detectDuplication, detectSolidProfile, devContext, dispatchAipilot, dispatchLessons, dispatchLifecycle, dispatchMemory, dryGate, extractSymbols, fusengineCache, gate, generateEcosystemMap, generateProjectMap, getFileDesc, gitContext, handleHook, handlePre, harnessStateDir, injectRules, isMcpTool, isProject, isoUtc, lessonsFileFor, lessonsStateFileFor, lifecycleStdout, listChildren, loadEnriched, loadSecurityState, loadSessionState, logToolFailure, mcpPostStore, mcpPreIntercept, mergeLines, normalizeEvent, postEditContext, postEditTypescript, postTrackingSideEffects, preCommitGate, projectContext, projectHash, promptSubmitContext, pruneEmptyDirs, purgeTtlTree, queryOf, readRules, recordActivity, removeOldFiles, respond, runSessionStartCleanups, sanitizeSessionId, saveApexState, saveSecurityState, saveSessionState, securityAdvisory, securityStateDir, securityStatePath, seoPostToolUse, seoPostToolUseResponse, sessionStartCore, sessionStatePath, sessionsDir, solidDetectStart, subagentCacheContext, taskContext, todayUtc, trackAgentMemory, trackEnrichment, trackFile, trackMcpResearch, trackSessionChanges, trackSkillRead, trackWatchResearch, trimLogFile, validateRulesLoaded, validateTeammateOutput, writePluginMap, writeTree };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fusengine/harness",
-  "version": "0.1.34",
+  "version": "0.1.36",
   "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",