@deepwatch/dsh-client-settings 0.1.0

package/lib/client.js

@@ -0,0 +1,3888 @@
+window.__ModuleLoader__.load({
+	id: "@deepwatch/dsh-client-settings",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+		let react = require("react");
+		let react_jsx_runtime = require("react/jsx-runtime");
+		let _deepseek_ai_dsh_client_ui_primitives = require("@deepseek-ai/dsh-client-ui-primitives");
+		//#region ../brand/lib/identity.js
+		/**
+		* The Watch product identity, and the one colour rule that matters.
+		*
+		* Kept as data rather than as markup so the same strings reach the sidebar,
+		* the conversation hero, the About panel, the window title and the release
+		* notes without four copies drifting apart. Attribution in particular has to
+		* be identical everywhere it appears, because it is a legal statement rather
+		* than a design element.
+		*
+		* @module @deepwatch/dsh-client-brand/identity
+		*/
+		/** What the product is called. Never "DeepSeek" anything. */
+		const PRODUCT_NAME = "DeepWatch";
+		/**
+		* Attribution to the upstream project.
+		*
+		* Required, and required to be visible. Watch is built on DeepSeek Harness and
+		* says so; the alternative — quietly shipping someone else's foundation — is
+		* both wrong and against the MIT notice this distribution inherits.
+		*/
+		const ATTRIBUTION = "Built on DeepSeek Harness · Powered by Watch Skill";
+		/**
+		* The independence disclosure.
+		*
+		* Equally required, and for the opposite reason: attribution without it could
+		* read as endorsement, and no such endorsement exists.
+		*/
+		const INDEPENDENCE = "DeepWatch and Watch Skill are independent projects and are not affiliated with or endorsed by DeepSeek.";
+		/**
+		* The semantic token a tone maps to.
+		*
+		* Feature packages ask for a tone and get a CSS variable. They never write a
+		* hex value, which is what stops the palette from being re-invented slightly
+		* differently in every panel — and what makes a theme change one edit.
+		*/
+		function tokenFor(tone) {
+			return `var(--watch-tone-${tone})`;
+		}
+		//#endregion
+		//#region ../brand/lib/mark.js
+		/**
+		* The Watch mark, inlined.
+		*
+		* Generated by `scripts/brand-assets.mjs` from `assets/watch-orca-master.png`.
+		* Do not edit by hand: the master is the brand source of truth and this is a
+		* mechanical derivation of it at 64px, which covers a 32px slot at 2x.
+		*
+		* @module @deepwatch/dsh-client-brand/mark
+		*/
+		/** The orca, as a transparent PNG data URI. */
+		const WATCH_MARK_PNG = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAYAAACqaXHeAAAF+UlEQVR42u1Za4hUZRhezbxladcfSkmpuO7sfJf5Y5EFupDRDcK0nTnf934nJNDKrCTCROyHv6JCEaWyP9mPjESQiH4EW4iYREkZhGDQRSq7kGl7cc/7zpz23M+M67qrM7s6ngc+dvYwwznP8z7v5ftOS0uGDBkyZMiQIUOGDBnGGtKmFqaQCcDnpcF3pcFPBeAnTFNnUxPPdeIUYXC1NPi9AHSlIbdgk1sw5AqNfQJoeVMSz2saL4BWSoPHfcIhaV+A4O+XAqitKckLoFkc8LOIbFqAgqGKBNzFNU1szsgrWiqA/pRRtKvJe9feYwrHN2mRo3XSEFURtwMhpJ//eJgBTW468kx5+Y5bBZDrLWnKbsEuJ+R9AagiDN19+VVxRdcJQ23C0CIBtEQaXCxtWpgr0XxmcEauRNO5xt0+8ZC8tMPlfTaxCIcvD8LaJwzC4PsC8JeAFLnCJH+9diY0utxfVPGvx9GnkHxyzf8+0M5L28YaZ3ON2wXQ6eTBz7N0QjoWwE4LFX3PF2vfJUm8reRcxTSt54C93sNyTS5XPrmKF2EvdyOCMrZ5DUEztFDebzgQMaDVCyyacAn1a7yJa/zci1DwoOgWN1LvF99VevvR7a9U3L6/Trr9e7rKPR1PY39EPixq1bavWenrkQihUMcGlsUtGttWmLfoVq7xKA/Je6tgk/Nfr3vGHQT/nHadjjXUH5NJRz8iHre+8pCC+P9rOsI1PjBG5PFGrvFYWMSSXAZyV71a7vvtb7e/VoBvj1W6F60ip0oAU50OMiJvD+6KSKS4Zhg/5fYwwJtHuW/jHq7Q9ZZvf11VrLyBpbxiA/U8t6XcveaNcs8jL1Jfrd1FKqqxCzwBngj7v31u8rK2Zmj8lQPdOyrk5z/u5GPiis4ITQck0DtC02tC41bh93T8WgKekUNUfVlT5KpTYBDbwzlc4Kegvxym8MlRmNWxkyt0BshsYppuGKItTuGA9wuNOwXQKZkSYNBKH8366fG3tnsEXcW71ieBugP3hQ6MPgO90Fj7A84TgCtH8huucZrUuFZoPJE88NkCpNMjiXxM+ggr0VqmcI60aVx4QDKbK9wsvXOBpBNVmMKnGr5xuSDxLLxHRFHUNbZOpUVseX9ipB+ZRRaHc7c9ZuGjItWNJGCZa3y4YQIsKNFEpujBkQrRVnTGC40/i8TKZ7W6QvL5Bwn0bLs6/+6vvYgzuMZKdGIUCIwnOdAdjasFJZqTt/B1ATRtROmgcF1s19QJjwDqKhjaKgFfEkB3SXt4g868x3rGMY17Y/JRLQn2EIfaVQMnR2moPa+wSxi6cwQtdCrXeLxWBAH0EwOaOuLNV5HuixwVnyDFxdO/x8uNrQeGbuGA+4ShN+d3OrcN0wVLhcZyusL7+wgYefESQAuFRscrflUtM5kR+oRpYCqERXFc3nJWCsBTAvBtpil33t8AbpAp2wbRwm8u5P7tRWemMLRGGjzkCRFun5M5QdMHo7U52i8g2gHiQaZxbU7h3MGKpXdNAr7iRy4pfmUGJC/mGbjCgtD4Uap9hl2B+CicCdD6pB9HbQx78pZzgClnOwOn2FrC26uE0LhCGvq3ELqAA26rSzAUGqGDabQQ1IcPcyVcLA1uHkiJXdLgNqYczRRdU896MEtAuO0NT3K4pq4w4hOkTddK++wbDqTNTAm4XXoppPB43RypscMLgEy1x0H2GCeYxmV1E4Er3BFX5eAg48CwHVRyprR34qy6Hc+VcHLewv2pFKvaa8RvmAArOQufqddO8Xqhg7PA8Ka/X+jkeNHBANoRFcTIAYWaly0S6DS38CBX+FXrivL0ermASYN/hAJU+Bi8wsorbBWAFLgxHr9Phe2yWxr6WBpaxjVNakxH0DjX2xYXDHrn+ZtGXQBNG9NTYbhJWiJtmjTcKfPiRbCcCVw7nRywY9TfNBnaHXeAoBvt9eaVlisFPJwFCoH9dzbty9QhDmTeCvN/y1gV4bF2gMWVczQPdHXLlYjW5TQpV8SHWjJkyJAhQ4YMGTJkyJAhQ4YMGTIMH/8DqnZ5/XHc+csAAAAASUVORK5CYII=";
+		//#endregion
+		//#region ../technology/lib/ocr.js
+		/** Shared resource limits for a local OCR engine. */
+		const LOCAL_LIMITS = {
+			maxConcurrency: 2,
+			timeoutMs: 12e4,
+			maxMemoryMb: 4096
+		};
+		/**
+		* The lightweight local route.
+		*
+		* The default, because it runs everywhere. Not because it is the most accurate
+		* — on clean documents it is not — but because a default that needs a GPU is
+		* not a default.
+		*/
+		const RAPID_OCR = {
+			id: "ocr.rapidocr",
+			displayName: "RapidOCR (ONNX)",
+			version: "1.x",
+			kind: "engine",
+			capabilities: ["document_ocr", "visual"],
+			modalities: ["image"],
+			roles: ["ocr_layout"],
+			runtime: "local_library",
+			protocols: [],
+			endpoints: [],
+			credentialReference: null,
+			hardware: {
+				gpu: "none",
+				minVramGb: null,
+				minRamGb: 2,
+				accelerators: []
+			},
+			privacy: {
+				egress: "none",
+				worksOffline: true,
+				requiresEgressConsent: false
+			},
+			install: {
+				method: "package_manager",
+				downloadBytes: null,
+				automatic: false
+			},
+			provenance: {
+				codeLicense: "Apache-2.0",
+				weightsLicense: "Apache-2.0",
+				revision: null,
+				sourceUrl: "https://github.com/RapidAI/RapidOCR",
+				weightsLicenseReviewed: true
+			},
+			resources: LOCAL_LIMITS,
+			trust: "built_in",
+			probeMethod: "import check",
+			testMethod: "recognize a bundled fixture image"
+		};
+		/** The deterministic system fallback, for scripts the ONNX route cannot read. */
+		const TESSERACT = {
+			id: "ocr.tesseract",
+			displayName: "Tesseract",
+			version: "5.x",
+			kind: "engine",
+			capabilities: ["document_ocr"],
+			modalities: ["image"],
+			roles: ["ocr_layout"],
+			runtime: "local_process",
+			protocols: [],
+			endpoints: [],
+			credentialReference: null,
+			hardware: {
+				gpu: "none",
+				minVramGb: null,
+				minRamGb: 1,
+				accelerators: []
+			},
+			privacy: {
+				egress: "none",
+				worksOffline: true,
+				requiresEgressConsent: false
+			},
+			install: {
+				method: "package_manager",
+				downloadBytes: null,
+				automatic: false
+			},
+			provenance: {
+				codeLicense: "Apache-2.0",
+				weightsLicense: "Apache-2.0",
+				revision: null,
+				sourceUrl: "https://github.com/tesseract-ocr/tesseract",
+				weightsLicenseReviewed: true
+			},
+			resources: LOCAL_LIMITS,
+			trust: "built_in",
+			probeMethod: "tesseract --version",
+			testMethod: "recognize a bundled fixture image"
+		};
+		/**
+		* DeepSeek-OCR, the compatibility and comparison route.
+		*
+		* Pinned to a reviewed revision. `trust_remote_code` in its published
+		* inference path is why `trust` is `isolated` and the runtime is a separate
+		* process: a surprise in a model repository should cost a worker, not the
+		* workspace.
+		*/
+		const DEEPSEEK_OCR = {
+			id: "ocr.deepseek-ocr",
+			displayName: "DeepSeek-OCR",
+			version: "1.0",
+			kind: "engine",
+			capabilities: ["document_ocr", "visual"],
+			modalities: ["image"],
+			roles: ["ocr_layout"],
+			runtime: "local_process",
+			protocols: [],
+			endpoints: [],
+			credentialReference: null,
+			hardware: {
+				gpu: "required",
+				minVramGb: 12,
+				minRamGb: 16,
+				accelerators: ["cuda"]
+			},
+			privacy: {
+				egress: "none",
+				worksOffline: true,
+				requiresEgressConsent: false
+			},
+			install: {
+				method: "download",
+				downloadBytes: null,
+				automatic: false
+			},
+			provenance: {
+				codeLicense: "MIT",
+				weightsLicense: null,
+				revision: "09eaf526153e7a01ed16c9dea8c96282aaea29c0",
+				sourceUrl: "https://github.com/deepseek-ai/DeepSeek-OCR",
+				weightsLicenseReviewed: false
+			},
+			resources: {
+				maxConcurrency: 1,
+				timeoutMs: 3e5,
+				maxMemoryMb: 16384
+			},
+			trust: "isolated",
+			probeMethod: "worker handshake",
+			testMethod: "recognize a bundled fixture image in the worker"
+		};
+		/** The engines this build knows about. */
+		const OCR_ENGINES = [
+			RAPID_OCR,
+			TESSERACT,
+			DEEPSEEK_OCR,
+			{
+				...DEEPSEEK_OCR,
+				id: "ocr.deepseek-ocr2",
+				displayName: "DeepSeek-OCR2",
+				version: "2.0",
+				provenance: {
+					codeLicense: "Apache-2.0",
+					weightsLicense: null,
+					revision: "2f3699ebbb96fa8af32212e8c170f2cc28730fad",
+					sourceUrl: "https://github.com/deepseek-ai/DeepSeek-OCR-2",
+					weightsLicenseReviewed: false
+				}
+			},
+			{
+				id: "ocr.cloud",
+				displayName: "Cloud OCR (deployment-configured)",
+				version: "1.0",
+				kind: "engine",
+				capabilities: ["document_ocr", "visual"],
+				modalities: ["image"],
+				roles: ["ocr_layout"],
+				runtime: "remote",
+				protocols: ["https"],
+				endpoints: [],
+				credentialReference: "dsh:connection",
+				hardware: {
+					gpu: "none",
+					minVramGb: null,
+					minRamGb: 0,
+					accelerators: []
+				},
+				privacy: {
+					egress: "content",
+					worksOffline: false,
+					requiresEgressConsent: true
+				},
+				install: {
+					method: "none",
+					downloadBytes: null,
+					automatic: false
+				},
+				provenance: {
+					codeLicense: "proprietary",
+					weightsLicense: "proprietary",
+					revision: null,
+					sourceUrl: "",
+					weightsLicenseReviewed: true
+				},
+				resources: {
+					maxConcurrency: 4,
+					timeoutMs: 6e4,
+					maxMemoryMb: 256
+				},
+				trust: "untrusted",
+				probeMethod: "endpoint reachability",
+				testMethod: "recognize a bundled fixture image over the wire"
+			}
+		];
+		//#endregion
+		//#region ../contracts/lib/readiness.js
+		/**
+		* Whether a role can actually run, kept as four separate facts.
+		*
+		* This module exists because they were one. A provider row showed a green dot
+		* the moment a credential was saved, and a person reasonably read that as "the
+		* product is ready" — so they typed a prompt, and the runtime routed it to a
+		* provider they had never configured, failed on a missing environment
+		* variable, and left a failed turn in their session. Every step of that was a
+		* consequence of one indicator standing for four different questions:
+		*
+		*   1. is there a credential?          {@link ProviderCredentialStatus}
+		*   2. does the provider answer?       {@link ProviderReachability}
+		*   3. is a model chosen?              {@link ModelSelectionStatus}
+		*   4. is a role bound and runnable?   {@link RoleBindingStatus}
+		*
+		* A credential is the *first* of those and implies none of the others.
+		* {@link roleReadiness} is the only thing in this product allowed to answer
+		* "ready", and it requires all four to line up, plus a route that supports the
+		* role and a policy state that permits the request.
+		*
+		* **Nothing here ever carries secret material.** Not a value, not a prefix, a
+		* suffix, a length or a hash. A credential appears in these types only as a
+		* *reference* — an opaque handle the Host can resolve — and as a status word.
+		* `configured_unverified` is the honest state after a save: something is
+		* stored, and nobody has asked the provider whether it works.
+		*
+		* Verification is deliberately not automatic. Saving a credential must not
+		* quietly spend a request, and discovering models must be distinguishable from
+		* a billable completion — so both are user actions with their own results, and
+		* {@link ProviderReachability} stays `unknown` until one of them runs.
+		*
+		* @module @deepwatch/dsh-contracts/readiness
+		*/
+		/**
+		* The order blockers are reported in.
+		*
+		* Not alphabetical and not arbitrary: it is the order a person has to fix them
+		* in. Telling somebody their model is unavailable when they have not chosen a
+		* provider sends them to the wrong screen.
+		*/
+		const BLOCKER_ORDER = [
+			"no_binding",
+			"provider_unknown",
+			"credential_absent",
+			"credential_inaccessible",
+			"credential_rejected",
+			"model_unset",
+			"model_invalid",
+			"model_unavailable",
+			"provider_untested",
+			"provider_unreachable",
+			"provider_rate_limited",
+			"route_lacks_role",
+			"modality_unsupported",
+			"contract_mismatch",
+			"consent_required",
+			"policy_forbids"
+		];
+		/**
+		* Whether a role can run, and if not, exactly what is missing.
+		*
+		* The single gate. A caller may not assemble "ready" from parts: every surface
+		* that shows readiness, and both halves of preflight, ask this function, so
+		* there is one definition of executable and it is testable on its own.
+		*
+		* @param inputs - every fact that bears on the decision.
+		* @param role - the role being asked about.
+		* @returns the status and the blockers, in the order they must be fixed.
+		*/
+		function roleReadiness(role, inputs) {
+			const found = /* @__PURE__ */ new Set();
+			const { binding, route } = inputs;
+			if (binding === null) found.add("no_binding");
+			else {
+				if (route === null) found.add("provider_unknown");
+				if (inputs.credential === "absent") found.add("credential_absent");
+				if (inputs.credential === "inaccessible") found.add("credential_inaccessible");
+				if (inputs.credential === "rejected") found.add("credential_rejected");
+				if (inputs.credential === "configured_unverified") found.add("provider_untested");
+				if (inputs.reachability === "unauthorized") found.add("credential_rejected");
+				if (inputs.reachability === "unknown") found.add("provider_untested");
+				if (inputs.reachability === "unreachable") found.add("provider_unreachable");
+				if (inputs.reachability === "rate_limited") found.add("provider_rate_limited");
+				if (inputs.model === "none" || binding.model === "") found.add("model_unset");
+				if (inputs.model === "invalid") found.add("model_invalid");
+				if (inputs.model === "unavailable") found.add("model_unavailable");
+				if (route !== null) {
+					if (!route.roles.includes(role)) found.add("route_lacks_role");
+					const supported = new Set(route.modalities);
+					if (!binding.modalities.every((modality) => supported.has(modality))) found.add("modality_unsupported");
+				}
+				if (!inputs.contractMatches) found.add("contract_mismatch");
+				if (!inputs.consentGranted) found.add("consent_required");
+				if (!inputs.policyPermits) found.add("policy_forbids");
+			}
+			const blockers = BLOCKER_ORDER.filter((blocker) => found.has(blocker));
+			if (blockers.length === 0) return {
+				role,
+				status: "executable",
+				blockers: [],
+				primaryBlocker: null
+			};
+			return {
+				role,
+				status: binding === null ? "unbound" : blockers.every((blocker) => blocker === "provider_untested") ? "bound_unverified" : "blocked",
+				blockers,
+				primaryBlocker: blockers[0] ?? null
+			};
+		}
+		/**
+		* Whether a role may be described to a person as ready.
+		*
+		* A helper rather than a comparison at each call site, because "ready" is
+		* exactly the word this whole module exists to stop being used loosely.
+		*/
+		function isExecutable(readiness) {
+			return readiness.status === "executable";
+		}
+		/** What a person should be told to do about one blocker, in their words. */
+		const BLOCKER_COPY = {
+			no_binding: "Choose a provider and model for this capability.",
+			provider_unknown: "The bound provider is no longer available. Choose another.",
+			credential_absent: "Add a credential for this provider.",
+			credential_inaccessible: "The saved credential could not be read. Save it again.",
+			credential_rejected: "The provider rejected the saved credential. Update it.",
+			provider_untested: "Run the provider test before using this capability.",
+			provider_unreachable: "The provider did not answer. Check the network and try again.",
+			provider_rate_limited: "The provider rate-limited the test. Wait, then try again.",
+			model_unset: "Choose a model for this capability.",
+			model_invalid: "The chosen model is not valid for this provider. Choose another.",
+			model_unavailable: "The provider no longer offers the chosen model. Choose another.",
+			route_lacks_role: "This provider cannot serve this capability. Choose another.",
+			modality_unsupported: "This model does not support what this capability needs.",
+			contract_mismatch: "This version of DeepWatch cannot talk to that provider.",
+			consent_required: "This capability needs a consent that has not been granted.",
+			policy_forbids: "Policy on this machine forbids this request."
+		};
+		/**
+		* One sentence a person can act on, for the blocker that matters most.
+		*
+		* Deliberately free of route ids, package names and environment variables:
+		* those belong in Diagnostics, and a person reading their first error should
+		* be told what to do rather than what broke internally.
+		*/
+		function blockerMessage(readiness) {
+			const blocker = readiness.primaryBlocker;
+			return blocker === null ? null : BLOCKER_COPY[blocker];
+		}
+		/**
+		* The accessible label for a status, so colour is never the only signal.
+		*
+		* Every surface uses these words, so a screen reader and a sighted reader are
+		* told the same thing, and a red or green dot is decoration on top of text
+		* rather than the fact itself.
+		*/
+		const BINDING_STATUS_LABEL = {
+			unbound: "Not configured",
+			bound_unverified: "Configured · not tested",
+			executable: "Ready",
+			blocked: "Blocked"
+		};
+		/** The accessible label for a credential status. */
+		const CREDENTIAL_STATUS_LABEL = {
+			absent: "No credential",
+			configured_unverified: "Credential saved · not yet assigned",
+			verified: "Credential accepted",
+			rejected: "Credential rejected",
+			inaccessible: "Credential unreadable"
+		};
+		//#endregion
+		//#region ../contracts/lib/bindings.js
+		/**
+		* What a person actually chose: which provider, which model, for which role.
+		*
+		* {@link module:@deepwatch/dsh-contracts/readiness} answers "can this run?"
+		* from four separate facts. This module is where three of those facts are
+		* *kept* — a durable document recording the decisions, so that reopening the
+		* product finds the same bindings rather than an empty screen and a composer
+		* pointed at somebody else's default.
+		*
+		* **A binding is a reference, never a credential.** The document below can be
+		* read by anything: it is written to the Harness's own settings file, it rides
+		* the settings RPC, it appears in Diagnostics, and it is included in a session
+		* export. None of that is safe unless the rule is absolute, so it is: the only
+		* credential-shaped field here is {@link RoleBindingRecord.credentialRef}, an
+		* opaque handle the Host resolves against its own store. No value, no prefix,
+		* no suffix, no length, no hash. {@link assertNoSecretMaterial} is the test
+		* this file is held to.
+		*
+		* **Nothing is bound implicitly.** There is no "default role", no inheritance
+		* from one role to another, and no provider that becomes bound because it was
+		* the only one configured. A role with no entry in {@link WatchBindings.roles}
+		* is unbound, and unbound means the composer refuses. That is the whole point
+		* of the module: the failure it exists to prevent was a product that treated a
+		* saved credential as a decision the person never made.
+		*
+		* @module @deepwatch/dsh-contracts/bindings
+		*/
+		/**
+		* The settings namespace this document lives in.
+		*
+		* A DeepWatch-owned section of the Harness's own user-settings document, which
+		* is what makes the binding durable, hot-reloaded and editable by hand without
+		* DeepWatch inventing a second configuration store beside the one the product
+		* already has.
+		*/
+		const BINDINGS_NAMESPACE = "watch-bindings";
+		/**
+		* The roles a person can bind to a provider, in the order setup presents them.
+		*
+		* These ids are `RoleId`s from `@deepwatch/dsh-technology`, spelled here rather
+		* than imported because `contracts` is the package everything else depends on
+		* and must not depend on anything. `tests/bindings-store.test.mjs` asserts the
+		* two lists agree, so the duplication is checked rather than trusted -- one
+		* role vocabulary with a gate on it, instead of two that drift.
+		*
+		* It is a *subset*. `verifier`, `ocr_layout`, `reranking` and
+		* `speaker_diarization` are served by local engines rather than chosen from a
+		* provider catalogue, so offering them here would offer a choice that is not
+		* there.
+		*
+		* `agent_model` is first and is the only one the first conversation needs. The
+		* rest are progressive: a product that demanded five bindings before the first
+		* message would be a product nobody finished configuring.
+		*/
+		const BINDABLE_ROLES = [
+			"agent_model",
+			"visual_perception",
+			"asr",
+			"audio_understanding",
+			"embeddings"
+		];
+		/** The role the first conversation needs, named once so nothing spells it twice. */
+		const PRIMARY_ROLE = "agent_model";
+		/**
+		* What each role is called on screen.
+		*
+		* `agent_model` is labelled **Chat**, and the difference is not cosmetic. A
+		* person configuring this product is not choosing an "agent model" -- they are
+		* choosing what answers them in the surface the Harness calls Chat, and every
+		* blocked-composer message and setup step has to name the thing they are
+		* looking at. The id stays `agent_model` because that is the vocabulary the
+		* descriptors and the routing rules already use.
+		*/
+		const ROLE_LABEL = {
+			agent_model: "Chat",
+			visual_perception: "Visual perception",
+			asr: "Speech to text",
+			audio_understanding: "Audio understanding",
+			embeddings: "Embeddings and retrieval"
+		};
+		/** Whether a string is a role this product binds. */
+		function isBindableRole(value) {
+			return BINDABLE_ROLES.includes(value);
+		}
+		/**
+		* What each role is for, in a person's words.
+		*
+		* Here rather than in a component because the setup flow, the Role Bindings
+		* screen and the blocked-composer card all name the same role, and three
+		* copies of this sentence would eventually be three different sentences.
+		*/
+		const ROLE_PURPOSE = {
+			agent_model: "Plans, reasons and writes. This is what answers you in a conversation.",
+			visual_perception: "Reads what is on screen or in a frame.",
+			asr: "Speech to text, with timings a citation can point at.",
+			audio_understanding: "Non-speech audio: events, tone, music.",
+			embeddings: "Search over the library and over memory."
+		};
+		/** The modalities each role's work actually needs a route to support. */
+		const ROLE_MODALITIES = {
+			agent_model: ["text"],
+			visual_perception: ["vision"],
+			asr: ["audio"],
+			audio_understanding: ["audio"],
+			embeddings: ["embedding"]
+		};
+		/** The actors a stored document may name. */
+		const BINDING_ACTORS = [
+			"person",
+			"setup",
+			"unknown"
+		];
+		/** Whether a stored value is an actor this build understands. */
+		function isBindingActor(value) {
+			return typeof value === "string" && BINDING_ACTORS.includes(value);
+		}
+		/** The document a profile that has never been configured has. */
+		const EMPTY_BINDINGS = {
+			version: 1,
+			roles: {}
+		};
+		/**
+		* A model id worth storing.
+		*
+		* Deliberately permissive about shape — provider model ids are provider-owned
+		* and this product does not get to decide that `openai/gpt-4o` is malformed —
+		* and deliberately strict about the things that make a stored value dangerous:
+		* control characters, newlines and absurd length, all of which arrive from a
+		* hand-edited settings file rather than from the picker.
+		*/
+		function isStorableId(value) {
+			return typeof value === "string" && value !== "" && value.length <= 200 && !/[\u0000-\u001f\u007f]/.test(value);
+		}
+		/**
+		* Read a stored document, keeping only what is well-formed.
+		*
+		* A hand-edited settings file is a supported way to configure this product, so
+		* a malformed entry must not take the whole document with it: the bad role is
+		* dropped and the rest survive. Dropping is the safe direction — an unbound
+		* role refuses at the composer, where a person is told what to fix, whereas a
+		* half-read binding would route a prompt somewhere nobody chose.
+		*
+		* @param raw - whatever the settings document held.
+		* @returns a document this build can act on.
+		*/
+		function readBindings(raw) {
+			if (typeof raw !== "object" || raw === null) return EMPTY_BINDINGS;
+			const record = raw;
+			if (typeof record.version === "number" && record.version > 1) return EMPTY_BINDINGS;
+			if (typeof record.roles !== "object" || record.roles === null) return EMPTY_BINDINGS;
+			const roles = {};
+			for (const [role, value] of Object.entries(record.roles)) {
+				if (!isBindableRole(role)) continue;
+				const entry = readBindingRecord(value);
+				if (entry !== null) roles[role] = entry;
+			}
+			return {
+				version: 1,
+				roles
+			};
+		}
+		/** One entry, or null when it is not something this build can honour. */
+		function readBindingRecord(value) {
+			if (typeof value !== "object" || value === null) return null;
+			const entry = value;
+			if (!isStorableId(entry["provider"]) || !isStorableId(entry["model"])) return null;
+			const ref = entry["credentialRef"];
+			const credentialRef = typeof ref === "string" && ref !== "" ? ref : null;
+			const boundAt = typeof entry["boundAt"] === "string" ? entry["boundAt"] : "";
+			const boundBy = isBindingActor(entry["boundBy"]) ? entry["boundBy"] : "unknown";
+			return {
+				provider: entry["provider"],
+				model: entry["model"],
+				credentialRef,
+				boundAt,
+				boundBy
+			};
+		}
+		/**
+		* The document with one role bound, as a new value.
+		*
+		* Never mutates: the caller holds a snapshot it may still be rendering from,
+		* and a document edited underneath a React tree is a stale-render bug that
+		* shows somebody the binding they had a moment ago.
+		*/
+		function withBinding(current, role, record) {
+			return {
+				version: 1,
+				roles: {
+					...current.roles,
+					[role]: record
+				}
+			};
+		}
+		/** The document with one role unbound. */
+		function withoutBinding(current, role) {
+			return {
+				version: 1,
+				roles: Object.fromEntries(Object.entries(current.roles).filter(([key]) => key !== role))
+			};
+		}
+		/**
+		* The readiness-shaped view of one stored role, or null when it is unbound.
+		*
+		* The join between this module and `readiness`: storage keeps records, the
+		* gate takes {@link RoleBinding}s, and this is the only place that converts
+		* one into the other — so the modalities a role is checked against always come
+		* from {@link ROLE_MODALITIES} rather than from whatever a call site guessed.
+		*/
+		function bindingFor(bindings, role) {
+			const record = bindings.roles[role];
+			if (record === void 0) return null;
+			return {
+				role,
+				provider: record.provider,
+				model: record.model,
+				credentialRef: record.credentialRef,
+				modalities: ROLE_MODALITIES[role]
+			};
+		}
+		/**
+		* Patterns that must never appear in a stored binding.
+		*
+		* Not an exhaustive secret detector — there is no such thing — but a guard on
+		* the shapes a credential takes when somebody pastes one into a field meant to
+		* hold a reference.
+		*
+		* `OPENROUTER_API_KEY` is deliberately *not* one of them, and that distinction
+		* is the design rather than an omission: it is a reference — the name of a
+		* place the Host looks — and naming a place is exactly what `credentialRef` is
+		* for. A guard that refused it would refuse every legitimate binding, be
+		* switched off within a day, and stop catching what it was written for. What
+		* is refused is a *value*: the shapes a key has when the key itself is pasted.
+		*/
+		const SECRET_SHAPES = [
+			/\bsk-[A-Za-z0-9_-]{8,}/,
+			/\bsk_live_[A-Za-z0-9]{8,}/,
+			/\bBearer\s+[A-Za-z0-9._-]{8,}/i,
+			/(?=[A-Za-z0-9+/_-]{32,})(?=[^\n]*[a-z])(?=[^\n]*[A-Z])(?=[^\n]*\d)[A-Za-z0-9+/_-]{32,}/
+		];
+		/**
+		* Throw when a document about to be stored or shown carries secret material.
+		*
+		* A programming error rather than a runtime condition: every write path builds
+		* this document from a picker, so a value matching one of these means a code
+		* path has started copying a credential into a place that is read back in
+		* plain text. Failing loudly at the write is the only point where that is
+		* still cheap to fix.
+		*
+		* @param where - the surface being guarded, for a message that can be acted on.
+		* @param bindings - the document about to leave a trusted boundary.
+		*/
+		function assertNoSecretMaterial(where, bindings) {
+			for (const [role, record] of Object.entries(bindings.roles)) for (const [field, value] of Object.entries(record)) {
+				if (typeof value !== "string") continue;
+				for (const shape of SECRET_SHAPES) {
+					if (!shape.test(value)) continue;
+					throw new Error(`${where}: the ${role} binding's ${field} looks like credential material. A binding stores a reference the Host resolves, never a value.`);
+				}
+			}
+		}
+		//#endregion
+		//#region ../contracts/lib/failures.js
+		/**
+		* What a person is told when a conversation cannot run, and what they are not.
+		*
+		* A prompt failed and the Chat surface showed the reader
+		* `@deepseek-ai/dsh-system-prompt`, the route id `llm-deepseek`, the provider
+		* key `deepseek-official`, the environment variable `DEEPSEEK_API_KEY`, and a
+		* paragraph of sandbox-policy text. Every one of those is true, and not one of
+		* them told the reader what to do. Worse, two of them named a provider they had
+		* never chosen, so the message actively misled: it read as *DeepWatch is a
+		* DeepSeek product that is broken* rather than *nothing is bound yet*.
+		*
+		* This module draws the line. A raw provider or runtime failure is classified
+		* into one of a small closed set of {@link FailureKind}s, each of which becomes
+		* a card with a title, one sentence, and exactly one next action. The detailed
+		* technical facts are not destroyed — they go to Diagnostics and the Session
+		* Log, redacted — but they never render in an ordinary conversation.
+		*
+		* **Two rules hold everything here together.**
+		*
+		* The first is that a card carries no implementation identity.
+		* {@link assertNoInternalDisclosure} is the executable form of that rule, and
+		* it is applied to every card this module produces rather than trusted to
+		* review.
+		*
+		* The second is that nothing here ever carries credential material — and
+		* "material" includes the things people reach for when they are trying to be
+		* helpful about a key without printing it: a prefix, a suffix, a length, a
+		* fingerprint, a hash. A reader does not need to be told their key is 51
+		* characters long, and an attacker reading a shared screenshot does.
+		*
+		* @module @deepwatch/dsh-contracts/failures
+		*/
+		/** The card each kind renders as. */
+		const CARDS = {
+			not_configured: {
+				title: "Chat model is not configured",
+				detail: "Choose a provider and a model, then assign one to Chat. Nothing is sent until you do.",
+				action: "Choose models and roles",
+				target: "role-bindings"
+			},
+			not_tested: {
+				title: "Chat provider has not been tested",
+				detail: "The provider and model are assigned, but no provider request has succeeded yet.",
+				action: "Run provider test",
+				target: "role-bindings"
+			},
+			credential_unavailable: {
+				title: "Credential is unavailable",
+				detail: "A credential is assigned to this provider, and it could not be read on this machine.",
+				action: "Review the provider credential",
+				target: "provider-credential"
+			},
+			credential_rejected: {
+				title: "Provider rejected the credential",
+				detail: "The provider answered and would not accept the credential saved for it.",
+				action: "Update the provider credential",
+				target: "provider-credential"
+			},
+			model_unavailable: {
+				title: "Model is no longer available",
+				detail: "The provider no longer offers the model assigned to this capability.",
+				action: "Choose another model",
+				target: "model-selection"
+			},
+			provider_unreachable: {
+				title: "Provider is temporarily unreachable",
+				detail: "No usable answer came back from the provider. Nothing was charged and no turn was recorded.",
+				action: "Try again",
+				target: "retry"
+			},
+			rate_limited: {
+				title: "Request was rate-limited",
+				detail: "The provider declined this request for rate reasons. Waiting and retrying usually clears it.",
+				action: "Try again",
+				target: "retry"
+			},
+			policy_forbids: {
+				title: "This machine’s policy blocked the request",
+				detail: "A policy in force here does not permit this request. Diagnostics records which one.",
+				action: "Open Diagnostics",
+				target: "diagnostics"
+			},
+			unavailable: {
+				title: "The request could not be completed",
+				detail: "Something went wrong before a reply could be produced. Diagnostics has the detail.",
+				action: "Open Diagnostics",
+				target: "diagnostics"
+			}
+		};
+		/**
+		* The card for one kind.
+		*
+		* @param kind - the classified failure.
+		* @param hasDiagnostics - whether a redacted record was written for it.
+		* @returns a card safe to render in an ordinary conversation.
+		*/
+		function failureCard(kind, hasDiagnostics = true) {
+			return {
+				kind,
+				...CARDS[kind],
+				hasDiagnostics
+			};
+		}
+		/**
+		* The card a readiness blocker becomes.
+		*
+		* The two vocabularies are separate because they answer different questions —
+		* a blocker is "what is missing", a card is "what a person sees when they tried
+		* anyway" — and this is the one place they are joined, so a blocker can never
+		* reach a reader with no card defined for it.
+		*/
+		function cardForBlocker(blocker) {
+			return failureCard(blocker === "credential_inaccessible" ? "credential_unavailable" : blocker === "provider_untested" ? "not_tested" : blocker === "credential_rejected" ? "credential_rejected" : blocker === "provider_unreachable" ? "provider_unreachable" : blocker === "provider_rate_limited" ? "rate_limited" : blocker === "model_unavailable" || blocker === "model_invalid" ? "model_unavailable" : blocker === "policy_forbids" || blocker === "consent_required" ? "policy_forbids" : "not_configured");
+		}
+		//#endregion
+		//#region src/client/readiness.tsx
+		const READINESS_STATUS_LABEL = {
+			loading: "Loading…",
+			ready: "Ready",
+			degraded: "Degraded",
+			unconfigured: "Not configured",
+			unavailable: "Unavailable",
+			not_tested: "Not tested",
+			error: "Error"
+		};
+		const READINESS = [
+			{
+				name: "Watch Core",
+				detail: "The engine that mints evidence and issues verdicts. Runs as a child of this workspace.",
+				section: "watch-diagnostics"
+			},
+			{
+				name: "Memory",
+				detail: "Durable, correctable memory with provenance on every record.",
+				section: "watch-memory",
+				coreCapabilities: ["watch.memory.recall"]
+			},
+			{
+				name: "Verification",
+				detail: "Deterministic checks against the world. Needs no model.",
+				section: "watch-verification",
+				coreCapabilities: ["watch.verification.run"]
+			},
+			{
+				name: "Browser",
+				detail: "A supervised browser that acts and returns Core-owned evidence and a receipt.",
+				section: "watch-sources",
+				coreCapabilities: [
+					"watch.browser.observe",
+					"watch.browser.operate",
+					"watch.evidence.resolve"
+				]
+			},
+			{
+				name: "Agent Model",
+				role: "agent_model",
+				detail: "Plans, reasons and writes. Any provider DSH supports — DeepSeek is one of them.",
+				section: "watch-roles"
+			},
+			{
+				name: "Visual Perception",
+				role: "visual_perception",
+				detail: "Reads what is on screen or in a frame. A local model works.",
+				section: "watch-roles"
+			},
+			{
+				name: "OCR",
+				detail: "Text out of images and pages. A CPU engine is available.",
+				section: "watch-engines",
+				defaultStatus: "not_tested"
+			},
+			{
+				name: "ASR",
+				role: "asr",
+				detail: "Speech to text, with timings a citation can point at.",
+				section: "watch-roles"
+			},
+			{
+				name: "Audio Understanding",
+				role: "audio_understanding",
+				detail: "Non-speech audio: events, tone, music.",
+				section: "watch-roles"
+			},
+			{
+				name: "Speaker / Diarization",
+				detail: "Who spoke, and when.",
+				section: "watch-roles",
+				defaultStatus: "unconfigured"
+			},
+			{
+				name: "Embeddings / Retrieval",
+				role: "embeddings",
+				detail: "Search over the library and over memory. Falls back to lexical matching.",
+				section: "watch-roles"
+			},
+			{
+				name: "Capture",
+				detail: "Screen, window, camera and microphone. Permission is asked at first use.",
+				section: "watch-sources",
+				defaultStatus: "unconfigured"
+			}
+		];
+		function toneFor$1(status) {
+			if (status === "ready") return "active";
+			if (status === "degraded" || status === "unavailable" || status === "error") return "caution";
+			return "neutral";
+		}
+		function coreStatus(health, reading) {
+			if (reading) return "loading";
+			if (health === null || health === void 0) return "error";
+			if (health.isTestOnlyMock) return "degraded";
+			if (health.blocker === "connected") return health.phase === "ready" ? "ready" : "degraded";
+			if (health.blocker === "core_missing" || health.blocker === "bridge_surface_missing") return "unavailable";
+			return health.phase === "degraded" ? "degraded" : "error";
+		}
+		/**
+		* Core's evidence level, said in the vocabulary a surface may use.
+		*
+		* The interesting line is `probed`. Core separates three facts on purpose:
+		* the code exists, its dependencies were found (`probed`), and a real request
+		* ran here and succeeded (`machine_tested`). Only the third is *ready*.
+		*
+		* `probed` was drawn as **Degraded** for one release, and that was a false
+		* alarm in the opposite direction to the green dot: a machine with Chromium
+		* installed and a healthy memory index reported two capabilities as impaired
+		* when nothing was wrong with either — they simply had not been exercised.
+		* Degraded means working and hurt. Ignorance is `not_tested`, which is a
+		* neutral word and the accurate one.
+		*/
+		function capabilityStatus(detail) {
+			if (detail === void 0) return "not_tested";
+			if (!detail.usable) return detail.status === "unavailable" ? "unavailable" : "degraded";
+			if (detail.status === "machine_tested") return "ready";
+			if (detail.status === "unavailable") return "unavailable";
+			return "not_tested";
+		}
+		const STATUS_PRIORITY = {
+			error: 7,
+			unavailable: 6,
+			degraded: 5,
+			loading: 4,
+			not_tested: 3,
+			unconfigured: 2,
+			ready: 1
+		};
+		/** Of two states, the one that promises less. */
+		function worse(left, right) {
+			return STATUS_PRIORITY[right] > STATUS_PRIORITY[left] ? right : left;
+		}
+		/** Derive every row from runtime facts. Used by both first-run and Diagnostics. */
+		function deriveReadiness(facts) {
+			const reading = facts.reading === true;
+			const health = facts.health;
+			const details = new Map((health?.capabilityDetails ?? []).map((item) => [item.capabilityId, item]));
+			const roles = new Map((facts.roles ?? []).map((row) => [row.role, row]));
+			const core = coreStatus(health, reading);
+			return READINESS.map((definition, index) => {
+				let status;
+				let detail = definition.detail;
+				let statusLabel;
+				if (index === 0) {
+					status = core;
+					if (health !== null && health !== void 0 && health.blocker !== "connected" && health.fix !== "") detail = health.fix;
+				} else if (definition.coreCapabilities !== void 0) {
+					status = definition.coreCapabilities.map((id) => capabilityStatus(details.get(id))).reduce(worse, core);
+					const problem = definition.coreCapabilities.map((id) => details.get(id)).find((item) => item !== void 0 && (!item.usable || item.status !== "machine_tested"));
+					if (problem !== void 0) detail = problem.fixes[0] ?? (problem.missing.length === 0 ? definition.detail : `Missing: ${problem.missing.join(", ")}.`);
+					else if (status !== "ready" && health !== null && health !== void 0 && health.fix !== "") detail = health.fix;
+				} else if (definition.role !== void 0) {
+					const role = roles.get(definition.role);
+					if (role === void 0) status = "unconfigured";
+					else if (isExecutable(role.readiness)) status = "ready";
+					else if (role.readiness.status === "bound_unverified") status = "not_tested";
+					else if (role.readiness.status === "unbound") status = "unconfigured";
+					else status = "error";
+					if (role !== void 0) {
+						statusLabel = BINDING_STATUS_LABEL[role.readiness.status];
+						if (!isExecutable(role.readiness)) detail = blockerMessage(role.readiness) ?? detail;
+					}
+				} else status = definition.defaultStatus ?? "not_tested";
+				return {
+					...definition,
+					detail,
+					status,
+					statusLabel: statusLabel ?? READINESS_STATUS_LABEL[status],
+					tone: toneFor$1(status)
+				};
+			});
+		}
+		function ReadinessList({ openSection, roles, health, reading }) {
+			const rows = deriveReadiness({
+				roles,
+				health,
+				reading
+			});
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+				style: {
+					border: "1px solid color-mix(in srgb, var(--watch-accent) 10%, var(--dsw-alias-border-l2))",
+					borderRadius: "14px",
+					overflow: "hidden",
+					background: "linear-gradient(145deg, color-mix(in srgb, var(--watch-accent) 3%, var(--dsw-alias-bg-layer-2)), var(--dsw-alias-bg-base))",
+					boxShadow: "0 10px 28px color-mix(in srgb, black 8%, transparent)"
+				},
+				children: rows.map((item, index) => /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+					style: {
+						display: "flex",
+						alignItems: "flex-start",
+						gap: "12px",
+						padding: "12px 16px",
+						borderTop: index === 0 ? "none" : "1px solid var(--dsw-alias-border-l2)"
+					},
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						style: {
+							flex: 1,
+							minWidth: 0
+						},
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+							style: {
+								fontSize: "13px",
+								fontWeight: 500
+							},
+							children: item.role === void 0 ? item.name : ROLE_LABEL[item.role]
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+							style: {
+								fontSize: "12px",
+								lineHeight: 1.5,
+								marginTop: "2px",
+								color: "var(--dsw-alias-label-tertiary)"
+							},
+							children: item.detail
+						})]
+					}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+						style: {
+							display: "flex",
+							gap: "8px",
+							alignItems: "center",
+							flexShrink: 0
+						},
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+							tone: item.tone,
+							children: item.statusLabel
+						}), item.section === void 0 || openSection === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+							type: "button",
+							onClick: () => {
+								openSection(item.section);
+							},
+							style: {
+								background: "none",
+								border: "none",
+								cursor: "pointer",
+								fontSize: "11px",
+								padding: "2px 4px",
+								color: "var(--dsw-alias-label-secondary)",
+								textDecoration: "underline"
+							},
+							children: "Configure"
+						})]
+					})]
+				}, item.name))
+			});
+		}
+		//#endregion
+		//#region src/ocr-measured.ts
+		/** The engine that was run, and where. */
+		const OCR_ENGINE = "rapidocr";
+		/** Per workload, because qualification is per workload and not an average. */
+		const OCR_BY_WORKLOAD = [
+			{
+				"workload": "dark_mode",
+				"samples": 1,
+				"cer": 0,
+				"wordAccuracy": 1,
+				"hallucination": 0,
+				"passes": true
+			},
+			{
+				"workload": "document",
+				"samples": 1,
+				"cer": 0,
+				"wordAccuracy": 1,
+				"hallucination": 0,
+				"passes": true
+			},
+			{
+				"workload": "low_resolution",
+				"samples": 4,
+				"cer": .6111,
+				"wordAccuracy": .25,
+				"hallucination": .25,
+				"passes": false
+			},
+			{
+				"workload": "mixed_script",
+				"samples": 2,
+				"cer": .75,
+				"wordAccuracy": .25,
+				"hallucination": 0,
+				"passes": false
+			},
+			{
+				"workload": "ui_text",
+				"samples": 8,
+				"cer": .0074,
+				"wordAccuracy": .9792,
+				"hallucination": 0,
+				"passes": true
+			},
+			{
+				"workload": "video_overlay",
+				"samples": 1,
+				"cer": 0,
+				"wordAccuracy": 1,
+				"hallucination": 0,
+				"passes": true
+			}
+		];
+		//#endregion
+		//#region src/client/components.tsx
+		/**
+		* The panel vocabulary every surface here shares.
+		*
+		* Exported because Role Bindings moved into its own file once it stopped being
+		* static copy, and two settings screens with independently-invented padding is
+		* how a panel starts looking like two products.
+		*/
+		const T = {
+			page: {
+				padding: "6px 4px 30px",
+				maxWidth: "880px",
+				background: "radial-gradient(circle at 0 0, color-mix(in srgb, var(--watch-accent) 5%, transparent), transparent 34%)"
+			},
+			lead: {
+				fontSize: "13.5px",
+				lineHeight: 1.65,
+				color: "var(--dsw-alias-label-secondary)",
+				margin: "0 0 20px",
+				maxWidth: "72ch"
+			},
+			card: {
+				border: "1px solid color-mix(in srgb, var(--watch-accent) 9%, var(--dsw-alias-border-l2))",
+				borderRadius: "14px",
+				padding: "16px 18px",
+				marginBottom: "12px",
+				background: "linear-gradient(145deg, color-mix(in srgb, var(--watch-accent) 3%, var(--dsw-alias-bg-layer-2)), var(--dsw-alias-bg-base))",
+				boxShadow: "0 10px 28px color-mix(in srgb, black 8%, transparent)"
+			},
+			cardHead: {
+				display: "flex",
+				alignItems: "baseline",
+				gap: "10px",
+				justifyContent: "space-between",
+				flexWrap: "wrap"
+			},
+			title: {
+				fontSize: "14px",
+				fontWeight: 620,
+				margin: 0,
+				letterSpacing: "-0.01em"
+			},
+			meta: {
+				display: "grid",
+				gridTemplateColumns: "max-content 1fr",
+				columnGap: "14px",
+				rowGap: "4px",
+				fontSize: "12px",
+				marginTop: "10px"
+			},
+			key: { color: "var(--dsw-alias-label-tertiary)" },
+			value: { color: "var(--dsw-alias-label-secondary)" },
+			note: {
+				fontSize: "12px",
+				lineHeight: 1.55,
+				color: "var(--dsw-alias-label-tertiary)",
+				borderInlineStart: "2px solid var(--watch-accent)",
+				paddingInlineStart: "10px",
+				margin: "14px 0 0"
+			},
+			h2: {
+				fontSize: "11px",
+				fontWeight: 700,
+				letterSpacing: "0.11em",
+				textTransform: "uppercase",
+				color: "var(--watch-accent)",
+				margin: "24px 0 9px"
+			}
+		};
+		/**
+		* A status chip.
+		*
+		* The tone vocabulary is the brand's, and `success` is deliberately absent:
+		* nothing in a settings page is a verification verdict, so nothing here is
+		* allowed to be green. A capability that is genuinely working reads as
+		* `active`, which is a different colour and a different claim.
+		*/
+		function StatusChip({ tone, children }) {
+			const colour = tokenFor(tone);
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+				style: {
+					display: "inline-flex",
+					alignItems: "center",
+					gap: "5px",
+					fontSize: "11px",
+					lineHeight: 1.4,
+					padding: "2px 8px",
+					borderRadius: "999px",
+					whiteSpace: "nowrap",
+					border: `1px solid color-mix(in srgb, ${colour} 60%, transparent)`,
+					color: colour,
+					background: `color-mix(in srgb, ${colour} 8%, transparent)`
+				},
+				children
+			});
+		}
+		/** A local/remote label, because where the data goes is a product fact. */
+		function Where({ local }) {
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+				tone: local ? "active" : "info",
+				children: local ? "Local" : "Remote"
+			});
+		}
+		function Row({ label, children }) {
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+				style: T.key,
+				children: label
+			}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+				style: T.value,
+				children
+			})] });
+		}
+		/**
+		* The empty state every surface here needs.
+		*
+		* A capability that is not configured must still render something a person can
+		* act on. A dead control that fails when clicked teaches people the product is
+		* broken; a sentence explaining what is missing and what would fix it does not.
+		*/
+		function NotConfigured({ what, why, fix }) {
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				style: {
+					...T.card,
+					borderStyle: "dashed"
+				},
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						style: T.cardHead,
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", {
+							style: T.title,
+							children: what
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+							tone: "neutral",
+							children: "Not configured"
+						})]
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						style: {
+							...T.lead,
+							margin: "8px 0 0"
+						},
+						children: why
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						style: {
+							...T.note,
+							marginTop: "10px"
+						},
+						children: fix
+					})
+				]
+			});
+		}
+		/**
+		* Lifecycle words a person can act on, and the tone each earns.
+		*
+		* `not_tested` is the state every engine is in on a machine where no capability
+		* check has run, and it is what `untestedHealth` returns. It is deliberately
+		* not styled as an error: nothing is broken, nobody has looked.
+		*/
+		function lifecycleChip(state) {
+			const entry = {
+				machine_tested: {
+					tone: "active",
+					text: "Machine tested"
+				},
+				ready: {
+					tone: "active",
+					text: "Ready"
+				},
+				probed: {
+					tone: "caution",
+					text: "Probed, not measured"
+				},
+				installed: {
+					tone: "caution",
+					text: "Installed, not tested"
+				},
+				discovered: {
+					tone: "neutral",
+					text: "Not tested"
+				},
+				not_tested: {
+					tone: "neutral",
+					text: "Not tested"
+				},
+				not_installed: {
+					tone: "neutral",
+					text: "Not installed"
+				},
+				installing: {
+					tone: "caution",
+					text: "Installing"
+				},
+				degraded: {
+					tone: "error",
+					text: "Degraded"
+				},
+				unavailable: {
+					tone: "error",
+					text: "Unavailable"
+				},
+				incompatible: {
+					tone: "error",
+					text: "Incompatible"
+				},
+				disabled: {
+					tone: "neutral",
+					text: "Disabled"
+				}
+			}[state] ?? {
+				tone: "neutral",
+				text: state
+			};
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+				tone: entry.tone,
+				children: entry.text
+			});
+		}
+		function gigabytes(bytes) {
+			if (bytes === null) return "unknown";
+			return `${(bytes / 1e9).toFixed(1)} GB`;
+		}
+		/**
+		* Perception Engines.
+		*
+		* An Engine Runtime is not a Provider Connection, and the distinction is the
+		* whole point of the screen: a provider is a credential and an endpoint, an
+		* engine is software that runs here. Presence on disk is not readiness, so the
+		* lifecycle state is shown verbatim rather than collapsed into a tick.
+		*
+		* No engine shows a quality or speed number. On a machine where nothing has
+		* been measured, every such number would be invented.
+		*/
+		function EnginesSection() {
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				style: T.page,
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						style: T.lead,
+						children: "An engine runs on this machine; a provider is something you connect to. Presence on disk is not readiness, so each engine shows the furthest state actually reached. Nothing here shows an accuracy or speed figure: none has been measured on this hardware, and a figure that was not measured would be fiction."
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h2", {
+						style: T.h2,
+						children: "OCR and layout"
+					}),
+					OCR_ENGINES.map((engine) => /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						style: T.card,
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							style: T.cardHead,
+							children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", {
+								style: T.title,
+								children: engine.displayName
+							}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+								style: {
+									display: "flex",
+									gap: "6px"
+								},
+								children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Where, { local: engine.runtime !== "remote" }), lifecycleChip("not_tested")]
+							})]
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							style: T.meta,
+							children: [
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "Version",
+									children: engine.version
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "Runtime",
+									children: engine.runtime
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "Hardware",
+									children: engine.hardware.gpu === "required" ? `GPU required${engine.hardware.minVramGb === null ? "" : `, ${String(engine.hardware.minVramGb)} GB VRAM`}` : engine.hardware.gpu === "optional" ? "GPU optional" : "CPU only"
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "Egress",
+									children: engine.privacy.egress === "none" ? "Nothing leaves this machine" : engine.privacy.egress === "metadata_only" ? "Metadata only" : "Sends content off this machine"
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "Offline",
+									children: engine.privacy.worksOffline ? "Works offline" : "Requires network"
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsxs)(Row, {
+									label: "Install",
+									children: [engine.install.method === "bundled" ? "Bundled" : engine.install.method, engine.install.downloadBytes === null ? "" : ` · ${gigabytes(engine.install.downloadBytes)} download`]
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "Quality",
+									children: engine.id.includes("rapidocr") ? "Measured on this machine — see the table below." : "Not measured on this machine"
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "How it would be checked",
+									children: engine.testMethod ?? engine.probeMethod ?? "No check is defined for this engine"
+								})
+							]
+						})]
+					}, engine.id)),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h2", {
+						style: T.h2,
+						children: `Measured accuracy — ${OCR_ENGINE} on cpu`
+					}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						style: T.card,
+						children: [
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+								style: {
+									...T.lead,
+									margin: "0 0 10px"
+								},
+								children: "A real run over a versioned ground-truth corpus, scored against thresholds committed before the benchmark existed. Reported per workload rather than as one average: an engine can be entirely fit for reading a settings panel and entirely unfit for reading grey-on-grey, and a single number hides both."
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+								style: T.meta,
+								children: OCR_BY_WORKLOAD.map((row) => /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(Row, {
+									label: row.workload,
+									children: [
+										/* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+											tone: row.passes ? "active" : "error",
+											children: row.passes ? "Qualified" : "Not qualified"
+										}),
+										` CER ${String(row.cer)} · word accuracy ${String(row.wordAccuracy)} `,
+										`· invented words ${String(row.hallucination)} · ${String(row.samples)} sample(s)`
+									]
+								}, row.workload))
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+								style: T.note,
+								children: "Accuracy is not a GPU question and is measured here. GPU throughput is not, because there is no GPU on this machine — that remains externally unvalidated."
+							})
+						]
+					})] }),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						style: T.note,
+						children: "An install is never automatic. Where a download is required, its size, hardware requirement and licence are shown before anything is fetched — multi-gigabyte weights are not something a product should acquire because a page was opened."
+					})
+				]
+			});
+		}
+		const SOURCES = [
+			{
+				id: "files",
+				name: "Files",
+				purpose: "Documents and recordings you open.",
+				local: true,
+				permission: "Granted per file, when you pick one"
+			},
+			{
+				id: "video",
+				name: "Video",
+				purpose: "Recorded footage, indexed so a citation can point at a moment.",
+				local: true,
+				permission: "Granted per file"
+			},
+			{
+				id: "browser",
+				name: "Browser",
+				purpose: "A supervised browser that acts and reports a receipt.",
+				local: true,
+				permission: "No OS permission needed"
+			},
+			{
+				id: "screen",
+				name: "Screen",
+				purpose: "The whole display.",
+				local: true,
+				permission: "Requested at first use"
+			},
+			{
+				id: "window",
+				name: "Window",
+				purpose: "One application window.",
+				local: true,
+				permission: "Requested at first use"
+			},
+			{
+				id: "camera",
+				name: "Camera",
+				purpose: "Live visual input.",
+				local: true,
+				permission: "Requested at first use"
+			},
+			{
+				id: "microphone",
+				name: "Microphone",
+				purpose: "Live audio input.",
+				local: true,
+				permission: "Requested at first use"
+			},
+			{
+				id: "live",
+				name: "Live session",
+				purpose: "A continuous session over one or more of the above.",
+				local: true,
+				permission: "Inherits its sources"
+			}
+		];
+		/**
+		* Sources & Devices.
+		*
+		* Nothing here asks the operating system for anything. A permission prompt on
+		* page load trains people to click Allow without reading, so a permission is
+		* requested when a capability is first used and not before — which is also why
+		* every row says when it would ask.
+		*/
+		function SourcesSection() {
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				style: T.page,
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+					style: T.lead,
+					children: "Opening this page requests nothing. A permission is asked for when a capability is first used, because a prompt on load teaches people to allow without reading. Every source below is local: what it captures stays on this machine unless a separate media-upload consent is given."
+				}), SOURCES.map((source) => /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+					style: T.card,
+					children: [
+						/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							style: T.cardHead,
+							children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", {
+								style: T.title,
+								children: source.name
+							}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+								style: {
+									display: "flex",
+									gap: "6px"
+								},
+								children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Where, { local: source.local }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+									tone: "neutral",
+									children: "Not requested"
+								})]
+							})]
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+							style: {
+								...T.lead,
+								margin: "6px 0 0"
+							},
+							children: source.purpose
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+							style: T.meta,
+							children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+								label: "Permission",
+								children: source.permission
+							})
+						})
+					]
+				}, source.id))]
+			});
+		}
+		const MEMORY_MODES = [
+			{
+				id: "off",
+				name: "Off",
+				detail: "Nothing is written and nothing is recalled."
+			},
+			{
+				id: "session_only",
+				name: "Session only",
+				detail: "Kept for this session and never reaches a later one."
+			},
+			{
+				id: "local_personal",
+				name: "Local Personal",
+				detail: "A ledger on this machine, for this profile."
+			},
+			{
+				id: "workspace_shared",
+				name: "Workspace Shared",
+				detail: "Knowledge and decisions are shared; personal taste is not."
+			}
+		];
+		/**
+		* Memory & Retrieval.
+		*
+		* The encryption row is the one that matters. The ledger is a plain file with
+		* the profile's permissions, and saying so is the difference between a product
+		* a person can calibrate their trust against and one that misleads them about
+		* where their data sits.
+		*/
+		function MemorySection() {
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				style: T.page,
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						style: T.lead,
+						children: "Memory is a product capability, not a plugin. The ledger is the authority and every projection — taste, index, log — is rebuilt from it, which is what makes Forget remove a record rather than hide it."
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h2", {
+						style: T.h2,
+						children: "Mode"
+					}),
+					MEMORY_MODES.map((mode) => /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						style: T.card,
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							style: T.cardHead,
+							children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", {
+								style: T.title,
+								children: mode.name
+							}), mode.id === "local_personal" ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+								tone: "active",
+								children: "Selected in this profile"
+							}) : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+								tone: "neutral",
+								children: "Available"
+							})]
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+							style: {
+								...T.lead,
+								margin: "6px 0 0"
+							},
+							children: mode.detail
+						})]
+					}, mode.id)),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h2", {
+						style: T.h2,
+						children: "Storage"
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						style: T.card,
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							style: T.meta,
+							children: [
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "Ledger",
+									children: "An append-only event log on this machine"
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "Projections",
+									children: "Rebuilt from the ledger, never edited in place"
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "Embeddings",
+									children: "Unbound — see Role Bindings. Retrieval falls back to lexical matching."
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "Retention",
+									children: "Kept until forgotten. Forget writes a tombstone."
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "Encryption at rest",
+									children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+										tone: "caution",
+										children: "Not encrypted"
+									})
+								})
+							]
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+							style: T.note,
+							children: "The ledger is a plain file. It is created owner-only — no group, no others — on systems that enforce file permissions; Windows has no equivalent and the file inherits the folder it sits in. On Desktop it is intended to move behind the OS keychain; until that is implemented and tested, this page will keep saying it is not encrypted. Claiming otherwise would be the one thing a privacy setting must never do."
+						})]
+					})
+				]
+			});
+		}
+		/**
+		* Verification.
+		*
+		* The screen leads with the distinction the whole product rests on, because
+		* this is where somebody configures how much proof they want and needs to know
+		* what a verdict does and does not mean.
+		*/
+		function VerificationSection() {
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				style: T.page,
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						style: {
+							...T.card,
+							borderColor: "var(--watch-accent)"
+						},
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", {
+							style: T.title,
+							children: "Agent completed ≠ Verified"
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+							style: {
+								...T.lead,
+								margin: "8px 0 0"
+							},
+							children: "A tool returning without an error means the call finished. It does not mean the thing happened. Only a verification against the world produces a verdict, and only Watch Core produces one — no plugin, no client and no model can mint a verdict, by construction rather than by convention."
+						})]
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h2", {
+						style: T.h2,
+						children: "Verifier"
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						style: T.card,
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							style: T.cardHead,
+							children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", {
+								style: T.title,
+								children: "Deterministic checks"
+							}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+								style: {
+									display: "flex",
+									gap: "6px"
+								},
+								children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Where, { local: true }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+									tone: "active",
+									children: "Available"
+								})]
+							})]
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+							style: {
+								...T.lead,
+								margin: "6px 0 0"
+							},
+							children: "Reads a row, an HTTP status, a file, an exit code. Needs no model, so it works offline and its result does not depend on a provider."
+						})]
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						style: T.card,
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							style: T.cardHead,
+							children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", {
+								style: T.title,
+								children: "Model-assisted checks"
+							}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+								tone: "neutral",
+								children: "Verifier role not bound"
+							})]
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+							style: {
+								...T.lead,
+								margin: "6px 0 0"
+							},
+							children: "For expectations a deterministic check cannot express. Bind the Verifier role to enable them; until then, expectations that need one return INCONCLUSIVE rather than a guess."
+						})]
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h2", {
+						style: T.h2,
+						children: "Verdicts"
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						style: T.card,
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							style: T.meta,
+							children: [
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "VERIFIED",
+									children: "Checked against the world, and it held."
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "FAILED",
+									children: "Checked, and it did not hold."
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "UNVERIFIED",
+									children: "Not checked. Not a failure — an absence."
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "INCONCLUSIVE",
+									children: "Checked, and the evidence did not settle it."
+								})
+							]
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+							style: T.note,
+							children: "Green is reserved for VERIFIED and nothing else reaches it — not a high confidence, not a completed turn, not five checks out of six."
+						})]
+					})
+				]
+			});
+		}
+		/**
+		* What the engine is doing, in one chip.
+		*
+		* `connected` is the only state that gets the active tone. Everything else —
+		* including the mock backend, which is *working* and is still not the product
+		* — reads as a problem, because on this screen it is one.
+		*/
+		function CoreStateChip({ health, reading }) {
+			if (health === null || health === void 0) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+				tone: "neutral",
+				children: reading ? "Reading…" : "Could not be read"
+			});
+			if (health.blocker === "connected") return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+				tone: "active",
+				children: "Connected"
+			});
+			if (health.isTestOnlyMock) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+				tone: "caution",
+				children: "Test-only mock"
+			});
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+				tone: "caution",
+				children: health.phase
+			});
+		}
+		/**
+		* Diagnostics. What is actually running, and what is not.
+		*
+		* The capability readiness list lives here rather than in the first-run notice.
+		* It needs the settings panel's width; the onboarding seat is 256 pixels wide,
+		* and putting this there once already spilled two thousand pixels out of a
+		* clipped sidebar column.
+		*/
+		function DiagnosticsSection({ openSection, roles, health, reading, onRefresh } = {}) {
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				style: T.page,
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						style: T.lead,
+						children: "What this installation actually consists of. Where a value cannot be read from the running system it says so, rather than showing a plausible default."
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h2", {
+						style: T.h2,
+						children: "Capability readiness"
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)(ReadinessList, {
+						openSection,
+						roles,
+						health,
+						reading
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h2", {
+						style: T.h2,
+						children: "Versions"
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+						style: T.card,
+						children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							style: T.meta,
+							children: [
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "DeepWatch",
+									children: "0.1.0"
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "DeepSeek Harness",
+									children: "0.1.1-rc.2"
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "Watch Core",
+									children: health === null || health === void 0 || health.coreVersion === null ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+										tone: "neutral",
+										children: "Not reported"
+									}) : health.coreVersion
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "Bridge protocol",
+									children: health === null || health === void 0 || health.protocolVersion === null ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+										tone: "neutral",
+										children: "Not reported"
+									}) : `${String(health.protocolVersion)} (Core supports ${health.protocolMin === null ? "?" : String(health.protocolMin)}-${health.protocolVersion === null ? "?" : String(health.protocolVersion)})`
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "Memory store schema",
+									children: "1"
+								})
+							]
+						})
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h2", {
+						style: T.h2,
+						children: "Health"
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						style: T.card,
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							style: T.meta,
+							children: [
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "Watch Core",
+									children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+										style: {
+											display: "inline-flex",
+											alignItems: "center",
+											gap: "8px"
+										},
+										children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(CoreStateChip, {
+											health,
+											reading: reading === true
+										}), onRefresh === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+											type: "button",
+											onClick: onRefresh,
+											disabled: reading === true,
+											style: {
+												background: "none",
+												border: "none",
+												padding: 0,
+												font: "inherit",
+												fontSize: "12px",
+												cursor: "pointer",
+												color: tokenFor("info"),
+												textDecoration: "underline"
+											},
+											children: "Re-read"
+										})]
+									})
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "Bridge transport",
+									children: health === null || health === void 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+										tone: "neutral",
+										children: "Not reported"
+									}) : health.isTestOnlyMock ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+										tone: "caution",
+										children: "Test-only mock backend"
+									}) : health.transport === null ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+										tone: "neutral",
+										children: "Not reported"
+									}) : health.transport
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "Contract",
+									children: health === null || health === void 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+										tone: "neutral",
+										children: "Not reported"
+									}) : health.contractsMatch ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+										tone: "active",
+										children: "Matches this build"
+									}) : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+										tone: "caution",
+										children: health.contractDrift.length === 0 ? "Unverified" : `Drifted: ${health.contractDrift.join(", ")}`
+									})
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "Capabilities",
+									children: health === null || health === void 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+										tone: "neutral",
+										children: "Not reported"
+									}) : `${String(health.capabilities.ready)} ready · ${String(health.capabilities.degraded)} degraded · ${String(health.capabilities.unavailable)} unavailable · ${String(health.capabilities.unknown)} unknown`
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "Last handshake",
+									children: health === null || health === void 0 || health.lastHandshakeAt === null ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+										tone: "neutral",
+										children: "Never"
+									}) : health.lastHandshakeAt
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "Engine starts",
+									children: health === null || health === void 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+										tone: "neutral",
+										children: "Not reported"
+									}) : String(health.restartCount)
+								}),
+								health !== null && health !== void 0 && health.blocker !== "connected" ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "Blocker",
+									children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+										tone: "caution",
+										children: health.blocker
+									}), health.fix === "" ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+										style: T.note,
+										children: [" ", health.fix]
+									})] })
+								}) : null,
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "Offline",
+									children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+										tone: "active",
+										children: "Offline only"
+									})
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "Media upload consent",
+									children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+										tone: "neutral",
+										children: "Not given"
+									})
+								})
+							]
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+							style: T.note,
+							children: "Offline-only and media-upload consent are two separate settings on purpose. Holding a provider credential is not permission to upload a frame, a transcript or a screen capture, and no agent can change either from inside a session."
+						})]
+					})
+				]
+			});
+		}
+		/**
+		* About.
+		*
+		* This is where the foundation becomes explicit. Watch is the product and
+		* DeepSeek Harness is what it is built on; both statements belong on the same
+		* screen, and the independence disclosure belongs beside them so the
+		* attribution cannot be read as an endorsement.
+		*/
+		function AboutSection() {
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				style: T.page,
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						style: {
+							display: "flex",
+							alignItems: "center",
+							gap: "14px",
+							marginBottom: "4px"
+						},
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("img", {
+							src: WATCH_MARK_PNG,
+							width: 44,
+							height: 44,
+							alt: "",
+							"aria-hidden": "true",
+							style: {
+								width: "44px",
+								height: "44px",
+								objectFit: "contain",
+								flexShrink: 0
+							}
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", {
+							style: {
+								...T.title,
+								fontSize: "19px"
+							},
+							children: PRODUCT_NAME
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+							style: {
+								...T.lead,
+								margin: "2px 0 0"
+							},
+							children: "An agent that sees, remembers, and can prove what actually happened."
+						})] })]
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+						style: T.card,
+						children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							style: T.meta,
+							children: [
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "DeepWatch",
+									children: "0.1.0"
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "Watch Core",
+									children: "Reported by the Bridge, not read from here"
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "Built on",
+									children: "DeepSeek Harness 0.1.1-rc.2"
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "DSH commit",
+									children: "b150a551b8d465e31e418e1b2eaf5e79bbb7d28e"
+								})
+							]
+						})
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						style: {
+							...T.card,
+							borderColor: "var(--watch-accent)"
+						},
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+							style: {
+								margin: 0,
+								fontSize: "13px",
+								lineHeight: 1.6
+							},
+							children: ATTRIBUTION
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+							style: {
+								margin: "8px 0 0",
+								fontSize: "13px",
+								lineHeight: 1.6,
+								color: "var(--dsw-alias-label-secondary)"
+							},
+							children: INDEPENDENCE
+						})]
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h2", {
+						style: T.h2,
+						children: "Licences"
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+						style: T.card,
+						children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							style: T.meta,
+							children: [
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "DeepWatch",
+									children: "MIT"
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "DeepSeek Harness",
+									children: "MIT, and its notice is carried unmodified"
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "Third-party notices",
+									children: "THIRD_PARTY_NOTICES.md, shipped with this distribution"
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Row, {
+									label: "Model weights",
+									children: "Distributed with none. A code licence is not a weights licence."
+								})
+							]
+						})
+					})
+				]
+			});
+		}
+		//#endregion
+		//#region \0watch-css-module:packages/watch/client-settings/src/client/onboarding.module.css.mjs
+		const css = ".kGnD4q_dialog{max-height:min(760px,100vh - 40px);border-color:color-mix(in srgb, var(--watch-accent,#4c8dff) 22%, var(--dsw-alias-border-inverted))!important;background:radial-gradient(circle at 8% 0%, color-mix(in srgb, var(--watch-accent,#4c8dff) 11%, transparent), transparent 38%), var(--dsw-alias-bg-layer-2)!important;width:min(720px,100vw - 40px)!important;padding:0!important}.kGnD4q_card{flex-direction:column;min-width:0;display:flex;overflow:auto}.kGnD4q_hero{border-bottom:1px solid var(--dsw-alias-separator);grid-template-columns:minmax(0,1.08fr) minmax(240px,.92fr);align-items:center;gap:34px;padding:34px 36px 28px;display:grid}.kGnD4q_identity{align-items:center;gap:18px;min-width:0;display:flex}.kGnD4q_markFrame{border:1px solid color-mix(in srgb, var(--watch-accent,#4c8dff) 35%, transparent);background:color-mix(in srgb, var(--watch-accent,#4c8dff) 12%, transparent);border-radius:22px;flex:0 0 4.875rem;place-items:center;width:4.875rem;height:4.875rem;display:grid;box-shadow:inset 0 1px #ffffff14}.kGnD4q_mark{object-fit:contain;width:3.625rem;height:3.625rem;display:block}.kGnD4q_titleBlock{min-width:0}.kGnD4q_eyebrow{color:var(--watch-accent,#4c8dff);letter-spacing:.14em;font-size:11px;font-weight:700}.kGnD4q_title{color:var(--dsw-alias-label-primary);letter-spacing:-.035em;margin:5px 0 7px;font-size:clamp(24px,3.2vw,32px);font-weight:650;line-height:1.08}.kGnD4q_tagline{color:var(--dsw-alias-label-secondary);margin:0;font-size:13px;line-height:1.55}.kGnD4q_lead{max-width:34ch;color:var(--dsw-alias-label-secondary);margin:0;font-size:14px;line-height:1.65}.kGnD4q_statusSection{padding:25px 36px 22px}.kGnD4q_statusHeading{justify-content:space-between;align-items:center;gap:16px;margin-bottom:12px;display:flex}.kGnD4q_liveLabel{color:var(--dsw-alias-label-tertiary);align-items:center;gap:7px;font-size:12px;display:inline-flex}.kGnD4q_liveDot{background:var(--watch-tone-success,#22c55e);width:.4375rem;height:.4375rem;box-shadow:0 0 0 3px color-mix(in srgb, var(--watch-tone-success,#22c55e) 14%, transparent);border-radius:999px}.kGnD4q_checkingDot{background:var(--watch-tone-caution,#d99026);box-shadow:0 0 0 3px color-mix(in srgb, var(--watch-tone-caution,#d99026) 14%, transparent)}.kGnD4q_statusGrid{grid-template-columns:1fr 1fr;gap:12px;display:grid}.kGnD4q_metricCard{border:1px solid var(--dsw-alias-separator);background:color-mix(in srgb, var(--dsw-alias-bg-layer-2) 86%, white 2%);border-radius:14px;min-width:0;padding:16px 17px}.kGnD4q_readyCard{border-color:color-mix(in srgb, var(--watch-accent,#4c8dff) 35%, var(--dsw-alias-separator));background:color-mix(in srgb, var(--watch-accent,#4c8dff) 7%, var(--dsw-alias-bg-layer-2))}.kGnD4q_metricTop{justify-content:space-between;align-items:center;gap:12px;display:flex}.kGnD4q_metricLabel{color:var(--dsw-alias-label-primary);align-items:center;gap:7px;font-size:13px;font-weight:600;display:inline-flex}.kGnD4q_readyCard .kGnD4q_metricLabel,.kGnD4q_readyCard .kGnD4q_metricValue{color:var(--watch-accent,#4c8dff)}.kGnD4q_metricValue{color:var(--dsw-alias-label-primary);letter-spacing:-.04em;font-size:25px;font-weight:650;line-height:1}.kGnD4q_metricCopy{color:var(--dsw-alias-label-secondary);margin:11px 0 0;font-size:12.5px;line-height:1.5}.kGnD4q_consent{background:color-mix(in srgb, var(--dsw-alias-bg-layer-1) 72%, transparent);border-radius:12px;align-items:flex-start;gap:11px;margin:0 36px;padding:13px 15px;display:flex}.kGnD4q_consentIcon{background:color-mix(in srgb, var(--watch-tone-success,#22c55e) 15%, transparent);width:1.4375rem;height:1.4375rem;color:var(--watch-tone-success,#22c55e);border-radius:999px;flex:0 0 1.4375rem;justify-content:center;align-items:center;display:inline-flex}.kGnD4q_consent strong{color:var(--dsw-alias-label-primary);font-size:12.5px;font-weight:600}.kGnD4q_consent p{color:var(--dsw-alias-label-tertiary);margin:3px 0 0;font-size:12px;line-height:1.5}.kGnD4q_footer{justify-content:space-between;align-items:center;gap:14px;padding:22px 36px 28px;display:flex}.kGnD4q_primaryActions{align-items:center;gap:9px;display:flex}@media (width<=620px){.kGnD4q_dialog{max-height:calc(100vh - 24px);width:min(460px,100vw - 24px)!important}.kGnD4q_hero{grid-template-columns:1fr;gap:18px;padding:26px 24px 22px}.kGnD4q_markFrame{border-radius:18px;flex-basis:4.125rem;width:4.125rem;height:4.125rem}.kGnD4q_mark{width:3rem;height:3rem}.kGnD4q_lead{max-width:none}.kGnD4q_statusSection{padding:21px 24px 18px}.kGnD4q_statusGrid{grid-template-columns:1fr}.kGnD4q_consent{margin:0 24px}.kGnD4q_footer{flex-direction:column-reverse;align-items:stretch;padding:18px 24px 24px}.kGnD4q_footer>button,.kGnD4q_primaryActions>button{flex:1}}";
+		const tagId = "@deepwatch/dsh-client-settings/onboarding.module.css";
+		if (typeof document !== "undefined" && document.querySelector("style[data-plugin-css=" + JSON.stringify(tagId) + "]") === null) {
+			const tag = document.createElement("style");
+			tag.dataset.plugin = "@deepwatch/dsh-client-settings";
+			tag.dataset.pluginCss = tagId;
+			tag.textContent = css;
+			document.head.appendChild(tag);
+		}
+		var onboarding_module_css_default = {
+			"card": "kGnD4q_card",
+			"checkingDot": "kGnD4q_checkingDot",
+			"consent": "kGnD4q_consent",
+			"consentIcon": "kGnD4q_consentIcon",
+			"dialog": "kGnD4q_dialog",
+			"eyebrow": "kGnD4q_eyebrow",
+			"footer": "kGnD4q_footer",
+			"hero": "kGnD4q_hero",
+			"identity": "kGnD4q_identity",
+			"lead": "kGnD4q_lead",
+			"liveDot": "kGnD4q_liveDot",
+			"liveLabel": "kGnD4q_liveLabel",
+			"mark": "kGnD4q_mark",
+			"markFrame": "kGnD4q_markFrame",
+			"metricCard": "kGnD4q_metricCard",
+			"metricCopy": "kGnD4q_metricCopy",
+			"metricLabel": "kGnD4q_metricLabel",
+			"metricTop": "kGnD4q_metricTop",
+			"metricValue": "kGnD4q_metricValue",
+			"primaryActions": "kGnD4q_primaryActions",
+			"readyCard": "kGnD4q_readyCard",
+			"statusGrid": "kGnD4q_statusGrid",
+			"statusHeading": "kGnD4q_statusHeading",
+			"statusSection": "kGnD4q_statusSection",
+			"tagline": "kGnD4q_tagline",
+			"title": "kGnD4q_title",
+			"titleBlock": "kGnD4q_titleBlock"
+		};
+		//#endregion
+		//#region src/client/onboarding.tsx
+		/** A human list that stays useful at zero, one and many items. */
+		function names(items) {
+			if (items.length === 0) return "None yet";
+			if (items.length <= 3) return items.map((item) => item.name).join(" · ");
+			return items.slice(0, 2).map((item) => item.name).join(" · ") + " · +" + String(items.length - 2) + " more";
+		}
+		/** The truthful, intentional first impression of DeepWatch. */
+		function WatchOnboarding({ complete, openSection, roles, health, reading }) {
+			const readiness = deriveReadiness({
+				roles,
+				health,
+				reading
+			});
+			const ready = readiness.filter((item) => item.status === "ready");
+			const pending = readiness.filter((item) => item.status !== "ready");
+			const finish = () => {
+				complete?.();
+			};
+			const go = (section) => {
+				openSection?.(section);
+				finish();
+			};
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Modal, {
+				open: true,
+				title: "Welcome to DeepWatch",
+				onClose: finish,
+				headless: true,
+				className: onboarding_module_css_default.dialog ?? "",
+				children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
+					className: onboarding_module_css_default.card,
+					"aria-labelledby": "watch-welcome-title",
+					children: [
+						/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("header", {
+							className: onboarding_module_css_default.hero,
+							children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+								className: onboarding_module_css_default.identity,
+								children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+									className: onboarding_module_css_default.markFrame,
+									"aria-hidden": "true",
+									children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("img", {
+										src: WATCH_MARK_PNG,
+										width: 58,
+										height: 58,
+										alt: "",
+										className: onboarding_module_css_default.mark
+									})
+								}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+									className: onboarding_module_css_default.titleBlock,
+									children: [
+										/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+											className: onboarding_module_css_default.eyebrow,
+											children: "DEEPWATCH / INTO THE KNOW"
+										}),
+										/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("h2", {
+											id: "watch-welcome-title",
+											className: onboarding_module_css_default.title,
+											children: [
+												"See what happened.",
+												/* @__PURE__ */ (0, react_jsx_runtime.jsx)("br", {}),
+												"Prove what worked."
+											]
+										}),
+										/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+											className: onboarding_module_css_default.tagline,
+											children: "See · Remember · Act · Verify"
+										})
+									]
+								})]
+							}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+								className: onboarding_module_css_default.lead,
+								children: "Your local evidence workspace is ready to begin. Connect a model when you want conversation; local capabilities need no provider and no network."
+							})]
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							className: onboarding_module_css_default.statusSection,
+							children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+								className: onboarding_module_css_default.statusHeading,
+								children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+									className: onboarding_module_css_default.eyebrow,
+									children: "INSTALLATION STATUS"
+								}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+									className: onboarding_module_css_default.liveLabel,
+									"aria-live": "polite",
+									children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+										className: [onboarding_module_css_default.liveDot, reading === true ? onboarding_module_css_default.checkingDot : ""].filter(Boolean).join(" "),
+										"aria-hidden": "true"
+									}), reading === true ? "Checking runtime" : "Runtime checked"]
+								})]
+							}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+								className: onboarding_module_css_default.statusGrid,
+								role: "group",
+								"aria-label": "What is ready now",
+								children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("article", {
+									className: [onboarding_module_css_default.metricCard, onboarding_module_css_default.readyCard].filter(Boolean).join(" "),
+									"data-watch-readiness": "ready",
+									children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+										className: onboarding_module_css_default.metricTop,
+										children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+											className: onboarding_module_css_default.metricLabel,
+											children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.IconCheckOutline16, { size: 16 }), "Ready now"]
+										}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("strong", {
+											className: onboarding_module_css_default.metricValue,
+											"data-watch-count": true,
+											children: reading === true ? "—" : ready.length
+										})]
+									}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+										className: onboarding_module_css_default.metricCopy,
+										children: reading === true ? "Checking this installation. Nothing is assumed ready." : names(ready) + " passed " + (ready.length === 1 ? "its" : "their") + " runtime gates."
+									})]
+								}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("article", {
+									className: onboarding_module_css_default.metricCard,
+									"data-watch-readiness": "pending",
+									children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+										className: onboarding_module_css_default.metricTop,
+										children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+											className: onboarding_module_css_default.metricLabel,
+											children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.IconSettingsOutline16, { size: 16 }), "Needs setup"]
+										}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("strong", {
+											className: onboarding_module_css_default.metricValue,
+											"data-watch-count": true,
+											children: pending.length
+										})]
+									}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+										className: onboarding_module_css_default.metricCopy,
+										children: "Configure, test or repair these when you need them. Saved is never presented as tested."
+									})]
+								})]
+							})]
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							className: onboarding_module_css_default.consent,
+							children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+								className: onboarding_module_css_default.consentIcon,
+								"aria-hidden": "true",
+								children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.IconCheckOutline16, { size: 14 })
+							}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("strong", { children: "Private by default" }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", { children: "Connecting a model does not permit uploading frames, audio, transcripts or evidence. Media access is separate and stays off." })] })]
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("footer", {
+							className: onboarding_module_css_default.footer,
+							children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Button, {
+								variant: "ghost",
+								icon: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.IconRightUpOutline16, { size: 16 }),
+								onClick: () => {
+									go("watch-diagnostics");
+								},
+								children: "View diagnostics"
+							}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+								className: onboarding_module_css_default.primaryActions,
+								children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Button, {
+									variant: "outline",
+									onClick: finish,
+									children: "Explore offline"
+								}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Button, {
+									variant: "primary",
+									onClick: () => {
+										go("watch-roles");
+									},
+									children: "Finish setup"
+								})]
+							})]
+						})
+					]
+				})
+			});
+		}
+		//#endregion
+		//#region src/client/binding-state.ts
+		/**
+		* The browser's view of what is configured, assembled from four Host answers.
+		*
+		* A person saved an OpenRouter credential, saw a green dot and the words
+		* "Saved openrouter.", and reasonably concluded the product was ready. It was
+		* not: no model had been chosen and nothing had been assigned to anything. The
+		* dot was answering "is a credential stored?" while the reader was asking "can
+		* I send a message?", and those turn out to be four separate questions.
+		*
+		* So this store never derives readiness itself. It gathers the four facts —
+		* from `llm.providers`, `llm.models`, `credentials.describe` and the stored
+		* bindings in `settings.describe` — and hands them to `roleReadiness`, which
+		* is the only thing in this product allowed to answer "ready". A surface that
+		* wanted to shade a dot green would have to go through the same gate.
+		*
+		* **Nothing here contacts a provider.** Opening a settings page must not spend
+		* somebody's money or rate budget, so reachability stays `unknown` until a
+		* person asks for a check. That is why a freshly saved credential reads
+		* "Credential saved · not yet assigned" rather than a claim about whether it
+		* works: the honest state after a save is *stored*, and the product says so.
+		*
+		* **No value crosses this boundary.** `credentials.describe` is structurally
+		* value-free — it answers `configured`, `source`, `writable` and has no slot
+		* for a value — and the binding this store writes holds a reference the Host
+		* resolves. There is nowhere in this file for a key to be, which is the
+		* property that makes the store safe to render, log and screenshot.
+		*
+		* @module @deepwatch/dsh-client-settings/binding-state
+		*/
+		/**
+		* Upstream's own settings section for the selection a new session starts with.
+		*
+		* Spelled here rather than imported: `AGENT_DEFAULT_MODEL_SETTINGS_NAMESPACE`
+		* lives in a Host package, and a browser bundle that imported it would carry
+		* the Harness's server-side settings machinery to learn one string.
+		* `tests/binding-flow.test.mjs` holds it to the value the pinned baseline
+		* composes.
+		*/
+		const DEFAULT_MODEL_NAMESPACE = "agent-default-model";
+		/**
+		* The identity a provider test result belongs to.
+		*
+		* Provider and model alone are not enough. Rebinding a role to a route served
+		* through a different credential must not inherit the previous verdict — that
+		* is the same "saved means working" claim this whole file exists to remove,
+		* wearing a route it was never asked about. So the credential *reference* is
+		* part of the key.
+		*
+		* What it deliberately cannot see: a value rotated behind a reference that
+		* did not change. No credential value crosses this boundary, so the browser
+		* half has nothing to compare. A result therefore lives only as long as the
+		* session that produced it, and is never persisted or restored — an untested
+		* binding after a reload reads as untested, which is the truthful answer.
+		*/
+		function providerTestKey(provider, model, credentialRef) {
+			return [
+				provider,
+				model,
+				credentialRef ?? ""
+			].join("\0");
+		}
+		const EMPTY = {
+			status: "idle",
+			error: null,
+			writable: false,
+			providers: [],
+			roles: [],
+			bindings: EMPTY_BINDINGS,
+			saving: false,
+			testingRole: null,
+			testMessage: null
+		};
+		/**
+		* The credential reference a provider's own settings section names.
+		*
+		* Walked out of the described value rather than asked for separately: the
+		* settings domain already returns each namespace's resolved value, and
+		* `apiKeyEnv` is a field in it. The walk is plain property access because the
+		* described value is plain JSON — the secret slots have already been removed
+		* by the seam, which is what makes reading this safe.
+		*/
+		function credentialRefOf(view, path) {
+			if (view === void 0) return null;
+			let cursor = view.value;
+			for (const step of path) {
+				if (typeof cursor !== "object" || cursor === null) return null;
+				cursor = cursor[step];
+			}
+			if (typeof cursor !== "object" || cursor === null) return null;
+			const ref = cursor["apiKeyEnv"];
+			return typeof ref === "string" && ref !== "" ? ref : null;
+		}
+		/**
+		* What is known about a provider's credential.
+		*
+		* `configured_unverified` rather than `verified` is the whole point. The Host
+		* can say a value resolves; only a provider can say it works, and nothing here
+		* has asked one. Calling a stored credential verified is the claim that sent a
+		* prompt to a provider nobody had configured.
+		*/
+		function credentialStatusOf(ref, described, readable) {
+			if (ref === null) return "absent";
+			if (!readable) return "inaccessible";
+			return described[ref]?.configured === true ? "configured_unverified" : "absent";
+		}
+		/** The route capability a provider row amounts to. */
+		function routeOf(row, role) {
+			if (row === void 0 || !row.active) return null;
+			return {
+				provider: row.provider,
+				roles: [...BINDABLE_ROLES],
+				modalities: ROLE_MODALITIES[role],
+				models: row.models.length === 0 ? null : row.models.map((model) => model.id)
+			};
+		}
+		/** Everything known about one role, folded through the single readiness gate. */
+		function roleRowOf(role, bindings, providers, tests = /* @__PURE__ */ new Map()) {
+			const binding = bindingFor(bindings, role);
+			const row = binding === null ? void 0 : providers.find((entry) => entry.provider === binding.provider);
+			const route = routeOf(row, role);
+			const known = route?.models ?? null;
+			const tested = binding === null ? void 0 : tests.get(providerTestKey(binding.provider, binding.model, row?.credentialRef ?? null));
+			const readiness = roleReadiness(role, {
+				binding,
+				credential: tested?.credential ?? row?.credential ?? "absent",
+				reachability: tested?.reachability ?? "unknown",
+				model: binding === null ? "none" : known === null || known.includes(binding.model) ? "selected" : "unavailable",
+				route,
+				consentGranted: true,
+				policyPermits: true,
+				contractMatches: true
+			});
+			return {
+				role,
+				provider: binding?.provider ?? null,
+				model: binding?.model ?? null,
+				readiness
+			};
+		}
+		/**
+		* The binding store, shaped for `useSyncExternalStore`.
+		*
+		* Deliberately a plain object with `subscribe`/`getSnapshot` rather than a
+		* framework store: this package's browser half is loaded into somebody else's
+		* React tree, and bringing a state library into a plugin bundle to hold six
+		* fields is how a distribution ends up shipping two of them.
+		*/
+		var BindingStore = class {
+			api;
+			providerTester;
+			readinessReader;
+			snapshot = EMPTY;
+			listeners = /* @__PURE__ */ new Set();
+			/** Guards against a slow load landing after a newer one. */
+			generation = 0;
+			revision;
+			defaultRevision;
+			providerTests = /* @__PURE__ */ new Map();
+			providerTestAbort = null;
+			constructor(api, providerTester, readinessReader) {
+				this.api = api;
+				this.providerTester = providerTester;
+				this.readinessReader = readinessReader;
+			}
+			/**
+			* Replace what this tab believes about tested routes with what the Host says.
+			*
+			* The browser used to be the only place a provider-test verdict lived, and a
+			* tab cannot see a Host restart, an edit made in another tab, or a key
+			* rotated behind a reference that did not change. It drew a tested badge over
+			* routes the Host had already stopped being willing to serve, and the
+			* composer that badge unlocks opened onto a refusal.
+			*
+			* So the Host is asked, per bound route, and its answer wins in both
+			* directions: a route it still proves is tested even in a tab that has just
+			* been reloaded and ran no test, and a route it no longer proves stops being
+			* tested here the moment this is read.
+			*/
+			async reconcileReadiness(bindings, providers, signal) {
+				if (this.readinessReader === void 0) return;
+				for (const role of BINDABLE_ROLES) {
+					const binding = bindingFor(bindings, role);
+					if (binding === null) continue;
+					const credentialRef = providers.find((entry) => entry.provider === binding.provider)?.credentialRef ?? null;
+					const key = providerTestKey(binding.provider, binding.model, credentialRef);
+					let verdict;
+					try {
+						verdict = await this.readinessReader(binding.provider, binding.model, signal);
+					} catch {
+						continue;
+					}
+					if (signal.aborted) return;
+					if (verdict.proved) this.providerTests.set(key, {
+						provider: binding.provider,
+						model: binding.model,
+						ok: true,
+						credential: "verified",
+						reachability: "reachable",
+						message: "The Host still holds a proof for this route."
+					});
+					else this.providerTests.delete(key);
+				}
+			}
+			/** @returns the current snapshot; stable between changes. */
+			getSnapshot = () => this.snapshot;
+			/** @param listener - called after every change. @returns the unsubscriber. */
+			subscribe = (listener) => {
+				this.listeners.add(listener);
+				return () => {
+					this.listeners.delete(listener);
+				};
+			};
+			publish(next) {
+				this.snapshot = {
+					...this.snapshot,
+					...next
+				};
+				for (const listener of this.listeners) listener();
+			}
+			/**
+			* Ask the Host everything, and fold it into one snapshot.
+			*
+			* The three reads run together because they are independent and a settings
+			* page that took three round trips in series felt broken on a slow link.
+			* Their failures are not equal, though: providers and settings are the page,
+			* so losing either is an error, while a credential describe that fails
+			* downgrades those providers to `inaccessible` and leaves the rest readable.
+			*/
+			async load() {
+				const generation = ++this.generation;
+				this.publish({
+					status: "loading",
+					error: null
+				});
+				let providers;
+				let namespaces;
+				let groups = [];
+				let failures = [];
+				let writable = false;
+				try {
+					const [directory, settings, catalogue] = await Promise.all([
+						this.api.llm.providers({}),
+						this.api.settings.describe({}),
+						this.api.llm.models({}).catch(() => null)
+					]);
+					if (!directory.result.ok) throw new Error(directory.result.error.message);
+					if (!settings.result.ok) throw new Error(settings.result.error.message);
+					providers = directory.result.value.providers;
+					namespaces = settings.result.value.namespaces;
+					writable = settings.result.value.writable;
+					if (catalogue !== null && catalogue.result.ok) {
+						groups = catalogue.result.value.groups;
+						failures = catalogue.result.value.failures;
+					}
+				} catch (error) {
+					if (generation !== this.generation) return;
+					this.publish({
+						status: "error",
+						error: error instanceof Error ? error.message : String(error)
+					});
+					return;
+				}
+				const byNs = new Map(namespaces.map((view) => [view.ns, view]));
+				const stored = byNs.get(BINDINGS_NAMESPACE);
+				this.revision = stored?.revision;
+				const bindings = readBindings(stored?.value);
+				const refs = /* @__PURE__ */ new Map();
+				for (const entry of providers) refs.set(entry.provider, credentialRefOf(byNs.get(entry.settingsNs), entry.settingsPath));
+				const wanted = [...new Set([...refs.values()].filter((ref) => ref !== null))];
+				let credentials = {};
+				let readable = true;
+				if (wanted.length > 0) try {
+					const answer = await this.api.credentials.describe({ refs: wanted });
+					if (answer.result.ok) credentials = answer.result.value.credentials;
+					else readable = false;
+				} catch {
+					readable = false;
+				}
+				if (generation !== this.generation) return;
+				const catalogByProvider = new Map(groups.map((group) => [group.id, group]));
+				const failureByProvider = new Map(failures.map((entry) => [entry.id, entry.message]));
+				const rows = providers.map((entry) => {
+					const ref = refs.get(entry.provider) ?? null;
+					return {
+						provider: entry.provider,
+						displayName: entry.displayName,
+						active: entry.active,
+						credentialRef: ref,
+						credential: credentialStatusOf(ref, credentials, readable),
+						models: catalogByProvider.get(entry.provider)?.models ?? [],
+						catalogError: failureByProvider.get(entry.provider) ?? null
+					};
+				});
+				const readiness = new AbortController();
+				await this.reconcileReadiness(bindings, rows, readiness.signal);
+				if (generation !== this.generation) return;
+				this.publish({
+					status: "ready",
+					error: null,
+					writable,
+					providers: rows,
+					bindings,
+					roles: BINDABLE_ROLES.map((role) => roleRowOf(role, bindings, rows, this.providerTests))
+				});
+				if (writable) await this.reconcileDefaultSelection(bindings, byNs.get(DEFAULT_MODEL_NAMESPACE));
+			}
+			/**
+			* Write the Harness selection only when it disagrees with the binding.
+			*
+			* Guarded on disagreement because this runs on every load: rewriting an
+			* already-correct section would bump its revision, invalidate every other
+			* open editor's `expectedRevision`, and turn a read into a source of write
+			* conflicts.
+			*/
+			async reconcileDefaultSelection(bindings, view) {
+				this.defaultRevision = view?.revision;
+				const chat = bindings.roles[PRIMARY_ROLE];
+				const wanted = chat === void 0 ? {
+					provider: "",
+					model: ""
+				} : {
+					provider: chat.provider,
+					model: chat.model
+				};
+				const current = view?.value ?? {};
+				if (current.provider === wanted.provider && current.model === wanted.model) return;
+				await this.syncDefaultSelection(bindings);
+			}
+			/**
+			* Bind one role to one provider and model, and persist the decision.
+			*
+			* `replace` rather than `update`, because unbinding has to be expressible:
+			* a merge cannot remove a key, and a role that could be added but not
+			* removed is a role somebody is stuck with. The whole document is rewritten
+			* from the snapshot the caller is looking at, and `expectedRevision` is what
+			* turns a concurrent edit into a refusal rather than a silent overwrite.
+			*/
+			async bind(role, provider, model) {
+				const row = this.snapshot.providers.find((entry) => entry.provider === provider);
+				await this.write(withBinding(this.snapshot.bindings, role, {
+					provider,
+					model,
+					credentialRef: row?.credentialRef ?? null,
+					boundAt: (/* @__PURE__ */ new Date()).toISOString(),
+					boundBy: "person"
+				}));
+			}
+			/** Remove one role's binding. The role becomes unbound, never inherited. */
+			async unbind(role) {
+				await this.write(withoutBinding(this.snapshot.bindings, role));
+			}
+			/** Run the exact bound route once; saving a credential never calls this. */
+			async testRole(role) {
+				const binding = bindingFor(this.snapshot.bindings, role);
+				if (binding === null || this.providerTester === void 0) {
+					this.publish({ testMessage: "Assign a provider and model before running the test." });
+					return;
+				}
+				const credentialRef = this.snapshot.providers.find((entry) => entry.provider === binding.provider)?.credentialRef ?? null;
+				const controller = new AbortController();
+				this.providerTestAbort?.abort();
+				this.providerTestAbort = controller;
+				this.publish({
+					testingRole: role,
+					testMessage: null
+				});
+				try {
+					const facts = await this.providerTester(binding.provider, binding.model, controller.signal);
+					if (controller.signal.aborted) return;
+					this.providerTests.set(providerTestKey(binding.provider, binding.model, credentialRef), facts);
+					this.publish({
+						testingRole: null,
+						testMessage: facts.message,
+						roles: BINDABLE_ROLES.map((current) => roleRowOf(current, this.snapshot.bindings, this.snapshot.providers, this.providerTests))
+					});
+				} catch {
+					if (controller.signal.aborted) return;
+					this.publish({
+						testingRole: null,
+						testMessage: "The provider test could not be started. Check Diagnostics and try again."
+					});
+				} finally {
+					if (this.providerTestAbort === controller) this.providerTestAbort = null;
+				}
+			}
+			/** Cancel only the explicit provider probe; no Chat turn is involved. */
+			cancelProviderTest() {
+				if (this.providerTestAbort === null) return;
+				this.providerTestAbort.abort();
+				this.providerTestAbort = null;
+				this.publish({
+					testingRole: null,
+					testMessage: "Provider test cancelled. This binding remains not tested."
+				});
+			}
+			/**
+			* Point the Harness's own default selection at what Chat is bound to.
+			*
+			* The link this subsystem was missing, and the failure it caused is worth
+			* stating plainly: a person added a provider, chose a model and assigned it
+			* to Chat, and still could not send. Every DeepWatch surface agreed the
+			* binding existed. It did — in DeepWatch's document. But the thing that
+			* actually routes a prompt is the Harness's model selection, which this
+			* distribution had *emptied* so that nothing would be chosen for anybody,
+			* and binding Chat never filled it in. Two records of one decision, and the
+			* one the runtime reads was the one nobody was writing.
+			*
+			* So a Chat binding writes both. `agent-default-model` is upstream's own
+			* settings section, read live by `AgentDefaultModelConfig` and re-read by a
+			* blank session on every look — so a session opened before the binding
+			* picks it up without being told.
+			*
+			* Only Chat. The other roles are DeepWatch's own concepts and have no
+			* upstream selection to keep in step; writing one for them would point the
+			* conversation at a model chosen for something else.
+			*/
+			async syncDefaultSelection(next) {
+				const chat = next.roles[PRIMARY_ROLE];
+				const section = chat === void 0 ? {
+					provider: "",
+					model: ""
+				} : {
+					provider: chat.provider,
+					model: chat.model
+				};
+				try {
+					const response = await this.api.settings.replace({
+						ns: DEFAULT_MODEL_NAMESPACE,
+						section,
+						...this.defaultRevision === void 0 ? {} : { expectedRevision: this.defaultRevision }
+					});
+					if (response.result.ok) this.defaultRevision = response.result.value.revision;
+					else this.publish({ error: response.result.error.message });
+				} catch (error) {
+					this.publish({ error: error instanceof Error ? error.message : String(error) });
+				}
+			}
+			async write(next) {
+				assertNoSecretMaterial("the binding document", next);
+				this.publish({
+					saving: true,
+					error: null
+				});
+				try {
+					const response = await this.api.settings.replace({
+						ns: BINDINGS_NAMESPACE,
+						section: {
+							version: 1,
+							roles: next.roles
+						},
+						...this.revision === void 0 ? {} : { expectedRevision: this.revision }
+					});
+					if (!response.result.ok) {
+						this.publish({
+							saving: false,
+							error: response.result.error.message
+						});
+						return;
+					}
+					this.revision = response.result.value.revision;
+					const bindings = readBindings(response.result.value.value);
+					await this.syncDefaultSelection(bindings);
+					this.publish({
+						saving: false,
+						bindings,
+						roles: BINDABLE_ROLES.map((role) => roleRowOf(role, bindings, this.snapshot.providers, this.providerTests))
+					});
+				} catch (error) {
+					this.publish({
+						saving: false,
+						error: error instanceof Error ? error.message : String(error)
+					});
+				}
+			}
+		};
+		/**
+		* Whether the capability a conversation needs can actually run.
+		*
+		* The one question the composer asks, given its own name so no surface has to
+		* remember which role Chat is or re-derive readiness to find out.
+		*/
+		function chatReadiness(snapshot) {
+			return snapshot.roles.find((row) => row.role === "agent_model")?.readiness ?? null;
+		}
+		//#endregion
+		//#region src/providers.ts
+		/** A few recognisable names, for a sentence that has to stay short. */
+		const SAMPLE_PROVIDERS = [
+			"amazon-bedrock",
+			"anthropic",
+			"deepseek",
+			"google",
+			"groq",
+			"mistral",
+			"openai",
+			"openrouter"
+		];
+		//#endregion
+		//#region src/client/role-bindings.tsx
+		/**
+		* Role Bindings, as a screen somebody can actually finish setup on.
+		*
+		* This surface used to be four rows of static copy saying "Not bound" and a
+		* paragraph explaining that bindings were stored by DSH. Both true. Neither
+		* gave anybody a way to bind anything — so a person who had saved an OpenRouter
+		* credential arrived here, read that nothing was bound, and had no control to
+		* change it. The screen described the product's design instead of operating it.
+		*
+		* What it does now is the four steps in order, because they *are* ordered and
+		* pretending otherwise is what made a saved credential look like a finished
+		* setup:
+		*
+		*   1. a provider has a credential          — stored, and nothing more
+		*   2. that provider advertises models      — asked for, never assumed
+		*   3. a model is assigned to a capability  — explicitly, by a person
+		*   4. the capability can run                — derived, never stored
+		*
+		* **Nothing here is signalled by colour alone.** Every state carries the word
+		* for it, and the chip is decoration on top of that word. A status conveyed by
+		* a green dot is a status a screen reader does not have, and — as the incident
+		* that produced this file showed — one a sighted reader misreads too.
+		*
+		* **Nothing is chosen implicitly.** There is no "use my only credential", no
+		* defaulting to the first model in the list, and no provider that becomes
+		* bound because it was configured. Every binding here is a button somebody
+		* pressed.
+		*
+		* @module @deepwatch/dsh-client-settings/role-bindings
+		*/
+		/**
+		* The tone a readiness status earns.
+		*
+		* `bound_unverified` is deliberately not `active`. That is precisely the state
+		* a green dot used to claim, and claiming it is what sent a prompt to a
+		* provider nobody had configured.
+		*/
+		function toneFor(readiness) {
+			if (isExecutable(readiness)) return "active";
+			return readiness.status === "blocked" ? "caution" : "neutral";
+		}
+		/** The tone a credential state earns. Stored is not working. */
+		function credentialTone(status) {
+			if (status === "verified") return "active";
+			if (status === "rejected" || status === "inaccessible") return "caution";
+			return "neutral";
+		}
+		const CONTROL = {
+			select: {
+				font: "inherit",
+				fontSize: "13px",
+				padding: "7px 10px",
+				borderRadius: "10px",
+				border: "1px solid color-mix(in srgb, var(--watch-accent) 12%, var(--dsw-alias-border-l2))",
+				background: "var(--dsw-alias-bg-layer-2)",
+				color: "var(--dsw-alias-label-primary)",
+				minWidth: "180px",
+				maxWidth: "100%"
+			},
+			primary: {
+				font: "inherit",
+				fontSize: "13px",
+				fontWeight: 600,
+				padding: "8px 15px",
+				borderRadius: "10px",
+				cursor: "pointer",
+				border: "1px solid var(--watch-accent)",
+				background: "var(--watch-accent)",
+				color: "white",
+				boxShadow: "0 6px 18px color-mix(in srgb, var(--watch-accent) 22%, transparent)"
+			},
+			quiet: {
+				font: "inherit",
+				fontSize: "13px",
+				padding: "8px 13px",
+				borderRadius: "10px",
+				cursor: "pointer",
+				border: "1px solid var(--dsw-alias-border-l2)",
+				background: "color-mix(in srgb, var(--dsw-alias-bg-layer-2) 80%, transparent)",
+				color: "var(--dsw-alias-label-secondary)"
+			},
+			field: {
+				display: "flex",
+				flexDirection: "column",
+				gap: "4px",
+				minWidth: 0
+			},
+			label: {
+				fontSize: "11px",
+				letterSpacing: "0.03em",
+				textTransform: "uppercase",
+				color: "var(--dsw-alias-label-tertiary)"
+			},
+			row: {
+				display: "flex",
+				flexWrap: "wrap",
+				gap: "10px",
+				alignItems: "flex-end",
+				marginTop: "12px"
+			}
+		};
+		/**
+		* The editor for one role: pick a provider, pick one of its models, assign it.
+		*
+		* Two selects rather than one combined list, because the two choices fail
+		* differently. A provider with no credential is a different problem from a
+		* provider whose catalogue is empty, and a single flattened list would report
+		* both as "nothing to choose".
+		*
+		* Exported because the blocked composer offers the same choice in place. A
+		* person who is stopped from sending should be able to fix it where they are
+		* standing, and offering them a *second* picker written separately is how two
+		* screens end up disagreeing about what a provider offers.
+		*/
+		function BindingEditor({ row, providers, saving, onBind, onCancel }) {
+			const providerId = (0, react.useId)();
+			const modelId = (0, react.useId)();
+			const noticeId = (0, react.useId)();
+			const first = (0, react.useRef)(null);
+			const [provider, setProvider] = (0, react.useState)(row.provider ?? "");
+			const [model, setModel] = (0, react.useState)(row.model ?? "");
+			(0, react.useEffect)(() => {
+				first.current?.focus();
+			}, []);
+			const chosen = providers.find((entry) => entry.provider === provider);
+			const models = chosen?.models ?? [];
+			const pickProvider = (next) => {
+				setProvider(next);
+				setModel("");
+			};
+			const notice = chosen === void 0 ? "Choose a provider to see the models it offers." : chosen.credential === "absent" ? `${chosen.displayName} has no credential yet. Add one in Models & Providers, then come back.` : chosen.catalogError !== null ? `${chosen.displayName} did not return a model list.` : models.length === 0 ? `${chosen.displayName} advertised no models.` : `${String(models.length)} model(s) offered by ${chosen.displayName}.`;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				style: CONTROL.row,
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+						style: CONTROL.field,
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("label", {
+							htmlFor: providerId,
+							style: CONTROL.label,
+							children: "Provider"
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("select", {
+							id: providerId,
+							ref: first,
+							style: CONTROL.select,
+							value: provider,
+							disabled: saving,
+							"aria-describedby": noticeId,
+							onChange: (event) => {
+								pickProvider(event.target.value);
+							},
+							children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+								value: "",
+								children: "Choose a provider…"
+							}), providers.map((entry) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+								value: entry.provider,
+								children: `${entry.displayName} — ${CREDENTIAL_STATUS_LABEL[entry.credential]}`
+							}, entry.provider))]
+						})]
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+						style: CONTROL.field,
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("label", {
+							htmlFor: modelId,
+							style: CONTROL.label,
+							children: "Model"
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("select", {
+							id: modelId,
+							style: CONTROL.select,
+							value: model,
+							disabled: saving || models.length === 0,
+							"aria-describedby": noticeId,
+							onChange: (event) => {
+								setModel(event.target.value);
+							},
+							children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+								value: "",
+								children: "Choose a model…"
+							}), models.map((entry) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+								value: entry.id,
+								children: entry.name === "" ? entry.id : entry.name
+							}, entry.id))]
+						})]
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+						type: "button",
+						style: {
+							...CONTROL.primary,
+							opacity: provider === "" || model === "" || saving ? .5 : 1
+						},
+						disabled: provider === "" || model === "" || saving,
+						onClick: () => {
+							onBind(provider, model);
+						},
+						children: saving ? "Assigning…" : `Assign to ${ROLE_LABEL[row.role]}`
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+						type: "button",
+						style: CONTROL.quiet,
+						onClick: onCancel,
+						disabled: saving,
+						children: "Cancel"
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						id: noticeId,
+						style: {
+							flexBasis: "100%",
+							margin: "2px 0 0",
+							fontSize: "12px",
+							lineHeight: 1.5,
+							color: "var(--dsw-alias-label-tertiary)"
+						},
+						children: notice
+					})
+				]
+			});
+		}
+		/** One role: what it is, what it is bound to, and whether that can run. */
+		function RoleCard({ row, providers, snapshot, store, openEditor, editing, onEdit, onClose }) {
+			const provider = providers.find((entry) => entry.provider === row.provider);
+			const blocker = blockerMessage(row.readiness);
+			const ready = isExecutable(row.readiness);
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				style: T.card,
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						style: T.cardHead,
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", {
+							style: T.title,
+							children: ROLE_LABEL[row.role]
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+							tone: toneFor(row.readiness),
+							children: BINDING_STATUS_LABEL[row.readiness.status]
+						})]
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						style: {
+							...T.lead,
+							margin: "6px 0 0"
+						},
+						children: ROLE_PURPOSE[row.role]
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						style: T.meta,
+						children: [
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+								style: T.key,
+								children: "Provider"
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+								style: T.value,
+								children: provider?.displayName ?? row.provider ?? "Nothing assigned"
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+								style: T.key,
+								children: "Model"
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+								style: T.value,
+								children: row.model ?? "Nothing assigned"
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+								style: T.key,
+								children: "Status"
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+								style: T.value,
+								children: ready ? `${ROLE_LABEL[row.role]} can run.` : blocker ?? "Not configured."
+							})
+						]
+					}),
+					openEditor && editing === row.role ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(BindingEditor, {
+						row,
+						providers,
+						saving: snapshot.saving,
+						onBind: (chosenProvider, chosenModel) => {
+							store.bind(row.role, chosenProvider, chosenModel).then(onClose);
+						},
+						onCancel: onClose
+					}) : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						style: CONTROL.row,
+						children: [
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+								type: "button",
+								style: CONTROL.primary,
+								disabled: !snapshot.writable,
+								"aria-describedby": snapshot.writable ? void 0 : "watch-bindings-readonly",
+								onClick: () => {
+									onEdit(row.role);
+								},
+								children: row.model === null ? "Choose a model" : "Change model"
+							}),
+							row.model === null ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+								type: "button",
+								style: CONTROL.quiet,
+								disabled: snapshot.testingRole !== null && snapshot.testingRole !== row.role || snapshot.saving,
+								onClick: () => {
+									if (snapshot.testingRole === row.role) store.cancelProviderTest();
+									else store.testRole(row.role);
+								},
+								children: snapshot.testingRole === row.role ? "Cancel provider test" : "Run provider test"
+							}),
+							row.model === null ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+								type: "button",
+								style: CONTROL.quiet,
+								disabled: !snapshot.writable || snapshot.saving,
+								"aria-describedby": snapshot.writable ? void 0 : "watch-bindings-readonly",
+								onClick: () => {
+									store.unbind(row.role);
+								},
+								children: `Unassign ${ROLE_LABEL[row.role]}`
+							})
+						]
+					})
+				]
+			});
+		}
+		/** The providers a person has actually configured, and what is known of each. */
+		function ProviderList({ providers }) {
+			const configured = providers.filter((entry) => entry.credential !== "absent");
+			if (configured.length === 0) return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				style: {
+					...T.card,
+					borderStyle: "dashed"
+				},
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+					style: T.cardHead,
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", {
+						style: T.title,
+						children: "No provider is configured yet"
+					}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+						tone: "neutral",
+						children: "No credential"
+					})]
+				}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+					style: {
+						...T.lead,
+						margin: "8px 0 0"
+					},
+					children: "Add a credential in the Harness’s own Models & Providers screen. A saved credential is the first of four steps — it stores a key and assigns nothing."
+				})]
+			});
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				style: T.card,
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						style: T.cardHead,
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", {
+							style: T.title,
+							children: `${String(37)} routes are available`
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+							tone: "neutral",
+							children: `${String(configured.length)} configured`
+						})]
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("p", {
+						style: {
+							...T.lead,
+							margin: "8px 0 0"
+						},
+						children: [
+							`${String(30)} hosted and ${String(7)} where you supply the endpoint — `,
+							SAMPLE_PROVIDERS.join(", "),
+							" and others. Watch adds none of these and removes none of them: the ",
+							"catalogue is the Harness’s, reached through its own Models & Providers screen."
+						]
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						style: T.meta,
+						children: [
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+								style: T.key,
+								children: "A local model"
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+								style: T.value,
+								children: "An OpenAI-compatible server you run — Ollama, vLLM, LM Studio, llama.cpp — is a base URL you supply, not a separate feature."
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+								style: T.key,
+								children: "DeepSeek"
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+								style: T.value,
+								children: "One route among many. Nothing here requires it, and nothing selects it for you."
+							})
+						]
+					})
+				]
+			}), configured.map((entry) => /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				style: T.card,
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+					style: T.cardHead,
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", {
+						style: T.title,
+						children: entry.displayName
+					}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+						tone: credentialTone(entry.credential),
+						children: CREDENTIAL_STATUS_LABEL[entry.credential]
+					})]
+				}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+					style: T.meta,
+					children: [
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							style: T.key,
+							children: "Route"
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							style: T.value,
+							children: entry.active ? "Served by an adapter" : "Not currently served"
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							style: T.key,
+							children: "Models offered"
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							style: T.value,
+							children: entry.catalogError !== null ? "The provider did not return a list." : entry.models.length === 0 ? "None advertised." : String(entry.models.length)
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							style: T.key,
+							children: "Credential save"
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							style: T.value,
+							children: "Does not contact the provider. Tests are explicit and apply to one exact provider/model binding."
+						})
+					]
+				})]
+			}, entry.provider))] });
+		}
+		/**
+		* Role Bindings.
+		*
+		* @param props.store - the binding store this surface reads and writes.
+		* @returns the section body.
+		*/
+		function RoleBindings({ store }) {
+			const snapshot = (0, react.useSyncExternalStore)(store.subscribe, store.getSnapshot, store.getSnapshot);
+			const [editing, setEditing] = (0, react.useState)(null);
+			(0, react.useEffect)(() => {
+				store.load();
+			}, [store]);
+			const onEdit = (0, react.useCallback)((role) => {
+				setEditing(role);
+			}, []);
+			const onClose = (0, react.useCallback)(() => {
+				setEditing(null);
+			}, []);
+			const chat = (0, react.useMemo)(() => snapshot.roles.find((row) => row.role === "agent_model") ?? null, [snapshot.roles]);
+			if (snapshot.status === "error") return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+				style: T.page,
+				children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+					style: {
+						...T.card,
+						borderStyle: "dashed"
+					},
+					children: [
+						/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							style: T.cardHead,
+							children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", {
+								style: T.title,
+								children: "Settings could not be read"
+							}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+								tone: "caution",
+								children: "Unavailable"
+							})]
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+							style: {
+								...T.lead,
+								margin: "8px 0 0"
+							},
+							children: "The Harness did not answer. Nothing has been changed, and no capability has been reconfigured."
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+							style: CONTROL.row,
+							children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+								type: "button",
+								style: CONTROL.primary,
+								onClick: () => {
+									store.load();
+								},
+								children: "Try again"
+							})
+						})
+					]
+				})
+			});
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				style: T.page,
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						style: T.lead,
+						children: "A capability is assigned per role, not per provider. One provider may serve several roles, and a role with nothing assigned says so — it never falls back to another role’s model, and a stored credential never assigns itself."
+					}),
+					snapshot.writable ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						id: "watch-bindings-readonly",
+						style: {
+							...T.card,
+							borderStyle: "dashed"
+						},
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							style: T.cardHead,
+							children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", {
+								style: T.title,
+								children: "Settings are read-only"
+							}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+								tone: "caution",
+								children: "Not writable"
+							})]
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+							style: {
+								...T.lead,
+								margin: "8px 0 0"
+							},
+							children: "This Workspace was opened against a configuration the Harness will not let it change, so assignments cannot be edited here. Nothing is wrong with the capabilities themselves — what is shown below is accurate and read from the running system."
+						})]
+					}),
+					chat !== null && !isExecutable(chat.readiness) ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						style: {
+							...T.card,
+							borderColor: "var(--watch-accent)"
+						},
+						children: [
+							/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+								style: T.cardHead,
+								children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", {
+									style: T.title,
+									children: "Chat is not ready yet"
+								}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+									tone: "neutral",
+									children: BINDING_STATUS_LABEL[chat.readiness.status]
+								})]
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("p", {
+								style: {
+									...T.lead,
+									margin: "8px 0 0"
+								},
+								children: [blockerMessage(chat.readiness) ?? "Choose a provider and model for Chat.", " Until then the composer stays closed and nothing is sent."]
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+								style: CONTROL.row,
+								children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+									type: "button",
+									style: CONTROL.primary,
+									disabled: !snapshot.writable,
+									"aria-describedby": snapshot.writable ? void 0 : "watch-bindings-readonly",
+									onClick: () => {
+										setEditing(PRIMARY_ROLE);
+									},
+									children: "Choose models and roles"
+								})
+							})
+						]
+					}) : null,
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						role: "status",
+						"aria-live": "polite",
+						style: {
+							margin: "0 0 10px",
+							fontSize: "12px",
+							color: "var(--dsw-alias-label-tertiary)",
+							minHeight: "1em"
+						},
+						children: snapshot.saving ? "Saving the assignment…" : snapshot.testingRole !== null ? `Testing ${ROLE_LABEL[snapshot.testingRole]} with one bounded provider request…` : snapshot.testMessage !== null ? snapshot.testMessage : snapshot.error !== null ? snapshot.error : ""
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h2", {
+						style: T.h2,
+						children: "Capabilities"
+					}),
+					BINDABLE_ROLES.map((role) => {
+						const row = snapshot.roles.find((entry) => entry.role === role);
+						return row === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(RoleCard, {
+							row,
+							providers: snapshot.providers,
+							snapshot,
+							store,
+							openEditor: editing === role,
+							editing,
+							onEdit,
+							onClose
+						}, role);
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h2", {
+						style: T.h2,
+						children: "Providers"
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)(ProviderList, { providers: snapshot.providers }),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						style: T.note,
+						children: "Assignments are stored beside the Harness’s own settings, and reference a credential rather than holding one. Watch keeps no second credential store and never sees a key."
+					})
+				]
+			});
+		}
+		//#endregion
+		//#region src/client/chat-gate.tsx
+		/**
+		* The composer, closed until something is actually bound to Chat — and the
+		* fastest way to bind it, offered where the person is standing.
+		*
+		* A person typed a message into a composer that looked ready, pressed send,
+		* and the prompt was routed to a provider they had never configured. Nothing
+		* about the composer had told them otherwise: the model chip named a DeepSeek
+		* model they had not chosen, the send button was live, and the first thing
+		* that disagreed was a failed turn.
+		*
+		* This is the client half of preflight. It raises the block upstream provides
+		* for exactly this — *"Composer blocks: the one way another plugin stops a
+		* session's input"* — so the textarea goes inert, the send button stops
+		* accepting, and the placeholder says why in the words of whoever knows.
+		*
+		* **This is an affordance, and it is not the enforcement.** It lives in a
+		* browser tab. The Host refuses an unbound route regardless of what any client
+		* disables (`@deepwatch/dsh-technology/routing`), and the composed default
+		* names no route so the Harness's own admission boundary refuses a turn before
+		* one exists. The value of this layer is not that it makes refusal certain — it
+		* is that a person finds out *before* typing rather than after sending.
+		*
+		* **The draft survives.** Blocking is one inert textarea, never a second tree:
+		* the composer keeps its DOM, so whatever was typed is still there when the
+		* binding is fixed. That is upstream's design and this file's reason for using
+		* it rather than rendering a replacement.
+		*
+		* **The way out is here, not somewhere else.** The settings panel's open state
+		* is component-local to `SettingsRoot`, so no plugin can navigate to a section
+		* — and a button that names a screen it cannot open is worse than no button.
+		* So the fix is offered inline: the same provider-and-model picker the Role
+		* Bindings screen uses, writing through the same store, so the two surfaces
+		* cannot disagree about what a provider offers.
+		*
+		* @module @deepwatch/dsh-client-settings/chat-gate
+		*/
+		/**
+		* The placeholder an inert composer carries.
+		*
+		* The blocker's own sentence, prefixed with the capability it is about. A
+		* placeholder reading only "Not configured" leaves a person guessing which of
+		* six things is missing, which is the failure the ordered blocker list exists
+		* to prevent.
+		*/
+		function blockReason(detail) {
+			return `${ROLE_LABEL[PRIMARY_ROLE]} is not ready — ${detail}`;
+		}
+		/**
+		* The block this snapshot calls for, or undefined when the composer may open.
+		*
+		* A pure function rather than a branch inside the effect, so the decision can
+		* be tested as the decision. A test that re-derived the same condition beside
+		* the component would agree with itself and prove nothing about what a person
+		* gets.
+		*
+		* `idle` and `loading` deliberately produce nothing. Blocking a composer
+		* because an answer has not arrived yet would make every reload look like a
+		* misconfiguration — and the Host refuses an unbound route regardless, so the
+		* safe direction here is to say nothing until something is known.
+		*
+		* @param snapshot - what the store currently knows.
+		* @returns the block to raise, or undefined to lift any standing one.
+		*/
+		function blockFor(snapshot) {
+			if (snapshot.status !== "ready") return void 0;
+			const chat = chatReadiness(snapshot);
+			if (chat === null || isExecutable(chat) || chat.primaryBlocker === null) return void 0;
+			return { reason: blockReason(cardForBlocker(chat.primaryBlocker).detail) };
+		}
+		/**
+		* Raise or clear this session's composer block, and offer the way out.
+		*
+		* @param props - see {@link ChatGateProps}.
+		* @returns the setup card while Chat cannot run, and nothing once it can.
+		*/
+		function ChatGate({ sessionId, store, blocks }) {
+			const snapshot = (0, react.useSyncExternalStore)(store.subscribe, store.getSnapshot, store.getSnapshot);
+			const [open, setOpen] = (0, react.useState)(false);
+			(0, react.useEffect)(() => {
+				store.load();
+			}, [store]);
+			const chat = chatReadiness(snapshot);
+			const ready = chat !== null && isExecutable(chat);
+			const card = chat === null || chat.primaryBlocker === null ? null : cardForBlocker(chat.primaryBlocker);
+			const block = blockFor(snapshot);
+			(0, react.useEffect)(() => {
+				const registry = blocks();
+				if (registry === void 0) return;
+				registry.set(sessionId, block);
+				return () => {
+					registry.set(sessionId, void 0);
+				};
+			}, [
+				blocks,
+				sessionId,
+				block?.reason
+			]);
+			if (ready || card === null || chat === null) return null;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
+				"aria-label": `${ROLE_LABEL[PRIMARY_ROLE]} setup`,
+				style: {
+					border: "1px solid color-mix(in srgb, var(--watch-accent) 68%, var(--dsw-alias-border-l2))",
+					borderRadius: "14px",
+					padding: "15px 17px",
+					margin: "0 0 8px",
+					background: "linear-gradient(145deg, color-mix(in srgb, var(--watch-accent) 7%, var(--dsw-alias-bg-layer-2)), var(--dsw-alias-bg-base))",
+					boxShadow: "0 10px 30px color-mix(in srgb, var(--watch-accent) 9%, transparent)"
+				},
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						style: {
+							display: "flex",
+							alignItems: "baseline",
+							gap: "10px",
+							justifyContent: "space-between",
+							flexWrap: "wrap"
+						},
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", {
+							style: {
+								fontSize: "13px",
+								fontWeight: 600,
+								margin: 0
+							},
+							children: card.title
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StatusChip, {
+							tone: "neutral",
+							children: chat.status === "bound_unverified" ? "Configured · not tested" : "Not ready"
+						})]
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						style: {
+							fontSize: "12px",
+							lineHeight: 1.55,
+							margin: "6px 0 0",
+							color: "var(--dsw-alias-label-secondary)"
+						},
+						children: card.detail
+					}),
+					open ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(BindingEditor, {
+						row: {
+							role: PRIMARY_ROLE,
+							provider: null,
+							model: null,
+							readiness: chat
+						},
+						providers: snapshot.providers,
+						saving: snapshot.saving,
+						onBind: (provider, model) => {
+							store.bind(PRIMARY_ROLE, provider, model).then(() => {
+								setOpen(false);
+							});
+						},
+						onCancel: () => {
+							setOpen(false);
+						}
+					}) : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						style: CONTROL.row,
+						children: [
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+								type: "button",
+								style: CONTROL.primary,
+								disabled: !snapshot.writable || snapshot.testingRole !== null,
+								"aria-describedby": snapshot.writable ? void 0 : "watch-chat-gate-readonly",
+								onClick: () => {
+									if (chat.primaryBlocker === "provider_untested") store.testRole(PRIMARY_ROLE);
+									else setOpen(true);
+								},
+								children: snapshot.testingRole === "agent_model" ? "Testing provider…" : card.action
+							}),
+							snapshot.writable ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+								id: "watch-chat-gate-readonly",
+								style: {
+									fontSize: "12px",
+									color: "var(--dsw-alias-label-tertiary)"
+								},
+								children: "This Workspace cannot change settings here, so Chat cannot be bound from this screen. What is shown is still read from the running system."
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+								style: {
+									fontSize: "12px",
+									color: "var(--dsw-alias-label-tertiary)"
+								},
+								children: "Settings → Role Bindings has the full view."
+							})
+						]
+					})
+				]
+			});
+		}
+		//#endregion
+		//#region src/client/index.tsx
+		/**
+		* The Watch Technology & Capability Center, registered into DSH's settings.
+		*
+		* `settings.section` is a list, so these seven sit alongside DSH's General,
+		* Models and Plugins rather than replacing any of them. That is the whole
+		* arrangement: the foundation keeps its settings, and Watch adds the surfaces
+		* that make its own capabilities inspectable.
+		*
+		* The `order` values start at 20 so upstream's sections keep the top of the
+		* list, and they are grouped so the reading order tells a story — what the
+		* agent is (Intelligence), what it can perceive (Perception), what it keeps
+		* (Memory), what it can prove (Truth), and what it actually is (System).
+		*
+		* @module @deepwatch/dsh-client-settings/client
+		*/
+		/**
+		* Services this half needs before it can register anything.
+		*
+		* `connection` is what makes Role Bindings a working screen rather than a
+		* description of one: it carries the RPC face this package asks for the
+		* provider directory, the model catalogue, credential state and the stored
+		* assignments. Registering the section without it would put a control on
+		* screen that fails when pressed.
+		*/
+		const inject = [
+			"slots",
+			"connection",
+			"remote",
+			"remote.watchQuery"
+		];
+		/** One live Core reading shared by onboarding and Diagnostics. */
+		var CoreHealthStore = class {
+			reader;
+			snapshot = {
+				health: null,
+				reading: true,
+				loaded: false
+			};
+			listeners = /* @__PURE__ */ new Set();
+			generation = 0;
+			inFlight = null;
+			constructor(reader) {
+				this.reader = reader;
+			}
+			getSnapshot = () => this.snapshot;
+			subscribe = (listener) => {
+				this.listeners.add(listener);
+				return () => {
+					this.listeners.delete(listener);
+				};
+			};
+			publish(snapshot) {
+				this.snapshot = snapshot;
+				for (const listener of this.listeners) listener();
+			}
+			/**
+			* Read once, however many surfaces ask.
+			*
+			* Onboarding and Diagnostics mount independently and both need the same
+			* reading. Firing a second Core handshake because a second surface appeared
+			* is two readings that can disagree, and the one a person is looking at
+			* would be whichever landed last.
+			*/
+			ensureLoaded() {
+				if (this.snapshot.loaded || this.inFlight !== null) return;
+				this.inFlight = this.refresh().finally(() => {
+					this.inFlight = null;
+				});
+			}
+			async refresh() {
+				const generation = ++this.generation;
+				this.publish({
+					...this.snapshot,
+					reading: true
+				});
+				const reader = this.reader();
+				if (reader === null) {
+					this.publish({
+						health: null,
+						reading: false,
+						loaded: true
+					});
+					return;
+				}
+				try {
+					const result = await reader({
+						protocol: 1,
+						requestId: `req_${Date.now().toString(36)}`,
+						deadlineMs: 15e3
+					}, new AbortController().signal);
+					if (generation !== this.generation) return;
+					const report = result.ok ? result.value : null;
+					this.publish({
+						health: report?.outcome === "core_health" ? report : null,
+						reading: false,
+						loaded: true
+					});
+				} catch {
+					if (generation === this.generation) this.publish({
+						health: null,
+						reading: false,
+						loaded: true
+					});
+				}
+			}
+		};
+		/** Add the Watch sections to DSH's settings panel. */
+		function apply(ctx) {
+			const slots = ctx.slots;
+			/**
+			* The channel to the engine, looked up when Diagnostics renders.
+			*
+			* Deliberately *not* an `inject` entry. Naming `remote.watchQuery` there
+			* parks this whole plugin until the service exists, and the cost of being
+			* wrong about that is not a missing Health card — it is every Watch settings
+			* section disappearing, which is what happened: "View diagnostics" became a
+			* button that did nothing. The same mistake is recorded twenty lines below
+			* about `conversation`, and it is the same mistake.
+			*
+			* So this is read at the point of use, and its absence is a state the panel
+			* already renders honestly: "could not be read" rather than a plausible
+			* default. A screen that says it does not know beats a screen that is not
+			* there.
+			*/
+			const readHealth = () => {
+				return ctx.remote?.watchQuery?.coreHealth ?? null;
+			};
+			const runProviderTest = async (provider, model, signal) => {
+				const method = ctx.remote?.watchQuery?.providerTest;
+				if (method === void 0) throw new Error("provider test remote unavailable");
+				const result = await method({
+					protocol: 1,
+					requestId: `req_provider_${Date.now().toString(36)}`,
+					deadlineMs: 15e3,
+					provider,
+					model
+				}, signal);
+				if (!result.ok) throw new Error("provider test remote refused the request");
+				const value = result.value;
+				if (value.outcome !== "provider_test" || value.provider !== provider || value.model !== model) throw new Error("provider test returned a mismatched response");
+				return value;
+			};
+			/**
+			* The Host's verdict on a route, read rather than remembered.
+			*
+			* Shaped like `runProviderTest` and deliberately not like it: this spends
+			* nothing, reaches no provider, and is asked on every load. It is what stops
+			* a tab that has been open across a Host restart, or across an edit made
+			* somewhere else, from drawing a tested badge over a route the Host would
+			* refuse.
+			*/
+			const readRouteReadiness = async (provider, model, signal) => {
+				const method = ctx.remote?.watchQuery?.routeReadiness;
+				if (method === void 0) throw new Error("route readiness remote unavailable");
+				const result = await method({
+					protocol: 1,
+					requestId: `req_readiness_${Date.now().toString(36)}`,
+					deadlineMs: 5e3,
+					provider,
+					model
+				}, signal);
+				if (!result.ok) throw new Error("route readiness remote refused the request");
+				const value = result.value;
+				if (value.outcome !== "route_readiness" || value.provider !== provider || value.model !== model) throw new Error("route readiness returned a mismatched response");
+				return {
+					proved: value.proved,
+					reason: value.reason
+				};
+			};
+			const store = new BindingStore(ctx.get("connection").api, runProviderTest, readRouteReadiness);
+			const RoleBindingsSection = () => RoleBindings({ store });
+			const healthStore = new CoreHealthStore(readHealth);
+			const DiagnosticsWithRoles = () => {
+				const snapshot = (0, react.useSyncExternalStore)(store.subscribe, store.getSnapshot, store.getSnapshot);
+				(0, react.useEffect)(() => {
+					store.load();
+				}, []);
+				const core = (0, react.useSyncExternalStore)(healthStore.subscribe, healthStore.getSnapshot, healthStore.getSnapshot);
+				(0, react.useEffect)(() => {
+					healthStore.ensureLoaded();
+				}, []);
+				return DiagnosticsSection({
+					roles: snapshot.roles,
+					health: core.health,
+					reading: core.reading,
+					onRefresh: () => {
+						healthStore.refresh();
+					}
+				});
+			};
+			const OnboardingWithReadiness = (props) => {
+				const snapshot = (0, react.useSyncExternalStore)(store.subscribe, store.getSnapshot, store.getSnapshot);
+				const core = (0, react.useSyncExternalStore)(healthStore.subscribe, healthStore.getSnapshot, healthStore.getSnapshot);
+				(0, react.useEffect)(() => {
+					store.load();
+					healthStore.ensureLoaded();
+				}, []);
+				return WatchOnboarding({
+					...props,
+					roles: snapshot.roles,
+					health: core.health,
+					reading: core.reading
+				});
+			};
+			const section = (id, label, order, component) => {
+				slots.inject("settings.section", () => {
+					slots.register({
+						name: "settings.section",
+						id,
+						label,
+						order
+					}, component);
+				});
+			};
+			section("watch-roles", "Role Bindings", 20, RoleBindingsSection);
+			section("watch-engines", "Perception", 30, EnginesSection);
+			section("watch-sources", "Sources", 40, SourcesSection);
+			section("watch-memory", "Memory", 50, MemorySection);
+			section("watch-verification", "Verification", 60, VerificationSection);
+			section("watch-diagnostics", "Diagnostics", 70, DiagnosticsWithRoles);
+			section("watch-about", "About", 80, AboutSection);
+			const blocks = () => ctx.get("conversation")?.blocks;
+			slots.inject("conversation.input.dock", () => {
+				slots.register({
+					name: "conversation.input.dock",
+					id: "watch-chat-gate",
+					order: 5
+				}, ({ sessionId }) => ChatGate({
+					sessionId,
+					store,
+					blocks
+				}));
+			});
+			slots.inject("settings.onboarding", () => {
+				slots.register({
+					name: "settings.onboarding",
+					id: "watch-welcome",
+					order: -50
+				}, OnboardingWithReadiness);
+			});
+		}
+		//#endregion
+		exports.AboutSection = AboutSection;
+		exports.BindingEditor = BindingEditor;
+		exports.BindingStore = BindingStore;
+		exports.CONTROL = CONTROL;
+		exports.ChatGate = ChatGate;
+		exports.DEFAULT_MODEL_NAMESPACE = DEFAULT_MODEL_NAMESPACE;
+		exports.DiagnosticsSection = DiagnosticsSection;
+		exports.EnginesSection = EnginesSection;
+		exports.MemorySection = MemorySection;
+		exports.NotConfigured = NotConfigured;
+		exports.READINESS = READINESS;
+		exports.READINESS_STATUS_LABEL = READINESS_STATUS_LABEL;
+		exports.ReadinessList = ReadinessList;
+		exports.RoleBindings = RoleBindings;
+		exports.SourcesSection = SourcesSection;
+		exports.StatusChip = StatusChip;
+		exports.T = T;
+		exports.VerificationSection = VerificationSection;
+		exports.WatchOnboarding = WatchOnboarding;
+		exports.apply = apply;
+		exports.blockFor = blockFor;
+		exports.blockReason = blockReason;
+		exports.chatReadiness = chatReadiness;
+		exports.credentialRefOf = credentialRefOf;
+		exports.credentialStatusOf = credentialStatusOf;
+		exports.deriveReadiness = deriveReadiness;
+		exports.inject = inject;
+		exports.providerTestKey = providerTestKey;
+		exports.roleRowOf = roleRowOf;
+		return module.exports;
+	}
+});
+
+//# sourceMappingURL=client.js.map