memhtml 0.5.0 → 0.5.1

package/dist/{dist-D5DlgqH2.mjs → dist-DgKlozi6.mjs}

@@ -9021,17 +9021,42 @@ const keyMembers = (items, textOf, options) => {
 	};
 };
 /**
+* The offered key a model's answer denotes, or `undefined` when it denotes none.
+*
+* A model shown `<member_m3>` answers `member_m3` at least as readily as `m3`: the wrapper tag is
+* the only place most batch prompts DISPLAY a key, so the label-prefixed form is the one the prompt
+* itself teaches (measured live 2026-08-23: `gpt-5.6-sol` answers the prefixed form on every call,
+* Claude Sonnet 5 on most). So a key that does not match directly is retried once with everything
+* up to its last `_` stripped, and only a suffix the batch actually offered resolves — `member_m9`
+* in a batch of three still denotes nothing, and a path or an invented name still drops. The
+* canonical form is returned so two spellings of one member collapse to one key everywhere a phase
+* keeps per-key state.
+*/
+const offeredKeyFor = (batch, key) => {
+	if (batch.itemForKey.has(key)) return key;
+	const at = key.lastIndexOf("_");
+	if (at === -1) return void 0;
+	const suffix = key.slice(at + 1);
+	return batch.itemForKey.has(suffix) ? suffix : void 0;
+};
+/**
 * Resolve the keys a model named back to items: unknown keys are dropped, repeats collapse.
 *
 * A key the batch never offered is a member the model invented, and every phase on this kernel turns
 * a named member into a write, so an unresolvable key must not reach that write. Dropping it leaves
 * the corresponding file untouched, which is the safe outcome for every one of the five phases.
+* Resolution goes through {@link offeredKeyFor}, so the label-prefixed spelling of an offered key
+* (`member_m3` for `m3`) resolves rather than reading as an invention.
 *
 * The result keeps the order the model named the keys in, and a key named twice appears once.
-* De-duplication is on the KEY rather than on the resolved item, so the count a phase gates on
-* ("at least two members absorbed") counts distinct offered members.
-*/
-const resolveKeys = (batch, keys) => [...new Set(keys)].flatMap((key) => {
+* De-duplication is on the CANONICAL key rather than on the spelling or the resolved item, so `m1`
+* and `member_m1` in one answer count as one member, and the count a phase gates on ("at least two
+* members absorbed") counts distinct offered members.
+*/
+const resolveKeys = (batch, keys) => [...new Set(keys.flatMap((key) => {
+	const canonical = offeredKeyFor(batch, key);
+	return canonical === void 0 ? [] : [canonical];
+}))].flatMap((key) => {
 	const item = batch.itemForKey.get(key);
 	return item === void 0 ? [] : [item];
 });
@@ -11038,7 +11063,9 @@ const compress = (env) => Effect.gen(function* () {
 		batches: batches.length,
 		canonicals: 0,
 		archived: 0,
-		skipped: 0
+		skipped: 0,
+		failed: 0,
+		refused: 0
 	};
 	if (batches.length === 0) return emptyOutcome(counts);
 	if (env.dryRun) return emptyOutcome(counts);
@@ -11046,7 +11073,16 @@ const compress = (env) => Effect.gen(function* () {
 	let llmCalls = 0;
 	let canonicals = 0;
 	let archived = 0;
+	/**
+	* `skipped` stays the total, and `failed` + `refused` partition it. The two are different
+	* diagnoses with different fixes — a failed call is the model or the wire (already logged by
+	* `isolate`), a refusal is an answer the phase declined to act on (logged below) — and a night
+	* reporting only their sum cannot say which one it had. 47 of 47 batches once skipped as
+	* refusals with nothing on stderr, and the sum read as flaky calls.
+	*/
 	let skipped = 0;
+	let failed = 0;
+	let refused = 0;
 	let lastCommit = null;
 	for (const batch of batches) {
 		/** Opaque keys again, so `absorbedKeys` cannot name a path. */
@@ -11062,12 +11098,15 @@ const compress = (env) => Effect.gen(function* () {
 		});
 		if (synthesis === void 0) {
 			skipped += 1;
+			failed += 1;
 			continue;
 		}
 		/** A key the batch never offered resolves to nothing, so a fold reaches only offered files. */
 		const absorbed = resolveKeys(keyed, synthesis.absorbedKeys).map((entry) => entry.row.path);
 		if (absorbed.length < 2 || synthesis.title.trim() === "" || synthesis.claim.trim() === "") {
 			skipped += 1;
+			refused += 1;
+			yield* Effect.logWarning(`sleep.llm compress batch of ${batch.length} refused: the model absorbed ${absorbed.length} of ${synthesis.absorbedKeys.length} named keys` + (synthesis.absorbedKeys.length > 0 && absorbed.length === 0 ? ` (none of the named keys resolved: ${synthesis.absorbedKeys.slice(0, 3).join(", ")}${synthesis.absorbedKeys.length > 3 ? ", …" : ""})` : ""));
 			continue;
 		}
 		/**
@@ -11080,6 +11119,8 @@ const compress = (env) => Effect.gen(function* () {
 		const members = excludeSelfSupersede(canonicalPath, absorbed);
 		if (members.length === 0) {
 			skipped += 1;
+			refused += 1;
+			yield* Effect.logWarning(`sleep.llm compress batch of ${batch.length} refused: every absorbed member was the canonical itself`);
 			continue;
 		}
 		/**
@@ -11094,6 +11135,8 @@ const compress = (env) => Effect.gen(function* () {
 		}
 		if (archivedPaths.length === 0) {
 			skipped += 1;
+			refused += 1;
+			yield* Effect.logWarning(`sleep.llm compress batch of ${batch.length} refused: every member was already gone from the tree`);
 			continue;
 		}
 		yield* writeFileBytes(env, canonicalPath, renderTemplate({
@@ -11112,7 +11155,9 @@ const compress = (env) => Effect.gen(function* () {
 			...counts,
 			canonicals,
 			archived,
-			skipped
+			skipped,
+			failed,
+			refused
 		});
 		if (commitSha !== null) lastCommit = commitSha;
 	}
@@ -11121,7 +11166,9 @@ const compress = (env) => Effect.gen(function* () {
 			...counts,
 			canonicals,
 			archived,
-			skipped
+			skipped,
+			failed,
+			refused
 		},
 		commitSha: lastCommit,
 		llmCalls
@@ -12032,7 +12079,9 @@ const dedupMerge = (env) => Effect.gen(function* () {
 				candidates: oriented.length,
 				components: 0,
 				llmGroups: 0,
-				vetoed: oriented.length - decisions.length
+				vetoed: oriented.length - decisions.length,
+				skipped: 0,
+				unresolved: 0
 			},
 			/**
 			* Every mined pair on this arm cleared 0.92, so a vetoed one here is a near-certain duplicate
@@ -12103,6 +12152,12 @@ const dedupMerge = (env) => Effect.gen(function* () {
 	let llmCalls = 0;
 	let llmGroups = 0;
 	let skipped = 0;
+	/**
+	* Model-named member keys that resolved to no offered member, dropped unacted. The drop is the
+	* safe outcome and stays; the count makes a systematic naming pattern visible instead of reading
+	* as a night in which the model proposed no merges (issue #58).
+	*/
+	let unresolved = 0;
 	/** Group-implied pairs, in batch then component then group order. */
 	const groupPairs = [];
 	/** Every path a surviving group claimed, so the mined arm cannot re-propose one. */
@@ -12142,11 +12197,17 @@ const dedupMerge = (env) => Effect.gen(function* () {
 			skipped += 1;
 			continue;
 		}
+		/** This batch's unresolvable keys, so the warning below can name the spellings that failed. */
+		const unresolvedKeys = [];
 		for (const group of partition.groups) {
+			const dropped = group.memberKeys.filter((key) => offeredKeyFor(keyed, key) === void 0);
+			unresolved += dropped.length;
+			unresolvedKeys.push(...dropped);
 			const members = resolveKeys(keyed, group.memberKeys);
 			if (members.length < 2) continue;
 			if (new Set(group.memberKeys.flatMap((key) => {
-				const id = componentOfKey.get(key);
+				const canonical = offeredKeyFor(keyed, key);
+				const id = canonical === void 0 ? void 0 : componentOfKey.get(canonical);
 				return id === void 0 ? [] : [id];
 			})).size !== 1) continue;
 			/** The keeper is the OLDEST member: the lowest corpus offset, the same rule a pair uses. */
@@ -12172,6 +12233,7 @@ const dedupMerge = (env) => Effect.gen(function* () {
 			}
 			grouped.add(keeper.path);
 		}
+		if (unresolvedKeys.length > 0) yield* Effect.logWarning(`sleep.llm dedup batch of ${batch.length} components dropped ${unresolvedKeys.length} member keys naming no offered member (${unresolvedKeys.slice(0, 3).join(", ")}${unresolvedKeys.length > 3 ? ", …" : ""})`);
 	}
 	/**
 	* Groups first, then the mined pairs above the DETERMINISTIC floor that no group claimed. The
@@ -12191,7 +12253,8 @@ const dedupMerge = (env) => Effect.gen(function* () {
 				components: components.length,
 				llmGroups,
 				vetoed: proposed.length - decisions.length,
-				skipped
+				skipped,
+				unresolved
 			},
 			/**
 			* On this arm a vetoed pair is one the MODEL grouped as the same memory, or one that cleared
@@ -12202,11 +12265,13 @@ const dedupMerge = (env) => Effect.gen(function* () {
 			*
 			* `judged` is false when a batch's call failed, because those components were never partitioned:
 			* their pairs reach the veto only through the mined arm, so a night that lost a call cannot say
-			* whether a pair it did not see is still a candidate.
+			* whether a pair it did not see is still a candidate. An unresolved member key is the same
+			* hazard from the answer side — a group the phase could not fully map was not fully judged —
+			* so it holds the sweep back the same way.
 			*/
 			{
 				vetoed: vetoedPairs(proposed),
-				judged: skipped === 0
+				judged: skipped === 0 && unresolved === 0
 			}
 		),
 		llmCalls
@@ -12631,6 +12696,7 @@ const edgeTyping = (env) => Effect.gen(function* () {
 		contradictions: 0,
 		promoted: 0,
 		skipped: 0,
+		unresolved: 0,
 		capped: 0,
 		duplicates: 0,
 		tasksMinted: 0,
@@ -12697,6 +12763,13 @@ const edgeTyping = (env) => Effect.gen(function* () {
 	let capped = 0;
 	/** Second-and-later verdicts naming a key their batch had already answered for. */
 	let duplicates = 0;
+	/**
+	* Verdicts whose key resolved to no offered pair, so they were dropped unacted. Dropping is the
+	* safe outcome and stays; the count is what makes a SYSTEMATIC pattern visible — a model naming
+	* keys in a spelling the resolver refuses drops every verdict of every batch, and a night that
+	* judged nothing looked identical to a night whose model answered nothing (issue #58).
+	*/
+	let unresolved = 0;
 	let llmCalls = 0;
 	/**
 	* Contradictions this night detected for the FIRST time, so below the promotion gate.
@@ -12737,18 +12810,27 @@ const edgeTyping = (env) => Effect.gen(function* () {
 		* rather than silently swallowed, so a model doing this is visible in a night's report.
 		*/
 		const answered = /* @__PURE__ */ new Set();
+		/** This batch's dropped verdicts, so the warning below can name the spellings that failed. */
+		const unresolvedKeys = [];
 		for (const verdict of answer.verdicts) {
 			/**
 			* The key is resolved through the kernel, so an invented key yields no candidate and no
-			* write.
+			* write. The CANONICAL key feeds the repeat guard, so `m1` and its label-prefixed spelling
+			* `pair_m1` in one answer are one pair answered twice, not two pairs.
 			*/
-			const [candidate] = resolveKeys(keyed, [verdict.pairKey]);
+			const pairKey = offeredKeyFor(keyed, verdict.pairKey);
+			if (pairKey === void 0) {
+				unresolved += 1;
+				unresolvedKeys.push(verdict.pairKey);
+				continue;
+			}
+			const [candidate] = resolveKeys(keyed, [pairKey]);
 			if (candidate === void 0) continue;
-			if (answered.has(verdict.pairKey)) {
+			if (answered.has(pairKey)) {
 				duplicates += 1;
 				continue;
 			}
-			answered.add(verdict.pairKey);
+			answered.add(pairKey);
 			judged += 1;
 			if (!assertsEdge(verdict)) continue;
 			if (assertsContradiction(verdict)) {
@@ -12851,14 +12933,18 @@ const edgeTyping = (env) => Effect.gen(function* () {
 			const [subject, object] = verdict.direction === "src_to_dst" ? [candidate.pair.src, candidate.pair.dst] : [candidate.pair.dst, candidate.pair.src];
 			if (yield* stampFile(env, subject, [link(verdict.rel, hrefFor(object)), meta("memhtml-updated", env.at)])) typed += 1;
 		}
+		if (unresolvedKeys.length > 0) yield* Effect.logWarning(`sleep.llm edge-typing batch of ${batch.length} dropped ${unresolvedKeys.length} verdicts naming no offered pair (${unresolvedKeys.slice(0, 3).join(", ")}${unresolvedKeys.length > 3 ? ", …" : ""})`);
 	}
 	/**
 	* The single-detection contradictions become tasks in the SAME commit as the promotions. The
 	* sweep is gated on a night that judged its whole candidate set: `skipped` counts pairs whose
 	* batch's call failed as well as pairs whose endpoint the tree no longer holds, and a pair the
 	* model was never asked about must not read as a pair the model stopped contradicting.
+	* `unresolved` is the same hazard from the answer side — a verdict the phase could not map to a
+	* pair is a pair that was never judged, so its held-back contradiction must not close as "no
+	* longer detected" over a misspelled key.
 	*/
-	const tasks = yield* mintContradictionTasks(env, deferred, skipped === 0);
+	const tasks = yield* mintContradictionTasks(env, deferred, skipped === 0 && unresolved === 0);
 	const counts = {
 		candidates: candidates.length,
 		judged,
@@ -12866,6 +12952,7 @@ const edgeTyping = (env) => Effect.gen(function* () {
 		contradictions,
 		promoted,
 		skipped,
+		unresolved,
 		capped,
 		duplicates,
 		tasksMinted: tasks.minted,
@@ -13382,6 +13469,12 @@ const entityResolution = (env) => Effect.gen(function* () {
 	/** Model calls that came back malformed. The sweep's precondition reads this; see below. */
 	let callsFailed = 0;
 	/**
+	* Cluster member keys (or canonical keys) resolving to no offered member, dropped unacted. The
+	* drop is the safe outcome and stays; the count makes a systematic naming pattern visible
+	* instead of reading as a night in which the model proposed no merges (issue #58).
+	*/
+	let unresolved = 0;
+	/**
 	* Every pair this night deferred to a human, as a value rather than only a count.
 	*
 	* This is issue #44's motivating case in one variable. The phase used to report
@@ -13493,6 +13586,8 @@ const entityResolution = (env) => Effect.gen(function* () {
 					callsFailed += 1;
 					continue;
 				}
+				/** This shard's unresolvable keys, so the warning below names the spellings that failed. */
+				const unresolvedKeys = [];
 				for (const cluster of clustering.clusters) {
 					/**
 					* A key the batch never offered resolves to nothing, so an invented member cannot become a
@@ -13500,6 +13595,9 @@ const entityResolution = (env) => Effect.gen(function* () {
 					* canonical is outside it contradicts itself, and guessing which half was meant would be
 					* the caller inventing a merge.
 					*/
+					const droppedKeys = [...cluster.memberKeys, cluster.canonicalKey].filter((key) => offeredKeyFor(keyed, key) === void 0);
+					unresolved += droppedKeys.length;
+					unresolvedKeys.push(...droppedKeys);
 					const memberNames = resolveKeys(keyed, cluster.memberKeys).map((centroid) => centroid.name);
 					const [canonicalMember] = resolveKeys(keyed, [cluster.canonicalKey]);
 					if (canonicalMember === void 0 || !memberNames.includes(canonicalMember.name)) continue;
@@ -13558,6 +13656,7 @@ const entityResolution = (env) => Effect.gen(function* () {
 						});
 					}
 				}
+				if (unresolvedKeys.length > 0) yield* Effect.logWarning(`sleep.llm entity-resolution ${entityType} batch of ${shard.length} dropped ${unresolvedKeys.length} cluster keys naming no offered member (${unresolvedKeys.slice(0, 3).join(", ")}${unresolvedKeys.length > 3 ? ", …" : ""})`);
 			}
 		}
 		/**
@@ -13595,6 +13694,8 @@ const entityResolution = (env) => Effect.gen(function* () {
 		aliasMerges,
 		pendingCorroboration,
 		reviewCandidates,
+		callsFailed,
+		unresolved,
 		tasksMinted: 0,
 		tasksFramed: 0,
 		tasksDismissed: 0,
@@ -13620,7 +13721,12 @@ const entityResolution = (env) => Effect.gen(function* () {
 	* 1. The old early return on `rewrites.size === 0` would have skipped exactly the night this
 	* feature exists for: a night whose only outcome was deferrals is a night with no rewrites.
 	*/
-	const tasks = yield* mintReviewTasks(env, deferred, model !== void 0 && callsFailed === 0);
+	/**
+	* `unresolved === 0` joins the sweep gate for the reason `callsFailed === 0` is already in it: a
+	* cluster key the phase could not map to a member is a name that was never judged, and sweeping
+	* against a night that lost part of an answer closes reviews over a misspelling.
+	*/
+	const tasks = yield* mintReviewTasks(env, deferred, model !== void 0 && callsFailed === 0 && unresolved === 0);
 	let rewritten = 0;
 	for (const [path, pairs] of [...rewrites.entries()].sort(([left], [right]) => left < right ? -1 : 1)) {
 		const html = yield* readFileBytes(env, path);
@@ -14617,6 +14723,12 @@ const taskDetection = (env) => Effect.gen(function* () {
 	let dismissed = 0;
 	let skipped = 0;
 	/**
+	* Findings whose key resolved to no offered member, dropped unacted. The drop is the safe
+	* outcome and stays; the count makes a systematic pattern visible, because a night whose every
+	* finding named an unresolvable key otherwise reads as a night with no open work (issue #58).
+	*/
+	let unresolved = 0;
+	/**
 	* Every key this night's scan SAW, whether or not it minted and whether or not it cleared the floor.
 	* The sweep's input; see the `liveKeys.add` below for why the floor is not a filter here.
 	*/
@@ -14644,11 +14756,20 @@ const taskDetection = (env) => Effect.gen(function* () {
 		* because it is called one key at a time here — a finding names one member.
 		*/
 		const answered = /* @__PURE__ */ new Set();
+		/** This batch's dropped findings, so the warning below can name the spellings that failed. */
+		const unresolvedKeys = [];
 		for (const finding of answer.findings) {
-			const [row] = resolveKeys(keyed, [finding.memberKey]);
+			/** The CANONICAL key feeds the repeat guard, same as edge-typing's, and for the same reason. */
+			const memberKey = offeredKeyFor(keyed, finding.memberKey);
+			if (memberKey === void 0) {
+				unresolved += 1;
+				unresolvedKeys.push(finding.memberKey);
+				continue;
+			}
+			const [row] = resolveKeys(keyed, [memberKey]);
 			if (row === void 0) continue;
-			if (answered.has(finding.memberKey)) continue;
-			answered.add(finding.memberKey);
+			if (answered.has(memberKey)) continue;
+			answered.add(memberKey);
 			findings += 1;
 			/**
 			* The key is the SOURCE PATH plus the normalized sentence, so the same commitment found again
@@ -14694,13 +14815,17 @@ const taskDetection = (env) => Effect.gen(function* () {
 			else if (outcome === "framed") framed += 1;
 			else if (outcome === "dismissed") dismissed += 1;
 		}
+		if (unresolvedKeys.length > 0) yield* Effect.logWarning(`sleep.llm task-detection batch of ${batch.length} dropped ${unresolvedKeys.length} findings naming no offered member (${unresolvedKeys.slice(0, 3).join(", ")}${unresolvedKeys.length > 3 ? ", …" : ""})`);
 	}
 	/**
 	* The sweep, only from a full-strength scan. `skipped > 0` means at least one batch's memories
 	* went unread, so a finding of theirs is missing from `liveKeys` because the phase could not look
-	* rather than because it is gone.
+	* rather than because it is gone. `unresolved > 0` is the same hazard from the answer side: the
+	* model reported a finding the phase could not map to a member, so its detection key was never
+	* constructed, and sweeping against that would close a live task because the model misspelled a
+	* key rather than because the finding vanished.
 	*/
-	const closed = skipped === 0 ? yield* closeVanishedDetections(env, TASK_DETECT_DETECTOR, liveKeys) : 0;
+	const closed = skipped === 0 && unresolved === 0 ? yield* closeVanishedDetections(env, TASK_DETECT_DETECTOR, liveKeys) : 0;
 	const counts = {
 		candidates: candidates.length,
 		batches: batches.length,
@@ -14712,7 +14837,8 @@ const taskDetection = (env) => Effect.gen(function* () {
 		dismissed,
 		closed,
 		capped: budget.overflow,
-		skipped
+		skipped,
+		unresolved
 	};
 	/**
 	* A refresh writes a `memhtml-updated` stamp, which is a staged file, so it commits — the queue's
@@ -14748,7 +14874,8 @@ const ZERO = {
 	dismissed: 0,
 	closed: 0,
 	capped: 0,
-	skipped: 0
+	skipped: 0,
+	unresolved: 0
 };
 
 //#endregion
@@ -16861,4 +16988,4 @@ const latest = (left, right) => left === null ? right : right === null ? left :
 
 //#endregion
 export { STATE_DB_PATH as $, IndexRecorder as A, IndexGit as B, ModelClient as C, EmbeddingsLive as D, Embeddings as E, makeRetrieval as F, MIGRATIONS_DIR as G, sanitizeFtsQuery as H, reinforce as I, Store as J, STATE_MIGRATIONS_DIR as K, Indexer as L, persistScanned as M, readWatermark as N, EMBED_DIM as O, Retrieval as P, SLEEP_REPORTS_DIR as Q, makeIndexer as R, runDiscrimination as S, wrapAsData as T, DatabaseService as U, makeGitPort as V, makeDatabase as W, makeStore as X, expandRoot as Y, INDEX_DB_PATH as Z, meta as _, parseSidecar as a, makeGit as at, isSleepPhase as b, generateArtifacts as c, setMeta as ct, allPaths as d, fenceOpeningOf as dt, STATE_SIDECAR_PATH as et, danglingEdges as f, REINFORCE_SIGNALS as ft, link as g, hrefFor as h, makeSleep as i, Git as it, makeIndexRecorder as j, EMBED_WATERMARK as k, DETECTION_PREFIX as l, isValidDatetime as lt, applyHeadEdits as m, scanTraceRoot as n, initRepo as nt, renderSidecar as o, commitSubject as ot, publishRows as p, frameKeyOf as pt, STATE_SCHEMA as q, Sleep as r, readFileOrNull as rt, archivedFormOf as s, checkMemory as st, mergeTailExtract as t, attemptIo as tt, accessRows as u, closesFence as ut, unlink as v, ModelClientLive as w, discriminationGate as x, SLEEP_PHASES as y, readIndexState as z };
-//# sourceMappingURL=dist-D5DlgqH2.mjs.map
+//# sourceMappingURL=dist-DgKlozi6.mjs.map