@tea-agent/loop-agent 0.44.0-next.1 → 0.44.0-next.11

package/dist/worker/observe/static/console-theme.css

@@ -0,0 +1,174 @@
+/* Opt-in palettes. Repeat tokens at the Inspect boundary: it owns local defaults
+ * and is loaded after the Console stylesheet. Specificity keeps load order safe. */
+:root[data-console-theme="midnight"],
+:root[data-console-theme="midnight"] body[data-shell="observe-console"],
+:root[data-console-theme="midnight"] .inspect-workspace-root {
+	color-scheme: dark;
+	--canvas: #1c222a;
+	--canvas-soft: #202730;
+	--surface: #252d37;
+	--surface-muted: #2d3641;
+	--ink: #dce2e9;
+	--surface-ink: #dce2e9;
+	--body: #bcc5d0;
+	--muted: #a1acba;
+	--muted-soft: #909eaf;
+	--muted-ink: #a1acba;
+	--hairline: #353f4b;
+	--hairline-strong: #526171;
+	--orange: #a0bcd3;
+	--orange-active: #b8cfe0;
+	--blue: #a0bcd3;
+	--brand: #b2aacb;
+	--theme-action: #4d6b86;
+	--theme-action-hover: #557590;
+	--theme-on-action: #ffffff;
+	--green: #99c5b0;
+	--amber: #d3b783;
+	--warn: #d3b783;
+	--red: #dea4ac;
+	--peach: #303e4d;
+	--mint: #2d403b;
+	--lavender: #393746;
+	--gold: #c3ac80;
+	--shadow-sm: 0 1px 2px rgb(0 0 0 / 12%);
+	--shadow-panel: 0 1px 2px rgb(0 0 0 / 12%), 0 6px 18px rgb(0 0 0 / 10%);
+	--shadow-soft: 0 8px 24px rgb(0 0 0 / 18%);
+	--shadow-lg: 0 16px 40px rgb(0 0 0 / 24%);
+}
+
+:root[data-console-theme="daylight"],
+:root[data-console-theme="daylight"] body[data-shell="observe-console"],
+:root[data-console-theme="daylight"] .inspect-workspace-root {
+	color-scheme: light;
+	--canvas: #eef0f2;
+	--canvas-soft: #f3f4f5;
+	--surface: #f9fafb;
+	--surface-muted: #e5e9ed;
+	--ink: #303b47;
+	--surface-ink: #303b47;
+	--body: #4b5867;
+	--muted: #5e6a78;
+	--muted-soft: #697583;
+	--muted-ink: #5e6a78;
+	--hairline: #dce1e6;
+	--hairline-strong: #b5bfc9;
+	--orange: #466581;
+	--orange-active: #365570;
+	--blue: #466581;
+	--brand: #706387;
+	--theme-action: #536f88;
+	--theme-action-hover: #466079;
+	--theme-on-action: #ffffff;
+	--green: #3e735d;
+	--amber: #85632d;
+	--warn: #85632d;
+	--red: #a04f5c;
+	--peach: #dfe7ee;
+	--mint: #e0eae4;
+	--lavender: #e7e3ed;
+	--gold: #927644;
+	--shadow-sm: 0 1px 2px rgb(35 45 58 / 4%);
+	--shadow-panel: 0 1px 2px rgb(35 45 58 / 3%), 0 6px 18px rgb(35 45 58 / 3%);
+	--shadow-soft: 0 8px 24px rgb(35 45 58 / 6%);
+	--shadow-lg: 0 16px 40px rgb(35 45 58 / 9%);
+}
+
+/* Only the two added themes override component literals; original warm paper
+ * remains byte-for-byte defined by its existing stylesheets. */
+:root:is([data-console-theme="midnight"], [data-console-theme="daylight"]) {
+	--orange-soft: color-mix(in srgb, var(--orange) 10%, var(--surface));
+	background: var(--canvas);
+
+	body[data-shell="observe-console"], .inspect-workspace-root {
+		--orange-soft: color-mix(in srgb, var(--orange) 10%, var(--surface));
+	}
+
+	::selection { background: color-mix(in srgb, var(--blue) 32%, var(--surface)); }
+
+	.oc-composer-shell, .console-update-channel, .console-update-button,
+	.panel-output { background: var(--surface); color: var(--ink); }
+	.console-update-channel, .console-update-button { border-color: var(--hairline-strong); }
+	.console-update-channel-label { color: var(--body); }
+	.console-update-error, .console-update-result-error { color: var(--red); }
+	.console-update-badge { background: var(--surface-muted); color: var(--amber); }
+
+	.oc-bubble-user { background: color-mix(in srgb, var(--blue) 9%, var(--surface)); }
+	.oc-composer-shell { box-shadow: var(--shadow-panel); }
+	.oc-bubble-assistant .oc-codeblock { background: var(--canvas-soft); }
+	.oc-session-scroll, .oc-tree-scroll { background: var(--canvas-soft); }
+	.oc-sidebar-new-session:is(:hover, :focus-visible),
+	.oc-hero-chip:is(:hover, :focus-visible, [aria-expanded="true"]) { background: var(--surface-muted); }
+
+	.night-health-pill, .models-status-pill[data-state="ready"],
+	.models-probe-item.is-ok .models-probe-badge {
+		background: color-mix(in srgb, var(--green) 14%, var(--surface));
+	}
+	.night-health-pill.is-bad, .models-status-pill[data-state="setup-required"],
+	.models-probe-item.is-bad .models-probe-badge, .dag-error-node {
+		background: color-mix(in srgb, var(--red) 12%, var(--surface));
+	}
+	.models-status-pill[data-state="degraded"], .models-degraded-note,
+	.dag-active-node { background: var(--orange-soft); }
+	.liveness-timeout-risk { background: color-mix(in srgb, var(--amber) 12%, var(--surface)); }
+	.night-strip-icon { color: var(--brand); }
+
+	/* Quiet selected surfaces keep navigation secondary to the content. */
+	.och-mode-thumb { background: var(--surface); box-shadow: var(--shadow-sm); }
+	.och-mode-btn.och-on { color: var(--ink); }
+	.dag-inspector-tab[aria-selected="true"],
+	.dag-graph-mode-tab[aria-selected="true"],
+	#dag-inspector-panel-prompt-restart button.prompt-restart-mode-option.is-selected {
+		background: var(--surface-muted);
+		color: var(--ink);
+	}
+
+	/* Accent text needs a different luminance from a white-labelled action. */
+	.btn-primary, button.btn-primary, .oc-send, .oc-question-button.is-primary,
+	.oc-scm-commitbtn, .skip-link, .dags-page-num.is-current,
+	.dag-action-primary, .context-export-submit,
+	#dag-inspector-panel-prompt-restart button.prompt-restart-submit:not(.is-secondary) {
+		background: var(--theme-action);
+		border-color: var(--theme-action);
+		color: var(--theme-on-action);
+		box-shadow: var(--shadow-sm);
+	}
+	.btn-primary:hover:not(:disabled), button.btn-primary:hover:not(:disabled),
+	.oc-send:hover:not(:disabled), .oc-question-button.is-primary:hover:not(:disabled),
+	.oc-scm-commitbtn:hover:not(:disabled), .dag-action-primary:hover:not(:disabled),
+	.context-export-submit:hover:not(:disabled),
+	#dag-inspector-panel-prompt-restart button.prompt-restart-submit:not(.is-secondary):hover {
+		background: var(--theme-action-hover);
+		border-color: var(--theme-action-hover);
+	}
+	.och-context-return, .process-timeline-autoscroll::after {
+		background: var(--surface-muted);
+		color: var(--ink);
+	}
+	.markdown-output pre, .output-block { background: var(--canvas-soft); color: var(--ink); }
+	.context-export-ticket { background: var(--surface-muted); color: var(--ink); }
+	.context-export-ticket-safety { color: var(--green); }
+	.context-export-ticket-safety.is-risk { color: var(--red); }
+}
+
+/* Syntax highlighting is independently hardcoded to a light palette. */
+:root[data-console-theme="midnight"] {
+	/* The SVG brand uses dark strokes; provide a subtle light backing, not a filter. */
+	.och-brand-mark, .oc-hero img { background: #aebac7; border-radius: 6px; }
+	.hljs { color: var(--ink); background: var(--canvas-soft); }
+	.hljs-doctag, .hljs-keyword, .hljs-meta .hljs-keyword,
+	.hljs-template-tag, .hljs-template-variable, .hljs-type,
+	.hljs-variable.language_ { color: #c7afcf; }
+	.hljs-title, .hljs-title.class_, .hljs-title.class_.inherited__,
+	.hljs-title.function_ { color: #b9b3d1; }
+	.hljs-attr, .hljs-attribute, .hljs-literal, .hljs-meta, .hljs-number,
+	.hljs-operator, .hljs-selector-attr, .hljs-selector-class,
+	.hljs-selector-id, .hljs-variable, .hljs-section { color: var(--blue); }
+	.hljs-meta .hljs-string, .hljs-regexp, .hljs-string,
+	.hljs-name, .hljs-quote, .hljs-selector-pseudo, .hljs-selector-tag { color: var(--green); }
+	.hljs-built_in, .hljs-symbol, .hljs-bullet { color: var(--amber); }
+	.hljs-code, .hljs-comment, .hljs-formula { color: var(--muted); }
+	.hljs-subst, .hljs-emphasis, .hljs-strong { color: var(--ink); }
+	.hljs-addition { color: var(--green); background: var(--mint); }
+	.hljs-deletion { color: var(--red); background: color-mix(in srgb, var(--red) 12%, var(--surface)); }
+}

package/dist/worker/observe/static/console-theme.js

@@ -0,0 +1,36 @@
+/** Shared Console theme identities; the default leaves the original palette intact. */
+export const CONSOLE_THEMES = Object.freeze([
+	{ id: "default", label: "默认" },
+	{ id: "midnight", label: "深色" },
+	{ id: "daylight", label: "浅色" },
+]);
+
+const STORAGE_KEY = "loop-console.theme.v1";
+
+function normalizeTheme(value) {
+	return CONSOLE_THEMES.some((theme) => theme.id === value) ? value : "default";
+}
+
+export function applyStoredConsoleTheme() {
+	let value;
+	try {
+		value = window.localStorage.getItem(STORAGE_KEY);
+	} catch {
+		// Storage can be disabled, including the localStorage getter itself.
+	}
+	const theme = normalizeTheme(value);
+	document.documentElement.dataset.consoleTheme = theme;
+	return theme;
+}
+
+export function setConsoleTheme(value) {
+	const theme = normalizeTheme(value);
+	// Apply before persistence: a storage failure must not disable the picker.
+	document.documentElement.dataset.consoleTheme = theme;
+	try {
+		window.localStorage.setItem(STORAGE_KEY, theme);
+	} catch {
+		// The document attribute remains the in-memory preference.
+	}
+	return theme;
+}

package/dist/worker/observe/static/operator-chrome.css

@@ -8,6 +8,84 @@
  * 的暖白 token 保持一致；宿主样式表已定义同名变量时以宿主为准。
  */
 
+@import "./console-theme.css";
+
+.och-theme {
+	display: flex;
+	align-items: center;
+	gap: 6px;
+	flex: none;
+	color: var(--och-muted);
+	font-size: 12px;
+}
+
+.och-theme-trigger {
+	display: inline-flex;
+	align-items: center;
+	justify-content: center;
+	width: 26px;
+	min-height: 26px;
+	padding: 0;
+	border: 1px solid transparent;
+	border-radius: 6px;
+	background: transparent;
+	color: var(--och-body);
+	font: inherit;
+	cursor: pointer;
+}
+
+.och-theme-trigger:hover,
+.och-theme-trigger[aria-expanded="true"] {
+	background: var(--och-surface-muted);
+	color: var(--och-ink);
+}
+
+.och-theme-trigger:focus-visible,
+.och-theme-option:focus-visible {
+	outline: 2px solid var(--och-orange);
+	outline-offset: 2px;
+}
+
+/* Native popover renders in the top layer, outside the narrow header's clip. */
+.och-theme-menu {
+	position: fixed;
+	inset: auto;
+	box-sizing: border-box;
+	width: 112px;
+	margin: 0;
+	padding: 4px;
+	border: 1px solid var(--och-hairline);
+	border-radius: 8px;
+	background: var(--och-surface);
+	color: var(--och-ink);
+	box-shadow: var(--shadow-soft);
+	font: inherit;
+}
+
+.och-theme-option {
+	display: flex;
+	align-items: center;
+	justify-content: space-between;
+	width: 100%;
+	min-height: 28px;
+	padding: 4px 8px;
+	border: 0;
+	border-radius: 4px;
+	background: transparent;
+	color: inherit;
+	font: inherit;
+	cursor: pointer;
+}
+
+.och-theme-option:hover,
+.och-theme-option[aria-pressed="true"] {
+	background: var(--och-surface-muted);
+}
+
+.och-theme-option[aria-pressed="true"]::after {
+	content: "✓";
+}
+
 .och {
 	--och-canvas: var(--canvas, #f3f4f6);
 	--och-surface: var(--surface, #fbfcfd);
@@ -622,7 +700,14 @@
 	.och-inner {
 		padding-inline: 12px;
 	}
+	.och-theme {
+		position: absolute;
+		top: 46px;
+		right: 0;
+	}
 	.och-global {
+		height: 84px;
+		padding-bottom: 40px;
 		gap: 6px;
 		overflow-x: auto;
 		scrollbar-width: none;

package/dist/worker/observe/static/operator-chrome.js

@@ -12,6 +12,8 @@
  */
 
 import { withWorkspaceQuery } from "./router.js";
+import { CONSOLE_THEMES, applyStoredConsoleTheme, setConsoleTheme } from "./console-theme.js";
+export { CONSOLE_THEMES } from "./console-theme.js";
 
 export const OPERATE_TABS = Object.freeze([
 	{ id: "tasks", label: "任务", href: "/#/operate/tasks" },
@@ -296,6 +298,13 @@ export function buildOperatorChromeModel(config) {
 
 const SVG_NS = "http:" + "//www.w3.org/2000/svg";
 const ICONS = Object.freeze({
+	theme: {
+		size: 16,
+		parts: [
+			["circle", { cx: 12, cy: 12, r: 9 }],
+			["path", { d: "M12 3a9 9 0 0 1 0 18Z", fill: "currentColor", stroke: "none" }],
+		],
+	},
 	radar: {
 		size: 17,
 		parts: [
@@ -426,6 +435,7 @@ function readWorkspaceCollapsedPref() {
 export function mountOperatorChrome(root, config = {}) {
 	if (!root) throw new Error("mountOperatorChrome: root element is required");
 	root.classList.add("och-host");
+	if (!document.documentElement.dataset.consoleTheme) applyStoredConsoleTheme();
 
 	let currentConfig = { ...config };
 	let popoverOpen = false;
@@ -701,6 +711,47 @@ export function mountOperatorChrome(root, config = {}) {
 
 		global.appendChild(el("span", "och-spacer"));
 
+		const themePicker = el("div", "och-theme");
+		const trigger = el("button", "och-theme-trigger");
+		trigger.type = "button";
+		trigger.title = "主题";
+		trigger.setAttribute("aria-label", "主题");
+		trigger.appendChild(makeIcon("theme"));
+		trigger.setAttribute("aria-expanded", "false");
+		const menu = el("div", "och-theme-menu");
+		menu.id = `${popoverId}-theme`;
+		menu.popover = "auto";
+		menu.setAttribute("role", "group");
+		menu.setAttribute("aria-label", "选择主题");
+		trigger.setAttribute("aria-controls", menu.id);
+		trigger.popoverTargetElement = menu;
+		menu.addEventListener("beforetoggle", (event) => {
+			if (event.newState !== "open") return;
+			const rect = trigger.getBoundingClientRect();
+			menu.style.top = `${rect.bottom + 6}px`;
+			menu.style.left = `${Math.max(8, Math.min(rect.right - 112, window.innerWidth - 120))}px`;
+		});
+		menu.addEventListener("toggle", (event) => {
+			trigger.setAttribute("aria-expanded", String(event.newState === "open"));
+		});
+		for (const theme of CONSOLE_THEMES) {
+			const option = el("button", "och-theme-option", theme.label);
+			option.type = "button";
+			option.dataset.theme = theme.id;
+			option.setAttribute("aria-pressed", String(theme.id === (document.documentElement.dataset.consoleTheme ?? "default")));
+			option.addEventListener("click", () => {
+				setConsoleTheme(theme.id);
+				for (const item of menu.children) {
+					item.setAttribute("aria-pressed", String(item.dataset.theme === theme.id));
+				}
+				menu.hidePopover();
+				trigger.focus();
+			});
+			menu.appendChild(option);
+		}
+		themePicker.append(trigger, menu);
+		global.appendChild(themePicker);
+
 		if (model.statusVisible && model.freshness) {
 			const fresh = el("span", "och-fresh");
 			fresh.setAttribute("aria-label", "数据新鲜度");

package/dist/worker/scheduler/scheduled-goal-dispatch.js

@@ -69,10 +69,11 @@ export async function prepareScheduledGoalDraft(input, client) {
     if (!assessment.ok)
         throw new Error(`scheduled goal ineligible: ${assessment.reason}`);
     const digest = (bytes) => createHash("sha256").update(bytes).digest("hex");
+    const repositoryPath = (file) => path.relative(root, file).split(path.sep).join("/");
     return scheduledGoalDraftSchema.parse({ ...parsed, controllerRef: identity.packageFingerprint.value,
         prepared: { gateToken: `${snapshot.gate.id}:${snapshot.gate.digest}`,
-            dagPath: path.relative(root, paths.dagDraftPath), dagHash: digest(dagBytes),
-            contractPath: path.relative(root, paths.taskConfigPath), contractHash: digest(configBytes) }, });
+            dagPath: repositoryPath(paths.dagDraftPath), dagHash: digest(dagBytes),
+            contractPath: repositoryPath(paths.taskConfigPath), contractHash: digest(configBytes) }, });
 }
 /** Materialize only contract/runtime inputs; execution remains owned by the operation host. */
 export async function prepareDerivedScheduledGoalTask(goalId, ownerToken, goals, client) {

package/dist/worker/scheduler/scheduled-goal-evidence.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { execFile } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
 import { promisify } from "node:util";
 import { lstat, readFile, readlink, realpath } from "node:fs/promises";
 import path from "node:path";
@@ -7,6 +7,59 @@ import { pathMatchesPattern } from "../../shared/git-progress.js";
 import { scheduledGoalDraftSchema } from "./scheduled-goal-types.js";
 const execFileAsync = promisify(execFile);
 const sha256 = (value) => createHash("sha256").update(value).digest("hex");
+/** Working-copy paths that are plain files, so Git can read them back. */
+async function plainFileNames(root, names) {
+    const plain = [];
+    for (const name of names) {
+        const info = await lstat(path.resolve(root, name)).catch(() => undefined);
+        if (info?.isFile())
+            plain.push(name);
+    }
+    return plain;
+}
+/**
+ * Repository-form blob IDs for working-copy files, computed by Git itself so
+ * that `core.autocrlf` and `eol` attributes normalize exactly as a commit
+ * would. Hashing never consults the index, so staged-only and
+ * `assume-unchanged` paths keep their raw-byte meaning. A failure degrades to
+ * the caller's raw-byte blob, which can only over-report change, never hide it;
+ * `--stdin-paths` cannot carry names containing a newline.
+ */
+async function gitNormalizedBlobIds(root, names) {
+    const ids = new Map();
+    const candidates = names.filter((name) => !name.includes("\n"));
+    if (candidates.length === 0)
+        return ids;
+    let stdout;
+    try {
+        stdout = await new Promise((resolve, reject) => {
+            const child = spawn("git", ["-C", root, "hash-object", "--stdin-paths"], { stdio: ["pipe", "pipe", "pipe"] });
+            let output = "";
+            let failure = "";
+            child.stdout.setEncoding("utf8");
+            child.stdout.on("data", (chunk) => { output += chunk; });
+            child.stderr.setEncoding("utf8");
+            child.stderr.on("data", (chunk) => { failure += chunk; });
+            child.on("error", reject);
+            child.on("close", (code) => {
+                if (code === 0)
+                    resolve(output);
+                else
+                    reject(new Error(`git hash-object failed: ${failure.trim()}`));
+            });
+            child.stdin.end(`${candidates.join("\n")}\n`);
+        });
+    }
+    catch {
+        return ids;
+    }
+    const hashes = stdout.split("\n").map((line) => line.trim()).filter(Boolean);
+    if (hashes.length !== candidates.length)
+        return ids;
+    for (let index = 0; index < candidates.length; index += 1)
+        ids.set(candidates[index], hashes[index]);
+    return ids;
+}
 /** Run only frozen AC commands. A timeout is uncertain execution, never a passing or repairable failure. */
 export async function evaluateScheduledGoalCriteria(frozen, options = {}) {
     frozen = scheduledGoalDraftSchema.pick({ worktreeRef: true, frozenBase: true, allowedPaths: true, forbiddenPaths: true, acceptance: true, time: true }).strip().parse(frozen);
@@ -115,6 +168,11 @@ export async function captureScheduledGoalTree(worktree, base, allowedPaths, for
     const blobId = (bytes) => createHash(objectFormat).update(`blob ${bytes.length}\0`).update(bytes).digest("hex");
     const names = [...new Set([...entries(tracked), ...entries(untracked), ...baseEntries.keys()])].sort();
     const deliveryNames = new Set(names);
+    // Compare content identity through Git's own normalization: a working copy
+    // materialized with `core.autocrlf` (or an `eol` attribute) is stored as LF
+    // while the checkout is CRLF, and raw bytes would report that as drift on
+    // every text file.
+    const normalizedIds = await gitNormalizedBlobIds(root, await plainFileNames(root, names));
     const files = [];
     const changedPaths = [];
     for (const name of names) {
@@ -143,8 +201,13 @@ export async function captureScheduledGoalTree(worktree, base, allowedPaths, for
             }
             else if (stat.isFile()) {
                 const bytes = await readFile(target);
-                files.push({ name, kind: "file", hash: sha256(bytes), executable: Boolean(stat.mode & 0o111) });
-                actualId = blobId(bytes);
+                actualId = normalizedIds.get(name) ?? blobId(bytes);
+                files.push({
+                    name,
+                    kind: "file",
+                    hash: sha256(`${objectFormat}:${actualId}`),
+                    executable: Boolean(stat.mode & 0o111),
+                });
                 actualMode = stat.mode & 0o111 ? "100755" : "100644";
             }
             else

package/dist/worker/scheduler/scheduled-goal-store.js

@@ -16,6 +16,16 @@ async function syncDirectory(directoryPath) {
     try {
         await directory.sync();
     }
+    catch (error) {
+        // The file body is already durable from the file-level fsync above.
+        // Windows refuses to flush a directory handle (EPERM) and some
+        // filesystems reject the call outright, so a directory-only failure must
+        // not abort a transaction whose data is already on disk.
+        const code = error.code;
+        if (code !== "EPERM" && code !== "EACCES" && code !== "EINVAL"
+            && code !== "ENOTSUP" && code !== "EOPNOTSUPP" && code !== "ENOSYS")
+            throw error;
+    }
     finally {
         await directory.close();
     }

package/dist/workflows/dag/budget-enforcement.js

@@ -1,6 +1,6 @@
 import { writeFile } from "node:fs/promises";
 import path from "node:path";
-import { checkBudgetPreNode, createBudgetLedger, formatBudgetReportMarkdown, isHardBudgetBreached, recordNodeBudgetSample, reserveProviderBudget, skipPendingNodesForBudgetBreach, } from "../../application/evaluation/budget.js";
+import { campaignBudgetSchema, checkBudgetPreNode, createBudgetLedger, formatBudgetReportMarkdown, isHardBudgetBreached, recordNodeBudgetSample, reserveProviderBudget, skipPendingNodesForBudgetBreach, } from "../../application/evaluation/budget.js";
 import { sha256OfCanonicalJson } from "../../task/contract/hash.js";
 /** A continuation already contains its ancestors' consumption. Never sum both. */
 export function validateCumulativeBudgetSuccessor(parent, child) {
@@ -9,9 +9,33 @@ export function validateCumulativeBudgetSuccessor(parent, child) {
     const next = child.budgetLedger;
     if (!previous || !next || !lineage || (child.continuation?.parentRunId ?? child.frontendRecoveryState?.parentRunId) !== parent.runId || lineage.parentLedgerSha256 !== sha256OfCanonicalJson(previous) || sha256OfCanonicalJson(lineage.inheritedConsumed) !== sha256OfCanonicalJson(previous.consumed) || sha256OfCanonicalJson(parent.budget ?? null) !== sha256OfCanonicalJson(child.budget ?? null))
         throw Error("FRONTEND_PROVIDER_BUDGET_LINEAGE_INVALID: unbound cumulative continuation");
+    const invalid = (reason) => { throw Error(`FRONTEND_PROVIDER_BUDGET_LINEAGE_INVALID: ${reason}`); };
+    for (const [state, ledger] of [[parent, previous], [child, next]]) {
+        const parsed = campaignBudgetSchema.safeParse(state.budget);
+        if (!parsed.success || ledger.schemaVersion !== 1 || ledger.mode !== parsed.data.mode || sha256OfCanonicalJson(ledger.limits) !== sha256OfCanonicalJson(parsed.data.limits))
+            invalid("ledger differs from frozen budget");
+        const count = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0;
+        for (const key of ["executorCalls", "wallTimeMs", "repairPasses", "peakContextChars"])
+            if (!count(ledger.consumed[key]))
+                invalid("invalid consumption");
+        if (ledger.consumed.tokens !== null && !count(ledger.consumed.tokens))
+            invalid("invalid token consumption");
+        if ((ledger.mode === "hard" && ledger.limits.maxProviderRequests !== undefined || ledger.consumed.providerRequests !== undefined) && !count(ledger.consumed.providerRequests))
+            invalid("invalid request consumption");
+        if (!Array.isArray(ledger.consumed.missingTokenNodeIds) || ledger.consumed.missingTokenNodeIds.some(id => typeof id !== "string" || !id))
+            invalid("invalid missing token records");
+        if (!Array.isArray(ledger.breaches) || (ledger.mode === "record-only" ? ledger.status !== "record-only" : !["ok", "breached"].includes(ledger.status)))
+            invalid("invalid ledger status");
+    }
     for (const key of ["executorCalls", "providerRequests", "wallTimeMs", "repairPasses", "peakContextChars"])
         if ((next.consumed[key] ?? 0) < (previous.consumed[key] ?? 0))
-            throw Error("FRONTEND_PROVIDER_BUDGET_LINEAGE_INVALID: consumption decreased");
+            invalid("consumption decreased");
+    if (previous.consumed.tokens !== null && (next.consumed.tokens === null || next.consumed.tokens < previous.consumed.tokens))
+        invalid("token consumption decreased");
+    if (previous.consumed.missingTokenNodeIds.some(id => !next.consumed.missingTokenNodeIds.includes(id)))
+        invalid("missing token records lost");
+    if (previous.status === "breached" && next.status !== "breached" || previous.breaches.some(breach => !next.breaches.some(value => sha256OfCanonicalJson(value) === sha256OfCanonicalJson(breach))))
+        invalid("budget breach lost");
     return next;
 }
 const requestQueues = new WeakMap();
@@ -27,6 +51,11 @@ export async function reserveDagProviderRequest(input) {
             throw Error("FRONTEND_PROVIDER_BUDGET_STALE: request belongs to an inactive attempt");
         if (isHardBudgetBreached(ledger))
             throw Error("FRONTEND_PROVIDER_BUDGET_EXHAUSTED: run budget already breached");
+        if ((ledger.consumed.providerRequests ?? 0) < ledger.limits.maxProviderRequests && input.reserveTaskRequest) {
+            await input.reserveTaskRequest();
+            if (!active())
+                throw Error("FRONTEND_PROVIDER_BUDGET_STALE: attempt stopped during task reservation");
+        }
         const breach = reserveProviderBudget(ledger, input.nodeId);
         if (breach)
             applyHardBudgetBreach(input.state, breach);