@fusengine/harness 0.1.47 → 0.1.49

package/dist/session-state-DMpotbRz.d.mts

@@ -0,0 +1,73 @@
+import { t as AuthEntry } from "./doc-helpers-CEKzGg2u.mjs";
+
+//#region src/policy/apex-authorization.d.ts
+/** Pending doc-credit target written on a Check-1 deny (parity enforce-apex-phases.ts:80 `state.target`). */
+interface SessionTarget {
+  project: string;
+  framework: string;
+  set_by: string;
+  set_at: string;
+}
+//#endregion
+//#region src/tracking/session-state.d.ts
+/** Quality of a recorded agent call (the freshness gate ignores insufficient ones). */
+type AgentQuality = "sufficient" | "insufficient";
+/** Recorded session activity that feeds the APEX gates. */
+interface SessionTrack {
+  authorizations: Record<string, AuthEntry>;
+  refsRead: string[];
+  /**
+  * Epoch-ms timestamp of each reference read, keyed by `refsRead` path (parity
+  * track-solid-reads.py `solid_reads[].timestamp`). Optional: tracks persisted
+  * before this field existed only carry `refsRead`, and such paths count as
+  * read (backward compat). PARITY: only the SOLID-read gate TTL-checks these —
+  * Python TTL-izes SOLID reads exclusively (require-solid-read.py); the other
+  * refsRead consumers (skill-trigger/shadcn/tailwind/design) stay session-scoped.
+  */
+  refsReadAt?: Record<string, number>;
+  /** Framework awaiting doc credit after a Check-1 deny. PERSISTS — {@link recordDoc} cross-credits it on EVERY consultation, never clears it; only the next deny replaces it via {@link recordTarget} (parity track-doc-consultation.py:62). */
+  target?: SessionTarget;
+  agents: {
+    name: string;
+    ts: number;
+    quality?: AgentQuality;
+  }[];
+  trivialEdits: number[];
+  brainstormRequired?: boolean;
+}
+/** A fresh, empty track. */
+declare function emptyTrack(): SessionTrack;
+/**
+* Record a doc consultation (Context7/Exa/web) for a framework in this session:
+* the Check-2 credit (`doc_sessions` + `sources`) plus the Check-1 stamp
+* (`sessions` + `doc_consulted` = ISO of `now`). PARITY track-doc-consultation.py
+* :62-70 — a `target` left by a Check-1 deny (enforce-apex-phases.ts:80) is
+* cross-credited on EVERY consultation, with NO TTL on `target.set_at`, and the
+* target PERSISTS (only the next deny replaces it via {@link recordTarget});
+* single-shot clearing or TTL-gating the target re-opened the deny loop when a
+* consultation landed > TTL after the deny. Immutable.
+*/
+declare function recordDoc(track: SessionTrack, framework: string, sessionId: string, source: string, now?: number): SessionTrack;
+/** Set the pending doc-credit target (written by the runtime on a Check-1 deny). Immutable. */
+declare function recordTarget(track: SessionTrack, target: SessionTarget): SessionTrack;
+/**
+* Record that a SOLID reference file was read (deduped). Immutable. When `now`
+* (epoch ms — the tool event's own timestamp, never a fresh `Date.now()`) is
+* supplied, the read is stamped in `refsReadAt`, refreshed on re-reads so the
+* LATEST read drives the SOLID TTL (parity track-solid-reads.py, which appends
+* a timestamped entry per read; require-solid-read.py checks the most recent).
+* Callers that omit `now` keep the legacy untimestamped behavior.
+*/
+declare function recordRefRead(track: SessionTrack, path: string, now?: number): SessionTrack;
+/** Record an agent/tool call with a timestamp + optional quality. Immutable. */
+declare function recordAgent(track: SessionTrack, name: string, ts: number, quality?: AgentQuality): SessionTrack;
+/** True when ALL of `names` ran within `windowMs` with non-insufficient quality. */
+declare function agentsFresh(track: SessionTrack, names: string[], windowMs: number, now: number): boolean;
+/** Record a trivial edit timestamp (sliding window; old evicted). Immutable. */
+declare function recordTrivialEdit(track: SessionTrack, ts: number, windowMs: number, now: number): SessionTrack;
+/** Count trivial edits within the sliding window. */
+declare function trivialCount(track: SessionTrack, windowMs: number, now: number): number;
+/** Set the brainstorm-required flag (from creation-intent detection). Immutable. */
+declare function recordBrainstormRequired(track: SessionTrack, required: boolean): SessionTrack;
+//#endregion
+export { recordAgent as a, recordRefRead as c, trivialCount as d, emptyTrack as i, recordTarget as l, SessionTrack as n, recordBrainstormRequired as o, agentsFresh as r, recordDoc as s, AgentQuality as t, recordTrivialEdit as u };

