machine-bridge-mcp 1.1.0 → 1.1.1

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 1.1.1 - 2026-07-15
+
+### Windows Worker deployment convergence
+
+- Make Worker health probes use the same standard `HTTP_PROXY`, `HTTPS_PROXY`, and `NO_PROXY` routing model as the relay. The previous direct `fetch` probe could time out on Windows or managed networks after Wrangler had already completed a valid deployment. Restrict probes to the recorded HTTPS `workers.dev` origin and reject redirects so persisted state cannot redirect the verifier to an arbitrary network target.
+- Persist the successful Wrangler deployment URL, content/secret fingerprint, and deployed package version before the secondary health probe. A timeout, proxy failure, TLS failure, network failure, or temporary HTTP 5xx response now stops with corrective guidance and a later start verifies the same Worker instead of uploading it again; only bounded, definitive stale-version/identity evidence triggers automatic same-name redeployment.
+- Prevent accidental Worker proliferation by rejecting a changed `--worker-name` for an initialized workspace unless `--force-worker` explicitly authorizes the replacement. Retain prior names in local inventory so full uninstall can delete intentionally replaced Workers. Add a real local CONNECT-proxy regression, deployment ambiguity/idempotency tests, worker-name replacement tests, expanded CLI/state coverage, and higher critical-module coverage floors.
+
 ## 1.1.0 - 2026-07-15
 
 ### Claude and Microsoft Copilot Studio remote MCP

package/README.md

@@ -120,6 +120,10 @@ On first remote start, the CLI:
 7. creates the initial `owner` account when needed and prints its password once;
 8. prints the Remote MCP URL.
 
+Worker deployment is convergent rather than append-only. Each workspace retains one stable Worker name. After Wrangler reports a successful upload, Machine Bridge records the Worker URL, package/secret fingerprint, and deployed version before performing the independent `/healthz` verification. A proxy, TLS, network, timeout, or temporary service failure therefore does not erase the successful deployment evidence or cause the next start to upload again. Only a bounded health result proving that the recorded Worker is stale causes an automatic redeploy under the same name.
+
+Do not append suffixes such as `-r2` to work around a health timeout: a different `--worker-name` is a different Cloudflare Worker. Changing an initialized workspace's Worker name is rejected unless the same command also supplies `--force-worker`, which makes the replacement intentional and keeps the prior name in uninstall inventory.
+
 A normal `machine-mcp` invocation is a foreground start: it remains attached to the terminal and prints `info` logs. Startup and other state-changing operations use an owner-token/process-identity lock and wait up to 30 seconds for an ordinary concurrent startup to finish instead of failing on a brief launchd/systemd race. After a global package upgrade, the CLI unloads the platform service and also checks the workspace lock for a detached/orphan `--daemon-only` process that the service manager no longer tracks. It terminates only a process whose PID, process start time, entrypoint, canonical workspace, canonical state root, and daemon-only arguments all match, waits up to 15 seconds for the PID and lock to disappear, and then starts the installed version in the foreground. A genuine foreground or unverifiable conflict is left untouched and reported with actionable guidance. To run only in the background, use `machine-mcp service start`; inspect its owner-only logs under `~/.local/state/machine-bridge-mcp/logs/`.
 
 Recommended upgrade sequence: repeat the package-free temporary-directory installation above, then run:
@@ -492,7 +496,7 @@ Default state roots:
 
 State/config writes use owner-only temporary files, `fsync`, and atomic replacement. Exclusive locks are fully written before a same-directory hard-link claim becomes visible; lock ownership includes a token and process start time so PID reuse and lock replacement cannot silently transfer ownership. Only successfully read but invalid JSON is retained as a bounded corrupt backup; permission, symbolic-link, size, encoding, and I/O failures remain explicit. A custom state root must not equal, contain, or be contained by the selected workspace. Resource source paths are redacted from `status` output. Active managed-job plans are owner-only and are deleted after a terminal result; bounded redacted results are retained temporarily. Uninstall first acquires a state-root maintenance lock that blocks new profile/state operations and state-backed operations from already constructed managed-job/browser managers, stops the platform service and all verified workspace daemons before removing definitions, rechecks jobs and locks, then validates markers, canonical paths, workspace/source exclusions, and known contents before recursive deletion.
 
-The relay honors standard `HTTP_PROXY`, `HTTPS_PROXY`, and `NO_PROXY` environment routing. Invalid or unsupported proxy configuration fails fast; runtime status reports only `direct`, `proxy`, or `invalid-proxy-configuration`, never proxy URLs or credentials.
+Worker health probes and the relay honor standard `HTTP_PROXY`, `HTTPS_PROXY`, and `NO_PROXY` environment routing. Invalid or unsupported proxy configuration fails fast. Health and relay diagnostics report only coarse `direct`, `proxy`, or invalid-route state and never proxy URLs or credentials.
 
 Default foreground logs report authenticated relay readiness, readable persistent-degradation summaries, and recovery rather than raw WebSocket callbacks or JSON field dumps. Brief self-healing disconnects and close codes/reasons are debug-only. Stalled connection attempts have a deadline, and sustained-outage reminders use autonomous exponential backoff. Every per-tool event—including success, failure, cancellation, and slow-call timing—also appears only at `--log-level debug` or `--verbose`. Background services use `warn`, so ordinary tool outcomes and brief network changes do not fill daemon logs. Log messages and structured fields are bounded, secret-like keys and known token formats are redacted, and tool arguments/results are not written. See [docs/LOGGING.md](docs/LOGGING.md) and [docs/OPERATIONS.md](docs/OPERATIONS.md).
 

package/browser-extension/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "Machine Bridge Browser",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Connects the current Chromium browser profile to the local Machine Bridge runtime for user-authorized automation.",
   "permissions": [
     "tabs",
@@ -30,5 +30,5 @@
   "action": {
     "default_title": "Machine Bridge Browser"
   },
-  "version_name": "1.1.0"
+  "version_name": "1.1.1"
 }

package/docs/ARCHITECTURE.md

@@ -211,9 +211,17 @@ Child processes run in a separate process group where supported. Timeout, cancel
 
 Managed jobs use the same argv/environment primitives but a different lifecycle. Each job is capped at 16 main and 16 finally steps, 50 retained jobs, 64 registered resources, 8 MiB of referenced resource bytes, 512 KiB of temporary-file content, and bounded per-step output. They are non-interactive. Resource paths/stdin/environment are injected only inside the runner. Exact resource output redaction is defense in depth; discard capture is the strong option when a command may echo credentials.
 
+## Worker deployment convergence
+
+Worker deployment is an explicit two-evidence state machine owned by `worker-deployment.mjs`. Wrangler upload is the authoritative remote write. Public `/healthz` is a subsequent read used to verify identity and package version; it is not a transaction commit signal for the upload. After a successful Wrangler result, local state atomically records the detected `workers.dev` URL, MCP URL, content/secret fingerprint, deployed package version, and timestamp before health verification begins. If verification is ambiguous, the next start compares the same fingerprint and performs a read-only verification rather than repeating the remote write.
+
+`worker-health.mjs` owns bounded health I/O: exact HTTPS `workers.dev` origin and Worker-name validation, environment-proxy selection, request timeout, redirect rejection, response-size limit, JSON/identity/version validation, and coarse error classification. `network-proxy.mjs` is shared by HTTP health probes and WebSocket relay construction so both paths honor `HTTP_PROXY`, `HTTPS_PROXY`, and `NO_PROXY` without exposing proxy details. Definitive stale evidence is retried for propagation and then permits a same-name redeploy; timeout, TLS, network, proxy, and temporary server failure remain ambiguous and fail without upload.
+
+Worker-name mutation is a separate identity transition. Existing state rejects a different name unless the caller also supplies the explicit force option. An authorized transition clears the current URL/fingerprint and appends the prior validated name to bounded uninstall inventory. This prevents a health-retry workaround from silently becoming a new remote resource while preserving cleanup of intentional replacements.
+
 ## Daemon reconnect and replacement
 
