omnius 1.0.607 → 1.0.609

package/dist/library.d.ts

@@ -1,5 +1,5 @@
-export { discoverCapabilities, discoveryDocsRoot, discoverySchemaVersion, findDiscoveryCatalogPath, loadDiscoveryCatalog, rankCapabilities, showCapability, } from "./discovery.js";
-export type { DiscoveryCatalog, DiscoveryEntry, DiscoveryInterface, DiscoveryKind, DiscoveryQueryOptions, DiscoveryReference, DiscoveryResult, } from "./discovery.js";
+export { discoverCapabilities, discoveryBootstrap, discoveryDocsRoot, DISCOVERY_KINDS, discoverySchemaVersion, findDiscoveryCatalogPath, loadDiscoveryCatalog, rankCapabilities, showCapability, } from "./discovery.js";
+export type { DiscoveryCatalog, DiscoveryBootstrap, DiscoveryEntry, DiscoveryExample, DiscoveryFailureMode, DiscoveryInterface, DiscoveryKind, DiscoveryQueryOptions, DiscoveryReference, DiscoveryResult, DiscoveryStep, DiscoveryVerification, } from "./discovery.js";
 export { assertServiceVersion, compareOmniusVersions, getServiceVersion, isVersionGatedExecutionRequest, OmniusVersionError, parseOmniusVersion, } from "./service-version.js";
 export type { ServiceVersionInfo } from "./service-version.js";
 export { buildProviderHeaders, detectProviderDescriptor, listProviderDescriptors, providerUrl, resolveProviderDescriptor, resolveProviderTransport, UnknownProviderProtocolError, } from "./providerRegistry.js";

package/dist/library.js

