memhtml 0.4.0 → 0.5.0

package/dist/{dist-D73gfqLc.mjs → dist-D5DlgqH2.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,
@@ -9341,7 +9528,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 +9546,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";
@@ -16685,4 +16861,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-D5DlgqH2.mjs.map