-The local `RelayConnection` treats proxy selection, transport construction, transport open, authenticated readiness, and outage recovery as separate states. `network-proxy.mjs` maps WebSocket targets to standard HTTP(S) environment-proxy resolution, honors `NO_PROXY`, rejects non-HTTP(S) proxy schemes, and creates the proxy agent without exposing its URL or credentials. Invalid proxy configuration is a fatal configuration error rather than a retryable outage.
+The local `RelayConnection` treats proxy selection, transport construction, transport open, authenticated readiness, and outage recovery as separate states. The shared proxy module maps WebSocket targets to standard HTTP(S) environment-proxy resolution, honors `NO_PROXY`, rejects non-HTTP(S) proxy schemes, and creates the proxy agent without exposing its URL or credentials. Invalid proxy configuration is a fatal configuration error rather than a retryable outage.
 
 The local `RelayConnection` otherwise treats transport construction, transport open, authenticated readiness, and outage recovery as separate states. A connection-attempt deadline terminates sockets stuck in `CONNECTING`; after WebSocket open it sends `hello` and reports readiness only after `hello_ack`. A missing acknowledgement reaches a distinct handshake deadline and the candidate is terminated. Once ready, application heartbeats require inbound activity; a silent half-open socket is terminated and reconnected. Outage reminders run on their own exponential-backoff timer rather than depending on another transport callback.
 

package/docs/AUDIT.md

@@ -1,5 +1,15 @@
 # Engineering and security audit
 
+## 2026-07-15 Windows Worker deployment convergence incident
+
+A Windows report showed Wrangler creating a Worker successfully, followed by `Worker deployment did not become healthy at the expected version: timeout`. Re-running startup, and then changing the name to a suffixed `-r2` variant, left multiple Workers in the Cloudflare account. The causal defect was not Worker creation itself: Wrangler and the long-lived relay already followed standard proxy routing, while the independent health verifier used a direct global `fetch`. On networks where outbound HTTPS required an environment proxy, deployment could succeed and health verification could time out.
+
+The state transition amplified that routing split. The previous path removed or withheld the deployment fingerprint until `/healthz` succeeded. A successful remote write followed by an ambiguous read therefore looked identical to “not deployed” on the next start and caused another Wrangler upload. Supplying another `--worker-name` made the effect more visible by asking Cloudflare for a distinct resource; Machine Bridge did not generate the suffix automatically, but it also did not guard that identity change.
+
+The correction separates upload evidence from verification evidence. `worker-deployment.mjs` persists the detected URL, exact content/secret fingerprint, deployed package version, and timestamp immediately after Wrangler success. `worker-health.mjs` accepts only the recorded HTTPS `workers.dev` origin matching the Worker name, rejects redirects, and performs the bounded request through the same reviewed proxy resolver used by the WebSocket path, with response-size and deadline limits. A subsequent timeout, proxy/TLS/network fault, or temporary 5xx now returns an actionable verification error while preserving the fingerprint, so the next start performs a read-only verification. Persistent version/identity mismatch or `404`/`410` is retried for propagation and is the only automatic same-name redeployment trigger.
+
+Existing Worker names are stable. A different `--worker-name` is rejected unless `--force-worker` explicitly authorizes an identity replacement; the prior validated name is retained in bounded uninstall inventory. The test reproduces the original network topology with a real local CONNECT proxy and an otherwise unresolvable hostname, proves one deployment across repeated health timeouts, proves stale-version convergence, and covers accidental/intentional name transitions. Coverage gates now include the extracted proxy, health, and deployment modules and raise the remaining CLI floors. Live duplicate deletion remains an operator decision because repository code cannot safely infer which pre-fix Worker is externally referenced.
+
 ## 2026-07-15 hosted-client OAuth interoperability audit
 
 The Claude and Microsoft Copilot Studio request was first tested against the existing protocol boundary rather than implemented as a brand allowlist. Both clients already use the deployed Streamable HTTP endpoint; the material gap was token continuity. Anthropic's connector contract advertises `offline_access`, performs form-encoded refreshes, and requires public-client refresh-token rotation. Copilot Studio's recommended Dynamic discovery path likewise discovers DCR/OAuth endpoints and exchanges refresh tokens. Adding browser origins alone would not implement either contract: Claude remote connectors originate from Anthropic cloud infrastructure, while Copilot Studio uses Power Platform connectivity. The fixed ChatGPT/Grok browser CORS set therefore remains unchanged.

package/docs/ENGINEERING.md

@@ -18,6 +18,7 @@ This document records project-wide decisions that must survive individual fixes,
 12. **Read failure is not empty state.** Permission, type, symbolic-link, size, encoding, and I/O errors must propagate. Corrupt backup/reconstruction applies only after a successful read proves that JSON content is invalid.
 13. **The public protocol contract is current-only.** Shared metadata advertises only the current MCP protocol version. Compatibility code for obsolete protocol dates, lock formats, or state schemas is not retained in the final runtime; upgrade safety comes from explicit version negotiation, fail-closed state validation, and bounded operator convergence.
 14. **Security analysis is a failing gate.** CodeQL or Scorecard execution alone is not success. Generated SARIF must contain no unaccepted result, and missing rule metadata fails closed rather than being interpreted as non-security. An intentional or externally constrained finding requires an exact rule/path record with a substantive rationale and an expiry date.
+15. **Ambiguous health is not permission to repeat a remote write.** A successful Wrangler deployment is recorded before secondary health verification. Timeout, proxy, TLS, network, and temporary service failures preserve the deployment fingerprint and fail for diagnosis; only bounded evidence of a stale identity/version permits automatic same-name redeployment. Changing the Worker name is an explicit remote-resource transition, not a retry strategy.
 
 A proposed change that conflicts with an invariant requires an explicit owner decision and corresponding documentation update. It must not be hidden inside an unrelated refactor.
 
@@ -109,7 +110,7 @@ A higher branch count is acceptable only when the function is an explicit state
 
 - Preserve a stable coarse error class for automation and a concise human message for operators.
 - Do not retry an operation merely because it failed; retry only when the error is positively classified as transient and the operation is idempotent or server state is checked after ambiguity.
-- When a remote write may have succeeded before the response was lost, query authoritative state before repeating it.
+- When a remote write may have succeeded before the response was lost, query authoritative state before repeating it. When the write itself returned success but a later verification read failed, persist the successful write evidence before returning the verification error.
 - Duration-based deadlines must use a monotonic clock. Wall time remains appropriate for persisted timestamps, credential expiry, retention, and operator-visible dates, but a system clock correction must not extend or prematurely terminate an in-process wait.
 - Timeouts must terminate the relevant process tree. Forced escalation must remain referenced until resistant descendants are handled; do not clear it merely because the direct child exited.
 - Half-open connections need liveness detection, not only periodic writes.

package/docs/GETTING_STARTED.md

@@ -140,6 +140,7 @@ Common installation failures:
 | `Invalid property "node"` or `Invalid property "devEngines.node"` | An old npm parser inspected incompatible project metadata | Run the install from a new empty temporary directory |
 | `machine-mcp: command not found` | The global npm binary directory is not on `PATH` | Reopen the terminal, inspect `npm prefix -g`, and add its binary directory to `PATH` |
 | Native package install warning | npm did not approve reviewed native build scripts | Use the documented `--allow-scripts` and `--omit=optional` command exactly |
+| Worker deployment completed, then health verification timed out | The independent `/healthz` route is blocked, mis-proxied, or temporarily unavailable; the upload may already be valid | Keep the recorded Worker name, run `machine-mcp status` and `machine-mcp doctor` from the same proxy environment, then retry normally. Do not invent a suffixed `--worker-name`; the saved fingerprint prevents a duplicate upload. |
 
 ## 6. First remote start
 
@@ -168,6 +169,8 @@ The first start performs these operations:
 
 The foreground command remains attached to the terminal. Keep it running while testing. The remote Worker cannot execute local tools when no authenticated daemon is connected.
 