@@ -4,14 +4,32 @@ import { createRequire as __omnius_createRequire } from "node:module"; import {
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-var DISCOVERY_SCHEMA_VERSION = "1.0.0";
+var DISCOVERY_KINDS = [
+  "capability",
+  "layer",
+  "module",
+  "workflow",
+  "runtime",
+  "store",
+  "provider",
+  "tool",
+  "api",
+  "command",
+  "skill",
+  "guide",
+  "config",
+  "operation"
+];
+var DISCOVERY_SCHEMA_VERSION = "2.0.0";
 var DEFAULT_LIMIT = 20;
 var MAX_LIMIT = 200;
 function discoveryCandidates() {
   const here = dirname(fileURLToPath(import.meta.url));
   const configured = process.env["OMNIUS_DOCS_ROOT"]?.trim();
+  if (configured) {
+    return [configured.endsWith(".json") ? resolve(configured) : resolve(configured, "DISCOVERY.json")];
+  }
   const candidates = [
-    configured ? configured.endsWith(".json") ? resolve(configured) : resolve(configured, "DISCOVERY.json") : "",
     // Published package: dist/index.js or dist/library.js -> ../docs.
     resolve(here, "..", "docs", "DISCOVERY.json"),
     // Workspace source/dist layouts.
@@ -30,7 +48,7 @@ function findDiscoveryCatalogPath() {
 function isDiscoveryEntry(value) {
   if (!value || typeof value !== "object") return false;
   const item = value;
-  return typeof item["id"] === "string" && typeof item["kind"] === "string" && typeof item["title"] === "string" && typeof item["summary"] === "string";
+  return typeof item["id"] === "string" && typeof item["kind"] === "string" && DISCOVERY_KINDS.includes(item["kind"]) && typeof item["title"] === "string" && typeof item["summary"] === "string";
 }
 function loadDiscoveryCatalog() {
   const path = findDiscoveryCatalogPath();
@@ -43,6 +61,13 @@ function loadDiscoveryCatalog() {
   if (typeof parsed.schema_version !== "string" || !Array.isArray(parsed.entries) || !parsed.entries.every(isDiscoveryEntry)) {
     throw new Error(`Invalid Omnius discovery catalog: ${path}`);
   }
+  const expectedMajor = DISCOVERY_SCHEMA_VERSION.split(".")[0];
+  const actualMajor = parsed.schema_version.split(".")[0];
+  if (actualMajor !== expectedMajor) {
+    throw new Error(
+      `Unsupported Omnius discovery schema ${parsed.schema_version}; this runtime requires ${expectedMajor}.x`
+    );
+  }
   return {
     ...parsed,
     schema_version: parsed.schema_version,
@@ -70,6 +95,25 @@ function scoreEntry(entry, query) {
       ...(entry.references ?? []).map((item) => `${item.type} ${item.target} ${item.relation ?? ""}`)
     ].join(" ")
   );
+  const operational = normalized(JSON.stringify({
+    layer: entry.layer,
+    audiences: entry.audiences,
+    use_when: entry.use_when,
+    avoid_when: entry.avoid_when,
+    inputs: entry.inputs,
+    outputs: entry.outputs,
+    workflow: entry.workflow,
+    examples: entry.examples,
+    verification: entry.verification,
+    failure_modes: entry.failure_modes,
+    state: entry.state,
+    safety: entry.safety,
+    prerequisites: entry.prerequisites,
+    source_of_truth: entry.source_of_truth,
+    capabilities: entry["capabilities"],
+    configuration: entry["configuration"],
+    runtime_requirements: entry["runtime_requirements"]
+  }));
   let score = 0;
   if (id === q) score += 1e3;
   if (aliases.includes(q)) score += 800;
@@ -98,6 +142,10 @@ function scoreEntry(entry, query) {
       score += 3;
       matched = true;
     }
+    if (tokens(operational).includes(token)) {
+      score += 5;
+      matched = true;
+    }
     if (matched) matchedTokens++;
   }
   if (queryTokens.length > 0 && matchedTokens === queryTokens.length) score += 50;
@@ -106,10 +154,10 @@ function scoreEntry(entry, query) {
 function discoverCapabilities(query = "", options = {}, catalog = loadDiscoveryCatalog()) {
   const limit = Math.min(MAX_LIMIT, Math.max(1, Math.floor(options.limit ?? DEFAULT_LIMIT)));
   const offset = Math.max(0, Math.floor(options.offset ?? 0));
-  return rankCapabilities(query, options.kind, catalog).slice(offset, offset + limit);
+  return rankCapabilities(query, options.kind, catalog, options).slice(offset, offset + limit);
 }
-function rankCapabilities(query = "", kind, catalog = loadDiscoveryCatalog()) {
-  return catalog.entries.filter((entry) => !kind || entry.kind === kind).map((entry) => ({ score: scoreEntry(entry, query), entry })).filter((result) => !query.trim() || result.score > 0).sort((a, b) => b.score - a.score || a.entry.id.localeCompare(b.entry.id));
+function rankCapabilities(query = "", kind, catalog = loadDiscoveryCatalog(), options = {}) {
+  return catalog.entries.filter((entry) => !kind || entry.kind === kind).filter((entry) => !options.layer || entry.layer === options.layer).filter((entry) => !options.audience || (entry.audiences ?? []).includes(options.audience)).filter((entry) => options.includeInternal || entry.maturity !== "internal").map((entry) => ({ score: scoreEntry(entry, query), entry })).filter((result) => !query.trim() || result.score > 0).sort((a, b) => b.score - a.score || a.entry.id.localeCompare(b.entry.id));
 }
 function showCapability(id, catalog = loadDiscoveryCatalog()) {
   const exact = catalog.entries.find((entry) => entry.id === id);
@@ -119,8 +167,18 @@ function showCapability(id, catalog = loadDiscoveryCatalog()) {
     (entry) => normalized(entry.id) === wanted || normalized(entry.title) === wanted || (entry.aliases ?? []).some((alias) => normalized(alias) === wanted)
   );
 }
+function discoveryBootstrap(catalog = loadDiscoveryCatalog()) {
+  return catalog.bootstrap ?? {
+    strategy: ["discover intent", "expand one stable id", "inspect the live contract", "act", "verify"],
+    start_here: ["overview"]
+  };
+}
 function discoverySchemaVersion() {
-  return DISCOVERY_SCHEMA_VERSION;
+  try {
+    return loadDiscoveryCatalog().schema_version;
+  } catch {
+    return DISCOVERY_SCHEMA_VERSION;
+  }
 }
 function discoveryDocsRoot() {
   const catalog = findDiscoveryCatalogPath();
@@ -927,6 +985,7 @@ var PROVIDER_PRESETS = [
   }
 ];
 export {
+  DISCOVERY_KINDS,
   OmniusVersionError,
   UnknownProviderProtocolError,
   assertServiceVersion,
@@ -934,6 +993,7 @@ export {
   compareOmniusVersions,
   detectProviderDescriptor,
   discoverCapabilities,
+  discoveryBootstrap,
   discoveryDocsRoot,
   discoverySchemaVersion,
   findDiscoveryCatalogPath,

package/dist/scripts/vibevoice-asr-worker.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+"""Pinned Microsoft VibeVoice-ASR JSONL worker managed by Omnius.
+
+This worker never installs dependencies or downloads weights intentionally.
+The Node runtime owns setup, revision pinning, disk checks, and CUDA selection.
+"""
+
+import argparse
+import json
+import os
+import sys
+import time
+from pathlib import Path
+
+
+def emit(payload):
+    print(json.dumps(payload, ensure_ascii=False), flush=True)
+
+
+def check_only():
+    required = [
+        "OMNIUS_VIBEVOICE_MODEL_ID",
+        "OMNIUS_VIBEVOICE_MODEL_REVISION",
+        "OMNIUS_VIBEVOICE_TOKENIZER_ID",
+        "OMNIUS_VIBEVOICE_TOKENIZER_REVISION",
+    ]
+    missing = [key for key in required if not os.environ.get(key)]
+    emit({"type": "check", "ok": not missing, "missing": missing})
+    return 0 if not missing else 2
+
+
+def normalize_seconds(value):
+    if value is None:
+        return 0.0
+    if isinstance(value, (int, float)):
+        return float(value)
+    text = str(value).strip()
+    if not text:
+        return 0.0
+    parts = text.split(":")
+    try:
+        if len(parts) == 3:
+            return float(parts[0]) * 3600 + float(parts[1]) * 60 + float(parts[2])
+        if len(parts) == 2:
+            return float(parts[0]) * 60 + float(parts[1])
+        return float(text)
+    except ValueError:
+        return 0.0
+
+
+class VibeVoiceWorker:
+    def __init__(self):
+        import torch
+        from huggingface_hub import snapshot_download
+        from vibevoice.modular.modeling_vibevoice_asr import VibeVoiceASRForConditionalGeneration
+        from vibevoice.processor.vibevoice_asr_processor import VibeVoiceASRProcessor
+
+        if not torch.cuda.is_available():
+            raise RuntimeError("CUDA is unavailable; CPU fallback is forbidden for VibeVoice ASR")
+        visible = os.environ.get("CUDA_VISIBLE_DEVICES", "").strip()
+        if not visible or "," in visible:
+            raise RuntimeError("exactly one CUDA_VISIBLE_DEVICES entry is required")
+        self.torch = torch
+        self.model_id = os.environ["OMNIUS_VIBEVOICE_MODEL_ID"]
+        self.model_revision = os.environ["OMNIUS_VIBEVOICE_MODEL_REVISION"]
+        tokenizer_id = os.environ["OMNIUS_VIBEVOICE_TOKENIZER_ID"]
+        tokenizer_revision = os.environ["OMNIUS_VIBEVOICE_TOKENIZER_REVISION"]
+        model_path = snapshot_download(
+            repo_id=self.model_id,
+            revision=self.model_revision,
+            local_files_only=True,
+        )
+        tokenizer_path = snapshot_download(
+            repo_id=tokenizer_id,
+            revision=tokenizer_revision,
+            local_files_only=True,
+            allow_patterns=["*.json", "*.model", "*.txt", "merges.txt", "vocab.json", "tokenizer*"],
+        )
+        self.processor = VibeVoiceASRProcessor.from_pretrained(
+            model_path,
+            language_model_pretrained_name=tokenizer_path,
+            local_files_only=True,
+        )
+        self.model = VibeVoiceASRForConditionalGeneration.from_pretrained(
+            model_path,
+            dtype=torch.bfloat16,
+            attn_implementation=os.environ.get("OMNIUS_VIBEVOICE_ATTN", "sdpa"),
+            local_files_only=True,
+        ).to("cuda:0")
+        self.model.eval()
+        emit({
+            "type": "ready",
+            "pid": os.getpid(),
+            "device": torch.cuda.get_device_name(0),
+            "computeCapability": ".".join(str(part) for part in torch.cuda.get_device_capability(0)),
+            "totalMemoryBytes": torch.cuda.get_device_properties(0).total_memory,
+            "cudaVisibleDevices": visible,
+            "modelId": self.model_id,
+            "modelRevision": self.model_revision,
+        })
+
+    def transcribe(self, request):
+        file_path = str(request.get("file") or "")
+        if not file_path or not Path(file_path).is_file():
+            raise ValueError("a readable audio file is required")
+        context = str(request.get("context") or "").strip() or None
+        started = time.monotonic()
+        inputs = self.processor(
+            audio=[file_path],
+            return_tensors="pt",
+            padding=True,
+            context_info=context,
+        )
+        inputs = {
+            key: value.to("cuda:0") if isinstance(value, self.torch.Tensor) else value
+            for key, value in inputs.items()
+        }
+        generation = {
+            "max_new_tokens": int(os.environ.get("OMNIUS_VIBEVOICE_MAX_NEW_TOKENS", "32768")),
+            "do_sample": False,
+            "pad_token_id": self.processor.pad_id,
+            "eos_token_id": self.processor.tokenizer.eos_token_id,
+        }
+        with self.torch.inference_mode():
+            output_ids = self.model.generate(**inputs, **generation)
+        input_length = inputs["input_ids"].shape[1]
+        generated_ids = output_ids[0, input_length:]
+        raw_text = self.processor.decode(generated_ids, skip_special_tokens=True)
+        parsed = self.processor.post_process_transcription(raw_text)
+        warnings = []
+        segments = []
+        speakers = []
+        for item in parsed:
+            text = str(item.get("text") or "").strip()
+            speaker = str(item.get("speaker_id") or "").strip()
+            if speaker and speaker not in speakers:
+                speakers.append(speaker)
+            segments.append({
+                "startMs": round(normalize_seconds(item.get("start_time")) * 1000),
+                "endMs": round(normalize_seconds(item.get("end_time")) * 1000),
+                "text": text,
+                **({"speakerId": speaker} if speaker else {}),
+            })
+        if not segments and raw_text.strip():
+            warnings.append("VibeVoice structured output could not be parsed; raw transcription was preserved")
+        text = " ".join(segment["text"] for segment in segments if segment["text"]).strip()
+        if not text:
+            text = raw_text.strip()
+        duration_ms = max((segment["endMs"] for segment in segments), default=0)
+        return {
+            "text": text,
+            "rawText": raw_text,
+            "segments": segments,
+            "speakers": speakers,
+            "durationMs": duration_ms or None,
+            "engineId": "vibevoice-transformers",
+            "modelId": "vibevoice-asr-7b",
+            "device": self.torch.cuda.get_device_name(0),
+            "warnings": warnings,
+            "latencyMs": round((time.monotonic() - started) * 1000),
+        }
+
+
+def serve():
+    try:
+        worker = VibeVoiceWorker()
+    except Exception as exc:
+        emit({"type": "error", "message": f"model activation failed: {exc}"})
+        return 1
+    for line in sys.stdin:
+        try:
+            request = json.loads(line)
+            request_id = str(request.get("id") or "")
+            if request.get("action") != "transcribe":
+                raise ValueError(f"unknown action: {request.get('action')}")
+            emit({"type": "result", "id": request_id, "result": worker.transcribe(request)})
+        except Exception as exc:
+            emit({"type": "error", "id": locals().get("request_id", ""), "message": str(exc)})
+    return 0
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--check", action="store_true")
+    parser.add_argument("--serve", action="store_true")
+    args = parser.parse_args()
+    if args.check:
+        return check_only()
+    if args.serve:
+        return serve()
+    parser.error("use --check or --serve")
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/dist/update-worker.js

@@ -293350,6 +293350,151 @@ init_camera_capture();
 var MM_DIR = join9(homedir9(), ".omnius", "multimodal-episodes");
 var MM_INDEX = join9(MM_DIR, "index.json");
 
+// packages/execution/dist/asr/registry.js
+var VIBEVOICE_ASR_MODEL_REVISION = "d0c9efdb8d614685062c04425d91e01b6f37d944";
+var VIBEVOICE_ASR_WEIGHTS_BYTES = 17348198410;
+var whisperCapabilities = Object.freeze({
+  file: true,
+  pcmStream: true,
+  partials: true,
+  diarization: false,
+  segmentTimestamps: true,
+  wordTimestamps: true,
+  languageDetection: true,
+  languageHints: true,
+  contextPrompt: false,
+  sampleRates: [16e3]
+});
+function whisperModel(engineId, id, label) {
+  return {
+    id,
+    engineId,
+    label,
+    detail: `${label} Whisper transcription model`,
+    upstreamModelId: id,
+    license: "MIT",
+    languages: ["multilingual"],
+    capabilities: whisperCapabilities,
+    resources: {
+      cpuSupported: engineId === "transcribe-cli",
+      architectures: ["x64", "arm64"],
+      notes: engineId === "transcribe-cli" ? ["Managed transcribe-cli runtime; implementation may use faster-whisper or ONNX."] : ["CUDA is required by Omnius unless an explicit local override is configured."]
+    }
+  };
+}
+var WHISPER_MODEL_IDS = ["tiny", "base", "small", "medium", "large-v3"];
+var whisperModels = (engineId) => WHISPER_MODEL_IDS.map((id) => whisperModel(engineId, id, id === "large-v3" ? "Large v3" : id[0].toUpperCase() + id.slice(1)));
+var ASR_ENGINES = Object.freeze([
+  {
+    id: "openai-whisper",
+    label: "OpenAI Whisper",
+    detail: "Local CUDA Whisper for reliable live and file transcription",
+    provider: "OpenAI",
+    runtime: "python",
+    setupMode: "managed",
+    models: whisperModels("openai-whisper")
+  },
+  {
+    id: "transcribe-cli",
+    label: "transcribe-cli",
+    detail: "Managed faster-whisper/ONNX bridge for live and file transcription",
+    provider: "transcribe-cli",
+    runtime: "node",
+    setupMode: "managed",
+    models: whisperModels("transcribe-cli")
+  },
+  {
+    id: "nemotron-streaming",
+    label: "NVIDIA Nemotron Speech Streaming",
+    detail: "Low-latency English streaming ASR",
+    provider: "NVIDIA",
+    runtime: "python",
+    setupMode: "managed",
+    models: [
+      {
+        id: "nemotron-speech-streaming-en-0.6b",
+        engineId: "nemotron-streaming",
+        label: "Nemotron Speech Streaming 0.6B",
+        detail: "English streaming model with partial transcripts",
+        upstreamModelId: "nvidia/nemotron-speech-streaming-en-0.6b",
+        languages: ["en"],
+        capabilities: {
+          file: true,
+          pcmStream: true,
+          partials: true,
+          diarization: false,
+          segmentTimestamps: false,
+          wordTimestamps: false,
+          languageDetection: false,
+          languageHints: false,
+          contextPrompt: false,
+          sampleRates: [16e3]
+        },
+        resources: {
+          parameterCount: "0.6B",
+          minimumCudaComputeCapability: 7.5,
+          cpuSupported: false,
+          architectures: ["x64", "arm64"],
+          notes: ["Requires a compatible CUDA-enabled NeMo runtime."]
+        }
+      }
+    ]
+  },
+  {
+    id: "vibevoice-transformers",
+    label: "Microsoft VibeVoice ASR",
+    detail: "Long-form multilingual ASR with speakers, timestamps, and context prompts",
+    provider: "Microsoft Research",
+    runtime: "python",
+    setupMode: "managed",
+    models: [
+      {
+        id: "vibevoice-asr-7b",
+        engineId: "vibevoice-transformers",
+        label: "VibeVoice ASR 7B",
+        detail: "Up to 60-minute structured transcription in more than 50 languages",
+        upstreamModelId: "microsoft/VibeVoice-ASR",
+        upstreamRevision: VIBEVOICE_ASR_MODEL_REVISION,
+        license: "MIT",
+        languages: ["multilingual", "code-switching", "51 languages"],
+        capabilities: {
+          file: true,
+          pcmStream: false,
+          partials: false,
+          diarization: true,
+          segmentTimestamps: true,
+          wordTimestamps: false,
+          languageDetection: true,
+          languageHints: false,
+          contextPrompt: true,
+          maxAudioSeconds: 3600,
+          sampleRates: [24e3]
+        },
+        resources: {
+          parameterCount: "9B (7B language decoder)",
+          weightsBytes: VIBEVOICE_ASR_WEIGHTS_BYTES,
+          minimumCudaComputeCapability: 8,
+          minimumGpuMemoryBytes: 24 * 1024 ** 3,
+          cpuSupported: false,
+          architectures: ["x64", "arm64"],
+          notes: [
+            "BF16 checkpoint split across eight safetensors shards.",
+            "Not incremental PCM streaming; use it for completed utterances and files.",
+            "Activation is fail-closed and never falls back to CPU or another GPU."
+          ]
+        }
+      }
+    ]
+  }
+]);
+
+// packages/execution/dist/asr/vibevoice-runtime.js
+init_process_async();
+init_model_store();
+var INSTALL_TIMEOUT_MS2 = 45 * 6e4;
+var ACTIVATE_TIMEOUT_MS = 20 * 6e4;
+var REQUEST_TIMEOUT_MS = 90 * 6e4;
+
 // packages/execution/dist/tools/asr-listen.js
 init_hf_media_models();
 init_cuda_device_filter();
@@ -293408,7 +293553,7 @@ init_system_deps();
 init_process_kill();
 
 // packages/cli/src/daemon.ts
-var OMNIUS_DIR = join14(homedir14(), ".omnius");
+var OMNIUS_DIR = process.env["OMNIUS_HOME"]?.trim() || join14(homedir14(), ".omnius");
 var PID_FILE = join14(OMNIUS_DIR, "daemon.pid");
 var DEFAULT_PORT2 = 11435;
 var LOCK_INITIALIZATION_GRACE_MS = 5e3;
@@ -293968,6 +294113,27 @@ async function startDaemon(port = getDaemonPort()) {
     }
   }
 }
+async function stopDaemonAtPort(port = getDaemonPort()) {
+  if (await managedDaemonServiceMatchesPort(port)) {
+    const stopped = await runUserSystemctl(["stop", "omnius-daemon.service"]);
+    if (stopped.ok && await waitForDaemonStopped(port)) return true;
+  }
+  const wasRunning = await isDaemonRunning(port);
+  const reclaimed = await reclaimOwnedDaemonListener(port);
+  if (!reclaimed.ok) return false;
+  const claimCleared = await reclaimStaleDaemonEndpointClaim(port);
+  return claimCleared && (wasRunning || reclaimed.action === "cleared");
+}
+async function quiesceDaemonForUpdate(port = getDaemonPort()) {
+  if (await managedDaemonServiceMatchesPort(port)) {
+    const stopped = await runUserSystemctl(["stop", "omnius-daemon.service"]);
+    return stopped.ok && await waitForDaemonStopped(port);
+  }
+  if (!await isDaemonRunning(port)) {
+    return daemonPortIsFree(port);
+  }
+  return stopDaemonAtPort(port);
+}
 
 // packages/cli/src/update-service.ts
 import { spawn as spawn2, spawnSync } from "node:child_process";
@@ -294099,6 +294265,19 @@ function writeUpdateState(state, paths = resolveUpdatePaths()) {
   ensurePrivateDirectories(paths);
   atomicPrivateJson(paths.stateFile, state);
 }
+function updateLockOwner(paths, operationId, pid) {
+  atomicPrivateJson(paths.lockFile, { operation_id: operationId, pid });
+}
+function adoptUpdateWorker(operationId, pid, paths = resolveUpdatePaths()) {
+  const state = readUpdateState(paths);
+  if (!state || state.operation_id !== operationId || state.status !== "running") {
+    throw new Error("Update worker could not adopt its durable operation state");
+  }
+  updateLockOwner(paths, operationId, pid);
+  const adopted = { ...state, pid, updated_at: (/* @__PURE__ */ new Date()).toISOString() };
+  writeUpdateState(adopted, paths);
+  return adopted;
+}
 function releaseUpdateLock(paths = resolveUpdatePaths(), operationId) {
   try {
     if (operationId) {
@@ -294256,6 +294435,7 @@ function installGlobalPackageStreaming(input) {
 }
 async function runVerifiedUpdateTransaction(initial, dependencies, paths = resolveUpdatePaths()) {
   let state = initial;
+  let daemonQuiesced = false;
   const target = assertExactUpdateTarget(initial.target_version);
   const npmPath = resolveNpmPath();
   const env = {
@@ -294267,6 +294447,15 @@ async function runVerifiedUpdateTransaction(initial, dependencies, paths = resol
     OMNIUS_UPDATE_COORDINATED: "1"
   };
   try {
+    if (dependencies.quiesceDaemon) {
+      state = transition(state, { phase: "daemon_quiescing" }, paths);
+      if (!await dependencies.quiesceDaemon()) {
+        throw new Error(
+          `Could not safely stop the daemon at ${state.daemon_endpoint ?? "the configured endpoint"} before updating`
+        );
+      }
+      daemonQuiesced = true;
+    }
     const prefixProbe = runSync(npmPath, ["prefix", "-g"], { env, timeout: 1e4 });
     state = transition(state, {
       phase: "installing",
@@ -294291,13 +294480,19 @@ async function runVerifiedUpdateTransaction(initial, dependencies, paths = resol
     }, paths);
     state = transition(state, { phase: "daemon_restarting" }, paths);
     if (!await dependencies.restartDaemon(target)) {
-      throw new Error("The daemon restart command did not produce a verified target runtime");
+      throw new Error(
+        `The daemon restart at ${state.daemon_endpoint ?? "the configured endpoint"} did not produce Omnius v${target}`
+      );
     }
+    daemonQuiesced = false;
     const daemon = await dependencies.observeDaemon();
     if (!daemon || daemon.bootVersion !== target) {
       throw new Error(`Daemon verification failed: expected ${target}, observed ${daemon?.bootVersion ?? "unreachable"}`);
     }
-    if (daemon.bootPackageHash && daemon.bootPackageHash !== evidence.packageHash) {
+    if (!daemon.bootPackageHash) {
+      throw new Error("Daemon package verification failed: the restarted runtime did not report a boot package hash");
+    }
+    if (daemon.bootPackageHash !== evidence.packageHash) {
       throw new Error(
         `Daemon package verification failed: boot hash ${daemon.bootPackageHash} does not match installed hash ${evidence.packageHash}`
       );
@@ -294325,12 +294520,21 @@ async function runVerifiedUpdateTransaction(initial, dependencies, paths = resol
     return state;
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
+    let recoveryNote;
+    if (daemonQuiesced && dependencies.recoverDaemon) {
+      try {
+        const recovered = await dependencies.recoverDaemon();
+        recoveryNote = recovered ? "The prior daemon was restarted after the failed update." : "The daemon could not be recovered automatically after the failed update.";
+      } catch (recoveryError) {
+        recoveryNote = `Daemon recovery failed: ${recoveryError instanceof Error ? recoveryError.message : String(recoveryError)}`;
+      }
+    }
     state = transition(state, {
       status: "failed",
       phase: "failed",
       completed_at: (/* @__PURE__ */ new Date()).toISOString(),
       error: message,
-      remediation: permissionRemediation(message)
+      remediation: [permissionRemediation(message), recoveryNote].filter(Boolean).join(" ") || void 0
     }, paths);
     return state;
   } finally {
@@ -294633,7 +294837,7 @@ async function main() {
   const operationId = arg("operation");
   const target = arg("target");
   const endpoint = arg("endpoint") || "http://127.0.0.1:11435";
-  const state = readUpdateState(paths);
+  const state = adoptUpdateWorker(operationId, process.pid, paths);
   if (!state || state.operation_id !== operationId || state.target_version !== target) {
     throw new Error("Update worker state does not match its operation arguments");
   }
@@ -294643,7 +294847,9 @@ async function main() {
   const finalState = await runVerifiedUpdateTransaction(
     state,
     {
+      quiesceDaemon: () => quiesceDaemonForUpdate(port),
       restartDaemon: (expected) => restartDaemon(port, expected),
+      recoverDaemon: () => restartDaemon(port),
       observeDaemon: async () => {
         const identity = await getDaemonReportedIdentity(port);
         return identity ? { bootVersion: identity.bootVersion, bootPackageHash: identity.bootPackageHash } : null;

package/docs/.vitepress/config.mts

@@ -33,6 +33,7 @@ export default defineConfig({
   themeConfig: {
     nav: [
       { text: "Discover", link: "/DISCOVERY" },
+      { text: "System Map", link: "/architecture/agent-system-map" },
       { text: "Guide", link: "/getting-started/install" },
       { text: "REST", link: "/reference/rest-api" },
       { text: "Commands", link: "/reference/slash-commands" },
@@ -107,6 +108,7 @@ export default defineConfig({
       {
         text: "Architecture",
         items: [
+          { text: "Agent System Map", link: "/architecture/agent-system-map" },
           { text: "Overview", link: "/architecture/overview" },
         ],
       },