memhtml 0.4.0 → 0.5.1

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

@@ -8267,12 +8267,23 @@ const EmbeddingsLive = Layer.effect(Embeddings, Effect.gen(function* () {
 //#endregion
 //#region packages/llm/dist/models.js
 /**
-* The three Claude 5 models the sleep phases run on, and the wire rules that differ
-* between them. The set is Anthropic-only on purpose, because the four LLM phases need one
-* call shape. A second vendor would add a second set of truncation and structured-output
-* semantics that no phase asks for.
+* The models the sleep phases run on, and the wire rules that differ between them.
+*
+* Two providers, two call shapes, one decode. The Anthropic lane speaks the native
+* Messages body with a forced `emit` tool; the OpenAI lane speaks the chat-completions
+* body with `response_format: {type: "json_schema", strict: true}`. The OpenAI lane
+* exists for exactly one property the Anthropic lane cannot offer on Bedrock today:
+* constrained decoding, which makes an off-schema structured answer impossible at
+* generation time instead of repaired after (probed live 2026-08-22 — the Claude 5
+* models reject `strict` and `output_config.format` on every Bedrock surface, while
+* `global.openai.gpt-5.6-sol` honors strict JSON schema on InvokeModel). Both lanes
+* converge on the same response shape before `decodeToolInput`, so every phase and
+* every test sees one contract.
+*/
+/**
+* Reasoning effort. The Anthropic lane passes it as `output_config.effort`, the OpenAI
+* lane as `reasoning_effort`; both accept all four values (sol probed live 2026-08-22).
 */
-/** Reasoning effort, passed as `output_config.effort`. Accepted by all three models. */
 const Effort = Schema.Literals([
 	"low",
 	"medium",
@@ -8282,27 +8293,39 @@ const Effort = Schema.Literals([
 const ModelKey = Schema.Literals([
 	"sonnet-5",
 	"opus-5",
-	"fable-5"
+	"fable-5",
+	"gpt-5.6-sol"
 ]);
 /**
 * Bedrock ids use the `global.` inference profiles, which makes them reachable from a
-* single region without provisioning per-region throughput.
+* single region without provisioning per-region throughput. The OpenAI models REQUIRE
+* the profile: the bare `openai.gpt-5.6-*` ids reject on-demand invocation outright
+* (probed live 2026-08-22).
 */
 const MODELS = [
 	{
 		key: "sonnet-5",
 		label: "Claude Sonnet 5",
-		modelId: "global.anthropic.claude-sonnet-5"
+		modelId: "global.anthropic.claude-sonnet-5",
+		provider: "anthropic"
 	},
 	{
 		key: "opus-5",
 		label: "Claude Opus 5",
-		modelId: "global.anthropic.claude-opus-5"
+		modelId: "global.anthropic.claude-opus-5",
+		provider: "anthropic"
 	},
 	{
 		key: "fable-5",
 		label: "Claude Fable 5",
-		modelId: "global.anthropic.claude-fable-5"
+		modelId: "global.anthropic.claude-fable-5",
+		provider: "anthropic"
+	},
+	{
+		key: "gpt-5.6-sol",
+		label: "GPT-5.6 Sol",
+		modelId: "global.openai.gpt-5.6-sol",
+		provider: "openai"
 	}
 ];
 const BY_KEY = new Map(MODELS.map((model) => [model.key, model]));
@@ -8317,12 +8340,13 @@ const modelByKey = (key) => {
 	return found;
 };
 /**
-* The `thinking` object per model. Opus 5 and Fable 5 take `{type: "adaptive"}` (Fable is
-* adaptive-only). Sonnet 5 reasons unconditionally and takes NO thinking key. Sending one
-* to Sonnet 5 raises a validation error instead of being ignored.
+* The `thinking` object per Anthropic model. Opus 5 and Fable 5 take `{type: "adaptive"}`
+* (Fable is adaptive-only). Sonnet 5 reasons unconditionally and takes NO thinking key.
+* Sending one to Sonnet 5 raises a validation error instead of being ignored. The OpenAI
+* lane never consults this: its reasoning dial is `reasoning_effort` alone.
 *
-* Verified live 2026-08-02: all three accept this shape alongside a forced `tool_choice`,
-* so structured output and adaptive thinking compose.
+* Verified live 2026-08-02: all three Claude models accept this shape alongside a forced
+* `tool_choice`, so structured output and adaptive thinking compose.
 */
 const thinkingFor = (key) => key === "opus-5" || key === "fable-5" ? { type: "adaptive" } : null;
 
@@ -8337,6 +8361,13 @@ const thinkingFor = (key) => key === "opus-5" || key === "fable-5" ? { type: "ad
 * default for an omitted field, and no accepted extra key. Downstream code cannot tell a
 * coerced object from a real one, and the phases that consume these objects archive and
 * rewrite files.
+*
+* ONE repair is the exception, because it recovers the payload the model meant rather than
+* inventing one: a top-level field the schema declares as an array or object sometimes
+* arrives double-encoded as a JSON STRING. That string is parsed once and the SAME strict
+* decode re-runs on the result, so nothing an off-schema answer carries can slip through —
+* a payload the repair cannot make satisfy the schema still fails with the original
+* violation. See {@link decodeToolInput}.
 */
 /** Cap on the raw payload carried on a violation, so a runaway response cannot bloat it. */
 const MAX_RAW = 800;
@@ -8371,6 +8402,50 @@ const preview = (payload) => {
 	})();
 	return rendered.length <= 800 ? rendered : `${rendered.slice(0, 800)}…`;
 };
+/** True when a property's derived JSON schema declares a container: an array, an object, or a
+* `$ref` (every hoisted definition is a struct). A string-typed property is NOT a container,
+* which is what keeps a field that legitimately holds JSON-looking text out of the repair. */
+const expectsContainer = (property) => {
+	if (typeof property !== "object" || property === null) return false;
+	const record = property;
+	return typeof record.$ref === "string" || record.type === "array" || record.type === "object";
+};
+/**
+* Undo ONE level of JSON-string double-encoding on the top-level fields of a tool payload.
+*
+* The shape this repairs was observed on the wire: a field the schema declares as an array
+* arrives as `"{\"groups\":[…]}"` — the whole answer serialized as a string under its own
+* key — or as the array itself serialized. So a string sitting where the derived
+* `input_schema` declares a container is parsed once; when the parsed value is an object
+* carrying the SAME key, the value at that key is taken, otherwise the parsed value stands.
+*
+* Returns `undefined` when there is nothing to repair: no field qualified, or no parse
+* succeeded. The caller then reports the ORIGINAL violation, and a repaired payload still
+* re-runs the same strict decode, so this never widens what the schema accepts.
+*/
+const unwrapDoubleEncoded = (schema, input) => {
+	if (typeof input !== "object" || input === null || Array.isArray(input)) return void 0;
+	const properties = toInputSchema(schema).properties;
+	if (properties === void 0) return void 0;
+	let repairedAField = false;
+	const repaired = {};
+	for (const [key, received] of Object.entries(input)) {
+		repaired[key] = received;
+		if (typeof received !== "string" || !expectsContainer(properties[key])) continue;
+		const parsed = (() => {
+			try {
+				return { value: JSON.parse(received) };
+			} catch {
+				return;
+			}
+		})();
+		if (parsed === void 0) continue;
+		const wrapper = typeof parsed.value === "object" && parsed.value !== null && !Array.isArray(parsed.value) ? parsed.value : void 0;
+		repaired[key] = wrapper !== void 0 && key in wrapper ? wrapper[key] : parsed.value;
+		repairedAField = true;
+	}
+	return repairedAField ? repaired : void 0;
+};
 /**
 * Decode a forced-tool payload against its schema.
 *
@@ -8379,13 +8454,29 @@ const preview = (payload) => {
 * would let a model answer a schema next to the one it was given and have the extra field
 * vanish. croq's judge rules out the same drift by enumerating its allowed keys.
 *
+* One failure shape is repaired before the violation is constructed: a top-level container
+* field double-encoded as a JSON string ({@link unwrapDoubleEncoded}). The repaired payload
+* goes through the SAME strict decode, and a repair that still does not satisfy the schema
+* reports the original payload's violation, so the repair cannot mask a genuinely off-schema
+* answer.
+*
 * `undefined` input means the model produced no `emit` call at all. That is the same class
 * of failure as a malformed one, and the reason text names it so a caller can tell the two
 * apart in a log without a second error type.
 */
 const decodeToolInput = (schema, input) => input === void 0 ? Effect.fail(LlmContractViolation.make({ reason: "model returned no tool_use block for the forced tool" })) : Effect.gen(function* () {
-	const decoded = yield* Effect.result(Schema.decodeUnknownEffect(schema, { onExcessProperty: "error" })(input));
-	return Result.isSuccess(decoded) ? decoded.success : yield* Effect.fail(LlmContractViolation.make({ reason: `tool payload does not satisfy its schema: ${String(decoded.failure)} (raw: ${preview(input)})` }));
+	const strictDecode = Schema.decodeUnknownEffect(schema, { onExcessProperty: "error" });
+	const decoded = yield* Effect.result(strictDecode(input));
+	if (Result.isSuccess(decoded)) return decoded.success;
+	const repaired = unwrapDoubleEncoded(schema, input);
+	if (repaired !== void 0) {
+		const redecoded = yield* Effect.result(strictDecode(repaired));
+		if (Result.isSuccess(redecoded)) {
+			yield* Effect.logWarning("llm.structured repaired a double-encoded tool field before decoding");
+			return redecoded.success;
+		}
+	}
+	return yield* Effect.fail(LlmContractViolation.make({ reason: `tool payload does not satisfy its schema: ${String(decoded.failure)} (raw: ${preview(input)})` }));
 });
 
 //#endregion
@@ -8397,16 +8488,18 @@ const decodeToolInput = (schema, input) => input === void 0 ? Effect.fail(LlmCon
 */
 const clampTokens = (requested) => Math.min(requested ?? 16384, MAX_TOKENS_CEILING);
 /**
-* Build the request body. The `tool` argument selects the lane. When it is absent the model
-* answers in prose. When it is present, `tool_choice` forces the model into exactly one
-* `emit` call, and that is the whole structured-output mechanism.
+* Build the request body in the model's own dialect. The `tool` argument selects the lane.
+* When it is absent the model answers in prose. When it is present the request constrains
+* the model to exactly one schema-shaped answer: a forced `emit` tool call on the
+* Anthropic dialect, a strict `json_schema` response format on the OpenAI one.
 *
 * `system` is omitted rather than sent empty, because an empty system block is a distinct
 * (and rejected) input from no system block at all. An omitted system also has nothing to cache, so
 * `cacheSystem` over an absent or empty system emits no `system` key at all instead of an empty
 * cached block.
 */
-const buildInvokeBody = (key, prompt, options, tool) => {
+const buildInvokeBody = (key, prompt, options, tool) => modelByKey(key).provider === "openai" ? buildOpenAiBody(prompt, options, tool) : buildAnthropicBody(key, prompt, options, tool);
+const buildAnthropicBody = (key, prompt, options, tool) => {
 	const body = {
 		anthropic_version: ANTHROPIC_VERSION,
 		max_tokens: clampTokens(options.maxTokens),
@@ -8437,6 +8530,51 @@ const buildInvokeBody = (key, prompt, options, tool) => {
 	return JSON.stringify(body);
 };
 /**
+* The OpenAI chat-completions body (probed live 2026-08-22 against
+* `global.openai.gpt-5.6-sol` — every field here is one the probe exercised).
+*
+* Differences from the Anthropic dialect, each one deliberate:
+*
+* - The token budget is `max_completion_tokens` and it bounds reasoning and answer
+*   together, so the same clamp applies. 128k accepted at the ceiling.
+* - Effort is `reasoning_effort`, taking the same four values.
+* - `system` rides as a leading `{role: "system"}` message; there is no `system` field.
+*   `cacheSystem` has no OpenAI-side marker — Bedrock reports `cache_write_tokens` in
+*   this dialect's usage without an opt-in field — so the flag is accepted and unused
+*   rather than rejected, keeping the option surface identical across lanes.
+* - The structured mechanism is `response_format.json_schema` with `strict: true`, named
+*   `emit` so logs read the same across providers. `description` becomes the schema's
+*   own `description`, the closest surface this dialect has to a tool description.
+*/
+const buildOpenAiBody = (prompt, options, tool) => {
+	const messages = [];
+	if (options.system !== void 0 && options.system.length > 0) messages.push({
+		role: "system",
+		content: options.system
+	});
+	messages.push({
+		role: "user",
+		content: prompt
+	});
+	const body = {
+		max_completion_tokens: clampTokens(options.maxTokens),
+		messages,
+		reasoning_effort: options.effort
+	};
+	if (tool !== void 0) body.response_format = {
+		type: "json_schema",
+		json_schema: {
+			name: STRUCTURED_TOOL_NAME,
+			strict: true,
+			schema: tool.description === void 0 ? tool.inputSchema : {
+				description: tool.description,
+				...tool.inputSchema
+			}
+		}
+	};
+	return JSON.stringify(body);
+};
+/**
 * `stop_reason` values that mean the content is not a complete answer. Both become typed
 * failures. A response cut off at `max_tokens` may never have reached the point that made
 * it a judgment, and a refusal carries no judgment at all. Reading either as a finished
@@ -8445,6 +8583,55 @@ const buildInvokeBody = (key, prompt, options, tool) => {
 const INCOMPLETE_STOP_REASONS = /* @__PURE__ */ new Set(["max_tokens", "refusal"]);
 /** The parsed payload, read defensively, since every field on the wire is optional. */
 const asResponseBody = (payload) => payload ?? {};
+/**
+* Fold an OpenAI chat-completions payload into {@link InvokeResponseBody}, so one read
+* side serves both dialects.
+*
+* `finish_reason` maps onto the Anthropic vocabulary this module already gates on:
+* `length` is `max_tokens` and `content_filter` is `refusal`, both of which
+* {@link INCOMPLETE_STOP_REASONS} already refuses; everything else passes through as a
+* complete answer. `structured` says how the caller asked, which decides how the content
+* is presented: a structured request's content is the schema-constrained JSON, parsed
+* here and presented as the `emit` tool's input, and a prose request's content is a text
+* block. Content that fails to parse on the structured path yields NO tool block, which
+* downstream reports as the existing "no tool_use block" violation — the right class,
+* since constrained decoding makes that a broken response rather than an off-schema one.
+*/
+const normalizeOpenAiResponse = (payload, structured) => {
+	const body = payload ?? {};
+	const choice = body.choices?.[0];
+	const finish = choice?.finish_reason ?? null;
+	const stopReason = finish === "length" ? "max_tokens" : finish === "content_filter" ? "refusal" : finish;
+	const text = choice?.message?.content;
+	const content = [];
+	if (typeof text === "string" && text.length > 0) {
+		if (structured) {
+			const input = (() => {
+				try {
+					return { value: JSON.parse(text) };
+				} catch {
+					return;
+				}
+			})();
+			if (input !== void 0) content.push({
+				type: "tool_use",
+				name: STRUCTURED_TOOL_NAME,
+				input: input.value
+			});
+		} else content.push({
+			type: "text",
+			text
+		});
+	}
+	return {
+		stop_reason: stopReason,
+		content,
+		usage: {
+			...body.usage?.prompt_tokens === void 0 ? {} : { input_tokens: body.usage.prompt_tokens },
+			...body.usage?.completion_tokens === void 0 ? {} : { output_tokens: body.usage.completion_tokens }
+		}
+	};
+};
 /** The incomplete `stop_reason`, or null when the response ran to a natural end. */
 const incompleteReason = (parsed) => {
 	const stop = parsed.stop_reason ?? null;
@@ -8483,7 +8670,7 @@ const makeModelClient = (client) => {
 			description: tool.description
 		}));
 		const finished = yield* Effect.clockWith((clock) => clock.currentTimeMillis);
-		const parsed = asResponseBody(payload);
+		const parsed = model.provider === "openai" ? normalizeOpenAiResponse(payload, tool !== void 0) : asResponseBody(payload);
 		const incomplete = incompleteReason(parsed);
 		if (incomplete !== null) return yield* Effect.fail(ModelUnavailable.make({
 			modelId: model.modelId,
@@ -8834,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];
 });
@@ -9341,7 +9553,16 @@ const datePlusDays = (date, days) => {
 //#endregion
 //#region packages/sleep/dist/env.js
 /**
-* Model assignments per LLM phase: the cheap judge for classification, the strong one for synthesis.
+* Model assignments per LLM phase.
+*
+* Every structured phase names `gpt-5.6-sol`, and the reason is one wire property rather
+* than a model-quality judgment: its strict `json_schema` mode does constrained decoding
+* on Bedrock today, so an off-schema answer — including the double-encoded-string shape
+* that skipped 13 batches in one Claude-5 run (issue #53) — cannot be generated at all.
+* The Claude 5 models reject `strict` and `output_config.format` on every Bedrock surface
+* (probed live 2026-08-22), so with them the schema is a request the decode enforces
+* after the fact, and a violated batch is work lost. When Claude 5 structured outputs
+* land on Bedrock, re-deciding this map is a quality question again; today it is not.
 *
 * `trace-consolidation` names `opus-5` and does not thereby choose it. The consolidator is an eve
 * agent that pins its own model in `apps/consolidator/agent/agent.ts`, and this map cannot reach that
@@ -9350,33 +9571,13 @@ const datePlusDays = (date, days) => {
 * the Bedrock global endpoint, high reasoning effort, no cost ceiling.)
 */
 const DEFAULT_MODELS = {
-	/**
-	* `dedup-merge` names sonnet for the same reason the edge-typing judge does: the question is a
-	* classification over text the model is shown, not a synthesis it has to write. It partitions a
-	* component into "these are the same memory" groups, and every consequence of that answer — which
-	* file survives, whether the pair diverges, whether either path is already claimed — is decided by
-	* code afterwards. The strong model is spent where prose gets written.
-	*/
-	"dedup-merge": "sonnet-5",
-	/**
-	* Sonnet, and one or two calls a night: the whole of one entity type's name list goes in one call.
-	* The question is a partition over short strings with their evidence inline, not a synthesis, so
-	* the strong model would buy nothing the deterministic floors around the answer do not already
-	* supply.
-	*/
-	"entity-resolution": "sonnet-5",
-	"edge-typing": "sonnet-5",
-	"arc-synthesis": "opus-5",
-	compress: "sonnet-5",
+	"dedup-merge": "gpt-5.6-sol",
+	"entity-resolution": "gpt-5.6-sol",
+	"edge-typing": "gpt-5.6-sol",
+	"arc-synthesis": "gpt-5.6-sol",
+	compress: "gpt-5.6-sol",
 	"trace-consolidation": "opus-5",
-	/**
-	* Sonnet, for the same reason `dedup-merge` and the edge-typing judge name it: the question is an
-	* extraction over text the model is shown — which of these memories carries an open commitment,
-	* quote the sentence — and every consequence is decided afterwards by code. The sentence has to be
-	* VERBATIM, which is copying rather than composing, and the confidence floor plus the verbatim
-	* check are what a stronger model would otherwise be buying.
-	*/
-	"task-detection": "sonnet-5"
+	"task-detection": "gpt-5.6-sol"
 };
 /** The model a phase calls: the caller's override, else {@link DEFAULT_MODELS}, else sonnet. */
 const modelFor = (deps, phase) => deps.models?.[phase] ?? DEFAULT_MODELS[phase] ?? "sonnet-5";
@@ -10862,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);
@@ -10870,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. */
@@ -10886,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;
 		}
 		/**
@@ -10904,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;
 		}
 		/**
@@ -10918,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({
@@ -10936,7 +11155,9 @@ const compress = (env) => Effect.gen(function* () {
 			...counts,
 			canonicals,
 			archived,
-			skipped
+			skipped,
+			failed,
+			refused
 		});
 		if (commitSha !== null) lastCommit = commitSha;
 	}
@@ -10945,7 +11166,9 @@ const compress = (env) => Effect.gen(function* () {
 			...counts,
 			canonicals,
 			archived,
-			skipped
+			skipped,
+			failed,
+			refused
 		},
 		commitSha: lastCommit,
 		llmCalls
@@ -11856,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
@@ -11927,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. */
@@ -11966,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. */
@@ -11996,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
@@ -12015,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
@@ -12026,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
@@ -12455,6 +12696,7 @@ const edgeTyping = (env) => Effect.gen(function* () {
 		contradictions: 0,
 		promoted: 0,
 		skipped: 0,
+		unresolved: 0,
 		capped: 0,
 		duplicates: 0,
 		tasksMinted: 0,
@@ -12521,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.
@@ -12561,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)) {
@@ -12675,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,
@@ -12690,6 +12952,7 @@ const edgeTyping = (env) => Effect.gen(function* () {
 		contradictions,
 		promoted,
 		skipped,
+		unresolved,
 		capped,
 		duplicates,
 		tasksMinted: tasks.minted,
@@ -13206,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
@@ -13317,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
@@ -13324,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;
@@ -13382,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 ? ", …" : ""})`);
 			}
 		}
 		/**
@@ -13419,6 +13694,8 @@ const entityResolution = (env) => Effect.gen(function* () {
 		aliasMerges,
 		pendingCorroboration,
 		reviewCandidates,
+		callsFailed,
+		unresolved,
 		tasksMinted: 0,
 		tasksFramed: 0,
 		tasksDismissed: 0,
@@ -13444,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);
@@ -14441,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.
 	*/
@@ -14468,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
@@ -14518,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,
@@ -14536,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
@@ -14572,7 +14874,8 @@ const ZERO = {
 	dismissed: 0,
 	closed: 0,
 	capped: 0,
-	skipped: 0
+	skipped: 0,
+	unresolved: 0
 };
 
 //#endregion
@@ -16685,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-D73gfqLc.mjs.map
+//# sourceMappingURL=dist-DgKlozi6.mjs.map