+The Worker name is a persistent workspace identity, not a retry counter. A successful Wrangler upload is recorded before health verification, so a later timeout does not require a new name and does not make the next start upload again. Supplying a different `--worker-name` for an initialized workspace requires `--force-worker` because it intentionally creates/replaces a separate Cloudflare Worker identity.
+
 To run only in the background after setup:
 
 ```sh

package/docs/LOGGING.md

@@ -33,6 +33,12 @@ Foreground mode defaults to `info` and human-readable text. Platform autostart s
 | `info` | Deployment/startup transitions, authenticated relay readiness, and recovery after a visible outage |
 | `debug` | Transport open/close codes and reasons, brief self-healing interruptions, retry timing, per-tool outcomes, and shortened correlation IDs |
 
+## Worker deployment and health event policy
+
+Wrangler upload and `/healthz` verification are logged as separate state transitions. A successful upload followed by ambiguous health failure must say that the deployment fingerprint was retained and that retry will verify rather than redeploy. Existing-state timeout, proxy, TLS, network, and temporary server failures must say that no deployment was attempted. Only a persistent stale identity/version result may emit the warning that the same Worker is being redeployed.
+
+Health routing records only `direct` or `proxy` at debug level. Proxy URLs, credentials, request headers, Worker secrets, and raw response bodies are never fields. Repeated per-attempt health failures remain debug-only; the terminal startup error contains one user-readable classification and corrective commands.
+
 ## Relay connection event policy
 
 A TCP/WebSocket `open` event is only transport availability. The daemon is reported as connected only after the Worker returns `hello_ack` for the authenticated `hello` message.

package/docs/OPERATIONS.md

@@ -10,6 +10,24 @@ machine-mcp service status
 
 `status` prints redacted profile state and verifies the deployed Worker version. Resource source paths remain redacted. `doctor` checks Node.js, the package-installed Wrangler binary, Cloudflare login, Worker health, and the same fixed local filesystem/process/shell/job-storage/resource probes exposed by `diagnose_runtime`. Public `/healthz` output contains only server identity and version; daemon details require an authenticated `server_info` call.
 
+### Worker deployment and health convergence
+
+Wrangler upload and public health verification are two separate observations. Once Wrangler reports a successful deployment and supplies the `workers.dev` URL, Machine Bridge immediately records that URL together with the exact deployment fingerprint and package version. It then verifies `/healthz` through the standard `HTTPS_PROXY`/`HTTP_PROXY` and `NO_PROXY` environment route. If that secondary probe times out or encounters a proxy, TLS, network, or temporary HTTP 5xx failure, startup stops with an actionable error, but the successful deployment evidence remains. The next ordinary start verifies the same Worker and does not repeat the upload.
+
+Automatic redeployment is limited to bounded health evidence that the recorded endpoint is genuinely stale: a persistent package-version mismatch, an unexpected Machine Bridge identity, or a persistent `404`/`410`. Unreachability is not proof of absence. `--force-worker` remains the explicit override when an operator deliberately wants an upload despite matching state.
+
+Each workspace has one stable Worker name. A command that supplies a different `--worker-name` after initialization is rejected unless `--force-worker` is present. A name such as `mbm-example-r2` is a separate Cloudflare Worker, not a revision of `mbm-example`. If an older release already created duplicates, first run `machine-mcp status` and verify the active URL/name, then remove only the confirmed unused Workers in the Cloudflare dashboard or with Wrangler. Source upgrades do not delete ambiguous live deployments automatically.
+
+For a health timeout on Windows or a managed network:
+
+```powershell
+machine-mcp status
+machine-mcp doctor
+machine-mcp --verbose
+```
+
+Run these commands from the same environment used for startup so `HTTPS_PROXY`, `HTTP_PROXY`, and `NO_PROXY` are identical. Debug logs expose only the selected route and classified error; they never print a proxy endpoint or credentials.
+
 ### Blocking-layer decision table
 
 | Result | Interpretation |

package/docs/TESTING.md

@@ -24,6 +24,8 @@ The suite includes:
 - foreground takeover of active and orphaned background daemons with current service-lock metadata, foreground-process protection, bounded final lock-handoff retry, actual-PID exit waiting, POSIX non-escalating timeout behavior, Windows verified-daemon stop semantics, daemon lock mode/version/process-start metadata, launchd service-target semantics, and silent idempotent duplicate service starts; daemon fixture subprocesses intentionally do not inherit V8 coverage because their purpose is ownership timing rather than code measurement;
 - fail-closed service lifecycle ordering for provider-stop, all-workspace daemon-stop, and definition removal, including platform/daemon/removal failure injection and normalized macOS/systemd/Windows results;
 - machine-level browser-broker ownership/client proxying, authenticated extension origin/subprotocol, non-cacheable local pairing, pairing-token non-disclosure, resource-backed upload routing, broker result redaction, pre-registered runtime-handshake listeners, bounded socket/HTTP waits, frozen-wall-clock browser deadline coverage, installed-application discovery caching, and name-based task matching;
+- Worker health direct/proxy routing through a real local HTTP CONNECT proxy, `NO_PROXY` bypass, exact `workers.dev` origin/name validation, redirect rejection, body/deadline bounds, error classification, bounded propagation retry, and invalid proxy fail-fast behavior without endpoint or credential disclosure;
+- Worker deployment ambiguity/idempotency: a successful Wrangler result followed by health timeout persists the fingerprint, a second start performs no upload, definitive stale-version evidence redeploys under the same name, accidental name changes are rejected, forced replacements clear current endpoint state, and prior names remain in uninstall inventory;
 - relay environment-proxy direct/bypass/agent selection, unsupported proxy rejection, fail-fast invalid configuration, and route observability without endpoint or credential disclosure;
 - canonical path and symbolic-link escape tests;
 - relative-path privacy and error-path redaction tests;
@@ -74,7 +76,7 @@ For deterministic release validation, perform an isolated-profile smoke test wit
 
 `npm run coverage:test` runs selected in-process and lightweight entrypoint fixtures under V8 coverage and enforces per-module baselines for policy, typed errors, call registration, execution middleware, lifecycle/observability, logging, Runtime/CLI orchestration, and Worker pending/policy/error modules. The full stdio and Worker OAuth/MCP integrations run separately in the main suite and are not duplicated inside coverage collection. The gate deliberately reports each module rather than one aggregate percentage. JavaScript modules enforce function and branch minima; Node's direct TypeScript stripping does not expose trustworthy branch ranges, so TypeScript modules enforce function coverage plus explicit state-machine tests and the real workerd integration suite.
 
-The current CLI entrypoint remains the weakest covered orchestration surface; its baseline is therefore reported and locked independently, while extracted `cli-options`, `cli-policy`, `records`, and `state-inventory` modules carry substantially higher thresholds. The state-inventory extraction raised the CLI branch floor from 5% to 10%; a refactor may raise a threshold, but must not lower one merely to make CI green without an explicit audit explanation.
+The current CLI entrypoint remains the weakest covered orchestration surface; its baseline is therefore reported and locked independently, while extracted `cli-options`, `cli-policy`, `records`, `state-inventory`, `network-proxy`, `worker-health`, and `worker-deployment` modules carry substantially higher thresholds. The Worker convergence extraction and expanded command fixtures raised the CLI function floor from 40% to 45% and branch floor from 10% to 20%; a refactor may raise a threshold, but must not lower one merely to make CI green without an explicit audit explanation.
 
 ## Additional release checks
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "machine-bridge-mcp",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Cross-client MCP bridge for local agent context, structured browser and application automation, files, Git, processes, resources, and durable jobs over stdio or OAuth relay.",
   "type": "module",
   "license": "MIT",
@@ -43,7 +43,7 @@
     "worker:types": "node scripts/generate-worker-types.mjs",
     "typecheck": "npm run worker:types && tsc -p tsconfig.json --noEmit",
     "syntax": "node scripts/syntax-check.mjs",
-    "check": "npm run privacy:check && npm run privacy:test && npm run release-impact:check && npm run release-impact:test && npm run release-state:test && npm run release-ci:test && npm run network-retry:test && npm run relay:test && npm run secure-file:test && npm run worker-secret-file:test && npm run sarif-security:test && npm run security-properties:test && npm run shell:test && npm run architecture:test && npm run markdown:test && npm run project-metadata:test && npm run numbers:test && npm run records:test && npm run state-inventory:test && npm run commit-message:test && npm run policy:test && npm run account:test && npm run policy-docs:check && npm run tool-docs:check && npm run runtime-infrastructure:test && npm run runtime-handlers:test && npm run cli-entrypoint:test && npm run lifecycle:test && npm run logging-structure:test && npm run coverage:test && npm run worker-runtime-infrastructure:test && npm run lint:test && npm run lint && npm run typecheck && npm run syntax && npm run deadline:test && npm run process-lock:test && npm run service-lifecycle:test && npm run service-platform:test && npm run catalog:test && npm run agent-context:test && npm run capability-ranking:test && npm run browser-command:test && npm run browser-devtools-input:test && npm run browser-service-worker:test && npm run browser-page-automation:test && npm run browser-bridge:test && npm run app-automation:test && npm run self-test && npm run atomic-fs:test && npm run package:test && npm run install:test && npm run ssh-key:test && npm run full-access:test && npm run managed-jobs:test && npm run stdio:integration-test && npm run worker:integration-test && npm run oauth-browser:test",
+    "check": "npm run privacy:check && npm run privacy:test && npm run release-impact:check && npm run release-impact:test && npm run release-state:test && npm run release-ci:test && npm run network-retry:test && npm run worker-deployment:test && npm run relay:test && npm run secure-file:test && npm run worker-secret-file:test && npm run sarif-security:test && npm run security-properties:test && npm run shell:test && npm run architecture:test && npm run markdown:test && npm run project-metadata:test && npm run numbers:test && npm run records:test && npm run state-inventory:test && npm run commit-message:test && npm run policy:test && npm run account:test && npm run policy-docs:check && npm run tool-docs:check && npm run runtime-infrastructure:test && npm run runtime-handlers:test && npm run cli-entrypoint:test && npm run lifecycle:test && npm run logging-structure:test && npm run coverage:test && npm run worker-runtime-infrastructure:test && npm run lint:test && npm run lint && npm run typecheck && npm run syntax && npm run deadline:test && npm run process-lock:test && npm run service-lifecycle:test && npm run service-platform:test && npm run catalog:test && npm run agent-context:test && npm run capability-ranking:test && npm run browser-command:test && npm run browser-devtools-input:test && npm run browser-service-worker:test && npm run browser-page-automation:test && npm run browser-bridge:test && npm run app-automation:test && npm run self-test && npm run atomic-fs:test && npm run package:test && npm run install:test && npm run ssh-key:test && npm run full-access:test && npm run managed-jobs:test && npm run stdio:integration-test && npm run worker:integration-test && npm run oauth-browser:test",
     "worker:dry-run": "wrangler deploy --dry-run",
     "worker:integration-test": "node tests/worker-integration-test.mjs",
     "release:check": "node scripts/github-release.mjs --check",
@@ -107,7 +107,8 @@
     "lint:test": "node tests/lint-gate-test.mjs",
     "shell:test": "node tests/shell-test.mjs",
     "deadline:test": "node tests/monotonic-deadline-test.mjs",
-    "oauth-browser:test": "node tests/oauth-browser-navigation-test.mjs"
+    "oauth-browser:test": "node tests/oauth-browser-navigation-test.mjs",
+    "worker-deployment:test": "node tests/worker-deployment-test.mjs"
   },
   "dependencies": {
     "https-proxy-agent": "9.1.0",

package/scripts/coverage-check.mjs

@@ -18,6 +18,7 @@ const tests = [
   "tests/records-test.mjs",
   "tests/project-metadata-test.mjs",
   "tests/state-inventory-test.mjs",
+  "tests/worker-deployment-test.mjs",
 ];
 
 try {
@@ -45,13 +46,16 @@ try {
     "src/local/process-tracker.mjs": [65, 35],
     "src/local/log.mjs": [60, 40],
     "src/local/runtime.mjs": [60, 35],
-    "src/local/cli.mjs": [40, 10],
+    "src/local/cli.mjs": [45, 20],
     "src/local/cli-options.mjs": [65, 35],
     "src/local/cli-policy.mjs": [70, 35],
     "src/local/numbers.mjs": [100, 100],
     "src/local/records.mjs": [100, 100],
     "src/local/project-metadata.mjs": [85, 55],
-    "src/local/state-inventory.mjs": [80, 50],
+    "src/local/state-inventory.mjs": [85, 55],
+    "src/local/network-proxy.mjs": [90, 65],
+    "src/local/worker-health.mjs": [85, 60],
+    "src/local/worker-deployment.mjs": [80, 55],
     "src/worker/pending-calls.ts": [85, null],
     "src/worker/policy.ts": [90, null],
     "src/worker/errors.ts": [100, null],

package/src/local/cli-options.mjs

@@ -22,7 +22,7 @@ const COMMAND_OPTIONS = {
   status: new Set(["workspace", "stateDir"]),
   doctor: new Set(["workspace", "stateDir"]),
   "full-test": new Set(["workspace", "stateDir", "json"]),
-  "rotate-secrets": new Set(["workspace", "stateDir", "workerName", "quiet"]),
+  "rotate-secrets": new Set(["workspace", "stateDir", "quiet"]),
   workspace: new Set(["workspace", "stateDir"]),
   service: new Set(["workspace", "stateDir", "quiet"]),
   autostart: new Set(["workspace", "stateDir", "quiet"]),

package/src/local/cli.mjs

@@ -1,6 +1,5 @@
-import { createHmac } from "node:crypto";
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
-import path, { join, resolve } from "node:path";
+import { readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
 import process from "node:process";
 import readline from "node:readline/promises";
 import { LocalRuntime } from "./runtime.mjs";
@@ -19,12 +18,13 @@ import { classifyOperationalError, createLogger, sanitizeLogText } from "./log.m
 import { runExecutable, runWrangler } from "./shell.mjs";
 import { runFullAccessTest } from "./full-access-test.mjs";
 import { stopAndRemoveAutostart } from "./service-lifecycle.mjs";
+import { ensureWorkerDeployment } from "./worker-deployment.mjs";
+import { workerHealth } from "./worker-health.mjs";
+export { workerHealthUserReason } from "./worker-health.mjs";
 import { activeStateJobs, activeStateLocks, knownProfileStates, knownWorkerNames } from "./state-inventory.mjs";
-import { withWorkerSecretsFile } from "./worker-secret-file.mjs";
 import {
   acquireMaintenanceLock,
   acquireStartupLockWithWait,
-  appName,
   daemonLockPathForState,
   defaultFirstRunWorkspace,
   defaultStateRoot,
@@ -225,7 +225,7 @@ function reportExistingDaemon(args, state, owner, logger) {
   logger.plain(`  Workspace: ${state.workspace.path}`);
 }
 
-function isIdempotentDaemonOnlyStart(args) {
+export function isIdempotentDaemonOnlyStart(args) {
   if (!args.daemonOnly || args.json) return false;
   return !Boolean(
     args.profile
@@ -258,7 +258,11 @@ async function startRemoteRuntime({ args, workspace, state, daemonLock, logger }
 
 async function prepareRemoteState({ args, workspace, state, logger }) {
   const workerName = validateWorkerName(args.workerName);
-  ensureWorkerSecrets(state, { rotateSecrets: Boolean(args.rotateSecrets), workerName });
+  ensureWorkerSecrets(state, {
+    rotateSecrets: Boolean(args.rotateSecrets),
+    workerName,
+    allowWorkerRename: Boolean(args.forceWorker),
+  });
   state.policy = resolvePolicy(args, state.policy);
   state.policy.updatedAt = new Date().toISOString();
   saveState(state);
@@ -366,146 +370,9 @@ async function clientConfigCommand(args) {
 
 async function ensureWorker(state, args) {
   const logger = createLogger({ level: args.json ? "error" : effectiveLogLevel(args), format: effectiveLogFormat(args), component: "worker" });
-  const desiredHash = workerDeploymentFingerprint(state);
-  const expectedVersion = currentPackageVersion();
-  const complete = state.worker.url && state.worker.mcpServerUrl && state.worker.accountAdminSecret && state.worker.daemonSecret && state.worker.oauthTokenVersion && state.worker.name;
-  if (!args.forceWorker && !args.rotateSecrets && complete && state.worker.deployHash === desiredHash) {
-    const health = await workerHealth(state.worker.url, expectedVersion);
-    if (health.ok) {
-      logger.success("Worker unchanged and healthy", { url: state.worker.url });
-      return state.worker;
-    }
-    logger.warn("Worker is not healthy at the expected version; redeploying automatically", { reason: workerHealthUserReason(health.error) });
-    logger.debug("Worker health check detail", { health_error: health.error });
-  }
-
-  logger.info("Checking Cloudflare Wrangler login");
-  const whoami = await runWrangler(["whoami"], { capture: true, allowFailure: true });
-  if (whoami.code !== 0) {
-    logger.info("Wrangler is not logged in; opening Cloudflare login");
-    await runWrangler(["login"]);
-  }
-
-  logger.info("Deploying Cloudflare Worker", { name: state.worker.name });
-  const deploy = await withWorkerSecretsFile(state, secretFile => runWrangler([
-    "deploy",
-    "--name", state.worker.name,
-    "--minify",
-    "--keep-vars",
-    "--secrets-file", secretFile,
-  ], { capture: true }));
-
-  const workerUrl = extractWorkerUrl(deploy.stdout) || extractWorkerUrl(deploy.stderr) || state.worker.url;
-  if (!workerUrl) throw new Error("Worker deployed but URL could not be detected. Re-run with --worker-name or inspect Wrangler output.");
-  state.worker.url = workerUrl.replace(/\/+$/, "");
-  state.worker.mcpServerUrl = `${state.worker.url}/mcp`;
-  delete state.worker.deployHash;
-  state.worker.updatedAt = new Date().toISOString();
-  saveState(state);
-
-  const health = await retryHealth(state.worker.url, expectedVersion, 8);
-  if (!health.ok) {
-    throw new Error(`Worker deployment did not become healthy at the expected version: ${health.error}`);
-  }
-  state.worker.deployHash = desiredHash;
-  saveState(state);
-  logger.success("Worker ready", { url: state.worker.url, version: health.version });
-  return state.worker;
-}
-
-
-function workerDeploymentFingerprint(state) {
-  const keyMaterial = [
-    String(state.worker.accountAdminSecret || ""),
-    String(state.worker.daemonSecret || ""),
-    String(state.worker.oauthTokenVersion || ""),
-  ].join("\0");
-  const fingerprint = createHmac("sha256", keyMaterial);
-  fingerprint.update("mbm-worker-deploy-v3");
-  fingerprint.update(String(state.worker.name || ""));
-  for (const file of workerDeployHashFiles()) {
-    fingerprint.update(path.relative(packageRoot, file));
-    fingerprint.update(workerHashContent(file));
-  }
-  return fingerprint.digest("hex");
-}
-
-function workerHashContent(file) {
-  return readFileSync(file, "utf8");
-}
-
-function workerDeployHashFiles() {
-  const files = [];
-  for (const item of ["src/worker", "src/shared", "wrangler.jsonc", "tsconfig.json"]) {
-    collectHashFiles(resolve(packageRoot, item), files);
-  }
-  return files.sort();
+  return ensureWorkerDeployment(state, args, { logger });
 }
 
-function collectHashFiles(target, out) {
-  if (!existsSync(target)) return;
-  const info = statSync(target);
-  if (info.isFile()) {
-    if (/\.(ts|js|mjs|json|jsonc|yaml|yml|lock)$/.test(target)) out.push(target);
-    return;
-  }
-  if (!info.isDirectory()) return;
-  for (const entry of readdirSync(target, { withFileTypes: true })) {
-    if (entry.name === "node_modules" || entry.name === ".wrangler" || entry.name.endsWith(".d.ts")) continue;
-    collectHashFiles(resolve(target, entry.name), out);
-  }
-}
-
-async function workerHealth(workerUrl, expectedVersion = currentPackageVersion()) {
-  if (!workerUrl) return { ok: false, error: "missing_worker_url" };
-  try {
-    const response = await fetch(`${String(workerUrl).replace(/\/+$/, "")}/healthz`, { signal: AbortSignal.timeout(5000) });
-    if (!response.ok) return { ok: false, error: `HTTP ${response.status}` };
-    const body = await response.json().catch(() => null);
-    if (body?.ok !== true || body?.server !== appName) return { ok: false, error: "unexpected_health_response" };
-    if (body?.version !== expectedVersion) return { ok: false, error: `version_mismatch:${body?.version || "unknown"}!=${expectedVersion}` };
-    return { ok: true, version: body.version };
-  } catch (error) {
-    return { ok: false, error: workerHealthError(error) };
-  }
-}
-
-export function workerHealthUserReason(value) {
-  const reason = String(value || "");
-  if (reason.startsWith("version_mismatch:")) return "deployed version does not match the local package";
-  if (/^HTTP \d+$/.test(reason)) return "health endpoint returned an HTTP error";
-  if (reason === "unexpected_health_response") return "health endpoint returned an unexpected response";
-  if (reason === "timeout") return "health check timed out";
-  if (reason === "tls_error") return "TLS validation failed";
-  if (reason === "network_error") return "network request failed";
-  if (reason === "missing_worker_url") return "Worker URL is missing";
-  return "health check failed";
-}
-
-function workerHealthError(error) {
-  const message = String(error?.message || error || "");
-  if (/timeout|aborted/i.test(message)) return "timeout";
-  if (/certificate|TLS|SSL/i.test(message)) return "tls_error";
-  if (/fetch failed|network|ECONN|ENOTFOUND|EAI_AGAIN/i.test(message)) return "network_error";
-  return "request_failed";
-}
-
-async function retryHealth(workerUrl, expectedVersion, attempts) {
-  let last = { ok: false, error: "not_checked" };
-  for (let i = 0; i < attempts; i += 1) {
-    last = await workerHealth(workerUrl, expectedVersion);
-    if (last.ok) return last;
-    await sleep(1000 + i * 500);
-  }
-  return last;
-}
-
-function extractWorkerUrl(text = "") {
-  const matches = [...String(text).matchAll(/https:\/\/[^\s"'<>]+\.workers\.dev[^\s"'<>]*/g)];
-  if (matches.length) return matches.at(-1)[0].replace(/[),.]+$/, "");
-  const anyHttps = [...String(text).matchAll(/https:\/\/[^\s"'<>]+/g)];
-  return anyHttps.find(match => /workers\.dev|\/healthz|\/mcp/.test(match[0]))?.[0]?.replace(/[),.]+$/, "") || "";
-}
 
 function printStartJson(state, { requestedChangesApplied = true, notice = "", initialOwner = null } = {}) {
   createLogger({ component: "ready" }).json({
@@ -566,7 +433,7 @@ async function statusCommand(args) {
   const workspace = await chooseWorkspace(args, { promptOnFirstRun: false, save: false, allowPositional: true });
   const state = loadState(workspace, { stateDir: args.stateDir });
   state.policy = resolvePolicy({}, state.policy);
-  const health = state.worker?.url ? await workerHealth(state.worker.url) : { ok: false, error: "no worker url" };
+  const health = state.worker?.url ? await workerHealth(state.worker.url, currentPackageVersion(), { expectedWorkerName: state.worker.name }) : { ok: false, error: "no worker url" };
   const payload = {
     ...redactState(state),
     workerHealth: health,
@@ -597,7 +464,7 @@ async function doctorCommand(args) {
       checks.push({ name: "full-policy-contract", ok: false, detail: sanitizeLines(error?.message || error) });
     }
   }
-  const health = state.worker?.url ? await workerHealth(state.worker.url) : { ok: false, error: "no worker url" };
+  const health = state.worker?.url ? await workerHealth(state.worker.url, currentPackageVersion(), { expectedWorkerName: state.worker.name }) : { ok: false, error: "no worker url" };
   checks.push({ name: "worker-health", ok: health.ok, detail: health.ok ? state.worker.url : health.error });
   const diagnosticRuntime = new LocalRuntime({
     workspace,
@@ -656,7 +523,7 @@ async function rotateSecretsCommand(args) {
     if (daemonIdentity?.current) {
       throw new Error(`refusing to rotate secrets while the daemon is active (pid ${daemonOwner.pid}); stop the foreground daemon and retry`);
     }
-    ensureWorkerSecrets(state, { rotateSecrets: true, workerName: validateWorkerName(args.workerName) });
+    ensureWorkerSecrets(state, { rotateSecrets: true });
     saveState(state);
     console.log("Rotated account administration, daemon, and global token-version secrets.");
     console.log("All account access tokens are invalid. Run machine-mcp to redeploy, then reconnect clients.");
@@ -963,8 +830,8 @@ Commands:
 
 Start options:
   --workspace PATH      Use and remember this workspace path
-  --worker-name NAME    Worker name (default: mbm-<workspace-hash>)
-  --force-worker        Force wrangler deploy even if hash and health match
+  --worker-name NAME    Worker name (default: mbm-<workspace-hash>); changing an existing name requires --force-worker
+  --force-worker        Force same-name deployment, or explicitly allow an intentional --worker-name replacement
   --rotate-secrets      Rotate secrets before deploying
   --daemon-only         Skip deploy and only connect daemon from existing state
   --no-autostart        Do not install login autostart during start

package/src/local/network-proxy.mjs

@@ -1,21 +1,39 @@
 import { HttpsProxyAgent } from "https-proxy-agent";
 import { getProxyForUrl } from "proxy-from-env";
 
+const HTTP_PROTOCOLS = new Set(["http:", "https:"]);
+
 export function proxyAgentForWebSocket(webSocketUrl, proxyResolver = getProxyForUrl) {
   const target = new URL(String(webSocketUrl));
   if (target.protocol !== "ws:" && target.protocol !== "wss:") throw new Error("relay WebSocket URL must use ws or wss");
-  const proxyLookupUrl = new URL(target);
-  proxyLookupUrl.protocol = target.protocol === "wss:" ? "https:" : "http:";
-  const proxyValue = String(proxyResolver(proxyLookupUrl.href) || "").trim();
+  const lookupUrl = new URL(target);
+  lookupUrl.protocol = target.protocol === "wss:" ? "https:" : "http:";
+  return proxyAgentForLookup(lookupUrl, proxyResolver, {
+    errorCode: "relay_proxy_configuration",
+    subject: "relay proxy",
+  });
+}
+
+export function proxyAgentForHttp(httpUrl, proxyResolver = getProxyForUrl) {
+  const target = new URL(String(httpUrl));
+  if (!HTTP_PROTOCOLS.has(target.protocol)) throw new Error("HTTP request URL must use http or https");
+  return proxyAgentForLookup(target, proxyResolver, {
+    errorCode: "http_proxy_configuration",
+    subject: "HTTP proxy",
+  });
+}
+
+function proxyAgentForLookup(lookupUrl, proxyResolver, context) {
+  const proxyValue = String(proxyResolver(lookupUrl.href) || "").trim();
   if (!proxyValue) return { agent: null, mode: "direct" };
   let proxyUrl;
   try {
     proxyUrl = new URL(proxyValue);
   } catch {
-    throw proxyConfigurationError("relay proxy configuration is not a valid URL");
+    throw proxyConfigurationError(`${context.subject} configuration is not a valid URL`, context.errorCode);
   }
-  if (!new Set(["http:", "https:"]).has(proxyUrl.protocol)) {
-    throw proxyConfigurationError("relay proxy must use HTTP or HTTPS");
+  if (!HTTP_PROTOCOLS.has(proxyUrl.protocol)) {
+    throw proxyConfigurationError(`${context.subject} must use HTTP or HTTPS`, context.errorCode);
   }
   try {
     return {
@@ -23,12 +41,12 @@ export function proxyAgentForWebSocket(webSocketUrl, proxyResolver = getProxyFor
       mode: "proxy",
     };
   } catch {
-    throw proxyConfigurationError("relay proxy configuration could not be initialized");
+    throw proxyConfigurationError(`${context.subject} configuration could not be initialized`, context.errorCode);
   }
 }
 
-function proxyConfigurationError(message) {
+function proxyConfigurationError(message, code) {
   const error = new Error(message);
-  error.code = "relay_proxy_configuration";
+  error.code = code;
   return error;
 }

package/src/local/state-inventory.mjs

@@ -28,11 +28,15 @@ export function knownWorkerNames(stateRoot) {
       throw unreadableWorkerState(entry.name);
     }
     if (!state || typeof state !== "object" || Array.isArray(state)) throw unreadableWorkerState(entry.name);
-    const name = String(state?.worker?.name || "");
-    if (name && !WORKER_NAME.test(name)) {
-      throw new Error(`profile ${entry.name} contains an invalid Worker name; local state was kept for inspection`);
+    const currentName = String(state?.worker?.name || "");
+    const previousNames = Array.isArray(state?.worker?.previousNames) ? state.worker.previousNames : [];
+    for (const name of [currentName, ...previousNames]) {
+      if (!name) continue;
+      if (typeof name !== "string" || !WORKER_NAME.test(name)) {
+        throw new Error(`profile ${entry.name} contains an invalid Worker name; local state was kept for inspection`);
+      }
+      names.add(name);
     }
-    if (name) names.add(name);
   }
   return [...names];
 }

package/src/local/state.mjs

@@ -594,7 +594,26 @@ export function ensureWorkerSecrets(state, options = {}) {
   if (!state.worker.accountAdminSecret || options.rotateSecrets) state.worker.accountAdminSecret = randomToken("account_admin");
   if (!state.worker.daemonSecret || options.rotateSecrets) state.worker.daemonSecret = randomToken("daemon_secret");
   if (!state.worker.oauthTokenVersion || options.rotateSecrets) state.worker.oauthTokenVersion = randomToken("token_version");
-  if (!state.worker.name || options.workerName) state.worker.name = options.workerName || defaultWorkerName(state.workspace.hash);
+
+  const requestedName = options.workerName || "";
+  if (!state.worker.name) {
+    state.worker.name = requestedName || defaultWorkerName(state.workspace.hash);
+    return;
+  }
+  if (!requestedName || requestedName === state.worker.name) return;
+  if (!options.allowWorkerRename) {
+    throw new Error(`this workspace already uses Worker ${state.worker.name}; changing --worker-name to ${requestedName} would create another Worker. Re-run with --force-worker only when that replacement is intentional`);
+  }
+
+  const previous = String(state.worker.name);
+  const previousNames = Array.isArray(state.worker.previousNames) ? state.worker.previousNames : [];
+  state.worker.previousNames = [...new Set([...previousNames, previous])].slice(-32);
+  state.worker.name = requestedName;
+  delete state.worker.url;
+  delete state.worker.mcpServerUrl;
+  delete state.worker.deployHash;
+  delete state.worker.deployedVersion;
+  delete state.worker.updatedAt;
 }
 
 function defaultWorkerName(hash) {

package/src/local/worker-deployment.mjs

@@ -0,0 +1,170 @@
+import { createHmac } from "node:crypto";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import path, { resolve } from "node:path";
+import { runWrangler } from "./shell.mjs";
+import { packageRoot, saveState } from "./state.mjs";
+import { withWorkerSecretsFile } from "./worker-secret-file.mjs";
+import {
+  retryWorkerHealth,
+  workerHealthRequiresRedeploy,
+  workerHealthUserReason,
+} from "./worker-health.mjs";
+
+export async function ensureWorkerDeployment(state, args = {}, options = {}) {
+  const logger = options.logger || console;
+  const expectedVersion = options.expectedVersion || currentPackageVersion(options.packageRoot || packageRoot);
+  const desiredHash = workerDeploymentFingerprint(state, { packageRoot: options.packageRoot || packageRoot });
+  const runWranglerFn = options.runWrangler || runWrangler;
+  const saveStateFn = options.saveState || saveState;
+  const retryHealthFn = options.retryHealth || retryWorkerHealth;
+  const withSecretsFileFn = options.withSecretsFile || withWorkerSecretsFile;
+  const healthOptions = { expectedWorkerName: state.worker.name, ...(options.healthOptions || {}) };
+  const complete = hasCompleteWorkerState(state.worker);
+
+  if (!args.forceWorker && !args.rotateSecrets && complete && state.worker.deployHash === desiredHash) {
+    const health = await retryHealthFn(state.worker.url, expectedVersion, options.existingHealthAttempts || 2, healthOptions);
+    if (health.ok) {
+      logger.success?.("Worker unchanged and healthy", { url: state.worker.url });
+      logger.debug?.("Worker health route", { network_route: health.networkRoute || "unknown" });
+      return state.worker;
+    }
+    if (!workerHealthRequiresRedeploy(health.error)) {
+      logger.debug?.("Worker health check detail", { health_error: health.error, network_route: health.networkRoute || "unknown" });
+      throw workerVerificationError(health.error, { deploymentSucceeded: false });
+    }
+    logger.warn?.("Recorded Worker is stale; redeploying the same Worker", { reason: workerHealthUserReason(health.error) });
+    logger.debug?.("Worker health check detail", { health_error: health.error, network_route: health.networkRoute || "unknown" });
+  }
+
+  logger.info?.("Checking Cloudflare Wrangler login");
+  const whoami = await runWranglerFn(["whoami"], { capture: true, allowFailure: true });
+  if (whoami.code !== 0) {
+    logger.info?.("Wrangler is not logged in; opening Cloudflare login");
+    await runWranglerFn(["login"]);
+  }
+
+  logger.info?.("Deploying Cloudflare Worker", { name: state.worker.name });
+  const deploy = await withSecretsFileFn(state, secretFile => runWranglerFn([
+    "deploy",
+    "--name", state.worker.name,
+    "--minify",
+    "--keep-vars",
+    "--secrets-file", secretFile,
+  ], { capture: true }));
+
+  const detectedUrl = extractWorkerUrl(deploy.stdout) || extractWorkerUrl(deploy.stderr);
+  const recordedUrl = workerUrlMatchesName(state.worker.url, state.worker.name) ? state.worker.url : "";
+  const workerUrl = detectedUrl || recordedUrl;
+  if (!workerUrl) {
+    throw new Error("Worker upload returned success, but Wrangler output contained no workers.dev URL and no matching recorded URL exists. The deployment fingerprint was not saved; rerun with --verbose and inspect the Wrangler output before retrying.");
+  }
+
+  state.worker.url = workerUrl.replace(/\/+$/, "");
+  state.worker.mcpServerUrl = `${state.worker.url}/mcp`;
+  state.worker.deployHash = desiredHash;
+  state.worker.deployedVersion = expectedVersion;
+  state.worker.updatedAt = new Date().toISOString();
+  saveStateFn(state);
+
+  const health = await retryHealthFn(state.worker.url, expectedVersion, options.deploymentHealthAttempts || 8, healthOptions);
+  if (!health.ok) {
+    logger.debug?.("Worker post-deployment health detail", { health_error: health.error, network_route: health.networkRoute || "unknown" });
+    throw workerVerificationError(health.error, { deploymentSucceeded: true });
+  }
+  logger.success?.("Worker ready", { url: state.worker.url, version: health.version });
+  logger.debug?.("Worker health route", { network_route: health.networkRoute || "unknown" });
+  return state.worker;
+}
+
+export function workerDeploymentFingerprint(state, options = {}) {
+  const root = resolve(options.packageRoot || packageRoot);
+  const keyMaterial = [
+    String(state.worker.accountAdminSecret || ""),
+    String(state.worker.daemonSecret || ""),
+    String(state.worker.oauthTokenVersion || ""),
+  ].join("\0");
+  const fingerprint = createHmac("sha256", keyMaterial);
+  fingerprint.update("mbm-worker-deploy-v3");
+  fingerprint.update(String(state.worker.name || ""));
+  for (const file of workerDeployHashFiles(root)) {
+    fingerprint.update(path.relative(root, file));
+    fingerprint.update(readFileSync(file, "utf8"));
+  }
+  return fingerprint.digest("hex");
+}
+
+export function extractWorkerUrl(text = "") {
+  const matches = [...String(text).matchAll(/https:\/\/[^\s"'<>]+\.workers\.dev[^\s"'<>]*/g)];
+  if (matches.length) return matches.at(-1)[0].replace(/[),.]+$/, "");
+  const anyHttps = [...String(text).matchAll(/https:\/\/[^\s"'<>]+/g)];
+  return anyHttps.find(match => /workers\.dev|\/healthz|\/mcp/.test(match[0]))?.[0]?.replace(/[),.]+$/, "") || "";
+}
+
+export function workerUrlMatchesName(workerUrl, workerName) {
+  if (!workerUrl || !workerName) return false;
+  try {
+    const url = new URL(String(workerUrl));
+    return url.protocol === "https:"
+      && url.hostname.endsWith(".workers.dev")
+      && url.hostname.startsWith(`${String(workerName)}.`);
+  } catch {
+    return false;
+  }
+}
+
+function hasCompleteWorkerState(worker = {}) {
+  return Boolean(worker.url && worker.mcpServerUrl && worker.accountAdminSecret && worker.daemonSecret && worker.oauthTokenVersion && worker.name);
+}
+
+function workerDeployHashFiles(root) {
+  const files = [];
+  for (const item of ["src/worker", "src/shared", "wrangler.jsonc", "tsconfig.json"]) {
+    collectHashFiles(resolve(root, item), files);
+  }
+  return files.sort();
+}
+
+function collectHashFiles(target, out) {
+  if (!existsSync(target)) return;
+  const info = statSync(target);
+  if (info.isFile()) {
+    if (/\.(ts|js|mjs|json|jsonc|yaml|yml|lock)$/.test(target)) out.push(target);
+    return;
+  }
+  if (!info.isDirectory()) return;
+  for (const entry of readdirSync(target, { withFileTypes: true })) {
+    if (entry.name === "node_modules" || entry.name === ".wrangler" || entry.name.endsWith(".d.ts")) continue;
+    collectHashFiles(resolve(target, entry.name), out);
+  }
+}
+
+function workerVerificationError(reason, { deploymentSucceeded }) {
+  const readable = workerHealthUserReason(reason);
+  const guidance = workerVerificationGuidance(reason);
+  const message = deploymentSucceeded
+    ? `Cloudflare reported the Worker deployment succeeded, but ${readable}. The deployment fingerprint was saved, so retrying will verify the same Worker instead of deploying again. ${guidance}`
+    : `The recorded Worker could not be verified because ${readable}. No deployment was attempted. ${guidance}`;
+  const error = new Error(message);
+  error.code = "worker_health_unverified";
+  error.healthError = reason;
+  error.deploymentSucceeded = deploymentSucceeded;
+  return error;
+}
+
+function workerVerificationGuidance(reason) {
+  if (reason === "proxy_configuration") {
+    return "Check HTTPS_PROXY, HTTP_PROXY, and NO_PROXY, then run machine-mcp doctor.";
+  }
+  if (["timeout", "tls_error", "network_error", "request_failed"].includes(reason)) {
+    return "Check network/TLS access and HTTPS_PROXY, HTTP_PROXY, and NO_PROXY, then run machine-mcp doctor.";
+  }
+  if (/^HTTP 5\d\d$/.test(String(reason || ""))) {
+    return "Retry after the service recovers, or run machine-mcp doctor for the current health result.";
+  }
+  return "Run machine-mcp doctor and inspect the health endpoint before forcing another deployment.";
+}
+
+function currentPackageVersion(root) {
+  const pkg = JSON.parse(readFileSync(resolve(root, "package.json"), "utf8"));
+  return String(pkg.version);
+}

package/src/local/worker-health.mjs

@@ -0,0 +1,246 @@
+import http from "node:http";
+import https from "node:https";
+import { appName } from "./state.mjs";
+import { proxyAgentForHttp } from "./network-proxy.mjs";
+
+const MAX_HEALTH_BODY_BYTES = 64 * 1024;
+const DEFAULT_HEALTH_TIMEOUT_MS = 5_000;
+const NON_RETRYABLE_HEALTH_ERRORS = new Set(["missing_worker_url", "invalid_worker_url", "proxy_configuration"]);
+const WORKER_NAME = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+const WORKERS_DEV_HOST = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.workers\.dev$/;
+
+export async function workerHealth(workerUrl, expectedVersion, options = {}) {
+  if (!workerUrl) return { ok: false, error: "missing_worker_url" };
+  let healthUrl;
+  try {
+    healthUrl = workerHealthUrl(workerUrl, options.expectedWorkerName);
+  } catch {
+    return { ok: false, error: "invalid_worker_url" };
+  }
+
+  try {
+    const probe = typeof options.probe === "function" ? options.probe : requestAllowedWorkerHealthJson;
+    const result = await probe(healthUrl, {
+      timeoutMs: options.timeoutMs,
+      proxyResolver: options.proxyResolver,
+      proxyAgentForUrl: options.proxyAgentForUrl,
+    });
+    const networkRoute = result.networkRoute || "direct";
+    if (result.statusCode !== 200) return { ok: false, error: `HTTP ${result.statusCode}`, networkRoute };
+    const body = result.body;
+    if (body?.ok !== true || body?.server !== appName) return { ok: false, error: "unexpected_health_response", networkRoute };
+    if (body?.version !== expectedVersion) return { ok: false, error: `version_mismatch:${body?.version || "unknown"}!=${expectedVersion}`, networkRoute };
+    return { ok: true, version: body.version, networkRoute };
+  } catch (error) {
+    return {
+      ok: false,
+      error: workerHealthError(error),
+      networkRoute: error?.networkRoute || (hasErrorCode(error, "http_proxy_configuration") ? "invalid-proxy-configuration" : "unknown"),
+    };
+  }
+}
+
+export async function retryWorkerHealth(workerUrl, expectedVersion, attempts, options = {}) {
+  const count = Math.max(1, Number.parseInt(String(attempts), 10) || 1);
+  const wait = typeof options.wait === "function" ? options.wait : sleep;
+  let last = { ok: false, error: "not_checked" };
+  for (let index = 0; index < count; index += 1) {
+    last = await workerHealth(workerUrl, expectedVersion, options);
+    if (last.ok) return last;
+    if (!isRetryableWorkerHealthError(last.error)) return last;
+    if (index + 1 < count) await wait(1_000 + index * 500);
+  }
+  return last;
+}
+
+export function workerHealthUrl(workerUrl, expectedWorkerName = "") {
+  const base = new URL(`${String(workerUrl).replace(/\/+$/, "")}/`);
+  const hostname = base.hostname.toLowerCase();
+  const expectedName = String(expectedWorkerName || "").toLowerCase();
+  if (base.protocol !== "https:" || base.port || base.username || base.password || base.search || base.hash || base.pathname !== "/") {
+    throw new Error("Worker URL must be an HTTPS workers.dev origin");
+  }
+  if (!WORKERS_DEV_HOST.test(hostname)) throw new Error("Worker URL must use a workers.dev hostname");
+  if (expectedName && (!WORKER_NAME.test(expectedName) || hostname.split(".")[0] !== expectedName)) {
+    throw new Error("Worker URL hostname does not match the recorded Worker name");
+  }
+  return `https://${hostname}/healthz`;
+}
+
+export function isRetryableWorkerHealthError(value) {
+  return !NON_RETRYABLE_HEALTH_ERRORS.has(String(value || ""));
+}
+
+export function workerHealthRequiresRedeploy(value) {
+  const reason = String(value || "");
+  return reason.startsWith("version_mismatch:")
+    || reason === "unexpected_health_response"
+    || reason === "HTTP 404"
+    || reason === "HTTP 410";
+}
+
+export function workerHealthUserReason(value) {
+  const reason = String(value || "");
+  if (reason.startsWith("version_mismatch:")) return "deployed version does not match the local package";
+  if (/^HTTP \d+$/.test(reason)) return "health endpoint returned an HTTP error";
+  if (reason === "unexpected_health_response") return "health endpoint returned an unexpected response";
+  if (reason === "timeout") return "health check timed out";
+  if (reason === "tls_error") return "TLS validation failed";
+  if (reason === "network_error") return "network request failed";
+  if (reason === "proxy_configuration") return "HTTP proxy configuration is invalid";
+  if (reason === "missing_worker_url") return "Worker URL is missing";
+  if (reason === "invalid_worker_url") return "Worker URL is invalid";
+  return "health check failed";
+}
+
+export function workerHealthError(error) {
+  if (hasErrorCode(error, "http_proxy_configuration")) return "proxy_configuration";
+  if (hasErrorCode(error, "ETIMEDOUT") || hasErrorCode(error, "ABORT_ERR") || /timeout|timed out|aborted/i.test(errorMessages(error))) return "timeout";
+  if (hasTlsError(error)) return "tls_error";
+  if (hasNetworkError(error)) return "network_error";
+  return "request_failed";
+}
+
+export function requestWorkerHealthJson(url, options = {}) {
+  return requestJson(new URL(String(url)), {
+    timeoutMs: boundedTimeout(options.timeoutMs),
+    proxyResolver: options.proxyResolver,
+    proxyAgentForUrl: options.proxyAgentForUrl,
+  });
+}
+
+function requestAllowedWorkerHealthJson(url, options = {}) {
+  const target = new URL(String(url));
+  if (target.protocol !== "https:" || target.port || target.pathname !== "/healthz" || target.search || target.hash || !WORKERS_DEV_HOST.test(target.hostname)) {
+    const error = new Error("health request target is not an allowed workers.dev endpoint");
+    error.code = "ERR_INVALID_WORKER_HEALTH_URL";
+    throw error;
+  }
+  return requestJson(target, {
+    timeoutMs: boundedTimeout(options.timeoutMs),
+    proxyResolver: options.proxyResolver,
+    proxyAgentForUrl: options.proxyAgentForUrl,
+  });
+}
+
+function requestJson(target, options) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const selectProxy = typeof options.proxyAgentForUrl === "function" ? options.proxyAgentForUrl : proxyAgentForHttp;
+    let proxy;
+    try {
+      proxy = selectProxy(target.href, options.proxyResolver);
+    } catch (error) {
+      rejectPromise(withNetworkRoute(error, "invalid-proxy-configuration"));
+      return;
+    }
+    const networkRoute = proxy?.agent ? "proxy" : "direct";
+    const transport = target.protocol === "https:" ? https : http;
+    const request = transport.request({
+      protocol: target.protocol,
+      hostname: target.hostname,
+      port: target.port || undefined,
+      method: "GET",
+      path: `${target.pathname}${target.search}`,
+      headers: {
+        Accept: "application/json",
+        "User-Agent": "machine-bridge-mcp-health",
+      },
+      ...(proxy?.agent ? { agent: proxy.agent } : {}),
+    });
+    let settled = false;
+    const finish = (callback) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      callback();
+    };
+    const rejectWithRoute = (error) => finish(() => rejectPromise(withNetworkRoute(error, networkRoute)));
+    const timer = setTimeout(() => {
+      const error = new Error(`health request timed out after ${options.timeoutMs}ms`);
+      error.code = "ETIMEDOUT";
+      request.destroy(error);
+    }, options.timeoutMs);
+    timer.unref?.();
+
+    request.on("response", (response) => {
+      const statusCode = Number(response.statusCode || 0);
+      const chunks = [];
+      let bytes = 0;
+      response.on("data", (chunk) => {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        bytes += buffer.length;
+        if (bytes > MAX_HEALTH_BODY_BYTES) {
+          const error = new Error("health response exceeded the size limit");
+          error.code = "ERR_RESPONSE_TOO_LARGE";
+          response.destroy(error);
+          return;
+        }
+        chunks.push(buffer);
+      });
+      response.on("error", rejectWithRoute);
+      response.on("end", () => {
+        if (settled) return;
+        let body = null;
+        try {
+          body = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+        } catch {
+          // Invalid JSON is reported through the normal unexpected-health-response classification.
+        }
+        finish(() => resolvePromise({ statusCode, body, networkRoute }));
+      });
+    });
+    request.on("error", rejectWithRoute);
+    request.end();
+  });
+}
+
+function withNetworkRoute(error, networkRoute) {
+  const value = error instanceof Error ? error : new Error(String(error));
+  if (!value.networkRoute) value.networkRoute = networkRoute;
+  return value;
+}
+
+function hasTlsError(error) {
+  const codes = errorCodes(error);
+  if (codes.some((code) => code.startsWith("ERR_TLS_") || code.startsWith("CERT_") || code.includes("CERTIFICATE") || code === "UNABLE_TO_VERIFY_LEAF_SIGNATURE" || code === "DEPTH_ZERO_SELF_SIGNED_CERT")) return true;
+  return /certificate|\bTLS\b|\bSSL\b/i.test(errorMessages(error));
+}
+
+function hasNetworkError(error) {
+  const networkCodes = new Set([
+    "ECONNABORTED", "ECONNREFUSED", "ECONNRESET", "EHOSTUNREACH", "ENETDOWN", "ENETRESET",
+    "ENETUNREACH", "ENOTFOUND", "EAI_AGAIN", "EPIPE", "UND_ERR_CONNECT_TIMEOUT",
+  ]);
+  if (errorCodes(error).some((code) => networkCodes.has(code))) return true;
+  return /fetch failed|network|socket hang up|connection reset|connection refused/i.test(errorMessages(error));
+}
+
+function hasErrorCode(error, expected) {
+  return errorCodes(error).includes(expected);
+}
+
+function errorCodes(error) {
+  const codes = [];
+  for (let current = error; current && typeof current === "object"; current = current.cause) {
+    if (typeof current.code === "string") codes.push(current.code);
+  }
+  return codes;
+}
+
+function errorMessages(error) {
+  const messages = [];
+  for (let current = error; current; current = current?.cause) {
+    messages.push(String(current?.message || current));
+    if (typeof current !== "object") break;
+  }
+  return messages.join(" ");
+}
+
+function boundedTimeout(value) {
+  const numeric = Number(value);
+  return Number.isFinite(numeric) && numeric > 0 ? Math.min(60_000, Math.floor(numeric)) : DEFAULT_HEALTH_TIMEOUT_MS;
+}
+
+function sleep(ms) {
+  return new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
+}

package/src/worker/index.ts

@@ -24,7 +24,7 @@ import {
 } from "./http";
 
 const SERVER_NAME = String(serverMetadata.name);
-const SERVER_VERSION = "1.1.0";
+const SERVER_VERSION = "1.1.1";
 const MCP_PROTOCOL_VERSION = String(serverMetadata.protocolVersion);
 const MCP_SUPPORTED_PROTOCOL_VERSIONS = serverMetadata.supportedProtocolVersions.map((value) => String(value));
 const JSONRPC_VERSION = "2.0";