package/dist/skill-path-DhItkBzk.mjs

@@ -0,0 +1,95 @@
+import { t as HOME_DIR } from "./dotenv-Jj8aL1FL.mjs";
+import { t as detectHarness } from "./harness-Cb9xR8dC.mjs";
+import { l as PLUGINS_DIR } from "./home-state-D0RLWP8J.mjs";
+import { join } from "node:path";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+//#region src/runtime/lifecycle/cartographer/detect.ts
+/**
+* Plugin discovery (fs). Ports `detect_plugins.py`: marketplace `plugins` dir
+* resolution + `plugin.json` meta reading.
+*/
+/** Sorted entry names of `dir` (alpha, byte-order), or `[]` on error. */
+function sortedNames(dir) {
+	try {
+		return readdirSync(dir).sort((a, b) => a.localeCompare(b, "en"));
+	} catch {
+		return [];
+	}
+}
+/**
+* Read `[version, name]` from `<pluginPath>/.claude-plugin/plugin.json`.
+* @param pluginPath - Absolute plugin directory.
+* @returns The `[version, name]` pair (both "" when absent/unreadable).
+*/
+function readPluginMeta(pluginPath) {
+	const pj = join(pluginPath, ".claude-plugin", "plugin.json");
+	if (!existsSync(pj)) return ["", ""];
+	try {
+		const meta = JSON.parse(readFileSync(pj, "utf-8"));
+		return [meta.version ?? "", meta.name ?? ""];
+	} catch {
+		return ["", ""];
+	}
+}
+/**
+* Auto-detect the marketplace `plugins` dir that contains `cartographer`,
+* falling back to the first marketplace with a `plugins` dir, else `cwd`.
+* Ports `find_marketplace_plugins`, but harness-agnostic: the config dir is
+* derived from the detected harness (`.claude`, `.codex`, `.cursor`, …) via the
+* shared `HOME_DIR` mapping instead of a hardcoded `.claude`.
+* @param home - Home directory (defaults to `~`).
+* @param id - Detected harness id (defaults to runtime detection).
+* @returns The resolved plugins directory.
+*/
+function findMarketplacePlugins(home = homedir(), id = detectHarness().id) {
+	const mp = join(home, HOME_DIR[id] ?? ".claude", "plugins", "marketplaces");
+	const markets = sortedNames(mp);
+	for (const m of markets) if (existsSync(join(mp, m, "plugins", "cartographer"))) return join(mp, m, "plugins");
+	for (const m of markets) if (existsSync(join(mp, m, "plugins"))) return join(mp, m, "plugins");
+	return process.cwd();
+}
+//#endregion
+//#region src/policy/skill-path.ts
+/**
+* Dynamic skill-path resolution (fs). Replaces a hardcoded `PLUGIN_DIR`
+* table (framework -> plugin dir name), which can drift from what's actually
+* installed: scans installed marketplace plugins for a `skills/<name>/SKILL.md`
+* that exists ON DISK, returning the first real absolute path found — never a
+* guessed one.
+*
+* Deliberately lighter than the cartographer's own `scanSkills` (which
+* frontmatter-parses every skill in a plugin): this runs once per missing
+* sub-skill on every gated Write/Edit, so it does a single flat `readdirSync`
+* of the plugins dir + one `existsSync` per candidate — no file reads, no
+* recursion, no `statSync`.
+*/
+/** Sorted entry names of `dir` (alpha, byte-order), or `[]` on error. */
+function pluginDirNames(dir) {
+	try {
+		return readdirSync(dir).sort((a, b) => a.localeCompare(b, "en"));
+	} catch {
+		return [];
+	}
+}
+/**
+* Resolve the real, installed `SKILL.md` path for `skillName`.
+* @param skillName - the sub-skill directory name (e.g. "solid-react",
+*   "shadcn-detection", "react-shadcn").
+* @param pluginsDirOverride - override for the marketplace plugins dir
+*   (tests); defaults to the auto-detected marketplace root.
+* @returns the absolute `<pluginDir>/skills/<skillName>/SKILL.md` of the
+*   first installed plugin that actually has it, or the generic
+*   `${PLUGINS_DIR}/<skillName>` fallback when none is found (CI/test
+*   environments without a marketplace).
+*/
+function resolveSkillPath(skillName, pluginsDirOverride) {
+	const pluginsDir = pluginsDirOverride ?? findMarketplacePlugins();
+	for (const dir of pluginDirNames(pluginsDir)) {
+		const candidate = join(pluginsDir, dir, "skills", skillName, "SKILL.md");
+		if (existsSync(candidate)) return candidate;
+	}
+	return `${PLUGINS_DIR}/${skillName}`;
+}
+//#endregion
+export { findMarketplacePlugins as n, readPluginMeta as r, resolveSkillPath as t };

package/dist/store-QSSTO3lY.mjs

@@ -0,0 +1,349 @@
+import { c as ttlLabel } from "./dotenv-Jj8aL1FL.mjs";
+import { n as fuseHarnessHome } from "./home-state-D0RLWP8J.mjs";
+import { a as writeJsonFile, i as readJsonFile } from "./json-io-DisYd2fb.mjs";
+import { i as resolveSessions } from "./doc-helpers-CWZegVdR.mjs";
+import { t as routeReferences } from "./router-PKVNBHge.mjs";
+import { t as resolveSkillPath } from "./skill-path-DhItkBzk.mjs";
+import { join } from "node:path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { createHmac, randomBytes } from "node:crypto";
+//#region src/policy/skill-source.ts
+/**
+* Framework -> SKILL.md doc source for the APEX Check-1 non-routed deny —
+* parity with the Python plugin's enforce-helpers.ts `getSkillSource()`
+* (10-entry map, fallback "mcp__context7__query-docs"). The map is ported
+* faithfully as skill NAMES only: disk paths are resolved DYNAMICALLY via
+* {@link resolveSkillPath} (proprietary rule — no static path table; installed
+* plugin dir names differ from upstream's `react-expert/...`, and a hardcoded
+* table drifts from what is actually installed).
+*/
+/**
+* Fallback doc source when no SKILL.md can be promised: the consigne to query
+* context7 (a TOOL name, not a path) — parity enforce-helpers.ts:51.
+*/
+const CONTEXT7_SOURCE = "mcp__context7__query-docs";
+/**
+* Framework -> sub-skill dir name, faithful to the Python
+* `getSkillSource` map (enforce-helpers.ts:39-50, all 10 entries).
+*/
+const SKILL_NAMES = {
+	react: "react-19",
+	nextjs: "nextjs-16",
+	swift: "swiftui-components",
+	laravel: "laravel-eloquent",
+	tailwind: "tailwindcss-v4",
+	generic: "solid-generic",
+	java: "solid-java",
+	go: "solid-go",
+	ruby: "solid-ruby",
+	rust: "solid-rust"
+};
+/**
+* The doc source a Check-1 deny may promise for `framework` (parity
+* `getSkillSource`): the REAL installed SKILL.md absolute path when it exists
+* on disk, else {@link CONTEXT7_SOURCE}. `resolveSkillPath` returns a
+* `/SKILL.md`-suffixed path ONLY on an `existsSync` hit; its
+* `${PLUGINS_DIR}/<name>` not-found fallback (no marketplace installed, or a
+* mapped skill absent on disk — e.g. upstream's `swiftui-components`) is
+* converted to the context7 consigne here, because a deny must never promise
+* a nonexistent path (every option a deny offers must actually unblock).
+* @param framework - Detected framework (the `detectFramework()` domain).
+* @param pluginsDirOverride - Marketplace plugins dir override (tests).
+*/
+function getSkillSource(framework, pluginsDirOverride) {
+	const name = SKILL_NAMES[framework];
+	if (!name) return CONTEXT7_SOURCE;
+	const path = resolveSkillPath(name, pluginsDirOverride);
+	return path.endsWith("/SKILL.md") ? path : CONTEXT7_SOURCE;
+}
+//#endregion
+//#region src/policy/apex-authorization.ts
+/**
+* Credit a doc consultation onto one framework's auth entry (parity
+* track-doc-consultation.py): the once-per-session Check-2 fields
+* (`doc_sessions` + `sources`) plus the per-framework Check-1 stamp
+* (`sessions` + `doc_consulted`). Pure.
+*/
+function creditDocConsultation(prev, sessionId, source, nowIso) {
+	const p = prev ?? {};
+	const add = (list, v) => v && !list.includes(v) ? [...list, v] : list;
+	return {
+		...p,
+		sessions: add(resolveSessions(p), sessionId),
+		doc_sessions: add(p.doc_sessions ?? [], sessionId),
+		sources: add(p.sources ?? (p.source ? [p.source] : []), source),
+		doc_consulted: nowIso
+	};
+}
+/**
+* Check 1 (parity enforce-apex-phases.ts isAuthorized): the framework's doc or
+* skill was consulted in THIS session (resolveSessions) AND the stamp is
+* younger than the TTL (FUSE_ENFORCE_TTL_SEC via src/config/ttl.ts).
+*/
+function isAuthorized(auth, sessionId, now, ttlMs) {
+	if (!auth?.doc_consulted || !resolveSessions(auth).includes(sessionId)) return false;
+	const readEpoch = Date.parse(auth.doc_consulted);
+	return !Number.isNaN(readEpoch) && now - readEpoch < ttlMs;
+}
+/**
+* A fresh same-session `skills/**.md` read whose path names the framework also
+* satisfies Check 1 (parity track-doc-consultation.py, which stamps
+* `doc_consulted` on `skills/.*\.md` Reads; the harness records those Reads in
+* `refsRead`/`refsReadAt` instead, and the track file is per-session).
+*/
+function skillReadAuthorized(ctx, now, ttlMs) {
+	const nameRe = new RegExp(`\\b(${{
+		laravel: "laravel|php",
+		tailwind: "tailwindcss?"
+	}[ctx.framework] ?? ctx.framework})\\b`, "i");
+	return (ctx.refsRead ?? []).some((p) => {
+		if (!/skills\/.*\.md$/i.test(p) || !nameRe.test(p)) return false;
+		const at = ctx.refsReadAt?.[p];
+		return at !== void 0 && now - at < ttlMs;
+	});
+}
+/**
+* Gate (Check 1): deny until the framework's doc/skill is freshly consulted.
+* The deny lists the routed SOLID refs when refs are loaded (parity
+* formatRoutedDeny), else the framework's skill source (parity getSkillSource:
+* a real installed SKILL.md path, or the context7 consigne). The RUNTIME
+* caller persists `state.target` on deny (recordTarget, parity :80-81) so
+* recordDoc can cross-credit this framework on the next doc consultation.
+*/
+const apexAuthorizationGate = (ctx) => {
+	const windowMs = ctx.windowMs ?? 120 * 1e3;
+	const now = ctx.now ?? Date.now();
+	if (isAuthorized(ctx.authorizations?.[ctx.framework], ctx.sessionId, now, windowMs)) return null;
+	if (skillReadAuthorized(ctx, now, windowMs)) return null;
+	const ttl = ttlLabel(Math.round(windowMs / 1e3));
+	const title = `APEX: ${ctx.framework} documentation required`;
+	const routed = ctx.refs?.length ? routeReferences(ctx.refs, ctx.filePath, ctx.content) : null;
+	if (!routed) {
+		const src = getSkillSource(ctx.framework);
+		return {
+			kind: "block",
+			title,
+			reason: `APEX: Read doc first (expires every ${ttl}) for ${ctx.framework}! Source: ${src}`,
+			actions: [src === "mcp__context7__query-docs" ? `Query ${CONTEXT7_SOURCE} for ${ctx.framework} docs` : `Read ${src}`]
+		};
+	}
+	const optional = routed.optional.map((r) => r.meta.filePath);
+	return {
+		kind: "block",
+		title,
+		reason: [
+			`APEX: Read specific SOLID references (expires every ${ttl}) for ${ctx.framework}.`,
+			`Editing: ${ctx.filePath}`,
+			...optional.length ? [`Optional: ${optional.join(", ")}`] : [],
+			`Full skill: ${routed.skillPath}`
+		].join("\n"),
+		actions: routed.required.map((r) => r.meta.filePath)
+	};
+};
+//#endregion
+//#region src/tracking/session-state.ts
+/** A fresh, empty track. */
+function emptyTrack() {
+	return {
+		authorizations: {},
+		refsRead: [],
+		agents: [],
+		trivialEdits: []
+	};
+}
+/**
+* Record a doc consultation (Context7/Exa/web) for a framework in this session:
+* the Check-2 credit (`doc_sessions` + `sources`) plus the Check-1 stamp
+* (`sessions` + `doc_consulted` = ISO of `now`). PARITY track-doc-consultation.py
+* :62-70 — a `target` left by a Check-1 deny (enforce-apex-phases.ts:80) is
+* cross-credited on EVERY consultation, with NO TTL on `target.set_at`, and the
+* target PERSISTS (only the next deny replaces it via {@link recordTarget});
+* single-shot clearing or TTL-gating the target re-opened the deny loop when a
+* consultation landed > TTL after the deny. Immutable.
+*/
+function recordDoc(track, framework, sessionId, source, now = Date.now()) {
+	const nowIso = new Date(now).toISOString();
+	const authorizations = {
+		...track.authorizations,
+		[framework]: creditDocConsultation(track.authorizations[framework], sessionId, source, nowIso)
+	};
+	const t = track.target;
+	if (t && t.framework !== framework) authorizations[t.framework] = creditDocConsultation(track.authorizations[t.framework], sessionId, source, nowIso);
+	return {
+		...track,
+		authorizations
+	};
+}
+/** Set the pending doc-credit target (written by the runtime on a Check-1 deny). Immutable. */
+function recordTarget(track, target) {
+	return {
+		...track,
+		target
+	};
+}
+/**
+* Record that a SOLID reference file was read (deduped). Immutable. When `now`
+* (epoch ms — the tool event's own timestamp, never a fresh `Date.now()`) is
+* supplied, the read is stamped in `refsReadAt`, refreshed on re-reads so the
+* LATEST read drives the SOLID TTL (parity track-solid-reads.py, which appends
+* a timestamped entry per read; require-solid-read.py checks the most recent).
+* Callers that omit `now` keep the legacy untimestamped behavior.
+*/
+function recordRefRead(track, path, now) {
+	const refsRead = track.refsRead.includes(path) ? track.refsRead : [...track.refsRead, path];
+	if (now === void 0) return refsRead === track.refsRead ? track : {
+		...track,
+		refsRead
+	};
+	return {
+		...track,
+		refsRead,
+		refsReadAt: {
+			...track.refsReadAt,
+			[path]: now
+		}
+	};
+}
+/** Record an agent/tool call with a timestamp + optional quality. Immutable. */
+function recordAgent(track, name, ts, quality) {
+	const entry = quality ? {
+		name,
+		ts,
+		quality
+	} : {
+		name,
+		ts
+	};
+	return {
+		...track,
+		agents: [...track.agents, entry]
+	};
+}
+/** True when ALL of `names` ran within `windowMs` with non-insufficient quality. */
+function agentsFresh(track, names, windowMs, now) {
+	const cutoff = now - windowMs;
+	return names.every((n) => track.agents.some((a) => a.name === n && a.ts > cutoff && a.quality !== "insufficient"));
+}
+/** Record a trivial edit timestamp (sliding window; old evicted). Immutable. */
+function recordTrivialEdit(track, ts, windowMs, now) {
+	const cutoff = now - windowMs;
+	return {
+		...track,
+		trivialEdits: [...(track.trivialEdits ?? []).filter((t) => t > cutoff), ts]
+	};
+}
+/** Count trivial edits within the sliding window. */
+function trivialCount(track, windowMs, now) {
+	const cutoff = now - windowMs;
+	return (track.trivialEdits ?? []).filter((t) => t > cutoff).length;
+}
+/** Set the brainstorm-required flag (from creation-intent detection). Immutable. */
+function recordBrainstormRequired(track, required) {
+	return {
+		...track,
+		brainstormRequired: required
+	};
+}
+//#endregion
+//#region src/tracking/integrity.ts
+/**
+* @module integrity
+* HMAC-SHA256 tamper-evident wrapping for {@link SessionTrack}.
+*
+* Failure policy: ONLY a MAC mismatch causes fail-closed (returns null).
+* The nonce is included in the signed payload and written to disk for advisory
+* diagnostics, but is NOT checked during verification — concurrent hook
+* invocations (PostToolUse, SubagentStop, …) legitimately load the same
+* envelope after the nonce watermark advances; a monotonic check would trigger
+* spurious fail-closed behaviour mid-session.
+*
+* The machine key is readable by the same agent process, so this deters naive
+* out-of-band tampering — not a determined re-sign. Item B (transcript-grounded
+* freshness) is the primary guarantee.
+* @packageDocumentation
+*/
+const HARNESS_DIR = fuseHarnessHome();
+const KEY_PATH = join(HARNESS_DIR, ".key");
+const NONCE_PATH = join(HARNESS_DIR, ".nonce");
+/** Load (or create on first use) the per-machine HMAC key stored at mode 0600. */
+function loadOrCreateKey() {
+	mkdirSync(HARNESS_DIR, { recursive: true });
+	if (!existsSync(KEY_PATH)) {
+		const key = randomBytes(32).toString("hex");
+		writeFileSync(KEY_PATH, key, {
+			encoding: "utf8",
+			mode: 384
+		});
+		return key;
+	}
+	return readFileSync(KEY_PATH, "utf8").trim();
+}
+/**
+* Persist the last-seen nonce for advisory diagnostics (mode 0600).
+* Never read during {@link verifyTrack} — see module JSDoc for rationale.
+*/
+function writeLastNonce(nonce) {
+	mkdirSync(HARNESS_DIR, { recursive: true });
+	writeFileSync(NONCE_PATH, String(nonce), {
+		encoding: "utf8",
+		mode: 384
+	});
+}
+/** Compute HMAC-SHA256 over the canonical message `"${nonce}:${data}"`. */
+function computeMac(key, data, nonce) {
+	return createHmac("sha256", key).update(`${nonce}:${data}`).digest("hex");
+}
+/**
+* Sign a {@link SessionTrack} into a tamper-evident envelope. The nonce
+* (`Date.now()`) is embedded in the MAC to bind the timestamp to the payload.
+*/
+function signTrack(track) {
+	const key = loadOrCreateKey();
+	const data = JSON.stringify(track);
+	const nonce = Date.now();
+	return {
+		data,
+		nonce,
+		mac: computeMac(key, data, nonce)
+	};
+}
+/**
+* Verify a {@link TrackEnvelope}. Returns the parsed {@link SessionTrack} on
+* success, or `null` ONLY on MAC mismatch / parse failure (fail-closed on
+* tampering). The nonce is NOT checked — see module JSDoc.
+*/
+function verifyTrack(envelope) {
+	try {
+		const key = loadOrCreateKey();
+		if (envelope.mac !== computeMac(key, envelope.data, envelope.nonce)) return null;
+		return JSON.parse(envelope.data);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/tracking/store.ts
+/**
+* Load and verify a session track from a signed envelope file.
+*
+* Returns {@link emptyTrack} (fail closed) when the file is absent, corrupt, or
+* fails MAC validation — so the gates re-require real agents rather than trust a
+* forged track. Only a MAC mismatch triggers fail-closed; the nonce is advisory
+* and is never checked during load.
+*/
+async function loadTrack(file) {
+	const envelope = await readJsonFile(file);
+	if (!envelope) return emptyTrack();
+	return verifyTrack(envelope) ?? emptyTrack();
+}
+/**
+* Sign and persist a session track as a tamper-evident envelope, then write the
+* advisory nonce watermark.
+*/
+async function saveTrack(file, track) {
+	const envelope = signTrack(track);
+	await writeJsonFile(file, envelope);
+	writeLastNonce(envelope.nonce);
+}
+//#endregion
+export { emptyTrack as a, recordDoc as c, recordTrivialEdit as d, trivialCount as f, agentsFresh as i, recordRefRead as l, saveTrack as n, recordAgent as o, apexAuthorizationGate as p, verifyTrack as r, recordBrainstormRequired as s, loadTrack as t, recordTarget as u };

package/dist/tracking/index.d.mts

@@ -1,4 +1,4 @@
-import { a as recordAgent, c as recordRefRead, i as emptyTrack, l as recordTrivialEdit, n as SessionTrack, o as recordBrainstormRequired, r as agentsFresh, s as recordDoc, t as AgentQuality, u as trivialCount } from "../session-state-D4F_Dub6.mjs";
+import { a as recordAgent, c as recordRefRead, d as trivialCount, i as emptyTrack, l as recordTarget, n as SessionTrack, o as recordBrainstormRequired, r as agentsFresh, s as recordDoc, t as AgentQuality, u as recordTrivialEdit } from "../session-state-DMpotbRz.mjs";
 
 //#region src/tracking/store.d.ts
 /**
@@ -16,4 +16,4 @@ declare function loadTrack(file: string): Promise<SessionTrack>;
 */
 declare function saveTrack(file: string, track: SessionTrack): Promise<void>;
 //#endregion
-export { AgentQuality, SessionTrack, agentsFresh, emptyTrack, loadTrack, recordAgent, recordBrainstormRequired, recordDoc, recordRefRead, recordTrivialEdit, saveTrack, trivialCount };
+export { AgentQuality, SessionTrack, agentsFresh, emptyTrack, loadTrack, recordAgent, recordBrainstormRequired, recordDoc, recordRefRead, recordTarget, recordTrivialEdit, saveTrack, trivialCount };

package/dist/tracking/index.mjs

@@ -1,2 +1,2 @@
-import { a as emptyTrack, c as recordDoc, d as trivialCount, i as agentsFresh, l as recordRefRead, n as saveTrack, o as recordAgent, s as recordBrainstormRequired, t as loadTrack, u as recordTrivialEdit } from "../store-CNjFenWe.mjs";
-export { agentsFresh, emptyTrack, loadTrack, recordAgent, recordBrainstormRequired, recordDoc, recordRefRead, recordTrivialEdit, saveTrack, trivialCount };
+import { a as emptyTrack, c as recordDoc, d as recordTrivialEdit, f as trivialCount, i as agentsFresh, l as recordRefRead, n as saveTrack, o as recordAgent, s as recordBrainstormRequired, t as loadTrack, u as recordTarget } from "../store-QSSTO3lY.mjs";
+export { agentsFresh, emptyTrack, loadTrack, recordAgent, recordBrainstormRequired, recordDoc, recordRefRead, recordTarget, recordTrivialEdit, saveTrack, trivialCount };

package/dist/{types-D56jSgD9.d.mts → types-DVbIl9md.d.mts}

@@ -14,6 +14,12 @@ interface Prompt {
   reason: string;
   /** Concrete next actions to proceed. */
   actions?: string[];
+  /**
+  * User-facing notice (Python `hook_output.allow_pass`/`post_pass` parity):
+  * shown to the HUMAN — Claude Code's `systemMessage` — never to the agent,
+  * unlike `reason`/additionalContext. Excluded from {@link formatPrompt}.
+  */
+  userMessage?: string;
 }
 /** Render a {@link Prompt} as a consistent, agent-readable memo block. */
 declare function formatPrompt(p: Prompt): string;